Convenience method equivalent to AT_LEAST_ONE1
convenience method, same as MANY but the repetition is of one or more. failing to match at least one repetition will result in a parsing error and cause the parser to attempt error recovery.
The lookahead function that 'decides' whether or not the AT_LEAST_ONE's action will be invoked or the action to optionally invoke
the rule to try and parse in backtracking mode
a predicate that given the result of the parse attempt will "decide" if the parse was successfully or not
a lookahead function that will try to parse the given grammarRule and will return true if succeed
Convenience method equivalent to CONSUME1
A Parsing DSL method use to consume a single terminal Token. a Token will be consumed, IFF the next token in the token vector is an instanceof tokClass. otherwise the parser will attempt to perform error recovery.
The index in the method name indicates the unique occurrence of a terminal consumption inside a the top level rule. What this means is that if a terminal appears more than once in a single rule, each appearance must have a difference index.
for example:
function parseQualifiedName() { this.CONSUME1(Identifier); this.MANY(()=> { this.CONSUME1(Dot); this.CONSUME2(Identifier); // <-- here we use CONSUME2 because the terminal }); // 'Identifier' has already appeared previously in the // the rule 'parseQualifiedName' }
A constructor function specifying the type of token to be consumed.
The consumed token.
Convenience method equivalent to MANY1
Parsing DSL method, that indicates a repetition of zero or more. This is equivalent to EBNF repetition {...}
note that the 'action' param is optional. so both of the following forms are valid:
short: this.MANY(()=>{ this.CONSUME(Comma}; this.CONSUME(Digit}); long: this.MANY(isComma, ()=>{ this.CONSUME(Comma}; this.CONSUME(Digit});
using the short form is recommended as it will compute the lookahead function automatically. however this currently has one limitation: It only works if the lookahead for the grammar is one.
As in CONSUME the index in the method name indicates the occurrence of the repetition production in it's top rule.
The lookahead function that 'decides' whether or not the MANY's action will be invoked or the action to optionally invoke
Convenience method equivalent to OPTION1
Parsing DSL Method that Indicates an Optional production in EBNF notation: [...]
note that the 'action' param is optional. so both of the following forms are valid:
short: this.OPTION(()=>{ this.CONSUME(Digit}); long: this.OPTION(isDigit, ()=>{ this.CONSUME(Digit});
using the short form is recommended as it will compute the lookahead function automatically. however this currently has one limitation: It only works if the lookahead for the grammar is one.
As in CONSUME the index in the method name indicates the occurrence of the optional production in it's top rule.
The lookahead function that 'decides' whether or not the OPTION's action will be invoked or the action to optionally invoke
true iff the OPTION's action has been invoked
Convenience method equivalent to OR1
Parsing DSL method that indicates a choice between a set of alternatives must be made. This is equivalent to EBNF alternation (A | B | C | D ...)
There are two forms:
short: this.OR([ {ALT:()=>{this.CONSUME(One)}}, {ALT:()=>{this.CONSUME(Two)}}, {ALT:()=>{this.CONSUME(Three)}}, ], "a number")
long: this.OR([ {WHEN: isOne, THEN_DO:()=>{this.CONSUME(One)}}, {WHEN: isTwo, THEN_DO:()=>{this.CONSUME(Two)}}, {WHEN: isThree, THEN_DO:()=>{this.CONSUME(Three)}}, ], "a number")
using the short form is recommended as it will compute the lookahead function automatically. however this currently has one limitation: It only works if the lookahead for the grammar is one.
As in CONSUME the index in the method name indicates the occurrence of the alternation production in it's top rule.
A description for the alternatives used in error messages
The result of invoking the chosen alternative
The name of the Rule. must match the var it is assigned to.
The implementation of the Rule
The parsing rule which is the impl Function wrapped with the parsing logic that handles Parser state / error recovery / ...
enable or disable re-sync recovery for this rule. defaults to true
Convenience method, same as RULE with doReSync=false
Convenience method equivalent to SUBRULE1
The Parsing DSL Method is used by one rule to call another.
This may seem redundant as it does not actually do much. However using it is mandatory for all sub rule invocations. calling another rule without wrapping in SUBRULE(...) will cause errors/mistakes in the Recognizer's self analysis which will lead to errors in error recovery/automatic lookahead calcualtion and any other functionality relying on the Recognizer's self analysis output.
As in CONSUME the index in the method name indicates the occurrence of the sub rule invocation in its rule.
the rule to invoke
the arguments to pass to the invoked subrule
the result of invoking ruleToCall
The Type of Token we wish to consume (Reference to its constructor function)
occurrence index of consumed token in the invoking parser rule text for example: IDENT (DOT IDENT)* the first ident will have idx 1 and the second one idx 2
* note that for the second ident the idx is always 2 even if its invoked 30 times in the same rule
the idx is about the position in grammar (source code) and has nothing to do with a specific invocation
details
the consumed Token
name of the Grammar rule
Generated using TypeDoc
A Recognizer capable of self analysis to determine it's grammar structure This is used for more advanced features requiring such information. for example: Error Recovery, Automatic lookahead calculation