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

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

多国语言处理

开发平台：

C/C++

Utility.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: Utility.c
  14.  * Abstract:
  15.  *           Utility functions for Chinese Language Processing
  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 "Utility.h"
  25. #include <stdio.h>
  26. #include <string.h>
  27. /*********************************************************************
  28.  *
  29.  *  Func Name  : GB2312_Generate
  30.  *
  31.  *  Description:  Generate the GB2312 List file
  32.  *              
  33.  *
  34.  *  Parameters : sFilename: the file name for the output GB2312 List
  35.  *    
  36.  *  Returns    : bool
  37.  *  Author     : Kevin Zhang  
  38.  *  History    : 
  39.  *              1.create 2002-1-8
  40.  *********************************************************************/
  41. bool GB2312_Generate(char *sFileName)
  42. {
  43.    FILE *fp;
  44.    unsigned int i,j;
  46.    if((fp=fopen(sFileName,"wt"))==NULL)
  47.    return false;//fail while opening the file
  48.    for(i=161;i<255;i++)
  49.    for(j=161;j<255;j++)
  50.    fprintf(fp,"%c%c,%d,%dn",i,j,i,j);
  51.    fclose(fp);
  52.    return true;
  53. }
  54. /*********************************************************************
  55.  *
  56.  *  Func Name  : CC_Generate
  57.  *
  58.  *  Description:  Generate the Chinese Char List file
  59.  *              
  60.  *
  61.  *  Parameters : sFilename: the file name for the output CC List
  62.  *    
  63.  *  Returns    : bool
  64.  *  Author     : Kevin Zhang  
  65.  *  History    : 
  66.  *              1.create 2002-1-8
  67.  *********************************************************************/
  68. bool CC_Generate(char *sFileName)
  69. {
  70.    FILE *fp;
  71.    unsigned int i,j;
  72.    if((fp=fopen(sFileName,"wt"))==NULL)
  73.    return false;//fail while opening the file
  74.    for(i=176;i<255;i++)
  75.    for(j=161;j<255;j++)
  76.    fprintf(fp,"%c%c,%d,%dn",i,j,i,j);
  77.    fclose(fp);
  78.    return true;
  79. }
  80. /*********************************************************************
  81.  *
  82.  *  Func Name  : CC_Find
  83.  *
  84.  *  Description: Find a Chinese sub-string in the Chinese String 
  85.  *              
  86.  *
  87.  *  Parameters :  string:Null-terminated string to search
  88.  *
  89.  *        strCharSet:Null-terminated string to search for
  90.  *
  91.  *  Returns    : char *
  92.  *  Author     : Kevin Zhang  
  93.  *  History    : 
  94.  *              1.create 2002-1-8
  95.  *********************************************************************/
  96. char *CC_Find(const char *string, const char *strCharSet)
  97. {
  98.    char *cp=strstr(string,strCharSet);
  99.    if(cp!=NULL&&(cp-string)%2==1)
  100.    {
  101.   return NULL;
  102.    }
  103.    return cp;
  104. }
  105. /*********************************************************************
  106.  *
  107.  *  Func Name  : charType
  108.  *
  109.  *  Description: Judge the type of sChar or (sChar,sChar+1)
  110.  *              
  111.  *
  112.  *  Parameters : sFilename: the file name for the output CC List
  113.  *    
  114.  *  Returns    : int : the type of char
  115.  *  Author     : Kevin Zhang  
  116.  *  History    : 
  117.  *              1.create 2002-1-8
  118.  *********************************************************************/
  119. int charType(unsigned char *sChar)
  120. {
  121.   if(*sChar<128)
  122.   {
  123.  if(strchr("42!,.?()[]{}+=",(int)*sChar))
  124.  return CT_DELIMITER;
  125.  return CT_SINGLE;
  126.   }
  127.   else if(*sChar==162)
  128.   return CT_INDEX;
  129.   else if(*sChar==163&&*(sChar+1)>175&&*(sChar+1)<186)
  130.   return CT_NUM;
  131.   else if(*sChar==163&&(*(sChar+1)>=193&&*(sChar+1)<=218||*(sChar+1)>=225&&*(sChar+1)<=250))
  132.   return CT_LETTER;
  133.   else if(*sChar==161||*sChar==163)
  134.   return CT_DELIMITER;
  135.   else if(*sChar>=176&&*sChar<=247)
  136.       return CT_CHINESE;
  137.   else
  138.       return CT_OTHER;
  139. }
  140. /*********************************************************************
  141.  *
  142.  *  Func Name  : GetCCPrefix
  143.  *
  144.  *  Description: Get the max Prefix string made up of Chinese Char
  145.  *              
  146.  *
  147.  *  Parameters : sSentence: the original sentence which includes Chinese or Non-Chinese char
  148.  *    
  149.  *  Returns    : the end of the sub-sentence
  150.  *  Author     : Kevin Zhang  
  151.  *  History    : 
  152.  *              1.create 2002-1-8
  153.  *********************************************************************/
  154. unsigned int  GetCCPrefix(unsigned char *sSentence)
  155. {
  156.    unsigned int nLen=strlen((const char *)sSentence),nCurPos=0;
  157.    while(nCurPos<nLen&&sSentence[nCurPos]>175&&sSentence[nCurPos]<248)
  158.    {
  159.       nCurPos+=2;//Get next Chinese Char
  160.    }
  161.    return nCurPos;
  162. }
  163. /*********************************************************************
  164.  *
  165.  *  Func Name  : IsAllSingleByte
  166.  *
  167.  *  Description: Judge the string is all made up of Single Byte Char
  168.  *              
  169.  *
  170.  *  Parameters : sSentence: the original sentence which includes Chinese or Non-Chinese char
  171.  *    
  172.  *  Returns    : the end of the sub-sentence
  173.  *  Author     : Kevin Zhang  
  174.  *  History    : 
  175.  *              1.create 2002-1-24
  176.  *********************************************************************/
  177. bool IsAllChinese(unsigned char *sString)
  178. {
  179. unsigned int nLen=strlen((const char *)sString),i=0;
  180. while(i<nLen-1&&sString[i]<248&&sString[i]>175)
  181. {
  182. i+=2;
  183. }
  184. if(i<nLen)
  185. return false;
  186. return true;
  187. }
  188. /*********************************************************************
  189.  *
  190.  *  Func Name  : IsAllNonChinese
  191.  *
  192.  *  Description: Judge the string is all made up of Single Byte Char
  193.  *              
  194.  *
  195.  *  Parameters : sSentence: the original sentence which includes Chinese or Non-Chinese char
  196.  *    
  197.  *  Returns    : the end of the sub-sentence
  198.  *  Author     : Kevin Zhang  
  199.  *  History    : 
  200.  *              1.create 2002-1-24
  201.  *********************************************************************/
  202. bool IsAllNonChinese(unsigned char *sString)
  203. {
  204. unsigned int nLen=strlen((const char *)sString),i=0;
  205. while(i<nLen)
  206. {
  207. if(sString[i]<248&&sString[i]>175)
  208. return false;
  209. if(sString[i]>128)
  210. i+=2;
  211. else
  212. i+=1;
  213. }
  214.     return true;
  215. }
  216. /*********************************************************************
  217.  *
  218.  *  Func Name  : IsAllSingleByte
  219.  *
  220.  *  Description: Judge the string is all made up of Single Byte Char
  221.  *              
  222.  *
  223.  *  Parameters : sSentence: the original sentence which includes Chinese or Non-Chinese char
  224.  *    
  225.  *  Returns    : the end of the sub-sentence
  226.  *  Author     : Kevin Zhang  
  227.  *  History    : 
  228.  *              1.create 2002-1-24
  229.  *********************************************************************/
  230. bool IsAllSingleByte(unsigned char *sString)
  231. {
  232. unsigned int nLen=strlen((const char *)sString),i=0;
  233. while(i<nLen&&sString[i]<128)
  234. {
  235. i++;
  236. }
  237. if(i<nLen)
  238. return false;
  239. return true;
  240. }
  241. /*********************************************************************
  242.  *
  243.  *  Func Name  : IsAllNum
  244.  *
  245.  *  Description: Judge the string is all made up of Num Char
  246.  *              
  247.  *
  248.  *  Parameters : sSentence: the original sentence which includes Chinese or Non-Chinese char
  249.  *    
  250.  *  Returns    : the end of the sub-sentence
  251.  *  Author     : Kevin Zhang  
  252.  *  History    : 
  253.  *              1.create 2002-1-24
  254.  *********************************************************************/
  255. bool IsAllNum(unsigned char *sString)
  256. {
  257. unsigned int nLen=strlen((const char *)sString),i=0;
  258. char sChar[3];
  259. sChar[2]=0;
  260. if(i<nLen)//Get prefix such as + -
  261. {
  262. sChar[0]=sString[i++];
  263. if(sChar[0]<0)//Get first char
  264. sChar[1]=sString[i++];
  265. else
  266. sChar[1]=0;
  267. if(!strstr("±+—-＋",sChar))
  268. {
  269. i=0;
  270. }
  271. }
  272. while(i<nLen-1&&sString[i]==163&&sString[i+1]>175&&sString[i+1]<186)
  273. {
  274. i+=2;
  275. }
  276. if(i<nLen)//Get middle delimiter such as .
  277. {
  278. sChar[0]=sString[i++];
  279. if(sChar[0]<0)//Get first char
  280. sChar[1]=sString[i++];
  281. else
  282. sChar[1]=0;
  283. if(CC_Find("∶·．",sChar)||sChar[0]=='.')
  284. {//98．1％
  285. while(i<nLen-1&&sString[i]==163&&sString[i+1]>175&&sString[i+1]<186)
  286. {
  287. i+=2;
  288. }
  289. }
  290. else
  291. {
  292. i-=strlen(sChar);
  293. }
  294. }
  296. if(i>=nLen)
  297. return true;
  298. while(i<nLen&&sString[i]>'0'-1&&sString[i]<'9'+1)
  299. {//single byte number char
  300. i+=1;
  301. }
  302. if(i<nLen)//Get middle delimiter such as .
  303. {
  304. sChar[0]=sString[i++];
  305. if(sChar[0]<0)//Get first char
  306. sChar[1]=sString[i++];
  307. else
  308. sChar[1]=0;
  309. if(CC_Find("∶·．",sChar)||sChar[0]=='.')
  310. {//98．1％
  311. while(i<nLen&&sString[i]>'0'-1&&sString[i]<'9'+1)
  312. {
  313. i+=1;
  314. }
  315. }
  316. else
  317. {
  318. i-=strlen(sChar);
  319. }
  320. }
  321. if(i<nLen)//Get middle delimiter such as .
  322. {
  323. sChar[0]=sString[i++];
  324. if(sChar[0]<0)//Get first char
  325. sChar[1]=sString[i++];
  326. else
  327. sChar[1]=0;
  328. if(!CC_Find("百千万亿佰仟％‰",sChar)&&sChar[0]!='%')
  329. i-=strlen(sChar);
  330. }
  331. if(i>=nLen)
  332. return true;
  333. return false;
  334. }
  335. /*********************************************************************
  336.  *
  337.  *  Func Name  : IsAllIndex
  338.  *
  339.  *  Description: Judge the string is all made up of Index Num Char
  340.  *              
  341.  *
  342.  *  Parameters : sSentence: the original sentence which includes Chinese or Non-Chinese char
  343.  *    
  344.  *  Returns    : the end of the sub-sentence
  345.  *  Author     : Kevin Zhang  
  346.  *  History    : 
  347.  *              1.create 2002-1-24
  348.  *********************************************************************/
  349. bool IsAllIndex(unsigned char *sString)
  350. {
  351. unsigned int nLen=strlen((const char *)sString),i=0;
  352. while(i<nLen-1&&sString[i]==162)
  353. {
  354. i+=2;
  355. }
  356. if(i>=nLen)
  357. return true;
  358.  while(i<nLen&&(sString[i]>'A'-1&&sString[i]<'Z'+1)||(sString[i]>'a'-1&&sString[i]<'z'+1))
  359.  {//single byte number char
  360. i+=1;
  361.  }
  363. if(i<nLen)
  364. return false;
  365. return true;
  367. }
  368. /*********************************************************************
  369.  *
  370.  *  Func Name  : IsAllLetter
  371.  *
  372.  *  Description: Judge the string is all made up of Letter Char
  373.  *              
  374.  *
  375.  *  Parameters : sSentence: the original sentence which includes Chinese or Non-Chinese char
  376.  *    
  377.  *  Returns    : the end of the sub-sentence
  378.  *  Author     : Kevin Zhang  
  379.  *  History    : 
  380.  *              1.create 2002-1-24
  381.  *********************************************************************/
  382. bool IsAllLetter(unsigned char *sString)
  383. {
  384. unsigned int nLen=strlen((const char *)sString),i=0;
  385. while(i<nLen-1&&sString[i]==163&&((sString[i+1]>=193&&sString[i+1]<=218)||(sString[i+1]>=225&&sString[i+1]<=250)))
  386. {
  387. i+=2;
  388. }
  389. if(i<nLen)
  390. return false;
  392. return true;
  393. }
  394. /*********************************************************************
  395.  *
  396.  *  Func Name  : IsAllDelimiter
  397.  *
  398.  *  Description: Judge the string is all made up of Delimiter
  399.  *              
  400.  *
  401.  *  Parameters : sSentence: the original sentence which includes Chinese or Non-Chinese char
  402.  *    
  403.  *  Returns    : the end of the sub-sentence
  404.  *  Author     : Kevin Zhang  
  405.  *  History    : 
  406.  *              1.create 2002-1-24
  407.  *********************************************************************/
  408. bool IsAllDelimiter(unsigned char *sString)
  409. {
  410. unsigned int nLen=strlen((const char *)sString),i=0;
  411. while(i<nLen-1&&(sString[i]==161||sString[i]==163))
  412. {
  413. i+=2;
  414. }
  415. if(i<nLen)
  416. return false;
  417. return true;
  418. }
  419. /*********************************************************************
  420.  *
  421.  *  Func Name  : BinarySearch
  422.  *
  423.  *  Description: Lookup the index of nVal in the table nTable which length is nTableLen
  424.  *
  425.  *  Parameters : nPOS: the POS value
  426.  *
  427.  *  Returns    : the index value
  428.  *  Author     : Kevin Zhang  
  429.  *  History    : 
  430.  *              1.create 2002-1-25
  431.  *********************************************************************/
  432. int BinarySearch(int nVal, int *nTable,int nTableLen)
  433. {
  434. int nStart=0,nEnd=nTableLen-1,nMid=(nStart+nEnd)/2;
  435. while(nStart<=nEnd)//Binary search
  436. {
  437.        if(nTable[nMid]==nVal)
  438.    {
  439. return nMid;//find it
  440.    }
  441.    else if(nTable[nMid]<nVal)
  442.    {
  443.    nStart=nMid+1;
  444.    }
  445.    else
  446.        {
  447.    nEnd=nMid-1;
  448.    }
  449.    nMid=(nStart+nEnd)/2;
  450. }
  451. return -1;//Can not find it;
  452. }
  453. /*********************************************************************
  454.  *
  455.  *  Func Name  : IsForeign
  456.  *
  457.  *  Description: Decide whether the word is not a Non-fereign word
  458.  *
  459.  *  Parameters : sWord: the word
  460.  *
  461.  *  Returns    : the index value
  462.  *  Author     : Kevin Zhang  
  463.  *  History    : 
  464.  *              1.create 2002-1-26
  465.  *********************************************************************/
  466. bool IsForeign(char *sWord)
  467. {
  468.   int nForeignCount=GetForeignCharCount(sWord),nCharCount=strlen(sWord);
  469.   if(nCharCount>2||nForeignCount>=1*nCharCount/2)
  470.   return true;
  471.   return false;
  472. }
  473. /*********************************************************************
  474.  *
  475.  *  Func Name  : IsAllForeign
  476.  *
  477.  *  Description: Decide whether the word is not a Non-fereign word
  478.  *
  479.  *  Parameters : sWord: the word
  480.  *
  481.  *  Returns    : the index value
  482.  *  Author     : Kevin Zhang  
  483.  *  History    : 
  484.  *              1.create 2002-3-25
  485.  *********************************************************************/
  486. bool IsAllForeign(char *sWord)
  487. {
  488.   unsigned int nForeignCount=(unsigned int)GetForeignCharCount(sWord);
  489.   if(2*nForeignCount==strlen(sWord))
  490.   return true;
  491.   return false;
  492. }
  493. /*********************************************************************
  494.  *
  495.  *  Func Name  : IsForeign
  496.  *
  497.  *  Description: Decide whether the word is Chinese Num word
  498.  *
  499.  *  Parameters : sWord: the word
  500.  *
  501.  *  Returns    : the index value
  502.  *  Author     : Kevin Zhang  
  503.  *  History    : 
  504.  *              1.create 2002-1-26
  505.  *********************************************************************/
  506. bool IsAllChineseNum(char *sWord)
  507. {//百分之五点六的人早上八点十八分起床
  508.   unsigned int  k; 
  509.   char tchar[3];
  510.   char ChineseNum[]="零○一二三四五六七八九十廿百千万亿壹贰叁肆伍陆柒捌玖拾佰仟∶·．／点";//
  511.   char sPrefix[]="几第数两";
  512.   for(k = 0; k < strlen(sWord); k+=2)
  513.   {
  514.      strncpy(tchar,sWord+k,2) ;
  515.      tchar[2]='';
  516.  if(strncmp(sWord+k,"分之",4)==0)//百分之五
  517.  {
  518. k+=2;
  519. continue;
  520.  }
  522.  if(!CC_Find(ChineseNum, tchar)&&!(k==0&&CC_Find(sPrefix, tchar)))
  523.  return false;
  524.   }
  525.   return true;
  526. }
  527. /*********************************************************************
  528.  *
  529.  *  Func Name  : GetForeignCharCount
  530.  *
  531.  *  Description: 
  532.  *
  533.  *  Parameters : sWord: the word
  534.  *
  535.  *  Returns    : the index value
  536.  *  Author     : Kevin Zhang  
  537.  *  History    : 
  538.  *              1.create 2002-4-4
  539.  *              2.Modify  2002-5-21
  540.  *********************************************************************/
  541. int GetForeignCharCount(char *sWord)
  542. {
  543.   unsigned int nForeignCount,nCount;
  544.   nForeignCount=GetCharCount(TRANS_ENGLISH,sWord);//English char counnts
  545.   nCount=GetCharCount(TRANS_JAPANESE,sWord);//Japan char counnts
  546.   if(nForeignCount<=nCount)
  547. nForeignCount=nCount;
  548.   nCount=GetCharCount(TRANS_RUSSIAN,sWord);//Russian char counnts
  549.   if(nForeignCount<=nCount)
  550. nForeignCount=nCount;
  551.   return nForeignCount;
  552. }
  553. /*********************************************************************
  554.  *
  555.  *  Func Name  : GetCharCount
  556.  *
  557.  *  Description: Get the count of char which is in sWord and in sCharSet
  558.  *
  559.  *  Parameters : sWord: the word
  560.  * 
  561.  *  Returns    : COUNT
  562.  *  Author     : Kevin Zhang  
  563.  *  History    : 
  564.  *              1.create 2002-5-21
  565.  *********************************************************************/
  566. int GetCharCount(char *sCharSet,char *sWord)
  567. {
  568.   unsigned int  k; 
  569.   char tchar[3];
  570.   int nCount=0,nCharCount=0;
  571.   for (k = 0; k < strlen(sWord); k+=2)
  572.   {
  573.      while(k < strlen(sWord)&&sWord[k]>0)
  574.  k++;
  575.      strncpy(tchar,sWord+k,2) ;
  576.      tchar[2]='';
  577.  nCharCount++;
  578.  if(CC_Find(sCharSet, tchar))
  579.           nCount++;
  580.   }
  581.   return nCount;
  582. }
  583. /*********************************************************************
  584.  *
  585.  *  Func Name  : GetForeignCharCount
  586.  *
  587.  *  Description: Return the foreign type 
  588.  *
  589.  *  Parameters : sWord: the word
  590.  *
  591.  *  Returns    : the index value
  592.  *  Author     : Kevin Zhang  
  593.  *  History    : 
  594.  *              1.create 2002-4-4
  595.  *              2.Modify  2002-5-21
  596.  *********************************************************************/
  597. int GetForeignType(char *sWord)
  598. {
  599.   unsigned int nForeignCount,nCount,nType=TT_ENGLISH;
  600.   nForeignCount=GetCharCount(TRANS_ENGLISH,sWord);//English char counnts
  601.   nCount=GetCharCount(TRANS_RUSSIAN,sWord);//Russian char counnts
  602.   if(nForeignCount<nCount)
  603.   {
  604.   nForeignCount=nCount;
  605.   nType=TT_RUSSIAN;
  606.   }
  607.   nCount=GetCharCount(TRANS_JAPANESE,sWord);//Japan char counnts
  608.   if(nForeignCount<nCount)
  609.   {
  610.   nForeignCount=nCount;
  611.   nType=TT_JAPANESE;
  612.   }
  613.   return nType;
  614. }
  615. bool PostfixSplit(char *sWord, char *sWordRet, char *sPostfix)
  616. {
  617. char sSinglePostfix[]=POSTFIX_SINGLE;
  618. char sMultiPostfix[][9]=POSTFIX_MUTIPLE;
  619. unsigned int nPostfixLen=0,nWordLen=strlen(sWord);
  620. int i=0;
  622. while(sMultiPostfix[i][0]!=0&&strncmp(sWord+nWordLen-strlen(sMultiPostfix[i]),sMultiPostfix[i],strlen(sMultiPostfix[i]))!=0)
  623. {//Try to get the postfix of an address
  624. i++;
  625. }
  626. strcpy(sPostfix,sMultiPostfix[i]);
  627. nPostfixLen=strlen(sMultiPostfix[i]);//Get the length of place postfix
  629. if(nPostfixLen==0)
  630. {
  631. sPostfix[2]=0;
  632. strncpy(sPostfix,sWord+nWordLen-2,2);
  633. if(CC_Find(sSinglePostfix,sPostfix))
  634. nPostfixLen=2;
  635. }
  637. strncpy(sWordRet,sWord,nWordLen-nPostfixLen);
  638. sWordRet[nWordLen-nPostfixLen]=0;//Get the place name which have erasing the postfix
  639. sPostfix[nPostfixLen]=0;
  640.     return true;
  641. }