mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-17 12:21:32 +00:00
87ef2648d5
add better support (decide which font to use in the init time instead of compile time) in the future.
1147 lines
39 KiB
C
1147 lines
39 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.
|
|
*/
|
|
/* fe_ccc.c */
|
|
/* Test harness code to be replaced by FE specific code */
|
|
|
|
#ifdef XP_OS2
|
|
#define INCL_DOS
|
|
#endif
|
|
#include "intlpriv.h"
|
|
|
|
#include <stdio.h>
|
|
#include "xp.h"
|
|
#include "intl_csi.h"
|
|
|
|
#ifdef XP_MAC
|
|
#include "resgui.h"
|
|
#endif
|
|
|
|
/* for XP_GetString() */
|
|
#include "xpgetstr.h"
|
|
extern int MK_OUT_OF_MEMORY;
|
|
|
|
|
|
/*
|
|
IMPORTANT NOTE:
|
|
|
|
mz_euc2euc
|
|
mz_b52b5
|
|
mz_cns2cns
|
|
mz_ksc2ksc
|
|
mz_sjis2sjis
|
|
mz_utf82utf8
|
|
|
|
is now replaced by mz_mbNullConv
|
|
we eventually should replacing mz_hz2gb after we extract the hz -> gb conversion
|
|
*/
|
|
PRIVATE unsigned char *
|
|
mz_hz2gb(CCCDataObject obj, const unsigned char *kscbuf, int32 kscbufsz);
|
|
PRIVATE unsigned char *
|
|
mz_gb2gb(CCCDataObject obj, const unsigned char *kscbuf, int32 kscbufsz);
|
|
|
|
PRIVATE unsigned char *
|
|
mz_mbNullConv(CCCDataObject obj, const unsigned char *buf, int32 bufsz);
|
|
|
|
PRIVATE unsigned char *
|
|
mz_AnyToAnyThroughUCS2(CCCDataObject obj, const unsigned char *buf, int32 bufsz);
|
|
|
|
/* intl_CharLenFunc is designed to used with mz_mbNullConv */
|
|
typedef int16 (*intl_CharLenFunc) ( unsigned char ch);
|
|
PRIVATE int16 intl_CharLen_SJIS( unsigned char ch);
|
|
PRIVATE int16 intl_CharLen_EUC_JP( unsigned char ch);
|
|
PRIVATE int16 intl_CharLen_CGK( unsigned char ch);
|
|
PRIVATE int16 intl_CharLen_CNS_8BIT( unsigned char ch);
|
|
PRIVATE int16 intl_CharLen_UTF8( unsigned char ch);
|
|
PRIVATE int16 intl_CharLen_SingleByte(unsigned char ch);
|
|
|
|
#define INTL_CHARLEN_SJIS 0
|
|
#define INTL_CHARLEN_EUC_JP 1
|
|
#define INTL_CHARLEN_CGK 2
|
|
#define INTL_CHARLEN_CNS_8BIT 3
|
|
#define INTL_CHARLEN_UTF8 4
|
|
#define INTL_CHARLEN_SINGLEBYTE 5
|
|
|
|
PRIVATE intl_CharLenFunc intl_char_len_func[]=
|
|
{
|
|
intl_CharLen_SJIS,
|
|
intl_CharLen_EUC_JP,
|
|
intl_CharLen_CGK,
|
|
intl_CharLen_CNS_8BIT,
|
|
intl_CharLen_UTF8,
|
|
intl_CharLen_SingleByte,
|
|
};
|
|
|
|
int haveBig5 = 0;
|
|
PRIVATE int16 *availableFontCharSets = NULL;
|
|
|
|
|
|
/* Table that maps the FROM char, codeset to all other relevant info:
|
|
* - TO character codeset
|
|
* - Fonts (fixe & proportional) for TO character codeset
|
|
* - Type of conversion (func for Win/Mac, value for X)
|
|
* - Argument for conversion routine. Routine-defined.
|
|
*
|
|
* Not all of these may be available. Depends upon available fonts,
|
|
* scripts, codepages, etc. Need to query system to build valid table.
|
|
*
|
|
* What info do I need to make the font change API on the 3 platforms?
|
|
* Is just a 32bit font ID sufficient?
|
|
*
|
|
* Some X Windows can render Japanese in either EUC or SJIS, how do we
|
|
* choose?
|
|
*/
|
|
/* The ***first*** match of a "FROM" encoding (1st col.) will be
|
|
* used as the URL->native encoding. Be careful of the
|
|
* ordering.
|
|
* Additional entries for the same "FROM" encoding, specifies
|
|
* how to convert going out (e.g., sending mail, news or forms).
|
|
*/
|
|
|
|
/*
|
|
What is the flag mean ?
|
|
|
|
For Mac the flag in One2OneCCC is the resouce number of a 256 byte mapping table
|
|
For all platform the flag in mz_mbNullConv is a pointer to a intl_CharLenFunc routine
|
|
|
|
*/
|
|
#ifdef XP_MAC
|
|
MODULE_PRIVATE cscvt_t cscvt_tbl[] = {
|
|
/* SINGLE BYTE */
|
|
/* LATIN1 */
|
|
{CS_LATIN1, CS_MAC_ROMAN, 0, (CCCFunc)One2OneCCC, xlat_LATIN1_TO_MAC_ROMAN},
|
|
{CS_ASCII, CS_MAC_ROMAN, 0, (CCCFunc)One2OneCCC, xlat_LATIN1_TO_MAC_ROMAN},
|
|
{CS_MAC_ROMAN, CS_MAC_ROMAN, 0, (CCCFunc)0, 0},
|
|
{CS_MAC_ROMAN, CS_LATIN1, 0, (CCCFunc)One2OneCCC, xlat_MAC_ROMAN_TO_LATIN1},
|
|
{CS_MAC_ROMAN, CS_ASCII, 0, (CCCFunc)One2OneCCC, xlat_MAC_ROMAN_TO_LATIN1},
|
|
|
|
/* LATIN2 */
|
|
{CS_LATIN2, CS_MAC_CE, 0, (CCCFunc)One2OneCCC, xlat_LATIN2_TO_MAC_CE},
|
|
{CS_MAC_CE, CS_MAC_CE, 0, (CCCFunc)0, 0},
|
|
{CS_MAC_CE, CS_LATIN2, 0, (CCCFunc)One2OneCCC, xlat_MAC_CE_TO_LATIN2},
|
|
{CS_MAC_CE, CS_ASCII, 0, (CCCFunc)One2OneCCC, xlat_MAC_CE_TO_LATIN2},
|
|
|
|
{CS_CP_1250, CS_MAC_CE, 0, (CCCFunc)One2OneCCC, xlat_CP_1250_TO_MAC_CE},
|
|
{CS_MAC_CE, CS_CP_1250, 0, (CCCFunc)One2OneCCC, xlat_MAC_CE_TO_CP_1250},
|
|
|
|
/* CYRILLIC */
|
|
{CS_8859_5, CS_MAC_CYRILLIC,0, (CCCFunc)One2OneCCC, xlat_8859_5_TO_MAC_CYRILLIC},
|
|
{CS_MAC_CYRILLIC,CS_MAC_CYRILLIC, 0, (CCCFunc)0, 0},
|
|
{CS_MAC_CYRILLIC,CS_8859_5, 0, (CCCFunc)One2OneCCC, xlat_MAC_CYRILLIC_TO_8859_5},
|
|
{CS_MAC_CYRILLIC,CS_ASCII, 0, (CCCFunc)One2OneCCC, xlat_MAC_CYRILLIC_TO_8859_5},
|
|
|
|
{CS_CP_1251, CS_MAC_CYRILLIC,0, (CCCFunc)One2OneCCC, xlat_CP_1251_TO_MAC_CYRILLIC},
|
|
{CS_MAC_CYRILLIC,CS_CP_1251, 0, (CCCFunc)One2OneCCC, xlat_MAC_CYRILLIC_TO_CP_1251},
|
|
|
|
{CS_KOI8_R, CS_MAC_CYRILLIC,0, (CCCFunc)One2OneCCC, xlat_KOI8_R_TO_MAC_CYRILLIC},
|
|
{CS_MAC_CYRILLIC,CS_KOI8_R, 0, (CCCFunc)One2OneCCC, xlat_MAC_CYRILLIC_TO_KOI8_R},
|
|
|
|
/* GREEK */
|
|
{CS_8859_7, CS_MAC_GREEK, 0, (CCCFunc)One2OneCCC, xlat_8859_7_TO_MAC_GREEK},
|
|
{CS_MAC_GREEK, CS_MAC_GREEK, 0, (CCCFunc)0, 0},
|
|
{CS_MAC_GREEK, CS_8859_7, 0, (CCCFunc)One2OneCCC, xlat_MAC_GREEK_TO_8859_7},
|
|
{CS_MAC_GREEK, CS_ASCII, 0, (CCCFunc)One2OneCCC, xlat_MAC_GREEK_TO_8859_7},
|
|
|
|
{CS_CP_1253, CS_MAC_GREEK, 0, (CCCFunc)One2OneCCC, xlat_CP_1253_TO_MAC_GREEK},
|
|
{CS_MAC_GREEK, CS_CP_1253, 0, (CCCFunc)One2OneCCC, xlat_MAC_GREEK_TO_CP_1253},
|
|
|
|
/* TURKISH */
|
|
{CS_8859_9, CS_MAC_TURKISH, 0, (CCCFunc)One2OneCCC, xlat_8859_9_TO_MAC_TURKISH},
|
|
{CS_MAC_TURKISH,CS_MAC_TURKISH, 0, (CCCFunc)0, 0},
|
|
{CS_MAC_TURKISH,CS_8859_9, 0, (CCCFunc)One2OneCCC, xlat_MAC_TURKISH_TO_8859_9},
|
|
{CS_MAC_TURKISH,CS_ASCII, 0, (CCCFunc)One2OneCCC, xlat_MAC_TURKISH_TO_8859_9},
|
|
|
|
/* MULTIBYTE */
|
|
/* JAPANESE */
|
|
{CS_SJIS, CS_SJIS, 1, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_SJIS },
|
|
{CS_SJIS, CS_JIS, 1, (CCCFunc)mz_sjis2jis, 0},
|
|
{CS_JIS, CS_SJIS, 1, (CCCFunc)jis2other, 0},
|
|
{CS_EUCJP, CS_SJIS, 1, (CCCFunc)mz_euc2sjis, 0},
|
|
{CS_JIS, CS_EUCJP, 1, (CCCFunc)jis2other, 1},
|
|
{CS_EUCJP, CS_JIS, 1, (CCCFunc)mz_euc2jis, 0},
|
|
{CS_SJIS, CS_EUCJP, 1, (CCCFunc)mz_sjis2euc, 0},
|
|
/* auto-detect Japanese conversions */
|
|
{CS_SJIS_AUTO, CS_SJIS, 1, (CCCFunc)autoJCCC, 0},
|
|
{CS_JIS_AUTO, CS_SJIS, 1, (CCCFunc)autoJCCC, 0},
|
|
{CS_EUCJP_AUTO, CS_SJIS, 1, (CCCFunc)autoJCCC, 0},
|
|
|
|
/* KOREAN */
|
|
{CS_KSC_8BIT, CS_KSC_8BIT, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK },
|
|
{CS_2022_KR, CS_KSC_8BIT, 0, (CCCFunc)mz_iso2euckr, 0},
|
|
{CS_KSC_8BIT, CS_2022_KR, 0, (CCCFunc)mz_euckr2iso, 0},
|
|
/* auto-detect Korean conversions */
|
|
{CS_KSC_8BIT_AUTO, CS_KSC_8BIT,1, (CCCFunc)autoKCCC, 0},
|
|
{(CS_2022_KR|CS_AUTO) , CS_KSC_8BIT,1, (CCCFunc)autoKCCC, 0},
|
|
|
|
/* SIMPLIFIED CHINESE */
|
|
{CS_GB_8BIT, CS_GB_8BIT, 0, (CCCFunc)mz_gb2gb, 0},
|
|
|
|
/* TRADITIONAL CHINESE */
|
|
{CS_BIG5, CS_BIG5, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK },
|
|
#ifdef FEATURE_BIG5CNS
|
|
{CS_BIG5, CS_CNS_8BIT, 0, (CCCFunc)mz_b52cns, 0},
|
|
{CS_CNS_8BIT, CS_BIG5, 0, (CCCFunc)mz_cns2b5, 0},
|
|
#endif
|
|
|
|
/* UNICODE */
|
|
{CS_UTF8, CS_UTF8, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_UTF8 },
|
|
|
|
{CS_UTF8, CS_UCS2, 0, (CCCFunc)mz_utf82ucs, 0},
|
|
{CS_UTF8, CS_UTF7, 0, (CCCFunc)mz_utf82utf7, 0},
|
|
{CS_UTF8, CS_UCS2_SWAP, 0, (CCCFunc)mz_utf82ucsswap, 0},
|
|
{CS_UTF8, CS_IMAP4_UTF7, 0, (CCCFunc)mz_utf82imap4utf7, 0},
|
|
{CS_UCS2, CS_UTF8, 0, (CCCFunc)mz_ucs2utf8, 0},
|
|
{CS_UCS2, CS_UTF7, 0, (CCCFunc)mz_ucs2utf7, 0},
|
|
{CS_UCS2_SWAP, CS_UTF8, 0, (CCCFunc)mz_ucs2utf8, 0},
|
|
{CS_UCS2_SWAP, CS_UTF7, 0, (CCCFunc)mz_ucs2utf7, 0},
|
|
{CS_UTF7, CS_UTF8, 0, (CCCFunc)mz_utf72utf8, 0},
|
|
{CS_IMAP4_UTF7, CS_UTF8, 0, (CCCFunc)mz_imap4utf72utf8, 0},
|
|
|
|
{CS_MAC_ROMAN, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_MAC_CE, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_MAC_CYRILLIC, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_KOI8_R, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_MAC_GREEK, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_MAC_TURKISH, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_SJIS, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SJIS},
|
|
{CS_KSC_8BIT, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
{CS_BIG5, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
{CS_GB_8BIT, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
|
|
{CS_UTF8, CS_MAC_ROMAN, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_MAC_CE, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_MAC_CYRILLIC,0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_KOI8_R, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_MAC_GREEK, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_MAC_TURKISH, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_SJIS, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_KSC_8BIT, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_BIG5, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_GB_8BIT, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
|
|
|
|
{CS_USER_DEFINED_ENCODING, CS_USER_DEFINED_ENCODING, 0, (CCCFunc)0, 0},
|
|
{0, 0, 1, (CCCFunc)0, 0}
|
|
};
|
|
|
|
#endif /* XP_MAC */
|
|
|
|
#if defined(XP_WIN) || defined(XP_OS2)
|
|
MODULE_PRIVATE cscvt_t cscvt_tbl[] = {
|
|
/* SINGLE BYTE */
|
|
/* LATIN1 */
|
|
{CS_LATIN1, CS_LATIN1, 0, (CCCFunc)0, 0},
|
|
{CS_LATIN1, CS_ASCII, 0, (CCCFunc)0, 0},
|
|
{CS_ASCII, CS_LATIN1, 0, (CCCFunc)0, 0},
|
|
{CS_ASCII, CS_ASCII, 0, (CCCFunc)0, 0},
|
|
|
|
/* LATIN2 */
|
|
{CS_CP_1250, CS_CP_1250, 0, (CCCFunc)0, 0},
|
|
{CS_CP_1250, CS_LATIN2, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_LATIN2, CS_CP_1250, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_LATIN2, CS_LATIN2, 0, (CCCFunc)0, 0},
|
|
{CS_LATIN2, CS_ASCII, 0, (CCCFunc)0, 0},
|
|
|
|
/* CYRILLIC */
|
|
{CS_CP_1251, CS_CP_1251, 0, (CCCFunc)0, 0},
|
|
{CS_8859_5, CS_CP_1251, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_CP_1251, CS_8859_5, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_CP_1251, CS_CP_1251, 0, (CCCFunc)0, 0},
|
|
|
|
{CS_KOI8_R, CS_CP_1251, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_CP_1251, CS_KOI8_R, 0, (CCCFunc)One2OneCCC, 0},
|
|
|
|
/* GREEK */
|
|
{CS_CP_1253, CS_CP_1253, 0, (CCCFunc)0, 0},
|
|
{CS_CP_1253, CS_8859_7, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_8859_7, CS_CP_1253, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_8859_7, CS_8859_7, 0, (CCCFunc)0, 0},
|
|
|
|
/* TURKISH */
|
|
#ifdef XP_OS2
|
|
{CS_CP_1254, CS_CP_1254, 0, (CCCFunc)0, 0},
|
|
{CS_CP_1254, CS_8859_9, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_8859_9, CS_CP_1254, 0, (CCCFunc)One2OneCCC, 0},
|
|
#endif
|
|
{CS_8859_9, CS_8859_9, 0, (CCCFunc)0, 0},
|
|
|
|
/* MULTIBYTE */
|
|
/* JAPANESE */
|
|
{CS_SJIS, CS_SJIS, 1, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_SJIS},
|
|
{CS_SJIS, CS_JIS, 1, (CCCFunc)mz_sjis2jis, 0},
|
|
{CS_JIS, CS_SJIS, 1, (CCCFunc)jis2other, 0},
|
|
{CS_EUCJP, CS_SJIS, 1, (CCCFunc)mz_euc2sjis, 0},
|
|
{CS_JIS, CS_EUCJP, 1, (CCCFunc)jis2other, 1},
|
|
{CS_EUCJP, CS_JIS, 1, (CCCFunc)mz_euc2jis, 0},
|
|
{CS_SJIS, CS_EUCJP, 1, (CCCFunc)mz_sjis2euc, 0},
|
|
/* auto-detect Japanese conversions */
|
|
{CS_SJIS_AUTO, CS_SJIS, 1, (CCCFunc)autoJCCC, 0},
|
|
{CS_JIS_AUTO, CS_SJIS, 1, (CCCFunc)autoJCCC, 0},
|
|
{CS_EUCJP_AUTO, CS_SJIS, 1, (CCCFunc)autoJCCC, 0},
|
|
|
|
/* KOREAN */
|
|
{CS_KSC_8BIT, CS_KSC_8BIT, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
{CS_2022_KR, CS_KSC_8BIT, 0, (CCCFunc)mz_iso2euckr, 0},
|
|
{CS_KSC_8BIT, CS_2022_KR, 0, (CCCFunc)mz_euckr2iso, 0},
|
|
/* auto-detect Korean conversions */
|
|
{CS_KSC_8BIT_AUTO, CS_KSC_8BIT,1, (CCCFunc)autoKCCC, 0},
|
|
{(CS_2022_KR|CS_AUTO) , CS_KSC_8BIT,1, (CCCFunc)autoKCCC, 0},
|
|
{CS_KSC5601, CS_KSC_8BIT, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
{CS_KSC_8BIT, CS_KSC5601, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
|
|
/* SIMPLIFIED CHINESE */
|
|
{CS_GB_8BIT, CS_GB_8BIT, 0, (CCCFunc)mz_gb2gb, 0},
|
|
{CS_GB2312, CS_GB_8BIT, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
{CS_GB_8BIT, CS_GB2312, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
|
|
/* TRADITIONAL CHINESE */
|
|
{CS_BIG5, CS_BIG5, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
#ifdef FEATURE_BIG5CNS
|
|
{CS_BIG5, CS_CNS_8BIT, 0, (CCCFunc)mz_b52cns, 0},
|
|
{CS_CNS_8BIT, CS_BIG5, 0, (CCCFunc)mz_cns2b5, 0},
|
|
#endif
|
|
{CS_X_BIG5, CS_BIG5, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
{CS_BIG5, CS_X_BIG5, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
|
|
/* UNICODE */
|
|
{CS_UTF8, CS_UTF8, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_UTF8},
|
|
|
|
{CS_UTF8, CS_UCS2, 0, (CCCFunc)mz_utf82ucs, 0},
|
|
{CS_UTF8, CS_UTF7, 0, (CCCFunc)mz_utf82utf7, 0},
|
|
{CS_UTF8, CS_UCS2_SWAP, 0, (CCCFunc)mz_utf82ucsswap, 0},
|
|
{CS_UCS2, CS_UTF8, 0, (CCCFunc)mz_ucs2utf8, 0},
|
|
{CS_UCS2, CS_UTF7, 0, (CCCFunc)mz_ucs2utf7, 0},
|
|
{CS_UTF8, CS_IMAP4_UTF7, 0, (CCCFunc)mz_utf82imap4utf7, 0},
|
|
{CS_UCS2_SWAP, CS_UTF8, 0, (CCCFunc)mz_ucs2utf8, 0},
|
|
{CS_UCS2_SWAP, CS_UTF7, 0, (CCCFunc)mz_ucs2utf7, 0},
|
|
{CS_UTF7, CS_UTF8, 0, (CCCFunc)mz_utf72utf8, 0},
|
|
{CS_IMAP4_UTF7, CS_UTF8, 0, (CCCFunc)mz_imap4utf72utf8, 0},
|
|
|
|
{CS_LATIN1, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_1250, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_1251, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_1253, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_8859_9, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_SJIS, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SJIS},
|
|
{CS_KSC_8BIT, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
{CS_BIG5, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
{CS_GB_8BIT, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
|
|
{CS_UTF8, CS_LATIN1, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_CP_1250, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_CP_1251, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_CP_1253, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_8859_9, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_SJIS, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_KSC_8BIT, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_BIG5, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_GB_8BIT, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
|
|
#ifdef XP_OS2
|
|
/*
|
|
* Define additional codepage conversions for OS/2. All of these use the unicode
|
|
* based conversion tables.
|
|
*/
|
|
/* Thai */
|
|
{CS_CP_874, CS_CP_874, 0, (CCCFunc)0, 0},
|
|
{CS_CP_874, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_UTF8, CS_CP_874, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
|
|
/* Baltic */
|
|
{CS_CP_1257, CS_CP_1257, 0, (CCCFunc)0, 0},
|
|
{CS_CP_1257, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_UTF8, CS_CP_1257, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
|
|
/* Hebrew */
|
|
{CS_CP_862, CS_CP_862, 0, (CCCFunc)0, 0},
|
|
{CS_CP_862, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_UTF8, CS_CP_862, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
|
|
/* Arabic */
|
|
{CS_CP_864, CS_CP_864, 0, (CCCFunc)0, 0},
|
|
{CS_CP_864, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_UTF8, CS_CP_864, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
|
|
/* PC codepages - Default convert to windows codepages */
|
|
{CS_CP_850, CS_LATIN1, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_852, CS_LATIN2, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_855, CS_CP_1251, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_857, CS_CP_1254, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_866, CS_CP_1251, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
|
|
{CS_CP_850, CS_CP_850, 0, (CCCFunc)0, 0},
|
|
{CS_CP_852, CS_CP_852, 0, (CCCFunc)0, 0},
|
|
{CS_CP_855, CS_CP_855, 0, (CCCFunc)0, 0},
|
|
{CS_CP_857, CS_CP_857, 0, (CCCFunc)0, 0},
|
|
{CS_CP_866, CS_CP_866, 0, (CCCFunc)0, 0},
|
|
|
|
{CS_LATIN1, CS_CP_850, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_LATIN2, CS_CP_852, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_1251, CS_CP_855, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_1254, CS_CP_857, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_1251, CS_CP_866, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
|
|
{CS_CP_850, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_852, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_855, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_857, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_CP_866, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_KOI8_R, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
|
|
{CS_UTF8, CS_CP_850, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_CP_852, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_CP_855, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_CP_857, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_CP_866, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_KOI8_R, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
|
|
{CS_MAC_ROMAN, CS_LATIN1, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_LATIN1, CS_MAC_ROMAN, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
#endif /* XP_OS2 */
|
|
|
|
|
|
{CS_USER_DEFINED_ENCODING, CS_USER_DEFINED_ENCODING, 0, (CCCFunc)0, 0},
|
|
{0, 0, 1, (CCCFunc)0, 0}
|
|
};
|
|
|
|
#endif /* XP_WIN || XP_OS2 */
|
|
#ifdef XP_UNIX
|
|
MODULE_PRIVATE cscvt_t cscvt_tbl[] = {
|
|
/* SINGLE BYTE */
|
|
/* LATIN1 */
|
|
{CS_LATIN1, CS_LATIN1, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_LATIN1, CS_ASCII, 0, NULL, 0},
|
|
{CS_ASCII, CS_LATIN1, 0, NULL, 0},
|
|
|
|
/* LATIN2 */
|
|
{CS_LATIN2, CS_LATIN2, 0, NULL, 0},
|
|
{CS_LATIN2, CS_ASCII, 0, NULL, 0},
|
|
{CS_LATIN2, CS_CP_1250, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_CP_1250, CS_LATIN2, 0, (CCCFunc)One2OneCCC, 0},
|
|
|
|
/* CYRILLIC */
|
|
{CS_KOI8_R, CS_KOI8_R, 0, NULL, 0},
|
|
{CS_8859_5, CS_8859_5, 0, NULL, 0},
|
|
{CS_8859_5, CS_KOI8_R, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_KOI8_R, CS_8859_5, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_CP_1251, CS_8859_5, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_8859_5, CS_CP_1251, 0, (CCCFunc)One2OneCCC, 0},
|
|
|
|
/* GREEK */
|
|
{CS_8859_7, CS_8859_7, 0, NULL, 0},
|
|
{CS_8859_7, CS_CP_1253, 0, (CCCFunc)One2OneCCC, 0},
|
|
{CS_CP_1253, CS_8859_7, 0, (CCCFunc)One2OneCCC, 0},
|
|
|
|
/* TURKISH */
|
|
{CS_8859_9, CS_8859_9, 0, NULL, 0},
|
|
|
|
/* MULTIBYTE */
|
|
/* JAPANESE */
|
|
{CS_EUCJP, CS_EUCJP, 1, mz_mbNullConv, INTL_CHARLEN_EUC_JP},
|
|
{CS_JIS, CS_EUCJP, 1, jis2other, 1},
|
|
{CS_SJIS, CS_EUCJP, 1, mz_sjis2euc, 0},
|
|
{CS_EUCJP, CS_SJIS, 1, mz_euc2sjis, 0},
|
|
{CS_JIS, CS_SJIS, 1, jis2other, 0},
|
|
{CS_SJIS, CS_SJIS, 1, mz_mbNullConv, INTL_CHARLEN_SJIS},
|
|
{CS_EUCJP, CS_JIS, 1, mz_euc2jis, 0},
|
|
{CS_SJIS, CS_JIS, 1, mz_sjis2jis, 0},
|
|
/* auto-detect Japanese conversions */
|
|
{CS_JIS_AUTO, CS_EUCJP, 1, autoJCCC, 1},
|
|
{CS_SJIS_AUTO, CS_EUCJP, 1, autoJCCC, 0},
|
|
{CS_EUCJP_AUTO, CS_EUCJP, 1, autoJCCC, 0},
|
|
{CS_EUCJP_AUTO, CS_SJIS, 1, autoJCCC, 0},
|
|
{CS_JIS_AUTO, CS_SJIS, 1, autoJCCC, 0},
|
|
{CS_SJIS_AUTO, CS_SJIS, 1, autoJCCC, 0},
|
|
|
|
/* KOREAN */
|
|
{CS_KSC_8BIT, CS_KSC_8BIT, 0, (CCCFunc)mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
{CS_2022_KR, CS_KSC_8BIT, 0, (CCCFunc)mz_iso2euckr, 0},
|
|
{CS_KSC_8BIT, CS_2022_KR, 0, (CCCFunc)mz_euckr2iso, 0},
|
|
/* auto-detect Korean conversions */
|
|
{CS_KSC_8BIT_AUTO, CS_KSC_8BIT,1, (CCCFunc)autoKCCC, 0},
|
|
{(CS_2022_KR|CS_AUTO) , CS_KSC_8BIT,1, (CCCFunc)autoKCCC, 0},
|
|
|
|
/* SIMPLIFIED CHINESE */
|
|
{CS_GB_8BIT, CS_GB_8BIT, 0, (CCCFunc)mz_gb2gb, 0},
|
|
|
|
/* TRADITIONAL CHINESE */
|
|
{CS_CNS_8BIT, CS_CNS_8BIT, 0, mz_mbNullConv, INTL_CHARLEN_CNS_8BIT},
|
|
#ifdef FEATURE_BIG5CNS
|
|
{CS_BIG5, CS_CNS_8BIT, 0, mz_b52cns, 0},
|
|
{CS_CNS_8BIT, CS_BIG5, 0, mz_cns2b5, 0},
|
|
#endif
|
|
{CS_BIG5, CS_BIG5, 0, mz_mbNullConv, INTL_CHARLEN_CGK},
|
|
|
|
{CS_USRDEF2, CS_USRDEF2, 0, NULL, 0},
|
|
|
|
/* UNICODE */
|
|
{CS_UTF8, CS_UTF8, 0, mz_mbNullConv, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_UCS2, 0, (CCCFunc)mz_utf82ucs, 0},
|
|
{CS_UTF8, CS_UTF7, 0, (CCCFunc)mz_utf82utf7, 0},
|
|
{CS_UTF8, CS_UCS2_SWAP, 0, (CCCFunc)mz_utf82ucsswap, 0},
|
|
{CS_UTF8, CS_IMAP4_UTF7, 0, (CCCFunc)mz_utf82imap4utf7, 0},
|
|
{CS_UCS2, CS_UTF8, 0, (CCCFunc)mz_ucs2utf8, 0},
|
|
{CS_UCS2, CS_UTF7, 0, (CCCFunc)mz_ucs2utf7, 0},
|
|
{CS_UCS2_SWAP, CS_UTF8, 0, (CCCFunc)mz_ucs2utf8, 0},
|
|
{CS_UCS2_SWAP, CS_UTF7, 0, (CCCFunc)mz_ucs2utf7, 0},
|
|
{CS_UTF7, CS_UTF8, 0, (CCCFunc)mz_utf72utf8, 0},
|
|
|
|
{CS_LATIN1, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_LATIN2, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_8859_5, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_KOI8_R, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_8859_7, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_8859_9, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SINGLEBYTE},
|
|
{CS_SJIS, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_SJIS},
|
|
{CS_EUCJP, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_EUC_JP},
|
|
{CS_KSC_8BIT, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
{CS_BIG5, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
{CS_CNS_8BIT, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CNS_8BIT},
|
|
{CS_GB_8BIT, CS_UTF8, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_CGK},
|
|
|
|
{CS_UTF8, CS_LATIN1, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_LATIN2, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_8859_5, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_KOI8_R, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_8859_7, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_8859_9, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_SJIS, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_EUCJP, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_KSC_8BIT, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_BIG5, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_CNS_8BIT, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
{CS_UTF8, CS_GB_8BIT, 0, (CCCFunc)mz_AnyToAnyThroughUCS2, INTL_CHARLEN_UTF8},
|
|
|
|
{CS_IMAP4_UTF7, CS_UTF8, 0, (CCCFunc)mz_imap4utf72utf8, 0},
|
|
{0, 0, 0, NULL, 0}
|
|
|
|
};
|
|
|
|
#endif /* XP_UNIX */
|
|
|
|
|
|
/*
|
|
* this routine is needed to make sure parser and layout see whole
|
|
* characters, not partial characters
|
|
*/
|
|
PRIVATE unsigned char *
|
|
mz_gb2gb(CCCDataObject obj, const unsigned char *gbbuf, int32 gbbufsz)
|
|
{
|
|
return mz_hz2gb(obj, gbbuf, gbbufsz);
|
|
}
|
|
PRIVATE unsigned char *
|
|
mz_hz2gb(CCCDataObject obj, const unsigned char *gbbuf, int32 gbbufsz)
|
|
{
|
|
unsigned char *start, *p, *q;
|
|
unsigned char *output;
|
|
int i, j, len;
|
|
unsigned char *uncvtbuf = INTL_GetCCCUncvtbuf(obj);
|
|
|
|
q = output = XP_ALLOC(strlen((char*)uncvtbuf) + gbbufsz + 1);
|
|
if (q == NULL)
|
|
return NULL;
|
|
|
|
start = NULL;
|
|
|
|
for (j = 0; j < 2; j++)
|
|
{
|
|
len = 0;
|
|
if (j == 0)
|
|
len = strlen((char *)uncvtbuf);
|
|
if (len)
|
|
p = (unsigned char *) uncvtbuf;
|
|
else
|
|
{
|
|
p = (unsigned char *) gbbuf ;
|
|
len = gbbufsz;
|
|
j = 100; /* quit this loop next time */
|
|
}
|
|
for (i = 0; i < len;)
|
|
{
|
|
if (start)
|
|
{
|
|
if (*p == '~' && *(p+1) == '}') /* switch back to ASCII mode */
|
|
{
|
|
for (; start < p; start++)
|
|
*q++ = *start | 0x80;
|
|
p += 2;
|
|
i += 2;
|
|
start = NULL;
|
|
}
|
|
else if (*p == 0x0D && *(p+1) == 0x0A) /* Unix or Mac return */
|
|
{
|
|
for (; start < p; start++)
|
|
*q++ = *start | 0x80;
|
|
i += 2;
|
|
*q++ = *p++; /* 0x0D */
|
|
*q++ = *p++; /* 0x0A */
|
|
start = NULL; /* reset start if we see normal line return */
|
|
}
|
|
else if (*p == 0x0A) /* Unix or Mac return */
|
|
{
|
|
for (; start < p; start++)
|
|
*q++ = *start | 0x80;
|
|
i ++;
|
|
*q++ = *p++; /* LF */
|
|
start = NULL; /* reset start if we see normal line return */
|
|
}
|
|
else if (*p == 0x0D) /* Unix or Mac return */
|
|
{
|
|
for (; start < p; start++)
|
|
*q++ = *start | 0x80;
|
|
i ++;
|
|
*q++ = *p++; /* LF */
|
|
start = NULL; /* reset start if we see normal line return */
|
|
}
|
|
else
|
|
{
|
|
i ++ ;
|
|
p ++ ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (*p == '~' && *(p+1) == '{') /* switch to GB mode */
|
|
{
|
|
start = p + 2;
|
|
p += 2;
|
|
i += 2;
|
|
}
|
|
else if (*p == '~' && *(p+1) == 0x0D && *(p+2) == 0x0A) /* line-continuation marker */
|
|
{
|
|
i += 3;
|
|
p += 3;
|
|
}
|
|
else if (*p == '~' && *(p+1) == 0x0A) /* line-continuation marker */
|
|
{
|
|
i += 2;
|
|
p += 2;
|
|
}
|
|
else if (*p == '~' && *(p+1) == 0x0D) /* line-continuation marker */
|
|
{
|
|
i += 2;
|
|
p += 2;
|
|
}
|
|
else if (*p == '~' && *(p+1) == '~') /* ~~ means ~ */
|
|
{
|
|
*q++ = '~';
|
|
p += 2;
|
|
i += 2;
|
|
}
|
|
else
|
|
{
|
|
i ++;
|
|
*q++ = *p++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*q = '\0';
|
|
INTL_SetCCCLen(obj, q - output);
|
|
if (start)
|
|
{
|
|
|
|
/* Consider UNCVTBUF_SIZE is only 8 byte long, it's not enough
|
|
for HZ anyway. Let's convert leftover to GB first and deal with
|
|
unfinished buffer in the coming block.
|
|
*/
|
|
INTL_SetCCCLen(obj, INTL_GetCCCLen(obj) + p - start);
|
|
for (; start < p; start++)
|
|
*q++ = *start | 0x80;
|
|
*q = '\0';
|
|
|
|
q = uncvtbuf;
|
|
XP_STRCPY((char *)q, "~{");
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
|
|
|
|
/* mz_mbNullConv
|
|
* this routine is needed to make sure parser and layout see whole
|
|
* characters, not partial characters
|
|
*/
|
|
/* This routine is designed to replace the following routine:
|
|
mz_euc2euc
|
|
mz_b52b5
|
|
mz_cns2cns
|
|
mz_ksc2ksc
|
|
mz_sjis2sjis
|
|
mz_utf82utf8
|
|
|
|
It should also replace
|
|
mz_gb2gb
|
|
but currently mz_gb2gb also handle hz to gb. We need to move that functionality out of mz_gb2gb
|
|
*/
|
|
PRIVATE unsigned char *
|
|
mz_mbNullConv(CCCDataObject obj, const unsigned char *buf, int32 bufsz)
|
|
{
|
|
int32 left_over;
|
|
int32 len;
|
|
unsigned char *p;
|
|
unsigned char *ret;
|
|
int32 total;
|
|
intl_CharLenFunc CharLenFunc = intl_char_len_func[INTL_GetCCCCvtflag(obj)];
|
|
int charlen = 0;
|
|
|
|
/* Get the unconverted buffer */
|
|
unsigned char *uncvtbuf = INTL_GetCCCUncvtbuf(obj);
|
|
int32 uncvtsz = strlen((char *)uncvtbuf);
|
|
|
|
/* return in the input is nonsense */
|
|
if ((!obj) || (! buf) || (bufsz < 0))
|
|
return NULL;
|
|
|
|
/* Allocate Output Buffer */
|
|
total = uncvtsz + bufsz;
|
|
ret = (unsigned char *) XP_ALLOC(total + 1);
|
|
if (!ret)
|
|
{
|
|
INTL_SetCCCRetval(obj, MK_OUT_OF_MEMORY);
|
|
return NULL;
|
|
}
|
|
|
|
/* Copy unconverted buffer into the output bufer */
|
|
memcpy(ret, uncvtbuf, uncvtsz);
|
|
/* Copy the current input buffer into the output buffer */
|
|
memcpy(ret+uncvtsz, buf, bufsz);
|
|
|
|
/* Walk through the buffer and figure out the left_over length */
|
|
for (p=ret, len=total, left_over=0; len > 0; p += charlen, len -= charlen)
|
|
{
|
|
if((charlen = CharLenFunc(*p)) > 1)
|
|
{ /* count left_over only if it is multibyte char */
|
|
if(charlen > len) /* count left_over only if the len is less than charlen */
|
|
left_over = len;
|
|
};
|
|
}
|
|
|
|
/* Copy the left over into the uncvtbuf */
|
|
if(left_over)
|
|
memcpy(uncvtbuf, p - charlen, left_over);
|
|
/* Null terminated the uncvtbuf */
|
|
uncvtbuf[left_over] = '\0';
|
|
|
|
/* Null terminate the return buffer and set the length */
|
|
INTL_SetCCCLen(obj, total - left_over);
|
|
ret[total - left_over] = 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
buf -> mz_mbNullConv -> frombuf -> INTL_TextToUnicode -> ucs2buf
|
|
-> INTL_UnicodeToStr -> tobuf
|
|
*/
|
|
PRIVATE unsigned char* mz_AnyToAnyThroughUCS2(CCCDataObject obj, const unsigned char *buf, int32 bufsz)
|
|
{
|
|
/* buffers */
|
|
unsigned char* fromBuf = NULL;
|
|
INTL_Unicode* ucs2Buf = NULL;
|
|
unsigned char* toBuf = NULL;
|
|
/* buffers' length */
|
|
uint32 ucs2BufLen = 0;
|
|
uint32 fromBufLen = 0;
|
|
uint32 toBufLen = 0;
|
|
/* from & to csid */
|
|
uint16 fromCsid = INTL_GetCCCFromCSID(obj);
|
|
uint16 toCsid = INTL_GetCCCToCSID(obj);
|
|
|
|
/* get the fromBuf */
|
|
if( !( fromBuf = mz_mbNullConv( obj, buf, bufsz) ) )
|
|
return NULL;
|
|
|
|
/* map fromBuf -> ucs2Buf */
|
|
fromBufLen = INTL_GetCCCLen(obj);
|
|
ucs2BufLen = INTL_TextToUnicodeLen( fromCsid, fromBuf, fromBufLen );
|
|
|
|
if( !( ucs2Buf = XP_ALLOC( (ucs2BufLen + 1 ) * 2)) ){
|
|
return NULL;
|
|
}
|
|
|
|
/* be care, the return value is HOW MANY UNICODE IN THIS UCS2BUF, not how many bytes */
|
|
ucs2BufLen = INTL_TextToUnicode( fromCsid, fromBuf, fromBufLen, ucs2Buf, ucs2BufLen );
|
|
|
|
/* map ucs2Buf -> toBuf */
|
|
toBufLen = INTL_UnicodeToStrLen( toCsid, ucs2Buf, ucs2BufLen ); /* we get BYTES here :) */
|
|
|
|
if( !( toBuf = XP_ALLOC( toBufLen + 1 ) ) )
|
|
return NULL;
|
|
|
|
INTL_UnicodeToStr( toCsid, ucs2Buf, ucs2BufLen, toBuf, toBufLen );
|
|
|
|
|
|
/* clean up after myself */
|
|
free( fromBuf );
|
|
free( ucs2Buf );
|
|
|
|
/* In order to let the caller know how long the buffer is, i have to set its tail NULL. */
|
|
toBuf[ toBufLen ] = 0;
|
|
return toBuf;
|
|
}
|
|
|
|
|
|
PRIVATE int16 intl_CharLen_SJIS( unsigned char ch)
|
|
{
|
|
return ( (((ch >= 0x81) && (ch <= 0x9f)) || ((ch >= 0xe0) && (ch <= 0xfc))) ? 2 : 1);
|
|
}
|
|
PRIVATE int16 intl_CharLen_EUC_JP( unsigned char ch)
|
|
{
|
|
return ( (((ch >= 0xa1) && (ch <= 0xfe)) || (ch == 0x8e)) ? 2 : ((ch ==0x8f) ? 3 : 1));
|
|
}
|
|
PRIVATE int16 intl_CharLen_CGK( unsigned char ch)
|
|
{
|
|
return ( ((ch >= 0xa1) && (ch <= 0xfe)) ? 2 : 1);
|
|
}
|
|
PRIVATE int16 intl_CharLen_CNS_8BIT( unsigned char ch)
|
|
{
|
|
return ( ((ch >= 0xa1) && (ch <= 0xfe)) ? 2 : ((ch == 0x8e) ? 4 : 1));
|
|
}
|
|
PRIVATE int16 intl_CharLen_UTF8( unsigned char ch)
|
|
{
|
|
return ( ((ch >= 0xc0) && (ch <= 0xdf)) ? 2 : (((ch >= 0xe0) && (ch <= 0xef)) ? 3 : 1));
|
|
}
|
|
PRIVATE int16 intl_CharLen_SingleByte( unsigned char ch)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
INTL_DefaultWinCharSetID,
|
|
Based on DefaultDocCSID, it determines which Win CSID to use for Display
|
|
*/
|
|
PUBLIC int16 INTL_DefaultWinCharSetID(iDocumentContext context)
|
|
{
|
|
|
|
if (context) {
|
|
INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(context);
|
|
if (INTL_GetCSIWinCSID(csi))
|
|
return INTL_GetCSIWinCSID(csi);
|
|
}
|
|
|
|
return INTL_DocToWinCharSetID(INTL_DefaultDocCharSetID(context));
|
|
}
|
|
|
|
/*
|
|
INTL_DocToWinCharSetID,
|
|
Based on DefaultDocCSID, it determines which Win CSID to use for Display
|
|
*/
|
|
/*
|
|
|
|
To Do: (ftang)
|
|
|
|
We should seperate the DocToWinCharSetID logic from the cscvt_t table
|
|
for Cyrillic users.
|
|
|
|
*/
|
|
PUBLIC int16 INTL_DocToWinCharSetID(int16 csid)
|
|
{
|
|
cscvt_t *cscvtp;
|
|
int16 from_csid = 0, to_csid = 0;
|
|
|
|
from_csid = csid & ~CS_AUTO; /* remove auto bit */
|
|
|
|
/* Look-up conversion method given FROM and TO char. code sets */
|
|
cscvtp = cscvt_tbl;
|
|
while (cscvtp->from_csid)
|
|
{
|
|
if (cscvtp->from_csid == from_csid)
|
|
{
|
|
/*
|
|
* disgusting hack...
|
|
*/
|
|
#ifdef XP_UNIX
|
|
if ((cscvtp->to_csid == CS_CNS_8BIT) && haveBig5) {
|
|
cscvtp++;
|
|
continue;
|
|
}
|
|
#endif
|
|
to_csid = cscvtp->to_csid;
|
|
break ;
|
|
}
|
|
cscvtp++;
|
|
}
|
|
return to_csid == 0 ? CS_FE_ASCII: to_csid ;
|
|
}
|
|
|
|
|
|
XP_Bool
|
|
INTL_CanAutoSelect(int16 csid)
|
|
{
|
|
register cscvt_t *cscvtp;
|
|
|
|
cscvtp = cscvt_tbl;
|
|
while (cscvtp->from_csid) {
|
|
if (cscvtp->from_csid == csid) {
|
|
return (cscvtp->autoselect);
|
|
}
|
|
cscvtp++;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
PUBLIC int16
|
|
INTL_DefaultTextAttributeCharSetID(iDocumentContext context)
|
|
{
|
|
if (context)
|
|
{
|
|
INTL_CharSetInfo c = LO_GetDocumentCharacterSetInfo(context);
|
|
if (INTL_GetCSIWinCSID(c))
|
|
return INTL_GetCSIWinCSID(c);
|
|
}
|
|
|
|
return INTL_DefaultWinCharSetID(context);
|
|
}
|
|
|
|
void
|
|
INTL_ReportFontCharSets(int16 *charsets)
|
|
{
|
|
uint16 len;
|
|
|
|
if (!charsets)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (availableFontCharSets)
|
|
{
|
|
free(availableFontCharSets);
|
|
}
|
|
|
|
availableFontCharSets = charsets;
|
|
|
|
while (*charsets)
|
|
{
|
|
if (*charsets == CS_X_BIG5)
|
|
{
|
|
haveBig5 = 1;
|
|
}
|
|
charsets++;
|
|
}
|
|
len = (charsets - availableFontCharSets);
|
|
|
|
#ifdef XP_UNIX
|
|
INTL_SetUnicodeCSIDList(len, availableFontCharSets);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
/* Code for CSID Iterator */
|
|
|
|
#define NUMOFCSIDINITERATOR 15
|
|
struct INTL_CSIDIteratorPriv
|
|
{
|
|
int16 cur;
|
|
int16 csidlist[NUMOFCSIDINITERATOR];
|
|
};
|
|
typedef struct INTL_CSIDIteratorPriv INTL_CSIDIteratorPriv;
|
|
|
|
#ifdef MOZ_MAIL_NEWS
|
|
|
|
PRIVATE void intl_FillTryIMAP4SearchIterator(INTL_CSIDIteratorPriv* p, int16 csid);
|
|
PRIVATE void intl_FillTryIMAP4SearchIterator(INTL_CSIDIteratorPriv* p, int16 csid)
|
|
{
|
|
int idx = 0;
|
|
cscvt_t *cscvtp = cscvt_tbl;
|
|
p->csidlist[idx++] = INTL_DefaultMailCharSetID(csid); /* add mailcsid first */
|
|
p->csidlist[idx++] = INTL_DefaultNewsCharSetID(csid); /* If the news csid is different add it */
|
|
if(p->csidlist[0] == p->csidlist[1])
|
|
idx--;
|
|
/* Add all the csid that we know how to convert to (Without CS_AUTO bit on */
|
|
while (cscvtp->from_csid)
|
|
{
|
|
if ( (cscvtp->from_csid & ~CS_AUTO) == (csid & ~CS_AUTO))
|
|
{
|
|
int16 foundcsid = cscvtp->to_csid & ~CS_AUTO;
|
|
XP_Bool notInTheList = TRUE;
|
|
int i;
|
|
for(i = 0; i < idx ;i++)
|
|
{
|
|
if(foundcsid == p->csidlist[i])
|
|
notInTheList = FALSE;
|
|
}
|
|
if(notInTheList)
|
|
{
|
|
p->csidlist[idx++] = foundcsid;
|
|
XP_ASSERT(NUMOFCSIDINITERATOR == idx);
|
|
if(NUMOFCSIDINITERATOR == idx)
|
|
break;
|
|
}
|
|
}
|
|
cscvtp++;
|
|
}
|
|
p->csidlist[idx] = 0; /* terminate the list by 0 */
|
|
}
|
|
|
|
PUBLIC void INTL_CSIDIteratorCreate( INTL_CSIDIterator* iterator, int16 csid, int flag)
|
|
{
|
|
INTL_CSIDIteratorPriv* priv =
|
|
(INTL_CSIDIteratorPriv*) XP_ALLOC(sizeof(INTL_CSIDIteratorPriv));
|
|
*iterator = (INTL_CSIDIterator) priv;
|
|
if(priv)
|
|
{
|
|
priv->cur = 0;
|
|
switch(flag)
|
|
{
|
|
case csiditerate_TryIMAP4Search:
|
|
intl_FillTryIMAP4SearchIterator (priv, (int16)(csid & ~CS_AUTO));
|
|
break;
|
|
default:
|
|
XP_ASSERT(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
#endif /* MOZ_MAIL_NEWS */
|
|
|
|
PUBLIC void INTL_CSIDIteratorDestroy(INTL_CSIDIterator* iterator)
|
|
{
|
|
INTL_CSIDIteratorPriv* priv = (INTL_CSIDIteratorPriv*) *iterator;
|
|
*iterator = NULL;
|
|
XP_FREE(priv);
|
|
}
|
|
|
|
PUBLIC XP_Bool INTL_CSIDIteratorNext( INTL_CSIDIterator* iterator, int16* pCsid)
|
|
{
|
|
INTL_CSIDIteratorPriv* priv = (INTL_CSIDIteratorPriv*) *iterator;
|
|
int16 csid = priv->csidlist[(priv->cur)++];
|
|
if(0 == csid)
|
|
{
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
*pCsid = csid;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef XP_OS2
|
|
/*
|
|
* Map Netscape charset to OS/2 codepage
|
|
*/
|
|
|
|
/*
|
|
* This is tricker then you think. For a given charset, first entry should
|
|
* be windows codepage, second entry should be OS/2 codepage.
|
|
*/
|
|
|
|
static uint16 CS2CodePage[] = {
|
|
CS_LATIN1 , 1004, /* 2 */
|
|
CS_ASCII , 1252, /* 1 */
|
|
CS_UTF8 , 1208, /* 290 */
|
|
CS_SJIS , 943, /* 260 */
|
|
CS_8859_3 , 913, /* 14 */
|
|
CS_8859_4 , 914, /* 15 */
|
|
CS_8859_5 , 915, /* 16 ISO Cyrillic */
|
|
CS_8859_6 , 1089, /* 17 ISO Arabic */
|
|
CS_8859_7 , 813, /* 18 ISO Greek */
|
|
CS_8859_8 , 916, /* 19 ISO Hebrew */
|
|
CS_8859_9 , 920, /* 20 */
|
|
CS_BIG5 , 950, /* 263 */
|
|
CS_GB2312 , 1386, /* 287 */
|
|
CS_CP_1250 , 1250, /* 44 CS_CP_1250 is window Centrl Europe */
|
|
CS_CP_1251 , 1251, /* 41 CS_CP_1251 is window Cyrillic */
|
|
CS_LATIN2 , 912, /* 10 */
|
|
CS_CP_1253 , 1253, /* 43 CS_CP_1253 is window Greek */
|
|
CS_CP_1254 , 1254, /* 45 CS_CP_1254 is window Turkish */
|
|
CS_CP_1257 , 1257, /* 61 Windows Baltic */
|
|
CS_CP_1258 , 1258, /* 62 Windows Vietnamese */
|
|
CS_CP_850 , 850, /* 53 PC Latin 1 */
|
|
CS_CP_852 , 852, /* 54 PC Latin 2 */
|
|
CS_CP_855 , 855, /* 55 PC Cyrillic */
|
|
CS_CP_857 , 857, /* 56 PC Turkish */
|
|
CS_CP_862 , 862, /* 57 PC Hebrew */
|
|
CS_CP_864 , 864, /* 58 PC Arabic */
|
|
CS_CP_866 , 866, /* 59 PC Russian */
|
|
CS_CP_874 , 874, /* 60 PC Thai */
|
|
CS_EUCJP , 930, /* 261 */
|
|
CS_GB_8BIT , 1386, /* 264 */
|
|
CS_KOI8_R , 878, /* 39 */
|
|
CS_KSC5601 , 949, /* 284 */
|
|
CS_MAC_CE , 1282, /* 11 */
|
|
CS_MAC_CYRILLIC, 1283, /* 40 */
|
|
CS_MAC_GREEK , 1280, /* 42 */
|
|
CS_MAC_ROMAN , 1275, /* 6 */
|
|
CS_MAC_TURKISH, 1281, /* 46 */
|
|
CS_UCS2 , 1200, /* 810 */
|
|
CS_USRDEF2 , 1252, /* 38 */
|
|
0, 0,
|
|
};
|
|
|
|
/*
|
|
* MapCpToCsNum: Search table and return netscape codeset name
|
|
*/
|
|
uint16 INTL_MapCpToCsNum(uint16 cpid) {
|
|
uint16 * up;
|
|
|
|
up = CS2CodePage;
|
|
while (*up) {
|
|
if (up[1] == cpid) {
|
|
return up[0];
|
|
}
|
|
up += 2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* MapCsToCpNum: Search table and return codepage
|
|
*/
|
|
uint16 INTL_MapCsToCpNum(uint16 csid) {
|
|
uint16 * up;
|
|
|
|
up = CS2CodePage;
|
|
while (*up) {
|
|
if (up[0] == csid) {
|
|
return up[1];
|
|
}
|
|
up += 2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Map from process codepage to default charset
|
|
*/
|
|
int16 INTL_MenuFontCSID(void) {
|
|
ULONG codepage, xxx;
|
|
|
|
DosQueryCp(4, &codepage, &xxx);
|
|
return INTL_MapCpToCsNum(codepage);
|
|
}
|
|
|
|
|
|
/*
|
|
* This returns the ID for the
|
|
*/
|
|
int INTL_MenuFontID() {
|
|
return 0;
|
|
}
|
|
|
|
#endif /* XP_OS2 */
|