org.antlr.v4.automata

Class ParserATNFactory

java.lang.Object

org.antlr.v4.automata.ParserATNFactory

All Implemented Interfaces:

ATNFactory

Direct Known Subclasses:

LexerATNFactory

public class ParserATNFactory
extends Object
implements ATNFactory

ATN construction routines triggered by ATNBuilder.g. No side-effects. It builds an ATN object and returns it.

Nested Class Summary

Nested classes/interfaces inherited from interface org.antlr.v4.automata.ATNFactory

ATNFactory.Handle

Field Summary

Fields

Modifier and Type	Field and Description
ATN	atn
int	currentOuterAlt
Rule	currentRule
Grammar	g
protected List<Tuple3<? extends Rule,? extends ATNState,? extends ATNState>>	preventEpsilonClosureBlocks
protected List<Tuple3<? extends Rule,? extends ATNState,? extends ATNState>>	preventEpsilonOptionalBlocks

Constructor Summary

Constructors

Constructor and Description
ParserATNFactory(Grammar g)

Method Summary

Methods

Modifier and Type	Method and Description
protected void	_createATN(Collection<Rule> rules)
ATNFactory.Handle	_ruleRef(GrammarAST node)
ATNFactory.Handle	action(ActionAST action) Build what amounts to an epsilon transition with an action.
ATNFactory.Handle	action(String action)
int	addEOFTransitionToStartRules() Add an EOF transition to any rule end ATNState that points to nothing (i.e., for all those rules not invoked by another rule).
void	addFollowLink(int ruleIndex, ATNState right)
void	addRuleFollowLinks()
ATNFactory.Handle	alt(List<ATNFactory.Handle> els)
ATNFactory.Handle	block(BlockAST blkAST, GrammarAST ebnfRoot, List<ATNFactory.Handle> alts) From A|B|..|Z alternative block build
static boolean	blockHasWildcardAlt(GrammarAST block) (BLOCK (ALT .)) or (BLOCK (ALT 'a') (ALT .)).
ATNFactory.Handle	charSetLiteral(GrammarAST charSetAST) [Aa] char sets not allowed in parser
ATN	createATN()
ATNFactory.Handle	elemList(List<ATNFactory.Handle> els)
protected void	epsilon(ATNState a, ATNState b)
protected void	epsilon(ATNState a, ATNState b, boolean prepend)
ATNFactory.Handle	epsilon(GrammarAST node) From an empty alternative build o-e->o.
boolean	expectNonGreedy(BlockAST blkAST)
protected int	getTokenType(GrammarAST atom)
boolean	isSLLDecision(BlockAST blkAST)
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)
protected ATNFactory.Handle	makeBlock(BlockStartState start, BlockAST blkAST, List<ATNFactory.Handle> alts)
ATNState	newState()
<T extends ATNState> T	newState(Class<T> nodeType, GrammarAST node)
ATNState	newState(GrammarAST node)
ATNFactory.Handle	optional(GrammarAST optAST, ATNFactory.Handle blk) From (A)? build either:
ATNFactory.Handle	plus(GrammarAST plusAST, ATNFactory.Handle blk) From (blk)+ build
ATNFactory.Handle	range(GrammarAST a, GrammarAST b) Not valid for non-lexers.
ATNFactory.Handle	rule(GrammarAST ruleAST, String name, ATNFactory.Handle blk)
ATNFactory.Handle	ruleRef(GrammarAST node) For reference to rule r, build
ATNFactory.Handle	sempred(PredAST pred) Build what amounts to an epsilon transition with a semantic predicate action.
ATNFactory.Handle	set(GrammarAST associatedAST, List<GrammarAST> terminals, boolean invert) From set build single edge graph o->o-set->o.
void	setCurrentOuterAlt(int alt)
void	setCurrentRuleName(String name)
ATNFactory.Handle	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	stringLiteral(TerminalAST stringLiteralAST) For a non-lexer, just build a simple token reference atom.
ATNFactory.Handle	tokenRef(TerminalAST node) From label A build graph o-A->o.
ATNFactory.Handle	wildcard(GrammarAST node) Build an atom with all possible values in its label.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

g

@NotNull
public final Grammar g

atn

@NotNull
public final ATN atn

currentRule

public Rule currentRule

currentOuterAlt

public int currentOuterAlt

preventEpsilonClosureBlocks

@NotNull
protected final List<Tuple3<? extends Rule,? extends ATNState,? extends ATNState>> preventEpsilonClosureBlocks

preventEpsilonOptionalBlocks

@NotNull
protected final List<Tuple3<? extends Rule,? extends ATNState,? extends ATNState>> preventEpsilonOptionalBlocks

Constructor Detail

ParserATNFactory

public ParserATNFactory(@NotNull
                Grammar g)

Method Detail

createATN

@NotNull
public ATN createATN()

Specified by:

createATN in interface ATNFactory

_createATN

protected void _createATN(@NotNull
              Collection<Rule> rules)

setCurrentRuleName

public void setCurrentRuleName(@NotNull
                      String name)

Specified by:

setCurrentRuleName in interface ATNFactory

setCurrentOuterAlt

public void setCurrentOuterAlt(int alt)

Specified by:

setCurrentOuterAlt in interface ATNFactory

rule

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

Specified by:

rule in interface ATNFactory

tokenRef

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

From label A build graph o-A->o.

Specified by:

tokenRef in interface ATNFactory

set

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

From set build single edge graph o->o-set->o. To conform to what an alt block looks like, must have extra state on left. This also handles ~A, converted to ~{A} set.

Specified by:

set in interface ATNFactory

range

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

Not valid for non-lexers.

Specified by:

range in interface ATNFactory

getTokenType

protected int getTokenType(@NotNull
               GrammarAST atom)

stringLiteral

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

For a non-lexer, just build a simple token reference atom.

Specified by:

stringLiteral in interface ATNFactory

charSetLiteral

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

[Aa] char sets not allowed in parser

Specified by:

charSetLiteral in interface ATNFactory

ruleRef

@NotNull
public ATNFactory.Handle ruleRef(@NotNull
                                GrammarAST node)

For reference to rule r, build

  o->(r)  o
 

where (r) is the start of rule r and the trailing o is not linked to from rule ref state directly (uses RuleTransition.followState).

Specified by:

ruleRef in interface ATNFactory

_ruleRef

@NotNull
public ATNFactory.Handle _ruleRef(@NotNull
                                 GrammarAST node)

addFollowLink

public void addFollowLink(int ruleIndex,
                 ATNState right)

epsilon

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

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

Specified by:

epsilon in interface ATNFactory

sempred

@NotNull
public 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 ANTLRParser.SEMPRED token.

Specified by:

sempred in interface ATNFactory

action

@NotNull
public 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 prediction if actionIndex<0.

Specified by:

action in interface ATNFactory

action

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

Specified by:

action in interface ATNFactory

block

@NotNull
public ATNFactory.Handle block(@NotNull
                              BlockAST blkAST,
                              @NotNull
                              GrammarAST ebnfRoot,
                              @NotNull
                              List<ATNFactory.Handle> alts)

From A|B|..|Z alternative block build

  o->o-A->o->o (last ATNState is BlockEndState pointed to by all alts)
  |          ^
  |->o-B->o--|
  |          |
  ...        |
  |          |
  |->o-Z->o--|
 

So start node points at every alternative with epsilon transition and every alt right side points at a block 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 edged o-set->o graph.

TODO: Set alt number (1..n) in the states?

Specified by:

block in interface ATNFactory

makeBlock

@NotNull
protected ATNFactory.Handle makeBlock(@NotNull
                                  BlockStartState start,
                                  @NotNull
                                  BlockAST blkAST,
                                  @NotNull
                                  List<ATNFactory.Handle> alts)

alt

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

Specified by:

alt in interface ATNFactory

elemList

@NotNull
public ATNFactory.Handle elemList(@NotNull
                                 List<ATNFactory.Handle> els)

optional

@NotNull
public 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

Specified by:

optional in interface ATNFactory

plus

@NotNull
public ATNFactory.Handle plus(@NotNull
                             GrammarAST plusAST,
                             @NotNull
                             ATNFactory.Handle blk)

From (blk)+ build

   |---------|
   v         |
  [o-blk-o]->o->o
 

We add a decision for loop back node to the existing one at blk start.

Specified by:

plus in interface ATNFactory

star

@NotNull
public ATNFactory.Handle star(@NotNull
                             GrammarAST starAST,
                             @NotNull
                             ATNFactory.Handle elem)

From (blk)* build ( blk+ )? with *two* decisions, one for entry and one for choosing alts of blk.

   |-------------|
   v             |
   o--[o-blk-o]->o  o
   |                ^
   -----------------|
 

Note that the optional bypass must jump outside the loop as (A|B)* is not the same thing as (A|B|)+.

Specified by:

star in interface ATNFactory

wildcard

@NotNull
public ATNFactory.Handle wildcard(@NotNull
                                 GrammarAST node)

Build an atom with all possible values in its label.

Specified by:

wildcard in interface ATNFactory

epsilon

protected void epsilon(ATNState a,
           @NotNull
           ATNState b)

epsilon

protected void epsilon(ATNState a,
           @NotNull
           ATNState b,
           boolean prepend)

addRuleFollowLinks

public void addRuleFollowLinks()

addEOFTransitionToStartRules

public int addEOFTransitionToStartRules()

Add an EOF transition to any rule end ATNState that points to nothing (i.e., for all those rules not invoked by another rule). These are start symbols then. Return the number of grammar entry points; i.e., how many rules are not invoked by another rule (they can only be invoked from outside). These are the start rules.

label

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

Specified by:

label in interface ATNFactory

listLabel

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

Specified by:

listLabel in interface ATNFactory

newState

@NotNull
public <T extends ATNState> T newState(@NotNull
                                      Class<T> nodeType,
                                      GrammarAST node)

newState

@NotNull
public ATNState newState(@Nullable
                        GrammarAST node)

newState

@NotNull
public ATNState newState()

Specified by:

newState in interface ATNFactory

expectNonGreedy

public boolean expectNonGreedy(@NotNull
                      BlockAST blkAST)

isSLLDecision

public boolean isSLLDecision(@NotNull
                    BlockAST blkAST)

blockHasWildcardAlt

public static boolean blockHasWildcardAlt(@NotNull
                          GrammarAST block)

(BLOCK (ALT .)) or (BLOCK (ALT 'a') (ALT .)).

lexerAltCommands

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

Specified by:

lexerAltCommands in interface ATNFactory

lexerCallCommand

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

Specified by:

lexerCallCommand in interface ATNFactory

lexerCommand

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

Specified by:

lexerCommand in interface ATNFactory