Rule (ANTLR 4 4.7.2 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	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 Description

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

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

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	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, String y, ActionAST node)`	$x.y Attribute: x is surrounding rule, label ref (in any alts)
`Attribute`	`resolveToAttribute(String x, ActionAST node)`	$x Attribute: rule arguments, return values, predefined rule prop.
`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