@light0x00/parser-generator/lib/LR/StateAutomata.js

A Parser Generator

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getStateSet = getStateSet;

var _Definition = require("./Definition");

var _debug = _interopRequireDefault(require("debug"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

let debug = (0, _debug.default)("APP:LR:Automata");
/*
构造项集族
更准确地说,是构造一个由项集组成的状态机,一个项集对应一个状态,对每个状态输入某一个符号可到达下一个状态.
这些用于记录状态间的连接关系的「边」也会存储在返回的数据结构里.

输入: 增广文法
输出: 项集族

注: 由于项集对应自动机中的一个状态,因此将交替使用「项集」、「状态」,两者含义等同.

S->E
E->E+T | T
T->T*F | F
F->(E) | id

计算开始项 S->·E 的闭包,可得到第一个状态 I0
I0
    S->·E
    E->·E+T
    E->·T
    T->·T*F
    T->·F
    F->·(E)
    F->·id

得到该项集中的每一项的中的「·」右侧的符号的集合
{E,T,F,(,id}

将该集合的每一项𝛂分别输入I0, 可得到I0的5个后继项集

𝛂=E
    E->E·+T
𝛂=T
    E->T·
    T->T·*F
𝛂=F
    T->F·
𝛂=(
    F->(·E)
𝛂=id
    F->id·

分别计算以上5个状态的闭包,可得到5个状态:

I1
    E->E·+T
I2
    E->T·
    T->T·*F
I3
    T->F·
I4
    F->(·E)
    E->·E+T
    E->·T
    T->·T*F
    T->·F
    F->·(E)
    F->·id
I5
    F->id·

遍历以上5个状态,重复上面的处理逻辑
*/

function getStateSet(grammar, tools) {
  //状态id计数
  let stateIdCounter = 1; // let I0 = new State(stateIdCounter++, closure(new ItemSet(new Item(grammar.prodOfStartNT))))

  let I0 = tools.getStartState(grammar);
  debug(`${I0}`); //存放状态集

  let stateSet = new _Definition.StateSet();
  stateSet.push(I0); //状态集中待处理的 状态的索引

  let procssedIdx = 0; //每一个状态集中尚未处理的状态

  while (procssedIdx < stateSet.length) {
    let curState = stateSet[procssedIdx++]; //得到当前状态的后继符号集

    let nextSymbols = curState.getNextSymbols(); //对当前状态输入 符号集 中的每个符号

    for (let nextSymbol of nextSymbols) {
      //生成当前状态对输入(nextSymbol)的后继状态
      let nextItemSet = tools.GOTO(curState, nextSymbol); //检查生成的状态是否已经存在 (判断状态相等标准见:ItemSet.equals())

      let nextState = stateSet.getExisting(nextItemSet);

      if (nextState == null) {
        nextState = new _Definition.State(stateIdCounter++, nextItemSet);
        stateSet.push(nextState);
        debug(`\n+Adding a new state:\n${nextState}\n`);
      } //记录当前状态 与 后继状态 的连接


      curState.addNextState(nextSymbol, nextState);
      debug(`mapping: ${curState.id} ----- ${nextSymbol} -----> ${nextState.id}`);
    }
  }

  return stateSet;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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