抓取网页(3)之部分工程文件

1.文字格式转码文件(DataInfo)

    1.1  gbk_unicode.idx


   1.2   gbk_utf.idx

2.lyParseUtil文件夹

  2.1 lyParseUtil.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include "lyFileUtil.h"
#include "../lyPublic.h"
#include "../lySQL.h"
#include "../lyString.h"

int ExactSameMatchFunc(const char *szSource,const char *szFileSource,char szUserData[], int iDataSize, int *iSubPos);
int ExactMatchFunc(const char *szSource,const char *szFileSource,int iType,char szUserData[], int iDataSize, int *iSubPos);
int PartialMatchFunc(const char *szSource,const char *szFileSource,int iType,char szUserData[], int iDataSize, int *iSubPos);
int InclusionMatchFunc(const char *szSource,const char *szFileSource,int iType,char szUserData[], int iDataSize, int *iSubPos);
/*
szSource表示输入内容
szUserData表示用户输出数据:完整的匹配项
iDataSize表示szUserData的大小,
iMatchtype表示匹配类型:0-完全一致匹配 ; 1-精确匹配  ; 2-部分匹配  ; 3-包含匹配
iType表示匹配位置:0--从起始位置,1--从末尾匹配;2--从任意位置匹配
                (Note:当iMatchtype值为4(包含匹配)时,iType:0--选择最先匹配;1--最短匹配;2--最长匹配)
iFileType表示匹配项:0-国家,1-全球城市
iStartPos匹配的起始位置
iSubPos为字串匹配到的位置

若判断出来,返回字符长度
若未判断出来,返回0    (.*)\((.*)\)
分隔符为:||
*/
int IsNeedDataInfo(const char *szSource,char szUserData[], int iDataSize,int iMatchtype,int iType,char * szFileName,int iStartPos, int *iSubPos)
{
    int iSrLen = 0 ;
    char *szFileSource;    //idx源文件
    const char *szPos1;
    int iRetVal = 0;    
    char szFileNameTemp[256]=""; //文件名

    *iSubPos = 0;
    if(!szSource || (int)strlen(szSource) <= iStartPos){  //输入字符串或者起始位置越界
        return -1;
    }
    memset(szUserData, 0, iDataSize);
//    if(strstr(szFileName,"DataInfo"))
        sprintf(szFileNameTemp,"%s",szFileName);
//    else
//        sprintf(szFileNameTemp,"%s%s",LY_DATA_PATH,szFileName);
    szFileSource = ReadFileData(szFileNameTemp); //读取文件  
    if(!szFileSource)
        return -1;

    szPos1 = szSource;
    iSrLen = strlen(szPos1);

    szPos1 += iStartPos; 

    if(iMatchtype == 0){        //完全一致匹配
        iRetVal = ExactSameMatchFunc(szPos1,szFileSource,szUserData,iDataSize, iSubPos);
    }
    else if(iMatchtype == 1){  //精确匹配
        iRetVal = ExactMatchFunc(szPos1,szFileSource,iType,szUserData,iDataSize, iSubPos);         
    }    
    else if(iMatchtype == 2){    //部分匹配
        iRetVal = PartialMatchFunc(szPos1,szFileSource,iType,szUserData,iDataSize, iSubPos);
    }
    else if(iMatchtype == 3){
        iRetVal = InclusionMatchFunc(szPos1, szFileSource, iType, szUserData, iDataSize, iSubPos);
    }
    else
        iRetVal = 0;
    if (szFileSource)
    {
        free(szFileSource);
        szFileSource = NULL;
    }
    //添加匹配位置偏移量
    if(*iSubPos > 0)
        *iSubPos += iStartPos;
    return iRetVal;
}

/*
    函数功能:“完全一致匹配”字符串的关键字。
    参数:szSource-:输入字符串。    
          iType:0--从起始位置,1--从末尾匹配;2--从任意位置匹配。
          szFileSource:文件。
          szUserData:用户输出数据
          iDataSize:用户输出数据的长度
          iSubPos:匹配到的位置
    返回值:大于0--关键字的长度;-1--意外错误;0--找不到关键字
*/
int ExactSameMatchFunc(const char *szSource,const char *szFileSource,char szUserData[], int iDataSize, int *iSubPos)
{
    const char *szPos1,*szPos2;
    char szTemp[512]="";
    int iSrLen;  //输入字符串的长度

    szPos1 = szSource;
    if(!szPos1)
        return -1;

    memset(szUserData, 0 , iDataSize );
    *iSubPos = 0;

    memset(szTemp,0,sizeof(szTemp));
    strcpy(szTemp,"||");
    strcat(szTemp,szPos1);
    strcat(szTemp,"||");

    szPos2 = strstr(szFileSource,szTemp);   //在文件完全一致查找
    if(szPos2){
        iSrLen = strlen(szPos1);
        strcpy(szUserData,szPos1);

        return iSrLen;
    }
    
    return 0;
}

/*
    函数功能:“精确匹配”字符串的关键字。
    参数:szSource-:输入字符串。    
          iType:0--从起始位置,1--从末尾匹配;2--从任意位置匹配。
          szFileSource:文件。
          szUserData:用户输出数据
          iDataSize:用户输出数据的长度
          iSubPos:匹配到的位置
    返回值:大于0--关键字的长度;-1--意外错误;0--找不到关键字
*/
int ExactMatchFunc(const char *szSource,const char *szFileSource,int iType,char szUserData[], int iDataSize, int *iSubPos)
{

    const char *szPos1,*szPos3;
    char szTempUnit[512]="";
    char szTempKeyWord[510]="";   //城市
    int iSrLen = 0 ; // 源字符串的长度
    int iKeyWordLen = 0;  // 城市的长度
    int iRunLen = 0;  //往后走的长度
    int iLeftLen = 0;

    szPos1 = szSource;  
    *iSubPos = 0;
    if(!szPos1)
        return -1;

    memset(szUserData, 0 , iDataSize );

    iSrLen = strlen(szPos1);   //输入字符的长度

    if(iSrLen < 4 || iSrLen >=500)        //   小于4返回-1
        return -1;
    else{                //大于1个长度的时候
    
            iRunLen = 1;
                while(1){
                        
                    //新增:判断是否为汉字
                    if(IsChnSatPos(szPos1,iRunLen) > 0)
                        iRunLen += 1;

                    iLeftLen = iSrLen - iRunLen;    

                    memset(szTempUnit,0,sizeof(szTempUnit));
                    strcat(szTempUnit,"||");
                    memset(szTempKeyWord,0,sizeof(szTempKeyWord));

                    if(iType == 0 || iType == 2)  //从头部开始匹配或者任意位置匹配
                        strncpy(szTempKeyWord,szPos1,iRunLen);

                    else if(iType == 1)    {//从尾部开始匹配
                        strncpy(szTempKeyWord, szPos1 + iSrLen - iRunLen ,  iRunLen );  //把尾部的长度切割给szTempKeyWord    
                    }
                     
                    strcat(szTempUnit,szTempKeyWord);

                    strcat(szTempUnit,"||");
                    iKeyWordLen = strlen(szTempKeyWord);        

                
                    szPos3 = strstr(szFileSource,szTempUnit);  //精确匹配--匹配格式:“|城市名|“
                    if(szPos3)
                    {    
                        //获取匹配到的位置
                        if (iType == 1) //尾部
                        {
                            *iSubPos = iSrLen - iKeyWordLen;
                        }
                        if (iType == 2) //任意位置
                        {
                            *iSubPos = szPos1 - szSource;
                        }
                        strcpy(szUserData,szTempKeyWord);
                        return iKeyWordLen;
                    }    
                    if(iLeftLen < 0)
                        return 0;
                        
                    if(iLeftLen == 0){                    
                        
                        if(iType == 2){

                            if(IsChnSatPos(szPos1,1) > 0)
                                szPos1 += 2; 
                            else
                                szPos1 ++;   //搜索起始位置不断下移1个长度

                            iSrLen = strlen(szPos1);

                            if(iSrLen == 0)            //如果搜索位置到达字符串末尾,则返回0,表示没有搜索到关键字
                                return 0;
                        }
                        else if(iType == 0 || iType == 1)
                            return 0;

                        iRunLen  = 0;
                    }

                    iRunLen ++;        
                            
                }  //while  in
            
    }  //else
}

/*
    函数功能:“部分匹配”字符串的关键字。
    参数:szSource-:输入字符串。    
          iType:0--从起始位置,1--从末尾匹配;2--从任意位置匹配。
          szFileSource:文件。
          szUserData:用户输出数据
          iDataSize:用户输出数据的长度
          iSubPos:匹配到的位置
    返回值:大于0--关键字的长度;-1--意外错误;0--找不到关键字
*/
int PartialMatchFunc(const char *szSource,const char *szFileSource,int iType,char szUserData[], int iDataSize, int *iSubPos)
{
    const char *szPos1,*szPos3,*szPos4,*szPos5;
    char szTempKeyWord[510]="";   
    int iSrLen = 0 ; // 源字符串的长度
    int iKeyWordLen = 0;  // 关键字的长度
    int iRunLen = 0;  //往后走的长度
    int iLeftLen = 0;

    int iTempLen = 0;
    *iSubPos = 0;
    szPos1 = szSource;  
    iSrLen = strlen(szPos1);   //输入字符的长度 

    memset(szUserData , 0 , iDataSize);

    if(iSrLen < 4 || iSrLen >=500)        //   小于4返回-1
        return -1;
    else{                //大于4个长度的时候
    
            iRunLen = 1;
                while(1){
                            
                    //新增:判断是否为汉字
                    if(IsChnSatPos(szPos1,iRunLen) > 0)
                        iRunLen += 1;
                    iLeftLen = iSrLen - iRunLen;    

                    memset(szTempKeyWord,0,sizeof(szTempKeyWord));

                    if(iType == 0 || iType == 2)  //从头部开始匹配或者任意位置匹配
                        strncpy(szTempKeyWord,szPos1,iRunLen);

                    else if(iType == 1)    {//从尾部开始匹配
                        strncpy(szTempKeyWord, szPos1 + iSrLen - iRunLen ,  iRunLen );  //把尾部的长度切割给szTempKeyWord    
                    
                    }
                    iKeyWordLen = strlen(szTempKeyWord);

                    if( IsChnSatPos(szTempKeyWord, 1 ) >0 && (iKeyWordLen % 2 == 0) ){
                    
                        szPos3 = strstr(szFileSource,szTempKeyWord);  //部分匹配--匹配格式:“关键字“
                        if(szPos3){

                            szPos4 = strstr(szPos3,"||");

                            while(1){
                                szPos3 --;
                                szPos5 = strstr(szPos3,"||"); 
                                if(szPos5){
                                    iTempLen = szPos4 - szPos5 - 1;
                                    if(iTempLen>0){
                                        memset(szUserData, 0, iDataSize);
                                        strncpy(szUserData,szPos5 + 2,iTempLen - 1);
                                        break;
                                    }
                                
                                }

                            }
                            //获取匹配到的位置
                            if (iType == 1) //尾部
                            {
                                *iSubPos = iSrLen - iKeyWordLen;
                            }
                            if (iType == 2) //任意位置
                            {
                                *iSubPos = szPos1 - szSource;
                            }
                            return iKeyWordLen;
                        }            
                    }

                    if(iLeftLen == 0){                    
                        
                        if(iType == 2){
                            if(szPos1 - szSource == iSrLen)    //如果搜索位置到达字符串末尾,则返回0,表示没有搜索到关键字
                                return 0;

                            //szPos1 ++;   //搜索起始位置不断下移1个长度
                            if(IsChnSatPos(szPos1,1) > 0)
                                szPos1 += 2; 
                            else
                                szPos1 ++;   //搜索起始位置不断下移1个长度

                            iSrLen = strlen(szPos1);
                        }
                        else if(iType == 0 || iType == 1)
                            return 0;

                        iRunLen  = 3;  
                        while(iRunLen >= iSrLen)
                            iRunLen --;
                    }

                    iRunLen ++;        
                            
                }  //while  in
            
    }  //else

}

/**
    函数功能: 匹配输入字符串中是否包含匹配数据
    参数:szSource-:输入字符串。    
    iType:0--选择最先匹配;1--最短匹配;2--最长匹配
    szFileSource:文件。
    szUserData:用户输出数据
    iDataSize:用户输出数据的长度
    iSubPos:匹配到的位置
    返回值:大于0--关键字的长度;-1--意外错误;0--找不到关键字
**/
int InclusionMatchFunc(const char *szSource,const char *szFileSource,int iType,char szUserData[], int iDataSize, int *iSubPos)
{
    const char *szPos1,*szPos2, *szPos3;
    char szTempKeyWord[510]="";
    char szTempMatchBuff[510] = "";
    int iSrLen = 0 ; // 源字符串的长度
    int iKeyWordLen = 0;  // 关键字的长度
    int iTempLen = 0;
    *iSubPos = 0;
    if(!szSource || !szFileSource)
        return -1;
 
    szPos1 = szFileSource;
    iSrLen = strlen(szSource);   //输入字符的长度 
    memset(szUserData , 0 ,sizeof(szUserData));

    if(iSrLen < 4 || iSrLen >=500)        //   小于4返回-1
        return -1;
    //判断匹配
    while (szPos1)
    {
        szPos2 = strstr(szPos1, "||");
        if (!szPos2)
        {
            memset(szTempKeyWord, 0, sizeof(szTempKeyWord));
            strcpy(szTempKeyWord, szPos1);
            szPos1 = szPos2;
        }
        else
        {
            iTempLen = szPos2 - szPos1;
            memset(szTempKeyWord, 0, sizeof(szTempKeyWord));
            strncpy(szTempKeyWord, szPos1, iTempLen);
            szPos1 = szPos2 + 2;
        }

        if (strlen(szTempKeyWord) > 0)
        {
            szPos3 = strstr(szSource, szTempKeyWord);
            if (szPos3)
            {
                if(strlen(szTempMatchBuff) == 0)
                {
                    strcpy(szTempMatchBuff, szTempKeyWord);
                    *iSubPos = szPos3 - szSource;
                }
                //最短匹配
                if (iType == 1)
                {
                    if (strlen(szTempMatchBuff) > strlen(szTempKeyWord))
                    {
                        strcpy(szTempMatchBuff, szTempKeyWord);
                        *iSubPos = szPos3 - szSource;
                    }
                }
                //最长匹配
                else if (iType == 2)
                {
                    if (strlen(szTempMatchBuff) < strlen(szTempKeyWord))
                    {
                        memset(szTempMatchBuff, 0, sizeof(szTempMatchBuff));
                        strcpy(szTempMatchBuff, szTempKeyWord);
                        *iSubPos = szPos3 - szSource;
                    }
                }
                //默认匹配
                else
                    break;
            }
        }
    }
    //找到匹配
    iKeyWordLen = strlen(szTempMatchBuff);
    if (iKeyWordLen > 0)
    {
        strcpy(szUserData, szTempMatchBuff);
        return iKeyWordLen;
    }
    return 0;
}

/****
    功能:查找是否包含匹配的字串,并提取其关键词
    szSource:输入字符串
    szDest:匹配到的字串所在类别的关键字
    iDestSize:szDest大小
    szFileName:匹配数据存放文件
               格式:[关键词1:字串1|字串2|字串3…][关键词2:字串1|字串2|字串3…]……
    iSubPos:匹配到的位置
    返回值:匹配字串的长度
**/
int GetSubStrFromFile(char *szSource, char *szDest, int iDestSize, char *szFileName, int *iSubPos)
{
    char szFileNameTemp[256] = "";
    char szTemp1[64] = "";
    char szTemp2[512] = "";
    char *szFileInfo, *szPos, *szPos1, *szPos2;
    int iLen, iTemp, iTempPos;

    if(!szSource || !szFileName)
        return 0;
    memset(szDest, 0, iDestSize);
    *iSubPos = 0;
    if(strstr(szFileName,"DataInfo"))
        sprintf(szFileNameTemp,"%s",szFileName);
    else
        sprintf(szFileNameTemp,"%s%s",LY_DATA_PATH,szFileName);
    szFileInfo = ReadFileData(szFileNameTemp);
    if(!szFileInfo)
        return 0;
    szPos = szFileInfo;

    while (1)
    {
        szPos1 = strstr(szPos, "[");
        if(!szPos1)
            break;
        szPos2 = strstr(szPos1 + 1, "]");
        if(!szPos2)
            break;
        iLen = szPos2 - szPos1 - 1;
        if(iLen < 0)
            break;
        szPos = szPos2 + 1;

        memset(szTemp1, 0, sizeof(szTemp1));
        memset(szTemp2, 0, sizeof(szTemp2));
        strncpy(szTemp2, szPos1 + 1, iLen);

        iTemp = GetSubStrPosAndLen(szTemp2, ":", 2, &iTempPos);
        if (iTemp > 0)
        {
            strncpy(szTemp1, szTemp2, iTempPos);
            strcpy(szTemp2, szTemp2 + iTempPos + iTemp);
        }
        iTemp = GetSubStrPosAndLen(szSource, szTemp2, 2, &iTempPos);
        if (iTemp > 0)
        {
            strcpy(szDest, szTemp1);
            *iSubPos = iTempPos;
            free(szFileInfo);
            return iTemp;            
        }
    }
    free(szFileInfo);
    return 0;
}


//根据键值获取数据
//返回值:数据,0-包含获取
int GetValueByKey(char *szSource, char *szFile, int iType,char *szDest, int iDestSize)
{
    const char *szPos1=NULL,*szPos2=NULL;
    char *szFileBuf;
    int iStrLen;
    char szFileName[256]="";
    
    //读取国家+首都文件
    sprintf(szFileName, "%s%s", LY_DATA_PATH,szFile);
    szFileBuf = ReadFileData(szFileName);
    if(!szFileBuf)
        return 0;

    //匹配数据
    szPos1= strstr(szFileBuf,szSource);
    if(!szPos1)
    {
        free(szFileBuf);
        return 0;
    }

    szPos1=strstr(szPos1,":");
    szPos2=strstr(szPos1+1,"|");
    iStrLen=szPos2-szPos1-1;
    szPos1=szPos1+1;
    memset(szDest,0,iDestSize);
    strncat(szDest,szPos1,iStrLen);

    free(szFileBuf);
    return 1;
}


/*
函数功能:“精确匹配”字符串的关键字。
参数:szSource-:输入字符串。
iType: 1--从前往后匹配(三星,先匹配三,再匹配三星),2--从后往前匹配(三星  先匹配三星,再匹配三)
       szFileSource:文件。
       szUserData:用户输出数据
       iDataSize:用户输出数据的长度
       
         数据存储格式为:szStartFlag关键字szEndFlag
        
    返回值:大于0--关键字的位置;-1--意外错误;0--找不到关键字
*/
int GetSubStrPosByMatchFunc(const char *szSource,const char *szFileSource, char *szStartFlag, char *szEndFlag, char szUserData[], int iDataSize,int iType)
{
    const char *szPos1 = NULL, *szPos2 = NULL, *szPos3 = NULL;
    char szTempUnit[512]="";
    char szTempKeyWord[512]="";   //城市
    char szRetKeyTemp[256] = "";
    int iSrLen = 0 ; // 源字符串的长度
    int iKeyWordLen = 0;  // 城市的长度
    int iRunLen = 0;  //往后走的长度
    int iLeftLen = 0;
    int iSubPos = 0;
    int iUserDataLen = 0;
    int iSubPos1 = 0;

    szPos1 = szSource;  

    if(!szPos1)
        return -1;

    memset(szUserData, 0 , iDataSize );

    iSrLen = strlen(szPos1);   //输入字符的长度

    if(iSrLen < 4 || iSrLen >=500)        //   小于4返回-1
        return -1;
        
    if (iType == 1)
    {    
        //如果为1则从开始往全部去匹配
        iRunLen = 1;
    }
    else
    {
        //其他则从全部往开始去匹配
        iRunLen = iSrLen;
    }
        
    while(1)
    {
        //新增:判断是否为汉字
        if(IsChnSatPos(szPos1,iRunLen) > 0)
        {
            if (iType == 1)
            {
                iRunLen += 1;
                iLeftLen = iSrLen - iRunLen;                 
            }
            else
            {
                iRunLen -= 1;
                iLeftLen = iRunLen;
            }
        }
        //iLeftLen为剩余的字数 iRunLen为去匹配的关键字长度
        if(iLeftLen < 0)
        {
            return 0;
        }
        if (iRunLen <= 0)
        {
            return 0;
        }
            
        memset(szTempUnit,0,sizeof(szTempUnit));
        if (szStartFlag)
        {
            strcat(szTempUnit, szStartFlag);
        }

        memset(szTempKeyWord, 0, sizeof(szTempKeyWord));
        strncpy(szTempKeyWord, szPos1, iRunLen);
                     
        strcat(szTempUnit,szTempKeyWord);
            
        if (szEndFlag)
        {
            strcat(szTempUnit, szEndFlag);
        }            
            
        iKeyWordLen = strlen(szTempKeyWord);
            
        szPos3 = strstr(szFileSource,szTempUnit);  //精确匹配--匹配格式:“||名称||“
        if(szPos3)
        {    
            //获取匹配到的位置
            iSubPos = szPos3 - szFileSource;
            memset(szUserData , 0 ,iDataSize);
            strcpy(szUserData, szTempKeyWord);
            return iSubPos;
        }    
            
        if (iType == 1)
        {
            iRunLen ++;
        }
        else
        {
            iRunLen --;
        }    
    }  

    return 0;
}
/****
    功能:从字符串的一个位置开始,到一个位置结束点中获取最后一个 关键字(改关键字被  szStartFlag开始,szEndFlag结束中包含的关键字)
    szSource:输入字符串
    iStartPos:输入的字符串匹配起始位置
    iEndPos:输入的字符串匹配的结束位置

    szStartFlag:结果的起始标识符
    szEndFlag:结果的结束标识符

    szDest:匹配到的字串所在类别的关键字
    iDestSize:szDest大小

    iType 1为获取的结果为第一个
          2为获取的结果为最后一个
    格式:szStartFlag关键词1szEndFlag|字串1|字串2|字串3…
          szStartFlag关键词2szEndFlag|字串1|字串2|字串3…
    返回值:匹配字串的长度
**/
int GetRetSubStrBySubFlag(const char *szSource, int iStartPos, int iEndPos, char *szStartFlag, char *szEndFlag, char *szDest, int iDestSize, int iType)
{
    const char *szPos = NULL, *szPos1 = NULL, *szPos2 = NULL;
    int iKeyWordLen = 0;

    if(!szSource || strlen(szSource) < 1)
        return 0;

    memset(szDest, 0, iDestSize);
    
    //从字符串的起始位置开始循环判断
    szPos = szSource + iStartPos;
    while (1)
    {
        //判断是否含有关键字的起始标识符
        szPos1 = strstr(szPos , szStartFlag);
        //如果没有找到该起始标识符或者获取到标识符的位置超出了 要判断的字符串的结束位置
        if (!szPos1 || (szPos1 - (szSource + iStartPos) > iEndPos))
        {
            //如果结果szDest中有数据,则返回该数据的长度,否则则返回0
            if (strlen(szDest) > 0)
            {
                return iKeyWordLen;
            }
            else
            {
                return 0;
            }
        }
        //从起始标识符后的数据判断是否包含有结束标识符
        szPos1 += strlen(szStartFlag);
        szPos2 = strstr(szPos1 , szEndFlag);
        if (szPos2)
        {
            //如果包含则将此之间的数据赋值给szDest
            iKeyWordLen = szPos2 - szPos1;
            if(iKeyWordLen > iDestSize)
                return 0;
            memset(szDest , 0, iDestSize);
            strncpy(szDest, szPos1, iKeyWordLen);
            //如果iType为1,则返回匹配到的第一个结果,否则则继续匹配,直到最后一个结果
            if (iType == 1)
            {
                return iKeyWordLen;
            }
        }
        
        //将要判断的字符串向后移
        szPos = szPos1 + iKeyWordLen + strlen(szEndFlag) ;
        if (!szPos)
        {
            //如果后面没数据,则返回结果
            if (strlen(szDest) > 0)
            {
                return iKeyWordLen;
            }
            else
            {
                return 0;
            }
        }
    }
    return 0;
}
View Code

  2.2  lyFileUtil.h

 

#ifndef _LYFILEUTIL_H_
#define _LYFILEUTIL_H_


#ifdef __cplusplus
extern "C"{
#endif

    int IsNeedDataInfo(const char *szSource,char szUserData[], int iDataSize,int iMatchtype,int iType,char * szFileName,int iStartPos, int *iSubPos);
    int GetSubStrPosByMatchFunc(const char *szSource,const char *szFileSource, char *szStartFlag, char *szEndFlag, char *szUserData, int iDataSize,int iType);
    int GetRetSubStrBySubFlag(const char *szSource, int iStartPos, int iEndPos, char *szStartFlag, char *szEndFlag, char *szDest, int iDestSize, int iType);
    int GetValueByKey(char *szSource, char *szFile, int iType,char *szDest, int iDestSize);
#ifdef __cplusplus
}
#endif

#endif 
View Code

  2.3  lyIsAppDataFromFile.c

 

/*************************************
标题:lyParseFromFile.c
功能:所有通过文件来判断或者获取数据的函数都放在这个文件里面
说明:
包含所有通过文件来判断,通过文件获取所需要数据的函数
作者:孙永超
当前版本: 1.0
修改信息: 2013.03.27
**************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include "lyFileUtil.h"
#include "../lyPublic.h"
#include "../lyString.h"
#include "../lyPublic/lySort.h"
#include "lyIsAppDataFromFile.h"
/*
该文件中包含所有通过文件来判断的函数
1 IsSinger    判断是否是歌手
2 IsSong    判断是否是歌曲
3 IsStoryName    判断是否是故事名称
4 IsEatMenu    判断是否是菜谱
5 IsWebSite    判断是否是网站
6 IsRestaurantName    判断是否餐厅名
7 IsPeopleNameFuzzy    模糊判断人名
8 IsPeopleName    精确判断人名
9 IsAndroidApp    判断是否android应用
10 IsGoods    判断是否是商品
11 IsPruduct_Phone 从头匹配是否为3C产品名称
12 If3cProduct    判断是否3C产品
13 IsFruit    判断是否是水果
14 IsToilet    判断是否是厕所
15 IsHotel    判断是否是酒店
16 IsEatAllRecipe    从所有文件判断是否是全菜谱

*/

int ParseValuefromKey(char *szSource,char * key,char *result);

//从头开始判断是否为歌手名称
//返回值:0——查找失败;大于0——歌手长度
int IsSinger(const char *szSource)
{
    char szFileName[256]="";
    int iRetVal=0;
    
    //得到歌手文件路径
    sprintf(szFileName, "%ssinger.idx", LY_MUSIC_PATH);
    
    //利用折半方式查找
    iRetVal = FuzzyMatchKeyWord(szSource, szFileName);
    
    return iRetVal;
}

//从头开始判断是否为歌曲名称
//返回值:0——查找失败;大于0——歌名长度
int IsSong(const char *szSource)
{
    char szFileName[256]="";
    int iRetVal=0;
    
    //得到歌手文件路径
    sprintf(szFileName, "%ssong.idx", LY_MUSIC_PATH);
    
    //利用折半方式查找
    iRetVal = FuzzyMatchKeyWord(szSource, szFileName);
    
    return iRetVal;
}

//判断某类别故事
int IsStoryName(char const *szSource, char *szDest, int iDestSize)
{
    char szUnit[256] = "";
    char szFileName[256]="";
    char *szIdFile=NULL, *szPos = NULL, *szPos1 = NULL;
    int iLen=0;
    int iRetval=0;
    
    memset(szDest, 0, iDestSize);
    //打开身份证验证文件
    sprintf(szFileName, "%sgushi_name.idx", LY_DATA_PATH);
    szIdFile = ReadFileData(szFileName);
    if(!szIdFile)
        return 0;
    
    //匹配是否存在
    szPos = szIdFile;
    while (szPos && *szPos != '\0')
    {
        memset(szUnit, 0, sizeof(szUnit));
        szPos = strstr(szPos, "[");
        if(!szPos)
            break;
        szPos++;
        szPos1 = strstr(szPos, "]");
        if(!szPos1)
            break;
        iLen = szPos1 - szPos;
        strncpy(szUnit, szPos, iLen);    //匹配的字串
        szPos = szPos1 + 1;

        if (StrCmpArray(szSource, szUnit) > 0)
        {
            szPos = strstr(szUnit, "|");
            if (szPos)
            {
                iLen = szPos - szUnit;
                strncpy(szDest, szUnit, iLen);
            }
            else
            {
                strcpy(szDest, szUnit);
            }
            iRetval = 1;
            break;
        }
    }
    free(szIdFile);
    szIdFile = NULL;
    
    return iRetval;
}

//从热门菜谱中判断是否为热门菜谱
int IsEatHotRecipe(const char *szSource)
{
    char szNewSource[512]="";
    char szFileName[256]="";
    char *szIdFile=NULL;
    int iLen=0;
    int iRetval=0;
    
    //打开身份证验证文件
    sprintf(szFileName, "%srecipe_hot.idx", LY_DATA_PATH);
    szIdFile = ReadFileData(szFileName);
    if(!szIdFile)
        return 0;
    
    //匹配是否存在
    sprintf(szNewSource, "|%s|", szSource);
    if(strstr(szIdFile, szNewSource))
        iRetval = 1;
    
    free(szIdFile);
    szIdFile = NULL;
    
    return iRetval;
}
//从所有菜谱的文件中判断是否是菜谱
int IsEatAllRecipe(const char* szSource)
{
    char szNewSource[512]="";
    char szFileName[256]="";
    char *szIdFile=NULL;
    int iLen=0;
    int iRetval=0;
    
    //打开身份证验证文件
    sprintf(szFileName, "%sword_caipu.idx", LY_DATA_PATH);
    szIdFile = ReadFileData(szFileName);
    if(!szIdFile)
        return 0;
    
    //匹配是否存在
    sprintf(szNewSource, "%s", szSource);
    if(strstr(szIdFile, szNewSource))
        iRetval = 1;
    
    free(szIdFile);
    szIdFile = NULL;
    
    return iRetval;
}

//判断是否为网站
int IsWebSite(const char *szSource)
{
    int iRetVal = 0;
    char szNewSource[256]="";
    char szFileName[256]="";
    char *szFileData=NULL;

    if(strlen(szNewSource)>=4)
        return 0;
    sprintf(szNewSource, "|%s|", szSource);
    sprintf(szFileName, "%swebsite.idx", LY_DATA_PATH);
    szFileData = ReadFileData(szFileName);
    if(!szFileData)
    {
        free(szFileData);
        szFileData=NULL;
        return 0;
    }
    if(strstr(szFileData, szNewSource))
    {
        free(szFileData);
        szFileData=NULL;
        return 1;
    }
    free(szFileData);
    szFileData=NULL;
    return 0;
}

//判断是否餐厅名
//iType:严格程度  1--严格;2--普通;3--宽松
int IsRestaurantName(const char *szSource, char *szDest, int iDestSize, int iType)
{
    char szNewSource[512] = "";
    char szFileName[256] = "";
    int iTemp, iTempPos;
    int iRetVal = 0;

    if(!szSource)
        return 0;
    strcpy(szNewSource, szSource);
    sprintf(szFileName, "%schina_restaurant_1.idx", LY_DATA_PATH);
    iTemp = IsNeedDataInfo(szNewSource, szDest, iDestSize, 3, 2, szFileName, 0, &iTempPos);
    if (iTemp > 0)
    {
        DelStrArray(szDest, szNewSource, sizeof(szNewSource));
        DelStrArray("中餐厅|西餐厅|餐馆|饭店|酒楼|酒家|饭庄|烧烤店|火锅店|烤鱼店|烤鱼馆|餐厅|店|馆", szNewSource, sizeof(szNewSource));
        switch (iType)
        {
        case 1:
            if(iTemp >= 6 && strlen(szNewSource) < 2)
                iRetVal = 1;
            break;
        case 2:
            if(iTemp >= 6 && strlen(szNewSource) < 4)
                iRetVal = 1;
            break;
        case 3:
            if(iTemp >= 4 && strlen(szNewSource) < 8)
                iRetVal = 1;
            break;
        default:
            iRetVal = 1;
        }
    }
    return iRetVal;
}

//模糊判断人名,如:李凯仁
int IsPeopleNameFuzzy(const char *szSource)
{
    char szFileName[256] = "";
    char szKeyword[128]="";
    char *szFileData = NULL;
    char szBuf[64] = "";
    int iTemp, iRetVal = 0;
    
    //长度只取2~4字
    if(!szSource || strlen(szSource) < 4 || strlen(szSource) > 8)
        return 0;

    //打开文件
    sprintf(szFileName, "%sfamily_name.idx", LY_DATA_PATH);
    szFileData = ReadFileData(szFileName);
    if(!szFileData)
        return 0;

    //验证开头是否姓氏,姓名长度为4字时判断是否复姓
    iTemp = GetSubStringPos(szSource, szFileData, 0);
    if(iTemp > 0 && strlen(szSource) - iTemp > 0 && (strlen(szSource) > 6 && iTemp > 3 || strlen(szSource) <= 6))
    {
        //验证名字,排除名字生僻字
        strcpy(szBuf, szSource + iTemp);
        strcpy(szKeyword, "猪|狗|鸡|鸭|我|你|他|它|她|了|啊|杀|奸|坏|宰|鬼|怪|死|血");
        if(GetSubStringPos(szBuf, szKeyword, 2) < 1)
            iRetVal = 1;
    }

    free(szFileData);
    szFileData = NULL;
    return iRetVal;
}

//精确判断人名,如:周星驰最近有什么电影,能够提取出“周星驰”
int IsPeopleName(const char *szSource, char *szDest, int iDestSize)
{
    char szFileName[256] = "", szUnit[64] = "";
    char szBuf[64] = "";
    char *szFileData = NULL, *szPos = NULL, *szPos1 = NULL;
    int iLen, iRetVal = 0;
    
    if(!szSource || strlen(szSource) < 4)
        return 0;
    
    //读取明星数据
    memset(szDest, 0, iDestSize);
    sprintf(szFileName, "%speoplename.idx", LY_DATA_PATH);
    szFileData = ReadFileData(szFileName);
    if(!szFileData)
        return 0;
    
    //从数据中判断
    szPos = szFileData + 2;    //super_star.idx文件用“||”分割
    while(szPos && *szPos != '\0')
    {
        szPos1 = strstr(szPos, "||");
        if(!szPos1)
            break;
        iLen = szPos1 - szPos;
        memset(szUnit, 0, sizeof(szUnit));
        strncpy(szUnit, szPos, iLen);
        if(strlen(szUnit) < 1)
            break;
        szPos = szPos1 + 2;
        
        //判断文本中是否存在名字
        //匹配最长
        if(GetSubStringPos(szSource, szUnit, 2) > 0 && strlen(szUnit) > strlen(szBuf))
        {
            strcpy(szBuf, szUnit);
            iRetVal = 1;
        }
    }
    
    free(szFileData);
    szFileData = NULL;
    strcpy(szDest, szBuf);
    return iRetVal;
}

//匹配应用名称
int CheckAppName(const char *szSource, char *szFileName, char *szDest, int iDestSize)
{
    char szNewSource[256] = "";
    char szBuf[256] = "";
    char *szFileData = NULL;
    int iRetVal = 0;
    
    strcpy(szNewSource, szSource);
    szFileData = ReadFileData(szFileName);
    if(!szFileData)
        return 0;
    while(1)
    {
        //小于2个字,退出, 特殊处理,针对qq等名称
        if ((strlen(szNewSource) < 4 && strcmp(szNewSource, "qq") != 0) || strlen(szNewSource) < 2)
            break;
        sprintf(szBuf, "|%s|", szNewSource);
        if(strstr(szFileData, szBuf))    //精确匹配
        {
            iRetVal = 1;
            break;
        }
        if((unsigned char)szNewSource[strlen(szNewSource) - 1] > 0x80)    //末尾为中文,减2字节
            szNewSource[strlen(szNewSource) - 2] = 0;
        else
            szNewSource[strlen(szNewSource) - 1] = 0;
    }
    free(szFileData);
    szFileData = NULL;
    if(iRetVal > 0)
    {
        memset(szDest, 0, iDestSize);
        strcpy(szDest, szNewSource);
    }
    return iRetVal;
}

//判断是否为应用,从头部开始匹配
//参数,iHotFlag:标识是否为热门应用,如:1表示热门;2表示全部
//参数,szDest:匹配后的应用名称
//返回值:大于0表示成功、1——游戏;2——软件
int IsAndroidApp(const char *szSource, int iHotFlag, char *szDest, int iDestSize)
{
    char szFileName[256]="";
    char szNewSource[256] = "";
    char szFileHotEx[32]="";
    int iRetVal = 0;
    
    strcpy(szNewSource, szSource);
    DelStrArray("网游|游戏|应用|软件", szNewSource, sizeof(szNewSource));
    
    if(iHotFlag == 1)    //是否热门
        sprintf(szFileHotEx, "_hot");
    //判断软件
    sprintf(szFileName, "%ssoftlist_android%s.idx", LY_APP_PATH, szFileHotEx);
    if(CheckAppName(szSource, szFileName, szDest, iDestSize) > 0)
        return 2;
    //判断游戏
    sprintf(szFileName, "%sgamelist_android%s.idx", LY_APP_PATH, szFileHotEx);
    if(CheckAppName(szSource, szFileName, szDest, iDestSize) > 0)
        return 1;
    return 0;
}

//函数功能,从头匹配判断是否是商品
//szSource,用户输入
//iType为查询类型,0-判断是否为商品,1-判断是否为手机商品
//2-判断是否为电脑商品,3-判断是否为相机商品
//4-判断是否为数码商品,5-判断是否为家电商品
//6-判断是否为衣服商品,7-判断是否为鞋包商品
//8-判断是否为运动商品,8-判断是否为化妆商品,9-判断是否为珠宝商品
//如果判断失败则返回0,否则返回大于0,如果iType为0则返回相应的商品类别
int IsGoods(const char *szSource, int iType, char *szDest, int iDestSize)
{
    char szNewSource[512]="";
    char szFileName[256]="";
    char szUserData[512]="";
    char szTemp[256] = "";
    char *szIdFile=NULL;
    char *szDestFile = NULL;
    //char *szDest = NULL;
    char *szPos1 = NULL;
    char *szPos2 = NULL;
    int iLen=0;
    int iRetVal=0, iSubPos = 0;
    int iDestFileSize = 1024*10;

    if (!szSource || strlen(szSource) < 1)
    {
        return 0;
    }
    strcpy(szNewSource ,szSource);
    DelStrArray(" ", szNewSource, sizeof(szNewSource));

    //打开淘宝商品文件
    sprintf(szFileName, "%staobao_goods.idx", LY_PRODUCT_PATH);
    szIdFile = ReadFileData(szFileName);
    if(!szIdFile)
        return 0;

    //已知商品的分类
    if (iType > 0)
    {
        //文件中商品分类标示:    [type=分类标示符]
        memset(szTemp , 0, sizeof(szTemp));
        sprintf(szTemp , "[type=%d]", iType);
        szDestFile = (char *)malloc(iDestFileSize);
        if (!szDestFile)
        {
            free(szIdFile);
            return 0;
        }
        memset(szDestFile , 0, iDestFileSize);
        
        //获取文件中该分类标示符下所有的名称(包含分类标示符)
        szPos1 = strstr(szIdFile, szTemp);
        if(szPos1)
        {        
            szPos2 = strstr(szPos1, "\n");
            if (!szPos2)
            {
                free(szIdFile);
                free(szDestFile);
                return 0;
            }

            iLen = szPos2-szPos1;
            
            if(iLen > iDestFileSize)
            {
                free(szIdFile);
                free(szDestFile);
                return 0;
            }
            
            strncpy(szDestFile, szPos1, iLen);
        }
        
        //从所有的名称中去判断是否包含szSource(从全部往前匹配)并将分类标示符返回
        //iRetVal为文件中的的分类
        iRetVal = GetSubStrPosByMatchFunc(szNewSource, szDestFile,"||","||",szTemp, sizeof(szTemp),2);
        if (iRetVal > 0 && strlen(szNewSource) - strlen(szTemp) <= 8)
        {
            iRetVal = iType;
        }
        free(szDestFile);
        szDestFile = NULL;
    }
    else
    {
        //如果没有分类标示符则,从文件中判断是否包含szSource(从全部往前匹配) 并将分类标示符返回
        //iRetVal为文件中的的分类名
        memset(szTemp , 0, sizeof(szTemp));
        iRetVal = GetSubStrPosByMatchFunc(szNewSource, szIdFile,"||","||",szTemp, sizeof(szTemp),2);
        if (iRetVal > 0 && strlen(szNewSource) - strlen(szTemp) <= 8)
        {
            GetRetSubStrBySubFlag(szIdFile, 0, iRetVal ,"[type=","]", szUserData, sizeof(szUserData), 2);
            if (strlen(szUserData) > 0)
            {
                sscanf(szUserData ,"%d" ,&iRetVal);
            }
            else
            {
                iRetVal  = 0;
            }
        }
    }

    if (iRetVal > 0 && strlen(szTemp) > 0)
    {
        strcpy(szDest, szTemp);
    }

    free(szIdFile);
    szIdFile = NULL;

    return iRetVal;
}

//从头匹配是否为3C产品名称
//失败返回0,成功返回大于0
//其中1-htc,2-三星,3-诺基亚,4-苹果,5-联想,6-步步高,7-摩托罗拉,8-黑莓,9-索尼
//10-LG,11-小米,12-华为,13-中兴,14-oppo,15-酷派,16-tlc,17-金立,18-魅族,19-天宇
//20-华硕,21-首派,22-飞利浦,23-koobee,24-thl,25-明泰,26-经纬,27-云台,28-博沃,29-优米,30-中恒
int IsPruduct_Phone(const char *szSource, char *szUserData , int iDataSize)
{
    char szNewSource[512]="";
    char szFileName[256]="";
    char szTemp[256] = "";
    char *szIdFile=NULL;
    char *szDestFile = NULL;
    char *szDest = NULL;
    char *szPos1 = NULL;
    char *szPos2 = NULL;
    int iLen=0;
    int iRetVal=0, iSubPos = 0;
    int iDestFileSize = 1024*10;
    
    if (!szSource || strlen(szSource) < 1)
    {
        return 0;
    }
    strcpy(szNewSource ,szSource);
    DelStrArray(" ", szNewSource, sizeof(szNewSource));
    //打开3C产品名文件
    sprintf(szFileName, "%spruduct_3c.idx", LY_DATA_PATH);
    szIdFile = ReadFileData(szFileName);
    if(!szIdFile)
        return 0;
    
    //从文件中判断是否包含szSource(从全部往前匹配) 并将分类标示符返回
    memset(szTemp , 0, sizeof(szTemp));
    iRetVal = GetSubStrPosByMatchFunc(szNewSource, szIdFile,"||","||",szTemp, sizeof(szTemp),2);
    if (iRetVal > 0 && strlen(szNewSource) - strlen(szTemp) <= 8)
    {
        memset(szUserData, 0, iDataSize);
        GetRetSubStrBySubFlag(szIdFile, 0, iRetVal ,"[type=","]", szUserData, iDataSize, 2);
        if (strlen(szUserData) > 0)
        {
            //iRetVal为文件中的的分类名
            sscanf(szUserData ,"%d" ,&iRetVal);
            memset(szUserData , 0, iDataSize);
            strcpy(szUserData, szTemp);
        }
        else
        {
            iRetVal  = 0;
        }
    }
    free(szIdFile);
    szIdFile = NULL;
    
    return iRetVal;
}

//判断是否3C类产品
int If3cProduct(const char *szSource, char *szDest, int iDataSize)
{
    char szNewSource[512] = "";
    int iTempValid=0;//在方法内部的一个反证,是不是3c产品
    int iTemp=0;
    int iPos = 0;
    char szKeyWord[4096];
    char szFileName[256];
    char szTemp[256];
    char *szFile;
    char *szPose = NULL, *szPose1 = NULL, *szPose2 = NULL;

    memset(szFileName, 0, sizeof(szFileName));
    memset(szTemp, 0, sizeof(szTemp));
    strcpy(szNewSource, szSource);
    memset(szDest, 0, iDataSize);

    //获取3C产品路径    
    sprintf(szFileName, "%sproduct_pc.idx", LY_DATA_PATH);

    iTempValid=GetSubStringPos(szNewSource,"电脑报",2);
    if(iTempValid>0)
    {
        return 0;
    }
    //关键字进行判断
    iTemp = GetSubStringPos(szNewSource,"mp3|mp4|mp5|电脑|pc|耳机|手机|相机|鼠标|键盘|平板|电子书|u盘|存储卡|sd卡|音响|内存|硬盘|机箱|电源|电子辞典|学习机|录音笔|游戏机|主板|显卡|单反|单电|摄像机|超级本|笔记本|数码录音笔|摄像头|显示器|cpu|台式机|gps",2);
    if(iTemp > 0)
    {
        strcpy(szDest, szNewSource);
        return 1;
    }
    //关键字进行判断
    memset(szKeyWord,0,sizeof(szKeyWord));
    strcat(szKeyWord,"艾诺|昂达|艾利和|爱国者|爱可|本色|驰为|colorfly|创新|方正|飞利浦|歌美|琥珀|hifiman|汉声|icoo|iaudio|itoos|金星|佳的美|酷比|魔方|可欧|蓝魔|蓝晨|蓝慧|摩托罗拉|msi微星|miffy|纽曼|尼派|欧恩|oppo|ourobot|普耐尔|苹果|锐舞|rta|三星|索爱|山水|世酷|尚伊|思歌|索尼|台电|汤姆逊|先科|现代|新科|原道|紫光|acer|宏碁|alienware|长城|戴尔|东芝|典籍|多彩|dcmofa|eser宇朔|富士通|gateway|华硕|惠普|海尔|瀚斯宝丽|intel|技嘉|联想|联想thinkpad|雷蛇|lg|镭波|明唐|清华同方|七喜|七彩虹|神舟|松下|史密斯|索泰|神酷|terrans force|微软|万顺达|万利达|新蓝|优派|爱立顺|爱可视|奥可视|爱帕|arnova|本易|毕升|创维|多丽通|多家乐|顶尖|e人e本|eking|e途|easy派|富士莱|google|国文电书|广达|海信|华为|黑莓|htc|虹pa|d汉王|华银|华夏安业|华舜|幻想兔|inpad|iapo|kupa|酷锐特|科特|肯诺|乐凡|乐天派|magicpad|魅族|明基|诺基亚|欧派德");
    strcat(szKeyWord,"|偶爱|皮尔卡丹|勤毅.尚品|帅酷|三巨网|赛维克|smp|尚合|硕颖|四意|丝诺|闪影|拓步|tcl|途美|炜疆|网尔|信利|锡恩帝|夏普|印象壹本|亚马逊|易方|易如|伊克萨斯|雅狐|影乐|智器|中|恒中国电子|中兴|akg|奥尼|阿波罗克|爱谱王|宾果|拜亚|缤特力|bose|冰豹|班德|b&o|b-link|cresyn|电音|达音科|多普达|esmooth|耳神|芙洛蒂|飞毛腿|斐雅通|feilips|奋达|歌尔|歌尚|谷客|海盗船|华业高宝|i.tech|捷波朗|佳禾|金河田|极致|吉星国际|jbl|精晟小太阳|酷比魔方|koss|雷柏|罗技|雷特|猎音者|力仕普罗|朗琴|蓝科|魔声|漫步者|魅格|美国杰士|牧音王|麦博|名海|momax|魔蔻|麦克赛尔|nba|欧凡|omiz|欧越|欧立格|ovc|浦科特|浦诺菲|pny|奇来富|锐腾|睿科|森海塞尔|硕美科|索尼移动|舒尔|赛睿|声丽|赛尔贝尔|三星pleomax|声籁|森麦|三诺|声奥|索浦|双飞燕|三浦|铁三角|天龙|图美|彤声|ttesports|ultimate ears|威士顿|吾爱|万圣|先锋|旋燕|西诺|音特美|伊赛斯|宜博|雅刚|音王子|中锘基|中电蓝牙|卓威奇亚|ibm|htc|iphone|步步高|金立|天语|西铂|明泰|小米|首派|酷派|lg|oppo|中恒|微铂|thl|vinus|tcl|长虹|卓普|盛大|alcatel");
    strcat(szKeyWord,"|康佳|altek|朵唯|臻爱|sonim|波导|夏新|亿通|奥克斯|欧新|欧盛|天迈|诺亚信|palm|17vee|高新奇|普莱达|voto|seals|greenorange|首信|迪奥|和信|getac|bfb|英华达|agm|笔电锋|华录|mops|阿尔法|东信|豪特|迪士尼|京瓷|世纪鼎利|lephone|优美|基伍|首亿|欧博信|夏朗|nnos|digitalk|锐合|斯达康|国信通|iwoo|乐目|天丽|天勤|大唐|电信|华蜀|友派|齐乐|欧谷|yahoo|卓拉|多美达|inq|港利通|金鹏|卡西欧|唯科|o2|山寨手机|易丰|烽火|高斯贝尔|泰克飞石|i-mate|veva|网易|贝尔丰|艾美讯|盛隆|itg|美奇|雷萨|锋达通|博迪|优珀|rim|摩西|伟恩|cect|华信|大显|美迪欧|衡天越|佳通|恒基伟业|弘谷电|中天|宇达电通|泛泰|盛泰|afti|宏基|微星|iphone|ipad|ibm|佳能|尼康|富士|宾得|奥林巴斯|徕卡|柯达|理光|哈苏|适马|飞思|ge|通用电气|禄莱|奥莱卡|欧达|柏卡|京华数码|ipod|surface|nexus|galaxy");    iTemp = GetSubStringPos(szNewSource,szKeyWord,2);
    if(iTemp > 0)
    {
        strcpy(szDest, szNewSource);
        return 1;
    }

    //判断文件中包含命令
    szFile=ReadFileData(szFileName);
    if(!szFile)
        return 0;
    szPose=strstr(szFile,"||");
    szPose1=strstr(szPose,szNewSource);
    if(szPose1)
    {
        free(szFile);
        strcpy(szDest, szNewSource);
        return 1;
    }
    free(szFile);

    iTemp = IsNeedDataInfo(szNewSource ,szTemp , sizeof(szTemp),1 , 2 , "product_pc.idx" , 0, &iPos);
    if(iTemp > 0)
    {
        strcpy(szDest, szTemp);
        return 1;
    }
    
    return 0;
}

//判断是否为水果名
//int IsFruit(const char *szSource)
//{
//    char szFileName[256]="";
//    char *szFileBuf;
//    const char *szPos1;
//    char szUnit[256]="|";
//    int iRetval=0;
//    
//    //读取机场数据文件
//    sprintf(szFileName, "%sfruit.idx", LY_DATA_PATH);
//    szFileBuf = ReadFileData(szFileName);
//    if(!szFileBuf)
//        return 0;
//    
//    //判断是否存在
//    strcat(szUnit,szSource);
//    strcat(szUnit,"|");
//    szPos1=strstr(szFileBuf,szUnit);
//    if(szPos1)
//        iRetval = 1;
//    free(szFileBuf);
//    
//    return iRetval;
//}


//判断是否为找厕所
//int IsToilet(const char *szSource)
//{
//    char szFileName[256]="";
//    char *szFileBuf;
//    const char *szPos1;
//    char szUnit[256]="|";
//    int iRetval=0;
//    
//    //读取厕所数据文件
//    sprintf(szFileName, "%stoilet.idx", LY_DATA_PATH);
//
//    szFileBuf = ReadFileData(szFileName);
//    if(!szFileBuf)
//        return 0;
//    
//    //判断是否存在
//    strcat(szUnit,szSource);
//    strcat(szUnit,"|");
//    szPos1=strstr(szFileBuf,szUnit);
//    if(szPos1)
//        iRetval = 1;
//    free(szFileBuf);
//    
//    return iRetval;
//}
//判断是否是酒店
//int IsHotel(const char *szSource)
//{
//    char szFileName[256]="";
//    char *szFileBuf;
//    const char *szPos1;
//    char szUnit[256]="|";
//    int iRetval=0;
//    int result=0;
//    char temp[1024]="";
//    strcpy(temp,szSource);
//    DelStrArray("预定|预订|订|定|入住|房",temp,sizeof(temp));
//
//    result = GetSubStringPos(szSource,"快捷酒店|酒店|旅馆|饭店|宾馆|旅店|住的|下榻|住宿|开房|房间|客房|开个房|住店",1);
//    if(result>0)
//        return 1;
//    
//    DelStrArray("和平宾馆|大饭店|海湾酒店|国际大酒店|度假酒店|富丽渡假酒店|度假村|全套房酒店|商务会所酒店|大酒店|快捷酒店|酒店|旅馆|饭店|宾馆|旅店|住的|下榻|住宿|开房|房间|客房|", temp, sizeof(temp));
//     //读取数据文件
//    sprintf(szFileName, "%shotel.idx", LY_DATA_PATH);
//    szFileBuf = ReadFileData(szFileName);
//    if(!szFileBuf)
//        return 0;
//    
//    //判断是否存在
//    strcat(szUnit,szSource);
//    strcat(szUnit,"|");
//    szPos1=strstr(szFileBuf,szUnit);
//    if(szPos1)
//        iRetval = 1;
//    free(szFileBuf);
//    
//    return iRetval;
//}

/**
 * 查找是否存在城市的字符串
 *
 * @param szString 字符串
 * @param iTempPos
 * @param szSepsCity城市
 * @param iszSepsCity
 * @return 成功返回字符串的长度 0-失败
 */
int SearchCityFromFile(char * szString, char *szSepsCity, int iszSepsCity)
{
    char szSeps[64]="|";
    /* 存放临时结果 */
    char szTemp[1024]="";
    char * szFirst, * szSec;
    char * szToken, * szPos;
    char *szfile;
    char szFileName[256]="";
    //szSec = szFile;
    int iLen;   // 用来记录文件字符串的长度
    sprintf(szFileName, "%stianqiaddr.idx", LY_DATA_PATH);
    szfile = ReadFromFile(szFileName, &iLen);//城市

    szSec = szfile;

    memset(szSepsCity, 0, iszSepsCity);
    szFirst = strstr(szSec + 1, szSeps);
    while(szFirst > 0)
    {
        memset(szTemp, 0, 1024);
        strncpy(szTemp, szSec, szFirst - szSec);
        szTemp[szFirst - szSec] = 0;

        szToken = strstr(szTemp, "[");
        if(szToken > 0)
        {
            szPos = strstr(szTemp, "@");
            strncpy(szTemp, szToken + 1, szPos - szToken - 1);
            szTemp[szPos - szToken - 1] = 0;
        }
        else
        {
            szToken = strstr(szTemp, "@");
            if(szToken > 0)
                strcpy(szTemp, szToken + 1);
        }

        if((szPos = strstr(szString, szTemp)) > 0)
        {
            strcpy(szSepsCity, szTemp);
            free(szfile);
            return strlen(szTemp);
        }
        szSec = szFirst + 1;
        szFirst = strstr(szSec + 1, szSeps);
    }
    free(szfile);
    return 0;
}

/**
 * 读取文件
 *
 * @param szFilePath 文件路径
 * @param iLen 来记录文件的长度,由调用方提供
 *
 * @return 返回文件字符数组
 */
char * ReadFromFile(char * szFilePath, int * iLen)
{
    FILE * fp;
    char * szFile;

    /* 打开指定的xml文件 */
    fp = fopen(szFilePath, "r");

    if (fp == NULL)
    {
        return NULL;
    }

    /* 移动文件指针到末尾 */
    fseek(fp, 0, SEEK_END);
    /* 获取文件指针到文件开头的距离 */
    *iLen = ftell(fp);
    /* 恢复文件指针到文件开头 */
    rewind(fp);
    /* 分配内存 */
    szFile = (char *)malloc(sizeof(char) * (*iLen + 1));
    /* 读取指定长度的数据 */
    fread(szFile, 1, *iLen, fp);

    szFile[*iLen] = 0;

    fclose(fp);

    return szFile;
}


/**
    查找
    成功找到职位——1
    失败——0
**/
int SearchJobFromFile(char * szString, char *szSepsJob, int iszSepsJob)
{
    char szTemp[128]="";
    char * szFirst, * szSec ,*szfile;
    char szFileName[256]="";
    int iLen;
    sprintf(szFileName, "%sjobname.idx", LY_DATA_PATH);
    szfile = ReadFromFile(szFileName, &iLen);//职位

    szSec = szfile;
    szFirst=szSec;
    while(szFirst > 0 && szSec > 0)
    {
        szSec = strstr(szFirst , "|");
        if(!szSec)
            break;
        szFirst = szSec + 1;
        szSec = strstr(szFirst, "|");
        if(!szSec)
            break;
        memset(szTemp, 0, sizeof(szTemp));
        strncpy(szTemp, szFirst, (szSec - szFirst));
        szFirst = szSec;
        if(strstr(szString, szTemp))
        {
            memset(szSepsJob, 0, iszSepsJob);
            strcpy(szSepsJob, szTemp);
            free(szfile);
            return 1;
        }
    }
    free(szfile);
    return 0;
}

//判断是否为股票名
int IsStockName(const char *szSource)
{
    int iRetVal = 0;
    char szNewSource[256]="";
    char szFileName[256]="";
    char *szFileData=NULL;

    sprintf(szNewSource, "|%s|", szSource);
    sprintf(szFileName, "%sstocknames.idx", LY_DATA_PATH);
    szFileData = ReadFileData(szFileName);
    if(!szFileData)
    {
        free(szFileData);
        szFileData=NULL;
        return 0;
    }
    if(strstr(szFileData, szNewSource))
    {
        free(szFileData);
        szFileData=NULL;
        return 1;
    }
    free(szFileData);
    szFileData=NULL;
    return 0;
}

//判断是否为电视剧名
int IsTvShowName(const char *szSource)
{
    int iRetVal = 0;
    char szNewSource[256]="";
    char szFileName[256]="";
    char *szFileData=NULL;

    sprintf(szNewSource, "||%s||", szSource);
    sprintf(szFileName, "%sdianshiju.idx", LY_DATA_PATH);
    szFileData = ReadFileData(szFileName);
    if(!szFileData)
    {
        free(szFileData);
        szFileData=NULL;
        return 0;
    }
    if(strstr(szFileData, szNewSource))
    {
        free(szFileData);
        szFileData=NULL;
        return 1;
    }
    free(szFileData);
    szFileData=NULL;
    return 0;
}

//从文件中获取节目表的名称
int GetProgramNameFromFile(char *szData ,char *szRetval, int iRetSize)
{
    int iStrLen = 0;
    char *szFileBuf = NULL, *szPos = NULL, *szPos1 = NULL, *szPos2 = NULL;
    char szBuf[64]="";
    char szBufTemp[64]="";
    char szFileName[256];
    int iLen = 0;
    int iFlag = 0;
    int iRet = 0;
    char szNewSource[512];
    memset(szNewSource, 0, sizeof(szNewSource));
    memset(szBufTemp, 0, sizeof(szBufTemp));

    strcpy(szNewSource, szData);

    //打开文件
    sprintf(szFileName, "%s%s", LY_DATA_PATH,"program/program_zongyi.idx");
    szFileBuf = ReadFileData(szFileName);
    if(!szFileBuf)
        return 0;
    
    szPos = strstr(szFileBuf, "|");
    szPos++;
    while (1)
    {
        //得到节目名
        szPos1 = strstr(szPos, "|");
        if(!szPos1)
            break;
        iLen = szPos1-szPos;
        if(iLen<2 || iLen>=sizeof(szBuf))
        {
            free(szFileBuf);
            break;
        }
        memset(szBuf, 0, sizeof(szBuf));
        strncpy(szBuf, szPos, iLen);
        
        if(strstr(szNewSource, szBuf))
        {
            strcpy(szRetval , szBuf);
            iRet = 691;
            //free(szFileBuf);
            break;
        }

        szPos = szPos1+1;
    }

    free(szFileBuf);
    
    return iRet;
}

/*
*从dbconfig.idx中获取该表名对应的host对应的索引,dbuser的索引,密码对应的索引,获取数据库的名称
*然后根据索引从dbconfigindex.idx中获取对应该索引的值,
*参数:
*(1)数据库表的结构体 (2)数据库的表名
*返回
* 0表示取值失败,1表示取值成功
*/
int GetDbInfofromTable(struct DbInfo *    strDbInfo,char* szTableName)
{
    char szTable[256]="";//放表名
    char szKeyFileName[256];//根据表名查找类型的文件名称
    char szResultFileName[256];//根据类型查找结果的文件名称
    FILE *fp;FILE *fp1;
    char szArr[512];//存储类型文件每一行读出来的字符串
    char szArr1[512];//存储类型对应的数据文件每一行读出来的字符串
    int iTemp=0;
    char szKeyTemp[64]="";//根据关键词取出来的数据
    char szName[128]="";//
    char szHostType[32]="";//存放host的类型,需要进一步取出host的值
    char szHostTypeTemp[32]="";//用于跟上面host值做比较的hosttype存放文件
    
    char szDbName[32]="";//存放数据库的名称
    strcpy(szTable,szTableName);
    
    sprintf(szKeyFileName, "%sdbconfig.idx", LY_DATA_PATH);
    fp = fopen(szKeyFileName, "r");
    if(!fp)
        return 0;
    while ((fgets (szArr, 512, fp)) != NULL)//一行一行的取出数据
    {
        fputs (szArr, stdout);
        ParseValuefromKey(szArr,"table=",szKeyTemp);
        if(strstr(szTableName,szKeyTemp)>0)//如果表名包含了文件里的表的名称(可能是部分),则取出里面所有的信息来
        {
            ParseValuefromKey(szArr,"host=",szHostType);
            ParseValuefromKey(szArr,"dbname=",szDbName);
            memset(strDbInfo->szDbName,0,sizeof(strDbInfo->szDbName));//数据库的名称就直接赋值给结构体了
            strcpy(strDbInfo->szDbName,szDbName);
            break;
        }
    }
    fclose(fp);
    if(strlen(szHostType)==0)
        strcpy(szHostType,"0");
    sprintf(szResultFileName, "%sdbconfigindex.idx", LY_DATA_PATH);
    fp1=fopen(szResultFileName,"r");
    if(!fp1)
        return 0;
    while ((fgets (szArr1, 512, fp1)) != NULL)//一行一行的取出数据
    {
        fputs (szArr1, stdout);
        ParseValuefromKey(szArr1,"hosttype=",szHostTypeTemp);
        if(strcmp(szHostType,szHostTypeTemp)==0)//取到了host的地址,就把该条的user和psw都取出来
        {
            memset(strDbInfo->host,0,sizeof(strDbInfo->host));
            ParseValuefromKey(szArr1,"realhost=",strDbInfo->host);//匹配到了host一致,就把realhost赋给结构体里host对应的值

            memset(strDbInfo->szUser,0,sizeof(strDbInfo->szUser));
            ParseValuefromKey(szArr1,"dbuser=",strDbInfo->szUser);//匹配到了host一致,就把这句字符串里的user赋给结构体里user对应的值

            memset(strDbInfo->szPassword,0,sizeof(strDbInfo->szPassword));
            ParseValuefromKey(szArr1,"dbpw=",strDbInfo->szPassword);//匹配到了host一致,就把这句字符串里的password赋给结构体里password对应的值
            break;
        }
        
    }
    fclose(fp1);
    OutPutLogInfo("GetDbInfofromTable:");
    OutPutLogInfo(strDbInfo->szDbName);
    OutPutLogInfo(strDbInfo->szPassword);
    OutPutLogInfo(strDbInfo->host);
    OutPutLogInfo("\n");
    return 1;
}

/*
*从指定格式的字符串中取到索引对应的值——[table=assist_log_][host=1][dhname=chongdong][dbuser=1][dbpw=1],如传入table=,取出assist_log_
*参数:
*1 指定的字符串 2 传入的关键词索引 3 取出的结果
*/
int ParseValuefromKey(char *szSource,char * key,char *result)
{
    char szNewSource[256]="";
    char* szTemp,*szTemp1;
    char szValue[256]="";//获取的结果
    strcpy(szNewSource,szSource);
    szTemp=strstr(szNewSource,key);//匹配关键词
    if(szTemp)
    {
        strcpy(szValue,szTemp+strlen(key));
    }
    szTemp1=strstr(szValue,"]");
    if(szTemp1)
    {
        szValue[strlen(szValue)-strlen(szTemp1)]=0;
    }
    memset(result,0,sizeof(result));
    strcpy(result,szValue);
    return 0;
}
View Code

  2.4 lyIsAppDataFromFile.h

#ifndef _LYPARSEFROMFILE_H_
#define _LYPARSEFROMFILE_H_


#ifdef __cplusplus
extern "C"{
#endif
    /*
    服务器的数据库信息
    */
    struct DbInfo
    {
        char szTableName[64];//读取输入的表名
        char host[64];  //数据库的地址,本地则是localhost
        char szDbName[64]; //数据库的名称
        char szUser[64];     //数据库的用户,root、customer等等
        char szPassword[64]; //数据库的密码
    };
    int IsSinger(const char *szSource);
    int IsSong(const char *szSource);
    int IsStoryName(char const *szSource, char *szDest, int iDestSize);
    int IsEatHotRecipe(const char *szSource);
    int IsEatAllRecipe(const char* szSource);
    int IsWebSite(const char *szSource);
    int IsRestaurantName(const char *szSource, char *szDest, int iDestSize, int iType);
    int IsPeopleNameFuzzy(const char *szSource);
    int IsPeopleName(const char *szSource, char *szDest, int iDestSize);
    int IsAndroidApp(const char *szSource, int iHotFlag, char *szDest, int iDestSize);
    int IsGoods(const char *szSource, int iType, char *szDest, int iDestSize);
    int IsPruduct_Phone(const char *szSource, char *szUserData , int iDataSize);
    int If3cProduct(const char *szSource, char *szDest, int iDataSize);
    int SearchCityFromFile(char * szString, char *szSepsCity, int iszSepsCity);
    char * ReadFromFile(char * szFilePath, int * iLen);
    int SearchJobFromFile(char * szString, char *szSepsJob, int iszSepsJob);
    int IsStockName(const char *szSource);
    int GetProgramNameFromFile(char *szData ,char *szRetval, int iRetSize);
    int IsTvShowName(const char *szSource);
    int GetDbInfofromTable(struct DbInfo *    strDbInfo,char* szTableName);
#ifdef __cplusplus
}
#endif

#endif 
View Code

3. lyPublic 文件夹

 

转载于:https://www.cnblogs.com/zibuyu/p/3196585.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值