J_LexYacc-一款纯JS编写的词法、语法分析生成器

一、说明

二、J_Lex

2.1 J_Lex使用说明

2.1.1 简单使用

step1: 包导入

import { J_Lex } from "J_LexYacc.js";

step2: 给参数

/**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]" ,}, //识别数字
 ],
 },
};

step3: 运行

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

step4: 将代码保存到文件,或直接eval执行

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

step5:运行生成的代码

//导入生成的代码
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();读取最后一个匹配

2.1.1 详细说明

词法定义说明

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'>*" },
 ],
 }
};

三、J_Yacc

3.1 J_Yacc使用说明

3.1.1 简单使用

step1: 包导入

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

step2: 给参数

/**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",
 },
 },
};

step3: 运行

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

step4: 将代码保存到文件,或直接eval执行

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

step5: 运行生成的代码

step5.1: 导入并新建对象

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

step5.2: 定义规约处理函数

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

step5.3: 读取符号

//读取符号及其挂载的参数
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();

step5.4: 打印语法树

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

3.1.2 详细说明

语法定义说明

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)

四、J_Lex、J_Yacc联合使用

#include<stdio.h>
int main()
{
 if(c)
 if(a)
 print("hhh");
 else
 {
 test(1,1&1);
 }
}
float test(int a,int b)
{
 return (float)(a+b);
}

Start
{ tag: [ '#include' ], value: '#include' }
{ tag: [ '<>' ], value: '<stdio.h>' }
{ tag: [ 'type', 'id' ], value: 'int' }
{ tag: [ 'id' ], value: 'main' }
{ tag: [ '(' ], value: '(' }
{ tag: [ ')' ], value: ')' }
{ tag: [ '{' ], value: '{' }
{ tag: [ 'if', 'id' ], value: 'if' }
{ tag: [ '(' ], value: '(' }
{ tag: [ 'id' ], value: 'c' }
{ tag: [ ')' ], value: ')' }
{ tag: [ 'if', 'id' ], value: 'if' }
{ tag: [ '(' ], value: '(' }
{ tag: [ 'id' ], value: 'a' }
{ tag: [ ')' ], value: ')' }
{ tag: [ 'id' ], value: 'print' }
{ tag: [ '(' ], value: '(' }
{ tag: [ 'string' ], value: '"hhh"' }
{ tag: [ ')' ], value: ')' }
{ tag: [ ';' ], value: ';' }
{ tag: [ 'else', 'id' ], value: 'else' }
{ tag: [ '{' ], value: '{' }
{ tag: [ 'id' ], value: 'test' }
{ tag: [ '(' ], value: '(' }
{ tag: [ 'integer', 'float' ], value: '1' }
{ tag: [ ',' ], value: ',' }
{ tag: [ 'integer', 'float' ], value: '1' }
{ tag: [ '&' ], value: '&' }
{ tag: [ 'integer', 'float' ], value: '1' }
{ tag: [ ')' ], value: ')' }
{ tag: [ ';' ], value: ';' }
{ tag: [ '}' ], value: '}' }
{ tag: [ '}' ], value: '}' }
{ tag: [ 'type', 'id' ], value: 'float' }
{ tag: [ 'id' ], value: 'test' }
{ tag: [ '(' ], value: '(' }
{ tag: [ 'type', 'id' ], value: 'int' }
{ tag: [ 'id' ], value: 'a' }
{ tag: [ ',' ], value: ',' }
{ tag: [ 'type', 'id' ], value: 'int' }
{ tag: [ 'id' ], value: 'b' }
{ tag: [ ')' ], value: ')' }
{ tag: [ '{' ], value: '{' }
{ tag: [ 'return', 'id' ], value: 'return' }
{ tag: [ '(' ], value: '(' }
{ tag: [ 'type', 'id' ], value: 'float' }
{ tag: [ ')' ], value: ')' }
{ tag: [ '(' ], value: '(' }
{ tag: [ 'id' ], value: 'a' }
{ tag: [ '+' ], value: '+' }
{ tag: [ 'id' ], value: 'b' }
{ tag: [ ')' ], value: ')' }
{ tag: [ ';' ], value: ';' }
{ tag: [ '}' ], value: '}' }
Start
┣predefine
┃┣#include ⇒ #include
┃┣<> ⇒ <stdio.h>
┃┗predefine
┗program
 ┣funcDef
 ┃┣type ⇒ int
 ┃┣id ⇒ main
 ┃┣( ⇒ (
 ┃┣funcValDef
 ┃┣) ⇒ )
 ┃┣{ ⇒ {
 ┃┣noneAbleBlock
 ┃┃┗blocks
 ┃┃ ┗block
 ┃┃ ┗if_block
 ┃┃ ┣if ⇒ if
 ┃┃ ┣( ⇒ (
 ┃┃ ┣expr
 ┃┃ ┃┗variable
 ┃┃ ┃ ┗id ⇒ c
 ┃┃ ┣) ⇒ )
 ┃┃ ┗block
 ┃┃ ┗if_block
 ┃┃ ┣if ⇒ if
 ┃┃ ┣( ⇒ (
 ┃┃ ┣expr
 ┃┃ ┃┗variable
 ┃┃ ┃ ┗id ⇒ a
 ┃┃ ┣) ⇒ )
 ┃┃ ┣block
 ┃┃ ┃┗statement
 ┃┃ ┃ ┗expr_S
 ┃┃ ┃ ┣expr
 ┃┃ ┃ ┃┗funcCall
 ┃┃ ┃ ┃ ┣id ⇒ print
 ┃┃ ┃ ┃ ┣( ⇒ (
 ┃┃ ┃ ┃ ┣expr
 ┃┃ ┃ ┃ ┃┗literal
 ┃┃ ┃ ┃ ┃ ┗string ⇒ "hhh"
 ┃┃ ┃ ┃ ┗) ⇒ )
 ┃┃ ┃ ┗; ⇒ ;
 ┃┃ ┣else ⇒ else
 ┃┃ ┗block
 ┃┃ ┗bracket_block
 ┃┃ ┣{ ⇒ {
 ┃┃ ┣noneAbleBlock
 ┃┃ ┃┗blocks
 ┃┃ ┃ ┗block
 ┃┃ ┃ ┗statement
 ┃┃ ┃ ┗expr_S
 ┃┃ ┃ ┣expr
 ┃┃ ┃ ┃┗funcCall
 ┃┃ ┃ ┃ ┣id ⇒ test
 ┃┃ ┃ ┃ ┣( ⇒ (
 ┃┃ ┃ ┃ ┣expr
 ┃┃ ┃ ┃ ┃┣expr
 ┃┃ ┃ ┃ ┃┃┗literal
 ┃┃ ┃ ┃ ┃┃ ┗integer ⇒ 1
 ┃┃ ┃ ┃ ┃┣, ⇒ ,
 ┃┃ ┃ ┃ ┃┗expr
 ┃┃ ┃ ┃ ┃ ┗bitExpr
 ┃┃ ┃ ┃ ┃ ┣expr
 ┃┃ ┃ ┃ ┃ ┃┗literal
 ┃┃ ┃ ┃ ┃ ┃ ┗integer ⇒ 1
 ┃┃ ┃ ┃ ┃ ┣& ⇒ &
 ┃┃ ┃ ┃ ┃ ┗expr
 ┃┃ ┃ ┃ ┃ ┗literal
 ┃┃ ┃ ┃ ┃ ┗integer ⇒ 1
 ┃┃ ┃ ┃ ┗) ⇒ )
 ┃┃ ┃ ┗; ⇒ ;
 ┃┃ ┗} ⇒ }
 ┃┗} ⇒ }
 ┗program
 ┣funcDef
 ┃┣type ⇒ float
 ┃┣id ⇒ test
 ┃┣( ⇒ (
 ┃┣funcValDef
 ┃┃┣type ⇒ int
 ┃┃┣id ⇒ a
 ┃┃┣, ⇒ ,
 ┃┃┗funcValDef
 ┃┃ ┣type ⇒ int
 ┃┃ ┗id ⇒ b
 ┃┣) ⇒ )
 ┃┣{ ⇒ {
 ┃┣noneAbleBlock
 ┃┃┗blocks
 ┃┃ ┗block
 ┃┃ ┗statement
 ┃┃ ┗return_S
 ┃┃ ┣return ⇒ return
 ┃┃ ┣expr
 ┃┃ ┃┗()Expr
 ┃┃ ┃ ┣( ⇒ (
 ┃┃ ┃ ┣type ⇒ float
 ┃┃ ┃ ┣) ⇒ )
 ┃┃ ┃ ┗expr
 ┃┃ ┃ ┗bracket
 ┃┃ ┃ ┣( ⇒ (
 ┃┃ ┃ ┣expr
 ┃┃ ┃ ┃┗add
 ┃┃ ┃ ┃ ┣expr
 ┃┃ ┃ ┃ ┃┗variable
 ┃┃ ┃ ┃ ┃ ┗id ⇒ a
 ┃┃ ┃ ┃ ┣+ ⇒ +
 ┃┃ ┃ ┃ ┗expr
 ┃┃ ┃ ┃ ┗variable
 ┃┃ ┃ ┃ ┗id ⇒ b
 ┃┃ ┃ ┗) ⇒ )
 ┃┃ ┗; ⇒ ;
 ┃┗} ⇒ }
 ┗program