1 /*********************************************************************** 2 * * 3 * This software is part of the ast package * 4 * Copyright (c) 1985-2008 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_default\t\t0x00004\n"); 327 fprintf(hf, "#define LC_defined\t\t0x00008\n"); 328 fprintf(hf, "#define LC_debug\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_verbose\t\t0x00200\n"); 334 fprintf(hf, "#define LC_user\t\t\t0x10000\n"); 335 fprintf(lf, "/* : : generated by %s : : */\n", command); 336 fprintf(lf, "\n"); 337 fprintf(lf, "#include \"lclib.h\"\n"); 338 fprintf(lf, "#include \"lclang.h\"\n"); 339 fprintf(lf, "\n"); 340 while (s = fgets(buf, sizeof(buf), stdin)) 341 { 342 line++; 343 while (isspace(*s)) 344 s++; 345 if (!*s || *s == '#') 346 continue; 347 b = s; 348 vp = arg; 349 for (;;) 350 { 351 for (*vp++ = s; *s && !isspace(*s); s++); 352 if (!*s) 353 break; 354 for (*s++ = 0; isspace(*s); s++); 355 if (!strcmp(*(vp - 1), "-")) 356 *(vp - 1) = 0; 357 if (!*s || vp >= ve) 358 break; 359 } 360 while (vp < ve) 361 *vp++ = 0; 362 if (*arg[0] == ':') 363 { 364 if (!strcmp(arg[0], ":map:")) 365 { 366 if (type != TERRITORY) 367 { 368 fprintf(stderr, "%s: %d: %s: must be specified after :territory:\n", command, line, arg[0]); 369 return 1; 370 } 371 type = MAP; 372 continue; 373 } 374 else if (!strcmp(arg[0], ":charset:")) 375 { 376 if (type != INIT) 377 { 378 fprintf(stderr, "%s: %d: %s must be specified first\n", command, line, arg[0]); 379 return 1; 380 } 381 type = CHARSET; 382 continue; 383 } 384 else if (!strcmp(arg[0], ":territory:")) 385 { 386 if (type != LANGUAGE) 387 { 388 fprintf(stderr, "%s: %d: %s: must be specified after :language:\n", command, line, arg[0]); 389 return 1; 390 } 391 type = TERRITORY; 392 continue; 393 } 394 else if (!strcmp(arg[0], ":language:")) 395 { 396 if (type != CHARSET) 397 { 398 fprintf(stderr, "%s: %d: %s must be specified after :charset:\n", command, line, arg[0]); 399 return 1; 400 } 401 type = LANGUAGE; 402 continue; 403 } 404 else 405 { 406 fprintf(stderr, "%s: %d: %s invalid\n", command, line, arg[0]); 407 return 1; 408 } 409 } 410 if (!arg[1]) 411 { 412 fprintf(stderr, "%s: %d: at least two arguments expected\n", command, line); 413 return 1; 414 } 415 switch (type) 416 { 417 case CHARSET: 418 if (!(cp = newof(0, Charset_t, 1, s - b + 1))) 419 { 420 fprintf(stderr, "%s: %d: out of space\n", command, line); 421 return 1; 422 } 423 b = (char*)(cp + 1); 424 cp->link.code = copy(&b, arg[0]); 425 cp->alternates = copy(&b, arg[1]); 426 cp->ms = copy(&b, arg[2]); 427 if (cp != (Charset_t*)enter(&state.charset, (Link_t*)cp)) 428 { 429 fprintf(stderr, "%s: %d: %s: duplicate charset\n", command, line, cp->link.code); 430 return 1; 431 } 432 break; 433 case TERRITORY: 434 if (!(tp = newof(0, Territory_t, 1, s - b + 1))) 435 { 436 fprintf(stderr, "%s: %d: out of space\n", command, line); 437 return 1; 438 } 439 b = (char*)(tp + 1); 440 tp->link.code = copy(&b, arg[0]); 441 tp->name = copy(&b, arg[1]); 442 tp->languages = 0; 443 if (s = copy(&b, arg[2])) 444 { 445 i = 0; 446 while (*(b = s)) 447 { 448 for (; *s && *s != ':' && *s != '|'; s++); 449 if (c = *s) 450 *s++ = 0; 451 if (!(lp = (Language_t*)lookup(&state.language, b))) 452 { 453 fprintf(stderr, "%s: %d: %s: unknown language\n", command, line, b); 454 return 1; 455 } 456 if (!(ll = newof(0, Language_list_t, 1, 0))) 457 { 458 fprintf(stderr, "%s: %d: out of space\n", command, line); 459 return 1; 460 } 461 if (!tp->languages) 462 tp->languages = ll; 463 else 464 lz->next = ll; 465 lz = ll; 466 ll->language = lp; 467 ll->next = 0; 468 i++; 469 if (c == ':') 470 { 471 for (b = s; *s && *s != '|'; s++); 472 if (*s) 473 *s++ = 0; 474 if (!strcmp(b, "primary")) 475 tp->primary = 1; 476 } 477 } 478 if (territory_language_max < i) 479 territory_language_max = i; 480 } 481 if (tp != (Territory_t*)enter(&state.territory, (Link_t*)tp)) 482 { 483 fprintf(stderr, "%s: %d: %s: duplicate territory\n", command, line, tp->link.code); 484 return 1; 485 } 486 break; 487 case LANGUAGE: 488 if (!(lp = newof(0, Language_t, 1, s - b + 1))) 489 { 490 fprintf(stderr, "%s: %d: out of space\n", command, line); 491 return 1; 492 } 493 b = (char*)(lp + 1); 494 lp->link.code = copy(&b, arg[0]); 495 lp->name = copy(&b, arg[1]); 496 lp->alternates = copy(&b, arg[2]); 497 if (!arg[3]) 498 lp->charset = 0; 499 else if (!(lp->charset = (Charset_t*)lookup(&state.charset, arg[3]))) 500 { 501 fprintf(stderr, "%s: %d: %s: unknown charset\n", command, line, arg[3]); 502 return 1; 503 } 504 lp->attributes = 0; 505 if (s = copy(&b, arg[4])) 506 { 507 i = 0; 508 fprintf(lf, "\nconst Lc_attribute_t attribute_%s[] =\n{\n", lp->link.code); 509 while (*(b = s)) 510 { 511 for (f = 0; *s && *s != '|'; s++) 512 if (*s == ':') 513 { 514 *s++ = 0; 515 f = s; 516 } 517 if (*s) 518 *s++ = 0; 519 fprintf(lf, "{\"%s\",", b); 520 if (f) 521 fprintf(lf, "LC_%s,", f); 522 else 523 fprintf(lf, "0,"); 524 if (!(ap = newof(0, Attribute_t, 1, 0))) 525 { 526 fprintf(stderr, "%s: %d: out of space\n", command, line); 527 return 1; 528 } 529 ap->link.code = b; 530 ap->link.index = i++; 531 if (!(al = newof(0, Attribute_list_t, 1, 0))) 532 { 533 fprintf(stderr, "%s: %d: out of space\n", command, line); 534 return 1; 535 } 536 if (!lp->attributes) 537 lp->attributes = al; 538 else 539 az->next = al; 540 az = al; 541 al->attribute = ap; 542 al->next = 0; 543 macro(lf, "SUBLANG", lp->name, b); 544 fprintf(lf, "\n},\n"); 545 } 546 if (language_attribute_max < i) 547 language_attribute_max = i; 548 fprintf(lf, "};\n"); 549 } 550 if (lp != (Language_t*)enter(&state.language, (Link_t*)lp)) 551 { 552 fprintf(stderr, "%s: %d: %s: duplicate language\n", command, line, lp->link.code); 553 return 1; 554 } 555 break; 556 case MAP: 557 if (!(mp = newof(0, Map_t, 1, s - b + 1))) 558 { 559 fprintf(stderr, "%s: %d: out of space\n", command, line); 560 return 1; 561 } 562 b = (char*)(mp + 1); 563 mp->link.code = copy(&b, arg[0]); 564 if (!arg[2]) 565 { 566 fprintf(stderr, "%s: %d: territory code expected\n", command, line); 567 return 1; 568 } 569 if (!(mp->language = (Language_t*)lookup(&state.language, arg[1]))) 570 { 571 fprintf(stderr, "%s: %d: %s: unknown language\n", command, line, arg[1]); 572 return 1; 573 } 574 if (!(mp->territory = (Territory_t*)lookup(&state.territory, arg[2]))) 575 { 576 fprintf(stderr, "%s: %d: %s: unknown territory\n", command, line, arg[2]); 577 return 1; 578 } 579 if (!arg[3]) 580 mp->charset = 0; 581 else if (!(mp->charset = (Charset_t*)lookup(&state.charset, arg[3]))) 582 { 583 fprintf(stderr, "%s: %d: %s: unknown charset\n", command, line, arg[3]); 584 return 1; 585 } 586 mp->attribute = 0; 587 if (arg[4]) 588 { 589 for (al = mp->language->attributes; al; al = al->next) 590 if (!strcmp(al->attribute->link.code, arg[4])) 591 { 592 mp->attribute = al->attribute; 593 break; 594 } 595 if (!mp->attribute) 596 { 597 fprintf(stderr, "%s: %d: %s: unknown attribute\n", command, line, arg[4]); 598 return 1; 599 } 600 } 601 if (mp != (Map_t*)enter(&state.map, (Link_t*)mp)) 602 { 603 fprintf(stderr, "%s: %d: %s: duplicate map\n", command, line, mp->link.code); 604 return 1; 605 } 606 break; 607 } 608 } 609 fprintf(hf, "#define LC_language_attribute_max\t\t%d\n", language_attribute_max); 610 fprintf(hf, "#define LC_territory_language_max\t\t%d\n", territory_language_max); 611 fprintf(hf, "\nstruct Lc_s;\n"); 612 fprintf(hf, "\ntypedef struct Lc_info_s\n{\n"); 613 fprintf(hf, "\tconst struct Lc_s*\tlc;\n"); 614 fprintf(hf, "\tunsigned long\t\tnumber;\n"); 615 fprintf(hf, "\tvoid*\t\t\tdata;\n"); 616 fprintf(hf, "} Lc_info_t;\n"); 617 fprintf(hf, "\ntypedef struct Lc_attribute_s\n{\n"); 618 fprintf(hf, "\tconst char*\t\tname;\n"); 619 fprintf(hf, "\tunsigned long\t\tflags;\n"); 620 fprintf(hf, "\tunsigned long\t\tindex;\n"); 621 fprintf(hf, "} Lc_attribute_t;\n"); 622 fprintf(hf, "\ntypedef struct Lc_charset_s\n{\n"); 623 fprintf(hf, "\tconst char*\t\tcode;\n"); 624 fprintf(hf, "\tconst char*\t\talternates;\n"); 625 fprintf(hf, "\tconst char*\t\tms;\n"); 626 fprintf(hf, "\tunsigned long\t\tindex;\n"); 627 fprintf(hf, "} Lc_charset_t;\n"); 628 fprintf(hf, "\ntypedef struct Lc_language_s\n{\n"); 629 fprintf(hf, "\tconst char*\t\tcode;\n"); 630 fprintf(hf, "\tconst char*\t\tname;\n"); 631 fprintf(hf, "\tconst char*\t\talternates;\n"); 632 fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n"); 633 fprintf(hf, "\tunsigned long\t\tflags;\n"); 634 fprintf(hf, "\tunsigned long\t\tindex;\n"); 635 fprintf(hf, "\tconst Lc_attribute_t*\tattributes[LC_language_attribute_max];\n"); 636 fprintf(hf, "} Lc_language_t;\n"); 637 fprintf(hf, "\ntypedef struct Lc_territory_s\n{\n"); 638 fprintf(hf, "\tconst char*\t\tcode;\n"); 639 fprintf(hf, "\tconst char*\t\tname;\n"); 640 fprintf(hf, "\tunsigned long\t\tflags;\n"); 641 fprintf(hf, "\tunsigned long\t\tindex;\n"); 642 fprintf(hf, "\tconst Lc_language_t*\tlanguages[LC_territory_language_max];\n"); 643 fprintf(hf, "#ifdef _LC_TERRITORY_PRIVATE_\n"); 644 fprintf(hf, "\t_LC_TERRITORY_PRIVATE_\n"); 645 fprintf(hf, "#endif\n"); 646 fprintf(hf, "} Lc_territory_t;\n"); 647 fprintf(hf, "\ntypedef struct Lc_map_s\n{\n"); 648 fprintf(hf, "\tconst char*\t\tcode;\n"); 649 fprintf(hf, "\tconst Lc_language_t*\tlanguage;\n"); 650 fprintf(hf, "\tconst Lc_territory_t*\tterritory;\n"); 651 fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n"); 652 fprintf(hf, "\tconst Lc_attribute_t*\tattribute;\n"); 653 fprintf(hf, "} Lc_map_t;\n"); 654 fprintf(hf, "\ntypedef struct Lc_attribute_list_s\n{\n"); 655 fprintf(hf, "\tstruct Lc_attribute_list_s*\tnext;\n"); 656 fprintf(hf, "\tconst Lc_attribute_t*\t\tattribute;\n"); 657 fprintf(hf, "} Lc_attribute_list_t;\n"); 658 fprintf(hf, "\ntypedef struct Lc_s\n{\n"); 659 fprintf(hf, "\tconst char*\t\tname;\n"); 660 fprintf(hf, "\tconst char*\t\tcode;\n"); 661 fprintf(hf, "\tconst Lc_language_t*\tlanguage;\n"); 662 fprintf(hf, "\tconst Lc_territory_t*\tterritory;\n"); 663 fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n"); 664 fprintf(hf, "\tconst Lc_attribute_list_t*\tattributes;\n"); 665 fprintf(hf, "\tunsigned long\t\tflags;\n"); 666 fprintf(hf, "\tunsigned long\t\tindex;\n"); 667 fprintf(hf, "#ifdef _LC_PRIVATE_\n"); 668 fprintf(hf, "\t_LC_PRIVATE_\n"); 669 fprintf(hf, "#endif\n"); 670 fprintf(hf, "} Lc_t;\n"); 671 fprintf(hf, "\nstruct Lc_category_s;\n"); 672 fprintf(hf, "\ntypedef int (*Lc_category_set_f)(struct Lc_category_s*);\n"); 673 fprintf(hf, "\ntypedef struct Lc_category_s\n{\n"); 674 fprintf(hf, "\tconst char*\t\tname;\n"); 675 fprintf(hf, "\tint\t\t\texternal;\n"); 676 fprintf(hf, "\tint\t\t\tinternal;\n"); 677 fprintf(hf, "\tLc_category_set_f\tsetf;\n"); 678 fprintf(hf, "\tLc_t*\t\t\tprev;\n"); 679 fprintf(hf, "} Lc_category_t;\n"); 680 fprintf(hf, "\n"); 681 fprintf(hf, "#if _BLD_ast && defined(__EXPORT__)\n"); 682 fprintf(hf, "#define extern\t\t__EXPORT__\n"); 683 fprintf(hf, "#endif\n"); 684 fprintf(hf, "\n"); 685 fprintf(hf, "extern size_t\t\tlccanon(Lc_t*, unsigned long flags, char*, size_t);\n"); 686 fprintf(hf, "extern Lc_category_t*\tlccategories(void);\n"); 687 fprintf(hf, "extern int\t\tlcindex(int, int);\n"); 688 fprintf(hf, "extern Lc_info_t*\tlcinfo(int);\n"); 689 fprintf(hf, "extern Lc_t*\t\tlcmake(const char*);\n"); 690 fprintf(hf, "extern Lc_t*\t\tlcscan(Lc_t*);\n"); 691 fprintf(hf, "\n"); 692 fprintf(hf, "#undef\textern\n"); 693 fprintf(lf, "\nconst Lc_charset_t lc_charsets[] =\n{\n"); 694 for (cp = (Charset_t*)state.charset.root; cp; cp = (Charset_t*)cp->link.next) 695 { 696 fprintf(lf, "{\"%s\",", cp->link.code); 697 if (cp->alternates) 698 fprintf(lf, "\"%s\",", cp->alternates); 699 else 700 fprintf(lf, "0,"); 701 if (cp->ms) 702 fprintf(lf, "\"%s\",", cp->ms); 703 else 704 fprintf(lf, "0"); 705 fprintf(lf, "},\n"); 706 } 707 fprintf(lf, "\t0\n};\n"); 708 fprintf(lf, "\nconst Lc_language_t lc_languages[] =\n{\n"); 709 fprintf(lf, "{\"C\",\"C\",\"POSIX\",&lc_charsets[0],LC_default,0,"); 710 for (i = 0; i < language_attribute_max; i++) 711 fprintf(lf, "0,"); 712 fprintf(lf, "},\n"); 713 fprintf(lf, "{\"debug\",\"debug\",0,&lc_charsets[0],LC_debug,0,"); 714 for (i = 0; i < language_attribute_max; i++) 715 fprintf(lf, "0,"); 716 fprintf(lf, "},\n"); 717 for (lp = (Language_t*)state.language.root; lp; lp = (Language_t*)lp->link.next) 718 { 719 fprintf(lf, "{\"%s\",\"%s\",", lp->link.code, lp->name); 720 if (lp->alternates) 721 fprintf(lf, "\"%s\",", lp->alternates); 722 else 723 fprintf(lf, "0,"); 724 fprintf(lf, "&lc_charsets[%d],0,", lp->charset ? lp->charset->link.index : 0); 725 macro(lf, "LANG", lp->name, (char*)0); 726 for (i = 0, al = lp->attributes; al; al = al->next, i++) 727 fprintf(lf, "&attribute_%s[%d],", lp->link.code, al->attribute->link.index); 728 for (; i < language_attribute_max; i++) 729 fprintf(lf, "0,"); 730 fprintf(lf, "\n},\n"); 731 } 732 fprintf(lf, "\t0\n};\n"); 733 fprintf(lf, "\nconst Lc_territory_t lc_territories[] =\n{\n"); 734 fprintf(lf, "{\"C\",\"C\",LC_default,0,&lc_languages[0],"); 735 for (i = 1; i < 2 * territory_language_max; i++) 736 fprintf(lf, "0,"); 737 fprintf(lf, "},\n"); 738 fprintf(lf, "{\"debug\",\"debug\",LC_debug,0,&lc_languages[1],"); 739 for (i = 1; i < 2 * territory_language_max; i++) 740 fprintf(lf, "0,"); 741 fprintf(lf, "},\n"); 742 for (tp = (Territory_t*)state.territory.root; tp; tp = (Territory_t*)tp->link.next) 743 { 744 fprintf(lf, "{\"%s\",\"%s\",", tp->link.code, tp->name); 745 if (tp->primary) 746 fprintf(lf, "LC_primary,"); 747 else 748 fprintf(lf, "0,"); 749 macro(lf, "CTRY", tp->name, (char*)0); 750 for (i = 0, ll = tp->languages; ll; ll = ll->next, i++) 751 fprintf(lf, "&lc_languages[%d],", ll->language->link.index); 752 for (; i < territory_language_max; i++) 753 fprintf(lf, "0,"); 754 for (i = 0, ll = tp->languages; ll; ll = ll->next, i++) 755 macro(lf, "SUBLANG", ll->language->name, tp->name); 756 for (; i < territory_language_max; i++) 757 fprintf(lf, "0,"); 758 fprintf(lf, "\n},\n"); 759 } 760 fprintf(lf, "\t0\n};\n"); 761 fprintf(lf, "\nconst Lc_map_t lc_maps[] =\n{\n"); 762 for (mp = (Map_t*)state.map.root; mp; mp = (Map_t*)mp->link.next) 763 { 764 fprintf(lf, "{\"%s\",", mp->link.code); 765 fprintf(lf, "&lc_languages[%d],", mp->language->link.index); 766 fprintf(lf, "&lc_territories[%d],", mp->territory->link.index); 767 fprintf(lf, "&lc_charsets[%d],", mp->charset ? mp->charset->link.index : 0); 768 if (mp->attribute) 769 fprintf(lf, "&attribute_%s[%d]", mp->language->link.code, mp->attribute->link.index); 770 else 771 fprintf(lf, "0"); 772 fprintf(lf, "},\n"); 773 } 774 fprintf(lf, "\t0\n};\n"); 775 fclose(lf); 776 fprintf(hf, "\n#endif\n"); 777 fclose(hf); 778 return 0; 779 } 780