diff options
Diffstat (limited to 'usr/src/lib/libast/common/port/lcgen.c')
-rw-r--r-- | usr/src/lib/libast/common/port/lcgen.c | 775 |
1 files changed, 775 insertions, 0 deletions
diff --git a/usr/src/lib/libast/common/port/lcgen.c b/usr/src/lib/libast/common/port/lcgen.c new file mode 100644 index 0000000000..bfc8656406 --- /dev/null +++ b/usr/src/lib/libast/common/port/lcgen.c @@ -0,0 +1,775 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1985-2007 AT&T Knowledge Ventures * +* and is licensed under the * +* Common Public License, Version 1.0 * +* by AT&T Knowledge Ventures * +* * +* A copy of the License is available at * +* http://www.opensource.org/licenses/cpl1.0.txt * +* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* David Korn <dgk@research.att.com> * +* Phong Vo <kpv@research.att.com> * +* * +***********************************************************************/ +/* + * generate <lc.h> implementation tables from lc.tab + * this must make it through vanilla cc with no -last + * + * # comment + * :charset: + * code name ms-codepage + * :language: + * code name alt1|alt2... charset|... attr1|attr2|... + * ... + * :territory: + * code name lang1|lang2... + * :abbreviation: + */ + +#include <stdio.h> +#include <ctype.h> +#ifdef __STDC__ +#include <stdlib.h> +#include <string.h> +#endif + +typedef struct Link_s +{ + struct Link_s* next; + char* code; + int index; +} Link_t; + +typedef struct Table_s +{ + Link_t* root; + int count; +} Table_t; + +typedef struct Abbreviation_s +{ + Link_t link; + char* value; +} Abbreviation_t; + +typedef struct Attribute_s +{ + Link_t link; +} Attribute_t; + +typedef struct Attribute_list_s +{ + struct Attribute_list_s*next; + Attribute_t* attribute; +} Attribute_list_t; + +typedef struct Charset_s +{ + Link_t link; + char* alternates; + char* ms; +} Charset_t; + +typedef struct Language_s +{ + Link_t link; + char* name; + char* alternates; + Charset_t* charset; + Attribute_list_t* attributes; +} Language_t; + +typedef struct Language_list_s +{ + struct Language_list_s* next; + Language_t* language; +} Language_list_t; + +typedef struct Territory_s +{ + Link_t link; + char* name; + Language_list_t* languages; + int primary; + int index; +} Territory_t; + +typedef struct Map_s +{ + Link_t link; + Language_t* language; + Territory_t* territory; + Charset_t* charset; + Attribute_t* attribute; +} Map_t; + +static struct State_s +{ + Table_t attribute; + Table_t charset; + Table_t language; + Table_t territory; + Table_t map; +} state; + +#define INIT 0 +#define CHARSET 1 +#define LANGUAGE 2 +#define TERRITORY 3 +#define MAP 4 + +#define elementsof(x) (sizeof(x)/sizeof(x[0])) +#define newof(p,t,n,x) ((t*)malloc(sizeof(t)*(n)+(x))) + +static Link_t* +#if defined(__STDC__) || defined(__cplusplus) +enter(register Table_t* tab, register Link_t* v) +#else +enter(tab, v) +register Table_t* tab; +register Link_t* v; +#endif +{ + register Link_t* x; + register Link_t* p; + + for (p = 0, x = tab->root; x; p = x, x = x->next) + if (!strcmp(x->code, v->code)) + return x; + if (p) + p->next = v; + else + tab->root = v; + v->next = 0; + v->index = tab->count++; + return v; +} + +static Link_t* +#if defined(__STDC__) || defined(__cplusplus) +lookup(register Table_t* tab, register char* s) +#else +lookup(tab, s) +register Table_t* tab; +register char* s; +#endif +{ + register Link_t* x; + + for (x = tab->root; x; x = x->next) + if (!strcmp(x->code, s)) + return x; + return 0; +} + +static char* +#if defined(__STDC__) || defined(__cplusplus) +copy(char** p, register char* f) +#else +copy(p, f) +char** p; +register char* f; +#endif +{ + register char* t; + char* b; + + if (!f) + return 0; + b = t = *p; + while (*t++ = *f++); + *p = t; + return b; +} + +static void +#if defined(__STDC__) || defined(__cplusplus) +macro(FILE* f, char* p1, char* p2, char* p3) +#else +macro(f, p1, p2, p3) +FILE* f; +char* p1; +char* p2; +char* p3; +#endif +{ + register int c; + register char* s; + register char* b; + register char* e; + int i; + int m; + int n; + char* part[4]; + char buf[128]; + + part[0] = p1; + part[1] = p2; + part[2] = p3; + part[3] = 0; + n = 0; + fprintf(f, "\n"); + do + { + i = m = 0; + b = buf; + e = &buf[sizeof(buf)-1]; + while (b < e) + { + if (!(s = part[i++])) + break; + if (i > 1) + *b++ = '_'; + while ((c = *s++) && b < e) + { + if (c == '|') + { + part[i-1] = s; + m = 1; + break; + } + else if (islower(c)) + c = toupper(c); + else if (!isalnum(c)) + c = '_'; + *b++ = c; + } + } + *b = 0; + fprintf(f, "#ifdef %s\n%s,\n#else\n", buf, buf); + n++; + } while (m); + fprintf(f, "0,\n"); + while (n-- > 0) + fprintf(f, "#endif\n"); +} + +#if defined(__STDC__) || defined(__cplusplus) +int +main(int argc, char** argv) +#else +int +main(argc, argv) +int argc; +char** argv; +#endif +{ + register char* s; + register char** vp; + register char** ve; + Attribute_t* ap; + Attribute_list_t* al; + Attribute_list_t* az; + Charset_t* cp; + Territory_t* tp; + Language_t* lp; + Language_list_t* ll; + Language_list_t* lz; + Map_t* mp; + char* b; + char* f; + char* command; + char* hdr; + char* lib; + FILE* hf; + FILE* lf; + int c; + int i; + int line; + int type; + int language_attribute_max; + int territory_language_max; + char* arg[5]; + char buf[1024]; + + command = *argv++; + line = 0; + if (!(hdr = *argv++) || !(lib = *argv++) || *argv) + { + fprintf(stderr, "%s: hdr and lib arguments expected\n", command); + return 1; + } + if (!(hf = fopen(hdr, "w"))) + { + fprintf(stderr, "%s: %s: cannot write\n", command, hdr); + return 1; + } + if (!(lf = fopen(lib, "w"))) + { + fprintf(stderr, "%s: %s: cannot write\n", command, lib); + return 1; + } + type = 0; + language_attribute_max = 0; + territory_language_max = 0; + state.language.count = 2; + state.territory.count = 2; + ve = &arg[elementsof(arg)]; + fprintf(hf, "/* : : generated by %s : : */\n", command); + fprintf(hf, "#pragma prototyped\n"); + fprintf(hf, "\n"); + fprintf(hf, "#ifndef _LC_H\n"); + fprintf(hf, "#define _LC_H\t\t\t1\n"); + fprintf(hf, "\n"); + fprintf(hf, "#include <ast.h>\n"); + fprintf(hf, "\n"); + fprintf(hf, "#define LC_abbreviated\t\t0x00001\n"); + fprintf(hf, "#define LC_checked\t\t0x00002\n"); + fprintf(hf, "#define LC_default\t\t0x00004\n"); + fprintf(hf, "#define LC_defined\t\t0x00008\n"); + fprintf(hf, "#define LC_debug\t\t0x00010\n"); + fprintf(hf, "#define LC_local\t\t0x00020\n"); + fprintf(hf, "#define LC_primary\t\t0x00040\n"); + fprintf(hf, "#define LC_qualified\t\t0x00080\n"); + fprintf(hf, "#define LC_undefined\t\t0x00100\n"); + fprintf(hf, "#define LC_verbose\t\t0x00200\n"); + fprintf(hf, "#define LC_user\t\t\t0x10000\n"); + fprintf(lf, "/* : : generated by %s : : */\n", command); + while (s = fgets(buf, sizeof(buf), stdin)) + { + line++; + while (isspace(*s)) + s++; + if (!*s || *s == '#') + continue; + b = s; + vp = arg; + for (;;) + { + for (*vp++ = s; *s && !isspace(*s); s++); + if (!*s) + break; + for (*s++ = 0; isspace(*s); s++); + if (!strcmp(*(vp - 1), "-")) + *(vp - 1) = 0; + if (!*s || vp >= ve) + break; + } + while (vp < ve) + *vp++ = 0; + if (*arg[0] == ':') + { + if (!strcmp(arg[0], ":map:")) + { + if (type != TERRITORY) + { + fprintf(stderr, "%s: %d: %s: must be specified after :territory:\n", command, line, arg[0]); + return 1; + } + type = MAP; + continue; + } + else if (!strcmp(arg[0], ":charset:")) + { + if (type != INIT) + { + fprintf(stderr, "%s: %d: %s must be specified first\n", command, line, arg[0]); + return 1; + } + type = CHARSET; + continue; + } + else if (!strcmp(arg[0], ":territory:")) + { + if (type != LANGUAGE) + { + fprintf(stderr, "%s: %d: %s: must be specified after :language:\n", command, line, arg[0]); + return 1; + } + type = TERRITORY; + continue; + } + else if (!strcmp(arg[0], ":language:")) + { + if (type != CHARSET) + { + fprintf(stderr, "%s: %d: %s must be specified after :charset:\n", command, line, arg[0]); + return 1; + } + type = LANGUAGE; + continue; + } + else + { + fprintf(stderr, "%s: %d: %s invalid\n", command, line, arg[0]); + return 1; + } + } + if (!arg[1]) + { + fprintf(stderr, "%s: %d: at least two arguments expected\n", command, line); + return 1; + } + switch (type) + { + case CHARSET: + if (!(cp = newof(0, Charset_t, 1, s - b + 1))) + { + fprintf(stderr, "%s: %d: out of space\n", command, line); + return 1; + } + b = (char*)(cp + 1); + cp->link.code = copy(&b, arg[0]); + cp->alternates = copy(&b, arg[1]); + cp->ms = copy(&b, arg[2]); + if (cp != (Charset_t*)enter(&state.charset, (Link_t*)cp)) + { + fprintf(stderr, "%s: %d: %s: duplicate charset\n", command, line, cp->link.code); + return 1; + } + break; + case TERRITORY: + if (!(tp = newof(0, Territory_t, 1, s - b + 1))) + { + fprintf(stderr, "%s: %d: out of space\n", command, line); + return 1; + } + b = (char*)(tp + 1); + tp->link.code = copy(&b, arg[0]); + tp->name = copy(&b, arg[1]); + tp->languages = 0; + if (s = copy(&b, arg[2])) + { + i = 0; + while (*(b = s)) + { + for (; *s && *s != ':' && *s != '|'; s++); + if (c = *s) + *s++ = 0; + if (!(lp = (Language_t*)lookup(&state.language, b))) + { + fprintf(stderr, "%s: %d: %s: unknown language\n", command, line, b); + return 1; + } + if (!(ll = newof(0, Language_list_t, 1, 0))) + { + fprintf(stderr, "%s: %d: out of space\n", command, line); + return 1; + } + if (!tp->languages) + tp->languages = ll; + else + lz->next = ll; + lz = ll; + ll->language = lp; + ll->next = 0; + i++; + if (c == ':') + { + for (b = s; *s && *s != '|'; s++); + if (*s) + *s++ = 0; + if (!strcmp(b, "primary")) + tp->primary = 1; + } + } + if (territory_language_max < i) + territory_language_max = i; + } + if (tp != (Territory_t*)enter(&state.territory, (Link_t*)tp)) + { + fprintf(stderr, "%s: %d: %s: duplicate territory\n", command, line, tp->link.code); + return 1; + } + break; + case LANGUAGE: + if (!(lp = newof(0, Language_t, 1, s - b + 1))) + { + fprintf(stderr, "%s: %d: out of space\n", command, line); + return 1; + } + b = (char*)(lp + 1); + lp->link.code = copy(&b, arg[0]); + lp->name = copy(&b, arg[1]); + lp->alternates = copy(&b, arg[2]); + if (!arg[3]) + lp->charset = 0; + else if (!(lp->charset = (Charset_t*)lookup(&state.charset, arg[3]))) + { + fprintf(stderr, "%s: %d: %s: unknown charset\n", command, line, arg[3]); + return 1; + } + lp->attributes = 0; + if (s = copy(&b, arg[4])) + { + i = 0; + fprintf(lf, "\nstatic Lc_attribute_t attribute_%s[] =\n{\n", lp->link.code); + while (*(b = s)) + { + for (f = 0; *s && *s != '|'; s++) + if (*s == ':') + { + *s++ = 0; + f = s; + } + if (*s) + *s++ = 0; + fprintf(lf, "{\"%s\",", b); + if (f) + fprintf(lf, "LC_%s,", f); + else + fprintf(lf, "0,"); + if (!(ap = newof(0, Attribute_t, 1, 0))) + { + fprintf(stderr, "%s: %d: out of space\n", command, line); + return 1; + } + ap->link.code = b; + ap->link.index = i++; + if (!(al = newof(0, Attribute_list_t, 1, 0))) + { + fprintf(stderr, "%s: %d: out of space\n", command, line); + return 1; + } + if (!lp->attributes) + lp->attributes = al; + else + az->next = al; + az = al; + al->attribute = ap; + al->next = 0; + macro(lf, "SUBLANG", lp->name, b); + fprintf(lf, "\n},\n"); + } + if (language_attribute_max < i) + language_attribute_max = i; + fprintf(lf, "};\n"); + } + if (lp != (Language_t*)enter(&state.language, (Link_t*)lp)) + { + fprintf(stderr, "%s: %d: %s: duplicate language\n", command, line, lp->link.code); + return 1; + } + break; + case MAP: + if (!(mp = newof(0, Map_t, 1, s - b + 1))) + { + fprintf(stderr, "%s: %d: out of space\n", command, line); + return 1; + } + b = (char*)(mp + 1); + mp->link.code = copy(&b, arg[0]); + if (!arg[2]) + { + fprintf(stderr, "%s: %d: territory code expected\n", command, line); + return 1; + } + if (!(mp->language = (Language_t*)lookup(&state.language, arg[1]))) + { + fprintf(stderr, "%s: %d: %s: unknown language\n", command, line, arg[1]); + return 1; + } + if (!(mp->territory = (Territory_t*)lookup(&state.territory, arg[2]))) + { + fprintf(stderr, "%s: %d: %s: unknown territory\n", command, line, arg[2]); + return 1; + } + if (!arg[3]) + mp->charset = 0; + else if (!(mp->charset = (Charset_t*)lookup(&state.charset, arg[3]))) + { + fprintf(stderr, "%s: %d: %s: unknown charset\n", command, line, arg[3]); + return 1; + } + mp->attribute = 0; + if (arg[4]) + { + for (al = mp->language->attributes; al; al = al->next) + if (!strcmp(al->attribute->link.code, arg[4])) + { + mp->attribute = al->attribute; + break; + } + if (!mp->attribute) + { + fprintf(stderr, "%s: %d: %s: unknown attribute\n", command, line, arg[4]); + return 1; + } + } + if (mp != (Map_t*)enter(&state.map, (Link_t*)mp)) + { + fprintf(stderr, "%s: %d: %s: duplicate map\n", command, line, mp->link.code); + return 1; + } + break; + } + } + fprintf(hf, "#define LC_language_attribute_max\t\t%d\n", language_attribute_max); + fprintf(hf, "#define LC_territory_language_max\t\t%d\n", territory_language_max); + fprintf(hf, "\nstruct Lc_s;\n"); + fprintf(hf, "\ntypedef struct Lc_info_s\n{\n"); + fprintf(hf, "\tconst struct Lc_s*\tlc;\n"); + fprintf(hf, "\tunsigned long\t\tnumber;\n"); + fprintf(hf, "\tvoid*\t\t\tdata;\n"); + fprintf(hf, "} Lc_info_t;\n"); + fprintf(hf, "\ntypedef struct Lc_attribute_s\n{\n"); + fprintf(hf, "\tconst char*\t\tname;\n"); + fprintf(hf, "\tunsigned long\t\tflags;\n"); + fprintf(hf, "\tunsigned long\t\tindex;\n"); + fprintf(hf, "} Lc_attribute_t;\n"); + fprintf(hf, "\ntypedef struct Lc_charset_s\n{\n"); + fprintf(hf, "\tconst char*\t\tcode;\n"); + fprintf(hf, "\tconst char*\t\talternates;\n"); + fprintf(hf, "\tconst char*\t\tms;\n"); + fprintf(hf, "\tunsigned long\t\tindex;\n"); + fprintf(hf, "} Lc_charset_t;\n"); + fprintf(hf, "\ntypedef struct Lc_language_s\n{\n"); + fprintf(hf, "\tconst char*\t\tcode;\n"); + fprintf(hf, "\tconst char*\t\tname;\n"); + fprintf(hf, "\tconst char*\t\talternates;\n"); + fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n"); + fprintf(hf, "\tunsigned long\t\tflags;\n"); + fprintf(hf, "\tunsigned long\t\tindex;\n"); + fprintf(hf, "\tconst Lc_attribute_t*\tattributes[LC_language_attribute_max];\n"); + fprintf(hf, "} Lc_language_t;\n"); + fprintf(hf, "\ntypedef struct Lc_territory_s\n{\n"); + fprintf(hf, "\tconst char*\t\tcode;\n"); + fprintf(hf, "\tconst char*\t\tname;\n"); + fprintf(hf, "\tunsigned long\t\tflags;\n"); + fprintf(hf, "\tunsigned long\t\tindex;\n"); + fprintf(hf, "\tconst Lc_language_t*\tlanguages[LC_territory_language_max];\n"); + fprintf(hf, "#ifdef _LC_TERRITORY_PRIVATE_\n"); + fprintf(hf, "\t_LC_TERRITORY_PRIVATE_\n"); + fprintf(hf, "#endif\n"); + fprintf(hf, "} Lc_territory_t;\n"); + fprintf(hf, "\ntypedef struct Lc_map_s\n{\n"); + fprintf(hf, "\tconst char*\t\tcode;\n"); + fprintf(hf, "\tconst Lc_language_t*\tlanguage;\n"); + fprintf(hf, "\tconst Lc_territory_t*\tterritory;\n"); + fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n"); + fprintf(hf, "\tconst Lc_attribute_t*\tattribute;\n"); + fprintf(hf, "} Lc_map_t;\n"); + fprintf(hf, "\ntypedef struct Lc_attribute_list_s\n{\n"); + fprintf(hf, "\tstruct Lc_attribute_list_s*\tnext;\n"); + fprintf(hf, "\tconst Lc_attribute_t*\t\tattribute;\n"); + fprintf(hf, "} Lc_attribute_list_t;\n"); + fprintf(hf, "\ntypedef struct Lc_s\n{\n"); + fprintf(hf, "\tconst char*\t\tname;\n"); + fprintf(hf, "\tconst char*\t\tcode;\n"); + fprintf(hf, "\tconst Lc_language_t*\tlanguage;\n"); + fprintf(hf, "\tconst Lc_territory_t*\tterritory;\n"); + fprintf(hf, "\tconst Lc_charset_t*\tcharset;\n"); + fprintf(hf, "\tconst Lc_attribute_list_t*\tattributes;\n"); + fprintf(hf, "\tunsigned long\t\tflags;\n"); + fprintf(hf, "\tunsigned long\t\tindex;\n"); + fprintf(hf, "#ifdef _LC_PRIVATE_\n"); + fprintf(hf, "\t_LC_PRIVATE_\n"); + fprintf(hf, "#endif\n"); + fprintf(hf, "} Lc_t;\n"); + fprintf(hf, "\nstruct Lc_category_s;\n"); + fprintf(hf, "\ntypedef int (*Lc_category_set_f)(struct Lc_category_s*);\n"); + fprintf(hf, "\ntypedef struct Lc_category_s\n{\n"); + fprintf(hf, "\tconst char*\t\tname;\n"); + fprintf(hf, "\tint\t\t\texternal;\n"); + fprintf(hf, "\tint\t\t\tinternal;\n"); + fprintf(hf, "\tLc_category_set_f\tsetf;\n"); + fprintf(hf, "\tLc_t*\t\t\tprev;\n"); + fprintf(hf, "} Lc_category_t;\n"); + fprintf(hf, "\n"); + fprintf(hf, "#if _BLD_ast && defined(__EXPORT__)\n"); + fprintf(hf, "#define extern\t\t__EXPORT__\n"); + fprintf(hf, "#endif\n"); + fprintf(hf, "\n"); + fprintf(hf, "extern size_t\t\tlccanon(Lc_t*, unsigned long flags, char*, size_t);\n"); + fprintf(hf, "extern Lc_category_t*\tlccategories(void);\n"); + fprintf(hf, "extern int\t\tlcindex(int, int);\n"); + fprintf(hf, "extern Lc_info_t*\tlcinfo(int);\n"); + fprintf(hf, "extern Lc_t*\t\tlcmake(const char*);\n"); + fprintf(hf, "extern Lc_t*\t\tlcscan(Lc_t*);\n"); + fprintf(hf, "\n"); + fprintf(hf, "#undef\textern\n"); + fprintf(lf, "\nstatic const Lc_charset_t charset[] =\n{\n"); + for (cp = (Charset_t*)state.charset.root; cp; cp = (Charset_t*)cp->link.next) + { + fprintf(lf, "{\"%s\",", cp->link.code); + if (cp->alternates) + fprintf(lf, "\"%s\",", cp->alternates); + else + fprintf(lf, "0,"); + if (cp->ms) + fprintf(lf, "\"%s\",", cp->ms); + else + fprintf(lf, "0"); + fprintf(lf, "},\n"); + } + fprintf(lf, "\t0\n};\n"); + fprintf(lf, "\nstatic const Lc_language_t language[] =\n{\n"); + fprintf(lf, "{\"C\",\"C\",\"POSIX\",&charset[0],LC_default,0,"); + for (i = 0; i < language_attribute_max; i++) + fprintf(lf, "0,"); + fprintf(lf, "},\n"); + fprintf(lf, "{\"debug\",\"debug\",0,&charset[0],LC_debug,0,"); + for (i = 0; i < language_attribute_max; i++) + fprintf(lf, "0,"); + fprintf(lf, "},\n"); + for (lp = (Language_t*)state.language.root; lp; lp = (Language_t*)lp->link.next) + { + fprintf(lf, "{\"%s\",\"%s\",", lp->link.code, lp->name); + if (lp->alternates) + fprintf(lf, "\"%s\",", lp->alternates); + else + fprintf(lf, "0,"); + fprintf(lf, "&charset[%d],0,", lp->charset ? lp->charset->link.index : 0); + macro(lf, "LANG", lp->name, (char*)0); + for (i = 0, al = lp->attributes; al; al = al->next, i++) + fprintf(lf, "&attribute_%s[%d],", lp->link.code, al->attribute->link.index); + for (; i < language_attribute_max; i++) + fprintf(lf, "0,"); + fprintf(lf, "\n},\n"); + } + fprintf(lf, "\t0\n};\n"); + fprintf(lf, "\nstatic const Lc_territory_t territory[] =\n{\n"); + fprintf(lf, "{\"C\",\"C\",LC_default,0,&language[0],"); + for (i = 1; i < 2 * territory_language_max; i++) + fprintf(lf, "0,"); + fprintf(lf, "},\n"); + fprintf(lf, "{\"debug\",\"debug\",LC_debug,0,&language[1],"); + for (i = 1; i < 2 * territory_language_max; i++) + fprintf(lf, "0,"); + fprintf(lf, "},\n"); + for (tp = (Territory_t*)state.territory.root; tp; tp = (Territory_t*)tp->link.next) + { + fprintf(lf, "{\"%s\",\"%s\",", tp->link.code, tp->name); + if (tp->primary) + fprintf(lf, "LC_primary,"); + else + fprintf(lf, "0,"); + macro(lf, "CTRY", tp->name, (char*)0); + for (i = 0, ll = tp->languages; ll; ll = ll->next, i++) + fprintf(lf, "&language[%d],", ll->language->link.index); + for (; i < territory_language_max; i++) + fprintf(lf, "0,"); + for (i = 0, ll = tp->languages; ll; ll = ll->next, i++) + macro(lf, "SUBLANG", ll->language->name, tp->name); + for (; i < territory_language_max; i++) + fprintf(lf, "0,"); + fprintf(lf, "\n},\n"); + } + fprintf(lf, "\t0\n};\n"); + fprintf(lf, "\nstatic const Lc_map_t map[] =\n{\n"); + for (mp = (Map_t*)state.map.root; mp; mp = (Map_t*)mp->link.next) + { + fprintf(lf, "{\"%s\",", mp->link.code); + fprintf(lf, "&language[%d],", mp->language->link.index); + fprintf(lf, "&territory[%d],", mp->territory->link.index); + fprintf(lf, "&charset[%d],", mp->charset ? mp->charset->link.index : 0); + if (mp->attribute) + fprintf(lf, "&attribute_%s[%d]", mp->language->link.code, mp->attribute->link.index); + else + fprintf(lf, "0"); + fprintf(lf, "},\n"); + } + fprintf(lf, "\t0\n};\n"); + fclose(lf); + fprintf(hf, "\n#endif\n"); + fclose(hf); + return 0; +} |