gecko-dev/lib/libi18n/vietnam.c
1998-09-30 10:31:32 +00:00

1108 lines
54 KiB
C

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
/* vietnam.c */
#include "intlpriv.h"
extern int MK_OUT_OF_MEMORY;
/**************************< vietnam.c >*******************************/
/*** Purpose: Please put all conversion routines that related to ***/
/*** ------- the vietnamese character sets here for easy maintenance**/
/*** Modifications ***/
/*** 08/17/98: Vuong: - Add support for CP1258 ***/
/*** - Reduce similar functions into 1 function ***/
/*** - Cover the unsupported buffer for VNI & CP1258**/
/**********************************************************************/
/**********************************************************************/
/*** The following section handles conversion from VIQR to VISCII ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/**********************************************************************/
/*** VISCII - VIQR - VISCII - VIQR - VISCII - VIQR - VISCII - VIQR ***/
/**********************************************************************/
/***************************************************/
/*** For Mozilla, I disable the state feature of ***/
/*** VIQR (\V \M \L) by not defining TRUE_VIQR ***/
/***************************************************/
#ifdef TRUE_VIQR
PRIVATE unsigned char VIQRStateName[6] =
/*----0----1----2----3----4----5----*/
{ 'v', 'V', 'm', 'M', 'l', 'L' };
#endif
PRIVATE unsigned char DefaultVIQR[10] =
/*----0----1----2----3----4----5----6----7----8----9---*/
/*----'----`----?----~----.----(----^----+----d----\---*/
{ 39, 96, 63, 126, 46, 40, 94, 43, 100, 92 };
PRIVATE unsigned char HotChars[66] =
/*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y----*/
{ 97, 229, 226, 101, 234, 105, 111, 244, 189, 117, 223, 121,
/*----a'---a`---a?---a~---a.---e'---e`---e?---e~---e.--------*/
225, 224, 228, 227, 213, 233, 232, 235, 168, 169,
/*----o'---o`---o?---o~---o.---u'---u`---u?---u~---u.---d----*/
243, 242, 246, 245, 247, 250, 249, 252, 251, 248, 100,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y----*/
65, 197, 194, 69, 202, 73, 79, 212, 180, 85, 191, 89,
/*----A'---A`---A?---A~---A.---E'---E`---E?---E~---E.--------*/
193, 192, 196, 195, 128, 201, 200, 203, 136, 137,
/*----O'---O`---O?---O~---O.---U'---U`---U?---U~---U.---D----*/
211, 210, 153, 160, 154, 218, 217, 156, 157, 158, 68 };
PRIVATE unsigned char CombiToneChar[5][24] =
/*************************** Acute ' ******************************/
{ /*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y---*/
{ 225, 161, 164, 233, 170, 237, 243, 175, 190, 250, 209, 253,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y---*/
193, 129, 132, 201, 138, 205, 211, 143, 149, 218, 186, 221 },
/*************************** Grave ` ******************************/
/*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y---*/
{ 224, 162, 165, 232, 171, 236, 242, 176, 182, 249, 215, 207,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y---*/
192, 130, 133, 200, 139, 204, 210, 144, 150, 217, 187, 159 },
/*************************** Hook Above ? *************************/
/*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y---*/
{ 228, 198, 166, 235, 172, 239, 246, 177, 183, 252, 216, 214,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y---*/
196, 2, 134, 203, 140, 155, 153, 145, 151, 156, 188, 20 },
/*************************** Tilde ~ ******************************/
/*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y---*/
{ 227, 199, 231, 168, 173, 238, 245, 178, 222, 251, 230, 219,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y---*/
195, 5, 6, 136, 141, 206, 160, 146, 179, 157, 255, 25 },
/*************************** Dot Below . **************************/
/*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y---*/
{ 213, 163, 167, 169, 174, 184, 247, 181, 254, 248, 241, 220,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y---*/
128, 131, 135, 137, 142, 152, 154, 147, 148, 158, 185, 30 }
};
PRIVATE unsigned char CombiModiChar[3][66] =
/*************************** Breve ( ******************************/
{ /*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y---*/
{ 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*----a'---a`---a?---a~---a.---e'---e`---e?---e~---e.--------*/
161, 162, 198, 199, 163, 0, 0, 0, 0, 0,
/*----o'---o`---o?---o~---o.---u'---u`---u?---u~---u.---d----*/
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y---*/
197, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*----A'---A`---A?---A~---A.---E'---E`---E?---E~---E.--------*/
129, 130, 2, 5, 131, 0, 0, 0, 0, 0,
/*----O'---O`---O?---O~---O.---U'---U`---U?---U~---U.---D----*/
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
/*************************** Circumflex ^ *************************/
/*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y---*/
{ 226, 0, 0, 234, 0, 0, 244, 0, 0, 0, 0, 0,
/*----a'---a`---a?---a~---a.---e'---e`---e?---e~---e.--------*/
164, 165, 166, 231, 167, 170, 171, 172, 173, 174,
/*----o'---o`---o?---o~---o.---u'---u`---u?---u~---u.---d----*/
175, 176, 177, 178, 181, 0, 0, 0, 0, 0, 0,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y---*/
194, 0, 0, 202, 0, 0, 212, 0, 0, 0, 0, 0,
/*----A'---A`---A?---A~---A.---E'---E`---E?---E~---E.--------*/
183, 133, 134, 6, 135, 138, 139, 140, 141, 142,
/*----O'---O`---O?---O~---O.---U'---U`---U?---U~---U.---D----*/
143, 144, 145, 146, 147, 0, 0, 0, 0, 0, 0 },
/*************************** Horn + *******************************/
/*----a----a(---a^---e----e^---i----o----o^---o+---u----u+---y---*/
{ 0, 0, 0, 0, 0, 0, 189, 0, 0, 223, 0, 0,
/*----a'---a`---a?---a~---a.---e'---e`---e?---e~---e.--------*/
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*----o'---o`---o?---o~---o.---u'---u`---u?---u~---u.---d----*/
190, 182, 183, 222, 254, 209, 215, 216, 230, 241, 0,
/*----A----A(---A^---E----E^---I----O----O^---O+---U----U+---Y---*/
0, 0, 0, 0, 0, 0, 180, 0, 0, 191, 0, 0,
/*----A'---A`---A?---A~---A.---E'---E`---E?---E~---E.--------*/
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*----O'---O`---O?---O~---O.---U'---U`---U?---U~---U.---D----*/
149, 150, 151, 179, 148, 186, 187, 188, 255, 185, 0 }
};
PRIVATE uint16 VIS_VIQ[128] = /*** 128 to 255 ***/
{ 0x1041,0x2141,0x2241,0x3041,0x4141,0x4241,0x4441,0x5041,
0x0845,0x1045,0x4145,0x4245,0x4445,0x4845,0x5045,0x414f,
0x424f,0x444f,0x484f,0x504f,0x904f,0x814f,0x824f,0x844f,
0x1049,0x044f,0x104f,0x0449,0x0455,0x0855,0x1055,0x0259,
0x084f,0x2161,0x2261,0x3061,0x4161,0x4261,0x4461,0x5061,
0x0865,0x1065,0x4165,0x4265,0x4465,0x4865,0x5065,0x416f,
0x426f,0x446f,0x486f,0x884f,0x804f,0x506f,0x826f,0x846f,
0x1069,0x9055,0x8155,0x8255,0x8455,0x806f,0x816f,0x8055,
0x0241,0x0141,0x4041,0x0841,0x0441,0x2041,0x2461,0x2861,
0x0245,0x0145,0x4045,0x0445,0x0249,0x0149,0x0849,0x0279,
0x0000,0x8175,0x024f,0x014f,0x404f,0x1061,0x0479,0x8275,
0x8475,0x0255,0x0155,0x0879,0x1079,0x0159,0x886f,0x8075,
0x0261,0x0161,0x4061,0x0861,0x0461,0x2061,0x8875,0x4861,
0x0265,0x0165,0x4065,0x0465,0x0269,0x0169,0x0869,0x0469,
0x0000,0x9075,0x026f,0x016f,0x406f,0x086f,0x046f,0x106f,
0x1075,0x0275,0x0175,0x0875,0x0475,0x0179,0x906f,0x8855 };
PRIVATE unsigned char VNI_VIS[191] = /*** Mapping from 65 .. 255 ***/
{ 0xff,0x42,0x43,0x44,0xff,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,
0x4d,0x4e,0xff,0x50,0x51,0x52,0x53,0x54,0xff,0x56,0x57,0x58,
0xff,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,0xff,0x62,0x63,0x64,
0xff,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0xff,0x70,
0x71,0x72,0x73,0x74,0xff,0x76,0x77,0x78,0xff,0x7a,0x7b,0x7c,
0x7d,0x7e,0x7f,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,
0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,0xa0,
0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,
0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,
0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf,0xc0,0xc1,0xc2,0xc3,0xc4,
0xc5,0x9b,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0x1e,0xcf,0xd0,
0xd0,0x98,0xce,0xff,0xd5,0xff,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,
0xdd,0xde,0xdf,0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xef,0xe7,0xe8,
0xe9,0xea,0xeb,0xec,0xed,0xdc,0xef,0xf0,0xf0,0xb8,0xee,0xff,
0xf5,0xff,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xdc };
PRIVATE uint16 VNIextended_VIS[118] =
{ 0xc085,0xc184,0xc2c2,0xc306,0xc487,0xc586,0xc882,0xc981,
0xcac5,0xcb83,0xcf80,0xd5c3,0xd8c0,0xd9c1,0xda02,0xdbc4,
0xdc05,0xc08b,0xc18a,0xc2ca,0xc38d,0xc48e,0xc58c,0xcf89,
0xd588,0xd8c8,0xd9c9,0xdbcb,0xc090,0xc18f,0xc2d4,0xc392,
0xc493,0xc591,0xcf9a,0xd5a0,0xd8d2,0xd9d3,0xdb99,0xcf9e,
0xd59d,0xd8d9,0xd9da,0xdb9c,0xcf1e,0xd519,0xd89f,0xd9dd,
0xdb14,0xe0a5,0xe1a4,0xe2e2,0xe3e7,0xe4a7,0xe5a6,0xe8a2,
0xe9a1,0xeae5,0xeba3,0xefd5,0xf5e3,0xf8e0,0xf9e1,0xfac6,
0xfbe4,0xfcc7,0xe0ab,0xe1aa,0xe2ea,0xe3ad,0xe4ae,0xe5ac,
0xefa9,0xf5a8,0xf8e8,0xf9e9,0xfbeb,0xe0b0,0xe1af,0xe2f4,
0xe3b2,0xe4b5,0xe5b1,0xeff7,0xf5f5,0xf8f2,0xf9f3,0xfbf6,
0xeff8,0xf5fb,0xf8f9,0xf9fa,0xfbfc,0xefdc,0xf5db,0xf8cf,
0xf9fd,0xfbd6,0xcf94,0xd5b3,0xd896,0xd995,0xdb97,0xcfb9,
0xd5ff,0xd8bb,0xd9ba,0xdbbc,0xeffe,0xf5de,0xf8b6,0xf9be,
0xfbb7,0xeff1,0xf5e6,0xf8d7,0xf9d1,0xfbd8 };
PRIVATE uint16 VIS_VNI[128] = /*** 128 to 255 ***/
{ 0xcf41,0xc941,0xc841,0xcb41,0xc141,0xc041,0xc541,0xc441,
0xd545,0xcf45,0xc145,0xc045,0xc545,0xc345,0xc445,0xc14f,
0xc04f,0xc54f,0xc34f,0xc44f,0xcfd4,0xd9d4,0xd8d4,0xdbd4,
0x00d2,0xdb4f,0xcf4f,0x00c6,0xdb55,0xd555,0xcf55,0xd859,
0xd54f,0xe961,0xe861,0xeb61,0xe161,0xe061,0xe561,0xe461,
0xf565,0xef65,0xe165,0xe065,0xe565,0xe365,0xe465,0xe16f,
0xe06f,0xe56f,0xe36f,0xd5d4,0x00d4,0xe46f,0xf8f4,0xfbf4,
0x00f2,0xcfd6,0xd9d6,0xd8d6,0xdbd6,0x00f4,0xf9f4,0x00d6,
0xd841,0xd941,0xc241,0xd541,0xdb41,0xca41,0xfa61,0xfc61,
0xd845,0xd945,0xc245,0xdb45,0x00cc,0x00cd,0x00d3,0xf879,
0x00d1,0xf9f6,0xd84f,0xd94f,0xc24f,0xef61,0xfb79,0xf8f6,
0xfbf6,0xd855,0xd955,0xf579,0x00ee,0xd959,0xf5f4,0x00f6,
0xf861,0xf961,0xe261,0xf561,0xfb61,0xea61,0xf5f6,0xe361,
0xf865,0xf965,0xe265,0xfb65,0x00ec,0x00ed,0x00f3,0x00e6,
0x00f1,0xeff6,0xf86f,0xf96f,0xe26f,0xf56f,0xfb6f,0xef6f,
0xef75,0xf875,0xf975,0xf575,0xfb75,0xf979,0xeff4,0xd5d6 };
PRIVATE unsigned char CP1258_VIS[191] = /*** Mapping from 65 .. 255 ***/
{ 0xff,0x42,0x43,0x44,0xff,0x46,0x47,0x48,0xff,0x4a,0x4b,0x4c,
0x4d,0x4e,0xff,0x50,0x51,0x52,0x53,0x54,0xff,0x56,0x57,0x58,
0xff,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,0xff,0x62,0x63,0x64,
0xff,0x66,0x67,0x68,0xff,0x6a,0x6b,0x6c,0x6d,0x6e,0xff,0x70,
0x71,0x72,0x73,0x74,0xff,0x76,0x77,0x78,0xff,0x7a,0x7b,0x7c,
0x7d,0x7e,0x7f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,
0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,
0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,
0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,
0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,
0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0x5f,0xc0,0xc1,0xff,0xff,0x5f,
0x5f,0x5f,0x5f,0xc8,0xc9,0xff,0x5f,0x5f,0xcd,0x5f,0x5f,0xd0,
0x5f,0x5f,0xd3,0xff,0xff,0x5f,0x5f,0x5f,0xd9,0xda,0x5f,0x5f,
0xff,0x5f,0x5f,0xe0,0xe1,0xff,0xff,0x5f,0x5f,0x5f,0x5f,0xe8,
0xe9,0xff,0x5f,0x5f,0xed,0x5f,0x5f,0xf0,0x5f,0x5f,0xf3,0xff,
0xff,0x5f,0x5f,0x5f,0xf9,0xfa,0x5f,0x5f,0xff,0x5f,0x5f };
PRIVATE uint16 CP1258extended_VIS[104] =
{ 0x49cc,0x4fd2,0x599f,0x69ec,0x6ff2,0x79cf,0xc285,0xc382,
0xca8b,0xd490,0xd596,0xddbb,0xe2a5,0xe3a2,0xeaab,0xf4b0,
0xf5b6,0xfdd7,0x41c4,0x45cb,0x499b,0x4f99,0x559c,0x5914,
0x61e4,0x65eb,0x69ef,0x6ff6,0x75fc,0x79d6,0xc286,0xc302,
0xca8c,0xd491,0xd597,0xddbc,0xe2a6,0xe3c6,0xeaac,0xf4b1,
0xf5b7,0xfdd8,0x41c3,0x4588,0x49ce,0x4fa0,0x559d,0x5919,
0x61e3,0x65a8,0x69ee,0x6ff5,0x75fb,0x79db,0xc206,0xc305,
0xca8d,0xd492,0xd5b3,0xddff,0xe2e7,0xe3c7,0xeaad,0xf4b2,
0xf5de,0xfde6,0x59dd,0x79fd,0xc284,0xc381,0xca8a,0xd48f,
0xd595,0xddba,0xe2a4,0xe3a1,0xeaaa,0xf4af,0xf5be,0xfdd1,
0x4180,0x4589,0x4998,0x4f9a,0x559e,0x591e,0x61d5,0x65a9,
0x69b8,0x6ff7,0x75f8,0x79dc,0xc287,0xc383,0xca8e,0xd493,
0xd594,0xddb9,0xe2a7,0xe3a3,0xeaae,0xf4b5,0xf5fe,0xfdf1 };
PRIVATE uint16 VIS_CP1258[128] = /*** 128 to 255 ***/
{ 0xf241,0xecc3,0xccc3,0xf2c3,0xecc2,0xccc2,0xd2c2,0xf2c2,
0xde45,0xf245,0xecca,0xccca,0xd2ca,0xdeca,0xf2ca,0xecd4,
0xccd4,0xd2d4,0xded4,0xf2d4,0xf2d5,0xecd5,0xccd5,0xd2d5,
0xf249,0xd24f,0xf24f,0xd249,0xd255,0xde55,0xf255,0xcc59,
0xde4f,0xece3,0xcce3,0xf2e3,0xece2,0xcce2,0xd2e2,0xf2e2,
0xde65,0xf265,0xecea,0xccea,0xd2ea,0xdeea,0xf2ea,0xecf4,
0xccf4,0xd2f4,0xdef4,0xded5,0x00d5,0xf2f4,0xccf5,0xd2f5,
0xf269,0xf2dd,0xecdd,0xccdd,0xd2dd,0x00f5,0xecf5,0x00dd,
0x00c0,0x00c1,0x00c2,0xde41,0xd241,0x00c3,0xd2e3,0xdee3,
0x00c8,0x00c9,0x00ca,0xd245,0xcc49,0x00cd,0xde49,0xcc79,
0x00d0,0xecfd,0xcc4f,0x00d3,0x00d4,0xf261,0xd279,0xccfd,
0xd2fd,0x00d9,0x00da,0xde79,0xf279,0xec59,0xdef5,0x00fd,
0x00e0,0x00e1,0x00e2,0xde61,0xd261,0x00e3,0xdefd,0xdee2,
0x00e8,0x00e9,0x00ea,0xd265,0xcc69,0x00ed,0xde69,0xd269,
0x00f0,0xf2fd,0xcc6f,0x00f3,0x00f4,0xde6f,0xd26f,0xf26f,
0xf275,0x00f9,0x00fa,0xde75,0xd275,0xec79,0xf2f5,0xdedd };
typedef int32 (*VietFunc)(const unsigned char *frombuffer, unsigned char *tobuffer, int32 maxsz, unsigned char *uncvtbuf);
PRIVATE unsigned char charType( unsigned char c);
PRIVATE unsigned char IsVIQRWord(const unsigned char *s,
int32 len_s,
int32 fromI,
int32 *toI);
PRIVATE unsigned char C_VIQR_to_VISCII( unsigned char *HotKeys,
unsigned char *CurState,
unsigned char *LastChar,
unsigned char NewChar);
PRIVATE unsigned char C_VISCII_to_VIQR( unsigned char *HotKeys,
unsigned char VISCII,
unsigned char *char1,
unsigned char *char2,
unsigned char *char3);
PRIVATE int32 S_VIQR_to_VISCII( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf);
PRIVATE int32 S_VISCII_to_VIQR( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf);
PRIVATE int32 S_VNI_to_VISCII( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf);
PRIVATE int32 S_VISCII_to_VNI( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf);
PRIVATE int32 S_CP1258_to_VISCII(const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf);
PRIVATE int32 S_VISCII_to_CP1258(const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf);
PRIVATE unsigned char *xlat_vis_ucs2_X(CCCDataObject obj,
const unsigned char *buf,
int32 bufsz);
PRIVATE unsigned char *xlat_X_ucs2_vis(CCCDataObject obj,
const unsigned char *buf,
int32 bufsz);
PRIVATE unsigned char *xlat_any_2_any (
CCCDataObject obj,
const unsigned char *in_buf,
int32 in_bufsz,
VietFunc customfunc,
int16 buf_ratio,
int16 do_unconverted);
/**********************************************************************/
/*** Function: charType() ***/
/*** Purpose: Determine the type of a character. ***/
/*** Returns: 0 - If c is a non-alpha character ***/
/*** 1 - If c is a consonant. ***/
/*** 2 - If c is a diacritical mark ***/
/*** 3 - If c is a hi-bit character ***/
/*** 4 - If c is a vowel (AEIOUY) ***/
/**********************************************************************/
PRIVATE unsigned char charType( unsigned char c)
{
if (c < 0x27) /*** below ' ***/
return (0);
else if (c > 0x7e) /*** above ~ ***/
return (3);
else {
if (XP_STRCHR("),-/0123456789:;<=>@[\\]_{|}",c)) return(0);
if (XP_IS_ALPHA(c)) {
if (XP_STRCHR("AEIOUYaeiouy",c)) return(4);
else return(1);
}
else return(2);
}
}
/**********************************************************************/
/*** Function: IsVIQRWord() ***/
/*** Purpose: Parse a string, marks the location of the first word.***/
/*** Returns: 0: if the word is not a VIQR word ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/**********************************************************************/
PRIVATE unsigned char IsVIQRWord(const unsigned char *s,
int32 len_s,
int32 fromI,
int32 *toI)
{ unsigned char c, t, flg;
int32 i, ctr_letter, ctr_mark, ctr_afterperiod, ctr_vowel;
flg = 0;
ctr_afterperiod = ctr_vowel = - len_s; /* set it a big negative number */
ctr_letter = ctr_mark = 0;
for (i=fromI; ((i < len_s) && ('\0' != (c = s[i]))); i++) {
t = charType(c);
if ((t == 0) || (t == 3)) /*** is control or hi-bit char? ***/
flg = 1; /**If it is not-viqr, mark the flag. **/
else { if (flg == 1) { /**And if after the not-viqr is viqr,**/
break; /**then done **/
}
switch (t) {
case 2: /*If a mark appears before any letter, ignore*/
if (ctr_letter > 0) ctr_mark++;
if (c == '.') { /** Pay attention to the period **/
if (ctr_afterperiod < 0) ctr_afterperiod=0;
}
break;
case 4: /* Vowel's first encounter will reset the counter*/
if (ctr_vowel > 0) { /** if Vowel,Consonant, and */
ctr_letter = 10; /** vowel again, then we */
} /** force an invalid word */
ctr_vowel = -1; /** flow to next case */
case 1: /* Consonant */
ctr_vowel++;
ctr_letter++; /** Count the # of letters */
ctr_afterperiod++;
}
}
}
*toI = i-1; /*** So the first word will be between fromI and toI ***/
/*******************************************************************/
/*** Now, the hard part, I should check the semantic of the word,***/
/*** But it will take more comparisions, and I don't think it is ***/
/*** necessary, so I temporarily use the common sense here to ***/
/*** detect a vietnamese word. I'll implement semantic checking ***/
/*** later if it's really necessary ***/
if (*toI > fromI) {
/*********************************************************/
/**First: If there are more 2 letters after a "." -> NO **/
if (ctr_afterperiod > 2) return(0);
/*********************************************************/
/**Then: Check for special cases of DD, Dd, dD, dd ***/
c = s[fromI];
if ((c == 'D') || (c == 'd')) {
c = s[fromI+1];
if ((c == 'D') || (c == 'd')) {
ctr_letter--;
if (ctr_mark == 0) ctr_mark++;
}
}
/*********************************************************/
/**Then: Check for common knowledge: A vietnamese word ***/
/**always has less than 8 letters and less than 4 ***/
/**diacritical marks at the same time ***/
if ((ctr_letter > 0) && (ctr_letter < 8)) {
if ((ctr_mark > 0) && (ctr_mark < 4)) return(1);
}
}
return(0);
}
/*********************************************************************/
/*** Function : C_VIQR_to_VISCII() ***/
/*** Purpose: Given 2 VIQR characters, combine into 1 VISCII ***/
/*** ------- character if possible ***/
/*** Return: 0-FALSE: Couldn't combined. ***/
/*** ------: 1-TRUE: if LastChar is modified to be a VISCII char ***/
/*** 2-TRUE: A state is changing (return BackSpace) ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/*********************************************************************/
PRIVATE unsigned char C_VIQR_to_VISCII( unsigned char *HotKeys,
unsigned char *CurState,
unsigned char *LastChar,
unsigned char NewChar)
{ unsigned char idkey, idchar, ochar, nchar, converted;
converted = 0;
ochar=*LastChar;
#ifdef TRUE_VIQR
unsigned char statechange, cs;
/***********************************************************/
statechange=(ochar==HotKeys[9]);
cs = *CurState;
if (cs > 0) {
if (cs >= 'a') {
cs -= 32; /*** Convert from lowercase to uppercase ***/
*CurState = cs;
*LastChar=NewChar;
return(1);
}
else if (statechange) {
for (idkey=0;idkey < 6; idkey++)
if (NewChar==VIQRStateName[idkey]) break;
statechange=(idkey & 6);
if (statechange < 6) { /**A state change is detected**/
cs = VIQRStateName[statechange | 1];
*CurState=cs;
*LastChar=8;
return(2);
}
}
}
/********************************************************************/
if (cs==VIQRStateName[5]) { } /******** Literal **************/
else if (cs==VIQRStateName[3]) { /******** English **************/
if (statechange) { cs = '\\';
*CurState=cs;
*LastChar=NewChar;
converted=1;
}
}
else
#endif
{ /*************************************************************/
/******** Vietnamese (V) or English+ESC (\) mode *************/
/*************************************************************/
/****** Solve the problem of DD (4 different cases ***********/
nchar = NewChar;
switch (nchar) {
case 'D': /*** if (HotKeys[8]=='d') ***/
nchar = 'd';
case 'd': if (ochar == '-') ochar = nchar;
break;
case '*': nchar = '+'; /** sometimes a * is used */
break; /** for + instead, */
}
/*********************************************************/
for (idkey=0; idkey < 9; idkey++)
if (nchar == HotKeys[idkey]) {
#ifdef TRUE_VIQR
if (statechange) /*** Escape character ***/
converted=1;
else
#endif
for (idchar=0; idchar < 66; idchar++)
if (ochar==HotChars[idchar]) {
if (idkey < 5) {
/******** For '`?~. tones ****/
ochar=idchar % 33;
if (ochar < 12)
NewChar=CombiToneChar[idkey]
[ochar+(idchar / 33)*12];
else NewChar=0;
} /*****************************/
else
if (idkey==8) { /****** For DD ****/
if ((idchar % 33) == 32)
NewChar=ochar+140;
else NewChar=0;
} /*****************************/
else /****** For ^(+ modifiers ****/
NewChar=CombiModiChar[idkey-5]
[idchar];
converted=(NewChar != 0);
break;
}
if (converted) *LastChar=NewChar;
break;
}
#ifdef TRUE_VIQR
if ((!converted) && (cs=='\\')) *CurState=VIQRStateName[3];
#endif
}
/********************************************************************/
return(converted);
}
/*********************************************************************/
/*** Function : C_VISCII_to_VIQR() ***/
/*** Purpose: Given 1 VISCII character, split to VIQR chars ***/
/*** Return: Number of returned characters. ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/*********************************************************************/
PRIVATE unsigned char C_VISCII_to_VIQR( unsigned char *HotKeys,
unsigned char VISCII,
unsigned char *char1,
unsigned char *char2,
unsigned char *char3)
{ uint16 key;
unsigned char mask, NumChars;
NumChars=1;
*char2=*char3=0;
key=VISCII;
/******************* Get the secret code *************************/
if (VISCII < 128) {
if (VISCII < 32)
switch (VISCII) {
case 2 : key= 9281; break; case 20 : key=1113; break;
case 5 : key=10305; break; case 25 : key=2137; break;
case 6 : key=18497; break; case 30 : key=4185; break;
}
}
else if ((VISCII==240) || (VISCII==208)) {
key-=140;
if (HotKeys[8]=='d') *char2=(unsigned char) key;
else *char2=HotKeys[8];
NumChars++;
}
else key=VIS_VIQ[VISCII-128];
/*****************************************************************/
*char1=key & 0xFF; /*** Get the base letter *******/
if ((key >>= 8)) /*** Get the diacritic marks ***/
for (mask=0x80,VISCII=7; key ; mask >>= 1, VISCII--)
if (key & mask) {
if (++NumChars ==2) *char2=HotKeys[VISCII];
else *char3=HotKeys[VISCII];
key &= (~mask);
}
return(NumChars);
}
/**********************************************************************/
/*** Procedure : S_VIQR_to_VISCII() ***/
/*** Purpose : Convert a VIQR string to a VISCII string. ***/
/*** ------- This routine will not convert any word that seems ***/
/*** not to be a Vietnamese word. Doing this, we will ***/
/*** avoid the problem of blind converting email, url, ***/
/*** html tags. ***/
/*** I would suggest all other vietnamese encodings ***/
/*** using this routine to convert from VIQR to their ***/
/*** codes (using VISCII as intermediate code) ***/
/*** eg: VIQR -> VISCII -> Vxxx ***/
/*** With this technique, then we will not need many ***/
/*** (duplicate) VIQR conversion routines. ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/*** Note: 08/19/98: Implemented the unconverted buffer processing ***/
/*** ---- but then removed because it is too complicated ***/
/*** (must examine the whole word). ***/
/*** Anyway the user always understand VIQR text ***/
/**********************************************************************/
PRIVATE int32 S_VIQR_to_VISCII( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf)
{ unsigned char oldc, newc, InitState, j, *p;
int32 fromI, toI, ctr, p_sz;
ctr=0;
InitState = 0;
p = (unsigned char *) frombuffer;
p_sz = maxsz;
fromI = 0;
while (fromI < p_sz) {
if ( IsVIQRWord(p, p_sz,fromI,&toI) ) {
/*******************************************************/
/*** This is a VIQR word, need conversion **************/
j = 0;
oldc = p[fromI++];
while ((fromI <= toI) && ('\0' != (newc = p[fromI]))) {
j = C_VIQR_to_VISCII(DefaultVIQR,&InitState,&oldc,newc);
if (j == 0) {
tobuffer[ctr++] = oldc;
oldc = newc;
}
fromI++;
}
if (j != 2) tobuffer[ctr++] = oldc;
}
else { /*******************************************************/
/*** This is not a VIQR word, simply copy it ***********/
while ((fromI <= toI) && ('\0' != (newc = p[fromI]))) {
tobuffer[ctr++] = newc;
fromI++;
}
}
}
tobuffer[ctr]=0;
return(ctr);
}
/**********************************************************************/
/*** Procedure : S_VISCII_to_VIQR() ***/
/*** Purpose : Convert a VISCII string to a VIQR string. ***/
/*** IMPORTANT : The size of tobuffer must be bigger than the size ***/
/*** --------- of frombuffer about 3 times (worst case) ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/**********************************************************************/
PRIVATE int32 S_VISCII_to_VIQR( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf)
{ int32 indx, i, n, ctr;
unsigned char c, cc[3];
indx = ctr = 0;
for (indx=0;((indx < maxsz) && ('\0' != (c=frombuffer[indx])));indx++) {
n = C_VISCII_to_VIQR(DefaultVIQR,c,cc,cc+1,cc+2);
if ((n==2) && (cc[1]=='d')) cc[1]=cc[0];
for (i=0; (i < n); i++) tobuffer[ctr++] = cc[i];
}
tobuffer[ctr]=0;
return(ctr);
}
/**********************************************************************/
/*** Function: S_VNI_to_VISCII() ***/
/*** Purpose: Converts a VNI string to a VISCII string ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/**********************************************************************/
PRIVATE int32 S_VNI_to_VISCII( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf)
{ unsigned char c, v, *p;
int32 i, ctr, p_sz, istart;
uint16 j, fr_i, to_i, x, idex, ibuf;
ctr = 0;
for (ibuf=0; ibuf < 2; ibuf++) {
if (ibuf == 0) {
/*** Process the un-converted buffer first ***/
p = uncvtbuf;
p_sz = XP_STRLEN((char*)p);
istart = 0;
}
else { /*** Then the input buffer next ***/
p = (unsigned char *) frombuffer;
p_sz = maxsz;
if (istart != 1) istart=0; /*** adjust the index if ***/
} /*** the 1st char used ***/
/***************************************************/
for (i = istart;(i < p_sz) && ('\0' != (c = p[i])); i++) {
if (c < 65) v = c; /*** saving 65 characters in the table ***/
else v = VNI_VIS[ c - 65 ];
if (v != 255) tobuffer[ctr++] = v;
else {
switch (c) {
case 65: idex = 0x0010; break;
case 69: idex = 0x111b; break;
case 79: idex = 0x1c26; break;
case 85: idex = 0x272b; break;
case 89: idex = 0x2c30; break;
case 97: idex = 0x3141; break;
case 101: idex = 0x424c; break;
case 111: idex = 0x4d57; break;
case 117: idex = 0x585c; break;
case 121: idex = 0x5d61; break;
case 212: idex = 0x6266; break;
case 214: idex = 0x676b; break;
case 244: idex = 0x6c70; break;
case 246: idex = 0x7175; break;
default: idex = 0;
}
if (idex != 0) {
j = i+1;
if (j >= p_sz) v = 0;
else v = p[j];
if ((v == 0) && (ibuf == 0) && (maxsz > 0)) {
/*** If end of un-convert buffer, ***/
/*** get first char of input buffer***/
v = (unsigned char) frombuffer[0];
istart = 2;
}
if (v) {
fr_i = (idex >> 8);
to_i = (idex & 0xFF);
for (j = fr_i; j <= to_i; j++) {
idex = VNIextended_VIS[j];
x = (idex >> 8);
if (x == v) {
x = (idex & 0xFF);
c = (unsigned char) x;
i++;
if (istart == 2) istart=1;
break;
}
}
if (j > to_i) {
switch (c) {
case 212: c = 180; break;
case 214: c = 191; break;
case 244: c = 189; break;
case 246: c = 223; break;
}
}
}
}
tobuffer[ctr++] = c;
}
}
}
tobuffer[ctr] = 0;
return(ctr);
}
/**********************************************************************/
/*** Function: S_VISCII_to_VNI() ***/
/*** Purpose: Converts a VISCII string to a VNI string ***/
/*** Note: tobuffer must have size at least 2 times bigger than ***/
/*** ---- than frombuffer (1-byte charset -> 2-byte charset) ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/**********************************************************************/
PRIVATE int32 S_VISCII_to_VNI( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf)
{ unsigned char c;
uint16 idex;
int32 i, ctr;
ctr = 0;
for (i = 0;(i < maxsz) && ('\0' != (c = (unsigned char) frombuffer[i])); i++) {
idex = 0;
if (c < 32)
switch (c) {
case 2: idex = 0xda41; break;
case 5: idex = 0xdc41; break;
case 6: idex = 0xc341; break;
case 20: idex = 0xdb59; break;
case 25: idex = 0xd559; break;
case 30: c = 0xCE; break;
}
else if (c > 127) idex = VIS_VNI[c-128];
if (idex) {
tobuffer[ctr++] = (unsigned char) (idex & 0xFF);
c = (unsigned char) (idex >> 8);
if (c) tobuffer[ctr++] = c;
}
else tobuffer[ctr++] = c;
}
tobuffer[ctr] = 0;
return(ctr);
}
/**********************************************************************/
/*** Function: S_CP1258_to_VISCII() ***/
/*** Purpose: Converts a CP1258 string to a VISCII string ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/**********************************************************************/
PRIVATE int32 S_CP1258_to_VISCII( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf)
{ unsigned char c, v, *p;
int32 i, ctr, p_sz, istart;
uint16 j, fr_i, to_i, x, idex, ibuf;
ctr = 0;
for (ibuf=0; ibuf < 2; ibuf++) {
if (ibuf == 0) {
/*** Process the un-converted buffer first ***/
p = uncvtbuf;
p_sz = XP_STRLEN((char*)p);
istart = 0;
}
else { /*** Then the input buffer next ***/
p = (unsigned char *) frombuffer;
p_sz = maxsz;
if (istart != 1) istart=0; /*** adjust the index if ***/
} /*** the 1st char used ***/
/***************************************************/
for (i = istart;(i < p_sz) && ('\0' != (c = p[i])); i++) {
if (c < 65) v = c; /*** saving 65 characters in the table ***/
else v = CP1258_VIS[ c - 65 ];
if (v != 255) tobuffer[ctr++] = v;
else { /*** now c contains the base letter *****************/
/*** Look for the next char as a diacritical mark ***/
j = i+1;
if (j >= p_sz) v = 0;
else v = p[j];
if ((v == 0) && (ibuf == 0) && (maxsz > 0)) {
/*** If end of un-convert buffer, ***/
/*** get first char of input buffer***/
v = (unsigned char) frombuffer[0];
istart = 2;
}
if (v) {
switch (v) {
case 0xcc: idex=0x0011; break;
case 0xd2: idex=0x1229; break;
case 0xde: idex=0x2a41; break;
case 0xec: idex=0x424f; break;
case 0xf2: idex=0x5067; break;
default: idex=0;
}
if (idex) {
fr_i = (idex >> 8);
to_i = (idex & 0xFF);
for (j = fr_i; j <= to_i; j++) {
idex = CP1258extended_VIS[j];
x = (idex >> 8);
if (x == c) {
x = (idex & 0xFF);
c = (unsigned char) x;
i++;
if (istart == 2) istart=1;
break;
}
}
}
}
tobuffer[ctr++] = c;
}
}
}
tobuffer[ctr] = 0;
return(ctr);
}
/**********************************************************************/
/*** Function: S_VISCII_to_CP1258() ***/
/*** Purpose: Converts a VISCII string to a CP1258 string ***/
/*** Note: tobuffer must have size at least 2 times bigger than ***/
/*** ---- than frombuffer (1-byte charset -> 2-byte charset) ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/**********************************************************************/
PRIVATE int32 S_VISCII_to_CP1258( const unsigned char *frombuffer,
unsigned char *tobuffer,
int32 maxsz,
unsigned char *uncvtbuf)
{ unsigned char c;
uint16 idex;
int32 i, ctr;
ctr = 0;
for (i = 0;(i < maxsz) && ('\0' != (c = (unsigned char) frombuffer[i])); i++) {
idex = 0;
if (c < 32)
switch (c) {
case 2: idex = 0xd2c3; break;
case 5: idex = 0xdec3; break;
case 6: idex = 0xdec2; break;
case 20: idex = 0xd259; break;
case 25: idex = 0xde59; break;
case 30: idex = 0xf259; break;
}
else if (c > 127) idex = VIS_CP1258[c-128];
if (idex) {
tobuffer[ctr++] = (unsigned char) (idex & 0xFF);
c = (unsigned char) (idex >> 8);
if (c) tobuffer[ctr++] = c;
}
else tobuffer[ctr++] = c;
}
tobuffer[ctr] = 0;
return(ctr);
}
/**********************************************************************/
/*** Function: xlat_vis_ucs2_X() ***/
/*** Purpose: Converts a converted temporary VISCII buffer to a ***/
/*** ------- to_charset via mz_AnyToAnyThroughUCS2 ***/
/**********************************************************************/
PRIVATE unsigned char *xlat_vis_ucs2_X(CCCDataObject obj,
const unsigned char *buf,
int32 bufsz)
{ unsigned char *out_buf;
uint16 oldcsid;
if (buf) {
oldcsid = INTL_GetCCCFromCSID(obj); /* Save current setting */
INTL_SetCCCFromCSID(obj, CS_VIET_VISCII); /* then set viscii */
out_buf = (unsigned char *) mz_AnyToAnyThroughUCS2(obj, buf, bufsz);
INTL_SetCCCFromCSID(obj, oldcsid); /* Restore current setting */
return(out_buf);
}
else return (NULL);
}
/**********************************************************************/
/*** Function: xlat_X_ucs2_vis() ***/
/*** Purpose: Converts a from_charset buffer to a temporary ***/
/*** ------- VISCII buffer via mz_AnyToAnyThroughUCS2 ***/
/**********************************************************************/
PRIVATE unsigned char *xlat_X_ucs2_vis(CCCDataObject obj,
const unsigned char *buf,
int32 bufsz)
{ unsigned char *out_buf;
uint16 oldcsid;
if (buf) {
oldcsid = INTL_GetCCCToCSID(obj); /* Save current setting */
INTL_SetCCCToCSID(obj, CS_VIET_VISCII); /* then set viscii */
out_buf = (unsigned char *) mz_AnyToAnyThroughUCS2(obj, buf, bufsz);
INTL_SetCCCToCSID(obj, oldcsid); /* Restore current setting */
return (out_buf);
}
else return (NULL);
}
/**********************************************************************/
/*** Function: xlat_any_2_any() ***/
/*** Purpose: Converts a from_csid buffer to a to_csid buffer ***/
/*** Arguments: in_buf: Ptr to the input buffer ***/
/*** --------- in_bufsize: Size in bytes of in_buf ***/
/*** customfunc: Address to the conversion function ***/
/*** buf_ratio: Contains the multiplication ratio for***/
/*** getting sufficient output memory ***/
/*** do_unconverted: flag telling to process unconverted**/
/*** buffer, it also used as a signal ***/
/*** where should stop when putting char**/
/*** into unconverted buffer ***/
/*** Returns: Returns NULL on failure, otherwise it returns a ***/
/*** ------- pointer to a buffer converted characters. ***/
/*** Caller must XP_FREE() this memory. ***/
/*** Implementer: Vuong Nguyen (vlangsj@pluto.ftos.net) ***/
/**********************************************************************/
PRIVATE unsigned char *xlat_any_2_any(
CCCDataObject obj,
const unsigned char *in_buf,
int32 in_bufsz,
VietFunc customfunc,
int16 buf_ratio,
int16 do_unconverted)
{
int32 out_bufsz, uncvt_bufsz, i, ctr;
unsigned char *uncvtbuf, *out_buf;
unsigned char c, nextunconv[UNCVTBUF_SIZE];
/***** Take care the un-converted buffer *********************/
ctr = 0;
uncvtbuf = INTL_GetCCCUncvtbuf(obj);
if (do_unconverted) {
uncvt_bufsz = XP_STRLEN((char*)uncvtbuf);
/*** Save the uncvtbuf only if the buffer is big, otherwise ***/
/*** we can assume this is the last packet, process all ***/
if (in_bufsz >= 128) { /*** is 128 big enough ***/
/*** We go backward until see a non-vowel character ***/
for (i=(in_bufsz-1); (i >= 0); i--) {
c = in_buf[i];
/*** We also use do_unconverted as a stop char **/
/*** For viqr, stop when seeing a non-alpha char (<1)**/
/*** else, stop when NOT seeing vowel or hi-bit (<3)**/
if (charType(c) < do_unconverted)
break;
if (++ctr > UNCVTBUF_SIZE-1) {
/*** Worst case, for CP1258 & VNI, the combining */
/*** vowels always happen at the last 6 letters, */
/*** otherwise, we can conclude it's not a viet */
/*** word, don't need to keep un-converted buffer*/
ctr = 0;
break;
}
}
}
for (i=0; i < ctr;i++) {
nextunconv[i] = in_buf[ in_bufsz - ctr + i ];
}
nextunconv[i] = 0; /*** save next uncnvbuf ***/
in_bufsz -= ctr; /*** reduce the size of input buffer ***/
}
else { /*** This happens for single-byte charset, we don't ***/
uncvtbuf[0] = 0; /*** need the un-converted buffer, ***/
uncvt_bufsz = 0; /*** so we clear it ***/
}
/*************************************************************/
out_buf = NULL;
out_bufsz = ((in_bufsz + uncvt_bufsz) * buf_ratio) + 1;
if ((out_buf = (unsigned char *)XP_ALLOC(out_bufsz)) == (unsigned char *)NULL) {
INTL_SetCCCRetval(obj, MK_OUT_OF_MEMORY);
return(NULL);
}
out_bufsz = customfunc(in_buf, out_buf, in_bufsz, uncvtbuf);
INTL_SetCCCLen(obj, out_bufsz); /* length not counting null */
/*************************************************************/
if (do_unconverted) {
XP_STRCPY((char*)uncvtbuf,(char*)nextunconv);
}
return(out_buf);
}
/*####################################################################*/
/*### The following routines are called by Mozilla ###*/
/*####################################################################*/
/**********************************************************************/
/*** Function: viet_any_2_any() ***/
/*** Purpose: Converts a from_csid buffer to a to_csif buffer. ***/
/**********************************************************************/
MODULE_PRIVATE unsigned char *viet_any_2_any(
CCCDataObject obj,
const unsigned char *in_buf,
int32 in_bufsz)
{
unsigned char *out_buf, *tmp_buf;
uint16 fcsid, tcsid, use_tmp_mem;
int32 bufsz;
fcsid = INTL_GetCCCFromCSID(obj);
tcsid = INTL_GetCCCToCSID(obj);
if (fcsid == tcsid) /*** This case is similar to (CCCFunc) 0 ***/
return ((unsigned char *) in_buf);
/*******************************************************************/
/*** Convert from from_csid buffer to a temporary VISCII buffer ****/
use_tmp_mem = 1; /*** Assume we will use a temporary VIS buf ***/
switch (fcsid) {
case CS_VIET_VISCII:
/*** No intermediate conversion is needed ***/
out_buf = (unsigned char *) in_buf;
bufsz = in_bufsz;
use_tmp_mem = 0;
break;
/*** These are multi-bytes charsets, cannot convert ***/
/*** via UCS2, so we use our internal conversion ***/
case CS_VIET_VIQR: /*** disable unconverted buffer processing **/
/*** by setting last parameter to be 0 **/
out_buf = xlat_any_2_any(obj,in_buf,in_bufsz,
(VietFunc) S_VIQR_to_VISCII, 1, 0);
break;
case CS_VIET_VNI:
out_buf = xlat_any_2_any(obj,in_buf,in_bufsz,
(VietFunc) S_VNI_to_VISCII, 1, 3);
break;
case CS_CP_1258:
out_buf = xlat_any_2_any(obj,in_buf,in_bufsz,
(VietFunc) S_CP1258_to_VISCII, 1, 3);
break;
default: /*** A via-UCS2 conversion is needed ***/
out_buf = xlat_X_ucs2_vis(obj, in_buf, in_bufsz);
}
/*******************************************************************/
/*** Convert the temporary VISCII buffer to to_csid buffer ****/
if (out_buf) {
if (use_tmp_mem) bufsz = INTL_GetCCCLen(obj);
switch (tcsid) {
case CS_VIET_VIQR:
tmp_buf = xlat_any_2_any(obj,out_buf,bufsz,
(VietFunc) S_VISCII_to_VIQR, 3, 0);
break;
case CS_VIET_VNI:
tmp_buf = xlat_any_2_any(obj,out_buf,bufsz,
(VietFunc) S_VISCII_to_VNI, 2, 0);
break;
case CS_CP_1258:
tmp_buf = xlat_any_2_any(obj,out_buf,bufsz,
(VietFunc) S_VISCII_to_CP1258, 2, 0);
break;
case CS_VIET_VISCII:
use_tmp_mem = 0;
tmp_buf = out_buf;
break;
default:
tmp_buf = xlat_vis_ucs2_X(obj, out_buf, bufsz);
}
if (use_tmp_mem) { /*** Multi-byte functions already got memory*/
XP_FREE(out_buf); /* so we need to free the temp VIS buf ***/
}
out_buf = tmp_buf;
}
return(out_buf);
}