Field Detail

• g

  public final Grammar g

• atn

  public final ATN atn

• currentRule

  public Rule currentRule

• currentOuterAlt

  public int currentOuterAlt

• preventEpsilonClosureBlocks

  protected final List<<any>> preventEpsilonClosureBlocks

• preventEpsilonOptionalBlocks

  protected final List<<any>> preventEpsilonOptionalBlocks

Constructor Detail

• ParserATNFactory

  public ParserATNFactory(Grammar g)

Method Detail

• createATN

  public ATN createATN()

• _createATN

  protected void _createATN(Collection<Rule> rules)

• setCurrentRuleName

  public void setCurrentRuleName(String name)

• setCurrentOuterAlt

  public void setCurrentOuterAlt(int alt)

• rule

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

• tokenRef

  public ATNFactory.Handle tokenRef(TerminalAST node)

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

• 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.

• range

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

  Not valid for non-lexers.

• getTokenType

  protected int getTokenType(GrammarAST atom)

• stringLiteral

  public ATNFactory.Handle stringLiteral(TerminalAST stringLiteralAST)

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

• charSetLiteral

  public ATNFactory.Handle charSetLiteral(GrammarAST charSetAST)

  [Aa] char sets not allowed in parser

• 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).

• _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.

• 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.

• 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.

• action

  public ATNFactory.Handle action(String action)

• 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?

• makeBlock

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

• alt

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

• elemList

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

• optional

  public 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

• plus

  public ATNFactory.Handle plus(GrammarAST plusAST,
                                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.

• star

  public 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.

     |-------------|
     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|)+.

• wildcard

  public ATNFactory.Handle wildcard(GrammarAST node)

  Build an atom with all possible values in its label.

• epsilon

  protected void epsilon(ATNState a,
                         ATNState b)

• epsilon

  protected void epsilon(ATNState a,
                         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

  public ATNFactory.Handle label(ATNFactory.Handle t)

• listLabel

  public ATNFactory.Handle listLabel(ATNFactory.Handle t)

• newState

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

• newState

  public ATNState newState(GrammarAST node)

• newState

  public ATNState newState()

• expectNonGreedy

  public boolean expectNonGreedy(BlockAST blkAST)

• blockHasWildcardAlt

  public static boolean blockHasWildcardAlt(GrammarAST block)

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

• lexerAltCommands

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

• lexerCallCommand

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

• lexerCommand

  public ATNFactory.Handle lexerCommand(GrammarAST ID)