org.antlr.v4.automata

Interface ATNFactory

All Known Implementing Classes:

LexerATNFactory, ParserATNFactory

public interface ATNFactory

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	ATNFactory.Handle A pair of states pointing to the left/right (start and end) states of a state submachine.

Method Summary

Methods

Modifier and Type	Method and Description
ATNFactory.Handle	action(ActionAST action) Build what amounts to an epsilon transition with an action.
ATNFactory.Handle	action(String action)
ATNFactory.Handle	alt(List<ATNFactory.Handle> els)
ATNFactory.Handle	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	charSetLiteral(GrammarAST charSetAST)
ATN	createATN()
ATNFactory.Handle	epsilon(GrammarAST node) From an empty alternative build Grip o-e->o
ATNFactory.Handle	label(ATNFactory.Handle t)
ATNFactory.Handle	lexerAltCommands(ATNFactory.Handle alt, ATNFactory.Handle cmds)
ATNFactory.Handle	lexerCallCommand(GrammarAST ID, GrammarAST arg)
ATNFactory.Handle	lexerCommand(GrammarAST ID)
ATNFactory.Handle	listLabel(ATNFactory.Handle t)
ATNState	newState()
ATNFactory.Handle	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	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	range(GrammarAST a, GrammarAST b)
ATNFactory.Handle	rule(GrammarAST ruleAST, String name, ATNFactory.Handle blk)
ATNFactory.Handle	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	sempred(PredAST pred) Build what amounts to an epsilon transition with a semantic predicate action.
ATNFactory.Handle	set(GrammarAST associatedAST, List<GrammarAST> alts, boolean invert)
void	setCurrentOuterAlt(int alt)
void	setCurrentRuleName(String name)
ATNFactory.Handle	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	stringLiteral(TerminalAST stringLiteralAST) For a non-lexer, just build a simple token reference atom.
ATNFactory.Handle	tokenRef(TerminalAST node)
ATNFactory.Handle	wildcard(GrammarAST associatedAST) Build an atom with all possible values in its label

Method Detail

createATN

@NotNull
ATN createATN()

setCurrentRuleName

void setCurrentRuleName(@NotNull
                      String name)

setCurrentOuterAlt

void setCurrentOuterAlt(int alt)

rule

@NotNull
ATNFactory.Handle rule(@NotNull
                             GrammarAST ruleAST,
                             @NotNull
                             String name,
                             @NotNull
                             ATNFactory.Handle blk)

newState

@NotNull
ATNState newState()

label

@NotNull
ATNFactory.Handle label(@NotNull
                              ATNFactory.Handle t)

listLabel

@NotNull
ATNFactory.Handle listLabel(@NotNull
                                  ATNFactory.Handle t)

tokenRef

@NotNull
ATNFactory.Handle tokenRef(@NotNull
                                 TerminalAST node)

set

@NotNull
ATNFactory.Handle set(@NotNull
                            GrammarAST associatedAST,
                            @NotNull
                            List<GrammarAST> alts,
                            boolean invert)

charSetLiteral

@NotNull
ATNFactory.Handle charSetLiteral(@NotNull
                                       GrammarAST charSetAST)

range

@NotNull
ATNFactory.Handle range(@NotNull
                              GrammarAST a,
                              @NotNull
                              GrammarAST b)

stringLiteral

@NotNull
ATNFactory.Handle stringLiteral(@NotNull
                                      TerminalAST stringLiteralAST)

For a non-lexer, just build a simple token reference atom. For a lexer, a string is a sequence of char to match. That is, "fog" is treated as 'f' 'o' 'g' not as a single transition in the DFA. Machine== o-'f'->o-'o'->o-'g'->o and has n+1 states for n characters.

ruleRef

@NotNull
ATNFactory.Handle ruleRef(@NotNull
                                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. If the rule r is just a list of tokens, it's block will be just a set on an edge o->o->o-set->o->o->o, could inline it rather than doing the rule reference, but i'm not doing this yet as I'm not sure it would help much in the ATN->DFA construction. TODO add to codegen: collapse alt blks that are sets into single matchSet

Parameters:

node -

epsilon

@NotNull
ATNFactory.Handle epsilon(@NotNull
                                GrammarAST node)

From an empty alternative build Grip o-e->o

sempred

@NotNull
ATNFactory.Handle sempred(@NotNull
                                PredAST pred)

Build what amounts to an epsilon transition with a semantic predicate action. The pred is a pointer into the AST of the SEMPRED token.

action

@NotNull
ATNFactory.Handle action(@NotNull
                               ActionAST action)

Build what amounts to an epsilon transition with an action. The action goes into ATN though it is ignored during analysis.

action

@NotNull
ATNFactory.Handle action(@NotNull
                               String action)

alt

@NotNull
ATNFactory.Handle alt(@NotNull
                            List<ATNFactory.Handle> els)

block

@NotNull
ATNFactory.Handle block(@NotNull
                              BlockAST blockAST,
                              @NotNull
                              GrammarAST ebnfRoot,
                              @NotNull
                              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--| | | ... | | | o->o-Z->o--| So every alternative gets begin ATNState connected by epsilon and every alt right side points at a block end ATNState. There is a new ATNState in the ATNState in the Grip for each alt plus one for the end ATNState. Special case: only one alternative: don't make a block with alt begin/end. Special case: if just a list of tokens/chars/sets, then collapse to a single edge'd o-set->o graph. Set alt number (1..n) in the left-Transition ATNState.

optional

@NotNull
ATNFactory.Handle optional(@NotNull
                                 GrammarAST optAST,
                                 @NotNull
                                 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

plus

@NotNull
ATNFactory.Handle plus(@NotNull
                             GrammarAST plusAST,
                             @NotNull
                             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. A can be single alternative or multiple. During analysis we'll call the follow link (transition 1) alt n+1 for an n-alt A block.

star

@NotNull
ATNFactory.Handle star(@NotNull
                             GrammarAST starAST,
                             @NotNull
                             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). See the Aplus() method for more on the loop back Transition. The new node on right edge is set to RIGHT_EDGE_OF_CLOSURE so we can detect nested (A*)* loops and insert an extra node. Previously, two blocks shared same EOB node. There are 2 or 3 decision points in a A*. If A is not a block (i.e., it only has one alt), then there are two decisions: the optional bypass and then loopback. If A is a block of alts, then there are three decisions: bypass, loopback, and A's decision point. Note that the optional bypass must be outside the loop as (A|B)* is not the same thing as (A|B|)+. This is an accurate ATN representation of the meaning of (A)*, but for generating code, I don't need a DFA for the optional branch by virtue of how I generate code. The exit-loopback-branch decision is sufficient to let me make an appropriate enter, exit, loop determination. See codegen.g

wildcard

@NotNull
ATNFactory.Handle wildcard(@NotNull
                                 GrammarAST associatedAST)

Build an atom with all possible values in its label

lexerAltCommands

@NotNull
ATNFactory.Handle lexerAltCommands(@NotNull
                                         ATNFactory.Handle alt,
                                         @NotNull
                                         ATNFactory.Handle cmds)

lexerCallCommand

@NotNull
ATNFactory.Handle lexerCallCommand(@NotNull
                                         GrammarAST ID,
                                         @NotNull
                                         GrammarAST arg)

lexerCommand

@NotNull
ATNFactory.Handle lexerCommand(@NotNull
                                     GrammarAST ID)