#define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include <limits.h> #include <assert.h> #include <locale.h> #include <langinfo.h> #include <nl_types.h> #include <stdint.h> #include "c8tables.h" #define __LOCALE_DATA_CATEGORIES 6 /* must agree with ordering of gen_mmap! */ static const unsigned char *lc_names[] = { "LC_CTYPE", "LC_NUMERIC", "LC_MONETARY", "LC_TIME", "LC_COLLATE", "LC_MESSAGES", #if __LOCALE_DATA_CATEGORIES == 12 "LC_PAPER", "LC_NAME", "LC_ADDRESS", "LC_TELEPHONE", "LC_MEASUREMENT", "LC_IDENTIFICATION", #elif __LOCALE_DATA_CATEGORIES != 6 #error unsupported __LOCALE_DATA_CATEGORIES value! #endif }; typedef struct { char *glibc_name; char name[5]; char dot_cs; /* 0 if no codeset specified */ char cs; unsigned char idx_name; unsigned char lc_time_row; unsigned char lc_numeric_row; unsigned char lc_monetary_row; unsigned char lc_messages_row; unsigned char lc_ctype_row; #if __LOCALE_DATA_CATEGORIES != 6 #error unsupported __LOCALE_DATA_CATEGORIES value #endif } locale_entry; static void read_at_mappings(void); static void read_enable_disable(void); static void read_locale_list(void); static int find_codeset_num(const char *cs); static int find_at_string_num(const char *as); static int le_cmp(const void *, const void *); static void dump_table8(const char *name, const char *tbl, int len); static void dump_table8c(const char *name, const char *tbl, int len); static void dump_table16(const char *name, const int *tbl, int len); static void do_lc_time(void); static void do_lc_numeric(void); static void do_lc_monetary(void); static void do_lc_messages(void); static void do_lc_ctype(void); static FILE *fp; static FILE *ofp; static char line_buf[80]; static char at_mappings[256]; static char at_mapto[256]; static char at_strings[1024]; static char *at_strings_end; static locale_entry locales[700]; static char glibc_locale_names[60000]; static int num_locales; static int default_utf8; static int default_8bit; static int total_size; static int null_count; static void do_locale_names(void) { /* "C" locale name is handled specially by the setlocale code. */ int uniq = 0; int i; if (num_locales <= 1) { /* printf("error - only C locale?\n"); */ /* exit(EXIT_FAILURE); */ fprintf(ofp, "static const unsigned char __locales[%d];\n", (3 + __LOCALE_DATA_CATEGORIES)); fprintf(ofp, "static const unsigned char __locale_names5[5];\n"); } else { if (default_utf8) { fprintf(ofp, "#define __CTYPE_HAS_UTF_8_LOCALES\t\t\t1\n"); } fprintf(ofp, "#define __LOCALE_DATA_CATEGORIES\t\t\t%d\n", __LOCALE_DATA_CATEGORIES); fprintf(ofp, "#define __LOCALE_DATA_WIDTH_LOCALES\t\t\t%d\n", 3+__LOCALE_DATA_CATEGORIES); fprintf(ofp, "#define __LOCALE_DATA_NUM_LOCALES\t\t\t%d\n", num_locales); fprintf(ofp, "static const unsigned char __locales[%d] = {\n", (num_locales) * (3 + __LOCALE_DATA_CATEGORIES)); for (i=0 ; i < num_locales ; i++) { if (memcmp(locales[i].name, locales[i-1].name, 5) != 0) { locales[i].idx_name = uniq; ++uniq; } else { locales[i].idx_name = uniq - 1; } fprintf(ofp, "\t%#4x, ", (int)((unsigned char) locales[i].idx_name)); fprintf(ofp, "\t%#4x, ", (int)((unsigned char) locales[i].dot_cs)); fprintf(ofp, "\t%#4x, ", (int)((unsigned char) locales[i].cs)); /* lc_ctype would store translit flags and turkish up/low flag. */ fprintf(ofp, "%#4x, ", (int)((unsigned char) locales[i].lc_ctype_row)); fprintf(ofp, "%#4x, ", (int)((unsigned char) locales[i].lc_numeric_row)); fprintf(ofp, "%#4x, ", (int)((unsigned char) locales[i].lc_monetary_row)); fprintf(ofp, "%#4x, ", (int)((unsigned char) locales[i].lc_time_row)); #if 1 /* lc_collate */ if (strlen(locales[i].glibc_name) >= 5) { fprintf(ofp, "COL_IDX_%.2s_%.2s, ", locales[i].glibc_name, locales[i].glibc_name+3); } else if (!strcmp(locales[i].glibc_name, "C")) { fprintf(ofp, "COL_IDX_C , "); } else { printf("don't know how to handle COL_IDX_ for %s\n", locales[i].glibc_name); exit(EXIT_FAILURE); } #else fprintf(ofp, "%#4x, ", 0); /* place holder for lc_collate */ #endif fprintf(ofp, "%#4x, ", (int)((unsigned char) locales[i].lc_messages_row)); fprintf(ofp, "\t/* %s */\n", locales[i].glibc_name); } fprintf(ofp, "};\n\n"); fprintf(ofp, "#define __LOCALE_DATA_NUM_LOCALE_NAMES\t\t%d\n", uniq ); fprintf(ofp, "static const unsigned char __locale_names5[%d] = \n\t", uniq * 5); uniq = 0; for (i=1 ; i < num_locales ; i++) { if (memcmp(locales[i].name, locales[i-1].name, 5) != 0) { fprintf(ofp, "\"%5.5s\" ", locales[i].name); ++uniq; if ((uniq % 8) == 0) { fprintf(ofp, "\n\t"); } } } fprintf(ofp,";\n\n"); if (at_strings_end > at_strings) { int i, j; char *p; i = 0; p = at_strings; while (*p) { ++i; p += 1 + (unsigned char) *p; } /* len, char, string\0 */ fprintf(ofp, "#define __LOCALE_DATA_AT_MODIFIERS_LENGTH\t\t%d\n", i + (at_strings_end - at_strings)); fprintf(ofp, "static const unsigned char __locale_at_modifiers[%d] = {", i + (at_strings_end - at_strings)); i = 0; p = at_strings; while (*p) { fprintf(ofp, "\n\t%4d, '%c',", (unsigned char) *p, /* len of string\0 */ at_mapto[i]); for (j=1 ; j < ((unsigned char) *p) ; j++) { fprintf(ofp, " '%c',", p[j]); } fprintf(ofp, " 0,"); ++i; p += 1 + (unsigned char) *p; } fprintf(ofp, "\n};\n\n"); } { int pos[__LOCALE_DATA_CATEGORIES]; pos[0] = __LOCALE_DATA_CATEGORIES; for (i=0 ; i < __LOCALE_DATA_CATEGORIES ; i++) { fprintf(ofp, "#define __%s\t\t%d\n", lc_names[i], i); if (i + 1 < __LOCALE_DATA_CATEGORIES) { pos[i+1] = 1 + strlen(lc_names[i]) + pos[i]; } } if (pos[__LOCALE_DATA_CATEGORIES-1] > 255) { printf("error - lc_names is too big (%d)\n", pos[__LOCALE_DATA_CATEGORIES-1]); exit(EXIT_FAILURE); } fprintf(ofp, "#define __LC_ALL\t\t%d\n\n", i); fprintf(ofp, "#define __lc_names_LEN\t\t%d\n", pos[__LOCALE_DATA_CATEGORIES-1] + strlen(lc_names[__LOCALE_DATA_CATEGORIES-1]) + 1); total_size += pos[__LOCALE_DATA_CATEGORIES-1] + strlen(lc_names[__LOCALE_DATA_CATEGORIES-1]) + 1; fprintf(ofp, "static unsigned const char lc_names[%d] =\n", pos[__LOCALE_DATA_CATEGORIES-1] + strlen(lc_names[__LOCALE_DATA_CATEGORIES-1]) + 1); fprintf(ofp, "\t\""); for (i=0 ; i < __LOCALE_DATA_CATEGORIES ; i++) { fprintf(ofp, "\\x%02x", (unsigned char) pos[i]); } fprintf(ofp, "\""); for (i=0 ; i < __LOCALE_DATA_CATEGORIES ; i++) { fprintf(ofp, "\n\t\"%s\\0\"", lc_names[i]); } fprintf(ofp, ";\n\n"); } printf("locale data = %d name data = %d for %d uniq\n", num_locales * (3 + __LOCALE_DATA_CATEGORIES), uniq * 5, uniq); total_size += num_locales * (3 + __LOCALE_DATA_CATEGORIES) + uniq * 5; } } static void read_at_mappings(void) { char *p; char *m; int mc = 0; do { if (!(p = strtok(line_buf, " \t\n")) || (*p == '#')) { if (!fgets(line_buf, sizeof(line_buf), fp)) { if (ferror(fp)) { printf("error reading file\n"); exit(EXIT_FAILURE); } return; /* EOF */ } if ((*line_buf == '#') && (line_buf[1] == '-')) { break; } continue; } if (*p == '@') { if (p[1] == 0) { printf("error: missing @modifier name\n"); exit(EXIT_FAILURE); } m = p; /* save the modifier name */ if (!(p = strtok(NULL, " \t\n")) || p[1] || (((unsigned char) *p) > 0x7f)) { printf("error: missing or illegal @modifier mapping char\n"); exit(EXIT_FAILURE); } if (at_mappings[(int)((unsigned char) *p)]) { printf("error: reused @modifier mapping char\n"); exit(EXIT_FAILURE); } at_mappings[(int)((unsigned char) *p)] = 1; at_mapto[mc] = *p; ++mc; *at_strings_end = (char)( (unsigned char) (strlen(m)) ); strcpy(++at_strings_end, m+1); at_strings_end += (unsigned char) at_strings_end[-1]; printf("@mapping: \"%s\" to '%c'\n", m, *p); if (((p = strtok(NULL, " \t\n")) != NULL) && (*p != '#')) { printf("ignoring trailing text: %s...\n", p); } *line_buf = 0; continue; } break; } while (1); #if 0 { p = at_strings; if (!*p) { printf("no @ strings\n"); return; } do { printf("%s\n", p+1); p += 1 + (unsigned char) *p; } while (*p); } #endif } static void read_enable_disable(void) { char *p; do { if (!(p = strtok(line_buf, " =\t\n")) || (*p == '#')) { if (!fgets(line_buf, sizeof(line_buf), fp)) { if (ferror(fp)) { printf("error reading file\n"); exit(EXIT_FAILURE); } return; /* EOF */ } if ((*line_buf == '#') && (line_buf[1] == '-')) { break; } continue; } if (!strcmp(p, "UTF-8")) { if (!(p = strtok(NULL, " =\t\n")) || ((toupper(*p) != 'Y') && (toupper(*p) != 'N'))) { printf("error: missing or illegal UTF-8 setting\n"); exit(EXIT_FAILURE); } default_utf8 = (toupper(*p) == 'Y'); printf("UTF-8 locales are %sabled\n", "dis\0en"+ (default_utf8 << 2)); } else if (!strcmp(p, "8-BIT")) { if (!(p = strtok(NULL, " =\t\n")) || ((toupper(*p) != 'Y') && (toupper(*p) != 'N'))) { printf("error: missing or illegal 8-BIT setting\n"); exit(EXIT_FAILURE); } default_8bit = (toupper(*p) == 'Y'); printf("8-BIT locales are %sabled\n", "dis\0en" + (default_8bit << 2)); } else { break; } if (((p = strtok(NULL, " \t\n")) != NULL) && (*p != '#')) { printf("ignoring trailing text: %s...\n", p); } *line_buf = 0; continue; } while (1); } #ifdef __LOCALE_DATA_CODESET_LIST static int find_codeset_num(const char *cs) { int r = 2; char *s = __LOCALE_DATA_CODESET_LIST; /* 7-bit is 1, UTF-8 is 2, 8-bits are > 2 */ if (strcmp(cs, "UTF-8") != 0) { ++r; while (*s && strcmp(__LOCALE_DATA_CODESET_LIST+ ((unsigned char) *s), cs)) { /* printf("tried %s\n", __LOCALE_DATA_CODESET_LIST + ((unsigned char) *s)); */ ++r; ++s; } if (!*s) { printf("error: unsupported codeset %s\n", cs); exit(EXIT_FAILURE); } } return r; } #else static int find_codeset_num(const char *cs) { int r = 2; /* 7-bit is 1, UTF-8 is 2, 8-bits are > 2 */ if (strcmp(cs, "UTF-8") != 0) { printf("error: unsupported codeset %s\n", cs); exit(EXIT_FAILURE); } return r; } #endif static int find_at_string_num(const char *as) { int i = 0; char *p = at_strings; while (*p) { if (!strcmp(p+1, as)) { return i; } ++i; p += 1 + (unsigned char) *p; } printf("error: unmapped @string %s\n", as); exit(EXIT_FAILURE); } static void read_locale_list(void) { char *p; char *s; char *ln; /* locale name */ char *ls; /* locale name ll_CC */ char *as; /* at string */ char *ds; /* dot string */ char *cs; /* codeset */ int i; typedef struct { char *glibc_name; char name[5]; char dot_cs; /* 0 if no codeset specified */ char cs; } locale_entry; /* First the C locale. */ locales[0].glibc_name = locales[0].name; strncpy(locales[0].name,"C",5); locales[0].dot_cs = 0; locales[0].cs = 1; /* 7-bit encoding */ ++num_locales; do { if (!(p = strtok(line_buf, " \t\n")) || (*p == '#')) { if (!fgets(line_buf, sizeof(line_buf), fp)) { if (ferror(fp)) { printf("error reading file\n"); exit(EXIT_FAILURE); } return; /* EOF */ } if ((*line_buf == '#') && (line_buf[1] == '-')) { break; } continue; } s = glibc_locale_names; for (i=0 ; i < num_locales ; i++) { if (!strcmp(s+1, p)) { break; } s += 1 + ((unsigned char) *s); } if (i < num_locales) { printf("ignoring dulplicate locale name: %s", p); *line_buf = 0; continue; } /* New locale, but don't increment num until codeset verified! */ *s = (char)((unsigned char) (strlen(p) + 1)); strcpy(s+1, p); locales[num_locales].glibc_name = s+1; ln = p; /* save locale name */ if (!(p = strtok(NULL, " \t\n"))) { printf("error: missing codeset for locale %s\n", ln); exit(EXIT_FAILURE); } cs = p; i = find_codeset_num(p); if ((i == 2) && !default_utf8) { printf("ignoring UTF-8 locale %s\n", ln); *line_buf = 0; continue; } else if ((i > 2) && !default_8bit) { printf("ignoring 8-bit codeset locale %s\n", ln); *line_buf = 0; continue; } locales[num_locales].cs = (char)((unsigned char) i); if (((p = strtok(NULL, " \t\n")) != NULL) && (*p != '#')) { printf("ignoring trailing text: %s...\n", p); } /* Now go back to locale string for .codeset and @modifier */ as = strtok(ln, "@"); if (as) { as = strtok(NULL, "@"); } ds = strtok(ln, "."); if (ds) { ds = strtok(NULL, "."); } ls = ln; if ((strlen(ls) != 5) || (ls[2] != '_')) { printf("error: illegal locale name %s\n", ls); exit(EXIT_FAILURE); } i = 0; /* value for unspecified codeset */ if (ds) { i = find_codeset_num(ds); if ((i == 2) && !default_utf8) { printf("ignoring UTF-8 locale %s\n", ln); *line_buf = 0; continue; } else if ((i > 2) && !default_8bit) { printf("ignoring 8-bit codeset locale %s\n", ln); *line_buf = 0; continue; } } locales[num_locales].dot_cs = (char)((unsigned char) i); if (as) { i = find_at_string_num(as); ls[2] = at_mapto[i]; } memcpy(locales[num_locales].name, ls, 5); /* printf("locale: %5.5s %2d %2d %s\n", */ /* locales[num_locales].name, */ /* locales[num_locales].cs, */ /* locales[num_locales].dot_cs, */ /* locales[num_locales].glibc_name */ /* ); */ ++num_locales; *line_buf = 0; } while (1); } static int le_cmp(const void *a, const void *b) { const locale_entry *p; const locale_entry *q; int r; p = (const locale_entry *) a; q = (const locale_entry *) b; if (!(r = p->name[0] - q->name[0]) && !(r = p->name[1] - q->name[1]) && !(r = p->name[3] - q->name[3]) && !(r = p->name[4] - q->name[4]) && !(r = p->name[2] - q->name[2]) && !(r = -(p->cs - q->cs)) ) { r = -(p->dot_cs - q->dot_cs); /* Reverse the ordering of the codesets so UTF-8 comes last. * Work-around (hopefully) for glibc bug affecting at least * the euro currency symbol. */ } return r; } int main(int argc, char **argv) { if ((argc != 2) || (!(fp = fopen(*++argv, "r")))) { printf("error: missing filename or file!\n"); return EXIT_FAILURE; } at_strings_end = at_strings; read_at_mappings(); read_enable_disable(); read_locale_list(); fclose(fp); /* handle C locale specially */ qsort(locales+1, num_locales-1, sizeof(locale_entry), le_cmp); #if 0 for (i=0 ; i < num_locales ; i++) { printf("locale: %5.5s %2d %2d %s\n", locales[i].name, locales[i].cs, locales[i].dot_cs, locales[i].glibc_name ); } #endif if (!(ofp = fopen("locale_tables.h", "w"))) { printf("error: can not open locale_tables.h for writing!\n"); return EXIT_FAILURE; } do_lc_time(); do_lc_numeric(); do_lc_monetary(); do_lc_messages(); do_lc_ctype(); do_locale_names(); fclose(ofp); printf("total data size = %d\n", total_size); printf("null count = %d\n", null_count); return EXIT_SUCCESS; } static char *idx[10000]; static char buf[100000]; static char *last; static int uniq; static int addblock(const char *s, size_t n) /* l includes nul terminator */ { int j; if (!s) { ++null_count; return 0; } for (j=0 ; (j < uniq) && (idx[j] + n < last) ; j++) { if (!memcmp(s, idx[j], n)) { return idx[j] - buf; } } if (uniq >= sizeof(idx)) { printf("too many uniq strings!\n"); exit(EXIT_FAILURE); } if (last + n >= buf + sizeof(buf)) { printf("need to increase size of buf!\n"); exit(EXIT_FAILURE); } idx[uniq] = last; ++uniq; memcpy(last, s, n); last += n; return idx[uniq - 1] - buf; } static int addstring(const char *s) { int j; size_t l; if (!s) { ++null_count; return 0; } for (j=0 ; j < uniq ; j++) { if (!strcmp(s, idx[j])) { return idx[j] - buf; } } if (uniq >= sizeof(idx)) { printf("too many uniq strings!\n"); exit(EXIT_FAILURE); } l = strlen(s) + 1; if (last + l >= buf + sizeof(buf)) { printf("need to increase size of buf!\n"); exit(EXIT_FAILURE); } idx[uniq] = last; ++uniq; strcpy(last, s); last += l; return idx[uniq - 1] - buf; } #define DO_LC_COMMON(CATEGORY) \ printf("buf-size=%d uniq=%d rows=%d\n", \ (int)(last - buf), uniq, lc_##CATEGORY##_uniq); \ printf("total = %d + %d * %d + %d = %d\n", \ num_locales, lc_##CATEGORY##_uniq, NUM_NL_##CATEGORY, (int)(last - buf), \ i = num_locales + lc_##CATEGORY##_uniq*NUM_NL_##CATEGORY + (int)(last - buf)); \ total_size += i; \ dump_table8c("__lc_" #CATEGORY "_data", buf, (int)(last - buf)); \ for (i=0 ; i < lc_##CATEGORY##_uniq ; i++) { \ m = locales[i].lc_##CATEGORY##_row; \ for (k=0 ; k < NUM_NL_##CATEGORY ; k++) { \ buf[NUM_NL_##CATEGORY*i + k] = (char)((unsigned char) lc_##CATEGORY##_uniq_X[i][k]); \ } \ } \ dump_table8("__lc_" #CATEGORY "_rows", buf, lc_##CATEGORY##_uniq * NUM_NL_##CATEGORY); \ buf16[0] =0; \ for (i=0 ; i < NUM_NL_##CATEGORY - 1 ; i++) { \ buf16[i+1] = buf16[i] + lc_##CATEGORY##_count[i]; \ } \ dump_table16("__lc_" #CATEGORY "_item_offsets", buf16, NUM_NL_##CATEGORY); \ m = 0; \ for (k=0 ; k < NUM_NL_##CATEGORY ; k++) { \ for (i=0 ; i < lc_##CATEGORY##_count[k] ; i++) { \ buf16[m] = lc_##CATEGORY##_item[k][i]; \ ++m; \ } \ } \ dump_table16("__lc_" #CATEGORY "_item_idx", buf16, m); #define DL_LC_LOOPTAIL(CATEGORY) \ if (k > NUM_NL_##CATEGORY) { \ printf("error -- lc_" #CATEGORY " nl_item count > %d!\n", NUM_NL_##CATEGORY); \ exit(EXIT_FAILURE); \ } \ { \ int r; \ for (r=0 ; r < lc_##CATEGORY##_uniq ; r++) { \ if (!memcmp(lc_##CATEGORY##_uniq_X[lc_##CATEGORY##_uniq], \ lc_##CATEGORY##_uniq_X[r], NUM_NL_##CATEGORY)) { \ break; \ } \ } \ if (r == lc_##CATEGORY##_uniq) { /* new locale row */ \ ++lc_##CATEGORY##_uniq; \ if (lc_##CATEGORY##_uniq > 255) { \ printf("too many unique lc_" #CATEGORY " rows!\n"); \ exit(EXIT_FAILURE); \ } \ } \ locales[i].lc_##CATEGORY##_row = r; \ } static int buf16[100*256]; static void dump_table8(const char *name, const char *tbl, int len) { int i; fprintf(ofp, "#define %s_LEN\t\t%d\n", name, len); fprintf(ofp, "static const unsigned char %s[%d] = {", name, len); for (i=0 ; i < len ; i++) { if ((i % 12) == 0) { fprintf(ofp, "\n\t"); } fprintf(ofp, "%#4x, ", (int)((unsigned char) tbl[i])); } fprintf(ofp, "\n};\n\n"); } #define __C_isdigit(c) \ ((sizeof(c) == sizeof(char)) \ ? (((unsigned char)((c) - '0')) < 10) \ : (((unsigned int)((c) - '0')) < 10)) #define __C_isalpha(c) \ ((sizeof(c) == sizeof(char)) \ ? (((unsigned char)(((c) | 0x20) - 'a')) < 26) \ : (((unsigned int)(((c) | 0x20) - 'a')) < 26)) #define __C_isalnum(c) (__C_isalpha(c) || __C_isdigit(c)) static void dump_table8c(const char *name, const char *tbl, int len) { int i; fprintf(ofp, "#define %s_LEN\t\t%d\n", name, len); fprintf(ofp, "static const unsigned char %s[%d] = {", name, len); for (i=0 ; i < len ; i++) { if ((i % 12) == 0) { fprintf(ofp, "\n\t"); } if (__C_isalnum(tbl[i]) || (tbl[i] == ' ')) { fprintf(ofp, " '%c', ", (int)((unsigned char) tbl[i])); } else { fprintf(ofp, "%#4x, ", (int)((unsigned char) tbl[i])); } } fprintf(ofp, "\n};\n\n"); } static void dump_table16(const char *name, const int *tbl, int len) { int i; fprintf(ofp, "#define %s_LEN\t\t%d\n", name, len); fprintf(ofp, "static const uint16_t %s[%d] = {", name, len); for (i=0 ; i < len ; i++) { if ((i % 8) == 0) { fprintf(ofp, "\n\t"); } if (tbl[i] != (uint16_t) tbl[i]) { printf("error - falls outside uint16 range!\n"); exit(EXIT_FAILURE); } fprintf(ofp, "%#6x, ", tbl[i]); } fprintf(ofp, "\n};\n\n"); } #define NUM_NL_time 50 static int lc_time_item[NUM_NL_time][256]; static int lc_time_count[NUM_NL_time]; static unsigned char lc_time_uniq_X[700][NUM_NL_time]; static int lc_time_uniq; #define DO_NL_S(X) lc_time_S(X, k++) static void lc_time_S(int X, int k) { size_t len; int j, m; const char *s = nl_langinfo(X); const char *p; static const char nulbuf[] = ""; if (X == ALT_DIGITS) { len = 1; if (!s) { s = nulbuf; } if (*s) { p = s; for (j = 0 ; j < 100 ; j++) { while (*p) { ++p; } ++p; } len = p - s; } j = addblock(s, len); /* if (len > 1) fprintf(stderr, "alt_digit: called addblock with len %zd\n", len); */ } else if (X == ERA) { if (!s) { s = nulbuf; } p = s; while (*p) { while (*p) { ++p; } ++p; } ++p; j = addblock(s, p - s); /* if (p-s > 1) fprintf(stderr, "era: called addblock with len %d\n", p-s); */ } else { j = addstring(s); } for (m=0 ; m < lc_time_count[k] ; m++) { if (lc_time_item[k][m] == j) { break; } } if (m == lc_time_count[k]) { /* new for this nl_item */ if (m > 255) { printf("too many nl_item %d entries in lc_time\n", k); exit(EXIT_FAILURE); } lc_time_item[k][m] = j; ++lc_time_count[k]; } lc_time_uniq_X[lc_time_uniq][k] = m; } static void do_lc_time(void) { int i, k, m; last = buf+1; uniq = 1; *buf = 0; *idx = buf; for (i=0 ; i < num_locales ; i++) { k = 0; if (!setlocale(LC_ALL, locales[i].glibc_name)) { printf("setlocale(LC_ALL,%s) failed!\n", locales[i].glibc_name); } DO_NL_S(ABDAY_1); DO_NL_S(ABDAY_2); DO_NL_S(ABDAY_3); DO_NL_S(ABDAY_4); DO_NL_S(ABDAY_5); DO_NL_S(ABDAY_6); DO_NL_S(ABDAY_7); DO_NL_S(DAY_1); DO_NL_S(DAY_2); DO_NL_S(DAY_3); DO_NL_S(DAY_4); DO_NL_S(DAY_5); DO_NL_S(DAY_6); DO_NL_S(DAY_7); DO_NL_S(ABMON_1); DO_NL_S(ABMON_2); DO_NL_S(ABMON_3); DO_NL_S(ABMON_4); DO_NL_S(ABMON_5); DO_NL_S(ABMON_6); DO_NL_S(ABMON_7); DO_NL_S(ABMON_8); DO_NL_S(ABMON_9); DO_NL_S(ABMON_10); DO_NL_S(ABMON_11); DO_NL_S(ABMON_12); DO_NL_S(MON_1); DO_NL_S(MON_2); DO_NL_S(MON_3); DO_NL_S(MON_4); DO_NL_S(MON_5); DO_NL_S(MON_6); DO_NL_S(MON_7); DO_NL_S(MON_8); DO_NL_S(MON_9); DO_NL_S(MON_10); DO_NL_S(MON_11); DO_NL_S(MON_12); DO_NL_S(AM_STR); DO_NL_S(PM_STR); DO_NL_S(D_T_FMT); DO_NL_S(D_FMT); DO_NL_S(T_FMT); DO_NL_S(T_FMT_AMPM); DO_NL_S(ERA); DO_NL_S(ERA_YEAR); /* non SuSv3 */ DO_NL_S(ERA_D_FMT); DO_NL_S(ALT_DIGITS); DO_NL_S(ERA_D_T_FMT); DO_NL_S(ERA_T_FMT); DL_LC_LOOPTAIL(time) } DO_LC_COMMON(time) } #undef DO_NL_S #define NUM_NL_numeric 3 static int lc_numeric_item[NUM_NL_numeric][256]; static int lc_numeric_count[NUM_NL_numeric]; static unsigned char lc_numeric_uniq_X[700][NUM_NL_numeric]; static int lc_numeric_uniq; #define DO_NL_S(X) lc_numeric_S(X, k++) static void lc_numeric_S(int X, int k) { int j, m; char buf[256]; char *e; char *s; char c; s = nl_langinfo(X); if (X == GROUPING) { if (s) { if ((*s == CHAR_MAX) || (*s == -1)) { /* stupid glibc... :-( */ s = ""; } e = s; c = 0; while (*e) { /* find end of string */ if (*e == CHAR_MAX) { c = CHAR_MAX; ++e; break; } ++e; } if ((e - s) > sizeof(buf)) { printf("grouping specifier too long\n"); exit(EXIT_FAILURE); } strncpy(buf, s, (e-s)); e = buf + (e-s); *e = 0; /* Make sure we're null-terminated. */ if (c != CHAR_MAX) { /* remove duplicate repeats */ while (e > buf) { --e; if (*e != e[-1]) { break; } } *++e = 0; } s = buf; } } j = addstring(s); for (m=0 ; m < lc_numeric_count[k] ; m++) { if (lc_numeric_item[k][m] == j) { break; } } if (m == lc_numeric_count[k]) { /* new for this nl_item */ if (m > 255) { printf("too many nl_item %d entries in lc_numeric\n", k); exit(EXIT_FAILURE); } lc_numeric_item[k][m] = j; ++lc_numeric_count[k]; } /* printf("\\x%02x", m); */ lc_numeric_uniq_X[lc_numeric_uniq][k] = m; } static void do_lc_numeric(void) { int i, k, m; last = buf+1; uniq = 1; *buf = 0; *idx = buf; for (i=0 ; i < num_locales ; i++) { k = 0; if (!setlocale(LC_ALL, locales[i].glibc_name)) { printf("setlocale(LC_ALL,%s) failed!\n", locales[i].glibc_name); } DO_NL_S(RADIXCHAR); /* DECIMAL_POINT */ DO_NL_S(THOUSEP); /* THOUSANDS_SEP */ DO_NL_S(GROUPING); DL_LC_LOOPTAIL(numeric) } DO_LC_COMMON(numeric) } #undef DO_NL_S #define NUM_NL_monetary (7+14+1) static int lc_monetary_item[NUM_NL_monetary][256]; static int lc_monetary_count[NUM_NL_monetary]; static unsigned char lc_monetary_uniq_X[700][NUM_NL_monetary]; static int lc_monetary_uniq; #define DO_NL_S(X) lc_monetary_S(X, k++) /* #define DO_NL_C(X) printf("%#02x", (int)(unsigned char)(*nl_langinfo(X))); */ #define DO_NL_C(X) lc_monetary_C(X, k++) static void lc_monetary_C(int X, int k) { int j, m; char c_buf[2]; #warning fix the char entries for monetary... target signedness of char may be different! c_buf[1] = 0; c_buf[0] = *nl_langinfo(X); j = addstring(c_buf); for (m=0 ; m < lc_monetary_count[k] ; m++) { if (lc_monetary_item[k][m] == j) { break; } } if (m == lc_monetary_count[k]) { /* new for this nl_item */ if (m > 255) { printf("too many nl_item %d entries in lc_monetary\n", k); exit(EXIT_FAILURE); } lc_monetary_item[k][m] = j; ++lc_monetary_count[k]; } /* printf("\\x%02x", m); */ lc_monetary_uniq_X[lc_monetary_uniq][k] = m; } static void lc_monetary_S(int X, int k) { int j, m; char buf[256]; char *e; char *s; char c; s = nl_langinfo(X); if (X == MON_GROUPING) { if (s) { if ((*s == CHAR_MAX) || (*s == -1)) { /* stupid glibc... :-( */ s = ""; } e = s; c = 0; while (*e) { /* find end of string */ if (*e == CHAR_MAX) { c = CHAR_MAX; ++e; break; } ++e; } if ((e - s) > sizeof(buf)) { printf("mon_grouping specifier too long\n"); exit(EXIT_FAILURE); } strncpy(buf, s, (e-s)); e = buf + (e-s); *e = 0; /* Make sure we're null-terminated. */ if (c != CHAR_MAX) { /* remove duplicate repeats */ while (e > buf) { --e; if (*e != e[-1]) { break; } } *++e = 0; } s = buf; } } j = addstring(s); for (m=0 ; m < lc_monetary_count[k] ; m++) { if (lc_monetary_item[k][m] == j) { break; } } if (m == lc_monetary_count[k]) { /* new for this nl_item */ if (m > 255) { printf("too many nl_item %d entries in lc_monetary\n", k); exit(EXIT_FAILURE); } lc_monetary_item[k][m] = j; ++lc_monetary_count[k]; } /* printf("\\x%02x", m); */ lc_monetary_uniq_X[lc_monetary_uniq][k] = m; } static void do_lc_monetary(void) { int i, k, m; last = buf+1; uniq = 1; *buf = 0; *idx = buf; for (i=0 ; i < num_locales ; i++) { k = 0; if (!setlocale(LC_ALL, locales[i].glibc_name)) { printf("setlocale(LC_ALL,%s) failed!\n", locales[i].glibc_name); } /* non SUSv3 */ DO_NL_S(INT_CURR_SYMBOL); DO_NL_S(CURRENCY_SYMBOL); DO_NL_S(MON_DECIMAL_POINT); DO_NL_S(MON_THOUSANDS_SEP); DO_NL_S(MON_GROUPING); DO_NL_S(POSITIVE_SIGN); DO_NL_S(NEGATIVE_SIGN); DO_NL_C(INT_FRAC_DIGITS); DO_NL_C(FRAC_DIGITS); DO_NL_C(P_CS_PRECEDES); DO_NL_C(P_SEP_BY_SPACE); DO_NL_C(N_CS_PRECEDES); DO_NL_C(N_SEP_BY_SPACE); DO_NL_C(P_SIGN_POSN); DO_NL_C(N_SIGN_POSN); DO_NL_C(INT_P_CS_PRECEDES); DO_NL_C(INT_P_SEP_BY_SPACE); DO_NL_C(INT_N_CS_PRECEDES); DO_NL_C(INT_N_SEP_BY_SPACE); DO_NL_C(INT_P_SIGN_POSN); DO_NL_C(INT_N_SIGN_POSN); DO_NL_S(CRNCYSTR); /* CURRENCY_SYMBOL */ DL_LC_LOOPTAIL(monetary) } DO_LC_COMMON(monetary) } #undef DO_NL_S #define NUM_NL_messages 4 static int lc_messages_item[NUM_NL_messages][256]; static int lc_messages_count[NUM_NL_messages]; static unsigned char lc_messages_uniq_X[700][NUM_NL_messages]; static int lc_messages_uniq; #define DO_NL_S(X) lc_messages_S(X, k++) static void lc_messages_S(int X, int k) { int j, m; j = addstring(nl_langinfo(X)); for (m=0 ; m < lc_messages_count[k] ; m++) { if (lc_messages_item[k][m] == j) { break; } } if (m == lc_messages_count[k]) { /* new for this nl_item */ if (m > 255) { printf("too many nl_item %d entries in lc_messages\n", k); exit(EXIT_FAILURE); } lc_messages_item[k][m] = j; ++lc_messages_count[k]; } /* printf("\\x%02x", m); */ lc_messages_uniq_X[lc_messages_uniq][k] = m; } static void do_lc_messages(void) { int i, k, m; last = buf+1; uniq = 1; *buf = 0; *idx = buf; for (i=0 ; i < num_locales ; i++) { k = 0; if (!setlocale(LC_ALL, locales[i].glibc_name)) { printf("setlocale(LC_ALL,%s) failed!\n", locales[i].glibc_name); } DO_NL_S(YESEXPR); DO_NL_S(NOEXPR); DO_NL_S(YESSTR); DO_NL_S(NOSTR); DL_LC_LOOPTAIL(messages) } DO_LC_COMMON(messages) } #undef DO_NL_S #define NUM_NL_ctype 10 static int lc_ctype_item[NUM_NL_ctype][256]; static int lc_ctype_count[NUM_NL_ctype]; static unsigned char lc_ctype_uniq_X[700][NUM_NL_ctype]; static int lc_ctype_uniq; #define DO_NL_S(X) lc_ctype_S(X, k++) static void lc_ctype_S(int X, int k) { int j, m; j = addstring(nl_langinfo(X)); for (m=0 ; m < lc_ctype_count[k] ; m++) { if (lc_ctype_item[k][m] == j) { break; } } if (m == lc_ctype_count[k]) { /* new for this nl_item */ if (m > 255) { printf("too many nl_item %d entries in lc_ctype\n", k); exit(EXIT_FAILURE); } lc_ctype_item[k][m] = j; ++lc_ctype_count[k]; } /* printf("\\x%02x", m); */ lc_ctype_uniq_X[lc_ctype_uniq][k] = m; } static void do_lc_ctype(void) { int i, k, m; last = buf+1; uniq = 1; *buf = 0; *idx = buf; for (i=0 ; i < num_locales ; i++) { k = 0; if (!setlocale(LC_ALL, locales[i].glibc_name)) { printf("setlocale(LC_ALL,%s) failed!\n", locales[i].glibc_name); } DO_NL_S(_NL_CTYPE_OUTDIGIT0_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT1_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT2_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT3_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT4_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT5_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT6_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT7_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT8_MB); DO_NL_S(_NL_CTYPE_OUTDIGIT9_MB); DL_LC_LOOPTAIL(ctype) } DO_LC_COMMON(ctype) }