← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to strings/conf_to_src.c

Removed conf_to_src. There was a MySQL Bug (#17122) about it. No one seems to 
know if it is used anymore, or if so, how. Removing it doesn't do anything to 
the build. /me considers it cruft.

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
 
}