Ejemplo n.º 1
0
 private static Lex LexBoost(QueryLexer lexer)
 {
     lexer.Ignore();
     lexer.AcceptDigitRun();
     lexer.Emit(LexemeType.Boost);
     return(LexText);
 }
Ejemplo n.º 2
0
 private static Lex LexEditDistance(QueryLexer lexer)
 {
     lexer.Ignore();
     lexer.AcceptDigitRun();
     lexer.Emit(LexemeType.EditDistance);
     return(LexText);
 }
Ejemplo n.º 3
0
 private static Lex LexField(QueryLexer lexer)
 {
     lexer.Backup();
     lexer.Emit(LexemeType.Field);
     lexer.Ignore();
     return(LexText);
 }
Ejemplo n.º 4
0
 private static Lex LexEOS(QueryLexer lexer)
 {
     if (lexer.Width > 0)
     {
         lexer.Emit(LexemeType.Term);
     }
     return(LexPastEOS);
 }
Ejemplo n.º 5
0
        private static Lex LexTerm(QueryLexer lexer)
        {
            if (lexer.Width > 1)
            {
                lexer.Backup();
                lexer.Emit(LexemeType.Term);
            }

            lexer.Ignore();

            if (lexer.HasMore)
            {
                return(LexText);
            }

            return(LexPastEOS);
        }
Ejemplo n.º 6
0
        private static Lex LexText(QueryLexer lexer)
        {
            while (true)
            {
                (bool EOS, char ch) = lexer.Next();

                if (EOS)
                {
                    return(LexEOS);
                }

                // Escape character is '\'
                if (ch == '\\')
                {
                    lexer.EscapeCharacter();
                    continue;
                }

                if (ch == ':')
                {
                    return(LexField);
                }

                if (ch == '~')
                {
                    lexer.Backup();
                    if (lexer.Width > 0)
                    {
                        lexer.Emit(LexemeType.Term);
                    }
                    return(LexEditDistance);
                }

                if (ch == '^')
                {
                    lexer.Backup();
                    if (lexer.Width > 0)
                    {
                        lexer.Emit(LexemeType.Term);
                    }
                    return(LexBoost);
                }

                // "+" indicates term presence is required
                // checking for length to ensure that only
                // leading "+" are considered
                if (ch == '+' && lexer.Width == 1)
                {
                    lexer.Emit(LexemeType.Presence);
                    return(LexText);
                }

                // "-" indicates term presence is prohibited
                // checking for length to ensure that only
                // leading "-" are considered
                if (ch == '-' && lexer.Width == 1)
                {
                    lexer.Emit(LexemeType.Presence);
                    return(LexText);
                }

                if (ch.IsLunrSeparator())
                {
                    return(LexTerm);
                }
            }
        }