ltf_id.c

T-kernel 的extension源代码

/*
 *----------------------------------------------------------------------
 *    T-Kernel / Standard Extension
 *
 *    Copyright (C) 2006 by Ken Sakamura. All rights reserved.
 *    T-Kernel / Standard Extension is distributed 
 *      under the T-License for T-Kernel / Standard Extension.
 *----------------------------------------------------------------------
 *
 *    Version:   1.00.00
 *    Released by T-Engine Forum(http://www.t-engine.org) at 2006/8/11.
 *
 *----------------------------------------------------------------------
 */

/*
 *	ltf_id.c (seio)
 *
 *	Standard input/output
 *	Local tf library
 */

#include <basic.h>
#include <tstring.h>
#include <libstr.h>
#include <extension/errno.h>
#include <sys/util.h>
#include "tf.h"
#include "ltf_inner.h"

#ifdef DEBUG
#define DP(x)	printf x
#else
#define DP(x)
#endif

#define TSD_LUT_VAL_2		2
#define TSD_LTF_VAL_2		2
#define TSD_LTF_WLN_2		2
#define TSD_LUT_WER_2		2
#define TSD_LTF_WLN_M1		(-1)
#define TSD_LTF_WER_M1		(-1)
#define TSD_LET_MSK_0X7F7F	(TC)0x7f7f
#define TSD_LTF_CD_0X81		(UB)0x81
#define TSD_LTF_CD_0X9F		(UB)0x9f
#define TSD_LTF_CD_0XE0		(UB)0xe0
#define TSD_LTF_CD_0XEF		(UB)0xef
#define TSD_LTF_CD_0X40		(UB)0x40
#define TSD_LTF_CD_0X7E		(UB)0x7e
#define TSD_LTF_CD_0X80		(UB)0x80
#define TSD_LTF_CD_0XFC		(UB)0xfc
#define TSD_LTF_CD_0XA0		(UB)0xa0
#define TSD_LTF_CD_0X71		(UB)0x71
#define TSD_LTF_CD_0XB1		(UB)0xb1
#define TSD_LTF_CD_0X7F		(UB)0x7f
#define TSD_LTF_CD_0X9E		(UB)0x9e
#define TSD_LTF_CD_0X7D		(UB)0x7d
#define TSD_LTF_CD_0X1F		(UB)0x1f
#define TSD_LTF_CD_0X20		(UB)0x20
#define TSD_LTF_CD_0X8E		(UB)0x8e
#define TSD_LTF_CD_0XA1		(UB)0xa1
#define TSD_LTF_CD_0XFE		(UB)0xfe
#define TSD_LTF_CD_0XFF		0xffU
#define TSD_LTF_CD_0X21		(UB)0x21
#define TSD_LTF_CD_0X22		(UB)0x22
#define TSD_LTF_CD_0X23		(UB)0x23
#define TSD_LTF_CD_0X25		(UB)0x25
#define TSD_LTF_CD_0X26		(UB)0x26
#define TSD_LTF_CD_0X2B		(UB)0x2b
#define TSD_LTF_CD_0X2C		(UB)0x2c
#define TSD_LTF_CD_0X56		(UB)0x56
#define TSD_LTF_CD_0X57		(UB)0x57
#define TSD_LTF_CD_0XE1		(UB)0xe1
#define TSD_LTF_CD_0X3F		(UB)0x3f
#define TSD_LTF_CD_0XAC		(UB)0xac
#define TSD_LTF_CD_0XA4		(UB)0xa4
#define TSD_LTF_CD_0XA5		(UB)0xa5
#define TSD_LTF_CD_0XDE		(UB)0xde
#define TSD_LTF_CD_0XDF		(UB)0xdf
#define TSD_LTF_CD_0XA2		(UB)0xa2
#define TSD_LTF_CD_0XA3		(UB)0xa3
#define TSD_LTF_CD_0XAE		(UB)0xae
#define TSD_LTF_TCD_0X222E	(TC)0x222e
#define TSD_LTF_TCD_0X212B	(TC)0x212b
#define TSD_LTF_TCD_0X20	(TC)0x20
#define TSD_LTF_TCD_0X80	(TC)0x80
#define TSD_LTF_TCD_0XFF	(TC)0xff
#define TSD_LTF_TCD_0X0020	(TC)0x0020
#define TSD_LTF_UCD_0X0020	(UH)0x0020
#define TSD_LTF_UCD_0X007F	(UH)0x007f
#define TSD_LTF_UCD_0XFF61	(UH)0xff61
#define TSD_LTF_UCD_0XFF9F	(UH)0xff9f
#define TSD_LTF_UCD_0XFF60	(UH)0xff60
#define TSD_LTF_UCD_0XFF00	0xff00
#define TSD_LTF_UCD_0X003F	(UH)0x003f
#define TSD_LTF_UCD_0X3013	(UH)0x3013
#define TSD_LTF_SFT_8		8
#define TSD_LTF_CS1_0		0
#define TSD_LTF_CS1_1		1
#define TSD_LTF_CS1_2		2
#define TSD_LTF_CS1_3		3
#define TSD_LTS_RTN_2		2
#define TSD_LTE_RTN_2		2
#define TSD_LTU_RTN_2		2
#define TSD_LTF_CS2_0		0
#define TSD_LTF_CS2_2		2
#define TSD_LTF_CS2_1		1
#define TSD_LTF_CCD_0X80	(UB)0x80
#define TSD_LTE_CAS_0X22	(UB)0x22
#define TSD_LTE_CAS_0X23	(UB)0x23
#define TSD_LTE_CAS_0X26	(UB)0x26
#define TSD_LTE_CAS_0X2B	(UB)0x2b
#define TSD_LTE_CAS_0X2C	(UB)0x2c
#define TSD_LTE_CAS_0X56	(UB)0x56
#define TSD_LTE_CAS_0X57	(UB)0x57
#define TSD_LTE_MSK_0X8080	(TC)0x8080
#define TSD_LTU_CAS_22		(UB)0x22
#define TSD_LTU_CAS_23		(UB)0x23
#define TSD_LTU_CAS_26		(UB)0x26
#define TSD_LTU_CAS_2B		(UB)0x2b
#define TSD_LTU_CAS_2C		(UB)0x2c
#define TSD_LTU_CAS_56		(UB)0x56
#define TSD_LTU_CAS_57		(UB)0x57

LOCAL W ltf_sjtotc( TF_CTX ctx, TC *ptcDst, UB *pubSjStr, W wAvailLen, W *pwZenHan, W *pwWantLen);
LOCAL W ltf_euctotc( TF_CTX ctx, TC *ptcDst, UB *pubEucStr, W wAvailLen, W *pwZenHan, W *pwWantLen);
#if defined(USE_UNICODE) 
LOCAL W ltf_unitotc( TF_CTX ctx, TC *ptcDst, UH *puhEucStr, W wAvailLen, W *pwZenHan, W *pwWantLen);
#endif	/* defined(USE_UNICODE) */
LOCAL W ltf_tctosj( TF_CTX ctx, UB *pubSjDst, TC tcTCSrc, W wZenHan);
LOCAL W ltf_tctoeuc( TF_CTX ctx, UB *pubEucDst, TC tcTCSrc, W wZenHan);
#if defined(USE_UNICODE) 
LOCAL W ltf_tctouni( TF_CTX ctx, UH *puhUniDst, TC tcTCSrc, W wZenHan);
#endif	/* defined(USE_UNICODE)  */

LOCAL W ltf_xs1end( TF_CTX ctx);
LOCAL W ltf_xs2end( TF_CTX ctx);

typedef struct {
	W idtype;
	B *keyword;
	W (*chgfunc)();
	W (*isEnd)();				/* End determination */
	W offset;
} LTF_ID_LIST_TABLE;

LOCAL LTF_ID_LIST_TABLE ltf_id_list_table[] = {
	{ TF_ID_PROFSET_CONVERTFROM,	"Shift_JISX0213",
		( W (*)())ltf_sjtotc,	ltf_xs1end,	0},
#if defined(USE_UNICODE) 
	{ TF_ID_PROFSET_CONVERTFROM,	"UTF-16LE",
		( W (*)())ltf_unitotc,	ltf_xs2end,	0},
#endif	/* defined(USE_UNICODE) */
	{ TF_ID_PROFSET_CONVERTFROM,	"EUC-JISX0213",
		( W (*)())ltf_euctotc,	ltf_xs1end,	0},
	{ TF_ID_PROFSET_CONVERTTO,	"Shift_JISX0213",
		( W (*)())ltf_tctosj,	NULL,	0}, 
#if defined(USE_UNICODE) 
	{ TF_ID_PROFSET_CONVERTTO,	"UTF-16LE",
		( W (*)())ltf_tctouni,	NULL,	0},
#endif	/* defined(USE_UNICODE) */
	{ TF_ID_PROFSET_CONVERTTO,	"EUC-JISX0213",
		( W (*)())ltf_tctoeuc,	NULL,	0},
	{ TF_ID_OPT_CONVERT,		"UNDEFINED_CHAR",
		( W (*)())NULL,		NULL,	offsetof( struct tf_ctx, ubX2TUndefChar)},
	{ TF_ID_OPT_CONVERT,		"UNSUPPORTED_CHAR",
		( W (*)())NULL,		NULL,	offsetof( struct tf_ctx, ubT2XUnsupChar)},
	{ 0,				NULL,
		( W (*)())NULL,		NULL,	0}
};

#define N_LTF_ID ( (sizeof(ltf_id_list_table) / sizeof(ltf_id_list_table[0])) - 1)

IMPORT	const	TC	_hzkana[];
#if defined(USE_UNICODE) && defined(USE_JIS)
IMPORT	const	TC	_ptcUni2TC[];
IMPORT	W		wUni2TCLen;
#endif	/* defined(USE_UNICODE) && defined(USE_JIS) */
/*
 * External function
 */
EXPORT WER tf_to_id(W idtype, const B *keyword)
{
	W tidx;

	if (((UW)idtype & ~(UW)TF_ID_TYPE_MASK) != 0) {
		return E_PAR;
	}

	tidx = 0;
	while (ltf_id_list_table[tidx].keyword != NULL) {
		if (idtype == ltf_id_list_table[tidx].idtype) {
			if (strcasecmp(ltf_id_list_table[tidx].keyword, keyword) == 0) {
				return tidx;
			}
		} 
		tidx++;
	}
	return E_NOEXS;
}

/*
 * External function
 * Set profiles based on name
 */
EXPORT ER tf_set_profile(TF_CTX ctx, W profid)
{
	if(( profid < 0 )||( N_LTF_ID <= (UW)profid)){
		return E_PAR;
	}
	switch( ltf_id_list_table[ profid].idtype){
	  case TF_ID_PROFSET_CONVERTFROM:
	  case TF_ID_PROFSET_CONVERTTO:
		ctx->chgfunc	= ltf_id_list_table[ profid].chgfunc;
		ctx->isEnd	= ltf_id_list_table[ profid].isEnd;
		break;
	  default:
	  	return E_PAR;
	}
	return E_OK;
}

/*
 * External function for option setting
 */
EXPORT ER tf_set_options (TF_CTX ctx, W optid, W value)
{
	if(( optid < 0 )||( N_LTF_ID <= (UW)optid)){
		return E_PAR;
	}
	switch( ltf_id_list_table[ optid].idtype){
	  case	TF_ID_OPT_CONVERT:
	  	*(((UB*)ctx) + ltf_id_list_table[ optid].offset) = (UB)value;
	  	break;
	  default:
	  	return E_PAR;
	}
	return E_OK;
}

/*
 *	Determine the end of single-byte code
 */
LOCAL W ltf_xs1end( TF_CTX ctx)
{
	return(( ctx->srcs.xs.pubCurSrc)[ ctx->srcs.xs.wSrcP] == 0);
}

/*
 *	Determine the end of double-byte code
 */
LOCAL W ltf_xs2end( TF_CTX ctx)
{
	return((( ctx->srcs.xs.pubCurSrc)[ ctx->srcs.xs.wSrcP] == 0 )
		&&( ( ctx->srcs.xs.pubCurSrc)[ ctx->srcs.xs.wSrcP + 1] == 0));
}

/*
 *	SJIS -> TC conversion function
 *	When there is an undefined character, return -1.
 */
LOCAL W ltf_sjtotc( TF_CTX ctx, TC *ptcDst, UB *pubSjStr, W wAvailLen, W *pwZenHan, W *pwWantLen)
{
	W  wErr, wLen;
	UB ubC1, ubC2;
	UH uhSJIS;

	if( wAvailLen < 1){
		wErr = E_NOEXS;		/* In the case of insufficient data */
		*pwWantLen = 1;
		goto err_ret;
	}
	ubC1 = *pubSjStr;
#if defined(USE_JIS)
	if((( TSD_LTF_CD_0X81 <= ubC1 )&&( ubC1 <= TSD_LTF_CD_0X9F)) ||(( TSD_LTF_CD_0XE0 <= ubC1 )&&( ubC1 <= TSD_LTF_CD_0XEF))){
		if( wAvailLen < TSD_LTF_VAL_2){
			wErr = E_NOEXS;	/* In the case of insufficient data */
			*pwWantLen = 1;
			goto err_ret;
		}
		ubC2 = *( pubSjStr + 1);
		if((( TSD_LTF_CD_0X40 <= ubC2) && ( ubC2 <= TSD_LTF_CD_0X7E)) || (( TSD_LTF_CD_0X80 <= ubC2) && ( ubC2 <= TSD_LTF_CD_0XFC))){
			uhSJIS = (( UH)ubC1 << TSD_LTF_SFT_8) | ubC2;
			SET_TFZEN( *pwZenHan);	/* Double-byte code */

			ubC1 -= ( ubC1 < TSD_LTF_CD_0XA0)? TSD_LTF_CD_0X71: TSD_LTF_CD_0XB1;
			ubC1 = ubC1 + ubC1 + 1;
			if( ubC2 > TSD_LTF_CD_0X7F) {
				ubC2--;
			}
			if( ubC2 >= TSD_LTF_CD_0X9E){
				ubC1++;
				ubC2 -= TSD_LTF_CD_0X7D;
			} else {
				ubC2 -= TSD_LTF_CD_0X1F;
			}
			if ( ptcDst != 0) {
				*ptcDst = (ubC1 << TSD_LTF_SFT_8) | (UB)ubC2;
			}
			wLen = TSD_LTF_WLN_2;
		}else{				/* Undefined character */
			goto undef_char;
		}
		return( wLen);
	}
#endif	/* defined(USE_JIS) */

	wLen = 1;
	if( ubC1 == 0){
		wLen = 0;
	}else if( ubC1 < TSD_LTF_CD_0X20){			/* Control code */
		if( ptcDst != 0) {
			*ptcDst = _asctotc[ ubC1];
		}
	}else if( ubC1 < TSD_LTF_CD_0X7F){
		SET_TFHAN( *pwZenHan);	/* Single-byte code */
		if( ptcDst != 0) {
			*ptcDst = _asctotc[ ubC1];
		}
#ifdef USE_HKANA
	}else if(( TSD_LTF_CD_0XA0 <= ubC1 )&&( ubC1 < TSD_LTF_CD_0XE0)){
		SET_TFHAN( *pwZenHan);	/* Single-byte kana */
		if( ptcDst != 0) {
			*ptcDst = _hzkana[ ubC1 - TSD_LTF_CD_0XA0];
		}
#endif
	}else{					/* Undefined character */
		goto undef_char;
	}
	return( wLen);

undef_char:
	wErr = 1;
	switch( ctx->ubX2TUndefChar){
	  case TSD_LTF_CS1_0:			/* = */
	  	if( ptcDst != 0) {
			*ptcDst = TSD_LTF_TCD_0X222E;
		}
	  	break;
	  case TSD_LTF_CS1_1:
	  	wErr = TSD_LTF_WER_M1;
		goto err_ret;
	  case TSD_LTF_CS1_2:			/* Not changed */
	  	if( ptcDst != 0) {
			*ptcDst = (TC)ubC1;
		}
	  	break;
	  case TSD_LTF_CS1_3:			/* Not supported (converted into 0x2345, etc.) */
	  default:
	  	wErr = E_NOSPT;
		goto err_ret;
	}
	return( wErr);
err_ret:
	DP(( "DEBUG:ltf_sjtotc() wAvailLen=%d *pubSjStr=0x%02x,0x%02x\n", wAvailLen, *pubSjStr, *(pubSjStr + 1)));
	return( wErr);
}

/*
 *	EUC -> TC conversion function
 */
LOCAL W ltf_euctotc( TF_CTX ctx, TC *ptcDst, UB *pubEucStr, W wAvailLen, W *pwZenHan, W *pwWantLen)
{
	W  wErr, wLen;
	UB ubC1, ubC2;
	UH uhEUC;

	if( wAvailLen < 1){
		wErr = E_NOEXS;		/* In the case of insufficient data */
		*pwWantLen = 1;
		goto err_ret;
	}
	ubC1 = *pubEucStr;
#ifdef USE_HKANA
	if( ubC1 == TSD_LTF_CD_0X8E){
		if( wAvailLen < TSD_LTF_VAL_2){
			wErr = E_NOEXS;		/* In the case of insufficient data */
			*pwWantLen = 1;
			goto err_ret;
		}
		
		ubC2 = *(pubEucStr + 1);
		if(( ubC2 < TSD_LTF_CD_0XA0 )||( TSD_LTF_CD_0XE0 <= ubC2)){
			goto undef_char;
		}
		SET_TFHAN( *pwZenHan);
		/* Single-width katakana */ 
		if (ptcDst != 0) {
			*ptcDst = _hzkana[ ubC2 - TSD_LTF_CD_0XA0];
		}
		wLen = TSD_LTF_WLN_2;
		return( wLen);
	}
#endif
#if defined(USE_JIS)
	if(( TSD_LTF_CD_0XA1 <= ubC1 )&&( ubC1 <= TSD_LTF_CD_0XFE)){
		if( wAvailLen < TSD_LTF_VAL_2){
			wErr = E_NOEXS;		/* In the case of insufficient data */
			*pwWantLen = 1;
			goto err_ret;
		}
		ubC2 = *( pubEucStr + 1);
		if(( ubC2 < TSD_LTF_CD_0XA1 )||( TSD_LTF_CD_0XFE < ubC2)){
			goto undef_char;
		}
		uhEUC = ((UH)ubC1 << TSD_LTF_SFT_8) | ubC2;
		SET_TFZEN( *pwZenHan);	/* Double-byte code */

		/* Double-width */
		if ( ptcDst != 0) {
			*ptcDst = (( ubC1 << TSD_LTF_SFT_8) | ( ubC2 & TSD_LTF_CD_0XFF)) & TSD_LET_MSK_0X7F7F;
		}

		wLen = TSD_LTF_WLN_2;
		return( wLen);
	}
#endif	/* defined(USE_JIS) */

	wLen = 1;
	if( ubC1 == 0){
		wLen = 0;
	}else if( ubC1 < TSD_LTF_CD_0X20){			/* Control code */
		if( ptcDst != 0 ) {
			*ptcDst = _asctotc[ ubC1];
		}
	}else if( ubC1 < TSD_LTF_CD_0X7F){
		SET_TFHAN( *pwZenHan);		/* Single-byte code */
		if( ptcDst != 0 ) {
			*ptcDst = _asctotc[ ubC1];
		}
	}else{					/* Undefined character */
		goto undef_char;
	}
	return( wLen);

undef_char:
	wErr = 1;
	switch( ctx->ubX2TUndefChar){
	  case TSD_LTF_CS1_0:				/* = */
	  	if( ptcDst != 0 ) {
			*ptcDst = TSD_LTF_TCD_0X222E;
		}
	  	break;
	  case TSD_LTF_CS1_1:
	  	wErr = TSD_LTF_WER_M1;
		goto err_ret;
	  case TSD_LTF_CS1_2:				/* Not changed */
	  	if( ptcDst != 0 ) {
			*ptcDst = (TC)ubC1;
		}
	  	break;
	  case TSD_LTF_CS1_3:				/* Not supported (converted into 0x2345, etc.) */
	  default:
	  	wErr = E_NOSPT;
		goto err_ret;
	}
	return( wErr);
err_ret:
	DP(( "DEBUG:ltf_euctotc() wAvailLen=%d *pubEucStr=0x%02x,0x%02x\n", wAvailLen, *pubEucStr, *(pubEucStr + 1)));
	return( wErr);
}

#if defined(USE_UNICODE) 
/*
 *	UNICODE -> TC conversion function
 *	For UTF-16LE
 *	wAvailLen is on a byte basis
 */
LOCAL W ltf_unitotc( TF_CTX ctx, TC *ptcDst, UH *puhUniStr, W wAvailLen, W *pwZenHan, W *pwWantLen)
{
	W  wErr, wLen;
	TC tcTC;
	UB ubC1, ubC2;

	if( wAvailLen < TSD_LTF_VAL_2){
		wErr = E_NOEXS;		/* In the case of insufficient data */
		*pwWantLen = TSD_LUT_VAL_2 - wAvailLen;
		goto err_ret;
	}

	if( *puhUniStr < TSD_LTF_UCD_0X0020){		/* Control code */
		if( ptcDst) {
			*ptcDst = _asctotc[ *puhUniStr];
		}
		wLen = TSD_LTF_WLN_2;
	}else if(( TSD_LTF_UCD_0X0020 <= *puhUniStr )&&( *puhUniStr < TSD_LTF_UCD_0X007F)){
		SET_TFHAN( *pwZenHan);		/* Single-byte code */
		if( ptcDst) {
			*ptcDst = _asctotc[ *puhUniStr];
		}
		wLen = TSD_LTF_WLN_2;
#ifdef USE_HKANA
	}else if(( TSD_LTF_UCD_0XFF61 <= *puhUniStr )&&( *puhUniStr <= TSD_LTF_UCD_0XFF9F)){
		SET_TFHAN( *pwZenHan);		/* Single-width katakana */ 
		if( ptcDst) {
			*ptcDst = _hzkana[ *puhUniStr - TSD_LTF_UCD_0XFF60];
		}
		wLen = TSD_LTF_WLN_2;
#endif
#if defined(USE_JIS)
	}else{					/* Double-width */
		tcTC = _ptcUni2TC[ *puhUniStr];
		if( tcTC == TNULL){
			goto undef_char;
		}
		SET_TFZEN( *pwZenHan);
		ubC1 = tcTC >> TSD_LTF_SFT_8;
		ubC2 = tcTC & TSD_LTF_CD_0XFF;
		if(( ubC2 <= TSD_LTF_CD_0X20 )||( TSD_LTF_CD_0X7F <= ubC2)){
			goto undef_char;
		}
		if( ptcDst) {
			*ptcDst = tcTC;
		}
		wLen = TSD_LTF_WLN_2;		
#else
	}else{
		goto undef_char;
#endif
	}
	return( wLen);
undef_char:
	wErr = TSD_LUT_WER_2;
	switch( ctx->ubX2TUndefChar){
	  case TSD_LTF_CS1_0:				/* = */
	  	if( ptcDst) {
			*ptcDst = TSD_LTF_TCD_0X222E;
		}
	  	break;
	  case TSD_LTF_CS1_1:
	  	wErr = TSD_LTF_WER_M1;
		goto err_ret;
	  case TSD_LTF_CS1_2:				/* Not changed */
	  	if( ptcDst) {
			*ptcDst = (TC)*puhUniStr;
		}
	  	break;
	  case TSD_LTF_CS1_3:				/* Not supported (converted into 0x2345, etc.) */
	  default:
	  	wErr = E_NOSPT;
		goto err_ret;
	}
	return( wErr);
err_ret:
	DP(( "DEBUG:ltf_unitotc() wAvailLen=%d *puhUniStr=0x%04x,0x%04x\n", 
			wAvailLen, *puhUniStr, *(puhUniStr + 1)));
	return( wErr);
}
#endif	/* defined(USE_UNICODE)  */

/*********************************************************/
/*
	JIS X 0208 ->JIS X 0201 conversion table
	Use 0x21xx (Row 1) of JIS X 0208 as a reference point for offset and store corresponding JIS X 0201 characters.

	Offset:
		JIS code - 0x2121
	JIS code:
		0			Cannot be converted into JIS X 0201.