windows-xp/Source/XPSP1/NT/windows/feime/chs/ntgen/conv.c

/*************************************************
 *  conv.c                                       *
 *                                               *
 *  Copyright (C) 1995-1999 Microsoft Inc.       *
 *                                               *
 *************************************************/

#include "conv.h"

DWORD       dwBaseWordNum;
HGLOBAL     hCreateWord;
HGLOBAL     hWordIndex;
HGLOBAL     hEncode;
#ifdef UNICODE
TCHAR Title[] = {0x6D4F, 0x89C8, 0x0000};
TCHAR szVer[] = {0x8F93, 0x5165, 0x6CD5, 0x0020, 0x7248, 0x672C, 0x0000};
#else
BYTE Title[] = "����";
BYTE szVer[] = "���뷨 �汾";
#endif
		 
/*****************************************************************************

  FUNCTION: ConvConv(HANDLE hWnd,LPCSTR lpSrcFileName, LPCSTR lpszMBFileName)

  PURPOSE:  Processes MB conversion .

  PARAMETERS:
    hWnd - window handle of the parent window.
	lpSrcFileName - pointer to source text file name.
	lpszMBFileName - pointer to destinate .mb  file name.
  
  RETURN VALUE:
    TRUE - conversion completed
    FALSE - conversion not completed

  HISTORY:
    
 ****************************************************************************/

BOOL ConvConv(HANDLE hWnd,LPCTSTR lpSrcFileName, LPCTSTR lpszMBFileName)
{
  int    nTemp;
  DWORD  dwDBCS;
  DWORD  dwRuleOffset, dwRuleLen;
  DWORD  dwDesOffset, dwDesLen;
  DWORD  i;
  int    nPages;
  TCHAR  szDBCS[512];
  //dwRuleOffset: Rule segment's offset in source file


  MAINID        MainID;
  LPMAININDEX   lpMainIndex;
  LPCREATEWORD  lpCreateWords;
  DESCRIPTION   Descript;
  LPWORDINDEX   lpWordIndex;
  LPRULE        lpRule;

  HANDLE        hReConvIndex, hMainIndex;
  LPRECONVINDEX lpReConvIndex;
  LPENCODEAREA  lpEncode; 
                              
  DispInfo(hWnd,IDS_CONVERTINFO);
  nTemp = (int)ConvGetDescript(hWnd,lpSrcFileName,&dwDesOffset,
      &dwDesLen,&Descript,FALSE);
  if(nTemp == -ERR_FILENOTOPEN || nTemp < -4 ) 
      return FALSE;   
  hMainIndex = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,sizeof(MAININDEX)*NUMTABLES);
  if(!(lpMainIndex = GlobalLock(hMainIndex) ) ) {
      ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
      return FALSE;
  }
  ConvInit(&Descript,&MainID,lpMainIndex);


  nPages = 1;
  dwBaseWordNum = 0;

  nTemp = sizeof(WORDINDEX)*GMEM_PAGESIZE;
  hWordIndex=GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT, nTemp);
  hCreateWord = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,
	   (DWORD)Descript.wMaxCodes*NUM_OF_ENCODE*sizeof(TCHAR));
  if(!hMainIndex||!hCreateWord || !hWordIndex || !hRule) {
      ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
	  goto err;
  }

  if(!(lpCreateWords = GlobalLock(hCreateWord) ) 
     ||!(lpWordIndex = (LPWORDINDEX) GlobalLock(hWordIndex))
     ||!(lpRule = GlobalLock(hRule)) )  {
      ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
	  goto err;
  }


  if(ConvGetRule(hWnd,lpSrcFileName,&dwRuleOffset,&dwRuleLen,
     lpRule,&Descript)<=0)
      goto err;
 
  hSRCFile = Create_File(hWnd,lpSrcFileName,GENERIC_READ,OPEN_EXISTING);
  if (hSRCFile == (HANDLE)-1)
	  return FALSE;		 
  hMBFile = Create_File(hWnd,lpszMBFileName,GENERIC_READ|GENERIC_WRITE,
           CREATE_ALWAYS);
  if (hMBFile == (HANDLE)-1) {
      CloseHandle(hSRCFile);
      return FALSE;
  }

  if(!ConvWriteMainID(hMBFile,&MainID)) {
      ProcessError(ERR_WRITEID,hWnd,ERR);
	  goto err;
  }
  if(!ConvWriteMainIndex(hMBFile,lpMainIndex)) {
      ProcessError(ERR_WRITEMAININDEX,hWnd,ERR);
	  goto err;
  }
  if(!ConvWriteDescript(hMBFile, &Descript, lpMainIndex)) {
      ProcessError(ERR_WRITEDESCRIPT,hWnd,ERR);
	  goto err;
  }
  if(lpMainIndex[TAG_RULE-1].dwLength != 0)
      if(!ConvWriteRule( hMBFile,Descript.wNumRules,lpRule, lpMainIndex)) {
          ProcessError(ERR_WRITERULE,hWnd,ERR);
	      goto err;
      }
  hReConvIndex = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,
	   (DWORD)Descript.wMaxCodes*NUM_OF_ENCODE*sizeof(TCHAR));

  if(!hReConvIndex) {
      ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);		
	  goto err;
  }

  if(!(lpReConvIndex = GlobalLock(hReConvIndex)) 
     || !(lpEncode = GlobalLock(hEncode)) )  {
      ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
	  goto err;
  }

  DispInfo(hWnd,IDS_READTEXTINFO);

  if(!ReadSRCFile(hWnd,&nPages,hSRCFile,lpCreateWords,
                  lpWordIndex,&dwDBCS,&Descript,lpReConvIndex))  {
	  goto err;
  }

  DispInfo(hWnd,IDS_WRCRTINFO);
//****** fill code mapping *****
  ConvWriteEncode(hMBFile,lpEncode,lpMainIndex);

  if(Descript.wNumRules != 0)	{
      LoadString(NULL,IDS_ISCHECKCRTWORD,szDBCS, sizeof(szDBCS)/sizeof(TCHAR));
      if(ErrMessage(hWnd, szDBCS))
	  {     
         if(!CheckCrtData(hWnd,lpCreateWords,lpEncode,Descript.wMaxCodes) ) {
             ProcessError(ERR_GB2312NOTENTIRE,hWnd,ERR);
		     goto err;
		 }
	  }
  }  //******* Debug *******

  if(lpMainIndex[TAG_CRTWORDCODE-1].dwLength != 0)
      ConvWriteCrtData(hMBFile,lpCreateWords,lpMainIndex);
  if(lpMainIndex[TAG_RECONVINDEX-1].dwLength != 0)
      ConvWriteReConvIdx(hMBFile,lpReConvIndex,lpMainIndex);
  GlobalUnlock(hEncode);

//****95.10.12 auto add code for phrases not exist code
  SetCursor (LoadCursor (NULL, IDC_WAIT));   
  if( Descript.wNumRules != 0)
  { 
     for(i=0; i<dwBaseWordNum; i++) 
     {
        if(lpWordIndex[i].wDBCSLen > 1
          && (lstrlen(lpWordIndex[i].szCode) == 0)
           ) {
           SetFilePointer(hSRCFile,lpWordIndex[i].dwOffset,0,FILE_BEGIN);
		   nTemp = 2*(DWORD)lpWordIndex[i].wDBCSLen;
		   ReadFile(hSRCFile,szDBCS,nTemp,&dwDBCS,NULL);
		   szDBCS[nTemp] = 0;
           ConvBatCreate(hWnd,Descript,lpRule,
	                 lpCreateWords,szDBCS,
                     lpWordIndex[i].szCode);
		   if(lpWordIndex[i].szCode[0] == TEXT(',') && lpWordIndex[i].szCode[1] == TEXT('z'))
		        continue;
		   if(lstrlen(lpWordIndex[i].szCode) == 0)
		   {
				goto err;
		   }

	    }
     }
  }

  SetCursor (LoadCursor (NULL, IDC_ARROW));   

  DispInfo(hWnd,IDS_SORT);

  ConvSort(hWnd,lpWordIndex,dwBaseWordNum);
  SetFilePointer(hMBFile,lpMainIndex[TAG_BASEDICINDEX-1].dwOffset,0,FILE_BEGIN);

//***** fill index area with null  *****
  nTemp = Descript.wNumCodes;
  nTemp = sizeof(DWORD)*(nTemp+1)*nTemp;
  WriteFile(hMBFile,NULL,nTemp,&nTemp,NULL);

//***** fill index area and length area *****
  ConvCalc(hWnd,hMBFile,lpWordIndex,lpMainIndex,&Descript);

//***** fill dictionary area  *****
  WriteMBFile(hWnd,hSRCFile,hMBFile,lpWordIndex,lpMainIndex,&Descript);
  MainID.dwNumWords = dwBaseWordNum;

//***** fill changed MainID  *****
  ConvWriteMainID(hMBFile,&MainID);

  GlobalUnlock(hRule);
  if(hCreateWord)
      GlobalFree(hCreateWord);
  GlobalUnlock(hReConvIndex);
  GlobalFree(hReConvIndex);

  GlobalUnlock(hWordIndex);
  GlobalFree(hWordIndex);
  CloseHandle(hMBFile);
  CloseHandle(hSRCFile);

  ProcessError(ERR_CONVEND, hWnd, INFO);
  return TRUE;

err:
  if(hSRCFile)
      CloseHandle(hSRCFile);
  if(hMBFile)
      CloseHandle(hMBFile);
  if(hMainIndex)
      GlobalFree(hMainIndex);
  if(hWordIndex)
      GlobalFree(hWordIndex);
  if(hCreateWord)
      GlobalFree(hCreateWord);
  if(hReConvIndex)
      GlobalFree(hReConvIndex);
  if(hRule)
      GlobalUnlock(hRule);
  return FALSE;

}

/*****************************************************************************

  FUNCTION: ConvReadFile(HANDLE hWnd,LPCSTR lpSrcFileName, LPCSTR lpDestFile)

  PURPOSE:  Processes source text file sorting.

  PARAMETERS:
    hWnd - window handle of the parent window.
	lpSrcFileName - pointer to source text file name.
	lpDestFile - pointer to destinate sorted text file name.
  
  RETURN VALUE:
    TRUE - sorting completed
    FALSE - sorting not completed

  HISTORY:
    
 ****************************************************************************/

BOOL ConvReadFile(HANDLE hWnd,
                  LPCTSTR lpSrcFileName,
				  LPCTSTR lpDestFile)
{
  DWORD  i,j;
  DWORD  dwRuleOffset, dwRuleLen;
  DWORD  dwDesOffset,  dwDesLen;
  DWORD  dwReadBytes;
  DWORD  dwFstOffset=0;
  DWORD  dwOffset=0;
  TCHAR  szStr[512],szDBCS[512];
  TCHAR  Buffer[MAXREADBUFFER];
  BOOL   bReadText = FALSE, bSameFile=FALSE;
  int    nRet;
  int    nPages;
  BOOL   IsGenCmb = FALSE;  

  HANDLE        hRule0;
  LPCREATEWORD  lpCreateWords;
  LPWORDINDEX   lpWordIndex;
  LPRULE        lpRule;
  DESCRIPTION   Descript;
  HANDLE 		hDlgItem;

  nRet = (int)ConvGetDescript(hWnd,lpSrcFileName,&dwDesOffset,
        &dwDesLen,&Descript,FALSE);
  if(nRet == -ERR_FILENOTOPEN)
      return FALSE; 
  if((-nRet)&7)
      bReadText = TRUE;
  if(Descript.wMaxCodes <= 0)
      Descript.wMaxCodes = MAXCODELEN;
  nPages = 1;
  dwBaseWordNum = 0;
  dwReadBytes = sizeof(WORDINDEX)*GMEM_PAGESIZE;
  hCreateWord = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,
	  MAXCODELEN*NUM_OF_ENCODE*sizeof(TCHAR));
  hWordIndex=GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT, dwReadBytes);
  if(!hWordIndex ) {
      ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
	  goto err;
  }
  if(!hCreateWord ) {
        ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
		goto err;
  }

  if(!(lpCreateWords = GlobalLock(hCreateWord) ) 
     ||!(lpWordIndex = (LPWORDINDEX) GlobalLock(hWordIndex))
     )  {
        ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
		goto err;
  }

  hRule0= GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,
          sizeof(RULE)*MAXCODELEN);
  if(!(lpRule = GlobalLock(hRule0)) )  {
        ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
		goto err;
  }

  if(ConvGetRule(hWnd,lpSrcFileName,&dwRuleOffset,&dwRuleLen,
               lpRule,&Descript) == -ERR_FILENOTOPEN)
       goto err;
  hSRCFile = Create_File(hWnd,lpSrcFileName,GENERIC_READ,OPEN_EXISTING);
  if (hSRCFile == (HANDLE)-1)
       goto err; 
  
  if(lstrcmpi(lpDestFile,lpSrcFileName)==0) {
	   bSameFile = TRUE;
       LoadString(NULL,IDS_OVERWRITE,szStr, sizeof(szStr)/sizeof(TCHAR));
       wsprintf(szDBCS,TEXT("\'%s\'\n%s"),lpSrcFileName,szStr); 
       if(!ErrMessage(hWnd, szDBCS))
	   {
           CloseHandle(hSRCFile);
           goto err; 
	   }
#ifdef UNICODE
       if(!_waccess(TEXT(TempFile),0))
#else
	   if(!_access(TEXT(TempFile),0))
#endif
           DeleteFile(TEXT(TempFile));
       hMBFile = Create_File(hWnd,TEXT(TempFile),GENERIC_WRITE|GENERIC_READ,CREATE_ALWAYS);
  }
  else 
       hMBFile = Create_File(hWnd,lpDestFile,GENERIC_WRITE|GENERIC_READ,CREATE_ALWAYS);
  if(hMBFile==(HANDLE)-1) {
       CloseHandle(hSRCFile);
       goto err; 
  }
  CloseHandle(hMBFile);

  DispInfo(hWnd,IDS_READTEXTINFO);
  SetFilePointer(hSRCFile,0,0,FILE_BEGIN);
  szStr[0] = 0;
  j = 0;

  SetCursor (LoadCursor (NULL, IDC_WAIT));


	SetDlgItemText (hWnd,TM_TOTALINFO,TEXT(""));
    LoadString(NULL,IDS_SORTWORDS,szStr,sizeof(szStr)/sizeof(TCHAR));
	SetDlgItemText (hWnd,TM_TOTAL,szStr);
	SetDlgItemInt (hWnd,TM_TOTALNUM,dwBaseWordNum,FALSE);
	hDlgItem=GetDlgItem(hWnd,TM_CONVNUM);
	InvalidateRect (hWnd,NULL,FALSE);


  while(ReadFile(hSRCFile,Buffer,MAXREADBUFFER,&dwReadBytes,NULL))
  {	
	 dwReadBytes = dwReadBytes/sizeof(TCHAR);
     for(i=0;i<(int)dwReadBytes;i++) {
      	if(Buffer[i] == 0x0d || Buffer[i] == 0xfeff) 
      	   continue;
      	if(Buffer[i] == TEXT('\n')) 
		{
		   szStr[j]=0;
		   j=0;
    	   if(lstrcmpi(szStr,TEXT(TextSeg))==0)  {
	           bReadText = TRUE;
//		       lstrcpy(szStr,"");
	           continue;
     	   }
    	   if(lstrcmpi(szStr,TEXT(RuleSeg))==0
    	      || lstrcmpi(szStr,TEXT(DescriptSeg))==0)  {
	           bReadText = FALSE;
//		  	   lstrcpy(szStr,"");
	           continue;
     	   }
     	  
		   if(bReadText) {
   	           trim(szStr);
	           if(lstrlen(szStr) != 0) {
                   nRet = SimpleSplit(hWnd,&nPages,szStr,lpCreateWords,lpWordIndex,Descript.wMaxCodes);	
                   if(nRet == 1)
                   {
                       lpWordIndex[dwBaseWordNum-1].dwOffset = dwOffset;
                       searchPos(lpWordIndex,dwBaseWordNum);  
		               

	                   if(dwBaseWordNum%100 == 0)
					   {
	                       SetDlgItemInt (hWnd,TM_TOTALNUM,dwBaseWordNum,FALSE);
			               InvalidateRect(hDlgItem,NULL,FALSE);
					   }

                   }
		  	   }
		   }
		   else
		       lstrcpy(szStr,TEXT(""));
		   continue;
		}
		else {
		   if(j == 0)
		       dwOffset = dwFstOffset + i*sizeof(TCHAR);
		   szStr[j]=Buffer[i];
		   j++; 
		}
	 } 
	 if(dwReadBytes*sizeof(TCHAR) < MAXREADBUFFER) 
	      break;
	 dwFstOffset += MAXREADBUFFER;
   };


  SetDlgItemInt (hWnd,TM_TOTALNUM,dwBaseWordNum,FALSE);
  InvalidateRect(hDlgItem,NULL,FALSE);



  if(bSameFile) {
      if(dwDesLen != 0)
          ConvSaveDescript(TEXT(TempFile),&Descript, 0,0);
      if(dwRuleLen != 0)
          ConvSaveRule(hWnd,TEXT(TempFile), dwDesLen, 0, 
              lpRule, Descript.wNumRules);
      hMBFile= Create_File(hWnd,TEXT(TempFile),GENERIC_READ|GENERIC_WRITE,OPEN_EXISTING);
  }
  else {
      if(dwDesLen != 0)
          ConvSaveDescript(lpDestFile,&Descript, 0,0);
      if(dwRuleLen != 0)
          ConvSaveRule(hWnd,lpDestFile, dwDesLen, 0, 
              lpRule, Descript.wNumRules);
      hMBFile= Create_File(hWnd,lpDestFile,GENERIC_READ|GENERIC_WRITE,OPEN_EXISTING);
  }

  SetCursor (LoadCursor (NULL, IDC_ARROW));
  if (hMBFile == (HANDLE)-1) {
      CloseHandle(hSRCFile);
      goto err; 
  }
  SetCursor (LoadCursor (NULL, IDC_WAIT));

  DispInfo(hWnd,IDS_WRITETEXTINFO);
  {
#ifdef UNICODE
      TCHAR cmbStr[] = {0x662F, 0x5426, 0x751F, 0x6210, 0x91CD, 0x7801, 0x8868, 0x0028, 0x0059, 0x002F, 0x004E, 0x0029, 0x003F, 0x0000};
#else
      BYTE cmbStr[] = "�Ƿ�����������(Y/N)?";
#endif //UNICODE
	  TCHAR cmbExt[] = TEXT(".CMB");
	  LPTSTR lpString;
	  TCHAR cmbFileName[MAX_PATH];

      IsGenCmb = ErrMessage(hWnd, cmbStr);
	  if(IsGenCmb)
      {
          lstrcpy(cmbFileName, lpSrcFileName);
		  if( (lpString = _tcsrchr(cmbFileName, TEXT('.'))) != NULL)
		      *lpString = 0;
		  lstrcat(cmbFileName, cmbExt);
          hCmbFile= Create_File(hWnd, cmbFileName, GENERIC_READ|GENERIC_WRITE, CREATE_ALWAYS);
		  if(hCmbFile == (HANDLE)-1)
		  {
               CloseHandle(hSRCFile);
               CloseHandle(hMBFile);
               goto err; 
		  }

	  }
  }

  SetCursor (LoadCursor (NULL, IDC_ARROW));

  WriteSortFile(hWnd,hSRCFile,hMBFile,lpWordIndex,lpCreateWords);

  GlobalUnlock(hCreateWord);
  GlobalFree(hCreateWord);
  GlobalFree(hWordIndex);

  SetCursor (LoadCursor (NULL, IDC_ARROW));

  if(hRule0)
      GlobalFree(hRule0);
  CloseHandle(hSRCFile);
  CloseHandle(hMBFile);
  if(hCmbFile > 0)
      CloseHandle(hCmbFile);
  if(bSameFile) {
      DeleteFile(lpSrcFileName);
      nRet = MoveFile(TEXT(TempFile),lpSrcFileName);
  }

  LoadString(NULL,IDS_SORTEND,szStr,sizeof(szStr));
#ifdef UNICODE
{
  TCHAR UniTmp[]={0x8BCD, 0x8BED, 0x6392, 0x5E8F, 0x0000};
  MessageBox(hWnd,szStr,UniTmp,MB_OK);
}
#else
  MessageBox(hWnd,szStr,"��������",MB_OK);
#endif
  return TRUE;

err:
  if(!_taccess(TEXT(TempFile),0))
      DeleteFile(TEXT(TempFile));
  if(hWordIndex)
      GlobalFree(hWordIndex);
  if(hCreateWord)
      GlobalFree(hCreateWord);
  if(hRule0)
      GlobalFree(hRule0);
  return FALSE;

}

/*****************************************************************************

  FUNCTION: ConvReConv(HANDLE hWnd,LPCSTR lpSrcFileName, LPCSTR lpszMBFileName)

  PURPOSE:  Processes MB reconversion .

  PARAMETERS:
    hWnd - window handle of the parent window.
	lpSrcFileName - pointer to source .mb file name.
	lpszMBFileName - pointer to destinate text  file name.
  
  RETURN VALUE:
    TRUE - reconversion completed
    FALSE - reconversion not completed

  HISTORY:
    05-21-95 Yehfew Tie  modifyed.
 ****************************************************************************/
BOOL ConvReConv(HANDLE hWnd,LPCTSTR lpSrcFileName,LPCTSTR lpMBFileName)
{
  DWORD         dwDesOffset,dwDesLen;
  HANDLE  		hRule0;

  MAINID        MainID;
  LPRULE       lpRule;
  DESCRIPTION   Descript;
  HANDLE		hReConvIndex;
  LPCREATEWORD  lpCreateWords, lpReConvIndex;
  MAININDEX     MainIndex[NUMTABLES];

  hMBFile = Create_File(hWnd,lpMBFileName,GENERIC_READ,OPEN_EXISTING);
  if (hMBFile == (HANDLE)-1) 
      return FALSE;
  DispInfo(hWnd,IDS_RECONVINFO);

  ConvGetMainID(hMBFile,&MainID);
  if(!ConvGetMainIndex(hWnd,hMBFile,MainIndex)) {
	  CloseHandle(hMBFile);
	  return FALSE;
  }

  hSRCFile = Create_File(hWnd,lpSrcFileName,
             GENERIC_READ|GENERIC_WRITE,CREATE_ALWAYS);
  if (hSRCFile == (HANDLE)-1)
	  return FALSE;		 
  CloseHandle(hSRCFile);
  ConvReadDescript(hMBFile,&Descript, MainIndex);
  ConvSaveDescript(lpSrcFileName,&Descript, 0,0);
  ConvGetDescript(hWnd,lpSrcFileName,&dwDesOffset,
           &dwDesLen,&Descript,FALSE);
  hCreateWord = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,
	                 (DWORD)Descript.wMaxCodes*NUM_OF_ENCODE*sizeof(TCHAR));
  if(!hCreateWord ) {
      ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
	  return FALSE;
  }

  if(!(lpCreateWords = GlobalLock(hCreateWord)) ) {
      ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
	  return FALSE;
  }
  hReConvIndex = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,
                       (DWORD)Descript.wMaxCodes*NUM_OF_ENCODE*sizeof(TCHAR));
  if(!hReConvIndex ) {
      ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
	  CloseHandle(hMBFile);
	  GlobalFree(hCreateWord);
	  return FALSE;
  }

  if( !(lpReConvIndex = GlobalLock(hReConvIndex)) ) {
      ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
	  GlobalFree(hReConvIndex);
	  CloseHandle(hMBFile);
	  GlobalFree(hCreateWord);
	  return FALSE;
  }

  if(Descript.wNumRules != 0) {
      hRule0 = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,
                    sizeof(RULE)*Descript.wNumRules);
      if(!hRule0) {
          ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
    	  GlobalFree(hReConvIndex);
    	  CloseHandle(hMBFile);
    	  GlobalFree(hCreateWord);
    	  return FALSE;
      }
    
      if(!(lpRule = GlobalLock(hRule0)) )  {
          ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
    	  CloseHandle(hMBFile);
    	  GlobalFree(hCreateWord);
    	  GlobalFree(hRule0);
       	  GlobalFree(hReConvIndex);
    	  return FALSE;
      }
    
      ConvReadRule(hMBFile,Descript.wNumRules ,lpRule, MainIndex);
      ConvSaveRule(hWnd,lpSrcFileName, dwDesLen, 0, lpRule, Descript.wNumRules);
  }
  ConvGetCrtData(hMBFile, lpCreateWords, MainIndex);
  ConvGetReConvIndex(hMBFile, lpReConvIndex,MainIndex);

  hSRCFile = Create_File(hWnd,lpSrcFileName,
      GENERIC_READ|GENERIC_WRITE,OPEN_EXISTING);
  if (hSRCFile == (HANDLE)-1)
	  return FALSE;		 
  ConvWriteBaseWord(hWnd,hSRCFile,hMBFile,MainID,
      MainIndex[TAG_BASEDIC-1].dwOffset, lpCreateWords, lpReConvIndex,Descript.wMaxCodes);

  // DispInfo(hWnd,IDS_RECONVEND); bug#57932
  CloseHandle(hSRCFile);
  CloseHandle(hMBFile);
  GlobalFree(hCreateWord);
  GlobalFree(hReConvIndex);
  if(Descript.wNumRules != 0) 
      GlobalFree(hRule0);
  ProcessError(ERR_RECONVEND, hWnd, INFO);
  return TRUE;
}  

void ConvInit(LPDESCRIPTION lpDescript,
              LPMAINID lpMainID,
              LPMAININDEX lpMainIndex)
{ 

  DWORD dwTotal;
  int i;

//*** initializes struct MainID ***
  lstrcpy(lpMainID->szVersion,TEXT("95.01"));
  lpMainID->dwLanguageID = WIN95_PRC;
#ifdef UNICODE
  lpMainID->dwEncodeID = UNICODE_IME;
#else
  lpMainID->dwEncodeID = GBK_IME;
#endif
  lpMainID->dwNumTables = NUMTABLES;
  lpMainID->dwNumWords = dwBaseWordNum;
  lpMainID->dwFileFlag = 0;
  if(lpDescript->byMaxElement > 1 )
      lpMainID->dwFileFlag |= FFLG_MULTIELEMENT;
  if(lpDescript->wNumRules > 0)
      lpMainID->dwFileFlag |= FFLG_RULE;

//*** set tables tag ****
  lpMainIndex[TAG_DESCRIPTION-1].dwTag = TAG_DESCRIPTION;
  lpMainIndex[TAG_RULE-1].dwTag = TAG_RULE;
  lpMainIndex[TAG_ENCODE-1].dwTag = TAG_ENCODE;
  lpMainIndex[TAG_CRTWORDCODE-1].dwTag = TAG_CRTWORDCODE;
  lpMainIndex[TAG_RECONVINDEX-1].dwTag = TAG_RECONVINDEX;
  lpMainIndex[TAG_BASEDICINDEX-1].dwTag = TAG_BASEDICINDEX;
  lpMainIndex[TAG_BASEDIC-1].dwTag = TAG_BASEDIC;
  
//*** set tables length ****  
  lpMainIndex[TAG_DESCRIPTION-1].dwLength = sizeof(DESCRIPTION);
  lpMainIndex[TAG_RULE-1].dwLength= sizeof(RULE)* lpDescript->wNumRules;
  lpMainIndex[TAG_ENCODE-1].dwLength = 
         2*sizeof(DWORD) + NUMENCODEAREA*sizeof(ENCODEAREA);
  lpMainIndex[TAG_CRTWORDCODE-1].dwLength =
         (DWORD)NUM_OF_ENCODE*(DWORD)lpDescript->wMaxCodes*sizeof(TCHAR);
  lpMainIndex[TAG_RECONVINDEX-1].dwLength = 
         (DWORD)lpDescript->wMaxCodes*NUM_OF_ENCODE*sizeof(TCHAR);

  switch(lpMainID->dwFileFlag) {
      case FFLG_RULE|FFLG_SINGLEELEMENT:
               lpMainIndex[TAG_RECONVINDEX-1].dwLength = 0;
	       break;

	  case FFLG_RULE|FFLG_MULTIELEMENT:
	       break;

	  case FFLG_NORULE|FFLG_SINGLEELEMENT:
	  case FFLG_NORULE|FFLG_MULTIELEMENT:
               lpMainIndex[TAG_RULE-1].dwLength = 0;
               lpMainIndex[TAG_CRTWORDCODE-1].dwLength = 0;
		   break;

	  default:
	   	   break;
  }

  lpMainIndex[TAG_BASEDICINDEX-1].dwLength =( (DWORD)lpDescript->wNumCodes+1)*
           (DWORD)lpDescript->wNumCodes*sizeof(DWORD)*2+MAXNUMCODES+CODEMAPOFFSET;
  lpMainIndex[TAG_BASEDIC-1].dwLength = 0;

//***** set tables offset *****
  dwTotal = sizeof(MAINID) + sizeof(MAININDEX)*NUMTABLES;
  lpMainIndex[TAG_DESCRIPTION-1].dwOffset = dwTotal;

  dwTotal +=  lpMainIndex[TAG_DESCRIPTION-1].dwLength;
  lpMainIndex[TAG_RULE-1].dwOffset = dwTotal;

  dwTotal += lpMainIndex[TAG_RULE-1].dwLength;
  lpMainIndex[TAG_ENCODE-1].dwOffset = dwTotal;

  dwTotal += lpMainIndex[TAG_ENCODE-1].dwLength;
  lpMainIndex[TAG_CRTWORDCODE-1].dwOffset = dwTotal;

  dwTotal += lpMainIndex[TAG_CRTWORDCODE-1].dwLength;
  lpMainIndex[TAG_RECONVINDEX-1].dwOffset =  dwTotal;	

  dwTotal += lpMainIndex[TAG_RECONVINDEX-1].dwLength;
  lpMainIndex[TAG_BASEDICINDEX-1].dwOffset = dwTotal;

  dwTotal += lpMainIndex[TAG_BASEDICINDEX-1].dwLength;
  lpMainIndex[TAG_BASEDIC-1].dwOffset = dwTotal;

  for(i=0; i<NUMTABLES; i++)
      lpMainIndex[i].dwCheckSum = lpMainIndex[i].dwTag +
	                              lpMainIndex[i].dwLength +
								  lpMainIndex[i].dwOffset;
}	   

BOOL ReadSRCFile(HANDLE hWnd,
				 LPINT nPages,
                 HANDLE hFile,
                 LPCREATEWORD lpCreateWords,
                 LPWORDINDEX lpWordIndex,
                 LPINT dwWord, LPDESCRIPTION lpDescript,
                 LPRECONVINDEX lpReConvIndex)
{
   TCHAR szStr[256];
   TCHAR Buffer[MAXREADBUFFER];
   BOOL  bReadText=FALSE;
   register int i,j;
   int   nRet;
   DWORD dwReadBytes;
   DWORD dwFstOffset=0;
   DWORD dwOffset=0;

   SetCursor (LoadCursor (NULL, IDC_WAIT));
   SetFilePointer(hFile,0,0,FILE_BEGIN);
   szStr[0] = 0;
   j = 0;
   dwLineNo = 0;
   dwOffset = 0;
 
   memset(WriteCrtFlag, 0, (NUM_OF_ENCODE+7)/8);



   while(ReadFile(hFile,Buffer,MAXREADBUFFER,&dwReadBytes,NULL))
   {
	 dwReadBytes = dwReadBytes/sizeof(TCHAR);
     for(i=0;i<(int)dwReadBytes;i++) {
      	if(Buffer[i] == 0x0d || Buffer[i] == 0xfeff) continue;
      	if(Buffer[i] == TEXT('\n')) 
		{
		   dwLineNo ++;
		   szStr[j]=0;
		   j = 0;
    	   if(lstrcmpi(szStr,TEXT("[TEXT]"))==0)  {
	           bReadText = TRUE;
			   lstrcpy(szStr,TEXT(""));
	           continue;
     	   }
    	   if(lstrcmpi(szStr,TEXT(RuleSeg))==0
    	      || lstrcmpi(szStr,TEXT(DescriptSeg))==0)  {
	           bReadText = FALSE;
			   lstrcpy(szStr,TEXT(""));
	           continue;
     	   }
     
		   if(bReadText) {
   	           trim(szStr);
	           if(lstrlen(szStr) != 0) {
                   nRet = WordSplit(hWnd,nPages,szStr,lpCreateWords,lpWordIndex,
                             lpDescript,lpReConvIndex);	
                   if(nRet == 1)
                       lpWordIndex[dwBaseWordNum-1].dwOffset = dwOffset;
                   else if(!nRet) {
                       SetCursor (LoadCursor (NULL, IDC_ARROW));
			       return FALSE;
                   }
			   }
	  	   }
		   else
		       lstrcpy(szStr,TEXT(""));
		   continue;
		}
	  	else {
		    if(j == 0)
			    dwOffset = dwFstOffset + i*sizeof(TCHAR);
		    szStr[j]=Buffer[i];
		    j++; 
		}
	 }
	 if(dwReadBytes*sizeof(TCHAR) < MAXREADBUFFER) break;
	 dwFstOffset += MAXREADBUFFER;
   };

   SetCursor (LoadCursor (NULL, IDC_ARROW));
   if(dwBaseWordNum == 0) {
       ProcessError(ERR_TEXTSEG,hWnd,ERR);
       return FALSE;
   }
   else
       return TRUE;
}


BOOL ConvCalc(HANDLE hWnd,
			  HANDLE hMBFile,
              LPWORDINDEX lpWordIndex,
              LPMAININDEX lpMainIndex,
              LPDESCRIPTION lpDescript)
{
    DWORD        i,j,dwRecLen,dwOffset;
    BYTE         bySwap;
	TCHAR        Code[MAXNUMCODES],cc;
	DWORD        NumX,NumY,NumCodes,FstAdr,dwXStart,dwYStart,dwMaxXLen=0;
	HGLOBAL      hNumXYWords,hDicIndex;
	LPNUMXYWORDS lpNumXYWords;
	LPDICINDEX   lpDicIndex;
	BOOL		 bStart = FALSE;

	NumCodes=lpDescript->wNumCodes;
	hNumXYWords = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,sizeof(DWORD)*((NumCodes+1)*NumCodes+1L));
	hDicIndex = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,sizeof(DWORD)*(NumCodes+1)*NumCodes);
	if(!hNumXYWords || !hDicIndex) {
        ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
	    return FALSE;
	}

    if( !(lpNumXYWords = GlobalLock(hNumXYWords)) 
        ||!(lpDicIndex = GlobalLock(hDicIndex)) )  {
            ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
			GlobalFree(hNumXYWords);
			GlobalFree(hDicIndex);
	        return FALSE;
	}

    lstrcpy(Code,lpDescript->szUsedCode);
	FstAdr = lpMainIndex[TAG_BASEDIC-1].dwOffset;
	NumX=0;
	NumY=0;
	dwXStart=0;
	dwYStart=0;
	dwOffset=0;
    lpNumXYWords[0]=0;
    lpDicIndex[0]=0;
    for(i =0; i<dwBaseWordNum;i++) {
		bySwap =(BYTE) lstrlen(lpWordIndex[i].szCode);
		dwRecLen = (DWORD)bySwap*sizeof(TCHAR)+sizeof(TCHAR);
		bySwap =(BYTE) lpWordIndex[i].wDBCSLen;

        // if the DBCS str length is longer than 126, just get the first 126 characters.
        if ( bySwap >= 126 )
            bySwap = 126;

		dwRecLen += 2*(DWORD)bySwap+sizeof(TCHAR);
	    while( lpWordIndex[i].szCode[0] != Code[NumX] )
	    {
	    	
	    	if(!bStart && NumY == 0)
	    	{
	    	    lpNumXYWords[NumX*(NumCodes+1)+NumY+1] = i;
			    lpDicIndex[NumX*(NumCodes+1)+NumY+1] = dwOffset;
			}   

	    	while(NumY  < NumCodes-1 )
	    	{
				NumY ++;
	    	    lpNumXYWords[NumX*(NumCodes+1)+NumY+1] = i;
			    lpDicIndex[NumX*(NumCodes+1)+NumY+1] = dwOffset;
			}
	    	NumX ++;
			if(NumX >= NumCodes) break;
	    	lpNumXYWords[NumX*(NumCodes+1)] = i;
			lpDicIndex[NumX*(NumCodes+1)] = dwOffset;
	    	NumY = 0;
			bStart = FALSE;
		}
		if(NumX >= NumCodes) break;
        cc = lpWordIndex[i].szCode[1];
		if(!bStart && cc != 0 && NumY == 0)
		{
	       	lpNumXYWords[NumX*(NumCodes+1)+1] = i;
			lpDicIndex[NumX*(NumCodes+1)+1] = dwOffset;
			bStart = TRUE;
		}
		  
		while(bStart && cc != 0 && cc != Code[NumY] && NumY < NumCodes - 1 )
		{
			NumY ++;
	    	lpNumXYWords[NumX*(NumCodes+1)+NumY+1] = i;
			lpDicIndex[NumX*(NumCodes+1)+NumY+1] = dwOffset;
        }

		dwOffset += dwRecLen;
 	    if(i == dwBaseWordNum-1) {
		    j = NumX*(NumCodes+1) + NumY + 1;
	    	while(j  < (NumCodes+1)*NumCodes - 1 )
	    	{
				j ++;
	    	    lpNumXYWords[j] = i + 1;
			    lpDicIndex[j] = dwOffset;
			}
	        
	        lpNumXYWords[NumCodes*(NumCodes+1)] = i;
		}
	}

	for(i = 0; i < NumCodes	; i++)
	{    
	    for(j = 0; j < NumCodes + 1; j++)
		{
 		   if(j == 0)
 		   {
 		       lpNumXYWords[i*(NumCodes+1)] = lpNumXYWords[(i+1)*(NumCodes+1)] -
		 	       lpNumXYWords[i*(NumCodes+1)];
		   
		   }
		   else
		   {
		       lpNumXYWords[i*(NumCodes+1)+j] = lpNumXYWords[i*(NumCodes+1)+j+1] - 
				   lpNumXYWords[i*(NumCodes+1)+j];
			   lpDicIndex[i*(NumCodes+1)+j] = lpDicIndex[i*(NumCodes+1)+j] -
			       lpDicIndex[i*(NumCodes+1)];
		   }
		}
	}
	lpMainIndex[TAG_BASEDIC-1].dwLength = dwOffset;
	lpMainIndex[TAG_BASEDIC-1].dwCheckSum = TAG_BASEDIC +
	                                lpMainIndex[TAG_BASEDIC-1].dwOffset+
								    dwOffset;
	                                    
	for(i=0; i< NumCodes - 1;i++) {
	    dwRecLen = lpDicIndex[(i+1)*(NumCodes+1)]-lpDicIndex[(NumCodes+1)*i];
		dwMaxXLen = (dwRecLen>dwMaxXLen)? dwRecLen:dwMaxXLen;
	}
	
	dwRecLen =  dwOffset - lpDicIndex[(NumCodes+1)*(NumCodes-1)];
	dwMaxXLen = (dwRecLen>dwMaxXLen)? dwRecLen:dwMaxXLen;
		
	ConvWriteMainIndex(hMBFile,lpMainIndex);
    ConvWriteCodeIndex(hMBFile,&dwMaxXLen,lpDescript->szUsedCode,lpMainIndex);
	ConvWriteDicIndex(hMBFile,lpDicIndex,lpDescript->wNumCodes,lpMainIndex);
	ConvWriteNumXYWords(hMBFile,lpNumXYWords,
	                    lpDescript->wNumCodes,lpMainIndex);

	GlobalUnlock(hDicIndex);
	GlobalUnlock(hNumXYWords);
	GlobalFree(hDicIndex);
	GlobalFree(hNumXYWords);
    return TRUE;
}


BOOL WriteMBFile(HANDLE hWnd,
                 HANDLE hSRCFile,
                 HANDLE hMBFile,
                 LPWORDINDEX lpWordIndex,
                 LPMAININDEX lpMainIndex,
                 LPDESCRIPTION lpDescript)
{
    DWORD  i,dwBytes,NumCodes,FstAdr;
    WORD   bySwap;
	TCHAR  szStr[256];
	TCHAR  Code[MAXNUMCODES];
	DWORD  dwReadSum;
	HANDLE hDlgItem;

    SetCursor (LoadCursor (NULL, IDC_WAIT));   
	SetDlgItemText(hWnd,TM_TOTALINFO,TEXT(""));
    LoadString(NULL,IDS_TOTALINFO,szStr,sizeof(szStr)/sizeof(TCHAR));
	SetDlgItemText(hWnd,TM_TOTAL,szStr);
    LoadString(NULL,IDS_CONVWORDS,szStr,sizeof(szStr)/sizeof(TCHAR));
	SetDlgItemText(hWnd,TM_CONVINFO,szStr);
	SetDlgItemInt(hWnd,TM_TOTALNUM,dwBaseWordNum,FALSE);
	dwReadSum = 0;
	SetDlgItemInt(hWnd,TM_CONVNUM,dwReadSum,FALSE);
	InvalidateRect(hWnd,NULL,FALSE);

	NumCodes=lpDescript->wNumCodes;
    lstrncpy(Code,NumCodes,lpDescript->szUsedCode);
	FstAdr = lpMainIndex[TAG_BASEDIC-1].dwOffset;
	SetFilePointer(hMBFile,FstAdr,0, FILE_BEGIN);
    for(i =0; i<dwBaseWordNum;i++) {
	    SetFilePointer(hSRCFile,lpWordIndex[i].dwOffset,0,FILE_BEGIN);
		bySwap =(WORD) lpWordIndex[i].wDBCSLen;
		ReadFile(hSRCFile,szStr,2*(DWORD)bySwap,&dwBytes,NULL);
		bySwap =(WORD) lstrlen(lpWordIndex[i].szCode);
	    WriteFile(hMBFile,&bySwap,sizeof(TCHAR),&dwBytes,NULL);
	    WriteFile(hMBFile,&(lpWordIndex[i].szCode),bySwap*sizeof(TCHAR),&dwBytes,NULL);


		bySwap =(WORD) lpWordIndex[i].wDBCSLen;

        // if the DBCS str length is longer than 126, just get the first 126 characters.

        if ( bySwap >= 126 )
            bySwap = 126;

        WriteFile(hMBFile,&bySwap,sizeof(TCHAR),&dwBytes,NULL);
	    WriteFile(hMBFile,szStr,2*bySwap,&dwBytes,NULL);

		dwReadSum ++;
		if(dwReadSum%100 ==0 || dwReadSum == dwBaseWordNum) {
	         SetDlgItemInt(hWnd,TM_CONVNUM,dwReadSum,FALSE);
			 hDlgItem=GetDlgItem(hWnd,TM_CONVNUM);
			 InvalidateRect(hDlgItem,NULL,FALSE);
		}
	}

    SetCursor (LoadCursor (NULL, IDC_ARROW));   
    return TRUE;
}

BOOL WriteSortFile(HANDLE hWnd,
                   HANDLE hSRCFile,
                   HANDLE hDestFile,
                   LPWORDINDEX lpWordIndex,
				   LPCREATEWORD lpCreateWords)
{
    DWORD i, k, dwBytes;
	WORD  wRecLen;
	BYTE  bySwap;
	TCHAR szStr[512],szDBCS[512];
	TCHAR szCode[13],szCreate[13];
	BOOL  IsGenCmb = (hCmbFile)?TRUE:FALSE;  
	BOOL  bExistNext = FALSE; 
	DWORD dwReadSum;

	SetFilePointer(hDestFile,0,0, FILE_END);
	dwReadSum = 0;
    
    for(i =0; i<dwBaseWordNum;i++) {
	    SetFilePointer(hSRCFile,lpWordIndex[i].dwOffset,0,FILE_BEGIN);
		wRecLen = 2*lpWordIndex[i].wDBCSLen/sizeof(TCHAR);
		ReadFile(hSRCFile,szDBCS,wRecLen*sizeof(TCHAR),&dwBytes,NULL);
		szDBCS[wRecLen] = 0;
	    lstrcpy(szCode,lpWordIndex[i].szCode);
		bySwap =(BYTE)lstrlen(lpWordIndex[i].szCode);
		if(wRecLen == 2/sizeof(TCHAR)){
             k = EncodeToNo(szDBCS);
		   	 if((long)k>=0 && k < NUM_OF_ENCODE) {
		   	     lstrncpy(szCreate,MAXCODELEN,&lpCreateWords[k*MAXCODELEN]);
			     szCreate[MAXCODELEN]=0;
				 if(lstrlen(szCreate))
       		         wsprintf(szStr,TEXT("%s%s %s\r\n"),szDBCS,szCode,szCreate);
		         else
		             wsprintf(szStr,TEXT("%s%s\r\n"),szDBCS,szCode);
			 }
		     else
		         wsprintf(szStr,TEXT("%s%s\r\n"),szDBCS,szCode);
		}
		else
		     wsprintf(szStr,TEXT("%s%s\r\n"),szDBCS,szCode);
	    WriteFile(hDestFile,szStr,lstrlen(szStr)*sizeof(TCHAR),&dwBytes,NULL);
		if(IsGenCmb)
		{
		    if(i != dwBaseWordNum - 1
		       && _wcsicmp(lpWordIndex[i].szCode, lpWordIndex[i+1].szCode) == 0)
			{
		        wsprintf(szStr,TEXT("%s%s\r\n"),szCode,szDBCS);
	            WriteFile(hCmbFile,szStr,lstrlen(szStr)*sizeof(TCHAR),&dwBytes,NULL);
				bExistNext = TRUE;
		        dwReadSum ++;
			}
			else
			{
			    if(bExistNext)
				{
		            wsprintf(szStr,TEXT("%s%s\r\n"),szCode,szDBCS);
	                WriteFile(hCmbFile,szStr,lstrlen(szStr)*sizeof(TCHAR),&dwBytes,NULL);
				}
				bExistNext = FALSE;
			}
		}
	}

    if(IsGenCmb)
	{
#ifdef UNICODE
	     TCHAR UniTmp[] = {0x5171, 0x8BA1, 0x91CD, 0x7801, 0x8BCD, 0x6761, 0x6570, 0x0000};
	     wsprintf(szStr,TEXT("%ws = %d\n"), UniTmp, dwReadSum);
#else
	     wsprintf(szStr,"�������������� = %ld\n", dwReadSum);
#endif
	     WriteFile(hCmbFile,szStr,lstrlen(szStr)*sizeof(TCHAR),&dwBytes,NULL);
	}
	    
    return TRUE;
}


int  SimpleSplit(HANDLE hWnd,
			     LPINT nPages,
                 LPTSTR szStr,
                 LPCREATEWORD lpCreateWords,
                 LPWORDINDEX  lpWordIndex,
                 WORD  wMaxCodes)
{
   register int i=0;
   int   nDBCS=0,  nCodes=0, nCreate = 0;
   TCHAR szDBCS[512],szCode[13],szCreate[128];

   if(ParseDBCSstr(hWnd,szStr,szDBCS,szCode,szCreate,wMaxCodes) != TRUE)
   {
        if(lstrlen(szDBCS) == 0)
		{
             LoadString(NULL, IDS_NOTEXISTDBCS, szCreate, sizeof(szCreate)/sizeof(TCHAR));
             wsprintf(szDBCS,TEXT("\'%s%lu)"),szCreate,dwLineNo); 
             FatalMessage(hWnd,szDBCS);
		}
       return FALSE;
   }
   nDBCS = lstrlen(szDBCS);
   DelIllegalCode(szCode);
   nCodes = lstrlen(szCode);
   nCreate = lstrlen(szCreate);
   dwBaseWordNum ++;

   lpWordIndex[dwBaseWordNum-1].wDBCSLen =(WORD)(nDBCS*sizeof(TCHAR)/2);
   lstrcpy(lpWordIndex[dwBaseWordNum-1].szCode,szCode);
      
   if(nDBCS == 2/sizeof(TCHAR)) {
       i =  EncodeToNo(szDBCS);
	   if(i>=0 && i < NUM_OF_ENCODE) 
	   {
            if(nCreate != 0) 
                lstrncpy(lpCreateWords+i*MAXCODELEN,
                         MAXCODELEN, szCreate);
       }
   }
   return TRUE;
}

int  WordSplit(HANDLE hWnd,
			   LPINT nPages,
               LPTSTR szStr,
               LPCREATEWORD lpCreateWords,
               LPWORDINDEX  lpWordIndex,
               LPDESCRIPTION lpDescript,
               LPRECONVINDEX lpReConvIndex)
{
   int   i, nDBCS=0,  nCodes=0, nCreate = 0;
   TCHAR szTemp[512],szTmpStr[256];
   TCHAR szDBCS[512],szCode[13],szCreate[128];

   if(ParseDBCSstr(hWnd,szStr,szDBCS,szCode,szCreate,lpDescript->wMaxCodes) != TRUE)
   {
        if(lstrlen(szDBCS) == 0)
		{
             LoadString(NULL, IDS_NOTEXISTDBCS, szTmpStr, sizeof(szTmpStr)/sizeof(TCHAR));
             wsprintf(szTemp,TEXT("\'%s%lu)"),szTmpStr,dwLineNo); 
             FatalMessage(hWnd,szTemp);
		}
        return FALSE;
   }


   if (  lstrlen(szDBCS) > 126 ) {
       // if the string is longer than 126, the rest will be cut.
       // so show a message to end user.

       LoadString(NULL, IDS_DBCSTOOLONG, szTmpStr, sizeof(szTmpStr)/sizeof(TCHAR));
#ifdef UNICODE
       {
	      TCHAR UniTmp[] = {0x0027, 0x0025, 0x0077, 0x0073, 0x0027, 0x0020, 0x0020, 
                            0x0020, 0x0028, 0x884C, 0x003A, 0x0025, 0x006C, 0x0075, 
                            0x0029, 0x0025, 0x0077, 0x0073, 0x000D, 0x000A, 0x000D,
                            0x000A, 0x9000, 0x51FA, 0x5426, 0x003F, 0x0020, 0x0000};

          wsprintf(szTemp, UniTmp, szDBCS,dwLineNo,szTmpStr); 
       }
#else
       wsprintf(szTemp,"\'%s\'%s(��:%lu)\n�˳���? ",szDBCS,szTmpStr,dwLineNo); 
#endif 
       if (ErrMessage(hWnd,szTemp)) 
          return FALSE;
   }


   if(!CheckCodeLegal(hWnd,szDBCS,szCode,szCreate,lpDescript))
        return FALSE;
   nDBCS = lstrlen(szDBCS);
   nCodes = lstrlen(szCode);
   nCreate = lstrlen(szCreate);

   if(nDBCS == 0) 
        return -1;
     
   if(nDBCS == 2/sizeof(TCHAR))
   {
       i =  EncodeToNo(szDBCS);
       if(i < 0 || i >= NUM_OF_ENCODE) 
           return FALSE;
       if(nCodes == 0) {
           LoadString(NULL, IDS_CODEEMPTY, szTmpStr, sizeof(szTmpStr)/sizeof(TCHAR));
#ifdef UNICODE
{
	   TCHAR UniTmp[] = {0x005C, 0x0027, 0x0025, 0x0077, 0x0073, 0x005C, 0x0027, 0x0025, 0x0077, 0x0073, 0x0028, 0x884C, 0x003A, 0x0025, 0x006C, 0x0075, 0x0029, 0x005C, 0x006E, 0x9000, 0x51FA, 0x5426, 0x003F, 0x0020, 0x0000};
       wsprintf(szTemp, UniTmp, szDBCS,szTmpStr,dwLineNo); 
}
#else
           wsprintf(szTemp,"\'%s\'%s(��:%lu)\n�˳���? ",szDBCS,szTmpStr,dwLineNo); 
#endif \\UNICODE
           if(ErrMessage(hWnd,szTemp)) 
              return FALSE;
	   }
       
//**** write create words
       if(lpDescript->wNumRules != 0 && nCreate != 0)
       {
           if(nCreate > lpDescript->wMaxCodes) {
                LoadString(NULL,IDS_DBCSCODE,szTmpStr,sizeof(szTmpStr)/sizeof(TCHAR));
#ifdef UNICODE
{
		TCHAR UniTmp[] = {0x005C, 0x0027, 0x0025, 0x0077, 0x0073, 0x0025, 0x0077, 0x0073, 0x005C, 0x0027, 0x0020, 0x0025, 0x0064, 0x0021, 0x0028, 0x884C, 0x003A, 0x0025, 0x006C, 0x0075, 0x0029, 0x005C, 0x006E, 0x9000, 0x51FA, 0x5426, 0x003F, 0x0000};
                wsprintf(szTemp,UniTmp, szDBCS,szTmpStr,
		                 lpDescript->byMaxElement,dwLineNo); 
}
#else
                wsprintf(szTemp,"\'%s%s\' %d!(��:%lu)\n�˳���?", szDBCS,szTmpStr,
		                 lpDescript->byMaxElement,dwLineNo); 
#endif \\UNICODE
                if( ErrMessage(hWnd,szTemp))
                     return FALSE;
           }
           lstrncpy(szTmpStr,lpDescript->wMaxCodes,
                    lpCreateWords+i*(DWORD)lpDescript->wMaxCodes);
	 	   szTmpStr[lpDescript->wMaxCodes] = 0;
		   if(!(WriteCrtFlag[i/8] & (1 << (7 - (i%8))) ) )
                lstrncpy(lpCreateWords+i*(DWORD)lpDescript->wMaxCodes,
                         lpDescript->wMaxCodes,
                         szCreate);
		   WriteCrtFlag[i/8] |= (1 << (7 - (i%8)) );
	   }
    
   }     
   else if(nDBCS>2*sizeof(TCHAR) && nCodes==0 && lpDescript->wNumRules==0)
    {
       LoadString(NULL,IDS_CODEEMPTY,szTmpStr,sizeof(szTmpStr)/sizeof(TCHAR));
#ifdef UNICODE
{
       TCHAR UniTmp[] = {0x005C, 0x0027, 0x0025, 0x0077, 0x0073, 0x005C, 0x0027, 0x0025, 0x0077, 0x0073, 0x0028, 0x884C, 0x003A, 0x0025, 0x006C, 0x0064, 0x0029, 0x0000};
       wsprintf(szTemp,UniTmp, szDBCS,szTmpStr,dwLineNo); 
}
#else
       wsprintf(szTemp,"\'%s\'%s(��:%ld)", szDBCS,szTmpStr,dwLineNo); 
#endif
       WarnMessage(hWnd,szTemp);
	   return FALSE;
   }
   

   dwBaseWordNum ++;
   if(dwBaseWordNum >(DWORD)(*nPages)*GMEM_PAGESIZE) {
       GlobalUnlock(hWordIndex);
       hWordIndex = IndexReAlloc(hWordIndex,nPages);
	   if(!hWordIndex) {
            ProcessError(ERR_OUTOFMEMORY,hWnd,ERR);
            return FALSE;
	   }
	   lpWordIndex = (LPWORDINDEX) GlobalLock(hWordIndex);
  	   if( !lpWordIndex )  {
            ProcessError(ERR_GLOBALLOCK,hWnd,ERR);
	        return FALSE;
	   }
   }

   lpWordIndex[dwBaseWordNum-1].wDBCSLen =(WORD)(nDBCS*sizeof(TCHAR)/2);
   lstrcpy(lpWordIndex[dwBaseWordNum-1].szCode,szCode);

   ConvReconvIndex(hWnd,szDBCS,lpCreateWords,lpWordIndex[dwBaseWordNum-1],lpDescript,lpReConvIndex); 
      
   return TRUE;
}


BOOL ConvWriteBaseWord  (HANDLE hWnd, 
                         HANDLE hSRCFile,
                         HANDLE hMBFile, 
						 MAINID MainID,
                         DWORD dwOffset, 
                         LPCREATEWORD lpCreateWords, 
						 LPRECONVINDEX lpReConvIndex,
                         DWORD MaxCodes)
{
  TCHAR  szCode[13],szCreate[13],szDBCS[512],szReCode[13];
  TCHAR  szStr[512];
  static TCHAR  ReadBuf[MAXREADBUFFER];
  static TCHAR  WriteBuf[2*MAXREADBUFFER];
  DWORD  dwReadBytes,dwRecLen,i,j,k,dwReadWords=0;
  DWORD  dwFileFlag = MainID.dwFileFlag;
  DWORD  dwNumWords = MainID.dwNumWords;
  DWORD  dwReadSum;
  HWND   hDlgItem;

  SetFilePointer(hMBFile,dwOffset,0,FILE_BEGIN);
  SetFilePointer(hSRCFile,0,0,FILE_END);

  SetDlgItemText(hWnd,TM_TOTALINFO,TEXT(""));
  LoadString(NULL,IDS_TOTALINFO,szStr,sizeof(szStr)/sizeof(TCHAR));
  SetDlgItemText(hWnd,TM_TOTAL,szStr);
  LoadString(NULL,IDS_RECONVWORDS,szStr,sizeof(szStr)/sizeof(TCHAR));
  SetDlgItemText(hWnd,TM_CONVINFO,szStr);
  SetDlgItemInt(hWnd,TM_TOTALNUM,dwNumWords,FALSE);
  dwReadSum = 0;
  SetDlgItemInt(hWnd,TM_CONVNUM,dwReadSum,FALSE);
  InvalidateRect(hWnd,NULL,FALSE);
  
  i=0;
  do {
      ReadFile(hMBFile,ReadBuf,sizeof(ReadBuf),&dwReadBytes,NULL);
	  i=0;
	  if(dwReadBytes == 0 ) break;
	  WriteBuf[0]=0;
	  dwReadBytes = dwReadBytes/sizeof(TCHAR);
	  while( i < dwReadBytes-1 ) {
	     j = (DWORD)ReadBuf[i]+1;
		 dwRecLen = j+(DWORD)ReadBuf[i+j]*2/sizeof(TCHAR)+1;
		 if( (dwReadBytes*sizeof(TCHAR) < MAXREADBUFFER) ||
		      ((i+j) < (dwReadBytes-1) && (i+dwRecLen) < (dwReadBytes-1) ) )  {
	        lstrncpy(szCode,ReadBuf[i],&ReadBuf[i+1]);
			szCode[ReadBuf[i]] = 0;
			lstrncpy(szDBCS,ReadBuf[i+j]*2/sizeof(TCHAR),&ReadBuf[i+j+1]);
			szDBCS[ReadBuf[i+j]*2/sizeof(TCHAR)] = 0;
			if(ReadBuf[i+j]==1 
			   &&(dwFileFlag&FFLG_RULE)) {
                k =  EncodeToNo(szDBCS);
				if((long)k>=0 && k < NUM_OF_ENCODE) {
			   	    lstrncpy(szCreate,MaxCodes,&lpCreateWords[k*MaxCodes]);
			   	    lstrncpy(szReCode,MaxCodes,&lpReConvIndex[k*MaxCodes]);
				    szCreate[MaxCodes]=0;
				    szReCode[MaxCodes]=0;
					if(lstrlen(szCreate) != 0 && lstrcmpi(szCreate,szCode) != 0)
       			       wsprintf(szStr,TEXT("%s%s %s\r\n"),szDBCS,szCode,szCreate);
				    else
			           wsprintf(szStr,TEXT("%s%s\r\n"),szDBCS,szCode);
				}
				else
			        wsprintf(szStr,TEXT("%s%s\r\n"),szDBCS,szCode);
			}
			else
			    wsprintf(szStr,TEXT("%s%s\r\n"),szDBCS,szCode);
			lstrcat(WriteBuf,szStr);
			dwReadWords ++;
			dwReadSum = dwReadWords;
			if(dwReadSum%100 ==0 || dwReadSum == dwNumWords) {
  	            SetDlgItemInt(hWnd,TM_CONVNUM,dwReadSum,FALSE);
				hDlgItem=GetDlgItem(hWnd,TM_CONVNUM);
				InvalidateRect(hDlgItem,NULL,FALSE);
			}
	        i += dwRecLen;
		}
	    else {
		    SetFilePointer(hMBFile,(i-dwReadBytes)*sizeof(TCHAR),0,FILE_CURRENT);
	       	break;
		}
	 }
	 WriteFile(hSRCFile,WriteBuf,lstrlen(WriteBuf)*sizeof(TCHAR),&k,NULL);
  }while (dwReadBytes == MAXREADBUFFER) ;
  return TRUE;
}


BOOL ConvBatCreate (HANDLE  hWnd,
                    DESCRIPTION   Descript,
                    LPRULE  lpRule,
					LPCREATEWORD lpCreateWord,
                    LPTSTR   szWordStr, 
                    LPTSTR   lpCode)
{
   int   nWordLen=lstrlen(szWordStr)*sizeof(TCHAR)/2;
   DWORD i,j,k,dwCodeLen;
   DWORD dwNumRules = Descript.wNumRules;
   WORD  wMaxCodes = Descript.wMaxCodes;
   TCHAR szDBCS[3],szCode[MAXCODELEN+1];
   BOOL  bReturn = FALSE;

   lpCode[0] = 0;
   if(dwNumRules == 0) {
       ProcessError(ERR_NORULE,hWnd,ERR);
       return FALSE;
   }
   for(i=0; i<dwNumRules; 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 ) 
 		   {   
 		       lstrncpy(szCode,wMaxCodes,&lpCreateWord[wMaxCodes*k]);
		       szCode[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,hWnd,ERR);
	lpCode[wMaxCodes] = 0;
	return bReturn;
}



BOOL  searchPos(LPWORDINDEX lpWordIndex, DWORD dwNumWords)
{
    DWORD i, retPos;
    WORDINDEX InsWordIndex = lpWordIndex[dwNumWords-1];
    if(dwNumWords == 1)
        return TRUE;
    retPos = bSearch(lpWordIndex, 0, dwNumWords-2, InsWordIndex);
    if(retPos == dwNumWords - 1)
	    return TRUE;
	memmove(&lpWordIndex[retPos+1], &lpWordIndex[retPos],
	     sizeof(WORDINDEX)*(dwNumWords - 1 - retPos) );
    lpWordIndex[retPos] = InsWordIndex;
    return TRUE;
}

DWORD bSearch(LPWORDINDEX lpWordIndex,  DWORD left, DWORD right, WORDINDEX InsWordIndex)
{
    WORDINDEX MidWordIndex;
    DWORD mid;

    if(left > right)
        return left;
    mid = (left + right)/2;

    MidWordIndex = lpWordIndex[mid];
    if(_wcsicmp(MidWordIndex.szCode, InsWordIndex.szCode) <= 0)
    {
        if(mid ==  right || _wcsicmp(lpWordIndex[mid+1].szCode, InsWordIndex.szCode) > 0) 
            return mid+1;
	    else
            return bSearch(lpWordIndex, mid+1, right, InsWordIndex);
    }	 
    else 
	{
        if(mid ==  left || _wcsicmp(lpWordIndex[mid-1].szCode, InsWordIndex.szCode) <= 0) 
            return mid;
	    else
//            return bSearch(lpWordIndex, left, mid, InsWordIndex);
            return bSearch(lpWordIndex, left, mid-1, InsWordIndex);
	}

    return 0;
}
//***** end 95.10.17