// Expects a "quoted value", but doesn't necessarily require the quotes... should that be
 // an explicit ''allowNoQuotes parameter for clarity?
 public static StatementBuilder <StatementType, ParserTokenType, LexerTokenType> ExpectRtypePropertyValue(
     this StatementBuilder <StatementType, ParserTokenType, LexerTokenType> statement,
     ParserTokenType parserTokenType)
 {
     return(statement.Accept(LexerTokenType.DoubleQuote, ParserTokenType.DoubleQuote,
                             ifDoubleQuote =>
     {
         return ifDoubleQuote.AggregateWhileNot(LexerTokenType.DoubleQuote, parserTokenType)
         .Expect(LexerTokenType.DoubleQuote, ParserTokenType.DoubleQuote);
     },
                             ifNoDoubleQuote =>
     {
         return ifNoDoubleQuote.Accept(LexerTokenType.SingleQuote, ParserTokenType.SingleQuote,
                                       ifSingleQuote =>
         {
             return ifSingleQuote.AggregateWhileNot(LexerTokenType.SingleQuote, parserTokenType)
             .Expect(LexerTokenType.SingleQuote, ParserTokenType.SingleQuote);
         },
                                       ifNoSingle =>
         {
             // Aggregate until whitespace, comment (hash), newline...
             return ifNoSingle.AggregateWhile(l =>
                                              l != LexerTokenType.Whitespace &&
                                              l != LexerTokenType.Hash &&
                                              l != LexerTokenType.Newline,
                                              parserTokenType,
                                              expectNonEmpty: true);
         });
     }));
 }
        public static StatementBuilder <StatementType, ParserTokenType, LexerTokenType> AcceptNameQualifier(
            this StatementBuilder <StatementType, ParserTokenType, LexerTokenType> statement,
            LexerTokenType qualifierDelimeter,
            ParserTokenType identifierType,
            ParserTokenType qualifierType)
        {
            if (statement.TokenBuffer.LooksLikeQualifiedName(qualifierDelimeter))
            {
                statement.Expect(LexerTokenType.Identifier, identifierType)
                .Expect(qualifierDelimeter, qualifierType);
            }

            return(statement);
        }
 private static TokenListBuilder<ParserTokenType> Token(ParserTokenType type, string value)
 {
     var builder = new TokenListBuilder<ParserTokenType>();
     return builder.Token(type, value);
 }
Exemple #4
0
 public ParserToken(string word, ParserTokenType type)
 {
     Word = word;
     Type = type;
 }
Exemple #5
0
 public ParserToken(ParserTokenType type, int startIndex, int endIndex)
 {
     this.type        = type;
     this._startIndex = startIndex;
     this.endIndex    = endIndex;
 }