source/lib/kanji.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Kanji Extensions
   5    Copyright (C) Andrew Tridgell 1992-1994
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21    Adding for Japanese language by <fujita@ainix.isac.co.jp> 1994.9.5
  22      and extend coding system to EUC/SJIS/JIS/HEX at 1994.10.11
  23      and add all jis codes sequence type at 1995.8.16
  24      Notes: Hexadecimal code by <ohki@gssm.otuka.tsukuba.ac.jp>
  25 */
  26 #ifdef KANJI
  27
  28 #define _KANJI_C_
  29 #include "includes.h"
  30
  31 /* coding system keep in */
  32 int coding_system = SJIS_CODE;
  33
  34 /* jis si/so sequence */
  35 char jis_kso = JIS_KSO;
  36 char jis_ksi = JIS_KSI;
  37 char hex_tag = HEXTAG;
  38
  39 /*******************************************************************
  40   SHIFT JIS functions
  41 ********************************************************************/
  42 /*******************************************************************
  43  search token from S1 separated any char of S2
  44  S1 contain SHIFT JIS chars.
  45 ********************************************************************/
  46 char *
  47 sj_strtok (char *s1, const char *s2)
  48 {
  49     static char *s = NULL;
  50     char *q;
  51     if (!s1) {
  52         if (!s) {
  53             return NULL;
  54         }
  55         s1 = s;
  56     }
  57     for (q = s1; *s1; ) {
  58         if (is_shift_jis (*s1)) {
  59             s1 += 2;
  60         } else if (is_kana (*s1)) {
  61             s1++;
  62         } else {
  63             char *p = strchr (s2, *s1);
  64             if (p) {
  65                 if (s1 != q) {
  66                     s = s1 + 1;
  67                     *s1 = '\0';
  68                     return q;
  69                 }
  70                 q = s1 + 1;
  71             }
  72             s1++;
  73         }
  74     }
  75     s = NULL;
  76     if (*q) {
  77         return q;
  78     }
  79     return NULL;
  80 }
  81
  82 /*******************************************************************
  83  search string S2 from S1
  84  S1 contain SHIFT JIS chars.
  85 ********************************************************************/
  86 char *
  87 sj_strstr (const char *s1, const char *s2)
  88 {
  89     register int len = strlen ((char *) s2);
  90     if (!*s2)
  91         return (char *) s1;
  92     for (;*s1;) {
  93         if (*s1 == *s2) {
  94             if (strncmp (s1, s2, len) == 0)
  95                 return (char *) s1;
  96         }
  97         if (is_shift_jis (*s1)) {
  98             s1 += 2;
  99         } else {
 100             s1++;
 101         }
 102     }
 103     return 0;
 104 }
 105
 106 /*******************************************************************
 107  Search char C from beginning of S.
 108  S contain SHIFT JIS chars.
 109 ********************************************************************/
 110 char *
 111 sj_strchr (const char *s, int c)
 112 {
 113     for (; *s; ) {
 114         if (*s == c)
 115             return (char *) s;
 116         if (is_shift_jis (*s)) {
 117             s += 2;
 118         } else {
 119             s++;
 120         }
 121     }
 122     return 0;
 123 }
 124
 125 /*******************************************************************
 126  Search char C end of S.
 127  S contain SHIFT JIS chars.
 128 ********************************************************************/
 129 char *
 130 sj_strrchr (const char *s, int c)
 131 {
 132     register char *q;
 133
 134     for (q = 0; *s; ) {
 135         if (*s == c) {
 136             q = (char *) s;
 137         }
 138         if (is_shift_jis (*s)) {
 139             s += 2;
 140         } else {
 141             s++;
 142         }
 143     }
 144     return q;
 145 }
 146
 147 /*******************************************************************
 148   Code conversion
 149 ********************************************************************/
 150 /* convesion buffer */
 151 static char cvtbuf[1024];
 152
 153 /*******************************************************************
 154   EUC <-> SJIS
 155 ********************************************************************/
 156 static int
 157 euc2sjis (register int hi, register int lo)
 158 {
 159     if (hi & 1)
 160         return ((hi / 2 + (hi < 0xdf ? 0x31 : 0x71)) << 8) |
 161             (lo - (lo >= 0xe0 ? 0x60 : 0x61));
 162     else
 163         return ((hi / 2 + (hi < 0xdf ? 0x30 : 0x70)) << 8) | (lo - 2);
 164 }
 165
 166 static int
 167 sjis2euc (register int hi, register int lo)
 168 {
 169     if (lo >= 0x9f)
 170         return ((hi * 2 - (hi >= 0xe0 ? 0xe0 : 0x60)) << 8) | (lo + 2);
 171     else
 172         return ((hi * 2 - (hi >= 0xe0 ? 0xe1 : 0x61)) << 8) |
 173             (lo + (lo >= 0x7f ? 0x60 : 0x61));
 174 }
 175
 176 /*******************************************************************
 177  Convert FROM contain SHIFT JIS codes to EUC codes
 178  return converted buffer
 179 ********************************************************************/
 180 static char *
 181 sj_to_euc (const char *from, BOOL overwrite)
 182 {
 183     register char *out;
 184     char *save;
 185
 186     save = (char *) from;
 187     for (out = cvtbuf; *from;) {
 188         if (is_shift_jis (*from)) {
 189             int code = sjis2euc ((int) from[0] & 0xff, (int) from[1] & 0xff);
 190             *out++ = (code >> 8) & 0xff;
 191             *out++ = code;
 192             from += 2;
 193         } else if (is_kana (*from)) {
 194             *out++ = euc_kana;
 195             *out++ = *from++;
 196         } else {
 197             *out++ = *from++;
 198         }
 199     }
 200     *out = 0;
 201     if (overwrite) {
 202         strcpy((char *) save, (char *) cvtbuf);
 203         return (char *) save;
 204     } else {
 205         return cvtbuf;
 206     }
 207 }
 208
 209 /*******************************************************************
 210  Convert FROM contain EUC codes to SHIFT JIS codes
 211  return converted buffer
 212 ********************************************************************/
 213 static char *
 214 euc_to_sj (const char *from, BOOL overwrite)
 215 {
 216     register char *out;
 217     char *save;
 218
 219     save = (char *) from;
 220     for (out = cvtbuf; *from; ) {
 221         if (is_euc (*from)) {
 222             int code = euc2sjis ((int) from[0] & 0xff, (int) from[1] & 0xff);
 223             *out++ = (code >> 8) & 0xff;
 224             *out++ = code;
 225             from += 2;
 226         } else if (is_euc_kana (*from)) {
 227             *out++ = from[1];
 228             from += 2;
 229         } else {
 230             *out++ = *from++;
 231         }
 232     }
 233     *out = 0;
 234     if (overwrite) {
 235         strcpy(save, (char *) cvtbuf);
 236         return save;
 237     } else {
 238         return cvtbuf;
 239     }
 240 }
 241
 242 /*******************************************************************
 243   JIS7,JIS8,JUNET <-> SJIS
 244 ********************************************************************/
 245 static int
 246 sjis2jis (register int hi, register int lo)
 247 {
 248     if (lo >= 0x9f)
 249         return ((hi * 2 - (hi >= 0xe0 ? 0x160 : 0xe0)) << 8) | (lo - 0x7e);
 250     else
 251         return ((hi * 2 - (hi >= 0xe0 ? 0x161 : 0xe1)) << 8) |
 252             (lo - (lo >= 0x7f ? 0x20 : 0x1f));
 253 }
 254
 255 static int
 256 jis2sjis (register int hi, register int lo)
 257 {
 258     if (hi & 1)
 259         return ((hi / 2 + (hi < 0x5f ? 0x71 : 0xb1)) << 8) |
 260             (lo + (lo >= 0x60 ? 0x20 : 0x1f));
 261     else
 262         return ((hi / 2 + (hi < 0x5f ? 0x70 : 0xb0)) << 8) | (lo + 0x7e);
 263 }
 264
 265 /*******************************************************************
 266  Convert FROM contain JIS codes to SHIFT JIS codes
 267  return converted buffer
 268 ********************************************************************/
 269 static char *
 270 jis8_to_sj (const char *from, BOOL overwrite)
 271 {
 272     register char *out;
 273     register int shifted;
 274     char *save;
 275
 276     shifted = _KJ_ROMAN;
 277     save = (char *) from;
 278     for (out = cvtbuf; *from;) {
 279         if (is_esc (*from)) {
 280             if (is_so1 (from[1]) && is_so2 (from[2])) {
 281                 shifted = _KJ_KANJI;
 282                 from += 3;
 283             } else if (is_si1 (from[1]) && is_si2 (from[2])) {
 284                 shifted = _KJ_ROMAN;
 285                 from += 3;
 286             } else {                    /* sequence error */
 287                 goto normal;
 288             }
 289         } else {
 290         normal:
 291             switch (shifted) {
 292             default:
 293             case _KJ_ROMAN:
 294                 *out++ = *from++;
 295                 break;
 296             case _KJ_KANJI:
 297                 {
 298                     int code = jis2sjis ((int) from[0] & 0xff, (int) from[1] & 0xff);
 299                     *out++ = (code >> 8) & 0xff;
 300                     *out++ = code;
 301                     from += 2;
 302                 }
 303                 break;
 304             }
 305         }
 306     }
 307     *out = 0;
 308     if (overwrite) {
 309         strcpy (save, (char *) cvtbuf);
 310         return save;
 311     } else {
 312         return cvtbuf;
 313     }
 314 }
 315
 316 /*******************************************************************
 317  Convert FROM contain SHIFT JIS codes to JIS codes
 318  return converted buffer
 319 ********************************************************************/
 320 static char *
 321 sj_to_jis8 (const char *from, BOOL overwrite)
 322 {
 323     register char *out;
 324     register int shifted;
 325     char *save;
 326
 327     shifted = _KJ_ROMAN;
 328     save = (char *) from;
 329     for (out = cvtbuf; *from; ) {
 330         if (is_shift_jis (*from)) {
 331             int code;
 332             switch (shifted) {
 333             case _KJ_ROMAN:             /* to KANJI */
 334                 *out++ = jis_esc;
 335                 *out++ = jis_so1;
 336                 *out++ = jis_kso;
 337                 shifted = _KJ_KANJI;
 338                 break;
 339             }
 340             code = sjis2jis ((int) from[0] & 0xff, (int) from[1] & 0xff);
 341             *out++ = (code >> 8) & 0xff;
 342             *out++ = code;
 343             from += 2;
 344         } else {
 345             switch (shifted) {
 346             case _KJ_KANJI:             /* to ROMAN/KANA */
 347                 *out++ = jis_esc;
 348                 *out++ = jis_si1;
 349                 *out++ = jis_ksi;
 350                 shifted = _KJ_ROMAN;
 351                 break;
 352             }
 353             *out++ = *from++;
 354         }
 355     }
 356     switch (shifted) {
 357     case _KJ_KANJI:                     /* to ROMAN/KANA */
 358         *out++ = jis_esc;
 359         *out++ = jis_si1;
 360         *out++ = jis_ksi;
 361         shifted = _KJ_ROMAN;
 362         break;
 363     }
 364     *out = 0;
 365     if (overwrite) {
 366         strcpy (save, (char *) cvtbuf);
 367         return save;
 368     } else {
 369         return cvtbuf;
 370     }
 371 }
 372
 373 /*******************************************************************
 374  Convert FROM contain 7 bits JIS codes to SHIFT JIS codes
 375  return converted buffer
 376 ********************************************************************/
 377 static char *
 378 jis7_to_sj (const char *from, BOOL overwrite)
 379 {
 380     register char *out;
 381     register int shifted;
 382     char *save;
 383
 384     shifted = _KJ_ROMAN;
 385     save = (char *) from;
 386     for (out = cvtbuf; *from;) {
 387         if (is_esc (*from)) {
 388             if (is_so1 (from[1]) && is_so2 (from[2])) {
 389                 shifted = _KJ_KANJI;
 390                 from += 3;
 391             } else if (is_si1 (from[1]) && is_si2 (from[2])) {
 392                 shifted = _KJ_ROMAN;
 393                 from += 3;
 394             } else {                    /* sequence error */
 395                 goto normal;
 396             }
 397         } else if (is_so (*from)) {
 398             shifted = _KJ_KANA;         /* to KANA */
 399             from++;
 400         } else if (is_si (*from)) {
 401             shifted = _KJ_ROMAN;        /* to ROMAN */
 402             from++;
 403         } else {
 404         normal:
 405             switch (shifted) {
 406             default:
 407             case _KJ_ROMAN:
 408                 *out++ = *from++;
 409                 break;
 410             case _KJ_KANJI:
 411                 {
 412                     int code = jis2sjis ((int) from[0] & 0xff, (int) from[1] & 0xff);
 413                     *out++ = (code >> 8) & 0xff;
 414                     *out++ = code;
 415                     from += 2;
 416                 }
 417                 break;
 418             case _KJ_KANA:
 419                 *out++ = ((int) from[0]) + 0x80;
 420                 break;
 421             }
 422         }
 423     }
 424     *out = 0;
 425     if (overwrite) {
 426         strcpy (save, (char *) cvtbuf);
 427         return save;
 428     } else {
 429         return cvtbuf;
 430     }
 431 }
 432
 433 /*******************************************************************
 434  Convert FROM contain SHIFT JIS codes to 7 bits JIS codes
 435  return converted buffer
 436 ********************************************************************/
 437 static char *
 438 sj_to_jis7 (const char *from, BOOL overwrite)
 439 {
 440     register char *out;
 441     register int shifted;
 442     char *save;
 443
 444     shifted = _KJ_ROMAN;
 445     save = (char *) from;
 446     for (out = cvtbuf; *from; ) {
 447         if (is_shift_jis (*from)) {
 448             int code;
 449             switch (shifted) {
 450             case _KJ_KANA:
 451                 *out++ = jis_si;        /* to ROMAN and through down */
 452             case _KJ_ROMAN:             /* to KANJI */
 453                 *out++ = jis_esc;
 454                 *out++ = jis_so1;
 455                 *out++ = jis_kso;
 456                 shifted = _KJ_KANJI;
 457                 break;
 458             }
 459             code = sjis2jis ((int) from[0] & 0xff, (int) from[1] & 0xff);
 460             *out++ = (code >> 8) & 0xff;
 461             *out++ = code;
 462             from += 2;
 463         } else if (is_kana (from[0])) {
 464             switch (shifted) {
 465             case _KJ_KANJI:             /* to ROMAN */
 466                 *out++ = jis_esc;
 467                 *out++ = jis_si1;
 468                 *out++ = jis_ksi;
 469             case _KJ_ROMAN:             /* to KANA */
 470                 *out++ = jis_so;
 471                 shifted = _KJ_KANA;
 472                 break;
 473             }
 474             *out++ = ((int) *from++) - 0x80;
 475         } else {
 476             switch (shifted) {
 477             case _KJ_KANA:
 478                 *out++ = jis_si;        /* to ROMAN */
 479                 shifted = _KJ_ROMAN;
 480                 break;
 481             case _KJ_KANJI:             /* to ROMAN */
 482                 *out++ = jis_esc;
 483                 *out++ = jis_si1;
 484                 *out++ = jis_ksi;
 485                 shifted = _KJ_ROMAN;
 486                 break;
 487             }
 488             *out++ = *from++;
 489         }
 490     }
 491     switch (shifted) {
 492     case _KJ_KANA:
 493         *out++ = jis_si;                /* to ROMAN */
 494         break;
 495     case _KJ_KANJI:                     /* to ROMAN */
 496         *out++ = jis_esc;
 497         *out++ = jis_si1;
 498         *out++ = jis_ksi;
 499         break;
 500     }
 501     *out = 0;
 502     if (overwrite) {
 503         strcpy (save, (char *) cvtbuf);
 504         return save;
 505     } else {
 506         return cvtbuf;
 507     }
 508 }
 509
 510 /*******************************************************************
 511  Convert FROM contain 7 bits JIS(junet) codes to SHIFT JIS codes
 512  return converted buffer
 513 ********************************************************************/
 514 static char *
 515 junet_to_sj (const char *from, BOOL overwrite)
 516 {
 517     register char *out;
 518     register int shifted;
 519     char *save;
 520
 521     shifted = _KJ_ROMAN;
 522     save = (char *) from;
 523     for (out = cvtbuf; *from;) {
 524         if (is_esc (*from)) {
 525             if (is_so1 (from[1]) && is_so2 (from[2])) {
 526                 shifted = _KJ_KANJI;
 527                 from += 3;
 528             } else if (is_si1 (from[1]) && is_si2 (from[2])) {
 529                 shifted = _KJ_ROMAN;
 530                 from += 3;
 531             } else if (is_juk1(from[1]) && is_juk2 (from[2])) {
 532                 shifted = _KJ_KANA;
 533                 from += 3;
 534             } else {                    /* sequence error */
 535                 goto normal;
 536             }
 537         } else {
 538         normal:
 539             switch (shifted) {
 540             default:
 541             case _KJ_ROMAN:
 542                 *out++ = *from++;
 543                 break;
 544             case _KJ_KANJI:
 545                 {
 546                     int code = jis2sjis ((int) from[0] & 0xff, (int) from[1] & 0xff);
 547                     *out++ = (code >> 8) & 0xff;
 548                     *out++ = code;
 549                     from += 2;
 550                 }
 551                 break;
 552             case _KJ_KANA:
 553                 *out++ = ((int) from[0]) + 0x80;
 554                 break;
 555             }
 556         }
 557     }
 558     *out = 0;
 559     if (overwrite) {
 560         strcpy (save, (char *) cvtbuf);
 561         return save;
 562     } else {
 563         return cvtbuf;
 564     }
 565 }
 566
 567 /*******************************************************************
 568  Convert FROM contain SHIFT JIS codes to 7 bits JIS(junet) codes
 569  return converted buffer
 570 ********************************************************************/
 571 static char *
 572 sj_to_junet (const char *from, BOOL overwrite)
 573 {
 574     register char *out;
 575     register int shifted;
 576     char *save;
 577
 578     shifted = _KJ_ROMAN;
 579     save = (char *) from;
 580     for (out = cvtbuf; *from; ) {
 581         if (is_shift_jis (*from)) {
 582             int code;
 583             switch (shifted) {
 584             case _KJ_KANA:
 585             case _KJ_ROMAN:             /* to KANJI */
 586                 *out++ = jis_esc;
 587                 *out++ = jis_so1;
 588                 *out++ = jis_so2;
 589                 shifted = _KJ_KANJI;
 590                 break;
 591             }
 592             code = sjis2jis ((int) from[0] & 0xff, (int) from[1] & 0xff);
 593             *out++ = (code >> 8) & 0xff;
 594             *out++ = code;
 595             from += 2;
 596         } else if (is_kana (from[0])) {
 597             switch (shifted) {
 598             case _KJ_KANJI:             /* to ROMAN */
 599             case _KJ_ROMAN:             /* to KANA */
 600                 *out++ = jis_esc;
 601                 *out++ = junet_kana1;
 602                 *out++ = junet_kana2;
 603                 shifted = _KJ_KANA;
 604                 break;
 605             }
 606             *out++ = ((int) *from++) - 0x80;
 607         } else {
 608             switch (shifted) {
 609             case _KJ_KANA:
 610             case _KJ_KANJI:             /* to ROMAN */
 611                 *out++ = jis_esc;
 612                 *out++ = jis_si1;
 613                 *out++ = jis_si2;
 614                 shifted = _KJ_ROMAN;
 615                 break;
 616             }
 617             *out++ = *from++;
 618         }
 619     }
 620     switch (shifted) {
 621     case _KJ_KANA:
 622     case _KJ_KANJI:                     /* to ROMAN */
 623         *out++ = jis_esc;
 624         *out++ = jis_si1;
 625         *out++ = jis_si2;
 626         break;
 627     }
 628     *out = 0;
 629     if (overwrite) {
 630         strcpy (save, (char *) cvtbuf);
 631         return save;
 632     } else {
 633         return cvtbuf;
 634     }
 635 }
 636
 637 /*******************************************************************
 638   HEX <-> SJIS
 639 ********************************************************************/
 640 /* ":xx" -> a byte */
 641 static char *
 642 hex_to_sj (const char *from, BOOL overwrite)
 643 {
 644     char *sp, *dp;
 645
 646     sp = (char *) from;
 647     dp = cvtbuf;
 648     while (*sp) {
 649         if (*sp == hex_tag && isxdigit (sp[1]) && isxdigit (sp[2])) {
 650             *dp++ = (hex2bin (sp[1])<<4) | (hex2bin (sp[2]));
 651             sp += 3;
 652         } else
 653             *dp++ = *sp++;
 654     }
 655     *dp = '\0';
 656     if (overwrite) {
 657         strcpy ((char *) from, (char *) cvtbuf);
 658         return (char *) from;
 659     } else {
 660         return cvtbuf;
 661     }
 662 }
 663
 664 /*******************************************************************
 665   kanji/kana -> ":xx"
 666 ********************************************************************/
 667 static char *
 668 sj_to_hex (const char *from, BOOL overwrite)
 669 {
 670     unsigned char *sp, *dp;
 671
 672     sp = (unsigned char*) from;
 673     dp = (unsigned char*) cvtbuf;
 674     while (*sp) {
 675         if (is_kana(*sp)) {
 676             *dp++ = hex_tag;
 677             *dp++ = bin2hex (((*sp)>>4)&0x0f);
 678             *dp++ = bin2hex ((*sp)&0x0f);
 679             sp++;
 680         } else if (is_shift_jis (*sp) && is_shift_jis2 (sp[1])) {
 681             *dp++ = hex_tag;
 682             *dp++ = bin2hex (((*sp)>>4)&0x0f);
 683             *dp++ = bin2hex ((*sp)&0x0f);
 684             sp++;
 685             *dp++ = hex_tag;
 686             *dp++ = bin2hex (((*sp)>>4)&0x0f);
 687             *dp++ = bin2hex ((*sp)&0x0f);
 688             sp++;
 689         } else
 690             *dp++ = *sp++;
 691     }
 692     *dp = '\0';
 693     if (overwrite) {
 694         strcpy ((char *) from, (char *) cvtbuf);
 695         return (char *) from;
 696     } else {
 697         return cvtbuf;
 698     }
 699 }
 700
 701 /*******************************************************************
 702   kanji/kana -> ":xx"
 703 ********************************************************************/
 704 static char *
 705 sj_to_cap (const char *from, BOOL overwrite)
 706 {
 707     unsigned char *sp, *dp;
 708
 709     sp = (unsigned char*) from;
 710     dp = (unsigned char*) cvtbuf;
 711     while (*sp) {
 712         if (*sp >= 0x80) {
 713             *dp++ = hex_tag;
 714             *dp++ = bin2hex (((*sp)>>4)&0x0f);
 715             *dp++ = bin2hex ((*sp)&0x0f);
 716             sp++;
 717         } else {
 718             *dp++ = *sp++;
 719         }
 720     }
 721     *dp = '\0';
 722     if (overwrite) {
 723         strcpy ((char *) from, (char *) cvtbuf);
 724         return (char *) from;
 725     } else {
 726         return cvtbuf;
 727     }
 728 }
 729
 730 /*******************************************************************
 731  sj to sj
 732 ********************************************************************/
 733 static char *
 734 sj_to_sj (const char *from, BOOL overwrite)
 735 {
 736     if (!overwrite) {
 737         strcpy (cvtbuf, (char *) from);
 738         return cvtbuf;
 739     } else {
 740         return (char *) from;
 741     }
 742 }
 743
 744 /************************************************************************
 745  conversion:
 746  _dos_to_unix           _unix_to_dos
 747 ************************************************************************/
 748
 749 char* (*_dos_to_unix) (const char *str, BOOL overwrite) = sj_to_sj;
 750 char* (*_unix_to_dos) (const char *str, BOOL overwrite) = sj_to_sj;
 751
 752 static int
 753 setup_string_function (int codes)
 754 {
 755     switch (codes) {
 756     default:
 757     case SJIS_CODE:
 758         _dos_to_unix = sj_to_sj;
 759         _unix_to_dos = sj_to_sj;
 760
 761         break;
 762
 763     case EUC_CODE:
 764         _dos_to_unix = sj_to_euc;
 765         _unix_to_dos = euc_to_sj;
 766         break;
 767
 768     case JIS7_CODE:
 769         _dos_to_unix = sj_to_jis7;
 770         _unix_to_dos = jis7_to_sj;
 771         break;
 772
 773     case JIS8_CODE:
 774         _dos_to_unix = sj_to_jis8;
 775         _unix_to_dos = jis8_to_sj;
 776         break;
 777
 778     case JUNET_CODE:
 779         _dos_to_unix = sj_to_junet;
 780         _unix_to_dos = junet_to_sj;
 781         break;
 782
 783     case HEX_CODE:
 784         _dos_to_unix = sj_to_hex;
 785         _unix_to_dos = hex_to_sj;
 786         break;
 787
 788     case CAP_CODE:
 789         _dos_to_unix = sj_to_cap;
 790         _unix_to_dos = hex_to_sj;
 791         break;
 792     }
 793     return codes;
 794 }
 795
 796 /*
 797  * Interpret coding system.
 798  */
 799 int
 800 interpret_coding_system (char *str, int def)
 801 {
 802     int codes = def;
 803
 804     if (strequal (str, "sjis")) {
 805         codes = SJIS_CODE;
 806     } else if (strequal (str, "euc")) {
 807         codes = EUC_CODE;
 808     } else if (strequal (str, "cap")) {
 809         codes = CAP_CODE;
 810         hex_tag = HEXTAG;
 811     } else if (strequal (str, "hex")) {
 812         codes = HEX_CODE;
 813         hex_tag = HEXTAG;
 814     } else if (strncasecmp (str, "hex", 3)) {
 815         codes = HEX_CODE;
 816         hex_tag = (str[3] ? str[3] : HEXTAG);
 817     } else if (strequal (str, "j8bb")) {
 818         codes = JIS8_CODE;
 819         jis_kso = 'B';
 820         jis_ksi = 'B';
 821     } else if (strequal (str, "j8bj") || strequal (str, "jis8")) {
 822         codes = JIS8_CODE;
 823         jis_kso = 'B';
 824         jis_ksi = 'J';
 825     } else if (strequal (str, "j8bh")) {
 826         codes = JIS8_CODE;
 827         jis_kso = 'B';
 828         jis_ksi = 'H';
 829     } else if (strequal (str, "j8@b")) {
 830         codes = JIS8_CODE;
 831         jis_kso = '@';
 832         jis_ksi = 'B';
 833     } else if (strequal (str, "j8@j")) {
 834         codes = JIS8_CODE;
 835         jis_kso = '@';
 836         jis_ksi = 'J';
 837     } else if (strequal (str, "j8@h")) {
 838         codes = JIS8_CODE;
 839         jis_kso = '@';
 840         jis_ksi = 'H';
 841     } else if (strequal (str, "j7bb")) {
 842         codes = JIS7_CODE;
 843         jis_kso = 'B';
 844         jis_ksi = 'B';
 845     } else if (strequal (str, "j7bj") || strequal (str, "jis7")) {
 846         codes = JIS7_CODE;
 847         jis_kso = 'B';
 848         jis_ksi = 'J';
 849     } else if (strequal (str, "j7bh")) {
 850         codes = JIS7_CODE;
 851         jis_kso = 'B';
 852         jis_ksi = 'H';
 853     } else if (strequal (str, "j7@b")) {
 854         codes = JIS7_CODE;
 855         jis_kso = '@';
 856         jis_ksi = 'B';
 857     } else if (strequal (str, "j7@j")) {
 858         codes = JIS7_CODE;
 859         jis_kso = '@';
 860         jis_ksi = 'J';
 861     } else if (strequal (str, "j7@h")) {
 862         codes = JIS7_CODE;
 863         jis_kso = '@';
 864         jis_ksi = 'H';
 865     } else if (strequal (str, "jubb")) {
 866         codes = JUNET_CODE;
 867         jis_kso = 'B';
 868         jis_ksi = 'B';
 869     } else if (strequal (str, "jubj") || strequal (str, "junet")) {
 870         codes = JUNET_CODE;
 871         jis_kso = 'B';
 872         jis_ksi = 'J';
 873     } else if (strequal (str, "jubh")) {
 874         codes = JUNET_CODE;
 875         jis_kso = 'B';
 876         jis_ksi = 'H';
 877     } else if (strequal (str, "ju@b")) {
 878         codes = JUNET_CODE;
 879         jis_kso = '@';
 880         jis_ksi = 'B';
 881     } else if (strequal (str, "ju@j")) {
 882         codes = JUNET_CODE;
 883         jis_kso = '@';
 884         jis_ksi = 'J';
 885     } else if (strequal (str, "ju@h")) {
 886         codes = JUNET_CODE;
 887         jis_kso = '@';
 888         jis_ksi = 'H';
 889     }
 890     return setup_string_function (codes);
 891 }
 892 #else
 893 int kanji_dummy_procedure(void)
 894 {return 0;}
 895 #endif /* KANJI */