@light0x00/parser-generator
Version:
A Parser Generator
540 lines (406 loc) • 41 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ProdsInjector = exports.ParsingTable = exports.Accept = exports.Reduce = exports.Goto = exports.Shift = exports.Operation = exports.AugmentedGrammar = exports.StateSet = exports.State = exports.ItemSet = exports.Item = void 0;
var _Definition = require("../Definition");
var _shim = require("@light0x00/shim");
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
/* 项是所属项集中的一个成员,一个「项」由「产生式」和一个「点」组成,例如 A->a·B */
class Item {
/*
由于lookaheadSet可能重复,所以使用Set来存储
为什么lookaheadSet可能重复?
S->A
A->BC
B->b | 𝝴
C->b | 𝝴
S->·A , {$}
A->·BC , {b,b,$} //重复
*/
constructor(production, dot = 0, lookaheadSet = new Set()) {
_defineProperty(this, "prod", void 0);
_defineProperty(this, "_dot", 0);
_defineProperty(this, "lookaheadSet", void 0);
_defineProperty(this, "hashCodeCache", void 0);
this.prod = production;
/* 对于空推导(形如A->𝝴). 直接将 dot 置于末尾(A->𝝴·) */
this._dot = production.isEpsilon() ? production.length : dot;
this.lookaheadSet = lookaheadSet;
}
get dotPos() {
return this._dot;
}
hasNext() {
return this._dot < this.prod.length;
}
nextSymbol() {
if (!this.hasNext()) throw new Error(`${this} has no next item!`);
return this.prod[this._dot];
}
nextItem() {
if (!this.hasNext()) throw new Error(`${this} has no next item!`);
/*
😇New features to support LR
为什么当前项展望集应该被后继项继承?
考虑如下文法:
S->As
A->a
I0
S->·As ,$
A->·a ,s
I1
A->a· ,s
如上所示,I0输入a得到I1
其中「A->a· ,s」继承了「 A->·a ,s」的展望符
*/
return new Item(this.prod, this._dot + 1, this.lookaheadSet);
}
toString() {
let str = "";
let symbols = this.prod;
for (let i = 0; i < symbols.length; i++) {
if (this._dot == i) str += "·";
str += symbols[i];
}
if (this._dot == symbols.length) str += "·";
str += ",";
str += "{" + Array.from(this.lookaheadSet).join(",") + "}";
return `${this.prod.name}->${str}`;
}
equals(other) {
/*
两个项是否相等,
1. 所含产生式一样
2. 「dot」所在位置一样
😇New features to support LR
3. 展望集(lookaheadSet)一样
*/
if (other.prod.id != this.prod.id) return false;
if (other._dot != this._dot) return false;
if (other.lookaheadSet.size != this.lookaheadSet.size) return false; //n2复杂度 暂时不管
for (let t of this.lookaheadSet) {
// let find = false
// for (let o of other.lookaheadSet) {
// if (o == t) {
// find = true
// break
// }
// }
// if (!find)
// return false
if (!other.lookaheadSet.has(t)) {
return false;
}
}
return true;
}
/* 😇New features to support LALR */
isSameCoreWith(other) {
if (other.prod.id != this.prod.id) return false;
if (other._dot != this._dot) return false;
return true;
}
hashCode() {
if (this.hashCodeCache == null) {
// this.hashCodeCache = this.prod.id + '' + this._dot + hash.keys(this.lookaheadSet)
this.hashCodeCache = this.prod.id + "-" + this._dot;
}
return this.hashCodeCache;
} // reducible() {
// return this.dot == this.prod.length
// }
}
exports.Item = Item;
class ItemSet extends Array {
//用于记录已经添加的项的Hash 防止逻辑上的重复
constructor(...items) {
super(...items);
_defineProperty(this, "added", new Map());
_defineProperty(this, "items", new Array());
for (let item of items) this.added.set(item.hashCode(), item);
}
contains(item) {
return this.added.has(item.hashCode());
}
pushOrMerge(item) {
let existing = this.added.get(item.hashCode());
if (existing === undefined) {
this.push(item);
} else {
//已经存在 则合并LR展望符集
(0, _shim.addAll_Set)(existing.lookaheadSet, item.lookaheadSet);
}
} //最好的办法是 将数组作为内部对象 而不是继承
push(item) {
this.added.set(item.hashCode(), item);
return super.push(item);
}
toString() {
let str = "";
for (let item of this) {
str += item.toString() + "\n";
}
return str.replace(/\n$/, "");
}
equals(other) {
/* 两个项集A、B是否相等,取决于
1. 它们所包含的项个数相等
2. A、B中的每一个项在对方集合中都存在相等的项
*/
if (other.length != this.length) return false; //又写出一个n2复杂度23333 !!更好的办法是用Set来存放
for (let o1 of this) {
let hasMatched = false;
for (let o2 of other) {
if (o1.equals(o2)) {
hasMatched = true;
break;
}
}
if (!hasMatched) return false;
}
return true;
}
/*
返回当前状态的后继符号集
例: 对于下状态(项集),其后继符号为: {E,T,F,(,id}
I0
S->·E
E->·E+T
E->·T
T->·T*F
T->·F
F->·(E)
F->·id
*/
getNextSymbols() {
let nextSymbols = new Set();
for (let item of this) {
if (item.hasNext()) {
nextSymbols.add(item.nextSymbol());
}
}
return nextSymbols;
}
}
/* 状态基本等同于项集 唯一的区别是状态需要id 而项集不需要 */
exports.ItemSet = ItemSet;
class State extends ItemSet {
/* 描述当前状态在接受某个符号后去往的后继状态 */
constructor(id, items) {
super(...items);
_defineProperty(this, "id", void 0);
_defineProperty(this, "mapping", new Map());
this.id = id;
}
toString() {
return `<${this.id}>\n${super.toString()}`;
}
/**
* 添加后继状态
* 添加当前状态输入「指定符号」后去往的「后继状态」
*
* 原则上一个状态对于同一符号只能有一个后继状态,如果重复将抛出异常
* @param symbol 输入符号
* @param nextState 后继状态
*/
addNextState(symbol, nextState) {
(0, _shim.assert)(this.mapping.get(symbol) == null, `A state can only have one next state to the same symbol`);
this.mapping.set(symbol, nextState);
}
getNextState(symbol) {
return this.mapping.get(symbol);
}
}
exports.State = State;
class StateSet extends Array {
constructor(...args) {
super(...args);
_defineProperty(this, "mapping", new Map());
}
/* 判断状态集中是否已经存在 相同性质(参见ItemSet的equals方法) 的状态(项集) */
getExisting(state) {
for (let existing of this) {
if (existing.equals(state)) {
return existing;
}
}
return null;
}
satrtState() {
(0, _shim.assert)(this[0] != null);
return this[0];
}
}
/*
LR\SLR 在构造状态时有所不同 因此将不同部分独立处理
*/
exports.StateSet = StateSet;
/**
*
* 将二维数组形式的产生式集(Symbol[][]) 转为带有编号的Production集合,并赋予指定的非终结符
*
* 一个非终结符的产生式集可视为一个Symbol二维数组,
* 为了便于实现LR分析表,需要将这个二维数组转为Production集合,
* 且为每个Production赋予一个编号.
*/
class AugmentedGrammar extends _Definition.ActionGrammar {
constructor(rawGrammar, traits) {
super(rawGrammar, traits);
}
afterConstruct() {
(0, _shim.assert)(this.startNT().length == 1 && this.startNT()[0].length == 1, "The start symbol of an augmented grammar has one and only one production, and the production contains only one symbol!");
}
/* 开始符号的产生式 原则上只能有一个 */
get prodOfStartNT() {
return this.startNT()[0];
}
}
/* 表示LR语法分析表格的操作 */
exports.AugmentedGrammar = AugmentedGrammar;
class Operation {
isReduce() {
return false;
}
isShift() {
return false;
}
isGoto() {
return false;
}
isAccept() {
return false;
}
}
exports.Operation = Operation;
class Shift extends Operation {
constructor(nextState, prec = -1, assoc = false) {
super();
_defineProperty(this, "nextState", void 0);
_defineProperty(this, "prec", void 0);
_defineProperty(this, "assoc", void 0);
this.nextState = nextState;
this.prec = prec;
this.assoc = assoc;
}
setIfLarger(prec, assoc) {
if (prec > this.prec) {
this.prec = prec;
this.assoc = assoc;
}
}
toString() {
return `shift ${this.nextState.id}`;
}
equals(obj) {
return obj instanceof Shift && obj.nextState == this.nextState;
}
isShift() {
return true;
}
}
exports.Shift = Shift;
class Goto extends Operation {
constructor(nextState) {
super();
_defineProperty(this, "nextState", void 0);
this.nextState = nextState;
}
toString() {
return `goto ${this.nextState.id}`;
}
equals(obj) {
return obj instanceof Goto && obj.nextState == this.nextState;
}
isGoto() {
return true;
}
}
exports.Goto = Goto;
class Reduce extends Operation {
/* 用于归约的产生式 */
constructor(prod, prec = -1, leftAssoc = false) {
super();
_defineProperty(this, "prod", void 0);
_defineProperty(this, "prec", void 0);
_defineProperty(this, "leftAssoc", void 0);
this.prod = prod;
this.prec = prec;
this.leftAssoc = leftAssoc;
}
toString() {
return `reduce ${this.prod.id}`;
}
equals(obj) {
return obj instanceof Reduce && obj.prod == this.prod;
}
isReduce() {
return true;
}
}
exports.Reduce = Reduce;
class Accept extends Operation {
constructor() {
super();
}
equals(obj) {
return obj instanceof Accept;
}
toString() {
return `accept`;
}
isAccept() {
return true;
}
}
exports.Accept = Accept;
class ParsingTable {
constructor() {
_defineProperty(this, "parsingTable", new Map());
}
get table() {
return this.parsingTable;
}
put(state, symbol, op) {
let row = this.parsingTable.get(state);
if (row == undefined) {
row = new Map();
this.parsingTable.set(state, row);
}
row.set(symbol, op);
}
has(state, symbol, op) {
let row = this.parsingTable.get(state);
if (row == undefined) return false;
let exstingOp = row.get(symbol);
if (exstingOp == null) return false;
return exstingOp.equals(op);
}
get(state, symbol) {
let row = this.parsingTable.get(state); // assert(row != null, `state(${state.id}) is not found in parsing table!`)
if (row == undefined) return undefined;
return row.get(symbol);
}
getExpectedSymbols(state) {
let row = this.parsingTable.get(state);
if (row == undefined) return [];
return Array.from(row.keys());
}
getExpectedTokens(state) {
let expS = this.getExpectedSymbols(state);
return expS.filter(s => !(s instanceof _Definition.NonTerminal));
}
}
exports.ParsingTable = ParsingTable;
class ProdsInjector {
constructor() {
_defineProperty(this, "prodIdCounter", 0);
}
inject(nt, rawProds) {
for (let rawProd of rawProds) {
nt.addProd(this.prodIdCounter++, rawProd);
}
}
}
exports.ProdsInjector = ProdsInjector;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LR/Definition.ts"],"names":["Item","constructor","production","dot","lookaheadSet","Set","prod","_dot","isEpsilon","length","dotPos","hasNext","nextSymbol","Error","nextItem","toString","str","symbols","i","Array","from","join","name","equals","other","id","size","t","has","isSameCoreWith","hashCode","hashCodeCache","ItemSet","items","Map","item","added","set","contains","pushOrMerge","existing","get","undefined","push","replace","o1","hasMatched","o2","getNextSymbols","nextSymbols","add","State","addNextState","symbol","nextState","mapping","getNextState","StateSet","getExisting","state","satrtState","AugmentedGrammar","ActionGrammar","rawGrammar","traits","afterConstruct","startNT","prodOfStartNT","Operation","isReduce","isShift","isGoto","isAccept","Shift","prec","assoc","setIfLarger","obj","Goto","Reduce","leftAssoc","Accept","ParsingTable","table","parsingTable","put","op","row","exstingOp","getExpectedSymbols","keys","getExpectedTokens","expS","filter","s","NonTerminal","ProdsInjector","inject","nt","rawProds","rawProd","addProd","prodIdCounter"],"mappings":"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","sourcesContent":["\nimport { Production, Terminal, Symbol, NonTerminal, ActionGrammar, RawActionGrammar, TraitsTable } from \"../Definition\";\nimport { addAll_Set, assert } from \"@light0x00/shim\";\nimport { ILexer, ASTree } from \"@light0x00/parser-definition\";\n\n/* 项是所属项集中的一个成员,一个「项」由「产生式」和一个「点」组成,例如 A->a·B */\nexport class Item {\n\n\tprod: Production;\n\tprivate _dot: number = 0;\n\t/*\n    由于lookaheadSet可能重复,所以使用Set来存储\n    为什么lookaheadSet可能重复?\n\n    S->A\n    A->BC\n    B->b | 𝝴\n    C->b | 𝝴\n\n    S->·A , {$}\n    A->·BC , {b,b,$}  //重复\n    */\n\tlookaheadSet: Set<Terminal>\n\tconstructor(production: Production, dot: number = 0, lookaheadSet: Set<Terminal> = new Set<Terminal>()) {\n\t\tthis.prod = production;\n\t\t/* 对于空推导(形如A->𝝴). 直接将 dot 置于末尾(A->𝝴·) */\n\t\tthis._dot = production.isEpsilon() ? production.length : dot;\n\t\tthis.lookaheadSet = lookaheadSet;\n\t}\n\n\tget dotPos() {\n\t\treturn this._dot;\n\t}\n\n\thasNext(): boolean {\n\t\treturn this._dot < this.prod.length;\n\t}\n\n\tnextSymbol(): Symbol {\n\t\tif (!this.hasNext())\n\t\t\tthrow new Error(`${this} has no next item!`);\n\t\treturn this.prod[this._dot];\n\t}\n\tnextItem() {\n\t\tif (!this.hasNext())\n\t\t\tthrow new Error(`${this} has no next item!`);\n\t\t/*\n\t\t\t😇New features to support LR\n\n\t\t\t为什么当前项展望集应该被后继项继承?\n\n\t\t\t考虑如下文法:\n\t\t\tS->As\n\t\t\tA->a\n\n\t\t\tI0\n\t\t\tS->·As ,$\n\t\t\tA->·a ,s\n\n\t\t\tI1\n\t\t\tA->a· ,s\n\n\t\t\t如上所示,I0输入a得到I1\n\t\t\t其中「A->a· ,s」继承了「 A->·a ,s」的展望符\n\t\t\t*/\n\t\treturn new Item(this.prod, this._dot + 1, this.lookaheadSet);\n\t}\n\ttoString() {\n\t\tlet str = \"\";\n\t\tlet symbols = this.prod;\n\t\tfor (let i = 0; i < symbols.length; i++) {\n\t\t\tif (this._dot == i)\n\t\t\t\tstr += \"·\";\n\t\t\tstr += symbols[i];\n\t\t}\n\t\tif (this._dot == symbols.length)\n\t\t\tstr += \"·\";\n\t\tstr += \",\";\n\t\tstr += \"{\" + Array.from(this.lookaheadSet).join(\",\") + \"}\";\n\t\treturn `${this.prod.name}->${str}`;\n\t}\n\tequals(other: Item) {\n\t\t/*\n\t\t\t两个项是否相等,\n\t\t\t1. 所含产生式一样\n\t\t\t2. 「dot」所在位置一样\n\n\t\t\t😇New features to support LR\n\t\t\t3. 展望集(lookaheadSet)一样\n\t\t\t*/\n\t\tif (other.prod.id != this.prod.id)\n\t\t\treturn false;\n\t\tif (other._dot != this._dot)\n\t\t\treturn false;\n\n\t\tif (other.lookaheadSet.size != this.lookaheadSet.size)\n\t\t\treturn false;\n\t\t//n2复杂度 暂时不管\n\t\tfor (let t of this.lookaheadSet) {\n\t\t\t// let find = false\n\t\t\t// for (let o of other.lookaheadSet) {\n\t\t\t//     if (o == t) {\n\t\t\t//         find = true\n\t\t\t//         break\n\t\t\t//     }\n\t\t\t// }\n\t\t\t// if (!find)\n\t\t\t//     return false\n\t\t\tif (!other.lookaheadSet.has(t)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\t/*  😇New features to support LALR */\n\tisSameCoreWith(other: Item) {\n\t\tif (other.prod.id != this.prod.id)\n\t\t\treturn false;\n\t\tif (other._dot != this._dot)\n\t\t\treturn false;\n\t\treturn true;\n\t}\n\n\tprivate hashCodeCache: string\n\thashCode(): string {\n\t\tif (this.hashCodeCache == null) {\n\t\t\t// this.hashCodeCache = this.prod.id + '' + this._dot + hash.keys(this.lookaheadSet)\n\t\t\tthis.hashCodeCache = this.prod.id + \"-\" + this._dot;\n\t\t}\n\t\treturn this.hashCodeCache;\n\t}\n\n\t// reducible() {\n\t//     return this.dot == this.prod.length\n\t// }\n}\n\nexport class ItemSet extends Array<Item> {\n\t//用于记录已经添加的项的Hash 防止逻辑上的重复\n\tadded = new Map<string, Item>()\n\titems = new Array<Item>()\n\tconstructor(...items: Item[]) {\n\t\tsuper(...items);\n\t\tfor (let item of items)\n\t\t\tthis.added.set(item.hashCode(), item);\n\t}\n\n\tcontains(item: Item) {\n\t\treturn this.added.has(item.hashCode());\n\t}\n\n\tpushOrMerge(item: Item) {\n\t\tlet existing = this.added.get(item.hashCode());\n\t\tif (existing === undefined) {\n\t\t\tthis.push(item);\n\t\t} else {\n\t\t\t//已经存在 则合并LR展望符集\n\t\t\taddAll_Set(existing.lookaheadSet, item.lookaheadSet);\n\t\t}\n\t}\n\t//最好的办法是 将数组作为内部对象 而不是继承\n\tpush(item: Item) {\n\t\tthis.added.set(item.hashCode(), item);\n\t\treturn super.push(item);\n\t}\n\n\ttoString() {\n\t\tlet str = \"\";\n\t\tfor (let item of this) {\n\t\t\tstr += item.toString() + \"\\n\";\n\t\t}\n\t\treturn str.replace(/\\n$/, \"\");\n\t}\n\tequals(other: ItemSet) {\n\t\t/* 两个项集A、B是否相等,取决于\n\t\t\t  1. 它们所包含的项个数相等\n\t\t\t  2. A、B中的每一个项在对方集合中都存在相等的项\n\t\t   */\n\t\tif (other.length != this.length)\n\t\t\treturn false;\n\t\t//又写出一个n2复杂度23333  !!更好的办法是用Set来存放\n\t\tfor (let o1 of this) {\n\t\t\tlet hasMatched = false;\n\t\t\tfor (let o2 of other) {\n\t\t\t\tif (o1.equals(o2)) {\n\t\t\t\t\thasMatched = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!hasMatched)\n\t\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t/*\n    返回当前状态的后继符号集\n    例: 对于下状态(项集),其后继符号为: {E,T,F,(,id}\n    I0\n        S->·E\n        E->·E+T\n        E->·T\n        T->·T*F\n        T->·F\n        F->·(E)\n        F->·id\n     */\n\tgetNextSymbols() {\n\t\tlet nextSymbols = new Set<Symbol>();\n\t\tfor (let item of this) {\n\t\t\tif (item.hasNext()) {\n\t\t\t\tnextSymbols.add(item.nextSymbol());\n\t\t\t}\n\t\t}\n\t\treturn nextSymbols;\n\t}\n\n}\n/* 状态基本等同于项集 唯一的区别是状态需要id 而项集不需要 */\nexport class State extends ItemSet {\n\tid: number\n\t/* 描述当前状态在接受某个符号后去往的后继状态 */\n\tmapping = new Map<Symbol, State>()\n\tconstructor(id: number, items: Item[]) {\n\t\tsuper(...items);\n\t\tthis.id = id;\n\t}\n\n\ttoString() {\n\t\treturn `<${this.id}>\\n${super.toString()}`;\n\t}\n\n\t/**\n     * 添加后继状态\n     * 添加当前状态输入「指定符号」后去往的「后继状态」\n     *\n     * 原则上一个状态对于同一符号只能有一个后继状态,如果重复将抛出异常\n     * @param symbol 输入符号\n     * @param nextState 后继状态\n     */\n\taddNextState(symbol: Symbol, nextState: State) {\n\t\tassert(this.mapping.get(symbol) == null, `A state can only have one next state to the same symbol`);\n\t\tthis.mapping.set(symbol, nextState);\n\t}\n\n\tgetNextState(symbol: Symbol) {\n\t\treturn this.mapping.get(symbol);\n\t}\n\n}\n\nexport class StateSet extends Array<State>{\n\tmapping = new Map<State, Map<Symbol, State>>()\n\t/* 判断状态集中是否已经存在 相同性质(参见ItemSet的equals方法) 的状态(项集) */\n\tgetExisting(state: ItemSet): null | State {\n\t\tfor (let existing of this) {\n\t\t\tif (existing.equals(state)) {\n\t\t\t\treturn existing;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\tsatrtState(): State {\n\t\tassert(this[0] != null);\n\t\treturn this[0];\n\t}\n}\n/*\nLR\\SLR 在构造状态时有所不同 因此将不同部分独立处理\n*/\nexport interface AutomataTools {\n\tGOTO(I: ItemSet, inputSymbol: Symbol): ItemSet\n\tclosure(itemSet: ItemSet): ItemSet\n\tgetStartState(grammar: ActionGrammar): State\n}\n\n/**\n *\n * 将二维数组形式的产生式集(Symbol[][]) 转为带有编号的Production集合,并赋予指定的非终结符\n *\n * 一个非终结符的产生式集可视为一个Symbol二维数组,\n * 为了便于实现LR分析表,需要将这个二维数组转为Production集合,\n * 且为每个Production赋予一个编号.\n */\nexport class AugmentedGrammar extends ActionGrammar {\n\n\tconstructor(rawGrammar: RawActionGrammar, traits: TraitsTable) {\n\t\tsuper(rawGrammar, traits);\n\t}\n\n\tafterConstruct() {\n\t\tassert(this.startNT().length == 1 && this.startNT()[0].length == 1,\n\t\t\t\"The start symbol of an augmented grammar has one and only one production, and the production contains only one symbol!\");\n\t}\n\t/* 开始符号的产生式 原则上只能有一个 */\n\tget prodOfStartNT(): Production {\n\t\treturn this.startNT()[0];\n\t}\n}\n\n/* 表示LR语法分析表格的操作 */\nexport abstract class Operation {\n\tabstract equals(obj: Object): boolean\n\n\tisReduce(): this is Reduce {\n\t\treturn false;\n\t}\n\tisShift(): this is Shift {\n\t\treturn false;\n\t}\n\n\tisGoto(): this is Goto {\n\t\treturn false;\n\t}\n\n\tisAccept(): this is Accept {\n\t\treturn false;\n\t}\n}\n\nexport class Shift extends Operation {\n\tnextState: State\n\tprec: number;\n\tassoc: boolean;\n\tconstructor(nextState: State, prec: number = -1, assoc: boolean = false) {\n\t\tsuper();\n\t\tthis.nextState = nextState;\n\t\tthis.prec = prec;\n\t\tthis.assoc = assoc;\n\t}\n\n\tsetIfLarger(prec: number, assoc: boolean) {\n\t\tif (prec > this.prec) {\n\t\t\tthis.prec = prec;\n\t\t\tthis.assoc = assoc;\n\t\t}\n\t}\n\n\ttoString() {\n\t\treturn `shift ${this.nextState.id}`;\n\t}\n\tequals(obj: Object) {\n\t\treturn obj instanceof Shift && obj.nextState == this.nextState;\n\t}\n\tisShift() {\n\t\treturn true;\n\t}\n}\n\nexport class Goto extends Operation {\n\tnextState: State\n\n\tconstructor(nextState: State) {\n\t\tsuper();\n\t\tthis.nextState = nextState;\n\t}\n\ttoString() {\n\t\treturn `goto ${this.nextState.id}`;\n\t}\n\tequals(obj: Object) {\n\t\treturn obj instanceof Goto && obj.nextState == this.nextState;\n\t}\n\n\tisGoto() {\n\t\treturn true;\n\t}\n}\n\nexport class Reduce extends Operation {\n\t/* 用于归约的产生式 */\n\tprod: Production;\n\tprec: number;\n\tleftAssoc: boolean;\n\tconstructor(prod: Production, prec: number = -1, leftAssoc: boolean = false) {\n\t\tsuper();\n\t\tthis.prod = prod;\n\t\tthis.prec = prec;\n\t\tthis.leftAssoc = leftAssoc;\n\t}\n\n\ttoString() {\n\t\treturn `reduce ${this.prod.id}`;\n\t}\n\n\tequals(obj: Object) {\n\t\treturn obj instanceof Reduce && obj.prod == this.prod;\n\t}\n\n\tisReduce() {\n\t\treturn true;\n\t}\n}\n\nexport class Accept extends Operation {\n\tconstructor() {\n\t\tsuper();\n\t}\n\tequals(obj: Object) {\n\t\treturn obj instanceof Accept;\n\t}\n\ttoString() {\n\t\treturn `accept`;\n\t}\n\tisAccept() {\n\t\treturn true;\n\t}\n}\n\nexport class ParsingTable {\n\tprivate parsingTable = new Map<State, Map<Symbol, Operation>>()\n\n\tget table() {\n\t\treturn this.parsingTable;\n\t}\n\n\tput(state: State, symbol: Symbol, op: Operation): void {\n\t\tlet row = this.parsingTable.get(state);\n\t\tif (row == undefined) {\n\t\t\trow = new Map<Symbol, Operation>();\n\t\t\tthis.parsingTable.set(state, row);\n\t\t}\n\t\trow.set(symbol, op);\n\t}\n\thas(state: State, symbol: Symbol, op: Operation): boolean {\n\t\tlet row = this.parsingTable.get(state);\n\t\tif (row == undefined)\n\t\t\treturn false;\n\t\tlet exstingOp = row.get(symbol);\n\t\tif (exstingOp == null)\n\t\t\treturn false;\n\t\treturn exstingOp.equals(op);\n\t}\n\tget(state: State, symbol: Symbol): Operation | undefined {\n\t\tlet row = this.parsingTable.get(state);\n\t\t// assert(row != null, `state(${state.id}) is not found in parsing table!`)\n\t\tif (row == undefined)\n\t\t\treturn undefined;\n\t\treturn row.get(symbol);\n\t}\n\n\tgetExpectedSymbols(state: State): Symbol[] {\n\t\tlet row = this.parsingTable.get(state);\n\t\tif (row == undefined)\n\t\t\treturn [];\n\t\treturn Array.from(row.keys());\n\t}\n\n\tgetExpectedTokens(state: State) {\n\t\tlet expS = this.getExpectedSymbols(state);\n\t\treturn expS.filter(s => !(s instanceof NonTerminal));\n\t}\n\n}\n\nexport interface IParser {\n\tparse(lexer: ILexer): ASTree\n}\n\nexport class ProdsInjector {\n\tprodIdCounter = 0\n\tinject(nt: NonTerminal, rawProds: Symbol[][]) {\n\t\tfor (let rawProd of rawProds) {\n\t\t\tnt.addProd(this.prodIdCounter++, rawProd);\n\t\t}\n\t}\n}\n\n"]}