home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / libi18n / uscan.c < prev   
Encoding:
C/C++ Source or Header  |  1998-04-08  |  9.6 KB  |  369 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18. #include "intlpriv.h"
  19. #include "ugen.h"
  20. #include "xp.h"
  21. /*=================================================================================
  22.  
  23. =================================================================================*/
  24. typedef  XP_Bool (*uSubScannerFunc) (unsigned char* in, uint16* out);
  25. /*=================================================================================
  26.  
  27. =================================================================================*/
  28.  
  29. typedef XP_Bool (*uScannerFunc) (
  30.         uShiftTable             *shift,
  31.         int32*                state,
  32.         unsigned char        *in,
  33.         uint16                *out,
  34.         uint16                 inbuflen,
  35.         uint16*                inscanlen
  36. );
  37.  
  38. MODULE_PRIVATE XP_Bool uScan(        
  39.         uShiftTable             *shift,
  40.         int32*                state,
  41.         unsigned char        *in,
  42.         uint16                *out,
  43.         uint16                 inbuflen,
  44.         uint16*                inscanlen
  45. );
  46.  
  47. #define uSubScanner(sub,in,out)    (* m_subscanner[sub])((in),(out))
  48.  
  49. PRIVATE XP_Bool uCheckAndScanAlways1Byte(
  50.         uShiftTable             *shift,
  51.         int32*                state,
  52.         unsigned char        *in,
  53.         uint16                *out,
  54.         uint16                 inbuflen,
  55.         uint16*                inscanlen
  56. );
  57. PRIVATE XP_Bool uCheckAndScanAlways2Byte(
  58.         uShiftTable             *shift,
  59.         int32*                state,
  60.         unsigned char        *in,
  61.         uint16                *out,
  62.         uint16                 inbuflen,
  63.         uint16*                inscanlen
  64. );
  65. PRIVATE XP_Bool uCheckAndScanAlways2ByteShiftGR(
  66.         uShiftTable             *shift,
  67.         int32*                state,
  68.         unsigned char        *in,
  69.         uint16                *out,
  70.         uint16                 inbuflen,
  71.         uint16*                inscanlen
  72. );
  73. PRIVATE XP_Bool uCheckAndScanByTable(
  74.         uShiftTable             *shift,
  75.         int32*                state,
  76.         unsigned char        *in,
  77.         uint16                *out,
  78.         uint16                 inbuflen,
  79.         uint16*                inscanlen
  80. );
  81. PRIVATE XP_Bool uCheckAndScan2ByteGRPrefix8F(
  82.         uShiftTable             *shift,
  83.         int32*                state,
  84.         unsigned char        *in,
  85.         uint16                *out,
  86.         uint16                 inbuflen,
  87.         uint16*                inscanlen
  88. );
  89. PRIVATE XP_Bool uCheckAndScan2ByteGRPrefix8EA2(
  90.         uShiftTable             *shift,
  91.         int32*                state,
  92.         unsigned char        *in,
  93.         uint16                *out,
  94.         uint16                 inbuflen,
  95.         uint16*                inscanlen
  96. );
  97.  
  98.  
  99. PRIVATE XP_Bool uScanAlways2Byte(
  100.         unsigned char*        in,
  101.         uint16*                out
  102. );
  103. PRIVATE XP_Bool uScanAlways2ByteShiftGR(
  104.         unsigned char*        in,
  105.         uint16*                out
  106. );
  107. PRIVATE XP_Bool uScanAlways1Byte(
  108.         unsigned char*        in,
  109.         uint16*                out
  110. );
  111. PRIVATE XP_Bool uScanAlways1BytePrefix8E(
  112.         unsigned char*        in,
  113.         uint16*                out
  114. );
  115. PRIVATE XP_Bool uScanAlways2ByteUTF8(
  116.         unsigned char*        in,
  117.         uint16*                out
  118. );
  119. PRIVATE XP_Bool uScanAlways3ByteUTF8(
  120.         unsigned char*        in,
  121.         uint16*                out
  122. );
  123. /*=================================================================================
  124.  
  125. =================================================================================*/
  126. PRIVATE uScannerFunc m_scanner[uNumOfCharsetType] =
  127. {
  128.     uCheckAndScanAlways1Byte,
  129.     uCheckAndScanAlways2Byte,
  130.     uCheckAndScanByTable,
  131.     uCheckAndScanAlways2ByteShiftGR,
  132.     uCheckAndScan2ByteGRPrefix8F,
  133.     uCheckAndScan2ByteGRPrefix8EA2,
  134. };
  135.  
  136. /*=================================================================================
  137.  
  138. =================================================================================*/
  139.  
  140. PRIVATE uSubScannerFunc m_subscanner[uNumOfCharType] =
  141. {
  142.     uScanAlways1Byte,
  143.     uScanAlways2Byte,
  144.     uScanAlways2ByteShiftGR,
  145.     uScanAlways1BytePrefix8E,
  146.     uScanAlways2ByteUTF8,
  147.     uScanAlways3ByteUTF8
  148. };
  149. /*=================================================================================
  150.  
  151. =================================================================================*/
  152. MODULE_PRIVATE XP_Bool uScan(        
  153.         uShiftTable             *shift,
  154.         int32*                state,
  155.         unsigned char        *in,
  156.         uint16                *out,
  157.         uint16                 inbuflen,
  158.         uint16*                inscanlen
  159. )
  160. {
  161.     return (* m_scanner[shift->classID]) (shift,state,in,out,inbuflen,inscanlen);
  162. }
  163. /*=================================================================================
  164.  
  165. =================================================================================*/
  166. PRIVATE XP_Bool uScanAlways1Byte(
  167.         unsigned char*        in,
  168.         uint16*                out
  169. )
  170. {
  171.     *out = (uint16) in[0];
  172.     return TRUE;
  173. }
  174.  
  175. /*=================================================================================
  176.  
  177. =================================================================================*/
  178. PRIVATE XP_Bool uScanAlways2Byte(
  179.         unsigned char*        in,
  180.         uint16*                out
  181. )
  182. {
  183.     *out = (uint16) (( in[0] << 8) | (in[1]));
  184.     return TRUE;
  185. }
  186. /*=================================================================================
  187.  
  188. =================================================================================*/
  189. PRIVATE XP_Bool uScanAlways2ByteShiftGR(
  190.         unsigned char*        in,
  191.         uint16*                out
  192. )
  193. {
  194.     *out = (uint16) ((( in[0] << 8) | (in[1])) &  0x7F7F);
  195.     return TRUE;
  196. }
  197.  
  198. /*=================================================================================
  199.  
  200. =================================================================================*/
  201. PRIVATE XP_Bool uScanAlways1BytePrefix8E(
  202.         unsigned char*        in,
  203.         uint16*                out
  204. )
  205. {
  206.     *out = (uint16) in[1];
  207.     return TRUE;
  208. }
  209. /*=================================================================================
  210.  
  211. =================================================================================*/
  212. PRIVATE XP_Bool uScanAlways2ByteUTF8(
  213.         unsigned char*        in,
  214.         uint16*                out
  215. )
  216. {
  217.     *out = (uint16) (((in[0] & 0x001F) << 6 )| (in[1] & 0x003F));
  218.     return TRUE;
  219. }
  220.  
  221. /*=================================================================================
  222.  
  223. =================================================================================*/
  224. PRIVATE XP_Bool uScanAlways3ByteUTF8(
  225.         unsigned char*        in,
  226.         uint16*                out
  227. )
  228. {
  229.     *out = (uint16) (((in[0] & 0x000F) << 12 ) | ((in[1] & 0x003F) << 6)
  230.                         | (in[2] & 0x003F));
  231.     return TRUE;
  232. }
  233. /*=================================================================================
  234.  
  235. =================================================================================*/
  236. PRIVATE XP_Bool uCheckAndScanAlways1Byte(
  237.         uShiftTable             *shift,
  238.         int32*                state,
  239.         unsigned char        *in,
  240.         uint16                *out,
  241.         uint16                 inbuflen,
  242.         uint16*                inscanlen
  243. )
  244. {
  245.     /*    Don't check inlen. The caller should ensure it is larger than 0 */
  246.     *inscanlen = 1;
  247.     *out = (uint16) in[0];
  248.  
  249.     return TRUE;
  250. }
  251.  
  252. /*=================================================================================
  253.  
  254. =================================================================================*/
  255. PRIVATE XP_Bool uCheckAndScanAlways2Byte(
  256.         uShiftTable             *shift,
  257.         int32*                state,
  258.         unsigned char        *in,
  259.         uint16                *out,
  260.         uint16                 inbuflen,
  261.         uint16*                inscanlen
  262. )
  263. {
  264.     if(inbuflen < 2)
  265.         return FALSE;
  266.     else
  267.     {
  268.         *inscanlen = 2;
  269.         *out = ((in[0] << 8) | ( in[1])) ;
  270.         return TRUE;
  271.     }
  272. }
  273. /*=================================================================================
  274.  
  275. =================================================================================*/
  276. PRIVATE XP_Bool uCheckAndScanAlways2ByteShiftGR(
  277.         uShiftTable             *shift,
  278.         int32*                state,
  279.         unsigned char        *in,
  280.         uint16                *out,
  281.         uint16                 inbuflen,
  282.         uint16*                inscanlen
  283. )
  284. {
  285.     if(inbuflen < 2)
  286.         return FALSE;
  287.     else
  288.     {
  289.         *inscanlen = 2;
  290.         *out = (((in[0] << 8) | ( in[1]))  & 0x7F7F);
  291.         return TRUE;
  292.     }
  293. }
  294. /*=================================================================================
  295.  
  296. =================================================================================*/
  297. PRIVATE XP_Bool uCheckAndScanByTable(
  298.         uShiftTable             *shift,
  299.         int32*                state,
  300.         unsigned char        *in,
  301.         uint16                *out,
  302.         uint16                 inbuflen,
  303.         uint16*                inscanlen
  304. )
  305. {
  306.     int16 i;
  307.     uShiftCell* cell = &(shift->shiftcell[0]);
  308.     int16 itemnum = shift->numOfItem;
  309.     for(i=0;i<itemnum;i++)
  310.     {
  311.         if( ( in[0] >=  cell[i].shiftin.Min) &&
  312.             ( in[0] <=  cell[i].shiftin.Max))
  313.         {
  314.             if(inbuflen < cell[i].reserveLen)
  315.                 return FALSE;
  316.             else
  317.             {
  318.                 *inscanlen = cell[i].reserveLen;
  319.                 return (uSubScanner(cell[i].classID,in,out));
  320.             }
  321.         }
  322.     }
  323.     return FALSE;
  324. }
  325. /*=================================================================================
  326.  
  327. =================================================================================*/
  328. PRIVATE XP_Bool uCheckAndScan2ByteGRPrefix8F(
  329.         uShiftTable             *shift,
  330.         int32*                state,
  331.         unsigned char        *in,
  332.         uint16                *out,
  333.         uint16                 inbuflen,
  334.         uint16*                inscanlen
  335. )
  336. {
  337.     if((inbuflen < 3) ||(in[0] != 0x8F))
  338.         return FALSE;
  339.     else
  340.     {
  341.         *inscanlen = 3;
  342.         *out = (((in[1] << 8) | ( in[2]))  & 0x7F7F);
  343.         return TRUE;
  344.     }
  345. }
  346. /*=================================================================================
  347.  
  348. =================================================================================*/
  349. PRIVATE XP_Bool uCheckAndScan2ByteGRPrefix8EA2(
  350.         uShiftTable             *shift,
  351.         int32*                state,
  352.         unsigned char        *in,
  353.         uint16                *out,
  354.         uint16                 inbuflen,
  355.         uint16*                inscanlen
  356. )
  357. {
  358.     if((inbuflen < 4) || (in[0] != 0x8E) || (in[1] != 0xA2))
  359.         return FALSE;
  360.     else
  361.     {
  362.         *inscanlen = 4;
  363.         *out = (((in[2] << 8) | ( in[3]))  & 0x7F7F);
  364.         return TRUE;
  365.     }
  366. }
  367.  
  368.  
  369.