← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/charset_info.h

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/charset_info.h
23
23
#include <sys/types.h>
24
24
#include <cstddef>
25
25
 
 
26
#include "drizzled/visibility.h"
 
27
 
26
28
namespace drizzled
27
29
{
28
30
 
322
324
#define ILLEGAL_CHARSET_INFO_NUMBER (UINT32_MAX)
323
325
 
324
326
 
325
 
extern CHARSET_INFO my_charset_bin;
326
 
extern CHARSET_INFO my_charset_utf8mb4_bin;
327
 
extern CHARSET_INFO my_charset_utf8mb4_general_ci;
328
 
extern CHARSET_INFO my_charset_utf8mb4_unicode_ci;
 
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;
329
331
 
330
332
#define MY_UTF8MB4                 "utf8"
331
333
#define my_charset_utf8_general_ci ::drizzled::my_charset_utf8mb4_general_ci
684
686
  return (c | 64);
685
687
}
686
688
 
687
 
inline static char my_toupper(const charset_info_st *s, char c)
688
 
{
689
 
  return (char)(s->to_upper[(unsigned char)c]);
690
 
}
691
 
 
692
 
inline static char my_tolower(const charset_info_st *s, char c)
693
 
{
694
 
  return (char)(s->to_lower[(unsigned char)c]);
695
 
}
696
 
 
697
 
inline static bool my_isalpha(const charset_info_st *s, char c)
698
 
{
699
 
  return ((s->ctype+1)[(unsigned char)c] & (_MY_U | _MY_L));
700
 
}
701
 
 
702
 
inline static bool my_isupper(const charset_info_st *s, char c)
703
 
{
704
 
  return ((s->ctype+1)[(unsigned char)c] & _MY_U);
705
 
}
706
 
 
707
 
inline static bool my_islower(const charset_info_st *s, char c)
708
 
{
709
 
  return ((s->ctype+1)[(unsigned char)c] & _MY_L);
710
 
}
711
 
 
712
 
inline static bool my_isdigit(const charset_info_st *s, char c)
713
 
{
714
 
  return ((s->ctype+1)[(unsigned char)c] & _MY_NMR);
715
 
}
716
 
 
717
 
inline static bool my_isxdigit(const charset_info_st *s, char c)
718
 
{
719
 
  return ((s->ctype+1)[(unsigned char)c] & _MY_X);
720
 
}
721
 
 
722
 
inline static bool my_isalnum(const charset_info_st *s, char c) 
723
 
{
724
 
  return ((s->ctype+1)[(unsigned char)c] & (_MY_U | _MY_L | _MY_NMR));
725
 
}
726
 
 
727
 
inline static bool my_isspace(const charset_info_st *s, char c)
728
 
{
729
 
  return ((s->ctype+1)[(unsigned char)c] & _MY_SPC);
730
 
}
731
 
 
732
 
inline static bool my_ispunct(const charset_info_st *s, char c)  
733
 
{
734
 
  return ((s->ctype+1)[(unsigned char)c] & _MY_PNT);
735
 
}
736
 
 
737
 
inline static bool my_isprint(const charset_info_st *s, char c)  
738
 
{
739
 
  return ((s->ctype+1)[(unsigned char)c] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR | _MY_B));
740
 
}
741
 
 
742
 
inline static bool my_isgraph(const charset_info_st *s, char c)
743
 
{
744
 
  return ((s->ctype+1)[(unsigned char)c] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR));
745
 
}
746
 
 
747
 
inline static bool my_iscntrl(const charset_info_st *s, char c)  
748
 
{
749
 
  return ((s->ctype+1)[(unsigned char)c] & _MY_CTR);
 
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;
750
752
}
751
753
 
752
754
/* Some macros that should be cleaned up a little */
753
755
inline static bool my_isvar(const charset_info_st *s, char c)
754
756
{
755
 
  return (my_isalnum(s,c) || (c) == '_');
 
757
  return my_isalnum(s,c) || (c) == '_';
756
758
}
757
759
 
758
760
inline static bool my_isvar_start(const charset_info_st *s, char c)
759
761
{
760
 
  return (my_isalpha(s,c) || (c) == '_');
 
762
  return my_isalpha(s,c) || (c) == '_';
761
763
}
762
764
 
763
765
inline static bool my_binary_compare(const charset_info_st *s)
764
766
{
765
 
  return (s->state  & MY_CS_BINSORT);
 
767
  return s->state  & MY_CS_BINSORT;
766
768
}
767
769
 
768
770
inline static bool use_strnxfrm(const charset_info_st *s)
769
771
{
770
 
  return (s->state & MY_CS_STRNXFRM);
 
772
  return s->state & MY_CS_STRNXFRM;
771
773
}
772
774
 
773
775
inline static size_t my_strnxfrm(const charset_info_st *cs, 
819
821
inline static size_t my_charpos(const charset_info_st *cs, 
820
822
                                const CHAR_T *b, const CHAR_T* e, size_t num)
821
823
{
822
 
  return (cs->cset->charpos(cs, (const char*) b, (const char *)e, num));
 
824
  return cs->cset->charpos(cs, reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(e), num);
823
825
}
824
826
 
825
827
inline static bool use_mb(const charset_info_st *cs)
826
828
{
827
 
  return (cs->cset->ismbchar != NULL);
 
829
  return cs->cset->ismbchar != NULL;
828
830
}
829
831
 
830
832
inline static unsigned int  my_ismbchar(const charset_info_st *cs, const char *a, const char *b)
831
833
{
832
 
  return (cs->cset->ismbchar(cs, a, b));
 
834
  return cs->cset->ismbchar(cs, a, b);
833
835
}
834
836
 
835
837
inline static unsigned int my_mbcharlen(const charset_info_st *cs, uint32_t c)
836
838
{
837
 
  return (cs->cset->mbcharlen(cs, c));
 
839
  return cs->cset->mbcharlen(cs, c);
838
840
}
839
841
 
840
842
 
841
843
inline static size_t my_caseup_str(const charset_info_st *cs, char *src)
842
844
{
843
 
  return (cs->cset->caseup_str(cs, src));
 
845
  return cs->cset->caseup_str(cs, src);
844
846
}
845
847
 
846
848
inline static size_t my_casedn_str(const charset_info_st *cs, char *src)
847
849
{
848
 
  return (cs->cset->casedn_str(cs, src));
 
850
  return cs->cset->casedn_str(cs, src);
849
851
}
850
852
 
851
853
inline static long my_strntol(const charset_info_st *cs,