windows-server-2003/inetsrv/query/qutil/querylib/scanner.cxx

//+---------------------------------------------------------------------------
//
//  Copyright (C) 1994-1998, Microsoft Corporation.
//
//  File:   SCANNER.CXX
//
//  Contents:   Implementation of CQueryScanner
//
//  History:    22-May-92   AmyA        Created.
//              23-Jun-92   MikeHew     Added weight token recognition.
//              17-May-94   t-jeffc     Added error info and reg ex support.
//
//----------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::CQueryScanner, public
//
//  Synopsis:   Create a scanner from a string.
//
//  Arguments:  [buffer] -- the string to be scanned.
//              [fLookForTextualKeywords] -- TRUE if the scanner should
//                                           look for "and/or/not/near" in
//                                           text form.
//              [lcid]   -- language for and/or/not/near detection
//              [fTreatPlusAsToken] -- TRUE if the scanner should treat the
//                                           '+' character as a token (used
//                                           in GroupBy parsing)
//
//  Notes:      This string is not copied, so the scanner does not own it.
//              If the string is changed outside of the scanner, it will
//              affect the information that is returned.
//
//  History:    30-Apr-92   AmyA        Created
//
//----------------------------------------------------------------------------

CQueryScanner::CQueryScanner(
    WCHAR const * buffer,
    BOOL fLookForTextualKeywords,
    LCID lcid,
    BOOL fTreatPlusAsToken )
    : _text( buffer ),
      _pBuf( buffer ),
      _pLookAhead( buffer ),
      _fLookForTextualKeywords( fLookForTextualKeywords ),
      _fTreatPlusAsToken( fTreatPlusAsToken ),
      _lcid( lcid )
{
    Accept();
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcceptWord, public
//
//  Synopsis:   Consumes a single word out of a phrase
//
//  Requires:   Should be called after AcqWord
//
//  History:    15-Sep-92   BartoszM    Created
//
//----------------------------------------------------------------------------

void CQueryScanner::AcceptWord()
{
    _pLookAhead = _text;
    Accept();
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcceptColumn, public
//
//  Synopsis:   Consumes a column name out of a phrase
//
//  Requires:   Should be called after AcqColumn
//
//  History:    15-Sep-92   BartoszM    Created
//
//----------------------------------------------------------------------------

void CQueryScanner::AcceptColumn()
{
    AcceptWord();
}


struct SStringToken
{
    WCHAR *  pwcToken;
    unsigned cwc;
    Token    token;
};

static SStringToken s_EnglishStringTokens[] =
{
    { L"AND",    (sizeof L"AND" / sizeof WCHAR) - 1,    AND_TOKEN },
    { L"OR",     (sizeof L"OR" / sizeof WCHAR) - 1,     OR_TOKEN },
    { L"NOT",    (sizeof L"NOT" / sizeof WCHAR) - 1,    NOT_TOKEN },
    { L"NEAR",   (sizeof L"NEAR" / sizeof WCHAR) - 1,   PROX_TOKEN },
};

static SStringToken s_GermanStringTokens[] =
{
    { L"UND",    (sizeof L"UND" / sizeof WCHAR) - 1,    AND_TOKEN },
    { L"ODER",   (sizeof L"ODER" / sizeof WCHAR) - 1,   OR_TOKEN },
    { L"NICHT",  (sizeof L"NICHT" / sizeof WCHAR) - 1,  NOT_TOKEN },
    { L"NAH",    (sizeof L"NAH" / sizeof WCHAR) - 1,    PROX_TOKEN },
};

static SStringToken s_FrenchStringTokens[] =
{
    { L"ET",     (sizeof L"ET" / sizeof WCHAR) - 1,     AND_TOKEN },
    { L"OU",     (sizeof L"OU" / sizeof WCHAR) - 1,     OR_TOKEN },
    { L"SANS",   (sizeof L"SANS" / sizeof WCHAR) - 1,   NOT_TOKEN },
    { L"PRES",   (sizeof L"PRES" / sizeof WCHAR) - 1,   PROX_TOKEN },
};

static SStringToken s_SpanishStringTokens[] =
{
    { L"Y",      (sizeof L"Y" / sizeof WCHAR) - 1,      AND_TOKEN },
    { L"O",      (sizeof L"O" / sizeof WCHAR) - 1,      OR_TOKEN },
    { L"NO",     (sizeof L"NO" / sizeof WCHAR) - 1,     NOT_TOKEN },
    { L"CERCA",  (sizeof L"CERCA" / sizeof WCHAR) - 1,  PROX_TOKEN },
};

static SStringToken s_DutchStringTokens[] =
{
    { L"EN",     (sizeof L"EN" / sizeof WCHAR) - 1,     AND_TOKEN },
    { L"OF",     (sizeof L"OF" / sizeof WCHAR) - 1,     OR_TOKEN },
    { L"NIET",   (sizeof L"NIET" / sizeof WCHAR) - 1,   NOT_TOKEN },
    { L"NABIJ",  (sizeof L"NABIJ" / sizeof WCHAR) - 1,  PROX_TOKEN },
};

static WCHAR aSwedishNear[] = { L'N', 0xc4, L'R', L'A', 0 };

static SStringToken s_SwedishStringTokens[] =
{
    { L"OCH",    (sizeof L"OCH" / sizeof WCHAR) - 1,    AND_TOKEN },
    { L"ELLER",  (sizeof L"ELLER" / sizeof WCHAR) - 1,  OR_TOKEN },
    { L"INTE",   (sizeof L"INTE" / sizeof WCHAR) - 1,   NOT_TOKEN },
    { aSwedishNear, 4,                                  PROX_TOKEN },
};

static SStringToken s_ItalianStringTokens[] =
{
    { L"E",      (sizeof L"E" / sizeof WCHAR) - 1,      AND_TOKEN },
    { L"O",      (sizeof L"O" / sizeof WCHAR) - 1,      OR_TOKEN },
    { L"NO",     (sizeof L"NO" / sizeof WCHAR) - 1,     NOT_TOKEN },
    { L"VICINO", (sizeof L"VICINO" / sizeof WCHAR) - 1, PROX_TOKEN },
};

const unsigned cStringTokens = sizeof(s_EnglishStringTokens) /
                               sizeof(s_EnglishStringTokens[0]);

#define WORD_STR  L"{}!&|~*@#()[],\t=<>\n\"^ "

//+---------------------------------------------------------------------------
//
//  Function:   InternalFindStringToken
//
//  Synopsis:   Looks for a textual token in plain text.
//
//  Arguments:  [pwcIn]   -- string to search
//              [token]   -- returns the token found
//              [cwc]     -- returns length of token found
//              [pTokens] -- token array to use
//
//  Returns:    Pointer to token or 0 if none was found
//
//  History:    08-Feb-96   dlee        created
//
//----------------------------------------------------------------------------

WCHAR * InternalFindStringToken(
    WCHAR *        pwcIn,
    Token &        token,
    unsigned &     cwc,
    SStringToken * pTokens )
{
    // for each of and/or/not/near

    WCHAR *pwcOut = 0;

    for ( unsigned i = 0; i < cStringTokens; i++ )
    {
        WCHAR *pwcStr = wcsstr( pwcIn, pTokens[i].pwcToken );

        while ( pwcStr )
        {
            // found a match -- does it have white space on either side?

            WCHAR wcBeyond = * (pwcStr + pTokens[i].cwc);
            if ( ( ( 0 == wcBeyond ) ||
                   ( wcschr( WORD_STR, wcBeyond ) ) ) &&
                 ( ( pwcStr == pwcIn ) ||
                   ( iswspace( * ( pwcStr - 1 ) ) ) ) )
            {
                // if the first match found or the match closest to the
                // beginning of the string, use it.

                if ( ( 0 == pwcOut ) ||
                     ( pwcStr < pwcOut ) )
                {
                    pwcOut = pwcStr;
                    token = pTokens[i].token;
                    cwc = pTokens[i].cwc;
                }

                break;
            }

            pwcStr = wcsstr( pwcStr + 1, pTokens[i].pwcToken );
        }
    }

    return pwcOut;
} //InternalFindStringToken

SStringToken * GetStringTokenArray(
    LCID lcid )
{
    SStringToken *pTokens;

    switch ( PRIMARYLANGID( LANGIDFROMLCID( lcid ) ) )
    {
        case LANG_GERMAN :
            pTokens = s_GermanStringTokens;
            break;
        case LANG_FRENCH :
            pTokens = s_FrenchStringTokens;
            break;
        case LANG_SPANISH :
            pTokens = s_SpanishStringTokens;
            break;
        case LANG_DUTCH :
            pTokens = s_DutchStringTokens;
            break;
        case LANG_SWEDISH :
            pTokens = s_SwedishStringTokens;
            break;
        case LANG_ITALIAN :
            pTokens = s_ItalianStringTokens;
            break;
        case LANG_NEUTRAL :
        case LANG_ENGLISH :
        default :
            pTokens = s_EnglishStringTokens;
            break;
    }

    Win4Assert( 0 != pTokens );

    return pTokens;
}

//+---------------------------------------------------------------------------
//
//  Function:   FindStringToken
//
//  Synopsis:   Looks for a textual token in plain text.  Always tries
//              English, tries a different language depending on _lcid.
//
//  Arguments:  [pwcIn] -- string to search
//              [token] -- returns the token found
//              [cwc]   -- returns length of token found
//
//  Returns:    Pointer to token or 0 if none was found
//
//  History:    08-Feb-96   dlee        created
//
//----------------------------------------------------------------------------

WCHAR * CQueryScanner::FindStringToken(
    WCHAR *    pwcIn,
    Token &    token,
    unsigned & cwc )
{
    SStringToken * pTokens = GetStringTokenArray( _lcid );

    WCHAR * pwcToken = InternalFindStringToken( pwcIn, token, cwc, pTokens );

    // if the search above wasn't in English, try English too.

    if ( pTokens != s_EnglishStringTokens )
    {
        unsigned cwcEnglish;
        Token tokenEnglish;
        WCHAR * pwcEnglish = InternalFindStringToken( pwcIn,
                                                      tokenEnglish,
                                                      cwcEnglish,
                                                      s_EnglishStringTokens );

        // If there is no language-specific match or the English match
        // occurs before the language-specific match, use the English
        // match.

        if ( ( 0 != pwcEnglish ) &&
             ( ( 0 == pwcToken ) || ( pwcEnglish < pwcToken ) ) )
        {
            pwcToken = pwcEnglish;
            token = tokenEnglish;
            cwc = cwcEnglish;
        }
    }

    return pwcToken;
} //FindStringToken

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::Accept, public
//
//  Synopsis:   Determines what the next token is.  Will advance _pLookAhead
//              over the next token and white space.
//
//  Notes:      There are five different types of TEXT_TOKENS, Phrase, Path,
//              Number, Column and Command.  Since the length of the token
//              depends on which token it is, _pLookAhead is forwarded to the
//              end of the longest, and _text is used to parse the token in the
//              various Acq and Get methods.
//
//  History:    30-Apr-92   AmyA        Created
//              19-May-92   AmyA        Added Guid hack
//              23-Jun-92   MikeHew     Added weight token recognition.
//              26-May-94   t-jeffc     Added more tokens; rearranged to
//                                      support parsing errors
//
//----------------------------------------------------------------------------

void CQueryScanner::Accept()
{
    EatWhiteSpace();

    _text = _pLookAhead;

    switch ( *_pLookAhead )
    {
    case '&':
        _pLookAhead++;
        _token = AND_TOKEN;
        break;

    case '*':
        _pLookAhead++;

        if ( *_pLookAhead == '*' )
        {
            _token = FUZ2_TOKEN;
            _pLookAhead++;
        }
        else
            _token = FUZZY_TOKEN;
        break;

    case '=':
        _pLookAhead++;
        _token = EQUAL_TOKEN;
        break;

    case '<':
        _pLookAhead++;
        if ( *_pLookAhead == '=' )
        {
            _token = LESS_EQUAL_TOKEN;
            _pLookAhead++;
        }
        else
            _token = LESS_TOKEN;
        break;

    case '>':
        _pLookAhead++;
        if ( *_pLookAhead == '=' )
        {
            _token = GREATER_EQUAL_TOKEN;
            _pLookAhead++;
        }
        else
            _token = GREATER_TOKEN;
        break;

    case '!':
        _pLookAhead++;
        if ( *_pLookAhead == '=' )
        {
            _token = NOT_EQUAL_TOKEN;
            _pLookAhead++;
        }
        else
        {
            _token = NOT_TOKEN;
        }
        break;

    case '|':
        _pLookAhead++;
        _token = OR_TOKEN;
        break;

    case '~':
        _pLookAhead++;
        _token = PROX_TOKEN;
        break;

    case '@':
        _pLookAhead++;
        _token = PROP_TOKEN;
        break;

    case '#':
        _pLookAhead++;
        _token = PROP_REGEX_TOKEN;
        break;

    case '(':
        _pLookAhead++;
        _token = OPEN_TOKEN;
        break;

    case ')':
        _pLookAhead++;
        _token = CLOSE_TOKEN;
        break;

    case '[':
        _pLookAhead++;
        _token = W_OPEN_TOKEN;
        break;

    case ']':
        _pLookAhead++;
        _token = W_CLOSE_TOKEN;
        break;

    case ',':
        _pLookAhead++;
        _token = COMMA_TOKEN;
        break;

    case '\0':
    case 0x1A:  // CTRL-Z
        _token = EOS_TOKEN;
        break;

    case '"':
        _pLookAhead++;
        _token = QUOTES_TOKEN;
        break;

    case '$':
        _pLookAhead++;
        _token = PROP_NATLANG_TOKEN;
        break;

    case '{':
       _pLookAhead++;
      _token = C_OPEN_TOKEN;
      break;

    case '}':
       _pLookAhead++;
      _token = C_CLOSE_TOKEN;
      break;

    case '^':
    {
        WCHAR wc = *(_pLookAhead + 1);

        BOOL fOk = TRUE;

        if (L'a' == wc) // all bits
            _token = ALLOF_TOKEN;
        else if (L's' == wc) // some bits
            _token = SOMEOF_TOKEN;
        else
            fOk = FALSE;

        if (fOk)
        {
            _pLookAhead += 2;
            break;
        }
    }
    // FALL THROUGH

    case '+':
        if (*_pLookAhead == L'+' && _fTreatPlusAsToken)
        {
            _pLookAhead++;
            _token = PLUS_TOKEN;
            break;
        }
    // FALL THROUGH

    default:
    {
        // forwards pwcEnd over anything that could be in a phrase,
        // which is the most inclusive of the TEXT_TOKENs.
        // (except, for regex's and phrases in quotes - but they're
        // handled separately)

        WCHAR const *pwcEnd = _text + wcscspn( _text, PHRASE_STR );

        if ( _fLookForTextualKeywords )
        {
            unsigned cwc = (unsigned) ( pwcEnd - _text );
            cwc = __min( cwc, MAX_PATH * 2 );

            // if a textual keyword is beyond 500 chars in the string,
            // blow it off -- the workaround is to use the '&|~' version.

            WCHAR awcBuf[ 1 + MAX_PATH * 2 ];
            RtlCopyMemory( awcBuf, _text, cwc * sizeof WCHAR );
            awcBuf[ cwc ] = 0;

            ULONG cwcOut = LCMapString( _lcid,
                                        LCMAP_UPPERCASE,
                                        awcBuf,
                                        cwc,
                                        awcBuf,
                                        cwc );
            if ( cwcOut != cwc )
                THROW( CException() );

            Token token;
            unsigned cwcToken;
            WCHAR *pwcTok = FindStringToken( awcBuf, token, cwcToken );

            if ( 0 != pwcTok )
            {
                // a textual token exists in the string

                if ( pwcTok == awcBuf )
                {
                    // textual token at the start of the string

                    _token = token;
                    _pLookAhead = _text + cwcToken;
                }
                else
                {
                    // textual token in the middle of the string, stop the
                    // current token at that point and get it next time
                    // Accept() is called.

                    _pLookAhead = _text + ( pwcTok - awcBuf );
                    _token = TEXT_TOKEN;
                }
            }
            else
            {
                _pLookAhead = pwcEnd;
                _token = TEXT_TOKEN;
            }
        }
        else
        {
            _pLookAhead = pwcEnd;
            _token = TEXT_TOKEN;
        }

        break;
    }
    }
}


//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AllocReturnString, private inline
//
//  Synopsis:   Copies all of the relevant characters of the string that
//              _text is pointing to and returns the new string.
//
//  History:    17 Apr 97   AlanW       Created
//
//----------------------------------------------------------------------------

inline WCHAR * CQueryScanner::AllocReturnString( int cch )
{
    WCHAR * newBuf = new WCHAR [ cch + 1 ];
    RtlCopyMemory ( newBuf, _text, cch * sizeof(WCHAR));
    newBuf[cch] = L'\0';

    _text += cch;
    while ( iswspace(*_text) )
        _text++;

    return newBuf;
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcqPath, public
//
//  Synopsis:   Copies all of the relevant characters of the string that
//              _text is pointing to and returns the new string.  Will
//              return 0 if _text is at end of whole TEXT_TOKEN.
//
//  Notes:      Since the string is copied, the caller of this function is
//              responsible for freeing the memory occupied by the string.
//              This method can be called several times before calling
//              Accept(), so many paths can be acquired if they exist in the
//              scanner.
//
//  History:    30-Apr-92   AmyA        Created
//
//----------------------------------------------------------------------------

WCHAR * CQueryScanner::AcqPath()
{
    if ( IsEndOfTextToken() )
        return 0;

    // how many characters follow _text that are not in CMND_STR?

    int count = wcscspn( _text, CMND_STR );

    return AllocReturnString( count );
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcqWord, public
//
//  Synopsis:   Copies the word that _text is pointing to and returns the
//              new string. Positions _text after the word and whitespace.
//              Returns 0 if at the end of a TEXT_TOKEN.
//
//  History:    29-Jun-92    MikeHew    Created.
//
//----------------------------------------------------------------------------

WCHAR * CQueryScanner::AcqWord()
{
    if ( IsEndOfTextToken() )
        return 0;

    WCHAR const * pEnd = _text;

    while ( !iswspace(*pEnd) && pEnd < _pLookAhead )
        pEnd++;

    unsigned count = CiPtrToUint( pEnd - _text );

    return AllocReturnString( count );
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcqColumn, public
//
//  Synopsis:   Copies a column name and returns the new string.  A column
//              name is either a single word, or a quoted string.
//              Positions _text after the word and whitespace.
//
//  Returns:    WCHAR* pointer to column name.  0 if no column name found.
//
//  History:    17 Apr 97    AlanW      Created.
//
//----------------------------------------------------------------------------

WCHAR * CQueryScanner::AcqColumn()
{
    if ( QUOTES_TOKEN == _token)
    {
        Accept();
        WCHAR * pwszOut = AcqPhraseInQuotes();
        _text = _pLookAhead;
        return pwszOut;
    }

    if ( IsEndOfTextToken() )
        return 0;

    int count = wcscspn( _text, COLUMN_STR );
    return AllocReturnString( count );
}


//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcqPhrase, public
//
//  Synopsis:   Copies all of the relevant characters of the string that
//              _text is pointing to and returns the new string.
//              Returns 0 if at the end of a text token.
//
//  Notes:      Since the string is copied, the caller of this function is
//              responsible for freeing the memory occupied by the string.
//              The difference between this function and AcqPath is that this
//              should only be called once before calling Accept().
//
//  History:    30-Apr-92   AmyA        Created
//              09-May-96   DwightKr    Strip trailing white space
//
//----------------------------------------------------------------------------

WCHAR * CQueryScanner::AcqPhrase()
{
    if( IsEndOfTextToken() )
        return 0;

    //
    //  Strip trailing white-space from the end of the phrase.  _pLookAhead
    //  points to the first character of the NEXT phrase.
    //
    WCHAR const * pEnd = _pLookAhead - 1;
    while ( (pEnd > _text) && iswspace(*pEnd) )
    {
        pEnd--;
    }

    unsigned count = CiPtrToUint( pEnd - _text ) + 1;

    WCHAR * newBuf = new WCHAR [ count + 1 ];
    RtlCopyMemory( newBuf, _text, count * sizeof( WCHAR ) );
    newBuf[count] = 0;

    return newBuf;
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcqRegEx, public
//
//  Synopsis:   Copies all of the relevant characters of the string that
//              _text is pointing to and returns the new string.  Matches
//              the longest string possible - the only restriction is that
//              the regex can not contain any of the characters in REGEX_STR
//              outside of <> braces (which may be nested).
//              Returns 0 if the regex is empty.
//
//  Notes:      Since the string is copied, the caller of this function is
//              responsible for freeing the memory occupied by the string.
//              Because some regex characters are duplicated in the query
//              language, _pLookAhead is ignored (and actually reset) in
//              this operation.  Like AcqPhrase(), this should be called only
//              once before Accept().
//
//  History:    10-May-94   t-jeffc     Created
//
//----------------------------------------------------------------------------

WCHAR * CQueryScanner::AcqRegEx()
{
    WCHAR const * pEnd = _text;
    BOOL fDone = FALSE;
    BOOL fQuoted = FALSE;

    if ( *pEnd == L'"' )
    {
        fQuoted = TRUE;
        pEnd++;
    }

    // scan the string - stop at \0 or if any REGEX_STR characters are
    // found outside of braces
    //
    for( ;; )
    {
        switch( *pEnd )
        {
        case '\0':
            if ( fQuoted )
                THROW( CException( QPARSE_E_UNEXPECTED_EOS ) );

            fDone = TRUE;
            break;

        case ' ':
            if ( !fQuoted )
                fDone = TRUE;
            break;

        case ')':
            if ( !fQuoted )
            {
                if ( ( pEnd != _text ) &&
                     ( '|' != (*(pEnd-1)) ) )
                    fDone = TRUE;
            }
            break;

        case '"':
            if ( fQuoted )
            {
                pEnd++;
                fDone = TRUE;
            }
            break;

        default:
            break;

        } // switch( *pEnd )

        if( fDone ) break;

        pEnd++;
    }

    if( _text == pEnd )
        return 0;

    // set _pLookAhead
    _pLookAhead = pEnd;

    // copy the string
    unsigned count = CiPtrToUint( _pLookAhead - _text );

    if ( fQuoted )
    {
        Win4Assert( count >= 2 );
        count -= 2;
    }
        
    WCHAR * newBuf = new WCHAR[ count + 1 ];

    RtlCopyMemory( newBuf, _text + (fQuoted ? 1 : 0), count * sizeof( WCHAR ) );
    newBuf[ count ] = 0;

    return newBuf;

}


//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcqPhraseInQuotes, public
//
//  Synopsis:   Copies all characters until a matching " is found, or until
//              the end of string.  Embedded quotes are escaped with a quote:
//              "Bill ""the man"" Gates"
//
//  Notes:      Since the string is copied, the caller of this function is
//              responsible for freeing the memory occupied by the string.
//
//  History:    18-Jan-95   SitaramR        Created
//               3-Jul-96   dlee            added embedded quotes
//
//----------------------------------------------------------------------------

WCHAR * CQueryScanner::AcqPhraseInQuotes()
{
    WCHAR const * pEnd = _text;

    do
    {
        if ( 0 == *pEnd )
            break;

        if ( L'"' == *pEnd )
        {
            if ( L'"' == *(pEnd+1) )
                pEnd++;
            else
                break;
        }

        pEnd++;
    } while ( TRUE );

    unsigned count = CiPtrToUint( pEnd - _text );

    WCHAR * newBuf = new WCHAR [ count + 1 ];
    WCHAR * pwcNewBuf = newBuf;
    WCHAR const * pStart = _text;

    // copy the string, but remove the extra quote characters

    while ( pStart < pEnd )
    {
        *pwcNewBuf++ = *pStart++;
        if ( L'"' == *pStart )
            pStart++;
    }

    *pwcNewBuf = 0;

    if ( *pEnd == L'"' )
        _pLookAhead = pEnd + 1;
    else
        _pLookAhead = pEnd;

    return newBuf;
}



//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::GetNumber, public
//
//  Synopsis:   If _text is at the end of the TEXT_TOKEN, returns FALSE.
//              If not, puts the ULONG from the scanner into number and
//              returns TRUE.
//
//  Arguments:  [number] -- the ULONG which will be changed and passed back
//                          out as the ULONG from the scanner.
//              [fAtEnd] -- returns TRUE if at the end of the scanned string
//
//  Notes:      May be called several times in a loop before Accept() is
//              called.
//
//  History:    11-May-92   AmyA        Created
//
//----------------------------------------------------------------------------
BOOL CQueryScanner::GetNumber( ULONG & number, BOOL & fAtEnd )
{
    if ( IsEndOfTextToken() || !iswdigit(*_text) || (*_text == L'-') )
        return FALSE;

    // is this a hex number?

    ULONG base = 10;

    if (_text[0] == L'0' && (_text[1] == L'x' || _text[1] == L'X'))
    {
        _text += 2;
        base = 16;
    }

    const WCHAR * pwcStart = _text;

    number = wcstoul( _text, (WCHAR **)(&_text), base );

    // looks like a real number?

    if ( ( pwcStart == _text ) ||
         ( L'.' == *_text ) )
        return FALSE;

    while ( iswspace(*_text) )
        _text++;

    fAtEnd = ( 0 == *_text );

    return TRUE;
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::GetNumber, public
//
//  Synopsis:   If _text is at the end of the TEXT_TOKEN, returns FALSE.
//              If not, puts the LONG from the scanner into number and
//              returns TRUE.
//
//  Arguments:  [number] -- the LONG which will be changed and passed back
//                          out as the LONG from the scanner.
//              [fAtEnd] -- returns TRUE if at the end of the scanned string
//
//  Notes:      May be called several times in a loop before Accept() is
//              called.
//
//  History:    96-Jan-15   DwightKr    Created
//
//----------------------------------------------------------------------------
BOOL CQueryScanner::GetNumber( LONG & number, BOOL & fAtEnd )
{
    WCHAR *text = (WCHAR *) _text;

    BOOL IsNegative = FALSE;

    ULONG ulMax = (ULONG) LONG_MAX;

    if ( L'-' == _text[0] )
    {
        IsNegative = TRUE;

        ulMax++; // can represent 1 more negative than positive.

        _text++;
    }

    ULONG ulNumber;
    if ( !GetNumber( ulNumber, fAtEnd ) )
    {
        _text = text;
        return FALSE;
    }

    //  Signed number overflow/underflow

    if ( ulNumber > ulMax )
    {
        _text = text;
        return FALSE;
    }

    if ( IsNegative )
    {
        if ( ulMax == ulNumber )
            number = LONG_MIN;
        else
            number = - (LONG) ulNumber;
    }
    else
    {
        number = (LONG) ulNumber;
    }

    return TRUE;
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::GetNumber, public
//
//  Synopsis:   If _text is at the end of the TEXT_TOKEN, returns FALSE.
//              If not, puts the ULONG from the scanner into number and
//              returns TRUE.
//
//  Arguments:  [number] -- the ULONG which will be changed and passed back
//                          out as the ULONG from the scanner.
//              [fAtEnd] -- returns TRUE if at the end of the scanned string
//
//  Notes:      May be called several times in a loop before Accept() is
//              called.
//
//  History:    27-Feb-96   dlee        Created
//
//----------------------------------------------------------------------------
BOOL CQueryScanner::GetNumber( unsigned _int64 & number, BOOL & fAtEnd )
{
    if ( IsEndOfTextToken() || !iswdigit(*_text) || (*_text == L'-') )
        return FALSE;

    // is this a hex number?

    ULONG base = 10;

    if (_text[0] == L'0' && (_text[1] == L'x' || _text[1] == L'X'))
    {
        _text += 2;
        base = 16;
    }

    const WCHAR * pwcStart = _text;

    number = _wcstoui64( _text, (WCHAR **)(&_text), base );

    // looks like a real number?

    if ( ( pwcStart == _text ) ||
         ( L'.' == *_text ) )
        return FALSE;

    while ( iswspace(*_text) )
        _text++;

    fAtEnd = ( 0 == *_text );

    return TRUE;
}


//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::GetNumber, public
//
//  Synopsis:   If _text is at the end of the TEXT_TOKEN, returns FALSE.
//              If not, puts the LONG from the scanner into number and
//              returns TRUE.
//
//  Arguments:  [number] -- the LONG which will be changed and passed back
//                          out as the LONG from the scanner.
//              [fAtEnd] -- returns TRUE if at the end of the scanned string
//
//  Notes:      May be called several times in a loop before Accept() is
//              called.
//
//  History:    27-Feb-96   dlee        Created
//
//----------------------------------------------------------------------------
BOOL CQueryScanner::GetNumber( _int64 & number, BOOL & fAtEnd )
{
    WCHAR *text = (WCHAR *) _text;

    BOOL IsNegative = FALSE;

    unsigned _int64 ullMax = (unsigned _int64) _I64_MAX;

    if ( L'-' == _text[0] )
    {
        IsNegative = TRUE;

        ullMax++; // can represent 1 more negative than positive.

        _text++;
    }

    unsigned _int64 ullNumber;
    if ( !GetNumber( ullNumber, fAtEnd ) )
    {
        _text = text;
        return FALSE;
    }

    //  Signed number overflow/underflow

    if ( ullNumber > ullMax )
    {
        _text = text;
        return FALSE;
    }

    if ( IsNegative )
    {
        if ( ullMax == ullNumber )
            number = _I64_MIN;
        else
            number = -((_int64) ullNumber);
    }
    else
    {
        number = (_int64) ullNumber;
    }

    return TRUE;
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::GetNumber, public
//
//  Synopsis:   If _text is at the end of the TEXT_TOKEN, returns FALSE.
//              If not, puts the LONG from the scanner into number and
//              returns TRUE.
//
//  Arguments:  [number] -- the double which will be changed and passed back
//                          out as the double from the scanner.
//
//  Notes:      May be called several times in a loop before Accept() is
//              called.
//
//  History:    96-Jan-15   DwightKr    Created
//
//----------------------------------------------------------------------------
BOOL CQueryScanner::GetNumber( double & number )
{
    if ( IsEndOfTextToken() || !iswdigit(*_text) )
        return FALSE;

    if ( swscanf( _text, L"%lf", &number ) != 1 )
    {
        return FALSE;
    }

    while ( iswspace(*_text) != 0 )
        _text++;

    return TRUE;
}


//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::GetCommandChar, public
//
//  Synopsis:   Returns the command character pointed to by _text and advances
//              _text.  If the command can't be uniquely determined by the
//              first character, each subsequent call will return the next
//              character in the word.  After the command has been determined,
//              AcceptCommand() should be called and then operand parsing may begin.
//
//  History:    14-May-92   AmyA        Created
//              16-May-94   t-jeffc     Returns one character at a time to
//                                      support more commands
//
//----------------------------------------------------------------------------

WCHAR CQueryScanner::GetCommandChar()
{
    if( IsEndOfTextToken() )
        return 0;

    WCHAR chCommand = _text[0];

    _text++;

    return towlower( chCommand );
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcceptCommand, public
//
//  Synopsis:   Advances _text past any characters in the command.
//              Used when enough command characters have been
//              read to uniquely determine the command and begin parsing
//              the operands.
//
//  History:    16-May-94   t-jeffc         Created
//
//----------------------------------------------------------------------------

void  CQueryScanner::AcceptCommand()
{
    int cChars = wcscspn( _text, CMND_STR ); // how many characters follow
                                             // _text that are not in CMND_STR

    _text += cChars;

    _pLookAhead = _text;

    Accept();
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::ResetBuffer, public
//
//  Synopsis:   Puts a new string into _pBuf and resets _pLookAhead
//              accordingly.
//
//  Arguments:  [buffer] -- the new string for _pBuf
//
//  History:    05-May-92   AmyA        Created
//
//----------------------------------------------------------------------------

void CQueryScanner::ResetBuffer( WCHAR const * buffer )
{
    _pBuf = buffer;
    _pLookAhead = _pBuf;
    Accept();
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::EatWhiteSpace, private
//
//  Synopsis:   Advances _pLookAhead past any white space in the string.
//
//  History:    29-Apr-92   AmyA        Created
//
//----------------------------------------------------------------------------

void CQueryScanner::EatWhiteSpace()
{
    while ( iswspace(*_pLookAhead) != 0 )
        _pLookAhead++;
}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::IsEndOfTextToken, private
//
//  Synopsis:   Returns TRUE if the current token is not a TEXT_TOKEN or
//              if the string starting at _text to _pLookAhead contains
//              nothing but whitespace.
//
//  History:    27-May-94   t-jeffc     Created
//
//----------------------------------------------------------------------------

BOOL CQueryScanner::IsEndOfTextToken()
{
    if( _token == TEXT_TOKEN && _text < _pLookAhead )
        return FALSE;
    else
        return TRUE;

}

//+---------------------------------------------------------------------------
//
//  Member:     CQueryScanner::AcqLine, public
//
//  Synopsis:   Copies all of the remaining characters on the line;
//              return 0 if _text is at end of whole TEXT_TOKEN.
//
//  Arguments:  [fParseQuotes] -- if TRUE, initial and final quotes are removed
//
//  Notes:      Since the string is copied, the caller of this function is
//              responsible for freeing the memory occupied by the string.
//              This method can be called several times before calling
//              Accept(), so many paths can be acquired if they exist in the
//              scanner.
//
//  History:    96-Jan-03   DwightKr    Created
//              96-Feb-26   DwightKr    Allow lines to be quoted
//
//----------------------------------------------------------------------------

WCHAR * CQueryScanner::AcqLine( BOOL fParseQuotes )
{
    if ( *_text == L'\0' )
        return 0;

    unsigned cwcBuffer = wcslen(_text);

    //
    // If there are \r, \n, or other white space at the end of the string,
    // strip it off
    //

    while ( cwcBuffer > 0 && _text[cwcBuffer-1] <= L' ' )
        cwcBuffer--;

    if ( fParseQuotes )
    {
        //
        //  If there is a pair of quotes delimiting this line, strip them off
        //
    
        if ( (L'"' == _text[0]) && (cwcBuffer > 1) )
        {
            if ( L'"' == _text[cwcBuffer-1] )
                cwcBuffer--;
    
            _text++;
            cwcBuffer--;
        }
    }

    WCHAR *pText = new WCHAR [ cwcBuffer + 1 ];
    RtlCopyMemory( pText, _text, cwcBuffer * sizeof(WCHAR) );
    pText[cwcBuffer] = 0;

    _pLookAhead = _text + cwcBuffer - 1;

    return pText;
} //AcqLine