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

A Parser Generator

"use strict";

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

var _Toolkit = require("../Toolkit");

var _shim = require("@light0x00/shim");

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

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:LR:parser");

class LRParser {
  constructor(stateAutomata, parsingTable) {
    _defineProperty(this, "stateAutomata", void 0);

    _defineProperty(this, "parsingTable", void 0);

    this.stateAutomata = stateAutomata;
    this.parsingTable = parsingTable;
  }
  /* !!重构 */


  determineTableKey(sym) {
    if (sym instanceof _Definition.NonTerminal) return sym;else {
      return sym.tableKey();
    }
  }

  parse(lexer) {
    let startState = this.stateAutomata.satrtState();
    let stateStack = new _shim.Stack(startState);
    let astStack = new _shim.Stack();
    let lookahead = lexer.peek();

    while (1) {
      let topSta = stateStack.peek();
      let op = this.parsingTable.get(topSta, this.determineTableKey(lookahead));
      if (op == undefined) throw new _Toolkit.MismatchError(this.parsingTable.getExpectedTokens(topSta), lookahead);

      if (op.isShift()) {
        astStack.push(lexer.nextToken());
        stateStack.push(op.nextState);
        lookahead = lexer.peek();
      } else if (op.isReduce()) {
        /* 此次归约产生的AST节点所需的元素 */
        let eles = []; // 动作: 归约完成后将符号对应的状态弹出
        // 每个状态都由输入一个符号得到 因此每个状态都一个对应的符号  详见:P158

        for (let i = 0; i < op.prod.length; i++) {
          stateStack.pop();
          eles.unshift(astStack.pop()); //此处将把顺序弄反
        }

        astStack.push(op.prod.makeAST(eles)); //issue ASTNode的元素的顺序问题

        debug(`reduce ${op.prod}, make ast: ${astStack.peek()}`); //将向前看符号指定为归约符号

        lookahead = op.prod.nonTerminal;
      } else if (op.isGoto()) {
        stateStack.push(op.nextState);
        lookahead = lexer.peek();
      } else if (op.isAccept()) {
        debug(`accept!`);
        break;
      }

      debug(`${astStack.join(" ")}`);
    }

    return astStack.pop();
  }

}
/*
1. ASTNode的元素的顺序问题

考虑如下文法
	S->E
	E->E+T | E-T | T
	T->T*F | T/F |F
	F->(E) | NUM

假设输入:
1 + 2 / 3
必然在某一时刻 Ast Stack中的元素为:
ENode + TNode / FNode

此时,即将要执行的动作是将 TNode / FNode 归约为T,创建一个TNode:
	new TNode([TNode,'/',FNode])
这时要注意的是,传给TNode的集合应该保持与产生式中定义的符号顺序保持一致.
假如传入的是 [FNode,'/',TNode], 那么原本的2/3的含义将变为3/2
*/


exports.LRParser = LRParser;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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