← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/charset.cc

Refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/charset.cc
25
25
 
26
26
using namespace std;
27
27
 
28
 
namespace drizzled {
 
28
namespace drizzled
 
29
{
29
30
 
30
31
/*
31
32
  We collect memory in this vector that we free on delete.
42
43
    - Setting server default character set
43
44
*/
44
45
 
45
 
bool my_charset_same(const charset_info_st *cs1, const charset_info_st *cs2)
46
 
{
47
 
  return cs1 == cs2 || not strcmp(cs1->csname, cs2->csname);
 
46
bool my_charset_same(const charset_info_st *cs1, const charset_info_st *cs2)
 
47
{
 
48
  return ((cs1 == cs2) || !strcmp(cs1->csname,cs2->csname));
48
49
}
49
50
 
50
 
static uint get_collation_number_internal(const char *name)
 
51
 
 
52
static uint
 
53
get_collation_number_internal(const char *name)
51
54
{
52
55
  for (charset_info_st **cs= all_charsets;
53
56
       cs < all_charsets+array_elements(all_charsets)-1;
61
64
  return 0;
62
65
}
63
66
 
64
 
static unsigned char* cs_alloc(size_t size)
 
67
static unsigned char *cs_alloc(size_t size)
65
68
{
66
69
  memory_vector.push_back(new unsigned char[size]);
67
70
  return memory_vector.back();
68
71
}
69
72
 
70
 
static void init_state_maps(charset_info_st *cs)
 
73
static bool init_state_maps(charset_info_st *cs)
71
74
{
72
 
  cs->state_map= cs_alloc(256);
73
 
  cs->ident_map= cs_alloc(256);
 
75
  if (!(cs->state_map= cs_alloc(256)))
 
76
    return 1;
 
77
    
 
78
  if (!(cs->ident_map= cs_alloc(256)))
 
79
    return 1;
74
80
 
75
81
  unsigned char *state_map= cs->state_map;
76
82
  unsigned char *ident_map= cs->ident_map;
117
123
  /* Special handling of hex and binary strings */
118
124
  state_map['x']= state_map['X']=  MY_LEX_IDENT_OR_HEX;
119
125
  state_map['b']= state_map['B']=  MY_LEX_IDENT_OR_BIN;
 
126
  return 0;
120
127
}
121
128
 
122
129
static bool charset_initialized= false;
130
137
  cs->state|= MY_CS_AVAILABLE;
131
138
}
132
139
 
133
 
static void init_available_charsets(myf myflags)
 
140
static bool init_available_charsets(myf myflags)
134
141
{
 
142
  bool error= false;
135
143
  /*
136
144
    We have to use charset_initialized to not lock on THR_LOCK_charset
137
145
    inside get_internal_charset...
138
146
  */
139
 
  if (charset_initialized)
140
 
    return;
141
 
  memset(&all_charsets, 0, sizeof(all_charsets));
142
 
  init_compiled_charsets(myflags);
143
 
 
144
 
  /* Copy compiled charsets */
145
 
  for (charset_info_st**cs= all_charsets;
146
 
    cs < all_charsets+array_elements(all_charsets)-1;
147
 
    cs++)
 
147
  if (charset_initialized == false)
148
148
  {
149
 
    if (*cs && cs[0]->ctype)
150
 
      init_state_maps(*cs);
 
149
    charset_info_st **cs;
 
150
    memset(&all_charsets, 0, sizeof(all_charsets));
 
151
    init_compiled_charsets(myflags);
 
152
 
 
153
    /* Copy compiled charsets */
 
154
    for (cs=all_charsets;
 
155
         cs < all_charsets+array_elements(all_charsets)-1 ;
 
156
         cs++)
 
157
    {
 
158
      if (*cs)
 
159
      {
 
160
        if (cs[0]->ctype)
 
161
          if (init_state_maps(*cs))
 
162
            *cs= NULL;
 
163
      }
 
164
    }
 
165
 
 
166
    charset_initialized= true;
151
167
  }
 
168
  assert(charset_initialized);
152
169
 
153
 
  charset_initialized= true;
 
170
  return error;
154
171
}
155
172
 
 
173
 
156
174
void free_charsets()
157
175
{
158
176
  charset_initialized= false;
164
182
  }
165
183
}
166
184
 
 
185
 
167
186
uint32_t get_collation_number(const char *name)
168
187
{
169
188
  init_available_charsets(MYF(0));
170
189
  return get_collation_number_internal(name);
171
190
}
172
191
 
 
192
 
173
193
uint32_t get_charset_number(const char *charset_name, uint32_t cs_flags)
174
194
{
175
195
  charset_info_st **cs;
185
205
  return 0;
186
206
}
187
207
 
 
208
 
188
209
const char *get_charset_name(uint32_t charset_number)
189
210
{
190
211
  init_available_charsets(MYF(0));
196
217
  return "?";   /* this mimics find_type() */
197
218
}
198
219
 
 
220
 
199
221
static const charset_info_st *get_internal_charset(uint32_t cs_number)
200
222
{
201
223
  charset_info_st *cs;
223
245
  return cs;
224
246
}
225
247
 
 
248
 
226
249
const charset_info_st *get_charset(uint32_t cs_number)
227
250
{
 
251
  const charset_info_st *cs;
228
252
  if (cs_number == default_charset_info->number)
229
253
    return default_charset_info;
230
254
 
231
 
  init_available_charsets(MYF(0));      /* If it isn't initialized */
 
255
  (void) init_available_charsets(MYF(0));       /* If it isn't initialized */
232
256
 
233
257
  if (!cs_number || cs_number >= array_elements(all_charsets)-1)
234
258
    return NULL;
235
259
 
236
 
  return get_internal_charset(cs_number);
 
260
  cs= get_internal_charset(cs_number);
 
261
 
 
262
  return cs;
237
263
}
238
264
 
239
265
const charset_info_st *get_charset_by_name(const char *cs_name)
240
266
{
241
 
  init_available_charsets(MYF(0));      /* If it isn't initialized */
242
 
  uint32_t cs_number= get_collation_number(cs_name);
243
 
  return cs_number ? get_internal_charset(cs_number) : NULL;
 
267
  uint32_t cs_number;
 
268
  const charset_info_st *cs;
 
269
  (void) init_available_charsets(MYF(0));       /* If it isn't initialized */
 
270
 
 
271
  cs_number= get_collation_number(cs_name);
 
272
  cs= cs_number ? get_internal_charset(cs_number) : NULL;
 
273
 
 
274
  return cs;
244
275
}
245
276
 
 
277
 
246
278
const charset_info_st *get_charset_by_csname(const char *cs_name, uint32_t cs_flags)
247
279
{
248
 
  init_available_charsets(MYF(0));      /* If it isn't initialized */
249
 
  uint32_t cs_number= get_charset_number(cs_name, cs_flags);
250
 
  return cs_number ? get_internal_charset(cs_number) : NULL;
 
280
  uint32_t cs_number;
 
281
  const charset_info_st *cs;
 
282
 
 
283
  (void) init_available_charsets(MYF(0));       /* If it isn't initialized */
 
284
 
 
285
  cs_number= get_charset_number(cs_name, cs_flags);
 
286
  cs= cs_number ? get_internal_charset(cs_number) : NULL;
 
287
 
 
288
  return(cs);
251
289
}
252
290
 
253
291