Rule (ANTLR 4 Tool 4.8 API)

java.lang.Object
- org.antlr.v4.tool.Rule

All Implemented Interfaces:

AttributeResolver

Direct Known Subclasses:

LeftRecursiveRule
```
public class Rule
extends Object
implements AttributeResolver
```

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`actionIndex`
`List<ActionAST>`	`actions` Track all executable actions other than named actions like @init and catch/finally (not in an alt).
`Alternative[]`	`alt` 1..n alts
`AttributeDict`	`args`
`RuleAST`	`ast`
`List<GrammarAST>`	`exceptions` Track exception handlers; points at "catch" node of (catch exception action) don't track finally action
`ActionAST`	`finallyAction`
`Grammar`	`g` In which grammar does this rule live?
`int`	`index` All rules have unique index 0..n-1
`boolean`	`isStartRule`
`AttributeDict`	`locals`
`String`	`mode` If we're in a lexer grammar, we might be in a mode
`List<GrammarAST>`	`modifiers`
`String`	`name`
`Map<String,ActionAST>`	`namedActions` Map a name to an action for this rule like @init {...}.
`int`	`numberOfAlts`
`static AttributeDict`	`predefinedRulePropertiesDict` Rule refs have a predefined set of attributes as well as the return values and args.
`AttributeDict`	`retvals`
`static Set<String>`	`validLexerCommands`

Constructor Summary

Constructors
Constructor and Description

Rule(Grammar g, String name, RuleAST ast, int numberOfAlts)

Constructors
Constructor and Description
`Rule(Grammar g, String name, RuleAST ast, int numberOfAlts)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`defineActionInAlt(int currentAlt, ActionAST actionAST)`
`void`	`defineLexerAction(ActionAST actionAST)` Lexer actions are numbered across rules 0..n-1
`void`	`definePredicateInAlt(int currentAlt, PredAST predAST)`
`boolean`	`equals(Object obj)`
`Map<String,List<Pair<Integer,AltAST>>>`	`getAltLabels()` Get `#` labels.
`LabelElementPair`	`getAnyLabelDef(String x)`
`org.stringtemplate.v4.misc.MultiMap<String,LabelElementPair>`	`getElementLabelDefs()`
`Set<String>`	`getElementLabelNames()`
`int`	`getOriginalNumberOfAlts()` Used for recursive rules (subclass), which have 1 alt, but many original alts
`AttributeDict`	`getPredefinedScope(LabelType ltype)`
`Set<String>`	`getTokenRefs()`
`List<AltAST>`	`getUnlabeledAltASTs()`
`boolean`	`hasAltSpecificContexts()`
`int`	`hashCode()`
`boolean`	`isFragment()`
`Attribute`	`resolveRetvalOrProperty(String y)`
`boolean`	`resolvesToAttributeDict(String x, ActionAST node)`
`boolean`	`resolvesToLabel(String x, ActionAST node)`
`boolean`	`resolvesToListLabel(String x, ActionAST node)`
`boolean`	`resolvesToToken(String x, ActionAST node)`
`Attribute`	`resolveToAttribute(String x, ActionAST node)` $x Attribute: rule arguments, return values, predefined rule prop.
`Attribute`	`resolveToAttribute(String x, String y, ActionAST node)` $x.y Attribute: x is surrounding rule, label ref (in any alts)
`Rule`	`resolveToRule(String x)`
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - predefinedRulePropertiesDict
```
public static final AttributeDict predefinedRulePropertiesDict
```
    Rule refs have a predefined set of attributes as well as the return values and args. These must be consistent with ActionTranslator.rulePropToModelMap, ...
  - validLexerCommands
```
public static final Set<String> validLexerCommands
```
  - name
```
public String name
```
  - modifiers
```
public List<GrammarAST> modifiers
```
  - ast
```
public RuleAST ast
```
  - args
```
public AttributeDict args
```
  - retvals
```
public AttributeDict retvals
```
  - locals
```
public AttributeDict locals
```
  - g
```
public Grammar g
```
    In which grammar does this rule live?
  - mode
```
public String mode
```
    If we're in a lexer grammar, we might be in a mode
  - namedActions
```
public Map<String,ActionAST> namedActions
```
    Map a name to an action for this rule like @init {...}. The code generator will use this to fill holes in the rule template. I track the AST node for the action in case I need the line number for errors.
  - exceptions
```
public List<GrammarAST> exceptions
```
    Track exception handlers; points at "catch" node of (catch exception action) don't track finally action
  - actions
```
public List<ActionAST> actions
```
    Track all executable actions other than named actions like @init and catch/finally (not in an alt). Also tracks predicates, rewrite actions. We need to examine these actions before code generation so that we can detect refs to $rule.attr etc... This tracks per rule; Alternative objs also track per alt.
  - finallyAction
```
public ActionAST finallyAction
```
  - numberOfAlts
```
public int numberOfAlts
```
  - isStartRule
```
public boolean isStartRule
```
  - alt
```
public Alternative[] alt
```
    1..n alts
  - index
```
public int index
```
    All rules have unique index 0..n-1
  - actionIndex
```
public int actionIndex
```
- Constructor Detail
  - Rule
```
public Rule(Grammar g,
    String name,
    RuleAST ast,
    int numberOfAlts)
```
- Method Detail
  - defineActionInAlt
```
public void defineActionInAlt(int currentAlt,
                     ActionAST actionAST)
```
  - defineLexerAction
```
public void defineLexerAction(ActionAST actionAST)
```
    Lexer actions are numbered across rules 0..n-1
  - definePredicateInAlt
```
public void definePredicateInAlt(int currentAlt,
                        PredAST predAST)
```
  - resolveRetvalOrProperty
```
public Attribute resolveRetvalOrProperty(String y)
```
  - getTokenRefs
```
public Set<String> getTokenRefs()
```
  - getElementLabelNames
```
public Set<String> getElementLabelNames()
```
  - getElementLabelDefs
```
public org.stringtemplate.v4.misc.MultiMap<String,LabelElementPair> getElementLabelDefs()
```
  - hasAltSpecificContexts
```
public boolean hasAltSpecificContexts()
```
  - getOriginalNumberOfAlts
```
public int getOriginalNumberOfAlts()
```
    Used for recursive rules (subclass), which have 1 alt, but many original alts
  - getAltLabels
```
public Map<String,List<Pair<Integer,AltAST>>> getAltLabels()
```
    Get # labels. The keys of the map are the labels applied to outer alternatives of a lexer rule, and the values are collections of pairs (alternative number and AltAST) identifying the alternatives with this label. Unlabeled alternatives are not included in the result.
  - getUnlabeledAltASTs
```
public List<AltAST> getUnlabeledAltASTs()
```
  - resolveToAttribute
```
public Attribute resolveToAttribute(String x,
                           ActionAST node)
```
    $x Attribute: rule arguments, return values, predefined rule prop.
    
    Specified by:
    
    resolveToAttribute in interface AttributeResolver
  - resolveToAttribute
```
public Attribute resolveToAttribute(String x,
                           String y,
                           ActionAST node)
```
    $x.y Attribute: x is surrounding rule, label ref (in any alts)
    
    Specified by:
    
    resolveToAttribute in interface AttributeResolver
  - resolvesToLabel
```
public boolean resolvesToLabel(String x,
                      ActionAST node)
```
    Specified by:
    
    resolvesToLabel in interface AttributeResolver
  - resolvesToListLabel
```
public boolean resolvesToListLabel(String x,
                          ActionAST node)
```
    Specified by:
    
    resolvesToListLabel in interface AttributeResolver
  - resolvesToToken
```
public boolean resolvesToToken(String x,
                      ActionAST node)
```
    Specified by:
    
    resolvesToToken in interface AttributeResolver
  - resolvesToAttributeDict
```
public boolean resolvesToAttributeDict(String x,
                              ActionAST node)
```
    Specified by:
    
    resolvesToAttributeDict in interface AttributeResolver
  - resolveToRule
```
public Rule resolveToRule(String x)
```
  - getAnyLabelDef
```
public LabelElementPair getAnyLabelDef(String x)
```
  - getPredefinedScope
```
public AttributeDict getPredefinedScope(LabelType ltype)
```
  - isFragment
```
public boolean isFragment()
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class Rule

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

predefinedRulePropertiesDict

validLexerCommands

name

modifiers

ast

args

retvals

locals

g

mode

namedActions

exceptions

actions

finallyAction

numberOfAlts

isStartRule

alt

index

actionIndex

Constructor Detail

Rule

Method Detail

defineActionInAlt

defineLexerAction

definePredicateInAlt

resolveRetvalOrProperty

getTokenRefs

getElementLabelNames

getElementLabelDefs

hasAltSpecificContexts

getOriginalNumberOfAlts

getAltLabels

getUnlabeledAltASTs

resolveToAttribute

resolveToAttribute

resolvesToLabel

resolvesToListLabel

resolvesToToken

resolvesToAttributeDict

resolveToRule

getAnyLabelDef

getPredefinedScope

isFragment

hashCode

equals

toString