import { J_Lex } from "J_LexYacc.js";

/**J_Lex输入参数*/
var lex = {
  input: {
    /**词法分析器输出代码配置 */
    code: {
      /**代码前缀，将添加到输出代码的最前面 */
      prefix: "/*J_LexDemo-简单案例，数字识别【此代码为自动生成代码】*/",
      /**代码后缀，将添加到输出代码的最后面 */
      suffix: "
        export default J_Lexers;", //模块化输出
    },
    /**词法正则表达式 */
    regxs: [
      { id: "ws", regx: " " }, //识别空格
      { id: "float", regx: "{num} .{num} |{num} " }, //识别小数
      { id: "int", regx: "{num} " }, //识别整数
      { id: "num", regx: "[0-9]" ,}, //识别数字
    ],
  },
};

//运行J_Lex，输出代码保存在lex.code中
console.log("开始生成");
J_Lex.run(lex);
console.log("生成完毕");

//将生成的代码写入到文件
fs.writeFileSync("./out/J_Lexers.js", lex.code);

//导入生成的代码
import J_Lexers from "./out/J_Lexers.js";
var j_lexers = new J_Lexers();

var input = "123 1 67.9 21"; //待解析的文本

var output = j_lexers.readTag(input);
console.log(output);//{ tag: [ 'float', 'int' ], value: '123', restStr: ' 1 67.9 21' }
output = j_lexers.readTag(output.restStr);
console.log(output);//{ tag: [ 'ws' ], value: ' ', restStr: '1 67.9 21' }
//以此类推重复调用readTag
//最后调用output = j_lexers.finishRead();读取最后一个匹配

var lex = {
  input:{
    /**词法正则表达式 */
    regxs: [
      //支持中文ID和中文词法解析
      { id: "中文也支持噢", regx: "耶" },
      //|使用，表示或
      //()使用，用于确定结合优先级
      // 使用，表示前面的字符串重复1~n次
      { id: "01string", regx: "(0|1) " },
      //{}使用，引用其他词法定义
      //*使用，表示前面的字符串重复0~n次
      { id: "float", regx: "{数字}*.{数字} " },
      //[]使用，等价于"\r|\n|\t| "，注意空格
      { id: "ws", regx: "[\r\n\t ]" },
      //-使用，等价于"<(c)=\\>c.charCodeAt(0)>=48&&c.charCodeAt(0)<=57>"
      //noMatch属性使用，表示该词法不需要匹配
      { id: "数字", regx: "[0-9]", noMatch: true },
      //<>使用，定义匹配函数function(c)=>bool，匹配一个字符，匹配与否由函数决定
      { id: "非引号字符", regx: `<(c)=\\>c != '"'>` },
      //\（反斜杠）使用，加在 *-|\()[]{}<>等前，用于表示其本身含义
      {
        id: "反斜杠使用",
        regx: "\\ |\\*|\\-|\\||\\\\|\\(|\\)|\\[|\\]|\\{|\\}|\\<|\\>",
      },
      //综合案例：识别c语言注释
      { id: "注释", regx: "//<(c)=\\>c != '\\\\n'>*" },
    ],
  }
};

import { J_Yacc } from "../../../J_LexYacc.js";

/**J_Yacc输入参数*/
var yacc = {
  input: {
    /**词法分析器输出代码配置 */
    code: {
      /**代码前缀，将添加到输出代码的最前面 */
      prefix: "/*J_YaccDemo-简单案例，对称串识别【此代码为自动生成代码】*/\n",
      /**代码后缀，将添加到输出代码的最后面 */
      suffix: "export default J_Parser;", //模块化输出
    },
    formalGram: {
      /**
       * 文法产生式定义
       */
      P: [
        { id: "S", gram: "A S A" },
        { id: "S", gram: "c" },
        { id: "A", gram: ["a", "b"] },
      ],
      /**
       * 非终结符定义
       */
      Vt: ["a", "b", "c"],
      /**
       * 文法开始符定义
       */
      S: "S",
    },
  },
};

//运行J_Yacc，输出代码保存在yacc.code中
console.log("开始生成");
J_Yacc.run(yacc);
console.log("打印中间变量");
console.log(yacc);
// J_Yacc.showClosuers(yacc) //可以打印闭包信息

//将生成的代码写入到文件
fs.writeFileSync("./out/J_Parser.js", yacc.code);
console.log("生成完毕");

//------代码测试------------代码测试------------代码测试------------代码测试------
//导入生成的代码
import J_Parser from "./out/J_Parser.js";
var j_parser = new J_Parser();

//自定义规约处理函数，用于处理属性文法，当前为生成一颗语法树
j_parser.scallback = (F) => {
  var temp = [];
  F.f.forEach((e) => {
    temp.push({ c: e.symbol, args: e.args });
  });
  //该返回值将作为规约符号的挂载属性
  return temp;
};

//读取符号及其挂载的参数
j_parser.readSymbol("b", { val: "1" });
j_parser.readSymbol("a", { val: "2" });
j_parser.readSymbol("c", { val: "3" });
j_parser.readSymbol("b", { val: "4" });
j_parser.readSymbol("a", { val: "5" });
//符号串读取完毕后调用此函数结束读取
var succeed = j_parser.finishRead();

if (succeed) {
  //如果分析成功，规约至起始符
  show(j_parser.shis.f[0]);
} else {
  //如果分析失败，未规约至起始符
  console.log("分析失败，未规约至起始符");
}
/**
 * 显示语法分析树的显示函数
 * @param {*} f j_parser.shis.f[0]
 */
function show(f) {
  console.log(f.symbol);
  showLayer(f.args, 0, "");
  function showLayer(args, layer, prefix) {
    var nextPrefix = prefix   "┃";
    for (var i = 0; i < args.length;   i) {
      var arg = args[i];
      var string;
      if (i < args.length - 1) {
        string = prefix   "┣"   arg.c;
      } else {
        string = prefix   "┗"   arg.c;
      }
      if (arg.args.val != undefined) {
        string  = " ⇒ "   arg.args.val;
      }
      console.log(string);
      if (i < args.length - 1) {
        showLayer(arg.args, layer   1, nextPrefix);
      } else {
        showLayer(arg.args, layer   1, prefix   " ");
      }
    }
  }
}

var yacc = {
  input: {
    formalGram: {
      /**
       * 定义全局结合性，表示以下文法表达式中没有特殊定义的文法表达式均采用此结合性，其值可以为m,l,r,以下的结合性定义均可设置这三个值
       * m：不定义结合性（默认），l：左结合，r：左结合
       */
      asso: "l",
      /**
       * 拓广文法的起始符结合性定义，可为空
       */
      S_asso: "l",
      /**
       * 拓广文法的优先级定义，可为空
       */
      S_priority: -1,
      /**
       * 文法产生式定义
       */
      P: [
        /**
         * id为非终结符
         * gram为其对应的文法产生式
         */
        {
          id: "Expr",
          gram: "num",
        },
        /**
         * id可重复，如果重复则表示该非终结符的不同产生式
         * gram定义以空格分隔
         */
        {
          id: "Expr",
          gram: "( Expr )",
        },
        /**
         * gram定义中可以出现数组，表示该非终结符的不同产生式
         * 如下表示等价于：
         * Expr=>Expr   Expr | Expr * Expr
         * 如果算上上面分开定义的两条Expr的产生式，则实际等价于：
         * Expr=> num | ( Expr ) | Expr   Expr | Expr * Expr
         */
        {
          id: "Expr",
          gram: ["Expr   Expr", "Expr * Expr"],
          /**
           *1  priority定义文法产生式的优先级，文法产生式的默认优先级为undefined，表示不参与优先级比较，如需让两产生式根据优先级比较进行冲突处理，则需同时为这两条产生式定义优先级，优先级为一个数
           *2  优先级越高的文法产生式在冲突处理时会被选择，不管是何种冲突
           *3 优先级定义同样可以写为数组或一个单一的值
           *4  如果priority数组大小小于gram数组大小，则表示多余的gram对应priority数组最后一项的优先级定义
           */
          priority: [0, 1],
        },
      ],
      /**
       * 非终结符定义
       */
      Vt: [" ", "*", "num", "(", ")"],
      /**
       * 文法开始符定义
       */
      S: "Expr",
    },
  },
};

J_Yacc.showClosuers(yacc);

J_Yacc.showConflictResolution(yacc)