Back to index

php5  5.3.10
Classes | Functions | Variables
gen_exp.c File Reference
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

Go to the source code of this file.

Classes

struct  mappings_entry
struct  mappings
struct  generator_entry

Functions

static void mappings_init (struct mappings *map)
static void mappings_destroy (struct mappings *map)
static int mappings_grow (struct mappings *map)
static int mappings_add (struct mappings *map, int cp_uni, int cp_932)
static int utf32_utf8 (char *buf, int k)
static void to_cp932_visitor (const struct mappings_entry *entry)
static void from_cp932_visitor (const struct mappings_entry *entry)
static void to_cp50220_visitor (const struct mappings_entry *entry)
static void to_cp50222_visitor (const struct mappings_entry *entry)
int main (int argc, char **argv)

Variables

static const char epilogue [] = "close\n"
static const char prologue_to_cp932 [] = "}\n"
static const char prologue_to_cp50220 [] = "}\n"
static const char prologue_to_cp50222 [] = "}\n"
static const char prologue_from_cp932 [] = "}\n"
static struct generator_entry []
static const char cp932_txt [] = "CP932.TXT"

Class Documentation

struct mappings_entry

Definition at line 7 of file gen_exp.c.

Class Members
int cp_932
int cp_uni
int n
struct mappings

Definition at line 13 of file gen_exp.c.

Collaboration diagram for mappings:
Class Members
struct mappings_entry * entries
size_t n
size_t nalloc

Function Documentation

static void from_cp932_visitor ( const struct mappings_entry entry) [static]

Definition at line 236 of file gen_exp.c.

{
       char buf_uni[32], buf_cp932[8];
       int i, len;

       if (entry->cp_uni < 32 || entry->cp_uni == 127)
              return;

       len = utf32_utf8(buf_uni, entry->cp_uni);
       buf_uni[len * 3] = '\0';
       i = len;
       while (--i >= 0) {
              unsigned char c = ((unsigned char *)buf_uni)[i];
              buf_uni[i * 3] = '%';
              buf_uni[i * 3 + 1] = "0123456789abcdef"[c >> 4];
              buf_uni[i * 3 + 2] = "0123456789abcdef"[c & 15];
       }

       for (i = 0; i < entry->n; ++i) {
              const int c = entry->cp_932[i];
              if (c >= 0x100)
                     sprintf(buf_cp932, "\\x%02x\\x%02x", (c >> 8) & 0xff, c & 0xff);
              else
                     sprintf(buf_cp932, "\\x%02x", c);
              printf("set test \"U+%06X\"\n"
                        "send -- \"%s\r\"\n"
                        "sleep 0.001\n"
                        "expect {\n"
                     "    \"%s (%d)\\r\\n\" { pass $test }\n"
                     "}\n",
                        entry->cp_uni, buf_cp932, buf_uni, len);
       }
}

Here is the call graph for this function:

int main ( int  argc,
char **  argv 
)

Definition at line 378 of file gen_exp.c.

{
       int retval = 0;
       FILE *fp;
       char buf[1024];
       struct generator_entry* gen;
       struct mappings map;

       if (argc <= 1) {
              fprintf(stderr, "usage: %s generator\n", argv[0]);
              return 255;
       }

       for (gen = entries;; ++gen) {
              if (!gen->name) {
                     fprintf(stderr, "Unknown generator: %s\n", argv[1]);
                     return 1;
              }
              if (strcmp(gen->name, argv[1]) == 0)
                     break;
       }

    fp = fopen(cp932_txt, "r");
       if (!fp) {
              fprintf(stderr, "Failed to open %s\n", cp932_txt);
              return 2;
       }

       mappings_init(&map);

       while (fgets(buf, sizeof(buf), fp)) {
              const char *fields[16];
              char *p = buf;
              int field = 0;
              int cp_932, cp_uni;
              for (;;) {
                     char *q = 0;
                     int eol = 0;

                     if (field >= sizeof(fields) / sizeof(*fields)) {
                            fprintf(stderr, "Too many fields (incorrect file?)\n");
                            retval = 3;
                            goto out;
                     }

                     for (;;) {
                            if (*p == '\0' || *p == '#' || *p == 0x0a) {
                                   eol = 1;
                                   break;
                            } else if (*p != ' ' && *p != '\t') {
                                   break;
                            }
                            ++p;
                     }

                     if (eol)
                            break;

                     q = p;

                     for (;;) {
                            if (*p == '\0' || *p == '#' || *p == 0x0a) {
                                   eol = 1;
                                   break;
                            } else if (*p == ' ' || *p == '\t') {
                                   break;
                            }
                            ++p;
                     }

                     *p = '\0';
                     fields[field++] = q;

                     if (eol)
                            break;
                     ++p;
              }
              if (field == 0 || field == 1) {
                     continue;
              } else if (field != 2) {
                     fprintf(stderr, "Unexpected field count (expected 2, got %d)\n", field);
                     retval = 3;
                     goto out;
              }
              cp_932 = strtol(fields[0], NULL, 0);
              if (errno == ERANGE || errno == EINVAL) {
                     fprintf(stderr, "Malformed field value: %s\n", fields[0]);
                     retval = 4;
                     goto out;
              }
              cp_uni = strtol(fields[1], NULL, 0);
              if (errno == ERANGE || errno == EINVAL) {
                     fprintf(stderr, "Malformed field value: %s\n", fields[1]);
                     retval = 4;
                     goto out;
              }

              if (mappings_add(&map, cp_uni, cp_932)) {
                     fprintf(stderr, "Too many mappings to the same Unicode codepoint (U+%06X)\n", cp_uni);
                     retval = 4;
                     goto out;
              }
       }

       {
              size_t i;
              printf("%s", gen->prologue);
              for (i = 0; i < map.n; ++i)
                     gen->visitor(&map.entries[i]);
              printf("%s", gen->epilogue);
       }

out:
       mappings_destroy(&map);
       return retval;
}

Here is the call graph for this function:

static int mappings_add ( struct mappings map,
int  cp_uni,
int  cp_932 
) [static]

Definition at line 53 of file gen_exp.c.

{
       size_t i;
       size_t s = 0, e = map->n;
       struct mappings_entry *entry;

       for (;;) {
              i = (s + e) / 2;
              entry = &map->entries[i];
              if (e == i || entry->cp_uni > cp_uni) {
                     if (e == i) {
                            int r = mappings_grow(map);
                            if (r)
                                   return r;
                            if (map->n > i) {
                                   size_t n = map->n - i, a = sizeof(*map->entries) * n;
                                   if (a / n != sizeof(*map->entries))
                                          return 2;
                                   memmove(&map->entries[i + 1], &map->entries[i], a);
                            }
                            ++map->n;
                            entry = &map->entries[i];
                            entry->cp_uni = cp_uni;
                            entry->n = 0;
                            break;
                     }
                     e = i;
              } else if (entry->cp_uni < cp_uni) {
                     if (s == i) {
                            int r = mappings_grow(map);
                            if (r)
                                   return r;
                            if (map->n > i + 1) {
                                   size_t n = (map->n - i - 1), a = sizeof(*map->entries) * n;
                                   if (a / n != sizeof(*map->entries))
                                          return 2;
                                   memmove(&map->entries[i + 2], &map->entries[i + 1], a);
                            }
                            ++map->n;
                            entry = &map->entries[i + 1];
                            entry->cp_uni = cp_uni;
                            entry->n = 0;
                            break;
                     }
                     s = i;
              } else {
                     break;
              }
       }
       if (entry->n >= sizeof(entry->cp_932) / sizeof(*entry->cp_932))
              return 1;
       entry->cp_932[entry->n++] = cp_932;
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mappings_destroy ( struct mappings map) [static]

Definition at line 26 of file gen_exp.c.

{
       if (map->entries)
              free(map->entries);
}

Here is the caller graph for this function:

static int mappings_grow ( struct mappings map) [static]

Definition at line 32 of file gen_exp.c.

{
       if (map->n >= map->nalloc) {
              struct mappings_entry *new_entries;
              size_t n = map->nalloc << 1, a;
              if (n == 0)
                     n = 1;
              else if (n <= map->n)
                     return 2;
              a = sizeof(*map->entries) * n;
              if (a / n != sizeof(*map->entries))
                     return 2;
              new_entries = realloc(map->entries, a);
              if (!new_entries)
                     return 2;
              map->entries = new_entries;
              map->nalloc = n;
       }
       return 0;
}

Here is the caller graph for this function:

static void mappings_init ( struct mappings map) [static]

Definition at line 19 of file gen_exp.c.

{
       map->n = 0;
       map->nalloc = 0;
       map->entries = 0;
}

Here is the caller graph for this function:

static void to_cp50220_visitor ( const struct mappings_entry entry) [static]

Definition at line 270 of file gen_exp.c.

{
       char buf_uni[32], buf_cp50220[32];
       int i;

       if (entry->cp_uni < 32 || entry->cp_uni == 127)
              return;

       i = utf32_utf8(buf_uni, entry->cp_uni);
       buf_uni[i * 4] = '\0';
       while (--i >= 0) {
              unsigned char c = ((unsigned char *)buf_uni)[i];
              buf_uni[i * 4] = '\\';
              buf_uni[i * 4 + 1] = 'x';
              buf_uni[i * 4 + 2] = "0123456789abcdef"[c >> 4];
              buf_uni[i * 4 + 3] = "0123456789abcdef"[c & 15];
       }

       printf("set test \"U+%06X\"\n"
              "send -- \"%s\r\"\n"
                 "sleep 0.001\n"
              "expect {\n", entry->cp_uni, buf_uni);

       for (i = 0; i < entry->n; ++i) {
              int len = 0;
              const int c = entry->cp_932[i];
              if (c >= 0xa1 && c < 0xe0) {
                     static const int jisx0208_tl_map[] = {
                            0x0000, 0x2123, 0x2156, 0x2157, 0x2122, 0x2126, 0x2572, 0x2521,
                            0x2523, 0x2525, 0x2527, 0x2529, 0x2563, 0x2565, 0x2567, 0x2543,
                            0x213c, 0x2522, 0x2524, 0x2526, 0x2528, 0x252a, 0x252b, 0x252d,
                            0x252f, 0x2531, 0x2533, 0x2535, 0x2537, 0x2539, 0x253b, 0x253d,
                            0x253f, 0x2541, 0x2544, 0x2546, 0x2548, 0x254a, 0x254b, 0x254c,
                            0x254d, 0x254e, 0x254f, 0x2552, 0x2555, 0x2558, 0x255b, 0x255e,
                            0x255f, 0x2560, 0x2561, 0x2562, 0x2564, 0x2566, 0x2568, 0x2569,
                            0x256a, 0x256b, 0x256c, 0x256d, 0x256f, 0x2573, 0x212b, 0x212c
                     };
                     const int j = jisx0208_tl_map[c - 0xa0];
                     len = 8;
                     sprintf(buf_cp50220, "%%1b%%24%%42%%%02x%%%02x%%1b%%28%%42", j >> 8, j & 0xff);
              } else if (c >= 0x100) {
                     const int j = ((((c & 0xff00) - (c >= 0xe000 ? 0xb000: 0x7000)) << 1) | ((c & 0xff) - (c & 0x80 ? 32: 31))) - ((c & 0xff) >= 159 ? 94: 0x100);
                     len = 8;
                     sprintf(buf_cp50220, "%%1b%%24%%42%%%02x%%%02x%%1b%%28%%42", j >> 8, j & 0xff);
              } else {
                     len = 1;
                     sprintf(buf_cp50220, "%%%02x", c);
              }
              printf("    \"%s (%d)\\r\\n\" { pass $test }\n", buf_cp50220, len);
       }

       printf("}\n");
}

Here is the call graph for this function:

static void to_cp50222_visitor ( const struct mappings_entry entry) [static]

Definition at line 324 of file gen_exp.c.

{
       char buf_uni[32], buf_cp50220[32];
       int i;

       if (entry->cp_uni < 32 || entry->cp_uni == 127)
              return;

       i = utf32_utf8(buf_uni, entry->cp_uni);
       buf_uni[i * 4] = '\0';
       while (--i >= 0) {
              unsigned char c = ((unsigned char *)buf_uni)[i];
              buf_uni[i * 4] = '\\';
              buf_uni[i * 4 + 1] = 'x';
              buf_uni[i * 4 + 2] = "0123456789abcdef"[c >> 4];
              buf_uni[i * 4 + 3] = "0123456789abcdef"[c & 15];
       }

       printf("set test \"U+%06X\"\n"
              "send -- \"%s\r\"\n"
                 "sleep 0.001\n"
              "expect {\n", entry->cp_uni, buf_uni);

       for (i = 0; i < entry->n; ++i) {
              int len = 0;
              const int c = entry->cp_932[i];
              if (c >= 0xa1 && c < 0xe0) {
                     len = 3;
                     sprintf(buf_cp50220, "%%0e%%%02x%%0f", c - 0x80);
              } else if (c >= 0x100) {
                     const int j = ((((c & 0xff00) - (c >= 0xe000 ? 0xb000: 0x7000)) << 1) | ((c & 0xff) - (c & 0x80 ? 32: 31))) - ((c & 0xff) >= 159 ? 94: 0x100);
                     len = 8;
                     sprintf(buf_cp50220, "%%1b%%24%%42%%%02x%%%02x%%1b%%28%%42", j >> 8, j & 0xff);
              } else {
                     len = 1;
                     sprintf(buf_cp50220, "%%%02x", c);
              }
              printf("    \"%s (%d)\\r\\n\" { pass $test }\n", buf_cp50220, len);
       }

       printf("}\n");
}

Here is the call graph for this function:

static void to_cp932_visitor ( const struct mappings_entry entry) [static]

Definition at line 197 of file gen_exp.c.

{
       char buf_uni[32], buf_cp932[8];
       int i;

       if (entry->cp_uni < 32 || entry->cp_uni == 127)
              return;

       i = utf32_utf8(buf_uni, entry->cp_uni);
       buf_uni[i * 4] = '\0';
       while (--i >= 0) {
              unsigned char c = ((unsigned char *)buf_uni)[i];
              buf_uni[i * 4] = '\\';
              buf_uni[i * 4 + 1] = 'x';
              buf_uni[i * 4 + 2] = "0123456789abcdef"[c >> 4];
              buf_uni[i * 4 + 3] = "0123456789abcdef"[c & 15];
       }

       printf("set test \"U+%06X\"\n"
              "send -- \"%s\r\"\n"
                 "sleep 0.001\n"
              "expect {\n", entry->cp_uni, buf_uni);

       for (i = 0; i < entry->n; ++i) {
              int len = 0;
              const int c = entry->cp_932[i];
              if (c >= 0x100) {
                     len = 2;
                     sprintf(buf_cp932, "%%%02x%%%02x", (c >> 8) & 0xff, c & 0xff);
              } else {
                     len = 1;
                     sprintf(buf_cp932, "%%%02x", c);
              }
              printf("    \"%s (%d)\\r\\n\" { pass $test }\n", buf_cp932, len);
       }

       printf("}\n");
}

Here is the call graph for this function:

static int utf32_utf8 ( char *  buf,
int  k 
) [static]

Definition at line 115 of file gen_exp.c.

{
       int retval = 0;

       if (k < 0x80) {
              buf[0] = k;
              retval = 1;
       } else if (k < 0x800) {
              buf[0] = 0xc0 | (k >> 6);
              buf[1] = 0x80 | (k & 0x3f);
              retval = 2;
       } else if (k < 0x10000) {
              buf[0] = 0xe0 | (k >> 12);
              buf[1] = 0x80 | ((k >> 6) & 0x3f);
              buf[2] = 0x80 | (k & 0x3f);
              retval = 3;
       } else if (k < 0x200000) {
              buf[0] = 0xf0 | (k >> 18);
              buf[1] = 0x80 | ((k >> 12) & 0x3f);
              buf[2] = 0x80 | ((k >> 6) & 0x3f);
              buf[3] = 0x80 | (k & 0x3f);
              retval = 4;
       } else if (k < 0x4000000) {
              buf[0] = 0xf8 | (k >> 24);
              buf[1] = 0x80 | ((k >> 18) & 0x3f);
              buf[2] = 0x80 | ((k >> 12) & 0x3f);
              buf[3] = 0x80 | ((k >> 6) & 0x3f);
              buf[4] = 0x80 | (k & 0x3f);
              retval = 5;
       } else {
              buf[0] = 0xfc | (k >> 30);
              buf[1] = 0x80 | ((k >> 24) & 0x3f);
              buf[2] = 0x80 | ((k >> 18) & 0x3f);
              buf[3] = 0x80 | ((k >> 12) & 0x3f);
              buf[4] = 0x80 | ((k >> 6) & 0x3f);
              buf[5] = 0x80 | (k & 0x3f);
              retval = 6;
       }
       buf[retval] = '\0';

       return retval;
}

Here is the caller graph for this function:


Variable Documentation

const char cp932_txt[] = "CP932.TXT" [static]

Definition at line 376 of file gen_exp.c.

const char epilogue[] = "close\n" [static]

Definition at line 158 of file gen_exp.c.

struct generator_entry[] [static]
Initial value:

Definition at line 368 of file gen_exp.c.

const char prologue_from_cp932[] = "}\n" [static]

Definition at line 188 of file gen_exp.c.

const char prologue_to_cp50220[] = "}\n" [static]

Definition at line 170 of file gen_exp.c.

const char prologue_to_cp50222[] = "}\n" [static]

Definition at line 179 of file gen_exp.c.

const char prologue_to_cp932[] = "}\n" [static]

Definition at line 161 of file gen_exp.c.