@light0x00/parser-generator/lib/Follow.js

A Parser Generator

"use strict";

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

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

var _parserDefinition = require("@light0x00/parser-definition");

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

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

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

class FollowSetCalculator {
  // issue: 9.循环依赖
  constructor(grammar, firstSetCalculator) {
    _defineProperty(this, "cyclicDector", new _Toolkit.CyclicDepsDector());

    _defineProperty(this, "cache", new Map());

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

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

    this.grammar = grammar;
    this.firstSetCalculator = firstSetCalculator;
  }

  throwError(holder, other) {
    throw new Error(`Cyclic dependencies are detected between the non-terminal ${holder} and ${other}  when calculating the follow set of ${holder}!`);
  }
  /*
     约定:
     j表示当前正在处理的产生式(prod)
     k表示当前正在处理的符号(j中的一个符号)
     k+n表示当前符号k后的n个符号
      伪代码:
     k是否为j末尾符号
         - 是, 加入Follow(j)
         - 不是,加入 (First(k+1)-{ε})
             - 如果 ε ∈ First(k+1) 则继续加入 First(k+2)).
                 并重复这一过程,直到第n个满足ε ∉ First(k+n),
                 如果符号(k+n)直到j的最后一个符号还仍旧存在 ε ∈ First(k+n), 则加入Follow(j)
      注:伪代码仅供参考,一切以实物为准!
     */


  getFollowSet(target) {
    if (this.cache.has(target)) {
      debug(`cache hit:${target}`);
      return this.cache.get(target);
    }

    let non_terminals = this.grammar.NTS();
    let follow_set = new Set();
    let whichHaveAddedFristSet = new Set(); //记录已经添加过哪些符号的First集

    let whichHaveAddedFollowSet = new Set(); //记录已经添加过哪些符号的Follow集

    if (non_terminals[0] == target) {
      // if start symbol
      follow_set.add(_parserDefinition.EOF);
      debug(`+EOF is added because ${target} is the beginning symbol`);
    } //每一个非终结符i


    for (let i = 0; i < non_terminals.length; i++) {
      let non_terminal = non_terminals[i]; //终结符中的每一个产生式j

      for (let j = 0; j < non_terminal.prods.length; j++) {
        let prod = non_terminal.prods[j];
        debug(`Scanning ${target} in production:${prod}`);
        let searching = false; //标记是否处于搜索状态 issue:  5. 连续重复
        //每一个符号k

        for (let k = 0; k < prod.length; k++) {
          if (prod[k] != target && !searching) {
            //非搜索状态,且非target,则跳过   issue:  5. 连续重复
            continue;
          } //k为j的末尾符号


          if (k == prod.length - 1) {
            if (non_terminal != target && !whichHaveAddedFollowSet.has(non_terminal)) {
              //issue: 6,7 自递归 && 重复添加
              if (this.cyclicDector.registerAndCheckCycl(target, non_terminal)) // issue: 9.循环依赖 跳过
                continue;
              debug(`+Since ${target.name} is at the end of production ${prod.name},add Follow(${non_terminal.name})`);
              (0, _shim.addAll_Set)(follow_set, this.getFollowSet(non_terminal));
              whichHaveAddedFollowSet.add(non_terminal); //标记Follow(p)已添加
            }

            break;
          }

          searching = true; //处理k+1

          let follower = prod[k + 1];
          if (whichHaveAddedFristSet.has(follower)) //issue: 6. 重复添加
            continue;
          let followerFirstSet = this.firstSetCalculator.getFirstSet(follower);
          whichHaveAddedFristSet.add(follower); //标记 First(k+1)为已添加
          //如果: ε ∈ First(k+1)

          if (followerFirstSet.has(_parserDefinition.NIL)) {
            (0, _shim.addAll_Set)(follow_set, followerFirstSet);
            follow_set.delete(_parserDefinition.NIL);
            debug(`+The symbol ${follower} follows ${target},add First(${follower})-{𝝴}, due ${follower} contains 𝝴 ,scan the following symbol of ${follower} `);
          } //如果 ε ∉ First(k+1)
          else {
              (0, _shim.addAll_Set)(follow_set, followerFirstSet);
              debug(`+The symbol ${follower} follows ${target},add First(${follower})`);
              searching = false; //k+1不可推出𝝴 则结束搜索状态    issue:  5. 连续重复
            }
        }
      }
    }

    this.cache.set(target, follow_set);
    return follow_set;
  }

  getFollowTable() {
    let followTable = new Map();

    for (let non_terminal of this.grammar.NTS()) {
      let followSet = this.getFollowSet(non_terminal);
      followTable.set(non_terminal.name, followSet);
    }

    return followTable;
  }

}

exports.FollowSetCalculator = FollowSetCalculator;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Follow.ts"],"names":["debug","FollowSetCalculator","constructor","grammar","firstSetCalculator","CyclicDepsDector","Map","throwError","holder","other","Error","getFollowSet","target","cache","has","get","non_terminals","NTS","follow_set","Set","whichHaveAddedFristSet","whichHaveAddedFollowSet","add","EOF","i","length","non_terminal","j","prods","prod","searching","k","cyclicDector","registerAndCheckCycl","name","follower","followerFirstSet","getFirstSet","NIL","delete","set","getFollowTable","followTable","followSet"],"mappings":"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","sourcesContent":["import { addAll_Set as addAll } from \"@light0x00/shim\";\nimport { EOF, NIL } from \"@light0x00/parser-definition\";\nimport { NonTerminal, Terminal, IGrammar, Symbol } from \"./Definition\";\nimport rootDebug from \"debug\";\nimport { CyclicDepsDector } from \"./Toolkit\";\nimport { FirstSetCalculator } from \"./First\";\n\nlet debug = rootDebug(\"APP:follow\");\n\nexport class FollowSetCalculator {\n\n\tprivate cyclicDector = new CyclicDepsDector<NonTerminal>()// issue: 9.循环依赖\n\tprivate cache = new Map<NonTerminal, Set<Terminal>>()\n\tprivate firstSetCalculator: FirstSetCalculator\n\tprivate grammar: IGrammar\n\n\tconstructor(grammar: IGrammar, firstSetCalculator: FirstSetCalculator) {\n\t\tthis.grammar = grammar;\n\t\tthis.firstSetCalculator = firstSetCalculator;\n\t}\n\tprivate throwError(holder: NonTerminal, other: NonTerminal) {\n\t\tthrow new Error(`Cyclic dependencies are detected between the non-terminal ${holder} and ${other}  when calculating the follow set of ${holder}!`);\n\t}\n\t/*\n    约定:\n    j表示当前正在处理的产生式(prod)\n    k表示当前正在处理的符号(j中的一个符号)\n    k+n表示当前符号k后的n个符号\n\n    伪代码:\n    k是否为j末尾符号\n        - 是, 加入Follow(j)\n        - 不是,加入 (First(k+1)-{ε})\n            - 如果 ε ∈ First(k+1) 则继续加入 First(k+2)).\n                并重复这一过程,直到第n个满足ε ∉ First(k+n),\n                如果符号(k+n)直到j的最后一个符号还仍旧存在 ε ∈ First(k+n), 则加入Follow(j)\n\n    注:伪代码仅供参考,一切以实物为准!\n    */\n\tgetFollowSet(target: NonTerminal): Set<Terminal> {\n\t\tif (this.cache.has(target)) {\n\t\t\tdebug(`cache hit:${target}`);\n\t\t\treturn this.cache.get(target)!;\n\t\t}\n\n\t\tlet non_terminals = this.grammar.NTS();\n\n\t\tlet follow_set = new Set<Terminal>();\n\t\tlet whichHaveAddedFristSet = new Set<Symbol>(); //记录已经添加过哪些符号的First集\n\t\tlet whichHaveAddedFollowSet = new Set<Symbol>(); //记录已经添加过哪些符号的Follow集\n\n\t\tif (non_terminals[0] == target) {  // if start symbol\n\t\t\tfollow_set.add(EOF);\n\t\t\tdebug(`+EOF is added because ${target} is the beginning symbol`);\n\t\t}\n\t\t//每一个非终结符i\n\t\tfor (let i = 0; i < non_terminals.length; i++) {\n\t\t\tlet non_terminal = non_terminals[i];\n\n\t\t\t//终结符中的每一个产生式j\n\t\t\tfor (let j = 0; j < non_terminal.prods.length; j++) {\n\t\t\t\tlet prod = non_terminal.prods[j];\n\t\t\t\tdebug(`Scanning ${target} in production:${prod}`);\n\n\t\t\t\tlet searching = false; //标记是否处于搜索状态 issue:  5. 连续重复\n\t\t\t\t//每一个符号k\n\t\t\t\tfor (let k = 0; k < prod.length; k++) {\n\t\t\t\t\tif (prod[k] != target && !searching) { //非搜索状态,且非target,则跳过   issue:  5. 连续重复\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\t//k为j的末尾符号\n\t\t\t\t\tif (k == prod.length - 1) {\n\t\t\t\t\t\tif (non_terminal != target && !whichHaveAddedFollowSet.has(non_terminal)) {   //issue: 6,7 自递归 && 重复添加\n\t\t\t\t\t\t\tif (this.cyclicDector.registerAndCheckCycl(target, non_terminal)) // issue: 9.循环依赖 跳过\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\tdebug(`+Since ${target.name} is at the end of production ${prod.name},add Follow(${non_terminal.name})`);\n\t\t\t\t\t\t\taddAll(follow_set, this.getFollowSet(non_terminal));\n\t\t\t\t\t\t\twhichHaveAddedFollowSet.add(non_terminal); //标记Follow(p)已添加\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tsearching = true;\n\t\t\t\t\t//处理k+1\n\t\t\t\t\tlet follower = prod[k + 1];\n\t\t\t\t\tif (whichHaveAddedFristSet.has(follower))  //issue: 6. 重复添加\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\tlet followerFirstSet = this.firstSetCalculator.getFirstSet(follower);\n\n\t\t\t\t\twhichHaveAddedFristSet.add(follower); //标记 First(k+1)为已添加\n\t\t\t\t\t//如果: ε ∈ First(k+1)\n\t\t\t\t\tif (followerFirstSet.has(NIL)) {\n\t\t\t\t\t\taddAll(follow_set, followerFirstSet);\n\t\t\t\t\t\tfollow_set.delete(NIL);\n\t\t\t\t\t\tdebug(`+The symbol ${follower} follows ${target},add First(${follower})-{𝝴}, due ${follower} contains 𝝴 ,scan the following symbol of ${follower} `);\n\t\t\t\t\t}\n\t\t\t\t\t//如果 ε ∉ First(k+1)\n\t\t\t\t\telse {\n\t\t\t\t\t\taddAll(follow_set, followerFirstSet);\n\t\t\t\t\t\tdebug(`+The symbol ${follower} follows ${target},add First(${follower})`);\n\t\t\t\t\t\tsearching = false;  //k+1不可推出𝝴 则结束搜索状态    issue:  5. 连续重复\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.cache.set(target, follow_set);\n\t\treturn follow_set;\n\t}\n\n\tgetFollowTable(): FollowSetTable {\n\t\tlet followTable = new Map<string, Set<Terminal>>();\n\t\tfor (let non_terminal of this.grammar.NTS()) {\n\t\t\tlet followSet = this.getFollowSet(non_terminal);\n\t\t\tfollowTable.set(non_terminal.name, followSet);\n\t\t}\n\t\treturn followTable;\n\t}\n}\nexport type FollowSet = Set<Terminal>;\nexport type FollowSetTable = Map<string, Set<Terminal>>;\n\n"]}