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