125 lines
5.3 KiB
TypeScript
125 lines
5.3 KiB
TypeScript
/*!
|
|
* Copyright 2016 The ANTLR Project. All rights reserved.
|
|
* Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
|
|
*/
|
|
import { Parser } from "./Parser";
|
|
import { Recognizer } from "./Recognizer";
|
|
import { RuleNode } from "./tree/RuleNode";
|
|
import { ParseTree } from "./tree/ParseTree";
|
|
import { Interval } from "./misc/Interval";
|
|
import { ParseTreeVisitor } from "./tree/ParseTreeVisitor";
|
|
/** 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 `undefined` 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 `undefined` 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, state); <-- 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
|
|
*/
|
|
export declare class RuleContext extends RuleNode {
|
|
_parent: RuleContext | undefined;
|
|
invokingState: number;
|
|
constructor();
|
|
constructor(parent: RuleContext | undefined, invokingState: number);
|
|
static getChildContext(parent: RuleContext, invokingState: number): RuleContext;
|
|
depth(): number;
|
|
/** A context is empty if there is no invoking state; meaning nobody called
|
|
* current context.
|
|
*/
|
|
get isEmpty(): boolean;
|
|
get sourceInterval(): Interval;
|
|
get ruleContext(): RuleContext;
|
|
get parent(): RuleContext | undefined;
|
|
/** @since 4.7. {@see ParseTree#setParent} comment */
|
|
setParent(parent: RuleContext): void;
|
|
get payload(): RuleContext;
|
|
/** Return the combined text of all child nodes. This method only considers
|
|
* tokens which have been added to the parse tree.
|
|
*
|
|
* Since tokens on hidden channels (e.g. whitespace or comments) are not
|
|
* added to the parse trees, they will not appear in the output of this
|
|
* method.
|
|
*/
|
|
get text(): string;
|
|
get ruleIndex(): number;
|
|
/** 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.
|
|
*
|
|
* @since 4.5.3
|
|
*/
|
|
get altNumber(): number;
|
|
/** Set the outer alternative number for this context node. Default
|
|
* implementation does nothing to avoid backing field overhead for
|
|
* trees that don't need it. Create
|
|
* a subclass of ParserRuleContext with backing field and set
|
|
* option contextSuperClass.
|
|
*
|
|
* @since 4.5.3
|
|
*/
|
|
set altNumber(altNumber: number);
|
|
getChild(i: number): ParseTree;
|
|
get childCount(): number;
|
|
accept<T>(visitor: ParseTreeVisitor<T>): T;
|
|
/** Print out a whole tree, not just a node, in LISP format
|
|
* (root child1 .. childN). Print just a node if this is a leaf.
|
|
* We have to know the recognizer so we can get rule names.
|
|
*/
|
|
toStringTree(recog: 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.
|
|
*/
|
|
toStringTree(ruleNames: string[] | undefined): string;
|
|
toStringTree(): string;
|
|
toString(): string;
|
|
toString(recog: Recognizer<any, any> | undefined): string;
|
|
toString(ruleNames: string[] | undefined): string;
|
|
toString(recog: Recognizer<any, any> | undefined, stop: RuleContext | undefined): string;
|
|
toString(ruleNames: string[] | undefined, stop: RuleContext | undefined): string;
|
|
}
|