~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_global.h

  • Committer: Monty Taylor
  • Date: 2008-07-05 11:20:18 UTC
  • mto: This revision was merged to the branch mainline in revision 62.
  • Revision ID: monty@inaugust.com-20080705112018-fr12kkmgphtu7m29
Changes so that removal of duplicate curr_dir from my_sys.h work.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
 
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 */
19
15
 
20
16
/* This is the include file that should be included 'first' in every C file. */
21
17
 
22
 
#ifndef DRIZZLE_SERVER_GLOBAL_H
23
 
#define DRIZZLE_SERVER_GLOBAL_H
 
18
#ifndef _global_h
 
19
#define _global_h
 
20
 
 
21
#define HAVE_REPLICATION
 
22
#define HAVE_EXTERNAL_CLIENT
 
23
 
 
24
/*
 
25
  InnoDB depends on some MySQL internals which other plugins should not
 
26
  need.  This is because of InnoDB's foreign key support, "safe" binlog
 
27
  truncation, and other similar legacy features.
 
28
 
 
29
  We define accessors for these internals unconditionally, but do not
 
30
  expose them in mysql/plugin.h.  They are declared in ha_innodb.h for
 
31
  InnoDB's use.
 
32
*/
 
33
#define INNODB_COMPATIBILITY_HOOKS
 
34
 
 
35
/* to make command line shorter we'll define USE_PRAGMA_INTERFACE here */
 
36
#ifdef USE_PRAGMA_IMPLEMENTATION
 
37
#define USE_PRAGMA_INTERFACE
 
38
#endif
24
39
 
25
40
#if defined(i386) && !defined(__i386__)
26
41
#define __i386__
27
42
#endif
28
43
 
29
 
#include "config.h"
30
 
 
31
 
#if defined(__cplusplus)
32
 
 
33
 
# if defined(__GNUC) && defined(__EXCEPTIONS)
34
 
#  error "Please add -fno-exceptions to CXXFLAGS and reconfigure/recompile"
35
 
# endif
36
 
 
37
 
# include CSTDINT_H
38
 
# include CINTTYPES_H
39
 
# include CMATH_H
40
 
# include <cstdio>
41
 
# include <cstdlib>
42
 
# include <cstddef>
43
 
# include <cassert>
44
 
# include <cerrno>
45
 
#else
46
 
# include <stdint.h>
47
 
# include <inttypes.h>
48
 
# include <stdio.h>
49
 
# include <stdlib.h>
50
 
# include <stddef.h>
51
 
# include <math.h>
52
 
# include <errno.h>        /* Recommended by debian */
53
 
/*
54
 
  A lot of our programs uses asserts, so better to always include it
55
 
*/
56
 
# include <assert.h>
57
 
# include <stdbool.h>
58
 
 
59
 
#endif // __cplusplus
60
 
 
61
 
/*
62
 
#if TIME_WITH_SYS_TIME
63
 
# include <sys/time.h>
64
 
# include <time.h>
65
 
#else
66
 
# if HAVE_SYS_TIME_H
67
 
#  include <sys/time.h>
68
 
# else
69
 
#  include <time.h>
70
 
# endif
71
 
#endif */ /* TIME_WITH_SYS_TIME */
 
44
/* Macros to make switching between C and C++ mode easier */
 
45
#ifdef __cplusplus
 
46
#define C_MODE_START    extern "C" {
 
47
#define C_MODE_END      }
 
48
#else
 
49
#define C_MODE_START
 
50
#define C_MODE_END
 
51
#endif
 
52
 
 
53
#include <my_config.h>
 
54
#if defined(__cplusplus) && defined(inline)
 
55
#undef inline                           /* fix configure problem */
 
56
#endif
 
57
 
 
58
/* Make it easier to add conditionl code for windows */
 
59
#define IF_WIN(A,B) (B)
 
60
 
 
61
/* Some defines to avoid ifdefs in the code */
 
62
#ifndef NETWARE_YIELD
 
63
#define NETWARE_YIELD
 
64
#define NETWARE_SET_SCREEN_MODE(A)
 
65
#endif
 
66
 
 
67
 
 
68
/*
 
69
  The macros below are borrowed from include/linux/compiler.h in the
 
70
  Linux kernel. Use them to indicate the likelyhood of the truthfulness
 
71
  of a condition. This serves two purposes - newer versions of gcc will be
 
72
  able to optimize for branch predication, which could yield siginficant
 
73
  performance gains in frequently executed sections of the code, and the
 
74
  other reason to use them is for documentation
 
75
*/
 
76
 
 
77
#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
 
78
#define __builtin_expect(x, expected_value) (x)
 
79
#endif
 
80
 
 
81
#define likely(x)       __builtin_expect((x),1)
 
82
#define unlikely(x)     __builtin_expect((x),0)
 
83
 
 
84
 
 
85
/*
 
86
  The macros below are useful in optimising places where it has been
 
87
  discovered that cache misses stall the process and where a prefetch
 
88
  of the cache line can improve matters. This is available in GCC 3.1.1
 
89
  and later versions.
 
90
  PREFETCH_READ says that addr is going to be used for reading and that
 
91
  it is to be kept in caches if possible for a while
 
92
  PREFETCH_WRITE also says that the item to be cached is likely to be
 
93
  updated.
 
94
  The *LOCALITY scripts are also available for experimentation purposes
 
95
  mostly and should only be used if they are verified to improve matters.
 
96
  For more input see GCC manual (available in GCC 3.1.1 and later)
 
97
*/
 
98
 
 
99
#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR > 10)
 
100
#define PREFETCH_READ(addr) __builtin_prefetch(addr, 0, 3)
 
101
#define PREFETCH_WRITE(addr) \
 
102
  __builtin_prefetch(addr, 1, 3)
 
103
#define PREFETCH_READ_LOCALITY(addr, locality) \
 
104
  __builtin_prefetch(addr, 0, locality)
 
105
#define PREFETCH_WRITE_LOCALITY(addr, locality) \
 
106
  __builtin_prefetch(addr, 1, locality)
 
107
#else
 
108
#define PREFETCH_READ(addr)
 
109
#define PREFETCH_READ_LOCALITY(addr, locality)
 
110
#define PREFETCH_WRITE(addr)
 
111
#define PREFETCH_WRITE_LOCALITY(addr, locality)
 
112
#endif
 
113
 
 
114
/*
 
115
  The following macro is used to ensure that code often used in most
 
116
  SQL statements and definitely for parts of the SQL processing are
 
117
  kept in a code segment by itself. This has the advantage that the
 
118
  risk of common code being overlapping in caches of the CPU is less.
 
119
  This can be a cause of big performance problems.
 
120
  Routines should be put in this category with care and when they are
 
121
  put there one should also strive to make as much of the error handling
 
122
  as possible (or uncommon code of the routine) to execute in a
 
123
  separate method to avoid moving to much code to this code segment.
 
124
 
 
125
  It is very easy to use, simply add HOT_METHOD at the end of the
 
126
  function declaration.
 
127
  For more input see GCC manual (available in GCC 2.95 and later)
 
128
*/
 
129
 
 
130
#if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR > 94)
 
131
#define HOT_METHOD \
 
132
  __attribute__ ((section ("hot_code_section")))
 
133
#else
 
134
#define HOT_METHOD
 
135
#endif
 
136
 
 
137
/*
 
138
  The following macro is used to ensure that popular global variables
 
139
  are located next to each other to avoid that they contend for the
 
140
  same cache lines.
 
141
 
 
142
  It is very easy to use, simply add HOT_DATA at the end of the declaration
 
143
  of the variable, the variable must be initialised because of the way
 
144
  that linker works so a declaration using HOT_DATA should look like:
 
145
  uint global_hot_data HOT_DATA = 0;
 
146
  For more input see GCC manual (available in GCC 2.95 and later)
 
147
*/
 
148
 
 
149
#if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR > 94)
 
150
#define HOT_DATA \
 
151
  __attribute__ ((section ("hot_data_section")))
 
152
#else
 
153
#define HOT_DATA
 
154
#endif
 
155
 
 
156
/*
 
157
  now let's figure out if inline functions are supported
 
158
  autoconf defines 'inline' to be empty, if not
 
159
*/
 
160
#if defined(inline)
 
161
#define HAVE_INLINE
 
162
#endif
 
163
/* helper macro for "instantiating" inline functions */
 
164
#define STATIC_INLINE static inline
 
165
 
 
166
/*
 
167
  The following macros are used to control inlining a bit more than
 
168
  usual. These macros are used to ensure that inlining always or
 
169
  never occurs (independent of compilation mode).
 
170
  For more input see GCC manual (available in GCC 3.1.1 and later)
 
171
*/
 
172
 
 
173
#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR > 10)
 
174
#define ALWAYS_INLINE __attribute__ ((always_inline))
 
175
#define NEVER_INLINE __attribute__ ((noinline))
 
176
#else
 
177
#define ALWAYS_INLINE
 
178
#define NEVER_INLINE
 
179
#endif
 
180
 
 
181
 
 
182
/* Fix problem with S_ISLNK() on Linux */
 
183
#if defined(TARGET_OS_LINUX) || defined(__GLIBC__)
 
184
#undef  _GNU_SOURCE
 
185
#define _GNU_SOURCE 1
 
186
#endif
72
187
 
73
188
/*
74
189
  Temporary solution to solve bug#7156. Include "sys/types.h" before
78
193
#include <sys/types.h>
79
194
#endif
80
195
 
81
 
 
82
 
#include <pthread.h>    /* AIX must have this included first */
83
 
 
84
 
#define _REENTRANT  1  /* Threads requires reentrant code */
85
 
 
 
196
#ifdef HAVE_THREADS_WITHOUT_SOCKETS
 
197
/* MIT pthreads does not work with unix sockets */
 
198
#undef HAVE_SYS_UN_H
 
199
#endif
 
200
 
 
201
#define __EXTENSIONS__ 1        /* We want some extension */
 
202
#ifndef __STDC_EXT__
 
203
#define __STDC_EXT__ 1          /* To get large file support on hpux */
 
204
#endif
 
205
 
 
206
/*
 
207
  Solaris 9 include file <sys/feature_tests.h> refers to X/Open document
 
208
 
 
209
    System Interfaces and Headers, Issue 5
 
210
 
 
211
  saying we should define _XOPEN_SOURCE=500 to get POSIX.1c prototypes,
 
212
  but apparently other systems (namely FreeBSD) don't agree.
 
213
 
 
214
  On a newer Solaris 10, the above file recognizes also _XOPEN_SOURCE=600.
 
215
  Furthermore, it tests that if a program requires older standard
 
216
  (_XOPEN_SOURCE<600 or _POSIX_C_SOURCE<200112L) it cannot be
 
217
  run on a new compiler (that defines _STDC_C99) and issues an #error.
 
218
  It's also an #error if a program requires new standard (_XOPEN_SOURCE=600
 
219
  or _POSIX_C_SOURCE=200112L) and a compiler does not define _STDC_C99.
 
220
 
 
221
  To add more to this mess, Sun Studio C compiler defines _STDC_C99 while
 
222
  C++ compiler does not!
 
223
 
 
224
  So, in a desperate attempt to get correct prototypes for both
 
225
  C and C++ code, we define either _XOPEN_SOURCE=600 or _XOPEN_SOURCE=500
 
226
  depending on the compiler's announced C standard support.
 
227
 
 
228
  Cleaner solutions are welcome.
 
229
*/
 
230
#ifdef __sun
 
231
#if __STDC_VERSION__ - 0 >= 199901L
 
232
#define _XOPEN_SOURCE 600
 
233
#else
 
234
#define _XOPEN_SOURCE 500
 
235
#endif
 
236
#endif
 
237
 
 
238
#ifndef _POSIX_PTHREAD_SEMANTICS
 
239
#define _POSIX_PTHREAD_SEMANTICS /* We want posix threads */
 
240
#endif
 
241
 
 
242
#define _REENTRANT      1       /* Some thread libraries require this */
 
243
 
 
244
#if !defined(_THREAD_SAFE) && !defined(_AIX)
 
245
#define _THREAD_SAFE            /* Required for OSF1 */
 
246
#endif
 
247
 
 
248
#include <pthread.h>            /* AIX must have this included first */
 
249
 
 
250
#define _REENTRANT      1       /* Threads requires reentrant code */
 
251
 
 
252
/* Go around some bugs in different OS and compilers */
 
253
 
 
254
#if defined(HAVE_BROKEN_INLINE) && !defined(__cplusplus)
 
255
#undef inline
 
256
#define inline
 
257
#endif
 
258
 
 
259
/* gcc/egcs issues */
 
260
 
 
261
#if defined(__GNUC) && defined(__EXCEPTIONS)
 
262
#error "Please add -fno-exceptions to CXXFLAGS and reconfigure/recompile"
 
263
#endif
 
264
 
 
265
#ifndef stdin
 
266
#include <stdio.h>
 
267
#endif
 
268
#ifdef HAVE_STDLIB_H
 
269
#include <stdlib.h>
 
270
#endif
 
271
#ifdef HAVE_STDDEF_H
 
272
#include <stddef.h>
 
273
#endif
 
274
 
 
275
#include <math.h>
86
276
#ifdef HAVE_LIMITS_H
87
277
#include <limits.h>
88
278
#endif
 
279
#ifdef HAVE_FLOAT_H
 
280
#include <float.h>
 
281
#endif
89
282
 
90
283
#ifdef HAVE_SYS_TYPES_H
91
284
#include <sys/types.h>
93
286
#ifdef HAVE_FCNTL_H
94
287
#include <fcntl.h>
95
288
#endif
96
 
 
 
289
#ifdef HAVE_SYS_TIMEB_H
 
290
#include <sys/timeb.h>                          /* Avoid warnings on SCO */
 
291
#endif
 
292
#if TIME_WITH_SYS_TIME
 
293
# include <sys/time.h>
 
294
# include <time.h>
 
295
#else
 
296
# if HAVE_SYS_TIME_H
 
297
#  include <sys/time.h>
 
298
# else
 
299
#  include <time.h>
 
300
# endif
 
301
#endif /* TIME_WITH_SYS_TIME */
97
302
#ifdef HAVE_UNISTD_H
98
303
#include <unistd.h>
99
304
#endif
105
310
#include <alloca.h>
106
311
#endif
107
312
 
108
 
 
109
 
 
110
 
#ifdef HAVE_SYS_STAT_H
111
 
# include <sys/stat.h>
112
 
#endif
 
313
#include <errno.h>                              /* Recommended by debian */
 
314
/* We need the following to go around a problem with openssl on solaris */
 
315
#if defined(HAVE_CRYPT_H)
 
316
#include <crypt.h>
 
317
#endif
 
318
 
 
319
#if defined(HAVE_STDINT_H)
 
320
#include <stdint.h>
 
321
#endif
 
322
#if defined(HAVE_STDBOOL_H)
 
323
#include <stdbool.h>
 
324
#endif
 
325
 
 
326
 
 
327
/*
 
328
  A lot of our programs uses asserts, so better to always include it
 
329
  This also fixes a problem when people uses DBUG_ASSERT without including
 
330
  assert.h
 
331
*/
 
332
#include <assert.h>
 
333
 
 
334
/* an assert that works at compile-time. only for constant expression */
 
335
#ifndef __GNUC__
 
336
#define compile_time_assert(X)  do { } while(0)
 
337
#else
 
338
#define compile_time_assert(X)                                  \
 
339
  do                                                            \
 
340
  {                                                             \
 
341
    char compile_time_assert[(X) ? 1 : -1]                      \
 
342
                             __attribute__ ((unused));          \
 
343
  } while(0)
 
344
#endif
 
345
 
 
346
/* Declare madvise where it is not declared for C++, like Solaris */
 
347
#if HAVE_MADVISE && !defined(HAVE_DECL_MADVISE) && defined(__cplusplus)
 
348
extern "C" int madvise(void *addr, size_t len, int behav);
 
349
#endif
 
350
 
 
351
/* We can not live without the following defines */
 
352
 
 
353
#define USE_MYFUNC 1            /* Must use syscall indirection */
 
354
#define MASTER 1                /* Compile without unireg */
 
355
#define ENGLISH 1               /* Messages in English */
 
356
#define POSIX_MISTAKE 1         /* regexp: Fix stupid spec error */
 
357
#define USE_REGEX 1             /* We want the use the regex library */
 
358
/* Do not define for ultra sparcs */
 
359
#define USE_BMOVE512 1          /* Use this unless system bmove is faster */
 
360
 
 
361
#define QUOTE_ARG(x)            #x      /* Quote argument (before cpp) */
 
362
#define STRINGIFY_ARG(x) QUOTE_ARG(x)   /* Quote argument, after cpp */
 
363
/* Does the system remember a signal handler after a signal ? */
 
364
#ifndef HAVE_BSD_SIGNALS
 
365
#define DONT_REMEMBER_SIGNAL
 
366
#endif
 
367
 
 
368
/* Define void to stop lint from generating "null effekt" comments */
 
369
#ifndef DONT_DEFINE_VOID
 
370
#ifdef _lint
 
371
int     __void__;
 
372
#define VOID(X)         (__void__ = (int) (X))
 
373
#else
 
374
#undef VOID
 
375
#define VOID(X)         (X)
 
376
#endif
 
377
#endif /* DONT_DEFINE_VOID */
113
378
 
114
379
#if !defined(HAVE_UINT)
115
380
#undef HAVE_UINT
116
381
#define HAVE_UINT
117
382
typedef unsigned int uint;
 
383
typedef unsigned short ushort;
118
384
#endif
119
385
 
120
 
/* Declared in int2str() */
121
 
extern char _dig_vec_upper[];
122
 
extern char _dig_vec_lower[];
123
 
 
 
386
#define CMP_NUM(a,b)    (((a) < (b)) ? -1 : ((a) == (b)) ? 0 : 1)
 
387
#define sgn(a)          (((a) < 0) ? -1 : ((a) > 0) ? 1 : 0)
 
388
#define swap_variables(t, a, b) { register t dummy; dummy= a; a= b; b= dummy; }
 
389
#define test(a)         ((a) ? 1 : 0)
124
390
#define set_if_bigger(a,b)  do { if ((a) < (b)) (a)=(b); } while(0)
125
 
 
126
391
#define set_if_smaller(a,b) do { if ((a) > (b)) (a)=(b); } while(0)
127
 
#define array_elements(A) ((size_t) (sizeof(A)/sizeof(A[0])))
 
392
#define test_all_bits(a,b) (((a) & (b)) == (b))
 
393
#define set_bits(type, bit_count) (sizeof(type)*8 <= (bit_count) ? ~(type) 0 : ((((type) 1) << (bit_count)) - (type) 1))
 
394
#define array_elements(A) ((uint) (sizeof(A)/sizeof(A[0])))
 
395
#ifndef HAVE_RINT
 
396
#define rint(A) floor((A)+(((A) < 0)? -0.5 : 0.5))
 
397
#endif
 
398
 
 
399
/* Define some general constants */
 
400
#ifndef TRUE
 
401
#define TRUE            (1)     /* Logical true */
 
402
#define FALSE           (0)     /* Logical false */
 
403
#endif
 
404
 
 
405
#if defined(__GNUC__)
 
406
#define function_volatile       volatile
 
407
#define my_reinterpret_cast(A) reinterpret_cast<A>
 
408
#define my_const_cast(A) const_cast<A>
 
409
# ifndef GCC_VERSION
 
410
#  define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
 
411
# endif
 
412
#elif !defined(my_reinterpret_cast)
 
413
#define my_reinterpret_cast(A) (A)
 
414
#define my_const_cast(A) (A)
 
415
#endif
 
416
 
 
417
#include <my_attribute.h>
 
418
 
 
419
/* From old s-system.h */
 
420
 
 
421
/*
 
422
  Support macros for non ansi & other old compilers. Since such
 
423
  things are no longer supported we do nothing. We keep then since
 
424
  some of our code may still be needed to upgrade old customers.
 
425
*/
 
426
#define _VARARGS(X) X
 
427
#define _STATIC_VARARGS(X) X
 
428
#define _PC(X)  X
 
429
 
 
430
/* The DBUG_ON flag always takes precedence over default DBUG_OFF */
 
431
#if defined(DBUG_ON) && defined(DBUG_OFF)
 
432
#undef DBUG_OFF
 
433
#endif
 
434
 
 
435
/* We might be forced to turn debug off, if not turned off already */
 
436
#if (defined(FORCE_DBUG_OFF) || defined(_lint)) && !defined(DBUG_OFF)
 
437
#  define DBUG_OFF
 
438
#  ifdef DBUG_ON
 
439
#    undef DBUG_ON
 
440
#  endif
 
441
#endif
 
442
 
 
443
#include <my_dbug.h>
 
444
 
 
445
#define MIN_ARRAY_SIZE  0       /* Zero or One. Gcc allows zero*/
 
446
#define ASCII_BITS_USED 8       /* Bit char used */
128
447
 
129
448
/* Some types that is different between systems */
130
449
 
131
 
typedef int  File;    /* File descriptor */
132
 
 
 
450
typedef int     File;           /* File descriptor */
 
451
#ifndef Socket_defined
 
452
typedef int     my_socket;      /* File descriptor for sockets */
 
453
#define INVALID_SOCKET -1
 
454
#endif
 
455
/* Type for fuctions that handles signals */
 
456
#define sig_handler RETSIGTYPE
 
457
C_MODE_START
 
458
typedef void    (*sig_return)(void);/* Returns type from signal */
 
459
C_MODE_END
 
460
#if defined(__GNUC__) && !defined(_lint)
 
461
typedef char    pchar;          /* Mixed prototypes can take char */
 
462
typedef char    puchar;         /* Mixed prototypes can take char */
 
463
typedef char    pbool;          /* Mixed prototypes can take char */
 
464
typedef short   pshort;         /* Mixed prototypes can take short int */
 
465
typedef float   pfloat;         /* Mixed prototypes can take float */
 
466
#else
 
467
typedef int     pchar;          /* Mixed prototypes can't take char */
 
468
typedef uint    puchar;         /* Mixed prototypes can't take char */
 
469
typedef int     pbool;          /* Mixed prototypes can't take char */
 
470
typedef int     pshort;         /* Mixed prototypes can't take short int */
 
471
typedef double  pfloat;         /* Mixed prototypes can't take float */
 
472
#endif
 
473
C_MODE_START
 
474
typedef int     (*qsort_cmp)(const void *,const void *);
 
475
typedef int     (*qsort_cmp2)(void*, const void *,const void *);
 
476
C_MODE_END
 
477
#define qsort_t RETQSORTTYPE    /* Broken GCC cant handle typedef !!!! */
133
478
#ifdef HAVE_SYS_SOCKET_H
134
479
#include <sys/socket.h>
135
480
#endif
136
 
 
 
481
typedef SOCKET_SIZE_TYPE size_socket;
 
482
 
 
483
#ifndef SOCKOPT_OPTLEN_TYPE
 
484
#define SOCKOPT_OPTLEN_TYPE size_socket
 
485
#endif
 
486
 
 
487
/* file create flags */
 
488
 
 
489
#ifndef O_SHARE                 /* Probably not windows */
 
490
#define O_SHARE         0       /* Flag to my_open for shared files */
 
491
#ifndef O_BINARY
 
492
#define O_BINARY        0       /* Flag to my_open for binary files */
 
493
#endif
 
494
#ifndef FILE_BINARY
 
495
#define FILE_BINARY     O_BINARY /* Flag to my_fopen for binary streams */
 
496
#endif
 
497
#ifdef HAVE_FCNTL
 
498
#define HAVE_FCNTL_LOCK
 
499
#define F_TO_EOF        0L      /* Param to lockf() to lock rest of file */
 
500
#endif
 
501
#endif /* O_SHARE */
 
502
 
 
503
#ifndef O_TEMPORARY
 
504
#define O_TEMPORARY     0
 
505
#endif
 
506
#ifndef O_SHORT_LIVED
 
507
#define O_SHORT_LIVED   0
 
508
#endif
 
509
#ifndef O_NOFOLLOW
 
510
#define O_NOFOLLOW      0
 
511
#endif
 
512
 
 
513
/* #define USE_RECORD_LOCK      */
 
514
 
 
515
        /* Unsigned types supported by the compiler */
 
516
#define UNSINT8                 /* unsigned int8 (char) */
 
517
#define UNSINT16                /* unsigned int16 */
 
518
#define UNSINT32                /* unsigned int32 */
 
519
 
 
520
        /* General constants */
 
521
#define SC_MAXWIDTH     256     /* Max width of screen (for error messages) */
 
522
#define FN_LEN          256     /* Max file name len */
 
523
#define FN_HEADLEN      253     /* Max length of filepart of file name */
 
524
#define FN_EXTLEN       20      /* Max length of extension (part of FN_LEN) */
 
525
#define FN_REFLEN       512     /* Max length of full path-name */
 
526
#define FN_EXTCHAR      '.'
 
527
#define FN_HOMELIB      '~'     /* ~/ is used as abbrev for home dir */
 
528
#define FN_CURLIB       '.'     /* ./ is used as abbrev for current dir */
 
529
#define FN_PARENTDIR    ".."    /* Parent directory; Must be a string */
137
530
 
138
531
#ifndef FN_LIBCHAR
139
 
#define FN_LIBCHAR  '/'
140
 
#define FN_ROOTDIR  "/"
 
532
#define FN_LIBCHAR      '/'
 
533
#define FN_ROOTDIR      "/"
141
534
#endif
142
 
#define MY_NFILE  64  /* This is only used to save filenames */
 
535
#define MY_NFILE        64      /* This is only used to save filenames */
143
536
#ifndef OS_FILE_LIMIT
144
 
#define OS_FILE_LIMIT  65535
 
537
#define OS_FILE_LIMIT   65535
145
538
#endif
146
539
 
 
540
/* #define EXT_IN_LIBNAME     */
 
541
/* #define FN_NO_CASE_SENCE   */
 
542
/* #define FN_UPPER_CASE TRUE */
 
543
 
 
544
/*
 
545
  Io buffer size; Must be a power of 2 and a multiple of 512. May be
 
546
  smaller what the disk page size. This influences the speed of the
 
547
  isam btree library. eg to big to slow.
 
548
*/
 
549
#define IO_SIZE                 4096
147
550
/*
148
551
  How much overhead does malloc have. The code often allocates
149
552
  something like 1024-MALLOC_OVERHEAD bytes
150
553
*/
151
554
#define MALLOC_OVERHEAD 8
152
555
 
153
 
/* get memory in huncs */
154
 
#define ONCE_ALLOC_INIT    (uint) (4096-MALLOC_OVERHEAD)
155
 
/* Typical record cash */
156
 
#define RECORD_CACHE_SIZE  (uint) (64*1024-MALLOC_OVERHEAD)
157
 
/* Typical key cash */
158
 
#define KEY_CACHE_SIZE    (uint) (8*1024*1024-MALLOC_OVERHEAD)
159
 
/* Default size of a key cache block  */
160
 
#define KEY_CACHE_BLOCK_SIZE  (uint) 1024
161
 
 
162
 
 
163
 
/* Some things that this system doesn't have */
 
556
        /* get memory in huncs */
 
557
#define ONCE_ALLOC_INIT         (uint) (4096-MALLOC_OVERHEAD)
 
558
        /* Typical record cash */
 
559
#define RECORD_CACHE_SIZE       (uint) (64*1024-MALLOC_OVERHEAD)
 
560
        /* Typical key cash */
 
561
#define KEY_CACHE_SIZE          (uint) (8*1024*1024-MALLOC_OVERHEAD)
 
562
        /* Default size of a key cache block  */
 
563
#define KEY_CACHE_BLOCK_SIZE    (uint) 1024
 
564
 
 
565
 
 
566
        /* Some things that this system doesn't have */
 
567
 
 
568
#define NO_HASH                 /* Not needed anymore */
164
569
 
165
570
/* Some defines of functions for portability */
166
571
 
167
 
#undef remove    /* Crashes MySQL on SCO 5.0.0 */
168
 
#ifndef uint64_t2double
169
 
#define uint64_t2double(A) ((double) (uint64_t) (A))
 
572
#undef remove           /* Crashes MySQL on SCO 5.0.0 */
 
573
#define closesocket(A)  close(A)
 
574
#ifndef ulonglong2double
 
575
#define ulonglong2double(A) ((double) (ulonglong) (A))
170
576
#define my_off_t2double(A)  ((double) (my_off_t) (A))
171
577
#endif
172
578
 
174
580
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
175
581
#endif
176
582
#define ulong_to_double(X) ((double) (ulong) (X))
 
583
#define SET_STACK_SIZE(X)       /* Not needed on real machines */
177
584
 
178
585
#ifndef STACK_DIRECTION
179
586
#error "please add -DSTACK_DIRECTION=1 or -1 to your CPPFLAGS"
183
590
#define strtok_r(A,B,C) strtok((A),(B))
184
591
#endif
185
592
 
186
 
#ifdef HAVE_FLOAT_H
187
 
#include <float.h>
188
 
#else
189
 
#if !defined(FLT_MIN)
190
 
#define FLT_MIN         ((float)1.40129846432481707e-45)
191
 
#endif
192
 
#if !defined(FLT_MAX)
193
 
#define FLT_MAX         ((float)3.40282346638528860e+38)
194
 
#endif
195
 
#endif
 
593
/* This is from the old m-machine.h file */
 
594
 
 
595
#if SIZEOF_LONG_LONG > 4
 
596
#define HAVE_LONG_LONG 1
 
597
#endif
 
598
 
 
599
/*
 
600
  Some pre-ANSI-C99 systems like AIX 5.1 and Linux/GCC 2.95 define
 
601
  ULONGLONG_MAX, LONGLONG_MIN, LONGLONG_MAX; we use them if they're defined.
 
602
  Also on Windows we define these constants by hand in config-win.h.
 
603
*/
 
604
 
 
605
#if defined(HAVE_LONG_LONG) && !defined(LONGLONG_MIN)
 
606
#if defined(INT64_MAX)
 
607
#define LONGLONG_MAX INT64_MAX
 
608
#else
 
609
#define LONGLONG_MAX ((int64_t) 0x7FFFFFFFFFFFFFFFLL)
 
610
#endif
 
611
#if defined(INT64_MIN)
 
612
#define LONGLONG_MIN INT64_MIN
 
613
#else
 
614
#define LONGLONG_MIN ((int64_t) 0x8000000000000000LL)
 
615
#endif
 
616
#endif /* defined(HAVE_LONG_LONG) && !defined(LONGLONG_MIN) */
 
617
 
 
618
#if defined(HAVE_LONG_LONG) && !defined(ULONGLONG_MAX)
 
619
/* First check for ANSI C99 definition: */
 
620
#if defined(UINT64_MAX)
 
621
#define ULONGLONG_MAX  UINT64_MAX
 
622
#else
 
623
#define ULONGLONG_MAX ((uint64_t)(~0ULL))
 
624
#endif
 
625
#endif /* defined (HAVE_LONG_LONG) && !defined(ULONGLONG_MAX)*/
 
626
 
 
627
#define INT_MIN32       (~0x7FFFFFFFL)
 
628
#define INT_MAX32       0x7FFFFFFFL
 
629
#define UINT_MAX32      0xFFFFFFFFL
 
630
#define INT_MIN24       (~0x007FFFFF)
 
631
#define INT_MAX24       0x007FFFFF
 
632
#define UINT_MAX24      0x00FFFFFF
 
633
#define INT_MIN16       (~0x7FFF)
 
634
#define INT_MAX16       0x7FFF
 
635
#define UINT_MAX16      0xFFFF
 
636
#define INT_MIN8        (~0x7F)
 
637
#define INT_MAX8        0x7F
 
638
#define UINT_MAX8       0xFF
196
639
 
197
640
/* From limits.h instead */
198
641
#ifndef DBL_MIN
199
 
#define DBL_MIN    4.94065645841246544e-324
 
642
#define DBL_MIN         4.94065645841246544e-324
 
643
#define FLT_MIN         ((float)1.40129846432481707e-45)
200
644
#endif
201
645
#ifndef DBL_MAX
202
 
#define DBL_MAX    1.79769313486231470e+308
 
646
#define DBL_MAX         1.79769313486231470e+308
 
647
#define FLT_MAX         ((float)3.40282346638528860e+38)
203
648
#endif
204
649
#ifndef SIZE_T_MAX
205
650
#define SIZE_T_MAX ~((size_t) 0)
206
651
#endif
207
652
 
 
653
#ifndef isfinite
 
654
#ifdef HAVE_FINITE
 
655
#define isfinite(x) finite(x)
 
656
#else
 
657
#define finite(x) (1.0 / fabs(x) > 0.0)
 
658
#endif /* HAVE_FINITE */
 
659
#endif /* isfinite */
 
660
 
 
661
#ifndef HAVE_ISNAN
 
662
#define isnan(x) ((x) != (x))
 
663
#endif
 
664
 
 
665
#ifdef HAVE_ISINF
 
666
/* isinf() can be used in both C and C++ code */
 
667
#define my_isinf(X) isinf(X)
 
668
#else
 
669
#define my_isinf(X) (!isfinite(X) && !isnan(X))
 
670
#endif
208
671
 
209
672
/* Define missing math constants. */
210
673
#ifndef M_PI
221
684
  Max size that must be added to a so that we know Size to make
222
685
  adressable obj.
223
686
*/
224
 
typedef ptrdiff_t my_ptrdiff_t;
 
687
#if SIZEOF_CHARP == 4
 
688
typedef int32_t         my_ptrdiff_t;
 
689
#else
 
690
typedef int64_t         my_ptrdiff_t;
 
691
#endif
225
692
 
226
 
#define MY_ALIGN(A,L)  (((A) + (L) - 1) & ~((L) - 1))
227
 
#define ALIGN_SIZE(A)  MY_ALIGN((A),sizeof(double))
 
693
#define MY_ALIGN(A,L)   (((A) + (L) - 1) & ~((L) - 1))
 
694
#define ALIGN_SIZE(A)   MY_ALIGN((A),sizeof(double))
228
695
/* Size to make adressable obj. */
229
696
#define ALIGN_PTR(A, t) ((t*) MY_ALIGN((A),sizeof(t)))
230
 
/* Offset of field f in structure t */
231
 
#define OFFSET(t, f)  ((size_t)(char *)&((t *)0)->f)
232
 
#define ADD_TO_PTR(ptr,size,type) (type) ((unsigned char*) (ptr)+size)
233
 
#define PTR_BYTE_DIFF(A,B) (my_ptrdiff_t) ((unsigned char*) (A) - (unsigned char*) (B))
 
697
                         /* Offset of field f in structure t */
 
698
#define OFFSET(t, f)    ((size_t)(char *)&((t *)0)->f)
 
699
#define ADD_TO_PTR(ptr,size,type) (type) ((uchar*) (ptr)+size)
 
700
#define PTR_BYTE_DIFF(A,B) (my_ptrdiff_t) ((uchar*) (A) - (uchar*) (B))
234
701
 
235
702
#define MY_DIV_UP(A, B) (((A) + (B) - 1) / (B))
236
703
#define MY_ALIGNED_BYTE_ARRAY(N, S, T) T N[MY_DIV_UP(S, sizeof(T))]
237
704
 
 
705
/*
 
706
  Custom version of standard offsetof() macro which can be used to get
 
707
  offsets of members in class for non-POD types (according to the current
 
708
  version of C++ standard offsetof() macro can't be used in such cases and
 
709
  attempt to do so causes warnings to be emitted, OTOH in many cases it is
 
710
  still OK to assume that all instances of the class has the same offsets
 
711
  for the same members).
 
712
 
 
713
  This is temporary solution which should be removed once File_parser class
 
714
  and related routines are refactored.
 
715
*/
 
716
 
 
717
#define my_offsetof(TYPE, MEMBER) \
 
718
        ((size_t)((char *)&(((TYPE *)0x10)->MEMBER) - (char*)0x10))
 
719
 
 
720
#define NullS           (char *) 0
 
721
 
 
722
#define STDCALL
 
723
 
238
724
/* Typdefs for easyier portability */
239
725
 
 
726
#ifndef HAVE_UCHAR
 
727
typedef unsigned char   uchar;  /* Short for unsigned char */
 
728
#endif
 
729
 
 
730
#ifndef HAVE_INT8
 
731
typedef signed char int8;       /* Signed integer >= 8  bits */
 
732
#endif
 
733
#ifndef HAVE_UINT8
 
734
typedef unsigned char uint8;    /* Unsigned integer >= 8  bits */
 
735
#endif
 
736
#ifndef HAVE_INT16
 
737
typedef short int16;
 
738
#endif
 
739
#ifndef HAVE_UINT16
 
740
typedef unsigned short uint16;
 
741
#endif
 
742
#if SIZEOF_INT == 4
 
743
#ifndef HAVE_INT32
 
744
typedef int int32;
 
745
#endif
 
746
#ifndef HAVE_UINT32
 
747
typedef unsigned int uint32;
 
748
#endif
 
749
#elif SIZEOF_LONG == 4
 
750
#ifndef HAVE_INT32
 
751
typedef long int32;
 
752
#endif
 
753
#ifndef HAVE_UINT32
 
754
typedef unsigned long uint32;
 
755
#endif
 
756
#else
 
757
#error Neither int or long is of 4 bytes width
 
758
#endif
 
759
 
240
760
#if !defined(HAVE_ULONG) && !defined(__USE_MISC)
241
 
typedef unsigned long ulong;      /* Short for unsigned long */
242
 
#endif
243
 
 
244
 
typedef uint64_t my_off_t;
245
 
 
246
 
#define MY_FILEPOS_ERROR  (UINT64_MAX)
247
 
 
248
 
typedef int    myf;  /* Type of MyFlags in my_funcs */
 
761
typedef uint32_t        ulong;            /* Short for unsigned long */
 
762
#endif
 
763
#ifndef longlong_defined
 
764
/* 
 
765
  Using [unsigned] long long is preferable as [u]longlong because we use 
 
766
  [unsigned] long long unconditionally in many places, 
 
767
  for example in constants with [U]LL suffix.
 
768
*/
 
769
typedef uint64_t ulonglong; /* ulong or unsigned long long */
 
770
typedef int64_t longlong;
 
771
#endif
 
772
 
 
773
#ifndef HAVE_INT64
 
774
typedef int64_t int64;
 
775
#endif
 
776
#ifndef HAVE_UINT64
 
777
typedef uint64_t uint64;
 
778
#endif
 
779
 
 
780
typedef uint64_t my_ulonglong;
 
781
 
 
782
#if SIZEOF_CHARP == SIZEOF_INT
 
783
typedef int intptr;
 
784
#elif SIZEOF_CHARP == SIZEOF_LONG
 
785
typedef long intptr;
 
786
#elif SIZEOF_CHARP == SIZEOF_LONG_LONG
 
787
typedef long long intptr;
 
788
#else
 
789
#error sizeof(void *) is neither sizeof(int) nor sizeof(long) nor sizeof(long long)
 
790
#endif
 
791
 
 
792
#define MY_ERRPTR ((void*)(intptr)1)
 
793
 
 
794
#ifdef USE_RAID
 
795
/*
 
796
  The following is done with a if to not get problems with pre-processors
 
797
  with late define evaluation
 
798
*/
 
799
#if SIZEOF_OFF_T == 4
 
800
#define SYSTEM_SIZEOF_OFF_T 4
 
801
#else
 
802
#define SYSTEM_SIZEOF_OFF_T 8
 
803
#endif
 
804
#undef  SIZEOF_OFF_T
 
805
#define SIZEOF_OFF_T        8
 
806
#else
 
807
#define SYSTEM_SIZEOF_OFF_T SIZEOF_OFF_T
 
808
#endif /* USE_RAID */
 
809
 
 
810
#if SIZEOF_OFF_T > 4
 
811
typedef ulonglong my_off_t;
 
812
#else
 
813
typedef unsigned long my_off_t;
 
814
#endif
 
815
#define MY_FILEPOS_ERROR        (~(my_off_t) 0)
 
816
 
 
817
typedef off_t os_off_t;
 
818
 
 
819
#define socket_errno    errno
 
820
#define closesocket(A)  close(A)
 
821
#define SOCKET_EINTR    EINTR
 
822
#define SOCKET_EAGAIN   EAGAIN
 
823
#define SOCKET_ETIMEDOUT SOCKET_EINTR
 
824
#define SOCKET_EWOULDBLOCK EWOULDBLOCK
 
825
#define SOCKET_EADDRINUSE EADDRINUSE
 
826
#define SOCKET_ENFILE   ENFILE
 
827
#define SOCKET_EMFILE   EMFILE
 
828
 
 
829
typedef uint8           int7;   /* Most effective integer 0 <= x <= 127 */
 
830
typedef short           int15;  /* Most effective integer 0 <= x <= 32767 */
 
831
typedef int             myf;    /* Type of MyFlags in my_funcs */
 
832
typedef char            my_bool; /* Small bool */
 
833
#if !defined(bool) && (!defined(HAVE_BOOL) || !defined(__cplusplus))
 
834
typedef char            bool;   /* Ordinary boolean values 0 1 */
 
835
#endif
 
836
        /* Macros for converting *constants* to the right type */
 
837
#define INT8(v)         (int8) (v)
 
838
#define INT16(v)        (int16) (v)
 
839
#define INT32(v)        (int32) (v)
249
840
#define MYF(v)          (myf) (v)
250
841
 
 
842
#ifndef LL
 
843
#ifdef HAVE_LONG_LONG
 
844
#define LL(A) A ## LL
 
845
#else
 
846
#define LL(A) A ## L
 
847
#endif
 
848
#endif
 
849
 
 
850
#ifndef ULL
 
851
#define ULL(A) A ## UL
 
852
#endif
 
853
 
 
854
/*
 
855
  Sometimes we want to make sure that the variable is not put into
 
856
  a register in debugging mode so we can see its value in the core
 
857
*/
 
858
 
 
859
#ifndef DBUG_OFF
 
860
#define dbug_volatile volatile
 
861
#else
 
862
#define dbug_volatile
 
863
#endif
 
864
 
251
865
/* Defines for time function */
252
 
#define SCALE_SEC  100
253
 
#define SCALE_USEC  10000
254
 
#define MY_HOW_OFTEN_TO_ALARM  2  /* How often we want info on screen */
255
 
#define MY_HOW_OFTEN_TO_WRITE  1000  /* How often we want info on screen */
256
 
 
 
866
#define SCALE_SEC       100
 
867
#define SCALE_USEC      10000
 
868
#define MY_HOW_OFTEN_TO_ALARM   2       /* How often we want info on screen */
 
869
#define MY_HOW_OFTEN_TO_WRITE   1000    /* How often we want info on screen */
 
870
 
 
871
 
 
872
 
 
873
/*
 
874
  Define-funktions for reading and storing in machine independent format
 
875
  (low byte first)
 
876
*/
 
877
 
 
878
/* Optimized store functions for Intel x86 */
 
879
#if defined(__i386__)
 
880
#define sint2korr(A)    (*((int16 *) (A)))
 
881
#define sint3korr(A)    ((int32) ((((uchar) (A)[2]) & 128) ? \
 
882
                                  (((uint32) 255L << 24) | \
 
883
                                   (((uint32) (uchar) (A)[2]) << 16) |\
 
884
                                   (((uint32) (uchar) (A)[1]) << 8) | \
 
885
                                   ((uint32) (uchar) (A)[0])) : \
 
886
                                  (((uint32) (uchar) (A)[2]) << 16) |\
 
887
                                  (((uint32) (uchar) (A)[1]) << 8) | \
 
888
                                  ((uint32) (uchar) (A)[0])))
 
889
#define sint4korr(A)    (*((long *) (A)))
 
890
#define uint2korr(A)    (*((uint16 *) (A)))
 
891
#if defined(HAVE_purify)
 
892
#define uint3korr(A)    (uint32) (((uint32) ((uchar) (A)[0])) +\
 
893
                                  (((uint32) ((uchar) (A)[1])) << 8) +\
 
894
                                  (((uint32) ((uchar) (A)[2])) << 16))
 
895
#else
 
896
/*
 
897
   ATTENTION !
 
898
   
 
899
    Please, note, uint3korr reads 4 bytes (not 3) !
 
900
    It means, that you have to provide enough allocated space !
 
901
*/
 
902
#define uint3korr(A)    (long) (*((unsigned int *) (A)) & 0xFFFFFF)
 
903
#endif /* HAVE_purify */
 
904
#define uint4korr(A)    (*((uint32 *) (A)))
 
905
#define uint5korr(A)    ((ulonglong)(((uint32) ((uchar) (A)[0])) +\
 
906
                                    (((uint32) ((uchar) (A)[1])) << 8) +\
 
907
                                    (((uint32) ((uchar) (A)[2])) << 16) +\
 
908
                                    (((uint32) ((uchar) (A)[3])) << 24)) +\
 
909
                                    (((ulonglong) ((uchar) (A)[4])) << 32))
 
910
#define uint6korr(A)    ((ulonglong)(((uint32)    ((uchar) (A)[0]))          + \
 
911
                                     (((uint32)    ((uchar) (A)[1])) << 8)   + \
 
912
                                     (((uint32)    ((uchar) (A)[2])) << 16)  + \
 
913
                                     (((uint32)    ((uchar) (A)[3])) << 24)) + \
 
914
                         (((ulonglong) ((uchar) (A)[4])) << 32) +       \
 
915
                         (((ulonglong) ((uchar) (A)[5])) << 40))
 
916
#define uint8korr(A)    (*((ulonglong *) (A)))
 
917
#define sint8korr(A)    (*((longlong *) (A)))
 
918
#define int2store(T,A)  *((uint16*) (T))= (uint16) (A)
 
919
#define int3store(T,A)  do { *(T)=  (uchar) ((A));\
 
920
                            *(T+1)=(uchar) (((uint) (A) >> 8));\
 
921
                            *(T+2)=(uchar) (((A) >> 16)); } while (0)
 
922
#define int4store(T,A)  *((long *) (T))= (long) (A)
 
923
#define int5store(T,A)  do { *(T)= (uchar)((A));\
 
924
                             *((T)+1)=(uchar) (((A) >> 8));\
 
925
                             *((T)+2)=(uchar) (((A) >> 16));\
 
926
                             *((T)+3)=(uchar) (((A) >> 24)); \
 
927
                             *((T)+4)=(uchar) (((A) >> 32)); } while(0)
 
928
#define int6store(T,A)  do { *(T)=    (uchar)((A));          \
 
929
                             *((T)+1)=(uchar) (((A) >> 8));  \
 
930
                             *((T)+2)=(uchar) (((A) >> 16)); \
 
931
                             *((T)+3)=(uchar) (((A) >> 24)); \
 
932
                             *((T)+4)=(uchar) (((A) >> 32)); \
 
933
                             *((T)+5)=(uchar) (((A) >> 40)); } while(0)
 
934
#define int8store(T,A)  *((ulonglong *) (T))= (ulonglong) (A)
 
935
 
 
936
typedef union {
 
937
  double v;
 
938
  long m[2];
 
939
} doubleget_union;
 
940
#define doubleget(V,M)  \
 
941
do { doubleget_union _tmp; \
 
942
     _tmp.m[0] = *((long*)(M)); \
 
943
     _tmp.m[1] = *(((long*) (M))+1); \
 
944
     (V) = _tmp.v; } while(0)
 
945
#define doublestore(T,V) do { *((long *) T) = ((doubleget_union *)&V)->m[0]; \
 
946
                             *(((long *) T)+1) = ((doubleget_union *)&V)->m[1]; \
 
947
                         } while (0)
 
948
#define float4get(V,M)   do { *((float *) &(V)) = *((float*) (M)); } while(0)
 
949
#define float8get(V,M)   doubleget((V),(M))
 
950
#define float4store(V,M) memcpy((uchar*) V,(uchar*) (&M),sizeof(float))
 
951
#define floatstore(T,V)  memcpy((uchar*)(T), (uchar*)(&V),sizeof(float))
 
952
#define floatget(V,M)    memcpy((uchar*) &V,(uchar*) (M),sizeof(float))
 
953
#define float8store(V,M) doublestore((V),(M))
 
954
#else
 
955
 
 
956
/*
 
957
  We're here if it's not a IA-32 architecture (Win32 and UNIX IA-32 defines
 
958
  were done before)
 
959
*/
 
960
#define sint2korr(A)    (int16) (((int16) ((uchar) (A)[0])) +\
 
961
                                 ((int16) ((int16) (A)[1]) << 8))
 
962
#define sint3korr(A)    ((int32) ((((uchar) (A)[2]) & 128) ? \
 
963
                                  (((uint32) 255L << 24) | \
 
964
                                   (((uint32) (uchar) (A)[2]) << 16) |\
 
965
                                   (((uint32) (uchar) (A)[1]) << 8) | \
 
966
                                   ((uint32) (uchar) (A)[0])) : \
 
967
                                  (((uint32) (uchar) (A)[2]) << 16) |\
 
968
                                  (((uint32) (uchar) (A)[1]) << 8) | \
 
969
                                  ((uint32) (uchar) (A)[0])))
 
970
#define sint4korr(A)    (int32) (((int32) ((uchar) (A)[0])) +\
 
971
                                (((int32) ((uchar) (A)[1]) << 8)) +\
 
972
                                (((int32) ((uchar) (A)[2]) << 16)) +\
 
973
                                (((int32) ((int16) (A)[3]) << 24)))
 
974
#define sint8korr(A)    (longlong) uint8korr(A)
 
975
#define uint2korr(A)    (uint16) (((uint16) ((uchar) (A)[0])) +\
 
976
                                  ((uint16) ((uchar) (A)[1]) << 8))
 
977
#define uint3korr(A)    (uint32) (((uint32) ((uchar) (A)[0])) +\
 
978
                                  (((uint32) ((uchar) (A)[1])) << 8) +\
 
979
                                  (((uint32) ((uchar) (A)[2])) << 16))
 
980
#define uint4korr(A)    (uint32) (((uint32) ((uchar) (A)[0])) +\
 
981
                                  (((uint32) ((uchar) (A)[1])) << 8) +\
 
982
                                  (((uint32) ((uchar) (A)[2])) << 16) +\
 
983
                                  (((uint32) ((uchar) (A)[3])) << 24))
 
984
#define uint5korr(A)    ((ulonglong)(((uint32) ((uchar) (A)[0])) +\
 
985
                                    (((uint32) ((uchar) (A)[1])) << 8) +\
 
986
                                    (((uint32) ((uchar) (A)[2])) << 16) +\
 
987
                                    (((uint32) ((uchar) (A)[3])) << 24)) +\
 
988
                                    (((ulonglong) ((uchar) (A)[4])) << 32))
 
989
#define uint6korr(A)    ((ulonglong)(((uint32)    ((uchar) (A)[0]))          + \
 
990
                                     (((uint32)    ((uchar) (A)[1])) << 8)   + \
 
991
                                     (((uint32)    ((uchar) (A)[2])) << 16)  + \
 
992
                                     (((uint32)    ((uchar) (A)[3])) << 24)) + \
 
993
                         (((ulonglong) ((uchar) (A)[4])) << 32) +       \
 
994
                         (((ulonglong) ((uchar) (A)[5])) << 40))
 
995
#define uint8korr(A)    ((ulonglong)(((uint32) ((uchar) (A)[0])) +\
 
996
                                    (((uint32) ((uchar) (A)[1])) << 8) +\
 
997
                                    (((uint32) ((uchar) (A)[2])) << 16) +\
 
998
                                    (((uint32) ((uchar) (A)[3])) << 24)) +\
 
999
                        (((ulonglong) (((uint32) ((uchar) (A)[4])) +\
 
1000
                                    (((uint32) ((uchar) (A)[5])) << 8) +\
 
1001
                                    (((uint32) ((uchar) (A)[6])) << 16) +\
 
1002
                                    (((uint32) ((uchar) (A)[7])) << 24))) <<\
 
1003
                                    32))
 
1004
#define int2store(T,A)       do { uint def_temp= (uint) (A) ;\
 
1005
                                  *((uchar*) (T))=  (uchar)(def_temp); \
 
1006
                                   *((uchar*) (T)+1)=(uchar)((def_temp >> 8)); \
 
1007
                             } while(0)
 
1008
#define int3store(T,A)       do { /*lint -save -e734 */\
 
1009
                                  *((uchar*)(T))=(uchar) ((A));\
 
1010
                                  *((uchar*) (T)+1)=(uchar) (((A) >> 8));\
 
1011
                                  *((uchar*)(T)+2)=(uchar) (((A) >> 16)); \
 
1012
                                  /*lint -restore */} while(0)
 
1013
#define int4store(T,A)       do { *((char *)(T))=(char) ((A));\
 
1014
                                  *(((char *)(T))+1)=(char) (((A) >> 8));\
 
1015
                                  *(((char *)(T))+2)=(char) (((A) >> 16));\
 
1016
                                  *(((char *)(T))+3)=(char) (((A) >> 24)); } while(0)
 
1017
#define int5store(T,A)       do { *((char *)(T))=     (char)((A));  \
 
1018
                                  *(((char *)(T))+1)= (char)(((A) >> 8)); \
 
1019
                                  *(((char *)(T))+2)= (char)(((A) >> 16)); \
 
1020
                                  *(((char *)(T))+3)= (char)(((A) >> 24)); \
 
1021
                                  *(((char *)(T))+4)= (char)(((A) >> 32)); \
 
1022
                                } while(0)
 
1023
#define int6store(T,A)       do { *((char *)(T))=     (char)((A)); \
 
1024
                                  *(((char *)(T))+1)= (char)(((A) >> 8)); \
 
1025
                                  *(((char *)(T))+2)= (char)(((A) >> 16)); \
 
1026
                                  *(((char *)(T))+3)= (char)(((A) >> 24)); \
 
1027
                                  *(((char *)(T))+4)= (char)(((A) >> 32)); \
 
1028
                                  *(((char *)(T))+5)= (char)(((A) >> 40)); \
 
1029
                                } while(0)
 
1030
#define int8store(T,A)       do { uint def_temp= (uint) (A), def_temp2= (uint) ((A) >> 32); \
 
1031
                                  int4store((T),def_temp); \
 
1032
                                  int4store((T+4),def_temp2); } while(0)
 
1033
#ifdef WORDS_BIGENDIAN
 
1034
#define float4store(T,A) do { *(T)= ((uchar *) &A)[3];\
 
1035
                              *((T)+1)=(char) ((uchar *) &A)[2];\
 
1036
                              *((T)+2)=(char) ((uchar *) &A)[1];\
 
1037
                              *((T)+3)=(char) ((uchar *) &A)[0]; } while(0)
 
1038
 
 
1039
#define float4get(V,M)   do { float def_temp;\
 
1040
                              ((uchar*) &def_temp)[0]=(M)[3];\
 
1041
                              ((uchar*) &def_temp)[1]=(M)[2];\
 
1042
                              ((uchar*) &def_temp)[2]=(M)[1];\
 
1043
                              ((uchar*) &def_temp)[3]=(M)[0];\
 
1044
                              (V)=def_temp; } while(0)
 
1045
#define float8store(T,V) do { *(T)= ((uchar *) &V)[7];\
 
1046
                              *((T)+1)=(char) ((uchar *) &V)[6];\
 
1047
                              *((T)+2)=(char) ((uchar *) &V)[5];\
 
1048
                              *((T)+3)=(char) ((uchar *) &V)[4];\
 
1049
                              *((T)+4)=(char) ((uchar *) &V)[3];\
 
1050
                              *((T)+5)=(char) ((uchar *) &V)[2];\
 
1051
                              *((T)+6)=(char) ((uchar *) &V)[1];\
 
1052
                              *((T)+7)=(char) ((uchar *) &V)[0]; } while(0)
 
1053
 
 
1054
#define float8get(V,M)   do { double def_temp;\
 
1055
                              ((uchar*) &def_temp)[0]=(M)[7];\
 
1056
                              ((uchar*) &def_temp)[1]=(M)[6];\
 
1057
                              ((uchar*) &def_temp)[2]=(M)[5];\
 
1058
                              ((uchar*) &def_temp)[3]=(M)[4];\
 
1059
                              ((uchar*) &def_temp)[4]=(M)[3];\
 
1060
                              ((uchar*) &def_temp)[5]=(M)[2];\
 
1061
                              ((uchar*) &def_temp)[6]=(M)[1];\
 
1062
                              ((uchar*) &def_temp)[7]=(M)[0];\
 
1063
                              (V) = def_temp; } while(0)
 
1064
#else
 
1065
#define float4get(V,M)   memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(float))
 
1066
#define float4store(V,M) memcpy_fixed((uchar*) V,(uchar*) (&M),sizeof(float))
 
1067
 
 
1068
#if defined(__FLOAT_WORD_ORDER) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN)
 
1069
#define doublestore(T,V) do { *(((char*)T)+0)=(char) ((uchar *) &V)[4];\
 
1070
                              *(((char*)T)+1)=(char) ((uchar *) &V)[5];\
 
1071
                              *(((char*)T)+2)=(char) ((uchar *) &V)[6];\
 
1072
                              *(((char*)T)+3)=(char) ((uchar *) &V)[7];\
 
1073
                              *(((char*)T)+4)=(char) ((uchar *) &V)[0];\
 
1074
                              *(((char*)T)+5)=(char) ((uchar *) &V)[1];\
 
1075
                              *(((char*)T)+6)=(char) ((uchar *) &V)[2];\
 
1076
                              *(((char*)T)+7)=(char) ((uchar *) &V)[3]; }\
 
1077
                         while(0)
 
1078
#define doubleget(V,M)   do { double def_temp;\
 
1079
                              ((uchar*) &def_temp)[0]=(M)[4];\
 
1080
                              ((uchar*) &def_temp)[1]=(M)[5];\
 
1081
                              ((uchar*) &def_temp)[2]=(M)[6];\
 
1082
                              ((uchar*) &def_temp)[3]=(M)[7];\
 
1083
                              ((uchar*) &def_temp)[4]=(M)[0];\
 
1084
                              ((uchar*) &def_temp)[5]=(M)[1];\
 
1085
                              ((uchar*) &def_temp)[6]=(M)[2];\
 
1086
                              ((uchar*) &def_temp)[7]=(M)[3];\
 
1087
                              (V) = def_temp; } while(0)
 
1088
#endif /* __FLOAT_WORD_ORDER */
 
1089
 
 
1090
#define float8get(V,M)   doubleget((V),(M))
 
1091
#define float8store(V,M) doublestore((V),(M))
 
1092
#endif /* WORDS_BIGENDIAN */
 
1093
 
 
1094
#endif /* __i386__ */
 
1095
 
 
1096
/*
 
1097
  Macro for reading 32-bit integer from network byte order (big-endian)
 
1098
  from unaligned memory location.
 
1099
*/
 
1100
#define int4net(A)        (int32) (((uint32) ((uchar) (A)[3]))        |\
 
1101
                                  (((uint32) ((uchar) (A)[2])) << 8)  |\
 
1102
                                  (((uint32) ((uchar) (A)[1])) << 16) |\
 
1103
                                  (((uint32) ((uchar) (A)[0])) << 24))
 
1104
/*
 
1105
  Define-funktions for reading and storing in machine format from/to
 
1106
  short/long to/from some place in memory V should be a (not
 
1107
  register) variable, M is a pointer to byte
 
1108
*/
 
1109
 
 
1110
#ifdef WORDS_BIGENDIAN
 
1111
 
 
1112
#define ushortget(V,M)  do { V = (uint16) (((uint16) ((uchar) (M)[1]))+\
 
1113
                                 ((uint16) ((uint16) (M)[0]) << 8)); } while(0)
 
1114
#define shortget(V,M)   do { V = (short) (((short) ((uchar) (M)[1]))+\
 
1115
                                 ((short) ((short) (M)[0]) << 8)); } while(0)
 
1116
#define longget(V,M)    do { int32 def_temp;\
 
1117
                             ((uchar*) &def_temp)[0]=(M)[0];\
 
1118
                             ((uchar*) &def_temp)[1]=(M)[1];\
 
1119
                             ((uchar*) &def_temp)[2]=(M)[2];\
 
1120
                             ((uchar*) &def_temp)[3]=(M)[3];\
 
1121
                             (V)=def_temp; } while(0)
 
1122
#define ulongget(V,M)   do { uint32 def_temp;\
 
1123
                            ((uchar*) &def_temp)[0]=(M)[0];\
 
1124
                            ((uchar*) &def_temp)[1]=(M)[1];\
 
1125
                            ((uchar*) &def_temp)[2]=(M)[2];\
 
1126
                            ((uchar*) &def_temp)[3]=(M)[3];\
 
1127
                            (V)=def_temp; } while(0)
 
1128
#define shortstore(T,A) do { uint def_temp=(uint) (A) ;\
 
1129
                             *(((char*)T)+1)=(char)(def_temp); \
 
1130
                             *(((char*)T)+0)=(char)(def_temp >> 8); } while(0)
 
1131
#define longstore(T,A)  do { *(((char*)T)+3)=((A));\
 
1132
                             *(((char*)T)+2)=(((A) >> 8));\
 
1133
                             *(((char*)T)+1)=(((A) >> 16));\
 
1134
                             *(((char*)T)+0)=(((A) >> 24)); } while(0)
 
1135
 
 
1136
#define floatget(V,M)    memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(float))
 
1137
#define floatstore(T,V)  memcpy_fixed((uchar*) (T),(uchar*)(&V),sizeof(float))
 
1138
#define doubleget(V,M)   memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(double))
 
1139
#define doublestore(T,V) memcpy_fixed((uchar*) (T),(uchar*) &V,sizeof(double))
 
1140
#define longlongget(V,M) memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(ulonglong))
 
1141
#define longlongstore(T,V) memcpy_fixed((uchar*) (T),(uchar*) &V,sizeof(ulonglong))
 
1142
 
 
1143
#else
 
1144
 
 
1145
#define ushortget(V,M)  do { V = uint2korr(M); } while(0)
 
1146
#define shortget(V,M)   do { V = sint2korr(M); } while(0)
 
1147
#define longget(V,M)    do { V = sint4korr(M); } while(0)
 
1148
#define ulongget(V,M)   do { V = uint4korr(M); } while(0)
 
1149
#define shortstore(T,V) int2store(T,V)
 
1150
#define longstore(T,V)  int4store(T,V)
 
1151
#ifndef floatstore
 
1152
#define floatstore(T,V)  memcpy_fixed((uchar*) (T),(uchar*) (&V),sizeof(float))
 
1153
#define floatget(V,M)    memcpy_fixed((uchar*) &V, (uchar*) (M), sizeof(float))
 
1154
#endif
 
1155
#ifndef doubleget
 
1156
#define doubleget(V,M)   memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(double))
 
1157
#define doublestore(T,V) memcpy_fixed((uchar*) (T),(uchar*) &V,sizeof(double))
 
1158
#endif /* doubleget */
 
1159
#define longlongget(V,M) memcpy_fixed((uchar*) &V,(uchar*) (M),sizeof(ulonglong))
 
1160
#define longlongstore(T,V) memcpy_fixed((uchar*) (T),(uchar*) &V,sizeof(ulonglong))
 
1161
 
 
1162
#endif /* WORDS_BIGENDIAN */
 
1163
 
 
1164
/* sprintf does not always return the number of bytes :- */
 
1165
#ifdef SPRINTF_RETURNS_INT
 
1166
#define my_sprintf(buff,args) sprintf args
 
1167
#else
 
1168
#ifdef SPRINTF_RETURNS_PTR
 
1169
#define my_sprintf(buff,args) ((int)(sprintf args - buff))
 
1170
#else
 
1171
#define my_sprintf(buff,args) ((ulong) sprintf args, (ulong) strlen(buff))
 
1172
#endif
 
1173
#endif
257
1174
 
258
1175
#if defined(HAVE_CHARSET_utf8mb3) || defined(HAVE_CHARSET_utf8mb4)
259
 
#define DRIZZLE_UNIVERSAL_CLIENT_CHARSET "utf8"
 
1176
#define MYSQL_UNIVERSAL_CLIENT_CHARSET "utf8"
260
1177
#else
261
 
#define DRIZZLE_UNIVERSAL_CLIENT_CHARSET DRIZZLE_DEFAULT_CHARSET_NAME
 
1178
#define MYSQL_UNIVERSAL_CLIENT_CHARSET MYSQL_DEFAULT_CHARSET_NAME
262
1179
#endif
263
1180
 
 
1181
#ifdef HAVE_DLOPEN
 
1182
#if defined(HAVE_DLFCN_H)
264
1183
#include <dlfcn.h>
 
1184
#endif
 
1185
#endif
265
1186
 
266
1187
/* FreeBSD 2.2.2 does not define RTLD_NOW) */
267
1188
#ifndef RTLD_NOW
268
1189
#define RTLD_NOW 1
269
1190
#endif
270
1191
 
271
 
#define cmax(a, b)       ((a) > (b) ? (a) : (b))
272
 
#define cmin(a, b)       ((a) < (b) ? (a) : (b))
 
1192
#ifndef HAVE_DLERROR
 
1193
#define dlerror() ""
 
1194
#endif
 
1195
 
 
1196
 
 
1197
/*
 
1198
 *  Include standard definitions of operator new and delete.
 
1199
 */
 
1200
#ifdef __cplusplus
 
1201
#include <new>
 
1202
#endif
273
1203
 
274
1204
/* Length of decimal number represented by INT32. */
275
1205
#define MY_INT32_NUM_DECIMAL_DIGITS 11
277
1207
/* Length of decimal number represented by INT64. */
278
1208
#define MY_INT64_NUM_DECIMAL_DIGITS 21
279
1209
 
 
1210
/* Define some useful general macros (should be done after all headers). */
 
1211
#if !defined(max)
 
1212
#define max(a, b)       ((a) > (b) ? (a) : (b))
 
1213
#define min(a, b)       ((a) < (b) ? (a) : (b))
 
1214
#endif  
280
1215
/*
281
1216
  Only Linux is known to need an explicit sync of the directory to make sure a
282
1217
  file creation/deletion/renaming in(from,to) this directory durable.
285
1220
#define NEED_EXPLICIT_SYNC_DIR 1
286
1221
#endif
287
1222
 
288
 
#include <libdrizzle/gettext.h>
289
 
 
290
 
#endif /* DRIZZLE_SERVER_GLOBAL_H */
 
1223
#endif /* my_global_h */