extra/locale/gen_wc8bit.c

   1 /*
   2  * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
   3  *
   4  * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
   5  */
   6 #define _GNU_SOURCE
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <locale.h>
  11 #include <stddef.h>
  12 #include <wctype.h>
  13 #include <limits.h>
  14
  15 #ifndef _CTYPE_H
  16 #define _CTYPE_H
  17 #endif
  18 #ifndef _WCTYPE_H
  19 #define _WCTYPE_H
  20 #endif
  21 #include "include/bits/uClibc_ctype.h"
  22
  23 /* TODO: maybe support -v like gen_wctype.c */
  24 #define verbose_msg(msg...) if (verbose) fprintf(stderr, msg)
  25
  26 /*  #define CTYPE_PACKED */
  27 #define UPLOW_IDX_SHIFT         3
  28 /* best if 2 unpacked or 3 packed */
  29 #define CTYPE_IDX_SHIFT         3
  30 /* 3 or 4 are very similar */
  31 #define C2WC_IDX_SHIFT          3
  32
  33 #define CTYPE_IDX_LEN           (128 >> (CTYPE_IDX_SHIFT))
  34 #define UPLOW_IDX_LEN           (128 >> (UPLOW_IDX_SHIFT))
  35 #define C2WC_IDX_LEN            (128 >> (C2WC_IDX_SHIFT))
  36
  37 /*  #ifdef CTYPE_PACKED */
  38 /*  #define CTYPE_ROW_LEN               (1 << ((CTYPE_IDX_SHIFT)-1)) */
  39 /*  #else */
  40 #define CTYPE_ROW_LEN           (1 << (CTYPE_IDX_SHIFT))
  41 /*  #endif */
  42 #define UPLOW_ROW_LEN           (1 << (UPLOW_IDX_SHIFT))
  43 #define C2WC_ROW_LEN            (1 << (C2WC_IDX_SHIFT))
  44
  45
  46
  47 #define MAX_WCHAR       (0x2600-1)
  48
  49 static unsigned char ctype_tbl[256 * CTYPE_ROW_LEN];
  50 static unsigned char uplow_tbl[256 * UPLOW_ROW_LEN];
  51 #ifdef DO_WIDE_CHAR
  52 static unsigned short c2wc_tbl[256 * C2WC_ROW_LEN];
  53 #endif
  54 static unsigned char tt[MAX_WCHAR+1];
  55 static unsigned char ti[MAX_WCHAR+1];
  56 static unsigned char xi[MAX_WCHAR+1];
  57
  58 static int n_ctype_rows;
  59 static int n_uplow_rows;
  60 #ifdef DO_WIDE_CHAR
  61 static int n_c2wc_rows;
  62 #endif
  63 static int tt_num;
  64 static int ti_num;
  65
  66 #define RANGE MAX_WCHAR
  67
  68 #define TT_SHIFT 4
  69 #define TI_SHIFT 4
  70
  71 #define II_LEN          ((MAX_WCHAR+1) >> (TT_SHIFT+TI_SHIFT))
  72
  73 typedef struct {
  74         unsigned long c2w[256];
  75         unsigned char w2c[MAX_WCHAR];
  76         unsigned char ii[II_LEN];
  77         unsigned char ctype_idx[CTYPE_IDX_LEN];
  78         unsigned char uplow_idx[UPLOW_IDX_LEN];
  79         unsigned char c2wc_idx[C2WC_IDX_LEN];
  80 } charset_data;
  81
  82 int main(int argc, char **argv)
  83 {
  84         FILE *fp;
  85         charset_data csd[30];
  86         unsigned long max_wchar;
  87         unsigned char *p;
  88         int numsets;
  89         int i;
  90         int j;
  91         char buf[80];
  92         unsigned char row[256];
  93 #ifdef DO_WIDE_CHAR
  94         unsigned short wrow[256];
  95 #endif
  96         char codeset_list[500];
  97         char codeset_index[30];
  98         int codeset_list_end = 0;
  99         int total_size = 0;
 100
 101         if (!setlocale(LC_CTYPE, "en_US.UTF-8")) {
 102                 /* Silly foreigners disabling en_US locales */
 103                 FILE *fp = popen("locale -a", "r");
 104                 if (!fp)
 105                         goto locale_failure;
 106
 107                 while (!feof(fp)) {
 108                         char buf[256];
 109                         size_t len;
 110
 111                         if (fgets(buf, sizeof(buf) - 10, fp) == NULL)
 112                                 goto locale_failure;
 113
 114                         len = strlen(buf);
 115                         if (len > 0 && buf[len - 1] == '\n')
 116                                 buf[--len] = '\0';
 117                         if (len < 5 || strcasecmp(&buf[len-5], ".UTF8") != 0)
 118                                 strcat(buf, ".UTF8");
 119                         if (setlocale(LC_CTYPE, buf))
 120                                 goto locale_success;
 121                 }
 122
 123  locale_failure:
 124                 printf("could not find a UTF8 locale ... please enable en_US.UTF-8\n");
 125                 return EXIT_FAILURE;
 126  locale_success:
 127                 pclose(fp);
 128         }
 129
 130         if (argc == 1) {
 131                 printf("#undef __CTYPE_HAS_8_BIT_LOCALES\n\n");
 132
 133                 printf("#define __LOCALE_DATA_NUM_CODESETS\t\t0\n");
 134                 printf("#define __LOCALE_DATA_CODESET_LIST\t\t\"\"\n");
 135         } else {
 136                 printf("#define __CTYPE_HAS_8_BIT_LOCALES\t\t1\n\n");
 137         }
 138
 139         printf("#define __LOCALE_DATA_Cctype_IDX_SHIFT\t%d\n", CTYPE_IDX_SHIFT);
 140         printf("#define __LOCALE_DATA_Cctype_IDX_LEN\t\t%d\n", CTYPE_IDX_LEN);
 141 #ifdef CTYPE_PACKED
 142         printf("#define __LOCALE_DATA_Cctype_ROW_LEN\t\t%d\n", CTYPE_ROW_LEN >> 1);
 143         printf("#define __LOCALE_DATA_Cctype_PACKED\t\t1\n");
 144 #else
 145         printf("#define __LOCALE_DATA_Cctype_ROW_LEN\t\t%d\n", CTYPE_ROW_LEN);
 146         printf("#undef __LOCALE_DATA_Cctype_PACKED\n");
 147 #endif
 148
 149         printf("\n#define __LOCALE_DATA_Cuplow_IDX_SHIFT\t%d\n", UPLOW_IDX_SHIFT);
 150         printf("#define __LOCALE_DATA_Cuplow_IDX_LEN\t\t%d\n", UPLOW_IDX_LEN);
 151         printf("#define __LOCALE_DATA_Cuplow_ROW_LEN\t\t%d\n", UPLOW_ROW_LEN);
 152
 153 #ifdef DO_WIDE_CHAR
 154         printf("\n#define __LOCALE_DATA_Cc2wc_IDX_LEN\t\t%d\n", C2WC_IDX_LEN);
 155         printf("#define __LOCALE_DATA_Cc2wc_IDX_SHIFT\t\t%d\n", C2WC_IDX_SHIFT);
 156         printf("#define __LOCALE_DATA_Cc2wc_ROW_LEN\t\t%d\n", C2WC_ROW_LEN);
 157 #endif
 158
 159         printf("\ntypedef struct {\n");
 160         printf("\tunsigned char idx8ctype[%d];\n", CTYPE_IDX_LEN);
 161         printf("\tunsigned char idx8uplow[%d];\n", UPLOW_IDX_LEN);
 162 #ifdef DO_WIDE_CHAR
 163         printf("\tunsigned char idx8c2wc[%d];\n", C2WC_IDX_LEN);
 164         printf("\tunsigned char idx8wc2c[%d];\n", II_LEN);
 165 #endif
 166 #ifndef __metag__
 167         printf("} __codeset_8_bit_t;\n\n");
 168 #else
 169         printf("} __attribute__((__packed__)) __codeset_8_bit_t;\n\n");
 170 #endif /* __metag__ */
 171
 172         printf("#ifdef WANT_DATA\n\n");
 173         printf("static const __codeset_8_bit_t codeset_8_bit[%d] = {\n", argc-1);
 174
 175         max_wchar = 0x7f;
 176         numsets = 0;
 177         codeset_index[0] = 0;
 178         while (--argc) {
 179                 if (!(fp = fopen(*++argv,"r"))) {
 180                         fprintf(stderr, "cannot open file \"%s\"\n", *argv);
 181                         return EXIT_FAILURE;
 182                 }
 183                 fprintf(stderr, "processing %s... ", *argv);
 184
 185                 {
 186                         char *s0;
 187                         char *s1;
 188                         int n;
 189
 190                         s0 = strrchr(*argv, '/');
 191                         if (!s0) {
 192                                 s0 = *argv;
 193                         } else {
 194                                 ++s0;
 195                         }
 196                         s1 = strrchr(s0, '.');
 197                         if (!s1) {
 198                                 n = strlen(s0);
 199                         } else {
 200                                 n = s1 - s0;
 201                         }
 202
 203 /*                      if ((numsets == 0) && strncmp("ASCII", s0, n)) { */
 204 /*                              printf("error - first codeset isn't ASCII!\n"); */
 205 /*                              return EXIT_FAILURE; */
 206 /*                      } */
 207
 208                         if (numsets >= sizeof(codeset_index)) {
 209                                 fprintf(stderr, "error - too many codesets!\n");
 210                                 return EXIT_FAILURE;
 211                         }
 212
 213                         if (codeset_list_end + n + 1 + numsets + 1 + 1 >= 256) {
 214                                 fprintf(stderr, "error - codeset list to big!\n");
 215                                 return EXIT_FAILURE;
 216                         }
 217
 218                         codeset_index[numsets+1] = codeset_index[numsets] + n+1;
 219                         strncpy(codeset_list + codeset_list_end, s0, n);
 220                         codeset_list_end += (n+1);
 221                         codeset_list[codeset_list_end - 1] = 0;
 222
 223                         printf("\t{ /* %.*s */", n, s0);
 224                 }
 225
 226                 memset(&csd[numsets], 0, sizeof(charset_data));
 227                 memset(xi, 0, sizeof(xi));
 228                 {
 229                         unsigned long c, wc;
 230                         int lines;
 231                         lines = 0;
 232                         while (fgets(buf,sizeof(buf),fp)) {
 233                                 if ((2 != sscanf(buf, "{ %lx , %lx", &c, &wc))
 234                                         || (c >= 256) || (wc > MAX_WCHAR)) {
 235                                         fprintf(stderr, "error: scanf failure! \"%s\"\n", buf);
 236                                         return EXIT_FAILURE;
 237                                 }
 238
 239                                 /* don't put in w2c... dynamicly build tt instead. */
 240
 241                                 if (c <= 0x7f) { /* check the 7bit entries but don't store */
 242                                         if (c != wc) {
 243                                                 fprintf(stderr, "error: c != wc in %s\n", buf);
 244                                                 return EXIT_FAILURE;
 245                                         }
 246                                         csd[numsets].c2w[c] = wc;
 247                                         csd[numsets].w2c[wc] = 0; /* ignore */
 248                                         if (wc > max_wchar) {
 249                                                 max_wchar = wc;
 250                                         }
 251                                 } else {
 252                                         csd[numsets].c2w[c] = wc;
 253                                         csd[numsets].w2c[wc] = c;
 254                                         if (wc > max_wchar) {
 255                                                 max_wchar = wc;
 256                                         }
 257                                 }
 258                                 ++lines;
 259                         }
 260                         fprintf(stderr, "%d lines  ", lines);
 261
 262                         for (i = 0 ; i <= MAX_WCHAR ; i += (1 << TT_SHIFT)) {
 263                                 p = &csd[numsets].w2c[i];
 264                                 for (j = 0 ; j < tt_num ; j++) {
 265                                         if (!memcmp(p, &tt[j << TT_SHIFT], (1 << TT_SHIFT))) {
 266                                                 break;
 267                                         }
 268                                 }
 269                                 if (j == tt_num) { /* new entry */
 270                                         memcpy(&tt[j << TT_SHIFT], p, (1 << TT_SHIFT));
 271                                         ++tt_num;
 272                                 }
 273                                 xi[i >> TT_SHIFT] = j;
 274                         }
 275
 276                         for (i = 0 ; i <= (MAX_WCHAR >> TT_SHIFT)  ; i += (1 << TI_SHIFT)) {
 277                                 p = &xi[i];
 278                                 for (j = 0 ; j < ti_num ; j++) {
 279                                         if (!memcmp(p, &ti[j << TI_SHIFT], (1 << TI_SHIFT))) {
 280                                                 break;
 281                                         }
 282                                 }
 283                                 if (j == ti_num) { /* new entry */
 284                                         memcpy(&ti[j << TI_SHIFT], p, (1 << TI_SHIFT));
 285                                         ++ti_num;
 286                                 }
 287                                 csd[numsets].ii[i >> TI_SHIFT] = j;
 288 /*                              fprintf(stderr, "%d ", i >> TI_SHIFT); */
 289                         }
 290
 291 #if 1
 292                         printf("\n\t\t/* idx8ctype data */\n\t\t{");
 293                         for (i = 128 ; i < 256 ; i++) {
 294                                 wchar_t c;
 295                                 unsigned int d;
 296
 297 /*                              if (!(i & 0x7)) { */
 298 /*                                      printf("\n"); */
 299 /*                              } */
 300
 301                                 c = csd[numsets].c2w[i];
 302
 303                                 if (c == 0) {   /* non-existant char in codeset */
 304                                         d = __CTYPE_unclassified;
 305                                 } else if (iswdigit(c)) {
 306                                         d = __CTYPE_digit;
 307                                 } else if (iswalpha(c)) {
 308                                         d = __CTYPE_alpha_nonupper_nonlower;
 309                                         if (iswlower(c)) {
 310                                                 d = __CTYPE_alpha_lower;
 311                                                 if (iswupper(c)) {
 312                                                         d = __CTYPE_alpha_upper_lower;
 313                                                 }
 314                                         } else if (iswupper(c)) {
 315                                                 d = __CTYPE_alpha_upper;
 316                                         }
 317                                 } else if (iswpunct(c)) {
 318                                         d = __CTYPE_punct;
 319                                 } else if (iswgraph(c)) {
 320                                         d = __CTYPE_graph;
 321                                 } else if (iswprint(c)) {
 322                                         d = __CTYPE_print_space_nonblank;
 323                                         if (iswblank(c)) {
 324                                                 d = __CTYPE_print_space_blank;
 325                                         }
 326                                 } else if (iswspace(c) && !iswcntrl(c)) {
 327                                         d = __CTYPE_space_nonblank_noncntrl;
 328                                         if (iswblank(c)) {
 329                                                 d = __CTYPE_space_blank_noncntrl;
 330                                         }
 331                                 } else if (iswcntrl(c)) {
 332                                         d = __CTYPE_cntrl_nonspace;
 333                                         if (iswspace(c)) {
 334                                                 d = __CTYPE_cntrl_space_nonblank;
 335                                                 if (iswblank(c)) {
 336                                                         d = __CTYPE_cntrl_space_blank;
 337                                                 }
 338                                         }
 339                                 } else {
 340                                         d = __CTYPE_unclassified;
 341                                 }
 342
 343 #if 1
 344                                 row[i & (CTYPE_ROW_LEN-1)] = d;
 345                                 if ((i & (CTYPE_ROW_LEN-1)) == (CTYPE_ROW_LEN-1)) {
 346                                         p = ctype_tbl;
 347                                         for (j=0 ; j < n_ctype_rows ; j++) {
 348                                                 if (!memcmp(p, row, CTYPE_ROW_LEN)) {
 349                                                         break;
 350                                                 }
 351                                                 p += CTYPE_ROW_LEN;
 352                                         }
 353                                         if (j == n_ctype_rows) { /* new entry */
 354                                                 if (++n_ctype_rows > 256) {
 355                                                         fprintf(stderr, "error -- to many ctype rows!\n");
 356                                                         return EXIT_FAILURE;
 357                                                 }
 358                                                 memcpy(p, row, CTYPE_ROW_LEN);
 359                                         }
 360                                         csd[numsets].ctype_idx[i >> CTYPE_IDX_SHIFT] = j;
 361                                         if (!((i >> CTYPE_IDX_SHIFT) & 0x7)
 362                                                 && (i != (127 + CTYPE_ROW_LEN))
 363                                                 ) {
 364                                                 printf("\n\t\t ");
 365                                         }
 366                                         printf(" %#4x,", j);
 367                                 }
 368 #else
 369                                 printf(" %#4x,", d);
 370 #endif
 371                         }
 372 #endif
 373                         printf(" }");
 374
 375 #if 1
 376                         printf(",\n\t\t/* idx8uplow data */\n\t\t{");
 377                         for (i = 128 ; i < 256 ; i++) {
 378                                 wchar_t c, u, l;
 379 /*                              if (!(i & 0x7)) { */
 380 /*                                      printf("\n"); */
 381 /*                              } */
 382                                 c = csd[numsets].c2w[i];
 383                                 if ((c != 0) || 1) {
 384                                         u = towupper(c);
 385                                         l = towlower(c);
 386
 387                                         if (u >= 0x80) u = csd[numsets].w2c[u];
 388                                         if (l >= 0x80) l = csd[numsets].w2c[l];
 389
 390                                         if (u == 0) u = i; /* upper is missing, so ignore */
 391                                         if (l == 0) l = i; /* lower is missing, so ignore */
 392
 393 #if 1
 394                                         /* store as unsigned char and let overflow handle it. */
 395 /*                                      if ((((u-i) < CHAR_MIN) || ((u-i) > CHAR_MAX)) */
 396 /*                                              || (((i-l) < CHAR_MIN) || ((i-l) > CHAR_MAX)) */
 397 /*                                              ) { */
 398 /*                                              fprintf(stderr, "error - uplow diff out of range! %d %ld %ld\n", */
 399 /*                                                         i, u, l); */
 400 /*                                              return EXIT_FAILURE; */
 401 /*                                      } */
 402
 403                                         row[i & (UPLOW_ROW_LEN-1)] = ((l==i) ? (u-i) : (i-l));
 404                                         if ((i & (UPLOW_ROW_LEN-1)) == (UPLOW_ROW_LEN-1)) {
 405                                                 p = uplow_tbl;
 406                                                 for (j=0 ; j < n_uplow_rows ; j++) {
 407                                                         if (!memcmp(p, row, UPLOW_ROW_LEN)) {
 408                                                                 break;
 409                                                         }
 410                                                         p += UPLOW_ROW_LEN;
 411                                                 }
 412                                                 if (j == n_uplow_rows) { /* new entry */
 413                                                         if (++n_uplow_rows > 256) {
 414                                                                 fprintf(stderr, "error -- to many uplow rows!\n");
 415                                                                 return EXIT_FAILURE;
 416                                                         }
 417                                                         memcpy(p, row, UPLOW_ROW_LEN);
 418                                                 }
 419                                                 csd[numsets].uplow_idx[i >> UPLOW_IDX_SHIFT] = j;
 420                                                 if (!((i >> UPLOW_IDX_SHIFT) & 0x7)
 421                                                         && (i != (127 + UPLOW_ROW_LEN))
 422                                                         ) {
 423                                                         printf("\n\t\t ");
 424                                                 }
 425                                                 printf(" %#4x,", j);
 426                                         }
 427
 428 #elif 0
 429                                         if (!(i & 0x7) && i) {
 430                                                 printf("\n");
 431                                         }
 432                                         printf(" %4ld,", (l==i) ? (u-i) : (i-l));
 433 /*                                      printf(" %4ld,", (l==i) ? u : l); */
 434 #else
 435                                         if ((u != i) || (l != i)) {
 436 #if 0
 437                                                 printf(" %#08lx, %#08lx, %#08lx, %#08lx, %#08lx, %#08lx, \n",
 438                                                                 (unsigned long) i,
 439                                                                 (unsigned long) c,
 440                                                                 (unsigned long) l,
 441                                                                 (unsigned long) towlower(c),
 442                                                                 (unsigned long) u,
 443                                                                 (unsigned long) towupper(c));
 444
 445 #else
 446                                                 printf(" %#08lx, %8ld, %d, %8ld, %d, %#08lx\n",
 447                                                                 (unsigned long) i,
 448                                                                 (long) (l - i),
 449                                                                 iswupper(c),
 450                                                                 (long) (i - u),
 451                                                                 iswlower(c),
 452                                                                 (unsigned long) c);
 453 #endif
 454                                         }
 455 #endif
 456                                 }
 457                         }
 458                         printf(" }");
 459 #endif
 460
 461 #ifndef DO_WIDE_CHAR
 462                         printf("\n");
 463 #else  /* DO_WIDE_CHAR */
 464
 465 #if 1
 466                         printf(",\n\t\t/* idx8c2wc data */\n\t\t{");
 467                         for (i = 128 ; i < 256 ; i++) {
 468 #if 1
 469                                 wrow[i & (C2WC_ROW_LEN-1)] = csd[numsets].c2w[i];
 470                                 if ((i & (C2WC_ROW_LEN-1)) == (C2WC_ROW_LEN-1)) {
 471                                         p = (unsigned char *) c2wc_tbl;
 472                                         for (j=0 ; j < n_c2wc_rows ; j++) {
 473                                                 if (!memcmp(p, (char *) wrow, 2*C2WC_ROW_LEN)) {
 474                                                         break;
 475                                                 }
 476                                                 p += 2*C2WC_ROW_LEN;
 477                                         }
 478                                         if (j == n_c2wc_rows) { /* new entry */
 479                                                 if (++n_c2wc_rows > 256) {
 480                                                         fprintf(stderr, "error -- to many c2wc rows!\n");
 481                                                         return EXIT_FAILURE;
 482                                                 }
 483                                                 memcpy(p, (char *) wrow, 2*C2WC_ROW_LEN);
 484                                         }
 485                                         csd[numsets].c2wc_idx[i >> C2WC_IDX_SHIFT] = j;
 486                                         if (!((i >> C2WC_IDX_SHIFT) & 0x7)
 487                                                 && (i != (127 + C2WC_ROW_LEN))
 488                                                 ) {
 489                                                 printf("\n\t\t ");
 490                                         }
 491                                         printf(" %#4x,", j);
 492                                 }
 493 #else
 494                                 if (!(i & 0x7) && i) {
 495                                         printf("\n");
 496                                 }
 497                                 printf(" %#6lx,", csd[numsets].c2w[i]);
 498 #endif
 499                         }
 500                         printf(" },\n");
 501 #endif
 502
 503 #if 1
 504 /*                      fprintf(stderr, "\nII_LEN = %d\n", II_LEN); */
 505                         printf("\t\t/* idx8wc2c data */\n\t\t{");
 506                         for (i = 0 ; i < II_LEN ; i++) {
 507                                 if (!(i & 0x7) && i) {
 508                                         printf("\n\t\t ");
 509                                 }
 510                                 printf(" %#4x,", csd[numsets].ii[i]);
 511                         }
 512                         printf(" }\n");
 513 #endif
 514
 515 #endif /* DO_WIDE_CHAR */
 516                         printf("\t},\n");
 517
 518                 }
 519                 ++numsets;
 520                 fprintf(stderr, "done\n");
 521         }
 522         printf("};\n");
 523         printf("\n#endif /* WANT_DATA */\n");
 524
 525 #ifdef DO_WIDE_CHAR
 526         printf("\n");
 527         printf("#define __LOCALE_DATA_Cwc2c_DOMAIN_MAX\t%#x\n", RANGE);
 528         printf("#define __LOCALE_DATA_Cwc2c_TI_SHIFT\t\t%d\n", TI_SHIFT);
 529         printf("#define __LOCALE_DATA_Cwc2c_TT_SHIFT\t\t%d\n", TT_SHIFT);
 530         printf("#define __LOCALE_DATA_Cwc2c_II_LEN\t\t%d\n", II_LEN);
 531         printf("#define __LOCALE_DATA_Cwc2c_TI_LEN\t\t%d\n", ti_num << TI_SHIFT);
 532         printf("#define __LOCALE_DATA_Cwc2c_TT_LEN\t\t%d\n", tt_num << TT_SHIFT);
 533         printf("\n");
 534
 535         printf("\n#define __LOCALE_DATA_Cwc2c_TBL_LEN\t\t%d\n",
 536                         (ti_num << TI_SHIFT) + (tt_num << TT_SHIFT));
 537
 538         printf("#ifdef WANT_DATA\n\n");
 539         printf("static const unsigned char __LOCALE_DATA_Cwc2c_data[%d] = {\n",
 540                         (ti_num << TI_SHIFT) + (tt_num << TT_SHIFT));
 541         printf("\t/* ti_table */\n\t");
 542         for (i=0 ; i < ti_num << TI_SHIFT ; i++) {
 543                 if (!(i & 7) && i) {
 544                         printf("\n\t");
 545                 }
 546                 printf(" %#4x,", ti[i]);
 547         }
 548         printf("\n");
 549         printf("\t/* tt_table */\n\t");
 550         for (i=0 ; i < tt_num << TT_SHIFT ; i++) {
 551                 if (!(i & 7) && i) {
 552                         printf("\n\t");
 553                 }
 554                 printf(" %#4x,", tt[i]);
 555         }
 556         printf("\n};\n");
 557
 558         printf("\n#endif /* WANT_DATA */\n");
 559 #endif /* DO_WIDE_CHAR */
 560
 561         printf("\n#define __LOCALE_DATA_Cuplow_TBL_LEN\t\t%d\n",
 562                         n_uplow_rows * UPLOW_ROW_LEN);
 563         printf("\n#ifdef WANT_DATA\n\n");
 564
 565         printf("\nstatic const unsigned char __LOCALE_DATA_Cuplow_data[%d] = {\n",
 566                         n_uplow_rows * UPLOW_ROW_LEN);
 567         p = uplow_tbl;
 568         for (j=0 ; j < n_uplow_rows ; j++) {
 569                 printf("\t");
 570                 for (i=0 ; i < UPLOW_ROW_LEN ; i++) {
 571                         printf(" %#4x,", (unsigned int)((unsigned char) p[i]));
 572                 }
 573                 printf("\n");
 574                 p += UPLOW_ROW_LEN;
 575         }
 576         printf("};\n");
 577
 578         printf("\n#endif /* WANT_DATA */\n");
 579         printf("\n#define __LOCALE_DATA_Cctype_TBL_LEN\t\t%d\n",
 580 #ifdef CTYPE_PACKED
 581                         n_ctype_rows * CTYPE_ROW_LEN / 2
 582 #else
 583                         n_ctype_rows * CTYPE_ROW_LEN
 584 #endif
 585                         );
 586         printf("\n#ifdef WANT_DATA\n\n");
 587
 588
 589         printf("\nstatic const unsigned char __LOCALE_DATA_Cctype_data[%d] = {\n",
 590 #ifdef CTYPE_PACKED
 591                         n_ctype_rows * CTYPE_ROW_LEN / 2
 592 #else
 593                         n_ctype_rows * CTYPE_ROW_LEN
 594 #endif
 595                         );
 596         p = ctype_tbl;
 597         for (j=0 ; j < n_ctype_rows ; j++) {
 598                 printf("\t");
 599                 for (i=0 ; i < CTYPE_ROW_LEN ; i++) {
 600 #ifdef CTYPE_PACKED
 601                         printf(" %#4x,", (unsigned int)(p[i] + (p[i+1] << 4)));
 602                         ++i;
 603 #else
 604                         printf(" %#4x,", (unsigned int)p[i]);
 605 #endif
 606                 }
 607                 printf("\n");
 608                 p += CTYPE_ROW_LEN;
 609         }
 610         printf("};\n");
 611
 612         printf("\n#endif /* WANT_DATA */\n");
 613
 614 #ifdef DO_WIDE_CHAR
 615
 616         printf("\n#define __LOCALE_DATA_Cc2wc_TBL_LEN\t\t%d\n",
 617                         n_c2wc_rows * C2WC_ROW_LEN);
 618         printf("\n#ifdef WANT_DATA\n\n");
 619
 620         printf("\nstatic const unsigned short __LOCALE_DATA_Cc2wc_data[%d] = {\n",
 621                         n_c2wc_rows * C2WC_ROW_LEN);
 622         p = (unsigned char *) c2wc_tbl;
 623         for (j=0 ; j < n_c2wc_rows ; j++) {
 624                 printf("\t");
 625                 for (i=0 ; i < C2WC_ROW_LEN ; i++) {
 626                         printf(" %#6x,", (unsigned int)(((unsigned short *)p)[i]));
 627                 }
 628                 printf("\n");
 629                 p += 2*C2WC_ROW_LEN;
 630         }
 631         printf("};\n");
 632         printf("\n#endif /* WANT_DATA */\n");
 633 #endif /* DO_WIDE_CHAR */
 634         printf("\n\n");
 635
 636         printf("#define __LOCALE_DATA_NUM_CODESETS\t\t%d\n", numsets);
 637         printf("#define __LOCALE_DATA_CODESET_LIST \\\n\t\"");
 638         for (i=0 ; i < numsets ; i++) {
 639                 printf("\\x%02x", numsets + 1 + (unsigned char) codeset_index[i]);
 640                 if (((i & 7) == 7) && (i + 1 < numsets)) {
 641                         printf("\" \\\n\t\"");
 642                 }
 643         }
 644         printf("\" \\\n\t\"\\0\"");
 645         for (i=0 ; i < numsets ; i++) {
 646                 printf(" \\\n\t\"%s\\0\"",
 647                                 codeset_list + ((unsigned char)codeset_index[i]));
 648         }
 649
 650         printf("\n\n");
 651         for (i=0 ; i < numsets ; i++) {
 652                 char buf[30];
 653                 char *z;
 654                 strcpy(buf, codeset_list + ((unsigned char)codeset_index[i]));
 655                 for (z=buf ; *z ; z++) {
 656                         if (*z == '-') {
 657                                 *z = '_';
 658                         }
 659                 }
 660                 printf("#define __CTYPE_HAS_CODESET_%s\n", buf);
 661         }
 662 #ifdef DO_WIDE_CHAR
 663         printf("#define __CTYPE_HAS_CODESET_UTF_8\n");
 664 #endif /* DO_WIDE_CHAR */
 665
 666 #if 0
 667         printf("\n#endif /* __CTYPE_HAS_8_BIT_LOCALES */\n\n");
 668 #endif
 669
 670         total_size = 0;
 671 #ifdef DO_WIDE_CHAR
 672         fprintf(stderr, "tt_num = %d   ti_num = %d\n", tt_num, ti_num);
 673         fprintf(stderr, "max_wchar = %#lx\n", max_wchar);
 674
 675         fprintf(stderr, "size is %d * %d  +  %d * %d  + %d * %d  =  %d\n",
 676                    tt_num, 1 << TT_SHIFT, ti_num, 1 << TI_SHIFT,
 677                    ((MAX_WCHAR >> (TT_SHIFT + TI_SHIFT)) + 1), numsets,
 678                    j = tt_num * (1 << TT_SHIFT) + ti_num * (1 << TI_SHIFT)
 679                    + ((MAX_WCHAR >> (TT_SHIFT + TI_SHIFT)) + 1) * numsets);
 680         total_size += j;
 681 #endif /* DO_WIDE_CHAR */
 682
 683 #ifdef CTYPE_PACKED
 684         i = 2;
 685 #else
 686         i = 1;
 687 #endif
 688
 689         fprintf(stderr, "ctype - CTYPE_IDX_SHIFT = %d -- %d * %d + %d * %d = %d\n",
 690                    CTYPE_IDX_SHIFT, numsets, CTYPE_IDX_LEN, n_ctype_rows, CTYPE_ROW_LEN / i,
 691                    j = numsets * CTYPE_IDX_LEN +  n_ctype_rows * CTYPE_ROW_LEN / i);
 692         total_size += j;
 693
 694         fprintf(stderr, "uplow - UPLOW_IDX_SHIFT = %d -- %d * %d + %d * %d = %d\n",
 695                    UPLOW_IDX_SHIFT, numsets, UPLOW_IDX_LEN, n_uplow_rows, UPLOW_ROW_LEN,
 696                    j = numsets * UPLOW_IDX_LEN +  n_uplow_rows * UPLOW_ROW_LEN);
 697         total_size += j;
 698
 699 #ifdef DO_WIDE_CHAR
 700
 701         fprintf(stderr, "c2wc - C2WC_IDX_SHIFT = %d -- %d * %d + 2 * %d * %d = %d\n",
 702                    C2WC_IDX_SHIFT, numsets, C2WC_IDX_LEN, n_c2wc_rows, C2WC_ROW_LEN,
 703                    j = numsets * C2WC_IDX_LEN +  2 * n_c2wc_rows * C2WC_ROW_LEN);
 704         total_size += j;
 705
 706 #endif /* DO_WIDE_CHAR */
 707
 708         fprintf(stderr, "total size = %d\n", total_size);
 709
 710 /*      for (i=0 ; i < numsets ; i++) { */
 711 /*              printf("codeset_index[i] = %d  codeset_list[ci[i]] = \"%s\"\n", */
 712 /*                         (unsigned char) codeset_index[i], */
 713 /*                         codeset_list + ((unsigned char)codeset_index[i])); */
 714 /*      } */
 715
 716         return EXIT_SUCCESS;
 717 }