LR(1)语法分析器生成器(生成Action表和Goto表)java实现(一)
序言 : 在看过<自己实现编译器链接器>源码之后,最近在看<编译器设计>,但感觉伪代码还是有点太浮空。没有掌握的感觉,也因为内网几乎没有LR(1)语法分析器生成器的内容,于是我就自己做了一个LR(1)语法分析器生成器。这个生成器除部分代码借鉴了<编译器设计>这本书有上的一些伪代码之外,其他皆为自己写的,可能不是那么完美,但也具有一些借鉴作用。在这里我会将我的思路以及实现代码全部都放在这个贴上。
说明 : 语法分析器生成器被称为编译器中的编译器,其方便快捷的特点使得在语法分析的过程中,许多编译器编写者在语法分析部分都喜欢采用的方法。语法分析器分为两类,一为生成语法分析器,其中包含生成表驱动语法分析器和生成代码语法分析器,二为手动编码语法分析器(顾明思意,手动编码就是自己写,具有可定制特殊语法的特点)。在这里是LR(1)表驱动语法分析器生成器。主要任务就是将BNF范式语句,转换为Action表和Goto表,然后编译器编写者利用这两个表来进行状态的转移去分析语法。
首先观看这贴所需 :
1) 了解 LR(1)的概念
2) 了解表驱动语法分析器的大概实现原理
3) 了解BNF范式
4) 了解FA(有限状态自动机)
5) 具有一定的数据结构与算法基础
我的LR(1)语法分析器生成器介绍 :
输入格式例子 :
start : <Goal>;
<Goal> ::= <Expr>;
<Expr> ::= <Term><Expr'>;
<Expr'> ::= "+" <Term><Expr'>
| "-" <Term><Expr'>
| "ε";
<Term> ::= <Factor><Term'>;
<Term'> ::= "*" <Factor><Term'>
| "/" <Factor><Term'>
| "ε";
<Factor> ::= "("<Expr>")"
| "num"
| "name";
#
首先,我的生成器采用的是标准输入(控制台输入),以#作为整个范式语句的结尾,这也是为了避免大量的代码去进行io操作之类的...在这里输入并非支持完整的BNF语法,而是取消了可选项[],和闭包{}等操作。可以将BNF范式以递归的形式代替闭包{},以枚举(或)的形式代替可选项。这也是为了避免出现太过复杂的数据形式去表示BNF范式。
输入符号类型集 : 终结符(T),非终结符(NT),定义符号(::=),或符号(|)。
特殊要求 :
1) 为了词法分析的便捷,对终结符,非终结符的输入作出了一定的限制 : 终结符被包含于""之内,非终结符被包含于<>之内。
2) 每句话以;结尾。
3) 利用start : <NT>;来确定目标(开始)非终结符符号。
4) 特殊终结谷 : 空 "ε",空是一个特殊的字符,也就是没有。
对于代码实现的第一步考虑即 : 如何将BNF范式语句字符串转换为一个中间格式的数据表示?
首先因为我将BNF削剪了,新语法的BNF产生式只需要利用一个NTNode来表示。因为每个产生式左端都为一个非终结符,而右端则用List<List<Integer>>来表示,所以每个NTNode包含这个非终结符的名称和这个List<List<Integer>>二维链表表示产生式右端。在这个List<List<Integer>>里,我是用一个整型来表示每个符号,首先我们可以先将终结符和非终结符映射在一张链表中,而这个表中的下标也就代表这个终结符或非终结符,但使用整型既可以表示终结符,也可以表示非终结符,这是怎么做到的呢？我采用一个 private static final int MASK = 0X80000000;来进行区分,如若这个符号是终结符,那么在表中我将其或上一个MASK,因为不可能有Integer.MAX_VALUE个T(终结符)或NT(非终结符),所以这必然是有效的。而当我们要访问时,即可通过这个链表中的元素来知道它是一个T还是NT,并且能找到它在对应的T链表或NT链表中的位置,在位置上记载这个符号的名称就可以得到它的名称了。又因为符号名称和符号所在下标是一个双射关系,所以我采用了一个Hash_Map来存储,非终结符Map,key : 非终结符名称,value : 非终结符在NTNode链表中的下标,终结符同理。这样就很好地用数据结构表示了BNF范式语句。
代码版本1.0 :
实现了将BNF字符串使用CodeAnalyzer类转换成BnfContainer。
package cn.vizdl.LR1;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;
/*
项目名 : LR(1) parser generator (LR(1)语法分析器生成器)
项目分析 :
输入 : 输入某文件内存地址。且内部采用 <Expr> ::= <Term> + <Factor>; 的结构输入的LR(1)语法。
这里的仅支持 BNF范式内部的 终结符,非终结符,或运算,;(表示产生式结束),::=(表示为定义为)
在这里不支持闭包,也就是{},因为闭包可以转换为非终结符的递归。
输入文本格式 :
start : <aim_name> //aim_name表示起始符号名称
例子 :
start : <Goal>;
<Goal> ::= <Expr>;
<Expr> ::= <Expr> "+" <Term> | <Expr> "-" <Term>;
<Term> ::= <Term> "*" <Factor> | <Term> "/" <Factor>;
<Factor> ::= "number";
#
以#作为结尾
输入分析 : 因为上下文无关语法是一个四元组,而LR(1)语法又是上下文无关语法的子集。所以采用四元组的形式来表示LR(1)语法,是不会损失信息的。
四元组 (T,NT,S,P)
T ： 终结符集合
NT : 非终结符集合
S : 语法的起始符号(非终结符)
P : 产生式集合
T, NT都可以用一个hash_set来表示。
P 可以分为两个部分,左侧一定是一个非终结符,右侧是一个支持或运算的产生式。
产生式左端可以使用Node节点来表示,产生式右端可以使用多个链表(具体有几个取决于当前产生式有多少个或运算符)来表示。
将当下语法分为三级,第一级是Expr,第二级别是Term,第三个级别是Factor
<Expr> ::= <Term> { "|" <Term>}; //产生式(表达式)可以表达成多个小句子 或 起来
<Term> ::= <Factor> { "+" <Factor>}; // + 表示连接
<Factor> ::= <T> | <NT>
输出 ：Action 和 GoTo 表。
*/
public class Demo {
public static void main (String[] args) {
//将输入的产生式都放入ch中
Scanner scanner = new Scanner(System.in);
String s = new String();
String c;
//输入处理...
while (true) {
c = scanner.nextLine();
int i;
for (i = 0; i < c.length(); i++) {
if (c.charAt(i) != '#')
s += c.charAt(i);
else {
scanner.close();
break;
}
}
if (i != c.length()) {
break;
}
}
//
BnfContainer bc = new BnfContainer();
CodeAnalyzer ca = new CodeAnalyzer(s, bc);
ca.analyze();
bc.printBNF();
}
}
/**
* 用来装载BNF范式的信息。
*/
class BnfContainer {
/**
* 内部类,NT的节点。
* @author HP
*/
class NTNode {
private String name; //符号id
private List<List<Integer>> expr;
public NTNode(String name) {
expr = new ArrayList<List<Integer>>();
this.name = name;
}
/**
* 添加一条expr
* 返回这个expr的下标
* @return
*/
public int addExpr() {
expr.add(new ArrayList<Integer>());
return expr.size() - 1;
}
/**
* 向下标为idx的expr添加value
* @param idx
* @param value
*/
public void addExprElement (int idx, int value) {
this.expr.get(idx).add(value);
}
/**
* 向最后一个表达式添加value
* @param value
*/
public void addExprElement (int value) {
this.addExprElement(this.expr.size() - 1, value);
}
public void printNTNode () {
System.out.println("NTNumber : " + this.name);
for (List<Integer> list : this.expr) {
for (Integer val : list) {
System.out.print(val + " ");
}System.out.println();
}
}
}
//常量定义
/**
* 这两个常量只出现在终结符
* 因为要将终结符和非终结符
* 放在同一个链表中
* 所以使用这个来辨别终结符和非终结符。
*/
private static final int MASK = 0X80000000; //掩码,用来给终结符做掩饰的编码。
private static final int DECODE = 0X7fffffff; //解码,破译掩码得到原本的编码。
/**
* 非终结符Map
* key : 非终结符名称
* value : 非终结符在production链表中的下标
*/
private HashMap<String,Integer> NTMap;
/**
* 终结符Map
* key : 终结符名称
* value : 终结符在T链表中的下标
*/
private HashMap<String,Integer> TMap;
// 终结符链表
private ArrayList<String> T;
// 产生式链表,因为一个非终结符一个产生式具有双射关系。
private ArrayList<NTNode> production;
//如若未设置,默认为0
public int startIndex = 0;
public BnfContainer() {
//内部数据结构初始化
NTMap = new HashMap<String,Integer>();
TMap = new HashMap<String,Integer>();
T = new ArrayList<String>();
production = new ArrayList<NTNode>();
}
/**
* 设置开始非终结符
* @param name
*/
public void setStart (String name) {
this.addNT(name);
this.startIndex = this.NTMap.get(name);
}
/**
* 将非终结符的名字传入,即可添加一个非终结符节点。
* @param name
*/
public void addNT (String name) {
if (name.isEmpty()) {
System.out.println("终结符不可为空");
System.exit(-1);
}
if (!NTMap.containsKey(name)) {
NTNode node = new NTNode(name);
NTMap.put(name, production.size());
production.add(node);
}
}
/**
* 将终结符传入,增加非终结符。
* @param name
*/
public void addT(String name) {
if (!this.TMap.containsKey(name)) {
this.TMap.put(name, T.size());
//System.out.println(name);
this.T.add(name);
}
}
/**
* 输入终结符名称
* 获取终结符编号
* 如若存在当前终结符,返回编号
* 否则返回-1,输出错误警告并且退出。
* @param name
* @return
*/
private int getTSerialNumber (String name) {
this.notFindTWarning(name);
return this.TMap.get(name) | BnfContainer.MASK;
}
/**
* 输入非终结符名称
* 获取非终结符编号
* 如若存在当前非终结符,返回编号
* 否则返回-1,输出错误警告并且退出。
* @param name
* @return
*/
private int getNTSerialNumber (String name) {
this.notFindNTWarning(name);
return this.NTMap.get(name);
}
/**
* 创建新的表达式并添加到名称为name的非终结符节点上
* 返回表达式编号
*/
public int creatNewExper(String name) {
this.notFindNTWarning(name);
NTNode ntn = this.production.get(this.NTMap.get(name));
return ntn.addExpr();
}
/**
* 向左端非终结符名称为name的产生式
* 第idx表达式添加元素
* @param name
* @param idx
* @param isNt
*/
public void addExpeElement(String name, int idx,boolean isNt, String addElement) {
NTNode ntn = this.production.get(this.NTMap.get(name));
if (isNt) {
this.notFindNTWarning(name);
this.notFindNTWarning(addElement);
ntn.addExprElement(idx, this.getNTSerialNumber(addElement));
}else {
this.addT(addElement);
ntn.addExprElement(idx, this.getTSerialNumber(addElement));
}
}
/**
* 向左端非终结符名称为name的产生式
* 最后一个表达式添加元素
* @param name
* @param list
*/
public void addExpeElement(String name,boolean isNt, String addElement) {
NTNode ntn = this.production.get(this.NTMap.get(name));
if (isNt) {
this.notFindNTWarning(name);
this.notFindNTWarning(addElement);
ntn.addExprElement(this.getNTSerialNumber(addElement));
}else {
this.addT(addElement);
ntn.addExprElement(this.getTSerialNumber(addElement));
}
}
/**
* 如若找到了当前非终结符,什么都不会发生。
* 否则会提示并且退出程序
* @param name
*/
private void notFindNTWarning(String name) {
if (!this.NTMap.containsKey(name)) {
System.out.println("错误的非终结符" + name + "!");
System.exit(-1);
}
}
/**
* 如若找到了当前终结符,什么都不会发生。
* 否则会提示并且退出程序
* @param name
*/
private void notFindTWarning(String name) {
if (!this.TMap.containsKey(name)) {
System.out.println("错误的终结符" + name + "!");
System.exit(-1);
}
}
public void printBNF() {
System.out.println("开始非终结符为 : " + this.production.get(startIndex).name);
System.out.println("终结符对应表 : ");
for (int i = 0; i < this.T.size(); i++) {
System.out.println(this.T.get(i) + " : " + (i | MASK));
}
System.out.println("非终结符对应表 : ");
for (int i = 0; i < this.production.size(); i++) {
System.out.println(this.production.get(i).name + " : " + i);
}
for (NTNode ntn : this.production) {
ntn.printNTNode();
}
}
}
/**
* 代码分析器
* 可以将代码转换为信息等价的数据结构
*/
class CodeAnalyzer {
class Token{
boolean isNt;
String name;
public Token (boolean isNt, String name) {
this.isNt = isNt;
this.name = name;
}
}
private char[] text;
private int textSize = 0; //字符串有效长度
private int point = 0; //text解析进度的指针
private BnfContainer bc;
private Token token;
String left; //左侧非终结符
private int count = 0; //记录当前已经解析到哪个产生式了
public CodeAnalyzer (String text, BnfContainer bc) {
this.bc = bc;
//初始化代码分析器
this.initText(text);
this.initStartSymbol();
this.initCodeAnalyzer();
}
/**
* 输入字符串文本,返回处理完毕的字符数组。
* @param s
* @return
*/
private void initText(String s) {
this.text = s.toCharArray();
int idx = 0;
//将字符串变为一个紧凑的字符数组(去除一些妨碍的字符)
while (idx < text.length) {
if (text[idx] == '\r' || text[idx] == '\n' || text[idx] == '\t' || text[idx] == ' ') {
idx++;
}else {
text[textSize++] = text[idx++];
}
}
}
private void initStartSymbol() {
// 验证是否存在start:<
point = 0;
char[] needle = { 's', 't', 'a', 'r', 't', ':', '<' };
if (textSize <= needle.length) {
this.notFindStartNT();
}
point = 0;
while (point < needle.length) {
if (needle[point] == text[point]) {
point++;
} else {
this.notFindStartNT();
}
}
point = needle.length;
while (point < textSize && text[point] != '>') {
point++;
}
this.bc.setStart(new String(text, needle.length, point - needle.length));
this.skip(Type.RT);
this.skip(Type.SEMICOLON);
}
/**
* 通过skip来跳过字符
*/
enum Type{
LT, //左尖括号
RT, //右尖括号
SEMICOLON, //分号
QUOTE, //双引号
OR, //或
COLON, // :
EQ, //等于号
}
private void skip (Type t) {
switch(t) {
case LT:
this.skip('<');
break;
case RT:
this.skip('>');
break;
case OR:
this.skip('|');
break;
case SEMICOLON:
this.skip(';');
break;
case QUOTE:
this.skip('"');
break;
case COLON:
this.skip(':');
break;
case EQ:
this.skip('=');
break;
}
}
private void skip (char c) {
if (point >= this.textSize || this.text[point] != c) {
System.out.println("第" + this.count + "个产生式,缺少符号 " + c);
System.exit(-1);
}
point++;
}
/**
* 报错 : 没有找到目标(开始)非终结符号! 并退出程序。
*/
private void notFindStartNT() {
System.out.println("没有找到目标非终结符号!");
System.exit(-1);
}
/**
* 之所以一开始就要添加非终结符,而不在解析BNF时候添加
* 是因为,非终结符存在定义的问题,如若 没有定义
* 但有使用(只在右侧出现,未在左侧定义),这个就是错误的。
*/
private void initCodeAnalyzer() {
int idx = this.point;
this.point = 0;
this.count = 0;
while (true) {
while (this.point < textSize && text[this.point] != ';') {
this.point++;
}this.point++;
this.count++;
//如若分号后面没有左括号
if (this.point >= textSize) {
break;
}
String name = this.getNT();
bc.addNT(name);
}this.count = 0;
this.point = idx;
}
/**
* BNF
* 从point开始解析字符串。
* <Goal> ::= {<Production>}
* <Production> ::= <左侧非终结符> "::=" <Expr>;
* <Expr> ::= <Term> { "|" <Term>}";";
* <Term> ::= {<Factor>}; //Term在这就是多个终结符或非终结符相连接
* <Factor> ::= <T> | <NT>
*/
public void analyze() {
while (point < this.textSize) {
this.count++;
production();
}
}
public void production(){
//先跳过左侧非终结符
this.left = this.getNT();
this.skipDefineSymol();
this.expr();
}
/**
* 跳过 ::=
*/
public void skipDefineSymol() {
skip(Type.COLON);
skip(Type.COLON);
skip(Type.EQ);
}
/**
* 获取非终结符
* <xxx>
*/
public String getNT () {
skip(Type.LT);
StringBuilder res = new StringBuilder();
while (this.point < this.textSize && text[this.point] != '>') {
res.append(text[this.point++]);
}
skip(Type.RT);
return res.toString();
}
/**
* 当前指针指向 "T" 中第一个"
* @return
*/
public String getT() {
this.skip(Type.QUOTE);
StringBuilder res = new StringBuilder();
while (this.point < this.textSize && this.text[this.point] != '"') {
res.append(text[this.point++]);
}
this.skip(Type.QUOTE);
return res.toString();
}
/**
* 当前指针指向 ::= <T>... 中 = 后一个符号
*/
public void expr(){
this.term();
while (this.point < this.textSize && text[this.point] == '|') {
this.skip(Type.OR);
term();
}this.skip(Type.SEMICOLON);
}
/**
* 如若还有符号,当前符号指向 终结符或非终结符的符号 < 或者 "
*/
public void term(){
//创建一个属于当前term的链表
bc.creatNewExper(this.left);
while (this.point < this.textSize && (text[this.point] == '"' || text[this.point] == '<')) {
factor();
bc.addExpeElement(this.left, token.isNt, token.name);
}
}
/**
* 通过factor获取token
*/
public void factor(){
//非终结符
if (text[this.point] == '"') {
String name = this.getT();
this.token = new Token(false, name);
}else {
String name = this.getNT();
token = new Token (true, name);
}
}
}
下一篇完整代码连接 : https://www.cnblogs.com/vizdl/p/11331278.html
