← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mystrings/m_string.h

  • Committer: Mark Atwood
  • Date: 2008-10-03 01:39:40 UTC
  • mto: This revision was merged to the branch mainline in revision 437.
  • Revision ID: mark@fallenpegasus.com-20081003013940-mvefjo725dltz41h
rename logging_noop to logging_query

Show diffs side-by-side

added added

removed removed

Lines of Context:
mystrings/m_string.h
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* There may be prolems include all of theese. Try to test in
17
17
   configure with ones are needed? */
18
18
 
19
 
 
20
 
 
21
 
#ifndef DRIZZLED_INTERNAL_M_STRING_H
22
 
#define DRIZZLED_INTERNAL_M_STRING_H
23
 
 
 
19
/*  This is needed for the definitions of strchr... on solaris */
 
20
 
 
21
 
 
22
#ifndef _m_string_h
 
23
#define _m_string_h
 
24
 
 
25
#include <drizzled/global.h>
 
26
 
 
27
#ifndef __USE_GNU
 
28
#define __USE_GNU                               /* We want to use stpcpy */
 
29
#endif
24
30
#if defined(HAVE_STRINGS_H)
25
31
#include <strings.h>
26
32
#endif
30
36
 
31
37
#include <stdlib.h>
32
38
#include <stddef.h>
33
 
#include <cassert>
 
39
#include <stdbool.h>
 
40
#include <assert.h>
34
41
#include <limits.h>
35
 
#include <ctype.h>
36
42
 
37
43
/*  This is needed for the definitions of memcpy... on solaris */
38
44
#if defined(HAVE_MEMORY_H) && !defined(__cplusplus)
39
45
#include <memory.h>
40
46
#endif
41
47
 
42
 
 
43
 
#include <drizzled/visibility.h>
44
 
 
45
 
namespace drizzled
46
 
{
47
 
namespace internal
48
 
{
 
48
#if defined(__cplusplus)
 
49
extern "C" {
 
50
#endif
 
51
 
 
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)
 
60
#define strmake_overlapp(A,B,C) strmake(A,B,C)
49
61
 
50
62
extern void bmove_upp(unsigned char *dst,const unsigned char *src,size_t len);
51
63
 
56
68
extern  char *strfill(char * s,size_t len,char fill);
57
69
extern  char *strkey(char *dst,char *head,char *tail,char *flags);
58
70
extern  char *strmake(char *dst,const char *src,size_t length);
 
71
#ifndef strmake_overlapp
 
72
extern  char *strmake_overlapp(char *dst,const char *src, size_t length);
 
73
#endif
59
74
 
60
75
extern  char *strsuff(const char *src,const char *suffix);
61
76
extern  char *strxcat(char *dst,const char *src, ...);
62
77
extern  char *strxmov(char *dst,const char *src, ...);
63
78
extern  char *strxcpy(char *dst,const char *src, ...);
64
79
extern  char *strxncat(char *dst,size_t len, const char *src, ...);
 
80
extern  char *strxnmov(char *dst,size_t len, const char *src, ...);
65
81
extern  char *strxncpy(char *dst,size_t len, const char *src, ...);
66
82
 
 
83
/* Prototypes of normal stringfunctions (with may ours) */
 
84
 
 
85
#ifdef WANT_STRING_PROTOTYPES
 
86
extern char *strcat(char *, const char *);
 
87
extern char *strchr(const char *, char);
 
88
extern char *strrchr(const char *, char);
 
89
extern char *strcpy(char *, const char *);
 
90
#endif
 
91
 
 
92
#ifndef HAVE_STPNCPY
 
93
char *stpncpy(register char *dst, register const char *src, size_t n);
 
94
#endif
 
95
 
 
96
#if !defined(__cplusplus)
 
97
#ifndef HAVE_STRPBRK
 
98
extern char *strpbrk(const char *, const char *);
 
99
#endif
 
100
#endif
 
101
extern int is_prefix(const char *, const char *);
 
102
 
67
103
/* Conversion routines */
68
104
typedef enum {
69
105
  MY_GCVT_ARG_FLOAT,
70
106
  MY_GCVT_ARG_DOUBLE
71
107
} my_gcvt_arg_type;
72
108
 
73
 
DRIZZLED_API double my_strtod(const char *str, char **end, int *error);
74
 
DRIZZLED_API double my_atof(const char *nptr);
75
 
DRIZZLED_API size_t my_fcvt(double x, int precision, char *to, bool *error);
76
 
DRIZZLED_API size_t my_gcvt(double x, my_gcvt_arg_type type, int width, char *to,
77
 
                            bool *error);
 
109
double my_strtod(const char *str, char **end, int *error);
 
110
double my_atof(const char *nptr);
 
111
size_t my_fcvt(double x, int precision, char *to, bool *error);
 
112
size_t my_gcvt(double x, my_gcvt_arg_type type, int width, char *to,
 
113
               bool *error);
78
114
 
79
 
#define NOT_FIXED_DEC (uint8_t)31
 
115
#define NOT_FIXED_DEC 31
80
116
 
81
117
/*
82
118
  The longest string my_fcvt can return is 311 + "precision" bytes.
100
136
  (DBL_DIG + 2) significant digits + sign + "." + ("e-NNN" or
101
137
  MAX_DECPT_FOR_F_FORMAT zeros for cases when |x|<1 and the 'f' format is used).
102
138
*/
103
 
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + cmax(5, MAX_DECPT_FOR_F_FORMAT))
104
 
 
 
139
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + max(5, MAX_DECPT_FOR_F_FORMAT))
 
140
  
105
141
 
106
142
extern char *llstr(int64_t value,char *buff);
107
143
extern char *ullstr(int64_t value,char *buff);
108
144
 
109
 
extern char *int2str(int32_t val, char *dst, int radix, int upcase);
110
 
extern char *int10_to_str(int32_t val,char *dst,int radix);
111
 
DRIZZLED_API int64_t my_strtoll10(const char *nptr, char **endptr, int *error);
112
 
DRIZZLED_API char *int64_t2str(int64_t val,char *dst,int radix);
113
 
DRIZZLED_API char *int64_t10_to_str(int64_t val,char *dst,int radix);
114
 
 
 
145
extern char *int2str(long val, char *dst, int radix, int upcase);
 
146
extern char *int10_to_str(long val,char *dst,int radix);
 
147
extern char *str2int(const char *src,int radix,long lower,long upper,
 
148
                         long *val);
 
149
int64_t my_strtoll10(const char *nptr, char **endptr, int *error);
 
150
#if SIZEOF_LONG == SIZEOF_LONG_LONG
 
151
#define int64_t2str(A,B,C) int2str((A),(B),(C),1)
 
152
#define int64_t10_to_str(A,B,C) int10_to_str((A),(B),(C))
 
153
#else
 
154
extern char *int64_t2str(int64_t val,char *dst,int radix);
 
155
extern char *int64_t10_to_str(int64_t val,char *dst,int radix);
 
156
#endif
 
157
 
 
158
 
 
159
#if defined(__cplusplus)
 
160
}
 
161
#endif
 
162
 
 
163
/*
 
164
  LEX_STRING -- a pair of a C-string and its length.
 
165
*/
 
166
 
 
167
#ifndef _my_plugin_h
 
168
/* This definition must match the one given in mysql/plugin.h */
 
169
struct st_mysql_lex_string
 
170
{
 
171
  char *str;
 
172
  size_t length;
 
173
};
 
174
#endif
 
175
typedef struct st_mysql_lex_string LEX_STRING;
 
176
 
 
177
#define STRING_WITH_LEN(X) (X), ((size_t) (sizeof(X) - 1))
 
178
#define USTRING_WITH_LEN(X) ((unsigned char*) X), ((size_t) (sizeof(X) - 1))
 
179
#define C_STRING_WITH_LEN(X) ((char *) (X)), ((size_t) (sizeof(X) - 1))
 
180
 
 
181
/* SPACE_INT is a word that contains only spaces */
 
182
#if SIZEOF_INT == 4
 
183
#define SPACE_INT 0x20202020
 
184
#elif SIZEOF_INT == 8
 
185
#define SPACE_INT 0x2020202020202020
 
186
#else
 
187
#error define the appropriate constant for a word full of spaces
 
188
#endif
115
189
 
116
190
/**
117
191
  Skip trailing space.
118
192
 
 
193
  On most systems reading memory in larger chunks (ideally equal to the size of
 
194
  the chinks that the machine physically reads from memory) causes fewer memory
 
195
  access loops and hence increased performance.
 
196
  This is why the 'int' type is used : it's closest to that (according to how
 
197
  it's defined in C).
 
198
  So when we determine the amount of whitespace at the end of a string we do
 
199
  the following :
 
200
    1. We divide the string into 3 zones :
 
201
      a) from the start of the string (__start) to the first multiple
 
202
        of sizeof(int)  (__start_words)
 
203
      b) from the end of the string (__end) to the last multiple of sizeof(int)
 
204
        (__end_words)
 
205
      c) a zone that is aligned to sizeof(int) and can be safely accessed
 
206
        through an int *
 
207
    2. We start comparing backwards from (c) char-by-char. If all we find is
 
208
       space then we continue
 
209
    3. If there are elements in zone (b) we compare them as unsigned ints to a
 
210
       int mask (SPACE_INT) consisting of all spaces
 
211
    4. Finally we compare the remaining part (a) of the string char by char.
 
212
       This covers for the last non-space unsigned int from 3. (if any)
 
213
 
 
214
   This algorithm works well for relatively larger strings, but it will slow
 
215
   the things down for smaller strings (because of the additional calculations
 
216
   and checks compared to the naive method). Thus the barrier of length 20
 
217
   is added.
 
218
 
119
219
   @param     ptr   pointer to the input string
120
220
   @param     len   the length of the string
121
221
   @return          the last non-space character
122
222
*/
123
223
 
124
 
static inline const unsigned char *
125
 
skip_trailing_space(const unsigned char *ptr, size_t len)
 
224
static inline const unsigned char *skip_trailing_space(const unsigned char *ptr,size_t len)
126
225
{
127
226
  const unsigned char *end= ptr + len;
128
227
 
129
 
  while (end > ptr && isspace(*--end))
130
 
    continue;
131
 
  return end+1;
 
228
  if (len > 20)
 
229
  {
 
230
    const unsigned char *end_words= (const unsigned char *)(intptr_t)
 
231
      (((uint64_t)(intptr_t)end) / SIZEOF_INT * SIZEOF_INT);
 
232
    const unsigned char *start_words= (const unsigned char *)(intptr_t)
 
233
       ((((uint64_t)(intptr_t)ptr) + SIZEOF_INT - 1) / SIZEOF_INT * SIZEOF_INT);
 
234
 
 
235
    assert(((uint64_t)(intptr_t)ptr) >= SIZEOF_INT);
 
236
    if (end_words > ptr)
 
237
    {
 
238
      while (end > end_words && end[-1] == 0x20)
 
239
        end--;
 
240
      if (end[-1] == 0x20 && start_words < end_words)
 
241
        while (end > start_words && ((const unsigned *)end)[-1] == SPACE_INT)
 
242
          end -= SIZEOF_INT;
 
243
    }
 
244
  }
 
245
  while (end > ptr && end[-1] == 0x20)
 
246
    end--;
 
247
  return (end);
132
248
}
133
249
 
134
 
} /* namespace internal */
135
 
} /* namespace drizzled */
136
 
 
137
 
#endif /* DRIZZLED_INTERNAL_M_STRING_H */
 
250
#endif