src/japanese.c

   1 /* File: japanese.c */
   2
   3
   4 #include "angband.h"
   5
   6 #ifdef JP
   7
   8 typedef struct convert_key convert_key;
   9
  10 struct convert_key
  11 {
  12         cptr key1;
  13         cptr key2;
  14 };
  15
  16 static const convert_key s2j_table[] = {
  17         {"mb","nb"}, {"mp","np"}, {"mv","nv"}, {"mm","nm"},
  18         {"x","ks"},
  19         /* sindar:¥·¥ó¥À¡¼¥ë  parantir:¥Ñ¥é¥ó¥Æ¥£¥¢  feanor:¥Õ¥§¥¢¥Î¡¼¥ë */
  20         {"ar$","a-ru$"}, {"ir$","ia$"}, {"or$","o-ru$"},
  21         {"ra","¥é"}, {"ri","¥ê"}, {"ru","¥ë"}, {"re","¥ì"}, {"ro","¥í"},
  22         {"ir","ia"}, {"ur","ua"}, {"er","ea"}, {"ar","a¥ë"},
  23         {"sha","¥·¥ã"}, {"shi","¥·"}, {"shu","¥·¥å"}, {"she","¥·¥§"}, {"sho","¥·¥ç"},
  24         {"tha","¥µ"}, {"thi","¥·"}, {"thu","¥¹"}, {"the","¥»"}, {"tho","¥½"},
  25         {"cha","¥Ï"}, {"chi","¥Ò"}, {"chu","¥Õ"}, {"che","¥Ø"}, {"cho","¥Û"},
  26         {"dha","¥¶"}, {"dhi","¥¸"}, {"dhu","¥º"}, {"dhe","¥¼"}, {"dho","¥¾"},
  27         {"ba","¥Ð"}, {"bi","¥Ó"}, {"bu","¥Ö"}, {"be","¥Ù"}, {"bo","¥Ü"},
  28         {"ca","¥«"}, {"ci","¥"}, {"cu","¥¯"}, {"ce","¥±"}, {"co","¥³"},
  29         {"da","¥À"}, {"di","¥Ç¥£"}, {"du","¥É¥¥"}, {"de","¥Ç"}, {"do","¥É"},
  30         {"fa","¥Õ¥¡"}, {"fi","¥Õ¥£"}, {"fu","¥Õ"}, {"fe","¥Õ¥§"}, {"fo","¥Õ¥©"},
  31         {"ga","¥¬"}, {"gi","¥®"}, {"gu","¥°"}, {"ge","¥²"}, {"go","¥´"},
  32         {"ha","¥Ï"}, {"hi","¥Ò"}, {"hu","¥Õ"}, {"he","¥Ø"}, {"ho","¥Û"},
  33         {"ja","¥¸¥ã"}, {"ji","¥¸"}, {"ju","¥¸¥å"}, {"je","¥¸¥§"}, {"jo","¥¸¥ç"},
  34         {"ka","¥«"}, {"ki","¥"}, {"ku","¥¯"}, {"ke","¥±"}, {"ko","¥³"},
  35         {"la","¥é"}, {"li","¥ê"}, {"lu","¥ë"}, {"le","¥ì"}, {"lo","¥í"},
  36         {"ma","¥Þ"}, {"mi","¥ß"}, {"mu","¥à"}, {"me","¥á"}, {"mo","¥â"},
  37         {"na","¥Ê"}, {"ni","¥Ë"}, {"nu","¥Ì"}, {"ne","¥Í"}, {"no","¥Î"},
  38         {"pa","¥Ñ"}, {"pi","¥Ô"}, {"pu","¥×"}, {"pe","¥Ú"}, {"po","¥Ý"},
  39         {"qu","¥¯"},
  40         {"sa","¥µ"}, {"si","¥·"}, {"su","¥¹"}, {"se","¥»"}, {"so","¥½"},
  41         {"ta","¥¿"}, {"ti","¥Æ¥£"}, {"tu","¥È¥¥"}, {"te","¥Æ"}, {"to","¥È"},
  42         {"va","¥ô¥¡"}, {"vi","¥ô¥£"}, {"vu","¥ô"}, {"ve","¥ô¥§"}, {"vo","¥ô¥©"},
  43         {"wa","¥ï"}, {"wi","¥¦¥£"}, {"wu","¥¦"}, {"we","¥¦¥§"}, {"wo","¥¦¥©"},
  44         {"ya","¥ä"}, {"yu","¥æ"}, {"yo","¥è"},
  45         {"za","¥¶"}, {"zi","¥¸"}, {"zu","¥º"}, {"ze","¥¼"}, {"zo","¥¾"},
  46         {"dh","¥º"}, {"ch","¥Õ"}, {"th","¥¹"},
  47         {"b","¥Ö"}, {"c","¥¯"}, {"d","¥É"}, {"f","¥Õ"}, {"g","¥°"},
  48         {"h","¥Õ"}, {"j","¥¸¥å"}, {"k","¥¯"}, {"l","¥ë"}, {"m","¥à"},
  49         {"n","¥ó"}, {"p","¥×"}, {"q","¥¯"}, {"r","¥ë"}, {"s","¥¹"},
  50         {"t","¥È"}, {"v","¥ô"}, {"w","¥¦"}, {"y","¥¤"},
  51         {"a","¥¢"}, {"i","¥¤"}, {"u","¥¦"}, {"e","¥¨"}, {"o","¥ª"},
  52         {"-","¡¼"},
  53         {NULL,NULL}
  54 };
  55
  56 /* ¥·¥ó¥À¥ê¥ó¤òÆüËÜ¸ì¤ÎÆÉ¤ß¤ËÊÑ´¹¤¹¤ë */
  57 void sindarin_to_kana(char *kana, const char *sindarin)
  58 {
  59         char buf[256];
  60         int idx;
  61
  62         sprintf(kana, "%s$", sindarin);
  63         for (idx = 0; kana[idx]; idx++)
  64                 if (isupper(kana[idx])) kana[idx] = tolower(kana[idx]);
  65
  66         for (idx = 0; s2j_table[idx].key1 != NULL; idx++)
  67         {
  68                 cptr pat1 = s2j_table[idx].key1;
  69                 cptr pat2 = s2j_table[idx].key2;
  70                 int len = strlen(pat1);
  71                 char *src = kana;
  72                 char *dest = buf;
  73
  74                 while (*src)
  75                 {
  76                         if (strncmp(src, pat1, len) == 0)
  77                         {
  78                                 strcpy(dest, pat2);
  79                                 src += len;
  80                                 dest += strlen(pat2);
  81                         }
  82                         else
  83                         {
  84                                 if (iskanji(*src))
  85                                 {
  86                                         *dest = *src;
  87                                         src++;
  88                                         dest++;
  89                                 }
  90                                 *dest = *src;
  91                                 src++;
  92                                 dest++;
  93                         }
  94                 }
  95
  96                 *dest = 0;
  97                 strcpy(kana, buf);
  98         }
  99
 100         idx = 0;
 101
 102         while (kana[idx] != '$') idx++;
 103
 104         kana[idx] = '\0';
 105 }
 106
 107
 108 /*ÆüËÜ¸ìÆ°»ì³èÍÑ (ÂÇ¤Ä¡äÂÇ¤Ã¤Æ,ÂÇ¤Á etc) */
 109 /* JVERB_AND: ²¥¤ë,½³¤ë > ²¥¤ê,½³¤ë */
 110 /* JVERB_TO:  ²¥¤ë,½³¤ë > ²¥¤Ã¤Æ½³¤ë */
 111 /* JVERB_OR:  ²¥¤ë,½³¤ë > ²¥¤Ã¤¿¤ê½³¤Ã¤¿¤ê */
 112
 113 static const struct jverb_table_t {
 114         const char* from;
 115         const char* to[3];
 116 } jverb_table[] = {
 117         { "¤¹¤ë", {"¤·", "¤·¤Æ", "¤·¤¿"}},
 118         { "¤¤¤ë", {"¤¤¤Æ", "¤¤¤Æ", "¤¤¤¿"}},
 119
 120         { "¤¨¤ë", {"¤¨", "¤¨¤Æ", "¤¨¤¿"}},
 121         { "¤±¤ë", {"¤±", "¤±¤Æ", "¤±¤¿"}},
 122         { "¤²¤ë", {"¤²", "¤¨¤Æ", "¤²¤¿"}},
 123         { "¤»¤ë", {"¤»", "¤»¤Æ", "¤»¤¿"}},
 124         { "¤¼¤ë", {"¤¼", "¤¼¤Æ", "¤¼¤¿"}},
 125         { "¤Æ¤ë", {"¤Æ", "¤Æ¤Ã¤Æ", "¤Æ¤Ã¤¿"}},
 126         { "¤Ç¤ë", {"¤Ç", "¤Ç¤Æ", "¤Ç¤¿"}},
 127         { "¤Í¤ë", {"¤Í", "¤Í¤Æ", "¤Í¤¿"}},
 128         { "¤Ø¤ë", {"¤Ø", "¤Ø¤Æ", "¤Ø¤¿"}},
 129         { "¤Ù¤ë", {"¤Ù", "¤Ù¤Æ", "¤Ù¤¿"}},
 130         { "¤á¤ë", {"¤á", "¤á¤Æ", "¤á¤¿"}},
 131         { "¤ì¤ë", {"¤ì", "¤ì¤Æ", "¤ì¤¿"}},
 132
 133         { "¤¦", {"¤¤", "¤Ã¤Æ", "¤Ã¤¿"}},
 134         { "¤¯", {"¤", "¤¤¤Æ", "¤¤¤¿"}},
 135         { "¤°", {"¤®", "¤¤¤Ç", "¤¤¤À"}},
 136         { "¤¹", {"¤·", "¤·¤Æ", "¤·¤¿"}},
 137         { "¤º", {"¤¸", "¤¸¤Æ", "¤¸¤¿"}},
 138         { "¤Ä", {"¤Á", "¤Ã¤Æ", "¤Ã¤¿"}},
 139         { "¤Å", {"¤Â", "¤Ã¤Æ", "¤Ã¤¿"}},
 140         { "¤Ì", {"¤Ë", "¤Í¤Æ", "¤Í¤¿"}},
 141         { "¤Õ", {"¤Ò", "¤Ø¤Æ", "¤Ø¤¿"}},
 142         { "¤Ö", {"¤Ó", "¤ó¤Ç", "¤ó¤À"}},
 143         { "¤à", {"¤ß", "¤ó¤Ç", "¤ó¤À"}},
 144         { "¤ë", {"¤ê", "¤Ã¤Æ", "¤Ã¤¿"}},
 145         { NULL, {"¤½¤·¤Æ", "¤³¤È¤Ë¤è¤ê", "¤³¤È¤ä"}},
 146 };
 147
 148 void jverb(const char *in , char *out , int flag)
 149 {
 150         const struct jverb_table_t * p;
 151         int in_len = strlen(in);
 152
 153         strcpy(out, in);
 154
 155         for (p = jverb_table; p->from; p++) {
 156                 int from_len = strlen(p->from);
 157                 if (strncmp(&in[in_len-from_len], p->from, from_len) == 0) {
 158                         strcpy(&out[in_len - from_len], p->to[flag - 1]);
 159                         break;
 160                 }
 161         }
 162
 163         if (p->from == NULL)
 164                 strcpy(&out[in_len], p->to[flag - 1]);
 165 }
 166
 167
 168 /*
 169  * Convert SJIS string to EUC string
 170  */
 171 void sjis2euc(char *str)
 172 {
 173         int i;
 174         unsigned char c1, c2;
 175         unsigned char *tmp;
 176
 177         int len = strlen(str);
 178
 179         C_MAKE(tmp, len+1, byte);
 180
 181         for (i = 0; i < len; i++)
 182         {
 183                 c1 = str[i];
 184                 if (c1 & 0x80)
 185                 {
 186                         i++;
 187                         c2 = str[i];
 188                         if (c2 >= 0x9f)
 189                         {
 190                                 c1 = c1 * 2 - (c1 >= 0xe0 ? 0xe0 : 0x60);
 191                                 c2 += 2;
 192                         }
 193                         else
 194                         {
 195                                 c1 = c1 * 2 - (c1 >= 0xe0 ? 0xe1 : 0x61);
 196                                 c2 += 0x60 + (c2 < 0x7f);
 197                         }
 198                         tmp[i - 1] = c1;
 199                         tmp[i] = c2;
 200                 }
 201                 else
 202                         tmp[i] = c1;
 203         }
 204         tmp[len] = 0;
 205         strcpy(str, (char *)tmp);
 206
 207         C_KILL(tmp, len+1, byte);
 208 }
 209
 210
 211 /*
 212  * Convert EUC string to SJIS string
 213  */
 214 void euc2sjis(char *str)
 215 {
 216         int i;
 217         unsigned char c1, c2;
 218         unsigned char *tmp;
 219
 220         int len = strlen(str);
 221
 222         C_MAKE(tmp, len+1, byte);
 223
 224         for (i = 0; i < len; i++)
 225         {
 226                 c1 = str[i];
 227                 if (c1 & 0x80)
 228                 {
 229                         i++;
 230                         c2 = str[i];
 231                         if (c1 % 2)
 232                         {
 233                                 c1 = (c1 >> 1) + (c1 < 0xdf ? 0x31 : 0x71);
 234                                 c2 -= 0x60 + (c2 < 0xe0);
 235                         }
 236                         else
 237                         {
 238                                 c1 = (c1 >> 1) + (c1 < 0xdf ? 0x30 : 0x70);
 239                                 c2 -= 2;
 240                         }
 241
 242                         tmp[i - 1] = c1;
 243                         tmp[i] = c2;
 244                 }
 245                 else
 246                         tmp[i] = c1;
 247         }
 248         tmp[len] = 0;
 249         strcpy(str, (char *)tmp);
 250
 251         C_KILL(tmp, len+1, byte);
 252 }
 253
 254
 255 /*
 256  * str¤ò´Ä¶¤Ë¹ç¤Ã¤¿Ê¸»ú¥³¡¼¥É¤ËÊÑ´¹¤·¡¢ÊÑ´¹Á°¤ÎÊ¸»ú¥³¡¼¥É¤òÊÖ¤¹¡£
 257  * str¤ÎÄ¹¤µ¤ËÀ©¸Â¤Ï¤Ê¤¤¡£
 258  *
 259  * 0: Unknown
 260  * 1: ASCII (Never known to be ASCII in this function.)
 261  * 2: EUC
 262  * 3: SJIS
 263  */
 264 byte codeconv(char *str)
 265 {
 266         byte code = 0;
 267         int i;
 268
 269         for (i = 0; str[i]; i++)
 270         {
 271                 unsigned char c1;
 272                 unsigned char c2;
 273
 274                 /* First byte */
 275                 c1 = str[i];
 276
 277                 /* ASCII? */
 278                 if (!(c1 & 0x80)) continue;
 279
 280                 /* Second byte */
 281                 i++;
 282                 c2 = str[i];
 283
 284                 if (((0xa1 <= c1 && c1 <= 0xdf) || (0xfd <= c1 && c1 <= 0xfe)) &&
 285                     (0xa1 <= c2 && c2 <= 0xfe))
 286                 {
 287                         /* Only EUC is allowed */
 288                         if (!code)
 289                         {
 290                                 /* EUC */
 291                                 code = 2;
 292                         }
 293
 294                         /* Broken string? */
 295                         else if (code != 2)
 296                         {
 297                                 /* No conversion */
 298                                 return 0;
 299                         }
 300                 }
 301
 302                 else if (((0x81 <= c1 && c1 <= 0x9f) &&
 303                           ((0x40 <= c2 && c2 <= 0x7e) || (0x80 <= c2 && c2 <= 0xfc))) ||
 304                          ((0xe0 <= c1 && c1 <= 0xfc) &&
 305                           (0x40 <= c2 && c2 <= 0x7e)))
 306                 {
 307                         /* Only SJIS is allowed */
 308                         if (!code)
 309                         {
 310                                 /* SJIS */
 311                                 code = 3;
 312                         }
 313
 314                         /* Broken string? */
 315                         else if (code != 3)
 316                         {
 317                                 /* No conversion */
 318                                 return 0;
 319                         }
 320                 }
 321         }
 322
 323
 324         switch (code)
 325         {
 326 #ifdef EUC
 327         case 3:
 328                 /* SJIS -> EUC */
 329                 sjis2euc(str);
 330                 break;
 331 #endif
 332
 333 #ifdef SJIS
 334         case 2:
 335                 /* EUC -> SJIS */
 336                 euc2sjis(str);
 337
 338                 break;
 339 #endif
 340         }
 341
 342         /* Return kanji code */
 343         return code;
 344 }
 345
 346 /* Ê¸»úÎós¤Îx¥Ð¥¤¥ÈÌÜ¤¬´Á»ú¤Î1¥Ð¥¤¥ÈÌÜ¤«¤É¤¦¤«È½Äê¤¹¤ë */
 347 bool iskanji2(cptr s, int x)
 348 {
 349         int i;
 350
 351         for (i = 0; i < x; i++)
 352         {
 353                 if (iskanji(s[i])) i++;
 354         }
 355         if ((x == i) && iskanji(s[x])) return TRUE;
 356
 357         return FALSE;
 358 }
 359
 360 /*!
 361  * @brief Ê¸»úÎó¤ÎÊ¸»ú¥³¡¼¥É¤¬ASCII¤«¤É¤¦¤«¤òÈ½Äê¤¹¤ë
 362  * @param str È½Äê¤¹¤ëÊ¸»úÎó¤Ø¤Î¥Ý¥¤¥ó¥¿
 363  * @return Ê¸»úÎó¤ÎÊ¸»ú¥³¡¼¥É¤¬ASCII¤Ê¤éTRUE¡¢¤½¤¦¤Ç¤Ê¤±¤ì¤ÐFALSE
 364  */
 365 static bool is_ascii_str(cptr str)
 366 {
 367         for (;*str; str++) {
 368                 if (!(0x00 < *str && *str <= 0x7f))
 369                         return FALSE;
 370         }
 371         return TRUE;
 372 }
 373
 374 /*!
 375  * @brief Ê¸»úÎó¤ÎÊ¸»ú¥³¡¼¥É¤¬UTF-8¤«¤É¤¦¤«¤òÈ½Äê¤¹¤ë
 376  * @param str È½Äê¤¹¤ëÊ¸»úÎó¤Ø¤Î¥Ý¥¤¥ó¥¿
 377  * @return Ê¸»úÎó¤ÎÊ¸»ú¥³¡¼¥É¤¬UTF-8¤Ê¤éTRUE¡¢¤½¤¦¤Ç¤Ê¤±¤ì¤ÐFALSE
 378  */
 379 static bool is_utf8_str(cptr str)
 380 {
 381         const unsigned char* p;
 382         for (p = (const unsigned char*)str; *p; p++) {
 383                 int subseq_num = 0;
 384                 if (0x00 < *p && *p <= 0x7f) continue;
 385
 386                 if ((*p & 0xe0) == 0xc0) subseq_num = 1;
 387                 if ((*p & 0xf0) == 0xe0) subseq_num = 2;
 388                 if ((*p & 0xf8) == 0xf0) subseq_num = 3;
 389
 390                 if (subseq_num == 0) return FALSE;
 391                 while (subseq_num--) {
 392                         p++;
 393                         if (!*p || (*p & 0xc0) != 0x80) return FALSE;
 394                 }
 395         }
 396         return TRUE;
 397 }
 398
 399 #if defined(EUC)
 400 #include <iconv.h>
 401 #elif defined(SJIS) && defined(WINDOWS)
 402 #include <Windows.h>
 403 #endif
 404 /*!
 405  * @brief Ê¸»ú¥³¡¼¥É¤¬UTF-8¤ÎÊ¸»úÎó¤ò¥·¥¹¥Æ¥à¤ÎÊ¸»ú¥³¡¼¥É¤ËÊÑ´¹¤¹¤ë
 406  * @param utf8_str ÊÑ´¹¤¹¤ëUTF-8¤ÎÊ¸»úÎó¤Ø¤Î¥Ý¥¤¥ó¥¿
 407  * @param sys_str_buffer ÊÑ´¹¤·¤¿¥·¥¹¥Æ¥à¤ÎÊ¸»ú¥³¡¼¥É¤ÎÊ¸»úÎó¤ò³ÊÇ¼¤¹¤ë¥Ð¥Ã¥Õ¥¡¤Ø¤Î¥Ý¥¤¥ó¥¿
 408  * @param sys_str_buflen ÊÑ´¹¤·¤¿¥·¥¹¥Æ¥à¤ÎÊ¸»ú¥³¡¼¥É¤ÎÊ¸»úÎó¤ò³ÊÇ¼¤¹¤ë¥Ð¥Ã¥Õ¥¡¤ÎÄ¹¤µ
 409  * @return ÊÑ´¹¤ËÀ®¸ù¤·¤¿¾ì¹çTRUE¡¢¼ºÇÔ¤·¤¿¾ì¹çFALSE¤òÊÖ¤¹
 410  */
 411 static bool utf8_to_sys(char* utf8_str, char* sys_str_buffer, size_t sys_str_buflen)
 412 {
 413 #if defined(EUC)
 414
 415         iconv_t cd = iconv_open("EUC-JP", "UTF-8");
 416         size_t utf8_len = strlen(utf8_str) + 1; /* include termination character */
 417         char *from = utf8_str;
 418         int ret = iconv(cd, &from, &utf8_len, &sys_str_buffer, &sys_str_buflen);
 419         iconv_close(cd);
 420         return (ret >= 0);
 421
 422 #elif defined(SJIS) && defined(WINDOWS)
 423
 424         LPWSTR utf16buf;
 425         int input_len = strlen(utf8_str) + 1; /* include termination character */
 426
 427         C_MAKE(utf16buf, input_len, WCHAR);
 428
 429         /* UTF-8 -> UTF-16 */
 430         if (MultiByteToWideChar( CP_UTF8, 0, utf8_str, input_len, utf16buf, input_len) == 0) {
 431                 C_KILL(utf16buf, input_len, WCHAR);
 432                 return FALSE;
 433         }
 434
 435         /* UTF-8 -> SJIS(CP932) */
 436         if (WideCharToMultiByte( CP_ACP, 0, utf16buf, -1, sys_str_buffer, sys_str_buflen, NULL, NULL ) == 0) {
 437                 C_KILL(utf16buf, input_len, WCHAR);
 438                 return FALSE;
 439         }
 440
 441         C_KILL(utf16buf, input_len, WCHAR);
 442         return TRUE;
 443
 444 #endif
 445 }
 446
 447 /*!
 448  * @brief ¼õ¤±¼è¤Ã¤¿Ê¸»úÎó¤ÎÊ¸»ú¥³¡¼¥É¤ò¿äÄê¤·¡¢¥·¥¹¥Æ¥à¤ÎÊ¸»ú¥³¡¼¥É¤ØÊÑ´¹¤¹¤ë
 449  * @param strbuf ÊÑ´¹¤¹¤ëÊ¸»úÎó¤ò³ÊÇ¼¤·¤¿¥Ð¥Ã¥Õ¥¡¤Ø¤Î¥Ý¥¤¥ó¥¿¡£
 450  *               ¥Ð¥Ã¥Õ¥¡¤ÏÊÑ´¹¤·¤¿Ê¸»úÎó¤Ç¾å½ñ¤¤µ¤ì¤ë¡£
 451  *               UTF-8¤«¤éSJIS¤â¤·¤¯¤ÏEUC¤Ø¤ÎÊÑ´¹¤òÁÛÄê¤·¤Æ¤¤¤ë¤Î¤Ç¥Ð¥Ã¥Õ¥¡¤ÎÄ¹¤µ¤¬Â¤ê¤Ê¤¯¤Ê¤ë¤³¤È¤Ï¤Ê¤¤¡£
 452  * @param buflen ¥Ð¥Ã¥Õ¥¡¤ÎÄ¹¤µ¡£
 453  * @return ¤Ê¤·
 454  */
 455 void guess_convert_to_system_encoding(char* strbuf, int buflen)
 456 {
 457         if (is_ascii_str(strbuf)) return;
 458
 459         if (is_utf8_str(strbuf)) {
 460                 char* work;
 461                 C_MAKE(work, buflen, char);
 462                 my_strcpy(work, strbuf, buflen);
 463                 if (!utf8_to_sys(work, strbuf, buflen)) {
 464                         msg_print("·Ù¹ð:Ê¸»ú¥³¡¼¥É¤ÎÊÑ´¹¤Ë¼ºÇÔ¤·¤Þ¤·¤¿");
 465                         msg_print(NULL);
 466                 }
 467                 C_KILL(work, buflen, char);
 468         }
 469 }
 470
 471 #endif /* JP */