← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/charset.c

  • Committer: Monty Taylor
  • Date: 2008-09-15 17:24:04 UTC
  • Revision ID: monty@inaugust.com-20080915172404-ygh6hiyu0q7qpa9x
Removed strndup calls.

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
 
118
118
 
 
119
#define MY_MAX_ALLOWED_BUF 1024*1024
119
120
#define MY_CHARSET_INDEX "Index.xml"
120
121
 
121
122
const char *charsets_dir= NULL;
133
134
  {
134
135
    if (test_if_hard_path(sharedir) ||
135
136
        is_prefix(sharedir, DEFAULT_CHARSET_HOME))
136
 
      strxmov(buf, sharedir, "/", CHARSET_DIR, NULL);
 
137
      strxmov(buf, sharedir, "/", CHARSET_DIR, NullS);
137
138
    else
138
139
      strxmov(buf, DEFAULT_CHARSET_HOME, "/", sharedir, "/", CHARSET_DIR,
139
 
              NULL);
 
140
              NullS);
140
141
  }
141
 
  res= convert_dirname(buf,buf,NULL);
 
142
  res= convert_dirname(buf,buf,NullS);
142
143
  return(res);
143
144
}
144
145
 
191
192
        }
192
193
      }
193
194
      
194
 
      my_stpcpy(get_charsets_dir(fname), MY_CHARSET_INDEX);
 
195
      stpcpy(get_charsets_dir(fname), MY_CHARSET_INDEX);
195
196
      charset_initialized=1;
196
197
    }
197
198
    pthread_mutex_unlock(&THR_LOCK_charset);
206
207
}
207
208
 
208
209
 
209
 
uint32_t get_collation_number(const char *name)
 
210
uint get_collation_number(const char *name)
210
211
{
211
212
  init_available_charsets(MYF(0));
212
213
  return get_collation_number_internal(name);
213
214
}
214
215
 
215
216
 
216
 
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)
217
218
{
218
219
  CHARSET_INFO **cs;
219
220
  init_available_charsets(MYF(0));
230
231
}
231
232
 
232
233
 
233
 
const char *get_charset_name(uint32_t charset_number)
 
234
const char *get_charset_name(uint charset_number)
234
235
{
235
236
  const CHARSET_INFO *cs;
236
237
  init_available_charsets(MYF(0));
243
244
}
244
245
 
245
246
 
246
 
static const CHARSET_INFO *get_internal_charset(uint32_t cs_number)
 
247
static const CHARSET_INFO *get_internal_charset(uint cs_number)
247
248
{
248
249
  CHARSET_INFO *cs;
249
250
  /*
272
273
}
273
274
 
274
275
 
275
 
const const CHARSET_INFO *get_charset(uint32_t cs_number, myf flags)
 
276
const const CHARSET_INFO *get_charset(uint cs_number, myf flags)
276
277
{
277
278
  const CHARSET_INFO *cs;
278
279
  if (cs_number == default_charset_info->number)
288
289
  if (!cs && (flags & MY_WME))
289
290
  {
290
291
    char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)], cs_string[23];
291
 
    my_stpcpy(get_charsets_dir(index_file),MY_CHARSET_INDEX);
 
292
    stpcpy(get_charsets_dir(index_file),MY_CHARSET_INDEX);
292
293
    cs_string[0]='#';
293
294
    int10_to_str(cs_number, cs_string+1, 10);
294
295
    my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_string, index_file);
298
299
 
299
300
const CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags)
300
301
{
301
 
  uint32_t cs_number;
 
302
  uint cs_number;
302
303
  const CHARSET_INFO *cs;
303
304
  (void) init_available_charsets(MYF(0));       /* If it isn't initialized */
304
305
 
308
309
  if (!cs && (flags & MY_WME))
309
310
  {
310
311
    char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
311
 
    my_stpcpy(get_charsets_dir(index_file),MY_CHARSET_INDEX);
 
312
    stpcpy(get_charsets_dir(index_file),MY_CHARSET_INDEX);
312
313
    my_error(EE_UNKNOWN_COLLATION, MYF(ME_BELL), cs_name, index_file);
313
314
  }
314
315
 
317
318
 
318
319
 
319
320
const CHARSET_INFO *get_charset_by_csname(const char *cs_name,
320
 
                                    uint32_t cs_flags,
 
321
                                    uint cs_flags,
321
322
                                    myf flags)
322
323
{
323
 
  uint32_t cs_number;
 
324
  uint cs_number;
324
325
  const CHARSET_INFO *cs;
325
326
 
326
327
  (void) init_available_charsets(MYF(0));       /* If it isn't initialized */
331
332
  if (!cs && (flags & MY_WME))
332
333
  {
333
334
    char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
334
 
    my_stpcpy(get_charsets_dir(index_file),MY_CHARSET_INDEX);
 
335
    stpcpy(get_charsets_dir(index_file),MY_CHARSET_INDEX);
335
336
    my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_name, index_file);
336
337
  }
337
338