@light0x00/parser-generator/lib/LR/SLR/Automata.js

A Parser Generator

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.constructStateSet_SLR = constructStateSet_SLR;
exports.SLRAutotamaTools = void 0;

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

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

var _StateAutomata = require("../StateAutomata");

/* SLR */
class SLRAutotamaTools {
  /**
      * 求指定项集的闭包
      *
      * 例
      * 考虑文法:
      * E->E+T | T
      * T->T*F | F
      * F->(E) | id
      *
      * 输入:
      *  E->·E+T
      *  E->·T
      *
      * 输出:
      *  E->·E+T
      *  E->·T
      *  T->·T*F
      *  T->·F
      *  F->·(E)
      *  F->·id
      *
      * @param itemSet 项集
      */
  closure(itemSet) {
    let itemSetClosure = itemSet; //考虑实际情况 不需要深拷贝

    let added = new Set(); //项集的每一个项 item

    for (let processedIdx = 0; processedIdx < itemSetClosure.length; processedIdx++) {
      let item = itemSetClosure[processedIdx];
      /*
               没有闭包的情况
               1. 「点」已经到了产生式的最后末尾
                       A-> X·
               2. 后继符号不是终结符 没有闭包
                       A-> ·a
               */

      if (!item.hasNext()) continue;
      let next = item.nextSymbol();
      if (!(next instanceof _Definition.NonTerminal)) continue; //如果已经添加过 则跳过

      if (added.has(next)) continue; //将后继符号的产生式加入 closure

      for (let prod of next.prods) {
        itemSetClosure.push(new _Definition2.Item(prod));
      }

      added.add(next);
    }

    return itemSetClosure;
  }

  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);
  }

  getStartState(grammar) {
    return new _Definition2.State(0, this.closure(new _Definition2.ItemSet(new _Definition2.Item(grammar.prodOfStartNT))));
  }

}

exports.SLRAutotamaTools = SLRAutotamaTools;

function constructStateSet_SLR(grammar) {
  return (0, _StateAutomata.getStateSet)(grammar, new SLRAutotamaTools());
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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