1168 lines
33 KiB
C
1168 lines
33 KiB
C
|
|
/*************************************************
|
|
* convcomm.c *
|
|
* *
|
|
* Copyright (C) 1995-1999 Microsoft Inc. *
|
|
* *
|
|
*************************************************/
|
|
|
|
#include "conv.h"
|
|
|
|
int CheckDescription(HANDLE hWnd, LPDESCRIPTION lpDescript)
|
|
//*** check description illegal ****
|
|
{
|
|
TCHAR szStr[256];
|
|
|
|
if(lstrlen(lpDescript->szName) == 0) {
|
|
LoadString(NULL,IDS_IMENAMEENTRY,szStr, sizeof(szStr)/sizeof(TCHAR));
|
|
InfoMessage(hWnd,szStr);
|
|
lpDescript->szName[24] = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
if(lpDescript->wMaxCodes == 0) {
|
|
LoadString(NULL,IDS_MAXCODESENTRY,szStr, sizeof(szStr)/sizeof(TCHAR));
|
|
WarnMessage(hWnd,szStr);
|
|
return FALSE;
|
|
}
|
|
|
|
if(lpDescript->byMaxElement == 0) {
|
|
lpDescript->byMaxElement = 1;
|
|
LoadString(NULL,IDS_ELEMENTENTRY,szStr, sizeof(szStr)/sizeof(TCHAR));
|
|
WarnMessage(hWnd,szStr);
|
|
return FALSE;
|
|
}
|
|
|
|
if( !CheckCodeCollection(hWnd,lpDescript->szUsedCode) )
|
|
return FALSE;
|
|
|
|
lpDescript->wNumCodes = (WORD) lstrlen(lpDescript->szUsedCode);
|
|
|
|
if(lpDescript->cWildChar == 0)
|
|
lpDescript->cWildChar = '?';
|
|
if(_tcschr(lpDescript->szUsedCode,lpDescript->cWildChar) != NULL) {
|
|
ProcessError(ERR_WILDCHAR,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
|
|
if(lpDescript->wNumRules >= 12) {
|
|
lpDescript->wNumRules=0;
|
|
LoadString(NULL,IDS_NUMRULESENTRY,szStr, sizeof(szStr)/sizeof(TCHAR));
|
|
WarnMessage(szStr,hWnd);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
int GetDescriptEntry(LPTSTR szSrcStr, LPDESCRIPTION lpDescript)
|
|
//*** get one description entry from source string ****
|
|
{
|
|
TCHAR szStr[256];
|
|
int retValue;
|
|
|
|
|
|
SetCursor (LoadCursor (NULL, IDC_WAIT));
|
|
if( GetEntryString(szSrcStr,
|
|
TEXT("Name"),
|
|
lpDescript->szName,
|
|
lpDescript->szName,
|
|
NAMESIZE-1)
|
|
)
|
|
return TRUE;
|
|
|
|
if( GetEntryInt(szSrcStr,
|
|
TEXT("MaxCodes"),
|
|
(int)lpDescript->wMaxCodes,
|
|
&retValue)
|
|
)
|
|
{
|
|
lpDescript->wMaxCodes = (WORD)retValue;
|
|
return TRUE;
|
|
}
|
|
|
|
if( GetEntryInt(szSrcStr,
|
|
TEXT("MaxElement"),
|
|
(int)lpDescript->byMaxElement,
|
|
& retValue)
|
|
)
|
|
{
|
|
lpDescript->byMaxElement = (BYTE) retValue;
|
|
return TRUE;
|
|
}
|
|
|
|
retValue = GetEntryString(szSrcStr,
|
|
TEXT("UsedCodes"),
|
|
lpDescript->szUsedCode,
|
|
szStr,
|
|
MAXUSEDCODES
|
|
);
|
|
if(retValue)
|
|
{
|
|
DelSpace(szStr);
|
|
lstrncpy(lpDescript->szUsedCode,MAXUSEDCODES,szStr);
|
|
return TRUE;
|
|
}
|
|
|
|
szStr[0] = lpDescript->cWildChar;
|
|
szStr[1] = 0;
|
|
|
|
retValue = GetEntryString(szSrcStr,
|
|
TEXT("WildChar"),
|
|
szStr,
|
|
szStr,
|
|
sizeof(szStr)/sizeof(TCHAR));
|
|
|
|
if(retValue)
|
|
{
|
|
DelSpace(szStr);
|
|
lpDescript->cWildChar = szStr[0];
|
|
return TRUE;
|
|
}
|
|
|
|
if(GetEntryInt(szSrcStr,
|
|
TEXT("NumRules"),
|
|
(int)lpDescript->wNumRules,
|
|
&retValue )
|
|
)
|
|
lpDescript->wNumRules = (WORD)retValue;
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
int ConvGetDescript(HANDLE hWnd,
|
|
LPCTSTR FileName,
|
|
LPDWORD fdwOffset,
|
|
LPDWORD fdwLen,
|
|
LPDESCRIPTION lpDescript,
|
|
BOOL bOnlyGetLength)
|
|
{
|
|
TCHAR szStr[1024];
|
|
TCHAR *Buffer;
|
|
BOOL bDescript = FALSE,bText = FALSE,bRule = FALSE;
|
|
BOOL bGetDes = FALSE;
|
|
register int i,j;
|
|
DWORD dwFstOffset=0 , dwOffset;
|
|
DWORD dwReadBytes;
|
|
HANDLE hFile;
|
|
HLOCAL hBuffer;
|
|
int errno;
|
|
|
|
if(!bOnlyGetLength)
|
|
{
|
|
memset(lpDescript->szName,0,sizeof(lpDescript->szName));
|
|
lpDescript->wMaxCodes=0;
|
|
lpDescript->byMaxElement=1;
|
|
memset(lpDescript->szUsedCode,0,sizeof(lpDescript->szUsedCode));
|
|
lpDescript->wNumRules=0;
|
|
lpDescript->wNumCodes=0;
|
|
lpDescript->cWildChar=0;
|
|
}
|
|
|
|
hFile = Create_File(hWnd,FileName,GENERIC_READ,OPEN_EXISTING);
|
|
if (hFile == (HANDLE)-1)
|
|
return (-ERR_FILENOTOPEN);
|
|
hBuffer = LocalAlloc(LMEM_ZEROINIT|LMEM_MOVEABLE, MAXREADBUFFER);
|
|
Buffer = (TCHAR *) LocalLock(hBuffer);
|
|
SetCursor (LoadCursor (NULL, IDC_WAIT));
|
|
*fdwOffset = 0;
|
|
SetFilePointer(hFile,0,0,FILE_BEGIN);
|
|
while(ReadFile(hFile,Buffer,MAXREADBUFFER,&dwReadBytes,NULL))
|
|
{
|
|
dwReadBytes = dwReadBytes/sizeof(TCHAR);
|
|
lstrcpy(szStr,TEXT(""));
|
|
j=0;
|
|
for(i=0;i<(int)dwReadBytes;i++) {
|
|
if(Buffer[i] == 0x0d || Buffer[i] == 0xfeff)
|
|
continue;
|
|
else if(Buffer[i] == TEXT('\n')) {
|
|
szStr[j]=0;
|
|
j=0;
|
|
if(lstrlen(szStr) < 6) continue;
|
|
if(lstrcmpi(szStr,TEXT(DescriptSeg))==0) {
|
|
#ifdef UNICODE
|
|
*fdwOffset= dwOffset - 2; //the size of 0xfeff flag
|
|
#else
|
|
*fdwOffset= dwOffset;
|
|
#endif
|
|
bDescript = TRUE;
|
|
bGetDes = TRUE;
|
|
lstrcpy(szStr,TEXT(""));
|
|
continue;
|
|
}
|
|
|
|
if( lstrcmpi(szStr,TEXT(TextSeg))==0)
|
|
{
|
|
bText =TRUE;
|
|
bGetDes = FALSE;
|
|
}
|
|
if( lstrcmpi(szStr,TEXT(RuleSeg))==0)
|
|
{
|
|
bRule = TRUE;
|
|
bGetDes = FALSE;
|
|
}
|
|
if( (bText||bRule)&& bDescript && !bGetDes) {
|
|
*fdwLen = dwOffset - (*fdwOffset);
|
|
if(!bOnlyGetLength)
|
|
errno = CheckDescription(hWnd, lpDescript);
|
|
LocalUnlock(hBuffer);
|
|
LocalFree(hBuffer);
|
|
CloseHandle(hFile);
|
|
SetCursor (LoadCursor (NULL, IDC_ARROW));
|
|
return errno;
|
|
}
|
|
if(bGetDes && !bOnlyGetLength)
|
|
{
|
|
GetDescriptEntry(szStr,lpDescript);
|
|
}
|
|
lstrcpy(szStr,TEXT(""));
|
|
continue;
|
|
}
|
|
else {
|
|
if(j == 0)
|
|
dwOffset = dwFstOffset + i*sizeof(TCHAR);
|
|
if(j<1024){
|
|
szStr[j]=Buffer[i];
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
if(dwReadBytes*sizeof(TCHAR) < MAXREADBUFFER) break;
|
|
dwFstOffset += MAXREADBUFFER;
|
|
};
|
|
|
|
*fdwLen = dwFstOffset+dwReadBytes-(*fdwOffset);
|
|
if(!bDescript) *fdwLen = 0;
|
|
LocalUnlock(hBuffer);
|
|
LocalFree(hBuffer);
|
|
CloseHandle(hFile);
|
|
errno = 0;
|
|
|
|
if(!bText) {
|
|
ProcessError(ERR_TEXTSEG,hWnd,ERR);
|
|
errno |= 4;
|
|
}
|
|
|
|
if(!bDescript) {
|
|
if(bText)
|
|
ProcessError(ERR_DESCRIPTSEG,hWnd,ERR);
|
|
errno |= 1;
|
|
}
|
|
if(!bRule){
|
|
if(bText && bDescript)
|
|
ProcessError(ERR_RULESEG,hWnd,WARNING);
|
|
errno |= 2;
|
|
}
|
|
SetCursor (LoadCursor (NULL, IDC_ARROW));
|
|
if(bDescript && bRule && bText)
|
|
return TRUE;
|
|
else
|
|
return (-errno);
|
|
}
|
|
|
|
|
|
BOOL ConvSaveDescript(LPCTSTR SrcFileName,
|
|
LPDESCRIPTION lpDescript,
|
|
DWORD dwOffset,
|
|
DWORD dwLength)
|
|
//*** save MB description to source text file ****
|
|
{
|
|
TCHAR szStr[256],szTemp[80],Buffer[4096];
|
|
DWORD dwBytes,dwNewLen;
|
|
HANDLE hSrcFile;
|
|
BOOL bText=TRUE;
|
|
WORD wFlag;
|
|
|
|
hSrcFile = Create_File(GetFocus(),SrcFileName,GENERIC_READ|GENERIC_WRITE,OPEN_EXISTING);
|
|
if (hSrcFile == (HANDLE)-1)
|
|
return FALSE;
|
|
|
|
#ifdef UNICODE
|
|
Buffer[0] = 0xfeff;
|
|
lstrcpy(&Buffer[1],TEXT("[Description]\r\n"));
|
|
#else
|
|
lstrcpy(Buffer,TEXT("[Description]\r\n"));
|
|
#endif
|
|
|
|
SetFilePointer(hSrcFile,dwOffset+dwLength,0,FILE_BEGIN);
|
|
ReadFile(hSrcFile,szTemp,sizeof(szTemp), &dwBytes,NULL);
|
|
if(dwBytes == 0 || szTemp[0] != TEXT('['))
|
|
bText = FALSE;
|
|
if(SetFilePointer(hSrcFile,dwOffset,0,FILE_BEGIN) != dwOffset) {
|
|
CloseHandle(hSrcFile);
|
|
return FALSE;
|
|
}
|
|
if(!CheckCodeCollection(GetFocus(),lpDescript->szUsedCode))
|
|
{
|
|
CloseHandle(hSrcFile);
|
|
return FALSE;
|
|
}
|
|
|
|
SetCursor (LoadCursor (NULL, IDC_WAIT));
|
|
//write code list name to buffer ****
|
|
wsprintf(szStr,TEXT("Name=%s\r\n"),lpDescript->szName);
|
|
lstrcat(Buffer,szStr);
|
|
|
|
//write maximum length of codes to buffer***
|
|
wsprintf(szStr,TEXT("MaxCodes=%d\r\n"),(int)lpDescript->wMaxCodes);
|
|
lstrcat(Buffer,szStr);
|
|
|
|
//write maximum element to Buffer ***
|
|
wsprintf(szStr,TEXT("MaxElement=%d\r\n"),(int)lpDescript->byMaxElement);
|
|
lstrcat(Buffer,szStr);
|
|
|
|
//write used codes collection ***
|
|
lstrncpy(szTemp,MAXUSEDCODES,lpDescript->szUsedCode);
|
|
szTemp[MAXUSEDCODES]=0;
|
|
wsprintf(szStr,TEXT("UsedCodes=%s\r\n"),lpDescript->szUsedCode);
|
|
lstrcat(Buffer,szStr);
|
|
|
|
//write wild char ***
|
|
if(lpDescript->cWildChar == 0)
|
|
lpDescript->cWildChar = TEXT('?'); //**** add by yehfeh 95.10.11
|
|
wsprintf(szStr,TEXT("WildChar=%c\r\n"),lpDescript->cWildChar);
|
|
lstrcat(Buffer,szStr);
|
|
|
|
//write number of rules ***
|
|
wsprintf(szStr,TEXT("NumRules=%d\r\n"),(int)lpDescript->wNumRules);
|
|
lstrcat(Buffer,szStr);
|
|
|
|
if(!bText)
|
|
lstrcat(Buffer,TEXT("[Text]\r\n"));
|
|
|
|
dwNewLen = lstrlen(Buffer)*sizeof(TCHAR);
|
|
if(dwNewLen > dwLength)
|
|
MoveFileBlock(hSrcFile,dwOffset+dwLength,dwNewLen-dwLength,1);
|
|
else
|
|
MoveFileBlock(hSrcFile,dwOffset+dwLength,dwLength-dwNewLen,0);
|
|
|
|
SetFilePointer(hSrcFile,dwOffset,0,FILE_BEGIN);
|
|
WriteFile(hSrcFile,Buffer,dwNewLen,&dwBytes,NULL);
|
|
CloseHandle(hSrcFile);
|
|
SetCursor (LoadCursor (NULL, IDC_ARROW));
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int ConvGetRule(HANDLE hWnd,LPCTSTR lpSrcFile,LPDWORD fdwOffset,
|
|
LPDWORD fdwRuleLen,LPRULE lpRule, LPDESCRIPTION lpDescript)
|
|
//*** read create word rule from source text file****
|
|
{
|
|
TCHAR szStr[256],Buffer[MAXREADBUFFER];
|
|
BOOL bRule=FALSE;
|
|
register int i,j;
|
|
DWORD dwReadBytes;
|
|
DWORD dwNumRules = 0;
|
|
DWORD dwFstOffset = 0, dwOffset;
|
|
HANDLE hSrcFile;
|
|
|
|
|
|
*fdwOffset = 0;
|
|
hSrcFile = Create_File(hWnd,lpSrcFile,GENERIC_READ,OPEN_EXISTING);
|
|
if (hSrcFile == (HANDLE)-1)
|
|
return (-ERR_FILENOTOPEN);
|
|
SetCursor (LoadCursor (NULL, IDC_WAIT));
|
|
SetFilePointer(hSrcFile,0,0,FILE_BEGIN);
|
|
while(ReadFile(hSrcFile,Buffer,MAXREADBUFFER,&dwReadBytes,NULL))
|
|
{
|
|
dwReadBytes = dwReadBytes/sizeof(TCHAR);
|
|
lstrcpy(szStr,TEXT(""));
|
|
j=0;
|
|
for(i=0;i<(int)dwReadBytes;i++) {
|
|
if(Buffer[i] == 0x0d || Buffer[i] == 0xfeff)
|
|
continue;
|
|
else if(Buffer[i] == TEXT('\n')) {
|
|
szStr[j]=0;
|
|
j=0;
|
|
if(lstrlen(szStr) < 4) continue;
|
|
if(lstrcmpi(szStr,TEXT(RuleSeg))==0) {
|
|
*fdwOffset= dwOffset;
|
|
bRule = TRUE;
|
|
lstrcpy(szStr,TEXT(""));
|
|
continue;
|
|
}
|
|
|
|
if( (lstrcmpi(szStr,TEXT(TextSeg))==0
|
|
||lstrcmpi(szStr,TEXT(DescriptSeg))==0)
|
|
&& bRule) {
|
|
*fdwRuleLen = dwOffset - (*fdwOffset);
|
|
CloseHandle(hSrcFile);
|
|
SetCursor (LoadCursor (NULL, IDC_ARROW));
|
|
if(dwNumRules != lpDescript->wNumRules) {
|
|
ProcessError(ERR_RULENUM,hWnd,ERR);
|
|
lpDescript->wNumRules =(WORD) dwNumRules;
|
|
return (-ERR_RULENUM);
|
|
}
|
|
return TRUE;
|
|
}
|
|
if(bRule) {
|
|
if(RuleParse(hWnd,szStr,dwNumRules,lpRule,lpDescript->wMaxCodes))
|
|
dwNumRules ++;
|
|
else {
|
|
CloseHandle(hSrcFile);
|
|
SetCursor (LoadCursor (NULL, IDC_ARROW));
|
|
return (-ERR_RULENUM);
|
|
}
|
|
lstrcpy(szStr,TEXT(""));
|
|
if(dwNumRules > lpDescript->wNumRules) {
|
|
ProcessError(ERR_RULENUM,hWnd,ERR);
|
|
CloseHandle(hSrcFile);
|
|
SetCursor (LoadCursor (NULL, IDC_ARROW));
|
|
return(-ERR_RULENUM);
|
|
}
|
|
continue;
|
|
}
|
|
else {
|
|
lstrcpy(szStr,TEXT(""));
|
|
continue;
|
|
}
|
|
}
|
|
else {
|
|
if(j == 0)
|
|
dwOffset = dwFstOffset + i*sizeof(TCHAR);
|
|
szStr[j]=Buffer[i];
|
|
j++;
|
|
}
|
|
} /*** for (i=0;...) ****/
|
|
if(dwReadBytes*sizeof(TCHAR) < MAXREADBUFFER) break;
|
|
dwFstOffset += MAXREADBUFFER;
|
|
};
|
|
|
|
*fdwRuleLen = dwFstOffset+dwReadBytes-(*fdwOffset);
|
|
|
|
if(!bRule)
|
|
*fdwRuleLen=0;
|
|
CloseHandle(hSrcFile);
|
|
|
|
SetCursor (LoadCursor (NULL, IDC_ARROW));
|
|
if(bRule||lpDescript->wNumRules==0)
|
|
return TRUE;
|
|
else {
|
|
ProcessError(ERR_RULESEG,hWnd,ERR);
|
|
lpDescript->wNumRules=0;
|
|
return (-ERR_RULESEG);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL ConvSaveRule(HANDLE hWnd,LPCTSTR SrcFileName,DWORD dwOffset, DWORD dwLength,
|
|
LPRULE lpRule, DWORD dwNumRules)
|
|
//*** save create word rule to source text file****
|
|
{
|
|
TCHAR szStr[256],Buffer[4096];
|
|
DWORD dwBytes,dwNewLen;
|
|
DWORD i;
|
|
HANDLE hFile;
|
|
|
|
hFile = Create_File(hWnd,SrcFileName,GENERIC_READ|GENERIC_WRITE,OPEN_EXISTING);
|
|
if (hFile == (HANDLE)-1)
|
|
return FALSE;
|
|
SetCursor (LoadCursor (NULL, IDC_WAIT));
|
|
lstrcpy(Buffer,TEXT("[Rule]\r\n"));
|
|
for(i=0; i<dwNumRules; i++) {
|
|
RuleToText(&lpRule[i], szStr);
|
|
lstrcat(Buffer,szStr);
|
|
}
|
|
|
|
dwNewLen = lstrlen(Buffer)*sizeof(TCHAR);
|
|
if(dwNewLen > dwLength)
|
|
MoveFileBlock(hFile,dwOffset+dwLength,dwNewLen-dwLength,1);
|
|
else
|
|
MoveFileBlock(hFile,dwOffset+dwLength,dwLength-dwNewLen,0);
|
|
SetFilePointer(hFile,dwOffset,0,FILE_BEGIN);
|
|
WriteFile(hFile,Buffer,dwNewLen,&dwBytes,NULL);
|
|
|
|
CloseHandle(hFile);
|
|
SetCursor (LoadCursor (NULL, IDC_ARROW));
|
|
return TRUE;
|
|
}
|
|
|
|
LPTSTR ConvCreateWord(HWND hWnd,LPCTSTR MBFileName,LPTSTR szWordStr)
|
|
{
|
|
int nWordLen = lstrlen(szWordStr)*sizeof(TCHAR)/2;
|
|
DWORD i,j,k,dwCodeLen;
|
|
TCHAR szDBCS[3],szCode[MAXCODELEN+1];
|
|
static TCHAR lpCode[128];
|
|
BOOL bReturn=FALSE;
|
|
HANDLE hMBFile;
|
|
DESCRIPTION Descript;
|
|
HANDLE hRule0;
|
|
LPRULE lpRule;
|
|
MAININDEX MainIndex[NUMTABLES];
|
|
|
|
for(i=0; i< 128; i++)
|
|
lpCode[0] = 0;
|
|
|
|
if(lstrlen(MBFileName)==0 || lstrlen(szWordStr) == 0)
|
|
return (LPTSTR)lpCode;
|
|
hMBFile = Create_File(hWnd,MBFileName,GENERIC_READ,OPEN_EXISTING);
|
|
if(hMBFile == (HANDLE)-1)
|
|
return (LPTSTR)lpCode;
|
|
if(!ConvGetMainIndex(hWnd,hMBFile,MainIndex)) {
|
|
CloseHandle(hMBFile);
|
|
return (LPTSTR)lpCode;
|
|
}
|
|
|
|
ConvReadDescript(hMBFile,&Descript, MainIndex);
|
|
|
|
if(Descript.wNumRules == 0) {
|
|
MessageBeep((UINT)-1);
|
|
MessageBeep((UINT)-1);
|
|
CloseHandle(hMBFile);
|
|
return (LPTSTR)lpCode;
|
|
}
|
|
hRule0 = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,sizeof(RULE)*Descript.wNumRules);
|
|
if(!hRule0) {
|
|
ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
|
|
CloseHandle(hMBFile);
|
|
return (LPTSTR)lpCode;
|
|
}
|
|
|
|
if(!(lpRule = GlobalLock(hRule0)) ) {
|
|
ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
|
|
CloseHandle(hMBFile);
|
|
GlobalFree(hRule0);
|
|
return (LPTSTR)lpCode;
|
|
}
|
|
|
|
ConvReadRule(hMBFile,Descript.wNumRules ,lpRule, MainIndex);
|
|
|
|
for(i=0; i<Descript.wNumRules; i++)
|
|
if( (lpRule[i].byLogicOpra == 0 && nWordLen == lpRule[i].byLength)
|
|
||(lpRule[i].byLogicOpra == 1 && nWordLen >= lpRule[i].byLength)
|
|
||(lpRule[i].byLogicOpra == 2 && nWordLen <= lpRule[i].byLength) ) {
|
|
|
|
int retCodeLen = 0;
|
|
for(j=0; j<lpRule[i].wNumCodeUnits; j++) {
|
|
k = lpRule[i].CodeUnit[j].wDBCSPosition;
|
|
if(k > (DWORD)nWordLen) k = (DWORD)nWordLen;
|
|
if(lpRule[i].CodeUnit[j].dwDirectMode == 0)
|
|
lstrncpy(szDBCS,2,&szWordStr[2*(k-1)]);
|
|
else
|
|
lstrncpy(szDBCS,2,&szWordStr[2*(nWordLen-k)]);
|
|
szDBCS[2] = 0;
|
|
k = EncodeToNo(szDBCS);
|
|
if((long)k >= 0 && k < NUM_OF_ENCODE )
|
|
{
|
|
SetFilePointer(hMBFile,MainIndex[TAG_CRTWORDCODE-1].dwOffset+Descript.wMaxCodes*k*sizeof(TCHAR),
|
|
0,FILE_BEGIN);
|
|
ReadFile(hMBFile,szCode,Descript.wMaxCodes,&k,NULL);
|
|
szCode[Descript.wMaxCodes] = 0;
|
|
dwCodeLen = lstrlen(szCode);
|
|
k = lpRule[i].CodeUnit[j].wCodePosition;
|
|
if(k == 0)
|
|
{
|
|
if(retCodeLen + dwCodeLen > Descript.wMaxCodes)
|
|
szCode[Descript.wMaxCodes - retCodeLen] = 0;
|
|
lstrcat(lpCode,szCode);
|
|
}
|
|
else
|
|
{
|
|
if(k > dwCodeLen) k = dwCodeLen;
|
|
lpCode[j] = (szCode[k-1] == 0)?((k > 1)? szCode[k-2]:Descript.szUsedCode[0]):szCode[k-1];
|
|
}
|
|
}
|
|
else
|
|
lpCode[j] = (j > 0)?lpCode[j-1]:Descript.szUsedCode[0];
|
|
retCodeLen = lstrlen(lpCode);
|
|
}
|
|
bReturn = TRUE;
|
|
break;
|
|
}
|
|
|
|
if(!bReturn)
|
|
ProcessError(ERR_NOTDEFRULE,GetFocus(),ERR);
|
|
lpCode[Descript.wMaxCodes] = 0;
|
|
CloseHandle(hMBFile);
|
|
GlobalFree(hRule0);
|
|
return (LPTSTR)lpCode;
|
|
}
|
|
|
|
|
|
INT ReadDescript(LPCTSTR MBFileName, LPDESCRIPTION lpDescript,DWORD ShareMode)
|
|
//*** read description from .MB file ****
|
|
{
|
|
HANDLE hMBFile;
|
|
DWORD dwBytes,i;
|
|
DWORD dwOffset;
|
|
MAININDEX lpMainIndex[NUMTABLES];
|
|
|
|
hMBFile = Create_File(GetFocus(),MBFileName,GENERIC_READ,OPEN_EXISTING);
|
|
if(hMBFile==INVALID_HANDLE_VALUE)
|
|
return -1;
|
|
SetFilePointer(hMBFile,ID_LENGTH,0,FILE_BEGIN);
|
|
ReadFile(hMBFile,lpMainIndex,sizeof(MAININDEX)*NUMTABLES,&dwBytes,NULL);
|
|
for(i=0; i<NUMTABLES; i++) {
|
|
dwBytes = lpMainIndex[i].dwTag+
|
|
lpMainIndex[i].dwOffset+
|
|
lpMainIndex[i].dwLength;
|
|
if(lpMainIndex[i].dwCheckSum != dwBytes) {
|
|
CloseHandle(hMBFile);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
dwOffset = lpMainIndex[TAG_DESCRIPTION-1].dwOffset;
|
|
SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN);
|
|
ReadFile(hMBFile,lpDescript,sizeof(DESCRIPTION),&dwBytes,NULL);
|
|
CloseHandle(hMBFile);
|
|
if(dwBytes < sizeof(DESCRIPTION) )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ReadRule(HWND hWnd,
|
|
LPCTSTR MBFileName,
|
|
int nRuleNum,
|
|
LPRULE lpRule)
|
|
//*** read create word rule from .MB file ****
|
|
{
|
|
HANDLE hMBFile;
|
|
DWORD dwBytes,i;
|
|
DWORD dwOffset;
|
|
MAININDEX lpMainIndex[NUMTABLES];
|
|
|
|
hMBFile = Create_File(hWnd,MBFileName,GENERIC_READ,OPEN_EXISTING);
|
|
if(hMBFile==INVALID_HANDLE_VALUE)
|
|
return(0);
|
|
SetFilePointer(hMBFile,ID_LENGTH,0,FILE_BEGIN);
|
|
ReadFile(hMBFile,lpMainIndex,sizeof(MAININDEX)*NUMTABLES,&dwBytes,NULL);
|
|
for(i=0; i<NUMTABLES; i++) {
|
|
dwBytes = lpMainIndex[i].dwTag+
|
|
lpMainIndex[i].dwOffset+
|
|
lpMainIndex[i].dwLength;
|
|
if(lpMainIndex[i].dwCheckSum != dwBytes) {
|
|
//ProcessError(ERR_READMAININDEX,hWnd);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
dwOffset = lpMainIndex[TAG_RULE-1].dwOffset;
|
|
SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN);
|
|
ReadFile(hMBFile,lpRule,nRuleNum*sizeof(RULE),&dwBytes,NULL);
|
|
CloseHandle(hMBFile);
|
|
if(dwBytes < nRuleNum*sizeof(RULE) )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL RuleParse(HANDLE hWnd, LPTSTR szStr,DWORD dwRuleNum, LPRULE lpRule, WORD wMaxCodes)
|
|
{
|
|
LPTSTR lpString;
|
|
DWORD i,j;
|
|
DWORD dwLen;
|
|
BYTE byDBCSLen, byDBCSPos, byCodePos;
|
|
static TCHAR subDBCS[] =TEXT("123456789abcdef");
|
|
static TCHAR subCode[] =TEXT("0123456789abc");
|
|
|
|
DelSpace(szStr);
|
|
dwLen = lstrlen(szStr);
|
|
if(dwLen == 0) return FALSE;
|
|
if(_tcschr(szStr,TEXT('=')) == NULL) {
|
|
ProcessError(ERR_RULEEQUAL,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
if(_tcschr(TEXT("Cc"),szStr[0]) == NULL) {
|
|
ProcessError(ERR_RULEHEADER,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
if(_tcschr(TEXT("EeAaBb"),szStr[1]) == NULL) {
|
|
ProcessError(ERR_RULELOGICOPRA,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
if(_tcschr(subDBCS,szStr[2]) == NULL
|
|
|| szStr[3] != TEXT('=')) {
|
|
ProcessError(ERR_RULEWORDLEN,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
|
|
byDBCSLen = (szStr[2] > TEXT('9'))?szStr[2]-TEXT('a')+10:szStr[2]-TEXT('0');
|
|
lpRule[dwRuleNum].wNumCodeUnits = 0;
|
|
|
|
lpString = &szStr[4];
|
|
for(i=0; i<dwLen-4; i+=4) {
|
|
if(_tcschr(TEXT("PpNn"), lpString[i]) == NULL) {
|
|
ProcessError(ERR_RULEDIRECTMODE,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
byDBCSPos = (lpString[i+1]>TEXT('9'))?10+lpString[i+1]-TEXT('a'):lpString[i+1]-TEXT('0');
|
|
if(_tcschr(subDBCS, lpString[i+1]) == NULL
|
|
||byDBCSPos > byDBCSLen) {
|
|
ProcessError(ERR_RULEDBCSPOS,hWnd,ERR) ;
|
|
return FALSE;
|
|
}
|
|
byCodePos = (lpString[i+2]>TEXT('9'))?lpString[i+2]-TEXT('a')+10:lpString[i+2]-TEXT('0');
|
|
if(_tcschr(subCode, lpString[i+2]) == NULL
|
|
|| (lpString[i+3] != TEXT('+') && lpString[i+3] != 0)
|
|
|| byCodePos > wMaxCodes) {
|
|
ProcessError(ERR_RULECODEPOS,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
j = lpRule[dwRuleNum].wNumCodeUnits;
|
|
lpRule[dwRuleNum].CodeUnit[j].dwDirectMode=(lpString[i]==TEXT('p'))?0:1;
|
|
lpRule[dwRuleNum].CodeUnit[j].wDBCSPosition=(WORD)byDBCSPos;
|
|
lpRule[dwRuleNum].CodeUnit[j].wCodePosition=(WORD)byCodePos;
|
|
lpRule[dwRuleNum].wNumCodeUnits ++;
|
|
}
|
|
lpRule[dwRuleNum].byLogicOpra = (szStr[1]==TEXT('e'))?0:(szStr[1]==TEXT('a'))?1:2;
|
|
lpRule[dwRuleNum].byLength = byDBCSLen;
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvGetMainID(HANDLE hMBFile,LPMAINID lpMainID)
|
|
{
|
|
DWORD dwBytes;
|
|
SetFilePointer(hMBFile,0,0,FILE_BEGIN);
|
|
ReadFile(hMBFile,lpMainID,sizeof(MAINID),&dwBytes,NULL);
|
|
if(dwBytes < sizeof(MAINID) )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvWriteMainID(HANDLE hMBFile,LPMAINID lpMainID)
|
|
{
|
|
DWORD dwBytes;
|
|
if(SetFilePointer(hMBFile,0,0,FILE_BEGIN) != 0)
|
|
return FALSE;
|
|
WriteFile(hMBFile,lpMainID,sizeof(MAINID),&dwBytes,NULL);
|
|
if(dwBytes < sizeof(MAINID) )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL ConvGetMainIndex(HANDLE hWnd, HANDLE hMBFile, LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes;
|
|
int i;
|
|
|
|
if(SetFilePointer(hMBFile,ID_LENGTH,0,FILE_BEGIN) != ID_LENGTH)
|
|
return FALSE;
|
|
ReadFile(hMBFile,lpMainIndex,sizeof(MAININDEX)*NUMTABLES,&dwBytes,NULL);
|
|
if(dwBytes < sizeof(MAININDEX)*NUMTABLES ) {
|
|
ProcessError(ERR_READMAININDEX,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
else
|
|
return TRUE;
|
|
for(i=0; i<NUMTABLES; i++) {
|
|
dwBytes = lpMainIndex[i].dwTag+
|
|
lpMainIndex[i].dwOffset+
|
|
lpMainIndex[i].dwLength;
|
|
if(lpMainIndex[i].dwCheckSum != dwBytes) {
|
|
ProcessError(ERR_READMAININDEX,hWnd,ERR);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL ConvWriteMainIndex(HANDLE hMBFile, LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes;
|
|
if(SetFilePointer(hMBFile,ID_LENGTH,0,FILE_BEGIN) != ID_LENGTH)
|
|
return FALSE;
|
|
WriteFile(hMBFile,lpMainIndex,sizeof(MAININDEX)*NUMTABLES,&dwBytes,NULL);
|
|
if(dwBytes < sizeof(MAININDEX)*NUMTABLES )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL ConvReadDescript(HANDLE hMBFile,
|
|
LPDESCRIPTION lpDescript,
|
|
LPMAININDEX lpMainIndex)
|
|
//*** read description from .MB file ****
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset = lpMainIndex[TAG_DESCRIPTION-1].dwOffset;
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
ReadFile(hMBFile,lpDescript,sizeof(DESCRIPTION),&dwBytes,NULL);
|
|
if(dwBytes < sizeof(DESCRIPTION) )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvWriteDescript(HANDLE hMBFile,
|
|
LPDESCRIPTION lpDescript,
|
|
LPMAININDEX lpMainIndex)
|
|
//*** write description to .MB file ****
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset = lpMainIndex[TAG_DESCRIPTION-1].dwOffset;
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
WriteFile(hMBFile,lpDescript,sizeof(DESCRIPTION),&dwBytes,NULL);
|
|
if(dwBytes < sizeof(DESCRIPTION) )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL ConvReadRule(HANDLE hMBFile,
|
|
int nRuleNum,
|
|
LPRULE lpRule,
|
|
LPMAININDEX lpMainIndex)
|
|
//*** read create word rule from .MB file ****
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset = lpMainIndex[TAG_RULE-1].dwOffset;
|
|
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
ReadFile(hMBFile,lpRule,nRuleNum*sizeof(RULE),&dwBytes,NULL);
|
|
if(dwBytes < nRuleNum*sizeof(RULE) )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvWriteRule(HANDLE hMBFile,
|
|
int nRuleNum,
|
|
LPRULE lpRule,
|
|
LPMAININDEX lpMainIndex)
|
|
//*** write create word rule to .MB file ****
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset = lpMainIndex[TAG_RULE-1].dwOffset;
|
|
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
WriteFile(hMBFile,lpRule,nRuleNum*sizeof(RULE),&dwBytes,NULL);
|
|
if(dwBytes < nRuleNum*sizeof(RULE) )
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
BOOL ConvGetEncode(HANDLE hMBFile,
|
|
LPENCODEAREA lpEncode,
|
|
LPDWORD fdwNumSWords,
|
|
LPDWORD fdwNumEncodeArea,
|
|
LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset=lpMainIndex[TAG_ENCODE-1].dwOffset;
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
|
|
ReadFile(hMBFile,fdwNumSWords,4,&dwBytes,NULL);
|
|
ReadFile(hMBFile,fdwNumEncodeArea,4,&dwBytes,NULL);
|
|
ReadFile(hMBFile,lpEncode,
|
|
lpMainIndex[TAG_ENCODE-1].dwLength,&dwBytes,NULL);
|
|
if(dwBytes < lpMainIndex[TAG_ENCODE-1].dwLength)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
//BOOL ConvInitEncode(LPENCODEAREA lpEncode)
|
|
BOOL ConvInitEncode(HGLOBAL hEncode)
|
|
{
|
|
LPENCODEAREA lpEncode;
|
|
DWORD i;
|
|
|
|
lpEncode = (LPENCODEAREA) GlobalLock(hEncode);
|
|
|
|
#ifdef UNICODE
|
|
//CJK Symbols and Punctuation
|
|
lpEncode[0].StartEncode = 0x3000;
|
|
lpEncode[0].EndEncode = 0x303f;
|
|
//CJK Miscellaneous
|
|
lpEncode[1].StartEncode = 0x3190;
|
|
lpEncode[1].EndEncode = 0x319f;
|
|
//Enclosed CJK Letters
|
|
lpEncode[2].StartEncode = 0x3200;
|
|
lpEncode[2].EndEncode = 0x32ff;
|
|
//CJK Compatibility
|
|
lpEncode[3].StartEncode = 0x3300;
|
|
lpEncode[3].EndEncode = 0x33ff;
|
|
//CJK Unified Ideograph
|
|
lpEncode[4].StartEncode = 0x4e00;
|
|
lpEncode[4].EndEncode = 0x9fff;
|
|
//Private Use Area
|
|
lpEncode[5].StartEncode = 0xe000;
|
|
lpEncode[5].EndEncode = 0xf8ff;
|
|
//CJK Compatibility Ideograph
|
|
lpEncode[6].StartEncode = 0xf900;
|
|
lpEncode[6].EndEncode = 0xfaff;
|
|
//CJK Compatibility Font
|
|
lpEncode[7].StartEncode = 0xfe30;
|
|
lpEncode[7].EndEncode = 0xfe4f;
|
|
|
|
lpEncode[0].PreCount = 0;
|
|
for(i=1; i< NUMENCODEAREA; i++) {
|
|
lpEncode[i].PreCount = lpEncode[i-1].PreCount + lpEncode[i-1].EndEncode
|
|
- lpEncode[i-1].StartEncode + 1;
|
|
}
|
|
|
|
#else
|
|
for(i=0; i< NUMENCODEAREA/2; i++) {
|
|
lpEncode[2*i].PreCount = i*190;
|
|
lpEncode[2*i].StartEncode = (0x81+i)*256 + 0x40;
|
|
lpEncode[2*i].EndEncode = lpEncode[2*i].StartEncode + 0x3e;
|
|
lpEncode[2*i+1].PreCount = i*190 + 0x3f ;
|
|
lpEncode[2*i+1].StartEncode = (0x81+i)*256 + 0x80;
|
|
lpEncode[2*i+1].EndEncode = lpEncode[2*i+1].StartEncode + 0x7e;
|
|
}
|
|
#endif
|
|
|
|
GlobalUnlock(hEncode);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvWriteEncode(HANDLE hMBFile, LPENCODEAREA lpEncode,
|
|
LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes,i;
|
|
DWORD dwOffset=lpMainIndex[TAG_ENCODE-1].dwOffset;
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
i = NUM_OF_ENCODE;
|
|
WriteFile(hMBFile,&i,4,&dwBytes,NULL);
|
|
i = NUMENCODEAREA;
|
|
WriteFile(hMBFile,&i,4,&dwBytes,NULL);
|
|
|
|
WriteFile(hMBFile,lpEncode,
|
|
lpMainIndex[TAG_ENCODE-1].dwLength,&dwBytes,NULL);
|
|
if(dwBytes < lpMainIndex[TAG_ENCODE-1].dwLength)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL ConvGetCrtData(HANDLE hMBFile, LPCREATEWORD lpCreateWord,
|
|
LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset=lpMainIndex[TAG_CRTWORDCODE-1].dwOffset;
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
ReadFile(hMBFile,lpCreateWord,
|
|
lpMainIndex[TAG_CRTWORDCODE-1].dwLength,&dwBytes,NULL);
|
|
if(dwBytes < lpMainIndex[TAG_CRTWORDCODE-1].dwLength)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvWriteCrtData(HANDLE hMBFile, LPCREATEWORD lpCreateWord,
|
|
LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset=lpMainIndex[TAG_CRTWORDCODE-1].dwOffset;
|
|
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
WriteFile(hMBFile,lpCreateWord,
|
|
lpMainIndex[TAG_CRTWORDCODE-1].dwLength,&dwBytes,NULL);
|
|
if(dwBytes < lpMainIndex[TAG_CRTWORDCODE-1].dwLength)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvGetReConvIndex(HANDLE hMBFile, LPRECONVINDEX lpReConvIndex,
|
|
LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset= lpMainIndex[TAG_RECONVINDEX-1].dwOffset;
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
ReadFile(hMBFile,lpReConvIndex,
|
|
lpMainIndex[TAG_RECONVINDEX-1].dwLength,&dwBytes,NULL);
|
|
if(dwBytes < lpMainIndex[TAG_RECONVINDEX-1].dwLength)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvWriteReConvIdx(HANDLE hMBFile, LPRECONVINDEX lpReConvIndex,
|
|
LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset= lpMainIndex[TAG_RECONVINDEX-1].dwOffset;
|
|
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
WriteFile(hMBFile,lpReConvIndex,
|
|
lpMainIndex[TAG_RECONVINDEX-1].dwLength,&dwBytes,NULL);
|
|
if(dwBytes < lpMainIndex[TAG_RECONVINDEX-1].dwLength)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
BOOL ConvGetCodeIndex(HANDLE hMBFile,LPDWORD fdwMaxXLen,
|
|
LPSTR Code, LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes;
|
|
DWORD dwOffset= lpMainIndex[TAG_BASEDICINDEX-1].dwOffset;
|
|
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
ReadFile(hMBFile,fdwMaxXLen,sizeof(DWORD),&dwBytes,NULL);
|
|
ReadFile(hMBFile,Code,MAXNUMCODES,&dwBytes,NULL);
|
|
if(dwBytes < MAXNUMCODES)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvWriteCodeIndex (HANDLE hMBFile, LPDWORD fdwMaxXLen,
|
|
LPTSTR Code, LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes,i;
|
|
DWORD dwOffset= lpMainIndex[TAG_BASEDICINDEX-1].dwOffset;
|
|
BYTE CodeIndex[MAXNUMCODES];
|
|
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
WriteFile(hMBFile,fdwMaxXLen,sizeof(DWORD),&dwBytes,NULL);
|
|
for(i=0;i<MAXNUMCODES;i++)
|
|
CodeIndex[i] = 0;
|
|
for(i=0;i<(DWORD)lstrlen(Code);i++)
|
|
CodeIndex[Code[i]] =(BYTE)(i+1);
|
|
WriteFile(hMBFile,CodeIndex,MAXNUMCODES,&dwBytes,NULL);
|
|
if(dwBytes < MAXNUMCODES)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvGetDicIndex(HANDLE hMBFile, LPDICINDEX lpDicIndex ,
|
|
DWORD dwNumCodes, LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes,ReadBytes;
|
|
DWORD dwOffset= lpMainIndex[TAG_BASEDICINDEX-1].dwOffset+
|
|
MAXNUMCODES+CODEMAPOFFSET;
|
|
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
ReadBytes = sizeof(DWORD)*(dwNumCodes+1)*dwNumCodes;
|
|
ReadFile(hMBFile,lpDicIndex,ReadBytes,&dwBytes,NULL);
|
|
if(dwBytes < ReadBytes)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvWriteDicIndex(HANDLE hMBFile, LPDICINDEX lpDicIndex ,
|
|
DWORD dwNumCodes, LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes,WriteBytes;
|
|
DWORD dwOffset= lpMainIndex[TAG_BASEDICINDEX-1].dwOffset+
|
|
MAXNUMCODES+CODEMAPOFFSET;
|
|
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
WriteBytes = sizeof(DWORD)*(dwNumCodes+1)*dwNumCodes;
|
|
WriteFile(hMBFile,lpDicIndex,WriteBytes,&dwBytes,NULL);
|
|
if(dwBytes < WriteBytes)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL ConvGetNumXYWords(HANDLE hMBFile, LPDWORD lpNumXYWords,
|
|
DWORD dwNumCodes, LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes,ReadBytes;
|
|
DWORD dwOffset;
|
|
|
|
ReadBytes = sizeof(DWORD)*(dwNumCodes+1)*dwNumCodes;
|
|
dwOffset=lpMainIndex[TAG_BASEDICINDEX-1].dwOffset+
|
|
MAXNUMCODES+CODEMAPOFFSET+ReadBytes;
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
ReadFile(hMBFile,lpNumXYWords,ReadBytes,&dwBytes,NULL);
|
|
if(dwBytes < ReadBytes)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL ConvWriteNumXYWords(HANDLE hMBFile, LPDWORD lpNumXYWords,
|
|
DWORD dwNumCodes, LPMAININDEX lpMainIndex)
|
|
{
|
|
DWORD dwBytes,WriteBytes;
|
|
DWORD dwOffset;
|
|
|
|
WriteBytes = sizeof(DWORD)*(dwNumCodes+1)*dwNumCodes;
|
|
dwOffset=lpMainIndex[TAG_BASEDICINDEX-1].dwOffset+
|
|
MAXNUMCODES+CODEMAPOFFSET+WriteBytes;
|
|
if(SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN) != dwOffset)
|
|
return FALSE;
|
|
|
|
SetFilePointer(hMBFile,lpMainIndex[TAG_BASEDICINDEX-1].dwOffset+
|
|
WriteBytes+MAXNUMCODES+CODEMAPOFFSET,0,FILE_BEGIN);
|
|
WriteFile(hMBFile,lpNumXYWords,WriteBytes,&dwBytes,NULL);
|
|
if(dwBytes < WriteBytes)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
int ConvReconvIndex(HANDLE hWnd,
|
|
LPTSTR szDBCS,
|
|
LPCREATEWORD lpCreateWords,
|
|
WORDINDEX WordIndex,
|
|
LPDESCRIPTION lpDescript,
|
|
LPRECONVINDEX lpReConvIndex)
|
|
{
|
|
int no;
|
|
TCHAR tmpStr[256];
|
|
|
|
if(WordIndex.wDBCSLen != 1)
|
|
return FALSE;
|
|
no = EncodeToNo(szDBCS);
|
|
if(no < 0 || no >= NUM_OF_ENCODE)
|
|
return FALSE;
|
|
if(lpDescript->wNumRules != 0 && lpDescript->byMaxElement == 1)
|
|
{
|
|
lstrncpy(tmpStr,
|
|
lpDescript->wMaxCodes,
|
|
lpCreateWords + no*(DWORD)lpDescript->wMaxCodes);
|
|
if(lstrlen(tmpStr) == 0 ||
|
|
#ifdef UNICODE
|
|
(!(WriteCrtFlag[(no/8)] & (1 << (7 - (no%8))) ) && _wcsicmp(WordIndex.szCode,tmpStr) < 0) )
|
|
#else
|
|
(!(WriteCrtFlag[(no/8)] & (1 << (7 - (no%8))) ) && _strcmpi(WordIndex.szCode,tmpStr) < 0) )
|
|
#endif UNICODE
|
|
lstrncpy(lpCreateWords + no*(DWORD)lpDescript->wMaxCodes,
|
|
lpDescript->wMaxCodes,
|
|
WordIndex.szCode);
|
|
}
|
|
else
|
|
{
|
|
lstrncpy(tmpStr,
|
|
lpDescript->wMaxCodes,
|
|
lpReConvIndex + no*(DWORD)lpDescript->wMaxCodes);
|
|
tmpStr[lpDescript->wMaxCodes] = 0;
|
|
#ifdef UNICODE
|
|
if(lstrlen(tmpStr) == 0 || _wcsicmp(WordIndex.szCode,tmpStr) < 0)
|
|
#else
|
|
if(lstrlen(tmpStr) == 0 || _strcmpi(WordIndex.szCode,tmpStr) < 0)
|
|
#endif
|
|
lstrncpy(lpReConvIndex + no*(DWORD)lpDescript->wMaxCodes,
|
|
lpDescript->wMaxCodes,
|
|
WordIndex.szCode);
|
|
}
|
|
return TRUE;
|
|
}
|