de_api.c

arena SDK开发应用

    FileInfor file;

    ExpandFile(pData, lib, &file, ulFile);
    pBlock = (BYTE*)lpGlobal->UnCompressedBuf;
    pEntry = (BYTE*)pBlock + GetUShortFromBuf(pBlock + 2 * ulBlock);
    
    for(i = 0; i < ulEntry; i++)
    {
        pEntry += GetNextEntryInBlock(pEntry);
    }

    return pEntry;
}

static unsigned char MySearchWord(DEData *pData, DESTR lpInputSort, DESTR lpOutputSort)
{
    LPDEGlobalData lpGlobal = (LPDEGlobalData)pData->pRAM;
    BOOL bEng = TRUE;
    DICT_FLAG flag;
    DWORD ulBlockFileIndex;
    DWORD ulBlockIndex;
    DWORD ulIndex;
    
    if(lpInputSort[0] < 0x0100)
    {
        if(lpGlobal->uchLastSearchLib != lpGlobal->uchECLib)
        {
            if(!InitLib(pData, &lpGlobal->curLib, lpGlobal->uchECLib))
                return DE_INVALID_DICT;
            lpGlobal->uchLastSearchLib = lpGlobal->uchECLib;
        }
    }
    else
    {
        bEng = FALSE;
        if(lpGlobal->uchLastSearchLib != lpGlobal->uchCELib)
        {
            if(!InitLib(pData, &lpGlobal->curLib, lpGlobal->uchCELib))
                return DE_INVALID_DICT;
            lpGlobal->uchLastSearchLib = lpGlobal->uchCELib;
        }
    }

    if(bEng)
        flag = SEC;
    else
    {
        if(lpGlobal->bTW)
            flag = TCE;
        else
            flag = SCE;
    }
    
    ulBlockFileIndex = FindNearestBlockFileIndex(pData, &lpGlobal->curLib, lpInputSort, flag);
    ExpandFile(pData, &lpGlobal->curLib, &lpGlobal->curFile, ulBlockFileIndex);
    ulBlockIndex = FindNearestBlockIndex(pData, lpInputSort, flag);
    ulIndex = FindNearestWordIndex(pData, &lpGlobal->curFile, lpInputSort, flag, ulBlockIndex);
    
    lpGlobal->posFocus.ulFile = ulBlockFileIndex;
    lpGlobal->posFocus.ulBlock = ulBlockIndex;
    lpGlobal->posFocus.ulEntry = ulIndex;
    lpGlobal->flag = flag;
       
	g_bEng = bEng;

    (void)ReadWord(GetEntryFromFileBlockEntryIndex(pData, &lpGlobal->curLib, ulBlockFileIndex, ulBlockIndex, ulIndex),
            lpOutputSort, (BOOL)!bEng);
    
    return DE_OK;
}

static BOOL FindWordInHis(HisWordList *his, DWORD ulFile, DWORD ulBlock, DWORD ulEntry, BLOCK_POS flag)
{
    if(flag == BEGINING_BLOCK || flag == ENDING_BLOCK)
    {
        if(his->pos.ulFile == ulFile && his->block_index == flag)
        {
            if(his->ushWordList[ulEntry][0] != 0x00)
                return TRUE;
            return FALSE;
        }
        return FALSE;
    }

    if((his->pos.ulFile == ulFile)
        && (his->pos.ulBlock == ulBlock))
    {
        if(his->ushWordList[ulEntry][0] != 0x00)
            return TRUE;
    }
    return FALSE;
}

/*********** explanation parse ********************/
static char* MyVirtualMalloc(char** ppBuf, long size)
{
    char* p = *ppBuf;
    long  n = size % ALIGN_NUM;
    
    if( n != 0)
        size += ALIGN_NUM - n;
    
    (*ppBuf) += size;
    return p;
}

static long FindUCCh(unsigned char* buf, long nLen, unsigned short usFlag)
{
    long i = 0;
    unsigned short usTemp;
    unsigned char* p = buf;
    
    while(i < nLen - 1)
    {
        usTemp = (unsigned short)(((unsigned short)p[i] << 8) | p[i + 1]);
        
        //---------corrected by IUnknown 2003-01-08---------------//
        if(usTemp == 0x0083 && usFlag != 0x0083)
            return -1;
        
        if(usTemp == usFlag)
            return i+2;
        else
            i ++;
    }
    
    return -1;
}

static long FindNextWordInSameType(unsigned char* buf, long nLen)
{
    unsigned char* p = buf;
    long i = 0;
    unsigned short usTemp;
    
    while(i < nLen - 1)
    {
        usTemp = (unsigned short)(((unsigned short)p[i] << 8) | p[i + 1]);
        
        if(usTemp == CH_COMPART || (0x0000 < usTemp && usTemp <= 0x0010) )
            break;
        
        i += 2;
    }
    
    return i;
}

static long FindWordNumInSameType(unsigned char* buf, long nLen)
{
    unsigned char* p = buf;
    long i = 0;
    unsigned short usTemp;
    long nWordNum = 0;
    
    if(buf[0] == 0x00 && buf[1] <= TYPE_ABBR)
        i += 2;
    
    while(i < nLen - 1)
    {
        usTemp = (unsigned short)(((unsigned short)p[i] << 8) | p[i + 1]);
        
        if(usTemp <= TYPE_ABBR)
            return nWordNum + 1;
        
        if(usTemp == CH_COMPART)
            nWordNum ++;
        
        i += 2;
    }
    
    return nWordNum + 1;
}

static long SingleFindNextWordInSameType(unsigned char* buf, long nLen)
{
    unsigned char* p = buf;
    long i = 0;
    
    while(i < nLen - 1)
    {
        if(p[i] == (unsigned char)CH_COMPART || (0x00 < p[i] && p[i] <= 0x10) )
            break;
        
        i ++;
    }
    
    return i;
}

static long SingleFindWordNumInSameType(unsigned char* buf, long nLen)
{
    unsigned char* p = buf;
    long i = 0;
    long nWordNum = 0;
    
    while(i < nLen - 1)
    {
        if(p[i] == 0x00)
            return nWordNum + 1;
        
        if(p[i] == (unsigned char)CH_COMPART)
            nWordNum ++;
        
        i ++;
    }
    
    return nWordNum + 1;
}

static long FindTypeNumInExp(unsigned char* buf, long nLen)
{
    unsigned char* p = buf;
    long i = 0;
    unsigned short usTemp;
    long nTypeNum = 0;
    long nInit = 0;
    
    usTemp = (unsigned short)(((unsigned short)p[0] << 8) | p[0 + 1]);
    if(T_EMPTY < usTemp && usTemp < T_END)
    {
        ++nInit;
        i += 2;
    }
    
    while(i < nLen - 1)
    {
        usTemp = (unsigned short)(((unsigned short)p[i] << 8) | p[i + 1]);
        if(T_EMPTY < usTemp && usTemp < T_END)
            ++nTypeNum;
        
        i += 2;
    }
    
    if(nInit)
        return ++nTypeNum;
    else
        if(nTypeNum > 0)
            return ++nTypeNum;
        else
            return 1;
}

static void GetExpSize(unsigned char* buf, long nLen, unsigned long* pContentLen)
{
    long nCurPos = 0;
    long nTypeNum = FindTypeNumInExp(buf, nLen);
    long nType = 0;
    
    while(nType < nTypeNum)
    {
        //WORDLIST* pWord;
        long nWordNum = FindWordNumInSameType(buf + nCurPos, nLen - nCurPos);
        long nWord = 0;
        long nOffset;
        
        *pContentLen += sizeof(WORDLIST);
        *pContentLen = AlignSize(*pContentLen);
        //pExp->interpretation = (WORDLIST*)MyVirtualMalloc(ppBufContent, sizeof(WORDLIST));
        //pWord = pExp->interpretation;
        
        if(buf[nCurPos] == 0x00 && buf[nCurPos + 1] <= TYPE_ABBR)
        {
            //pExp->typeofword = (BYTE)buf[nCurPos + 1];
            nCurPos += 2;
        }
        
        nOffset = nCurPos;
        while(nWord < nWordNum)
        {
            long nWordLen = FindNextWordInSameType(buf + nOffset, nLen - nOffset);
            *pContentLen += (DWORD)(nWordLen + 2);
            *pContentLen = AlignSize(*pContentLen);
            //pWord->pWord = (DESTR)MyVirtualMalloc(ppBufContent, nWordLen + 2);
            //UCMemcpy(pWord->pWord, buf + nOffset, nWordLen);
            if(nWord < nWordNum - 1)
            {
                *pContentLen += sizeof(WORDLIST);
                *pContentLen = AlignSize(*pContentLen);
                //pWord->pNext = (WORDLIST*)MyVirtualMalloc(ppBufContent, sizeof(WORDLIST));
                //pWord = pWord->pNext;
                nOffset += nWordLen + 2;
            }
            else
            {
                //pWord->pNext = NULL;
                nOffset += nWordLen;
            }
            
            ++nWord;
        }
        
        if(nType < nTypeNum - 1)
        {
            *pContentLen += sizeof(ONEEXP);
            *pContentLen = AlignSize(*pContentLen);
            //pExp->pNext = (ONEEXP*)MyVirtualMalloc(ppBufContent, sizeof(ONEEXP));
            //pExp = pExp->pNext;
        }
        //nCurPos = nOffset + 2;
        nCurPos = nOffset;
        ++nType;
    }
}

static void GetCEBufInStructSize(LPDEData pData, unsigned char* buf, long nLen, DWORD* pContentLen)
{
    LPDEGlobalData lpGlobal = (LPDEGlobalData)pData->pRAM;
    long i;
    long nPos;
    long nWordNum = 0;
    
    i = 0;
    lpGlobal->pinyinbuflen = 0;
    //buf[0] = CH_PINYIN
    if(buf[i] == CH_PINYIN)
    {
        ++i;
        while(buf[i] != CH_JS)
        {
            unsigned short wIndex = (WORD)(GetUShortFromBuf((BYTE*)buf + i) - 0x5000);
            lpGlobal->pinyinbuflen += GetPinyinBufLen(pData, wIndex) + 2;
            *pContentLen += lpGlobal->pinyinbuflen;
            i += 2;
        }
    }

    nPos = ++i;
    for(; i < nLen; i ++)
    {
        if(buf[i] == CH_COMPART)
            nWordNum ++;
    }
    ++nWordNum;
    
    *pContentLen += sizeof(ONEEXP);
    *pContentLen = AlignSize(*pContentLen);

    *pContentLen += sizeof(WORDLIST);
    *pContentLen = AlignSize(*pContentLen);

    i = 0;
    while(i < nWordNum)
    {
        long j = 0;
        while(buf[nPos] != CH_COMPART && nPos < nLen)
        {
            ++ j;
            ++ nPos;
        }
        
        *pContentLen += (DWORD)(2 * j + 2);
        *pContentLen = AlignSize(*pContentLen);
        //pWordList->pWord = (DESTR)MyVirtualMalloc(ppBufContent, 2 * j + 2);
        ++nPos;
        //pWordList->pWord[j] = 0;  /* '\0' */
        if(i < nWordNum - 1)
        {
            *pContentLen += sizeof(WORDLIST);
            *pContentLen = AlignSize(*pContentLen);
            //pWordList->pNext = (WORDLIST*)MyVirtualMalloc(ppBufContent, sizeof(WORDLIST));
            //pWordList = pWordList->pNext;
        }
        ++i;
    }
}

static void GetECBufInStructSize(unsigned char* buf, long nLen, DWORD* pContentLen)
{
    long nIrregularNum;
    long nAntonymNum;
    long nSynonymNum;
    // unsigned char* p = buf;
    long i;
    
    /*
    fill phonetic symbol
    */
    i = FindUCCh(buf, nLen, CH_YB);
    if(i > 0)
    {
        long n = 0;
        // unsigned char* pTemp = buf + i;

        while(buf[i + n] < 0x80)
            ++n;
        
        if(n > 0)
        {
            *pContentLen += (DWORD)(2 * n + 2);
            *pContentLen = AlignSize(*pContentLen);
            //pContent->pronunciation = (DESTR)MyVirtualMalloc(ppBufContent, 2 * n + 2);
            //SingleUCMemcpy(pContent->pronunciation, buf + i, n);
        }
    }
    
    /*
    fill irregular
    */
    i = FindUCCh(buf, nLen, CH_BGZ);
    if(i > 0)
    {
        long n = 0;
        // unsigned char* pTemp = buf + i;

        while(buf[i + n] < 0x80)
            ++n;
        if(n > 0)
        {
            long t = 0;
            long nCurPos;
            nIrregularNum = SingleFindWordNumInSameType(buf + i, nLen - i);
            
            *pContentLen += (DWORD)((DWORD)(nIrregularNum + 1) * sizeof(DESTR));
            *pContentLen = AlignSize(*pContentLen);
            //pContent->pIrregular = (DESTR*)MyVirtualMalloc(ppBufContent, 
            //                              (nIrregularNum + 1) * sizeof(DESTR));
            nCurPos = i;
            //pContent->numofIrregular = nIrregularNum;
            while(t < nIrregularNum)
            {
                long nWordLen = SingleFindNextWordInSameType(buf + nCurPos, nLen - nCurPos);
                
                *pContentLen += (DWORD)(2 * nWordLen + 2);
                *pContentLen = AlignSize(*pContentLen);
                //pContent->pIrregular[t] = (DESTR)MyVirtualMalloc(ppBufContent,
                //                              2 * nWordLen + 2);
                //SingleUCMemcpy(pContent->pIrregular[t], buf + nCurPos, nWordLen);
                t ++;
                nCurPos += nWordLen + 1;
            }
            //pContent->pIrregular[nIrregularNum] = 0x00;
        }
    }
    /*
    fill antonym
    */
    i = FindUCCh(buf, nLen, CH_FYC);