home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 July & August / Pcwk78a98.iso / Wtestowe / Clico / UNIX / SAMBA / SOURCE / SAMBA.TAR / samba-1.9.17 / source / kanji.c < prev    next >
C/C++ Source or Header  |  1997-05-08  |  21KB  |  895 lines
  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. #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 interpret_coding_system(char *str, int def)
  800. {
  801.     int codes = def;
  802.     
  803.     if (strequal (str, "sjis")) {
  804.     codes = SJIS_CODE;
  805.     } else if (strequal (str, "euc")) {
  806.     codes = EUC_CODE;
  807.     } else if (strequal (str, "cap")) {
  808.     codes = CAP_CODE;
  809.     hex_tag = HEXTAG;
  810.     } else if (strequal (str, "hex")) {
  811.     codes = HEX_CODE;
  812.     hex_tag = HEXTAG;
  813.     } else if (strncasecmp (str, "hex", 3)) {
  814.     codes = HEX_CODE;
  815.     hex_tag = (str[3] ? str[3] : HEXTAG);
  816.     } else if (strequal (str, "j8bb")) {
  817.     codes = JIS8_CODE;
  818.     jis_kso = 'B';
  819.     jis_ksi = 'B';
  820.     } else if (strequal (str, "j8bj") || strequal (str, "jis8")) {
  821.     codes = JIS8_CODE;
  822.     jis_kso = 'B';
  823.     jis_ksi = 'J';
  824.     } else if (strequal (str, "j8bh")) {
  825.     codes = JIS8_CODE;
  826.     jis_kso = 'B';
  827.     jis_ksi = 'H';
  828.     } else if (strequal (str, "j8@b")) {
  829.     codes = JIS8_CODE;
  830.     jis_kso = '@';
  831.     jis_ksi = 'B';
  832.     } else if (strequal (str, "j8@j")) {
  833.     codes = JIS8_CODE;
  834.     jis_kso = '@';
  835.     jis_ksi = 'J';
  836.     } else if (strequal (str, "j8@h")) {
  837.     codes = JIS8_CODE;
  838.     jis_kso = '@';
  839.     jis_ksi = 'H';
  840.     } else if (strequal (str, "j7bb")) {
  841.     codes = JIS7_CODE;
  842.     jis_kso = 'B';
  843.     jis_ksi = 'B';
  844.     } else if (strequal (str, "j7bj") || strequal (str, "jis7")) {
  845.     codes = JIS7_CODE;
  846.     jis_kso = 'B';
  847.     jis_ksi = 'J';
  848.     } else if (strequal (str, "j7bh")) {
  849.     codes = JIS7_CODE;
  850.     jis_kso = 'B';
  851.     jis_ksi = 'H';
  852.     } else if (strequal (str, "j7@b")) {
  853.     codes = JIS7_CODE;
  854.     jis_kso = '@';
  855.     jis_ksi = 'B';
  856.     } else if (strequal (str, "j7@j")) {
  857.     codes = JIS7_CODE;
  858.     jis_kso = '@';
  859.     jis_ksi = 'J';
  860.     } else if (strequal (str, "j7@h")) {
  861.     codes = JIS7_CODE;
  862.     jis_kso = '@';
  863.     jis_ksi = 'H';
  864.     } else if (strequal (str, "jubb")) {
  865.     codes = JUNET_CODE;
  866.     jis_kso = 'B';
  867.     jis_ksi = 'B';
  868.     } else if (strequal (str, "jubj") || strequal (str, "junet")) {
  869.     codes = JUNET_CODE;
  870.     jis_kso = 'B';
  871.     jis_ksi = 'J';
  872.     } else if (strequal (str, "jubh")) {
  873.     codes = JUNET_CODE;
  874.     jis_kso = 'B';
  875.     jis_ksi = 'H';
  876.     } else if (strequal (str, "ju@b")) {
  877.     codes = JUNET_CODE;
  878.     jis_kso = '@';
  879.     jis_ksi = 'B';
  880.     } else if (strequal (str, "ju@j")) {
  881.     codes = JUNET_CODE;
  882.     jis_kso = '@';
  883.     jis_ksi = 'J';
  884.     } else if (strequal (str, "ju@h")) {
  885.     codes = JUNET_CODE;
  886.     jis_kso = '@';
  887.     jis_ksi = 'H';
  888.     }    
  889.     return setup_string_function (codes);
  890. }
  891. #else 
  892.  int kanji_dummy_procedure(void)
  893. {return 0;}
  894. #endif /* KANJI */
  895.