?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8354 sync regcomp(3C) with upstream (fix make catalog)
[unleashed/tickless.git] / usr / src / lib / libast / common / port / lcgen.c
blobe91f69b39a3c15e46383afb56995c4dbf30c6dc1
1 /***********************************************************************
2 * *
3 * This software is part of the ast package *
4 * Copyright (c) 1985-2010 AT&T Intellectual Property *
5 * and is licensed under the *
6 * Common Public License, Version 1.0 *
7 * by AT&T Intellectual Property *
8 * *
9 * A copy of the License is available at *
10 * http://www.opensource.org/licenses/cpl1.0.txt *
11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
12 * *
13 * Information and Software Systems Research *
14 * AT&T Research *
15 * Florham Park NJ *
16 * *
17 * Glenn Fowler <gsf@research.att.com> *
18 * David Korn <dgk@research.att.com> *
19 * Phong Vo <kpv@research.att.com> *
20 * *
21 ***********************************************************************/
22 /*
23 * generate <lc.h> implementation tables from lc.tab
24 * this must make it through vanilla cc with no -last
25 *
26 * # comment
27 * :charset:
28 * code name ms-codepage
29 * :language:
30 * code name alt1|alt2... charset|... attr1|attr2|...
31 * ...
32 * :territory:
33 * code name lang1|lang2...
34 * :abbreviation:
35 */
36
37 #include <stdio.h>
38 #include <ctype.h>
39 #ifdef __STDC__
40 #include <stdlib.h>
41 #include <string.h>
42 #endif
43
44 typedef struct Link_s
45 {
46 struct Link_s* next;
47 char* code;
48 int index;
49 } Link_t;
50
51 typedef struct Table_s
52 {
53 Link_t* root;
54 int count;
55 } Table_t;
56
57 typedef struct Abbreviation_s
58 {
59 Link_t link;
60 char* value;
61 } Abbreviation_t;
62
63 typedef struct Attribute_s
64 {
65 Link_t link;
66 } Attribute_t;
67
68 typedef struct Attribute_list_s
69 {
70 struct Attribute_list_s*next;
71 Attribute_t* attribute;
72 } Attribute_list_t;
73
74 typedef struct Charset_s
75 {
76 Link_t link;
77 char* alternates;
78 char* ms;
79 } Charset_t;
80
81 typedef struct Language_s
82 {
83 Link_t link;
84 char* name;
85 char* alternates;
86 Charset_t* charset;
87 Attribute_list_t* attributes;
88 } Language_t;
89
90 typedef struct Language_list_s
91 {
92 struct Language_list_s* next;
93 Language_t* language;
94 } Language_list_t;
95
96 typedef struct Territory_s
97 {
98 Link_t link;
99 char* name;
100 Language_list_t* languages;
101 int primary;
102 int index;
103 } Territory_t;
104
105 typedef struct Map_s
106 {
107 Link_t link;
108 Language_t* language;
109 Territory_t* territory;
110 Charset_t* charset;
111 Attribute_t* attribute;
112 } Map_t;
113
114 static struct State_s
115 {
116 Table_t attribute;
117 Table_t charset;
118 Table_t language;
119 Table_t territory;
120 Table_t map;
121 } state;
122
123 #define INIT 0
124 #define CHARSET 1
125 #define LANGUAGE 2
126 #define TERRITORY 3
127 #define MAP 4
128
129 #define elementsof(x) (sizeof(x)/sizeof(x[0]))
130 #define newof(p,t,n,x) ((t*)malloc(sizeof(t)*(n)+(x)))
131
132 static Link_t*
133 #if defined(__STDC__) || defined(__cplusplus)
134 enter(register Table_t* tab, register Link_t* v)
135 #else
136 enter(tab, v)
137 register Table_t* tab;
138 register Link_t* v;
139 #endif
140 {
141 register Link_t* x;
142 register Link_t* p;
143
144 for (p = 0, x = tab->root; x; p = x, x = x->next)
145 if (!strcmp(x->code, v->code))
146 return x;
147 if (p)
148 p->next = v;
149 else
150 tab->root = v;
151 v->next = 0;
152 v->index = tab->count++;
153 return v;
154 }
155
156 static Link_t*
157 #if defined(__STDC__) || defined(__cplusplus)
158 lookup(register Table_t* tab, register char* s)
159 #else
160 lookup(tab, s)
161 register Table_t* tab;
162 register char* s;
163 #endif
164 {
165 register Link_t* x;
166
167 for (x = tab->root; x; x = x->next)
168 if (!strcmp(x->code, s))
169 return x;
170 return 0;
171 }
172
173 static char*
174 #if defined(__STDC__) || defined(__cplusplus)
175 copy(char** p, register char* f)
176 #else
177 copy(p, f)
178 char** p;
179 register char* f;
180 #endif
181 {
182 register char* t;
183 char* b;
184
185 if (!f)
186 return 0;
187 b = t = *p;
188 while (*t++ = *f++);
189 *p = t;
190 return b;
191 }
192
193 static void
194 #if defined(__STDC__) || defined(__cplusplus)
195 macro(FILE* f, char* p1, char* p2, char* p3)
196 #else
197 macro(f, p1, p2, p3)
198 FILE* f;
199 char* p1;
200 char* p2;
201 char* p3;
202 #endif
203 {
204 register int c;
205 register char* s;
206 register char* b;
207 register char* e;
208 int i;
209 int m;
210 int n;
211 char* part[4];
212 char buf[128];
213
214 part[0] = p1;
215 part[1] = p2;
216 part[2] = p3;
217 part[3] = 0;
218 n = 0;
219 fprintf(f, "\n");
220 do
221 {
222 i = m = 0;
223 b = buf;
224 e = &buf[sizeof(buf)-1];
225 while (b < e)
226 {
227 if (!(s = part[i++]))
228 break;
229 if (i > 1)
230 *b++ = '_';
231 while ((c = *s++) && b < e)
232 {
233 if (c == '|')
234 {
235 part[i-1] = s;
236 m = 1;
237 break;
238 }
239 else if (islower(c))
240 c = toupper(c);
241 else if (!isalnum(c))
242 c = '_';
243 *b++ = c;
244 }
245 }
246 *b = 0;
247 fprintf(f, "#ifdef %s\n%s,\n#else\n", buf, buf);
248 n++;
249 } while (m);
250 fprintf(f, "0,\n");
251 while (n-- > 0)
252 fprintf(f, "#endif\n");
253 }
254
255 #if defined(__STDC__) || defined(__cplusplus)
256 int
257 main(int argc, char** argv)
258 #else
259 int
260 main(argc, argv)
261 int argc;
262 char** argv;
263 #endif
264 {
265 register char* s;
266 register char** vp;
267 register char** ve;
268 Attribute_t* ap;
269 Attribute_list_t* al;
270 Attribute_list_t* az;
271 Charset_t* cp;
272 Territory_t* tp;
273 Language_t* lp;
274 Language_list_t* ll;
275 Language_list_t* lz;
276 Map_t* mp;
277 char* b;
278 char* f;
279 char* command;
280 char* hdr;
281 char* lib;
282 FILE* hf;
283 FILE* lf;
284 int c;
285 int i;
286 int line;
287 int type;
288 int language_attribute_max;
289 int territory_language_max;
290 char* arg[5];
291 char buf[1024];
292
293 command = *argv++;
294 line = 0;
295 if (!(hdr = *argv++) || !(lib = *argv++) || *argv)
296 {
297 fprintf(stderr, "%s: { hdr lib tab } arguments expected\n", command);
298 return 1;
299 }
300 if (!(hf = fopen(hdr, "w")))
301 {
302 fprintf(stderr, "%s: %s: cannot write\n", command, hdr);
303 return 1;
304 }
305 if (!(lf = fopen(lib, "w")))
306 {
307 fprintf(stderr, "%s: %s: cannot write\n", command, lib);
308 return 1;
309 }
310 type = 0;
311 language_attribute_max = 0;
312 territory_language_max = 0;
313 state.language.count = 2;
314 state.territory.count = 2;
315 ve = &arg[elementsof(arg)];
316 fprintf(hf, "/* : : generated by %s : : */\n", command);
317 fprintf(hf, "#pragma prototyped\n");
318 fprintf(hf, "\n");
319 fprintf(hf, "#ifndef _LC_H\n");
320 fprintf(hf, "#define _LC_H\t\t\t1\n");
321 fprintf(hf, "\n");
322 fprintf(hf, "#include <ast.h>\n");
323 fprintf(hf, "\n");
324 fprintf(hf, "#define LC_abbreviated\t\t0x00001\n");
325 fprintf(hf, "#define LC_checked\t\t0x00002\n");
326 fprintf(hf, "#define LC_debug\t\t0x00004\n");
327 fprintf(hf, "#define LC_default\t\t0x00008\n");
328 fprintf(hf, "#define LC_defined\t\t0x00010\n");
329 fprintf(hf, "#define LC_local\t\t0x00020\n");
330 fprintf(hf, "#define LC_primary\t\t0x00040\n");
331 fprintf(hf, "#define LC_qualified\t\t0x00080\n");
332 fprintf(hf, "#define LC_undefined\t\t0x00100\n");
333 fprintf(hf, "#define LC_utf8\t\t\t0x00200\n");
334 fprintf(hf, "#define LC_verbose\t\t0x00400\n");
335 fprintf(hf, "#define LC_setlocale\t\t\t0x10000\n");
336 fprintf(hf, "#define LC_setenv\t\t\t0x20000\n");
337 fprintf(hf, "#define LC_user\t\t\t0x40000\n");
338 fprintf(lf, "/* : : generated by %s : : */\n", command);
339 fprintf(lf, "\n");
340 fprintf(lf, "#include \"lclib.h\"\n");
341 fprintf(lf, "#include \"lclang.h\"\n");
342 fprintf(lf, "\n");
343 while (s = fgets(buf, sizeof(buf), stdin))
344 {
345 line++;
346 while (isspace(*s))
347 s++;
348 if (!*s || *s == '#')
349 continue;
350 b = s;
351 vp = arg;
352 for (;;)
353 {
354 for (*vp++ = s; *s && !isspace(*s); s++);
355 if (!*s)
356 break;
357 for (*s++ = 0; isspace(*s); s++);
358 if (!strcmp(*(vp - 1), "-"))
359 *(vp - 1) = 0;
360 if (!*s || vp >= ve)
361 break;
362 }
363 while (vp < ve)
364 *vp++ = 0;
365 if (*arg[0] == ':')
366 {
367 if (!strcmp(arg[0], ":map:"))
368 {
369 if (type != TERRITORY)
370 {
371 fprintf(stderr, "%s: %d: %s: must be specified after :territory:\n", command, line, arg[0]);
372 return 1;
373 }
374 type = MAP;
375 continue;
376 }
377 else if (!strcmp(arg[0], ":charset:"))
378 {
379 if (type != INIT)
380 {
381 fprintf(stderr, "%s: %d: %s must be specified first\n", command, line, arg[0]);
382 return 1;
383 }
384 type = CHARSET;
385 continue;
386 }
387 else if (!strcmp(arg[0], ":territory:"))
388 {
389 if (type != LANGUAGE)
390 {
391 fprintf(stderr, "%s: %d: %s: must be specified after :language:\n", command, line, arg[0]);
392 return 1;
393 }
394 type = TERRITORY;
395 continue;
396 }
397 else if (!strcmp(arg[0], ":language:"))
398 {
399 if (type != CHARSET)
400 {
401 fprintf(stderr, "%s: %d: %s must be specified after :charset:\n", command, line, arg[0]);
402 return 1;
403 }
404 type = LANGUAGE;
405 continue;
406 }
407 else
408 {
409 fprintf(stderr, "%s: %d: %s invalid\n", command, line, arg[0]);
410 return 1;
411 }
412 }
413 if (!arg[1])
414 {
415 fprintf(stderr, "%s: %d: at least two arguments expected\n", command, line);
416 return 1;
417 }
418 switch (type)
419 {
420 case CHARSET:
421 if (!(cp = newof(0, Charset_t, 1, s - b + 1)))
422 {
423 fprintf(stderr, "%s: %d: out of space\n", command, line);
424 return 1;
425 }
426 b = (char*)(cp + 1);
427 cp->link.code = copy(&b, arg[0]);
428 cp->alternates = copy(&b, arg[1]);
429 cp->ms = copy(&b, arg[2]);
430 if (cp != (Charset_t*)enter(&state.charset, (Link_t*)cp))
431 {
432 fprintf(stderr, "%s: %d: %s: duplicate charset\n", command, line, cp->link.code);
433 return 1;
434 }
435 break;
436 case TERRITORY:
437 if (!(tp = newof(0, Territory_t, 1, s - b + 1)))
438 {
439 fprintf(stderr, "%s: %d: out of space\n", command, line);
440 return 1;
441 }
442 b = (char*)(tp + 1);
443 tp->link.code = copy(&b, arg[0]);
444 tp->name = copy(&b, arg[1]);
445 tp->languages = 0;
446 if (s = copy(&b, arg[2]))
447 {
448 i = 0;
449 while (*(b = s))
450 {
451 for (; *s && *s != ':' && *s != '|'; s++);
452 if (c = *s)
453 *s++ = 0;
454 if (!(lp = (Language_t*)lookup(&state.language, b)))
455 {
456 fprintf(stderr, "%s: %d: %s: unknown language\n", command, line, b);
457 return 1;
458 }
459 if (!(ll = newof(0, Language_list_t, 1, 0)))
460 {
461 fprintf(stderr, "%s: %d: out of space\n", command, line);
462 return 1;
463 }
464 if (!tp->languages)
465 tp->languages = ll;
466 else
467 lz->next = ll;
468 lz = ll;
469 ll->language = lp;
470 ll->next = 0;
471 i++;
472 if (c == ':')
473 {
474 for (b = s; *s && *s != '|'; s++);
475 if (*s)
476 *s++ = 0;
477 if (!strcmp(b, "primary"))
478 tp->primary = 1;
479 }
480 }
481 if (territory_language_max < i)
482 territory_language_max = i;
483 }
484 if (tp != (Territory_t*)enter(&state.territory, (Link_t*)tp))
485 {
486 fprintf(stderr, "%s: %d: %s: duplicate territory\n", command, line, tp->link.code);
487 return 1;
488 }
489 break;
490 case LANGUAGE:
491 if (!(lp = newof(0, Language_t, 1, s - b + 1)))
492 {
493 fprintf(stderr, "%s: %d: out of space\n", command, line);
494 return 1;
495 }
496 b = (char*)(lp + 1);
497 lp->link.code = copy(&b, arg[0]);
498 lp->name = copy(&b, arg[1]);
499 lp->alternates = copy(&b, arg[2]);
500 if (!arg[3])
501 lp->charset = 0;
502 else if (!(lp->charset = (Charset_t*)lookup(&state.charset, arg[3])))
503 {
504 fprintf(stderr, "%s: %d: %s: unknown charset\n", command, line, arg[3]);
505 return 1;
506 }
507 lp->attributes = 0;
508 if (s = copy(&b, arg[4]))
509 {
510 i = 0;
511 fprintf(lf, "\nconst Lc_attribute_t attribute_%s[] =\n{\n", lp->link.code);
512 while (*(b = s))
513 {
514 for (f = 0; *s && *s != '|'; s++)
515 if (*s == ':')
516 {
517 *s++ = 0;
518 f = s;
519 }
520 if (*s)
521 *s++ = 0;
522 fprintf(lf, "{\"%s\",", b);
523 if (f)
524 fprintf(lf, "LC_%s,", f);
525 else
526 fprintf(lf, "0,");
527 if (!(ap = newof(0, Attribute_t, 1, 0)))
528 {
529 fprintf(stderr, "%s: %d: out of space\n", command, line);
530 return 1;
531 }
532 ap->link.code = b;
533 ap->link.index = i++;
534 if (!(al = newof(0, Attribute_list_t, 1, 0)))
535 {
536 fprintf(stderr, "%s: %d: out of space\n", command, line);
537 return 1;
538 }
539 if (!lp->attributes)
540 lp->attributes = al;
541 else
542 az->next = al;
543 az = al;
544 al->attribute = ap;
545 al->next = 0;
546 macro(lf, "SUBLANG", lp->name, b);
547 fprintf(lf, "\n},\n");
548 }
549 if (language_attribute_max < i)
550 language_attribute_max = i;
551 fprintf(lf, "};\n");
552 }
553 if (lp != (Language_t*)enter(&state.language, (Link_t*)lp))
554 {
555 fprintf(stderr, "%s: %d: %s: duplicate language\n", command, line, lp->link.code);
556 return 1;
557 }
558 break;
559 case MAP:
560 if (!(mp = newof(0, Map_t, 1, s - b + 1)))
561 {
562 fprintf(stderr, "%s: %d: out of space\n", command, line);
563 return 1;
564 }
565 b = (char*)(mp + 1);
566 mp->link.code = copy(&b, arg[0]);
567 if (!arg[2])
568 {
569 fprintf(stderr, "%s: %d: territory code expected\n", command, line);
570 return 1;
571 }
572 if (!(mp->language = (Language_t*)lookup(&state.language, arg[1])))
573 {
574 fprintf(stderr, "%s: %d: %s: unknown language\n", command, line, arg[1]);
575 return 1;
576 }
577 if (!(mp->territory = (Territory_t*)lookup(&state.territory, arg[2])))
578 {
579 fprintf(stderr, "%s: %d: %s: unknown territory\n", command, line, arg[2]);
580 return 1;
581 }
582 if (!arg[3])
583 mp->charset = 0;
584 else if (!(mp->charset = (Charset_t*)lookup(&state.charset, arg[3])))
585 {
586 fprintf(stderr, "%s: %d: %s: unknown charset\n", command, line, arg[3]);
587 return 1;
588 }
589 mp->attribute = 0;
590 if (arg[4])
591 {
592 for (al = mp->language->attributes; al; al = al->next)
593 if (!strcmp(al->attribute->link.code, arg[4]))
594 {
595 mp->attribute = al->attribute;
596 break;
597 }
598 if (!mp->attribute)
599 {
600 fprintf(stderr, "%s: %d: %s: unknown attribute\n", command, line, arg[4]);
601 return 1;
602 }
603 }
604 if (mp != (Map_t*)enter(&state.map, (Link_t*)mp))
605 {
606 fprintf(stderr, "%s: %d: %s: duplicate map\n", command, line, mp->link.code);
607 return 1;
608 }
609 break;
610 }
611 }
612 fprintf(hf, "#define LC_language_attribute_max\t\t%d\n", language_attribute_max);
613 fprintf(hf, "#define LC_territory_language_max\t\t%d\n", territory_language_max);
614 fprintf(hf, "\nstruct Lc_s;\n");
615 fprintf(hf, "\ntypedef struct Lc_info_s\n{\n");
616 fprintf(hf, "\tconst struct Lc_s*\tlc;\n");
617 fprintf(hf, "\tunsigned long\t\tnumber;\n");
618 fprintf(hf, "\tvoid*\t\t\tdata;\n");
619 fprintf(hf, "} Lc_info_t;\n");
620 fprintf(hf, "\ntypedef struct Lc_attribute_s\n{\n");
621 fprintf(hf, "\tconst char*\t\tname;\n");
622 fprintf(hf, "\tunsigned long\t\tflags;\n");
623 fprintf(hf, "\tunsigned long\t\tindex;\n");
624 fprintf(hf, "} Lc_attribute_t;\n");
625 fprintf(hf, "\ntypedef struct Lc_charset_s\n{\n");
626 fprintf(hf, "\tconst char*\t\tcode;\n");
627 fprintf(hf, "\tconst char*\t\talternates;\n");
628 fprintf(hf, "\tconst char*\t\tms;\n");
629 fprintf(hf, "\tunsigned long\t\tindex;\n");
630 fprintf(hf, "} Lc_charset_t;\n");
631 fprintf(hf, "\ntypedef struct Lc_language_s\n{\n");
632 fprintf(hf, "\tconst char*\t\tcode;\n");
633 fprintf(hf, "\tconst char*\t\tname;\n");
634 fprintf(hf, "\tconst char*\t\talternates;\n");
635 fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n");
636 fprintf(hf, "\tunsigned long\t\tflags;\n");
637 fprintf(hf, "\tunsigned long\t\tindex;\n");
638 fprintf(hf, "\tconst Lc_attribute_t*\tattributes[LC_language_attribute_max];\n");
639 fprintf(hf, "} Lc_language_t;\n");
640 fprintf(hf, "\ntypedef struct Lc_territory_s\n{\n");
641 fprintf(hf, "\tconst char*\t\tcode;\n");
642 fprintf(hf, "\tconst char*\t\tname;\n");
643 fprintf(hf, "\tunsigned long\t\tflags;\n");
644 fprintf(hf, "\tunsigned long\t\tindex;\n");
645 fprintf(hf, "\tconst Lc_language_t*\tlanguages[LC_territory_language_max];\n");
646 fprintf(hf, "#ifdef _LC_TERRITORY_PRIVATE_\n");
647 fprintf(hf, "\t_LC_TERRITORY_PRIVATE_\n");
648 fprintf(hf, "#endif\n");
649 fprintf(hf, "} Lc_territory_t;\n");
650 fprintf(hf, "\ntypedef struct Lc_map_s\n{\n");
651 fprintf(hf, "\tconst char*\t\tcode;\n");
652 fprintf(hf, "\tconst Lc_language_t*\tlanguage;\n");
653 fprintf(hf, "\tconst Lc_territory_t*\tterritory;\n");
654 fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n");
655 fprintf(hf, "\tconst Lc_attribute_t*\tattribute;\n");
656 fprintf(hf, "} Lc_map_t;\n");
657 fprintf(hf, "\ntypedef struct Lc_attribute_list_s\n{\n");
658 fprintf(hf, "\tstruct Lc_attribute_list_s*\tnext;\n");
659 fprintf(hf, "\tconst Lc_attribute_t*\t\tattribute;\n");
660 fprintf(hf, "} Lc_attribute_list_t;\n");
661 fprintf(hf, "\ntypedef struct Lc_s\n{\n");
662 fprintf(hf, "\tconst char*\t\tname;\n");
663 fprintf(hf, "\tconst char*\t\tcode;\n");
664 fprintf(hf, "\tconst Lc_language_t*\tlanguage;\n");
665 fprintf(hf, "\tconst Lc_territory_t*\tterritory;\n");
666 fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n");
667 fprintf(hf, "\tconst Lc_attribute_list_t*\tattributes;\n");
668 fprintf(hf, "\tunsigned long\t\tflags;\n");
669 fprintf(hf, "\tunsigned long\t\tindex;\n");
670 fprintf(hf, "#ifdef _LC_PRIVATE_\n");
671 fprintf(hf, "\t_LC_PRIVATE_\n");
672 fprintf(hf, "#endif\n");
673 fprintf(hf, "} Lc_t;\n");
674 fprintf(hf, "\nstruct Lc_category_s;\n");
675 fprintf(hf, "\ntypedef int (*Lc_category_set_f)(struct Lc_category_s*);\n");
676 fprintf(hf, "\ntypedef struct Lc_category_s\n{\n");
677 fprintf(hf, "\tconst char*\t\tname;\n");
678 fprintf(hf, "\tint\t\t\texternal;\n");
679 fprintf(hf, "\tint\t\t\tinternal;\n");
680 fprintf(hf, "\tLc_category_set_f\tsetf;\n");
681 fprintf(hf, "\tLc_t*\t\t\tprev;\n");
682 fprintf(hf, "\tunsigned int\t\tflags;\n");
683 fprintf(hf, "} Lc_category_t;\n");
684 fprintf(hf, "\n");
685 fprintf(hf, "#if _BLD_ast && defined(__EXPORT__)\n");
686 fprintf(hf, "#define extern\t\t__EXPORT__\n");
687 fprintf(hf, "#endif\n");
688 fprintf(hf, "\n");
689 fprintf(hf, "extern size_t\t\tlccanon(Lc_t*, unsigned long flags, char*, size_t);\n");
690 fprintf(hf, "extern Lc_category_t*\tlccategories(void);\n");
691 fprintf(hf, "extern int\t\tlcindex(int, int);\n");
692 fprintf(hf, "extern Lc_info_t*\tlcinfo(int);\n");
693 fprintf(hf, "extern Lc_t*\t\tlcmake(const char*);\n");
694 fprintf(hf, "extern Lc_t*\t\tlcscan(Lc_t*);\n");
695 fprintf(hf, "\n");
696 fprintf(hf, "#undef\textern\n");
697 fprintf(lf, "\nconst Lc_charset_t lc_charsets[] =\n{\n");
698 for (cp = (Charset_t*)state.charset.root; cp; cp = (Charset_t*)cp->link.next)
699 {
700 fprintf(lf, "{\"%s\",", cp->link.code);
701 if (cp->alternates)
702 fprintf(lf, "\"%s\",", cp->alternates);
703 else
704 fprintf(lf, "0,");
705 if (cp->ms)
706 fprintf(lf, "\"%s\",", cp->ms);
707 else
708 fprintf(lf, "0");
709 fprintf(lf, "},\n");
710 }
711 fprintf(lf, "\t0\n};\n");
712 fprintf(lf, "\nconst Lc_language_t lc_languages[] =\n{\n");
713 fprintf(lf, "{\"C\",\"C\",\"POSIX\",&lc_charsets[0],LC_default,0,");
714 for (i = 0; i < language_attribute_max; i++)
715 fprintf(lf, "0,");
716 fprintf(lf, "},\n");
717 fprintf(lf, "{\"debug\",\"debug\",0,&lc_charsets[0],LC_debug,0,");
718 for (i = 0; i < language_attribute_max; i++)
719 fprintf(lf, "0,");
720 fprintf(lf, "},\n");
721 for (lp = (Language_t*)state.language.root; lp; lp = (Language_t*)lp->link.next)
722 {
723 fprintf(lf, "{\"%s\",\"%s\",", lp->link.code, lp->name);
724 if (lp->alternates)
725 fprintf(lf, "\"%s\",", lp->alternates);
726 else
727 fprintf(lf, "0,");
728 fprintf(lf, "&lc_charsets[%d],0,", lp->charset ? lp->charset->link.index : 0);
729 macro(lf, "LANG", lp->name, (char*)0);
730 for (i = 0, al = lp->attributes; al; al = al->next, i++)
731 fprintf(lf, "&attribute_%s[%d],", lp->link.code, al->attribute->link.index);
732 for (; i < language_attribute_max; i++)
733 fprintf(lf, "0,");
734 fprintf(lf, "\n},\n");
735 }
736 fprintf(lf, "\t0\n};\n");
737 fprintf(lf, "\nconst Lc_territory_t lc_territories[] =\n{\n");
738 fprintf(lf, "{\"C\",\"C\",LC_default,0,&lc_languages[0],");
739 for (i = 1; i < 2 * territory_language_max; i++)
740 fprintf(lf, "0,");
741 fprintf(lf, "},\n");
742 fprintf(lf, "{\"debug\",\"debug\",LC_debug,0,&lc_languages[1],");
743 for (i = 1; i < 2 * territory_language_max; i++)
744 fprintf(lf, "0,");
745 fprintf(lf, "},\n");
746 for (tp = (Territory_t*)state.territory.root; tp; tp = (Territory_t*)tp->link.next)
747 {
748 fprintf(lf, "{\"%s\",\"%s\",", tp->link.code, tp->name);
749 if (tp->primary)
750 fprintf(lf, "LC_primary,");
751 else
752 fprintf(lf, "0,");
753 macro(lf, "CTRY", tp->name, (char*)0);
754 for (i = 0, ll = tp->languages; ll; ll = ll->next, i++)
755 fprintf(lf, "&lc_languages[%d],", ll->language->link.index);
756 for (; i < territory_language_max; i++)
757 fprintf(lf, "0,");
758 for (i = 0, ll = tp->languages; ll; ll = ll->next, i++)
759 macro(lf, "SUBLANG", ll->language->name, tp->name);
760 for (; i < territory_language_max; i++)
761 fprintf(lf, "0,");
762 fprintf(lf, "\n},\n");
763 }
764 fprintf(lf, "\t0\n};\n");
765 fprintf(lf, "\nconst Lc_map_t lc_maps[] =\n{\n");
766 for (mp = (Map_t*)state.map.root; mp; mp = (Map_t*)mp->link.next)
767 {
768 fprintf(lf, "{\"%s\",", mp->link.code);
769 fprintf(lf, "&lc_languages[%d],", mp->language->link.index);
770 fprintf(lf, "&lc_territories[%d],", mp->territory->link.index);
771 fprintf(lf, "&lc_charsets[%d],", mp->charset ? mp->charset->link.index : 0);
772 if (mp->attribute)
773 fprintf(lf, "&attribute_%s[%d]", mp->language->link.code, mp->attribute->link.index);
774 else
775 fprintf(lf, "0");
776 fprintf(lf, "},\n");
777 }
778 fprintf(lf, "\t0\n};\n");
779 fclose(lf);
780 fprintf(hf, "\n#endif\n");
781 fclose(hf);
782 return 0;
783 }
unleashed repo fork