antlr4ts
Version:
ANTLR 4 runtime for JavaScript written in Typescript
216 lines • 8.21 kB
JavaScript
;
/*!
* 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.
*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RuleContext = void 0;
// ConvertTo-TS run at 2016-10-04T11:26:57.3490837-07:00
const ATN_1 = require("./atn/ATN");
const Recognizer_1 = require("./Recognizer");
const RuleNode_1 = require("./tree/RuleNode");
const Interval_1 = require("./misc/Interval");
const Decorators_1 = require("./Decorators");
const Trees_1 = require("./tree/Trees");
const ParserRuleContext_1 = require("./ParserRuleContext");
/** 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
*/
class RuleContext extends RuleNode_1.RuleNode {
constructor(parent, invokingState) {
super();
this._parent = parent;
this.invokingState = invokingState != null ? invokingState : -1;
}
static getChildContext(parent, invokingState) {
return new RuleContext(parent, invokingState);
}
depth() {
let n = 0;
let p = this;
while (p) {
p = p._parent;
n++;
}
return n;
}
/** A context is empty if there is no invoking state; meaning nobody called
* current context.
*/
get isEmpty() {
return this.invokingState === -1;
}
// satisfy the ParseTree / SyntaxTree interface
get sourceInterval() {
return Interval_1.Interval.INVALID;
}
get ruleContext() { return this; }
get parent() { return this._parent; }
/** @since 4.7. {@see ParseTree#setParent} comment */
setParent(parent) {
this._parent = parent;
}
get payload() { return this; }
/** 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() {
if (this.childCount === 0) {
return "";
}
let builder = "";
for (let i = 0; i < this.childCount; i++) {
builder += this.getChild(i).text;
}
return builder.toString();
}
get ruleIndex() { return -1; }
/** 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() { return ATN_1.ATN.INVALID_ALT_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) {
// intentionally ignored by the base implementation
}
getChild(i) {
throw new RangeError("i must be greater than or equal to 0 and less than childCount");
}
get childCount() {
return 0;
}
accept(visitor) {
return visitor.visitChildren(this);
}
toStringTree(recog) {
return Trees_1.Trees.toStringTree(this, recog);
}
toString(arg1, stop) {
const ruleNames = (arg1 instanceof Recognizer_1.Recognizer) ? arg1.ruleNames : arg1;
stop = stop || ParserRuleContext_1.ParserRuleContext.emptyContext();
let buf = "";
let p = this;
buf += ("[");
while (p && p !== stop) {
if (!ruleNames) {
if (!p.isEmpty) {
buf += (p.invokingState);
}
}
else {
let ruleIndex = p.ruleIndex;
let ruleName = (ruleIndex >= 0 && ruleIndex < ruleNames.length)
? ruleNames[ruleIndex] : ruleIndex.toString();
buf += (ruleName);
}
if (p._parent && (ruleNames || !p._parent.isEmpty)) {
buf += (" ");
}
p = p._parent;
}
buf += ("]");
return buf.toString();
}
}
__decorate([
Decorators_1.Override
], RuleContext.prototype, "sourceInterval", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "ruleContext", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "parent", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "setParent", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "payload", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "text", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "getChild", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "childCount", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "accept", null);
__decorate([
Decorators_1.Override
], RuleContext.prototype, "toStringTree", null);
exports.RuleContext = RuleContext;
//# sourceMappingURL=RuleContext.js.map