开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 查看源码
Dictionary.cpp
资源名称：ictclas_Source_Code.zip　[点击查看]
上传用户：chen_dj
上传日期：2013-04-22
资源大小：111k
文件大小：28k
源码类别：

多国语言处理

开发平台：

C/C++

Dictionary.cpp：源码内容
  1. /****************************************************************************
  2.  *
  3.  * Copyright (c) 2000, 2001 
  4.  *     Machine Group
  5.  *     Software Research Lab.
  6.  *     Institute of Computing Tech.
  7.  *     Chinese Academy of Sciences
  8.  *     All rights reserved.
  9.  *
  10.  * This file is the confidential and proprietary property of 
  11.  * Institute of Computing Tech. and the posession or use of this file requires 
  12.  * a written license from the author.
  13.  * Filename: Dictionary.cpp
  14.  * Abstract:
  15.  *           implementation of the CDictionary class.
  16.  * Author:   Kevin Zhang 
  17.  *          (zhanghp@software.ict.ac.cn)
  18.  * Date:     2002-1-8
  19.  *
  20.  * Notes:
  21.  *                
  22.  ****************************************************************************/
  23. #include "stdafx.h"
  24. #include "Dictionary.h"
  25. #include "Utility.h"
  26. #include <string.h>
  27. #include <stdlib.h>
  28. #include <malloc.h>
  29. #include <stdio.h>
  30. //////////////////////////////////////////////////////////////////////
  31. // Construction/Destruction
  32. //////////////////////////////////////////////////////////////////////
  34. CDictionary::CDictionary()
  35. {
  36.   //initilization
  37.   memset(m_IndexTable,0,sizeof(m_IndexTable));
  38.   m_pModifyTable=NULL;
  39. }
  41. CDictionary::~CDictionary()
  42. {
  43. for(int i=0;i<CC_NUM;i++)
  44. {//delete the memory of word item array in the dictionary
  45. for(int j=0;j<m_IndexTable[i].nCount;j++)
  46. delete m_IndexTable[i].pWordItemHead[j].sWord;
  47. delete [] m_IndexTable[i].pWordItemHead;
  48. }
  49.     DelModified();
  50. }
  51. /*********************************************************************
  52.  *
  53.  *  Func Name  : Load
  54.  *
  55.  *  Description: Load the dictionary from the file .dct
  56.  *              
  57.  *
  58.  *  Parameters : sFilename: the file name
  59.  *
  60.  *  Returns    : success or fail
  61.  *  Author     : Kevin Zhang  
  62.  *  History    : 
  63.  *              1.create 2002-1-9
  64.  *********************************************************************/
  65. bool CDictionary::Load(char *sFilename,bool bReset)
  66. {
  67.    FILE *fp;
  68.    int i,j,nBuffer[3];
  69.    if((fp=fopen(sFilename,"rb"))==NULL)
  70.    return false;//fail while opening the file
  71.    
  72.    //Release the memory for new files
  73.    for( i=0;i<CC_NUM;i++)
  74. {//delete the memory of word item array in the dictionary
  75. for( j=0;j<m_IndexTable[i].nCount;j++)
  76. delete m_IndexTable[i].pWordItemHead[j].sWord;
  77. delete [] m_IndexTable[i].pWordItemHead;
  78. }
  79.     DelModified();
  80.    for(i=0;i<CC_NUM;i++)
  81.    {
  82.    fread(&(m_IndexTable[i].nCount),sizeof(int),1,fp);
  83.        if(m_IndexTable[i].nCount>0)
  84.      m_IndexTable[i].pWordItemHead=new WORD_ITEM[m_IndexTable[i].nCount];
  85.    else 
  86.    {
  87.    m_IndexTable[i].pWordItemHead=0;
  88.    continue;
  89.    }
  90.        j=0;
  91.    while(j<m_IndexTable[i].nCount)
  92.    {
  93.          fread(nBuffer,sizeof(int),3,fp);
  94.          m_IndexTable[i].pWordItemHead[j].sWord=new char[nBuffer[1]+1];
  95.     if(nBuffer[1])//String length is more than 0
  96.  {
  97.  fread(m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
  98.  }
  99.  m_IndexTable[i].pWordItemHead[j].sWord[nBuffer[1]]=0;
  100.         if(bReset)//Reset the frequency
  101.           m_IndexTable[i].pWordItemHead[j].nFrequency=0;
  102.  else
  103.               m_IndexTable[i].pWordItemHead[j].nFrequency=nBuffer[0];
  104.  m_IndexTable[i].pWordItemHead[j].nWordLen=nBuffer[1];
  105.  m_IndexTable[i].pWordItemHead[j].nHandle=nBuffer[2];
  106.    j+=1;//Get next item in the original table.
  107.    }
  108.    }
  109.    fclose(fp);
  110.    return true;
  111. }
  112. /*********************************************************************
  113.  *
  114.  *  Func Name  : Save
  115.  *
  116.  *  Description: Save the dictionary as the file .dct
  117.  *              
  118.  *
  119.  *  Parameters : sFilename: the file name
  120.  *
  121.  *  Returns    : success or fail
  122.  *  Author     : Kevin Zhang  
  123.  *  History    : 
  124.  *              1.create 2002-1-9
  125.  *********************************************************************/
  127. bool CDictionary::Save(char *sFilename)
  128. {
  129.    FILE *fp;
  130.    int i,j,nCount,nBuffer[3];
  131.    PWORD_CHAIN pCur;
  132.    if((fp=fopen(sFilename,"wb"))==NULL)
  133.    return false;//fail while opening the file
  134.    for(i=0;i<CC_NUM;i++)
  135.    {
  136.    pCur=NULL;
  137.    if(m_pModifyTable)
  138.    {//Modification made
  139.    nCount=m_IndexTable[i].nCount+m_pModifyTable[i].nCount-m_pModifyTable[i].nDelete;
  140.    fwrite(&nCount,sizeof(int),1,fp);
  141.    pCur=m_pModifyTable[i].pWordItemHead;
  142.    j=0;
  143.    while(pCur!=NULL&&j<m_IndexTable[i].nCount)
  144.    {//Output to the file after comparision
  145.    if(strcmp(pCur->data.sWord,m_IndexTable[i].pWordItemHead[j].sWord)<0||(strcmp(pCur->data.sWord,m_IndexTable[i].pWordItemHead[j].sWord)==0&&pCur->data.nHandle<m_IndexTable[i].pWordItemHead[j].nHandle))
  146.    {//Output the modified data to the file
  147.  nBuffer[0]=pCur->data.nFrequency;
  148.          nBuffer[1]=pCur->data.nWordLen;
  149.      nBuffer[2]=pCur->data.nHandle;
  150.                  fwrite(nBuffer,sizeof(int),3,fp);
  151.  if(nBuffer[1])//String length is more than 0
  152.           fwrite(pCur->data.sWord,sizeof(char),nBuffer[1],fp);
  153.                  pCur=pCur->next;//Get next item in the modify table.
  154.    }
  155.    else if(m_IndexTable[i].pWordItemHead[j].nFrequency==-1)
  156.    {//The item has been removed,so skip it
  157.    j+=1;
  158.    }
  159.    else if(strcmp(pCur->data.sWord,m_IndexTable[i].pWordItemHead[j].sWord)>0||(strcmp(pCur->data.sWord,m_IndexTable[i].pWordItemHead[j].sWord)==0&&pCur->data.nHandle>m_IndexTable[i].pWordItemHead[j].nHandle))
  160.    {//Output the index table data to the file
  161.  nBuffer[0]=m_IndexTable[i].pWordItemHead[j].nFrequency;
  162.  nBuffer[1]=m_IndexTable[i].pWordItemHead[j].nWordLen;
  163.  nBuffer[2]=m_IndexTable[i].pWordItemHead[j].nHandle;
  164.  fwrite(nBuffer,sizeof(int),3,fp);
  165.  if(nBuffer[1])//String length is more than 0
  166.    fwrite(m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
  167.  j+=1;//Get next item in the original table.
  168.    }
  169.    }
  170.    if(j<m_IndexTable[i].nCount)
  171.    {
  172.    while(j<m_IndexTable[i].nCount)
  173.    {
  174.    if(m_IndexTable[i].pWordItemHead[j].nFrequency!=-1)
  175.    {//Has been deleted
  176.  nBuffer[0]=m_IndexTable[i].pWordItemHead[j].nFrequency;
  177.  nBuffer[1]=m_IndexTable[i].pWordItemHead[j].nWordLen;
  178.  nBuffer[2]=m_IndexTable[i].pWordItemHead[j].nHandle;
  179.  fwrite(nBuffer,sizeof(int),3,fp);
  180.  if(nBuffer[1])//String length is more than 0
  181.    fwrite(m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
  182.    }
  183.    j+=1;//Get next item in the original table.
  184.    }
  185.    }
  186.    else////No Modification
  187.    while(pCur!=NULL)//Add the rest data to the file.
  188.    {
  189.  nBuffer[0]=pCur->data.nFrequency;
  190.          nBuffer[1]=pCur->data.nWordLen;
  191.      nBuffer[2]=pCur->data.nHandle;
  192.                  fwrite(nBuffer,sizeof(int),3,fp);
  193.  if(nBuffer[1])//String length is more than 0
  194.    fwrite(pCur->data.sWord,sizeof(char),nBuffer[1],fp);
  195.                  pCur=pCur->next;//Get next item in the modify table.
  196.    }
  197.    }
  198.    else
  199.    {
  200.    fwrite(&m_IndexTable[i].nCount,sizeof(int),1,fp);
  201.    //write to the file
  202.            j=0;  
  203.    while(j<m_IndexTable[i].nCount)
  204.    {
  205.  nBuffer[0]=m_IndexTable[i].pWordItemHead[j].nFrequency;
  206.      nBuffer[1]=m_IndexTable[i].pWordItemHead[j].nWordLen;
  207.  nBuffer[2]=m_IndexTable[i].pWordItemHead[j].nHandle;
  208.              fwrite(nBuffer,sizeof(int),3,fp);
  209.  if(nBuffer[1])//String length is more than 0
  210.    fwrite(m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
  211.    j+=1;//Get next item in the original table.
  212.    }
  213.    }
  214.    }
  215.    fclose(fp);
  216.    return true;
  217. }
  218. /*********************************************************************
  219.  *
  220.  *  Func Name  : AddItem
  221.  *
  222.  *  Description: Add a word item to the dictionary
  223.  *              
  224.  *
  225.  *  Parameters : sWord: the word
  226.  *               nHandle:the handle number
  227.  *               nFrequency: the frequency
  228.  *  Returns    : success or fail
  229.  *  Author     : Kevin Zhang  
  230.  *  History    : 
  231.  *              1.create 2002-1-9
  232.  *********************************************************************/
  234. bool CDictionary::AddItem(char *sWord, int nHandle,int nFrequency)
  235. {
  237.    char sWordAdd[WORD_MAXLENGTH-2];
  238.    int nPos,nFoundPos;
  239.    PWORD_CHAIN pRet,pTemp,pNext;
  240.    int i=0;
  241.    if(!PreProcessing(sWord, &nPos,sWordAdd,true))
  242.    return false;
  243.    if(FindInOriginalTable(nPos,sWordAdd,nHandle,&nFoundPos))
  244.    {//The word exists in the original table, so add the frequency
  245.     //Operation in the index table and its items 
  246.        if(m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency==-1)
  247.    {//The word item has been removed
  248.       m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency=nFrequency;
  249.         if(!m_pModifyTable)//Not prepare the buffer
  250.   {
  251.    m_pModifyTable=new MODIFY_TABLE[CC_NUM];
  252.    memset(m_pModifyTable,0,CC_NUM*sizeof(MODIFY_TABLE));
  253.   }
  254.   m_pModifyTable[nPos].nDelete-=1;
  255.    }
  256.    else
  257.   m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency+=nFrequency;
  258.    return true;
  259.    }
  261.    //The items not exists in the index table.
  262.    //As following, we have to find the item whether exists in the modify data region
  263.    //If exists, change the frequency .or else add a item
  264.    if(!m_pModifyTable)//Not prepare the buffer
  265.    {
  266.    m_pModifyTable=new MODIFY_TABLE[CC_NUM];
  267.    memset(m_pModifyTable,0,CC_NUM*sizeof(MODIFY_TABLE));
  268.    }
  269.    if(FindInModifyTable(nPos,sWordAdd,nHandle,&pRet))
  270.    {
  271.    if(pRet!=NULL)
  272.    pRet=pRet->next;
  273.    else
  274.    pRet=m_pModifyTable[nPos].pWordItemHead;
  275.    pRet->data.nFrequency+=nFrequency;
  276.    return true;
  277.    }
  278.    //find the proper position to add the word to the modify data table and link
  279.    pTemp=new WORD_CHAIN;//Allocate the word chain node
  280.    if(pTemp==NULL)//Allocate memory failure
  281.    return false;
  282.    memset(pTemp,0,sizeof(WORD_CHAIN));//init it with 0
  283.    pTemp->data.nHandle=nHandle;//store the handle 
  284.    pTemp->data.nWordLen=strlen(sWordAdd);
  285.    pTemp->data.sWord=new char[1+pTemp->data.nWordLen];
  286.    strcpy(pTemp->data.sWord,sWordAdd);
  287.    pTemp->data.nFrequency=nFrequency;
  288.    pTemp->next=NULL;   
  289.    if(pRet!=NULL)
  290.    {
  291.    pNext=pRet->next;//Get the next item before the current item
  292.    pRet->next=pTemp;//link the node to the chain
  293.    }
  294.    else
  295.    {
  296.    pNext=m_pModifyTable[nPos].pWordItemHead;
  297.    m_pModifyTable[nPos].pWordItemHead=pTemp;//Set the pAdd as the head node
  298.    }
  299.    pTemp->next=pNext;//Very important!!!! or else it will lose some node
  300.    //Modify in 2001-10-29
  301.    m_pModifyTable[nPos].nCount++;//the number increase by one
  302.    return true;
  303. }
  304. bool CDictionary::DelItem(char *sWord,int nHandle)
  305. {
  306.    char sWordDel[WORD_MAXLENGTH-2];
  307.    int nPos,nFoundPos,nTemp;
  308.    PWORD_CHAIN pPre,pTemp,pCur;
  309.    if(!PreProcessing(sWord, &nPos,sWordDel))
  310.    return false;
  311.    if(FindInOriginalTable(nPos,sWordDel,nHandle,&nFoundPos))
  312.    {
  313.        if(!m_pModifyTable)//Not prepare the buffer
  314.    {
  315.    m_pModifyTable=new MODIFY_TABLE[CC_NUM];
  316.    memset(m_pModifyTable,0,CC_NUM*sizeof(MODIFY_TABLE));
  317.    }
  318.        m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency=-1;
  319.    m_pModifyTable[nPos].nDelete+=1;
  320.    if(nHandle==-1)//Remove all items which word is sWordDel,ignoring the handle
  321.    {
  322. /*    nTemp=nFoundPos-1;//Check its previous position
  323.    while(nTemp>0&&strcmp(m_IndexTable[nPos].pWordItemHead[nFoundPos].sWord,sWordDel)==0)
  324.    {
  325. m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency=-1;
  326. m_pModifyTable[nPos].nDelete+=1;
  327. nTemp-=1;
  328.    }
  329. */    nTemp=nFoundPos+1;//Check its previous position
  330.    while(nTemp<m_IndexTable[nPos].nCount&&strcmp(m_IndexTable[nPos].pWordItemHead[nFoundPos].sWord,sWordDel)==0)
  331.    {
  332. m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency=-1;
  333. m_pModifyTable[nPos].nDelete+=1;
  334. nTemp+=1;
  335.    }
  336.    }
  337.    return true;
  338.    }
  339.    //Operation in the modify table and its items 
  340.    if(FindInModifyTable(nPos,sWordDel,nHandle,&pPre))
  341.    {
  342.      pCur=m_pModifyTable[nPos].pWordItemHead;
  343.      if(pPre!=NULL)
  344.  pCur=pPre->next;
  345.          while(pCur!=NULL && _stricmp(pCur->data.sWord,sWordDel)==0&&(pCur->data.nHandle==nHandle||nHandle<0))
  346.  {
  347.  pTemp=pCur;
  348.       if(pPre!=NULL)//pCur is the first item
  349.  pPre->next=pCur->next;
  350.  else
  351.  m_pModifyTable[nPos].pWordItemHead=pCur->next;
  352.  pCur=pCur->next;
  353.  delete pTemp->data.sWord;//Delete the word
  354.  delete pTemp;
  355.  }
  356.    return true;
  357.    }
  358.    return false;
  359. }
  360. bool CDictionary::DelModified()
  361. {
  362.   PWORD_CHAIN pTemp,pCur;
  363.   if(!m_pModifyTable)
  364.   return true;
  365.   for(int i=0;i<CC_NUM;i++)
  366.   {
  367.       pCur=m_pModifyTable[i].pWordItemHead;
  368.   while(pCur!=NULL)
  369.   {
  370.   pTemp=pCur;
  371.   pCur=pCur->next;
  372.   delete pTemp->data.sWord;
  373.   delete pTemp;
  374.   }
  375.   }
  376.   delete [] m_pModifyTable;
  377.   m_pModifyTable=NULL;
  378.   return true;
  379. }
  380. bool CDictionary::IsExist(char *sWord,  int nHandle)
  381. {
  382.    char sWordFind[WORD_MAXLENGTH-2];
  383.    int nPos;
  384.    if(!PreProcessing(sWord, &nPos,sWordFind))
  385.    return false;
  386.    return(FindInOriginalTable(nPos,sWordFind,nHandle)||FindInModifyTable(nPos,sWordFind,nHandle));
  387. }
  388. bool CDictionary::GetHandle(char *sWord,int *pnCount,int *pnHandle,int *pnFrequency)
  389. {
  390.    char sWordGet[WORD_MAXLENGTH-2];
  391.    int nPos,nFoundPos,nTemp;
  392.    PWORD_CHAIN pPre,pCur;
  393.    *pnCount=0;
  394.    if(!PreProcessing(sWord, &nPos,sWordGet))
  395.    return false;
  396.    if(FindInOriginalTable(nPos,sWordGet,-1,&nFoundPos))
  397.    {
  398.        pnHandle[*pnCount]=m_IndexTable[nPos].pWordItemHead[nFoundPos].nHandle;
  399.    pnFrequency[*pnCount]=m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency;
  400.    *pnCount+=1;
  401. /*    nTemp=nFoundPos-1;//Check its previous position
  402.    while(nTemp>0&&strcmp(m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)==0)
  403.    {
  404.    pnHandle[*pnCount]=m_IndexTable[nPos].pWordItemHead[nTemp].nHandle;
  405.    pnFrequency[*pnCount]=m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency;
  406.    *pnCount+=1;
  407.        nTemp-=1;
  408.    }
  409. */    nTemp=nFoundPos+1;//Check its previous position
  410.    while(nTemp<m_IndexTable[nPos].nCount&&strcmp(m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)==0)
  411.    {
  412.    pnHandle[*pnCount]=m_IndexTable[nPos].pWordItemHead[nTemp].nHandle;
  413.    pnFrequency[*pnCount]=m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency;
  414.    *pnCount+=1;
  415.    nTemp+=1;
  416.    }
  417.    return true;
  418.    }
  419.    //Operation in the index table and its items 
  420.    if(FindInModifyTable(nPos,sWordGet,-1,&pPre))
  421.    {
  422.      pCur=m_pModifyTable[nPos].pWordItemHead;
  423.      if(pPre!=NULL)
  424.  pCur=pPre->next;
  425.          while(pCur!=NULL && _stricmp(pCur->data.sWord,sWordGet)==0)
  426.  {
  427.  pnHandle[*pnCount]=pCur->data.nHandle;
  428.  pnFrequency[*pnCount]=pCur->data.nFrequency;
  429.  *pnCount+=1;
  430.    pCur=pCur->next;
  431.  }
  432.    return true;
  433.    }
  434.    return false;
  435. }
  436. /*********************************************************************
  437.  *
  438.  *  Func Name  : FindInOriginalTable
  439.  *
  440.  *  Description: judge the word and handle exist in the inner table and its items
  441.  *              
  442.  *
  443.  *  Parameters : nInnerCode: the inner code of the first CHines char
  444.  *               sWord: the word
  445.  *               nHandle:the handle number
  446.  *               *nPosRet:the position which node is matched
  447.  *
  448.  *  Returns    : success or fail
  449.  *  Author     : Kevin Zhang  
  450.  *  History    : 
  451.  *              1.create 2002-1-9
  452.  *********************************************************************/
  454. bool CDictionary::FindInOriginalTable(int nInnerCode,char *sWord,int nHandle,int *nPosRet)
  455. {
  456.     PWORD_ITEM pItems=m_IndexTable[nInnerCode].pWordItemHead;
  457. int nStart=0,nEnd=m_IndexTable[nInnerCode].nCount-1,nMid=(nStart+nEnd)/2,nCount=0,nCmpValue;
  458. while(nStart<=nEnd)//Binary search
  459. {
  460.        nCmpValue=strcmp(pItems[nMid].sWord,sWord);
  461.        if(nCmpValue==0&&(pItems[nMid].nHandle==nHandle||nHandle==-1))
  462.    {
  463.    if(nPosRet)
  464.    {
  465.    if(nHandle==-1)//Not very strict match
  466.    {//Add in 2002-1-28
  467.    nMid-=1;
  468.    while(nMid>=0&&strcmp(pItems[nMid].sWord,sWord)==0)
  469.    //Get the first item which match the current word
  470.    nMid--;
  471.                    if(nMid<0||strcmp(pItems[nMid].sWord,sWord)!=0)
  472.    nMid++;
  473.    }
  474.    *nPosRet=nMid;
  475.                return true;   
  476.    }
  477.         if(nPosRet)
  478. *nPosRet=nMid;
  479. return true;//find it
  480.    }
  481.    else if(nCmpValue<0||(nCmpValue==0&&pItems[nMid].nHandle<nHandle&&nHandle!=-1))
  482.    {
  483.    nStart=nMid+1;
  484.    }
  485.    else if(nCmpValue>0||(nCmpValue==0&&pItems[nMid].nHandle>nHandle&&nHandle!=-1))
  486.        {
  487.    nEnd=nMid-1;
  488.    }
  489.    nMid=(nStart+nEnd)/2;
  490. }
  491.     if(nPosRet)
  492. {
  493. //Get the previous position
  494. *nPosRet=nMid-1;
  495. }
  496. return false;
  497. }
  499. /*********************************************************************
  500.  *
  501.  *  Func Name  : FindInModifyTable
  502.  *
  503.  *  Description: judge the word and handle exist in the modified table and its items
  504.  *              
  505.  *
  506.  *  Parameters : nInnerCode: the inner code of the first CHines char
  507.  *               sWord: the word
  508.  *               nHandle:the handle number
  509.  *               *pFindRet: the node found
  510.  *
  511.  *  Returns    : success or fail
  512.  *  Author     : Kevin Zhang  
  513.  *  History    : 
  514.  *              1.create 2002-1-9
  515.  *********************************************************************/
  516. bool CDictionary::FindInModifyTable(int nInnerCode,char *sWord,int nHandle,PWORD_CHAIN *pFindRet)
  517. {
  518.    PWORD_CHAIN pCur,pPre;
  519.    if(m_pModifyTable==NULL)//empty
  520.    return false;
  521.    pCur=m_pModifyTable[nInnerCode].pWordItemHead;
  522.    pPre=NULL;
  523.    while(pCur!=NULL&&(_stricmp(pCur->data.sWord,sWord)<0||(_stricmp(pCur->data.sWord,sWord)==0&&pCur->data.nHandle<nHandle)))
  524.    //sort the link chain as alphabet
  525.    {
  526.        pPre=pCur;
  527.    pCur=pCur->next;
  528.    }
  529.    if(pFindRet)
  530.      *pFindRet=pPre;
  531.    if(pCur!=NULL && _stricmp(pCur->data.sWord,sWord)==0&&(pCur->data.nHandle==nHandle||nHandle<0))
  532.    {//The node exists, delete the node and return 
  533.    return true;
  534.    }
  535.    return false;
  536. }
  537. /*********************************************************************
  538.  *
  539.  *  Func Name  : GetWordType
  540.  *
  541.  *  Description: Get the type of word
  542.  *              
  543.  *
  544.  *  Parameters : sWord: the word
  546.  *  Returns    : the type
  547.  *  Author     : Kevin Zhang  
  548.  *  History    : 
  549.  *              1.create 2002-1-9
  550.  *********************************************************************/
  551. int CDictionary::GetWordType(char *sWord)
  552. {
  553.    int nType=charType((unsigned char *)sWord),nLen=strlen(sWord);
  554.    if(nLen>0&&nType==CT_CHINESE&&IsAllChinese((unsigned char *)sWord))
  555.    return WT_CHINESE;//Chinese word
  556.    else if(nLen>0&&nType==CT_DELIMITER)
  557.        return WT_DELIMITER;//Delimiter
  558.    else
  559.    return WT_OTHER;//other invalid
  560. }
  561. /*********************************************************************
  562.  *
  563.  *  Func Name  : PreProcessing
  564.  *
  565.  *  Description: Get the type of word
  566.  *              
  567.  *
  568.  *  Parameters : sWord: the word
  570.  *  Returns    : the type
  571.  *  Author     : Kevin Zhang  
  572.  *  History    : 
  573.  *              1.create 2002-1-9
  574.  *********************************************************************/
  575. bool CDictionary::PreProcessing(char *sWord, int *nId, char *sWordRet,bool bAdd)
  576. {
  577.    //Position for the delimeters
  578.    int nType=charType((unsigned char *)sWord),nLen=strlen(sWord);
  579.    int nEnd=nLen-1,nBegin=0;
  580.    if(nLen==0)
  581.    return false;
  582.    while(nEnd>=0&&sWord[nEnd]==' ')
  583. nEnd-=1;
  584.    while(nBegin<=nEnd&&sWord[nBegin]==' ')
  585. nBegin+=1;
  586.    if(nBegin>nEnd)
  587.    return false;
  588.    if(nEnd!=nLen-1||nBegin!=0)
  589.    {
  590.    strncpy(sWord,sWord+nBegin,nEnd-nBegin+1);
  591.    sWord[nEnd-nBegin+1]=0;
  592.    }
  593. /*
  594.    if((bAdd||strlen(sWord)>4)&&IsAllChineseNum(sWord))
  595.    {  //Only convert the Chinese Num to 3755 while 
  596.       //Get the inner code of the first Chinese Char
  597.        strcpy(sWord,"五十八");
  598.    }
  599. */   
  600.    if(nType==CT_CHINESE)//&&IsAllChinese((unsigned char *)sWord)
  601.    {//Chinese word
  602.    *nId=CC_ID(sWord[0],sWord[1]);
  603.    //Get the inner code of the first Chinese Char
  604. strcpy(sWordRet,&sWord[2]);//store the word,not store the first Chinese Char
  605. return true;
  606.    }
  607. /* if(nType==CT_NUM&&IsAllNum((unsigned char *)sWord))
  608.    {
  609.    *nId=3756;
  610.        //Get the inner code of the first Chinese Char
  611.        sWordRet[0]=0;//store the word,not store the first Chinese Char
  612.    return true;
  613.    }
  614. */ if(nType==CT_DELIMITER)
  615.    {//Delimiter
  616.    *nId=3755;
  617.        //Get the inner code of the first Chinese Char
  618.        strcpy(sWordRet,sWord);//store the word,not store the first Chinese Char
  619.    return true;
  620.    }
  621. /*
  622.    if(nType==CT_LETTER&&IsAllLetter((unsigned char *)sWord))
  623.    {
  624.    *nId=3757;
  625.        //Get the inner code of the first Chinese Char
  626.        sWordRet[0]=0;//store the word,not store the first Chinese Char
  627.    return true;
  628.    }
  629.    if(nType==CT_SINGLE&&IsAllSingleByte((unsigned char *)sWord))
  630.    {
  631.    *nId=3758;
  632.        //Get the inner code of the first Chinese Char
  633.        sWordRet[0]=0;//store the word,not store the first Chinese Char
  634.    return true;
  635.    }
  636.    if(nType==CT_INDEX&&IsAllIndex((unsigned char *)sWord))
  637.    {
  638.    *nId=3759;
  639.        //Get the inner code of the first Chinese Char
  640.        sWordRet[0]=0;//store the word,not store the first Chinese Char
  641.    return true;
  642.    }
  643. */
  644.    return false;//other invalid
  645. }
  646. /*********************************************************************
  647.  *
  648.  *  Func Name  : MergePOS
  649.  *
  650.  *  Description: Merge all the POS into nHandle,
  651.  *              just get the word in the dictionary and set its Handle as nHandle
  652.  *              
  653.  *
  654.  *  Parameters : nHandle: the only handle which will be attached to the word
  656.  *  Returns    : the type
  657.  *  Author     : Kevin Zhang  
  658.  *  History    : 
  659.  *              1.create 2002-1-21
  660.  *********************************************************************/
  661. bool CDictionary::MergePOS(int nHandle)
  662. {
  663.     int i,j,nCompare;
  664. char sWordPrev[WORD_MAXLENGTH];
  665. PWORD_CHAIN pPre,pCur,pTemp;
  666.     if(!m_pModifyTable)//Not prepare the buffer
  667.     {
  668.    m_pModifyTable=new MODIFY_TABLE[CC_NUM];
  669.    memset(m_pModifyTable,0,CC_NUM*sizeof(MODIFY_TABLE));
  670.     }
  671. for( i=0;i<CC_NUM;i++)//Operation in the index table
  672. {//delete the memory of word item array in the dictionary
  673. sWordPrev[0]=0;//Set empty
  674. for(j=0;j<m_IndexTable[i].nCount;j++)
  675. {
  676. nCompare=_stricmp(sWordPrev,m_IndexTable[i].pWordItemHead[j].sWord);
  677.             if((j==0||nCompare<0)&&m_IndexTable[i].pWordItemHead[j].nFrequency!=-1)
  678. {//Need to modify its handle
  679.     m_IndexTable[i].pWordItemHead[j].nHandle=nHandle;//Change its handle
  680. strcpy(sWordPrev,m_IndexTable[i].pWordItemHead[j].sWord);//Refresh previous Word
  681. }
  682. else if(nCompare==0&&m_IndexTable[i].pWordItemHead[j].nFrequency!=-1)
  683. {//Need to delete when not delete and same as previous word
  684. m_IndexTable[i].pWordItemHead[j].nFrequency=-1;//Set delete flag
  685. m_pModifyTable[i].nDelete+=1;//Add the number of being deleted
  686. }
  687. }
  688. }
  689. for( i=0;i<CC_NUM;i++)//Operation in the modify table
  690. {
  691.  pPre=NULL;
  692.      pCur=m_pModifyTable[i].pWordItemHead;
  693.  sWordPrev[0]=0;//Set empty
  694.          while(pCur!=NULL)
  695.  {
  696.  if(_stricmp(pCur->data.sWord,sWordPrev)>0)
  697.  {//The new word
  698. pCur->data.nHandle=nHandle;//Chang its handle
  699. strcpy(sWordPrev,pCur->data.sWord);//Set new previous word
  700. pPre=pCur;//New previous pointer
  701. pCur=pCur->next;
  702.  }
  703.  else
  704.  {//The same word as previous,delete it.
  705.  pTemp=pCur;
  706.       if(pPre!=NULL)//pCur is the first item
  707.  pPre->next=pCur->next;
  708.  else
  709.  m_pModifyTable[i].pWordItemHead=pCur->next;
  710.  pCur=pCur->next;
  711.    delete pTemp->data.sWord;//Delete the word
  712.  delete pTemp;//Delete the item
  713.  }
  714.  }
  715.    }
  716. return true;
  717. }
  718. /*********************************************************************
  719.  *
  720.  *  Func Name  : GetMaxMatch
  721.  *
  722.  *  Description: Get the max match to the word
  723.  *              
  724.  *
  725.  *  Parameters : nHandle: the only handle which will be attached to the word
  727.  *  Returns    : success or fail
  728.  *  Author     : Kevin Zhang  
  729.  *  History    : 
  730.  *              1.create 2002-1-21
  731.  *********************************************************************/
  732. bool CDictionary::GetMaxMatch(char *sWord, char *sWordRet,int *npHandleRet)
  733. {
  734.    char sWordGet[WORD_MAXLENGTH-2],sFirstChar[3];
  735.    int nPos,nFoundPos,nTemp;
  736.    PWORD_CHAIN pCur;
  737.    *npHandleRet=-1;
  738.    if(!PreProcessing(sWord, &nPos,sWordGet))
  739.    return false;
  740.    sWordRet[0]=0;
  741.    strncpy(sFirstChar,sWord,strlen(sWord)-strlen(sWordGet));//Get the first char
  742.    sFirstChar[strlen(sWord)-strlen(sWordGet)]=0;//Set the end flag
  743.    FindInOriginalTable(nPos,sWordGet,-1,&nFoundPos);
  744.    nTemp=nFoundPos;//Check its previous position
  745.    if(nFoundPos==-1)
  746. nTemp=0;
  747.    while(nTemp<m_IndexTable[nPos].nCount&&CC_Find(m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)!=m_IndexTable[nPos].pWordItemHead[nTemp].sWord)
  748.    {//Get the next
  749.    nTemp+=1;
  750.    }
  751.    if(nTemp<m_IndexTable[nPos].nCount&&CC_Find(m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)==m_IndexTable[nPos].pWordItemHead[nTemp].sWord)
  752.    {
  753.    strcpy(sWordRet,sFirstChar);
  754.    strcat(sWordRet,m_IndexTable[nPos].pWordItemHead[nTemp].sWord);
  755.    *npHandleRet=m_IndexTable[nPos].pWordItemHead[nTemp].nHandle;
  756.    return true;
  757.    }//Cannot get the item and retrieve the modified data if exists
  758.     //Operation in the index table and its items 
  759.    if(m_pModifyTable&&m_pModifyTable[nPos].pWordItemHead)//Exists 
  760.    pCur=m_pModifyTable[nPos].pWordItemHead;
  761.    else
  762.    pCur=NULL;
  763.    while(pCur!=NULL&&strcmp(pCur->data.sWord,sWordGet)<=0&&CC_Find(pCur->data.sWord,sWordGet)!=pCur->data.sWord)//
  764.    {
  765.    pCur=pCur->next;
  766.    }
  767.    if(pCur!=NULL&&CC_Find(pCur->data.sWord,sWordGet)!=pCur->data.sWord)
  768.    {//Get it
  769.    strcpy(sWordRet,sFirstChar);
  770.    strcat(sWordRet,pCur->data.sWord);
  771.    *npHandleRet=pCur->data.nHandle;
  772.    return true;
  773.    }
  774.    return false;
  775. }
  776. /*********************************************************************
  777.  *
  778.  *  Func Name  : GetPOSValue
  779.  *
  780.  *  Description: Get the POS value according the POS string
  781.  *              
  782.  *
  783.  *  Parameters : 
  785.  *  Returns    : the value
  786.  *  Author     : Kevin Zhang  
  787.  *  History    : 
  788.  *              1.create 2002-1-29
  789.  *********************************************************************/
  790. int CDictionary::GetPOSValue(char *sPOS)
  791. {
  792. int nPOS;
  793. char *sPlusPos,sTemp[4];
  794. if(strlen(sPOS)<3)
  795. {
  796. nPOS=sPOS[0]*256+sPOS[1];
  797. }
  798. else
  799. {
  800. sPlusPos=strchr(sPOS,'+');
  801. strncpy(sTemp,sPOS,sPlusPos-sPOS);
  802. sTemp[sPlusPos-sPOS]=0;
  803.         nPOS=100*GetPOSValue(sTemp);
  804. strncpy(sTemp,sPlusPos+1,4);
  805.         nPOS+=atoi(sTemp);
  806. }
  807. return nPOS;
  808. }
  809. /*********************************************************************
  810.  *
  811.  *  Func Name  : GetPOSString
  812.  *
  813.  *  Description: Get the POS string according the POS value
  814.  *              
  815.  *
  816.  *  Parameters : 
  818.  *  Returns    : success or fail
  819.  *  Author     : Kevin Zhang  
  820.  *  History    : 
  821.  *              1.create 2002-1-29
  822.  *********************************************************************/
  823. bool CDictionary::GetPOSString(int nPOS, char *sPOSRet)
  824. {
  825.     if(nPOS>'a'*25600) 
  826. {
  827. if((nPOS/100)%256!=0)
  828.   sprintf(sPOSRet,"%c%c+%d",nPOS/25600,(nPOS/100)%256,nPOS%100);
  829. else
  830. sprintf(sPOSRet,"%c+%d",nPOS/25600,nPOS%100);
  831. }
  832. else
  833. {
  834.   if(nPOS>256)
  835. sprintf(sPOSRet,"%c%c",nPOS/256,nPOS%256);
  836.   else
  837. sprintf(sPOSRet,"%c",nPOS%256);
  838. }
  839. return true;
  840. }
  842. int CDictionary::GetFrequency(char *sWord, int nHandle)
  843. {
  844.    char sWordFind[WORD_MAXLENGTH-2];
  845.    int nPos,nIndex;
  846.    PWORD_CHAIN pFound;
  847.    if(!PreProcessing(sWord, &nPos,sWordFind))
  848.    return 0;
  849.    if(FindInOriginalTable(nPos,sWordFind,nHandle,&nIndex))
  850.    {
  851. return m_IndexTable[nPos].pWordItemHead[nIndex].nFrequency;
  852.    }
  853.    if(FindInModifyTable(nPos,sWordFind,nHandle,&pFound))
  854.    {
  855.    return pFound->data.nFrequency;
  856.    }
  857.    return 0;
  858. }
  860. bool CDictionary::Output(char *sFilename)
  861. {
  862.    FILE *fp;
  863.    int i,j;
  864.    PWORD_CHAIN pCur;
  865.    char sPrevWord[WORD_MAXLENGTH]="", sCurWord[WORD_MAXLENGTH],sPOS[10];
  866.    if((fp=fopen(sFilename,"wb"))==NULL)
  867.    return false;//fail while opening the file
  868.    if(m_pModifyTable)
  869.    {//Modification made, not to output when modify table exists.
  870.    return false;
  871.    }   
  872.    for(i=0;i<CC_NUM;i++)
  873.    {
  874.    pCur=NULL;
  875.        j=0;  
  876.    while(j<m_IndexTable[i].nCount)
  877.    {
  878.  GetPOSString(m_IndexTable[i].pWordItemHead[j].nHandle,sPOS);
  879.  //Get the POS string
  880.  sprintf(sCurWord,"%c%c%s",CC_CHAR1(i),CC_CHAR2(i),m_IndexTable[i].pWordItemHead[j].sWord);
  881.          if(strcmp(sPrevWord,sCurWord)!=0)
  882.  fprintf(fp,"n%s %s",sCurWord,sPOS);
  883.  else
  884.  fprintf(fp," %s",sPOS);
  885.  strcpy(sPrevWord,sCurWord);
  886.    j+=1;//Get next item in the original table.
  887.    }
  888.    }
  889.    fclose(fp);
  890.    return true;
  891. }