Class Rule

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

public class Rule extends Object
Combine the info associated with a rule.
  • Field Details

    • name

      public String name
    • index

      public int index
    • modifier

      public String modifier
    • startState

      public NFAState startState
    • stopState

      public NFAState stopState
    • options

      protected Map options
      This rule's options
    • legalOptions

      public static final Set legalOptions
    • tree

      public GrammarAST tree
      The AST representing the whole rule
    • grammar

      public Grammar grammar
      To which grammar does this belong?
    • argActionAST

      public GrammarAST argActionAST
      For convenience, track the argument def AST action node if any
    • EORNode

      public GrammarAST EORNode
    • FIRST

      public LookaheadSet FIRST
      The set of all tokens reachable from the start state w/o leaving via the accept state. If it reaches the accept state, FIRST includes EOR_TOKEN_TYPE.
    • returnScope

      public AttributeScope returnScope
      The return values of a rule and predefined rule attributes
    • parameterScope

      public AttributeScope parameterScope
    • ruleScope

      public AttributeScope ruleScope
      the attributes defined with "scope {...}" inside a rule
    • useScopes

      public List useScopes
      A list of scope names (String) used by this rule
    • tokenLabels

      public LinkedHashMap tokenLabels
      A list of all LabelElementPair attached to tokens like id=ID
    • wildcardTreeLabels

      public LinkedHashMap wildcardTreeLabels
      A list of all LabelElementPair attached to tokens like x=. in tree grammar
    • wildcardTreeListLabels

      public LinkedHashMap wildcardTreeListLabels
      A list of all LabelElementPair attached to tokens like x+=. in tree grammar
    • charLabels

      public LinkedHashMap charLabels
      A list of all LabelElementPair attached to single char literals like x='a'
    • ruleLabels

      public LinkedHashMap ruleLabels
      A list of all LabelElementPair attached to rule references like f=field
    • tokenListLabels

      public LinkedHashMap tokenListLabels
      A list of all Token list LabelElementPair like ids+=ID
    • ruleListLabels

      public LinkedHashMap ruleListLabels
      A list of all rule ref list LabelElementPair like ids+=expr
    • labelNameSpace

      protected Map<String,Grammar.LabelElementPair> labelNameSpace
      All labels go in here (plus being split per the above lists) to catch dup label and label type mismatches.
    • actions

      protected Map<String,GrammarAST> actions
      Map a name to an action for this rule. Currently init is only one we use, but we can add more in future. 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. A better name is probably namedActions, but I don't want everyone to have to change their code gen templates now.
    • inlineActions

      protected List<GrammarAST> inlineActions
      Track all executable actions other than named actions like @init. Also tracks exception handlers, predicates, and rewrite rewrites. We need to examine these actions before code generation so that we can detect refs to $rule.attr etc...
    • numberOfAlts

      public int numberOfAlts
    • altToTokenRefMap

      protected Map<String,List<GrammarAST>>[] altToTokenRefMap
      Each alt has a Map<tokenRefName,List>; range 1..numberOfAlts. So, if there are 3 ID refs in a rule's alt number 2, you'll have altToTokenRef[2].get("ID").size()==3. This is used to see if $ID is ok. There must be only one ID reference in the alt for $ID to be ok in an action--must be unique. This also tracks '+' and "int" literal token references (if not in LEXER). Rewrite rules force tracking of all tokens.
    • altToRuleRefMap

      protected Map<String,List<GrammarAST>>[] altToRuleRefMap
      Each alt has a Map<ruleRefName,List>; range 1..numberOfAlts So, if there are 3 expr refs in a rule's alt number 2, you'll have altToRuleRef[2].get("expr").size()==3. This is used to see if $expr is ok. There must be only one expr reference in the alt for $expr to be ok in an action--must be unique. Rewrite rules force tracking of all rule result ASTs. 1..n
    • altsWithRewrites

      protected boolean[] altsWithRewrites
      Track which alts have rewrite rules associated with them. 1..n
    • referencedPredefinedRuleAttributes

      public boolean referencedPredefinedRuleAttributes
      Do not generate start, stop etc... in a return value struct unless somebody references $r.start somewhere.
    • isSynPred

      public boolean isSynPred
    • imported

      public boolean imported
  • Constructor Details

    • Rule

      public Rule(Grammar grammar, String ruleName, int ruleIndex, int numberOfAlts)
  • Method Details

    • defineLabel

      public void defineLabel(antlr.Token label, GrammarAST elementRef, int type)
    • getLabel

      public Grammar.LabelElementPair getLabel(String name)
    • getTokenLabel

      public Grammar.LabelElementPair getTokenLabel(String name)
    • getRuleLabels

      public Map getRuleLabels()
    • getRuleListLabels

      public Map getRuleListLabels()
    • getRuleLabel

      public Grammar.LabelElementPair getRuleLabel(String name)
    • getTokenListLabel

      public Grammar.LabelElementPair getTokenListLabel(String name)
    • getRuleListLabel

      public Grammar.LabelElementPair getRuleListLabel(String name)
    • trackTokenReferenceInAlt

      public void trackTokenReferenceInAlt(GrammarAST refAST, int outerAltNum)
      Track a token ID or literal like '+' and "void" as having been referenced somewhere within the alts (not rewrite sections) of a rule. This differs from Grammar.altReferencesTokenID(), which tracks all token IDs to check for token IDs without corresponding lexer rules.
    • getTokenRefsInAlt

      public List getTokenRefsInAlt(String ref, int outerAltNum)
    • trackRuleReferenceInAlt

      public void trackRuleReferenceInAlt(GrammarAST refAST, int outerAltNum)
    • getRuleRefsInAlt

      public List getRuleRefsInAlt(String ref, int outerAltNum)
    • getTokenRefsInAlt

      public Set getTokenRefsInAlt(int altNum)
    • getAllTokenRefsInAltsWithRewrites

      public Set getAllTokenRefsInAltsWithRewrites()
      For use with rewrite rules, we must track all tokens matched on the left-hand-side; so we need Lists. This is a unique list of all token types for which the rule needs a list of tokens. This is called from the rule template not directly by the code generator.
    • getRuleRefsInAlt

      public Set getRuleRefsInAlt(int outerAltNum)
    • getAllRuleRefsInAltsWithRewrites

      public Set getAllRuleRefsInAltsWithRewrites()
      For use with rewrite rules, we must track all rule AST results on the left-hand-side; so we need Lists. This is a unique list of all rule results for which the rule needs a list of results.
    • getInlineActions

      public List<GrammarAST> getInlineActions()
    • hasRewrite

      public boolean hasRewrite(int i)
    • trackAltsWithRewrites

      public void trackAltsWithRewrites(GrammarAST altAST, int outerAltNum)
      Track which rules have rewrite rules. Pass in the ALT node for the alt so we can check for problems when output=template, rewrite=true, and grammar type is tree parser.
    • getAttributeScope

      public AttributeScope getAttributeScope(String name)
      Return the scope containing name
    • getLocalAttributeScope

      public AttributeScope getLocalAttributeScope(String name)
      Get the arg, return value, or predefined property for this rule
    • getElementLabel

      public String getElementLabel(String refdSymbol, int outerAltNum, CodeGenerator generator)
      For references to tokens rather than by label such as $ID, we need to get the existing label for the ID ref or create a new one.
    • getHasMultipleReturnValues

      public boolean getHasMultipleReturnValues()
      If a rule has no user-defined return values and nobody references it's start/stop (predefined attributes), then there is no need to define a struct; otherwise for now we assume a struct. A rule also has multiple return values if you are building trees or templates.
    • getHasSingleReturnValue

      public boolean getHasSingleReturnValue()
    • getHasReturnValue

      public boolean getHasReturnValue()
    • getSingleValueReturnType

      public String getSingleValueReturnType()
    • getSingleValueReturnName

      public String getSingleValueReturnName()
    • defineNamedAction

      public void defineNamedAction(GrammarAST ampersandAST, GrammarAST nameAST, GrammarAST actionAST)
      Given @scope::name {action} define it for this grammar. Later, the code generator will ask for the actions table.
    • trackInlineAction

      public void trackInlineAction(GrammarAST actionAST)
    • getActions

      public Map<String,GrammarAST> getActions()
    • setActions

      public void setActions(Map<String,GrammarAST> actions)
    • setOption

      public String setOption(String key, Object value, antlr.Token optionsStartToken)
      Save the option key/value pair and process it; return the key or null if invalid option.
    • setOptions

      public void setOptions(Map options, antlr.Token optionsStartToken)
    • toString

      public String toString()
      Used during grammar imports to see if sets of rules intersect... public int hashCode() { return name.hashCode(); }
      Overrides:
      toString in class Object