source/lib/kanji.c

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