@light0x00/parser-generator
Version:
A Parser Generator
351 lines (273 loc) • 34.3 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getStateSet_LR = getStateSet_LR;
exports.LRAutomataTools = void 0;
var _parserDefinition = require("@light0x00/parser-definition");
var _Definition = require("../../Definition");
var _Definition2 = require("../Definition");
var _shim = require("@light0x00/shim");
var _StateAutomata = require("../StateAutomata");
var _debug = _interopRequireDefault(require("debug"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
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; }
let debug = (0, _debug.default)("APP:LR1:automata");
/*
1.何时应该展开
对于何时应该展开 需要考虑如下几种场景
1.1 「点」已经到了产生式的最末尾,形如A-> X·
1.2 展开符不是终结符 没有闭包,形如 A-> ·a
1.3 由别的项展开自己
S->A
A->B | B𝜶
B->b
I0
S->·A
A->·B
A->·B𝜶
B->·b $
B->·b 𝜶
如上状态集中,B被A的两个项分别引用,
由A->·B 可展开得到 B->·b $
由A->·B𝜶 可展开得到 B->·b 𝜶
此种情况允许同一符号被多次展开✅
1.4 自己展开自己
S->A
A->AAb | a
I0
S->·A
A->·AAb
A->·a
在项 A->·AAb 中,由于为左递归产生式,且「点」位于「左递归符号」前,因此不能再展开A.❌
I1
S->A·
A->A·Ab
在项A->A·Ab中,虽然左递归,但「点」在左递归符号之后,因此可以展开A. I1继续加入如下项:✅
A->·AAb
A->·a
此时,在项A->·AAb中,「点」位于左递归符号之前,因此不能再展开A❌
结论
0. 存在展开符号,且展开符号为非终结符
1. 一个符号被不同的多个个项引用,可以重复展开多次
2. 左递归 且 展开符为最左符号 不得展开 , 形如 A->·AA𝜶
3. 左递归 但 展开符不是最左符号,可以展开,形如 A->A·A𝜶
2.如何展开(LR展望符集计算)
名词约定:
- 展望符集,LR中每个项都有自己的展望符集,一个项的展望符集决定何时可以归约(后称lookaheadSet,有时简称lookSet)
- 展开符号,例如项S->·E是可展开的,展开符号为E
- Look(A->·𝜶) 表示项A->·𝜶的展望符集
对展望符的计算可分为3种情况
例:
S->E
E->E+F | E*F | F
F->id
I0
S->·E $
E->·E+F $
E->·E*F $
E->·F +,*,$
F->·id +,*,$
2.1. 针对闭包项
2.1.1 展开符包含左递归产生式,初始状态I0中项S->·E产生如下3个闭包项:
E->·E+F $,+,*
E->·E*F $,+,*
E->·F $,+,*
它们的lookSet计算方式如下
E->·E+F、E->·E*F、E->·F 均为左递归产生式,它们可能处于末端,也可能被嵌入另一个左递归产生式
例1 对于项E->·E+F而言
- 如果它处于末端,那么 lookSet(E·E+F)就应该有`$` (继承自 lookSet(S->·E))
- 如果它被嵌入E->·E*F,那么 lookSet(E->·E+F)就应该有`*`
- 如果它被嵌入E->·E+F,那么 lookSet(E->·E+F)就应该有`+`
- 要注意,它不可能被嵌入E->·F,所以 lookSet(E->·E+F)不包含`id`
例2 对于E->·F而言,虽然其本身没有左递归,但是由于它的兄弟项中存在左递归项,因此它仍然可能被嵌入其左递归的兄弟项
- 如果E->·F 直接作为S->·E的右侧,那么LookSet(E->·F)应包含`$` (继承自 lookSet(S->·E))
- 如果E->·F被嵌入E->·E+F,那么LookSet(E->·F)应包含`+`
- 如果E->·F被嵌入E->·E*F,那么LookSet(E->·F)应包含`*`
更一般的讲,一个左递归项的LookSet应该包含它的「左递归兄弟项及其本身」的「最左非左递归符号」,以及继承的LookSet
在本例中,E->·E+F的「左递归兄弟项」是 E->·E*F,这个兄弟项的「最左非左递归符号」是`*`, 且E->·E+F继承了`$`.
2.1.2 展开符不包含左递归的产生式,由上一个项确定 的lookSet.
- 如果项形如A->𝜶·B,由展开符B得到的项应为lookSet(A)
- 如果项形如A->·B𝜶𝜷
- 若𝝴∉First(𝜶) 由展开符B得到的项的lookSet为First(𝜶)
- 否则,应当继续加入First(B),重复以上过程,直到末尾时,如果仍包含𝝴,则加入lookSet(A)
此例中,E->·F, 由于展开符是最末符号,因此展开的项F->·id可继承lookSet(A)
2.2 针对前进项
如果只是单纯的项的「点」前进,那么可以直接继承.
例如,项E->·E+F 前进后得到项E->E·+F, 后者的lookSet应该继承前者.
3. 展开后的处理
3.1 如果项集中存在产生式相同,且「点」的位置相同的项, 应将它们合并.
例
A->·𝜶 $
A->·𝜶 𝜶
合并后:
A->·𝜶 $,𝜶
*/
/* 构造自动机所需要的方法 */
class LRAutomataTools {
constructor(firstSetCalculator) {
_defineProperty(this, "getFirstSet", void 0);
this.getFirstSet = firstSetCalculator;
}
GOTO(I, inputSymbol) {
let nextItemSet = new _Definition2.ItemSet();
for (let item of I) {
if (!item.hasNext()) continue;
if (item.nextSymbol() == inputSymbol) {
nextItemSet.push(item.nextItem());
}
}
return this.closure(nextItemSet);
}
closure(itemSet) {
let itemSetClosure = itemSet; //项集的每一个项 item
for (let processedIdx = 0; processedIdx < itemSetClosure.length; processedIdx++) {
let item = itemSetClosure[processedIdx];
if (!item.hasNext()) //issue 1.1
continue;
let expandSym = item.nextSymbol();
if (!(expandSym instanceof _Definition.NonTerminal)) //issue 1.2
continue;
if (item.prod[0] == item.prod.nonTerminal && item.dotPos == 0) {
//issue 1.4
debug(`Stop expanding left recursion production ${expandSym}`);
continue;
}
let lrps = this.getLeftRecursiveProds(expandSym); //issue 2.1.1.1 左递归产生式
let nlrlookSet = this.determineNonLeftRecursionLookSet(item); //issue 2.1.1 展开符包含左递归产生式的情况
if (lrps.length > 0) {
let lrLookSet = this.determineLeftRecursionLookSet(item); //由所有左递归项带来的展望符集
for (let lrp of expandSym) {
let unionLookSet = new Set();
(0, _shim.addAll_Set)(unionLookSet, lrLookSet);
(0, _shim.addAll_Set)(unionLookSet, nlrlookSet);
itemSetClosure.pushOrMerge(new _Definition2.Item(lrp, 0, unionLookSet));
}
} //issue 2.1.2 展开符不包含递归产生式的情况
else {
for (let prod of expandSym.prods) {
let newItem = new _Definition2.Item(prod, 0, nlrlookSet);
itemSetClosure.pushOrMerge(newItem);
}
}
}
return itemSetClosure;
}
/**
========展开符包含左递归产生式的处理========
文法:
S->A
A->A𝜶 | A𝜷 | 𝝲
状态:
S->·A ,$
A->·A𝜶,$
A->·A𝜷,$
A->·𝝲, ?
如何求「 A->𝝲 」的展望集?
若𝜶,𝜷不能推出𝝴,则 lookSet(A->·𝝲) = {𝜶,𝜷}
否则 lookSet(A->·𝝲) ={𝜶,𝜷,$}
形式化:
加入在A中的每一个左递归产生式中的「第一非A的符号的First集」,记为First(!A), 如果该集内存在𝝴,则一路向后直到末尾,如果仍存在𝝴,则加入 Look(A)
伪代码:
for each lr-prod in A
for each sym in lr-prod
if sym != A
add First(sym)
if 𝝴 ∉ First(sym)
break
else if sym is rightmost
add lookSet(S)
注: Look(S) 表示S的lookeheadSet
* @param curItem
*/
determineLeftRecursionLookSet(curItem) {
let target = curItem.nextSymbol();
(0, _shim.assert)(target instanceof _Definition.NonTerminal);
let lookaheadSet = new Set(); //目标的所有左递归产生式
let lrProds = this.getLeftRecursiveProds(target); //每一个左递归产生式
for (let lr_prod of lrProds) {
//每一个符号
let searching = false;
for (let j = 0; j < lr_prod.length; j++) {
if (lr_prod[j] != target && !searching) {
continue;
} // right-most
if (j == lr_prod.length - 1) {
(0, _shim.addAll_Set)(lookaheadSet, curItem.lookaheadSet);
} else {
let follower = lr_prod[j + 1];
let follower_first_set = this.getFirstSet(follower);
(0, _shim.addAll_Set)(lookaheadSet, follower_first_set); // 𝝴 ∉ First(follower)
if (!follower_first_set.has(_parserDefinition.NIL)) {
break;
} // 𝝴 ∈ First(follower) scan next one
else {
lookaheadSet.delete(_parserDefinition.NIL);
searching = true;
}
}
}
}
return lookaheadSet;
}
/**
========展开符不包含左递归产生式的处理========
约定
- 将闭包项记为 closureItem ,例如S->·As
- 将展开项计为 expandItem , 例如由展开符A得到的项 A->·a
形式化计算规则如下:
展开符位于item末端,形如A->·B
lookSet(expandItem)=lookSet(prevItem)
next非末端,形如A->·B𝜶𝜷
lookSet(expandItem)=First(𝜶) ,
如果𝜶可推出𝝴,则继续向后寻找𝜷,重复这个过程,
如果𝜷为最末尾符号,且𝜷仍可推出𝝴,那么将lookSet(prevItem)放入lookSet(next)
* @param prevItem
*/
determineNonLeftRecursionLookSet(prevItem) {
let expandSym = prevItem.nextSymbol();
(0, _shim.assert)(expandSym instanceof _Definition.NonTerminal);
let lookaheadSet = new Set();
for (let i = prevItem.dotPos; i < prevItem.prod.length; i++) {
if (i == prevItem.prod.length - 1) {
(0, _shim.addAll_Set)(lookaheadSet, prevItem.lookaheadSet);
break;
} else {
let firstSetOfFollow = this.getFirstSet(prevItem.prod[i + 1]);
(0, _shim.addAll_Set)(lookaheadSet, firstSetOfFollow);
if (firstSetOfFollow.has(_parserDefinition.NIL)) {
lookaheadSet.delete(_parserDefinition.NIL);
} else {
break;
}
}
}
return lookaheadSet;
}
getLeftRecursiveProds(non_terminal) {
let lr_prods = []; //每一个产生式
for (let prod of non_terminal.prods) {
//产生式中的每一个符号
for (let symbol of prod) {
//若相等,,则表示prod存在左递归
if (symbol == non_terminal) {
lr_prods.push(prod);
break;
} //若不相等 且First(symbol)不存在𝝴则中断,则表示prod没有左递归
else if (!this.getFirstSet(symbol).has(_parserDefinition.NIL)) {
break;
}
}
}
debug(lr_prods.join(","));
return lr_prods;
}
getStartState(grammar) {
return new _Definition2.State(0, this.closure(new _Definition2.ItemSet(new _Definition2.Item(grammar.prodOfStartNT, 0, new Set([_parserDefinition.EOF])))));
}
}
exports.LRAutomataTools = LRAutomataTools;
function getStateSet_LR(grammar, getFirstSet) {
return (0, _StateAutomata.getStateSet)(grammar, new LRAutomataTools(getFirstSet));
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/LR/LR1/Automata.ts"],"names":["debug","LRAutomataTools","constructor","firstSetCalculator","getFirstSet","GOTO","I","inputSymbol","nextItemSet","ItemSet","item","hasNext","nextSymbol","push","nextItem","closure","itemSet","itemSetClosure","processedIdx","length","expandSym","NonTerminal","prod","nonTerminal","dotPos","lrps","getLeftRecursiveProds","nlrlookSet","determineNonLeftRecursionLookSet","lrLookSet","determineLeftRecursionLookSet","lrp","unionLookSet","Set","pushOrMerge","Item","prods","newItem","curItem","target","lookaheadSet","lrProds","lr_prod","searching","j","follower","follower_first_set","has","Nil","delete","prevItem","i","firstSetOfFollow","non_terminal","lr_prods","symbol","join","getStartState","grammar","State","prodOfStartNT","EOF","getStateSet_LR"],"mappings":"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","sourcesContent":["import { NIL as Nil, EOF } from \"@light0x00/parser-definition\";\nimport { Production, NonTerminal, Symbol, Terminal, } from \"../../Definition\";\nimport { ItemSet, State, Item, AugmentedGrammar, AutomataTools } from \"../Definition\";\nimport { addAll_Set, IFunction } from \"@light0x00/shim\";\nimport { getStateSet } from \"../StateAutomata\";\nimport { assert } from \"@light0x00/shim\";\n\nimport rootDebug from \"debug\";\nlet debug = rootDebug(\"APP:LR1:automata\");\n\n/*\n\n1.何时应该展开\n\n    对于何时应该展开 需要考虑如下几种场景\n\n    1.1 「点」已经到了产生式的最末尾,形如A-> X·\n\n    1.2 展开符不是终结符 没有闭包,形如 A-> ·a\n\n    1.3 由别的项展开自己\n    S->A\n    A->B | B𝜶\n    B->b\n\n    I0\n    S->·A\n    A->·B\n    A->·B𝜶\n    B->·b   $\n    B->·b   𝜶\n\n    如上状态集中,B被A的两个项分别引用,\n        由A->·B 可展开得到 B->·b   $\n        由A->·B𝜶  可展开得到 B->·b   𝜶\n    此种情况允许同一符号被多次展开✅\n\n    1.4 自己展开自己\n\n    S->A\n    A->AAb | a\n\n    I0\n    S->·A\n    A->·AAb\n    A->·a\n\n    在项 A->·AAb 中,由于为左递归产生式,且「点」位于「左递归符号」前,因此不能再展开A.❌\n\n    I1\n    S->A·\n    A->A·Ab\n\n    在项A->A·Ab中,虽然左递归,但「点」在左递归符号之后,因此可以展开A. I1继续加入如下项:✅\n\n    A->·AAb\n    A->·a\n\n    此时,在项A->·AAb中,「点」位于左递归符号之前,因此不能再展开A❌\n\n\n    结论\n        0. 存在展开符号,且展开符号为非终结符\n        1. 一个符号被不同的多个个项引用,可以重复展开多次\n        2. 左递归 且 展开符为最左符号 不得展开 , 形如 A->·AA𝜶\n        3. 左递归 但 展开符不是最左符号,可以展开,形如 A->A·A𝜶\n\n\n2.如何展开(LR展望符集计算)\n\n    名词约定:\n    - 展望符集,LR中每个项都有自己的展望符集,一个项的展望符集决定何时可以归约(后称lookaheadSet,有时简称lookSet)\n\t- 展开符号,例如项S->·E是可展开的,展开符号为E\n\t- Look(A->·𝜶) 表示项A->·𝜶的展望符集\n\n    对展望符的计算可分为3种情况\n\n    例:\n    S->E\n    E->E+F | E*F | F\n    F->id\n\n    I0\n    S->·E       $\n    E->·E+F     $\n    E->·E*F     $\n    E->·F       +,*,$\n    F->·id      +,*,$\n\n    2.1. 针对闭包项\n        2.1.1 展开符包含左递归产生式,初始状态I0中项S->·E产生如下3个闭包项:\n            E->·E+F     $,+,*\n            E->·E*F     $,+,*\n            E->·F       $,+,*\n            它们的lookSet计算方式如下\n\t\t\t\tE->·E+F、E->·E*F、E->·F 均为左递归产生式,它们可能处于末端,也可能被嵌入另一个左递归产生式\n\n\t\t\t\t例1 对于项E->·E+F而言\n\t\t\t\t\t- 如果它处于末端,那么 lookSet(E·E+F)就应该有`$` (继承自 lookSet(S->·E))\n\t\t\t\t\t- 如果它被嵌入E->·E*F,那么 lookSet(E->·E+F)就应该有`*`\n\t\t\t\t\t- 如果它被嵌入E->·E+F,那么 lookSet(E->·E+F)就应该有`+`\n\t\t\t\t\t- 要注意,它不可能被嵌入E->·F,所以 lookSet(E->·E+F)不包含`id`\n\n\t\t\t\t例2 对于E->·F而言,虽然其本身没有左递归,但是由于它的兄弟项中存在左递归项,因此它仍然可能被嵌入其左递归的兄弟项\n\t\t\t\t\t- 如果E->·F 直接作为S->·E的右侧,那么LookSet(E->·F)应包含`$` (继承自 lookSet(S->·E))\n\t\t\t\t\t- 如果E->·F被嵌入E->·E+F,那么LookSet(E->·F)应包含`+`\n\t\t\t\t\t- 如果E->·F被嵌入E->·E*F,那么LookSet(E->·F)应包含`*`\n\n\t\t\t更一般的讲,一个左递归项的LookSet应该包含它的「左递归兄弟项及其本身」的「最左非左递归符号」,以及继承的LookSet\n\t\t\t在本例中,E->·E+F的「左递归兄弟项」是 E->·E*F,这个兄弟项的「最左非左递归符号」是`*`, 且E->·E+F继承了`$`.\n\n        2.1.2 展开符不包含左递归的产生式,由上一个项确定 的lookSet.\n            - 如果项形如A->𝜶·B,由展开符B得到的项应为lookSet(A)\n            - 如果项形如A->·B𝜶𝜷\n                - 若𝝴∉First(𝜶) 由展开符B得到的项的lookSet为First(𝜶)\n                - 否则,应当继续加入First(B),重复以上过程,直到末尾时,如果仍包含𝝴,则加入lookSet(A)\n            此例中,E->·F, 由于展开符是最末符号,因此展开的项F->·id可继承lookSet(A)\n\n    2.2 针对前进项\n        如果只是单纯的项的「点」前进,那么可以直接继承.\n        例如,项E->·E+F 前进后得到项E->E·+F, 后者的lookSet应该继承前者.\n\n3. 展开后的处理\n\n    3.1 如果项集中存在产生式相同,且「点」的位置相同的项, 应将它们合并.\n\n    例\n    A->·𝜶   $\n    A->·𝜶   𝜶\n\n    合并后:\n    A->·𝜶   $,𝜶\n*/\nexport type FirstSetGetter = IFunction<Symbol, Set<Terminal>>;\n/* 构造自动机所需要的方法 */\nexport class LRAutomataTools implements AutomataTools {\n\tgetFirstSet: FirstSetGetter\n\tconstructor(firstSetCalculator: FirstSetGetter) {\n\t\tthis.getFirstSet = firstSetCalculator;\n\t}\n\n\tGOTO(I: ItemSet, inputSymbol: Symbol): ItemSet {\n\t\tlet nextItemSet = new ItemSet();\n\t\tfor (let item of I) {\n\t\t\tif (!item.hasNext())\n\t\t\t\tcontinue;\n\t\t\tif (item.nextSymbol() == inputSymbol) {\n\t\t\t\tnextItemSet.push(item.nextItem());\n\t\t\t}\n\t\t}\n\t\treturn this.closure(nextItemSet);\n\t}\n\n\tclosure(itemSet: ItemSet): ItemSet {\n\t\tlet itemSetClosure: ItemSet = itemSet;\n\t\t//项集的每一个项 item\n\t\tfor (let processedIdx = 0; processedIdx < itemSetClosure.length; processedIdx++) {\n\t\t\tlet item = itemSetClosure[processedIdx];\n\t\t\tif (!item.hasNext()) //issue 1.1\n\t\t\t\tcontinue;\n\t\t\tlet expandSym = item.nextSymbol();\n\t\t\tif (!(expandSym instanceof NonTerminal)) //issue 1.2\n\t\t\t\tcontinue;\n\t\t\tif (item.prod[0] == item.prod.nonTerminal && item.dotPos == 0) { //issue 1.4\n\t\t\t\tdebug(`Stop expanding left recursion production ${expandSym}`);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tlet lrps = this.getLeftRecursiveProds(expandSym); //issue 2.1.1.1 左递归产生式\n\t\t\tlet nlrlookSet = this.determineNonLeftRecursionLookSet(item);\n\t\t\t//issue 2.1.1 展开符包含左递归产生式的情况\n\t\t\tif (lrps.length > 0) {\n\t\t\t\tlet lrLookSet = this.determineLeftRecursionLookSet(item); //由所有左递归项带来的展望符集\n\t\t\t\tfor (let lrp of expandSym) {\n\t\t\t\t\tlet unionLookSet = new Set<Terminal>();\n\t\t\t\t\taddAll_Set(unionLookSet, lrLookSet);\n\t\t\t\t\taddAll_Set(unionLookSet, nlrlookSet);\n\t\t\t\t\titemSetClosure.pushOrMerge(new Item(lrp, 0, unionLookSet));\n\t\t\t\t}\n\t\t\t}\n\t\t\t//issue 2.1.2 展开符不包含递归产生式的情况\n\t\t\telse {\n\t\t\t\tfor (let prod of expandSym.prods) {\n\t\t\t\t\tlet newItem = new Item(prod, 0, nlrlookSet);\n\t\t\t\t\titemSetClosure.pushOrMerge(newItem);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn itemSetClosure;\n\t}\n\n\t/**\n    ========展开符包含左递归产生式的处理========\n\n    文法:\n    S->A\n    A->A𝜶 | A𝜷 | 𝝲\n\n    状态:\n    S->·A ,$\n    A->·A𝜶,$\n    A->·A𝜷,$\n    A->·𝝲, ?\n\n    如何求「 A->𝝲 」的展望集?\n\n    若𝜶,𝜷不能推出𝝴,则 lookSet(A->·𝝲) = {𝜶,𝜷}\n    否则 lookSet(A->·𝝲) ={𝜶,𝜷,$}\n\n    形式化:\n    加入在A中的每一个左递归产生式中的「第一非A的符号的First集」,记为First(!A), 如果该集内存在𝝴,则一路向后直到末尾,如果仍存在𝝴,则加入 Look(A)\n\n    伪代码:\n    for each lr-prod in A\n        for each sym in lr-prod\n            if sym != A\n                add First(sym)\n                if 𝝴 ∉ First(sym)\n                    break\n                else if sym is rightmost\n                    add lookSet(S)\n\n    注: Look(S) 表示S的lookeheadSet\n    * @param curItem\n    */\n\tdetermineLeftRecursionLookSet(curItem: Item): Set<Terminal> {\n\t\tlet target = curItem.nextSymbol();\n\t\tassert(target instanceof NonTerminal);\n\n\t\tlet lookaheadSet = new Set<Terminal>();\n\t\t//目标的所有左递归产生式\n\t\tlet lrProds = this.getLeftRecursiveProds(target);\n\t\t//每一个左递归产生式\n\t\tfor (let lr_prod of lrProds) {\n\t\t\t//每一个符号\n\t\t\tlet searching = false;\n\t\t\tfor (let j = 0; j < lr_prod.length; j++) {\n\t\t\t\tif (lr_prod[j] != target && !searching) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t// right-most\n\t\t\t\tif (j == lr_prod.length - 1) {\n\t\t\t\t\taddAll_Set(lookaheadSet, curItem.lookaheadSet);\n\t\t\t\t} else {\n\t\t\t\t\tlet follower = lr_prod[j + 1];\n\t\t\t\t\tlet follower_first_set = this.getFirstSet(follower);\n\t\t\t\t\taddAll_Set(lookaheadSet, follower_first_set);\n\t\t\t\t\t// 𝝴 ∉ First(follower)\n\t\t\t\t\tif (!follower_first_set.has(Nil)) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\t// 𝝴 ∈ First(follower)  scan next one\n\t\t\t\t\telse {\n\t\t\t\t\t\tlookaheadSet.delete(Nil);\n\t\t\t\t\t\tsearching = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn lookaheadSet;\n\t}\n\t/**\n    ========展开符不包含左递归产生式的处理========\n\n    约定\n    - 将闭包项记为 closureItem ,例如S->·As\n    - 将展开项计为 expandItem , 例如由展开符A得到的项 A->·a\n\n    形式化计算规则如下:\n    展开符位于item末端,形如A->·B\n        lookSet(expandItem)=lookSet(prevItem)\n    next非末端,形如A->·B𝜶𝜷\n        lookSet(expandItem)=First(𝜶) ,\n            如果𝜶可推出𝝴,则继续向后寻找𝜷,重复这个过程,\n            如果𝜷为最末尾符号,且𝜷仍可推出𝝴,那么将lookSet(prevItem)放入lookSet(next)\n    * @param prevItem\n    */\n\tdetermineNonLeftRecursionLookSet(prevItem: Item): Set<Terminal> {\n\t\tlet expandSym = prevItem.nextSymbol();\n\t\tassert(expandSym instanceof NonTerminal);\n\n\t\tlet lookaheadSet = new Set<Terminal>();\n\n\t\tfor (let i = prevItem.dotPos; i < prevItem.prod.length; i++) {\n\t\t\tif (i == prevItem.prod.length - 1) {\n\t\t\t\taddAll_Set(lookaheadSet, prevItem.lookaheadSet);\n\t\t\t\tbreak;\n\t\t\t} else {\n\t\t\t\tlet firstSetOfFollow = this.getFirstSet(prevItem.prod[i + 1]);\n\t\t\t\taddAll_Set(lookaheadSet, firstSetOfFollow);\n\t\t\t\tif (firstSetOfFollow.has(Nil)) {\n\t\t\t\t\tlookaheadSet.delete(Nil);\n\t\t\t\t} else {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn lookaheadSet;\n\t}\n\tgetLeftRecursiveProds(non_terminal: NonTerminal) {\n\t\tlet lr_prods: Production[] = [];\n\t\t//每一个产生式\n\t\tfor (let prod of non_terminal.prods) {\n\t\t\t//产生式中的每一个符号\n\t\t\tfor (let symbol of prod) {\n\t\t\t\t//若相等,,则表示prod存在左递归\n\t\t\t\tif (symbol == non_terminal) {\n\t\t\t\t\tlr_prods.push(prod);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t//若不相等 且First(symbol)不存在𝝴则中断,则表示prod没有左递归\n\t\t\t\telse if (!this.getFirstSet(symbol).has(Nil)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdebug(lr_prods.join(\",\"));\n\t\treturn lr_prods;\n\t}\n\tgetStartState(grammar: AugmentedGrammar) {\n\t\treturn new State(0, this.closure(new ItemSet(new Item(grammar.prodOfStartNT, 0, new Set<Terminal>([EOF])))));\n\t}\n\n}\n\nexport function getStateSet_LR(grammar: AugmentedGrammar, getFirstSet: FirstSetGetter) {\n\treturn getStateSet(grammar, new LRAutomataTools(getFirstSet));\n}\n"]}