• 抓取网页(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 != '')
        {
            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 != '')
        {
            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, "
    ");
                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("
    ");
        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 文件夹

  • 相关阅读:
    java Random 随机重排
    java Random 带权重的随机选择
    java 枚举
    springboot docker 部署
    docker 国内镜像加速
    BigDecimal使用
    java继承实现的基本原理
    MySQL 数据类型
    Knockout: 让ViewModel从htm中剥离出去。
    常用代码之五:RequireJS, 一个Define需要且只能有一个返回值/对象,一个JS文件里只能放一个Define.
  • 原文地址:https://www.cnblogs.com/zibuyu/p/3196585.html
Copyright © 2020-2023  润新知