ectrans.c

windows环境下的一套汉字处理引擎,可以对汉字进行相应的处理

/*************************************************************************
	   File: ECTRANS.C
	 Module: WSENGINE.DLL
	   Date: 1994.1 - 1995.1
     Created By: Wang Zhidong
    Description: English-Chinese Translation Manager for MLR System.
	Exports:
		 WseResetECDict
		 WseConfigECDict

		 ECDctFindString
		 _InitECDct
		 _ExitECDct
*************************************************************************/
#include <windows.h>
#include <commdlg.h>
#include <mate.h>

#define huge

#include "engine.h"

#define GMEMBLOCKFLAG (GMEM_MOVEABLE | GMEM_DISCARDABLE | GMEM_SHARE)
#define ECERRBUFFSIZE	0x10000

#define ___Araaa

long	IndexPosTab[256];
BOOL	ECTransEnable = FALSE;
HANDLE	hECCache = NULL;
HWND	hWndECDialog = NULL;
extern	HANDLE hInst;

int	ECRecordLevel = 0;
HGLOBAL hMemECErr = NULL;

extern char szSystem[];
extern char szConfirm[];
extern char szConfirmDelete[];
extern char szTextFilter[];
extern char szSaveAs[];
extern char szAlwaysOnTop[];
extern char szRICHWINHLP[];
extern char szECWINMLR[];
extern char szMLR_LIB[];

BOOL RecordNewECError (LPSTR lpEStr)
{
//    HFILE   hFile;
    HGLOBAL hmemECLib;
    LPSTR   lpECLib, lpStr, lpECErr;
    UINT    i;

    if (hMemECErr == NULL)
	return NULL;

    lpECErr = GlobalLock (hMemECErr);
    if (lpECErr == NULL)
	return NULL;

    i = lstrlen (lpEStr);
    for (lpStr = lpEStr; (UINT)(lpStr-lpEStr) < i; lpStr = WseCharNext (HCODE_SYSTEM, lpStr))
	{
	if (WseCharNext (HCODE_SYSTEM, lpStr)-lpStr == 2)
	    return NULL;	// Is a Chinese String.
	}

    hmemECLib = GlobalAlloc (GPTR, 2*lstrlen(lpEStr)+2);
    lpECLib = GlobalLock (hmemECLib);
    for (i = 0, lpStr = lpEStr; *lpStr; i++, lpStr++)
	{
	switch (*lpStr)
	    {
	    case 8:
		lpECLib[i] = '\\'; i++;
		lpECLib[i] = 'a';
		break;
	    case 9:
		lpECLib[i] = '\\'; i++;
		lpECLib[i] = 't';
		break;
	    case 10:
		lpECLib[i] = '\\'; i++;
		lpECLib[i] = 'n';
		break;
	    case 13:
		lpECLib[i] = '\\'; i++;
		lpECLib[i] = 't';
		break;
	    case '=':
		lpECLib[i] = '\\'; i++;
	    default:
		lpECLib[i] = *lpStr;
	    }
	}
    lpECLib[i] = '\0';

    for (lpStr = lpECErr; *lpStr; lpStr += lstrlen(lpStr)+1)
	{
	if (lstrcmpi (lpStr, lpECLib) == NULL)
	    {
	    GlobalUnlock (hmemECLib);
	    GlobalFree (hmemECLib);
	    GlobalUnlock (hMemECErr);
	    return FALSE;
	    }
	}

    i = lstrlen(lpECLib)+1;
    if (!IsBadWritePtr (lpStr, i))
	{
	lstrcpy (lpStr, lpECLib);
	lpStr[i] = 0;
	}

    GlobalUnlock (hMemECErr);
    GlobalUnlock (hmemECLib);
    GlobalFree (hmemECLib);

    return TRUE;
}

int FindString (LPSTR lpEStr, LPSTR lpCStr, int wSize)
{
	long	dwCnt;
	HGLOBAL hmemECLib;
	LPSTR	lpECLib, lpStr;
	int	wCnt, i;
	char	ch;
	int	wLen = lstrlen (lpEStr);

	if (!ECTransEnable)
	    return NULL;

	if (wLen < 1 || wLen > 255)
		return NULL;

	if (ECRecordLevel == 2)
	    RecordNewECError (lpEStr);

	dwCnt = IndexPosTab[wLen] - IndexPosTab[wLen-1];

	if (dwCnt <= 0 || dwCnt > 0x10000)
		{
#ifndef DEMO
		if (ECRecordLevel == 1)
		    RecordNewECError (lpEStr);
#endif
		return NULL;
		}

	hmemECLib = GlobalAlloc (GPTR, dwCnt+10);
	if (hmemECLib == NULL)
		return NULL;

	lpECLib = GlobalLock (hmemECLib);
	if (lpECLib == NULL)
		{
		GlobalFree (hmemECLib);
		return NULL;
		}

	if (!WseReadFileCache (hECCache, IndexPosTab[wLen-1],
			       (UINT)dwCnt, lpECLib))
		{
		GlobalUnlock (hmemECLib);
		GlobalFree (hmemECLib);
		return NULL;
		}

	ch = lpEStr[0] & ~0x20;
	if (ch < 'A' || ch > 'Z')
		{
		ch = lpEStr[1] & ~0x20;
		if (ch < 'A' || ch > 'Z')
			ch = '@';
		}
	i = ch - '@';

	if (i == 0)
		{
		lpStr = lpECLib+27*2;
		wCnt = *(UINT far *)lpECLib;
		}
	else
		{
		lpStr = lpECLib+27*2+((UINT far *)lpECLib)[i-1]*(wLen+3);
		wCnt = ((UINT far *)lpECLib)[i] - ((UINT far *)lpECLib)[i-1];
		}

	while (wCnt > 0 && lstrcmpi (lpStr+2, lpEStr) != NULL)
		{
		lpStr += wLen+3;
		wCnt--;
		}

	if (wCnt <= 0)
		{
		GlobalUnlock (hmemECLib);
		GlobalFree (hmemECLib);
#ifndef DEMO
		if (ECRecordLevel== 1)
		    RecordNewECError (lpEStr);
#endif
		return NULL;
		}

	lpStr = lpECLib+*(UINT far *)lpStr;
	wCnt = lstrlen (lpStr);
	if (lpCStr != NULL && wSize > 1)
		{
		wCnt = min(wCnt, wSize-1);
		WseRepMovsb (lpCStr, lpStr, wCnt);
		lpCStr[wCnt] = 0;
		}
	GlobalUnlock (hmemECLib);
	GlobalFree (hmemECLib);
	return wCnt;
}

BOOL WINAPI WseResetECDict (LPSTR lpStr, WORD wTag)
{

    NPSTR   szFile;
    HFILE   hFile;
    int     i;

    szFile = (NPSTR)LocalAlloc (LPTR, 64);
    WseGetModuleFilePath (NULL, szFile, 63);
    lstrcat (szFile, szECWINMLR);

    hFile = _lopen (szFile, OF_READ);

    if (hFile == HFILE_ERROR)
	{
	LocalFree ((HANDLE)szFile);
	return FALSE;
	}
    _lread (hFile, (LPSTR)IndexPosTab, 64);
    if (lstrcmp ((LPSTR)IndexPosTab, szMLR_LIB) != NULL)
	    {
	    _lclose (hFile);
	    LocalFree ((HANDLE)szFile);
	    return FALSE;
	    }
    _lread (hFile, (LPSTR)IndexPosTab, sizeof(IndexPosTab));
    _lclose (hFile);

    if (hECCache)
	WseReleaseFileCache (hECCache);

    hECCache = WseBuildFileCache (szFile, IndexPosTab[0],
				  IndexPosTab[255] - IndexPosTab[0]);
    for (i = 1; i < 256; i++)
	IndexPosTab[i] -= IndexPosTab[0];
    IndexPosTab[0] = 0;

    LocalFree ((HANDLE)szFile);

    if (hECCache == NULL)
	{
	ECTransEnable = NULL;
	return FALSE;
	}
    return TRUE;
}

int WINAPI ECDctFindString (LPSTR lpEStr, LPSTR lpCStr, int wSize)
{
    int i, j;
    char csk = 0;
    int wCnt = lstrlen (lpEStr);
    HGLOBAL hmStr = GlobalAlloc (GPTR, wCnt+2);
    LPSTR lpStr = GlobalLock (hmStr);
    if (lpStr == NULL)
	{
	if (hmStr)
	    {
	    GlobalUnlock (hmStr);
	    GlobalFree (hmStr);
	    }
	return NULL;
	}

    for (i = j = 0; i < wCnt && (BYTE)(lpEStr[i]) >= ' '; i++, j++)
	{
	if (lpEStr[i] == '&')
	    {
	    i++;
	    if (lpEStr[i] != '&')
		csk = lpEStr[i];
	    }
	lpStr[j] = lpEStr[i];
	}

    while (j > 0 &&
	  (lpEStr[i-1] == '.' || lpEStr[i-1] == ':' || lpEStr[i-1] == ' '))
	{
	i--;
	j--;
	}
    lpStr[j] = 0;

    lstrcpy (lpStr+j+1, lpEStr+i);

    i  = lstrlen (lpEStr+i);
    if (csk)
	i += 4;

    if (FindString (lpStr, lpCStr, wSize))
	{
	wCnt = lstrlen (lpCStr);
	if (i+wCnt < wSize)
	    {
	    if (lpCStr)
		{
		if (csk)
		    {
		    *(DWORD FAR *)(lpCStr+wCnt) = *(DWORD *)&"(&&)";
		    lpCStr[wCnt+2] = (csk & ~0x20);
		    lpCStr[wCnt+4] = 0;
		    lstrcpy (lpCStr+wCnt+4, lpStr+j+1);
		    }
		else
		    lstrcpy (lpCStr+wCnt, lpStr+j+1);
		}
	    wCnt += i;
	    }
	}
    else
	wCnt = NULL;

    GlobalUnlock (hmStr);
    GlobalFree (hmStr);
    return wCnt;
}

int FindNearestString (LPSTR lpEStr, LPSTR lpCStr, int wSize)
{
    int i;
    NPSTR pStr;

    if (i = ECDctFindString (lpEStr, lpCStr, wSize))
	return i;

    pStr = (NPSTR)LocalAlloc (LPTR, lstrlen(lpEStr)+4);
    lstrcpy (pStr, lpEStr);

    for (i = 0; pStr[i]; i++)
	{
	if (pStr[i] == ' ')
	    {
	    pStr[i] = 0;
	    i++;
	    }
	}

    lpEStr = lpCStr;

    if (pStr[lstrlen (pStr)+1] && wSize > 1)
	{
	*lpCStr = '*';
	lpCStr++;
	wSize--;
	}
    *lpCStr = 0;

    for (i = 0; pStr[i]; i += lstrlen(pStr+i)+1)
	{
	int wCnt = ECDctFindString (pStr+i, lpCStr, wSize);
	if (wCnt)
	    wSize -= wCnt;
	else if (wSize > (wCnt = lstrlen (pStr+i)))
	    {
	    lstrcpy (lpCStr, pStr+i);
	    if (pStr[i+wCnt+1])
		{
		lstrcat (lpCStr, " ");
		wCnt++;
		}
	    wSize -= wCnt;
	    }
	lpCStr += lstrlen (lpCStr);
	}
    LocalFree ((HANDLE)pStr);

    return lstrlen (lpEStr);
}

BOOL ECDctModifyString (LPSTR lpEStr, LPSTR lpCStr)
{
    long    dwCnt;
    HGLOBAL hmemECLib;
    LPSTR   lpECLib, lpStr;
    int     wCnt, i, j, k;
    char    ch;
    HFILE   hFile;
    int     wLen = lstrlen (lpEStr);

    if (wLen < 1 || wLen > 255)
	return FALSE;

    for (lpStr = lpEStr; *lpStr && WseCharNext (HCODE_SYSTEM, lpStr) != lpStr+2; lpStr++);
    if (*lpStr)
	return FALSE;		// Is a Chinese String.

    dwCnt = IndexPosTab[wLen] - IndexPosTab[wLen-1];

    if (dwCnt < 0 || dwCnt > 0x10000)
	return FALSE;		// MLR Error

    ch = lpEStr[0] & ~0x20;
    if (ch < 'A' || ch > 'Z')
	{
	ch = lpEStr[1] & ~0x20;
	if (ch < 'A' || ch > 'Z')
	    ch = '@';
	}
    i = ch - '@';               // Get First Char ID

    wCnt = (wLen+3)+lstrlen (lpCStr)+1;

    hmemECLib = GlobalAlloc (GPTR, max(27*2,dwCnt)+wCnt+10);