← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/charset.c

  • Committer: Lee
  • Date: 2008-10-03 23:31:06 UTC
  • mfrom: (413.2.3 drizzle)
  • mto: This revision was merged to the branch mainline in revision 459.
  • Revision ID: lbieber@lbieber-desktop-20081003233106-tgvzu0fh25gb3xeg
breaking out enum field classes

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/charset.c
54
54
 
55
55
static bool init_state_maps(CHARSET_INFO *cs)
56
56
{
57
 
  uint32_t i;
58
 
  unsigned char *state_map;
59
 
  unsigned char *ident_map;
 
57
  uint i;
 
58
  uchar *state_map;
 
59
  uchar *ident_map;
60
60
 
61
 
  if (!(cs->state_map= (unsigned char*) my_once_alloc(256, MYF(MY_WME))))
 
61
  if (!(cs->state_map= (uchar*) my_once_alloc(256, MYF(MY_WME))))
62
62
    return 1;
63
63
    
64
 
  if (!(cs->ident_map= (unsigned char*) my_once_alloc(256, MYF(MY_WME))))
 
64
  if (!(cs->ident_map= (uchar*) my_once_alloc(256, MYF(MY_WME))))
65
65
    return 1;
66
66
 
67
67
  state_map= cs->state_map;
71
71
  for (i=0; i < 256 ; i++)
72
72
  {
73
73
    if (my_isalpha(cs,i))
74
 
      state_map[i]=(unsigned char) MY_LEX_IDENT;
 
74
      state_map[i]=(uchar) MY_LEX_IDENT;
75
75
    else if (my_isdigit(cs,i))
76
 
      state_map[i]=(unsigned char) MY_LEX_NUMBER_IDENT;
 
76
      state_map[i]=(uchar) MY_LEX_NUMBER_IDENT;
77
77
#if defined(USE_MB) && defined(USE_MB_IDENT)
78
78
    else if (my_mbcharlen(cs, i)>1)
79
 
      state_map[i]=(unsigned char) MY_LEX_IDENT;
 
79
      state_map[i]=(uchar) MY_LEX_IDENT;
80
80
#endif
81
81
    else if (my_isspace(cs,i))
82
 
      state_map[i]=(unsigned char) MY_LEX_SKIP;
 
82
      state_map[i]=(uchar) MY_LEX_SKIP;
83
83
    else
84
 
      state_map[i]=(unsigned char) MY_LEX_CHAR;
 
84
      state_map[i]=(uchar) MY_LEX_CHAR;
85
85
  }
86
 
  state_map[(unsigned char)'_']=state_map[(unsigned char)'$']=(unsigned char) MY_LEX_IDENT;
87
 
  state_map[(unsigned char)'\'']=(unsigned char) MY_LEX_STRING;
88
 
  state_map[(unsigned char)'.']=(unsigned char) MY_LEX_REAL_OR_POINT;
89
 
  state_map[(unsigned char)'>']=state_map[(unsigned char)'=']=state_map[(unsigned char)'!']= (unsigned char) MY_LEX_CMP_OP;
90
 
  state_map[(unsigned char)'<']= (unsigned char) MY_LEX_LONG_CMP_OP;
91
 
  state_map[(unsigned char)'&']=state_map[(unsigned char)'|']=(unsigned char) MY_LEX_BOOL;
92
 
  state_map[(unsigned char)'#']=(unsigned char) MY_LEX_COMMENT;
93
 
  state_map[(unsigned char)';']=(unsigned char) MY_LEX_SEMICOLON;
94
 
  state_map[(unsigned char)':']=(unsigned char) MY_LEX_SET_VAR;
95
 
  state_map[0]=(unsigned char) MY_LEX_EOL;
96
 
  state_map[(unsigned char)'\\']= (unsigned char) MY_LEX_ESCAPE;
97
 
  state_map[(unsigned char)'/']= (unsigned char) MY_LEX_LONG_COMMENT;
98
 
  state_map[(unsigned char)'*']= (unsigned char) MY_LEX_END_LONG_COMMENT;
99
 
  state_map[(unsigned char)'@']= (unsigned char) MY_LEX_USER_END;
100
 
  state_map[(unsigned char) '`']= (unsigned char) MY_LEX_USER_VARIABLE_DELIMITER;
101
 
  state_map[(unsigned char)'"']= (unsigned char) MY_LEX_STRING_OR_DELIMITER;
 
86
  state_map[(uchar)'_']=state_map[(uchar)'$']=(uchar) MY_LEX_IDENT;
 
87
  state_map[(uchar)'\'']=(uchar) MY_LEX_STRING;
 
88
  state_map[(uchar)'.']=(uchar) MY_LEX_REAL_OR_POINT;
 
89
  state_map[(uchar)'>']=state_map[(uchar)'=']=state_map[(uchar)'!']= (uchar) MY_LEX_CMP_OP;
 
90
  state_map[(uchar)'<']= (uchar) MY_LEX_LONG_CMP_OP;
 
91
  state_map[(uchar)'&']=state_map[(uchar)'|']=(uchar) MY_LEX_BOOL;
 
92
  state_map[(uchar)'#']=(uchar) MY_LEX_COMMENT;
 
93
  state_map[(uchar)';']=(uchar) MY_LEX_SEMICOLON;
 
94
  state_map[(uchar)':']=(uchar) MY_LEX_SET_VAR;
 
95
  state_map[0]=(uchar) MY_LEX_EOL;
 
96
  state_map[(uchar)'\\']= (uchar) MY_LEX_ESCAPE;
 
97
  state_map[(uchar)'/']= (uchar) MY_LEX_LONG_COMMENT;
 
98
  state_map[(uchar)'*']= (uchar) MY_LEX_END_LONG_COMMENT;
 
99
  state_map[(uchar)'@']= (uchar) MY_LEX_USER_END;
 
100
  state_map[(uchar) '`']= (uchar) MY_LEX_USER_VARIABLE_DELIMITER;
 
101
  state_map[(uchar)'"']= (uchar) MY_LEX_STRING_OR_DELIMITER;
102
102
 
103
103
  /*
104
104
    Create a second map to make it faster to find identifiers
105
105
  */
106
106
  for (i=0; i < 256 ; i++)
107
107
  {
108
 
    ident_map[i]= (unsigned char) (state_map[i] == MY_LEX_IDENT ||
 
108
    ident_map[i]= (uchar) (state_map[i] == MY_LEX_IDENT ||
109
109
                           state_map[i] == MY_LEX_NUMBER_IDENT);
110
110
  }
111
111
 
112
112
  /* Special handling of hex and binary strings */
113
 
  state_map[(unsigned char)'x']= state_map[(unsigned char)'X']= (unsigned char) MY_LEX_IDENT_OR_HEX;
114
 
  state_map[(unsigned char)'b']= state_map[(unsigned char)'B']= (unsigned char) MY_LEX_IDENT_OR_BIN;
 
113
  state_map[(uchar)'x']= state_map[(uchar)'X']= (uchar) MY_LEX_IDENT_OR_HEX;
 
114
  state_map[(uchar)'b']= state_map[(uchar)'B']= (uchar) MY_LEX_IDENT_OR_BIN;
115
115
  return 0;
116
116
}
117
117
 
134
134
  {
135
135
    if (test_if_hard_path(sharedir) ||
136
136
        is_prefix(sharedir, DEFAULT_CHARSET_HOME))
137
 
      strxmov(buf, sharedir, "/", CHARSET_DIR, NULL);
 
137
      strxmov(buf, sharedir, "/", CHARSET_DIR, NullS);
138
138
    else
139
139
      strxmov(buf, DEFAULT_CHARSET_HOME, "/", sharedir, "/", CHARSET_DIR,
140
 
              NULL);
 
140
              NullS);
141
141
  }
142
 
  res= convert_dirname(buf,buf,NULL);
 
142
  res= convert_dirname(buf,buf,NullS);
143
143
  return(res);
144
144
}
145
145
 
207
207
}
208
208
 
209
209
 
210
 
uint32_t get_collation_number(const char *name)
 
210
uint get_collation_number(const char *name)
211
211
{
212
212
  init_available_charsets(MYF(0));
213
213
  return get_collation_number_internal(name);
214
214
}
215
215
 
216
216
 
217
 
uint32_t get_charset_number(const char *charset_name, uint32_t cs_flags)
 
217
uint get_charset_number(const char *charset_name, uint cs_flags)
218
218
{
219
219
  CHARSET_INFO **cs;
220
220
  init_available_charsets(MYF(0));
231
231
}
232
232
 
233
233
 
234
 
const char *get_charset_name(uint32_t charset_number)
 
234
const char *get_charset_name(uint charset_number)
235
235
{
236
236
  const CHARSET_INFO *cs;
237
237
  init_available_charsets(MYF(0));
244
244
}
245
245
 
246
246
 
247
 
static const CHARSET_INFO *get_internal_charset(uint32_t cs_number)
 
247
static const CHARSET_INFO *get_internal_charset(uint cs_number)
248
248
{
249
249
  CHARSET_INFO *cs;
250
250
  /*
273
273
}
274
274
 
275
275
 
276
 
const const CHARSET_INFO *get_charset(uint32_t cs_number, myf flags)
 
276
const const CHARSET_INFO *get_charset(uint cs_number, myf flags)
277
277
{
278
278
  const CHARSET_INFO *cs;
279
279
  if (cs_number == default_charset_info->number)
299
299
 
300
300
const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags)
301
301
{
302
 
  uint32_t cs_number;
 
302
  uint cs_number;
303
303
  const CHARSET_INFO *cs;
304
304
  (void) init_available_charsets(MYF(0));       /* If it isn't initialized */
305
305
 
318
318
 
319
319
 
320
320
const CHARSET_INFO *get_charset_by_csname(const char *cs_name,
321
 
                                    uint32_t cs_flags,
 
321
                                    uint cs_flags,
322
322
                                    myf flags)
323
323
{
324
 
  uint32_t cs_number;
 
324
  uint cs_number;
325
325
  const CHARSET_INFO *cs;
326
326
 
327
327
  (void) init_available_charsets(MYF(0));       /* If it isn't initialized */