← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_sys.h

  • Committer: Brian Aker
  • Date: 2008-07-13 22:45:08 UTC
  • Revision ID: brian@tangent.org-20080713224508-hb20z4okblotb39a
longlong replacement

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/my_sys.h
15
15
 
16
16
#ifndef _my_sys_h
17
17
#define _my_sys_h
 
18
C_MODE_START
18
19
 
19
20
#ifdef HAVE_AIOWAIT
20
21
#include <sys/asynch.h>                 /* Used by record-cache */
27
28
#include <errno.h>
28
29
#define my_errno (errno)
29
30
 
30
 
#include <mysys/my_pthread.h>
 
31
#include <my_pthread.h>
31
32
 
32
 
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
 
33
#include <m_ctype.h>                    /* for CHARSET_INFO */
33
34
#include <stdarg.h>
34
 
#include <mysys/typelib.h>
 
35
#include <typelib.h>
35
36
 
 
37
#define MYSYS_PROGRAM_DONT_USE_CURSES()  { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;}
36
38
#define MY_INIT(name);          { my_progname= name; my_init(); }
37
39
 
38
40
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
68
70
 
69
71
#define MY_CHECK_ERROR  1       /* Params to my_end; Check open-close */
70
72
#define MY_GIVE_INFO    2       /* Give time info about process*/
 
73
#define MY_DONT_FREE_DBUG 4     /* Do not call DBUG_END() in my_end() */
71
74
 
72
75
#define MY_REMOVE_NONE    0     /* Params for modify_defaults_file */
73
76
#define MY_REMOVE_OPTION  1
107
110
        /* Some constants */
108
111
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
109
112
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
 
113
#define MIN_COMPRESS_LENGTH             50      /* Don't compress small bl. */
110
114
#define DFLT_INIT_HITS  3
111
115
 
112
116
        /* root_alloc flags */
125
129
#define GETDATE_FIXEDLENGTH     16
126
130
 
127
131
        /* defines when allocating data */
 
132
#ifdef SAFEMALLOC
 
133
#else
128
134
#define my_checkmalloc()
129
135
#undef TERMINATE
130
136
#define TERMINATE(A,B) {}
131
 
 
132
 
#ifdef __cplusplus
133
 
extern "C" {
134
 
#endif
135
 
 
136
 
typedef int  (*qsort_cmp)(const void *,const void *);
137
 
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
138
 
 
 
137
#define QUICK_SAFEMALLOC
 
138
#define NORMAL_SAFEMALLOC
139
139
extern void *my_malloc(size_t Size,myf MyFlags);
140
140
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
141
141
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
144
144
extern char *my_strdup(const char *from,myf MyFlags);
145
145
extern char *my_strndup(const char *from, size_t length,
146
146
                                   myf MyFlags);
 
147
/* we do use FG (as a no-op) in below so that a typo on FG is caught */
 
148
#define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
147
149
#define CALLER_INFO_PROTO   /* nothing */
148
150
#define CALLER_INFO         /* nothing */
149
151
#define ORIG_CALLER_INFO    /* nothing */
150
152
#define TRASH(A,B) /* nothing */
 
153
#endif
151
154
 
152
155
#ifdef HAVE_ALLOCA
153
156
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
154
157
#define alloca __builtin_alloca
155
158
#endif /* GNUC */
156
 
#define my_alloca(SZ) malloc((size_t) (SZ))
157
 
#define my_afree(PTR) free((PTR))
 
159
#define my_alloca(SZ) alloca((size_t) (SZ))
 
160
#define my_afree(PTR) {}
158
161
#else
159
 
#define my_alloca(SZ) malloc((SZ))
160
 
#define my_afree(PTR) free((PTR))
 
162
#define my_alloca(SZ) my_malloc(SZ,MYF(0))
 
163
#define my_afree(PTR) my_free(PTR,MYF(MY_WME))
161
164
#endif /* HAVE_ALLOCA */
162
165
 
163
166
#ifndef errno                           /* did we already get it? */
170
173
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
171
174
extern char *home_dir;                  /* Home directory for user */
172
175
extern const char *my_progname;         /* program-name (printed in errors) */
173
 
extern void (*error_handler_hook)(uint32_t my_err, const char *str,myf MyFlags);
174
 
extern void (*fatal_error_handler_hook)(uint32_t my_err, const char *str,
 
176
extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
 
177
extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
175
178
                                        myf MyFlags);
176
 
extern uint32_t my_file_limit;
177
 
extern uint32_t my_thread_stack_size;
 
179
extern uint my_file_limit;
 
180
extern ulong my_thread_stack_size;
178
181
 
179
182
/* charsets */
180
 
extern const CHARSET_INFO *default_charset_info;
 
183
extern CHARSET_INFO *default_charset_info;
181
184
extern CHARSET_INFO *all_charsets[256];
182
185
extern CHARSET_INFO compiled_charsets[];
183
186
 
184
187
/* statistics */
185
 
extern uint32_t my_file_opened,my_stream_opened, my_tmp_file_created;
186
 
extern uint32_t    my_file_total_opened;
 
188
extern ulong    my_file_opened,my_stream_opened, my_tmp_file_created;
 
189
extern ulong    my_file_total_opened;
187
190
extern uint     mysys_usage_id;
188
191
extern bool     my_init_done;
189
192
 
199
202
           my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
200
203
           my_dont_interrupt;   /* call remember_intr when set */
201
204
extern bool mysys_uses_curses, my_use_symdir;
202
 
extern uint32_t sf_malloc_cur_memory, sf_malloc_max_memory;
 
205
extern ulong sf_malloc_cur_memory, sf_malloc_max_memory;
203
206
 
204
 
extern uint32_t my_default_record_cache_size;
205
 
extern bool my_disable_async_io,
 
207
extern ulong    my_default_record_cache_size;
 
208
extern bool my_disable_locking, my_disable_async_io,
206
209
               my_disable_flush_key_blocks, my_disable_symlinks;
207
210
extern char     wild_many, wild_one, wild_prefix;
208
211
extern const char *charsets_dir;
238
241
  int   rc_seek,error,inited;
239
242
  uint  rc_length,read_length,reclength;
240
243
  my_off_t rc_record_pos,end_of_file;
241
 
  unsigned char *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
 
244
  uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
242
245
#ifdef HAVE_AIOWAIT
243
246
  int   use_async_io;
244
247
  my_aio_result aio_result;
265
268
 
266
269
typedef struct st_dynamic_array
267
270
{
268
 
  unsigned char *buffer;
269
 
  uint32_t elements,max_element;
270
 
  uint32_t alloc_increment;
271
 
  uint32_t size_of_element;
 
271
  uchar *buffer;
 
272
  uint elements,max_element;
 
273
  uint alloc_increment;
 
274
  uint size_of_element;
272
275
} DYNAMIC_ARRAY;
273
276
 
274
277
typedef struct st_my_tmpdir
275
278
{
276
279
  DYNAMIC_ARRAY full_list;
277
280
  char **list;
278
 
  uint32_t cur, max;
 
281
  uint cur, max;
279
282
  pthread_mutex_t mutex;
280
283
} MY_TMPDIR;
281
284
 
 
285
typedef struct st_dynamic_string
 
286
{
 
287
  char *str;
 
288
  size_t length,max_length,alloc_increment;
 
289
} DYNAMIC_STRING;
 
290
 
282
291
struct st_io_cache;
283
292
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
284
293
 
291
300
  my_off_t              pos_in_file;
292
301
  /* If a synchronized write cache is the source of the data. */
293
302
  struct st_io_cache    *source_cache;
294
 
  unsigned char                 *buffer;         /* The read buffer. */
295
 
  unsigned char                 *read_end;       /* Behind last valid byte of buffer. */
 
303
  uchar                 *buffer;         /* The read buffer. */
 
304
  uchar                 *read_end;       /* Behind last valid byte of buffer. */
296
305
  int                   running_threads; /* threads not in lock. */
297
306
  int                   total_threads;   /* threads sharing the cache. */
298
307
  int                   error;           /* Last error. */
304
313
 
305
314
typedef struct st_io_cache              /* Used when cacheing files */
306
315
{
307
 
  /* Offset in file corresponding to the first byte of unsigned char* buffer. */
 
316
  /* Offset in file corresponding to the first byte of uchar* buffer. */
308
317
  my_off_t pos_in_file;
309
318
  /*
310
319
    The offset of end of file for READ_CACHE and WRITE_CACHE.
313
322
  */
314
323
  my_off_t end_of_file;
315
324
  /* Points to current read position in the buffer */
316
 
  unsigned char *read_pos;
 
325
  uchar *read_pos;
317
326
  /* the non-inclusive boundary in the buffer for the currently valid read */
318
 
  unsigned char  *read_end;
319
 
  unsigned char  *buffer;                               /* The read buffer */
 
327
  uchar  *read_end;
 
328
  uchar  *buffer;                               /* The read buffer */
320
329
  /* Used in ASYNC_IO */
321
 
  unsigned char  *request_pos;
 
330
  uchar  *request_pos;
322
331
 
323
332
  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
324
 
  unsigned char  *write_buffer;
 
333
  uchar  *write_buffer;
325
334
  /*
326
335
    Only used in SEQ_READ_APPEND, and points to the current read position
327
336
    in the write buffer. Note that reads in SEQ_READ_APPEND caches can
328
 
    happen from both read buffer (unsigned char* buffer) and write buffer
329
 
    (unsigned char* write_buffer).
 
337
    happen from both read buffer (uchar* buffer) and write buffer
 
338
    (uchar* write_buffer).
330
339
  */
331
 
  unsigned char *append_read_pos;
 
340
  uchar *append_read_pos;
332
341
  /* Points to current write position in the write buffer */
333
 
  unsigned char *write_pos;
 
342
  uchar *write_pos;
334
343
  /* The non-inclusive boundary of the valid write area */
335
 
  unsigned char *write_end;
 
344
  uchar *write_end;
336
345
 
337
346
  /*
338
347
    Current_pos and current_end are convenience variables used by
340
349
    current_pos points to &write_pos, and current_end to &write_end in a
341
350
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise
342
351
  */
343
 
  unsigned char  **current_pos, **current_end;
 
352
  uchar  **current_pos, **current_end;
344
353
  /*
345
354
    The lock is for append buffer used in SEQ_READ_APPEND cache
346
355
    need mutex copying from append buffer to read buffer.
362
371
    my_b_read() will call read_function to fetch the data. read_function
363
372
    must never be invoked directly.
364
373
  */
365
 
  int (*read_function)(struct st_io_cache *,unsigned char *,size_t);
 
374
  int (*read_function)(struct st_io_cache *,uchar *,size_t);
366
375
  /*
367
376
    Same idea as in the case of read_function, except my_b_write() needs to
368
377
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
369
378
  */
370
 
  int (*write_function)(struct st_io_cache *,const unsigned char *,size_t);
 
379
  int (*write_function)(struct st_io_cache *,const uchar *,size_t);
371
380
  /*
372
381
    Specifies the type of the cache. Depending on the type of the cache
373
382
    certain operations might not be available and yield unpredicatable
388
397
    Counts the number of times, when we were forced to use disk. We use it to
389
398
    increase the binlog_cache_disk_use status variable.
390
399
  */
391
 
  uint32_t disk_writes;
 
400
  ulong disk_writes;
392
401
  void* arg;                            /* for use by pre/post_read */
393
402
  char *file_name;                      /* if used with 'open_cached_file' */
394
403
  char *dir,*prefix;
418
427
    As inidicated by ifdef, this is for async I/O, which is not currently
419
428
    used (because it's not reliable on all systems)
420
429
  */
421
 
  uint32_t inited;
 
430
  uint inited;
422
431
  my_off_t aio_read_pos;
423
432
  my_aio_result aio_result;
424
433
#endif
447
456
 
448
457
#define my_b_get(info) \
449
458
  ((info)->read_pos != (info)->read_end ?\
450
 
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
 
459
   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\
451
460
   _my_b_get(info))
452
461
 
453
462
        /* my_b_write_byte dosn't have any err-check */
475
484
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
476
485
                                          *(info)->current_pos)
477
486
 
478
 
typedef uint32_t ha_checksum;
 
487
typedef uint32 ha_checksum;
479
488
 
480
489
/* Define the type of function to be passed to process_default_option_files */
481
490
typedef int (*Process_option_func)(void *ctx, const char *group_name,
482
491
                                   const char *option);
483
492
 
484
 
#include <mysys/my_alloc.h>
 
493
#include <my_alloc.h>
485
494
 
486
495
 
487
496
        /* Prototypes for mysys and my_func functions */
488
497
 
489
498
extern int my_copy(const char *from,const char *to,myf MyFlags);
 
499
extern int my_append(const char *from,const char *to,myf MyFlags);
490
500
extern int my_delete(const char *name,myf MyFlags);
491
501
extern int my_getwd(char * buf,size_t size,myf MyFlags);
492
502
extern int my_setwd(const char *dir,myf MyFlags);
 
503
extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
493
504
extern void *my_once_alloc(size_t Size,myf MyFlags);
494
505
extern void my_once_free(void);
495
506
extern char *my_once_strdup(const char *src,myf myflags);
497
508
extern File my_open(const char *FileName,int Flags,myf MyFlags);
498
509
extern File my_register_filename(File fd, const char *FileName,
499
510
                                 enum file_type type_of_file,
500
 
                                 uint32_t error_message_number, myf MyFlags);
 
511
                                 uint error_message_number, myf MyFlags);
501
512
extern File my_create(const char *FileName,int CreateFlags,
502
513
                      int AccessFlags, myf MyFlags);
503
514
extern int my_close(File Filedes,myf MyFlags);
511
522
extern int my_delete_with_symlink(const char *name, myf MyFlags);
512
523
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
513
524
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
514
 
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
 
525
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
515
526
extern int my_rename(const char *from,const char *to,myf MyFlags);
516
527
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
517
528
extern my_off_t my_tell(File fd,myf MyFlags);
518
 
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
 
529
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
519
530
                     myf MyFlags);
520
 
extern size_t my_fwrite(FILE *stream,const unsigned char *Buffer,size_t Count,
 
531
extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
 
532
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
521
533
                      myf MyFlags);
522
534
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
 
535
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
523
536
extern void *_mymalloc(size_t uSize,const char *sFile,
524
 
                       uint32_t uLine, myf MyFlag);
 
537
                       uint uLine, myf MyFlag);
525
538
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
526
 
                       uint32_t uLine, myf MyFlag);
527
 
extern void * my_multi_malloc (myf MyFlags, ...);
528
 
extern void _myfree(void *pPtr, const char *sFile, uint32_t uLine, myf MyFlag);
529
 
extern int _sanity(const char *sFile, uint32_t uLine);
 
539
                       uint uLine, myf MyFlag);
 
540
extern void * my_multi_malloc _VARARGS((myf MyFlags, ...));
 
541
extern void _myfree(void *pPtr,const char *sFile,uint uLine, myf MyFlag);
 
542
extern int _sanity(const char *sFile, uint uLine);
530
543
extern void *_my_memdup(const void *from, size_t length,
531
 
                        const char *sFile, uint32_t uLine,myf MyFlag);
532
 
extern char * _my_strdup(const char *from, const char *sFile, uint32_t uLine,
 
544
                        const char *sFile, uint uLine,myf MyFlag);
 
545
extern char * _my_strdup(const char *from, const char *sFile, uint uLine,
533
546
                         myf MyFlag);
534
547
extern char *_my_strndup(const char *from, size_t length,
535
 
                         const char *sFile, uint32_t uLine,
 
548
                         const char *sFile, uint uLine,
536
549
                         myf MyFlag);
537
550
 
 
551
/* implemented in my_memmem.c */
 
552
extern void *my_memmem(const void *haystack, size_t haystacklen,
 
553
                       const void *needle, size_t needlelen);
 
554
 
 
555
 
538
556
#define my_access access
539
557
extern int check_if_legal_filename(const char *path);
540
558
extern int check_if_legal_tablename(const char *path);
542
560
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
543
561
 
544
562
#ifndef TERMINATE
545
 
extern void TERMINATE(FILE *file, uint32_t flag);
 
563
extern void TERMINATE(FILE *file, uint flag);
546
564
#endif
547
565
extern void init_glob_errs(void);
548
566
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
 
567
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
549
568
extern int my_fclose(FILE *fd,myf MyFlags);
550
569
extern int my_sync(File fd, myf my_flags);
551
570
extern int my_sync_dir(const char *dir_name, myf my_flags);
552
571
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
553
 
extern void my_error(int nr,myf MyFlags, ...);
554
 
extern void my_printf_error(uint32_t my_err, const char *format,
555
 
                            myf MyFlags, ...)
556
 
  __attribute__((format(printf, 2, 4)));
 
572
extern void my_error _VARARGS((int nr,myf MyFlags, ...));
 
573
extern void my_printf_error _VARARGS((uint my_err, const char *format,
 
574
                                      myf MyFlags, ...))
 
575
                                      ATTRIBUTE_FORMAT(printf, 2, 4);
557
576
extern int my_error_register(const char **errmsgs, int first, int last);
558
577
extern const char **my_error_unregister(int first, int last);
559
 
extern void my_message(uint32_t my_err, const char *str,myf MyFlags);
560
 
extern void my_message_no_curses(uint32_t my_err, const char *str,myf MyFlags);
 
578
extern void my_message(uint my_err, const char *str,myf MyFlags);
 
579
extern void my_message_no_curses(uint my_err, const char *str,myf MyFlags);
561
580
extern bool my_init(void);
562
581
extern void my_end(int infoflag);
563
582
extern int my_redel(const char *from, const char *to, int MyFlags);
574
593
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
575
594
extern void free_tmpdir(MY_TMPDIR *tmpdir);
576
595
 
577
 
extern void my_remember_signal(int signal_number,RETSIGTYPE (*func)(int));
 
596
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
578
597
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
579
598
extern size_t dirname_length(const char *name);
580
599
#define base_name(A) (A+dirname_length(A))
585
604
extern char * fn_ext(const char *name);
586
605
extern char * fn_same(char * toname,const char *name,int flag);
587
606
extern char * fn_format(char * to,const char *name,const char *dir,
588
 
                           const char *form, uint32_t flag);
 
607
                           const char *form, uint flag);
589
608
extern size_t strlength(const char *str);
590
609
extern void pack_dirname(char * to,const char *from);
591
610
extern size_t unpack_dirname(char * to,const char *from);
600
619
extern char * my_load_path(char * to, const char *path,
601
620
                              const char *own_path_prefix);
602
621
extern int wild_compare(const char *str,const char *wildstr,
603
 
                        bool str_is_pattern);
 
622
                        pbool str_is_pattern);
604
623
extern WF_PACK *wf_comp(char * str);
605
624
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
606
625
extern void wf_end(struct wild_file_pack *buffer);
 
626
extern size_t strip_sp(char * str);
607
627
extern bool array_append_string_unique(const char *str,
608
628
                                          const char **array, size_t size);
609
629
extern void get_date(char * to,int timeflag,time_t use_time);
610
630
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
611
 
                    bool remove_garbage);
 
631
                    pbool remove_garbage);
612
632
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
613
633
                             size_t reclength,enum cache_type type,
614
 
                             bool use_async_io);
615
 
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
 
634
                             pbool use_async_io);
 
635
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
616
636
extern int end_record_cache(RECORD_CACHE *info);
617
637
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
618
 
                              const unsigned char *record,size_t length);
 
638
                              const uchar *record,size_t length);
619
639
extern int flush_write_cache(RECORD_CACHE *info);
620
 
extern RETSIGTYPE sigtstp_handler(int signal_number);
 
640
extern long my_clock(void);
 
641
extern sig_handler sigtstp_handler(int signal_number);
621
642
extern void handle_recived_signals(void);
622
643
 
623
 
extern RETSIGTYPE my_set_alarm_variable(int signo);
624
 
extern void my_string_ptr_sort(unsigned char *base,uint32_t items,size_t size);
625
 
extern void radixsort_for_str_ptr(unsigned char* base[], uint32_t number_of_elements,
626
 
                                  size_t size_of_element,unsigned char *buffer[]);
627
 
extern RETQSORTTYPE my_qsort(void *base_ptr, size_t total_elems, size_t size,
628
 
                             qsort_cmp cmp);
629
 
extern RETQSORTTYPE my_qsort2(void *base_ptr, size_t total_elems, size_t size,
630
 
                              qsort2_cmp cmp, void *cmp_argument);
 
644
extern sig_handler my_set_alarm_variable(int signo);
 
645
extern void my_string_ptr_sort(uchar *base,uint items,size_t size);
 
646
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
 
647
                                  size_t size_of_element,uchar *buffer[]);
 
648
extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
649
                        qsort_cmp cmp);
 
650
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
651
                         qsort2_cmp cmp, void *cmp_argument);
631
652
extern qsort2_cmp get_ptr_compare(size_t);
632
 
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
633
 
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
 
653
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
 
654
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
634
655
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
635
656
                         enum cache_type type,my_off_t seek_offset,
636
 
                         bool use_async_io, myf cache_myflags);
 
657
                         pbool use_async_io, myf cache_myflags);
637
658
extern bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
638
 
                               my_off_t seek_offset,bool use_async_io,
639
 
                               bool clear_cache);
 
659
                               my_off_t seek_offset,pbool use_async_io,
 
660
                               pbool clear_cache);
640
661
extern void setup_io_cache(IO_CACHE* info);
641
 
extern int _my_b_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
642
 
extern int _my_b_read_r(IO_CACHE *info,unsigned char *Buffer,size_t Count);
 
662
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
663
extern int _my_b_read_r(IO_CACHE *info,uchar *Buffer,size_t Count);
643
664
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
644
 
                                IO_CACHE *write_cache, uint32_t num_threads);
 
665
                                IO_CACHE *write_cache, uint num_threads);
645
666
extern void remove_io_thread(IO_CACHE *info);
646
 
extern int _my_b_seq_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
647
 
extern int _my_b_net_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
 
667
extern int _my_b_seq_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
668
extern int _my_b_net_read(IO_CACHE *info,uchar *Buffer,size_t Count);
648
669
extern int _my_b_get(IO_CACHE *info);
649
 
extern int _my_b_async_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
650
 
extern int _my_b_write(IO_CACHE *info,const unsigned char *Buffer,size_t Count);
651
 
extern int my_b_append(IO_CACHE *info,const unsigned char *Buffer,size_t Count);
652
 
extern int my_b_safe_write(IO_CACHE *info,const unsigned char *Buffer,size_t Count);
 
670
extern int _my_b_async_read(IO_CACHE *info,uchar *Buffer,size_t Count);
 
671
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
672
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
 
673
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
653
674
 
654
 
extern int my_block_write(IO_CACHE *info, const unsigned char *Buffer,
 
675
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
655
676
                          size_t Count, my_off_t pos);
656
677
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
657
678
 
675
696
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
676
697
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
677
698
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
678
 
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint32_t element_size,
679
 
                                   void *init_buffer, uint32_t init_alloc, 
680
 
                                   uint32_t alloc_increment
 
699
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint element_size,
 
700
                                   void *init_buffer, uint init_alloc, 
 
701
                                   uint alloc_increment
681
702
                                   CALLER_INFO_PROTO);
682
703
/* init_dynamic_array() function is deprecated */
683
 
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint32_t element_size,
684
 
                                  uint32_t init_alloc,uint32_t alloc_increment
 
704
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
 
705
                                  uint init_alloc,uint alloc_increment
685
706
                                  CALLER_INFO_PROTO);
686
 
extern bool insert_dynamic(DYNAMIC_ARRAY *array,unsigned char * element);
687
 
extern unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array);
688
 
extern unsigned char *pop_dynamic(DYNAMIC_ARRAY*);
689
 
extern bool set_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
690
 
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements);
691
 
extern void get_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
 
707
extern bool insert_dynamic(DYNAMIC_ARRAY *array,uchar * element);
 
708
extern uchar *alloc_dynamic(DYNAMIC_ARRAY *array);
 
709
extern uchar *pop_dynamic(DYNAMIC_ARRAY*);
 
710
extern bool set_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
 
711
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements);
 
712
extern void get_dynamic(DYNAMIC_ARRAY *array,uchar * element,uint array_index);
692
713
extern void delete_dynamic(DYNAMIC_ARRAY *array);
693
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
 
714
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
694
715
extern void freeze_size(DYNAMIC_ARRAY *array);
695
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
 
716
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, uchar * element);
696
717
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
697
718
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
698
719
#define push_dynamic(A,B) insert_dynamic((A),(B))
699
720
#define reset_dynamic(array) ((array)->elements= 0)
700
721
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
701
722
 
 
723
extern bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
 
724
                                   size_t init_alloc,size_t alloc_increment);
 
725
extern bool dynstr_append(DYNAMIC_STRING *str, const char *append);
 
726
bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
 
727
                          size_t length);
 
728
extern bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
 
729
                                       ...);
 
730
extern bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
 
731
extern bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
 
732
extern bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
 
733
extern void dynstr_free(DYNAMIC_STRING *str);
 
734
#ifdef HAVE_MLOCK
 
735
extern void *my_malloc_lock(size_t length,myf flags);
 
736
extern void my_free_lock(void *ptr,myf flags);
 
737
#else
702
738
#define my_malloc_lock(A,B) my_malloc((A),(B))
 
739
#define my_free_lock(A,B) my_free((A),(B))
 
740
#endif
703
741
#define alloc_root_inited(A) ((A)->min_malloc != 0)
704
742
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
705
743
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
723
761
                                const char *option_value,
724
762
                                const char *section_name, int remove_option);
725
763
extern int my_search_option_files(const char *conf_file, int *argc,
726
 
                                  char ***argv, uint32_t *args_used,
 
764
                                  char ***argv, uint *args_used,
727
765
                                  Process_option_func func, void *func_ctx);
728
766
extern void free_defaults(char **argv);
729
767
extern void my_print_default_files(const char *conf_file);
730
768
extern void print_defaults(const char *conf_file, const char **groups);
731
 
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
 
769
extern bool my_compress(uchar *, size_t *, size_t *);
 
770
extern bool my_uncompress(uchar *, size_t , size_t *);
 
771
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
 
772
                                size_t *complen);
 
773
extern ha_checksum my_checksum(ha_checksum crc, const uchar *mem,
732
774
                               size_t count);
733
 
extern void my_sleep(uint32_t m_seconds);
734
 
extern uint32_t my_set_max_open_files(uint32_t files);
 
775
extern void my_sleep(ulong m_seconds);
 
776
extern uint my_set_max_open_files(uint files);
735
777
void my_free_open_file_info(void);
736
778
 
737
779
extern time_t my_time(myf flags);
739
781
extern uint64_t my_micro_time(void);
740
782
extern uint64_t my_micro_time_and_time(time_t *time_arg);
741
783
time_t my_time_possible_from_micro(uint64_t microtime);
742
 
extern bool my_gethwaddr(unsigned char *to);
 
784
extern bool my_gethwaddr(uchar *to);
 
785
extern int my_getncpus(void);
743
786
 
744
787
#ifdef HAVE_SYS_MMAN_H
745
788
#include <sys/mman.h>
768
811
#define MAP_NOSYNC       0x0800
769
812
#define MAP_FAILED       ((void *)-1)
770
813
#define MS_SYNC          0x0000
 
814
 
 
815
#ifndef __NETWARE__
771
816
#define HAVE_MMAP
 
817
#endif
772
818
 
773
819
void *my_mmap(void *, size_t, int, int, int, my_off_t);
774
820
int my_munmap(void *, size_t);
775
821
#endif
776
822
 
 
823
/* my_getpagesize */
 
824
#ifdef HAVE_GETPAGESIZE
 
825
#define my_getpagesize()        getpagesize()
 
826
#else
 
827
int my_getpagesize(void);
 
828
#endif
 
829
 
777
830
/* character sets */
778
 
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
779
 
extern uint32_t get_collation_number(const char *name);
780
 
extern const char *get_charset_name(uint32_t cs_number);
 
831
extern uint get_charset_number(const char *cs_name, uint cs_flags);
 
832
extern uint get_collation_number(const char *name);
 
833
extern const char *get_charset_name(uint cs_number);
781
834
 
782
 
extern const CHARSET_INFO *get_charset(uint32_t cs_number, myf flags);
783
 
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
784
 
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags, myf my_flags);
 
835
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
 
836
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
 
837
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
 
838
                                           uint cs_flags, myf my_flags);
785
839
 
786
840
extern bool resolve_charset(const char *cs_name,
787
 
                            const CHARSET_INFO *default_cs,
788
 
                            const CHARSET_INFO **cs);
 
841
                               CHARSET_INFO *default_cs,
 
842
                               CHARSET_INFO **cs);
789
843
extern bool resolve_collation(const char *cl_name,
790
 
                             const CHARSET_INFO *default_cl,
791
 
                             const CHARSET_INFO **cl);
 
844
                                 CHARSET_INFO *default_cl,
 
845
                                 CHARSET_INFO **cl);
792
846
 
793
847
extern void free_charsets(void);
794
848
extern char *get_charsets_dir(char *buf);
795
 
extern bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2);
 
849
extern bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2);
796
850
extern bool init_compiled_charsets(myf flags);
797
851
extern void add_compiled_collation(CHARSET_INFO *cs);
798
 
extern size_t escape_string_for_drizzle(const CHARSET_INFO *charset_info,
799
 
                                        char *to, size_t to_length,
800
 
                                        const char *from, size_t length);
801
 
extern size_t escape_quotes_for_drizzle(const CHARSET_INFO *charset_info,
802
 
                                        char *to, size_t to_length,
803
 
                                        const char *from, size_t length);
804
 
 
805
 
extern void thd_increment_bytes_sent(uint32_t length);
806
 
extern void thd_increment_bytes_received(uint32_t length);
807
 
extern void thd_increment_net_big_packet_count(uint32_t length);
808
 
 
809
 
#ifdef __cplusplus
810
 
}
811
 
#endif
812
 
 
 
852
extern size_t escape_string_for_mysql(CHARSET_INFO *charset_info,
 
853
                                      char *to, size_t to_length,
 
854
                                      const char *from, size_t length);
 
855
extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
 
856
                                      char *to, size_t to_length,
 
857
                                      const char *from, size_t length);
 
858
 
 
859
extern void thd_increment_bytes_sent(ulong length);
 
860
extern void thd_increment_bytes_received(ulong length);
 
861
extern void thd_increment_net_big_packet_count(ulong length);
 
862
 
 
863
C_MODE_END
813
864
#endif /* _my_sys_h */