开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
jis.c
资源名称：3.0-20000220-SNAP.tar.gz　[点击查看]
上传用户：minyiyu
上传日期：2018-12-24
资源大小：864k
文件大小：25k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

jis.c：源码内容
  1. /*
  2. Program: JIS.C
  3. Version: 2.2
  4. Date:    January 1, 1992
  5. Author:  Ken R. Lunde, Adobe Systems Incorporated
  6.   EMAIL: lunde@adobe.com
  7.   MAIL : 1585 Charleston Road, P.O. Box 7900, Mountain View, CA 94039-7900
  8. Type:    A utility for converting the kanji code of Japanese textfiles.
  9. Code:    ANSI C (portable)
  10.  
  11. PORTABILITY:
  12. This source code was written so that it would be portable on C compilers which
  13. conform to the ANSI C standard. It has been tested on the following compilers:
  14. THINK C (Macintosh), Vax C, Convex's C, Turbo C, and GNU C.
  15.  
  16. There are 4 lines which have been commented out. These lines of code are
  17. necessary to develop a program which handles command-line arguments on a
  18. Macintosh. I used THINK C as my development platform. I left these lines in
  19. so that it would be easier to enhance/debug the program later. For those of
  20. you who wish to use this program on the Macintosh, simply delete the comments
  21. from those 4 lines of code, add the ANSI library to the THINK C project, and
  22. then build the application. You then have a double-clickable application,
  23. which when launched, will greet you with a Macintosh-style interface.
  24.  
  25. DISTRIBUTION AND RESTRICTIONS ON USAGE:
  26.  1) Please give this source code away to your friends at no charge.
  27.  2) Please try to compile this source code on various platforms to check for
  28.     portablity, and please report back to me with any results be they good or
  29.     bad. Suggestions are always welcome.
  30.  3) Only use this program on a copy of a file -- do not use an original. This
  31.     is just common sense.
  32.  4) This source code or a compiled version may be bundled with commercial
  33.     software as long as the author is notified beforehand. The author's name
  34.     should also be mentioned in the credits.
  35.  5) Feel free to use any of the algorithms for your own work. Many of them are
  36.     being used in other programs I have written.
  37.  6) The most current version can be obtained through FTP at ucdavis.edu
  38.     (128.120.2.1) in the pub/JIS/C directory, or by requesting a copy
  39.     directly from me.
  40.  
  41. DESCRIPTION:
  42.  1) Supports Shift-JIS, EUC, New-JIS, Old-JIS, and NEC-JIS for both input and
  43.     output.
  44.  2) Automatically detects input file's kanji code. There is only one thing
  45.     which will make this fail: a Shift-JIS file which only contains half-size
  46.     katakana (remedy: insert a kanji anywhere in the file).
  47.  3) The ability to convert half-size katakana in Shift-JIS and EUC into full-
  48.     size equivalents. Note that half-size katakana includes other symbols such
  49.     as a Japanese period, Japanese comma, center dot, etc.
  50.  4) Supports conversion between the same code (i.e., EUC -> EUC, Shift-JIS ->
  51.     Shift-JIS, etc.). This is useful as a filter for converting half-size
  52.     katakana to their full-size equivalents.
  53.  5) If the input file does not contain any Japanese, then the input file's
  54.     contents are simply echoed to the output file. This adds reliability in
  55.     case this program were used as a filter for incoming/outgoing mail.
  56.  
  57. OPERATION:
  58.  1) The UNIX-style command-line is
  59.  
  60.     jis [-kanji-code] [-half-to-full] [infile] [outfile]
  61.  
  62.     The [-kanji-code] and [-half-to-full] flags can be in any order, but MUST
  63.     come before the file names (if used). Note that [infile] and [outfile] can
  64.     be replaced by redirecting stdin/stdout on UNIX systems.
  65.  2) The [-kanji-code] flag, which determines the outfile's kanji code, can be
  66.     1 of 5 possible values:
  67.  
  68.     -j    =    New-JIS (.new)
  69.     -o    =    Old-JIS (.old)
  70.     -n    =    NEC-JIS (.nec)
  71.     -e    =    EUC (.euc)
  72.     -s    =    Shift-JIS (.sjs)
  73.  
  74.     Upper- and lower-case are acceptable. The default kanji code flag (if the
  75.     user doesn't select one) is -s (Shift-JIS).
  76.  3) The [-half-to-full] flag, which determines whether to convert half-size
  77.     katakana to their full-size counterparts, can be indicated by -f. The
  78.     default is to NOT convert half-size katakana, but if the output file is
  79.     in New-JIS, Old-JIS, or NEC-JIS, ALL half-size katakana will be converted
  80.     to their full-size counterparts (necessary, since those 3 7-bit codes do
  81.     not support half-size katakana). Again, upper- and lower-case are
  82.     acceptable.
  83.  4) The [infile] field is optional as one can redirect stdin and stdout.
  84.  5) The [outfile] field is also optional. If no [outfile] field is specified,
  85.     the program will semi-intelligently change the file's name. The program
  86.     simply scans the [outfile] field, finds the last period in it, terminates
  87.     the string at that point, and tacks on one of 5 possible extensions (they
  88.     are listed under (2 above). Here are some example command lines, and the
  89.     resulting outfile names:
  90.  
  91.     a) jis -e sig.jpn                     = sig.euc
  92.     b) jis sig.jpn                        = sig.sjs (defaulted to Shift-JIS)
  93.     c) jis -j sig.jpn.txt                 = sig.jpn.new
  94.     d) jis -o sig                         = sig.old
  95.  
  96.     This is very useful for MS-DOS users since a filename such as sig.jpn.new
  97.     will not result in converting a file called sig.jpn.
  98.  
  99.     Also note that if the outfile and infile have the same name, the program
  100.     will not work, and data will be lost. I tried to build safe-guards against
  101.     this. For example, note how my program will change the outfile name so
  102.     that it does not overwrite the infile:
  103.     
  104.     a) jis -f sig.sjs                     = sig-.sjs
  105.     b) jis -f sig.sjs sig.sjs             = sig-.sjs
  106.     c) jis sig-.sjs                       = sig--.sjs
  107.     
  108.     If only the [infile] is given, a hyphen is inserted after the last period,
  109.     and the extension is then reattached. If the outfile is specified by the
  110.     user, then it will search for the last period (if any), attach a hyphen,
  111.     and finally attach the proper extension). This sort of protection is NOT
  112.     available from this program if stdin/stdout are used.
  113. */
  114.  
  115. /* #include <console.h>
  116. #include <stdlib.h> */
  117. #include <stdio.h>
  118. #include <string.h>
  119.  
  120. #define NOT_SET     0
  121. #define SET         1
  122. #define NEW         1
  123. #define OLD         2
  124. #define NEC         3
  125. #define EUC         4
  126. #define SJIS        5
  127. #define NEW_KI      "$B"
  128. #define OLD_KI      "$@"
  129. #define NEC_KI      "K"
  130. #define NEW_KO      "(J"
  131. #define OLD_KO      "(J"
  132. #define NEC_KO      "H"
  133. #define NUL         0
  134. #define NL          10
  135. #define FF          12
  136. #define CR          13
  137. #define ESC         27
  138. #define TRUE        1
  139. #define FALSE       0
  140. #define PERIOD      '.'
  141. #define SJIS1(A)    (((A >= 129) && (A <= 159)) || ((A >= 224) && (A <= 239)))
  142. #define SJIS2(A)    ((A >= 64) && (A <= 252))
  143. #define HANKATA(A)  ((A >= 161) && (A <= 223))
  144. #define ISEUC(A)    ((A >= 161) && (A <= 254))
  145. #define NOTEUC(A,B) (((A >= 129) && (A <= 159)) && ((B >= 64) && (B <= 160)))
  146. #define ISMARU(A)   ((A >= 202) && (A <= 206))
  147. #define ISNIGORI(A) (((A >= 182) && (A <= 196)) || ((A >= 202) && (A <= 206)))
  148.  
  149. void han2zen(FILE *in,int *ptr1,int *ptr2,int incode);
  150. void SkipESCSeq(FILE *in,int data,int *ptr);
  151. void sjis2jis(int *ptr1,int *ptr2);
  152. void jis2sjis(int *ptr1,int *ptr2);
  153. void echo2file(FILE *in,FILE *out);
  154. void shift2seven(FILE *in,FILE *out,int outcode,int incode);
  155. void shift2euc(FILE *in,FILE *out,int incode,int tofullsize);
  156. void euc2seven(FILE *in,FILE *out,int outcode,int incode);
  157. void euc2euc(FILE *in,FILE *out,int incode,int tofullsize);
  158. void shift2shift(FILE *in,FILE *out,int incode,int tofullsize);
  159. void euc2shift(FILE *in,FILE *out,int incode,int tofullsize);
  160. void seven2shift(FILE *in,FILE *out);
  161. void seven2euc(FILE *in,FILE *out);
  162. void seven2seven(FILE *in,FILE *out,int outcode);
  163. void KanjiIn(FILE *out,int data);
  164. void KanjiOut(FILE *out,int data);
  165. /* int ccommand(char ***p); */
  166. int DetectCodeType(FILE *in);
  167.  
  168. main(int argc,char **argv)
  169. {
  170.   FILE *in,*out;
  171.   char infilename[100],outfilename[100],extension[5];
  172.   int c,incode,tofullsize = FALSE,outcode = NOT_SET;
  173.  
  174. /*  argc = ccommand(&argv); */
  175.  
  176.   while ((--argc > 0 ) && ((*++argv)[0] == '-')) {
  177.     while (c = *++argv[0]) {
  178.       switch (c) {
  179.         case 'j' :
  180.         case 'J' :
  181.           outcode = NEW;
  182.           strcpy(extension,".new");
  183.           break;
  184.         case 'o' :
  185.         case 'O' :
  186.           outcode = OLD;
  187.           strcpy(extension,".old");
  188.           break;
  189.         case 'n' :
  190.         case 'N' :
  191.           outcode = NEC;
  192.           strcpy(extension,".nec");
  193.           break;
  194.         case 'e' :
  195.         case 'E' :
  196.           outcode = EUC;
  197.           strcpy(extension,".euc");
  198.           break;
  199.         case 's' :
  200.         case 'S' :
  201.           outcode = SJIS;
  202.           strcpy(extension,".sjs");
  203.           break;
  204.         case 'f' :
  205.         case 'F' :
  206.           tofullsize = TRUE;
  207.           break;
  208.         default :
  209.           break;
  210.       }
  211.     }
  212.   }
  213.   if (outcode == NOT_SET) {
  214.     outcode = SJIS;
  215.     strcpy(extension,".sjs");
  216.   }
  217.   if (argc == 0) {
  218.     in = stdin;
  219.     out = stdout;
  220.   }
  221.   else if (argc > 0) {
  222.     if (argc == 1) {
  223.       strcpy(infilename,*argv);
  224.       if (strchr(*argv,PERIOD) != NULL)
  225.         *strrchr(*argv,PERIOD) = '';
  226.       strcpy(outfilename,*argv);
  227.       strcat(outfilename,extension);
  228.       if (!strcmp(infilename,outfilename)) {
  229.         if (strchr(outfilename,PERIOD) != NULL)
  230.           *strrchr(outfilename,PERIOD) = '';
  231.         strcat(outfilename,"-");
  232.         strcat(outfilename,extension);
  233.       }
  234.     }
  235.     else if (argc > 1) {
  236.       strcpy(infilename,*argv);
  237.       strcpy(outfilename,*++argv);
  238.       if (!strcmp(infilename,outfilename)) {
  239.         if (strchr(outfilename,PERIOD) != NULL)
  240.           *strrchr(outfilename,PERIOD) = '';
  241.         strcat(outfilename,"-");
  242.         strcat(outfilename,extension);
  243.       }
  244.     }
  245.     if ((in = fopen(infilename,"r")) == NULL) {
  246.       printf("nCannot open %sn",infilename);
  247.       exit(1);
  248.     }
  249.     if ((out = fopen(outfilename,"w")) == NULL) {
  250.       printf("nCannot open %sn",outfilename);
  251.       exit(1);
  252.     }
  253.   }
  254.   incode = DetectCodeType(in);
  255.   rewind(in);
  256.   switch (incode) {
  257.     case NOT_SET :
  258.       echo2file(in,out);
  259.       break;
  260.     case NEW :
  261.     case OLD :
  262.     case NEC :
  263.       switch (outcode) {
  264.         case NEW :
  265.         case OLD :
  266.         case NEC :
  267.           seven2seven(in,out,outcode);
  268.           break;
  269.         case EUC :
  270.           seven2euc(in,out);
  271.           break;
  272.         case SJIS :
  273.           seven2shift(in,out);
  274.           break;
  275.       }
  276.       break;
  277.     case EUC :
  278.       switch (outcode) {
  279.         case NEW :
  280.         case OLD :
  281.         case NEC :
  282.           euc2seven(in,out,outcode,incode);
  283.           break;
  284.         case EUC :
  285.           euc2euc(in,out,incode,tofullsize);
  286.           break;
  287.         case SJIS :
  288.           euc2shift(in,out,incode,tofullsize);
  289.           break;
  290.       }
  291.       break;
  292.     case SJIS :
  293.       switch (outcode) {
  294.         case NEW :
  295.         case OLD :
  296.         case NEC :
  297.           shift2seven(in,out,outcode,incode);
  298.           break;
  299.         case EUC :
  300.           shift2euc(in,out,incode,tofullsize);
  301.           break;
  302.         case SJIS :
  303.           shift2shift(in,out,incode,tofullsize);
  304.           break;
  305.       }
  306.       break;
  307.   }
  308.   exit(0);
  309. }
  310.  
  311. void SkipESCSeq(FILE *in,int temp,int *shifted_in)
  312. {
  313.   if ((temp == '$') || (temp == '('))
  314.     getc(in);
  315.   if ((temp == 'K') || (temp == '$'))
  316.     *shifted_in = TRUE;
  317.   else
  318.     *shifted_in = FALSE;
  319. }
  320.  
  321. void KanjiIn(FILE *out,int outcode)
  322. {
  323.   switch (outcode) {
  324.     case NEW :
  325.       fprintf(out,"%c%s",ESC,NEW_KI);
  326.       break;
  327.     case OLD :
  328.       fprintf(out,"%c%s",ESC,OLD_KI);
  329.       break;
  330.     case NEC :
  331.       fprintf(out,"%c%s",ESC,NEC_KI);
  332.       break;
  333.   }
  334. }
  335.  
  336. void KanjiOut(FILE *out,int outcode)
  337. {
  338.   switch (outcode) {
  339.     case NEW :
  340.       fprintf(out,"%c%s",ESC,NEW_KO);
  341.       break;
  342.     case OLD :
  343.       fprintf(out,"%c%s",ESC,OLD_KO);
  344.       break;
  345.     case NEC :
  346.       fprintf(out,"%c%s",ESC,NEC_KO);
  347.       break;
  348.   }
  349. }
  350.  
  351. void sjis2jis(int *p1, int *p2)
  352. {
  353. register unsigned char c1 = *p1;
  354. register unsigned char c2 = *p2;
  355. register int adjust = c2 < 159;
  356. register int rowOffset = c1 < 160 ? 112 : 176;
  357. register int cellOffset = adjust ? (31 + (c2 > 127)) : 126;
  358.  
  359. *p1 = ((c1 - rowOffset) << 1) - adjust;
  360. *p2 -= cellOffset;
  361. }
  362.  
  363. void jis2sjis(int *p1, int *p2)
  364. {
  365. register unsigned char c1 = *p1;
  366. register unsigned char c2 = *p2;
  367. register int rowOffset = c1 < 95 ? 112 : 176;
  368. register int cellOffset = c1 % 2 ? 31 + (c2 > 95) : 126;
  369.  
  370. *p1 = ((c1 + 1) >> 1) + rowOffset;
  371. *p2 = c2 + cellOffset;
  372. }
  373.  
  374. void echo2file(FILE *in,FILE *out)
  375. {
  376.   int p1;
  377.  
  378.   while ((p1 = getc(in)) != EOF)
  379.     fprintf(out,"%c",p1);
  380. }
  381.  
  382. void shift2seven(FILE *in,FILE *out,int outcode,int incode)
  383. {
  384.   int shifted_in,p1,p2;
  385.   
  386.   shifted_in = FALSE;
  387.   while ((p1 = getc(in)) != EOF) {
  388.     switch (p1) {
  389.       case NUL :
  390.       case FF :
  391.         break;
  392.       case CR :
  393.       case NL :
  394.         if (shifted_in) {
  395.           shifted_in = FALSE;
  396.           KanjiOut(out,outcode);
  397.         }
  398.         fprintf(out,"%c",NL);
  399.         break;
  400.       default :
  401.         if SJIS1(p1) {
  402.           p2 = getc(in);
  403.           if SJIS2(p2) {
  404.             sjis2jis(&p1,&p2);
  405.             if (!shifted_in) {
  406.               shifted_in = TRUE;
  407.               KanjiIn(out,outcode);
  408.             }
  409.           }
  410.           fprintf(out,"%c%c",p1,p2);
  411.         }
  412.         else if HANKATA(p1) {
  413.           han2zen(in,&p1,&p2,incode);
  414.           sjis2jis(&p1,&p2);
  415.           if (!shifted_in) {
  416.             shifted_in = TRUE;
  417.             KanjiIn(out,outcode);
  418.           }
  419.           fprintf(out,"%c%c",p1,p2);
  420.         }
  421.         else {
  422.           if (shifted_in) {
  423.             shifted_in = FALSE;
  424.             KanjiOut(out,outcode);
  425.           }
  426.           fprintf(out,"%c",p1);
  427.         }
  428.         break;
  429.     }
  430.   }
  431.   if (shifted_in)
  432.     KanjiOut(out,outcode);
  433. }
  434.  
  435. void shift2euc(FILE *in,FILE *out,int incode,int tofullsize)
  436. {
  437.   int p1,p2;
  438.   while ((p1 = getc(in)) != EOF) {
  439. printf("%c",p1);
  440.     switch (p1) {
  441.       case CR :
  442.       case NL :
  443.         fprintf(out,"%c",NL);
  444.         break;
  445.       case NUL :
  446.       case FF :
  447.         break;
  448.       default :
  449.         if SJIS1(p1) {
  450.           p2 = getc(in);
  451.           if SJIS2(p2) {
  452.             sjis2jis(&p1,&p2);
  453.             p1 += 128;
  454.             p2 += 128;
  455.           }
  456.           fprintf(out,"%c%c",p1,p2);
  457.         }
  458.         else if HANKATA(p1) {
  459.           if (tofullsize) {
  460.             han2zen(in,&p1,&p2,incode);
  461.             sjis2jis(&p1,&p2);
  462.             p1 += 128;
  463.             p2 += 128;
  464.           }
  465.           else {
  466.             p2 = p1;
  467.             p1 = 142;
  468.           }
  469.           fprintf(out,"%c%c",p1,p2);
  470.         }
  471.         else {
  472.           fprintf(out,"%c",p1);
  473.         }
  474.         break;
  475.     }
  476.   }
  477. }
  478.  
  479. void euc2seven(FILE *in,FILE *out,int outcode,int incode)
  480. {
  481.   int shifted_in,p1,p2;
  482.  
  483.   shifted_in = FALSE;
  484.   while ((p1 = getc(in)) != EOF) {
  485.     switch (p1) {
  486.       case NL :
  487.         if (shifted_in) {
  488.           shifted_in = FALSE;
  489.           KanjiOut(out,outcode);
  490.         }
  491.         fprintf(out,"%c",p1);
  492.         break;
  493.       case FF :
  494.         break;
  495.       default :
  496.         if ISEUC(p1) {
  497.           p2 = getc(in);
  498.           if ISEUC(p2) {
  499.             p1 -= 128;
  500.             p2 -= 128;
  501.             if (!shifted_in) {
  502.               shifted_in = TRUE;
  503.               KanjiIn(out,outcode);
  504.             }
  505.           }
  506.           fprintf(out,"%c%c",p1,p2);
  507.         }
  508.         else if (p1 == 142) {
  509.           p2 = getc(in);
  510.           if HANKATA(p2) {
  511.             p1 = p2;
  512.             han2zen(in,&p1,&p2,incode);
  513.             sjis2jis(&p1,&p2);
  514.             if (!shifted_in) {
  515.               shifted_in = TRUE;
  516.               KanjiIn(out,outcode);
  517.             }
  518.           }
  519.           fprintf(out,"%c%c",p1,p2);
  520.         }
  521.         else {
  522.           if (shifted_in) {
  523.             shifted_in = FALSE;
  524.             KanjiOut(out,outcode);
  525.           }
  526.           fprintf(out,"%c",p1);
  527.         }
  528.         break;
  529.     }
  530.   }
  531.   if (shifted_in)
  532.     KanjiOut(out,outcode);
  533. }
  534.  
  535. void euc2shift(FILE *in,FILE *out,int incode,int tofullsize)
  536. {
  537.   int p1,p2;
  538.  
  539.   while ((p1 = getc(in)) != EOF) {
  540.     switch (p1) {
  541.       case FF :
  542.         break;
  543.       default :
  544.         if ISEUC(p1) {
  545.           p2 = getc(in);
  546.           if ISEUC(p2) {
  547.             p1 -= 128;
  548.             p2 -= 128;
  549.             jis2sjis(&p1,&p2);
  550.           }
  551.           fprintf(out,"%c%c",p1,p2);
  552.         }
  553.         else if (p1 == 142) {
  554.           p2 = getc(in);
  555.           if HANKATA(p2) {
  556.             if (tofullsize) {
  557.               p1 = p2;
  558.               han2zen(in,&p1,&p2,incode);
  559.               fprintf(out,"%c%c",p1,p2);
  560.             }
  561.             else {
  562.               p1 = p2;
  563.               fprintf(out,"%c",p1);
  564.             }
  565.           }
  566.           else
  567.             fprintf(out,"%c%c",p1,p2);
  568.         }
  569.         else
  570.           fprintf(out,"%c",p1);
  571.         break;
  572.     }
  573.   }
  574. }
  575.  
  576. void seven2shift(FILE *in,FILE *out)
  577. {
  578.   int shifted_in,temp,p1,p2;
  579.  
  580.   shifted_in = FALSE;
  581.   while ((p1 = getc(in)) != EOF) {
  582.     switch (p1) {
  583.       case ESC :
  584.         temp = getc(in);
  585.         SkipESCSeq(in,temp,&shifted_in);
  586.         break;
  587.       case FF :
  588.         break;
  589.       default :
  590.         if (shifted_in) {
  591.           p2 = getc(in);
  592.           jis2sjis(&p1,&p2);
  593.           fprintf(out,"%c%c",p1,p2);
  594.         }
  595.         else
  596.           fprintf(out,"%c",p1);
  597.         break;
  598.     }
  599.   }
  600. }
  601.   
  602. void seven2euc(FILE *in,FILE *out)
  603. {
  604.   int shifted_in,temp,p1,p2;
  605.  
  606.   shifted_in = FALSE;
  607.   while ((p1 = getc(in)) != EOF) {
  608.     switch (p1) {
  609.       case ESC :
  610.         temp = getc(in);
  611.         SkipESCSeq(in,temp,&shifted_in);
  612.         break;
  613.       case NL :
  614.         if (shifted_in) {
  615.           shifted_in = FALSE;
  616.         }
  617.         fprintf(out,"%c",p1);
  618.         break;
  619.       case FF :
  620.         break;
  621.       default :
  622.         if (shifted_in) {
  623.           p2 = getc(in);
  624.           p1 += 128;
  625.           p2 += 128;
  626.           fprintf(out,"%c%c",p1,p2);
  627.         }
  628.         else
  629.           fprintf(out,"%c",p1);
  630.         break;
  631.     }
  632.   }
  633. }
  634.  
  635. void seven2seven(FILE *in,FILE *out,int outcode)
  636. {
  637.   int shifted_in,temp,p1,p2;
  638.  
  639.   shifted_in = FALSE;
  640.   while ((p1 = getc(in)) != EOF) {
  641.     switch (p1) {
  642.       case ESC :
  643.         temp = getc(in);
  644.         SkipESCSeq(in,temp,&shifted_in);
  645.         if (shifted_in)
  646.           KanjiIn(out,outcode);
  647.         else
  648.           KanjiOut(out,outcode);
  649.         break;
  650.       case NL :
  651.         if (shifted_in) {
  652.           shifted_in = FALSE;
  653.           KanjiOut(out,outcode);
  654.         }
  655.         fprintf(out,"%c",p1);
  656.         break;
  657.       case FF :
  658.         break;
  659.       default :
  660.         if (shifted_in) {
  661.           p2 = getc(in);
  662.           fprintf(out,"%c%c",p1,p2);
  663.         }
  664.         else
  665.           fprintf(out,"%c",p1);
  666.         break;
  667.     }
  668.   }
  669.   if (shifted_in)
  670.     KanjiOut(out,outcode);
  671. }
  672.  
  673. void euc2euc(FILE *in,FILE *out,int incode,int tofullsize)
  674. {
  675.   int p1,p2;
  676.  
  677.   while ((p1 = getc(in)) != EOF) {
  678.     switch (p1) {
  679.       case FF :
  680.         break;
  681.       default :
  682.         if ISEUC(p1) {
  683.           p2 = getc(in);
  684.           if ISEUC(p2)
  685.             fprintf(out,"%c%c",p1,p2);
  686.         }
  687.         else if (p1 == 142) {
  688.           p2 = getc(in);
  689.           if (HANKATA(p2) && (tofullsize)) {
  690.             p1 = p2;
  691.             han2zen(in,&p1,&p2,incode);
  692.             sjis2jis(&p1,&p2);
  693.             p1 += 128;
  694.             p2 += 128;
  695.           }
  696.           fprintf(out,"%c%c",p1,p2);
  697.         }
  698.         else
  699.           fprintf(out,"%c",p1);
  700.         break;
  701.     }
  702.   }
  703. }
  704.  
  705. void shift2shift(FILE *in,FILE *out,int incode,int tofullsize)
  706. {
  707.   int p1,p2;
  708.   
  709.   while ((p1 = getc(in)) != EOF) {
  710.     switch (p1) {
  711.       case CR :
  712.       case NL :
  713.         fprintf(out,"%c",NL);
  714.         break;
  715.       case NUL :
  716.       case FF :
  717.         break;
  718.       default :
  719.         if SJIS1(p1) {
  720.           p2 = getc(in);
  721.           if SJIS2(p2)
  722.             fprintf(out,"%c%c",p1,p2);
  723.         }
  724.         else if (HANKATA(p1) && (tofullsize)) {
  725.           han2zen(in,&p1,&p2,incode);
  726.           fprintf(out,"%c%c",p1,p2);
  727.         }
  728.         else
  729.           fprintf(out,"%c",p1);
  730.         break;
  731.     }
  732.   }
  733. }
  734.  
  735. int DetectCodeType(FILE *in)
  736. {
  737.   int p1,p2,p3,whatcode;
  738.  
  739.   whatcode = NOT_SET;
  740.   while (((p1 = getc(in)) != EOF) &&
  741.   ((whatcode == NOT_SET) || (whatcode == EUC))) {
  742.     if (p1 == ESC) {
  743.       p2 = getc(in);
  744.       if (p2 == '$') {
  745.         p3 = getc(in);
  746.         if (p3 == 'B')
  747.           whatcode = NEW;
  748.         else if (p3 == '@')
  749.           whatcode = OLD;
  750.       }
  751.       else if (p2 == 'K')
  752.         whatcode = NEC;
  753.     }
  754.     else if ((p1 >= 129) && (p1 <= 254)) {
  755.       p2 = getc(in);
  756.       if NOTEUC(p1,p2)
  757.         whatcode = SJIS;
  758.       else if (ISEUC(p1) && ISEUC(p2))
  759.         whatcode = EUC;
  760.       else if (((p1 == 142)) && HANKATA(p2))
  761.         whatcode = EUC;
  762.     }
  763.   }
  764.   return whatcode;
  765. }
  766.  
  767. void han2zen(FILE *in,int *one,int *two,int incode)
  768. {
  769.   int junk,maru,nigori;
  770.  
  771.   maru = nigori = FALSE;
  772.   if (incode == SJIS) {
  773.     *two = getc(in);
  774.     if (*two == 222) {
  775.       if (ISNIGORI(*one) || (*one == 179))
  776.         nigori = TRUE;
  777.       else
  778.         ungetc(*two,in);
  779.     }
  780.     else if (*two == 223) {
  781.       if ISMARU(*one)
  782.         maru = TRUE;
  783.       else
  784.         ungetc(*two,in);
  785.     }
  786.     else
  787.       ungetc(*two,in);
  788.   }
  789.   else if (incode == EUC) {
  790.     junk = getc(in);
  791.     if (junk == 142) {
  792.       *two = getc(in);
  793.       if (*two == 222) {
  794.         if (ISNIGORI(*one) || (*one == 179))
  795.           nigori = TRUE;
  796.         else {
  797.           ungetc(*two,in);
  798.           ungetc(junk,in);
  799.         }
  800.       }
  801.       else if (*two == 223) {
  802.         if ISMARU(*one)
  803.           maru = TRUE;
  804.         else {
  805.           ungetc(*two,in);
  806.           ungetc(junk,in);
  807.         }
  808.       }
  809.       else {
  810.         ungetc(*two,in);
  811.         ungetc(junk,in);
  812.       }
  813.     }
  814.     else
  815.       ungetc(junk,in);
  816.   }
  817.   switch (*one) {
  818.     case 161 :
  819.       *one = 129;
  820.       *two = 66;
  821.       break;
  822.     case 162 :
  823.       *one = 129;
  824.       *two = 117;
  825.       break;
  826.     case 163 :
  827.       *one = 129;
  828.       *two = 118;
  829.       break;
  830.     case 164 :
  831.       *one = 129;
  832.       *two = 65;
  833.       break;
  834.     case 165 :
  835.       *one = 129;
  836.       *two = 69;
  837.       break;
  838.     case 166 :
  839.       *one = 131;
  840.       *two = 146;
  841.       break;
  842.     case 167 :
  843.       *one = 131;
  844.       *two = 64;
  845.       break;
  846.     case 168 :
  847.       *one = 131;
  848.       *two = 66;
  849.       break;
  850.     case 169 :
  851.       *one = 131;
  852.       *two = 68;
  853.       break;
  854.     case 170 :
  855.       *one = 131;
  856.       *two = 70;
  857.       break;
  858.     case 171 :
  859.       *one = 131;
  860.       *two = 72;
  861.       break;
  862.     case 172 :
  863.       *one = 131;
  864.       *two = 131;
  865.       break;
  866.     case 173 :
  867.       *one = 131;
  868.       *two = 133;
  869.       break;
  870.     case 174 :
  871.       *one = 131;
  872.       *two = 135;
  873.       break;
  874.     case 175 :
  875.       *one = 131;
  876.       *two = 98;
  877.       break;
  878.     case 176 :
  879.       *one = 129;
  880.       *two = 91;
  881.       break;
  882.     case 177 :
  883.       *one = 131;
  884.       *two = 65;
  885.       break;
  886.     case 178 :
  887.       *one = 131;
  888.       *two = 67;
  889.       break;
  890.     case 179 :
  891.       *one = 131;
  892.       *two = 69;
  893.       break;
  894.     case 180 :
  895.       *one = 131;
  896.       *two = 71;
  897.       break;
  898.     case 181 :
  899.       *one = 131;
  900.       *two = 73;
  901.       break;
  902.     case 182 :
  903.       *one = 131;
  904.       *two = 74;
  905.       break;
  906.     case 183 :
  907.       *one = 131;
  908.       *two = 76;
  909.       break;
  910.     case 184 :
  911.       *one = 131;
  912.       *two = 78;
  913.       break;
  914.     case 185 :
  915.       *one = 131;
  916.       *two = 80;
  917.       break;
  918.     case 186 :
  919.       *one = 131;
  920.       *two = 82;
  921.       break;
  922.     case 187 :
  923.       *one = 131;
  924.       *two = 84;
  925.       break;
  926.     case 188 :
  927.       *one = 131;
  928.       *two = 86;
  929.       break;
  930.     case 189 :
  931.       *one = 131;
  932.       *two = 88;
  933.       break;
  934.     case 190 :
  935.       *one = 131;
  936.       *two = 90;
  937.       break;
  938.     case 191 :
  939.       *one = 131;
  940.       *two = 92;
  941.       break;
  942.     case 192 :
  943.       *one = 131;
  944.       *two = 94;
  945.       break;
  946.     case 193 :
  947.       *one = 131;
  948.       *two = 96;
  949.       break;
  950.     case 194 :
  951.       *one = 131;
  952.       *two = 99;
  953.       break;
  954.     case 195 :
  955.       *one = 131;
  956.       *two = 101;
  957.       break;
  958.     case 196 :
  959.       *one = 131;
  960.       *two = 103;
  961.       break;
  962.     case 197 :
  963.       *one = 131;
  964.       *two = 105;
  965.       break;
  966.     case 198 :
  967.       *one = 131;
  968.       *two = 106;
  969.       break;
  970.     case 199 :
  971.       *one = 131;
  972.       *two = 107;
  973.       break;
  974.     case 200 :
  975.       *one = 131;
  976.       *two = 108;
  977.       break;
  978.     case 201 :
  979.       *one = 131;
  980.       *two = 109;
  981.       break;
  982.     case 202 :
  983.       *one = 131;
  984.       *two = 110;
  985.       break;
  986.     case 203 :
  987.       *one = 131;
  988.       *two = 113;
  989.       break;
  990.     case 204 :
  991.       *one = 131;
  992.       *two = 116;
  993.       break;
  994.     case 205 :
  995.       *one = 131;
  996.       *two = 119;
  997.       break;
  998.     case 206 :
  999.       *one = 131;
  1000.       *two = 122;
  1001.       break;
  1002.     case 207 :
  1003.       *one = 131;
  1004.       *two = 125;
  1005.       break;
  1006.     case 208 :
  1007.       *one = 131;
  1008.       *two = 126;
  1009.       break;
  1010.     case 209 :
  1011.       *one = 131;
  1012.       *two = 128;
  1013.       break;
  1014.     case 210 :
  1015.       *one = 131;
  1016.       *two = 129;
  1017.       break;
  1018.     case 211 :
  1019.       *one = 131;
  1020.       *two = 130;
  1021.       break;
  1022.     case 212 :
  1023.       *one = 131;
  1024.       *two = 132;
  1025.       break;
  1026.     case 213 :
  1027.       *one = 131;
  1028.       *two = 134;
  1029.       break;
  1030.     case 214 :
  1031.       *one = 131;
  1032.       *two = 136;
  1033.       break;
  1034.     case 215 :
  1035.       *one = 131;
  1036.       *two = 137;
  1037.       break;
  1038.     case 216 :
  1039.       *one = 131;
  1040.       *two = 138;
  1041.       break;
  1042.     case 217 :
  1043.       *one = 131;
  1044.       *two = 139;
  1045.       break;
  1046.     case 218 :
  1047.       *one = 131;
  1048.       *two = 140;
  1049.       break;
  1050.     case 219 :
  1051.       *one = 131;
  1052.       *two = 141;
  1053.       break;
  1054.     case 220 :
  1055.       *one = 131;
  1056.       *two = 143;
  1057.       break;
  1058.     case 221 :
  1059.       *one = 131;
  1060.       *two = 147;
  1061.       break;
  1062.     case 222 :
  1063.       *one = 129;
  1064.       *two = 74;
  1065.       break;
  1066.     case 223 :
  1067.       *one = 129;
  1068.       *two = 75;
  1069.       break;
  1070.   }
  1071.   if (nigori) {
  1072.     if (((*two >= 74) && (*two <= 103)) || ((*two >= 110) && (*two <= 122)))
  1073.       (*two)++;
  1074.     else if ((*one == 131) && (*two == 69))
  1075.       *two = 148;
  1076.   }
  1077.   else if ((maru) && ((*two >= 110) && (*two <= 122)))
  1078.     *two += 2;
  1079. }