@light0x00/parser-generator
Version:
A Parser Generator
242 lines (205 loc) • 26.6 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getParsingTable = getParsingTable;
var _shim = require("@light0x00/shim");
var _parserDefinition = require("@light0x00/parser-definition");
var _Definition = require("../Definition");
var _Definition2 = require("./Definition");
var _debug = _interopRequireDefault(require("debug"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
let debug = (0, _debug.default)("APP:LR:parsing-table");
/*
输入: 一个由「项集族」和「项集间跳转关系」组成的状态机
输出: LR/SLR分析表
注: 用 stateA.next_state(input_symbol) 表示状态A输入符号后进入的下一个状态
遍历每一个状态S中的每一个项I
- I为Reduce/Accpet项,形如 A->𝜶𝜷·
- 若A是不是开始符号,则为Follow(T)中的每一个符号f填入: T[S][f] = Reduce A
- 若A是开始符号,操作同上,不过填入得时 Accept A (本质上Accept项是一个特殊的归约项)
- I为Shift/Goto, A->𝜶·𝜷
- 若𝜷为非终结符,则产生 跳转项, T[S][𝜷] = Goto S.next_state(𝜷)
- 若𝜷为终结符,则产生式 移入项, T[S][𝜷] = Shift S.next_state(𝜷)
*/
/**
*
* @param stateSet 状态机
* @param startSymbol 开始符号
* @param allowedFollowsWhenReducing 对于任意一个归约项,返回其允许的「归约展望符」(SLR/LR)
*/
function getParsingTable(stateSet, startSymbol, allowedFollowsWhenReducing) {
let parsingTable = new _Definition2.ParsingTable(); //状态集中的每一个状态
for (let curState of stateSet) {
//状态中的每一个项
for (let curItem of curState) {
let {
prec: curPrec,
leftAssoc: curLeftAssoc
} = curItem.prod; // 移入项 形如: A->𝜶·𝜷
if (curItem.hasNext()) {
let followSymbol = curItem.nextSymbol();
let existingOp = parsingTable.get(curState, followSymbol);
if (existingOp != null) {
//issue #关于冲突检查 1
if (existingOp.isReduce()) {
//issue #关于冲突检查 2. 移入-归约冲突
if (!compareForShiftReduceConflict({
prec: curPrec,
leftAssoc: curLeftAssoc
}, {
prec: existingOp.prec,
leftAssoc: existingOp.leftAssoc
})) continue;
} else if (existingOp.isShift()) //issue #关于优先级与结合性 2
existingOp.setIfLarger(curPrec, curLeftAssoc);
}
let nextState = curState.getNextState(followSymbol);
(0, _shim.assert)(nextState != null);
let op; //goto
if (followSymbol instanceof _Definition.NonTerminal) op = new _Definition2.Goto(nextState); //shift
else op = new _Definition2.Shift(nextState, curPrec, curLeftAssoc);
debug(`state(${curState.id}) ${followSymbol} ${op}`);
parsingTable.put(curState, followSymbol, op);
} //归约项 形如: A->𝜶𝜷·
else {
let allowedFollows = allowedFollowsWhenReducing(curItem); //issue #关于lookahead的确定
(0, _shim.assert)(allowedFollows != null);
for (let followSymbol of allowedFollows) {
let existingOp = parsingTable.get(curState, followSymbol);
if (existingOp != null) {
//issue #关于冲突检查
if (existingOp.isReduce() && existingOp.prod.nonTerminal != curItem.prod.nonTerminal) {
//issue #关于冲突检查 1. 归约-归约冲突
if (!compareForReduceReduceConflict({
prec: curPrec,
leftAssoc: curLeftAssoc
}, {
prec: existingOp.prec,
leftAssoc: curLeftAssoc
})) {
continue;
}
} else if (existingOp.isShift()) {
//issue #关于冲突检查 2. 移入-归约冲突
if (!compareForShiftReduceConflict({
prec: curPrec,
leftAssoc: curLeftAssoc
}, {
prec: existingOp.prec,
leftAssoc: curLeftAssoc
})) {
continue;
}
}
}
let op; //accept
if (followSymbol == _parserDefinition.EOF && curItem.prod.nonTerminal == startSymbol) op = new _Definition2.Accept(); //reduce
else op = new _Definition2.Reduce(curItem.prod, curPrec, curLeftAssoc);
debug(`state(${curState.id}) ${followSymbol} ${op}`);
parsingTable.put(curState, followSymbol, op);
}
}
}
}
return parsingTable;
} //issue #关于优先级与结合性 3.1 移入归约冲突
function compareForShiftReduceConflict(cur, existing) {
let {
prec: curPrec,
leftAssoc: curLeftAssoc
} = cur;
let {
prec: existingPrec
} = existing;
if (curPrec > existingPrec) {
//shift
return true;
} else if (curPrec == existingPrec) {
// assert(curLeftAssoc == exisingAssoc, `Both ${existingOp.prod},${curItem.prod} contain the same priority ${curPrec} but assoc differently`);
if (curLeftAssoc) {
//reduce
return false;
} else {
//shift
return true;
}
} else {
//reduce
return false;
}
} //issue #关于优先级与结合性 3.2 归约归约冲突
function compareForReduceReduceConflict(cur, existing) {
let {
prec: curPrec
} = cur;
let {
prec: existingPrec
} = existing;
if (curPrec > existingPrec) {
return true;
} else {
return false;
}
}
/*
关于Shift、GOTO、Reduce、Accept的产生时机
- Shift/GOTO,每当遇到形如A->𝜶·𝜷的项时,如果𝜷是非终结符则产生GOTO动作,否则为Shift
- Reduce/Accept,每当遇到形如A->𝜶·的项时,如果A是开始符号则Accpet,否则为Reduce
关于lookahead的确定
- Shift/GOTO,对于一个形如A->𝜶·𝜷的项,其lookahead为𝜷
- Reduce/Accept,取决于具体分析算法:
- SLR,lookhead存在于「项对应的产生式的Follow集」
- LR,lookhead存在于项的展望集(lookaheadSet)
关于冲突检查
1. 移入-归约冲突
1.1 允许多个项移入同一符号,考虑如下两个项:
S->·E
E->·E+T
它们的 nextSymbol 都是 E, 在处理第一个项时,已经计算了当前状态对输入E的后继状态,所以在当前状态第二次遇到E时,不必再重新处理.
1.2 对同一lookahead,存在移入、归约操作,考虑如下项集:
E->E+E·,{+,*,EOF}
E->E·+E,{+,*,EOF}
E->E·*E,{+,*,EOF}
该项集对于输入{+,*,EOF},同时存在移入、归约操作.
2. 归约-归约冲突, 原则上同一个状态对同一符号只能有一个操作,若个一个状态中的多个归约项的Follow集存在交集,那么分为如下两种情况进行处理:
2.1 允许状态中多个项归约为同一个符号. 如下例子中,虽然两个项的Follow集都为Follow(A),但是归约动作/结果都是相同的(都是A),因此允许该情况存在.
A->𝜶·
A->𝜶·
2.2 不允许状态中多个项归约为不同符号. 如下例子中,Follow(A) ∩ Follow(B)不为空的情况下,无法预知归约为A还是B,因此如下情况不允许存在.
A->𝜶·
B->𝜶·
3. 其他冲突
3.1 允许GOTO-GOTO冲突, 即: A->a·C B->b·C
3.2 Accept和 GOTO、Shift、Reduce都不可能冲突,因为Accept具备以下特征:
- EOF才可能触发Accept (Shift、GOTO不具备)
- 归约项必须为开始符号 (Reduce不具备)
关于优先级与结合性
1.每一个项都具有优先级、结合性属性.
E->E+E·,{+,*,EOF}
E->E·+E,{+,*,EOF}
E->E·*E,{+,*,EOF}
+: prec=1,assoc=left
*: prec=2,assoc=left
2. 如何确定一个项、操作的优先级、结合性?
2.1 项的prec、assoc由产生式中的符号决定,例如 E->E+E中只有`+`会有优先级、结合性,因此该产生式的优先级、结合性取决于`+`;
如果项中存在多个符号具有prec、assoc,则以prec最大的符号为准,例如 E->E+E*, 其优先级以`*`为准.
2.2 操作的prec、assoc取决于产生式该移入操作的项,例如 E->E·+E,会产生式一个对+的`shift`操作,该操作的优先级、结合性取决于项E->E·+E;
类似的,E->E+E·会产生式一个`reduce`操作,该操作的prec、assoc取决于E->E+E·
3. 如何根据优先级、结合性决定解决冲突?
通过比较两个操作的prec、assoc,
3.1 移入归约冲突
如果相同优先级
结合方向相同
- 左结合,优先归约
- 右结合,优先移入
结合方向不同
抛出异常
不同优先级
以高优先级的操作的prec、assoc为准
3.2 归约归约冲突
以高优先级的操作的prec、assoc为准
例1,E->E·+E产生一个`shift`,而E->E+E·产生一个`reduce`,两个操作的优先级相同,且为左结合,因此选择`reduce`
例2,E->E·*E将产生一个`shift`, 而E->E+E·产生一个`reduce`,前者的优先级更高,因此选择`shift`
*/
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LR/ParsingTable.ts"],"names":["debug","getParsingTable","stateSet","startSymbol","allowedFollowsWhenReducing","parsingTable","ParsingTable","curState","curItem","prec","curPrec","leftAssoc","curLeftAssoc","prod","hasNext","followSymbol","nextSymbol","existingOp","get","isReduce","compareForShiftReduceConflict","isShift","setIfLarger","nextState","getNextState","op","NonTerminal","Goto","Shift","id","put","allowedFollows","nonTerminal","compareForReduceReduceConflict","EOF","Accept","Reduce","cur","existing","existingPrec"],"mappings":"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","sourcesContent":["import { assert } from \"@light0x00/shim\";\nimport { EOF } from \"@light0x00/parser-definition\";\nimport { NonTerminal, Terminal } from \"../Definition\";\nimport { StateSet, Operation, ParsingTable, Shift, Goto, Reduce, Accept, Item } from \"./Definition\";\n\nimport { IFunction } from \"@light0x00/shim\";\n\nimport rootDebug from \"debug\";\nlet debug = rootDebug(\"APP:LR:parsing-table\");\n\n/*\n输入: 一个由「项集族」和「项集间跳转关系」组成的状态机\n输出: LR/SLR分析表\n\n注: 用 stateA.next_state(input_symbol) 表示状态A输入符号后进入的下一个状态\n\n遍历每一个状态S中的每一个项I\n    - I为Reduce/Accpet项,形如 A->𝜶𝜷·\n        - 若A是不是开始符号,则为Follow(T)中的每一个符号f填入: T[S][f] = Reduce A\n        - 若A是开始符号,操作同上,不过填入得时 Accept A (本质上Accept项是一个特殊的归约项)\n    - I为Shift/Goto, A->𝜶·𝜷\n        - 若𝜷为非终结符,则产生 跳转项, T[S][𝜷] = Goto S.next_state(𝜷)\n        - 若𝜷为终结符,则产生式 移入项, T[S][𝜷] = Shift S.next_state(𝜷)\n*/\n/**\n *\n * @param stateSet 状态机\n * @param startSymbol 开始符号\n * @param allowedFollowsWhenReducing 对于任意一个归约项,返回其允许的「归约展望符」(SLR/LR)\n */\nexport function getParsingTable(stateSet: StateSet, startSymbol: NonTerminal, allowedFollowsWhenReducing: IFunction<Item, Set<Terminal>>): ParsingTable {\n\n\tlet parsingTable = new ParsingTable();\n\n\t//状态集中的每一个状态\n\tfor (let curState of stateSet) {\n\t\t//状态中的每一个项\n\t\tfor (let curItem of curState) {\n\t\t\tlet { prec: curPrec, leftAssoc: curLeftAssoc } = curItem.prod;\n\t\t\t// 移入项 形如: A->𝜶·𝜷\n\t\t\tif (curItem.hasNext()) {\n\t\t\t\tlet followSymbol = curItem.nextSymbol();\n\t\t\t\tlet existingOp = parsingTable.get(curState, followSymbol);\n\t\t\t\tif (existingOp != null) { //issue #关于冲突检查 1\n\t\t\t\t\tif (existingOp.isReduce()) { //issue #关于冲突检查 2. 移入-归约冲突\n\t\t\t\t\t\tif (!compareForShiftReduceConflict({ prec: curPrec, leftAssoc: curLeftAssoc }, { prec: existingOp.prec, leftAssoc: existingOp.leftAssoc }))\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\telse if (existingOp.isShift()) //issue #关于优先级与结合性 2\n\t\t\t\t\t\texistingOp.setIfLarger(curPrec, curLeftAssoc);\n\t\t\t\t}\n\t\t\t\tlet nextState = curState.getNextState(followSymbol);\n\t\t\t\tassert(nextState != null);\n\t\t\t\tlet op: Operation;\n\t\t\t\t//goto\n\t\t\t\tif (followSymbol instanceof NonTerminal)\n\t\t\t\t\top = new Goto(nextState);\n\t\t\t\t//shift\n\t\t\t\telse\n\t\t\t\t\top = new Shift(nextState, curPrec, curLeftAssoc);\n\t\t\t\tdebug(`state(${curState.id}) ${followSymbol} ${op}`);\n\t\t\t\tparsingTable.put(curState, followSymbol, op);\n\t\t\t}\n\t\t\t//归约项 形如: A->𝜶𝜷·\n\t\t\telse {\n\t\t\t\tlet allowedFollows = allowedFollowsWhenReducing(curItem); //issue #关于lookahead的确定\n\t\t\t\tassert(allowedFollows != null);\n\t\t\t\tfor (let followSymbol of allowedFollows) {\n\t\t\t\t\tlet existingOp = parsingTable.get(curState, followSymbol);\n\t\t\t\t\tif (existingOp != null) { //issue #关于冲突检查\n\t\t\t\t\t\tif (existingOp.isReduce() && existingOp.prod.nonTerminal != curItem.prod.nonTerminal) { //issue #关于冲突检查 1. 归约-归约冲突\n\t\t\t\t\t\t\tif (!compareForReduceReduceConflict(\n\t\t\t\t\t\t\t\t{ prec: curPrec, leftAssoc: curLeftAssoc },\n\t\t\t\t\t\t\t\t{ prec: existingOp.prec, leftAssoc: curLeftAssoc })) {\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if (existingOp.isShift()) { //issue #关于冲突检查 2. 移入-归约冲突\n\t\t\t\t\t\t\tif (!compareForShiftReduceConflict(\n\t\t\t\t\t\t\t\t{ prec: curPrec, leftAssoc: curLeftAssoc },\n\t\t\t\t\t\t\t\t{ prec: existingOp.prec, leftAssoc: curLeftAssoc })) {\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tlet op;\n\t\t\t\t\t//accept\n\t\t\t\t\tif (followSymbol == EOF && curItem.prod.nonTerminal == startSymbol)\n\t\t\t\t\t\top = new Accept();\n\t\t\t\t\t//reduce\n\t\t\t\t\telse\n\t\t\t\t\t\top = new Reduce(curItem.prod,curPrec,curLeftAssoc);\n\t\t\t\t\tdebug(`state(${curState.id}) ${followSymbol} ${op}`);\n\t\t\t\t\tparsingTable.put(curState, followSymbol, op);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn parsingTable;\n}\n\n//issue #关于优先级与结合性 3.1 移入归约冲突\nfunction compareForShiftReduceConflict(cur: { prec: number, leftAssoc: boolean }, existing: { prec: number, leftAssoc: boolean }) {\n\tlet { prec: curPrec, leftAssoc: curLeftAssoc } = cur;\n\tlet { prec: existingPrec } = existing;\n\n\tif (curPrec > existingPrec) {\n\t\t//shift\n\t\treturn true;\n\t} else if (curPrec == existingPrec) {\n\t\t// assert(curLeftAssoc == exisingAssoc, `Both ${existingOp.prod},${curItem.prod} contain the same priority ${curPrec} but assoc differently`);\n\t\tif (curLeftAssoc) {\n\t\t\t//reduce\n\t\t\treturn false;\n\t\t} else {\n\t\t\t//shift\n\t\t\treturn true;\n\t\t}\n\t} else {\n\t\t//reduce\n\t\treturn false;\n\t}\n}\n\n//issue #关于优先级与结合性 3.2 归约归约冲突\nfunction compareForReduceReduceConflict(cur: { prec: number, leftAssoc: boolean }, existing: { prec: number, leftAssoc: boolean }) {\n\tlet { prec: curPrec } = cur;\n\tlet { prec: existingPrec } = existing;\n\n\tif (curPrec > existingPrec) {\n\t\treturn true;\n\t} else {\n\t\treturn false;\n\t}\n}\n\n/*\n关于Shift、GOTO、Reduce、Accept的产生时机\n\t- Shift/GOTO,每当遇到形如A->𝜶·𝜷的项时,如果𝜷是非终结符则产生GOTO动作,否则为Shift\n\t- Reduce/Accept,每当遇到形如A->𝜶·的项时,如果A是开始符号则Accpet,否则为Reduce\n\n关于lookahead的确定\n\t- Shift/GOTO,对于一个形如A->𝜶·𝜷的项,其lookahead为𝜷\n\t- Reduce/Accept,取决于具体分析算法:\n\t\t- SLR,lookhead存在于「项对应的产生式的Follow集」\n\t\t- LR,lookhead存在于项的展望集(lookaheadSet)\n\n关于冲突检查\n1. 移入-归约冲突\n\t1.1 允许多个项移入同一符号,考虑如下两个项:\n\t\tS->·E\n\t\tE->·E+T\n\t\t它们的 nextSymbol 都是 E, 在处理第一个项时,已经计算了当前状态对输入E的后继状态,所以在当前状态第二次遇到E时,不必再重新处理.\n\t1.2 对同一lookahead,存在移入、归约操作,考虑如下项集:\n\t\tE->E+E·,{+,*,EOF}\n\t\tE->E·+E,{+,*,EOF}\n\t\tE->E·*E,{+,*,EOF}\n\n\t\t该项集对于输入{+,*,EOF},同时存在移入、归约操作.\n\n2. 归约-归约冲突, 原则上同一个状态对同一符号只能有一个操作,若个一个状态中的多个归约项的Follow集存在交集,那么分为如下两种情况进行处理:\n\t2.1 允许状态中多个项归约为同一个符号. 如下例子中,虽然两个项的Follow集都为Follow(A),但是归约动作/结果都是相同的(都是A),因此允许该情况存在.\n\t\tA->𝜶·\n\t\tA->𝜶·\n\t2.2 不允许状态中多个项归约为不同符号. 如下例子中,Follow(A) ∩ Follow(B)不为空的情况下,无法预知归约为A还是B,因此如下情况不允许存在.\n\t\tA->𝜶·\n\t\tB->𝜶·\n\n3. 其他冲突\n\t3.1 允许GOTO-GOTO冲突, 即: A->a·C B->b·C\n\t3.2 Accept和 GOTO、Shift、Reduce都不可能冲突,因为Accept具备以下特征:\n\t\t- EOF才可能触发Accept (Shift、GOTO不具备)\n\t\t- 归约项必须为开始符号 (Reduce不具备)\n\n关于优先级与结合性\n\t1.每一个项都具有优先级、结合性属性.\n\t\tE->E+E·,{+,*,EOF}\n\t\tE->E·+E,{+,*,EOF}\n\t\tE->E·*E,{+,*,EOF}\n\t\t+: prec=1,assoc=left\n\t\t*: prec=2,assoc=left\n\n\t2. 如何确定一个项、操作的优先级、结合性?\n\t\t2.1 项的prec、assoc由产生式中的符号决定,例如 E->E+E中只有`+`会有优先级、结合性,因此该产生式的优先级、结合性取决于`+`;\n\t\t\t如果项中存在多个符号具有prec、assoc,则以prec最大的符号为准,例如 E->E+E*, 其优先级以`*`为准.\n\t\t2.2 操作的prec、assoc取决于产生式该移入操作的项,例如 E->E·+E,会产生式一个对+的`shift`操作,该操作的优先级、结合性取决于项E->E·+E;\n\t\t\t类似的,E->E+E·会产生式一个`reduce`操作,该操作的prec、assoc取决于E->E+E·\n\n\t3. 如何根据优先级、结合性决定解决冲突?\n\t\t通过比较两个操作的prec、assoc,\n\t\t3.1 移入归约冲突\n\t\t\t如果相同优先级\n\t\t\t\t结合方向相同\n\t\t\t\t\t- 左结合,优先归约\n\t\t\t\t\t- 右结合,优先移入\n\t\t\t\t结合方向不同\n\t\t\t\t\t抛出异常\n\t\t\t不同优先级\n\t\t\t\t以高优先级的操作的prec、assoc为准\n\t\t3.2 归约归约冲突\n\t\t\t以高优先级的操作的prec、assoc为准\n\t\t例1,E->E·+E产生一个`shift`,而E->E+E·产生一个`reduce`,两个操作的优先级相同,且为左结合,因此选择`reduce`\n\t\t例2,E->E·*E将产生一个`shift`, 而E->E+E·产生一个`reduce`,前者的优先级更高,因此选择`shift`\n*/"]}