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

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

Telnet服务器

开发平台：

Unix_Linux

sinocode.c：源码内容
  1. /*
  2.   Copyright (C) 1992 Per Hammarlund <perham@nada.kth.se>
  3. */
  5. /*
  6.   Written by Per Hammarlund <perham@nada.kth.se>
  7.   Helpful remarks from Ken-Ichi Handa <handa@etl.go.jp>.
  8.   The sinoco??.cod (translation) files are provided by Urs Widmer
  9.   <a06g@alf.zfn.uni-bremen.de>.
  10. */
  12. /*
  13.   This program is free software; you can redistribute it and/or modify
  14.   it under the terms of the GNU General Public License as published by
  15.   the Free Software Foundation; either version 1, or (at your option)
  16.   any later version.
  17.  
  18.   This program is distributed in the hope that it will be useful,
  19.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.   GNU General Public License for more details.
  22.  
  23.   You should have received a copy of the GNU General Public License
  24.   along with this program; if not, write to the Free Software
  25.   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26. */ 
  28. #include <stdio.h>
  29. #include <strings.h>
  30. #include <stdlib.h>
  32. #define VERSIONSTRING "Sinocode Version 0.11"
  34. /* make sure that you have a "/" at */
  35. /* the end of this string. */
  36. #ifndef TRANSLATIONSFILESDIR
  37. #define TRANSLATIONSFILESDIR "/home/sans/perham/src/new-sinocode/"
  38. #endif
  41. #define PROGNAME 0
  42. #define HELPORVERSION 1
  43. #define INFILECONV 1
  44. #define INFILENAME 2
  45. #define OUTFILECONV 3
  46. #define OUTFILENAME 4
  48. #define GB_2312_TO_BIG_5     0
  49. #define GB_2312_TO_IBM_555   1
  50. #define GB_2312_TO_JIS_EUC   2
  51. #define BIG_5_TO_GB_2312     3
  52. #define BIG_5_TO_IBM_555     4
  53. #define BIG_5_TO_JIS_EUC     5
  54. #define JIS_EUC_TO_GB_2312   6
  55. #define JIS_EUC_TO_BIG_5     7
  56. #define IBM_555_TO_BIG_5     8
  57. #define IBM_555_TO_GB_2312   9
  59. /* this should be done with a malloc */
  60. /* depending on the size of the */
  61. /* translation file... */
  62. #define NO_CHAR_IN_TABLE 16000
  63. #define FIRST 0
  64. #define SECOND 1
  66. #define NULL 0
  67. /* numbering the coding */
  68. #define NO_CODES     4
  69. #define JIS_EUC_CODE 0
  70. #define BIG5_CODE    1
  71. #define GB2312_CODE  2
  72. #define IBM555_CODE  3
  73. /* some strings for some useful */
  74. /* missing characters */
  75. #define NO_NAMED_CHARACTERS 3
  76. #define FAT_EQUAL  "fat_equal"
  77. #define BLACK_BOX  "black_box"
  78. #define SQUARE_BOX "square_box"
  80. /* the names of the missing chars */
  81. /* enviornment vars */
  82. #define SINOCODE_DEFAULT_MISSING_CHAR "SINOMISSDEF"
  83. #define JIS_EUC_CHAR                  "SINOJISEUC"
  84. #define BIG5_CHAR                     "SINOBIG5"
  85. #define GB2312_CHAR                   "SINOGB2312"
  86. #define IBM555_CHAR                   "SINOIBM555"
  88. typedef unsigned short u16;
  89. typedef struct code_pair
  90. {
  91.   char first, second;
  92. } code_pair;
  94. typedef struct named_character 
  95. {
  96.   char * char_name;
  97.   code_pair character_codes[NO_CODES];
  98. } named_character;
  100. named_character codes_for_named_characters[NO_NAMED_CHARACTERS] = 
  101. {
  102.   {FAT_EQUAL,
  103.      {
  104.        {(char) 0xA2, (char) 0xAE},
  105.        {(char) 0x21, (char) 0x7E},
  106.        {(char) 0xA1, (char) 0xFE},
  107.        {(char) 0x22, (char) 0x2E}
  108.      }},
  109.   {BLACK_BOX,
  110.      {
  111.        {(char) 0xA2, (char) 0xA3},
  112.        {(char) 0xA1, (char) 0xBD},
  113.        {(char) 0xA1, (char) 0xF6},
  114.        {(char) 0xFF, (char) 0xFF}
  115.      }},
  116.   {SQUARE_BOX,
  117.      {
  118.        {(char) 0xA2, (char) 0xA2},
  119.        {(char) 0xA1, (char) 0xBC},
  120.        {(char) 0xA1, (char) 0xF5},
  121.        {(char) 0xFF, (char) 0xFF}
  122.      }}};
  125.   
  126. char * env_vars_to_check[NO_CODES] = 
  127. {
  128.   JIS_EUC_CHAR,
  129.   BIG5_CHAR,
  130.   GB2312_CHAR,
  131.   IBM555_CHAR
  132.   };
  134. char * default_missing_char_names[NO_CODES] =
  135.   {
  136.     FAT_EQUAL,
  137.     FAT_EQUAL,
  138.     FAT_EQUAL,
  139.     FAT_EQUAL
  140.   };
  142. char default_missing_char_codes[NO_CODES][2];
  144. static int translation_table[NO_CHAR_IN_TABLE][2];
  146. static char * progname;
  147. /* file names of the translation files */
  148. static char * translation_files[10] = 
  149. {
  150.   "sinocogb.cod",
  151.   "sinocogb.cod",
  152.   "sinocogj.cod",
  153.   "sinocobg.cod",
  154.   "",
  155.   "sinocobj.cod",
  156.   "sinocojg.cod",
  157.   "sinocojb.cod",
  158.   "",
  159.   "sinocobg.cod"
  160.   };
  162. void print_help()
  163. {
  164.   fprintf( stdout, "There is no help so far!n");
  165. }
  169. void setup_missing_chars_to_use(void)
  170. {
  171.   char * env_ptr;
  172.   int i, j;
  173. /* first check the default env var */
  174.   if( (env_ptr = getenv( SINOCODE_DEFAULT_MISSING_CHAR )) != NULL)
  175.     for( i = 0; i < NO_CODES; i++)
  176.       default_missing_char_names[i] = env_ptr;
  177.   
  178. /* Then check the others */
  179.   for( i = 0; i < NO_CODES; i++)
  180.     if( (env_ptr = getenv(env_vars_to_check[i])) != NULL )
  181.       default_missing_char_names[i] = env_ptr;
  182.   
  183. /* Then set the codes up from the */
  184. /* names they have been given */
  185.   for( i = 0; i < NO_CODES; i++)
  186.     {
  187. /* possibly loop through all the */
  188. /* indexes */
  189.       for( j = 0; j < NO_NAMED_CHARACTERS; j++)
  190. if( ! strcmp(default_missing_char_names[i],
  191.      codes_for_named_characters[j].char_name))
  192.   break;
  194. /* now we have either found a coding */
  195. /* or we have to use the two byte */
  196. /* string supplied by the user */
  197.       if( j != NO_NAMED_CHARACTERS )
  198. {
  199.   default_missing_char_codes[i][0] =
  200.     codes_for_named_characters[j].character_codes[i].first;
  201.   default_missing_char_codes[i][1] =
  202.     codes_for_named_characters[j].character_codes[i].second;
  203. }
  204.       else
  205. /* use what the user has supplied */
  206. if( 2 == strlen( default_missing_char_names[i] ))
  207.   {
  208.     default_missing_char_codes[i][0] =
  209.       default_missing_char_names[i][0];
  210.     default_missing_char_codes[i][1] =
  211.       default_missing_char_names[i][1];
  212.   }
  213. else
  214.   {
  215.     fprintf( stderr,
  216.     "%s: Your environment variables "%s" or "%s" arennot correct.n",
  217.     progname,
  218.     SINOCODE_DEFAULT_MISSING_CHAR,
  219.     env_vars_to_check[i]);
  220.     fprintf(stderr, "Either they should contain one of the following strings:n");
  221.     for( i = 0; i < NO_NAMED_CHARACTERS; i++)
  222.       fprintf( stderr, ""%s"n",
  223.       codes_for_named_characters[i].char_name );
  224.     fprintf( stderr, "Or be a two byte code for a charactersn");
  225.     exit(1);
  226.   }
  227.     }
  228. } /* setup_missing_chars_to_use */
  230.   
  231. void read_translation_table( char *filename )
  232. {
  233.   char *realpath;
  234.   FILE *tranfp;
  235.   int i, junk;
  236.   
  237. /* allocate memory for the real */
  238. /* filename */
  239.   if( ! (realpath = (char *) malloc(strlen(TRANSLATIONSFILESDIR) +
  240.     strlen(filename) +
  241.     1)))
  242.     {
  243.       fprintf( stderr, "%s: Couldn't get enough memory.n",
  244.       progname );
  245.       exit( 1 );
  246.     }
  247.   
  248.   strcpy( realpath, TRANSLATIONSFILESDIR);
  249.   strcat( realpath, filename );
  251.   if( !(tranfp = fopen( realpath, "r" )))
  252.     {
  253.       fprintf( stderr, "%s: Couldn't open translation file: "%s"n",
  254.       progname, realpath );
  255.       exit( 1 );
  256.     }
  257.   
  258.   for( i = 1; 1; i++ )
  259.     {
  260.       translation_table[i][FIRST] = getc( tranfp );
  261.       translation_table[i][SECOND] = getc( tranfp );
  262.       junk = getc( tranfp );
  263.       if( junk == EOF )
  264. break;
  265.     }
  266.   return;
  267. }
  269. void find_gb_big_code(int ch1, int ch2, int * outch1, int * outch2)
  270. {
  271.   int index;
  272.   
  273.   index = ((ch1 - 161) * 94)+ ch2 - 160;
  275.   *outch1 = translation_table[index][FIRST];
  276.   *outch2 = translation_table[index][SECOND];
  278.   return;
  279. }
  281. void find_big_gb_code( int ch1, int ch2, int * outch1, int * outch2 )
  282. {
  283.   int index;
  285.   index = ((ch1-161)*157)+ch2-63-((ch2 < 161)?0:34);
  287.   *outch1 = translation_table[index][FIRST];
  288.   *outch2 = translation_table[index][SECOND];
  290.   return;
  291. } /* find_big_gb_code */
  293. void find_big( int char1, int char2,
  294.       int * outchar1, int * outchar2 )
  295. {
  296.   int rno, tmp1, tmp2;
  297.   rno = (char1-137)*188 + char2 - 63 - (char2>126)?1:0;
  298.   rno -= (rno>408)?93:0;
  299.   tmp1 = rno%157+161;
  300.   tmp2 = (rno - ((rno % 157) * 157))+63;
  301.   tmp2 += (tmp2>126)?34:0;
  302.   *outchar1 = tmp1;
  303.   *outchar2 = tmp2;
  304.   return;  
  305. } /* find_big */
  308. void find_ibm( int char1, int char2,
  309.       int * outchar1, int * outchar2 )
  310. {
  311.   int rno, tmp1, tmp2;
  312.   
  313.   rno = (char1 - 161) * 157 + char2 - 63-(char2>126)?34:0;
  314.   rno += (rno>408)?93:0;
  315.   tmp1 = (rno % 188) + 137;
  316.   tmp2 = (rno - ((rno % 188) * 188))+63;
  317.   if( tmp2 > 126 )
  318.     tmp2++;
  319.   *outchar1 = tmp1;
  320.   *outchar1 = tmp2;
  321.   return;
  322. } /* find_ibm */
  325. /* 1 */
  326. void gb_2312_to_big_5( FILE *infilefp, FILE *outfilefp )
  327. {
  328.   int char1, char2;
  329.   int outchar1, outchar2;
  330.   
  331.   read_translation_table( translation_files[GB_2312_TO_BIG_5]);
  332.   
  333.   while ( (char1 = getc( infilefp )) != EOF )
  334.     {
  335.       if ( char1 >= 160 && char1 <= 255 )
  336. {
  337.   char2 = getc( infilefp );
  338.   find_gb_big_code( char1, char2, & outchar1, & outchar2 );
  339.   if ( outchar1 == (char) ' ' )
  340.     {
  341.       putc( default_missing_char_codes[BIG5_CODE][FIRST], outfilefp);
  342.       putc( default_missing_char_codes[BIG5_CODE][SECOND], outfilefp);
  343.     }
  344.   else
  345.     {
  346.       putc( (char) outchar1, outfilefp);
  347.       putc( (char) outchar2, outfilefp);
  348.     }
  349. }
  350.       else
  351. putc( (char) char1, outfilefp );
  352.     }
  353.   
  354.   return;
  355. }
  356. /* 2 */
  357. void gb_2312_to_ibm_555( FILE *infilefp, FILE *outfilefp )
  358. { 
  359.   int char1, char2;
  360.   int outchar1, outchar2;
  361.   
  362.   read_translation_table( translation_files[GB_2312_TO_IBM_555]);
  363.   
  364.   while ( (char1 = getc( infilefp )) != EOF )
  365.     {
  366.       if ( char1 >= 160 && char1 <= 255 )
  367. {
  368.   char2 = getc( infilefp );
  369.   find_gb_big_code( char1, char2, & outchar1, & outchar2 );
  370. /* convert to IBM */
  371.   if ( outchar1 < 161 )
  372.     outchar1 = (int) ' ';
  373.   else
  374.     find_ibm( outchar1, outchar2, &outchar1, &outchar2 );
  376.   if ( outchar1 == (int) ' ' )
  377.     {
  378.       putc( default_missing_char_codes[IBM555_CODE][FIRST], outfilefp);
  379.       putc( default_missing_char_codes[IBM555_CODE][SECOND], outfilefp);
  380.     }
  381.   else
  382.     {
  383.       putc( (char) outchar1, outfilefp);
  384.       putc( (char) outchar2, outfilefp);
  385.     }
  386. }
  387.       else
  388. putc( (char) char1, outfilefp );
  389.     }
  390.   return;
  391. }
  393. /* 3 */
  394. void gb_2312_to_jis_euc( FILE *infilefp, FILE *outfilefp )
  395. {
  396.   int char1, char2;
  397.   int outchar1, outchar2;
  398.   read_translation_table( translation_files[GB_2312_TO_JIS_EUC]);
  400.   while ( (char1 = getc( infilefp )) != EOF )
  401.     {
  402.       if ( char1 >= 160 && char1 <= 255 )
  403. {
  404.   char2 = getc( infilefp );
  405.   find_gb_big_code( char1, char2, & outchar1, & outchar2 );
  406.   if ( outchar1 == (char) ' ' )
  407.     {
  408.       putc( default_missing_char_codes[JIS_EUC_CODE][FIRST], outfilefp);
  409.       putc( default_missing_char_codes[JIS_EUC_CODE][SECOND], outfilefp);
  410.     }
  411.   else
  412.     {
  413.       putc( (char) outchar1, outfilefp);
  414.       putc( (char) outchar2, outfilefp);
  415.     }
  416. }
  417.       else
  418. putc( (char) char1, outfilefp );
  419.     }
  420.   return;
  421. }
  423. /* 4 */
  424. void big_5_to_gb_2312( FILE *infilefp, FILE *outfilefp )
  425. {
  426.   int char1, char2;
  427.   int outchar1, outchar2;
  428.   read_translation_table( translation_files[BIG_5_TO_GB_2312]);
  430.   while ( (char1 = getc( infilefp )) != EOF )
  431.     {
  432.       if ( char1 >= 160 && char1 <= 255 )
  433. {
  434.   char2 = getc( infilefp );
  435.   find_big_gb_code( char1, char2, & outchar1, &outchar2 );
  436.   if ( outchar1 == (char) ' ' )
  437.     {
  438.       putc( default_missing_char_codes[GB2312_CODE][FIRST], outfilefp);
  439.       putc( default_missing_char_codes[GB2312_CODE][SECOND], outfilefp);
  440.     }
  441.   else
  442.     {
  443.       putc( (char) outchar1, outfilefp);
  444.       putc( (char) outchar2, outfilefp);
  445.     }
  446. }
  447.       else
  448. putc( (char) char1, outfilefp );
  449.     }
  450.   
  451.   return;
  452. }
  454. /* 5 */
  455. void big_5_to_ibm_555( FILE *infilefp, FILE *outfilefp )
  456. {
  457.   int char1, char2;
  458.   int outchar1, outchar2;
  459.   read_translation_table( translation_files[BIG_5_TO_IBM_555]);
  461.   while ( (char1 = getc( infilefp )) != EOF )
  462.     {
  463.       if ( char1 >= 160 && char1 <= 255 )
  464. {
  465.   char2 = getc( infilefp );
  466.   find_ibm( char1, char2, & outchar1, & outchar2 );
  467.   if ( outchar1 == (char) ' ' )
  468.     {
  469.       putc( default_missing_char_codes[IBM555_CODE][FIRST], outfilefp);
  470.       putc( default_missing_char_codes[IBM555_CODE][SECOND], outfilefp);
  471.     }
  472.   else
  473.     {
  474.       putc( (char) outchar1, outfilefp);
  475.       putc( (char) outchar2, outfilefp);
  476.     }
  477. }
  478.       else
  479. putc( (char) char1, outfilefp );
  480.     }
  482.   return;
  483. }
  485. /* 6 */
  486. void big_5_to_jis_euc( FILE *infilefp, FILE *outfilefp )
  487. {
  488.   int char1, char2;
  489.   int outchar1, outchar2;
  490.   read_translation_table( translation_files[BIG_5_TO_JIS_EUC]);
  492.   while ( (char1 = getc( infilefp )) != EOF )
  493.     {
  494.       if ( char1 >= 160 && char1 <= 255 )
  495. {
  496.   char2 = getc( infilefp );
  497.   find_big_gb_code( char1, char2, & outchar1, & outchar2 );
  498.   if ( outchar1 == (int) ' ' )
  499.     {
  500.       putc( default_missing_char_codes[JIS_EUC_CODE][FIRST], outfilefp);
  501.       putc( default_missing_char_codes[JIS_EUC_CODE][SECOND], outfilefp);
  502.     }
  503.   else
  504.     {
  505.       putc( (char) outchar1, outfilefp);
  506.       putc( (char) outchar2, outfilefp);
  507.     }
  508. }
  509.       else
  510. putc( (char) char1, outfilefp );
  511.     }
  512.   return;
  513. }
  515. /* 7 */
  516. void jis_euc_to_gb_2312( FILE *infilefp, FILE *outfilefp )
  517. {
  518.   int char1, char2;
  519.   int outchar1, outchar2;
  520.   read_translation_table( translation_files[JIS_EUC_TO_GB_2312]);
  521.   while ( (char1 = getc( infilefp )) != EOF )
  522.     {
  523.       if ( char1 >= 160 && char1 <= 255 )
  524. {
  525.   char2 = getc( infilefp );
  526.   find_gb_big_code( char1, char2, & outchar1, & outchar2 );
  527.   if ( outchar1 == (char) ' ' )
  528.     {
  529.       putc( default_missing_char_codes[GB2312_CODE][FIRST], outfilefp);
  530.       putc( default_missing_char_codes[GB2312_CODE][SECOND], outfilefp);
  531.     }
  532.   else
  533.     {
  534.       putc( (char) outchar1, outfilefp);
  535.       putc( (char) outchar2, outfilefp);
  536.     }
  537. }
  538.       else
  539. putc( (char) char1, outfilefp );
  540.     }
  542.   return;
  543. }
  545. /* 8 */
  546. void jis_euc_to_big_5( FILE *infilefp, FILE *outfilefp )
  547. {
  548.   int char1, char2;
  549.   int outchar1, outchar2;
  550.   read_translation_table( translation_files[JIS_EUC_TO_BIG_5]);
  552.   while ( (char1 = getc( infilefp )) != EOF )
  553.     {
  554.       if ( char1 >= 160 && char1 <= 255 )
  555. {
  556.   char2 = getc( infilefp );
  557.   find_gb_big_code( char1, char2, & outchar1, & outchar2 );
  558.   if ( outchar1 == (char) ' ' )
  559.     {
  560.       putc( default_missing_char_codes[BIG5_CODE][FIRST], outfilefp);
  561.       putc( default_missing_char_codes[BIG5_CODE][SECOND], outfilefp);
  562.     }
  563.   else
  564.     {
  565.       putc( (char) outchar1, outfilefp);
  566.       putc( (char) outchar2, outfilefp);
  567.     }
  568. }
  569.       else
  570. putc( (char) char1, outfilefp );
  571.     }
  572.   return;
  573. }
  575. /* 9 */
  576. void ibm_555_to_big_5( FILE *infilefp, FILE *outfilefp )
  577. {
  578.   int char1, char2;
  579.   int outchar1, outchar2;
  581.   return;
  583. #ifdef IBM
  584.   read_translation_table( translation_files[ibm_555_to_big_5]);
  585.     while ( (char1 = getc( infilefp )) != EOF )
  586.     {
  587.       if ( char1 >= 134 && char <= 255 )
  588. {
  589.   char2 = getc( infilefp );
  590.   find_gb_big_code( char1, char2, & outchar1, & outchar2 );
  591.   if ( outchar1 == (char) ' ' )
  592.     {
  593.       putc( default_missing_char_codes[BIG5_CODE][FIRST], outfilefp);
  594.       putc( default_missing_char_codes[BIG5_CODE][SECOND], outfilefp);
  595.     }
  596.   else
  597.     {
  598.       putc( (char) * outchar1, outfilefp);
  599.       putc( (char) * outchar2, outfilefp);
  600.     }
  601. }
  602.       else
  603. putc( (char) char1, outfilefp );
  604.     }
  605.   return;
  606. #endif
  607. }
  609. /* 10 */
  610. void ibm_555_to_gb_2312( FILE *infilefp, FILE *outfilefp )
  611. {
  612.   int char1, char2;
  613.   int outchar1, outchar2;
  614.   read_translation_table( translation_files[IBM_555_TO_GB_2312]);
  616.   find_big( char1, char2, & outchar1, & outchar2 );
  617.   find_big_gb_code( outchar1, outchar2, &outchar1, &outchar2 );
  618.   if ( outchar1 == (char) ' ' )
  619.     {
  620.       putc( default_missing_char_codes[GB2312_CODE][FIRST], outfilefp);
  621.       putc( default_missing_char_codes[GB2312_CODE][SECOND], outfilefp);
  622.     }
  623.   else
  624.     {
  625.       putc( (char) outchar1, outfilefp);
  626.       putc( (char) outchar2, outfilefp);
  627.     }
  628.   return;
  629. }
  632. void main(argc, argv)
  633.   int argc;
  634.   char **argv;
  635. {
  636.   FILE *infilefp, *outfilefp;
  637.   
  638.   progname = argv[0];
  639. /* make sure we use the correct */
  640. /* missing chars */
  641.   setup_missing_chars_to_use();
  642.   
  643. /* this should aways be called with */
  644. /* either one of four arguments. */
  645.   if( argc == 2)
  646.     {
  647.       if( !strcmp(argv[HELPORVERSION], "-version"))
  648. {
  649.   fprintf( stdout, "%s: %sn", argv[PROGNAME], VERSIONSTRING );
  650.   exit( 0 );
  651. }
  652.       else
  653. if( ! strcmp(argv[HELPORVERSION], "-help"))
  654.   {
  655.     print_help();
  656.     exit( 0 );
  657.   }
  658.     }
  659.   else
  660.     if( argc == 5 )
  661.       {
  662. /* first check the two files. */
  663. if( ! strcmp( argv[INFILENAME], "-"))
  664.   infilefp = stdin;
  665. else
  666.   if( ! (infilefp = fopen( argv[INFILENAME], "r")))
  667.     {
  668.       fprintf(stderr, "%s: Couldn't open input file: "%s"n",
  669.       argv[PROGNAME], argv[INFILENAME]);
  670.       exit( 1 );
  671.     }
  673. if( ! strcmp( argv[OUTFILENAME], "-"))
  674.   outfilefp = stdout;
  675. else
  676. /* perhaps we should stat here to make */
  677. /* sure that we do not overwrite */
  678. /* something. perham: future */
  679.   if( ! (outfilefp = fopen( argv[OUTFILENAME], "w")))
  680.     {
  681.       fprintf(stderr, "%s: Couldn't open output file: "%s"n",
  682.       argv[PROGNAME], argv[INFILENAME]);
  683.       exit( 1 );
  684.     }
  685. /* then parse the switches and */
  686. /* directly jump to the conversion */
  688. /* GB-2312   -->  BIG-5  */
  689. if((0 == strcmp( argv[INFILECONV], "-gb")) &&
  690.    (0 == strcmp( argv[OUTFILECONV], "-big")))
  691.   {
  692.     gb_2312_to_big_5( infilefp, outfilefp );
  693.     goto out;
  694.   }
  696. /* GB-2312   -->  IBM-555  */
  697. if((0 == strcmp( argv[INFILECONV], "-gb")) &&
  698.    (0 == strcmp( argv[OUTFILECONV], "-ibm")))
  699.   {
  700.     ( infilefp, outfilefp );
  701.     goto out;
  702.   }
  704. /* GB-2312   -->  JIS (EUC)  */
  705. if((0 == strcmp( argv[INFILECONV], "-gb")) &&
  706.    (0 == strcmp( argv[OUTFILECONV], "-jis")))
  707.   {
  708.     gb_2312_to_jis_euc( infilefp, outfilefp );
  709.     goto out;
  710.   }
  712. /* BIG-5     -->  GB-2312  */
  713. if((0 == strcmp( argv[INFILECONV], "-big")) &&
  714.    (0 == strcmp( argv[OUTFILECONV], "-gb")))
  715.   {
  716.     big_5_to_gb_2312( infilefp, outfilefp );
  717.     goto out;
  718.   }
  720. /* BIG-5     -->  IBM-555  */
  721. if((0 == strcmp( argv[INFILECONV], "-big")) &&
  722.    (0 == strcmp( argv[OUTFILECONV], "-ibm")))
  723.   {
  724.     big_5_to_ibm_555( infilefp, outfilefp );
  725.     goto out;
  726.   }
  728. /* BIG-5     -->  JIS (EUC)  */
  729. if((0 == strcmp( argv[INFILECONV], "-big")) &&
  730.    (0 == strcmp( argv[OUTFILECONV], "-jis")))
  731.   {
  732.     big_5_to_jis_euc( infilefp, outfilefp );
  733.     goto out;
  734.   }
  736. /* JIS (EUC) -->  GB-2312  */
  737. if((0 == strcmp( argv[INFILECONV], "-jis")) &&
  738.    (0 == strcmp( argv[OUTFILECONV], "-gb")))
  739.   {
  740.     jis_euc_to_gb_2312( infilefp, outfilefp );
  741.     goto out;
  742.   }
  744. /* JIS (EUC) -->  BIG-5  */
  745. if((0 == strcmp( argv[INFILECONV], "-jis")) &&
  746.    (0 == strcmp( argv[OUTFILECONV], "-big")))
  747.   {
  748.     jis_euc_to_big_5( infilefp, outfilefp );
  749.     goto out;
  750.   }
  752. /* IBM-555   -->  BIG-5  */
  753. if((0 == strcmp( argv[INFILECONV], "-ibm")) &&
  754.    (0 == strcmp( argv[OUTFILECONV], "-big")))
  755.   {
  756.     ibm_555_to_big_5( infilefp, outfilefp );
  757.     goto out;
  758.   }
  760. /* IBM-555   -->  GB-2312  */
  761. if((0 == strcmp( argv[INFILECONV], "-ibm")) &&
  762.    (0 == strcmp( argv[OUTFILECONV], "-gb")))
  763.   {
  764.     ibm_555_to_gb_2312( infilefp, outfilefp );
  765.     goto out;
  766.   }
  768. /* If we arrive here, then we have not */
  769. /* found a coding scheme */
  770. fprintf(stderr, "%s: Unknown coding scheme(s)n",
  771. argv[PROGNAME]);
  772. /* we do use goto! :-) */
  773.       out:;
  774.       } /* four arguments */
  775.     else
  776.       {
  777. fprintf( stderr, "%s: %sn", argv[0], "Wrong number of arguments");
  778. exit( 1 );
  779.       }
  780. /* Just a plain exit. */
  781.   exit( 0 );
  782. } /* main */