#include <windows.h>
#include <imm.h>
#include "imeattr.h"
#include "imedefs.h"

#if !defined(ROMANIME)
#if defined(WINAR30)
/**********************************************************************/
/* SearchQuickKey()                                                   */
/* Description:                                                       */
/*      Search for the quick key table                                */
/*      file format can be changed in different version for           */
/*      performance consideration, ISVs should not assume its format  */
/*      Array has the CopyRight of this table file                    */
/**********************************************************************/
void PASCAL SearchQuickKey(
    LPCANDIDATELIST     lpCandList,
    LPPRIVCONTEXT       lpImcP)
{
    UINT   uStart, uEnd;
    HANDLE hHighWordTbl;
    LPWORD lpHighWordTbl;

    if (lpImcP->bSeq[1]) {
        uStart = (lpImcP->bSeq[0] - 1) * 300 + (lpImcP->bSeq[1] - 1) * 10 +
            300;
    } else {
        uStart = (lpImcP->bSeq[0] - 1) * 10;
    }

    hHighWordTbl = OpenFileMapping(FILE_MAP_READ, FALSE,
        lpImeL->szTblFile[1]);
    if (!hHighWordTbl) {
        return;
    }

    lpHighWordTbl = MapViewOfFile(hHighWordTbl, FILE_MAP_READ,
        0, 0, 0);
    if (!lpHighWordTbl) {
        goto SrchQuickKeyOvr;
    }

    uEnd = uStart + 10;

    for (; uStart < uEnd; uStart++) {
        UINT uCode;

        uCode = (WORD)*(lpHighWordTbl + uStart);

        AddCodeIntoCand(lpCandList, uCode);
    }

    UnmapViewOfFile(lpHighWordTbl);

SrchQuickKeyOvr:
    CloseHandle(hHighWordTbl);
}
#endif

#if defined(DAYI) || defined(UNIIME)
/**********************************************************************/
/* SearchPhraseTbl()                                                  */
/* Description:                                                       */
/*      file format can be changed in different version for           */
/*      performance consideration, ISVs should not assume its format  */
/**********************************************************************/
void PASCAL SearchPhraseTbl(        // searching the phrase table files
#if defined(UNIIME)
    LPIMEL          lpImeL,
#endif
    UINT            uTblIndex,
    LPCANDIDATELIST lpCandList,
    DWORD           dwPattern)
{
    HANDLE  hTbl;
    LPBYTE  lpTbl;
    int     iLo, iHi, iMid;
    BOOL    bFound;
    LPBYTE  lpPattern;

    hTbl = OpenFileMapping(FILE_MAP_READ, FALSE,
        lpImeL->szTblFile[uTblIndex]);
    if (!hTbl) {
        return;
    }

    lpTbl = (LPBYTE)MapViewOfFile(hTbl, FILE_MAP_READ, 0, 0, 0);
    if (!lpTbl) {
        CloseHandle(hTbl);
        return;
    }

    iLo = 0;
#ifdef UNICODE
    iHi = lpImeL->uTblSize[uTblIndex] / (lpImeL->nSeqBytes + sizeof(DWORD));
#else
    iHi = lpImeL->uTblSize[uTblIndex] / (lpImeL->nSeqBytes + sizeof(WORD));
#endif
    iMid = (iHi + iLo) /2;

    // binary search
    for (; iLo <= iHi; ) {
        LPUNADWORD lpCurr;

#ifdef UNICODE
        lpCurr = (LPDWORD)(lpTbl + (lpImeL->nSeqBytes + sizeof(DWORD)) *
            iMid);
#else
        lpCurr = (LPDWORD)(lpTbl + (lpImeL->nSeqBytes + sizeof(WORD)) *
            iMid);
#endif

        if (dwPattern > (*lpCurr & lpImeL->dwPatternMask)) {
            iLo = iMid + 1;
        } else if (dwPattern < (*lpCurr & lpImeL->dwPatternMask)) {
            iHi = iMid - 1;
        } else {
            bFound = TRUE;
            break;
        }

        iMid = (iHi + iLo) /2;
    }

    if (bFound) {
        HANDLE  hPhrase;
        LPBYTE  lpPhrase;
        LPWORD  lpStart, lpEnd;

        // find the lower bound
#ifdef UNICODE
        lpPattern = lpTbl + (lpImeL->nSeqBytes + sizeof(DWORD)) * iMid;
#else
        lpPattern = lpTbl + (lpImeL->nSeqBytes + sizeof(WORD)) * iMid;
#endif

#ifdef UNICODE
        for (; (LPBYTE)lpPattern >= lpTbl; (LPBYTE)lpPattern -=
            lpImeL->nSeqBytes + sizeof(DWORD)) {
#else
        for (; (LPBYTE)lpPattern >= lpTbl; (LPBYTE)lpPattern -=
            lpImeL->nSeqBytes + sizeof(WORD)) {
#endif
            if (dwPattern > (*(LPUNADWORD)lpPattern & lpImeL->dwPatternMask)) {
                // previous one is the lower bound
#ifdef UNICODE
                (LPBYTE)lpPattern += lpImeL->nSeqBytes + sizeof(DWORD);
#else
                (LPBYTE)lpPattern += lpImeL->nSeqBytes + sizeof(WORD);
#endif
                break;
            }
        }

        if ((LPBYTE)lpPattern <= lpTbl) {
            goto SrchPhrUnmapPattern;
        }

        hPhrase = OpenFileMapping(FILE_MAP_READ, FALSE,
            lpImeL->szTblFile[uTblIndex + 1]);
        if (!hPhrase) {
            goto SrchPhrUnmapPattern;
        }

        lpPhrase = (LPBYTE)MapViewOfFile(hPhrase, FILE_MAP_READ, 0, 0, 0);
        if (!lpPhrase) {
            goto SrchPhrClosePhr;
        }

        // offset of the string
#ifdef UNICODE
        lpEnd = (LPWORD)lpPhrase + *(LPUNADWORD)(lpPattern +
            lpImeL->nSeqBytes);
#else
        lpEnd = (LPWORD)lpPhrase + *(LPUNAWORD)(lpPattern + lpImeL->nSeqBytes);
#endif

#ifdef UNICODE
        for (; dwPattern == (*(LPUNADWORD)lpPattern & lpImeL->dwPatternMask);
            (LPBYTE)lpPattern += lpImeL->nSeqBytes + sizeof(DWORD)) {
#else
        for (; dwPattern == (*(LPUNADWORD)lpPattern & lpImeL->dwPatternMask);
            (LPBYTE)lpPattern += lpImeL->nSeqBytes + sizeof(WORD)) {
#endif
            WORD   wCode;
            DWORD  dwStrLen;

            lpStart = lpEnd;

            // offset of next string
#ifdef UNICODE
            lpEnd = (LPWORD)lpPhrase + *(LPUNADWORD)(lpPattern +
                lpImeL->nSeqBytes * 2 + sizeof(DWORD));
#else
            lpEnd = (LPWORD)lpPhrase + *(LPUNAWORD)(lpPattern +
                lpImeL->nSeqBytes * 2 + sizeof(WORD));
#endif

            for (dwStrLen = 0; lpStart < lpEnd; lpStart++,
                dwStrLen += sizeof(WORD)) {

                wCode = *lpStart;

#ifndef UNICODE
                wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8);
#endif

                // add this char into candidate list
                *(LPWSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[
                    lpCandList->dwCount] + dwStrLen) = wCode;
            }

            // null terminator
            *(LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[
              lpCandList->dwCount] + dwStrLen) = '\0';

            dwStrLen += sizeof(TCHAR);

            // add one string into candidate list
            lpCandList->dwCount++;

            if (lpCandList->dwCount >= MAXCAND) {
                // Grow memory here and do something,
                // if you still want to process it.
                break;
            }

            // string length plus size of the null terminator
            lpCandList->dwOffset[lpCandList->dwCount] =
                lpCandList->dwOffset[lpCandList->dwCount - 1] +
                dwStrLen + sizeof(TCHAR);
        }

        UnmapViewOfFile(lpPhrase);

SrchPhrClosePhr:
        CloseHandle(hPhrase);
    }

SrchPhrUnmapPattern:
    UnmapViewOfFile(lpTbl);

    CloseHandle(hTbl);

    return;
}
#endif

#if defined(CHAJEI) || defined(QUICK) || defined(WINAR30)
/**********************************************************************/
/* MatchPattern()                                                     */
/**********************************************************************/
DWORD PASCAL MatchPattern(
    DWORD         dwSearchPattern,
    LPPRIVCONTEXT lpImcP)
{
    int i;

    if (lpImcP->iGhostCard == lpImeL->nMaxKey) {
#if defined(WINAR30)
    } else if (lpImcP->iGhostCard == 0) {
        // no order search
        BYTE bSeq[8];
        int  j;

        *(LPDWORD)bSeq = *(LPDWORD)lpImcP->bSeq;
        *(LPDWORD)&bSeq[4] = *(LPDWORD)&lpImcP->bSeq[4];
        // 0 out the ghost card *XYZ -> 0XYZ
        bSeq[0] = 0;

        for (j = 0; j < lpImeL->nMaxKey; j++,
            dwSearchPattern >>= lpImeL->nSeqBits) {
            DWORD dwSeqCode;

            dwSeqCode = dwSearchPattern & lpImeL->dwSeqMask;

            if (!dwSeqCode) {
                continue;
            }

            for (i = 1; i < lpImcP->iInputEnd; i++) {
                if (dwSeqCode == bSeq[i]) {
                    // find one - turn off this one not search again
                    bSeq[i] = 0;
                    break;
                }
            }
        }

        if (*(LPDWORD)bSeq) {
            // not matched, next one
            dwSearchPattern = 0;
        } else if (*(LPDWORD)&bSeq[4]) {
            // not matched, next one
            dwSearchPattern = 0;
        } else {
            dwSearchPattern = lpImcP->dwPattern;
        }
#endif
    } else {
        DWORD dwPatternTmp;
        DWORD dwPrefixMask, dwPostfixMask;
        int   iGhostCard;

#if defined(QUICK)
        if (lpImcP->iInputEnd == 1) {
            // for quick the single input X can not get any mask
            return (dwSearchPattern);
        }
#endif

        dwPatternTmp = dwSearchPattern;

        // prepare prefix mask - for example XX mask of XX*Y
        dwPrefixMask = lpImeL->dwPatternMask;

        for (i = lpImeL->nMaxKey - 1; i >= lpImcP->iGhostCard; i--) {
            dwPrefixMask <<= lpImeL->nSeqBits;
        }

        dwSearchPattern &= dwPrefixMask;

        // prepare postfix mask - for example YY mask of X*YY
#if defined(QUICK)
        // we do not have X*Y for quick IME, we use a virtual * here
        iGhostCard = lpImcP->iGhostCard - 1;
#else
        iGhostCard = lpImcP->iGhostCard;
#endif
        // + 1 because this first mask do not need to shift
        // so the shift time will be one time less
        for (i = iGhostCard + 1 + 1; i < lpImeL->nMaxKey; i++,
            dwPatternTmp >>= lpImeL->nSeqBits) {
            if (dwPatternTmp & lpImeL->dwSeqMask) {
                break;
            }
        }

        dwPostfixMask = 0;

        for (i = iGhostCard + 1; i < lpImcP->iInputEnd; i++) {
            dwPostfixMask <<= lpImeL->nSeqBits;
            dwPostfixMask |= lpImeL->dwSeqMask;
        }

        dwPatternTmp &= dwPostfixMask;

        for (; i < lpImeL->nMaxKey; i++) {
            dwPatternTmp <<= lpImeL->nSeqBits;
        }

        dwSearchPattern |= dwPatternTmp;
    }

    return (dwSearchPattern);
}
#endif

#if defined(WINAR30)
/**********************************************************************/
/* WildCardSearchPattern()                                            */
/**********************************************************************/
void PASCAL WildCardSearchPattern(
    LPBYTE          lpCurr,
    LPBYTE          lpEnd,
    LPPRIVCONTEXT   lpImcP,
    LPCANDIDATELIST lpCandList)
{
    DWORD dwRecLen;

    dwRecLen = lpImeL->nSeqBytes + sizeof(WORD);

    for (; lpCurr < lpEnd; lpCurr += dwRecLen) {
        DWORD dwSearchPattern;
#if defined(WINAR30)
        DWORD dwWildCardPattern;
#endif
        UINT  uCode;

        // skip the first word (bank ID) of internal code
        dwSearchPattern = *(LPUNADWORD)lpCurr & lpImeL->dwPatternMask;

#if defined(WINAR30)
        dwWildCardPattern = dwSearchPattern;
#endif

        if (lpImcP->iGhostCard != lpImeL->nMaxKey) {
            dwSearchPattern = MatchPattern(dwSearchPattern, lpImcP);
        }

#if defined(WINAR30)
        dwSearchPattern &= lpImcP->dwWildCardMask;
#endif

        if (lpImcP->dwPattern != dwSearchPattern) {
            continue;
        }

#if defined(WINAR30)
        if (!lpImcP->dwLastWildCard) {
        } else if (dwWildCardPattern & lpImcP->dwLastWildCard) {
            // a ? wild card or a * ghost card must have a stroke there
        } else {
            // a ? wild card or a * ghost card do not have a stroke there
            // - can not match
            continue;
        }
#endif

        uCode = *(LPUNAWSTR)(lpCurr + lpImeL->nSeqBytes);

        AddCodeIntoCand(lpCandList, uCode);

        if (lpCandList->dwCount >= MAXCAND) {
            // Grow memory here and do something,
            // if you still want to process it.
            break;
        }
    }

    return;
}
#endif

#if !defined(WINIME) && !defined(UNICDIME)
/**********************************************************************/
/* SearchPattern()                                                    */
/**********************************************************************/
#if defined(CHAJEI) || defined(QUICK)
int PASCAL SearchPattern(
    LPBYTE        lpTbl,
    LPPRIVCONTEXT lpImcP)
{
    int   iLo, iMid, iHi;
#if defined(CHAJEI)
    DWORD dwCompReadStrLen;
#endif

    if (lpImcP->bSeq[0] > lpImeL->nSeqCode) {
        return (0);
    }

    iMid = lpImcP->bSeq[0] * (lpImeL->nSeqCode + 1);        // A1 char

#if defined(QUICK)
    if (lpImcP->bSeq[1] > lpImeL->nSeqCode) {
        return (0);
    }

    iMid += lpImcP->bSeq[1];
#endif
#if defined(CHAJEI)
    if (!lpImcP->bSeq[0]) {
        dwCompReadStrLen = 0;
    } else if (!lpImcP->bSeq[1]) {
        dwCompReadStrLen = sizeof(WORD);
    } else if (!lpImcP->bSeq[2]) {
        dwCompReadStrLen = 2 * sizeof(WORD);
    } else if (!lpImcP->bSeq[3]) {
        dwCompReadStrLen = 3 * sizeof(WORD);
    } else if (!lpImcP->bSeq[4]) {
        dwCompReadStrLen = 4 * sizeof(WORD);
    } else {
        dwCompReadStrLen = 5 * sizeof(WORD);
    } 

    if (dwCompReadStrLen > sizeof(WORD)) {
        if (lpImcP->bSeq[dwCompReadStrLen / 2 - 1] > lpImeL->nSeqCode) {
            return (0);
        }

        iMid += lpImcP->bSeq[dwCompReadStrLen / 2 - 1];
    }
#endif

    iLo = *((LPWORD)lpTbl + iMid);      // start WORD of A234.TBL & ACODE.TBL
    iHi = *((LPWORD)lpTbl + iMid + 1);  // end WORD of A234.TBL & ACODE.TBL

    if (iLo < iHi) {
        return (iMid);
    } else {
        return (0);
    }
}
#else
int PASCAL SearchPattern(
#if defined(UNIIME)
    LPIMEL        lpImeL,
#endif
    LPBYTE        lpTbl,
    UINT          uTblIndex,
    LPPRIVCONTEXT lpImcP)
{
    int   iLo, iMid, iHi;
    BOOL  fFound;
    DWORD dwRecLen;

    fFound = FALSE;

#if defined(PHON)
    dwRecLen = lpImeL->nSeqBytes;
#else
    dwRecLen = lpImeL->nSeqBytes + sizeof(WORD);
#endif

    iLo = 0;
    iHi = lpImeL->uTblSize[uTblIndex] / dwRecLen;
    iMid = (iLo + iHi) / 2;

    for (; iLo <= iHi; ) {
        LPUNADWORD lpCurr;

        lpCurr = (LPDWORD)(lpTbl + dwRecLen * iMid);

        if (lpImcP->dwPattern > (*lpCurr & lpImeL->dwPatternMask)) {
            iLo = iMid + 1;
        } else if (lpImcP->dwPattern < (*lpCurr & lpImeL->dwPatternMask)) {
            iHi = iMid - 1;
        } else {
            fFound = TRUE;
            break;
        }

        iMid = (iLo + iHi) / 2;
    }

    if (fFound) {
        return (iMid);
    } else {
        return (0);
    }
}
#endif

/**********************************************************************/
/* FindPattern()                                                      */
/**********************************************************************/
void PASCAL FindPattern(
#if defined(UNIIME)
    LPIMEL          lpImeL,
#endif
    LPBYTE          lpTbl,
    int             iMid,
    LPCANDIDATELIST lpCandList,
    LPPRIVCONTEXT   lpImcP)
{
    int    iLo, iHi;
    DWORD  dwRecLen;
#if defined(CHAJEI)
    HANDLE hTblA234;
    LPBYTE lpTblA234, lpA234;
    DWORD  dwPatternA234;
#endif
#if defined(PHON) || defined(CHAJEI) || defined(QUICK)
    HANDLE hTblCode;
    LPBYTE lpTblCode;
#endif
    LPBYTE lpStart, lpEnd;

#if defined(PHON)
    dwRecLen = lpImeL->nSeqBytes;
#elif !defined(CHAJEI) && !defined(QUICK)
    dwRecLen = lpImeL->nSeqBytes + sizeof(WORD);
#else
#endif

    // find the lower bound
#if defined(PHON)
    {
        HANDLE hTable;
        LPWORD lpTable;

        hTable = OpenFileMapping(FILE_MAP_READ, FALSE, lpImeL->szTblFile[1]);
        if (!hTable) {
            return;
        }

        lpTable = MapViewOfFile(hTable, FILE_MAP_READ, 0, 0, 0);
        if (!lpTable) {
            goto FndPatCloseTbl1;
        }

        iLo = *(lpTable + iMid);
        iHi = *(lpTable + iMid + 1);

        UnmapViewOfFile(lpTable);

FndPatCloseTbl1:
        CloseHandle(hTable);

        if (!lpTable) {
            return;
        }
    }
#elif defined(CHAJEI) || defined(QUICK)
    iLo = *((LPWORD)lpTbl + iMid);

    iHi = *((LPWORD)lpTbl + iMid + 1);

    if (iLo >= iHi) {
        return;
    }
#else
    // find the lower bound
    iLo = iMid - 1;

    lpStart = lpTbl + dwRecLen * iLo;

    for (; lpStart >= lpTbl; lpStart -= dwRecLen) {
        register DWORD dwSearchPattern;

        dwSearchPattern = *(LPUNADWORD)lpStart & lpImeL->dwPatternMask;

        if (lpImcP->dwPattern > dwSearchPattern) {
            // previous one is the lower bound
            lpStart += dwRecLen;
            break;
        }
    }

    if (lpStart <= lpTbl) {
        return;
    }

    // offset of code
    lpStart += lpImeL->nSeqBytes;

    // find the higher bound
    iHi = iMid + 1;

    lpEnd = lpTbl + dwRecLen * iHi;

    for (; ; lpEnd += dwRecLen) {
        register DWORD dwSearchPattern;

        dwSearchPattern = *(LPUNADWORD)lpEnd & lpImeL->dwPatternMask;

        if (lpImcP->dwPattern < dwSearchPattern) {
            // the one is the higher bound, not including
            break;
        }
    }

    // offset of code
    lpEnd += lpImeL->nSeqBytes;
#endif

#if defined(CHAJEI)
    // A234.TBL
    hTblA234 = OpenFileMapping(FILE_MAP_READ, FALSE, lpImeL->szTblFile[1]);
    if (!hTblA234) {
        return;
    }

    lpTblA234 = MapViewOfFile(hTblA234, FILE_MAP_READ, 0, 0, 0);
    if (!lpTblA234) {
        goto FndPatCloseTblA234;
    }

    lpA234 = lpTblA234 + sizeof(WORD) * iLo;

    dwPatternA234 = 0;

    if (lpImcP->bSeq[2]) {
        dwPatternA234 |= lpImcP->bSeq[1] << (lpImeL->nSeqBits * 2);
    }

    if (lpImcP->bSeq[3]) {
        dwPatternA234 |= lpImcP->bSeq[2] << lpImeL->nSeqBits;
    }

    if (lpImcP->bSeq[4]) {
        dwPatternA234 |= lpImcP->bSeq[3];
    }
#endif

#if defined(PHON) || defined(CHAJEI) || defined(QUICK)
    // PHONCODE.TBL ACODE.TBL
    hTblCode = OpenFileMapping(FILE_MAP_READ, FALSE, lpImeL->szTblFile[2]);
    if (!hTblCode) {
        return;
    }

    lpTblCode = MapViewOfFile(hTblCode, FILE_MAP_READ, 0, 0, 0);
    if (!lpTblCode) {
        goto FndPatCloseTblCode;
    }

    lpStart = lpTblCode + sizeof(WORD) * iLo;

    lpEnd = lpTblCode + sizeof(WORD) * iHi;

    dwRecLen = sizeof(WORD);
#endif

#if defined(CHAJEI)
    for (; lpStart < lpEnd; lpStart += dwRecLen, lpA234 += sizeof(WORD)) {
#else
    for (; lpStart < lpEnd; lpStart += dwRecLen) {
#endif
        UINT uCode;

#if defined(CHAJEI)
        if (lpImcP->bSeq[1] == GHOSTCARD_SEQCODE) {
            if (!lpImcP->bSeq[2]) {
                // if the 3rd sequence code is 0, it is not a ghost card
                continue;
            }
        } else if (dwPatternA234 != *(LPWORD)lpA234) {
            continue;
        } else {
        }
#endif

        uCode = *(LPUNAWORD)lpStart;

#if defined(PHON) || defined(DAYI)
#ifdef UNICODE
        if (!IsValidCode(uCode)) {
            uCode = InverseEncode(uCode);
        }
#else
        // resolve duplicate composition for one code
        if (!(uCode & 0x8000)) {
            uCode |= 0x8000;
        }
#endif
#endif

        AddCodeIntoCand(lpCandList, uCode);

        if (lpCandList->dwCount >= MAXCAND) {
            // Grow memory here and do something,
            // if you still want to process it.
            break;
        }
    }

#if defined(PHON) || defined(CHAJEI) || defined(QUICK)
    UnmapViewOfFile(lpTblCode);

FndPatCloseTblCode:
    CloseHandle(hTblCode);
#endif

#if defined(CHAJEI)
    UnmapViewOfFile(lpTblA234);

FndPatCloseTblA234:
    CloseHandle(hTblA234);
#endif

    return;
}
#endif // !defined(WINIME) && !defined(UNICDIME)

/**********************************************************************/
/* SearchTbl()                                                        */
/* Description:                                                       */
/*      file format can be changed in different version for           */
/*      performance consideration, ISVs should not assume its format  */
/**********************************************************************/
void PASCAL SearchTbl(          // searching the standard table files
#if defined(UNIIME)
    LPIMEL          lpImeL,
#endif
    UINT            uTblIndex,
    LPCANDIDATELIST lpCandList,
    LPPRIVCONTEXT   lpImcP)
{
#if defined(WINIME) || defined(UNICDIME)
    if (!lpImcP->bSeq[0]) {
    } else if (!lpImcP->bSeq[1]) {
    } else if (!lpImcP->bSeq[3]) {
        DWORD i;
        UINT  uCode;

        uCode = (lpImcP->bSeq[0] - 1) << 12;
        uCode |= (lpImcP->bSeq[1] - 1) << 8;
        if (lpImcP->bSeq[2]) {
            // we want it match with internal code here so | 0x0001
            uCode |= (lpImcP->bSeq[2] - 1) << 4 | 0x0001;
        } else {
            uCode |= 0x0040;
        }

        for (i = 0; i < lpCandList->dwPageSize; i++, uCode++) {
#if defined(WINIME) && defined(UNICODE)
            CHAR  szCode[2];
            WCHAR wCode[2];

            szCode[0] = HIBYTE(uCode);
            szCode[1] = LOBYTE(uCode);

            wCode[0] = 0;

            MultiByteToWideChar(sImeG.uAnsiCodePage, MB_PRECOMPOSED,
                szCode, 2, wCode, sizeof(wCode) / sizeof(WCHAR));

            uCode = wCode[0];
#endif
            AddCodeIntoCand(lpCandList, uCode);
        }
    } else if (!lpImcP->bSeq[2]) {
        return;
    } else {
        UINT  uCode;
#if defined(WINIME) && defined(UNICODE)
        CHAR  szCode[2];
        WCHAR wCode[2];
#endif

        uCode = (lpImcP->bSeq[0] - 1) << 12;
        uCode |= (lpImcP->bSeq[1] - 1) << 8;
        uCode |= (lpImcP->bSeq[2] - 1) << 4;
        uCode |= (lpImcP->bSeq[3] - 1);

#if defined(WINIME) && defined(UNICODE)
        szCode[0] = HIBYTE(uCode);
        szCode[1] = LOBYTE(uCode);

        wCode[0] = 0;

        MultiByteToWideChar(sImeG.uAnsiCodePage, MB_PRECOMPOSED,
            szCode, 2, wCode, sizeof(wCode) / sizeof(WCHAR));

        uCode = wCode[0];
#endif
        AddCodeIntoCand(lpCandList, uCode);
    }

    return;
#else
    HANDLE      hTbl;
    LPBYTE      lpTbl;

    if (!lpImcP->dwPattern) {
        return;
    }

    hTbl = OpenFileMapping(FILE_MAP_READ, FALSE,
        lpImeL->szTblFile[uTblIndex]);
    if (!hTbl) {
        return;
    }

    lpTbl = (LPBYTE)MapViewOfFile(hTbl, FILE_MAP_READ, 0, 0, 0);
    if (!lpTbl) {
        goto SearchTblOvr;
    }

#if defined(WINAR30)
    if (lpImcP->iGhostCard != lpImeL->nMaxKey) {
        WildCardSearchPattern(lpTbl, lpTbl + lpImeL->uTblSize[uTblIndex],
            lpImcP, lpCandList);
    } else if (lpImcP->dwLastWildCard) {
        WildCardSearchPattern(lpTbl, lpTbl + lpImeL->uTblSize[uTblIndex],
            lpImcP, lpCandList);
    } else {
#else
    {
#endif // defined(WINAR30)
        int iMid;

#if defined(CHAJEI) || defined(QUICK)
        iMid = SearchPattern(lpTbl, lpImcP);
#else
        iMid = SearchPattern(
#if defined(UNIIME)
            lpImeL,
#endif
            lpTbl, uTblIndex, lpImcP);
#endif

        if (iMid > 0) {
            FindPattern(
#if defined(UNIIME)
                lpImeL,
#endif
                lpTbl, iMid, lpCandList, lpImcP);
        }
    }

    UnmapViewOfFile(lpTbl);

SearchTblOvr:
    CloseHandle(hTbl);

#if defined(DAYI)
    if (uTblIndex == 0) {       // do not duplciate search the phrase table
        SearchPhraseTbl(1, lpCandList, lpImcP->dwPattern);
    }
#endif

#if defined(UNIIME)             // same as Dayi need to search phrase table
    SearchPhraseTbl(lpImeL, 1, lpCandList, lpImcP->dwPattern);
#endif

    return;
#endif // !defined(WINIME) && !defined(UNICDIME)
}

#if !defined(WINIME) && !defined(UNICDIME) && !defined(ROMANIME)
/**********************************************************************/
/* SearchUsrDic()                                                     */
/**********************************************************************/
void PASCAL SearchUsrDic(       // searching the user dictionary
#if defined(UNIIME)
    LPIMEL          lpImeL,
#endif
    LPCANDIDATELIST lpCandList,
    LPPRIVCONTEXT   lpImcP)
{
    HANDLE hUsrDicMem;
    LPBYTE lpUsrDicStart, lpCurr, lpUsrDicLimit;

    hUsrDicMem = OpenFileMapping(FILE_MAP_READ, FALSE,
        lpImeL->szUsrDicMap);
    if (!hUsrDicMem) {
        return;
    }

    lpUsrDicStart = (LPBYTE)MapViewOfFile(hUsrDicMem, FILE_MAP_READ,
        0, 0, lpImeL->uUsrDicSize);
    if (!lpUsrDicStart) {
        goto SearchUsrDicOvr;
    }

    lpUsrDicLimit = lpUsrDicStart + lpImeL->uUsrDicSize;

    for (lpCurr = lpUsrDicStart; lpCurr < lpUsrDicLimit;
        lpCurr += lpImeL->nSeqBytes + sizeof(WORD)) {
        DWORD dwSearchPattern;
        UINT  uCode;

        // skip the first word (bank ID) of internal code
        dwSearchPattern = *(LPUNADWORD)(lpCurr + sizeof(WORD)) &
            lpImeL->dwPatternMask;

#if defined(CHAJEI) || defined(QUICK) || defined(WINAR30)
        if (lpImcP->iGhostCard != lpImeL->nMaxKey) {
            dwSearchPattern = MatchPattern(dwSearchPattern, lpImcP);
        }
#endif

#if defined(WINAR30)
        dwSearchPattern &= lpImcP->dwWildCardMask;
#endif

        if (lpImcP->dwPattern != dwSearchPattern) {
            continue;
        }

#if defined(WINAR30)
        if (!lpImcP->dwLastWildCard) {
        } else if (dwSearchPattern & lpImcP->dwLastWildCard) {
            // a ? wild card must have a stroke there
        } else {
            // a ? wild card do not have a stroke there - can not match
            continue;
        }
#endif

        uCode = *(LPUNAWSTR)lpCurr;

        AddCodeIntoCand(lpCandList, uCode);

        if (lpCandList->dwCount >= MAXCAND) {
            // Grow memory here and do something,
            // if you still want to process it.
            break;
        }
    }

    UnmapViewOfFile(lpUsrDicStart);

SearchUsrDicOvr:
    CloseHandle(hUsrDicMem);

    return;
}
#endif // !defined(WINIME) && !defined(UNICDIME) && !defined(ROMANIME)

#endif // !defined(ROMANIME)

