windows-server-2003/inetcore/outlookexpress/directdb/engine/query.cpp

//--------------------------------------------------------------------------
// Query.cpp
//--------------------------------------------------------------------------
#include "pch.hxx"
#include "database.h"
#include "query.h"
#include "shlwapi.h"
#include "strconst.h"

//--------------------------------------------------------------------------
// OPERATORTYPE
//--------------------------------------------------------------------------
typedef enum tagOPERATORTYPE {
    OPERATOR_LEFTPAREN,
    OPERATOR_RIGHTPAREN,
    OPERATOR_EQUAL,
    OPERATOR_NOTEQUAL,
    OPERATOR_LESSTHANEQUAL,
    OPERATOR_LESSTHAN,
    OPERATOR_GREATERTHANEQUAL,
    OPERATOR_GREATERTHAN,
    OPERATOR_AND,
    OPERATOR_BITWISEAND,
    OPERATOR_OR,
    OPERATOR_BITWISEOR,
    OPERATOR_STRSTRI,
    OPERATOR_STRSTR,
    OPERATOR_LSTRCMPI,
    OPERATOR_LSTRCMP,
    OPERATOR_ADD,
    OPERATOR_SUBTRACT,
    OPERATOR_MULTIPLY,
    OPERATOR_DIVIDE,
    OPERATOR_MOD,
    OPERATOR_LAST
} OPERATORTYPE;

//--------------------------------------------------------------------------
// TOKENTYPE
//--------------------------------------------------------------------------
typedef enum tagTOKENTYPE {
    TOKEN_INVALID,
    TOKEN_OPERATOR,
    TOKEN_OPERAND
} TOKENTYPE;

//--------------------------------------------------------------------------
// OPERANDTYPE
//--------------------------------------------------------------------------
typedef enum tagOPERANDTYPE {
    OPERAND_INVALID,
    OPERAND_COLUMN,
    OPERAND_STRING,
    OPERAND_DWORD,
    OPERAND_METHOD,
    OPERAND_LAST
} OPERANDTYPE;

//--------------------------------------------------------------------------
// OPERANDINFO
//--------------------------------------------------------------------------
typedef struct tagOPERANDINFO {
    OPERANDTYPE         tyOperand;
    DWORD               iSymbol;
    LPVOID              pRelease;
    union {
        COLUMNORDINAL   iColumn;        // OPERAND_COLUMN
        LPSTR           pszString;      // OPERAND_STRING
        DWORD           dwValue;        // OPERAND_DWORD
        METHODID        idMethod;       // OPERAND_METHOD
    };
    DWORD               dwReserved;
} OPERANDINFO, *LPOPERANDINFO;

//--------------------------------------------------------------------------
// QUERYTOKEN
//--------------------------------------------------------------------------
typedef struct tagQUERYTOKEN *LPQUERYTOKEN;
typedef struct tagQUERYTOKEN {
    TOKENTYPE           tyToken;
    DWORD               cRefs;
    union {
        OPERATORTYPE    tyOperator;     // TOKEN_OPERATOR
        OPERANDINFO     Operand;        // TOKEN_OPERAND
    };
    LPQUERYTOKEN        pNext;
    LPQUERYTOKEN        pPrevious;
} QUERYTOKEN;

//--------------------------------------------------------------------------
// PFNCOMPAREOPERAND - Compares Two Operands of the same type
//--------------------------------------------------------------------------
typedef INT (APIENTRY *PFNCOMPAREOPERAND)(LPVOID pDataLeft, LPVOID pDataRight);
#define PCOMPARE(_pfn) ((PFNCOMPAREOPERAND)_pfn)

//--------------------------------------------------------------------------
// CompareOperandString
//--------------------------------------------------------------------------
INT CompareOperandString(LPVOID pDataLeft, LPVOID pDataRight) {
    return(lstrcmpi((LPSTR)pDataLeft, (LPSTR)pDataRight));
}

//--------------------------------------------------------------------------
// CompareOperandDword
//--------------------------------------------------------------------------
INT CompareOperandDword(LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) - *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// g_rgpfnCompareOperand
//--------------------------------------------------------------------------
const static PFNCOMPAREOPERAND g_rgpfnCompareOperand[OPERAND_LAST] = {
    NULL,                           // OPERAND_INVALID        
    NULL,                           // OPERAND_COLUMN
    PCOMPARE(CompareOperandString), // OPERAND_STRING
    PCOMPARE(CompareOperandDword)   // OPERAND_DWORD
};

//--------------------------------------------------------------------------
// CompareOperands
//--------------------------------------------------------------------------
#define CompareOperands(_tyOperand, _pDataLeft, _pDataRight) \
    (*(g_rgpfnCompareOperand[_tyOperand]))(_pDataLeft, _pDataRight)

//--------------------------------------------------------------------------
// PFNEVALUATEOPERATOR - Compares data in two flat records.
//--------------------------------------------------------------------------
typedef DWORD (APIENTRY *PFNEVALUATEOPERATOR)(OPERANDTYPE tyOperand, 
    LPVOID pDataLeft, LPVOID pDataRight);
#define PEVAL(_pfn) ((PFNEVALUATEOPERATOR)_pfn)

//--------------------------------------------------------------------------
// Evaluate Operator Prototypes
//--------------------------------------------------------------------------
DWORD EvaluateEqual(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateNotEqual(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateLessThanEqual(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateLessThan(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateGreaterThanEqual(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateGreaterThan(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateAnd(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateBitwiseAnd(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateOr(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateBitwiseOr(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateStrStrI(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateStrStr(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateStrcmpi(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateStrcmp(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateAdd(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateSubtract(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateMultiply(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateDivide(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);
DWORD EvaluateModula(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight);

//--------------------------------------------------------------------------
// OPERATORINFO
//--------------------------------------------------------------------------
typedef struct tagOPERATORINFO {
    LPCSTR              pszName;
    BYTE                bISP;
    BYTE                bICP;
    PFNEVALUATEOPERATOR pfnEvaluate;
} OPERATORINFO, *LPOPERATORINFO;

//--------------------------------------------------------------------------
// Operator Precedence Table
//--------------------------------------------------------------------------
static const OPERATORINFO g_rgOperator[OPERATOR_LAST] = {
    // Name         ISP     ICP     Function
    { "(",          6,      0,      NULL                                }, // OPERATOR_LEFTPAREN
    { ")",          1,      1,      NULL                                }, // OPERATOR_RIGHTPAREN
    { "==",         5,      5,      PEVAL(EvaluateEqual)                }, // OPERATOR_EQUAL
    { "!=",         5,      5,      PEVAL(EvaluateNotEqual)             }, // OPERATOR_NOTEQUAL
    { "<=",         5,      5,      PEVAL(EvaluateLessThanEqual)        }, // OPERATOR_LESSTHANEQUAL
    { "<",          5,      5,      PEVAL(EvaluateLessThan)             }, // OPERATOR_LESSTHAN
    { ">=",         5,      5,      PEVAL(EvaluateGreaterThanEqual)     }, // OPERATOR_GREATERTHANEQUAL
    { ">",          5,      5,      PEVAL(EvaluateGreaterThan)          }, // OPERATOR_GREATERTHAN
    { "&&",         4,      4,      PEVAL(EvaluateAnd)                  }, // OPERATOR_AND
    { "&",          3,      3,      PEVAL(EvaluateBitwiseAnd)           }, // OPERATOR_BITWISEAND
    { "||",         4,      4,      PEVAL(EvaluateOr)                   }, // OPERATOR_OR
    { "|",          3,      3,      PEVAL(EvaluateBitwiseOr)            }, // OPERATOR_BITWISEOR
    { "containsi",  5,      5,      PEVAL(EvaluateStrStrI)              }, // OPERATOR_STRSTRI
    { "contains",   5,      5,      PEVAL(EvaluateStrStr)               }, // OPERATOR_STRSTR
    { "comparei",   5,      5,      PEVAL(EvaluateStrcmpi)              }, // OPERATOR_LSTRCMPI
    { "compare",    5,      5,      PEVAL(EvaluateStrcmp)               }, // OPERATOR_LSTRCMP
    { "+",          4,      4,      PEVAL(EvaluateAdd)                  }, // OPERATOR_ADD,
    { "-",          4,      4,      PEVAL(EvaluateSubtract)             }, // OPERATOR_SUBTRACT,
    { "*",          3,      3,      PEVAL(EvaluateMultiply)             }, // OPERATOR_MULTIPLY,
    { "/",          3,      3,      PEVAL(EvaluateDivide)               }, // OPERATOR_DIVIDE,
    { "%",          3,      3,      PEVAL(EvaluateModula)               }, // OPERATOR_MOD,
};

//--------------------------------------------------------------------------
// EvaluateOperator
//--------------------------------------------------------------------------
#define EvaluateOperator(_tyOperator, _tyOperand, _pDataLeft, _pDataRight) \
    (*(g_rgOperator[_tyOperator].pfnEvaluate))(_tyOperand, _pDataLeft, _pDataRight)

//--------------------------------------------------------------------------
// MAPCOLUMNTYPE
//--------------------------------------------------------------------------
typedef void (APIENTRY *PFNMAPCOLUMNTYPE)(LPOPERANDINFO pOperand, 
    LPCTABLECOLUMN pColumn, LPVOID pBinding, LPVOID *ppValue);
#define PMAP(_pfn) ((PFNMAPCOLUMNTYPE)_pfn)

//--------------------------------------------------------------------------
// MapColumnString
//--------------------------------------------------------------------------
void MapColumnString(LPOPERANDINFO pOperand, LPCTABLECOLUMN pColumn, 
    LPVOID pBinding, LPVOID *ppValue) {
    (*ppValue) = *((LPSTR *)((LPBYTE)pBinding + pColumn->ofBinding));
}

//--------------------------------------------------------------------------
// MapColumnByte
//--------------------------------------------------------------------------
void MapColumnByte(LPOPERANDINFO pOperand, LPCTABLECOLUMN pColumn, 
    LPVOID pBinding, LPVOID *ppValue) {
    pOperand->dwReserved = *((BYTE *)((LPBYTE)pBinding + pColumn->ofBinding));
    (*ppValue) = (LPVOID)&pOperand->dwReserved;
}

//--------------------------------------------------------------------------
// MapColumnDword
//--------------------------------------------------------------------------
void MapColumnDword(LPOPERANDINFO pOperand, LPCTABLECOLUMN pColumn, 
    LPVOID pBinding, LPVOID *ppValue) {
    pOperand->dwReserved = *((DWORD *)((LPBYTE)pBinding + pColumn->ofBinding));
    (*ppValue) = (LPVOID)&pOperand->dwReserved;
}

//--------------------------------------------------------------------------
// MapColumnWord
//--------------------------------------------------------------------------
void MapColumnWord(LPOPERANDINFO pOperand, LPCTABLECOLUMN pColumn, 
    LPVOID pBinding, LPVOID *ppValue) {
    pOperand->dwReserved = *((WORD *)((LPBYTE)pBinding + pColumn->ofBinding));
    (*ppValue) = (LPVOID)&pOperand->dwReserved;
}

//--------------------------------------------------------------------------
// COLUMNTYPEINFO
//--------------------------------------------------------------------------
typedef struct tagCOLUMNTYPEINFO {
    OPERANDTYPE         tyOperand;
    PFNMAPCOLUMNTYPE    pfnMapColumnType;
} COLUMNTYPEINFO, *LPCOLUMNTYPEINFO;

//--------------------------------------------------------------------------
// g_rgColumnTypeInfo
//--------------------------------------------------------------------------
static const COLUMNTYPEINFO g_rgColumnTypeInfo[CDT_LASTTYPE] = {
    { OPERAND_INVALID, NULL                     }, // CDT_FILETIME,
    { OPERAND_STRING,  PMAP(MapColumnString)    }, // CDT_FIXSTRA,
    { OPERAND_STRING,  PMAP(MapColumnString)    }, // CDT_VARSTRA,
    { OPERAND_DWORD,   PMAP(MapColumnByte)      }, // CDT_BYTE,
    { OPERAND_DWORD,   PMAP(MapColumnDword)     }, // CDT_DWORD,
    { OPERAND_DWORD,   PMAP(MapColumnWord)      }, // CDT_WORD,
    { OPERAND_DWORD,   PMAP(MapColumnDword)     }, // CDT_STREAM,
    { OPERAND_INVALID, NULL                     }, // CDT_VARBLOB,
    { OPERAND_INVALID, NULL                     }, // CDT_FIXBLOB,
    { OPERAND_DWORD,   PMAP(MapColumnDword)     }, // CDT_FLAGS,
    { OPERAND_DWORD,   PMAP(MapColumnDword)     }, // CDT_UNIQUE
};

//--------------------------------------------------------------------------
// MapColumnType
//--------------------------------------------------------------------------
#define MapColumnType(_tyColumn, _pOperand, _pColumn, _pBinding, _ppValue) \
    (*(g_rgColumnTypeInfo[_tyColumn].pfnMapColumnType))(_pOperand, _pColumn, _pBinding, _ppValue)

//--------------------------------------------------------------------------
// Prototypes
//--------------------------------------------------------------------------
HRESULT GetNextQueryToken(LPSTR *ppszT, LPCTABLESCHEMA pSchema, LPQUERYTOKEN *ppToken, CDatabase *pDB);
HRESULT LinkToken(LPQUERYTOKEN pToken, LPQUERYTOKEN *ppHead, LPQUERYTOKEN *ppTail);
HRESULT ReleaseTokenList(BOOL fReverse, LPQUERYTOKEN *ppHead, CDatabase *pDB);
HRESULT ReleaseToken(LPQUERYTOKEN *ppToken, CDatabase *pDB);
HRESULT ParseStringLiteral(LPCSTR pszStart, LPOPERANDINFO pOperand, LPSTR *ppszEnd, CDatabase *pDB);
HRESULT ParseNumeric(LPCSTR pszT, LPOPERANDINFO pOperand, LPSTR *ppszEnd);
HRESULT ParseSymbol(LPCSTR pszT, LPCTABLESCHEMA pSchema, LPOPERANDINFO pOperand, LPSTR *ppszEnd, CDatabase *pDB);
HRESULT PushStackToken(LPQUERYTOKEN pToken, LPQUERYTOKEN *ppStackTop);
HRESULT PopStackToken(LPQUERYTOKEN *ppToken, LPQUERYTOKEN *ppStackTop);
HRESULT EvaluateClause(OPERATORTYPE tyOperator, LPVOID pBinding, LPCTABLESCHEMA pSchema, LPQUERYTOKEN *ppStackTop, CDatabase *pDB, IDatabaseExtension *pExtension);
IF_DEBUG(HRESULT DebugDumpExpression(LPCSTR pszQuery, LPCTABLESCHEMA pSchema, LPQUERYTOKEN pPostfixHead));

//--------------------------------------------------------------------------
// ISP inline
//--------------------------------------------------------------------------
inline BYTE ISP(LPQUERYTOKEN pToken)
{
    // Validate
    Assert(TOKEN_OPERATOR == pToken->tyToken && pToken->tyOperator < OPERATOR_LAST);

    // Return ISP
    return (g_rgOperator[pToken->tyOperator].bISP);
}

//--------------------------------------------------------------------------
// ICP inline
//--------------------------------------------------------------------------
inline BYTE ICP(LPQUERYTOKEN pToken)
{
    // Validate
    Assert(TOKEN_OPERATOR == pToken->tyToken && pToken->tyOperator < OPERATOR_LAST);

    // Return ISP
    return (g_rgOperator[pToken->tyOperator].bICP);
}

// --------------------------------------------------------------------------
// DBIsDigit
// --------------------------------------------------------------------------
int DBIsDigit(LPSTR psz)
{
    WORD wType;
    if (IsDBCSLeadByte(*psz))
        SideAssert(GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, psz, 2, &wType));
    else
        SideAssert(GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, psz, 1, &wType));
    return(wType & C1_DIGIT);
}

//--------------------------------------------------------------------------
// EvaluateQuery
//--------------------------------------------------------------------------
HRESULT EvaluateQuery(HQUERY hQuery, LPVOID pBinding, LPCTABLESCHEMA pSchema,
    CDatabase *pDB, IDatabaseExtension *pExtension)
{
    // Locals
    HRESULT         hr=S_OK;
    LPQUERYTOKEN    pToken;
    LPQUERYTOKEN    pResult=NULL;
    LPQUERYTOKEN    pStackTop=NULL;

    // Trace
    TraceCall("EvaluateQuery");

    // Assert
    Assert(hQuery && pBinding && pSchema);

    // Walk through the tokens
    for (pToken=(LPQUERYTOKEN)hQuery; pToken!=NULL; pToken=pToken->pNext)
    {
        // If this is an operand, append to the stack
        if (TOKEN_OPERAND == pToken->tyToken)
        {
            // LinkStackToken
            PushStackToken(pToken, &pStackTop);
        }

        // Otherwise, must be an operator
        else
        {
            // Operator ?
            Assert(TOKEN_OPERATOR == pToken->tyToken && g_rgOperator[pToken->tyOperator].pfnEvaluate != NULL);

            // EvaluateOperator
            IF_FAILEXIT(hr = EvaluateClause(pToken->tyOperator, pBinding, pSchema, &pStackTop, pDB, pExtension));
        }
    }

    // Pop the stack
    PopStackToken(&pResult, &pStackTop);

    // No Token and Stack should now be empty..
    Assert(pResult && NULL == pStackTop && pResult->tyToken == TOKEN_OPERAND && pResult->Operand.tyOperand == OPERAND_DWORD);

    // 0 or not zero
    hr = (pResult->Operand.dwValue == 0) ? S_FALSE : S_OK;

exit:
    // Cleanup
    ReleaseToken(&pResult, pDB);
    ReleaseTokenList(TRUE, &pStackTop, pDB);

    // Done
    return(SUCCEEDED(hr) ? hr : S_FALSE);
}

//--------------------------------------------------------------------------
// ParseQuery
//--------------------------------------------------------------------------
HRESULT ParseQuery(LPCSTR pszQuery, LPCTABLESCHEMA pSchema, LPHQUERY phQuery,
    CDatabase *pDB)
{
    // Locals
    HRESULT         hr=S_OK;
    LPSTR           pszT=(LPSTR)pszQuery;
    LPQUERYTOKEN    pCurrent;
    LPQUERYTOKEN    pPrevious;
    LPQUERYTOKEN    pToken=NULL;
    LPQUERYTOKEN    pPostfixHead=NULL;
    LPQUERYTOKEN    pPostfixTail=NULL;
    LPQUERYTOKEN    pStackTop=NULL;

    // Trace
    TraceCall("ParseQuery");

    // Invalid Args
    if (NULL == pszQuery || NULL == pSchema || NULL == phQuery)
        return TraceResult(E_INVALIDARG);

    // Initialize
    (*phQuery) = NULL;

    // Start the Parsing Loop
    while(1)
    {
        // Parse next Token
        IF_FAILEXIT(hr = GetNextQueryToken(&pszT, pSchema, &pToken, pDB));

        // Done
        if (S_FALSE == hr)
            break;

        // If this was an operand, append to postfix expression
        if (TOKEN_OPERAND == pToken->tyToken)
        {
            // LinkToken
            LinkToken(pToken, &pPostfixHead, &pPostfixTail);

            // Don't pToken
            ReleaseToken(&pToken, pDB);
        }

        // Otherwise, must be an operator
        else
        {
            // Must be an operator
            Assert(TOKEN_OPERATOR == pToken->tyToken);
        
            // If Right Paren
            if (OPERATOR_RIGHTPAREN == pToken->tyOperator)
            {
                // Pop all the items from the stack and link into the postfix expression
                while (pStackTop && OPERATOR_LEFTPAREN != pStackTop->tyOperator)
                {
                    // Save pPrevious
                    pPrevious = pStackTop->pPrevious;

                    // Otherwise
                    LinkToken(pStackTop, &pPostfixHead, &pPostfixTail);

                    // Releae
                    ReleaseToken(&pStackTop, pDB);

                    // Goto Previuos
                    pStackTop = pPrevious;
                }

                // If not a left parent was found, then we failed
                if (OPERATOR_LEFTPAREN != pStackTop->tyOperator)
                {
                    hr = TraceResult(DB_E_UNMATCHINGPARENS);
                    goto exit;
                }

                // Save pPrevious
                pPrevious = pStackTop->pPrevious;

                // Free pStackTop
                ReleaseToken(&pStackTop, pDB);

                // Reset pStackTop
                pStackTop = pPrevious;

                // Free pToken
                ReleaseToken(&pToken, pDB);
            }

            // Otherwise
            else
            {
                // Pop all the items into the postfix expression according to a cool little priority rule
                while (pStackTop && ISP(pStackTop) <= ICP(pToken))
                {
                    // Save pPrevious
                    pPrevious = pStackTop->pPrevious;

                    // Otherwise
                    LinkToken(pStackTop, &pPostfixHead, &pPostfixTail);

                    // Releae
                    ReleaseToken(&pStackTop, pDB);

                    // Goto Previuos
                    pStackTop = pPrevious;
                }

                // Append pToken to the Stack
                LinkToken(pToken, NULL, &pStackTop);

                // Don't pToken
                ReleaseToken(&pToken, pDB);
            }
        }
    }

    // Pop all the items from the stack and link into the postfix expression
    while (pStackTop)
    {
        // Save pPrevious
        pPrevious = pStackTop->pPrevious;

        // Append to Postfix Expression
        LinkToken(pStackTop, &pPostfixHead, &pPostfixTail);

        // Releae
        ReleaseToken(&pStackTop, pDB);

        // Goto Previuos
        pStackTop = pPrevious;
    }

    // lets write the postfix notation...
    //IF_DEBUG(DebugDumpExpression(pszQuery, pSchema, pPostfixHead));

    // Success
    (*phQuery) = (HQUERY)pPostfixHead;

exit:
    // Cleanup On Failure
    if (FAILED(hr))
    {
        // Free pToken
        ReleaseToken(&pToken, pDB);

        // Free the Stack
        ReleaseTokenList(TRUE, &pStackTop, pDB);

        // Free the Postfix Expression
        ReleaseTokenList(FALSE, &pPostfixHead, pDB);
    }

    // Done
    return(hr);
}

//--------------------------------------------------------------------------
// DebugDumpExpression
//--------------------------------------------------------------------------
#ifdef DEBUG
HRESULT DebugDumpExpression(LPCSTR pszQuery, LPCTABLESCHEMA pSchema, 
    LPQUERYTOKEN pPostfixHead)
{
    // Locals
    LPQUERYTOKEN pToken;

    // Trace
    TraceCall("DebugDumpExpression");

    // Write Infix
    DebugTrace("ParseQuery (Infix)   : %s\n", pszQuery);

    // Write Postfix header
    DebugTrace("ParseQuery (Postfix) : ");

    // Loop through the tokens
    for (pToken=pPostfixHead; pToken!=NULL; pToken=pToken->pNext)
    {
        // Operator
        if (TOKEN_OPERATOR == pToken->tyToken)
        {
            // Write the Operator
            DebugTrace("%s", g_rgOperator[pToken->tyOperator].pszName);
        }

        // Operand
        else if (TOKEN_OPERAND == pToken->tyToken)
        {
            // Column Operand
            if (OPERAND_COLUMN == pToken->Operand.tyOperand)
            {
                // Must have an iSymbol
                Assert(0xffffffff != pToken->Operand.iSymbol);

                // Write the Symbol
                DebugTrace("Column: %d (%s)", pToken->Operand.dwValue, pSchema->pSymbols->rgSymbol[pToken->Operand.iSymbol].pszName);
            }

            // String Operand
            else if (OPERAND_STRING == pToken->Operand.tyOperand)
            {
                // Write the Symbol
                DebugTrace("<%s>", pToken->Operand.pszString);
            }

            // Dword Operand
            else if (OPERAND_DWORD == pToken->Operand.tyOperand)
            {
                // Has a iSymbol
                if (0xffffffff != pToken->Operand.iSymbol)
                {
                    // Write the Symbol
                    DebugTrace("%d (%s)", pToken->Operand.dwValue, pSchema->pSymbols->rgSymbol[pToken->Operand.iSymbol].pszName);
                }

                // Otherwise, just write the value
                else
                {
                    // Write the Symbol
                    DebugTrace("%d", pToken->Operand.dwValue);
                }
            }

            // Method 
            else if (OPERAND_METHOD == pToken->Operand.tyOperand)
            {
                // Validate Symbol Type
                Assert(SYMBOL_METHOD == pSchema->pSymbols->rgSymbol[pToken->Operand.iSymbol].tySymbol);

                // Write the Method
                DebugTrace("Method: %d (%s)", pToken->Operand.idMethod, pSchema->pSymbols->rgSymbol[pToken->Operand.iSymbol].pszName);
            }
        }

        // Bad
        else
            Assert(FALSE);

        // Write Delimiter
        DebugTrace(", ");
    }

    // Wrap the line
    DebugTrace("\n");

    // Done
    return(S_OK);
}
#endif // DEBUG

//--------------------------------------------------------------------------
// CompareSymbol
//--------------------------------------------------------------------------
HRESULT CompareSymbol(LPSTR pszT, LPCSTR pszName, LPSTR *ppszEnd)
{
    // Locals
    LPSTR       pszName1;
    LPSTR       pszName2;

    // Trace
    TraceCall("CompareSymbol");

    // Set pszName
    pszName1 = (LPSTR)pszName;

    // Set pszName2
    pszName2 = pszT;

    // Compare pszTo to Operator pszName...
    while ('\0' != *pszName2 && *pszName1 == *pszName2)
    {
        // Increment
        pszName1++;
        pszName2++;

        // Reached the End of pszName1, must be a match
        if ('\0' == *pszName1)
        {
            // Set ppszEnd
            *ppszEnd = pszName2;

            // Done
            return(S_OK);
        }
    }

    // Done
    return(S_FALSE);
}

//--------------------------------------------------------------------------
// GetNextQueryToken
//--------------------------------------------------------------------------
HRESULT GetNextQueryToken(LPSTR *ppszT, LPCTABLESCHEMA pSchema,
    LPQUERYTOKEN *ppToken, CDatabase *pDB)
{
    // Locals
    HRESULT         hr=S_FALSE;
    LPSTR           pszT=(*ppszT);
    LPSTR           pszEnd;
    DWORD           i;
    LPQUERYTOKEN    pToken=NULL;

    // Trace
    TraceCall("GetNextQueryToken");

    // Allocate a Token
    IF_NULLEXIT(pToken = (LPQUERYTOKEN)pDB->PHeapAllocate(HEAP_ZERO_MEMORY, sizeof(QUERYTOKEN)));

    // Set Reference Count
    pToken->cRefs = 1;

    // No Token foundyet
    pToken->tyToken = TOKEN_INVALID;

    // Invalid Symbol Index
    pToken->Operand.iSymbol = 0xffffffff;

    // Skip White Space...
    while(*pszT && (*pszT == ' ' || *pszT == '\t'))
        pszT++;

    // Done
    if ('\0' == *pszT)
        goto exit;
    
    // Check for the Start of an Operator...
    for (i=0; i<OPERATOR_LAST; i++)
    {
        // Does pszT point to the start of an operator ?
        if (S_OK == CompareSymbol(pszT, g_rgOperator[i].pszName, &pszEnd))
        {
            // Update pszT
            pszT = pszEnd;

            // We found an operator
            pToken->tyToken = TOKEN_OPERATOR;

            // Set the operator type
            pToken->tyOperator = (OPERATORTYPE)i;

            // Done
            break;
        }
    }

    // No Token Yet ?
    if (TOKEN_INVALID == pToken->tyToken)
    {
        // Start of a String Literal ?
        if ('"' == *pszT)
        {
            // ParseStringLiteral
            IF_FAILEXIT(hr = ParseStringLiteral(pszT, &pToken->Operand, &pszEnd, pDB));
        }

        // Otherwise, start of a number
        else if (DBIsDigit(pszT))
        {
            // ParseNumeric
            IF_FAILEXIT(hr = ParseNumeric(pszT, &pToken->Operand, &pszEnd));
        }

        // Start of a Symbol
        else
        {
            // ParseSymbol
            IF_FAILEXIT(hr = ParseSymbol(pszT, pSchema, &pToken->Operand, &pszEnd, pDB));
        }

        // Must have been an operand
        pToken->tyToken = TOKEN_OPERAND;

        // Set pszT
        pszT = pszEnd;
    }

    // Set ppszT
    *ppszT = pszT;

    // Success
    hr = S_OK;

    // Return the Token
    *ppToken = pToken;

    // Don't Free the Token
    pToken = NULL;

exit:
    // Cleanup
    ReleaseToken(&pToken, pDB);

    // Done
    return(hr);
}

//--------------------------------------------------------------------------
// ParseStringLiteral
//--------------------------------------------------------------------------
HRESULT ParseStringLiteral(LPCSTR pszStart, LPOPERANDINFO pOperand, 
    LPSTR *ppszEnd, CDatabase *pDB)
{
    // Locals
    HRESULT         hr=S_OK;
    LPSTR           pszValue;
    DWORD           cchString;
    LPSTR           pszT=(LPSTR)pszStart;
    
    // Trace
    TraceCall("ParseStringLiteral");

    // Validate Args
    Assert(*pszT == '"' && pOperand && ppszEnd);

    // Increment over "
    pszT++;

    // Find the End of the Quoted String
    while(*pszT)
    {
        // DBCS Lead Byte
        if (IsDBCSLeadByte(*pszT) || '\\' == *pszT)
        {
            pszT+=2;
            continue;
        }

        // If Escaped Quote..
        if ('"' == *pszT)
        {
            // Set ppszEnd
            *ppszEnd = pszT + 1;

            // Done
            break;
        }

        // Increment pszT
        pszT++;
    }

    // Not Found
    if ('\0' == *pszT)
    {
        hr = TraceResult(DB_E_UNMATCHINGQUOTES);
        goto exit;
    }

    // Get Size
    cchString = (DWORD)(pszT - (pszStart + 1));

    // Duplicate the String
    IF_NULLEXIT(pszValue = (LPSTR)pDB->PHeapAllocate(NOFLAGS, cchString + 1));

    // Copy the String
    CopyMemory(pszValue, pszStart + 1, cchString);

    // Set the Null
    pszValue[cchString] = '\0';

    // Set Operand Type
    pOperand->tyOperand = OPERAND_STRING;

    // Release
    pOperand->pRelease = (LPVOID)pszValue;

    // Set Value
    pOperand->pszString = pszValue;

exit:
    // Done
    return(hr);
}

//--------------------------------------------------------------------------
// ParseNumeric
//--------------------------------------------------------------------------
HRESULT ParseNumeric(LPCSTR pszStart, LPOPERANDINFO pOperand, LPSTR *ppszEnd)
{
    // Locals
    HRESULT         hr=S_OK;
    DWORD           dwValue;
    CHAR            szNumber[255];
    DWORD           dwIncrement=0;
    LPSTR           pszT=(LPSTR)pszStart;
    DWORD           cchNumber;
    
    // Trace
    TraceCall("ParseNumeric");

    // Validate Args
    Assert(DBIsDigit(pszT) && pOperand && ppszEnd);

    // Is Hex: 0x
    if ('0' == *pszT && '\0' != *(pszT + 1) && 'X' == TOUPPERA(*(pszT + 1)))
    {
        // IsHex
        dwIncrement = 2;

        // Set pszT
        pszT += 2;
    }

    // Find the End of the Number
    while (*pszT && DBIsDigit(pszT))
    {
        // Increment
        pszT++;
    }

    // Get Length
    cchNumber = (DWORD)(pszT - (pszStart + dwIncrement));

    // Too Frickin Big
    if (cchNumber >= ARRAYSIZE(szNumber))
    {
        hr = TraceResult(DB_E_NUMBERTOOBIG);
        goto exit;
    }

    // Copy into szNumber
    CopyMemory(szNumber, pszStart + dwIncrement, cchNumber);

    // Set Null
    szNumber[cchNumber] = '\0';

    // If Is Hex, convert to integer
    if (FALSE == StrToIntEx(szNumber, dwIncrement ? STIF_SUPPORT_HEX : STIF_DEFAULT, (INT *)&dwValue))
    {
        hr = TraceResult(DB_E_BADNUMBER);
        goto exit;
    }

    // Set Operand Type
    pOperand->tyOperand = OPERAND_DWORD;

    // Set Value
    pOperand->dwValue = dwValue;

    // Return ppszEnd
    *ppszEnd = pszT;

exit:
    // Done
    return(hr);
}

//--------------------------------------------------------------------------
// ParseSymbol
//--------------------------------------------------------------------------
HRESULT ParseSymbol(LPCSTR pszT, LPCTABLESCHEMA pSchema, LPOPERANDINFO pOperand, 
    LPSTR *ppszEnd, CDatabase *pDB)
{
    // Locals
    HRESULT         hr=S_OK;
    DWORD           i;
    LPSYMBOLINFO    pSymbol;
    LPSTR           pszEnd;
    
    // Trace
    TraceCall("ParseSymbol");

    // No Symbols
    if (NULL == pSchema->pSymbols)
    {
        hr = TraceResult(DB_E_NOSYMBOLS);
        goto exit;
    }

    // Check for the Start of an Operator...
    for (i=0; i<pSchema->pSymbols->cSymbols; i++)
    {
        // Readability
        pSymbol = (LPSYMBOLINFO)&pSchema->pSymbols->rgSymbol[i];

        // Does pszT point to the start of an operator ?
        if (S_OK == CompareSymbol((LPSTR)pszT, pSymbol->pszName, &pszEnd))
        {
            // Update pszT
            *ppszEnd = pszEnd;

            // Save iSymbol
            pOperand->iSymbol = i;

            // Is Column Symbol
            if (SYMBOL_COLUMN == pSymbol->tySymbol)
            {
                // Validate the Ordinal
                if (pSymbol->dwValue > pSchema->cColumns)
                {
                    hr = TraceResult(DB_E_INVALIDCOLUMN);
                    goto exit;
                }

                // Convert to OPERANDTYPE
                pOperand->tyOperand = OPERAND_COLUMN;

                // Save the Column
                pOperand->iColumn = (COLUMNORDINAL)pSymbol->dwValue;
            }

            // Otherwise, is a method ?
            else if (SYMBOL_METHOD == pSymbol->tySymbol)
            {
                // Convert to OPERANDTYPE
                pOperand->tyOperand = OPERAND_METHOD;

                // Save the Column
                pOperand->idMethod = pSymbol->dwValue;
            }

            // Otherwise, just a dword value
            else
            {
                // Dword
                pOperand->tyOperand = OPERAND_DWORD;

                // Set the operator type
                pOperand->dwValue = pSymbol->dwValue;
            }

            // Done
            goto exit;
        }
    }

    // Not Found
    hr = TraceResult(DB_E_INVALIDSYMBOL);

exit:
    // Done
    return(hr);
}

//--------------------------------------------------------------------------
// CloseQuery
//--------------------------------------------------------------------------
HRESULT CloseQuery(LPHQUERY phQuery, CDatabase *pDB)
{
    // Trace
    TraceCall("CloseQuery");

    // ReleaseTokenList
    ReleaseTokenList(FALSE, (LPQUERYTOKEN *)phQuery, pDB);

    // Done
    return(S_OK);
}

//--------------------------------------------------------------------------
// PushStackToken
//--------------------------------------------------------------------------
HRESULT PushStackToken(LPQUERYTOKEN pToken, LPQUERYTOKEN *ppStackTop)
{
    // Trace
    TraceCall("PushStackToken");

    // Set pStackPrevious
    pToken->pPrevious = (*ppStackTop);

    // Update Stack Top
    (*ppStackTop) = pToken;

    // AddRef the Token
    pToken->cRefs++;

    // Done
    return(S_OK);
}

//--------------------------------------------------------------------------
// PopStackToken
//--------------------------------------------------------------------------
HRESULT PopStackToken(LPQUERYTOKEN *ppToken, LPQUERYTOKEN *ppStackTop)
{
    // Trace
    TraceCall("PopStackToken");

    // Validate
    Assert(ppToken && ppStackTop);

    // No more tokens...
    if (NULL == *ppStackTop)
        return TraceResult(DB_E_BADEXPRESSION);

    // Set Token
    *ppToken = (*ppStackTop);

    // Goto Previous
    (*ppStackTop) = (*ppToken)->pPrevious;

    // Release the Token
    //(*ppToken)->cRefs--;

    // Done
    return(S_OK);
}

//--------------------------------------------------------------------------
// LinkToken
//--------------------------------------------------------------------------
HRESULT LinkToken(LPQUERYTOKEN pToken, LPQUERYTOKEN *ppHead, LPQUERYTOKEN *ppTail)
{
    // Trace
    TraceCall("LinkToken");

    // Invalid Args
    Assert(pToken && ppTail);

    // No Next and No Previous
    pToken->pNext = pToken->pPrevious = NULL;

    // No Head yet ?
    if (ppHead && NULL == *ppHead)
    {
        // Set the Head and Tail
        *ppHead = pToken;
    }

    // Otherwise, append to the end
    else if (*ppTail)
    {
        // Set ppTail->pNext
        (*ppTail)->pNext = pToken;

        // Set Previous
        pToken->pPrevious = (*ppTail);
    }

    // Update the Tail
    *ppTail = pToken;

    // AddRef the Token
    pToken->cRefs++;

    // Done
    return(S_OK);
}

//--------------------------------------------------------------------------
// ReleaseToken
//--------------------------------------------------------------------------
HRESULT ReleaseToken(LPQUERYTOKEN *ppToken, CDatabase *pDB)
{
    // Trace
    TraceCall("ReleaseToken");

    // Token
    if (*ppToken)
    {
        // Validate Reference Count
        Assert((*ppToken)->cRefs);

        // Decrement Reference Count
        (*ppToken)->cRefs--;

        // No more refs...
        if (0 == (*ppToken)->cRefs)
        {
            // Free pData
            pDB->HeapFree((*ppToken)->Operand.pRelease);

            // Free pElement
            pDB->HeapFree((*ppToken));
        }

        // Don't Release Again
        *ppToken = NULL;
    }

    // Done
    return(S_OK);
}

//--------------------------------------------------------------------------
// ReleaseTokenList
//--------------------------------------------------------------------------
HRESULT ReleaseTokenList(BOOL fReverse, LPQUERYTOKEN *ppHead, CDatabase *pDB)
{
    // Locals
    LPQUERYTOKEN    pNext;
    LPQUERYTOKEN    pToken=(*ppHead);

    // Trace
    TraceCall("ReleaseTokenList");

    // Walk the Linked List
    while (pToken)
    {
        // Save Next
        pNext = (fReverse ? pToken->pPrevious : pToken->pNext);

        // Free this token
        ReleaseToken(&pToken, pDB);

        // Goto Next
        pToken = pNext;
    }

    // Don't Free Again
    *ppHead = NULL;

    // Done
    return(S_OK);
}

//--------------------------------------------------------------------------
// PGetOperandData
//--------------------------------------------------------------------------
LPVOID PGetOperandData(OPERANDTYPE tyOperand, LPOPERANDINFO pOperand, 
    LPVOID pBinding, LPCTABLESCHEMA pSchema, CDatabase *pDB, 
    IDatabaseExtension *pExtension)
{
    // Locals
    LPVOID      pValue=NULL;

    // Trace
    TraceCall("PGetOperandData");

    // OPERAND_COLUMN
    if (OPERAND_COLUMN == pOperand->tyOperand)
    {
        // Get the Tag 
        LPCTABLECOLUMN pColumn = &pSchema->prgColumn[pOperand->iColumn];

        // MapColumnType
        MapColumnType(pColumn->type, pOperand, pColumn, pBinding, &pValue);
    }

    // OPERAND_STRING
    else if (OPERAND_STRING == pOperand->tyOperand)
    {
        // Better want a string out
        Assert(OPERAND_STRING == tyOperand);

        // Return Data Pointer
        pValue = pOperand->pszString;
    }

    // OPERAND_DWORD
    else if (OPERAND_DWORD == pOperand->tyOperand)
    {
        // Better want a dword out
        Assert(OPERAND_DWORD == tyOperand);

        // Return Data Pointer
        pValue = (LPVOID)&pOperand->dwValue;
    }

    // OPERAND_METHOD
    else if (OPERAND_METHOD == pOperand->tyOperand && pExtension)
    {
        // Better want a dword out
        Assert(OPERAND_DWORD == tyOperand);

        // Call the Method on the Extension
        pExtension->OnExecuteMethod(pOperand->idMethod, pBinding, &pOperand->dwReserved);

        // Return Data Pointer
        pValue = (LPVOID)&pOperand->dwReserved;
    }

    // No Data ?
    if (NULL == pValue)
    {
        // What type of operand was wanted
        switch(tyOperand)
        {
        case OPERAND_STRING:
            pValue = (LPVOID)c_szEmpty;
            break;

        case OPERAND_DWORD:
            pOperand->dwReserved = 0;
            pValue = (LPVOID)&pOperand->dwReserved;
            break;

        default:
            AssertSz(FALSE, "While go ahead and Jimmy my buffet..");
            break;
        }
    }

    // Done
    return(pValue);
}

//--------------------------------------------------------------------------
// GetCommonOperandType
//--------------------------------------------------------------------------
OPERANDTYPE GetCommonOperandType(LPOPERANDINFO pLeft, LPOPERANDINFO pRight,
    LPCTABLESCHEMA pSchema)
{
    // Locals
    OPERANDTYPE tyLeft = (OPERAND_STRING == pLeft->tyOperand ? OPERAND_STRING : OPERAND_DWORD);
    OPERANDTYPE tyRight = (OPERAND_STRING == pRight->tyOperand ? OPERAND_STRING : OPERAND_DWORD);

    // Trace
    TraceCall("GetCommonOperandType");

    // Left is a column
    if (OPERAND_COLUMN == pLeft->tyOperand)
    {
        // Maps to a string
        if (OPERAND_STRING == g_rgColumnTypeInfo[pSchema->prgColumn[pLeft->iColumn].type].tyOperand)
            tyLeft = OPERAND_STRING;
    }

    // Right is a string
    if (OPERAND_COLUMN == pRight->tyOperand)
    {
        // Maps to a String ?
        if (OPERAND_STRING == g_rgColumnTypeInfo[pSchema->prgColumn[pRight->iColumn].type].tyOperand)
            tyRight = OPERAND_STRING;
    }

    // Better be the Same
    Assert(tyLeft == tyRight);

    // Return tyLeft since they are the same
    return(tyLeft);
}

//--------------------------------------------------------------------------
// EvaluateClause
//--------------------------------------------------------------------------
HRESULT EvaluateClause(OPERATORTYPE tyOperator, LPVOID pBinding,
    LPCTABLESCHEMA pSchema, LPQUERYTOKEN *ppStackTop, CDatabase *pDB,
    IDatabaseExtension *pExtension)
{
    // Locals
    HRESULT         hr=S_OK;
    LPVOID          pDataLeft=NULL;
    LPVOID          pDataRight=NULL;
    LPQUERYTOKEN    pTokenResult=NULL;
    LPQUERYTOKEN    pTokenRight=NULL;
    LPQUERYTOKEN    pTokenLeft=NULL;
    OPERANDTYPE     tyOperand;
    INT             nCompare;

    // Trace
    TraceCall("EvaluateClause");

    // Pop the right token
    IF_FAILEXIT(hr = PopStackToken(&pTokenRight, ppStackTop));

    // Pop the left token
    IF_FAILEXIT(hr = PopStackToken(&pTokenLeft, ppStackTop));

    // Better have Data
    Assert(TOKEN_OPERAND == pTokenLeft->tyToken && TOKEN_OPERAND == pTokenRight->tyToken);

    // Compute Operand type
    tyOperand = GetCommonOperandType(&pTokenLeft->Operand, &pTokenRight->Operand, pSchema);

    // Get Left Data
    pDataLeft = PGetOperandData(tyOperand, &pTokenLeft->Operand, pBinding, pSchema, pDB, pExtension);

    // Get Right Data
    pDataRight = PGetOperandData(tyOperand, &pTokenRight->Operand, pBinding, pSchema, pDB, pExtension);

    // Create new Token to push back onto the stack
    IF_NULLEXIT(pTokenResult = (LPQUERYTOKEN)pDB->PHeapAllocate(HEAP_ZERO_MEMORY, sizeof(QUERYTOKEN)));

    // Set Reference Count
    pTokenResult->cRefs = 1;

    // No Token foundyet
    pTokenResult->tyToken = TOKEN_OPERAND;

    // Invalid Symbol Index
    pTokenResult->Operand.iSymbol = 0xffffffff;

    // Set Result
    pTokenResult->Operand.tyOperand = OPERAND_DWORD;

    // EvaluateData
    pTokenResult->Operand.dwValue = EvaluateOperator(tyOperator, tyOperand, pDataLeft, pDataRight);

    // Push the result operand
    PushStackToken(pTokenResult, ppStackTop);
   
exit:
    // Cleanup
    ReleaseToken(&pTokenLeft, pDB);
    ReleaseToken(&pTokenRight, pDB);
    ReleaseToken(&pTokenResult, pDB);

    // Done
    return(hr);
}

//--------------------------------------------------------------------------
// EvaluateEqual
//--------------------------------------------------------------------------
DWORD EvaluateEqual(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (0 == CompareOperands(tyOperand, pDataLeft, pDataRight) ? TRUE : FALSE);
}

//--------------------------------------------------------------------------
// EvaluateNotEqual
//--------------------------------------------------------------------------
DWORD EvaluateNotEqual(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (0 != CompareOperands(tyOperand, pDataLeft, pDataRight) ? TRUE : FALSE);
}

//--------------------------------------------------------------------------
// EvaluateLessThanEqual
//--------------------------------------------------------------------------
DWORD EvaluateLessThanEqual(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (CompareOperands(tyOperand, pDataLeft, pDataRight) <= 0 ? TRUE : FALSE);
}

//--------------------------------------------------------------------------
// EvaluateLessThan
//--------------------------------------------------------------------------
DWORD EvaluateLessThan(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (CompareOperands(tyOperand, pDataLeft, pDataRight) < 0 ? TRUE : FALSE);
}

//--------------------------------------------------------------------------
// EvaluateGreaterThanEqual
//--------------------------------------------------------------------------
DWORD EvaluateGreaterThanEqual(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (CompareOperands(tyOperand, pDataLeft, pDataRight) >= 0 ? TRUE : FALSE);
}

//--------------------------------------------------------------------------
// EvaluateGreaterThan
//--------------------------------------------------------------------------
DWORD EvaluateGreaterThan(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (CompareOperands(tyOperand, pDataLeft, pDataRight) > 0 ? TRUE : FALSE);
}

//--------------------------------------------------------------------------
// EvaluateAnd
//--------------------------------------------------------------------------
DWORD EvaluateAnd(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) && *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// EvaluateBitwiseAnd
//--------------------------------------------------------------------------
DWORD EvaluateBitwiseAnd(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) & *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// EvaluateOr
//--------------------------------------------------------------------------
DWORD EvaluateOr(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) || *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// EvaluateBitwiseOr
//--------------------------------------------------------------------------
DWORD EvaluateBitwiseOr(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) | *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// EvaluateStrStrI
//--------------------------------------------------------------------------
DWORD EvaluateStrStrI(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (NULL == StrStrIA((LPCSTR)pDataLeft, (LPCSTR)pDataRight) ? FALSE : TRUE);
}

//--------------------------------------------------------------------------
// EvaluateStrStr
//--------------------------------------------------------------------------
DWORD EvaluateStrStr(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (NULL == StrStrA((LPCSTR)pDataLeft, (LPCSTR)pDataRight) ? FALSE : TRUE);
}

//--------------------------------------------------------------------------
// EvaluateStrcmpi
//--------------------------------------------------------------------------
DWORD EvaluateStrcmpi(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (lstrcmpi((LPCSTR)pDataLeft, (LPCSTR)pDataRight) == 0 ? TRUE : FALSE);
}

//--------------------------------------------------------------------------
// EvaluateStrcmp
//--------------------------------------------------------------------------
DWORD EvaluateStrcmp(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (lstrcmp((LPCSTR)pDataLeft, (LPCSTR)pDataRight) == 0 ? TRUE : FALSE);
}

//--------------------------------------------------------------------------
// EvaluateAdd
//--------------------------------------------------------------------------
DWORD EvaluateAdd(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) + *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// EvaluateSubtract
//--------------------------------------------------------------------------
DWORD EvaluateSubtract(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) - *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// EvaluateMultiply
//--------------------------------------------------------------------------
DWORD EvaluateMultiply(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) * *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// EvaluateDivide
//--------------------------------------------------------------------------
DWORD EvaluateDivide(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) / *((DWORD *)pDataRight));
}

//--------------------------------------------------------------------------
// EvaluateModula
//--------------------------------------------------------------------------
DWORD EvaluateModula(OPERANDTYPE tyOperand, LPVOID pDataLeft, LPVOID pDataRight) {
    return (INT)(*((DWORD *)pDataLeft) % *((DWORD *)pDataRight));
}