ATNFactory.Handle |
ParserATNFactory._ruleRef(GrammarAST node) |
|
ATNFactory.Handle |
ATNFactory.action(String action) |
|
ATNFactory.Handle |
ATNFactory.action(ActionAST action) |
Build what amounts to an epsilon transition with an action.
|
ATNFactory.Handle |
LexerATNFactory.action(String action) |
|
ATNFactory.Handle |
LexerATNFactory.action(ActionAST action) |
|
protected ATNFactory.Handle |
LexerATNFactory.action(GrammarAST node,
LexerAction lexerAction) |
|
ATNFactory.Handle |
ParserATNFactory.action(String action) |
|
ATNFactory.Handle |
ParserATNFactory.action(ActionAST action) |
Build what amounts to an epsilon transition with an action.
|
ATNFactory.Handle |
ATNFactory.alt(List<ATNFactory.Handle> els) |
|
ATNFactory.Handle |
ParserATNFactory.alt(List<ATNFactory.Handle> els) |
|
ATNFactory.Handle |
ATNFactory.block(BlockAST blockAST,
GrammarAST ebnfRoot,
List<ATNFactory.Handle> alternativeGrips) |
From A|B|..|Z alternative block build
o->o-A->o->o (last ATNState is blockEndATNState pointed to by all alts)
| ^
o->o-B->o--|
| |
...
|
ATNFactory.Handle |
ParserATNFactory.block(BlockAST blkAST,
GrammarAST ebnfRoot,
List<ATNFactory.Handle> alts) |
From A|B|..|Z alternative block build
|
ATNFactory.Handle |
ATNFactory.charSetLiteral(GrammarAST charSetAST) |
|
ATNFactory.Handle |
LexerATNFactory.charSetLiteral(GrammarAST charSetAST) |
[Aa\t ሴa-z\]\p{Letter}\-] char sets
|
ATNFactory.Handle |
ParserATNFactory.charSetLiteral(GrammarAST charSetAST) |
[Aa] char sets not allowed in parser
|
ATNFactory.Handle |
ParserATNFactory.elemList(List<ATNFactory.Handle> els) |
|
ATNFactory.Handle |
ATNFactory.epsilon(GrammarAST node) |
From an empty alternative build Grip o-e->o
|
ATNFactory.Handle |
ParserATNFactory.epsilon(GrammarAST node) |
From an empty alternative build o-e->o .
|
ATNFactory.Handle |
ATNFactory.label(ATNFactory.Handle t) |
|
ATNFactory.Handle |
ParserATNFactory.label(ATNFactory.Handle t) |
|
ATNFactory.Handle |
ATNFactory.lexerAltCommands(ATNFactory.Handle alt,
ATNFactory.Handle cmds) |
|
ATNFactory.Handle |
LexerATNFactory.lexerAltCommands(ATNFactory.Handle alt,
ATNFactory.Handle cmds) |
|
ATNFactory.Handle |
ParserATNFactory.lexerAltCommands(ATNFactory.Handle alt,
ATNFactory.Handle cmds) |
|
ATNFactory.Handle |
ATNFactory.lexerCallCommand(GrammarAST ID,
GrammarAST arg) |
|
ATNFactory.Handle |
LexerATNFactory.lexerCallCommand(GrammarAST ID,
GrammarAST arg) |
|
ATNFactory.Handle |
ParserATNFactory.lexerCallCommand(GrammarAST ID,
GrammarAST arg) |
|
ATNFactory.Handle |
ATNFactory.lexerCommand(GrammarAST ID) |
|
ATNFactory.Handle |
LexerATNFactory.lexerCommand(GrammarAST ID) |
|
ATNFactory.Handle |
ParserATNFactory.lexerCommand(GrammarAST ID) |
|
ATNFactory.Handle |
ATNFactory.listLabel(ATNFactory.Handle t) |
|
ATNFactory.Handle |
ParserATNFactory.listLabel(ATNFactory.Handle t) |
|
protected ATNFactory.Handle |
ParserATNFactory.makeBlock(BlockStartState start,
BlockAST blkAST,
List<ATNFactory.Handle> alts) |
|
ATNFactory.Handle |
ATNFactory.optional(GrammarAST optAST,
ATNFactory.Handle blk) |
From (A)? build either:
o--A->o
| ^
o---->|
or, if A is a block, just add an empty alt to the end of the block
|
ATNFactory.Handle |
ParserATNFactory.optional(GrammarAST optAST,
ATNFactory.Handle blk) |
From (A)? build either:
|
ATNFactory.Handle |
ATNFactory.plus(GrammarAST plusAST,
ATNFactory.Handle blk) |
From (A)+ build
|---| (Transition 2 from A.right points at alt 1)
v | (follow of loop is Transition 1)
o->o-A-o->o
Meaning that the last ATNState in A points back to A's left Transition ATNState
and we add a new begin/end ATNState.
|
ATNFactory.Handle |
ParserATNFactory.plus(GrammarAST plusAST,
ATNFactory.Handle blk) |
From (blk)+ build
|
ATNFactory.Handle |
ATNFactory.range(GrammarAST a,
GrammarAST b) |
|
ATNFactory.Handle |
LexerATNFactory.range(GrammarAST a,
GrammarAST b) |
|
ATNFactory.Handle |
ParserATNFactory.range(GrammarAST a,
GrammarAST b) |
Not valid for non-lexers.
|
ATNFactory.Handle |
ATNFactory.rule(GrammarAST ruleAST,
String name,
ATNFactory.Handle blk) |
|
ATNFactory.Handle |
LexerATNFactory.rule(GrammarAST ruleAST,
String name,
ATNFactory.Handle blk) |
|
ATNFactory.Handle |
ParserATNFactory.rule(GrammarAST ruleAST,
String name,
ATNFactory.Handle blk) |
|
ATNFactory.Handle |
ATNFactory.ruleRef(GrammarAST node) |
For reference to rule r, build
o-e->(r) o
where (r) is the start of rule r and the trailing o is not linked
to from rule ref state directly (it's done thru the transition(0)
RuleClosureTransition.
|
ATNFactory.Handle |
ParserATNFactory.ruleRef(GrammarAST node) |
For reference to rule r , build
|
ATNFactory.Handle |
ATNFactory.sempred(PredAST pred) |
Build what amounts to an epsilon transition with a semantic
predicate action.
|
ATNFactory.Handle |
ParserATNFactory.sempred(PredAST pred) |
Build what amounts to an epsilon transition with a semantic
predicate action.
|
ATNFactory.Handle |
ATNFactory.set(GrammarAST associatedAST,
List<GrammarAST> alts,
boolean invert) |
|
ATNFactory.Handle |
LexerATNFactory.set(GrammarAST associatedAST,
List<GrammarAST> alts,
boolean invert) |
|
ATNFactory.Handle |
ParserATNFactory.set(GrammarAST associatedAST,
List<GrammarAST> terminals,
boolean invert) |
From set build single edge graph o->o-set->o .
|
ATNFactory.Handle |
ATNFactory.star(GrammarAST starAST,
ATNFactory.Handle blk) |
From (A)* build
|---|
v |
o->o-A-o--o (Transition 2 from block end points at alt 1; follow is Transition 1)
| ^
o---------| (optional branch is 2nd alt of optional block containing A+)
Meaning that the last (end) ATNState in A points back to A's
left side ATNState and we add 3 new ATNStates (the
optional branch is built just like an optional subrule).
|
ATNFactory.Handle |
ParserATNFactory.star(GrammarAST starAST,
ATNFactory.Handle elem) |
From (blk)* build ( blk+ )? with *two* decisions, one for
entry and one for choosing alts of blk .
|
ATNFactory.Handle |
ATNFactory.stringLiteral(TerminalAST stringLiteralAST) |
For a non-lexer, just build a simple token reference atom.
|
ATNFactory.Handle |
LexerATNFactory.stringLiteral(TerminalAST stringLiteralAST) |
For a lexer, a string is a sequence of char to match.
|
ATNFactory.Handle |
ParserATNFactory.stringLiteral(TerminalAST stringLiteralAST) |
For a non-lexer, just build a simple token reference atom.
|
ATNFactory.Handle |
ATNFactory.tokenRef(TerminalAST node) |
|
ATNFactory.Handle |
LexerATNFactory.tokenRef(TerminalAST node) |
|
ATNFactory.Handle |
ParserATNFactory.tokenRef(TerminalAST node) |
From label A build graph o-A->o .
|
ATNFactory.Handle |
ATNFactory.wildcard(GrammarAST associatedAST) |
Build an atom with all possible values in its label
|
ATNFactory.Handle |
ParserATNFactory.wildcard(GrammarAST node) |
Build an atom with all possible values in its label.
|