RuleContext class abstract

A rule context is a record of a single rule invocation.

We form a stack of these context objects using the parent pointer. A parent pointer of null indicates that the current context is the bottom of the stack. The ParserRuleContext subclass as a children list so that we can turn this data structure into a tree.

The root node always has a null pointer and invokingState of -1.

Upon entry to parsing, the first invoked rule function creates a context object (a subclass specialized for that rule such as SContext) and makes it the root of a parse tree, recorded by field Parser._ctx.

public final SContext s() throws RecognitionException { SContext _localctx = new SContext(_ctx, getState()); <-- create new node enterRule(_localctx, 0, RULE_s); <-- push it ... exitRule(); <-- pop back to _localctx return _localctx; }

A subsequent rule invocation of r from the start rule s pushes a new context object for r whose parent points at s and use invoking state is the state with r emanating as edge label.

The invokingState fields from a context object to the root together form a stack of rule indication states where the root (bottom of the stack) has a -1 sentinel value. If we invoke start symbol s then call r1, which calls r2, the would look like this:

SContext[-1]   <- root node (bottom of the stack)
R1Context[p]   <- p in rule s called r1
R2Context[q]   <- q in rule r1 called r2

So the top of the stack, _ctx, represents a call to the current rule and it holds the return address from another rule that invoke to this rule. To invoke a rule, we must always have a current context.

The parent contexts are useful for computing lookahead sets and getting error information.

These objects are used during parsing and prediction. For the special case of parsers, we use the subclass ParserRuleContext.

@see ParserRuleContext

Inheritance
Implementers

Constructors

RuleContext({RuleContext? parent, int? invokingState})

Properties

altNumber ↔ int
For rule associated with this parse tree internal node, return the outer alternative number used to match the input. Default implementation does not compute nor store this alt num. Create a subclass of ParserRuleContext with backing field and set option contextSuperClass. to set it.
getter/setter pair
childCount → int
no setteroverride
hashCode → int
The hash code for this object.
no setterinherited
invokingState ↔ int
What state invoked the rule associated with this context? The "return address" is the followState of invokingState If parent is null, this should be -1.
getter/setter pair
isEmpty → bool
A context is empty if there is no invoking state; meaning nobody call current context.
no setter
parent ↔ RuleContext?
Set the parent for this node.
covariantgetter/setter pairoverride
payload → RuleContext
no setteroverride
ruleContext → RuleContext
no setteroverride
ruleIndex → int
no setter
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
sourceInterval → Interval
satisfy the ParseTree / SyntaxTree interface
no setteroverride
text → String
Return the combined text of all child nodes. This method only considers tokens which have been added to the parse tree.
no setteroverride

Methods

accept<T>(ParseTreeVisitor<T> visitor) → T?
The ParseTreeVisitor needs a double dispatch method. */
override
depth() → int
getChild<T>(int i) → ParseTree?
override
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
toString({List<String>? ruleNames, Recognizer<ATNSimulator>? recog, RuleContext? stop}) → String
A string representation of this object.
override
toStringTree({List<String>? ruleNames, Parser? parser}) → String
Print out a whole tree, not just a node, in LISP format (root child1 .. childN). Print just a node if this is a leaf.
override

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Properties

EMPTY → ParserRuleContext
final