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

Constructor Summary

Constructors

Constructor and Description
ParserATNFactory(Grammar g)

Method Summary

Methods

Modifier and Type	Method and Description
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)
ATNFactory.Handle	epsilon(GrammarAST node) From an empty alternative build o-e->o.
boolean	expectNonGreedy(BlockAST blkAST)
protected int	getTokenType(GrammarAST atom)
ATNFactory.Handle	label(ATNFactory.Handle t)
ATNFactory.Handle	lexerAltCommands(ATNFactory.Handle alt, ATNFactory.Handle cmds)
String	lexerCallCommand(GrammarAST ID, GrammarAST arg)
String	lexerCommand(GrammarAST ID)
ATNFactory.Handle	listLabel(ATNFactory.Handle t)
protected ATNFactory.Handle	makeBlock(BlockStartState start, GrammarAST 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

Constructor Detail

ParserATNFactory

public ParserATNFactory(@NotNull
                Grammar g)

Method Detail

createATN

public ATN createATN()

Specified by:

createATN in interface ATNFactory

_createATN

public void _createATN(Collection<Rule> rules)

setCurrentRuleName

public void setCurrentRuleName(String name)

Specified by:

setCurrentRuleName in interface ATNFactory

setCurrentOuterAlt

public void setCurrentOuterAlt(int alt)

Specified by:

setCurrentOuterAlt in interface ATNFactory

rule

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

Specified by:

rule in interface ATNFactory

tokenRef

public ATNFactory.Handle tokenRef(TerminalAST node)

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

Specified by:

tokenRef in interface ATNFactory

set

public ATNFactory.Handle set(GrammarAST associatedAST,
                    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

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

Not valid for non-lexers.

Specified by:

range in interface ATNFactory

getTokenType

protected int getTokenType(GrammarAST atom)

stringLiteral

public ATNFactory.Handle stringLiteral(TerminalAST stringLiteralAST)

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

Specified by:

stringLiteral in interface ATNFactory

charSetLiteral

public ATNFactory.Handle charSetLiteral(GrammarAST charSetAST)

[Aa] char sets not allowed in parser

Specified by:

charSetLiteral in interface ATNFactory

ruleRef

public ATNFactory.Handle ruleRef(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

public ATNFactory.Handle _ruleRef(GrammarAST node)

addFollowLink

public void addFollowLink(int ruleIndex,
                 ATNState right)

epsilon

public ATNFactory.Handle epsilon(GrammarAST node)

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

Specified by:

epsilon in interface ATNFactory

sempred

public ATNFactory.Handle sempred(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

public ATNFactory.Handle action(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

public ATNFactory.Handle action(String action)

Specified by:

action in interface ATNFactory

block

public ATNFactory.Handle block(BlockAST blkAST,
                      GrammarAST ebnfRoot,
                      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

protected ATNFactory.Handle makeBlock(BlockStartState start,
                          GrammarAST blkAST,
                          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(GrammarAST node)

Build an atom with all possible values in its label.

Specified by:

wildcard in interface ATNFactory

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

public ATNFactory.Handle label(ATNFactory.Handle t)

Specified by:

label in interface ATNFactory

listLabel

public ATNFactory.Handle listLabel(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)

blockHasWildcardAlt

public static boolean blockHasWildcardAlt(@NotNull
                          GrammarAST block)

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

lexerAltCommands

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

Specified by:

lexerAltCommands in interface ATNFactory

lexerCallCommand

public String lexerCallCommand(GrammarAST ID,
                      GrammarAST arg)

Specified by:

lexerCallCommand in interface ATNFactory

lexerCommand

public String lexerCommand(GrammarAST ID)

Specified by:

lexerCommand in interface ATNFactory