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
org.antlr.v4.runtime.atn.ATN	atn
int	currentOuterAlt
Rule	currentRule
Grammar	g
protected List<org.antlr.v4.runtime.misc.Tuple3<? extends Rule,? extends org.antlr.v4.runtime.atn.ATNState,? extends org.antlr.v4.runtime.atn.ATNState>>	preventEpsilonClosureBlocks
protected List<org.antlr.v4.runtime.misc.Tuple3<? extends Rule,? extends org.antlr.v4.runtime.atn.ATNState,? extends org.antlr.v4.runtime.atn.ATNState>>	preventEpsilonOptionalBlocks

Constructor Summary

Constructors

Constructor and Description
ParserATNFactory(Grammar g)

Method Summary

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, org.antlr.v4.runtime.atn.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
org.antlr.v4.runtime.atn.ATN	createATN()
ATNFactory.Handle	elemList(List<ATNFactory.Handle> els)
protected void	epsilon(org.antlr.v4.runtime.atn.ATNState a, org.antlr.v4.runtime.atn.ATNState b)
protected void	epsilon(org.antlr.v4.runtime.atn.ATNState a, org.antlr.v4.runtime.atn.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(org.antlr.v4.runtime.atn.BlockStartState start, BlockAST blkAST, List<ATNFactory.Handle> alts)
org.antlr.v4.runtime.atn.ATNState	newState()
<T extends org.antlr.v4.runtime.atn.ATNState> T	newState(Class<T> nodeType, GrammarAST node)
org.antlr.v4.runtime.atn.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 org.antlr.v4.runtime.atn.ATN atn

currentRule

public Rule currentRule

currentOuterAlt

public int currentOuterAlt

preventEpsilonClosureBlocks

@NotNull
protected final List<org.antlr.v4.runtime.misc.Tuple3<? extends Rule,? extends org.antlr.v4.runtime.atn.ATNState,? extends org.antlr.v4.runtime.atn.ATNState>> preventEpsilonClosureBlocks

preventEpsilonOptionalBlocks

@NotNull
protected final List<org.antlr.v4.runtime.misc.Tuple3<? extends Rule,? extends org.antlr.v4.runtime.atn.ATNState,? extends org.antlr.v4.runtime.atn.ATNState>> preventEpsilonOptionalBlocks

Constructor Detail

ParserATNFactory

public ParserATNFactory(@NotNull
                        Grammar g)

Method Detail

createATN

@NotNull
public org.antlr.v4.runtime.atn.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,
                          org.antlr.v4.runtime.atn.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
                                                org.antlr.v4.runtime.atn.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(org.antlr.v4.runtime.atn.ATNState a,
                       @NotNull
                       org.antlr.v4.runtime.atn.ATNState b)

epsilon

protected void epsilon(org.antlr.v4.runtime.atn.ATNState a,
                       @NotNull
                       org.antlr.v4.runtime.atn.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 org.antlr.v4.runtime.atn.ATNState> T newState(@NotNull
                                                                          Class<T> nodeType,
                                                                          GrammarAST node)

newState

@NotNull
public org.antlr.v4.runtime.atn.ATNState newState(@Nullable
                                                            GrammarAST node)

newState

@NotNull
public org.antlr.v4.runtime.atn.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