%{
//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1997 - 2000.
//
//  File:       parser.l
//
//  Contents:   Lex rules for parser
//
//  Notes:      Written for flex version 2.5.4
//
//  History:    10-01-97        emilyb  created
//
//----------------------------------------------------------------------------

class CValueParser;

#include "yybase.hxx"
#include "parser.h" 
#include "parsepl.h"
#include "flexcpp.h"

#define TOKEN(tknNum)  return (tknNum);
#define STRING_VALUE(tknNum, fLong, fQuote)     \
        {       \
            if (!IsTokenEmpty())        \
                return CreateTknValue(yylval, tknNum, fLong, fQuote);   \
        }

/*
** Make Lex read from a block of data
**    buffer is the character buffer,
**    result is a variable to store the number of chars read
**    ms is the size of the buffer
*/
#undef YY_INPUT
#define YY_INPUT(b, r, ms) (r = yybufferinput(b, ms))

DECLARE_INFOLEVEL(yacc)

//+---------------------------------------------------------------------------
//
//  Function:   YYLEXER::IsTokenEmpty 
//
//  Synopsis:   Determines if a token is empty. An empty token only has 
//              whitespace or has nothing in it.
//
//  Arguments:  None.
//
//  Returns:    Boolean value.
//
//  History:    08-APR-98        KrishnaN  created
//
//----------------------------------------------------------------------------

BOOL YYLEXER::IsTokenEmpty()
{
    LPWSTR pwsz = yytext;
    
    Win4Assert(pwsz);
    
    while (*pwsz != 0)
    {
        if (*pwsz != L' ' && *pwsz != L'\t')
            return FALSE;
        pwsz++;
    }
    
    return TRUE;
}


//+---------------------------------------------------------------------------
//
//  Function:   YYLEXER::IsNotOperator 
//
//  Synopsis:   Determines if we have a not operator.
//
//  Arguments:  None.
//
//  Returns:    Boolean value.
//
//  History:    08-DEC-98        KrishnaN  created
//
//----------------------------------------------------------------------------

BOOL YYLEXER::IsNotOperator()
{
    LPWSTR pwsz = yytext;
    
    Win4Assert(pwsz);
    
    // skip past leading spaces
    int i = 0;
    while (*pwsz != 0 && (*pwsz == L' ' || *pwsz == L'\t'))
    {
        pwsz++;
        i++;
    }
    
    // If we don't have at least four chars to consider, we don't have a 
    // not operator.
    if (yyleng < i+4)
        return FALSE;
    
    if ( (*pwsz == L'n' || *pwsz == L'N') &&
         (*(pwsz+1) == L'o' || *(pwsz+1) == L'O') &&
         (*(pwsz+2) == L't' || *(pwsz+2) == L'T') &&
         (*(pwsz+3) == L'@' || *(pwsz+3) == L'#' || *(pwsz+3) == L'$')
       )
        return TRUE;
    else
        return FALSE;
}

//+---------------------------------------------------------------------------
//
//  Function:   YYLEXER::CreateTknValue 
//
//  Synopsis:   Allocs a WCHAR string which is passed to the YACC value stack.  
//
//  Arguments:  [ppStg]  -- set to pointer to alloc'd memory
//              [tknNum] -- token id
//              [fLong]  -- true if token is in longhand version
//              [fQuote] -- true if token is quoted
//
//  Returns:    Updated token id
//
//  History:    10-01-97        emilyb  created
//
//----------------------------------------------------------------------------

short YYLEXER::CreateTknValue(YYSTYPE *ppStg, short tknNum, BOOL fLong, BOOL fQuote )
{
    HRESULT hr = S_OK;
    short retTkn = tknNum;
    LPWSTR pwsz = yytext;
    
    if (!fQuote)    
    {
        // If we see a double quote, consider the string quoted.
        while (L' ' == *pwsz)
            pwsz++;
        if (*pwsz == L'"')
        {
            // strip trailing blanks and check if we see a trailing "
            
            LPWSTR pLast = pwsz + wcslen(pwsz) - 1;

            while (pLast >= pwsz && L' ' == *pLast )
            {
                *pLast = L'\0';
                pLast--;
            }
            
            if (*pLast == L'"' && pLast > pwsz )
                fQuote = TRUE;
        }
    }
    
    // start parsing from the beginning of the string
    pwsz = yytext;
    
    if (_PHRASEORREGEX == tknNum)
    {
        // A quoted string is always a phrase.
        if (fQuote)
            retTkn = _PHRASE;
        else
            retTkn = DetermineTokenType();
    }

    switch (retTkn)
    {
    case _PHRASE:

        {    
            LPWSTR pLast;

            pLast = pwsz + wcslen(pwsz) - 1;

            // if long version, find the phrase
            if (fLong)
            {
                pwsz = pwsz + wcslen(L"{phrase}");
                pLast = pLast - wcslen(L"{/phrase}"+1);
                Win4Assert(*pLast == L'{');
                *pLast = L'\0';
            }

            // strip leading and trailing blanks            
            while (L' ' == *pwsz)
                pwsz++;

            pLast = pwsz + wcslen(pwsz) - 1;

            while (pLast >= pwsz && L' ' == *pLast )
            {
                *pLast = L'\0';
                pLast--;
            }    
            // NOTE: Don't strip double quotes here, they will be stripped later
            
            yaccDebugOut((DEB_ITRACE, "Phrase %ws in %ws format\n",  pwsz, fLong ? L"Long" : L"Short"));
        }
        break;
    case _PROPNAME:

        {
            LPWSTR pLast;
            
            if (fLong)  // looks like: { prop name = "prop name"  }
            {
                // find =
                while (L'=' != *pwsz)
                    pwsz++;
                pwsz++; 

                pLast = pwsz + wcslen(pwsz) - 1;
                Win4Assert( *pLast == L'}');
                *pLast-- = L'\0';
            }
            else
            {
                // Strip @ or # or $ token
                Win4Assert(*pwsz == L'@' || *pwsz == L'#' || *pwsz == L'$');
                pwsz = pwsz + 1;
            }

            // strip leading and trailing blanks            
            while (L' ' == *pwsz)
                pwsz++;

            pLast = pwsz + wcslen(pwsz) - 1;

            while (pLast >= pwsz && L' ' == *pLast )
            {
                *pLast--= L'\0';
            }    

            if (fQuote)
            {
                pwsz++;
                *pLast = L'\0';                              
            }

            yaccDebugOut((DEB_ITRACE, "Propname %ws in %ws format and %ws\n", 
                          pwsz, fLong ? L"Long" : L"Short", fQuote ? L"quoted" : L"unquoted"));
        }
        break;                
    case _FREETEXT:
        {    
            LPWSTR pLast;

            // if long version, find the FREETEXT
            if (fLong)
            {
                pwsz = pwsz + wcslen(L"{freetext}");
                pLast = pwsz + wcslen(pwsz) - 1;                
                pLast = pLast - wcslen(L"{/freetext}")+1;
                Win4Assert(*pLast == L'{');
                *pLast = L'\0';
            }

            // strip leading and trailing blanks            
            while (L' ' == *pwsz)
                pwsz++;

            pLast = pwsz + wcslen(pwsz) - 1;

            while (pLast >= pwsz && L' ' == *pLast )
            {
                *pLast = L'\0';
                pLast--;
            }    

            if (fQuote)
            {
                Win4Assert(pLast >= pwsz+1);
                // Strip quotes
                pwsz = pwsz + 1;
                *pLast = L'\0';               
            }
            
            yaccDebugOut((DEB_ITRACE, "Freetext %ws in %ws format\n",  pwsz, fLong ? L"Long" : L"Short"));
        }
        break;

    case _REGEX:
        {
            LPWSTR pLast;

            // if long version, find the regex
            if (fLong)
            {
                pwsz = pwsz + wcslen(L"{regex}");
                pLast = pwsz + wcslen(pwsz);                
                pLast = pLast - wcslen(L"{/regex}");
                Win4Assert(*pLast == L'{');
                *pLast = L'\0';
            }
            
            // strip leading blanks
            while (L' ' == *pwsz)
                pwsz++;
                
            // If the first char is =, ignore it. We only ignore the first
            // = character. This is backward compatible with Triplish1
            if (L'=' == *pwsz)
                pwsz++;

            // strip leading and trailing blanks            
            while (L' ' == *pwsz)
                pwsz++;
                
            pLast = pwsz + wcslen(pwsz) - 1;
            
            while (pLast >= pwsz && L' ' == *pLast )
            {
                *pLast = L'\0';
                pLast--;
            }    
                
            // After we strip a leading =, we might have a quoted phrase
            // Check only if fQuote is false.
            // We don't want to deal with an unpaired double quote.
            if (!fQuote && *pwsz == L'"' && *pLast == L'"' && pLast > pwsz )
                fQuote = TRUE;
                
            if (fQuote)
            {
                Win4Assert(pLast >= pwsz+1);
                // Strip quotes
                pwsz = pwsz + 1;
                *pLast = L'\0';               
            }
            
            yaccDebugOut((DEB_ITRACE, "RegEx %ws in %ws format\n",  pwsz, fLong ? L"Long" : L"Short"));
        }
        break;                

    case _WEIGHT:
        {  
            Assert (fLong);
            Assert(!fQuote);
            if (fLong)  // looks like: {weight value = number }
            {
                // find =
                while (L'=' != *pwsz)
                    pwsz++;
                pwsz++;

                // step past leading blanks
                while (L' ' == *pwsz)
                    pwsz++;

                // remove trailing } and blanks
                LPWSTR pLast = pwsz + wcslen(pwsz) - 1;
                Win4Assert(*pLast == L'}');
                *(pLast--) = L'\0';

                while (pLast >= pwsz && L' ' == *pLast )
                {
                    *(pLast--) = L'\0';
                }    
            }
        }
        break;                

    case _NEARDIST:
        {  
            Assert (fLong);
            Assert(!fQuote);
            if (fLong)  // looks like: dist = number
            {
                // find =
                while (L'=' != *pwsz)
                    pwsz++;
                pwsz++;

                // step past leading blanks
                while (L' ' == *pwsz)
                    pwsz++;
            }
            
            yaccDebugOut((DEB_ITRACE, "NearDist string: %ws in %s format\n",  pwsz, fLong ? L"Long" : L"Short"));
        }
        break;                
    case _NEARUNIT:
        {  
            Assert (fLong);
            Assert(!fQuote);
            if (fLong)  // looks like: unit = blah
            {
                // find =
                while (L'=' != *pwsz)
                    pwsz++;
                pwsz++;

                // step past leading blanks
                while (L' ' == *pwsz)
                    pwsz++;
            }
            
            yaccDebugOut((DEB_ITRACE, "NearUnit string: %ws in %s format\n",  pwsz, fLong ? L"Long" : L"Short"));
        }
        break; 
    case _VECTORELEMENT:
        {              
            // strip leading and trailing blanks            
            while (L' ' == *pwsz)
                pwsz++;

            LPWSTR pTemp = pwsz + wcslen(pwsz) - 1;

            if (fLong)  // strip trailing ; 
            {
                Win4Assert(L';' == *pTemp);
                *pTemp--='\0';
            }

            while (L' ' == *pTemp && pTemp > pwsz)
                *pTemp-- = L'\0';

            if (fQuote)
            {
                // Strip quotes
                pwsz = pwsz + 1;
                pwsz[wcslen(pwsz)-1] = L'\0';               
            }

            yaccDebugOut((DEB_ITRACE, "VectorElem %ws in %ws format\n",  pwsz, fLong ? L"Long" : L"Short"));
        }
        break;                        
    case _VEMETHOD:
        { 
            Assert (fLong);

            LPWSTR pTemp;

            if (fLong)  // looks like: {vector rankmethod= blah}
            {
                // find =
                while (L'=' != *pwsz)
                    pwsz++;
                pwsz++;

                // strip trailing }
                pTemp = pwsz + wcslen(pwsz) - 1;               
                Win4Assert(L'}' == *pTemp);
                *pTemp-- = L'\0';

            }

            // strip leading and trailing blanks and quotes          
            while (L' ' == *pwsz)
                pwsz++;

            pTemp = pwsz + wcslen(pwsz) - 1;

            while (L' ' == *pTemp && pTemp > pwsz)
                *pTemp-- = L'\0';

            if (fQuote)
            {
                // Strip quotes
                pwsz = pwsz + 1;
                pwsz[wcslen(pwsz)-1] = L'\0';               
            }
            
            yaccDebugOut((DEB_ITRACE, "VectorMethod %ws in %ws format\n",  pwsz, fLong ? L"Long" : L"Short"));
        }
        break; 


    }

    int len = wcslen(pwsz);
    XPtrST<WCHAR> xwszRet(new WCHAR[len + 1]);
    
    _allocations.Add(xwszRet.GetPointer(), _allocations.Count());
    
    RtlCopyMemory(xwszRet.GetPointer(), pwsz, (len+1) * sizeof(WCHAR));
    (*ppStg).pwszChar = xwszRet.Acquire();
    
    return retTkn;
}        


//+---------------------------------------------------------------------------
//
//  Function:   YYLEXER::DetermineTokenType 
//
//  Synopsis:   Determines if we have a regular expression or a regular string.  
//              A  regular expression is a string that contains atleast one of
//              *, ?, or | characters.
//
//  Returns:    Token id
//
//  History:    Jun-05-98        KrishnaN  created
//
//----------------------------------------------------------------------------

short YYLEXER::DetermineTokenType()
{
    LPWSTR pwsz = yytext;
    
    LPWSTR pLast = pwsz + wcslen(pwsz) - 1;

    while (pLast >= pwsz)
    {
        if (L'|' == *pwsz || L'*' == *pwsz || L'?' == *pwsz)
            return _REGEX;
            
        pwsz++;
    }    
    
    // None of the regular expression defining characters have been found
    return _PHRASE;
}        


        //
        // 
        //    RULES       
        // 
        // Notes:  Any characters which are not matched, cause yylexer to throw.
        //         We can also throw if E_OUTOFMEMORY.
        //         Tokens which need 2 return more than 1 value (e.g. {near}
        //         use start states to return each pice of the value. The start
        //         states also emit a "token end" token so that the parser can
        //         check that they are syntactically complete.
        //         Lex matches to the longest match in the rules.  If 2 matches
        //         are the same, it matches to the 1st match. 
%}

%x innear
%x shortgen
%x shortregex
%x mayberegex
%x implicitphrase
%x infreefreetext
%x invector

white    [ \t\n\f\r]+

begin_freetext  \{[fF][rR][eE][eE][tT][eE][xX][tT]\}[ ]*
end_freetext    [ ]*\{\/[fF][rR][eE][eE][tT][eE][xX][tT]\}
begin_phrase    \{[pP][hH][rR][aA][sS][eE]\}[ ]*
end_phrase      [ ]*\{\/[pP][hH][rR][aA][sS][eE]\}
prop            [pP][rR][oO][pP]
propname        {prop}[ ]+[nN][aA][mM][eE][ ]*
contains        [cC][oO][nN][tT][aA][iI][nN][sS]
and             [aA][nN][dD]
or              [oO][rR]
not             [nN][oO][tT]
near            [nN][eE][aA][rR]
vector          [vV][eE][cC][tT][oO][rR]
vecmethod       {vector}[ ]+[rR][aA][nN][kK][mM][eE][tT][hH][oO][dD][ ]*
ve              [vV][eE]
weight          [wW][eE][iI][gG][hH][tT][ ]+[vV][aA][lL][uU][eE][ ]*
coerce          [cC][oO][eE][rR][cC][eE]
generate        [gG][eE][nN][eE][rR][aA][tT][eE]
genmethod       {generate}[ ]+[mM][eE][tT][hH][oO][dD][ ]*
begin_regex     \{[rR][eE][gG][eE][xX]\}[ ]*
end_regex       [ ]*\{\/[rR][eE][gG][eE][xX]\}
dist            [dD][iI][sS][tT][ ]*
unit            [uU][nN][iI][tT][ ]*
word            [wW][oO][rR][dD]
sent            [sS][eE][nN][tT]
par             [pP][aA][rR]
chap            [cC][hH][aA][pP]

%%

{white}               { /* do nothing */ }

\(                 {    fContinueImplicitPhrase = FALSE;
                        fContinueRegex = FALSE;
                        fContinueMaybeRegex = FALSE;
                        TOKEN (_OPEN);
                   }
\)                 {
                        fContinueImplicitPhrase = FALSE;
                        fContinueRegex = FALSE;
                        fContinueMaybeRegex = FALSE;
                        TOKEN (_CLOSE); 
                   }
  
    %{// ************
      // PROPNAME
      // ************ %}
     
    %{ // If something was treated as a phrase in Tripolish 1, it should
       // be treated as such even now. That applies here. For e.g. @propname
       // caused the following text to be treated as a phrase. The same should
       // apply to {prop name = propname}
       // 
    %}
    
    %{// shorthand, quoted %}
@\"[^"]+\"                              { 
                                            // treat value as a phrase
                                            BEGIN implicitphrase;
                                            STRING_VALUE(_PROPNAME, FALSE, TRUE);
                                        }     
   %{// shorthand, not quoted %}
@[^" <>=!&|~\^]+                        { 
                                            // treat value as a phrase
                                            BEGIN implicitphrase;
                                            STRING_VALUE(_PROPNAME, FALSE, FALSE);
                                        }
                                         
   %{// shorthand, quoted %}
$\"[^"]+\"                              { 
                                            // treat value as freetext
                                            BEGIN infreefreetext;
                                            STRING_VALUE(_PROPNAME, FALSE, TRUE);
                                        }     
   %{// shorthand, not quoted %}
$[^" <>=!&|~\^]+                        { 
                                            // treat value as freetext
                                            BEGIN infreefreetext;
                                            STRING_VALUE(_PROPNAME, FALSE, FALSE);
                                        }    
    
   %{// longhand, quoted %}
\{{propname}=[ ]*\"[^"]*\"[ ]*\}        { 
                                            // treat value as a phrase
                                            BEGIN implicitphrase;
                                            STRING_VALUE(_PROPNAME, TRUE, TRUE);
                                        }
   %{// longhand, not quoted %}
\{{propname}=[ ]*[^"} ][^}]*\}          { 
                                            // treat value as a phrase
                                            BEGIN implicitphrase;
                                            STRING_VALUE(_PROPNAME, TRUE, FALSE);
                                        }
   %{// closing token %}
\{\/{prop}\}                            { TOKEN (_PROPEND); }

   %{// *********
     // OPERATORS
     // ********* %}

{contains}[ ]+   { if (fContinueImplicitPhrase)
                   {
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
                   TOKEN (_CONTAINS); 
                 }
{and}[ ]+        { if (fContinueImplicitPhrase)
                   {
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
                   TOKEN (_AND);
                 }
{and}\{          { 
		   yyless(yyleng-1);
		   if (fContinueImplicitPhrase)
                   {
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
                   TOKEN (_AND);
                 }		 
{or}[ ]+         { if (fContinueImplicitPhrase)
                   {
		       yaccDebugOut(( DEB_ITRACE, "fContinueImplicitPhrase\n" )); 
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
		       yaccDebugOut(( DEB_ITRACE, "fContinueRegex\n" ));  
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
		       yaccDebugOut(( DEB_ITRACE, "fContinueMaybeRegex\n" ));  
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
		   yaccDebugOut(( DEB_ITRACE, "OR TOKEN found !!!\n" ));
                   TOKEN (_OR); }
{or}\{		 { 
		   yyless(yyleng-1);
		   if (fContinueImplicitPhrase)
                   {
		       yaccDebugOut(( DEB_ITRACE, "OR{ fContinueImplicitPhrase\n" )); 
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
		       yaccDebugOut(( DEB_ITRACE, "OR{ fContinueRegex\n" ));  
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
		       yaccDebugOut(( DEB_ITRACE, "OR{ fContinueMaybeRegex\n" ));  
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
		   yaccDebugOut(( DEB_ITRACE, "OR{ TOKEN found !!!\n" ));
                   TOKEN (_OR); }     	   
{not}[ ]+        { if (fContinueImplicitPhrase)
                   {
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
                   TOKEN (_NOT);}
{not}\{		 { 
		   yyless(yyleng-1);
		   if (fContinueImplicitPhrase)
		   {
		       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
                   TOKEN (_NOT);}		   
&                { if (fContinueImplicitPhrase)
                   {
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
                   TOKEN (_AND);}
\|               { if (fContinueImplicitPhrase)
                   {
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
                   TOKEN (_OR);}
!                { if (fContinueImplicitPhrase)
                   {
                       BEGIN implicitphrase;
                       fContinueImplicitPhrase = FALSE;
                   }
                   else if (fContinueRegex)
                   {
                       BEGIN shortregex;
                       fContinueRegex = FALSE;
                   }
                   else if (fContinueMaybeRegex)
                   {
                       BEGIN mayberegex;
                       fContinueMaybeRegex = FALSE;
                   }
                   TOKEN (_NOT);}
{near}[ ]+       { yaccDebugOut(( DEB_ITRACE, "near[ ]+ _NEAR token, begin implicitphrase\n" ));
		   BEGIN implicitphrase;
                   TOKEN (_NEAR);}
{near}\{	 { yaccDebugOut(( DEB_ITRACE, "near{ _NEAR token, begin implicitphrase\n" ));
		   yyless(yyleng-1);
		   BEGIN implicitphrase;
                   TOKEN (_NEAR);}			   
~                { BEGIN implicitphrase;
                   TOKEN (_NEAR);}
\<               { TOKEN (_LT);}
\>               { TOKEN (_GT);}
\<\=             { TOKEN (_LTE);}
\>\=             { TOKEN (_GTE);}
\=               { if (fContinueMaybeRegex) 
                      {
                          // We are not sure if we are going to find a
                          // regular expression or a phrase.
                          
                          BEGIN mayberegex;
                          fContinueMaybeRegex = FALSE;
                      }
                      TOKEN (_EQ);
                    }
\!\=                { TOKEN (_NE); }
\^a                 { TOKEN (_ALLOF); }
\^s                 { TOKEN (_SOMEOF); }
\<[ ]*\^s |
\^s[ ]*\<           { TOKEN (_LTSOME); }
\>[ ]*\^s |
\^s[ ]*\>           { TOKEN (_GTSOME); }
\<\=[ ]*\^s |
\^s[ ]*\<\=         { TOKEN (_LTESOME); }
\>\=[ ]*\^s |
\^s[ ]*\>\=         { TOKEN (_GTESOME); }
\=[ ]*\^s |
\^s[ ]*\=           { TOKEN (_EQSOME); }
\!\=[ ]*\^s |
\^s[ ]*\!\=         { TOKEN (_NESOME); }

\^s[ ]*\^a          { TOKEN (_ALLOFSOME); }
\^s[ ]*\^s          { TOKEN (_SOMEOFSOME); }
\^<[ ]*\^a  |
\^a[ ]*\<           { TOKEN (_LTALL); }
\>[ ]*\^a   |
\^a[ ]*\>           { TOKEN (_GTALL); }
\<\=[ ]*\^a |
\^a[ ]*\<\=         { TOKEN (_LTEALL); }
\>\=[ ]*\^a |
\^a[ ]*\>\=         { TOKEN (_GTEALL); }
\=[ ]*\^a   |
\^a[ ]*\=           { TOKEN (_EQALL); }
\!\=[ ]*\^a |
\^a[ ]*\!\=         { TOKEN (_NEALL); }
\^a[ ]*\^a          { TOKEN (_ALLOFALL); }
\^a[ ]*\^s          { TOKEN (_SOMEOFALL); }

   %{// *************
     // VECTOR SPACE TOKENS
     // ************* %}
\{{vecmethod}=[ ]*\"[^"]*\"[ ]*\}               { STRING_VALUE(_VEMETHOD, TRUE, TRUE); }
\{{vecmethod}=[^}]*\}                           { STRING_VALUE(_VEMETHOD, TRUE, FALSE); }
\{{ve}\}                                        {
                                                    // makes more sense to enter phrase mode
                                                    // rather than freetext mode.
                                                    fContinueImplicitPhrase = TRUE;
                                                    BEGIN implicitphrase;
                                                    TOKEN (_VE);
                                                }
                                                   
\{\/{vector}\}                                  { TOKEN (_VECTOR_END); }

    %{// *************
      // longhand NEAR
      // ************* %}
   
    %{// must return both unit and distance, so use start state to pull them out, and 
      // return _NEAR_END so parser knows we hit the closing }  
    %}
\{{near}[ ]     { yaccDebugOut(( DEB_ITRACE, "Longhand _NEAR token, begin innear\n" ));
		  BEGIN innear; }
\{{near}\{	{ yaccDebugOut(( DEB_ITRACE, "Longhand _NEAR{ token, begin innear\n" ));
		  yyless(yyleng-1);
		  BEGIN innear; }

   %{// ************
     // WEIGHT
     // ************ %}
\{{weight}=[ ]*(0|1|0\.[0-9]*|1\.[0]*|\.[0-9]+)[ ]*\} { 
							  if (fContinueImplicitPhrase)
							  {
							      BEGIN implicitphrase;
							      fContinueImplicitPhrase = FALSE;
							  }
						
							  yaccDebugOut(( DEB_ITRACE, "_WEIGHT TOKEN FOUND!!\n" ));
							  STRING_VALUE(_WEIGHT,TRUE,FALSE);
						      }

\{{coerce}\}    {
                        if (fContinueImplicitPhrase)
                        {
                            BEGIN implicitphrase;
                            fContinueImplicitPhrase = FALSE;
                        }
                        TOKEN (_COERCE); }

   %{// ****************
     // longhand GENERATE
     // **************** %}

\{{genmethod}=[" ]*prefix[" ]*\}                {
                                                    if (fContinueImplicitPhrase)
                                                    {
                                                        BEGIN implicitphrase;
                                                        fContinueImplicitPhrase = FALSE;
                                                    }
                                                    yaccDebugOut((DEB_ITRACE, "Prefix recognized.\n"));
                                                    TOKEN(_GENPREFIX);
                                                }
\{{genmethod}=[" ]*inflect[" ]*\}               {
                                                    if (fContinueImplicitPhrase)
                                                    {
                                                        BEGIN implicitphrase;
                                                        fContinueImplicitPhrase = FALSE;
                                                    }
                                                    yaccDebugOut((DEB_ITRACE, "Inflect recognized.\n"));
                                                    TOKEN(_GENINFLECT);
                                                }
\{\/{generate}\}                                { TOKEN (_GENNORMAL); }

    %{// ****************
      // longhand REGEX
      // ****************   %}

{begin_regex}\"[^"]*\"{end_regex}       { STRING_VALUE(_REGEX,TRUE,TRUE);}
{begin_regex}[^{]*{end_regex}           { STRING_VALUE(_REGEX,TRUE,FALSE);}
{begin_regex}([^{]*\|[()\[{}\],*?+][^{]*)*{end_regex}       { STRING_VALUE(_REGEX,TRUE,FALSE);}


    %{// ****************
      // shorthand REGEX
      // ****************   %}
     
    %{// shorthand, quoted %}
#\"[^"]+\"                              { 
                                            // Get into short form of reg expression
                                            BEGIN shortregex;
                                            STRING_VALUE(_PROPNAME, FALSE, TRUE);
                                        }     
    %{// shorthand, not quoted %}
#[^" <>=!&|~\^]+                        {
                                            // Get into short form of reg expression
                                            BEGIN shortregex;
                                            STRING_VALUE(_PROPNAME, FALSE, FALSE);
                                        }    


    %{// ***************
      // longhand PHRASE                                            
      // *************** %}
    
    %{// quoted, with trailing * or **  %}
{begin_phrase}\"[^"]*\"{end_phrase}\*       {
                                                // trailing * has to be for inflection - 
                                                // process it in shortgen on next pass.  
                                                // Grab phrase now.
                                                yyless(yyleng-1); 
                                                BEGIN shortgen; 
                                                STRING_VALUE(_PHRASE,TRUE,TRUE); 
                                            }
    %{// quoted, without trailing * or **  %}                                           
{begin_phrase}\"[^"]*\"{end_phrase}         {   
                                                // no trailing * -- phrase only
                                                STRING_VALUE(_PHRASE,TRUE,TRUE);
                                            }
    %{// unquoted, with trailing * or ** %}                                           
{begin_phrase}[^{]*{end_phrase}\*           {  
                                                // trailing * has to be for inflection - 
                                                // process it in shortgen on next pass.  
                                                // Grab phrase now.
                                                yyless(yyleng-1); 
                                                BEGIN shortgen; 
                                                STRING_VALUE(_PHRASE,TRUE,FALSE); 
                                            }
    %{// unquoted, without trailing * or **  %}                                                                                        
{begin_phrase}[^{]*{end_phrase}             {   
                                                // no trailing * -- phrase only
                                                STRING_VALUE(_PHRASE,TRUE,FALSE); 
                                            }
    %{// *************                                        
      // shorthand PHRASE                                            
      // *************  %}
    
    %{// with trailing * or **  %}
\"[^"]*\"\*                                 {
                                                // trailing * has to be for inflection -        
                                                // process it in shortgen on next pass.  
                                                // Grab phrase now.
                                                yyless(yyleng-1); 
                                                BEGIN shortgen;
                                                STRING_VALUE(_PHRASE, FALSE, TRUE); 
                                            } 
    %{ // without trailing * or ** %}                                           
\"[^"]*\"                                   {
                                                // no trailing * -- phrase only 
                                                STRING_VALUE(_PHRASE, FALSE, TRUE); 
                                            }
                                            
    %{// *****************
    // longhand FREETEXT
    // *****************          %}
    
    %{// quoted, with trailing * or **  %}
{begin_freetext}\"[^"]*\"{end_freetext}\*       {
                                                    // trailing * has to be for inflection - 
                                                    // process it in shortgen on next pass.  
                                                    // Grab freetext now.
                                                    yyless(yyleng-1); 
                                                    BEGIN shortgen;
                                                    STRING_VALUE(_FREETEXT,TRUE,TRUE); 
                                                }
    %{// quoted, without trailing * or ** %}                                               
{begin_freetext}\"[^"]*\"{end_freetext}         {
                                                    // no trailing * -- freetext  only
                                                    STRING_VALUE(_FREETEXT,TRUE,TRUE); 
                                                }
    %{// unquoted, with trailing * or ** %}                                               
{begin_freetext}[^{]*{end_freetext}\*              {
                                                    // trailing * has to be for inflection - 
                                                    // process it in shortgen on next pass.  
                                                    // Grab freetext now.
                                                    yyless(yyleng-1); 
                                                    BEGIN shortgen;
                                                    STRING_VALUE(_FREETEXT,TRUE,FALSE); 
                                                }
    %{// unquoted, without trailing * or **  %}                                                
{begin_freetext}[^{]*{end_freetext}                {
                                                    // no trailing * -- freetext  only
                                                    STRING_VALUE(_FREETEXT,TRUE,FALSE); 
                                                }
    %{// ******************
      // shorthand FREETEXT 
      // ****************** %}
     
[^#$@~&|<>=!\^*"()\{ ][^&~|{) ]*[ ]     {
                                            // For backward compatibility, we want to special
                                            // case and recognize the "not" operator when it
                                            // is immediately followed by a mode specifier character
                                            // (@, $, #). For e.g. "not@size > 2" should be treated
                                            // as if we have a "not" operator followed by "@size > 2".
                                            // Without this special case, "not@size > 2" gets recognized
                                            // as free text.
                                            
                                            if (IsNotOperator())
                                            {
                                                yyless(3);
                                                BEGIN INITIAL;
                                                TOKEN(_NOT);
                                            }
                                            
                                            yaccDebugOut(( DEB_ITRACE, "fTreatFreetextAsPhrase is %d\n", fTreatFreetextAsPhrase ));
                                            if (fTreatFreetextAsPhrase)
                                                BEGIN implicitphrase;
                                            else
                                                BEGIN infreefreetext;
                                        
                                            fTreatFreetextAsPhrase = FALSE;    
                                            yymore();
                                        }  
[^#$@~&|<>=!\^*"()\{ ][^&~|{) ]*        {
                                            // IsNotOperator is used here for the same reason as the
                                            // use above, except that this rule covers situations where
                                            // we have no spaces in the query. E.g. "not@size>2". 
                                            // This should be equivalent to 
                                            // "not@size > 2", which in turn should be equivalent to
                                            // "not @size > 2"
                                            
                                            if (IsNotOperator())
                                            {
                                                yyless(3);
                                                BEGIN INITIAL;
                                                TOKEN(_NOT);
                                            }
                                            
                                            if (fTreatFreetextAsPhrase)
                                            {
                                                STRING_VALUE(_PHRASE,FALSE,FALSE);
                                            }
                                            else
                                            {
                                                STRING_VALUE(_FREETEXT,FALSE,FALSE);
                                            }
                                            
                                            fTreatFreetextAsPhrase = FALSE;
                                        }  
  

    %{// *************
      // VECTOR VALUES
      // *************  %}
       
    %{// quoted multi-value vector - has ; separator.  Singlets caught in parser  %}
\([ ]*\"[^"]*\"[ ]*;    { BEGIN invector; yyless(1);}
  %{// unquoted multi-value vector - has ; separator.  Singlets caught in parser %}
\([^(;)]+;              { BEGIN invector; yyless(1);}


  %{// 
    // INNEAR: longhand NEAR processing
    // 
    %}
<innear>{white}                 {}
<innear>,                       {}
<innear>dist[ ]*=[ ]*[0-9]+     { STRING_VALUE(_NEARDIST,TRUE,FALSE);}
<innear>unit[ ]*=[ ]*{word}     { STRING_VALUE(_NEARUNIT,TRUE,FALSE);}  
<innear>unit[ ]*=[ ]*{sent}     { STRING_VALUE(_NEARUNIT,TRUE,FALSE);} 
<innear>unit[ ]*=[ ]*{par}      { STRING_VALUE(_NEARUNIT,TRUE,FALSE);}
<innear>unit[ ]*=[ ]*{chap}     { STRING_VALUE(_NEARUNIT,TRUE,FALSE);}
<innear>\}                      { BEGIN implicitphrase; TOKEN (_NEAR_END);} 

    %{// 
      // INVECTOR: multi value vector processing
      // 
    %}
<invector>{white}           {}
<invector>;                 {}
<invector>\"[^"]*\"         { STRING_VALUE(_VECTORELEMENT, FALSE, TRUE);}
<invector>[^ ";)][^;)]*;    { STRING_VALUE(_VECTORELEMENT, TRUE, FALSE);}
<invector>[^ ";)][^;)]*\)   {
                                //  Need to emit _VECTORELEMENT and _VE_END -- so backup 1
                                //  so we can emit _VE_END on next pass                               
                                yyless(yyleng-1);
                                STRING_VALUE(_VECTORELEMENT, FALSE, FALSE);
                            }
<invector>\)                { BEGIN INITIAL; TOKEN (_VE_END); } 

    %{// 
      // INFREEFREETEXT: shorthand FREETEXT processing
      //
      // NOTE:  and, or, near need to be localized %}
<infreefreetext>[ ]+        { yymore(); }
<infreefreetext>{and}[ ]    {
                                yyless(yyleng-4); 
                                BEGIN INITIAL;                        
                                STRING_VALUE(_FREETEXT,FALSE,FALSE); 
                            }  
<infreefreetext>{and}\{     {
                                yyless(yyleng-4); 
                                BEGIN INITIAL;                        
                                STRING_VALUE(_FREETEXT,FALSE,FALSE); 
                            }  			    
<infreefreetext>{or}[ ]     { 
                                yyless(yyleng-3); 
                                BEGIN INITIAL;
                                STRING_VALUE(_FREETEXT,FALSE,FALSE); 
                            }
<infreefreetext>{or}\{	    { 
                                yyless(yyleng-3); 
                                BEGIN INITIAL;
                                STRING_VALUE(_FREETEXT,FALSE,FALSE); 
                            }			    
<infreefreetext>{near}[ ]   { 
				yaccDebugOut(( DEB_ITRACE, "{infreefreetext}{near}[ ]\n" ));
                                yyless(yyleng-5); 
                                fTreatFreetextAsPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
			    
<infreefreetext>{near}\{    { 
				yaccDebugOut(( DEB_ITRACE, "{infreefreetext}{near}{\n" ));
                                yyless(yyleng-5); 
                                fTreatFreetextAsPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
<infreefreetext>\{{near}[ ] { 
				yaccDebugOut(( DEB_ITRACE, "{infreefreetext}{{near}\n" ));
                                yyless(yyleng-6); 
                                fTreatFreetextAsPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
<infreefreetext>\{{near}\{  { 
				yaccDebugOut(( DEB_ITRACE, "{infreefreetext}{{near}{\n" ));
                                yyless(yyleng-6); 
                                fTreatFreetextAsPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }			    
<infreefreetext>&           {
                                yyless(yyleng-1); 
                                BEGIN INITIAL;
                                STRING_VALUE(_FREETEXT,FALSE,FALSE); 
                            }  
<infreefreetext>\|          { 
                                yyless(yyleng-1); 
                                BEGIN INITIAL;
                                STRING_VALUE(_FREETEXT,FALSE,FALSE); 
                            }
<infreefreetext>~           { 
                                yyless(yyleng-1); 
                                fTreatFreetextAsPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
<infreefreetext>\(          { 
                                yyless(yyleng-1); 
                                BEGIN INITIAL;
                                STRING_VALUE(_FREETEXT,FALSE,FALSE); 
                            }                             
<infreefreetext>\)          { 
                                yyless(yyleng-1); 
                                BEGIN INITIAL;
                                STRING_VALUE(_FREETEXT,FALSE,FALSE); 
                            }                             
<infreefreetext>\{          { 
                                yyless(yyleng-1); 
                                BEGIN INITIAL;
                                STRING_VALUE(_FREETEXT,FALSE,FALSE);
                            }
<infreefreetext>\"[^"]+\"   { 
                                BEGIN INITIAL;
                                STRING_VALUE(_FREETEXT,FALSE,FALSE);
                            }
<infreefreetext>[^~&|{}()" ]+[ ]  { yymore(); }
<infreefreetext>[^~&|{}()" ]+     {
				      BEGIN INITIAL;
				      STRING_VALUE(_FREETEXT,FALSE,FALSE); 
				  }   
                               
    %{// 
      // SHORTGEN:  * or ** processing
      //
      // can only get here by backing up over *, 
      // so we will always find a match  %}
<shortgen>\*\*  {  
                   BEGIN INITIAL; 
                   TOKEN(_SHGENINFLECT);
                }
<shortgen>\*    {   
                   BEGIN INITIAL; 
                   TOKEN(_SHGENPREFIX); 
                }
                
    %{//
      // SHORTREGEX: #propname processing
      //
      // can only get here when #"propname" or #propname
      // (quoted or unquoted) version is detected.
      // NOTE:  and, or need to be localized
      // NOTE:  It doesn't make sense to have the near operator following 
      //        a regular expression. A regex is Boolean and doesn't evaluate
      //        to a position value. 
      //
      //
      
    %}
<shortregex>[ ]+        { yymore(); }
<shortregex>=           {
                          // ignore equal operators...
                          BEGIN shortregex;
                        }
<shortregex>\"[^"]*\"   { STRING_VALUE(_REGEX, FALSE, TRUE);}
<shortregex>{and}[ ]    {
                            fContinueRegex = TRUE;
                            yyless(yyleng-4); 
                            BEGIN INITIAL;
                            STRING_VALUE(_REGEX,FALSE,FALSE); 
                        }  
<shortregex>{or}[ ]     { 
                            fContinueRegex = TRUE;
                            yyless(yyleng-3); 
                            BEGIN INITIAL;
                            STRING_VALUE(_REGEX,FALSE,FALSE); 
                        }
                        
<shortregex>{not}[ ]    { 
                                yyless(yyleng-4); 
                                // The only valid way to get here is to
                                // have had seen "and" before. Don't recognize
                                // a regex. Back off and let the lexer takes its
                                // normal course.
                                fContinueRegex = TRUE;
                                BEGIN INITIAL;
                        }                           
<shortregex>&           {
                            fContinueRegex = TRUE;
                            yyless(yyleng-1); 
                            BEGIN INITIAL;                        
                            STRING_VALUE(_REGEX,FALSE,FALSE); 
                        }  
<shortregex>\|          { 
                            fContinueRegex = TRUE;
                            yyless(yyleng-1); 
                            BEGIN INITIAL;
                            STRING_VALUE(_REGEX,FALSE,FALSE); 
                        }
                        
<shortregex>!           { 
                            yyless(yyleng-1); 
                            // The only valid way to get here is to
                            // have had seen "and" before. Don't recognize
                            // a phrase. Back off and let the lexer takes its
                            // normal course.
                            fContinueRegex = TRUE;
                            BEGIN INITIAL;
                        }                           
%{
    // When we find an operator we should treat it as one. 
    // So backup and get out if you see one.
    // Normally '^' is treated as part of an operator (e.g. ^a), but it also 
    // has a special meaning in regular expression syntax. So we will have to
    // let it through when it is part of a regular expression. As an alternative,
    // we can allow '^' in regular expression in a limited manner (i.e. only the use
    // in square brackets to exclude the set of chars "[^abc]" where abc are excluded).
    // This alternative will let the common case use of '^' in a regular expression
    // while allowing it to be treated as part of an operator when it doesn't 
    // occur immediately after a '['.
    // We are implementing the alternative here because our regex capability
    // only allows for the "[^" construct.
%}                           
<shortregex>[\^<>@$#]   { 
                            yyless(yyleng-1);
                            fContinueRegex = FALSE;
                            BEGIN INITIAL;
                        }
<shortregex>\(          { 
                            yyless(yyleng-1); 
                            BEGIN INITIAL;
                            STRING_VALUE(_REGEX,FALSE,FALSE); 
                        }                             
<shortregex>\)          { 
                            yyless(yyleng-1); 
                            BEGIN INITIAL;
                            STRING_VALUE(_REGEX,FALSE,FALSE); 
                        }                             
<shortregex>\{          { 
                            yyless(yyleng-1); 
                            BEGIN INITIAL;
                            STRING_VALUE(_REGEX,FALSE,FALSE); 
                        }                     
<shortregex>(([^~&|{}()\^<>!@$#= ])*(\|[()\[{}\],*?+])*(\|\[\^)*([^~&|{}()\^<>!@$#= ])*)+[ ]  { yymore(); }
<shortregex>(([^~&|{}()\^<>!@$#= ])*(\|[()\[{}\],*?+])*(\|\[\^)*([^~&|{}()\^<>!@$#= ])*)+ {
                            fContinueRegex = TRUE;
                            BEGIN INITIAL;
                            STRING_VALUE(_REGEX,FALSE,FALSE); 
                        }


<mayberegex>{and}[ ]    {
                            yyless(yyleng-4); 
                            fContinueMaybeRegex = TRUE;
                            BEGIN INITIAL;
                            STRING_VALUE(_PHRASEORREGEX,FALSE,FALSE); 
                        }  
<mayberegex>{or}[ ]     { 
                            yyless(yyleng-3); 
                            fContinueMaybeRegex = TRUE;
                            BEGIN INITIAL;
                            STRING_VALUE(_PHRASEORREGEX,FALSE,FALSE); 
                        }
                       
<mayberegex>{not}[ ]    { 
                            yyless(yyleng-4); 
                            // The only valid way to get here is to
                            // have had seen "and" before. Don't recognize
                            // a regex. Back off and let the lexer takes its
                            // normal course.
                            fContinueMaybeRegex = TRUE;
                            BEGIN INITIAL;
                        }                           
<mayberegex>&           {
                            fContinueMaybeRegex = TRUE;
                            yyless(yyleng-1); 
                            BEGIN INITIAL;                        
                            STRING_VALUE(_PHRASEORREGEX,FALSE,FALSE); 
                        }  
<mayberegex>\|          { 
                            fContinueMaybeRegex = TRUE;
                            yyless(yyleng-1); 
                            BEGIN INITIAL;
                            STRING_VALUE(_PHRASEORREGEX,FALSE,FALSE); 
                        }
                        
<mayberegex>!           { 
                            yyless(yyleng-1); 
                            // The only valid way to get here is to
                            // have had seen "and" before. Don't recognize
                            // a phrase. Back off and let the lexer takes its
                            // normal course.
                            fContinueMaybeRegex = TRUE;
                            BEGIN INITIAL;
                        }                           
<mayberegex>\(          { 
                            yyless(yyleng-1); 
                            BEGIN INITIAL;
                            STRING_VALUE(_PHRASEORREGEX,FALSE,FALSE); 
                        }                             
<mayberegex>\)          { 
                            yyless(yyleng-1); 
                            BEGIN INITIAL;
                            STRING_VALUE(_PHRASEORREGEX,FALSE,FALSE); 
                        }                             
<mayberegex>\{          { 
                            yyless(yyleng-1); 
                            BEGIN INITIAL;
                            STRING_VALUE(_PHRASEORREGEX,FALSE,FALSE); 
                        }
<mayberegex>[ ]+            { yymore(); }
<mayberegex>\"[^"]*\"       { STRING_VALUE(_PHRASE, FALSE, TRUE);}
<mayberegex>(([^~&|{}()\^<>!@$# ])*(\|[()\[{}\],*?+])*(\|\[\^)*([^~&|{}()\^<>!@$# ])*)+[ ]  {   yymore(); }
<mayberegex>(([^~&|{}()\^<>!@$# ])*(\|[()\[{}\],*?+])*(\|\[\^)*([^~&|{}()\^<>!@$# ])*)+ {
                                 fContinueMaybeRegex = TRUE;
                                 BEGIN INITIAL;
                                 STRING_VALUE(_PHRASEORREGEX,FALSE,FALSE); 
                            }
%{
    // When we find an operator at the start of a phrase, 
    // we should treat it as one. So backup and get out if you see one.
%}                           
<mayberegex>[\^<>@$#]       { 
                                yyless(yyleng-1);
                                fContinueMaybeRegex = FALSE;
                                BEGIN INITIAL;
                            }
                               

    %{//
      // IMPLICITPHRASE: Where phrase is implied.
      //
      // can only get here when @propname or {prop name = propname} is detected.
      // NOTE:  and, or, not need to be localized when time permits.
      //
      // NTRAID#DB-NTBUG9-84571-2000/07/31-dlee Indexing Service tripolish2 query expressions misinterpreted as strings
      // if expression has trailing blanks, we'll emit a string value
    %}
<implicitphrase>\"[^"]*\"   {   
				fContinueImplicitPhrase = FALSE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE, FALSE, TRUE);
                            }    
<implicitphrase>[ ]+        {   yymore(); }
<implicitphrase>{and}[ ]    {
				yyless(yyleng-4);
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }  
<implicitphrase>{or}[ ]     { 
                                yyless(yyleng-3);
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
<implicitphrase>{near}[ ]   { 
                                yyless(yyleng-5); 
                                // We want to treat the following token as a phrase
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
<implicitphrase>{near}\{    { 
                                yyless(yyleng-5); 
                                // We want to treat the following token as a phrase
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }			    
<implicitphrase>{not}[ ]    { 
                                yyless(yyleng-4); 
                                // The only valid way to get here is to
                                // have had seen "and" before. Don't recognize
                                // a phrase. Back off and let the lexer takes its
                                // normal course.
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                            }                           
<implicitphrase>&           {
                                yyless(yyleng-1);
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }  
<implicitphrase>~           {
                                yyless(yyleng-1); 
                                // We want to treat the following token as a phrase
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;                        
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }  
                           
<implicitphrase>!           { 
                                yyless(yyleng-1); 
                                // The only valid way to get here is to
                                // have had seen "and" before. Don't recognize
                                // a phrase. Back off and let the lexer takes its
                                // normal course.
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                            }                           
<implicitphrase>\|          { 
                                yyless(yyleng-1); 
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
<implicitphrase>\(          {
                                yyless(yyleng-1); 
                                fContinueImplicitPhrase = FALSE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
<implicitphrase>\)          {
                                yyless(yyleng-1); 
                                fContinueImplicitPhrase = FALSE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }                             
<implicitphrase>\{          {
                                yyless(yyleng-1);
                                fContinueImplicitPhrase = TRUE; 
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE); 
                            }
<implicitphrase>{contains}[ ] {
                                yyless(yyleng-9);
                                fContinueImplicitPhrase = TRUE;
                                BEGIN INITIAL;
                                STRING_VALUE(_PHRASE,FALSE,FALSE);
                              }                           
%{
    // When we find an operator at the start of an implicit phrase, 
    // we should treat it as one. So backup and get out if you see one.
%}                           
<implicitphrase>[\^<>@$#]   { 
                                yyless(yyleng-1);
                                fContinueImplicitPhrase = FALSE;
                                BEGIN INITIAL;
                            }
%{
    // Triplish2 uses = to indicate that whatever appears after it may 
    // be using wildcards. Implement that here.
%}                            
<implicitphrase>=           { 
                                yyless(yyleng-1);
                                fContinueMaybeRegex = TRUE;
                                BEGIN INITIAL;
                            }                            
<implicitphrase>[^~&|{}()\^<>=!@$# ]+[ ] { yymore(); }
<implicitphrase>[^~&|{}()\^<>=!@$# ]+    {
					    fContinueImplicitPhrase = TRUE;
                                            BEGIN INITIAL;
                                            STRING_VALUE(_PHRASE,FALSE,FALSE); 
                                         }