big5.cpp

代码实现了对一组字符串内存

// BIG5.cpp : Implementation of CBIG5
#include "stdafx.h"
#include "Gb2Big.h"
#include "BIG5.h"

#define B2G_bad1	0xa1
#define B2G_bad2	0xf5
#define G2B_bad1	0xa1
#define G2B_bad2	0xbc

#define is_GB1(x)       ((x)>=0xa1 && (x)<=0xf7)
#define is_GB2(x)       ((x)>=0xa1 && (x)<=0xfe)
#define is_B51(x)       ((x)>=0xa1 && (x)<=0xfe)
#define is_B52(x)       (((x)>=0x40 && (x)<=0x7e) || ((x)>=0xa1 && (x)<=0xfe))

#define _BUF_LEN		102400
#define _BIG_FILE

#define _NO_DBCS		0
#define _LEADER_CHAR	1
#define _NEXT_CHAR		2

static char* s_pcG2BTab = NULL;
static char* s_pcB2GTab = NULL;
void g2b(unsigned char* pcBuffer,int nSize);
void b2g(unsigned char* pcBuffer,int nSize);
char* LoadLongResource(UINT nID);

/////////////////////////////////////////////////////////////////////////////
// CBIG5
STDMETHODIMP CBIG5::Convert(VARIANT varInData, VARIANT *varOutData)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

	VariantInit(varOutData);
	char* szRet = NULL;

	//Process
	WORD wType = varInData.vt;
	if ((wType & VT_ARRAY) == VT_ARRAY)
	{
		SAFEARRAY* lpSFArray = varInData.parray;
		int nSize = lpSFArray->rgsabound[0].cElements;
		szRet = Process((char*)(lpSFArray->pvData), nSize);

		if (szRet)
		{
			VARIANT var;
			VariantInit(&var);
			SAFEARRAY FAR* psa;
			psa = SafeArrayCreateVector(VT_UI1, 0, nSize);
			if (psa != NULL)
			{
				psa->pvData = (void *)szRet;
				var.vt = VT_ARRAY|VT_UI1;
				var.parray = psa;
				VariantCopy(varOutData, &var);
			}
			VariantClear(&var);
			free(szRet);
		}
	}

	return S_OK;
}

/////////////////////////////////////////////////////////////////////////////
// CConvert
void b2g(unsigned char* pcBuffer,int nSize)
{
	int nIndex;
	int nOffset;

	if (s_pcB2GTab == NULL)
	{
		s_pcB2GTab = LoadLongResource(IDR_BIGCHAR2);
	}
	nIndex = 0;
	while (nIndex < nSize)
	{
		if (is_B51(*(pcBuffer+nIndex)) && is_B52(*(pcBuffer+nIndex+1)))
		{
			if ((*(pcBuffer+nIndex) >= 0xa1) && (*(pcBuffer+nIndex) <= 0xf6))
			{
				if (*(pcBuffer+nIndex+1) >= 0x40 && *(pcBuffer+nIndex+1) <= 0x7e)
				{
					nOffset = ((*(pcBuffer+nIndex) - 0xa1) * 157 + (*(pcBuffer+nIndex+1) - 0x40)) * 2;
				}
				else
				{
					nOffset = ((*(pcBuffer+nIndex) - 0xa1) * 157 + (*(pcBuffer+nIndex+1) - 0xa1 + 63)) * 2;
				}
			}
			else if (*(pcBuffer+nIndex) == 0xf7 && (*(pcBuffer+nIndex+1) >= 0x40) && (*(pcBuffer+nIndex+1) <= 0x55))
				nOffset = ((*(pcBuffer+nIndex) - 0xa1) * 157 + (*(pcBuffer+nIndex+1) - 0x40)) * 2;
			else
				nOffset = -1;

			if (nOffset>-1)
			{
				*(pcBuffer+nIndex) = *(s_pcB2GTab + nOffset);
				*(pcBuffer+nIndex+1) = *(s_pcB2GTab + nOffset + 1);
			}
			else
			{
				*(pcBuffer+nIndex) = B2G_bad1;
				*(pcBuffer+nIndex+1) = B2G_bad2;
			}
			nIndex++;
		}
		nIndex++;
	}
}


void g2b(unsigned char* pcBuffer,int nSize)
{
	int nIndex;
	int nOffset;

	if (s_pcG2BTab == NULL)
	{
		s_pcG2BTab = LoadLongResource(IDR_BIGCHAR1);
	}
	nIndex = 0;
	while (nIndex < nSize)
	{
		if (is_GB1(*(pcBuffer+nIndex)) && is_GB2(*(pcBuffer+nIndex+1)))
		{
			if (*(pcBuffer+nIndex) <= 0xa9)
			{
				nOffset = (*(pcBuffer+nIndex) - 0xa1) * 94;
			}
			else
			{
				nOffset = (*(pcBuffer+nIndex) - 0xa7) * 94;
			}
			nOffset = (nOffset + (*(pcBuffer+nIndex+1) - 0xa1)) *2;
			*(pcBuffer+nIndex) = *(s_pcG2BTab + nOffset);
			*(pcBuffer+nIndex+1) = *(s_pcG2BTab + nOffset + 1);
			nIndex++;
		}
		nIndex++;
	}
}

//*************************************************************
//此函数调用文件资源
char* LoadLongResource(UINT nID)
{
	char* pszStorage = NULL;
	HRSRC hRes;
	HINSTANCE hInst = AfxGetResourceHandle();
	BOOL bResult = FALSE;
	
	LPTSTR lpSrc = MAKEINTRESOURCE(nID);
	hRes = FindResource(hInst, MAKEINTRESOURCE(nID), _T("BIGCHAR"));
	if (hRes != NULL)
	{
		DWORD dwSize = SizeofResource(hInst, hRes);
		if (dwSize > 0)
		{
			pszStorage = (char*)malloc(dwSize);

			HGLOBAL hGlob = LoadResource(hInst, hRes);
			if (hGlob != NULL)
			{
				LPVOID lpData = LockResource(hGlob);

				if (lpData != NULL)
				{
					memcpy(pszStorage, lpData, dwSize);
					bResult = TRUE;
				}

				FreeResource(hGlob);
			}
		}
	}

	return pszStorage;
}

char* CBIG5::Process(char* pcBuffer, int nSize)
{
	char* pcTemp = pcBuffer;
	int nCharType = _NO_DBCS;
	char* szBuf = NULL;
	
	if (nSize > 0)
	{
		szBuf = (char*) malloc(nSize);
		memcpy(szBuf, pcBuffer, nSize);
		// Convert here.
		switch (m_nTrunType)
		{
		case TRUNTOBIG5:
			g2b((unsigned char*)szBuf,nSize);
			break;
		case TRUNTOGB:
			b2g((unsigned char*)szBuf,nSize);
			break;
		}
	}

	return szBuf;
}


STDMETHODIMP CBIG5::get_TrunType(short *pVal)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

	*pVal = m_nTrunType;

	return S_OK;
}

STDMETHODIMP CBIG5::put_TrunType(short newVal)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

	m_nTrunType = newVal;

	return S_OK;
}