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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 查看源码
Dictionary.cpp
资源名称：TextClassify.rar　[点击查看]
上传用户：sanxfzhen
上传日期：2014-12-28
资源大小：2324k
文件大小：33k
源码类别：

多国语言处理

开发平台：

Visual C++

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