← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/m_string.h

  • Committer: Brian Aker
  • Date: 2010-01-27 18:58:12 UTC
  • Revision ID: brian@gaz-20100127185812-n62n0vwetnx8jrjy
Remove dead code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/m_string.h
19
19
/*  This is needed for the definitions of strchr... on solaris */
20
20
 
21
21
 
22
 
#ifndef _m_string_h
23
 
#define _m_string_h
24
 
 
25
 
#include <drizzled/global.h>
 
22
#ifndef DRIZZLED_INTERNAL_M_STRING_H
 
23
#define DRIZZLED_INTERNAL_M_STRING_H
26
24
 
27
25
#ifndef __USE_GNU
28
 
#define __USE_GNU                               /* We want to use stpcpy */
 
26
#define __USE_GNU                               /* We want to use my_stpcpy */
29
27
#endif
30
28
#if defined(HAVE_STRINGS_H)
31
29
#include <strings.h>
34
32
#include <string.h>
35
33
#endif
36
34
 
 
35
#include <stdint.h>
37
36
#include <stdlib.h>
38
37
#include <stddef.h>
39
 
#include <stdbool.h>
40
38
#include <assert.h>
41
39
#include <limits.h>
 
40
#include <ctype.h>
42
41
 
43
42
/*  This is needed for the definitions of memcpy... on solaris */
44
43
#if defined(HAVE_MEMORY_H) && !defined(__cplusplus)
49
48
extern "C" {
50
49
#endif
51
50
 
52
 
/*
53
 
  my_str_malloc() and my_str_free() are assigned to implementations in
54
 
  strings/alloc.c, but can be overridden in the calling program.
55
 
 */
56
 
extern void *(*my_str_malloc)(size_t);
57
 
extern void (*my_str_free)(void *);
58
 
 
59
 
#define strmov_overlapp(A,B) stpcpy(A,B)
 
51
#define strmov_overlapp(A,B) my_stpcpy(A,B)
60
52
#define strmake_overlapp(A,B,C) strmake(A,B,C)
61
53
 
62
54
extern void bmove_upp(unsigned char *dst,const unsigned char *src,size_t len);
63
55
 
64
56
extern  void bchange(unsigned char *dst,size_t old_len,const unsigned char *src,
65
57
                     size_t new_len,size_t tot_len);
66
 
extern  char *strend(const char *s);
67
58
extern  char *strfield(char *src,int fields,int chars,int blanks,
68
59
                           int tabch);
69
60
extern  char *strfill(char * s,size_t len,char fill);
78
69
extern  char *strxmov(char *dst,const char *src, ...);
79
70
extern  char *strxcpy(char *dst,const char *src, ...);
80
71
extern  char *strxncat(char *dst,size_t len, const char *src, ...);
81
 
extern  char *strxnmov(char *dst,size_t len, const char *src, ...);
82
72
extern  char *strxncpy(char *dst,size_t len, const char *src, ...);
83
73
 
84
74
/* Prototypes of normal stringfunctions (with may ours) */
90
80
extern char *strcpy(char *, const char *);
91
81
#endif
92
82
 
93
 
#ifndef HAVE_STPNCPY
94
 
char *stpncpy(register char *dst, register const char *src, size_t n);
95
 
#endif
96
 
 
97
 
#if !defined(__cplusplus)
98
 
#ifndef HAVE_STRPBRK
99
 
extern char *strpbrk(const char *, const char *);
100
 
#endif
101
 
#ifndef HAVE_STRSTR
102
 
extern char *strstr(const char *, const char *);
103
 
#endif
104
 
#endif
105
 
extern int is_prefix(const char *, const char *);
106
 
 
107
83
/* Conversion routines */
108
84
typedef enum {
109
85
  MY_GCVT_ARG_FLOAT,
116
92
size_t my_gcvt(double x, my_gcvt_arg_type type, int width, char *to,
117
93
               bool *error);
118
94
 
119
 
#define NOT_FIXED_DEC 31
 
95
#define NOT_FIXED_DEC (uint8_t)31
120
96
 
121
97
/*
122
98
  The longest string my_fcvt can return is 311 + "precision" bytes.
140
116
  (DBL_DIG + 2) significant digits + sign + "." + ("e-NNN" or
141
117
  MAX_DECPT_FOR_F_FORMAT zeros for cases when |x|<1 and the 'f' format is used).
142
118
*/
143
 
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + max(5, MAX_DECPT_FOR_F_FORMAT))
144
 
  
 
119
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + cmax(5, MAX_DECPT_FOR_F_FORMAT))
 
120
 
145
121
 
146
122
extern char *llstr(int64_t value,char *buff);
147
123
extern char *ullstr(int64_t value,char *buff);
148
124
 
149
 
extern char *int2str(long val, char *dst, int radix, int upcase);
150
 
extern char *int10_to_str(long val,char *dst,int radix);
151
 
extern char *str2int(const char *src,int radix,long lower,long upper,
152
 
                         long *val);
 
125
extern char *int2str(int32_t val, char *dst, int radix, int upcase);
 
126
extern char *int10_to_str(int32_t val,char *dst,int radix);
153
127
int64_t my_strtoll10(const char *nptr, char **endptr, int *error);
154
 
#if SIZEOF_LONG == SIZEOF_LONG_LONG
155
 
#define int64_t2str(A,B,C) int2str((A),(B),(C),1)
156
 
#define int64_t10_to_str(A,B,C) int10_to_str((A),(B),(C))
157
 
#undef strtoll
158
 
#define strtoll(A,B,C) strtol((A),(B),(C))
159
 
#define strtoull(A,B,C) strtoul((A),(B),(C))
160
 
#ifndef HAVE_STRTOULL
161
 
#define HAVE_STRTOULL
162
 
#endif
163
 
#ifndef HAVE_STRTOLL
164
 
#define HAVE_STRTOLL
165
 
#endif
166
 
#else
167
128
extern char *int64_t2str(int64_t val,char *dst,int radix);
168
129
extern char *int64_t10_to_str(int64_t val,char *dst,int radix);
169
 
#if (!defined(HAVE_STRTOULL) || defined(NO_STRTOLL_PROTO))
170
 
extern int64_t strtoll(const char *str, char **ptr, int base);
171
 
extern uint64_t strtoull(const char *str, char **ptr, int base);
172
 
#endif
173
 
#endif
174
130
 
175
131
 
176
132
#if defined(__cplusplus)
177
133
}
178
134
#endif
179
135
 
180
 
/*
181
 
  LEX_STRING -- a pair of a C-string and its length.
182
 
*/
183
 
 
184
 
#ifndef _my_plugin_h
185
 
/* This definition must match the one given in mysql/plugin.h */
186
 
struct st_mysql_lex_string
187
 
{
188
 
  char *str;
189
 
  size_t length;
190
 
};
191
 
#endif
192
 
typedef struct st_mysql_lex_string LEX_STRING;
193
 
 
194
 
#define STRING_WITH_LEN(X) (X), ((size_t) (sizeof(X) - 1))
195
 
#define USTRING_WITH_LEN(X) ((unsigned char*) X), ((size_t) (sizeof(X) - 1))
196
 
#define C_STRING_WITH_LEN(X) ((char *) (X)), ((size_t) (sizeof(X) - 1))
197
 
 
198
 
/* SPACE_INT is a word that contains only spaces */
199
 
#if SIZEOF_INT == 4
200
 
#define SPACE_INT 0x20202020
201
 
#elif SIZEOF_INT == 8
202
 
#define SPACE_INT 0x2020202020202020
203
 
#else
204
 
#error define the appropriate constant for a word full of spaces
205
 
#endif
206
136
 
207
137
/**
208
138
  Skip trailing space.
209
139
 
210
 
  On most systems reading memory in larger chunks (ideally equal to the size of
211
 
  the chinks that the machine physically reads from memory) causes fewer memory
212
 
  access loops and hence increased performance.
213
 
  This is why the 'int' type is used : it's closest to that (according to how
214
 
  it's defined in C).
215
 
  So when we determine the amount of whitespace at the end of a string we do
216
 
  the following :
217
 
    1. We divide the string into 3 zones :
218
 
      a) from the start of the string (__start) to the first multiple
219
 
        of sizeof(int)  (__start_words)
220
 
      b) from the end of the string (__end) to the last multiple of sizeof(int)
221
 
        (__end_words)
222
 
      c) a zone that is aligned to sizeof(int) and can be safely accessed
223
 
        through an int *
224
 
    2. We start comparing backwards from (c) char-by-char. If all we find is
225
 
       space then we continue
226
 
    3. If there are elements in zone (b) we compare them as unsigned ints to a
227
 
       int mask (SPACE_INT) consisting of all spaces
228
 
    4. Finally we compare the remaining part (a) of the string char by char.
229
 
       This covers for the last non-space unsigned int from 3. (if any)
230
 
 
231
 
   This algorithm works well for relatively larger strings, but it will slow
232
 
   the things down for smaller strings (because of the additional calculations
233
 
   and checks compared to the naive method). Thus the barrier of length 20
234
 
   is added.
235
 
 
236
140
   @param     ptr   pointer to the input string
237
141
   @param     len   the length of the string
238
142
   @return          the last non-space character
239
143
*/
240
144
 
241
 
static inline const unsigned char *skip_trailing_space(const unsigned char *ptr,size_t len)
 
145
static inline const unsigned char *
 
146
skip_trailing_space(const unsigned char *ptr, size_t len)
242
147
{
243
148
  const unsigned char *end= ptr + len;
244
149
 
245
 
  if (len > 20)
246
 
  {
247
 
    const unsigned char *end_words= (const unsigned char *)(intptr_t)
248
 
      (((uint64_t)(intptr_t)end) / SIZEOF_INT * SIZEOF_INT);
249
 
    const unsigned char *start_words= (const unsigned char *)(intptr_t)
250
 
       ((((uint64_t)(intptr_t)ptr) + SIZEOF_INT - 1) / SIZEOF_INT * SIZEOF_INT);
251
 
 
252
 
    assert(((uint64_t)(intptr_t)ptr) >= SIZEOF_INT);
253
 
    if (end_words > ptr)
254
 
    {
255
 
      while (end > end_words && end[-1] == 0x20)
256
 
        end--;
257
 
      if (end[-1] == 0x20 && start_words < end_words)
258
 
        while (end > start_words && ((const unsigned *)end)[-1] == SPACE_INT)
259
 
          end -= SIZEOF_INT;
260
 
    }
261
 
  }
262
 
  while (end > ptr && end[-1] == 0x20)
263
 
    end--;
264
 
  return (end);
 
150
  while (end > ptr && isspace(*--end))
 
151
    continue;
 
152
  return end+1;
265
153
}
266
154
 
267
 
#endif
 
155
#endif /* DRIZZLED_INTERNAL_M_STRING_H */