← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to strings/conf_to_src.c

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
strings/conf_to_src.c
 
1
/* Copyright (C) 2000 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#include <my_global.h>
 
17
#include <m_string.h>
 
18
#include <m_ctype.h>
 
19
#include <fcntl.h>
 
20
#include <my_xml.h>
 
21
 
 
22
#define ROW_LEN         16
 
23
#define ROW16_LEN       8
 
24
#define MAX_BUF         64*1024
 
25
 
 
26
static CHARSET_INFO all_charsets[256];
 
27
 
 
28
 
 
29
void
 
30
print_array(FILE *f, const char *set, const char *name, uchar *a, int n)
 
31
{
 
32
  int i;
 
33
 
 
34
  fprintf(f,"uchar %s_%s[] = {\n", name, set);
 
35
  
 
36
  for (i=0 ;i<n ; i++)
 
37
  {
 
38
    fprintf(f,"0x%02X",a[i]);
 
39
    fprintf(f, (i+1<n) ? "," :"" );
 
40
    fprintf(f, ((i+1) % ROW_LEN == n % ROW_LEN) ? "\n" : "" );
 
41
  }
 
42
  fprintf(f,"};\n\n");
 
43
}
 
44
 
 
45
 
 
46
void
 
47
print_array16(FILE *f, const char *set, const char *name, uint16 *a, int n)
 
48
{
 
49
  int i;
 
50
 
 
51
  fprintf(f,"uint16 %s_%s[] = {\n", name, set);
 
52
  
 
53
  for (i=0 ;i<n ; i++)
 
54
  {
 
55
    fprintf(f,"0x%04X",a[i]);
 
56
    fprintf(f, (i+1<n) ? "," :"" );
 
57
    fprintf(f, ((i+1) % ROW16_LEN == n % ROW16_LEN) ? "\n" : "" );
 
58
  }
 
59
  fprintf(f,"};\n\n");
 
60
}
 
61
 
 
62
 
 
63
static int get_charset_number(const char *charset_name)
 
64
{
 
65
  CHARSET_INFO *cs;
 
66
  for (cs= all_charsets; cs < all_charsets+255; ++cs)
 
67
  {
 
68
    if ( cs->name && !strcmp(cs->name, charset_name))
 
69
      return cs->number;
 
70
  }  
 
71
  return 0;
 
72
}
 
73
 
 
74
char *mdup(const char *src, uint len)
 
75
{
 
76
  char *dst=(char*)malloc(len);
 
77
  if (!dst)
 
78
    exit(1);
 
79
  memcpy(dst,src,len);
 
80
  return dst;
 
81
}
 
82
 
 
83
static void simple_cs_copy_data(CHARSET_INFO *to, CHARSET_INFO *from)
 
84
{
 
85
  to->number= from->number ? from->number : to->number;
 
86
  to->state|= from->state;
 
87
 
 
88
  if (from->csname)
 
89
    to->csname= strdup(from->csname);
 
90
  
 
91
  if (from->name)
 
92
    to->name= strdup(from->name);
 
93
  
 
94
  if (from->ctype)
 
95
    to->ctype= (uchar*) mdup((char*) from->ctype, MY_CS_CTYPE_TABLE_SIZE);
 
96
  if (from->to_lower)
 
97
    to->to_lower= (uchar*) mdup((char*) from->to_lower, MY_CS_TO_LOWER_TABLE_SIZE);
 
98
  if (from->to_upper)
 
99
    to->to_upper= (uchar*) mdup((char*) from->to_upper, MY_CS_TO_UPPER_TABLE_SIZE);
 
100
  if (from->sort_order)
 
101
  {
 
102
    to->sort_order= (uchar*) mdup((char*) from->sort_order, MY_CS_SORT_ORDER_TABLE_SIZE);
 
103
    /*
 
104
      set_max_sort_char(to);
 
105
    */
 
106
  }
 
107
  if (from->tab_to_uni)
 
108
  {
 
109
    uint sz= MY_CS_TO_UNI_TABLE_SIZE*sizeof(uint16);
 
110
    to->tab_to_uni= (uint16*)  mdup((char*)from->tab_to_uni, sz);
 
111
    /*
 
112
    create_fromuni(to);
 
113
    */
 
114
  }
 
115
}
 
116
 
 
117
static my_bool simple_cs_is_full(CHARSET_INFO *cs)
 
118
{
 
119
  return ((cs->csname && cs->tab_to_uni && cs->ctype && cs->to_upper &&
 
120
           cs->to_lower) &&
 
121
          (cs->number && cs->name && 
 
122
          (cs->sort_order || (cs->state & MY_CS_BINSORT))));
 
123
}
 
124
 
 
125
static int add_collation(CHARSET_INFO *cs)
 
126
{
 
127
  if (cs->name && (cs->number || (cs->number=get_charset_number(cs->name))))
 
128
  {
 
129
    if (!(all_charsets[cs->number].state & MY_CS_COMPILED))
 
130
    {
 
131
      simple_cs_copy_data(&all_charsets[cs->number],cs);
 
132
      
 
133
    }
 
134
    
 
135
    cs->number= 0;
 
136
    cs->name= NULL;
 
137
    cs->state= 0;
 
138
    cs->sort_order= NULL;
 
139
    cs->state= 0;
 
140
  }
 
141
  return MY_XML_OK;
 
142
}
 
143
 
 
144
 
 
145
static int my_read_charset_file(const char *filename)
 
146
{
 
147
  char buf[MAX_BUF];
 
148
  int  fd;
 
149
  uint len;
 
150
  
 
151
  if ((fd=open(filename,O_RDONLY)) < 0)
 
152
  {
 
153
    fprintf(stderr,"Can't open '%s'\n",filename);
 
154
    return 1;
 
155
  }
 
156
  
 
157
  len=read(fd,buf,MAX_BUF);
 
158
  DBUG_ASSERT(len < MAX_BUF);
 
159
  close(fd);
 
160
  
 
161
  if (my_parse_charset_xml(buf,len,add_collation))
 
162
  {
 
163
#if 0
 
164
    printf("ERROR at line %d pos %d '%s'\n",
 
165
           my_xml_error_lineno(&p)+1,
 
166
           my_xml_error_pos(&p),
 
167
           my_xml_error_string(&p));
 
168
#endif
 
169
  }
 
170
  
 
171
  return FALSE;
 
172
}
 
173
 
 
174
static int
 
175
is_case_sensitive(CHARSET_INFO *cs)
 
176
{
 
177
 return (cs->sort_order &&
 
178
         cs->sort_order['A'] < cs->sort_order['a'] &&
 
179
         cs->sort_order['a'] < cs->sort_order['B']) ? 1 : 0;
 
180
}
 
181
 
 
182
 
 
183
void dispcset(FILE *f,CHARSET_INFO *cs)
 
184
{
 
185
  fprintf(f,"{\n");
 
186
  fprintf(f,"  %d,%d,%d,\n",cs->number,0,0);
 
187
  fprintf(f,"  MY_CS_COMPILED%s%s%s%s%s,\n",
 
188
          cs->state & MY_CS_BINSORT         ? "|MY_CS_BINSORT"   : "",
 
189
          cs->state & MY_CS_PRIMARY         ? "|MY_CS_PRIMARY"   : "",
 
190
          is_case_sensitive(cs)             ? "|MY_CS_CSSORT"    : "",
 
191
          my_charset_is_8bit_pure_ascii(cs) ? "|MY_CS_PUREASCII" : "",
 
192
          !my_charset_is_ascii_compatible(cs) ? "|MY_CS_NONASCII": "");
 
193
  
 
194
  if (cs->name)
 
195
  {
 
196
    fprintf(f,"  \"%s\",                     /* cset name     */\n",cs->csname);
 
197
    fprintf(f,"  \"%s\",                     /* coll name     */\n",cs->name);
 
198
    fprintf(f,"  \"\",                       /* comment       */\n");
 
199
    fprintf(f,"  NULL,                       /* tailoring     */\n");
 
200
    fprintf(f,"  ctype_%s,                   /* ctype         */\n",cs->name);
 
201
    fprintf(f,"  to_lower_%s,                /* lower         */\n",cs->name);
 
202
    fprintf(f,"  to_upper_%s,                /* upper         */\n",cs->name);
 
203
    if (cs->sort_order)
 
204
      fprintf(f,"  sort_order_%s,            /* sort_order    */\n",cs->name);
 
205
    else
 
206
      fprintf(f,"  NULL,                     /* sort_order    */\n");
 
207
    fprintf(f,"  NULL,                       /* contractions  */\n");
 
208
    fprintf(f,"  NULL,                       /* sort_order_big*/\n");
 
209
    fprintf(f,"  to_uni_%s,                  /* to_uni        */\n",cs->name);
 
210
  }
 
211
  else
 
212
  {
 
213
    fprintf(f,"  NULL,                       /* cset name     */\n");
 
214
    fprintf(f,"  NULL,                       /* coll name     */\n");
 
215
    fprintf(f,"  NULL,                       /* comment       */\n");
 
216
    fprintf(f,"  NULL,                       /* tailoging     */\n");
 
217
    fprintf(f,"  NULL,                       /* ctype         */\n");
 
218
    fprintf(f,"  NULL,                       /* lower         */\n");
 
219
    fprintf(f,"  NULL,                       /* upper         */\n");
 
220
    fprintf(f,"  NULL,                       /* sort order    */\n");
 
221
    fprintf(f,"  NULL,                       /* contractions  */\n");
 
222
    fprintf(f,"  NULL,                       /* sort_order_big*/\n");
 
223
    fprintf(f,"  NULL,                       /* to_uni        */\n");
 
224
  }
 
225
 
 
226
  fprintf(f,"  NULL,                       /* from_uni      */\n");
 
227
  fprintf(f,"  my_unicase_default,         /* caseinfo      */\n");
 
228
  fprintf(f,"  NULL,                       /* state map     */\n");
 
229
  fprintf(f,"  NULL,                       /* ident map     */\n");
 
230
  fprintf(f,"  1,                          /* strxfrm_multiply*/\n");
 
231
  fprintf(f,"  1,                          /* caseup_multiply*/\n");
 
232
  fprintf(f,"  1,                          /* casedn_multiply*/\n");
 
233
  fprintf(f,"  1,                          /* mbminlen      */\n");
 
234
  fprintf(f,"  1,                          /* mbmaxlen      */\n");
 
235
  fprintf(f,"  0,                          /* min_sort_char */\n");
 
236
  fprintf(f,"  255,                        /* max_sort_char */\n");
 
237
  fprintf(f,"  ' ',                        /* pad_char      */\n");
 
238
  fprintf(f,"  0,                          /* escape_with_backslash_is_dangerous */\n");
 
239
  fprintf(f,"  1,                          /* levels_for_compare */\n");
 
240
  fprintf(f,"  1,                          /* levels_for_order   */\n");
 
241
  
 
242
  fprintf(f,"  &my_charset_8bit_handler,\n");
 
243
  if (cs->state & MY_CS_BINSORT)
 
244
    fprintf(f,"  &my_collation_8bit_bin_handler,\n");
 
245
  else
 
246
    fprintf(f,"  &my_collation_8bit_simple_ci_handler,\n");
 
247
  fprintf(f,"}\n");
 
248
}
 
249
 
 
250
 
 
251
static void
 
252
fprint_copyright(FILE *file)
 
253
{
 
254
  fprintf(file,
 
255
"/* Copyright (C) 2000-2007 MySQL AB\n"
 
256
"\n"
 
257
"   This program is free software; you can redistribute it and/or modify\n"
 
258
"   it under the terms of the GNU General Public License as published by\n"
 
259
"   the Free Software Foundation; version 2 of the License.\n"
 
260
"\n"
 
261
"   This program is distributed in the hope that it will be useful,\n"
 
262
"   but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 
263
"   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 
264
"   GNU General Public License for more details.\n"
 
265
"\n"
 
266
"   You should have received a copy of the GNU General Public License\n"
 
267
"   along with this program; if not, write to the Free Software\n"
 
268
"   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */\n"
 
269
"\n");
 
270
}
 
271
 
 
272
 
 
273
int
 
274
main(int argc, char **argv  __attribute__((unused)))
 
275
{
 
276
  CHARSET_INFO  ncs;
 
277
  CHARSET_INFO  *cs;
 
278
  char filename[256];
 
279
  FILE *f= stdout;
 
280
  
 
281
  if (argc < 2)
 
282
  {
 
283
    fprintf(stderr, "usage: %s source-dir\n", argv[0]);
 
284
    exit(EXIT_FAILURE);
 
285
  }
 
286
  
 
287
  bzero((void*)&ncs,sizeof(ncs));
 
288
  bzero((void*)&all_charsets,sizeof(all_charsets));
 
289
  
 
290
  sprintf(filename,"%s/%s",argv[1],"Index.xml");
 
291
  my_read_charset_file(filename);
 
292
  
 
293
  for (cs=all_charsets; cs < all_charsets+256; cs++)
 
294
  {
 
295
    if (cs->number && !(cs->state & MY_CS_COMPILED))
 
296
    {
 
297
      if ( (!simple_cs_is_full(cs)) && (cs->csname))
 
298
      {
 
299
        sprintf(filename,"%s/%s.xml",argv[1],cs->csname);
 
300
        my_read_charset_file(filename);
 
301
      }
 
302
    }
 
303
  }
 
304
  
 
305
  fprintf(f, "/*\n");
 
306
  fprintf(f, "  This file was generated by the conf_to_src utility. "
 
307
          "Do not edit it directly,\n");
 
308
  fprintf(f, "  edit the XML definitions in sql/share/charsets/ instead.\n\n");
 
309
  fprintf(f, "  To re-generate, run the following in the strings/ "
 
310
          "directory:\n");
 
311
  fprintf(f, "    ./conf_to_src ../sql/share/charsets/ > FILE\n");
 
312
  fprintf(f, "*/\n\n");
 
313
  fprint_copyright(f);
 
314
  fprintf(f,"#include <my_global.h>\n");
 
315
  fprintf(f,"#include <m_ctype.h>\n\n");
 
316
  
 
317
  
 
318
  for (cs=all_charsets; cs < all_charsets+256; cs++)
 
319
  {
 
320
    if (simple_cs_is_full(cs))
 
321
    {
 
322
      fprintf(f,"#ifdef HAVE_CHARSET_%s\n",cs->csname);
 
323
      print_array(f, cs->name, "ctype",      cs->ctype,      MY_CS_CTYPE_TABLE_SIZE);
 
324
      print_array(f, cs->name, "to_lower",   cs->to_lower,   MY_CS_TO_LOWER_TABLE_SIZE);
 
325
      print_array(f, cs->name, "to_upper",   cs->to_upper,   MY_CS_TO_UPPER_TABLE_SIZE);
 
326
      if (cs->sort_order)
 
327
        print_array(f, cs->name, "sort_order", cs->sort_order, MY_CS_SORT_ORDER_TABLE_SIZE);
 
328
      print_array16(f, cs->name, "to_uni",     cs->tab_to_uni, MY_CS_TO_UNI_TABLE_SIZE);
 
329
      fprintf(f,"#endif\n");
 
330
      fprintf(f,"\n");
 
331
    }
 
332
  }
 
333
  
 
334
  fprintf(f,"CHARSET_INFO compiled_charsets[] = {\n");
 
335
  for (cs=all_charsets; cs < all_charsets+256; cs++)
 
336
  {
 
337
    if (simple_cs_is_full(cs))
 
338
    {
 
339
      fprintf(f,"#ifdef HAVE_CHARSET_%s\n",cs->csname);
 
340
      dispcset(f,cs);
 
341
      fprintf(f,",\n");
 
342
      fprintf(f,"#endif\n");
 
343
    }
 
344
  }
 
345
  
 
346
  dispcset(f,&ncs);
 
347
  fprintf(f,"};\n");
 
348
  
 
349
  return 0;
 
350
}