#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
struct mappings_entry {
int cp_uni;
int n;
int cp_932[16];
};
struct mappings {
size_t n;
size_t nalloc;
struct mappings_entry *entries;
};
static void mappings_init(struct mappings *map)
{
map->n = 0;
map->nalloc = 0;
map->entries = 0;
}
static void mappings_destroy(struct mappings *map)
{
if (map->entries)
free(map->entries);
}
static int mappings_grow(struct mappings *map)
{
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;
}
static int mappings_add(struct mappings *map, int cp_uni, int cp_932)
{
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;
}
struct generator_entry {
const char *name;
const char *prologue;
const char *epilogue;
void(*visitor)(const struct mappings_entry *);
};
static int utf32_utf8(char *buf, int k)
{
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;
}
static const char epilogue[] =
"close\n";
static const char prologue_to_cp932[] =
"#!/usr/bin/expect -f\n"
"spawn tests/conv_encoding Japanese CP932 UTF-8\n"
"set timeout 1\n"
"\n"
"expect_after {\n"
" \"\\[^\\r\\n\\]*\\r\\n\" { fail $test }\n"
"}\n";
static const char prologue_to_cp50220[] =
"#!/usr/bin/expect -f\n"
"spawn tests/conv_encoding Japanese CP50220 UTF-8\n"
"set timeout 1\n"
"\n"
"expect_after {\n"
" \"\\[^\\r\\n\\]*\\r\\n\" { fail $test }\n"
"}\n";
static const char prologue_to_cp50222[] =
"#!/usr/bin/expect -f\n"
"spawn tests/conv_encoding Japanese CP50222 UTF-8\n"
"set timeout 1\n"
"\n"
"expect_after {\n"
" \"\\[^\\r\\n\\]*\\r\\n\" { fail $test }\n"
"}\n";
static const char prologue_from_cp932[] =
"#!/usr/bin/expect -f\n"
"spawn tests/conv_encoding Japanese UTF-8 CP932\n"
"set timeout 1\n"
"\n"
"expect_after {\n"
" \"\\[^\\r\\n\\]*\\r\\n\" { fail $test }\n"
"}\n";
static void to_cp932_visitor(const struct mappings_entry *entry)
{
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");
}
static void from_cp932_visitor(const struct mappings_entry *entry)
{
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);
}
}
static void to_cp50220_visitor(const struct mappings_entry *entry)
{
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");
}
static void to_cp50222_visitor(const struct mappings_entry *entry)
{
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");
}
static struct generator_entry entries[] = {
{ "to_cp932", prologue_to_cp932, epilogue, to_cp932_visitor },
{ "to_cp50220", prologue_to_cp50220, epilogue, to_cp50220_visitor },
{ "to_cp50222", prologue_to_cp50222, epilogue, to_cp50222_visitor },
{ "from_cp932", prologue_from_cp932, epilogue, from_cp932_visitor },
{ NULL }
};
static const char cp932_txt[] = "CP932.TXT";
int main(int argc, char **argv)
{
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;
}