1                 : /*
       2                 :  * "streamable kanji code filter and converter"
       3                 :  * Copyright (c) 1998-2002 HappySize, Inc. All rights reserved.
       4                 :  *
       5                 :  * LICENSE NOTICES
       6                 :  *
       7                 :  * This file is part of "streamable kanji code filter and converter",
       8                 :  * which is distributed under the terms of GNU Lesser General Public
       9                 :  * License (version 2) as published by the Free Software Foundation.
      10                 :  *
      11                 :  * This software is distributed in the hope that it will be useful,
      12                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :  * GNU Lesser General Public License for more details.
      15                 :  *
      16                 :  * You should have received a copy of the GNU Lesser General Public
      17                 :  * License along with "streamable kanji code filter and converter";
      18                 :  * if not, write to the Free Software Foundation, Inc., 59 Temple Place,
      19                 :  * Suite 330, Boston, MA  02111-1307  USA
      20                 :  *
      21                 :  * The author of this file: Hayk Chamyan <hamshen@gmail.com>
      22                 :  *  
      23                 :  */
      24                 : 
      25                 : /*
      26                 :  * "armenian code filter and converter"
      27                 :  */
      28                 : 
      29                 : #ifdef HAVE_CONFIG_H
      30                 : #include "config.h"
      31                 : #endif
      32                 : 
      33                 : #include "mbfilter.h"
      34                 : #include "mbfilter_armscii8.h"
      35                 : #include "unicode_table_armscii8.h"
      36                 : 
      37                 : static int mbfl_filt_ident_armscii8(int c, mbfl_identify_filter *filter);
      38                 : 
      39                 : static const char *mbfl_encoding_armscii8_aliases[] = {"ArmSCII-8", "ArmSCII8", "ARMSCII-8", "ARMSCII8", NULL};
      40                 : 
      41                 : const mbfl_encoding mbfl_encoding_armscii8 = {
      42                 :         mbfl_no_encoding_armscii8,
      43                 :         "ArmSCII-8",
      44                 :         "ArmSCII-8",
      45                 :         (const char *(*)[])&mbfl_encoding_armscii8_aliases,
      46                 :         NULL,
      47                 :         MBFL_ENCTYPE_SBCS
      48                 : };
      49                 : 
      50                 : const struct mbfl_identify_vtbl vtbl_identify_armscii8 = {
      51                 :         mbfl_no_encoding_armscii8,
      52                 :         mbfl_filt_ident_common_ctor,
      53                 :         mbfl_filt_ident_common_dtor,
      54                 :         mbfl_filt_ident_armscii8
      55                 : };
      56                 : 
      57                 : const struct mbfl_convert_vtbl vtbl_wchar_armscii8 = {
      58                 :         mbfl_no_encoding_wchar,
      59                 :         mbfl_no_encoding_armscii8,
      60                 :         mbfl_filt_conv_common_ctor,
      61                 :         mbfl_filt_conv_common_dtor,
      62                 :         mbfl_filt_conv_wchar_armscii8,
      63                 :         mbfl_filt_conv_common_flush
      64                 : };
      65                 : 
      66                 : const struct mbfl_convert_vtbl vtbl_armscii8_wchar = {
      67                 :         mbfl_no_encoding_armscii8,
      68                 :         mbfl_no_encoding_wchar,
      69                 :         mbfl_filt_conv_common_ctor,
      70                 :         mbfl_filt_conv_common_dtor,
      71                 :         mbfl_filt_conv_armscii8_wchar,
      72                 :         mbfl_filt_conv_common_flush
      73                 : };
      74                 : 
      75                 : #define CK(statement)   do { if ((statement) < 0) return (-1); } while (0)
      76                 : 
      77                 : /*
      78                 :  * armscii8 => wchar
      79                 :  */
      80                 : int mbfl_filt_conv_armscii8_wchar(int c, mbfl_convert_filter *filter)
      81               0 : {
      82                 :         int s;
      83                 : 
      84               0 :         if (c >= 0 && c < armscii8_ucs_table_min) {
      85               0 :                 s = c;
      86               0 :         } else if (c >= armscii8_ucs_table_min && c < 0x100) {
      87               0 :                 s = armscii8_ucs_table[c - armscii8_ucs_table_min];
      88               0 :                 if (s <= 0) {
      89               0 :                         s = c;
      90               0 :                         s &= MBFL_WCSPLANE_MASK;
      91               0 :                         s |= MBFL_WCSPLANE_ARMSCII8;
      92                 :                 }
      93                 :         } else {
      94               0 :                 s = c;
      95               0 :                 s &= MBFL_WCSGROUP_MASK;
      96               0 :                 s |= MBFL_WCSGROUP_THROUGH;
      97                 :         }
      98                 : 
      99               0 :         CK((*filter->output_function)(s, filter->data));
     100                 : 
     101               0 :         return c;
     102                 : }
     103                 : 
     104                 : /*
     105                 :  * wchar => armscii8
     106                 :  */
     107                 : int mbfl_filt_conv_wchar_armscii8(int c, mbfl_convert_filter *filter)
     108               0 : {
     109                 : 
     110                 :         int s, n;
     111                 : 
     112               0 :         if (c >= 0x28 && c < 0x30) {
     113               0 :                 s = ucs_armscii8_table[c-0x28];
     114               0 :         } else if (c < armscii8_ucs_table_min) {
     115               0 :                 s = c;
     116                 :         } else {
     117               0 :                 s = -1;
     118               0 :                 n = armscii8_ucs_table_len-1;
     119               0 :                 while (n >= 0) {
     120               0 :                         if (c == armscii8_ucs_table[n]) {
     121               0 :                                 s = armscii8_ucs_table_min + n;
     122               0 :                                 break;
     123                 :                         }
     124               0 :                         n--;
     125                 :                 }
     126               0 :                 if (s <= 0 && (c & ~MBFL_WCSPLANE_MASK) == MBFL_WCSPLANE_ARMSCII8) {
     127               0 :                         s = c & MBFL_WCSPLANE_MASK;
     128                 :                 }
     129                 :         }
     130                 : 
     131               0 :         if (s >= 0) {
     132               0 :                 CK((*filter->output_function)(s, filter->data));
     133                 :         } else {
     134               0 :                 if (filter->illegal_mode != MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
     135               0 :                         CK(mbfl_filt_conv_illegal_output(c, filter));
     136                 :                 }
     137                 :         }
     138                 : 
     139               0 :         return c;
     140                 : }
     141                 : 
     142                 : static int mbfl_filt_ident_armscii8(int c, mbfl_identify_filter *filter)
     143               0 : {
     144               0 :         if (c >= armscii8_ucs_table_min && c <= 0xff)
     145               0 :                 filter->flag = 0;
     146                 :         else
     147               0 :                 filter->flag = 1; /* not it */
     148               0 :         return c;
     149                 : }