pegisland
Version:
General PEG-based parser supporting island grammars with lake symbols
204 lines • 6.53 kB
JavaScript
;
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var _a, _ParseTree_seq, _ParseTree_getId;
Object.defineProperty(exports, "__esModule", { value: true });
exports.traverseNonterminals = exports.NodeRewriting = exports.NodeLake = exports.NodeGrouping = exports.NodeOrderedChoice = exports.NodeSequence = exports.NodeNot = exports.NodeAnd = exports.NodeOptional = exports.NodeOneOrMore = exports.NodeZeroOrMore = exports.NodeNonterminal = exports.NodeTerminal = exports.DefaultParseTreeVisitor = exports.Range = void 0;
class Range {
constructor(start, end) {
this.start = start;
this.end = end;
}
}
exports.Range = Range;
class ParseTree {
constructor(childNodes, range) {
this.childNodes = childNodes;
this.range = range;
this.id = __classPrivateFieldGet(ParseTree, _a, "m", _ParseTree_getId).call(ParseTree);
this.parentNode = this;
childNodes.forEach((n) => (n.parentNode = this));
}
}
_a = ParseTree, _ParseTree_getId = function _ParseTree_getId() {
var _b, _c, _d;
return __classPrivateFieldSet(_b = ParseTree, _a, (_d = __classPrivateFieldGet(_b, _a, "f", _ParseTree_seq), _c = _d++, _d), "f", _ParseTree_seq), _c;
};
_ParseTree_seq = { value: 0 };
class DefaultParseTreeVisitor {
visitNonterminal(_node) {
// Do nothing.
}
visitTerminal(_node) {
// Do nothing.
}
visitLake(_node) {
// Do nothing.
}
visitZeroOrMore(_node) {
// Do nothing.
}
visitOneOrMore(_node) {
// Do nothing.
}
visitOptional(_node) {
// Do nothing.
}
visitOrderedChoice(_node) {
// Do nothing.
}
visitSequence(_node) {
// Do nothing.
}
visitAnd(_node) {
// Do nothing.
}
visitNot(_node) {
// Do nothing.
}
visitGrouping(_node) {
// Do nothing.
}
visitRewriting(_node) {
// Do nothing.
}
}
exports.DefaultParseTreeVisitor = DefaultParseTreeVisitor;
class NodeTerminal extends ParseTree {
constructor(range, pattern, text) {
super([], range);
this.pattern = pattern;
this.text = text;
}
accept(visitor, ...arg) {
return visitor.visitTerminal(this, ...arg);
}
}
exports.NodeTerminal = NodeTerminal;
class NodeNonterminal extends ParseTree {
constructor(symbol, range, childNode) {
super([childNode], range);
this.symbol = symbol;
}
accept(visitor, ...arg) {
return visitor.visitNonterminal(this, ...arg);
}
}
exports.NodeNonterminal = NodeNonterminal;
class NodeZeroOrMore extends ParseTree {
constructor(range, childNodes) {
super(childNodes, range);
}
accept(visitor, ...arg) {
return visitor.visitZeroOrMore(this, ...arg);
}
}
exports.NodeZeroOrMore = NodeZeroOrMore;
class NodeOneOrMore extends ParseTree {
constructor(range, childNodes) {
super(childNodes, range);
}
accept(visitor, ...arg) {
return visitor.visitOneOrMore(this, ...arg);
}
}
exports.NodeOneOrMore = NodeOneOrMore;
class NodeOptional extends ParseTree {
constructor(range, childNodes) {
super(childNodes, range);
}
accept(visitor, ...arg) {
return visitor.visitOptional(this, ...arg);
}
}
exports.NodeOptional = NodeOptional;
class NodeAnd extends ParseTree {
constructor(range, childNode) {
super([childNode], range);
}
accept(visitor, ...arg) {
return visitor.visitAnd(this, ...arg);
}
}
exports.NodeAnd = NodeAnd;
class NodeNot extends ParseTree {
constructor(range) {
super([], range);
}
accept(visitor, ...arg) {
return visitor.visitNot(this, ...arg);
}
}
exports.NodeNot = NodeNot;
class NodeSequence extends ParseTree {
constructor(range, childNodes) {
super(childNodes, range);
}
accept(visitor, ...arg) {
return visitor.visitSequence(this, ...arg);
}
}
exports.NodeSequence = NodeSequence;
class NodeOrderedChoice extends ParseTree {
constructor(range, childNode, index) {
super([childNode], range);
this.index = index;
}
accept(visitor, ...arg) {
return visitor.visitOrderedChoice(this, ...arg);
}
}
exports.NodeOrderedChoice = NodeOrderedChoice;
class NodeGrouping extends ParseTree {
constructor(range, childNode) {
super([childNode], range);
}
accept(visitor, ...arg) {
return visitor.visitGrouping(this, ...arg);
}
}
exports.NodeGrouping = NodeGrouping;
class NodeLake extends ParseTree {
constructor(range, childNodes, pe) {
super(childNodes, range);
this.pe = pe;
}
accept(visitor, ...arg) {
return visitor.visitLake(this, ...arg);
}
}
exports.NodeLake = NodeLake;
class NodeRewriting extends ParseTree {
constructor(range, childNode, spec) {
super([childNode], range);
this.spec = spec;
}
accept(visitor, ...arg) {
return visitor.visitRewriting(this, ...arg);
}
}
exports.NodeRewriting = NodeRewriting;
function traverseNonterminals(parseTree, func) {
traverseTree(parseTree, (node) => {
if (node instanceof NodeNonterminal) {
func(node);
}
});
}
exports.traverseNonterminals = traverseNonterminals;
function traverseTree(parseTree, func) {
parseTree.childNodes.forEach((node) => {
func(node);
traverseTree(node, func);
});
}
//# sourceMappingURL=ParseTree.js.map