← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_sys.h

  • Committer: Jay Pipes
  • Date: 2009-02-21 16:00:06 UTC
  • mto: (907.1.1 trunk-with-temporal)
  • mto: This revision was merged to the branch mainline in revision 908.
  • Revision ID: jpipes@serialcoder-20090221160006-vnk3wt4qbcz62eru
Removes the TIME column type and related time functions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_sys.h
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#ifndef DRIZZLED_INTERNAL_MY_SYS_H
22
 
#define DRIZZLED_INTERNAL_MY_SYS_H
23
 
 
24
 
#ifdef __cplusplus
25
 
# include <cstdio>
26
 
#else
27
 
# include <stdio.h>
28
 
#endif
 
21
#ifndef _my_sys_h
 
22
#define _my_sys_h
29
23
 
30
24
#include <errno.h>
31
 
 
32
 
#include "drizzled/internal/my_pthread.h"
33
 
 
34
 
#include "drizzled/charset_info.h"                    /* for CHARSET_INFO */
 
25
#define my_errno (errno)
 
26
 
 
27
#include <mysys/my_pthread.h>
 
28
 
 
29
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
35
30
#include <stdarg.h>
36
 
#include "drizzled/typelib.h"
37
 
#include "drizzled/internal/aio_result.h"
38
 
 
39
 
#include "drizzled/memory/root.h"
40
 
#include "drizzled/error.h"
41
 
 
42
 
#ifndef errno                           /* did we already get it? */
43
 
#ifdef HAVE_ERRNO_AS_DEFINE
44
 
#include <errno.h>                      /* errno is a define */
45
 
#else
46
 
extern int errno;                       /* declare errno */
47
 
#endif
48
 
#endif                                  /* #ifndef errno */
49
 
 
50
 
#include <drizzled/dynamic_array.h>
51
 
 
52
 
#include <sys/mman.h>
53
 
 
54
 
#include "drizzled/qsort_cmp.h"
55
 
 
56
 
namespace drizzled
57
 
{
58
 
namespace internal
59
 
{
60
 
 
61
 
#ifndef MAP_NOSYNC
62
 
#define MAP_NOSYNC      0
63
 
#endif
64
 
#ifndef MAP_NORESERVE
65
 
#define MAP_NORESERVE 0         /* For irix and AIX */
66
 
#endif
67
 
 
68
 
/*
69
 
  EDQUOT is used only in 3 C files only in mysys/. If it does not exist on
70
 
  system, we set it to some value which can never happen.
71
 
*/
72
 
#ifndef EDQUOT
73
 
#define EDQUOT (-1)
74
 
#endif
 
31
#include <mysys/typelib.h>
 
32
#include <mysys/aio_result.h>
 
33
 
 
34
#include <mysys/my_alloc.h>
75
35
 
76
36
/* Sun Studio does not inject this into main namespace yet */
77
37
#if defined(__cplusplus)
78
38
  using std::FILE;
79
39
#endif
80
40
 
81
 
#define MY_INIT(name);          { ::drizzled::internal::my_progname= name; ::drizzled::internal::my_init(); }
 
41
#define MY_INIT(name);          { my_progname= name; my_init(); }
82
42
 
 
43
/* Max width of screen (for error messages) */
 
44
#define SC_MAXWIDTH 256
 
45
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
 
46
#define NRERRBUFFS      (2)     /* Buffers for parameters */
 
47
#define MY_FILE_ERROR   ((size_t) -1)
83
48
 
84
49
        /* General bitmaps for my_func's */
85
50
#define MY_FFNF         1       /* Fatal if file not found */
95
60
#define MY_LINK_WARNING 32      /* my_redel() gives warning if links */
96
61
#define MY_COPYTIME     64      /* my_redel() copys time */
97
62
#define MY_DELETE_OLD   256     /* my_create_with_symlink() */
 
63
#define MY_RESOLVE_LINK 128     /* my_realpath(); Only resolve links */
98
64
#define MY_HOLD_ORIGINAL_MODES 128  /* my_copy() holds to file modes */
99
65
#define MY_REDEL_MAKE_BACKUP 256
100
66
#define MY_DONT_WAIT    64      /* my_lock() don't wait if can't lock */
 
67
#define MY_ZEROFILL     32      /* my_multi_malloc(), fill array with zero */
101
68
#define MY_DONT_OVERWRITE_FILE 1024     /* my_copy: Don't overwrite file */
102
69
#define MY_THREADSAFE 2048      /* my_seek(): lock fd mutex */
103
70
 
 
71
#define MY_CHECK_ERROR  1       /* Params to my_end; Check open-close */
 
72
#define MY_GIVE_INFO    2       /* Give time info about process*/
 
73
 
 
74
#define MY_REMOVE_NONE    0     /* Params for modify_defaults_file */
 
75
#define MY_REMOVE_OPTION  1
 
76
#define MY_REMOVE_SECTION 2
 
77
 
 
78
#define ME_HIGHBYTE     8       /* Shift for colours */
 
79
#define ME_NOCUR        1       /* Don't use curses message */
104
80
#define ME_OLDWIN       2       /* Use old window */
105
81
#define ME_BELL         4       /* Ring bell then printing message */
106
82
#define ME_HOLDTANG     8       /* Don't delete last keys */
 
83
#define ME_WAITTOT      16      /* Wait for errtime secs of for a action */
107
84
#define ME_WAITTANG     32      /* Wait for a user action  */
108
85
#define ME_NOREFRESH    64      /* Dont refresh screen */
109
86
#define ME_NOINPUT      128     /* Dont use the input libary */
 
87
#define ME_COLOUR1      ((1 << ME_HIGHBYTE))    /* Possibly error-colours */
 
88
#define ME_COLOUR2      ((2 << ME_HIGHBYTE))
 
89
#define ME_COLOUR3      ((3 << ME_HIGHBYTE))
 
90
#define ME_FATALERROR   1024    /* Fatal statement error */
110
91
 
111
92
        /* Bits in last argument to fn_format */
112
93
#define MY_REPLACE_DIR          1       /* replace dir in name with 'dir' */
113
94
#define MY_REPLACE_EXT          2       /* replace extension with 'ext' */
114
95
#define MY_UNPACK_FILENAME      4       /* Unpack name (~ -> home) */
 
96
#define MY_PACK_FILENAME        8       /* Pack name (home -> ~) */
115
97
#define MY_RESOLVE_SYMLINKS     16      /* Resolve all symbolic links */
116
98
#define MY_RETURN_REAL_PATH     32      /* return full path for file */
117
99
#define MY_SAFE_PATH            64      /* Return NULL if too long path */
124
106
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
125
107
#define DFLT_INIT_HITS  3
126
108
 
 
109
        /* root_alloc flags */
 
110
#define MY_KEEP_PREALLOC        1
 
111
#define MY_MARK_BLOCKS_FREE     2  /* move used to free list and reuse them */
 
112
 
127
113
        /* Internal error numbers (for assembler functions) */
128
114
#define MY_ERRNO_EDOM           33
129
115
#define MY_ERRNO_ERANGE         34
135
121
#define GETDATE_GMT             8
136
122
#define GETDATE_FIXEDLENGTH     16
137
123
 
138
 
 
139
 
typedef uint64_t my_off_t;
 
124
        /* defines when allocating data */
 
125
#define my_checkmalloc()
 
126
#undef TERMINATE
 
127
#define TERMINATE(A,B) {}
 
128
 
 
129
#ifdef __cplusplus
 
130
extern "C" {
 
131
#endif
 
132
 
 
133
typedef int  (*qsort_cmp)(const void *,const void *);
 
134
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
140
135
 
141
136
#define TRASH(A,B) /* nothing */
142
137
 
 
138
#ifndef errno                           /* did we already get it? */
 
139
#ifdef HAVE_ERRNO_AS_DEFINE
 
140
#include <errno.h>                      /* errno is a define */
 
141
#else
 
142
extern int errno;                       /* declare errno */
 
143
#endif
 
144
#endif                                  /* #ifndef errno */
 
145
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
143
146
extern char *home_dir;                  /* Home directory for user */
144
147
extern const char *my_progname;         /* program-name (printed in errors) */
 
148
typedef void (*error_handler_func)(uint32_t my_err, const char *str,myf MyFlags);
 
149
extern error_handler_func error_handler_hook;
145
150
extern uint32_t my_file_limit;
146
151
 
 
152
/* charsets */
 
153
extern const CHARSET_INFO *default_charset_info;
 
154
extern CHARSET_INFO *all_charsets[256];
 
155
extern CHARSET_INFO compiled_charsets[];
 
156
 
147
157
/* statistics */
 
158
extern uint32_t my_file_opened,my_stream_opened, my_tmp_file_created;
 
159
extern uint32_t    my_file_total_opened;
148
160
extern uint     mysys_usage_id;
149
161
extern bool     my_init_done;
150
162
 
 
163
typedef void (*void_ptr_func)(void);
 
164
typedef void (*void_ptr_int_func)(int);
 
165
 
 
166
                                        /* Point to current my_message() */
 
167
extern void_ptr_func my_sigtstp_cleanup,
 
168
                                        /* Executed before jump to shell */
 
169
            my_sigtstp_restart;
 
170
extern void_ptr_int_func my_abort_hook;
151
171
                                        /* Executed when comming from shell */
152
172
extern int my_umask,            /* Default creation mask  */
153
173
           my_umask_dir,
176
196
  char *        *wild;          /* Pointer to wildcards */
177
197
} WF_PACK;
178
198
 
 
199
enum loglevel {
 
200
   ERROR_LEVEL,
 
201
   WARNING_LEVEL,
 
202
   INFORMATION_LEVEL
 
203
};
 
204
 
179
205
enum cache_type
180
206
{
181
207
  TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE,
184
210
 
185
211
typedef struct st_record_cache  /* Used when cacheing records */
186
212
{
187
 
  int file;
 
213
  File file;
188
214
  int   rc_seek,error,inited;
189
215
  uint  rc_length,read_length,reclength;
190
216
  my_off_t rc_record_pos,end_of_file;
196
222
  enum cache_type type;
197
223
} RECORD_CACHE;
198
224
 
 
225
enum file_type
 
226
{
 
227
  UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,
 
228
  FILE_BY_MKSTEMP, FILE_BY_DUP
 
229
};
 
230
 
 
231
struct st_my_file_info
 
232
{
 
233
  char *                name;
 
234
  enum file_type        type;
 
235
};
 
236
 
 
237
extern struct st_my_file_info *my_file_info;
 
238
 
 
239
typedef struct st_dynamic_array
 
240
{
 
241
  unsigned char *buffer;
 
242
  size_t elements,max_element;
 
243
  uint32_t alloc_increment;
 
244
  uint32_t size_of_element;
 
245
} DYNAMIC_ARRAY;
 
246
 
 
247
 
 
248
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
199
249
 
200
250
        /* defines for mf_iocache */
201
251
 
221
271
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
222
272
   _my_b_get(info))
223
273
 
 
274
        /* my_b_write_byte dosn't have any err-check */
 
275
#define my_b_write_byte(info,chr) \
 
276
  (((info)->write_pos < (info)->write_end) ?\
 
277
   ((*(info)->write_pos++)=(chr)) :\
 
278
   (_my_b_write(info,0,0) , ((*(info)->write_pos++)=(chr))))
 
279
 
 
280
#define my_b_fill_cache(info) \
 
281
  (((info)->read_end=(info)->read_pos),(*(info)->read_function)(info,0,0))
 
282
 
224
283
#define my_b_tell(info) ((info)->pos_in_file + \
225
284
                         (size_t) (*(info)->current_pos - (info)->request_pos))
226
285
 
 
286
#define my_b_get_buffer_start(info) (info)->request_pos
 
287
#define my_b_get_bytes_in_buffer(info) (char*) (info)->read_end -   \
 
288
  (char*) my_b_get_buffer_start(info)
 
289
#define my_b_get_pos_in_file(info) (info)->pos_in_file
 
290
 
 
291
 
227
292
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
228
293
                                          *(info)->current_pos)
229
294
 
236
301
int handle_default_option(void *in_ctx, const char *group_name,
237
302
                          const char *option);
238
303
 
 
304
#include <mysys/my_alloc.h>
239
305
 
240
306
 
241
307
        /* Prototypes for mysys and my_func functions */
242
308
 
243
309
extern int my_copy(const char *from,const char *to,myf MyFlags);
244
310
extern int my_delete(const char *name,myf MyFlags);
245
 
extern int my_open(const char *FileName,int Flags,myf MyFlags);
246
 
extern int my_register_filename(int fd, const char *FileName,
 
311
extern File my_open(const char *FileName,int Flags,myf MyFlags);
 
312
extern File my_register_filename(File fd, const char *FileName,
 
313
                                 enum file_type type_of_file,
247
314
                                 uint32_t error_message_number, myf MyFlags);
248
 
extern int my_create(const char *FileName,int CreateFlags,
 
315
extern File my_create(const char *FileName,int CreateFlags,
249
316
                      int AccessFlags, myf MyFlags);
250
 
extern int my_close(int Filedes,myf MyFlags);
 
317
extern int my_close(File Filedes,myf MyFlags);
 
318
extern File my_dup(File file, myf MyFlags);
251
319
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
 
320
extern int my_readlink(char *to, const char *filename, myf MyFlags);
252
321
extern int my_realpath(char *to, const char *filename, myf MyFlags);
253
 
extern int my_create_with_symlink(const char *linkname, const char *filename,
 
322
extern File my_create_with_symlink(const char *linkname, const char *filename,
254
323
                                   int createflags, int access_flags,
255
324
                                   myf MyFlags);
256
325
extern int my_delete_with_symlink(const char *name, myf MyFlags);
257
326
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
258
 
extern size_t my_read(int Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
 
327
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
 
328
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
259
329
extern int my_rename(const char *from,const char *to,myf MyFlags);
260
 
extern size_t my_write(int Filedes,const unsigned char *Buffer,size_t Count,
 
330
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
261
331
                     myf MyFlags);
 
332
extern void * my_multi_malloc (myf MyFlags, ...);
262
333
extern int _sanity(const char *sFile, uint32_t uLine);
263
334
 
 
335
#define my_access access
264
336
extern int check_if_legal_filename(const char *path);
265
337
extern int check_if_legal_tablename(const char *path);
266
338
 
267
339
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
268
340
 
269
 
extern int my_sync(int fd, myf my_flags);
 
341
#ifndef TERMINATE
 
342
extern void TERMINATE(FILE *file, uint32_t flag);
 
343
#endif
 
344
extern void init_glob_errs(void);
 
345
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
 
346
extern int my_fclose(FILE *fd,myf MyFlags);
 
347
extern int my_sync(File fd, myf my_flags);
270
348
extern int my_sync_dir(const char *dir_name, myf my_flags);
271
349
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
 
350
extern void my_error(int nr,myf MyFlags, ...);
 
351
extern void my_printf_error(uint32_t my_err, const char *format,
 
352
                            myf MyFlags, ...)
 
353
  __attribute__((format(printf, 2, 4)));
 
354
extern int my_error_register(const char **errmsgs, int first, int last);
 
355
extern const char **my_error_unregister(int first, int last);
 
356
extern void my_message(uint32_t my_err, const char *str,myf MyFlags);
 
357
extern void my_message_no_curses(uint32_t my_err, const char *str,myf MyFlags);
272
358
extern bool my_init(void);
273
 
extern void my_end(void);
 
359
extern void my_end(int infoflag);
274
360
extern int my_redel(const char *from, const char *to, int MyFlags);
275
361
extern int my_copystat(const char *from, const char *to, int MyFlags);
276
 
extern char * my_filename(int fd);
 
362
extern char * my_filename(File fd);
 
363
 
 
364
#ifdef EXTRA_DEBUG
 
365
void my_print_open_files(void);
 
366
#else
 
367
#define my_print_open_files()
 
368
#endif
277
369
 
278
370
extern void my_remember_signal(int signal_number,void (*func)(int));
279
371
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
280
372
extern size_t dirname_length(const char *name);
281
373
#define base_name(A) (A+dirname_length(A))
282
 
bool test_if_hard_path(const char *dir_name);
 
374
static inline bool test_if_hard_path(const char *dir_name)
 
375
{
 
376
  if (dir_name[0] == FN_HOMELIB && dir_name[1] == FN_LIBCHAR)
 
377
    return (home_dir != NULL && test_if_hard_path(home_dir));
 
378
  if (dir_name[0] == FN_LIBCHAR)
 
379
    return (true);
 
380
  return false;
 
381
} /* test_if_hard_path */
283
382
 
284
383
extern char *convert_dirname(char *to, const char *from, const char *from_end);
285
384
extern char * fn_ext(const char *name);
288
387
                           const char *form, uint32_t flag);
289
388
extern size_t strlength(const char *str);
290
389
extern size_t unpack_dirname(char * to,const char *from);
 
390
extern size_t cleanup_dirname(char * to,const char *from);
 
391
extern size_t system_filename(char * to,const char *from);
291
392
extern size_t unpack_filename(char * to,const char *from);
292
393
extern char * intern_filename(char * to,const char *from);
 
394
extern char * directory_file_name(char * dst, const char *src);
293
395
extern int pack_filename(char * to, const char *name, size_t max_length);
294
396
extern char * my_load_path(char * to, const char *path,
295
397
                              const char *own_path_prefix);
301
403
extern bool array_append_string_unique(const char *str,
302
404
                                          const char **array, size_t size);
303
405
extern void get_date(char * to,int timeflag,time_t use_time);
304
 
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,int file,
 
406
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
 
407
                    bool remove_garbage);
 
408
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
305
409
                             size_t reclength,enum cache_type type,
306
410
                             bool use_async_io);
307
411
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
323
427
extern qsort2_cmp get_ptr_compare(size_t);
324
428
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
325
429
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
326
 
int create_temp_file(char *to, const char *dir, const char *pfx, myf MyFlags);
 
430
File create_temp_file(char *to, const char *dir, const char *pfx,
 
431
                      int mode, myf MyFlags);
 
432
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D)
 
433
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D)
 
434
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E)
 
435
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E)
 
436
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint32_t element_size,
 
437
                                   void *init_buffer, uint32_t init_alloc,
 
438
                                   uint32_t alloc_increment);
 
439
/* init_dynamic_array() function is deprecated */
 
440
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint32_t element_size,
 
441
                                  uint32_t init_alloc,uint32_t alloc_increment);
 
442
extern bool insert_dynamic(DYNAMIC_ARRAY *array,unsigned char * element);
 
443
extern unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array);
 
444
extern unsigned char *pop_dynamic(DYNAMIC_ARRAY*);
 
445
extern bool set_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
 
446
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements);
 
447
extern void get_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
 
448
extern void delete_dynamic(DYNAMIC_ARRAY *array);
 
449
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
 
450
extern void freeze_size(DYNAMIC_ARRAY *array);
 
451
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
 
452
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
 
453
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
 
454
#define push_dynamic(A,B) insert_dynamic((A),(B))
 
455
#define reset_dynamic(array) ((array)->elements= 0)
 
456
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
327
457
 
 
458
#define alloc_root_inited(A) ((A)->min_malloc != 0)
 
459
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
 
460
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
328
461
extern int get_defaults_options(int argc, char **argv,
329
462
                                char **defaults, char **extra_defaults,
330
463
                                char **group_suffix);
331
464
extern int load_defaults(const char *conf_file, const char **groups,
332
465
                         int *argc, char ***argv);
 
466
extern int modify_defaults_file(const char *file_location, const char *option,
 
467
                                const char *option_value,
 
468
                                const char *section_name, int remove_option);
333
469
extern int my_search_option_files(const char *conf_file, int *argc,
334
470
                                  char ***argv, uint32_t *args_used,
335
471
                                  Process_option_func func, void *func_ctx);
339
475
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
340
476
                               size_t count);
341
477
extern void my_sleep(uint32_t m_seconds);
342
 
 
343
 
 
 
478
extern uint64_t my_set_max_open_files(uint64_t files);
 
479
void my_free_open_file_info(void);
 
480
 
 
481
extern uint64_t my_getsystime(void);
 
482
extern uint64_t my_micro_time(void);
 
483
extern uint64_t my_micro_time_and_time(time_t *time_arg);
 
484
time_t my_time_possible_from_micro(uint64_t microtime);
 
485
 
 
486
#ifdef HAVE_SYS_MMAN_H
 
487
#include <sys/mman.h>
 
488
 
 
489
#ifndef MAP_NOSYNC
 
490
#define MAP_NOSYNC      0
 
491
#endif
 
492
#ifndef MAP_NORESERVE
 
493
#define MAP_NORESERVE 0         /* For irix and AIX */
 
494
#endif
 
495
 
 
496
#ifdef HAVE_MMAP64
 
497
#define my_mmap(a,b,c,d,e,f)    mmap64(a,b,c,d,e,f)
 
498
#else
 
499
#define my_mmap(a,b,c,d,e,f)    mmap(a,b,c,d,e,f)
 
500
#endif
 
501
#define my_munmap(a,b)          munmap((a),(b))
 
502
 
 
503
#else
 
504
/* not a complete set of mmap() flags, but only those that nesessary */
 
505
#define PROT_READ        1
 
506
#define PROT_WRITE       2
 
507
#define MAP_NORESERVE    0
 
508
#define MAP_SHARED       0x0001
 
509
#define MAP_PRIVATE      0x0002
 
510
#define MAP_NOSYNC       0x0800
 
511
#define MAP_FAILED       ((void *)-1)
 
512
#define MS_SYNC          0x0000
 
513
#define HAVE_MMAP
 
514
 
 
515
void *my_mmap(void *, size_t, int, int, int, my_off_t);
 
516
int my_munmap(void *, size_t);
 
517
#endif
 
518
 
 
519
/* character sets */
 
520
void *cs_alloc(size_t size);
 
521
 
 
522
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
 
523
extern uint32_t get_collation_number(const char *name);
 
524
extern const char *get_charset_name(uint32_t cs_number);
 
525
 
 
526
extern const CHARSET_INFO *get_charset(uint32_t cs_number);
 
527
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name);
 
528
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags);
 
529
 
 
530
extern bool resolve_charset(const char *cs_name,
 
531
                            const CHARSET_INFO *default_cs,
 
532
                            const CHARSET_INFO **cs);
 
533
extern bool resolve_collation(const char *cl_name,
 
534
                             const CHARSET_INFO *default_cl,
 
535
                             const CHARSET_INFO **cl);
 
536
 
 
537
extern void free_charsets(void);
 
538
extern char *get_charsets_dir(char *buf);
 
539
extern bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2);
 
540
extern bool init_compiled_charsets(myf flags);
 
541
extern void add_compiled_collation(CHARSET_INFO *cs);
 
542
extern size_t escape_string_for_drizzle(const CHARSET_INFO *charset_info,
 
543
                                        char *to, size_t to_length,
 
544
                                        const char *from, size_t length);
 
545
extern size_t escape_quotes_for_drizzle(const CHARSET_INFO *charset_info,
 
546
                                        char *to, size_t to_length,
 
547
                                        const char *from, size_t length);
344
548
 
345
549
extern void thd_increment_bytes_sent(uint32_t length);
346
550
extern void thd_increment_bytes_received(uint32_t length);
347
551
extern void thd_increment_net_big_packet_count(uint32_t length);
348
552
 
349
 
} /* namespace internal */
350
 
} /* namespace drizzled */
 
553
#ifdef __cplusplus
 
554
}
 
555
#endif
351
556
 
352
 
#endif /* DRIZZLED_INTERNAL_MY_SYS_H */
 
557
#endif /* _my_sys_h */