← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/m_string.h

  • Committer: Brian Aker
  • Date: 2008-07-14 16:24:25 UTC
  • Revision ID: brian@tangent.org-20080714162425-juw3vw221gs9kysh
Cleanup around intptr_t

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/m_string.h
18
18
 
19
19
/*  This is needed for the definitions of strchr... on solaris */
20
20
 
21
 
 
22
21
#ifndef _m_string_h
23
22
#define _m_string_h
24
 
 
25
 
#include <drizzled/global.h>
26
 
 
27
23
#ifndef __USE_GNU
28
 
#define __USE_GNU                               /* We want to use my_stpcpy */
 
24
#define __USE_GNU                               /* We want to use stpcpy */
29
25
#endif
30
26
#if defined(HAVE_STRINGS_H)
31
27
#include <strings.h>
34
30
#include <string.h>
35
31
#endif
36
32
 
37
 
#include <stdlib.h>
38
 
#include <stddef.h>
39
 
#include <stdbool.h>
40
 
#include <assert.h>
41
 
#include <limits.h>
 
33
#ifdef _AIX
 
34
#undef HAVE_BCMP
 
35
#endif
 
36
 
 
37
/*  This is needed for the definitions of bzero... on solaris */
 
38
#if defined(HAVE_STRINGS_H)
 
39
#include <strings.h>
 
40
#endif
42
41
 
43
42
/*  This is needed for the definitions of memcpy... on solaris */
44
43
#if defined(HAVE_MEMORY_H) && !defined(__cplusplus)
45
44
#include <memory.h>
46
45
#endif
47
46
 
 
47
#if !defined(HAVE_MEMCPY) && !defined(HAVE_MEMMOVE)
 
48
# define memcpy(d, s, n)        bcopy ((s), (d), (n))
 
49
# define memset(A,C,B)          bfill((A),(B),(C))
 
50
# define memmove(d, s, n)       bmove ((d), (s), (n))
 
51
#elif defined(HAVE_MEMMOVE)
 
52
# define bmove(d, s, n)         memmove((d), (s), (n))
 
53
#else
 
54
# define memmove(d, s, n)       bmove((d), (s), (n)) /* our bmove */
 
55
#endif
 
56
 
 
57
/* Unixware 7 */
 
58
#if !defined(HAVE_BFILL)
 
59
# define bfill(A,B,C)           memset((A),(C),(B))
 
60
# define bmove_align(A,B,C)    memcpy((A),(B),(C))
 
61
#endif
 
62
 
 
63
#if !defined(HAVE_BCMP)
 
64
# define bcopy(s, d, n)         memcpy((d), (s), (n))
 
65
# define bcmp(A,B,C)            memcmp((A),(B),(C))
 
66
# define bzero(A,B)             memset((A),0,(B))
 
67
# define bmove_align(A,B,C)     memcpy((A),(B),(C))
 
68
#endif
 
69
 
48
70
#if defined(__cplusplus)
49
71
extern "C" {
50
72
#endif
56
78
extern void *(*my_str_malloc)(size_t);
57
79
extern void (*my_str_free)(void *);
58
80
 
59
 
char *my_stpncpy(register char *dst, register const char *src, size_t n);
60
 
char *my_stpcpy(register char *dst, register const char *src);
61
 
 
62
 
#define strmov_overlapp(A,B) my_stpcpy(A,B)
 
81
#if defined(HAVE_STPCPY)
 
82
#define strmov(A,B) stpcpy((A),(B))
 
83
#endif
 
84
 
 
85
/* Declared in int2str() */
 
86
extern char _dig_vec_upper[];
 
87
extern char _dig_vec_lower[];
 
88
 
 
89
#ifdef BAD_STRING_COMPILER
 
90
#define strmov(A,B)  (memccpy(A,B,0,INT_MAX)-1)
 
91
#else
 
92
#define strmov_overlapp(A,B) strmov(A,B)
63
93
#define strmake_overlapp(A,B,C) strmake(A,B,C)
64
 
 
65
 
extern void bmove_upp(unsigned char *dst,const unsigned char *src,size_t len);
66
 
 
67
 
extern  void bchange(unsigned char *dst,size_t old_len,const unsigned char *src,
 
94
#endif
 
95
 
 
96
#ifdef BAD_MEMCPY                       /* Problem with gcc on Alpha */
 
97
#define memcpy_fixed(A,B,C) bmove((A),(B),(C))
 
98
#else
 
99
#define memcpy_fixed(A,B,C) memcpy((A),(B),(C))
 
100
#endif
 
101
 
 
102
#if (!defined(USE_BMOVE512) || defined(HAVE_purify)) && !defined(bmove512)
 
103
#define bmove512(A,B,C) memcpy(A,B,C)
 
104
#endif
 
105
 
 
106
        /* Prototypes for string functions */
 
107
 
 
108
#if !defined(bfill) && !defined(HAVE_BFILL)
 
109
extern  void bfill(uchar *dst,size_t len,char fill);
 
110
#endif
 
111
 
 
112
#if !defined(bzero) && !defined(HAVE_BZERO)
 
113
extern  void bzero(uchar * dst,size_t len);
 
114
#endif
 
115
 
 
116
#if !defined(bcmp) && !defined(HAVE_BCMP)
 
117
extern  size_t bcmp(const uchar *s1,const uchar *s2,size_t len);
 
118
#endif
 
119
#ifdef HAVE_purify
 
120
extern  size_t my_bcmp(const uchar *s1,const uchar *s2,size_t len);
 
121
#undef bcmp
 
122
#define bcmp(A,B,C) my_bcmp((A),(B),(C))
 
123
#define bzero_if_purify(A,B) bzero(A,B)
 
124
#else
 
125
#define bzero_if_purify(A,B)
 
126
#endif /* HAVE_purify */
 
127
 
 
128
#ifndef bmove512
 
129
extern  void bmove512(uchar *dst,const uchar *src,size_t len);
 
130
#endif
 
131
 
 
132
#if !defined(HAVE_BMOVE) && !defined(bmove)
 
133
extern  void bmove(uuchar *dst, const uchar *src,size_t len);
 
134
#endif
 
135
 
 
136
extern  void bmove_upp(uchar *dst,const uchar *src,size_t len);
 
137
extern  void bchange(uchar *dst,size_t old_len,const uchar *src,
68
138
                     size_t new_len,size_t tot_len);
 
139
extern  void strappend(char *s,size_t len,char fill);
 
140
extern  char *strend(const char *s);
 
141
extern  char *strcend(const char *, char);
69
142
extern  char *strfield(char *src,int fields,int chars,int blanks,
70
143
                           int tabch);
71
144
extern  char *strfill(char * s,size_t len,char fill);
 
145
extern  size_t strinstr(const char *str,const char *search);
 
146
extern  size_t r_strinstr(const char *str, size_t from, const char *search);
72
147
extern  char *strkey(char *dst,char *head,char *tail,char *flags);
73
148
extern  char *strmake(char *dst,const char *src,size_t length);
74
149
#ifndef strmake_overlapp
75
150
extern  char *strmake_overlapp(char *dst,const char *src, size_t length);
76
151
#endif
77
152
 
 
153
#ifndef strmov
 
154
extern  char *strmov(char *dst,const char *src);
 
155
#endif
 
156
extern  char *strnmov(char *dst,const char *src,size_t n);
78
157
extern  char *strsuff(const char *src,const char *suffix);
79
 
extern  char *strxcat(char *dst,const char *src, ...);
80
 
extern  char *strxmov(char *dst,const char *src, ...);
81
 
extern  char *strxcpy(char *dst,const char *src, ...);
82
 
extern  char *strxncat(char *dst,size_t len, const char *src, ...);
83
 
extern  char *strxnmov(char *dst,size_t len, const char *src, ...);
84
 
extern  char *strxncpy(char *dst,size_t len, const char *src, ...);
 
158
extern  char *strcont(const char *src,const char *set);
 
159
extern  char *strxcat _VARARGS((char *dst,const char *src, ...));
 
160
extern  char *strxmov _VARARGS((char *dst,const char *src, ...));
 
161
extern  char *strxcpy _VARARGS((char *dst,const char *src, ...));
 
162
extern  char *strxncat _VARARGS((char *dst,size_t len, const char *src, ...));
 
163
extern  char *strxnmov _VARARGS((char *dst,size_t len, const char *src, ...));
 
164
extern  char *strxncpy _VARARGS((char *dst,size_t len, const char *src, ...));
85
165
 
86
166
/* Prototypes of normal stringfunctions (with may ours) */
87
167
 
90
170
extern char *strchr(const char *, char);
91
171
extern char *strrchr(const char *, char);
92
172
extern char *strcpy(char *, const char *);
 
173
extern int strcmp(const char *, const char *);
 
174
#ifndef __GNUC__
 
175
extern size_t strlen(const char *);
 
176
#endif
 
177
#endif
 
178
#ifndef HAVE_STRNLEN
 
179
extern size_t strnlen(const char *s, size_t n);
93
180
#endif
94
181
 
95
182
#if !defined(__cplusplus)
96
183
#ifndef HAVE_STRPBRK
97
184
extern char *strpbrk(const char *, const char *);
98
185
#endif
 
186
#ifndef HAVE_STRSTR
 
187
extern char *strstr(const char *, const char *);
 
188
#endif
99
189
#endif
100
190
extern int is_prefix(const char *, const char *);
101
191
 
107
197
 
108
198
double my_strtod(const char *str, char **end, int *error);
109
199
double my_atof(const char *nptr);
110
 
size_t my_fcvt(double x, int precision, char *to, bool *error);
 
200
size_t my_fcvt(double x, int precision, char *to, my_bool *error);
111
201
size_t my_gcvt(double x, my_gcvt_arg_type type, int width, char *to,
112
 
               bool *error);
 
202
               my_bool *error);
113
203
 
114
204
#define NOT_FIXED_DEC 31
115
205
 
135
225
  (DBL_DIG + 2) significant digits + sign + "." + ("e-NNN" or
136
226
  MAX_DECPT_FOR_F_FORMAT zeros for cases when |x|<1 and the 'f' format is used).
137
227
*/
138
 
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + cmax(5, MAX_DECPT_FOR_F_FORMAT))
 
228
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + max(5, MAX_DECPT_FOR_F_FORMAT))
139
229
  
140
230
 
141
231
extern char *llstr(int64_t value,char *buff);
142
232
extern char *ullstr(int64_t value,char *buff);
 
233
#ifndef HAVE_STRTOUL
 
234
extern long strtol(const char *str, char **ptr, int base);
 
235
extern ulong strtoul(const char *str, char **ptr, int base);
 
236
#endif
143
237
 
144
238
extern char *int2str(long val, char *dst, int radix, int upcase);
145
239
extern char *int10_to_str(long val,char *dst,int radix);
149
243
#if SIZEOF_LONG == SIZEOF_LONG_LONG
150
244
#define int64_t2str(A,B,C) int2str((A),(B),(C),1)
151
245
#define int64_t10_to_str(A,B,C) int10_to_str((A),(B),(C))
 
246
#undef strtoll
 
247
#define strtoll(A,B,C) strtol((A),(B),(C))
 
248
#define strtoull(A,B,C) strtoul((A),(B),(C))
 
249
#ifndef HAVE_STRTOULL
 
250
#define HAVE_STRTOULL
 
251
#endif
 
252
#ifndef HAVE_STRTOLL
 
253
#define HAVE_STRTOLL
 
254
#endif
152
255
#else
153
256
extern char *int64_t2str(int64_t val,char *dst,int radix);
154
257
extern char *int64_t10_to_str(int64_t val,char *dst,int radix);
 
258
#if (!defined(HAVE_STRTOULL) || defined(NO_STRTOLL_PROTO))
 
259
extern int64_t strtoll(const char *str, char **ptr, int base);
 
260
extern uint64_t strtoull(const char *str, char **ptr, int base);
 
261
#endif
155
262
#endif
156
263
 
157
264
 
174
281
typedef struct st_mysql_lex_string LEX_STRING;
175
282
 
176
283
#define STRING_WITH_LEN(X) (X), ((size_t) (sizeof(X) - 1))
177
 
#define USTRING_WITH_LEN(X) ((unsigned char*) X), ((size_t) (sizeof(X) - 1))
 
284
#define USTRING_WITH_LEN(X) ((uchar*) X), ((size_t) (sizeof(X) - 1))
178
285
#define C_STRING_WITH_LEN(X) ((char *) (X)), ((size_t) (sizeof(X) - 1))
179
286
 
180
287
/* SPACE_INT is a word that contains only spaces */
220
327
   @return          the last non-space character
221
328
*/
222
329
 
223
 
static inline const unsigned char *skip_trailing_space(const unsigned char *ptr,size_t len)
 
330
static inline const uchar *skip_trailing_space(const uchar *ptr,size_t len)
224
331
{
225
 
  const unsigned char *end= ptr + len;
 
332
  const uchar *end= ptr + len;
226
333
 
227
334
  if (len > 20)
228
335
  {
229
 
    const unsigned char *end_words= (const unsigned char *)(intptr_t)
 
336
    const uchar *end_words= (const uchar *)(intptr_t)
230
337
      (((uint64_t)(intptr_t)end) / SIZEOF_INT * SIZEOF_INT);
231
 
    const unsigned char *start_words= (const unsigned char *)(intptr_t)
 
338
    const uchar *start_words= (const uchar *)(intptr_t)
232
339
       ((((uint64_t)(intptr_t)ptr) + SIZEOF_INT - 1) / SIZEOF_INT * SIZEOF_INT);
233
340
 
234
 
    assert(((uint64_t)(intptr_t)ptr) >= SIZEOF_INT);
 
341
    DBUG_ASSERT(((uint64_t)(intptr_t)ptr) >= SIZEOF_INT);
235
342
    if (end_words > ptr)
236
343
    {
237
344
      while (end > end_words && end[-1] == 0x20)
238
345
        end--;
239
346
      if (end[-1] == 0x20 && start_words < end_words)
240
 
        while (end > start_words && ((const unsigned *)end)[-1] == SPACE_INT)
 
347
        while (end > start_words && ((unsigned *)end)[-1] == SPACE_INT)
241
348
          end -= SIZEOF_INT;
242
349
    }
243
350
  }