← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/charset.h

  • Committer: Muhammad Umair
  • Date: 2011-04-20 22:18:30 UTC
  • mto: (2291.1.1 drizzle-ga)
  • mto: This revision was merged to the branch mainline in revision 2293.
  • Revision ID: umair@remotedesk-20110420221830-51yvqpew2tp0idg8
https://launchpad.net/bugs/621859
Merged charset declarations of global_charset_info.h and charset_info.h into charset.h header file.

After that I needed to remove global_charset_info.h and charset_info.h header declarations from all the drizzle code base. I wrote a script 
that search for global_charset_info.h in all the source code files and replace it with charset.h if that file does not already have charset.h 
header declaration otherwise it just remove global_charset_info.h from that particular file. I wrote a smilar scrpt for replacing charset_info.h 
with charset.h. I then restructured charset.h in order to make it more structural. i.e All the extern declarations are consolidated together one 
after the other. Similar pattern has been followed for struct declarations and functions in the charset.h header file

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/charset.h
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
 
20
/*
 
21
  Header File that defines all the charset declarations being used in Drizzle source code
 
22
*/
 
23
 
20
24
#pragma once
21
25
 
 
26
#include <sys/types.h>
22
27
#include <cstddef>
 
28
#include <drizzled/visibility.h>
23
29
#include <drizzled/definitions.h>
24
30
 
25
 
#include <drizzled/visibility.h>
26
 
 
27
31
namespace drizzled
28
32
{
29
33
 
30
 
struct charset_info_st;
 
34
#define MY_CS_NAME_SIZE                 32
 
35
#define MY_CS_CTYPE_TABLE_SIZE          257
 
36
#define MY_CS_TO_LOWER_TABLE_SIZE       256
 
37
#define MY_CS_TO_UPPER_TABLE_SIZE       256
 
38
#define MY_CS_SORT_ORDER_TABLE_SIZE     256
 
39
#define MY_CS_TO_UNI_TABLE_SIZE         256
 
40
#define CHARSET_DIR     "charsets/"
 
41
#define my_wc_t unsigned long
 
42
/* wm_wc and wc_mb return codes */
 
43
#define MY_CS_ILSEQ     0     /* Wrong by sequence: wb_wc                   */
 
44
#define MY_CS_ILUNI     0     /* Cannot encode Unicode to charset: wc_mb    */
 
45
#define MY_CS_TOOSMALL  -101  /* Need at least one byte:    wc_mb and mb_wc */
 
46
#define MY_CS_TOOSMALL2 -102  /* Need at least two bytes:   wc_mb and mb_wc */
 
47
#define MY_CS_TOOSMALL3 -103  /* Need at least three bytes: wc_mb and mb_wc */
 
48
/* These following three are currently not really used */
 
49
#define MY_CS_TOOSMALL4 -104  /* Need at least 4 bytes: wc_mb and mb_wc */
 
50
#define MY_CS_TOOSMALL5 -105  /* Need at least 5 bytes: wc_mb and mb_wc */
 
51
#define MY_CS_TOOSMALL6 -106  /* Need at least 6 bytes: wc_mb and mb_wc */
 
52
#define MY_SEQ_INTTAIL  1
 
53
#define MY_SEQ_SPACES   2
 
54
#define MY_CS_COMPILED  1      /* compiled-in sets               */
 
55
#define MY_CS_CONFIG    2      /* sets that have a *.conf file   */
 
56
#define MY_CS_INDEX     4      /* sets listed in the Index file  */
 
57
#define MY_CS_LOADED    8      /* sets that are currently loaded */
 
58
#define MY_CS_BINSORT   16     /* if binary sort order           */
 
59
#define MY_CS_PRIMARY   32     /* if primary collation           */
 
60
#define MY_CS_STRNXFRM  64     /* if strnxfrm is used for sort   */
 
61
#define MY_CS_UNICODE   128    /* is a charset is full unicode   */
 
62
#define MY_CS_READY     256    /* if a charset is initialized    */
 
63
#define MY_CS_AVAILABLE 512    /* If either compiled-in or loaded*/
 
64
#define MY_CS_CSSORT    1024   /* if case sensitive sort order   */
 
65
#define MY_CS_HIDDEN    2048   /* don't display in SHOW          */
 
66
#define MY_CS_NONASCII  8192   /* if not ASCII-compatible        */
 
67
#define MY_CHARSET_UNDEFINED 0
 
68
/* Flags for strxfrm */
 
69
#define MY_STRXFRM_LEVEL1          0x00000001 /* for primary weights   */
 
70
#define MY_STRXFRM_LEVEL2          0x00000002 /* for secondary weights */
 
71
#define MY_STRXFRM_LEVEL3          0x00000004 /* for tertiary weights  */
 
72
#define MY_STRXFRM_LEVEL4          0x00000008 /* fourth level weights  */
 
73
#define MY_STRXFRM_LEVEL5          0x00000010 /* fifth level weights   */
 
74
#define MY_STRXFRM_LEVEL6          0x00000020 /* sixth level weights   */
 
75
#define MY_STRXFRM_LEVEL_ALL       0x0000003F /* Bit OR for the above six */
 
76
#define MY_STRXFRM_NLEVELS         6          /* Number of possible levels*/
 
77
#define MY_STRXFRM_PAD_WITH_SPACE  0x00000040 /* if pad result with spaces */
 
78
#define MY_STRXFRM_UNUSED_00000080 0x00000080 /* for future extensions     */
 
79
#define MY_STRXFRM_DESC_LEVEL1     0x00000100 /* if desc order for level1 */
 
80
#define MY_STRXFRM_DESC_LEVEL2     0x00000200 /* if desc order for level2 */
 
81
#define MY_STRXFRM_DESC_LEVEL3     0x00000300 /* if desc order for level3 */
 
82
#define MY_STRXFRM_DESC_LEVEL4     0x00000800 /* if desc order for level4 */
 
83
#define MY_STRXFRM_DESC_LEVEL5     0x00001000 /* if desc order for level5 */
 
84
#define MY_STRXFRM_DESC_LEVEL6     0x00002000 /* if desc order for level6 */
 
85
#define MY_STRXFRM_DESC_SHIFT      8
 
86
#define MY_STRXFRM_UNUSED_00004000 0x00004000 /* for future extensions     */
 
87
#define MY_STRXFRM_UNUSED_00008000 0x00008000 /* for future extensions     */
 
88
#define MY_STRXFRM_REVERSE_LEVEL1  0x00010000 /* if reverse order for level1 */
 
89
#define MY_STRXFRM_REVERSE_LEVEL2  0x00020000 /* if reverse order for level2 */
 
90
#define MY_STRXFRM_REVERSE_LEVEL3  0x00040000 /* if reverse order for level3 */
 
91
#define MY_STRXFRM_REVERSE_LEVEL4  0x00080000 /* if reverse order for level4 */
 
92
#define MY_STRXFRM_REVERSE_LEVEL5  0x00100000 /* if reverse order for level5 */
 
93
#define MY_STRXFRM_REVERSE_LEVEL6  0x00200000 /* if reverse order for level6 */
 
94
#define MY_STRXFRM_REVERSE_SHIFT   16
 
95
#define ILLEGAL_CHARSET_INFO_NUMBER (UINT32_MAX)
 
96
#define MY_UTF8MB4                 "utf8"
 
97
#define my_charset_utf8_general_ci ::drizzled::my_charset_utf8mb4_general_ci
 
98
#define my_charset_utf8_bin        ::drizzled::my_charset_utf8mb4_bin
 
99
#define _MY_U   01      /* Upper case */
 
100
#define _MY_L   02      /* Lower case */
 
101
#define _MY_NMR 04      /* Numeral (digit) */
 
102
#define _MY_SPC 010     /* Spacing character */
 
103
#define _MY_PNT 020     /* Punctuation */
 
104
#define _MY_CTR 040     /* Control character */
 
105
#define _MY_B   0100    /* Blank */
 
106
#define _MY_X   0200    /* heXadecimal digit */
 
107
 
 
108
/* Some typedef to make it easy for C++ to make function pointers */
 
109
typedef int (*my_charset_conv_mb_wc)(const struct charset_info_st * const, my_wc_t *,
 
110
                                     const unsigned char *, const unsigned char *);
 
111
typedef int (*my_charset_conv_wc_mb)(const struct charset_info_st * const, my_wc_t,
 
112
                                     unsigned char *, unsigned char *);
 
113
typedef size_t (*my_charset_conv_case)(const struct charset_info_st * const,
 
114
                                       char *, size_t, char *, size_t);
 
115
struct charset_info_st;
 
116
typedef struct unicase_info_st
 
117
{
 
118
  uint16_t toupper;
 
119
  uint16_t tolower;
 
120
  uint16_t sort;
 
121
} MY_UNICASE_INFO;
 
122
 
 
123
typedef struct uni_ctype_st
 
124
{
 
125
  unsigned char  pctype;
 
126
  unsigned char  *ctype;
 
127
} MY_UNI_CTYPE;
 
128
 
 
129
/* A helper function for "need at least n bytes" */
 
130
inline static int my_cs_toosmalln(int n)
 
131
{
 
132
  return -100-n;
 
133
}
 
134
 
 
135
typedef struct my_uni_idx_st
 
136
{
 
137
  uint16_t from;
 
138
  uint16_t to;
 
139
  unsigned char  *tab;
 
140
} MY_UNI_IDX;
 
141
 
 
142
typedef struct
 
143
{
 
144
  uint32_t beg;
 
145
  uint32_t end;
 
146
  uint32_t mb_len;
 
147
} my_match_t;
 
148
 
 
149
enum my_lex_states
 
150
{
 
151
  MY_LEX_START, MY_LEX_CHAR, MY_LEX_IDENT,
 
152
  MY_LEX_IDENT_SEP, MY_LEX_IDENT_START,
 
153
  MY_LEX_REAL, MY_LEX_HEX_NUMBER, MY_LEX_BIN_NUMBER,
 
154
  MY_LEX_CMP_OP, MY_LEX_LONG_CMP_OP, MY_LEX_STRING, MY_LEX_COMMENT, MY_LEX_END,
 
155
  MY_LEX_OPERATOR_OR_IDENT, MY_LEX_NUMBER_IDENT, MY_LEX_INT_OR_REAL,
 
156
  MY_LEX_REAL_OR_POINT, MY_LEX_BOOL, MY_LEX_EOL, MY_LEX_ESCAPE,
 
157
  MY_LEX_LONG_COMMENT, MY_LEX_END_LONG_COMMENT, MY_LEX_SEMICOLON,
 
158
  MY_LEX_SET_VAR, MY_LEX_USER_END, MY_LEX_HOSTNAME, MY_LEX_SKIP,
 
159
  MY_LEX_USER_VARIABLE_DELIMITER, MY_LEX_SYSTEM_VAR,
 
160
  MY_LEX_IDENT_OR_KEYWORD,
 
161
  MY_LEX_IDENT_OR_HEX, MY_LEX_IDENT_OR_BIN,
 
162
  MY_LEX_STRING_OR_DELIMITER
 
163
};
 
164
 
 
165
struct charset_info_st;
 
166
 
 
167
/* See strings/charset_info_st.txt for information about this structure  */
 
168
typedef struct my_collation_handler_st
 
169
{
 
170
  bool (*init)(struct charset_info_st *, unsigned char *(*alloc)(size_t));
 
171
  /* Collation routines */
 
172
  int     (*strnncoll)(const struct charset_info_st * const,
 
173
                       const unsigned char *, size_t, const unsigned char *, size_t, bool);
 
174
  int     (*strnncollsp)(const struct charset_info_st * const,
 
175
                         const unsigned char *, size_t, const unsigned char *, size_t,
 
176
                         bool diff_if_only_endspace_difference);
 
177
  size_t  (*strnxfrm)(const struct charset_info_st * const,
 
178
                      unsigned char *dst, size_t dstlen, uint32_t nweights,
 
179
                      const unsigned char *src, size_t srclen, uint32_t flags);
 
180
  size_t    (*strnxfrmlen)(const struct charset_info_st * const, size_t);
 
181
  bool (*like_range)(const struct charset_info_st * const,
 
182
                        const char *s, size_t s_length,
 
183
                        char escape, char w_one, char w_many,
 
184
                        size_t res_length,
 
185
                        char *min_str, char *max_str,
 
186
                        size_t *min_len, size_t *max_len);
 
187
  int     (*wildcmp)(const struct charset_info_st * const,
 
188
                     const char *str,const char *str_end,
 
189
                     const char *wildstr,const char *wildend,
 
190
                     int escape,int w_one, int w_many);
 
191
 
 
192
  int  (*strcasecmp)(const struct charset_info_st * const, const char *, const char *);
 
193
 
 
194
  uint32_t (*instr)(const struct charset_info_st * const,
 
195
                const char *b, size_t b_length,
 
196
                const char *s, size_t s_length,
 
197
                my_match_t *match, uint32_t nmatch);
 
198
 
 
199
  /* Hash calculation */
 
200
  void (*hash_sort)(const struct charset_info_st *cs, const unsigned char *key, size_t len,
 
201
                    uint32_t *nr1, uint32_t *nr2);
 
202
  bool (*propagate)(const struct charset_info_st *cs, const unsigned char *str, size_t len);
 
203
} MY_COLLATION_HANDLER;
 
204
 
 
205
/* See strings/charset_info_st.txt about information on this structure  */
 
206
typedef struct my_charset_handler_st
 
207
{
 
208
  bool (*init)(struct charset_info_st *, unsigned char *(*alloc)(size_t));
 
209
  /* Multibyte routines */
 
210
  uint32_t    (*ismbchar)(const struct charset_info_st * const, const char *, const char *);
 
211
  uint32_t    (*mbcharlen)(const struct charset_info_st * const, uint32_t c);
 
212
  size_t  (*numchars)(const struct charset_info_st * const, const char *b, const char *e);
 
213
  size_t  (*charpos)(const struct charset_info_st * const, const char *b, const char *e,
 
214
                     size_t pos);
 
215
  size_t  (*well_formed_len)(const struct charset_info_st * const,
 
216
                             const char *b,const char *e,
 
217
                             size_t nchars, int *error);
 
218
  size_t  (*lengthsp)(const struct charset_info_st * const, const char *ptr, size_t length);
 
219
  size_t  (*numcells)(const struct charset_info_st * const, const char *b, const char *e);
 
220
 
 
221
  /* Unicode conversion */
 
222
  my_charset_conv_mb_wc mb_wc;
 
223
  my_charset_conv_wc_mb wc_mb;
 
224
 
 
225
  /* CTYPE scanner */
 
226
  int (*ctype)(const struct charset_info_st *cs, int *ctype,
 
227
               const unsigned char *s, const unsigned char *e);
 
228
 
 
229
  /* Functions for case and sort conversion */
 
230
  size_t  (*caseup_str)(const struct charset_info_st * const, char *);
 
231
  size_t  (*casedn_str)(const struct charset_info_st * const, char *);
 
232
 
 
233
  my_charset_conv_case caseup;
 
234
  my_charset_conv_case casedn;
 
235
 
 
236
  /* Charset dependant snprintf() */
 
237
  size_t (*snprintf)(const struct charset_info_st * const, char *to, size_t n,
 
238
                     const char *fmt,
 
239
                     ...)
 
240
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 
241
                         __attribute__((format(printf, 4, 5)))
 
242
#endif
 
243
                         ;
 
244
  size_t (*long10_to_str)(const struct charset_info_st * const, char *to, size_t n,
 
245
                          int radix, long int val);
 
246
  size_t (*int64_t10_to_str)(const struct charset_info_st * const, char *to, size_t n,
 
247
                              int radix, int64_t val);
 
248
 
 
249
  void (*fill)(const struct charset_info_st * const, char *to, size_t len, int fill);
 
250
 
 
251
  /* String-to-number conversion routines */
 
252
  long        (*strntol)(const struct charset_info_st * const, const char *s, size_t l,
 
253
                         int base, char **e, int *err);
 
254
  unsigned long      (*strntoul)(const struct charset_info_st * const, const char *s, size_t l,
 
255
                         int base, char **e, int *err);
 
256
  int64_t   (*strntoll)(const struct charset_info_st * const, const char *s, size_t l,
 
257
                         int base, char **e, int *err);
 
258
  uint64_t (*strntoull)(const struct charset_info_st * const, const char *s, size_t l,
 
259
                         int base, char **e, int *err);
 
260
  double      (*strntod)(const struct charset_info_st * const, char *s, size_t l, char **e,
 
261
                         int *err);
 
262
  int64_t    (*strtoll10)(const struct charset_info_st *cs,
 
263
                           const char *nptr, char **endptr, int *error);
 
264
  uint64_t   (*strntoull10rnd)(const struct charset_info_st *cs,
 
265
                                const char *str, size_t length,
 
266
                                int unsigned_fl,
 
267
                                char **endptr, int *error);
 
268
  size_t        (*scan)(const struct charset_info_st * const, const char *b, const char *e,
 
269
                        int sq);
 
270
} MY_CHARSET_HANDLER;
 
271
 
 
272
 
 
273
/* See strings/charset_info_st.txt about information on this structure  */
 
274
struct charset_info_st
 
275
{
 
276
  uint32_t      number;
 
277
  uint32_t      primary_number;
 
278
  uint32_t      binary_number;
 
279
  uint32_t      state;
 
280
  const char *csname;
 
281
  const char *name;
 
282
  const char *comment;
 
283
  const char *tailoring;
 
284
  unsigned char    *ctype;
 
285
  unsigned char    *to_lower;
 
286
  unsigned char    *to_upper;
 
287
  unsigned char    *sort_order;
 
288
  uint16_t   *contractions;
 
289
  uint16_t   **sort_order_big;
 
290
  uint16_t      *tab_to_uni;
 
291
  MY_UNI_IDX  *tab_from_uni;
 
292
  MY_UNICASE_INFO **caseinfo;
 
293
  unsigned char     *state_map;
 
294
  unsigned char     *ident_map;
 
295
  uint32_t      strxfrm_multiply;
 
296
  unsigned char     caseup_multiply;
 
297
  unsigned char     casedn_multiply;
 
298
  uint32_t      mbminlen;
 
299
  uint32_t      mbmaxlen;
 
300
  uint16_t    min_sort_char;
 
301
  uint16_t    max_sort_char; /* For LIKE optimization */
 
302
  unsigned char     pad_char;
 
303
  bool   escape_with_backslash_is_dangerous;
 
304
  unsigned char     levels_for_compare;
 
305
  unsigned char     levels_for_order;
 
306
 
 
307
  MY_CHARSET_HANDLER *cset;
 
308
  MY_COLLATION_HANDLER *coll;
 
309
 
 
310
};
31
311
 
32
312
extern DRIZZLED_API charset_info_st *all_charsets[256];
33
313
extern charset_info_st compiled_charsets[];
34
 
 
35
314
extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
36
315
extern uint32_t get_collation_number(const char *name);
37
316
extern const char *get_charset_name(uint32_t cs_number);
38
 
 
39
 
DRIZZLED_API const charset_info_st *get_charset(uint32_t cs_number);
40
 
DRIZZLED_API const charset_info_st *get_charset_by_name(const char *cs_name);
41
 
DRIZZLED_API const charset_info_st *get_charset_by_csname(const char *cs_name, uint32_t cs_flags);
42
 
 
43
317
extern bool resolve_charset(const char *cs_name,
44
318
                            const charset_info_st *default_cs,
45
319
                            const charset_info_st **cs);
46
320
extern bool resolve_collation(const char *cl_name,
47
321
                             const charset_info_st *default_cl,
48
322
                             const charset_info_st **cl);
49
 
 
50
323
extern void free_charsets(void);
51
324
extern char *get_charsets_dir(char *buf);
52
325
extern bool my_charset_same(const charset_info_st *cs1, const charset_info_st *cs2);
58
331
extern size_t escape_quotes_for_drizzle(const charset_info_st *charset_info,
59
332
                                        char *to, size_t to_length,
60
333
                                        const char *from, size_t length);
 
334
extern DRIZZLED_API const charset_info_st *default_charset_info;
 
335
extern DRIZZLED_API const charset_info_st *system_charset_info;
 
336
extern const charset_info_st *files_charset_info;
 
337
extern const charset_info_st *table_alias_charset;
 
338
extern MY_UNICASE_INFO *my_unicase_default[256];
 
339
extern MY_UNICASE_INFO *my_unicase_turkish[256];
 
340
extern MY_UNI_CTYPE my_uni_ctype[256];
 
341
extern MY_COLLATION_HANDLER my_collation_mb_bin_handler;
 
342
extern MY_COLLATION_HANDLER my_collation_8bit_simple_ci_handler;
 
343
extern MY_COLLATION_HANDLER my_collation_ucs2_uca_handler;
 
344
extern DRIZZLED_API charset_info_st my_charset_bin;
 
345
extern DRIZZLED_API charset_info_st my_charset_utf8mb4_bin;
 
346
extern DRIZZLED_API charset_info_st my_charset_utf8mb4_general_ci;
 
347
extern DRIZZLED_API charset_info_st my_charset_utf8mb4_unicode_ci;
 
348
size_t my_strnxfrmlen_simple(const charset_info_st * const, size_t);
 
349
extern int  my_strnncollsp_simple(const charset_info_st * const, const unsigned char *, size_t,
 
350
                                  const unsigned char *, size_t,
 
351
                                  bool diff_if_only_endspace_difference);
 
352
extern size_t my_lengthsp_8bit(const charset_info_st * const cs, const char *ptr, size_t length);
 
353
extern uint32_t my_instr_simple(const charset_info_st * const,
 
354
                            const char *b, size_t b_length,
 
355
                            const char *s, size_t s_length,
 
356
                            my_match_t *match, uint32_t nmatch);
 
357
extern MY_CHARSET_HANDLER my_charset_8bit_handler;
 
358
extern MY_CHARSET_HANDLER my_charset_ucs2_handler;
 
359
extern size_t my_caseup_str_mb(const charset_info_st * const, char *);
 
360
extern size_t my_casedn_str_mb(const charset_info_st * const, char *);
 
361
extern size_t my_caseup_mb(const charset_info_st * const, char *src, size_t srclen,
 
362
                                         char *dst, size_t dstlen);
 
363
extern size_t my_casedn_mb(const charset_info_st * const, char *src, size_t srclen,
 
364
                                         char *dst, size_t dstlen);
 
365
extern int my_strcasecmp_mb(const charset_info_st * const  cs, const char *s, const char *t);
 
366
extern bool my_parse_charset_xml(const char *bug, size_t len,
 
367
                                    int (*add)(charset_info_st *cs));
 
368
 
 
369
DRIZZLED_API const charset_info_st *get_charset(uint32_t cs_number);
 
370
DRIZZLED_API const charset_info_st *get_charset_by_name(const char *cs_name);
 
371
DRIZZLED_API const charset_info_st *get_charset_by_csname(const char *cs_name, uint32_t cs_flags);
 
372
 
 
373
/* Functions for 8bit */
 
374
int my_mb_ctype_8bit(const charset_info_st * const,int *, const unsigned char *,const unsigned char *);
 
375
int my_mb_ctype_mb(const charset_info_st * const,int *, const unsigned char *,const unsigned char *);
 
376
 
 
377
size_t my_scan_8bit(const charset_info_st * const cs, const char *b, const char *e, int sq);
 
378
 
 
379
size_t my_snprintf_8bit(const charset_info_st * const, char *to, size_t n,
 
380
                        const char *fmt, ...)
 
381
  __attribute__((format(printf, 4, 5)));
 
382
 
 
383
long       my_strntol_8bit(const charset_info_st * const, const char *s, size_t l, int base,
 
384
                           char **e, int *err);
 
385
unsigned long      my_strntoul_8bit(const charset_info_st * const, const char *s, size_t l, int base,
 
386
                            char **e, int *err);
 
387
int64_t   my_strntoll_8bit(const charset_info_st * const, const char *s, size_t l, int base,
 
388
                            char **e, int *err);
 
389
uint64_t my_strntoull_8bit(const charset_info_st * const, const char *s, size_t l, int base,
 
390
                            char **e, int *err);
 
391
double      my_strntod_8bit(const charset_info_st * const, char *s, size_t l,char **e,
 
392
                            int *err);
 
393
size_t my_long10_to_str_8bit(const charset_info_st * const, char *to, size_t l, int radix,
 
394
                             long int val);
 
395
size_t my_int64_t10_to_str_8bit(const charset_info_st * const, char *to, size_t l, int radix,
 
396
                                 int64_t val);
 
397
int64_t my_strtoll10_8bit(const charset_info_st * const cs,
 
398
                           const char *nptr, char **endptr, int *error);
 
399
int64_t my_strtoll10_ucs2(charset_info_st *cs,
 
400
                           const char *nptr, char **endptr, int *error);
 
401
 
 
402
uint64_t my_strntoull10rnd_8bit(const charset_info_st * const cs,
 
403
                                 const char *str, size_t length, int
 
404
                                 unsigned_fl, char **endptr, int *error);
 
405
uint64_t my_strntoull10rnd_ucs2(charset_info_st *cs,
 
406
                                 const char *str, size_t length,
 
407
                                 int unsigned_fl, char **endptr, int *error);
 
408
 
 
409
void my_fill_8bit(const charset_info_st * const cs, char* to, size_t l, int fill);
 
410
 
 
411
bool  my_like_range_simple(const charset_info_st * const cs,
 
412
                              const char *ptr, size_t ptr_length,
 
413
                              char escape, char w_one, char w_many,
 
414
                              size_t res_length,
 
415
                              char *min_str, char *max_str,
 
416
                              size_t *min_length, size_t *max_length);
 
417
 
 
418
bool  my_like_range_mb(const charset_info_st * const cs,
 
419
                          const char *ptr, size_t ptr_length,
 
420
                          char escape, char w_one, char w_many,
 
421
                          size_t res_length,
 
422
                          char *min_str, char *max_str,
 
423
                          size_t *min_length, size_t *max_length);
 
424
 
 
425
bool  my_like_range_ucs2(const charset_info_st * const cs,
 
426
                            const char *ptr, size_t ptr_length,
 
427
                            char escape, char w_one, char w_many,
 
428
                            size_t res_length,
 
429
                            char *min_str, char *max_str,
 
430
                            size_t *min_length, size_t *max_length);
 
431
 
 
432
bool  my_like_range_utf16(const charset_info_st * const cs,
 
433
                             const char *ptr, size_t ptr_length,
 
434
                             char escape, char w_one, char w_many,
 
435
                             size_t res_length,
 
436
                             char *min_str, char *max_str,
 
437
                             size_t *min_length, size_t *max_length);
 
438
 
 
439
bool  my_like_range_utf32(const charset_info_st * const cs,
 
440
                             const char *ptr, size_t ptr_length,
 
441
                             char escape, char w_one, char w_many,
 
442
                             size_t res_length,
 
443
                             char *min_str, char *max_str,
 
444
                             size_t *min_length, size_t *max_length);
 
445
 
 
446
 
 
447
int my_wildcmp_8bit(const charset_info_st * const,
 
448
                    const char *str,const char *str_end,
 
449
                    const char *wildstr,const char *wildend,
 
450
                    int escape, int w_one, int w_many);
 
451
 
 
452
int my_wildcmp_bin(const charset_info_st * const,
 
453
                   const char *str,const char *str_end,
 
454
                   const char *wildstr,const char *wildend,
 
455
                   int escape, int w_one, int w_many);
 
456
 
 
457
size_t my_numchars_8bit(const charset_info_st * const, const char *b, const char *e);
 
458
size_t my_numcells_8bit(const charset_info_st * const, const char *b, const char *e);
 
459
size_t my_charpos_8bit(const charset_info_st * const, const char *b, const char *e, size_t pos);
 
460
size_t my_well_formed_len_8bit(const charset_info_st * const, const char *b, const char *e,
 
461
                             size_t pos, int *error);
 
462
typedef unsigned char *(*cs_alloc_func)(size_t);
 
463
bool my_coll_init_simple(charset_info_st *cs, cs_alloc_func alloc);
 
464
bool my_cset_init_8bit(charset_info_st *cs, cs_alloc_func alloc);
 
465
uint32_t my_mbcharlen_8bit(const charset_info_st * const, uint32_t c);
 
466
 
 
467
/* Functions for multibyte charsets */
 
468
int my_wildcmp_mb(const charset_info_st * const,
 
469
                  const char *str,const char *str_end,
 
470
                  const char *wildstr,const char *wildend,
 
471
                  int escape, int w_one, int w_many);
 
472
size_t my_numchars_mb(const charset_info_st * const, const char *b, const char *e);
 
473
size_t my_numcells_mb(const charset_info_st * const, const char *b, const char *e);
 
474
size_t my_charpos_mb(const charset_info_st * const, const char *b, const char *e, size_t pos);
 
475
size_t my_well_formed_len_mb(const charset_info_st * const, const char *b, const char *e,
 
476
                             size_t pos, int *error);
 
477
uint32_t my_instr_mb(const charset_info_st * const,
 
478
                 const char *b, size_t b_length,
 
479
                 const char *s, size_t s_length,
 
480
                 my_match_t *match, uint32_t nmatch);
 
481
 
 
482
int my_strnncoll_mb_bin(const charset_info_st * const  cs,
 
483
                        const unsigned char *s, size_t slen,
 
484
                        const unsigned char *t, size_t tlen,
 
485
                        bool t_is_prefix);
 
486
 
 
487
int my_strnncollsp_mb_bin(const charset_info_st * const cs,
 
488
                          const unsigned char *a, size_t a_length,
 
489
                          const unsigned char *b, size_t b_length,
 
490
                          bool diff_if_only_endspace_difference);
 
491
 
 
492
int my_wildcmp_mb_bin(const charset_info_st * const cs,
 
493
                      const char *str,const char *str_end,
 
494
                      const char *wildstr,const char *wildend,
 
495
                      int escape, int w_one, int w_many);
 
496
 
 
497
int my_strcasecmp_mb_bin(const charset_info_st * const, const char *s, const char *t);
 
498
 
 
499
void my_hash_sort_mb_bin(const charset_info_st * const,
 
500
                         const unsigned char *key, size_t len, uint32_t *nr1, uint32_t *nr2);
 
501
 
 
502
size_t my_strnxfrm_mb(const charset_info_st * const,
 
503
                      unsigned char *dst, size_t dstlen, uint32_t nweights,
 
504
                      const unsigned char *src, size_t srclen, uint32_t flags);
 
505
 
 
506
int my_wildcmp_unicode(const charset_info_st * const cs,
 
507
                       const char *str, const char *str_end,
 
508
                       const char *wildstr, const char *wildend,
 
509
                       int escape, int w_one, int w_many,
 
510
                       MY_UNICASE_INFO **weights);
 
511
 
 
512
bool my_propagate_simple(const charset_info_st * const cs, const unsigned char *str, size_t len);
 
513
bool my_propagate_complex(const charset_info_st * const cs, const unsigned char *str, size_t len);
 
514
 
 
515
 
 
516
uint32_t my_strxfrm_flag_normalize(uint32_t flags, uint32_t nlevels);
 
517
void my_strxfrm_desc_and_reverse(unsigned char *str, unsigned char *strend,
 
518
                                 uint32_t flags, uint32_t level);
 
519
size_t my_strxfrm_pad_desc_and_reverse(const charset_info_st * const cs,
 
520
                                       unsigned char *str, unsigned char *frmend, unsigned char *strend,
 
521
                                       uint32_t nweights, uint32_t flags, uint32_t level);
 
522
 
 
523
bool my_charset_is_ascii_compatible(const charset_info_st * const cs);
 
524
 
 
525
/*
 
526
  Compare 0-terminated UTF8 strings.
 
527
 
 
528
  SYNOPSIS
 
529
    my_strcasecmp_utf8mb3()
 
530
    cs                  character set handler
 
531
    s                   First 0-terminated string to compare
 
532
    t                   Second 0-terminated string to compare
 
533
 
 
534
  IMPLEMENTATION
 
535
 
 
536
  RETURN
 
537
    - negative number if s < t
 
538
    - positive number if s > t
 
539
    - 0 is the strings are equal
 
540
*/
 
541
int my_wc_mb_filename(const charset_info_st * const,
 
542
                  my_wc_t wc, unsigned char *s, unsigned char *e);
 
543
 
 
544
int my_mb_wc_filename(const charset_info_st * const,
 
545
                  my_wc_t *pwc, const unsigned char *s, const unsigned char *e);
 
546
 
 
547
 
 
548
unsigned int my_ismbchar_utf8mb4(const charset_info_st * const cs, const char *b, const char *e);
 
549
unsigned int my_mbcharlen_utf8mb4(const charset_info_st * const, uint32_t c);
 
550
 
 
551
size_t my_strnxfrmlen_utf8mb4(const charset_info_st * const, size_t len);
 
552
size_t
 
553
my_strnxfrm_utf8mb4(const charset_info_st * const cs,
 
554
                    unsigned char *dst, size_t dstlen, uint32_t nweights,
 
555
                    const unsigned char *src, size_t srclen, uint32_t flags);
 
556
 
 
557
int my_wildcmp_utf8mb4(const charset_info_st * const cs,
 
558
                   const char *str, const char *strend,
 
559
                   const char *wildstr, const char *wildend,
 
560
                   int escape, int w_one, int w_many);
 
561
int my_strnncollsp_utf8mb4(const charset_info_st * const cs,
 
562
                       const unsigned char *s, size_t slen,
 
563
                       const unsigned char *t, size_t tlen,
 
564
                       bool diff_if_only_endspace_difference);
 
565
int my_strcasecmp_utf8mb4(const charset_info_st * const cs,
 
566
                          const char *s, const char *t);
 
567
 
 
568
int my_strnncoll_utf8mb4(const charset_info_st * const cs,
 
569
                     const unsigned char *s, size_t slen,
 
570
                     const unsigned char *t, size_t tlen,
 
571
                     bool t_is_prefix);
 
572
 
 
573
int my_mb_wc_utf8mb4(const charset_info_st * const cs,
 
574
                 my_wc_t * pwc, const unsigned char *s, const unsigned char *e);
 
575
 
 
576
int my_wc_mb_utf8mb4(const charset_info_st * const cs,
 
577
                 my_wc_t wc, unsigned char *r, unsigned char *e);
 
578
 
 
579
size_t my_caseup_str_utf8mb4(const charset_info_st * const cs, char *src);
 
580
size_t my_casedn_str_utf8mb4(const charset_info_st * const cs, char *src);
 
581
 
 
582
size_t my_caseup_utf8mb4(const charset_info_st * const cs, char *src, size_t srclen,
 
583
                  char *dst, size_t dstlen);
 
584
size_t my_casedn_utf8mb4(const charset_info_st * const cs,
 
585
                  char *src, size_t srclen,
 
586
                  char *dst, size_t dstlen);
 
587
 
 
588
 
 
589
bool my_coll_init_uca(charset_info_st *cs, cs_alloc_func alloc);
 
590
 
 
591
int my_strnncoll_any_uca(const charset_info_st * const cs,
 
592
                         const unsigned char *s, size_t slen,
 
593
                         const unsigned char *t, size_t tlen,
 
594
                         bool t_is_prefix);
 
595
 
 
596
int my_strnncollsp_any_uca(const charset_info_st * const cs,
 
597
                           const unsigned char *s, size_t slen,
 
598
                           const unsigned char *t, size_t tlen,
 
599
                           bool diff_if_only_endspace_difference);
 
600
 
 
601
void my_hash_sort_any_uca(const charset_info_st * const cs,
 
602
                          const unsigned char *s, size_t slen,
 
603
                          uint32_t *n1, uint32_t *n2);
 
604
 
 
605
size_t my_strnxfrm_any_uca(const charset_info_st * const cs,
 
606
                           unsigned char *dst, size_t dstlen, uint32_t nweights,
 
607
                           const unsigned char *src, size_t srclen,
 
608
                           uint32_t flags);
 
609
 
 
610
int my_wildcmp_uca(const charset_info_st * const cs,
 
611
                   const char *str,const char *str_end,
 
612
                   const char *wildstr,const char *wildend,
 
613
                   int escape, int w_one, int w_many);
 
614
 
 
615
int my_strnncoll_8bit_bin(const charset_info_st * const,
 
616
                          const unsigned char *s, size_t slen,
 
617
                          const unsigned char *t, size_t tlen,
 
618
                          bool t_is_prefix);
 
619
int my_strnncollsp_8bit_bin(const charset_info_st * const,
 
620
                            const unsigned char *a, size_t a_length,
 
621
                            const unsigned char *b, size_t b_length,
 
622
                            bool diff_if_only_endspace_difference);
 
623
size_t my_case_str_bin(const charset_info_st * const, char *);
 
624
size_t my_case_bin(const charset_info_st * const, char *,
 
625
                   size_t srclen, char *, size_t);
 
626
int my_strcasecmp_bin(const charset_info_st * const,
 
627
                      const char *s, const char *t);
 
628
size_t my_strnxfrm_8bit_bin(const charset_info_st * const cs,
 
629
                     unsigned char * dst, size_t dstlen, uint32_t nweights,
 
630
                     const unsigned char *src, size_t srclen, uint32_t flags);
 
631
uint32_t my_instr_bin(const charset_info_st * const,
 
632
                      const char *b, size_t b_length,
 
633
                      const char *s, size_t s_length,
 
634
                      my_match_t *match, uint32_t nmatch);
 
635
size_t my_lengthsp_binary(const charset_info_st * const,
 
636
                          const char *, size_t length);
 
637
int my_mb_wc_bin(const charset_info_st * const,
 
638
                 my_wc_t *wc, const unsigned char *str,
 
639
                 const unsigned char *end);
 
640
int my_wc_mb_bin(const charset_info_st * const, my_wc_t wc,
 
641
                 unsigned char *str, unsigned char *end);
 
642
void my_hash_sort_8bit_bin(const charset_info_st * const,
 
643
                           const unsigned char *key, size_t len,
 
644
                           uint32_t *nr1, uint32_t *nr2);
 
645
bool my_coll_init_8bit_bin(charset_info_st *cs,
 
646
                           cs_alloc_func);
 
647
int my_strnncoll_binary(const charset_info_st * const,
 
648
                        const unsigned char *s, size_t slen,
 
649
                        const unsigned char *t, size_t tlen,
 
650
                        bool t_is_prefix);
 
651
int my_strnncollsp_binary(const charset_info_st * const cs,
 
652
                          const unsigned char *s, size_t slen,
 
653
                          const unsigned char *t, size_t tlen,
 
654
                          bool);
 
655
 
 
656
inline static bool my_isascii(char c)      
 
657
{
 
658
  return (!(c & ~0177));
 
659
}
 
660
 
 
661
inline static char my_toascii(char c)
 
662
{
 
663
  return (c & 0177);
 
664
}
 
665
 
 
666
inline static char my_tocntrl(char c) 
 
667
{
 
668
  return (c & 31);
 
669
}
 
670
 
 
671
inline static char my_toprint(char c)
 
672
{
 
673
  return (c | 64);
 
674
}
 
675
 
 
676
inline static char my_toupper(const charset_info_st *s, unsigned char c)
 
677
{
 
678
  return s->to_upper[c];
 
679
}
 
680
 
 
681
inline static char my_tolower(const charset_info_st *s, unsigned char c)
 
682
{
 
683
  return s->to_lower[c];
 
684
}
 
685
 
 
686
inline static bool my_isalpha(const charset_info_st *s, unsigned char c)
 
687
{
 
688
  return (s->ctype+1)[c] & (_MY_U | _MY_L);
 
689
}
 
690
 
 
691
inline static bool my_isupper(const charset_info_st *s, unsigned char c)
 
692
{
 
693
  return (s->ctype+1)[c] & _MY_U;
 
694
}
 
695
 
 
696
inline static bool my_islower(const charset_info_st *s, unsigned char c)
 
697
{
 
698
  return (s->ctype+1)[c] & _MY_L;
 
699
}
 
700
 
 
701
inline static bool my_isdigit(const charset_info_st *s, unsigned char c)
 
702
{
 
703
  return (s->ctype+1)[c] & _MY_NMR;
 
704
}
 
705
 
 
706
inline static bool my_isxdigit(const charset_info_st *s, unsigned char c)
 
707
{
 
708
  return (s->ctype+1)[c] & _MY_X;
 
709
}
 
710
 
 
711
inline static bool my_isalnum(const charset_info_st *s, unsigned char c) 
 
712
{
 
713
  return (s->ctype+1)[c] & (_MY_U | _MY_L | _MY_NMR);
 
714
}
 
715
 
 
716
inline static bool my_isspace(const charset_info_st *s, unsigned char c)
 
717
{
 
718
  return (s->ctype+1)[c] & _MY_SPC;
 
719
}
 
720
 
 
721
inline static bool my_ispunct(const charset_info_st *s, unsigned char c)  
 
722
{
 
723
  return (s->ctype+1)[c] & _MY_PNT;
 
724
}
 
725
 
 
726
inline static bool my_isprint(const charset_info_st *s, unsigned char c)  
 
727
{
 
728
  return (s->ctype+1)[c] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR | _MY_B);
 
729
}
 
730
 
 
731
inline static bool my_isgraph(const charset_info_st *s, unsigned char c)
 
732
{
 
733
  return (s->ctype+1)[c] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR);
 
734
}
 
735
 
 
736
inline static bool my_iscntrl(const charset_info_st *s, unsigned char c)  
 
737
{
 
738
  return (s->ctype+1)[c] & _MY_CTR;
 
739
}
 
740
 
 
741
/* Some macros that should be cleaned up a little */
 
742
inline static bool my_isvar(const charset_info_st *s, char c)
 
743
{
 
744
  return my_isalnum(s,c) || (c) == '_';
 
745
}
 
746
 
 
747
inline static bool my_isvar_start(const charset_info_st *s, char c)
 
748
{
 
749
  return my_isalpha(s,c) || (c) == '_';
 
750
}
 
751
 
 
752
inline static bool my_binary_compare(const charset_info_st *s)
 
753
{
 
754
  return s->state  & MY_CS_BINSORT;
 
755
}
 
756
 
 
757
inline static bool use_strnxfrm(const charset_info_st *s)
 
758
{
 
759
  return s->state & MY_CS_STRNXFRM;
 
760
}
 
761
 
 
762
inline static size_t my_strnxfrm(const charset_info_st *cs, 
 
763
                                 unsigned char *dst, 
 
764
                                 const size_t dstlen, 
 
765
                                 const unsigned char *src, 
 
766
                                 const uint32_t srclen)
 
767
{
 
768
  return (cs->coll->strnxfrm(cs, dst, dstlen, dstlen, src, srclen, MY_STRXFRM_PAD_WITH_SPACE));
 
769
}
 
770
 
 
771
inline static int my_strnncoll(const charset_info_st *cs, 
 
772
                               const unsigned char *s, 
 
773
                               const size_t slen, 
 
774
                               const unsigned char *t,
 
775
                               const size_t tlen) 
 
776
{
 
777
  return (cs->coll->strnncoll(cs, s, slen, t, tlen, 0));
 
778
}
 
779
 
 
780
inline static bool my_like_range(const charset_info_st *cs,
 
781
                                 const char *ptr, const size_t ptrlen,
 
782
                                 const char escape, 
 
783
                                 const char w_one,
 
784
                                 const char w_many, 
 
785
                                 const size_t reslen, 
 
786
                                 char *minstr, char *maxstr, 
 
787
                                 size_t *minlen, size_t *maxlen)
 
788
{
 
789
  return (cs->coll->like_range(cs, ptr, ptrlen, escape, w_one, w_many, reslen, 
 
790
                               minstr, maxstr, minlen, maxlen));
 
791
}
 
792
 
 
793
inline static int my_wildcmp(const charset_info_st *cs,
 
794
                             const char *str, const char *strend,
 
795
                             const char *w_str, const char *w_strend,
 
796
                             const int escape,
 
797
                             const int w_one, const int w_many) 
 
798
{
 
799
  return (cs->coll->wildcmp(cs, str, strend, w_str, w_strend, escape, w_one, w_many));
 
800
}
 
801
 
 
802
inline static int my_strcasecmp(const charset_info_st *cs, const char *s, const char *t)
 
803
{
 
804
  return (cs->coll->strcasecmp(cs, s, t));
 
805
}
 
806
 
 
807
template <typename CHAR_T>
 
808
inline static size_t my_charpos(const charset_info_st *cs, 
 
809
                                const CHAR_T *b, const CHAR_T* e, size_t num)
 
810
{
 
811
  return cs->cset->charpos(cs, reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(e), num);
 
812
}
 
813
 
 
814
inline static bool use_mb(const charset_info_st *cs)
 
815
{
 
816
  return cs->cset->ismbchar != NULL;
 
817
}
 
818
 
 
819
inline static unsigned int  my_ismbchar(const charset_info_st *cs, const char *a, const char *b)
 
820
{
 
821
  return cs->cset->ismbchar(cs, a, b);
 
822
}
 
823
 
 
824
inline static unsigned int my_mbcharlen(const charset_info_st *cs, uint32_t c)
 
825
{
 
826
  return cs->cset->mbcharlen(cs, c);
 
827
}
 
828
 
 
829
 
 
830
inline static size_t my_caseup_str(const charset_info_st *cs, char *src)
 
831
{
 
832
  return cs->cset->caseup_str(cs, src);
 
833
}
 
834
 
 
835
inline static size_t my_casedn_str(const charset_info_st *cs, char *src)
 
836
{
 
837
  return cs->cset->casedn_str(cs, src);
 
838
}
 
839
 
 
840
inline static long my_strntol(const charset_info_st *cs, 
 
841
                              const char* s, const size_t l, const int base, char **e, int *err)
 
842
{
 
843
  return (cs->cset->strntol(cs, s, l, base, e, err));
 
844
}
 
845
 
 
846
inline static unsigned long my_strntoul(const charset_info_st *cs, 
 
847
                                        const char* s, const size_t l, const int base, 
 
848
                                        char **e, int *err)
 
849
{
 
850
  return (cs->cset->strntoul(cs, s, l, base, e, err));
 
851
}
 
852
 
 
853
inline static int64_t my_strntoll(const charset_info_st *cs, 
 
854
                                 const char* s, const size_t l, const int base, char **e, int *err)
 
855
{
 
856
  return (cs->cset->strntoll(cs, s, l, base, e, err));
 
857
}
 
858
 
 
859
inline static int64_t my_strntoull(const charset_info_st *cs, 
 
860
                                   const char* s, const size_t l, const int base, 
 
861
                                   char **e, int *err)
 
862
{
 
863
  return (cs->cset->strntoull(cs, s, l, base, e, err));
 
864
}
 
865
 
 
866
 
 
867
inline static double my_strntod(const charset_info_st *cs, 
 
868
                                char* s, const size_t l, char **e, int *err)
 
869
{
 
870
  return (cs->cset->strntod(cs, s, l, e, err));
 
871
}
 
872
 
 
873
int make_escape_code(const charset_info_st * const cs, const char *escape);
61
874
 
62
875
} /* namespace drizzled */
63
876