~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_sys.h

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* Copyright (C) 2000-2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#ifndef _my_sys_h
 
17
#define _my_sys_h
 
18
C_MODE_START
 
19
 
 
20
#ifdef HAVE_AIOWAIT
 
21
#include <sys/asynch.h>                 /* Used by record-cache */
 
22
typedef struct my_aio_result {
 
23
  aio_result_t result;
 
24
  int          pending;
 
25
} my_aio_result;
 
26
#endif
 
27
 
 
28
#ifndef THREAD
 
29
extern int my_errno;            /* Last error in mysys */
 
30
#else
 
31
#include <my_pthread.h>
 
32
#endif
 
33
 
 
34
#include <m_ctype.h>                    /* for CHARSET_INFO */
 
35
#include <stdarg.h>
 
36
#include <typelib.h>
 
37
 
 
38
#define MYSYS_PROGRAM_DONT_USE_CURSES()  { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;}
 
39
#define MY_INIT(name);          { my_progname= name; my_init(); }
 
40
 
 
41
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
 
42
#define NRERRBUFFS      (2)     /* Buffers for parameters */
 
43
#define MY_FILE_ERROR   ((size_t) -1)
 
44
 
 
45
        /* General bitmaps for my_func's */
 
46
#define MY_FFNF         1       /* Fatal if file not found */
 
47
#define MY_FNABP        2       /* Fatal if not all bytes read/writen */
 
48
#define MY_NABP         4       /* Error if not all bytes read/writen */
 
49
#define MY_FAE          8       /* Fatal if any error */
 
50
#define MY_WME          16      /* Write message on error */
 
51
#define MY_WAIT_IF_FULL 32      /* Wait and try again if disk full error */
 
52
#define MY_IGNORE_BADFD 32      /* my_sync: ignore 'bad descriptor' errors */
 
53
#define MY_SYNC_DIR     1024    /* my_create/delete/rename: sync directory */
 
54
#define MY_RAID         64      /* Support for RAID */
 
55
#define MY_FULL_IO     512      /* For my_read - loop intil I/O is complete */
 
56
#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */
 
57
#define MY_LINK_WARNING 32      /* my_redel() gives warning if links */
 
58
#define MY_COPYTIME     64      /* my_redel() copys time */
 
59
#define MY_DELETE_OLD   256     /* my_create_with_symlink() */
 
60
#define MY_RESOLVE_LINK 128     /* my_realpath(); Only resolve links */
 
61
#define MY_HOLD_ORIGINAL_MODES 128  /* my_copy() holds to file modes */
 
62
#define MY_REDEL_MAKE_BACKUP 256
 
63
#define MY_SEEK_NOT_DONE 32     /* my_lock may have to do a seek */
 
64
#define MY_DONT_WAIT    64      /* my_lock() don't wait if can't lock */
 
65
#define MY_ZEROFILL     32      /* my_malloc(), fill array with zero */
 
66
#define MY_ALLOW_ZERO_PTR 64    /* my_realloc() ; zero ptr -> malloc */
 
67
#define MY_FREE_ON_ERROR 128    /* my_realloc() ; Free old ptr on error */
 
68
#define MY_HOLD_ON_ERROR 256    /* my_realloc() ; Return old ptr on error */
 
69
#define MY_DONT_OVERWRITE_FILE 1024     /* my_copy: Don't overwrite file */
 
70
#define MY_THREADSAFE 2048      /* my_seek(): lock fd mutex */
 
71
 
 
72
#define MY_CHECK_ERROR  1       /* Params to my_end; Check open-close */
 
73
#define MY_GIVE_INFO    2       /* Give time info about process*/
 
74
#define MY_DONT_FREE_DBUG 4     /* Do not call DBUG_END() in my_end() */
 
75
 
 
76
#define MY_REMOVE_NONE    0     /* Params for modify_defaults_file */
 
77
#define MY_REMOVE_OPTION  1
 
78
#define MY_REMOVE_SECTION 2
 
79
 
 
80
#define ME_HIGHBYTE     8       /* Shift for colours */
 
81
#define ME_NOCUR        1       /* Don't use curses message */
 
82
#define ME_OLDWIN       2       /* Use old window */
 
83
#define ME_BELL         4       /* Ring bell then printing message */
 
84
#define ME_HOLDTANG     8       /* Don't delete last keys */
 
85
#define ME_WAITTOT      16      /* Wait for errtime secs of for a action */
 
86
#define ME_WAITTANG     32      /* Wait for a user action  */
 
87
#define ME_NOREFRESH    64      /* Dont refresh screen */
 
88
#define ME_NOINPUT      128     /* Dont use the input libary */
 
89
#define ME_COLOUR1      ((1 << ME_HIGHBYTE))    /* Possibly error-colours */
 
90
#define ME_COLOUR2      ((2 << ME_HIGHBYTE))
 
91
#define ME_COLOUR3      ((3 << ME_HIGHBYTE))
 
92
#define ME_FATALERROR   1024    /* Fatal statement error */
 
93
 
 
94
        /* Bits in last argument to fn_format */
 
95
#define MY_REPLACE_DIR          1       /* replace dir in name with 'dir' */
 
96
#define MY_REPLACE_EXT          2       /* replace extension with 'ext' */
 
97
#define MY_UNPACK_FILENAME      4       /* Unpack name (~ -> home) */
 
98
#define MY_PACK_FILENAME        8       /* Pack name (home -> ~) */
 
99
#define MY_RESOLVE_SYMLINKS     16      /* Resolve all symbolic links */
 
100
#define MY_RETURN_REAL_PATH     32      /* return full path for file */
 
101
#define MY_SAFE_PATH            64      /* Return NULL if too long path */
 
102
#define MY_RELATIVE_PATH        128     /* name is relative to 'dir' */
 
103
#define MY_APPEND_EXT           256     /* add 'ext' as additional extension*/
 
104
 
 
105
 
 
106
        /* My seek flags */
 
107
#define MY_SEEK_SET     0
 
108
#define MY_SEEK_CUR     1
 
109
#define MY_SEEK_END     2
 
110
 
 
111
        /* Some constants */
 
112
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
 
113
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
 
114
#define MIN_COMPRESS_LENGTH             50      /* Don't compress small bl. */
 
115
#define DFLT_INIT_HITS  3
 
116
 
 
117
        /* root_alloc flags */
 
118
#define MY_KEEP_PREALLOC        1
 
119
#define MY_MARK_BLOCKS_FREE     2  /* move used to free list and reuse them */
 
120
 
 
121
        /* Internal error numbers (for assembler functions) */
 
122
#define MY_ERRNO_EDOM           33
 
123
#define MY_ERRNO_ERANGE         34
 
124
 
 
125
        /* Bits for get_date timeflag */
 
126
#define GETDATE_DATE_TIME       1
 
127
#define GETDATE_SHORT_DATE      2
 
128
#define GETDATE_HHMMSSTIME      4
 
129
#define GETDATE_GMT             8
 
130
#define GETDATE_FIXEDLENGTH     16
 
131
 
 
132
        /* defines when allocating data */
 
133
#ifdef SAFEMALLOC
 
134
#else
 
135
#define my_checkmalloc()
 
136
#undef TERMINATE
 
137
#define TERMINATE(A,B) {}
 
138
#define QUICK_SAFEMALLOC
 
139
#define NORMAL_SAFEMALLOC
 
140
extern void *my_malloc(size_t Size,myf MyFlags);
 
141
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
 
142
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
 
143
extern void my_no_flags_free(void *ptr);
 
144
extern void *my_memdup(const void *from,size_t length,myf MyFlags);
 
145
extern char *my_strdup(const char *from,myf MyFlags);
 
146
extern char *my_strndup(const char *from, size_t length,
 
147
                                   myf MyFlags);
 
148
/* we do use FG (as a no-op) in below so that a typo on FG is caught */
 
149
#define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
 
150
#define CALLER_INFO_PROTO   /* nothing */
 
151
#define CALLER_INFO         /* nothing */
 
152
#define ORIG_CALLER_INFO    /* nothing */
 
153
#define TRASH(A,B) /* nothing */
 
154
#endif
 
155
 
 
156
#ifdef HAVE_LARGE_PAGES
 
157
extern uint my_get_large_page_size(void);
 
158
extern uchar * my_large_malloc(size_t size, myf my_flags);
 
159
extern void my_large_free(uchar * ptr, myf my_flags);
 
160
#else
 
161
#define my_get_large_page_size() (0)
 
162
#define my_large_malloc(A,B) my_malloc_lock((A),(B))
 
163
#define my_large_free(A,B) my_free_lock((A),(B))
 
164
#endif /* HAVE_LARGE_PAGES */
 
165
 
 
166
#ifdef HAVE_ALLOCA
 
167
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
 
168
#define alloca __builtin_alloca
 
169
#endif /* GNUC */
 
170
#define my_alloca(SZ) alloca((size_t) (SZ))
 
171
#define my_afree(PTR) {}
 
172
#else
 
173
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
 
174
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
 
175
#endif /* HAVE_ALLOCA */
 
176
 
 
177
#ifndef errno                           /* did we already get it? */
 
178
#ifdef HAVE_ERRNO_AS_DEFINE
 
179
#include <errno.h>                      /* errno is a define */
 
180
#else
 
181
extern int errno;                       /* declare errno */
 
182
#endif
 
183
#endif                                  /* #ifndef errno */
 
184
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
 
185
extern char *home_dir;                  /* Home directory for user */
 
186
extern const char *my_progname;         /* program-name (printed in errors) */
 
187
extern char curr_dir[];         /* Current directory for user */
 
188
extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
 
189
extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
 
190
                                        myf MyFlags);
 
191
extern uint my_file_limit;
 
192
extern ulong my_thread_stack_size;
 
193
 
 
194
#ifdef HAVE_LARGE_PAGES
 
195
extern my_bool my_use_large_pages;
 
196
extern uint    my_large_page_size;
 
197
#endif
 
198
 
 
199
/* charsets */
 
200
extern CHARSET_INFO *default_charset_info;
 
201
extern CHARSET_INFO *all_charsets[256];
 
202
extern CHARSET_INFO compiled_charsets[];
 
203
 
 
204
/* statistics */
 
205
extern ulong    my_file_opened,my_stream_opened, my_tmp_file_created;
 
206
extern ulong    my_file_total_opened;
 
207
extern uint     mysys_usage_id;
 
208
extern my_bool  my_init_done;
 
209
 
 
210
                                        /* Point to current my_message() */
 
211
extern void (*my_sigtstp_cleanup)(void),
 
212
                                        /* Executed before jump to shell */
 
213
            (*my_sigtstp_restart)(void),
 
214
            (*my_abort_hook)(int);
 
215
                                        /* Executed when comming from shell */
 
216
extern int my_umask,            /* Default creation mask  */
 
217
           my_umask_dir,
 
218
           my_recived_signals,  /* Signals we have got */
 
219
           my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
 
220
           my_dont_interrupt;   /* call remember_intr when set */
 
221
extern my_bool mysys_uses_curses, my_use_symdir;
 
222
extern ulong sf_malloc_cur_memory, sf_malloc_max_memory;
 
223
 
 
224
extern ulong    my_default_record_cache_size;
 
225
extern my_bool my_disable_locking, my_disable_async_io,
 
226
               my_disable_flush_key_blocks, my_disable_symlinks;
 
227
extern char     wild_many, wild_one, wild_prefix;
 
228
extern const char *charsets_dir;
 
229
/* from default.c */
 
230
extern char *my_defaults_extra_file;
 
231
extern const char *my_defaults_group_suffix;
 
232
extern const char *my_defaults_file;
 
233
 
 
234
extern my_bool timed_mutexes;
 
235
 
 
236
typedef struct wild_file_pack   /* Struct to hold info when selecting files */
 
237
{
 
238
  uint          wilds;          /* How many wildcards */
 
239
  uint          not_pos;        /* Start of not-theese-files */
 
240
  char *        *wild;          /* Pointer to wildcards */
 
241
} WF_PACK;
 
242
 
 
243
enum loglevel {
 
244
   ERROR_LEVEL,
 
245
   WARNING_LEVEL,
 
246
   INFORMATION_LEVEL
 
247
};
 
248
 
 
249
enum cache_type
 
250
{
 
251
  TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE,
 
252
  SEQ_READ_APPEND               /* sequential read or append */,
 
253
  READ_FIFO, READ_NET,WRITE_NET};
 
254
 
 
255
enum flush_type
 
256
{
 
257
  FLUSH_KEEP,           /* flush block and keep it in the cache */
 
258
  FLUSH_RELEASE,        /* flush block and remove it from the cache */
 
259
  FLUSH_IGNORE_CHANGED, /* remove block from the cache */
 
260
  /*
 
261
    As my_disable_flush_pagecache_blocks is always 0, the following option
 
262
    is strictly equivalent to FLUSH_KEEP
 
263
  */
 
264
  FLUSH_FORCE_WRITE
 
265
};
 
266
 
 
267
typedef struct st_record_cache  /* Used when cacheing records */
 
268
{
 
269
  File file;
 
270
  int   rc_seek,error,inited;
 
271
  uint  rc_length,read_length,reclength;
 
272
  my_off_t rc_record_pos,end_of_file;
 
273
  uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
 
274
#ifdef HAVE_AIOWAIT
 
275
  int   use_async_io;
 
276
  my_aio_result aio_result;
 
277
#endif
 
278
  enum cache_type type;
 
279
} RECORD_CACHE;
 
280
 
 
281
enum file_type
 
282
{
 
283
  UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,
 
284
  FILE_BY_MKSTEMP, FILE_BY_DUP
 
285
};
 
286
 
 
287
struct st_my_file_info
 
288
{
 
289
  char *                name;
 
290
  enum file_type        type;
 
291
#if defined(THREAD) && !defined(HAVE_PREAD)
 
292
  pthread_mutex_t       mutex;
 
293
#endif
 
294
};
 
295
 
 
296
extern struct st_my_file_info *my_file_info;
 
297
 
 
298
typedef struct st_dynamic_array
 
299
{
 
300
  uchar *buffer;
 
301
  uint elements,max_element;
 
302
  uint alloc_increment;
 
303
  uint size_of_element;
 
304
} DYNAMIC_ARRAY;
 
305
 
 
306
typedef struct st_my_tmpdir
 
307
{
 
308
  DYNAMIC_ARRAY full_list;
 
309
  char **list;
 
310
  uint cur, max;
 
311
#ifdef THREAD
 
312
  pthread_mutex_t mutex;
 
313
#endif
 
314
} MY_TMPDIR;
 
315
 
 
316
typedef struct st_dynamic_string
 
317
{
 
318
  char *str;
 
319
  size_t length,max_length,alloc_increment;
 
320
} DYNAMIC_STRING;
 
321
 
 
322
struct st_io_cache;
 
323
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
 
324
 
 
325
#ifdef THREAD
 
326
typedef struct st_io_cache_share
 
327
{
 
328
  pthread_mutex_t       mutex;           /* To sync on reads into buffer. */
 
329
  pthread_cond_t        cond;            /* To wait for signals. */
 
330
  pthread_cond_t        cond_writer;     /* For a synchronized writer. */
 
331
  /* Offset in file corresponding to the first byte of buffer. */
 
332
  my_off_t              pos_in_file;
 
333
  /* If a synchronized write cache is the source of the data. */
 
334
  struct st_io_cache    *source_cache;
 
335
  uchar                 *buffer;         /* The read buffer. */
 
336
  uchar                 *read_end;       /* Behind last valid byte of buffer. */
 
337
  int                   running_threads; /* threads not in lock. */
 
338
  int                   total_threads;   /* threads sharing the cache. */
 
339
  int                   error;           /* Last error. */
 
340
#ifdef NOT_YET_IMPLEMENTED
 
341
  /* whether the structure should be free'd */
 
342
  my_bool alloced;
 
343
#endif
 
344
} IO_CACHE_SHARE;
 
345
#endif
 
346
 
 
347
typedef struct st_io_cache              /* Used when cacheing files */
 
348
{
 
349
  /* Offset in file corresponding to the first byte of uchar* buffer. */
 
350
  my_off_t pos_in_file;
 
351
  /*
 
352
    The offset of end of file for READ_CACHE and WRITE_CACHE.
 
353
    For SEQ_READ_APPEND it the maximum of the actual end of file and
 
354
    the position represented by read_end.
 
355
  */
 
356
  my_off_t end_of_file;
 
357
  /* Points to current read position in the buffer */
 
358
  uchar *read_pos;
 
359
  /* the non-inclusive boundary in the buffer for the currently valid read */
 
360
  uchar  *read_end;
 
361
  uchar  *buffer;                               /* The read buffer */
 
362
  /* Used in ASYNC_IO */
 
363
  uchar  *request_pos;
 
364
 
 
365
  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
 
366
  uchar  *write_buffer;
 
367
  /*
 
368
    Only used in SEQ_READ_APPEND, and points to the current read position
 
369
    in the write buffer. Note that reads in SEQ_READ_APPEND caches can
 
370
    happen from both read buffer (uchar* buffer) and write buffer
 
371
    (uchar* write_buffer).
 
372
  */
 
373
  uchar *append_read_pos;
 
374
  /* Points to current write position in the write buffer */
 
375
  uchar *write_pos;
 
376
  /* The non-inclusive boundary of the valid write area */
 
377
  uchar *write_end;
 
378
 
 
379
  /*
 
380
    Current_pos and current_end are convenience variables used by
 
381
    my_b_tell() and other routines that need to know the current offset
 
382
    current_pos points to &write_pos, and current_end to &write_end in a
 
383
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise
 
384
  */
 
385
  uchar  **current_pos, **current_end;
 
386
#ifdef THREAD
 
387
  /*
 
388
    The lock is for append buffer used in SEQ_READ_APPEND cache
 
389
    need mutex copying from append buffer to read buffer.
 
390
  */
 
391
  pthread_mutex_t append_buffer_lock;
 
392
  /*
 
393
    The following is used when several threads are reading the
 
394
    same file in parallel. They are synchronized on disk
 
395
    accesses reading the cached part of the file asynchronously.
 
396
    It should be set to NULL to disable the feature.  Only
 
397
    READ_CACHE mode is supported.
 
398
  */
 
399
  IO_CACHE_SHARE *share;
 
400
#endif
 
401
  /*
 
402
    A caller will use my_b_read() macro to read from the cache
 
403
    if the data is already in cache, it will be simply copied with
 
404
    memcpy() and internal variables will be accordinging updated with
 
405
    no functions invoked. However, if the data is not fully in the cache,
 
406
    my_b_read() will call read_function to fetch the data. read_function
 
407
    must never be invoked directly.
 
408
  */
 
409
  int (*read_function)(struct st_io_cache *,uchar *,size_t);
 
410
  /*
 
411
    Same idea as in the case of read_function, except my_b_write() needs to
 
412
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
 
413
  */
 
414
  int (*write_function)(struct st_io_cache *,const uchar *,size_t);
 
415
  /*
 
416
    Specifies the type of the cache. Depending on the type of the cache
 
417
    certain operations might not be available and yield unpredicatable
 
418
    results. Details to be documented later
 
419
  */
 
420
  enum cache_type type;
 
421
  /*
 
422
    Callbacks when the actual read I/O happens. These were added and
 
423
    are currently used for binary logging of LOAD DATA INFILE - when a
 
424
    block is read from the file, we create a block create/append event, and
 
425
    when IO_CACHE is closed, we create an end event. These functions could,
 
426
    of course be used for other things
 
427
  */
 
428
  IO_CACHE_CALLBACK pre_read;
 
429
  IO_CACHE_CALLBACK post_read;
 
430
  IO_CACHE_CALLBACK pre_close;
 
431
  /*
 
432
    Counts the number of times, when we were forced to use disk. We use it to
 
433
    increase the binlog_cache_disk_use status variable.
 
434
  */
 
435
  ulong disk_writes;
 
436
  void* arg;                            /* for use by pre/post_read */
 
437
  char *file_name;                      /* if used with 'open_cached_file' */
 
438
  char *dir,*prefix;
 
439
  File file; /* file descriptor */
 
440
  /*
 
441
    seek_not_done is set by my_b_seek() to inform the upcoming read/write
 
442
    operation that a seek needs to be preformed prior to the actual I/O
 
443
    error is 0 if the cache operation was successful, -1 if there was a
 
444
    "hard" error, and the actual number of I/O-ed bytes if the read/write was
 
445
    partial.
 
446
  */
 
447
  int   seek_not_done,error;
 
448
  /* buffer_length is memory size allocated for buffer or write_buffer */
 
449
  size_t        buffer_length;
 
450
  /* read_length is the same as buffer_length except when we use async io */
 
451
  size_t  read_length;
 
452
  myf   myflags;                        /* Flags used to my_read/my_write */
 
453
  /*
 
454
    alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
 
455
    0 if it was supplied by the user.
 
456
    Currently READ_NET is the only one that will use a buffer allocated
 
457
    somewhere else
 
458
  */
 
459
  my_bool alloced_buffer;
 
460
#ifdef HAVE_AIOWAIT
 
461
  /*
 
462
    As inidicated by ifdef, this is for async I/O, which is not currently
 
463
    used (because it's not reliable on all systems)
 
464
  */
 
465
  uint inited;
 
466
  my_off_t aio_read_pos;
 
467
  my_aio_result aio_result;
 
468
#endif
 
469
} IO_CACHE;
 
470
 
 
471
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
 
472
 
 
473
        /* defines for mf_iocache */
 
474
 
 
475
        /* Test if buffer is inited */
 
476
#define my_b_clear(info) (info)->buffer=0
 
477
#define my_b_inited(info) (info)->buffer
 
478
#define my_b_EOF INT_MIN
 
479
 
 
480
#define my_b_read(info,Buffer,Count) \
 
481
  ((info)->read_pos + (Count) <= (info)->read_end ?\
 
482
   (memcpy(Buffer,(info)->read_pos,(size_t) (Count)), \
 
483
    ((info)->read_pos+=(Count)),0) :\
 
484
   (*(info)->read_function)((info),Buffer,Count))
 
485
 
 
486
#define my_b_write(info,Buffer,Count) \
 
487
 ((info)->write_pos + (Count) <=(info)->write_end ?\
 
488
  (memcpy((info)->write_pos, (Buffer), (size_t)(Count)),\
 
489
   ((info)->write_pos+=(Count)),0) : \
 
490
   (*(info)->write_function)((info),(Buffer),(Count)))
 
491
 
 
492
#define my_b_get(info) \
 
493
  ((info)->read_pos != (info)->read_end ?\
 
494
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
 
495
   _my_b_get(info))
 
496
 
 
497
        /* my_b_write_byte dosn't have any err-check */
 
498
#define my_b_write_byte(info,chr) \
 
499
  (((info)->write_pos < (info)->write_end) ?\
 
500
   ((*(info)->write_pos++)=(chr)) :\
 
501
   (_my_b_write(info,0,0) , ((*(info)->write_pos++)=(chr))))
 
502
 
 
503
#define my_b_fill_cache(info) \
 
504
  (((info)->read_end=(info)->read_pos),(*(info)->read_function)(info,0,0))
 
505
 
 
506
#define my_b_tell(info) ((info)->pos_in_file + \
 
507
                         (size_t) (*(info)->current_pos - (info)->request_pos))
 
508
 
 
509
#define my_b_get_buffer_start(info) (info)->request_pos 
 
510
#define my_b_get_bytes_in_buffer(info) (char*) (info)->read_end -   \
 
511
  (char*) my_b_get_buffer_start(info)
 
512
#define my_b_get_pos_in_file(info) (info)->pos_in_file
 
513
 
 
514
/* tell write offset in the SEQ_APPEND cache */
 
515
int      my_b_copy_to_file(IO_CACHE *cache, FILE *file);
 
516
my_off_t my_b_append_tell(IO_CACHE* info);
 
517
my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
 
518
 
 
519
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
 
520
                                          *(info)->current_pos)
 
521
 
 
522
typedef uint32 ha_checksum;
 
523
 
 
524
/* Define the type of function to be passed to process_default_option_files */
 
525
typedef int (*Process_option_func)(void *ctx, const char *group_name,
 
526
                                   const char *option);
 
527
 
 
528
#include <my_alloc.h>
 
529
 
 
530
 
 
531
        /* Prototypes for mysys and my_func functions */
 
532
 
 
533
extern int my_copy(const char *from,const char *to,myf MyFlags);
 
534
extern int my_append(const char *from,const char *to,myf MyFlags);
 
535
extern int my_delete(const char *name,myf MyFlags);
 
536
extern int my_getwd(char * buf,size_t size,myf MyFlags);
 
537
extern int my_setwd(const char *dir,myf MyFlags);
 
538
extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
 
539
extern void *my_once_alloc(size_t Size,myf MyFlags);
 
540
extern void my_once_free(void);
 
541
extern char *my_once_strdup(const char *src,myf myflags);
 
542
extern void *my_once_memdup(const void *src, size_t len, myf myflags);
 
543
extern File my_open(const char *FileName,int Flags,myf MyFlags);
 
544
extern File my_register_filename(File fd, const char *FileName,
 
545
                                 enum file_type type_of_file,
 
546
                                 uint error_message_number, myf MyFlags);
 
547
extern File my_create(const char *FileName,int CreateFlags,
 
548
                      int AccessFlags, myf MyFlags);
 
549
extern int my_close(File Filedes,myf MyFlags);
 
550
extern File my_dup(File file, myf MyFlags);
 
551
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
 
552
extern int my_readlink(char *to, const char *filename, myf MyFlags);
 
553
extern int my_realpath(char *to, const char *filename, myf MyFlags);
 
554
extern File my_create_with_symlink(const char *linkname, const char *filename,
 
555
                                   int createflags, int access_flags,
 
556
                                   myf MyFlags);
 
557
extern int my_delete_with_symlink(const char *name, myf MyFlags);
 
558
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
 
559
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
 
560
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
 
561
extern size_t my_pread(File Filedes,uchar *Buffer,size_t Count,my_off_t offset,
 
562
                     myf MyFlags);
 
563
extern int my_rename(const char *from,const char *to,myf MyFlags);
 
564
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
 
565
extern my_off_t my_tell(File fd,myf MyFlags);
 
566
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
 
567
                     myf MyFlags);
 
568
extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count,
 
569
                      my_off_t offset,myf MyFlags);
 
570
extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
 
571
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
 
572
                      myf MyFlags);
 
573
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
 
574
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
 
575
extern void *_mymalloc(size_t uSize,const char *sFile,
 
576
                       uint uLine, myf MyFlag);
 
577
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
 
578
                       uint uLine, myf MyFlag);
 
579
extern void * my_multi_malloc _VARARGS((myf MyFlags, ...));
 
580
extern void _myfree(void *pPtr,const char *sFile,uint uLine, myf MyFlag);
 
581
extern int _sanity(const char *sFile, uint uLine);
 
582
extern void *_my_memdup(const void *from, size_t length,
 
583
                        const char *sFile, uint uLine,myf MyFlag);
 
584
extern char * _my_strdup(const char *from, const char *sFile, uint uLine,
 
585
                         myf MyFlag);
 
586
extern char *_my_strndup(const char *from, size_t length,
 
587
                         const char *sFile, uint uLine,
 
588
                         myf MyFlag);
 
589
 
 
590
/* implemented in my_memmem.c */
 
591
extern void *my_memmem(const void *haystack, size_t haystacklen,
 
592
                       const void *needle, size_t needlelen);
 
593
 
 
594
 
 
595
#define my_access access
 
596
extern int check_if_legal_filename(const char *path);
 
597
extern int check_if_legal_tablename(const char *path);
 
598
 
 
599
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
 
600
 
 
601
#ifndef TERMINATE
 
602
extern void TERMINATE(FILE *file, uint flag);
 
603
#endif
 
604
extern void init_glob_errs(void);
 
605
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
 
606
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
 
607
extern int my_fclose(FILE *fd,myf MyFlags);
 
608
extern int my_chsize(File fd,my_off_t newlength, int filler, myf MyFlags);
 
609
extern int my_sync(File fd, myf my_flags);
 
610
extern int my_sync_dir(const char *dir_name, myf my_flags);
 
611
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
 
612
extern void my_error _VARARGS((int nr,myf MyFlags, ...));
 
613
extern void my_printf_error _VARARGS((uint my_err, const char *format,
 
614
                                      myf MyFlags, ...))
 
615
                                      ATTRIBUTE_FORMAT(printf, 2, 4);
 
616
extern int my_error_register(const char **errmsgs, int first, int last);
 
617
extern const char **my_error_unregister(int first, int last);
 
618
extern void my_message(uint my_err, const char *str,myf MyFlags);
 
619
extern void my_message_no_curses(uint my_err, const char *str,myf MyFlags);
 
620
extern my_bool my_init(void);
 
621
extern void my_end(int infoflag);
 
622
extern int my_redel(const char *from, const char *to, int MyFlags);
 
623
extern int my_copystat(const char *from, const char *to, int MyFlags);
 
624
extern char * my_filename(File fd);
 
625
 
 
626
#ifndef THREAD
 
627
extern void dont_break(void);
 
628
extern void allow_break(void);
 
629
#else
 
630
#define dont_break()
 
631
#define allow_break()
 
632
#endif
 
633
 
 
634
#ifdef EXTRA_DEBUG
 
635
void my_print_open_files(void);
 
636
#else
 
637
#define my_print_open_files()
 
638
#endif
 
639
 
 
640
extern my_bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
 
641
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
 
642
extern void free_tmpdir(MY_TMPDIR *tmpdir);
 
643
 
 
644
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
 
645
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
 
646
extern size_t dirname_length(const char *name);
 
647
#define base_name(A) (A+dirname_length(A))
 
648
extern int test_if_hard_path(const char *dir_name);
 
649
extern my_bool has_path(const char *name);
 
650
extern char *convert_dirname(char *to, const char *from, const char *from_end);
 
651
extern void to_unix_path(char * name);
 
652
extern char * fn_ext(const char *name);
 
653
extern char * fn_same(char * toname,const char *name,int flag);
 
654
extern char * fn_format(char * to,const char *name,const char *dir,
 
655
                           const char *form, uint flag);
 
656
extern size_t strlength(const char *str);
 
657
extern void pack_dirname(char * to,const char *from);
 
658
extern size_t unpack_dirname(char * to,const char *from);
 
659
extern size_t cleanup_dirname(char * to,const char *from);
 
660
extern size_t system_filename(char * to,const char *from);
 
661
extern size_t unpack_filename(char * to,const char *from);
 
662
extern char * intern_filename(char * to,const char *from);
 
663
extern char * directory_file_name(char * dst, const char *src);
 
664
extern int pack_filename(char * to, const char *name, size_t max_length);
 
665
extern char * my_path(char * to,const char *progname,
 
666
                         const char *own_pathname_part);
 
667
extern char * my_load_path(char * to, const char *path,
 
668
                              const char *own_path_prefix);
 
669
extern int wild_compare(const char *str,const char *wildstr,
 
670
                        pbool str_is_pattern);
 
671
extern WF_PACK *wf_comp(char * str);
 
672
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
 
673
extern void wf_end(struct wild_file_pack *buffer);
 
674
extern size_t strip_sp(char * str);
 
675
extern my_bool array_append_string_unique(const char *str,
 
676
                                          const char **array, size_t size);
 
677
extern void get_date(char * to,int timeflag,time_t use_time);
 
678
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
 
679
                    pbool remove_garbage);
 
680
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
 
681
                             size_t reclength,enum cache_type type,
 
682
                             pbool use_async_io);
 
683
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
 
684
extern int end_record_cache(RECORD_CACHE *info);
 
685
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
 
686
                              const uchar *record,size_t length);
 
687
extern int flush_write_cache(RECORD_CACHE *info);
 
688
extern long my_clock(void);
 
689
extern sig_handler sigtstp_handler(int signal_number);
 
690
extern void handle_recived_signals(void);
 
691
 
 
692
extern sig_handler my_set_alarm_variable(int signo);
 
693
extern void my_string_ptr_sort(uchar *base,uint items,size_t size);
 
694
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
 
695
                                  size_t size_of_element,uchar *buffer[]);
 
696
extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
697
                        qsort_cmp cmp);
 
698
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
699
                         qsort2_cmp cmp, void *cmp_argument);
 
700
extern qsort2_cmp get_ptr_compare(size_t);
 
701
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
 
702
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
 
703
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
 
704
                         enum cache_type type,my_off_t seek_offset,
 
705
                         pbool use_async_io, myf cache_myflags);
 
706
extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
 
707
                               my_off_t seek_offset,pbool use_async_io,
 
708
                               pbool clear_cache);
 
709
extern void setup_io_cache(IO_CACHE* info);
 
710
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
711
#ifdef THREAD
 
712
extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
 
713
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
 
714
                                IO_CACHE *write_cache, uint num_threads);
 
715
extern void remove_io_thread(IO_CACHE *info);
 
716
#endif
 
717
extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
718
extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
719
extern int _my_b_get(IO_CACHE *info);
 
720
extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
721
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
722
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
723
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
724
 
 
725
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
 
726
                          size_t Count, my_off_t pos);
 
727
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
 
728
 
 
729
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
 
730
 
 
731
extern int end_io_cache(IO_CACHE *info);
 
732
extern size_t my_b_fill(IO_CACHE *info);
 
733
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
 
734
extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
 
735
extern my_off_t my_b_filelength(IO_CACHE *info);
 
736
extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...);
 
737
extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
 
738
extern my_bool open_cached_file(IO_CACHE *cache,const char *dir,
 
739
                                 const char *prefix, size_t cache_size,
 
740
                                 myf cache_myflags);
 
741
extern my_bool real_open_cached_file(IO_CACHE *cache);
 
742
extern void close_cached_file(IO_CACHE *cache);
 
743
File create_temp_file(char *to, const char *dir, const char *pfx,
 
744
                      int mode, myf MyFlags);
 
745
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D CALLER_INFO)
 
746
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
 
747
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
 
748
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
 
749
extern my_bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
 
750
                                   void *init_buffer, uint init_alloc, 
 
751
                                   uint alloc_increment
 
752
                                   CALLER_INFO_PROTO);
 
753
/* init_dynamic_array() function is deprecated */
 
754
extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
 
755
                                  uint init_alloc,uint alloc_increment
 
756
                                  CALLER_INFO_PROTO);
 
757
extern my_bool insert_dynamic(DYNAMIC_ARRAY *array,uchar * element);
 
758
extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array);
 
759
extern uchar *pop_dynamic(DYNAMIC_ARRAY*);
 
760
extern my_bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
 
761
extern my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements);
 
762
extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
 
763
extern void delete_dynamic(DYNAMIC_ARRAY *array);
 
764
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
 
765
extern void freeze_size(DYNAMIC_ARRAY *array);
 
766
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
 
767
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
 
768
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
 
769
#define push_dynamic(A,B) insert_dynamic((A),(B))
 
770
#define reset_dynamic(array) ((array)->elements= 0)
 
771
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
 
772
 
 
773
extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
 
774
                                   size_t init_alloc,size_t alloc_increment);
 
775
extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append);
 
776
my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
 
777
                          size_t length);
 
778
extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
 
779
                                       ...);
 
780
extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
 
781
extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
 
782
extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
 
783
extern void dynstr_free(DYNAMIC_STRING *str);
 
784
#ifdef HAVE_MLOCK
 
785
extern void *my_malloc_lock(size_t length,myf flags);
 
786
extern void my_free_lock(void *ptr,myf flags);
 
787
#else
 
788
#define my_malloc_lock(A,B) my_malloc((A),(B))
 
789
#define my_free_lock(A,B) my_free((A),(B))
 
790
#endif
 
791
#define alloc_root_inited(A) ((A)->min_malloc != 0)
 
792
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
 
793
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
 
794
extern void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
 
795
                            size_t pre_alloc_size);
 
796
extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
 
797
extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
 
798
extern void free_root(MEM_ROOT *root, myf MyFLAGS);
 
799
extern void set_prealloc_root(MEM_ROOT *root, char *ptr);
 
800
extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
 
801
                                size_t prealloc_size);
 
802
extern char *strdup_root(MEM_ROOT *root,const char *str);
 
803
extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
 
804
extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
 
805
extern int get_defaults_options(int argc, char **argv,
 
806
                                char **defaults, char **extra_defaults,
 
807
                                char **group_suffix);
 
808
extern int load_defaults(const char *conf_file, const char **groups,
 
809
                         int *argc, char ***argv);
 
810
extern int modify_defaults_file(const char *file_location, const char *option,
 
811
                                const char *option_value,
 
812
                                const char *section_name, int remove_option);
 
813
extern int my_search_option_files(const char *conf_file, int *argc,
 
814
                                  char ***argv, uint *args_used,
 
815
                                  Process_option_func func, void *func_ctx);
 
816
extern void free_defaults(char **argv);
 
817
extern void my_print_default_files(const char *conf_file);
 
818
extern void print_defaults(const char *conf_file, const char **groups);
 
819
extern my_bool my_compress(uchar *, size_t *, size_t *);
 
820
extern my_bool my_uncompress(uchar *, size_t , size_t *);
 
821
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
 
822
                                size_t *complen);
 
823
extern int packfrm(uchar *, size_t, uchar **, size_t *);
 
824
extern int unpackfrm(uchar **, size_t *, const uchar *);
 
825
 
 
826
extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
 
827
                               size_t count);
 
828
extern void my_sleep(ulong m_seconds);
 
829
extern ulong crc32(ulong crc, const uchar *buf, uint len);
 
830
extern uint my_set_max_open_files(uint files);
 
831
void my_free_open_file_info(void);
 
832
 
 
833
extern time_t my_time(myf flags);
 
834
extern ulonglong my_getsystime(void);
 
835
extern ulonglong my_micro_time();
 
836
extern ulonglong my_micro_time_and_time(time_t *time_arg);
 
837
time_t my_time_possible_from_micro(ulonglong microtime);
 
838
extern my_bool my_gethwaddr(uchar *to);
 
839
extern int my_getncpus();
 
840
 
 
841
#ifdef HAVE_SYS_MMAN_H
 
842
#include <sys/mman.h>
 
843
 
 
844
#ifndef MAP_NOSYNC
 
845
#define MAP_NOSYNC      0
 
846
#endif
 
847
#ifndef MAP_NORESERVE
 
848
#define MAP_NORESERVE 0         /* For irix and AIX */
 
849
#endif
 
850
 
 
851
#ifdef HAVE_MMAP64
 
852
#define my_mmap(a,b,c,d,e,f)    mmap64(a,b,c,d,e,f)
 
853
#else
 
854
#define my_mmap(a,b,c,d,e,f)    mmap(a,b,c,d,e,f)
 
855
#endif
 
856
#define my_munmap(a,b)          munmap((a),(b))
 
857
 
 
858
#else
 
859
/* not a complete set of mmap() flags, but only those that nesessary */
 
860
#define PROT_READ        1
 
861
#define PROT_WRITE       2
 
862
#define MAP_NORESERVE    0
 
863
#define MAP_SHARED       0x0001
 
864
#define MAP_PRIVATE      0x0002
 
865
#define MAP_NOSYNC       0x0800
 
866
#define MAP_FAILED       ((void *)-1)
 
867
#define MS_SYNC          0x0000
 
868
 
 
869
#ifndef __NETWARE__
 
870
#define HAVE_MMAP
 
871
#endif
 
872
 
 
873
void *my_mmap(void *, size_t, int, int, int, my_off_t);
 
874
int my_munmap(void *, size_t);
 
875
#endif
 
876
 
 
877
/* my_getpagesize */
 
878
#ifdef HAVE_GETPAGESIZE
 
879
#define my_getpagesize()        getpagesize()
 
880
#else
 
881
int my_getpagesize(void);
 
882
#endif
 
883
 
 
884
int my_msync(int, void *, size_t, int);
 
885
 
 
886
/* character sets */
 
887
extern uint get_charset_number(const char *cs_name, uint cs_flags);
 
888
extern uint get_collation_number(const char *name);
 
889
extern const char *get_charset_name(uint cs_number);
 
890
 
 
891
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
 
892
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
 
893
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
 
894
                                           uint cs_flags, myf my_flags);
 
895
 
 
896
extern my_bool resolve_charset(const char *cs_name,
 
897
                               CHARSET_INFO *default_cs,
 
898
                               CHARSET_INFO **cs);
 
899
extern my_bool resolve_collation(const char *cl_name,
 
900
                                 CHARSET_INFO *default_cl,
 
901
                                 CHARSET_INFO **cl);
 
902
 
 
903
extern void free_charsets(void);
 
904
extern char *get_charsets_dir(char *buf);
 
905
extern my_bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2);
 
906
extern my_bool init_compiled_charsets(myf flags);
 
907
extern void add_compiled_collation(CHARSET_INFO *cs);
 
908
extern size_t escape_string_for_mysql(CHARSET_INFO *charset_info,
 
909
                                      char *to, size_t to_length,
 
910
                                      const char *from, size_t length);
 
911
extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
 
912
                                      char *to, size_t to_length,
 
913
                                      const char *from, size_t length);
 
914
 
 
915
extern void thd_increment_bytes_sent(ulong length);
 
916
extern void thd_increment_bytes_received(ulong length);
 
917
extern void thd_increment_net_big_packet_count(ulong length);
 
918
 
 
919
C_MODE_END
 
920
#endif /* _my_sys_h */