← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/my_sys.h

  • Committer: Stewart Smith
  • Date: 2010-11-03 03:30:27 UTC
  • mto: (1902.1.1 build) (1910.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1903.
  • Revision ID: stewart@flamingspork.com-20101103033027-lskb6gxwwforfz71
fix docs warning: underline/overline too short for replace.rst

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/my_sys.h
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#ifndef _my_sys_h
22
 
#define _my_sys_h
 
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
23
29
 
24
30
#include <errno.h>
25
 
#define my_errno (errno)
26
 
 
27
 
#include <mysys/my_pthread.h>
28
 
 
29
 
#include <mystrings/m_ctype.h>                    /* for CHARSET_INFO */
 
31
 
 
32
#include "drizzled/internal/my_pthread.h"
 
33
 
 
34
#include "drizzled/charset_info.h"                    /* for CHARSET_INFO */
30
35
#include <stdarg.h>
31
 
#include <mysys/typelib.h>
32
 
#include <mysys/aio_result.h>
33
 
 
34
 
#include <mysys/my_alloc.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
#ifdef HAVE_SYS_MMAN_H 
 
53
#include <sys/mman.h>
 
54
#endif
 
55
 
 
56
#include "drizzled/qsort_cmp.h"
 
57
 
 
58
namespace drizzled
 
59
{
 
60
namespace internal
 
61
{
 
62
 
 
63
#ifndef MAP_NOSYNC
 
64
#define MAP_NOSYNC      0
 
65
#endif
 
66
#ifndef MAP_NORESERVE
 
67
#define MAP_NORESERVE 0         /* For irix and AIX */
 
68
#endif
 
69
 
 
70
/*
 
71
  EDQUOT is used only in 3 C files only in mysys/. If it does not exist on
 
72
  system, we set it to some value which can never happen.
 
73
*/
 
74
#ifndef EDQUOT
 
75
#define EDQUOT (-1)
 
76
#endif
35
77
 
36
78
/* Sun Studio does not inject this into main namespace yet */
37
79
#if defined(__cplusplus)
38
80
  using std::FILE;
39
 
#endif 
40
 
 
41
 
#define MY_INIT(name);          { my_progname= name; my_init(); }
42
 
 
43
 
#define ERRMSGSIZE      (SC_MAXWIDTH)   /* Max length of a error message */
44
 
#define NRERRBUFFS      (2)     /* Buffers for parameters */
45
 
#define MY_FILE_ERROR   ((size_t) -1)
 
81
#endif
 
82
 
 
83
#define MY_INIT(name);          { ::drizzled::internal::my_progname= name; ::drizzled::internal::my_init(); }
 
84
 
46
85
 
47
86
        /* General bitmaps for my_func's */
48
87
#define MY_FFNF         1       /* Fatal if file not found */
58
97
#define MY_LINK_WARNING 32      /* my_redel() gives warning if links */
59
98
#define MY_COPYTIME     64      /* my_redel() copys time */
60
99
#define MY_DELETE_OLD   256     /* my_create_with_symlink() */
61
 
#define MY_RESOLVE_LINK 128     /* my_realpath(); Only resolve links */
62
100
#define MY_HOLD_ORIGINAL_MODES 128  /* my_copy() holds to file modes */
63
101
#define MY_REDEL_MAKE_BACKUP 256
64
 
#define MY_SEEK_NOT_DONE 32     /* my_lock may have to do a seek */
65
102
#define MY_DONT_WAIT    64      /* my_lock() don't wait if can't lock */
66
 
#define MY_ZEROFILL     32      /* my_malloc(), fill array with zero */
67
 
#define MY_ALLOW_ZERO_PTR 64    /* my_realloc() ; zero ptr -> malloc */
68
 
#define MY_FREE_ON_ERROR 128    /* my_realloc() ; Free old ptr on error */
69
 
#define MY_HOLD_ON_ERROR 256    /* my_realloc() ; Return old ptr on error */
70
103
#define MY_DONT_OVERWRITE_FILE 1024     /* my_copy: Don't overwrite file */
71
104
#define MY_THREADSAFE 2048      /* my_seek(): lock fd mutex */
72
105
 
73
 
#define MY_CHECK_ERROR  1       /* Params to my_end; Check open-close */
74
 
#define MY_GIVE_INFO    2       /* Give time info about process*/
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
106
#define ME_OLDWIN       2       /* Use old window */
83
107
#define ME_BELL         4       /* Ring bell then printing message */
84
108
#define ME_HOLDTANG     8       /* Don't delete last keys */
85
 
#define ME_WAITTOT      16      /* Wait for errtime secs of for a action */
86
109
#define ME_WAITTANG     32      /* Wait for a user action  */
87
110
#define ME_NOREFRESH    64      /* Dont refresh screen */
88
111
#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
112
 
94
113
        /* Bits in last argument to fn_format */
95
114
#define MY_REPLACE_DIR          1       /* replace dir in name with 'dir' */
96
115
#define MY_REPLACE_EXT          2       /* replace extension with 'ext' */
97
116
#define MY_UNPACK_FILENAME      4       /* Unpack name (~ -> home) */
98
 
#define MY_PACK_FILENAME        8       /* Pack name (home -> ~) */
99
117
#define MY_RESOLVE_SYMLINKS     16      /* Resolve all symbolic links */
100
118
#define MY_RETURN_REAL_PATH     32      /* return full path for file */
101
119
#define MY_SAFE_PATH            64      /* Return NULL if too long path */
103
121
#define MY_APPEND_EXT           256     /* add 'ext' as additional extension*/
104
122
 
105
123
 
106
 
        /* My seek flags */
107
 
#define MY_SEEK_SET     0
108
 
#define MY_SEEK_CUR     1
109
 
#define MY_SEEK_END     2
110
 
 
111
124
        /* Some constants */
112
125
#define MY_WAIT_FOR_USER_TO_FIX_PANIC   60      /* in seconds */
113
126
#define MY_WAIT_GIVE_USER_A_MESSAGE     10      /* Every 10 times of prev */
114
127
#define DFLT_INIT_HITS  3
115
128
 
116
 
        /* root_alloc flags */
117
 
#define MY_KEEP_PREALLOC        1
118
 
#define MY_MARK_BLOCKS_FREE     2  /* move used to free list and reuse them */
119
 
 
120
129
        /* Internal error numbers (for assembler functions) */
121
130
#define MY_ERRNO_EDOM           33
122
131
#define MY_ERRNO_ERANGE         34
128
137
#define GETDATE_GMT             8
129
138
#define GETDATE_FIXEDLENGTH     16
130
139
 
131
 
        /* defines when allocating data */
132
 
#define my_checkmalloc()
133
 
#undef TERMINATE
134
 
#define TERMINATE(A,B) {}
135
 
 
136
 
#ifdef __cplusplus
137
 
extern "C" {
138
 
#endif
139
 
 
140
 
typedef int  (*qsort_cmp)(const void *,const void *);
141
 
typedef int  (*qsort_cmp2)(void*, const void *,const void *);
142
 
 
143
 
extern void *my_malloc(size_t Size,myf MyFlags);
144
 
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
145
 
extern void *my_realloc(void *oldpoint, size_t Size, myf MyFlags);
146
 
extern void my_no_flags_free(void *ptr);
147
 
extern void *my_memdup(const void *from,size_t length,myf MyFlags);
148
 
extern char *my_strdup(const char *from,myf MyFlags);
149
 
extern char *my_strndup(const char *from, size_t length,
150
 
                                   myf MyFlags);
151
 
#define CALLER_INFO_PROTO   /* nothing */
152
 
#define CALLER_INFO         /* nothing */
153
 
#define ORIG_CALLER_INFO    /* nothing */
 
140
 
 
141
typedef uint64_t my_off_t;
 
142
 
154
143
#define TRASH(A,B) /* nothing */
155
144
 
156
 
#ifdef HAVE_ALLOCA
157
 
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca)
158
 
#define alloca __builtin_alloca
159
 
#endif /* GNUC */
160
 
#define my_alloca(SZ) malloc((size_t) (SZ))
161
 
#define my_afree(PTR) free((PTR))
162
 
#else
163
 
#define my_alloca(SZ) malloc((SZ))
164
 
#define my_afree(PTR) free((PTR))
165
 
#endif /* HAVE_ALLOCA */
166
 
 
167
 
#ifndef errno                           /* did we already get it? */
168
 
#ifdef HAVE_ERRNO_AS_DEFINE
169
 
#include <errno.h>                      /* errno is a define */
170
 
#else
171
 
extern int errno;                       /* declare errno */
172
 
#endif
173
 
#endif                                  /* #ifndef errno */
174
 
extern char errbuff[NRERRBUFFS][ERRMSGSIZE];
175
145
extern char *home_dir;                  /* Home directory for user */
176
146
extern const char *my_progname;         /* program-name (printed in errors) */
177
 
extern void (*error_handler_hook)(uint32_t my_err, const char *str,myf MyFlags);
178
 
extern void (*fatal_error_handler_hook)(uint32_t my_err, const char *str,
179
 
                                        myf MyFlags);
180
147
extern uint32_t my_file_limit;
181
 
extern uint32_t my_thread_stack_size;
182
 
 
183
 
/* charsets */
184
 
extern const CHARSET_INFO *default_charset_info;
185
 
extern CHARSET_INFO *all_charsets[256];
186
 
extern CHARSET_INFO compiled_charsets[];
187
148
 
188
149
/* statistics */
189
 
extern uint32_t my_file_opened,my_stream_opened, my_tmp_file_created;
190
 
extern uint32_t    my_file_total_opened;
191
150
extern uint     mysys_usage_id;
192
151
extern bool     my_init_done;
193
152
 
194
 
                                        /* Point to current my_message() */
195
 
extern void (*my_sigtstp_cleanup)(void),
196
 
                                        /* Executed before jump to shell */
197
 
            (*my_sigtstp_restart)(void),
198
 
            (*my_abort_hook)(int);
199
153
                                        /* Executed when comming from shell */
200
154
extern int my_umask,            /* Default creation mask  */
201
155
           my_umask_dir,
217
171
 
218
172
extern bool timed_mutexes;
219
173
 
220
 
typedef struct wild_file_pack   /* Struct to hold info when selecting files */
 
174
typedef class wild_file_pack    /* Struct to hold info when selecting files */
221
175
{
 
176
public:
222
177
  uint          wilds;          /* How many wildcards */
223
178
  uint          not_pos;        /* Start of not-theese-files */
224
179
  char *        *wild;          /* Pointer to wildcards */
 
180
 
 
181
  wild_file_pack():
 
182
    wilds(0),
 
183
    not_pos(0),
 
184
    wild(NULL)
 
185
  {}
 
186
 
225
187
} WF_PACK;
226
188
 
227
 
enum loglevel {
228
 
   ERROR_LEVEL,
229
 
   WARNING_LEVEL,
230
 
   INFORMATION_LEVEL
231
 
};
232
 
 
233
189
enum cache_type
234
190
{
235
 
  TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE,
236
 
  SEQ_READ_APPEND               /* sequential read or append */,
237
 
  READ_FIFO, READ_NET,WRITE_NET};
 
191
  TYPE_NOT_SET= 0,
 
192
  READ_CACHE,
 
193
  WRITE_CACHE,
 
194
  READ_FIFO,
 
195
  READ_NET,
 
196
  WRITE_NET
 
197
};
238
198
 
239
 
typedef struct st_record_cache  /* Used when cacheing records */
 
199
typedef struct record_cache     /* Used when cacheing records */
240
200
{
241
 
  File file;
 
201
public:
 
202
  int file;
242
203
  int   rc_seek,error,inited;
243
204
  uint  rc_length,read_length,reclength;
244
205
  my_off_t rc_record_pos,end_of_file;
248
209
  my_aio_result aio_result;
249
210
#endif
250
211
  enum cache_type type;
 
212
 
 
213
  record_cache():
 
214
    file(0),
 
215
    rc_seek(0),
 
216
    error(0),
 
217
    inited(0),
 
218
    rc_length(0),
 
219
    read_length(0),
 
220
    reclength(0),
 
221
    rc_record_pos(0),
 
222
    end_of_file(0),
 
223
    rc_buff(NULL),
 
224
    rc_buff2(NULL),
 
225
    rc_pos(NULL),
 
226
    rc_end(NULL),
 
227
    rc_request_pos(NULL)
 
228
  {}
 
229
 
251
230
} RECORD_CACHE;
252
231
 
253
 
enum file_type
254
 
{
255
 
  UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,
256
 
  FILE_BY_MKSTEMP, FILE_BY_DUP
257
 
};
258
 
 
259
 
struct st_my_file_info
260
 
{
261
 
  char *                name;
262
 
  enum file_type        type;
263
 
#if !defined(HAVE_PREAD)
264
 
  pthread_mutex_t       mutex;
265
 
#endif
266
 
};
267
 
 
268
 
extern struct st_my_file_info *my_file_info;
269
 
 
270
 
typedef struct st_dynamic_array
271
 
{
272
 
  unsigned char *buffer;
273
 
  uint32_t elements,max_element;
274
 
  uint32_t alloc_increment;
275
 
  uint32_t size_of_element;
276
 
} DYNAMIC_ARRAY;
277
 
 
278
 
typedef struct st_my_tmpdir
279
 
{
280
 
  DYNAMIC_ARRAY full_list;
281
 
  char **list;
282
 
  uint32_t cur, max;
283
 
  pthread_mutex_t mutex;
284
 
} MY_TMPDIR;
285
 
 
286
 
 
287
 
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
288
232
 
289
233
        /* defines for mf_iocache */
290
234
 
310
254
   ((info)->read_pos++, (int) (unsigned char) (info)->read_pos[-1]) :\
311
255
   _my_b_get(info))
312
256
 
313
 
        /* my_b_write_byte dosn't have any err-check */
314
 
#define my_b_write_byte(info,chr) \
315
 
  (((info)->write_pos < (info)->write_end) ?\
316
 
   ((*(info)->write_pos++)=(chr)) :\
317
 
   (_my_b_write(info,0,0) , ((*(info)->write_pos++)=(chr))))
318
 
 
319
 
#define my_b_fill_cache(info) \
320
 
  (((info)->read_end=(info)->read_pos),(*(info)->read_function)(info,0,0))
321
 
 
322
257
#define my_b_tell(info) ((info)->pos_in_file + \
323
258
                         (size_t) (*(info)->current_pos - (info)->request_pos))
324
259
 
325
 
#define my_b_get_buffer_start(info) (info)->request_pos 
326
 
#define my_b_get_bytes_in_buffer(info) (char*) (info)->read_end -   \
327
 
  (char*) my_b_get_buffer_start(info)
328
 
#define my_b_get_pos_in_file(info) (info)->pos_in_file
329
 
 
330
 
 
331
260
#define my_b_bytes_in_cache(info) (size_t) (*(info)->current_end - \
332
261
                                          *(info)->current_pos)
333
262
 
337
266
typedef int (*Process_option_func)(void *ctx, const char *group_name,
338
267
                                   const char *option);
339
268
 
340
 
#include <mysys/my_alloc.h>
 
269
int handle_default_option(void *in_ctx, const char *group_name,
 
270
                          const char *option);
 
271
 
341
272
 
342
273
 
343
274
        /* Prototypes for mysys and my_func functions */
344
275
 
345
276
extern int my_copy(const char *from,const char *to,myf MyFlags);
346
277
extern int my_delete(const char *name,myf MyFlags);
347
 
extern int my_getwd(char * buf,size_t size,myf MyFlags);
348
 
extern int my_setwd(const char *dir,myf MyFlags);
349
 
extern void *my_once_alloc(size_t Size,myf MyFlags);
350
 
extern void my_once_free(void);
351
 
extern char *my_once_strdup(const char *src,myf myflags);
352
 
extern void *my_once_memdup(const void *src, size_t len, myf myflags);
353
 
extern File my_open(const char *FileName,int Flags,myf MyFlags);
354
 
extern File my_register_filename(File fd, const char *FileName,
355
 
                                 enum file_type type_of_file,
 
278
extern int my_open(const char *FileName,int Flags,myf MyFlags);
 
279
extern int my_register_filename(int fd, const char *FileName,
356
280
                                 uint32_t error_message_number, myf MyFlags);
357
 
extern File my_create(const char *FileName,int CreateFlags,
 
281
extern int my_create(const char *FileName,int CreateFlags,
358
282
                      int AccessFlags, myf MyFlags);
359
 
extern int my_close(File Filedes,myf MyFlags);
360
 
extern File my_dup(File file, myf MyFlags);
 
283
extern int my_close(int Filedes,myf MyFlags);
361
284
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
362
 
extern int my_readlink(char *to, const char *filename, myf MyFlags);
363
285
extern int my_realpath(char *to, const char *filename, myf MyFlags);
364
 
extern File my_create_with_symlink(const char *linkname, const char *filename,
 
286
extern int my_create_with_symlink(const char *linkname, const char *filename,
365
287
                                   int createflags, int access_flags,
366
288
                                   myf MyFlags);
367
289
extern int my_delete_with_symlink(const char *name, myf MyFlags);
368
290
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
369
 
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
370
 
extern size_t my_read(File Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
 
291
extern size_t my_read(int Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
371
292
extern int my_rename(const char *from,const char *to,myf MyFlags);
372
 
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
373
 
extern my_off_t my_tell(File fd,myf MyFlags);
374
 
extern size_t my_write(File Filedes,const unsigned char *Buffer,size_t Count,
 
293
extern size_t my_write(int Filedes,const unsigned char *Buffer,size_t Count,
375
294
                     myf MyFlags);
376
 
extern size_t my_fwrite(FILE *stream,const unsigned char *Buffer,size_t Count,
377
 
                      myf MyFlags);
378
 
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
379
 
extern void *_mymalloc(size_t uSize,const char *sFile,
380
 
                       uint32_t uLine, myf MyFlag);
381
 
extern void *_myrealloc(void *pPtr,size_t uSize,const char *sFile,
382
 
                       uint32_t uLine, myf MyFlag);
383
 
extern void * my_multi_malloc (myf MyFlags, ...);
384
 
extern void _myfree(void *pPtr, const char *sFile, uint32_t uLine, myf MyFlag);
385
295
extern int _sanity(const char *sFile, uint32_t uLine);
386
 
extern void *_my_memdup(const void *from, size_t length,
387
 
                        const char *sFile, uint32_t uLine,myf MyFlag);
388
 
extern char * _my_strdup(const char *from, const char *sFile, uint32_t uLine,
389
 
                         myf MyFlag);
390
 
extern char *_my_strndup(const char *from, size_t length,
391
 
                         const char *sFile, uint32_t uLine,
392
 
                         myf MyFlag);
393
296
 
394
 
#define my_access access
395
297
extern int check_if_legal_filename(const char *path);
396
298
extern int check_if_legal_tablename(const char *path);
397
299
 
398
300
#define my_delete_allow_opened(fname,flags)  my_delete((fname),(flags))
399
301
 
400
 
#ifndef TERMINATE
401
 
extern void TERMINATE(FILE *file, uint32_t flag);
402
 
#endif
403
 
extern void init_glob_errs(void);
404
 
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
405
 
extern int my_fclose(FILE *fd,myf MyFlags);
406
 
extern int my_sync(File fd, myf my_flags);
 
302
extern int my_sync(int fd, myf my_flags);
407
303
extern int my_sync_dir(const char *dir_name, myf my_flags);
408
304
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
409
 
extern void my_error(int nr,myf MyFlags, ...);
410
 
extern void my_printf_error(uint32_t my_err, const char *format,
411
 
                            myf MyFlags, ...)
412
 
  __attribute__((format(printf, 2, 4)));
413
 
extern int my_error_register(const char **errmsgs, int first, int last);
414
 
extern const char **my_error_unregister(int first, int last);
415
 
extern void my_message(uint32_t my_err, const char *str,myf MyFlags);
416
 
extern void my_message_no_curses(uint32_t my_err, const char *str,myf MyFlags);
417
305
extern bool my_init(void);
418
 
extern void my_end(int infoflag);
 
306
extern void my_end(void);
419
307
extern int my_redel(const char *from, const char *to, int MyFlags);
420
308
extern int my_copystat(const char *from, const char *to, int MyFlags);
421
 
extern char * my_filename(File fd);
422
 
 
423
 
#ifdef EXTRA_DEBUG
424
 
void my_print_open_files(void);
425
 
#else
426
 
#define my_print_open_files()
427
 
#endif
428
 
 
429
 
extern bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
430
 
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
431
 
extern void free_tmpdir(MY_TMPDIR *tmpdir);
432
 
 
433
 
extern void my_remember_signal(int signal_number,RETSIGTYPE (*func)(int));
 
309
extern char * my_filename(int fd);
 
310
 
 
311
extern void my_remember_signal(int signal_number,void (*func)(int));
434
312
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
435
313
extern size_t dirname_length(const char *name);
436
314
#define base_name(A) (A+dirname_length(A))
437
 
extern int test_if_hard_path(const char *dir_name);
438
 
extern bool has_path(const char *name);
 
315
bool test_if_hard_path(const char *dir_name);
 
316
 
439
317
extern char *convert_dirname(char *to, const char *from, const char *from_end);
440
 
extern void to_unix_path(char * name);
441
318
extern char * fn_ext(const char *name);
442
319
extern char * fn_same(char * toname,const char *name,int flag);
443
320
extern char * fn_format(char * to,const char *name,const char *dir,
444
321
                           const char *form, uint32_t flag);
445
322
extern size_t strlength(const char *str);
446
 
extern void pack_dirname(char * to,const char *from);
447
323
extern size_t unpack_dirname(char * to,const char *from);
448
 
extern size_t cleanup_dirname(char * to,const char *from);
449
 
extern size_t system_filename(char * to,const char *from);
450
324
extern size_t unpack_filename(char * to,const char *from);
451
325
extern char * intern_filename(char * to,const char *from);
452
 
extern char * directory_file_name(char * dst, const char *src);
453
326
extern int pack_filename(char * to, const char *name, size_t max_length);
454
 
extern char * my_path(char * to,const char *progname,
455
 
                         const char *own_pathname_part);
456
327
extern char * my_load_path(char * to, const char *path,
457
328
                              const char *own_path_prefix);
458
329
extern int wild_compare(const char *str,const char *wildstr,
459
330
                        bool str_is_pattern);
460
331
extern WF_PACK *wf_comp(char * str);
461
 
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
462
 
extern void wf_end(struct wild_file_pack *buffer);
 
332
extern int wf_test(wild_file_pack *wf_pack,const char *name);
 
333
extern void wf_end(wild_file_pack *buffer);
463
334
extern bool array_append_string_unique(const char *str,
464
335
                                          const char **array, size_t size);
465
336
extern void get_date(char * to,int timeflag,time_t use_time);
466
 
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
467
 
                    bool remove_garbage);
468
 
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
 
337
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,int file,
469
338
                             size_t reclength,enum cache_type type,
470
339
                             bool use_async_io);
471
340
extern int read_cache_record(RECORD_CACHE *info,unsigned char *to);
473
342
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
474
343
                              const unsigned char *record,size_t length);
475
344
extern int flush_write_cache(RECORD_CACHE *info);
476
 
extern RETSIGTYPE sigtstp_handler(int signal_number);
 
345
extern void sigtstp_handler(int signal_number);
477
346
extern void handle_recived_signals(void);
478
347
 
479
 
extern RETSIGTYPE my_set_alarm_variable(int signo);
 
348
extern void my_set_alarm_variable(int signo);
480
349
extern void my_string_ptr_sort(unsigned char *base,uint32_t items,size_t size);
481
350
extern void radixsort_for_str_ptr(unsigned char* base[], uint32_t number_of_elements,
482
351
                                  size_t size_of_element,unsigned char *buffer[]);
483
 
extern RETQSORTTYPE my_qsort(void *base_ptr, size_t total_elems, size_t size,
484
 
                             qsort_cmp cmp);
485
 
extern RETQSORTTYPE my_qsort2(void *base_ptr, size_t total_elems, size_t size,
486
 
                              qsort2_cmp cmp, void *cmp_argument);
 
352
extern void my_qsort(void *base_ptr, size_t total_elems, size_t size,
 
353
                     qsort_cmp cmp);
 
354
extern void my_qsort2(void *base_ptr, size_t total_elems, size_t size,
 
355
                      qsort2_cmp cmp, void *cmp_argument);
487
356
extern qsort2_cmp get_ptr_compare(size_t);
488
357
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
489
358
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
490
 
File create_temp_file(char *to, const char *dir, const char *pfx,
491
 
                      int mode, myf MyFlags);
492
 
#define my_init_dynamic_array(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D CALLER_INFO)
493
 
#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array2(A,B,NULL,C,D ORIG_CALLER_INFO)
494
 
#define my_init_dynamic_array2(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E CALLER_INFO)
495
 
#define my_init_dynamic_array2_ci(A,B,C,D,E) init_dynamic_array2(A,B,C,D,E ORIG_CALLER_INFO)
496
 
extern bool init_dynamic_array2(DYNAMIC_ARRAY *array,uint32_t element_size,
497
 
                                   void *init_buffer, uint32_t init_alloc, 
498
 
                                   uint32_t alloc_increment
499
 
                                   CALLER_INFO_PROTO);
500
 
/* init_dynamic_array() function is deprecated */
501
 
extern bool init_dynamic_array(DYNAMIC_ARRAY *array,uint32_t element_size,
502
 
                                  uint32_t init_alloc,uint32_t alloc_increment
503
 
                                  CALLER_INFO_PROTO);
504
 
extern bool insert_dynamic(DYNAMIC_ARRAY *array,unsigned char * element);
505
 
extern unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array);
506
 
extern unsigned char *pop_dynamic(DYNAMIC_ARRAY*);
507
 
extern bool set_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
508
 
extern bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements);
509
 
extern void get_dynamic(DYNAMIC_ARRAY *array,unsigned char * element,uint32_t array_index);
510
 
extern void delete_dynamic(DYNAMIC_ARRAY *array);
511
 
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t array_index);
512
 
extern void freeze_size(DYNAMIC_ARRAY *array);
513
 
extern int  get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char * element);
514
 
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
515
 
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
516
 
#define push_dynamic(A,B) insert_dynamic((A),(B))
517
 
#define reset_dynamic(array) ((array)->elements= 0)
518
 
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
 
359
int create_temp_file(char *to, const char *dir, const char *pfx, myf MyFlags);
519
360
 
520
 
#define my_malloc_lock(A,B) my_malloc((A),(B))
521
 
#define alloc_root_inited(A) ((A)->min_malloc != 0)
522
 
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
523
 
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
524
361
extern int get_defaults_options(int argc, char **argv,
525
362
                                char **defaults, char **extra_defaults,
526
363
                                char **group_suffix);
527
364
extern int load_defaults(const char *conf_file, const char **groups,
528
365
                         int *argc, char ***argv);
529
 
extern int modify_defaults_file(const char *file_location, const char *option,
530
 
                                const char *option_value,
531
 
                                const char *section_name, int remove_option);
532
366
extern int my_search_option_files(const char *conf_file, int *argc,
533
367
                                  char ***argv, uint32_t *args_used,
534
368
                                  Process_option_func func, void *func_ctx);
538
372
extern ha_checksum my_checksum(ha_checksum crc, const unsigned char *mem,
539
373
                               size_t count);
540
374
extern void my_sleep(uint32_t m_seconds);
541
 
extern uint32_t my_set_max_open_files(uint32_t files);
542
 
void my_free_open_file_info(void);
543
 
 
544
 
extern time_t my_time(myf flags);
545
 
extern uint64_t my_getsystime(void);
546
 
extern uint64_t my_micro_time(void);
547
 
extern uint64_t my_micro_time_and_time(time_t *time_arg);
548
 
time_t my_time_possible_from_micro(uint64_t microtime);
549
 
extern bool my_gethwaddr(unsigned char *to);
550
 
 
551
 
#ifdef HAVE_SYS_MMAN_H
552
 
#include <sys/mman.h>
553
 
 
554
 
#ifndef MAP_NOSYNC
555
 
#define MAP_NOSYNC      0
556
 
#endif
557
 
#ifndef MAP_NORESERVE
558
 
#define MAP_NORESERVE 0         /* For irix and AIX */
559
 
#endif
560
 
 
561
 
#ifdef HAVE_MMAP64
562
 
#define my_mmap(a,b,c,d,e,f)    mmap64(a,b,c,d,e,f)
563
 
#else
564
 
#define my_mmap(a,b,c,d,e,f)    mmap(a,b,c,d,e,f)
565
 
#endif
566
 
#define my_munmap(a,b)          munmap((a),(b))
567
 
 
568
 
#else
569
 
/* not a complete set of mmap() flags, but only those that nesessary */
570
 
#define PROT_READ        1
571
 
#define PROT_WRITE       2
572
 
#define MAP_NORESERVE    0
573
 
#define MAP_SHARED       0x0001
574
 
#define MAP_PRIVATE      0x0002
575
 
#define MAP_NOSYNC       0x0800
576
 
#define MAP_FAILED       ((void *)-1)
577
 
#define MS_SYNC          0x0000
578
 
#define HAVE_MMAP
579
 
 
580
 
void *my_mmap(void *, size_t, int, int, int, my_off_t);
581
 
int my_munmap(void *, size_t);
582
 
#endif
583
 
 
584
 
/* character sets */
585
 
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
586
 
extern uint32_t get_collation_number(const char *name);
587
 
extern const char *get_charset_name(uint32_t cs_number);
588
 
 
589
 
extern const CHARSET_INFO *get_charset(uint32_t cs_number, myf flags);
590
 
extern const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
591
 
extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags, myf my_flags);
592
 
 
593
 
extern bool resolve_charset(const char *cs_name,
594
 
                            const CHARSET_INFO *default_cs,
595
 
                            const CHARSET_INFO **cs);
596
 
extern bool resolve_collation(const char *cl_name,
597
 
                             const CHARSET_INFO *default_cl,
598
 
                             const CHARSET_INFO **cl);
599
 
 
600
 
extern void free_charsets(void);
601
 
extern char *get_charsets_dir(char *buf);
602
 
extern bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2);
603
 
extern bool init_compiled_charsets(myf flags);
604
 
extern void add_compiled_collation(CHARSET_INFO *cs);
605
 
extern size_t escape_string_for_drizzle(const CHARSET_INFO *charset_info,
606
 
                                        char *to, size_t to_length,
607
 
                                        const char *from, size_t length);
608
 
extern size_t escape_quotes_for_drizzle(const CHARSET_INFO *charset_info,
609
 
                                        char *to, size_t to_length,
610
 
                                        const char *from, size_t length);
 
375
 
 
376
 
611
377
 
612
378
extern void thd_increment_bytes_sent(uint32_t length);
613
379
extern void thd_increment_bytes_received(uint32_t length);
614
380
extern void thd_increment_net_big_packet_count(uint32_t length);
615
381
 
616
 
#ifdef __cplusplus
617
 
}
618
 
#endif
 
382
} /* namespace internal */
 
383
} /* namespace drizzled */
619
384
 
620
 
#endif /* _my_sys_h */
 
385
#endif /* DRIZZLED_INTERNAL_MY_SYS_H */