← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/charset_info.h

Merge Monty - Change the requirement from either libinnodb to libhaildb. Also, tied it to version 2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/charset_info.h
21
21
#define DRIZZLED_CHARSET_INFO_H
22
22
 
23
23
#include <sys/types.h>
24
 
#include <cstddef>
25
 
 
26
 
#include "drizzled/visibility.h"
27
24
 
28
25
namespace drizzled
29
26
{
68
65
#define MY_CS_TOOSMALL4 -104  /* Need at least 4 bytes: wc_mb and mb_wc */
69
66
#define MY_CS_TOOSMALL5 -105  /* Need at least 5 bytes: wc_mb and mb_wc */
70
67
#define MY_CS_TOOSMALL6 -106  /* Need at least 6 bytes: wc_mb and mb_wc */
71
 
 
72
 
/* A helper function for "need at least n bytes" */
73
 
inline static int my_cs_toosmalln(int n)
74
 
{
75
 
  return -100-n;
76
 
}
 
68
/* A helper macros for "need at least n bytes" */
 
69
#define MY_CS_TOOSMALLN(n)    (-100-(n))
77
70
 
78
71
#define MY_SEQ_INTTAIL  1
79
72
#define MY_SEQ_SPACES   2
245
238
  /* Charset dependant snprintf() */
246
239
  size_t (*snprintf)(const struct charset_info_st * const, char *to, size_t n,
247
240
                     const char *fmt,
248
 
                     ...)
249
 
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
250
 
                         __attribute__((format(printf, 4, 5)))
251
 
#endif
252
 
                         ;
 
241
                     ...) __attribute__((format(printf, 4, 5)));
253
242
  size_t (*long10_to_str)(const struct charset_info_st * const, char *to, size_t n,
254
243
                          int radix, long int val);
255
244
  size_t (*int64_t10_to_str)(const struct charset_info_st * const, char *to, size_t n,
324
313
#define ILLEGAL_CHARSET_INFO_NUMBER (UINT32_MAX)
325
314
 
326
315
 
327
 
extern DRIZZLED_API CHARSET_INFO my_charset_bin;
328
 
extern DRIZZLED_API CHARSET_INFO my_charset_utf8mb4_bin;
329
 
extern DRIZZLED_API CHARSET_INFO my_charset_utf8mb4_general_ci;
330
 
extern DRIZZLED_API CHARSET_INFO my_charset_utf8mb4_unicode_ci;
 
316
extern CHARSET_INFO my_charset_bin;
 
317
extern CHARSET_INFO my_charset_utf8mb4_bin;
 
318
extern CHARSET_INFO my_charset_utf8mb4_general_ci;
 
319
extern CHARSET_INFO my_charset_utf8mb4_unicode_ci;
331
320
 
332
321
#define MY_UTF8MB4                 "utf8"
333
322
#define my_charset_utf8_general_ci ::drizzled::my_charset_utf8mb4_general_ci
666
655
#define _MY_X   0200    /* heXadecimal digit */
667
656
 
668
657
 
669
 
inline static bool my_isascii(char c)      
670
 
{
671
 
  return (!(c & ~0177));
672
 
}
673
 
 
674
 
inline static char my_toascii(char c)
675
 
{
676
 
  return (c & 0177);
677
 
}
678
 
 
679
 
inline static char my_tocntrl(char c) 
680
 
{
681
 
  return (c & 31);
682
 
}
683
 
 
684
 
inline static char my_toprint(char c)
685
 
{
686
 
  return (c | 64);
687
 
}
688
 
 
689
 
inline static char my_toupper(const charset_info_st *s, unsigned char c)
690
 
{
691
 
  return s->to_upper[c];
692
 
}
693
 
 
694
 
inline static char my_tolower(const charset_info_st *s, unsigned char c)
695
 
{
696
 
  return s->to_lower[c];
697
 
}
698
 
 
699
 
inline static bool my_isalpha(const charset_info_st *s, unsigned char c)
700
 
{
701
 
  return (s->ctype+1)[c] & (_MY_U | _MY_L);
702
 
}
703
 
 
704
 
inline static bool my_isupper(const charset_info_st *s, unsigned char c)
705
 
{
706
 
  return (s->ctype+1)[c] & _MY_U;
707
 
}
708
 
 
709
 
inline static bool my_islower(const charset_info_st *s, unsigned char c)
710
 
{
711
 
  return (s->ctype+1)[c] & _MY_L;
712
 
}
713
 
 
714
 
inline static bool my_isdigit(const charset_info_st *s, unsigned char c)
715
 
{
716
 
  return (s->ctype+1)[c] & _MY_NMR;
717
 
}
718
 
 
719
 
inline static bool my_isxdigit(const charset_info_st *s, unsigned char c)
720
 
{
721
 
  return (s->ctype+1)[c] & _MY_X;
722
 
}
723
 
 
724
 
inline static bool my_isalnum(const charset_info_st *s, unsigned char c) 
725
 
{
726
 
  return (s->ctype+1)[c] & (_MY_U | _MY_L | _MY_NMR);
727
 
}
728
 
 
729
 
inline static bool my_isspace(const charset_info_st *s, unsigned char c)
730
 
{
731
 
  return (s->ctype+1)[c] & _MY_SPC;
732
 
}
733
 
 
734
 
inline static bool my_ispunct(const charset_info_st *s, unsigned char c)  
735
 
{
736
 
  return (s->ctype+1)[c] & _MY_PNT;
737
 
}
738
 
 
739
 
inline static bool my_isprint(const charset_info_st *s, unsigned char c)  
740
 
{
741
 
  return (s->ctype+1)[c] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR | _MY_B);
742
 
}
743
 
 
744
 
inline static bool my_isgraph(const charset_info_st *s, unsigned char c)
745
 
{
746
 
  return (s->ctype+1)[c] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR);
747
 
}
748
 
 
749
 
inline static bool my_iscntrl(const charset_info_st *s, unsigned char c)  
750
 
{
751
 
  return (s->ctype+1)[c] & _MY_CTR;
752
 
}
 
658
#define my_isascii(c)   (!((c) & ~0177))
 
659
#define my_toascii(c)   ((c) & 0177)
 
660
#define my_tocntrl(c)   ((c) & 31)
 
661
#define my_toprint(c)   ((c) | 64)
 
662
#define my_toupper(s,c) (char) ((s)->to_upper[(unsigned char) (c)])
 
663
#define my_tolower(s,c) (char) ((s)->to_lower[(unsigned char) (c)])
 
664
#define my_isalpha(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & (_MY_U | _MY_L))
 
665
#define my_isupper(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & _MY_U)
 
666
#define my_islower(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & _MY_L)
 
667
#define my_isdigit(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & _MY_NMR)
 
668
#define my_isxdigit(s, c) (((s)->ctype+1)[(unsigned char) (c)] & _MY_X)
 
669
#define my_isalnum(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & (_MY_U | _MY_L | _MY_NMR))
 
670
#define my_isspace(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & _MY_SPC)
 
671
#define my_ispunct(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & _MY_PNT)
 
672
#define my_isprint(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR | _MY_B))
 
673
#define my_isgraph(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR))
 
674
#define my_iscntrl(s, c)  (((s)->ctype+1)[(unsigned char) (c)] & _MY_CTR)
753
675
 
754
676
/* Some macros that should be cleaned up a little */
755
 
inline static bool my_isvar(const charset_info_st *s, char c)
756
 
{
757
 
  return my_isalnum(s,c) || (c) == '_';
758
 
}
759
 
 
760
 
inline static bool my_isvar_start(const charset_info_st *s, char c)
761
 
{
762
 
  return my_isalpha(s,c) || (c) == '_';
763
 
}
764
 
 
765
 
inline static bool my_binary_compare(const charset_info_st *s)
766
 
{
767
 
  return s->state  & MY_CS_BINSORT;
768
 
}
769
 
 
770
 
inline static bool use_strnxfrm(const charset_info_st *s)
771
 
{
772
 
  return s->state & MY_CS_STRNXFRM;
773
 
}
774
 
 
775
 
inline static size_t my_strnxfrm(const charset_info_st *cs, 
776
 
                                 unsigned char *dst, 
777
 
                                 const size_t dstlen, 
778
 
                                 const unsigned char *src, 
779
 
                                 const uint32_t srclen)
780
 
{
781
 
  return (cs->coll->strnxfrm(cs, dst, dstlen, dstlen, src, srclen, MY_STRXFRM_PAD_WITH_SPACE));
782
 
}
783
 
 
784
 
inline static int my_strnncoll(const charset_info_st *cs, 
785
 
                               const unsigned char *s, 
786
 
                               const size_t slen, 
787
 
                               const unsigned char *t,
788
 
                               const size_t tlen) 
789
 
{
790
 
  return (cs->coll->strnncoll(cs, s, slen, t, tlen, 0));
791
 
}
792
 
 
793
 
inline static bool my_like_range(const charset_info_st *cs,
794
 
                                 const char *ptr, const size_t ptrlen,
795
 
                                 const char escape, 
796
 
                                 const char w_one,
797
 
                                 const char w_many, 
798
 
                                 const size_t reslen, 
799
 
                                 char *minstr, char *maxstr, 
800
 
                                 size_t *minlen, size_t *maxlen)
801
 
{
802
 
  return (cs->coll->like_range(cs, ptr, ptrlen, escape, w_one, w_many, reslen, 
803
 
                               minstr, maxstr, minlen, maxlen));
804
 
}
805
 
 
806
 
inline static int my_wildcmp(const charset_info_st *cs,
807
 
                             const char *str, const char *strend,
808
 
                             const char *w_str, const char *w_strend,
809
 
                             const int escape,
810
 
                             const int w_one, const int w_many) 
811
 
{
812
 
  return (cs->coll->wildcmp(cs, str, strend, w_str, w_strend, escape, w_one, w_many));
813
 
}
814
 
 
815
 
inline static int my_strcasecmp(const charset_info_st *cs, const char *s, const char *t)
816
 
{
817
 
  return (cs->coll->strcasecmp(cs, s, t));
818
 
}
819
 
 
820
 
template <typename CHAR_T>
821
 
inline static size_t my_charpos(const charset_info_st *cs, 
822
 
                                const CHAR_T *b, const CHAR_T* e, size_t num)
823
 
{
824
 
  return cs->cset->charpos(cs, reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(e), num);
825
 
}
826
 
 
827
 
inline static bool use_mb(const charset_info_st *cs)
828
 
{
829
 
  return cs->cset->ismbchar != NULL;
830
 
}
831
 
 
832
 
inline static unsigned int  my_ismbchar(const charset_info_st *cs, const char *a, const char *b)
833
 
{
834
 
  return cs->cset->ismbchar(cs, a, b);
835
 
}
836
 
 
837
 
inline static unsigned int my_mbcharlen(const charset_info_st *cs, uint32_t c)
838
 
{
839
 
  return cs->cset->mbcharlen(cs, c);
840
 
}
841
 
 
842
 
 
843
 
inline static size_t my_caseup_str(const charset_info_st *cs, char *src)
844
 
{
845
 
  return cs->cset->caseup_str(cs, src);
846
 
}
847
 
 
848
 
inline static size_t my_casedn_str(const charset_info_st *cs, char *src)
849
 
{
850
 
  return cs->cset->casedn_str(cs, src);
851
 
}
852
 
 
853
 
inline static long my_strntol(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->strntol(cs, s, l, base, e, err));
857
 
}
858
 
 
859
 
inline static unsigned long my_strntoul(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->strntoul(cs, s, l, base, e, err));
864
 
}
865
 
 
866
 
inline static int64_t my_strntoll(const charset_info_st *cs, 
867
 
                                 const char* s, const size_t l, const int base, char **e, int *err)
868
 
{
869
 
  return (cs->cset->strntoll(cs, s, l, base, e, err));
870
 
}
871
 
 
872
 
inline static int64_t my_strntoull(const charset_info_st *cs, 
873
 
                                   const char* s, const size_t l, const int base, 
874
 
                                   char **e, int *err)
875
 
{
876
 
  return (cs->cset->strntoull(cs, s, l, base, e, err));
877
 
}
878
 
 
879
 
 
880
 
inline static double my_strntod(const charset_info_st *cs, 
881
 
                                char* s, const size_t l, char **e, int *err)
882
 
{
883
 
  return (cs->cset->strntod(cs, s, l, e, err));
884
 
}
 
677
#define my_isvar(s,c)                 (my_isalnum(s,c) || (c) == '_')
 
678
#define my_isvar_start(s,c)           (my_isalpha(s,c) || (c) == '_')
 
679
 
 
680
#define my_binary_compare(s)          ((s)->state  & MY_CS_BINSORT)
 
681
#define use_strnxfrm(s)               ((s)->state  & MY_CS_STRNXFRM)
 
682
#define my_strnxfrm(cs, d, dl, s, sl) \
 
683
   ((cs)->coll->strnxfrm((cs), (d), (dl), (dl), (s), (sl), MY_STRXFRM_PAD_WITH_SPACE))
 
684
#define my_strnncoll(s, a, b, c, d) ((s)->coll->strnncoll((s), (a), (b), (c), (d), 0))
 
685
#define my_like_range(s, a, b, c, d, e, f, g, h, i, j) \
 
686
   ((s)->coll->like_range((s), (a), (b), (c), (d), (e), (f), (g), (h), (i), (j)))
 
687
#define my_wildcmp(cs,s,se,w,we,e,o,m) ((cs)->coll->wildcmp((cs),(s),(se),(w),(we),(e),(o),(m)))
 
688
#define my_strcasecmp(s, a, b)        ((s)->coll->strcasecmp((s), (a), (b)))
 
689
#define my_charpos(cs, b, e, num)     (cs)->cset->charpos((cs), (const char*) (b), (const char *)(e), (num))
 
690
 
 
691
 
 
692
#define use_mb(s)                     ((s)->cset->ismbchar != NULL)
 
693
#define my_ismbchar(s, a, b)          ((s)->cset->ismbchar((s), (a), (b)))
 
694
#define my_mbcharlen(s, a)            ((s)->cset->mbcharlen((s),(a)))
 
695
 
 
696
#define my_caseup_str(s, a)           ((s)->cset->caseup_str((s), (a)))
 
697
#define my_casedn_str(s, a)           ((s)->cset->casedn_str((s), (a)))
 
698
#define my_strntol(s, a, b, c, d, e)  ((s)->cset->strntol((s),(a),(b),(c),(d),(e)))
 
699
#define my_strntoul(s, a, b, c, d, e) ((s)->cset->strntoul((s),(a),(b),(c),(d),(e)))
 
700
#define my_strntoll(s, a, b, c, d, e) ((s)->cset->strntoll((s),(a),(b),(c),(d),(e)))
 
701
#define my_strntoull(s, a, b, c,d, e) ((s)->cset->strntoull((s),(a),(b),(c),(d),(e)))
 
702
#define my_strntod(s, a, b, c, d)     ((s)->cset->strntod((s),(a),(b),(c),(d)))
885
703
 
886
704
int make_escape_code(const CHARSET_INFO * const cs, const char *escape);
887
705