← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mystrings/m_string.h

  • Committer: Monty Taylor
  • Date: 2008-10-16 06:32:30 UTC
  • mto: (511.1.5 codestyle)
  • mto: This revision was merged to the branch mainline in revision 521.
  • Revision ID: monty@inaugust.com-20081016063230-4brxsra0qsmsg84q
Added -Wunused-macros.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mystrings/m_string.h
18
18
 
19
19
/*  This is needed for the definitions of strchr... on solaris */
20
20
 
 
21
 
21
22
#ifndef _m_string_h
22
23
#define _m_string_h
 
24
 
 
25
#include <drizzled/global.h>
 
26
 
23
27
#ifndef __USE_GNU
24
 
#define __USE_GNU                               /* We want to use stpcpy */
 
28
#define __USE_GNU                               /* We want to use my_stpcpy */
25
29
#endif
26
30
#if defined(HAVE_STRINGS_H)
27
31
#include <strings.h>
30
34
#include <string.h>
31
35
#endif
32
36
 
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
 
37
#include <stdlib.h>
 
38
#include <stddef.h>
 
39
#include <stdbool.h>
 
40
#include <assert.h>
 
41
#include <limits.h>
 
42
#include <ctype.h>
41
43
 
42
44
/*  This is needed for the definitions of memcpy... on solaris */
43
45
#if defined(HAVE_MEMORY_H) && !defined(__cplusplus)
44
46
#include <memory.h>
45
47
#endif
46
48
 
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
 
 
70
49
#if defined(__cplusplus)
71
50
extern "C" {
72
51
#endif
78
57
extern void *(*my_str_malloc)(size_t);
79
58
extern void (*my_str_free)(void *);
80
59
 
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)
 
60
char *my_stpncpy(register char *dst, register const char *src, size_t n);
 
61
char *my_stpcpy(register char *dst, register const char *src);
 
62
 
 
63
#define strmov_overlapp(A,B) my_stpcpy(A,B)
93
64
#define strmake_overlapp(A,B,C) strmake(A,B,C)
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,
 
65
 
 
66
extern void bmove_upp(unsigned char *dst,const unsigned char *src,size_t len);
 
67
 
 
68
extern  void bchange(unsigned char *dst,size_t old_len,const unsigned char *src,
138
69
                     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);
142
70
extern  char *strfield(char *src,int fields,int chars,int blanks,
143
71
                           int tabch);
144
72
extern  char *strfill(char * s,size_t len,char fill);
148
76
extern  char *strmake_overlapp(char *dst,const char *src, size_t length);
149
77
#endif
150
78
 
151
 
#ifndef strmov
152
 
extern  char *strmov(char *dst,const char *src);
153
 
#endif
154
 
extern  char *strnmov(char *dst,const char *src,size_t n);
155
79
extern  char *strsuff(const char *src,const char *suffix);
156
 
extern  char *strcont(const char *src,const char *set);
157
 
extern  char *strxcat _VARARGS((char *dst,const char *src, ...));
158
 
extern  char *strxmov _VARARGS((char *dst,const char *src, ...));
159
 
extern  char *strxcpy _VARARGS((char *dst,const char *src, ...));
160
 
extern  char *strxncat _VARARGS((char *dst,size_t len, const char *src, ...));
161
 
extern  char *strxnmov _VARARGS((char *dst,size_t len, const char *src, ...));
162
 
extern  char *strxncpy _VARARGS((char *dst,size_t len, const char *src, ...));
 
80
extern  char *strxcat(char *dst,const char *src, ...);
 
81
extern  char *strxmov(char *dst,const char *src, ...);
 
82
extern  char *strxcpy(char *dst,const char *src, ...);
 
83
extern  char *strxncat(char *dst,size_t len, const char *src, ...);
 
84
extern  char *strxnmov(char *dst,size_t len, const char *src, ...);
 
85
extern  char *strxncpy(char *dst,size_t len, const char *src, ...);
163
86
 
164
87
/* Prototypes of normal stringfunctions (with may ours) */
165
88
 
168
91
extern char *strchr(const char *, char);
169
92
extern char *strrchr(const char *, char);
170
93
extern char *strcpy(char *, const char *);
171
 
extern int strcmp(const char *, const char *);
172
 
#ifndef __GNUC__
173
 
extern size_t strlen(const char *);
174
 
#endif
175
 
#endif
176
 
#ifndef HAVE_STRNLEN
177
 
extern size_t strnlen(const char *s, size_t n);
178
94
#endif
179
95
 
180
96
#if !defined(__cplusplus)
181
97
#ifndef HAVE_STRPBRK
182
98
extern char *strpbrk(const char *, const char *);
183
99
#endif
184
 
#ifndef HAVE_STRSTR
185
 
extern char *strstr(const char *, const char *);
186
 
#endif
187
100
#endif
188
101
extern int is_prefix(const char *, const char *);
189
102
 
195
108
 
196
109
double my_strtod(const char *str, char **end, int *error);
197
110
double my_atof(const char *nptr);
198
 
size_t my_fcvt(double x, int precision, char *to, my_bool *error);
 
111
size_t my_fcvt(double x, int precision, char *to, bool *error);
199
112
size_t my_gcvt(double x, my_gcvt_arg_type type, int width, char *to,
200
 
               my_bool *error);
 
113
               bool *error);
201
114
 
202
115
#define NOT_FIXED_DEC 31
203
116
 
223
136
  (DBL_DIG + 2) significant digits + sign + "." + ("e-NNN" or
224
137
  MAX_DECPT_FOR_F_FORMAT zeros for cases when |x|<1 and the 'f' format is used).
225
138
*/
226
 
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + max(5, MAX_DECPT_FOR_F_FORMAT))
 
139
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + cmax(5, MAX_DECPT_FOR_F_FORMAT))
227
140
  
228
141
 
229
142
extern char *llstr(int64_t value,char *buff);
230
143
extern char *ullstr(int64_t value,char *buff);
231
 
#ifndef HAVE_STRTOUL
232
 
extern long strtol(const char *str, char **ptr, int base);
233
 
extern ulong strtoul(const char *str, char **ptr, int base);
234
 
#endif
235
144
 
236
 
extern char *int2str(long val, char *dst, int radix, int upcase);
237
 
extern char *int10_to_str(long val,char *dst,int radix);
 
145
extern char *int2str(int32_t val, char *dst, int radix, int upcase);
 
146
extern char *int10_to_str(int32_t val,char *dst,int radix);
238
147
extern char *str2int(const char *src,int radix,long lower,long upper,
239
148
                         long *val);
240
149
int64_t my_strtoll10(const char *nptr, char **endptr, int *error);
241
 
#if SIZEOF_LONG == SIZEOF_LONG_LONG
242
 
#define int64_t2str(A,B,C) int2str((A),(B),(C),1)
243
 
#define int64_t10_to_str(A,B,C) int10_to_str((A),(B),(C))
244
 
#undef strtoll
245
 
#define strtoll(A,B,C) strtol((A),(B),(C))
246
 
#define strtoull(A,B,C) strtoul((A),(B),(C))
247
 
#ifndef HAVE_STRTOULL
248
 
#define HAVE_STRTOULL
249
 
#endif
250
 
#ifndef HAVE_STRTOLL
251
 
#define HAVE_STRTOLL
252
 
#endif
253
 
#else
254
150
extern char *int64_t2str(int64_t val,char *dst,int radix);
255
151
extern char *int64_t10_to_str(int64_t val,char *dst,int radix);
256
 
#if (!defined(HAVE_STRTOULL) || defined(NO_STRTOLL_PROTO))
257
 
extern int64_t strtoll(const char *str, char **ptr, int base);
258
 
extern uint64_t strtoull(const char *str, char **ptr, int base);
259
 
#endif
260
 
#endif
261
152
 
262
153
 
263
154
#if defined(__cplusplus)
279
170
typedef struct st_mysql_lex_string LEX_STRING;
280
171
 
281
172
#define STRING_WITH_LEN(X) (X), ((size_t) (sizeof(X) - 1))
282
 
#define USTRING_WITH_LEN(X) ((uchar*) X), ((size_t) (sizeof(X) - 1))
 
173
#define USTRING_WITH_LEN(X) ((unsigned char*) X), ((size_t) (sizeof(X) - 1))
283
174
#define C_STRING_WITH_LEN(X) ((char *) (X)), ((size_t) (sizeof(X) - 1))
284
175
 
285
 
/* SPACE_INT is a word that contains only spaces */
286
 
#if SIZEOF_INT == 4
287
 
#define SPACE_INT 0x20202020
288
 
#elif SIZEOF_INT == 8
289
 
#define SPACE_INT 0x2020202020202020
290
 
#else
291
 
#error define the appropriate constant for a word full of spaces
292
 
#endif
293
 
 
294
176
/**
295
177
  Skip trailing space.
296
178
 
297
 
  On most systems reading memory in larger chunks (ideally equal to the size of
298
 
  the chinks that the machine physically reads from memory) causes fewer memory
299
 
  access loops and hence increased performance.
300
 
  This is why the 'int' type is used : it's closest to that (according to how
301
 
  it's defined in C).
302
 
  So when we determine the amount of whitespace at the end of a string we do
303
 
  the following :
304
 
    1. We divide the string into 3 zones :
305
 
      a) from the start of the string (__start) to the first multiple
306
 
        of sizeof(int)  (__start_words)
307
 
      b) from the end of the string (__end) to the last multiple of sizeof(int)
308
 
        (__end_words)
309
 
      c) a zone that is aligned to sizeof(int) and can be safely accessed
310
 
        through an int *
311
 
    2. We start comparing backwards from (c) char-by-char. If all we find is
312
 
       space then we continue
313
 
    3. If there are elements in zone (b) we compare them as unsigned ints to a
314
 
       int mask (SPACE_INT) consisting of all spaces
315
 
    4. Finally we compare the remaining part (a) of the string char by char.
316
 
       This covers for the last non-space unsigned int from 3. (if any)
317
 
 
318
 
   This algorithm works well for relatively larger strings, but it will slow
319
 
   the things down for smaller strings (because of the additional calculations
320
 
   and checks compared to the naive method). Thus the barrier of length 20
321
 
   is added.
322
 
 
323
179
   @param     ptr   pointer to the input string
324
180
   @param     len   the length of the string
325
181
   @return          the last non-space character
326
182
*/
327
183
 
328
 
static inline const uchar *skip_trailing_space(const uchar *ptr,size_t len)
 
184
static inline const unsigned char *
 
185
skip_trailing_space(const unsigned char *ptr,size_t len)
329
186
{
330
 
  const uchar *end= ptr + len;
331
 
 
332
 
  if (len > 20)
333
 
  {
334
 
    const uchar *end_words= (const uchar *)(intptr_t)
335
 
      (((uint64_t)(intptr_t)end) / SIZEOF_INT * SIZEOF_INT);
336
 
    const uchar *start_words= (const uchar *)(intptr_t)
337
 
       ((((uint64_t)(intptr_t)ptr) + SIZEOF_INT - 1) / SIZEOF_INT * SIZEOF_INT);
338
 
 
339
 
    DBUG_ASSERT(((uint64_t)(intptr_t)ptr) >= SIZEOF_INT);
340
 
    if (end_words > ptr)
341
 
    {
342
 
      while (end > end_words && end[-1] == 0x20)
343
 
        end--;
344
 
      if (end[-1] == 0x20 && start_words < end_words)
345
 
        while (end > start_words && ((unsigned *)end)[-1] == SPACE_INT)
346
 
          end -= SIZEOF_INT;
347
 
    }
348
 
  }
349
 
  while (end > ptr && end[-1] == 0x20)
350
 
    end--;
351
 
  return (end);
 
187
  const unsigned char *end= ptr + len;
 
188
 
 
189
  while (end > ptr && isspace(*--end))
 
190
    continue;
 
191
  return end+1;
352
192
}
353
193
 
354
194
#endif