MySQL 8.4.3
Source Code Documentation
m_ctype.h
Go to the documentation of this file.
1/* Copyright (c) 2000, 2024, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is designed to work with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have either included with
13 the program or referenced in the documentation.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License, version 2.0, for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
23
24#ifndef INCLUDE_MYSQL_STRINGS_M_CTYPE_H_
25#define INCLUDE_MYSQL_STRINGS_M_CTYPE_H_
26
27/**
28 @file include/mysql/strings/m_ctype.h
29 A better implementation of the UNIX ctype(3) library.
30*/
31
32#include <sys/types.h>
33
34#include <cassert>
35#include <cstddef>
36#include <cstdint>
37#include <cstdlib>
38#include <cstring>
39#include <deque>
40
41#include "mysql/attribute.h"
42#include "mysql/my_loglevel.h"
43#include "mysql/strings/api.h"
44#include "template_utils.h"
45
46constexpr int MY_CS_NAME_SIZE = 32;
47
48constexpr const char *CHARSET_DIR = "charsets/";
49
50typedef int myf; /* Type of MyFlags in my_funcs */
51
52/**
53 Our own version of wchar_t, ie., a type that holds a single Unicode code point
54 ("wide character"). unsigned long is always big enough to hold any character
55 in the BMP.
56*/
57typedef unsigned long my_wc_t;
58
59static inline void MY_PUT_MB2(unsigned char *s, uint16_t code) {
60 s[0] = code >> 8;
61 s[1] = code & 0xFF;
62}
63
65 uint32_t toupper;
66 uint32_t tolower;
67 uint32_t sort;
68};
69
73};
74
75struct MY_UCA_INFO;
76
78 uint8_t pctype;
79 uint8_t *ctype;
80};
81
82/* wm_wc and wc_mb return codes */
83/* clang-format off */
84static constexpr int
85 MY_CS_ILSEQ = 0; /* Wrong by sequence: wb_wc */
86static constexpr int
87 MY_CS_ILUNI = 0; /* Cannot encode Unicode to charset: wc_mb */
88static constexpr int
89 MY_CS_TOOSMALL = -101; /* Need at least one byte: wc_mb and mb_wc */
90static constexpr int
91 MY_CS_TOOSMALL2 = -102; /* Need at least two bytes: wc_mb and mb_wc */
92static constexpr int
93 MY_CS_TOOSMALL3 = -103; /* Need at least three bytes: wc_mb and mb_wc */
94
95/* These following three are currently not really used */
96static constexpr int
97 MY_CS_TOOSMALL4 = -104; /* Need at least 4 bytes: wc_mb and mb_wc */
98static constexpr int
99 MY_CS_TOOSMALL5 = -105; /* Need at least 5 bytes: wc_mb and mb_wc */
100static constexpr int
101 MY_CS_TOOSMALL6 = -106; /* Need at least 6 bytes: wc_mb and mb_wc */
102/* clang-format on */
103
104static constexpr int MY_SEQ_INTTAIL = 1;
105static constexpr int MY_SEQ_SPACES = 2;
106
107/* CHARSET_INFO::state flags */
108/* clang-format off */
109static constexpr uint32_t
110 MY_CHARSET_UNDEFINED = 0; // for unit testing
111static constexpr uint32_t
112 MY_CS_COMPILED = 1 << 0; // compiled-in charsets
113static constexpr uint32_t
114 MY_CS_CONFIG_UNUSED = 1 << 1; // unused bitmask
115static constexpr uint32_t
116 MY_CS_INDEX_UNUSED = 1 << 2; // unused bitmask
117static constexpr uint32_t
118 MY_CS_LOADED = 1 << 3; // charsets that are currently loaded
119static constexpr uint32_t
120 MY_CS_BINSORT = 1 << 4; // if binary sort order
121static constexpr uint32_t
122 MY_CS_PRIMARY = 1 << 5; // if primary collation
123static constexpr uint32_t
124 MY_CS_STRNXFRM = 1 << 6; // if _not_ set, sort_order will
125 // give same result as strnxfrm --
126 // all new collations should have
127 // this flag set,
128 // do not check it in new code
129static constexpr uint32_t
130 MY_CS_UNICODE = 1 << 7; // if a charset is BMP Unicode
131static constexpr uint32_t
132 MY_CS_READY = 1 << 8; // if a charset is initialized
133static constexpr uint32_t
134 MY_CS_AVAILABLE = 1 << 9; // if either compiled-in or loaded
135static constexpr uint32_t
136 MY_CS_CSSORT = 1 << 10; // if case sensitive sort order
137static constexpr uint32_t
138 MY_CS_HIDDEN = 1 << 11; // don't display in SHOW
139static constexpr uint32_t
140 MY_CS_PUREASCII = 1 << 12; // if a charset is pure ascii
141static constexpr uint32_t
142 MY_CS_NONASCII = 1 << 13; // if not ASCII-compatible
143static constexpr uint32_t
144 MY_CS_UNICODE_SUPPLEMENT = 1 << 14; // Non-BMP Unicode characters
145static constexpr uint32_t
146 MY_CS_LOWER_SORT = 1 << 15; // if use lower case as weight
147static constexpr uint32_t
148 MY_CS_INLINE = 1 << 16; // CS definition is C++ source
149
150/* Character repertoire flags */
151static constexpr uint32_t
152 MY_REPERTOIRE_ASCII = 1; /* Pure ASCII U+0000..U+007F */
153static constexpr uint32_t
154 MY_REPERTOIRE_EXTENDED = 2; /* Extended characters: U+0080..U+FFFF */
155static constexpr uint32_t
156 MY_REPERTOIRE_UNICODE30 = 3; /* ASCII | EXTENDED: U+0000..U+FFFF */
157
158/* Flags for strxfrm */
159static constexpr uint32_t
160 MY_STRXFRM_PAD_TO_MAXLEN = 0x00000080; /* if pad tail(for filesort) */
161
162/* clang-format on */
163
165 uint16_t from;
166 uint16_t to;
167 const uint8_t *tab;
168};
169
171 unsigned beg;
172 unsigned end;
173 unsigned mb_len;
174};
175
176struct CHARSET_INFO;
177
178/**
179 Helper structure to return error messages from collation parser/initializer.
180*/
182 static constexpr int errmsg_size = 192;
183 unsigned errcode{0}; ///< See include/mysys_err.h
184 char errarg[errmsg_size]{}; ///< Error message text
185};
186
187/**
188 User-specified callback interface for collation parser/initializer
189*/
191 public:
192 MY_CHARSET_LOADER() = default;
193 virtual ~MY_CHARSET_LOADER();
194
197
200
201 /**
202 Intercepts error messages from collation parser/initializer
203
204 @param loglevel ERROR_LEVEL or WARNING_LEVEL
205 @param errcode See include/mysys_err.h
206 */
207 virtual void reporter(enum loglevel loglevel, unsigned errcode, ...) = 0;
208
209 /**
210 Loads a file by its OS path into collation parser/initializer
211
212 @param path '\0'-terminated file path to load
213 @param size Byte size of @p path
214
215 @returns Pointer to file data on success, otherwise nullptr.
216 This is a caller's responsibility to free this pointer
217 with free().
218 */
219 virtual void *read_file(const char *path, size_t *size) = 0;
220
221 /**
222 Collation parser helper function (not overloadable).
223
224 @param cs New collation object to register in the collation library
225
226 @return MY_XML_OK on success, otherwise MY_XML_ERROR
227 */
229
230 /**
231 Allocate-and-forget version of malloc().
232 */
233 virtual void *once_alloc(size_t);
234
235 virtual void *mem_malloc(size_t size) { return malloc(size); }
236 virtual void mem_free(void *ptr) { free(ptr); }
237
238 private:
239 std::deque<void *> m_delete_list;
240};
241
243
245
246/* See strings/CHARSET_INFO.txt for information about this structure */
250 /* Collation routines */
251 int (*strnncoll)(const CHARSET_INFO *, const uint8_t *, size_t,
252 const uint8_t *, size_t, bool);
253 /**
254 Compare the two strings under the pad rules given by the collation.
255
256 Thus, for NO PAD collations, this is identical to strnncoll with is_prefix
257 set to false. For PAD SPACE collations, the two strings are conceptually
258 extended infinitely at the end using space characters (0x20) and then
259 compared under the collation's normal comparison rules, so that e.g 'a' is
260 equal to 'a '.
261 */
262 int (*strnncollsp)(const CHARSET_INFO *, const uint8_t *, size_t,
263 const uint8_t *, size_t);
264 /**
265 Transform the string into a form such that memcmp() between transformed
266 strings yields the correct collation order.
267
268 @param [out] dst Buffer for the transformed string.
269 @param [out] dstlen Number of bytes available in dstlen.
270 Must be even.
271 @param num_codepoints Treat the string as if it were of type
272 CHAR(num_codepoints). In particular, this means that if the
273 collation is a pad collation (pad_attribute is PAD_SPACE) and
274 string has fewer than "num_codepoints" codepoints, the string
275 will be transformed as if it ended in (num_codepoints-n) extra spaces.
276 If the string has more than "num_codepoints" codepoints,
277 behavior is undefined; may truncate, may crash, or do something
278 else entirely. Note that MY_STRXFRM_PAD_TO_MAXLEN overrides this;
279 if it is given for a PAD SPACE collation, this value is taken to be
280 effectively infinity.
281 @param src The source string, in the required character set
282 for the collation.
283 @param srclen Number of bytes in src.
284 @param flags ORed bitmask of MY_STRXFRM_* flags.
285
286 @return Number of bytes written to dst.
287 */
288 size_t (*strnxfrm)(const CHARSET_INFO *, uint8_t *dst, size_t dstlen,
289 unsigned num_codepoints, const uint8_t *src, size_t srclen,
290 unsigned flags);
291
292 /**
293 Return the maximum number of output bytes needed for strnxfrm()
294 to output all weights for any string of the given input length.
295 You can use this to e.g. size buffers for sort keys.
296
297 @param num_bytes Number of bytes in the input string. Note that for
298 multibyte character sets, this _must_ be a pessimistic estimate,
299 ie., one that's cs->mbmaxlen * max_num_codepoints. So for e.g.
300 the utf8mb4 string "foo", you will need to give in 12, not 3.
301 */
302 size_t (*strnxfrmlen)(const CHARSET_INFO *, size_t num_bytes);
303 bool (*like_range)(const CHARSET_INFO *, const char *s, size_t s_length,
304 char w_prefix, char w_one, char w_many, size_t res_length,
305 char *min_str, char *max_str, size_t *min_len,
306 size_t *max_len);
307 int (*wildcmp)(const CHARSET_INFO *, const char *str, const char *str_end,
308 const char *wildstr, const char *wildend, int escape,
309 int w_one, int w_many);
310
311 int (*strcasecmp)(const CHARSET_INFO *, const char *, const char *);
312
313 unsigned (*strstr)(const CHARSET_INFO *, const char *b, size_t b_length,
314 const char *s, size_t s_length, my_match_t *match,
315 unsigned nmatch);
316
317 /**
318 Compute a sort hash for the given key. This hash must preserve equality
319 under the given collation, so that a=b => H(a)=H(b). Note that this hash
320 is used for hash-based partitioning (PARTITION KEY), so you cannot change
321 it except when writing a new collation; it needs to be unchanged across
322 releases, so that the on-disk format does not change. (It is also used
323 for testing equality in the MEMORY storage engine.)
324
325 nr1 and nr2 are both in/out parameters. nr1 is the actual hash value;
326 nr2 holds extra state between invocations.
327 */
328 void (*hash_sort)(const CHARSET_INFO *cs, const uint8_t *key, size_t len,
329 uint64_t *nr1, uint64_t *nr2);
330 bool (*propagate)(const CHARSET_INFO *cs, const uint8_t *str, size_t len);
331};
332
333/* Some typedef to make it easy for C++ to make function pointers */
335 const uint8_t *, const uint8_t *);
336typedef int (*my_charset_conv_wc_mb)(const CHARSET_INFO *, my_wc_t, uint8_t *,
337 uint8_t *);
338typedef size_t (*my_charset_conv_case)(const CHARSET_INFO *, char *, size_t,
339 char *, size_t);
340
341/* See strings/CHARSET_INFO.txt about information on this structure */
344 /* Multibyte routines */
345 unsigned (*ismbchar)(const CHARSET_INFO *, const char *, const char *);
346 unsigned (*mbcharlen)(const CHARSET_INFO *, unsigned c);
347 size_t (*numchars)(const CHARSET_INFO *, const char *b, const char *e);
348
349 /**
350 Return at which byte codepoint number "pos" begins, relative to
351 the start of the string. If the string is shorter than or is
352 exactly "pos" codepoints long, returns a value equal or greater to
353 (e-b).
354 */
355 size_t (*charpos)(const CHARSET_INFO *, const char *b, const char *e,
356 size_t pos);
357 size_t (*well_formed_len)(const CHARSET_INFO *, const char *b, const char *e,
358 size_t nchars, int *error);
359 /**
360 Given a pointer and a length in bytes, returns a new length in bytes where
361 all trailing space characters are stripped. This holds even for NO PAD
362 collations.
363
364 Exception: The "binary" collation, which is used behind-the-scenes to
365 implement the BINARY type (by mapping it to CHAR(n) COLLATE "binary"),
366 returns just the length back with no stripping. It's done that way so that
367 Field_string (implementing CHAR(n)) returns the full padded width on read
368 (as opposed to a normal CHAR, where we usually strip the spaces on read),
369 but it's suboptimal, since lengthsp() is also used in a number of other
370 places, e.g. stripping trailing spaces from enum values given in by the
371 user. If you call this function, be aware of this special exception and
372 consider the implications.
373 */
374 size_t (*lengthsp)(const CHARSET_INFO *, const char *ptr, size_t length);
375 size_t (*numcells)(const CHARSET_INFO *, const char *b, const char *e);
376
377 /* Unicode conversion */
380
381 /* CTYPE scanner */
382 int (*ctype)(const CHARSET_INFO *cs, int *ctype, const uint8_t *s,
383 const uint8_t *e);
384
385 /* Functions for case and sort conversion */
386 size_t (*caseup_str)(const CHARSET_INFO *, char *);
387 size_t (*casedn_str)(const CHARSET_INFO *, char *);
388
391
392 /* Charset dependant snprintf() */
393 size_t (*snprintf)(const CHARSET_INFO *, char *to, size_t n, const char *fmt,
394 ...) MY_ATTRIBUTE((format(printf, 4, 5)));
395
396 size_t (*long10_to_str)(const CHARSET_INFO *, char *to, size_t n, int radix,
397 long int val);
398 size_t (*longlong10_to_str)(const CHARSET_INFO *, char *to, size_t n,
399 int radix, long long val);
400
401 void (*fill)(const CHARSET_INFO *, char *to, size_t len, int fill);
402
403 /* String-to-number conversion routines */
404 long (*strntol)(const CHARSET_INFO *, const char *s, size_t l, int base,
405 const char **e, int *err);
406 unsigned long (*strntoul)(const CHARSET_INFO *, const char *s, size_t l,
407 int base, const char **e, int *err);
408 long long (*strntoll)(const CHARSET_INFO *, const char *s, size_t l, int base,
409 const char **e, int *err);
410 unsigned long long (*strntoull)(const CHARSET_INFO *, const char *s, size_t l,
411 int base, const char **e, int *err);
412 double (*strntod)(const CHARSET_INFO *, const char *s, size_t l,
413 const char **e, int *err);
414 long long (*strtoll10)(const CHARSET_INFO *cs, const char *nptr,
415 const char **endptr, int *error);
416 unsigned long long (*strntoull10rnd)(const CHARSET_INFO *cs, const char *str,
417 size_t length, int unsigned_fl,
418 const char **endptr, int *error);
419 size_t (*scan)(const CHARSET_INFO *, const char *b, const char *e, int sq);
420};
421
422/* See strings/CHARSET_INFO.txt about information on this structure */
424 unsigned number;
427 unsigned state;
428 const char *csname;
429 const char *m_coll_name;
430 const char *comment;
431 const char *tailoring;
433 const uint8_t *ctype;
434 const uint8_t *to_lower;
435 const uint8_t *to_upper;
436 const uint8_t *sort_order;
437 struct MY_UCA_INFO *uca; /* This can be changed in apply_one_rule() */
438 const uint16_t *tab_to_uni;
441 const struct lex_state_maps_st *state_maps; /* parser internal data */
442 const uint8_t *ident_map; /* parser internal data */
446 unsigned mbminlen;
447 unsigned mbmaxlen;
448 unsigned mbmaxlenlen;
450 my_wc_t max_sort_char; /* For LIKE optimization */
451 uint8_t pad_char;
454
457
458 /**
459 If this collation is PAD_SPACE, it collates as if all inputs were
460 padded with a given number of spaces at the end (see the "num_codepoints"
461 flag to strnxfrm). NO_PAD simply compares unextended strings.
462
463 Note that this is fundamentally about the behavior of coll->strnxfrm.
464 */
466};
467
468/*
469 NOTE: You cannot use a CHARSET_INFO without it having been initialized first.
470 In particular, they are not initialized when a unit test starts; do not use
471 these globals indiscriminately from here, and do not add more. Instead,
472 initialize them using my_collation_get_by_name().
473*/
474
480
489
490/**
491 @note Deprecated function, please call cs->coll->wildcmp(cs...) instead.
492*/
494 const char *str, const char *str_end,
495 const char *wildstr,
496 const char *wildend, int escape,
497 int w_one, int w_many);
498
500 const char *str, const char *end,
501 const char *reject,
502 size_t reject_length);
503
505 const char *str, size_t len);
506
508
509/**
510 Detect whether a character set is ASCII compatible.
511*/
513 return (cs->state & MY_CS_NONASCII) == 0;
514}
515
516inline bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2) {
517 assert(0 != strcmp(cs1->csname, "utf8"));
518 assert(0 != strcmp(cs2->csname, "utf8"));
519 return ((cs1 == cs2) || !strcmp(cs1->csname, cs2->csname));
520}
521
523
525
526MYSQL_STRINGS_EXPORT size_t my_convert(char *to, size_t to_length,
527 const CHARSET_INFO *to_cs,
528 const char *from, size_t from_length,
529 const CHARSET_INFO *from_cs,
530 unsigned *errors);
531
533 const char *s, const char *e);
534
536 const char *wildstr,
537 const char *wildend, int escape,
538 int w_many, size_t *prefix_len);
539
540/* clang-format off */
541static constexpr uint8_t MY_CHAR_U = 01; /* Upper case */
542static constexpr uint8_t MY_CHAR_L = 02; /* Lower case */
543static constexpr uint8_t MY_CHAR_NMR = 04; /* Numeral (digit) */
544static constexpr uint8_t MY_CHAR_SPC = 010; /* Spacing character */
545static constexpr uint8_t MY_CHAR_PNT = 020; /* Punctuation */
546static constexpr uint8_t MY_CHAR_CTR = 040; /* Control character */
547static constexpr uint8_t MY_CHAR_B = 0100; /* Blank */
548static constexpr uint8_t MY_CHAR_X = 0200; /* heXadecimal digit */
549/* clang-format on */
550
551/* The following functions make sense only for one-byte character sets.
552They will not fail for multibyte character sets, but will not produce
553the expected results. They may have some limited usability like
554e.g. for utf8mb3/utf8mb4, meaningful results will be produced for
555values < 0x7F. */
556
557inline bool my_isascii(char ch) { return (ch & ~0177) == 0; }
558
559inline char my_toupper(const CHARSET_INFO *cs, char ch) {
560 return static_cast<char>(cs->to_upper[static_cast<uint8_t>(ch)]);
561}
562
563inline char my_tolower(const CHARSET_INFO *cs, char ch) {
564 return static_cast<char>(cs->to_lower[static_cast<uint8_t>(ch)]);
565}
566
567inline bool my_isalpha(const CHARSET_INFO *cs, char ch) {
568 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] &
569 (MY_CHAR_U | MY_CHAR_L)) != 0;
570}
571
572inline bool my_isupper(const CHARSET_INFO *cs, char ch) {
573 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_U) != 0;
574}
575
576inline bool my_islower(const CHARSET_INFO *cs, char ch) {
577 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_L) != 0;
578}
579
580inline bool my_isdigit(const CHARSET_INFO *cs, char ch) {
581 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_NMR) != 0;
582}
583
584inline bool my_isxdigit(const CHARSET_INFO *cs, char ch) {
585 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_X) != 0;
586}
587
588inline bool my_isalnum(const CHARSET_INFO *cs, char ch) {
589 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] &
590 (MY_CHAR_U | MY_CHAR_L | MY_CHAR_NMR)) != 0;
591}
592
593inline bool my_isspace(const CHARSET_INFO *cs, char ch) {
594 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_SPC) != 0;
595}
596
597inline bool my_ispunct(const CHARSET_INFO *cs, char ch) {
598 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_PNT) != 0;
599}
600
601inline bool my_isgraph(const CHARSET_INFO *cs, char ch) {
602 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] &
604}
605
606inline bool my_iscntrl(const CHARSET_INFO *cs, char ch) {
607 return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_CTR) != 0;
608}
609
610inline bool my_isvar(const CHARSET_INFO *cs, char ch) {
611 return my_isalnum(cs, ch) || (ch == '_');
612}
613
614inline bool my_isvar_start(const CHARSET_INFO *cs, char ch) {
615 return my_isalpha(cs, ch) || (ch == '_');
616}
617
618// Properties of character sets.
619inline bool my_binary_compare(const CHARSET_INFO *cs) {
620 return (cs->state & MY_CS_BINSORT) != 0;
621}
622
623inline bool use_strnxfrm(const CHARSET_INFO *cs) {
624 return (cs->state & MY_CS_STRNXFRM) != 0;
625}
626
627// Interfaces to member functions.
628inline size_t my_strnxfrm(const CHARSET_INFO *cs, uint8_t *dst, size_t dstlen,
629 const uint8_t *src, size_t srclen) {
630 return cs->coll->strnxfrm(cs, dst, dstlen, dstlen, src, srclen, 0);
631}
632
633inline int my_strnncoll(const CHARSET_INFO *cs, const uint8_t *a,
634 size_t a_length, const uint8_t *b, size_t b_length) {
635 return cs->coll->strnncoll(cs, a, a_length, b, b_length, false);
636}
637
638inline bool my_like_range(const CHARSET_INFO *cs, const char *s,
639 size_t s_length, char w_prefix, char w_one,
640 char w_many, size_t res_length, char *min_str,
641 char *max_str, size_t *min_len, size_t *max_len) {
642 return cs->coll->like_range(cs, s, s_length, w_prefix, w_one, w_many,
643 res_length, min_str, max_str, min_len, max_len);
644}
645
646inline int my_wildcmp(const CHARSET_INFO *cs, const char *str,
647 const char *str_end, const char *wildstr,
648 const char *wildend, int escape, int w_one, int w_many) {
649 return cs->coll->wildcmp(cs, str, str_end, wildstr, wildend, escape, w_one,
650 w_many);
651}
652
653inline int my_strcasecmp(const CHARSET_INFO *cs, const char *s1,
654 const char *s2) {
655 return cs->coll->strcasecmp(cs, s1, s2);
656}
657
658inline size_t my_charpos(const CHARSET_INFO *cs, const char *beg,
659 const char *end, size_t pos) {
660 return cs->cset->charpos(cs, beg, end, pos);
661}
662
663inline size_t my_charpos(const CHARSET_INFO *cs, const unsigned char *beg,
664 const unsigned char *end, size_t pos) {
665 return cs->cset->charpos(cs, pointer_cast<const char *>(beg),
666 pointer_cast<const char *>(end), pos);
667}
668
669inline bool use_mb(const CHARSET_INFO *cs) {
670 return cs->cset->ismbchar != nullptr;
671}
672
673inline unsigned my_ismbchar(const CHARSET_INFO *cs, const char *str,
674 const char *strend) {
675 return cs->cset->ismbchar(cs, str, strend);
676}
677
678inline unsigned my_ismbchar(const CHARSET_INFO *cs, const uint8_t *str,
679 const uint8_t *strend) {
680 return cs->cset->ismbchar(cs, pointer_cast<const char *>(str),
681 pointer_cast<const char *>(strend));
682}
683
684inline unsigned my_mbcharlen(const CHARSET_INFO *cs, unsigned first_byte) {
685 return cs->cset->mbcharlen(cs, first_byte);
686}
687
688/**
689 Get the length of gb18030 code by the given two leading bytes
690
691 @param[in] cs charset_info
692 @param[in] first_byte first byte of gb18030 code
693 @param[in] second_byte second byte of gb18030 code
694 @return the length of gb18030 code starting with given two bytes,
695 the length would be 2 or 4 for valid gb18030 code,
696 or 0 for invalid gb18030 code
697*/
698inline unsigned my_mbcharlen_2(const CHARSET_INFO *cs, uint8_t first_byte,
699 uint8_t second_byte) {
700 return cs->cset->mbcharlen(cs,
701 ((first_byte & 0xFF) << 8) + (second_byte & 0xFF));
702}
703
704/**
705 Get the maximum length of leading bytes needed to determine the length of a
706 multi-byte gb18030 code
707
708 @param[in] cs charset_info
709 @return number of leading bytes we need, would be 2 for gb18030
710 and 1 for all other charsets
711*/
712inline unsigned my_mbmaxlenlen(const CHARSET_INFO *cs) {
713 return cs->mbmaxlenlen;
714}
715
716/**
717 Judge if the given byte is a possible leading byte for a charset.
718 For gb18030 whose mbmaxlenlen is 2, we can't determine the length of
719 a multi-byte character by looking at the first byte only
720
721 @param[in] cs charset_info
722 @param[in] leading_byte possible leading byte
723 @return true if it is, otherwise false
724*/
725inline bool my_ismb1st(const CHARSET_INFO *cs, unsigned leading_byte) {
726 return my_mbcharlen(cs, leading_byte) > 1 ||
727 (my_mbmaxlenlen(cs) == 2 && my_mbcharlen(cs, leading_byte) == 0);
728}
729
730inline size_t my_caseup_str(const CHARSET_INFO *cs, char *str) {
731 return cs->cset->caseup_str(cs, str);
732}
733
734inline size_t my_casedn_str(const CHARSET_INFO *cs, char *str) {
735 return cs->cset->casedn_str(cs, str);
736}
737
738inline long my_strntol(const CHARSET_INFO *cs, const char *str, size_t length,
739 int base, const char **end, int *err) {
740 return cs->cset->strntol(cs, str, length, base, end, err);
741}
742
743inline unsigned long my_strntoul(const CHARSET_INFO *cs, const char *str,
744 size_t length, int base, const char **end,
745 int *err) {
746 return cs->cset->strntoul(cs, str, length, base, end, err);
747}
748
749inline int64_t my_strntoll(const CHARSET_INFO *cs, const char *str,
750 size_t length, int base, const char **end,
751 int *err) {
752 return cs->cset->strntoll(cs, str, length, base, end, err);
753}
754
755inline uint64_t my_strntoull(const CHARSET_INFO *cs, const char *str,
756 size_t length, int base, const char **end,
757 int *err) {
758 return cs->cset->strntoull(cs, str, length, base, end, err);
759}
760
761inline double my_strntod(const CHARSET_INFO *cs, const char *str, size_t length,
762 const char **end, int *err) {
763 return cs->cset->strntod(cs, str, length, end, err);
764}
765
767 return (cs->mbminlen == 1);
768}
769
770#endif // INCLUDE_MYSQL_STRINGS_M_CTYPE_H_
#define MYSQL_STRINGS_EXPORT
Definition: api.h:47
static Mysys_charset_loader * loader
Definition: charset.cc:185
User-specified callback interface for collation parser/initializer.
Definition: m_ctype.h:190
virtual ~MY_CHARSET_LOADER()
Definition: ctype.cc:1158
virtual void * mem_malloc(size_t size)
Definition: m_ctype.h:235
MY_CHARSET_LOADER()=default
virtual void * once_alloc(size_t)
Allocate-and-forget version of malloc().
Definition: ctype.cc:1286
MY_CHARSET_LOADER & operator=(const MY_CHARSET_LOADER &&)=delete
MY_CHARSET_LOADER(const MY_CHARSET_LOADER &)=delete
virtual void mem_free(void *ptr)
Definition: m_ctype.h:236
std::deque< void * > m_delete_list
Definition: m_ctype.h:239
int add_collation(CHARSET_INFO *cs)
Collation parser helper function (not overloadable).
Definition: ctype.cc:1164
MY_CHARSET_LOADER(const MY_CHARSET_LOADER &&)=delete
virtual void * read_file(const char *path, size_t *size)=0
Loads a file by its OS path into collation parser/initializer.
MY_CHARSET_LOADER & operator=(const MY_CHARSET_LOADER &)=delete
virtual void reporter(enum loglevel loglevel, unsigned errcode,...)=0
Intercepts error messages from collation parser/initializer.
static int flags[50]
Definition: hp_test1.cc:40
#define malloc(A)
Definition: lexyy.cc:914
#define free(A)
Definition: lexyy.cc:915
static constexpr int MY_CS_TOOSMALL4
Definition: m_ctype.h:97
static constexpr int MY_SEQ_SPACES
Definition: m_ctype.h:105
static constexpr uint32_t MY_CS_PUREASCII
Definition: m_ctype.h:140
static constexpr uint8_t MY_CHAR_CTR
Definition: m_ctype.h:546
static void MY_PUT_MB2(unsigned char *s, uint16_t code)
Definition: m_ctype.h:59
static constexpr int MY_CS_TOOSMALL
Definition: m_ctype.h:89
static constexpr uint8_t MY_CHAR_L
Definition: m_ctype.h:542
int myf
Definition: m_ctype.h:50
char my_tolower(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:563
static constexpr uint8_t MY_CHAR_NMR
Definition: m_ctype.h:543
int my_strcasecmp(const CHARSET_INFO *cs, const char *s1, const char *s2)
Definition: m_ctype.h:653
bool my_like_range(const CHARSET_INFO *cs, const char *s, size_t s_length, char w_prefix, char w_one, char w_many, size_t res_length, char *min_str, char *max_str, size_t *min_len, size_t *max_len)
Definition: m_ctype.h:638
static constexpr uint32_t MY_REPERTOIRE_UNICODE30
Definition: m_ctype.h:156
static constexpr uint32_t MY_CS_READY
Definition: m_ctype.h:132
static constexpr uint32_t MY_CS_INLINE
Definition: m_ctype.h:148
static constexpr uint8_t MY_CHAR_PNT
Definition: m_ctype.h:545
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_bin
Definition: ctype-bin.cc:509
static constexpr uint32_t MY_CS_NONASCII
Definition: m_ctype.h:142
int(* my_charset_conv_wc_mb)(const CHARSET_INFO *, my_wc_t, uint8_t *, uint8_t *)
Definition: m_ctype.h:336
static constexpr uint32_t MY_CS_STRNXFRM
Definition: m_ctype.h:124
bool my_isvar_start(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:614
constexpr int MY_CS_NAME_SIZE
Definition: m_ctype.h:46
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb3_tolower_ci
Definition: ctype-utf8.cc:5829
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb4_bin
Definition: ctype-utf8.cc:7822
static constexpr uint32_t MY_CS_BINSORT
Definition: m_ctype.h:120
bool my_isxdigit(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:584
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_latin1_bin
Definition: ctype-latin1.cc:672
static constexpr int MY_CS_ILUNI
Definition: m_ctype.h:87
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb4_0900_ai_ci
Definition: ctype-uca.cc:9610
static constexpr uint32_t MY_STRXFRM_PAD_TO_MAXLEN
Definition: m_ctype.h:160
bool my_isupper(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:572
int64_t my_strntoll(const CHARSET_INFO *cs, const char *str, size_t length, int base, const char **end, int *err)
Definition: m_ctype.h:749
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb3_unicode_ci
Definition: ctype-uca.cc:6131
size_t my_charpos(const CHARSET_INFO *cs, const char *beg, const char *end, size_t pos)
Definition: m_ctype.h:658
MYSQL_STRINGS_EXPORT size_t my_convert(char *to, size_t to_length, const CHARSET_INFO *to_cs, const char *from, size_t from_length, const CHARSET_INFO *from_cs, unsigned *errors)
Convert a string between two character sets.
Definition: ctype.cc:912
uint64_t my_strntoull(const CHARSET_INFO *cs, const char *str, size_t length, int base, const char **end, int *err)
Definition: m_ctype.h:755
bool my_isalnum(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:588
static constexpr uint32_t MY_CS_LOWER_SORT
Definition: m_ctype.h:146
int my_wildcmp(const CHARSET_INFO *cs, const char *str, const char *str_end, const char *wildstr, const char *wildend, int escape, int w_one, int w_many)
Definition: m_ctype.h:646
size_t my_casedn_str(const CHARSET_INFO *cs, char *str)
Definition: m_ctype.h:734
static constexpr uint8_t MY_CHAR_SPC
Definition: m_ctype.h:544
MYSQL_STRINGS_EXPORT bool my_is_prefixidx_cand(const CHARSET_INFO *cs, const char *wildstr, const char *wildend, int escape, int w_many, size_t *prefix_len)
Identify whether given like pattern looks like a prefix pattern, which can become candidate for index...
Definition: ctype.cc:999
bool my_ispunct(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:597
static constexpr uint32_t MY_CS_UNICODE_SUPPLEMENT
Definition: m_ctype.h:144
bool my_isvar(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:610
unsigned long my_strntoul(const CHARSET_INFO *cs, const char *str, size_t length, int base, const char **end, int *err)
Definition: m_ctype.h:743
bool my_isdigit(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:580
static constexpr int MY_CS_TOOSMALL3
Definition: m_ctype.h:93
unsigned my_mbcharlen_2(const CHARSET_INFO *cs, uint8_t first_byte, uint8_t second_byte)
Get the length of gb18030 code by the given two leading bytes.
Definition: m_ctype.h:698
size_t(* my_charset_conv_case)(const CHARSET_INFO *, char *, size_t, char *, size_t)
Definition: m_ctype.h:338
MYSQL_STRINGS_EXPORT unsigned my_string_repertoire(const CHARSET_INFO *cs, const char *str, size_t len)
Definition: ctype.cc:778
int(* my_charset_conv_mb_wc)(const CHARSET_INFO *, my_wc_t *, const uint8_t *, const uint8_t *)
Definition: m_ctype.h:334
static constexpr uint32_t MY_CS_AVAILABLE
Definition: m_ctype.h:134
bool my_isspace(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:593
double my_strntod(const CHARSET_INFO *cs, const char *str, size_t length, const char **end, int *err)
Definition: m_ctype.h:761
bool use_strnxfrm(const CHARSET_INFO *cs)
Definition: m_ctype.h:623
static constexpr uint32_t MY_REPERTOIRE_EXTENDED
Definition: m_ctype.h:154
unsigned long my_wc_t
Our own version of wchar_t, ie., a type that holds a single Unicode code point ("wide character").
Definition: m_ctype.h:57
static constexpr int MY_SEQ_INTTAIL
Definition: m_ctype.h:104
bool my_iscntrl(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:606
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_latin1
Definition: ctype-latin1.cc:366
unsigned my_mbcharlen(const CHARSET_INFO *cs, unsigned first_byte)
Definition: m_ctype.h:684
static constexpr uint32_t MY_CHARSET_UNDEFINED
Definition: m_ctype.h:110
static constexpr int MY_CS_TOOSMALL5
Definition: m_ctype.h:99
static constexpr uint32_t MY_CS_UNICODE
Definition: m_ctype.h:130
unsigned my_ismbchar(const CHARSET_INFO *cs, const char *str, const char *strend)
Definition: m_ctype.h:673
bool my_isascii(char ch)
Definition: m_ctype.h:557
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb4_general_ci
Definition: ctype-utf8.cc:7786
static constexpr uint32_t MY_CS_HIDDEN
Definition: m_ctype.h:138
MYSQL_STRINGS_EXPORT size_t my_strcspn(const CHARSET_INFO *cs, const char *str, const char *end, const char *reject, size_t reject_length)
Calculate the length of the initial segment of 'str' which consists entirely of characters not in 're...
Definition: my_strchr.cc:64
MYSQL_STRINGS_EXPORT unsigned my_mbcharlen_ptr(const CHARSET_INFO *cs, const char *s, const char *e)
Get the length of the first code in given sequence of chars.
Definition: ctype.cc:971
bool my_ismb1st(const CHARSET_INFO *cs, unsigned leading_byte)
Judge if the given byte is a possible leading byte for a charset.
Definition: m_ctype.h:725
static constexpr int MY_CS_ILSEQ
Definition: m_ctype.h:85
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb4_0900_bin
Definition: ctype-uca.cc:11481
bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2)
Definition: m_ctype.h:516
size_t my_strnxfrm(const CHARSET_INFO *cs, uint8_t *dst, size_t dstlen, const uint8_t *src, size_t srclen)
Definition: m_ctype.h:628
MYSQL_STRINGS_EXPORT int(* my_string_stack_guard)(int)
Definition: collations_internal.cc:43
static constexpr uint32_t MY_CS_CONFIG_UNUSED
Definition: m_ctype.h:114
long my_strntol(const CHARSET_INFO *cs, const char *str, size_t length, int base, const char **end, int *err)
Definition: m_ctype.h:738
static constexpr uint32_t MY_CS_LOADED
Definition: m_ctype.h:118
static constexpr uint32_t MY_CS_INDEX_UNUSED
Definition: m_ctype.h:116
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb3_bin
Definition: ctype-utf8.cc:5899
constexpr const char * CHARSET_DIR
Definition: m_ctype.h:48
bool use_mb(const CHARSET_INFO *cs)
Definition: m_ctype.h:669
MYSQL_STRINGS_EXPORT unsigned my_charset_repertoire(const CHARSET_INFO *cs)
Definition: ctype.cc:800
unsigned my_mbmaxlenlen(const CHARSET_INFO *cs)
Get the maximum length of leading bytes needed to determine the length of a multi-byte gb18030 code.
Definition: m_ctype.h:712
bool my_isalpha(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:567
size_t my_caseup_str(const CHARSET_INFO *cs, char *str)
Definition: m_ctype.h:730
static constexpr uint32_t MY_REPERTOIRE_ASCII
Definition: m_ctype.h:152
bool is_supported_parser_charset(const CHARSET_INFO *cs)
Definition: m_ctype.h:766
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb3_general_ci
Definition: ctype-utf8.cc:5794
MYSQL_STRINGS_EXPORT unsigned my_strxfrm_flag_normalize(unsigned flags)
Definition: ctype-simple.cc:1497
MYSQL_STRINGS_EXPORT bool my_charset_is_ascii_based(const CHARSET_INFO *cs)
Detect whether a character set is ASCII compatible.
Definition: m_ctype.h:512
static constexpr uint8_t MY_CHAR_X
Definition: m_ctype.h:548
static constexpr int MY_CS_TOOSMALL2
Definition: m_ctype.h:91
MYSQL_STRINGS_EXPORT int my_wildcmp_mb_bin(const CHARSET_INFO *cs, const char *str, const char *str_end, const char *wildstr, const char *wildend, int escape, int w_one, int w_many)
Definition: ctype-mb.cc:1040
bool my_islower(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:576
static constexpr uint32_t MY_CS_PRIMARY
Definition: m_ctype.h:122
bool my_binary_compare(const CHARSET_INFO *cs)
Definition: m_ctype.h:619
static constexpr uint32_t MY_CS_COMPILED
Definition: m_ctype.h:112
static constexpr uint8_t MY_CHAR_B
Definition: m_ctype.h:547
int my_strnncoll(const CHARSET_INFO *cs, const uint8_t *a, size_t a_length, const uint8_t *b, size_t b_length)
Definition: m_ctype.h:633
bool my_isgraph(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:601
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_filename
Definition: ctype-utf8.cc:7056
static constexpr uint32_t MY_CS_CSSORT
Definition: m_ctype.h:136
char my_toupper(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:559
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf32_unicode_ci
Definition: ctype-uca.cc:7836
Pad_attribute
Definition: m_ctype.h:244
@ NO_PAD
Definition: m_ctype.h:244
@ PAD_SPACE
Definition: m_ctype.h:244
static constexpr int MY_CS_TOOSMALL6
Definition: m_ctype.h:101
static constexpr uint8_t MY_CHAR_U
Definition: m_ctype.h:541
static const char * strend(const char *s)
Definition: m_string.h:69
Definition of the global "loglevel" enumeration.
loglevel
Definition: my_loglevel.h:41
static char * path
Definition: mysqldump.cc:149
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1081
Definition: commit_order_queue.h:34
static std::string escape(const std::string &str)
Escapes (only) apostrophes.
Definition: st_units_of_measure.cc:39
bool length(const dd::Spatial_reference_system *srs, const Geometry *g1, double *length, bool *null) noexcept
Computes the length of linestrings and multilinestrings.
Definition: length.cc:76
static Value err()
Create a Value object that represents an error condition.
Definition: json_binary.cc:927
size_t size(const char *const c)
Definition: base64.h:46
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:192
required string key
Definition: replication_asynchronous_connection_failover.proto:60
Definition: m_ctype.h:423
uint8_t casedn_multiply
Definition: m_ctype.h:445
uint8_t pad_char
Definition: m_ctype.h:451
const struct lex_state_maps_st * state_maps
Definition: m_ctype.h:441
const uint16_t * tab_to_uni
Definition: m_ctype.h:438
unsigned binary_number
Definition: m_ctype.h:426
const uint8_t * ctype
Definition: m_ctype.h:433
const char * csname
Definition: m_ctype.h:428
my_wc_t max_sort_char
Definition: m_ctype.h:450
const MY_UNICASE_INFO * caseinfo
Definition: m_ctype.h:440
bool escape_with_backslash_is_dangerous
Definition: m_ctype.h:452
unsigned number
Definition: m_ctype.h:424
const uint8_t * to_lower
Definition: m_ctype.h:434
uint8_t caseup_multiply
Definition: m_ctype.h:444
unsigned mbmaxlenlen
Definition: m_ctype.h:448
unsigned mbmaxlen
Definition: m_ctype.h:447
unsigned strxfrm_multiply
Definition: m_ctype.h:443
MY_COLLATION_HANDLER * coll
Definition: m_ctype.h:456
const uint8_t * sort_order
Definition: m_ctype.h:436
MY_CHARSET_HANDLER * cset
Definition: m_ctype.h:455
const char * m_coll_name
Definition: m_ctype.h:429
const uint8_t * ident_map
Definition: m_ctype.h:442
uint8_t levels_for_compare
Definition: m_ctype.h:453
unsigned mbminlen
Definition: m_ctype.h:446
const MY_UNI_IDX * tab_from_uni
Definition: m_ctype.h:439
struct Coll_param * coll_param
Definition: m_ctype.h:432
struct MY_UCA_INFO * uca
Definition: m_ctype.h:437
const uint8_t * to_upper
Definition: m_ctype.h:435
my_wc_t min_sort_char
Definition: m_ctype.h:449
unsigned primary_number
Definition: m_ctype.h:425
enum Pad_attribute pad_attribute
If this collation is PAD_SPACE, it collates as if all inputs were padded with a given number of space...
Definition: m_ctype.h:465
const char * tailoring
Definition: m_ctype.h:431
unsigned state
Definition: m_ctype.h:427
const char * comment
Definition: m_ctype.h:430
Definition: str_uca_type.h:74
Helper structure to return error messages from collation parser/initializer.
Definition: m_ctype.h:181
unsigned errcode
See include/mysys_err.h.
Definition: m_ctype.h:183
char errarg[errmsg_size]
Error message text.
Definition: m_ctype.h:184
static constexpr int errmsg_size
Definition: m_ctype.h:182
Definition: m_ctype.h:342
size_t(* lengthsp)(const CHARSET_INFO *, const char *ptr, size_t length)
Given a pointer and a length in bytes, returns a new length in bytes where all trailing space charact...
Definition: m_ctype.h:374
double(* strntod)(const CHARSET_INFO *, const char *s, size_t l, const char **e, int *err)
Definition: m_ctype.h:412
long long(* strtoll10)(const CHARSET_INFO *cs, const char *nptr, const char **endptr, int *error)
Definition: m_ctype.h:414
int(* ctype)(const CHARSET_INFO *cs, int *ctype, const uint8_t *s, const uint8_t *e)
Definition: m_ctype.h:382
size_t(* well_formed_len)(const CHARSET_INFO *, const char *b, const char *e, size_t nchars, int *error)
Definition: m_ctype.h:357
size_t(* caseup_str)(const CHARSET_INFO *, char *)
Definition: m_ctype.h:386
unsigned long long(* strntoull10rnd)(const CHARSET_INFO *cs, const char *str, size_t length, int unsigned_fl, const char **endptr, int *error)
Definition: m_ctype.h:416
unsigned(* ismbchar)(const CHARSET_INFO *, const char *, const char *)
Definition: m_ctype.h:345
unsigned long long(* strntoull)(const CHARSET_INFO *, const char *s, size_t l, int base, const char **e, int *err)
Definition: m_ctype.h:410
unsigned long(* strntoul)(const CHARSET_INFO *, const char *s, size_t l, int base, const char **e, int *err)
Definition: m_ctype.h:406
bool(* init)(CHARSET_INFO *, MY_CHARSET_LOADER *loader, MY_CHARSET_ERRMSG *)
Definition: m_ctype.h:343
long(* strntol)(const CHARSET_INFO *, const char *s, size_t l, int base, const char **e, int *err)
Definition: m_ctype.h:404
size_t(* charpos)(const CHARSET_INFO *, const char *b, const char *e, size_t pos)
Return at which byte codepoint number "pos" begins, relative to the start of the string.
Definition: m_ctype.h:355
size_t(* longlong10_to_str)(const CHARSET_INFO *, char *to, size_t n, int radix, long long val)
Definition: m_ctype.h:398
size_t(* numchars)(const CHARSET_INFO *, const char *b, const char *e)
Definition: m_ctype.h:347
size_t(* numcells)(const CHARSET_INFO *, const char *b, const char *e)
Definition: m_ctype.h:375
void(* fill)(const CHARSET_INFO *, char *to, size_t len, int fill)
Definition: m_ctype.h:401
my_charset_conv_wc_mb wc_mb
Definition: m_ctype.h:379
size_t(* scan)(const CHARSET_INFO *, const char *b, const char *e, int sq)
Definition: m_ctype.h:419
long long(* strntoll)(const CHARSET_INFO *, const char *s, size_t l, int base, const char **e, int *err)
Definition: m_ctype.h:408
my_charset_conv_mb_wc mb_wc
Definition: m_ctype.h:378
unsigned(* mbcharlen)(const CHARSET_INFO *, unsigned c)
Definition: m_ctype.h:346
my_charset_conv_case caseup
Definition: m_ctype.h:389
size_t(* casedn_str)(const CHARSET_INFO *, char *)
Definition: m_ctype.h:387
size_t(* long10_to_str)(const CHARSET_INFO *, char *to, size_t n, int radix, long int val)
Definition: m_ctype.h:396
my_charset_conv_case casedn
Definition: m_ctype.h:390
size_t(* snprintf)(const CHARSET_INFO *, char *to, size_t n, const char *fmt,...)
Definition: m_ctype.h:393
Definition: m_ctype.h:247
int(* strcasecmp)(const CHARSET_INFO *, const char *, const char *)
Definition: m_ctype.h:311
size_t(* strnxfrm)(const CHARSET_INFO *, uint8_t *dst, size_t dstlen, unsigned num_codepoints, const uint8_t *src, size_t srclen, unsigned flags)
Transform the string into a form such that memcmp() between transformed strings yields the correct co...
Definition: m_ctype.h:288
unsigned(* strstr)(const CHARSET_INFO *, const char *b, size_t b_length, const char *s, size_t s_length, my_match_t *match, unsigned nmatch)
Definition: m_ctype.h:313
bool(* like_range)(const CHARSET_INFO *, const char *s, size_t s_length, char w_prefix, char w_one, char w_many, size_t res_length, char *min_str, char *max_str, size_t *min_len, size_t *max_len)
Definition: m_ctype.h:303
int(* strnncoll)(const CHARSET_INFO *, const uint8_t *, size_t, const uint8_t *, size_t, bool)
Definition: m_ctype.h:251
void(* hash_sort)(const CHARSET_INFO *cs, const uint8_t *key, size_t len, uint64_t *nr1, uint64_t *nr2)
Compute a sort hash for the given key.
Definition: m_ctype.h:328
int(* wildcmp)(const CHARSET_INFO *, const char *str, const char *str_end, const char *wildstr, const char *wildend, int escape, int w_one, int w_many)
Definition: m_ctype.h:307
bool(* propagate)(const CHARSET_INFO *cs, const uint8_t *str, size_t len)
Definition: m_ctype.h:330
bool(* init)(CHARSET_INFO *, MY_CHARSET_LOADER *, MY_CHARSET_ERRMSG *)
Definition: m_ctype.h:248
int(* strnncollsp)(const CHARSET_INFO *, const uint8_t *, size_t, const uint8_t *, size_t)
Compare the two strings under the pad rules given by the collation.
Definition: m_ctype.h:262
size_t(* strnxfrmlen)(const CHARSET_INFO *, size_t num_bytes)
Return the maximum number of output bytes needed for strnxfrm() to output all weights for any string ...
Definition: m_ctype.h:302
void(* uninit)(CHARSET_INFO *, MY_CHARSET_LOADER *)
Definition: m_ctype.h:249
Definition: str_uca_type.h:125
Definition: m_ctype.h:64
uint32_t tolower
Definition: m_ctype.h:66
uint32_t toupper
Definition: m_ctype.h:65
uint32_t sort
Definition: m_ctype.h:67
Definition: m_ctype.h:70
const MY_UNICASE_CHARACTER ** page
Definition: m_ctype.h:72
my_wc_t maxchar
Definition: m_ctype.h:71
Definition: m_ctype.h:77
uint8_t * ctype
Definition: m_ctype.h:79
uint8_t pctype
Definition: m_ctype.h:78
Definition: m_ctype.h:164
uint16_t to
Definition: m_ctype.h:166
uint16_t from
Definition: m_ctype.h:165
const uint8_t * tab
Definition: m_ctype.h:167
Definition: sql_chars.h:90
Definition: m_ctype.h:170
unsigned mb_len
Definition: m_ctype.h:173
unsigned beg
Definition: m_ctype.h:171
unsigned end
Definition: m_ctype.h:172
int n
Definition: xcom_base.cc:509