de_api.c

arena SDK开发应用

        *OutputLine = 0x00;

        return (DWORD)((BYTE*)p - (BYTE*)chTemp);
    }
}

#if 0
static DWORD ReadLine(BYTE* lpBuf, DESTR OutputLine, BOOL bEvenByte)
{
    BYTE* lpOld = lpBuf;
    // If OutputLine == NULL, just used to calculate the number of buffer to be needed.
    if(!OutputLine)
    {
        while(!(lpBuf[0] == 0x0d && lpBuf[1] == 0x0a))
            lpBuf++;
        return (DWORD)(lpBuf - lpOld);
    }
    else
    {
        while(!(lpBuf[0] == 0x0d && lpBuf[1] == 0x0a))
        {
            if(bEvenByte)
            {
                *OutputLine++ = (DECHAR)(((DECHAR)lpBuf[0] << 8) | (DECHAR)lpBuf[1]);
                lpBuf += 2;
            }
            else
                *OutputLine++ = (DECHAR)*lpBuf++;
        }
        *OutputLine = 0x00;
        
        return (DWORD)(lpBuf - lpOld);
    }
}
#endif

static DWORD ReadWord(BYTE* lpBuf, DESTR OutputLine, BOOL bEvenByte)
{
    BYTE* lpOld = lpBuf;
    
    if(bEvenByte)
    {
        while((*OutputLine = (DECHAR)(((DECHAR)lpBuf[0] << 8) | (DECHAR)lpBuf[1])) >= 0x9000)
        {   
            OutputLine++;
            lpBuf += 2;
        }
    }
    else
    {
        while( (*OutputLine = (DECHAR)*lpBuf) < 0x0080)
        {
            OutputLine++;
            lpBuf++;
        }
    }
    
    *OutputLine = 0x00;
    
    return (DWORD)(lpBuf - lpOld);
}

static unsigned char InputToSort(LPDEData pData, DESTR InputWord, DESTR OutputWord)
{
    DECHAR InputString[MAX_WORD_SIZE];
    DESTR UcIn = OutputWord;
    LPDEGlobalData lpGlobal;
    long i = 0;
    UcIn = OutputWord;

    if(InputWord == NULL)
        return DE_NO_ENOUGH_MEMORY;
    if(OutputWord == NULL)
        return DE_NO_ENOUGH_MEMORY;

#define SPACE_HALF 0x20
#define SPACE_FULL 0x3000

    while(*InputWord && i < MAX_WORD_SIZE - 1)
    {
        if(InputWord[0] != SPACE_HALF && InputWord[0] != SPACE_FULL)
            InputString[i++] = *InputWord++;
        else if(InputWord[1] != SPACE_HALF && InputWord[1] != SPACE_FULL && InputWord[1] != 0x00)
        {
            if(i != 0)
                InputString[i++] = *InputWord;
            
            InputWord++;
        }
        else
            InputWord++;
    }
    
    InputString[i] = 0x00;

    if(i == 0)
    {
        InputString[0] = 'A';
        InputString[1] = 0x00;
    }
    
    if(InputString[0] == 0xa3
        || InputString[0] == 0xbf
        || InputString[0] == 0xa1
        || InputString[0] == 0xa7
        || InputString[0] == 0xa5
        || InputString[0] == 0xa4
        || InputString[0] == 0x20ac
        || InputString[0] == 0xf706
        || InputString[0] == 0xa0)
    {
        InputString[0] = 'A';
        InputString[1] = 0x00;
    }
    else if(InputString[0] == 0x2018
        || InputString[0] == 0x2019
        || InputString[0] == 0x2026
        || InputString[0] == 0x3001
        || InputString[0] == 0x201c
        || InputString[0] == 0x201d
        || InputString[0] == 0x3002
        || InputString[0] == 0x300a
        || InputString[0] == 0x300b
        || InputString[0] == 0xff01
        || InputString[0] == 0xff03
        || InputString[0] == 0xff04
        || InputString[0] == 0xff05
        || InputString[0] == 0xff06
        || InputString[0] == 0xff08
        || InputString[0] == 0xff09
        || InputString[0] == 0xff0a
        || InputString[0] == 0xff0b
        || InputString[0] == 0xff0c
        || InputString[0] == 0xff0d
        || InputString[0] == 0xff0f
        || InputString[0] == 0xff1a
        || InputString[0] == 0xff1b
        || InputString[0] == 0xff1c
        || InputString[0] == 0xff1d
        || InputString[0] == 0xff1e
        || InputString[0] == 0xff1f
        || InputString[0] == 0xff20
        || InputString[0] == 0xff3b
        || InputString[0] == 0xff3c
        || InputString[0] == 0xff3d
        || InputString[0] == 0xff3e
        || InputString[0] == 0xff3f
        || InputString[0] == 0xff5b
        || InputString[0] == 0xff5c
        || InputString[0] == 0xff5d
        || InputString[0] == 0xff5e
        || InputString[0] == 0xffe1
        || InputString[0] == 0xffe5)
    {
        InputString[0] = 0x4e00;
        InputString[1] = 0x00;
    }

    lpGlobal = (LPDEGlobalData)pData->pRAM;
    if(lpGlobal->bTW)
        ConvertTWUnicodeToSort(InputString, UcIn);
    else
    {
        if(InputString[0] < 0x0100)
            ConvertUnicodeToSort(pData, lpGlobal->uchCELib, 0, InputString, UcIn);
        else
        {
            if(lpGlobal->keyvalue == 0)
                return DE_INVALID_DICT;
            ConvertUnicodeToSort(pData, lpGlobal->uchCELib, lpGlobal->keyvalue, InputString, UcIn);
        }
    }

    return DE_OK;
}

static unsigned short Sortcode2UC(unsigned short x)
{
    if(x < COMPOST_JUMPINGOFF)
        return x;
    
    x -= COMPOST_JUMPINGOFF;
    x = (unsigned short)(x - (unsigned short)(x / 0x100));
    x += MIN_UNICODE;
    
    return x;
}

static void ConvertTWSortToUnicode(DESTR lpInput, DESTR lpOut)
{
    while(*lpInput)
    {
        if(*lpInput >= MIN_JUMP)
        {
            *lpOut++ = Sortcode2UC(*lpInput++);
        }
        else
            *lpOut++ = *lpInput++;
    }
    
    *lpOut = 0;
}

static unsigned short GetKeyFromValue(LPDEData pData, BYTE iCEDict, DWORD pKeyValueBuf, DECHAR shInput)
{
    if( shInput >= COMPOST_JUMPINGOFF)
    {
        BYTE chTemp[2];

        unsigned short off_perch;
        DWORD offset;
        
        shInput -= COMPOST_JUMPINGOFF;
        
        off_perch = (unsigned short)(shInput / 0x100);
        offset = (DWORD)(shInput - off_perch) * 4 + 2;
        
        (void)pData->Seek((DE_HANDLE)pData->pStandardLib[iCEDict], (DWORD)pKeyValueBuf + offset, DE_FILE_BEGIN);
        (void)pData->Read((DE_HANDLE)pData->pStandardLib[iCEDict], (char*)chTemp, 2);
        
        return (unsigned short)((((unsigned short)chTemp[0] << 8))
            | chTemp[1]);
    }
    
    return shInput;
}

static void ConvertSortToUnicode(LPDEData pData, BYTE iCEDict, DWORD pKeyValueBuf, DESTR lpInput, DESTR lpOutput)
{
    DECHAR uch;
    
    if(lpOutput == NULL)
        return;
    
    while( (uch = *lpInput++) != 0 )
    {
        if(uch <= 0x007f && uch >= 0x0020)
        {
            *lpOutput++ = uch;
        }
        else
        {
            *lpOutput++ = GetKeyFromValue(pData, iCEDict, pKeyValueBuf, uch);
        }
    }
    
    *lpOutput = 0;
}

static BOOL InitLib(DEData *pData, LibInfor *lib, BYTE uchLib)
{
    LPDEGlobalData lpGlobal = (LPDEGlobalData)pData->pRAM;
    DE_HANDLE lpLibAddr;
    DWORD ulOffset;
    int i;
    BYTE chTemp[0x20];

    if(uchLib >= pData->NumofStandardLib)
        return FALSE;
    
    lpLibAddr = pData->pStandardLib[uchLib];
    lib->hLib = lpLibAddr;
    
    (void)pData->Seek((DE_HANDLE)lpLibAddr, 0, DE_FILE_BEGIN);
    (void)pData->Read((DE_HANDLE)lpLibAddr, (char*)chTemp, 0x20);

    lib->dwLibSize = GetULongFromBuf((BYTE*)chTemp + FILE_TOTAL_SIZE);
    lib->dwBlockFilesIndex = GetULongFromBuf((BYTE*)chTemp + BLOCK_FILE_ADDRESS);
    lib->dwWordsListIndex = ADDR_OFFSET_WORDLIST;

    (void)pData->Seek((DE_HANDLE)lpLibAddr, lib->dwWordsListIndex, DE_FILE_BEGIN);
    (void)pData->Read((DE_HANDLE)lpLibAddr, (char*)chTemp, 2);

    ulOffset = ((DWORD)chTemp[0] << 8) | (DWORD)chTemp[1];
    lib->dwWordsList = ulOffset;
    lib->dwTotalFilesNum = (lib->dwWordsList - lib->dwWordsListIndex) / 4;
    
    lpGlobal->his.pos.ulFile =  0xffffffff;
    lpGlobal->his.pos.ulBlock = 0xffffffff;
    lpGlobal->his.pos.ulEntry = 0xffffffff;
    lpGlobal->his.block_index = OTHER_BLOCK;

    for(i = 0; i < BLOCK_PAGE_SIZE; i++)
        lpGlobal->his.ushWordList[i][0] = 0x00;

    return TRUE;
}

static DWORD FindNearestBlockFileIndex(DEData *pData, LibInfor *lib, DESTR lpInputSort, DICT_FLAG flag)
{
    DECHAR uchWord[MAX_WORD_SIZE];
    DWORD pIndex;
    int (*pFuncCmp)(unsigned short* p1, unsigned short* p2);
    int nRet;
    DWORD pOffset;
    DWORD dwLow = lib->dwWordsListIndex;
    DWORD dwHigh = lib->dwWordsList;
    
    if(flag == SEC || flag == TEC)
        pFuncCmp = SJTU_stricmpExW;
    else
        pFuncCmp = SJTU_strcmpW;

    pIndex = dwLow + ((dwHigh - dwLow) / 8) * 4;
    while(dwLow < dwHigh)
    {
        BYTE chTemp[4];
        if(dwLow >= dwHigh - 4)
        {
            pIndex = dwLow;
            break;
        }

        (void)pData->Seek((DE_HANDLE)lib->hLib, pIndex, DE_FILE_BEGIN);
        (void)pData->Read((DE_HANDLE)lib->hLib, (char*)chTemp, 4);

        pOffset = GetUShortFromBuf((char*)chTemp);
        if(flag == SEC || flag == TEC)
            (void)FileReadLine(pData, lib->hLib, pOffset, uchWord, FALSE);
        else
            (void)FileReadLine(pData, lib->hLib, pOffset, uchWord, TRUE);

        nRet = pFuncCmp(uchWord, lpInputSort);
        if(nRet >= 0)
        {
            if(nRet == 0)
            {
#ifdef MATCH_CASE
                if(flag == TCE || flag == SCE)
                    break;

                if(SJTU_strcmpExW(uchWord, lpInputSort) == 0)
                    break;
                else
                {
                    DWORD pPreIndex = pIndex;
                    DWORD pPreOffset;
                    if(pIndex > lib->dwWordsListIndex)
                        pPreIndex = pIndex - 2;
                    else
                        break;
                
                    (void)pData->Seek((DE_HANDLE)lib->hLib, pPreIndex, DE_FILE_BEGIN);
                    (void)pData->Read((DE_HANDLE)lib->hLib, (char*)chTemp, 4);
                
                    pPreOffset = GetUShortFromBuf((BYTE*)chTemp);
                    (void)FileReadLine(pData, lib->hLib, pPreOffset, uchWord, FALSE);
                 
                    nRet = SJTU_strcmpExW(uchWord, lpInputSort);
                    if(nRet == 0)
                        pIndex = pPreIndex;
                    break;  
                }
#else
                DWORD pPreIndex = pIndex;
                DWORD pPreOffset;
                
                if(flag == TCE || flag == SCE)
                    break;
                if(pIndex > lib->dwWordsListIndex)
                    pPreIndex = pIndex - 2;
                else
                    break;

                (void)pData->Seek((DE_HANDLE)lib->hLib, pPreIndex, DE_FILE_BEGIN);
                (void)pData->Read((DE_HANDLE)lib->hLib, (char*)chTemp, 4);

                pPreOffset = GetUShortFromBuf((BYTE*)chTemp);
                if(flag == SEC || flag == TEC)
                    (void)FileReadLine(pData, lib->hLib, pPreOffset, uchWord, FALSE);
                
                nRet = SJTU_stricmpExW(uchWord, lpInputSort);
                if(nRet == 0)
                    pIndex = pPreIndex;
                break;  
#endif
            }
            else
            {
                DWORD pPreIndex = pIndex;
                DWORD pPreOffset;
                if(pIndex > lib->dwWordsListIndex)
                    pPreIndex = pIndex - 2;
                else
                    break;
                
                (void)pData->Seek((DE_HANDLE)lib->hLib, pPreIndex, DE_FILE_BEGIN);
                (void)pData->Read((DE_HANDLE)lib->hLib, (char*)chTemp, 4);

                pPreOffset = GetUShortFromBuf((BYTE*)chTemp);
                if(flag == SEC || flag == TEC)
                    (void)FileReadLine(pData, lib->hLib, pPreOffset, uchWord, FALSE);
                else
                    (void)FileReadLine(pData, lib->hLib, pPreOffset, uchWord, TRUE);

                nRet = pFuncCmp(uchWord, lpInputSort);
                if(nRet > 0)
                {
                    //dwHigh = pIndex - 4;
                    dwHigh = pIndex;
                }
                else
                {
                    //dwHigh = pIndex - 4;
                    pIndex = pPreIndex;
                    break;
                }
            }
        }
        else
        {
            //dwLow = pIndex + 4;
            dwLow = pIndex;
        }
// to be continued... IUnknown.
        //pIndex += 4;
        pIndex = dwLow + ((dwHigh - dwLow) / 8) * 4;
    }

    if(pIndex >= lib->dwWordsList)
        pIndex = lib->dwWordsList - 4;

    return (DWORD)((DWORD)(pIndex - lib->dwWordsListIndex) / 4);
}

static DWORD GetPreEntryInBlock(BYTE* pBuf)
{
    BYTE* p = pBuf;
    if(*(p - 2) == 0x0d && *(p - 1) == 0x0a)
        p -= 2;
    while(!(p[0] == 0x0d && p[1] == 0x0a))
        --p;
    p += 2;
    return (DWORD)(pBuf - p);
}

static DWORD GetNextEntryInBlock(BYTE* pBuf)
{