锐客网

  1. 首页 > it技术 > >

java|编译原理课设

javac

一、课程设计内容
1.1、前置条件：有效文法及正确的算符优先表
1.2、功能需求：根据文法及算符优先表，实现算符优先分析过程，输入串采用教材133页习题2中（2）中的字符串（#(((a,a),x,(a)),a)#）。
1.3、开发环境： Java(jdk1.8)
Windows 10
二、数据结构设计
2.1、类
2.1.1、文法对象类
public class Grammar {
private String left;
private String right;
public Grammar(String l, String r) {
this.left = l;
this.right = r;
}
public String getLeft() {
return left;
}
public String getRight() {
return right;
}
}
2.1.2、文法集合对象
public class GrammarList {
private List list = new ArrayList<>();
private List leftList = new ArrayList<>();
private List rightList = new ArrayList<>();
public void addGrammar(Grammar grammar) {
leftList.add(grammar.getLeft());
rightList.add(grammar.getRight());
list.add(new Grammar(grammar.getLeft(), grammar.getRight()));
}
public List getGrammarList() {
return list;
}
public List getLeftList() {
return leftList;
}
public List getRightList() {
return rightList;
}
}
2.2、全局变量
2.2.1、当前操作符
String signTemp
2.2.2、符号栈
Stack signStack
2.2.3、字符串栈
Stack opStack
2.2.4、分析步骤计数
int num
三、程序总体设计
public class Main {
public static void main(String[] args) {
Priority[][] matrix = MakeMatrix.getMatrix();
Map keyMap = MakeMatrix.getKeyMap();
// 1、输入字符串
String str = "#(((a,a),x,(a)),a)#"; // ^ 用x代替
String[] strings = str.split("");
// 2、创建文法
Grammar grammar0 = new Grammar("S", "a");
Grammar grammar1 = new Grammar("S", "x");
Grammar grammar2 = new Grammar("S", "(R)");
Grammar grammar3 = new Grammar("T", "S,T");
Grammar grammar4 = new Grammar("T", "S");
Grammar grammar5 = new Grammar("R", "T");
// 3、添加文法
GrammarList list = new GrammarList();
list.addGrammar(grammar0);
list.addGrammar(grammar1);
list.addGrammar(grammar2);
list.addGrammar(grammar3);
list.addGrammar(grammar4);
list.addGrammar(grammar5);
// 4、算符优先分析
Analyse runner = new Analyse();
runner.analyse(list, matrix, keyMap, strings);
}
}
四、详细设计
4.1、向文法集合中添加文法
public void addGrammar(Grammar grammar)
4.2、获取文法集合
public List getGrammarList()
4.3、获取算符优先矩阵
public static Priority[][] getMatrix()
4.4、获取终结符对应行列
public static Map getKeyMap()
4.5、进行算符优先分析
GrammarList list 文法集合
Priority[][] matrix 算符优先矩阵
Map keyMap 终结符行列号
String[] strings 输入串
public void analyse(GrammarList list, Priority[][] matrix, Map keyMap, String[] strings)
4.6、规约函数
String now 规约串
private boolean gy(String now, GrammarList list)
4.7、打印信息
Stack opStack 字符串栈
String signTemp 符号栈顶元素
int index 分析步骤序号
String action 分析动作(移进/归约)
【java|编译原理课设】private void outputProcess(Stack opStack, String signTemp, String[] strings, int index, String action)
4.8、流程图
java|编译原理课设
文章图片


五、测试数据设计
输入串：#(((a,a),x,(a)),a)#
六、程序输出结果分析
java|编译原理课设
文章图片

七、设计重点难点分析
八、参考文献
九、附录
9.1、Main.class
import analysestring.Analyse;
import enums.Priority;
import grammar.Grammar;
import grammar.GrammarList;
import makematrix.MakeMatrix;
import java.util.Map;

public class Main {
public static void main(String[] args) {
Priority[][] matrix = MakeMatrix.getMatrix();
Map keyMap = MakeMatrix.getKeyMap();
String str = "#(((a,a),x,(a)),a)#"; // ^ 用x代替
String[] strings = str.split("");

Grammar grammar0 = new Grammar("S", "a");
Grammar grammar1 = new Grammar("S", "x");
Grammar grammar2 = new Grammar("S", "(R)");
Grammar grammar3 = new Grammar("T", "S,T");
Grammar grammar4 = new Grammar("T", "S");
Grammar grammar5 = new Grammar("R", "T");

GrammarList list = new GrammarList();
list.addGrammar(grammar0);
list.addGrammar(grammar1);
list.addGrammar(grammar2);
list.addGrammar(grammar3);
list.addGrammar(grammar4);
list.addGrammar(grammar5);

Analyse runner = new Analyse();
runner.analyse(list, matrix, keyMap, strings);
}
}
9.2、Grammar.class
public class Grammar {
private String left;
private String right;

public Grammar(String l, String r) {
this.left = l;
this.right = r;
}

public String getLeft() {
return left;
}

public String getRight() {
return right;
}
}
9.3、GrammarList.class
import java.util.ArrayList;
import java.util.List;

public class GrammarList {
private List list = new ArrayList<>();
private List leftList = new ArrayList<>();
private List rightList = new ArrayList<>();

public void addGrammar(Grammar grammar) {
leftList.add(grammar.getLeft());
rightList.add(grammar.getRight());
list.add(new Grammar(grammar.getLeft(), grammar.getRight()));
}

public List getGrammarList() {
return list;
}

public List getLeftList() {
return leftList;
}

public List getRightList() {
return rightList;
}
}
9.4、Priority.class
public enum Priority {
NULL(0, "无关系"),
SMALL(1, "小于"),
EQUAL(2, "等于"),
BIG(3, "大于");

private int state;
private String stateInfo;

private Priority(int state, String stateInfo) {
this.state = state;
this.stateInfo = stateInfo;
}

public int getState() {
return this.state;
}

public String getStateInfo() {
return this.stateInfo;
}
}
9.5、MakeMatrix.class
import enums.Priority;
import java.util.HashMap;
import java.util.Map;

public class MakeMatrix {
private static Map key = new HashMap<>();

static {
key.put("a", 0);
key.put("x", 1);
key.put("(", 2);
key.put(")", 3);
key.put(",", 4);
key.put("#", 5);
}

private static Priority[][] operationMatrix = {
{Priority.NULL, Priority.NULL, Priority.NULL, Priority.BIG, Priority.BIG, Priority.BIG},
{Priority.NULL, Priority.NULL, Priority.NULL, Priority.BIG, Priority.BIG, Priority.BIG},
{Priority.SMALL, Priority.SMALL, Priority.SMALL, Priority.EQUAL, Priority.SMALL, Priority.NULL},
{Priority.NULL, Priority.NULL, Priority.NULL, Priority.BIG, Priority.BIG, Priority.BIG},
{Priority.SMALL, Priority.SMALL, Priority.SMALL, Priority.BIG, Priority.SMALL, Priority.NULL},
{Priority.SMALL, Priority.SMALL, Priority.SMALL, Priority.NULL, Priority.NULL, Priority.NULL}};

public static Priority[][] getMatrix() {
return operationMatrix;
}

public static Map getKeyMap() {
return key;
}
}
9.6、Analyse.class
import enums.Priority;
import grammar.Grammar;
import grammar.GrammarList;

import java.util.List;
import java.util.Map;
import java.util.Stack;

public class Analyse {
private String signTemp = new String("");
private Stack signStack = new Stack<>();
private Stack opStack = new Stack<>();
private int num = 0;

public void analyse(GrammarList list, Priority[][] matrix, Map keyMap, String[] strings) {
for (int i = 0; i < strings.length; i++) {
if (i == 0) {
opStack.push(strings[i]);
signStack.push(strings[i]);
signTemp = strings[i];
outputProcess(opStack, signTemp, strings, i + 1, "开始");
continue;
}
if (strings[i].equals(strings[0])) {
outputProcess(opStack, signTemp, strings, i, "结束");
System.out.println("程序结束");
break;
}
int v1 = keyMap.get(signTemp);
int v2 = keyMap.get(strings[i]);
if (matrix[v1][v2].equals(Priority.BIG)) { // 大于 则规约
String now = opStack.peek(); // 取出单字符大小的字符串
if (signStack.peek().equals(",")) {
if (now.equals("S")) {
// 用 T -> S 规约
outputProcess(opStack, signTemp, strings, i, "归约");
if (!gy(now, list)) {
break;
}
i--;
continue;
}
if (now.equals("T")) {
// 用T -> S,T 规约
outputProcess(opStack, signTemp, strings, i, "归约");
StringBuilder sb = new StringBuilder();
sb.append(opStack.pop());
sb.append(opStack.pop());
sb.append(opStack.peek());
if (!gy(new String(sb.reverse()), list)) {
break;
}
i--;
continue;
}
}
if (now.equals("T")) {
if (signTemp.equals("(")) {
outputProcess(opStack, signTemp, strings, i, "归约");
if (!gy(now, list)) {
break;
}
i--;
continue;
}
}
outputProcess(opStack, signTemp, strings, i, "归约");
if (!gy(now, list)) {
break;
}
i--;
} else if (matrix[v1][v2].equals(Priority.SMALL)) { // 小于 则移进

outputProcess(opStack, signTemp, strings, i, "移进");
opStack.push(strings[i]);
signStack.push(strings[i]);
signTemp = signStack.peek();
} else if (matrix[v1][v2].equals(Priority.EQUAL)) { // 去括号
StringBuilder sb = new StringBuilder();
while (!opStack.peek().equals("R")) {
outputProcess(opStack, signTemp, strings, i, "归约");
gy(opStack.peek(), list);
}
outputProcess(opStack, signTemp, strings, i, "移进");
opStack.push(strings[i]);
signStack.push(strings[i]);
signTemp = signStack.peek();
outputProcess(opStack, signTemp, strings, i + 1, "归约");
signStack.pop();
signTemp = signStack.peek();
sb.append(opStack.pop());
sb.append(opStack.pop());
sb.append(opStack.peek());
if (!gy(new String(sb.reverse()), list)) {
break;
}
continue;
} else { // Priority.NULL出错
System.out.println("规约出错Priority.NULL");
break;
}
}
}

private boolean gy(String now, GrammarList list) {
List grammars = list.getGrammarList();
if (list.getRightList().contains(now)) {
for (int j = 0; j < grammars.size(); j++) {
String right = grammars.get(j).getRight();
if (right.equals(now)) {
opStack.pop();
opStack.push(grammars.get(j).getLeft());
if (right.equals("T") || right.equals("S")) { // 当T->S 和R->T时无关符号
break;
}
signStack.pop();
signTemp = signStack.peek();
break;
}
}
return true;
} else {
System.out.println("规约出错: 找不到规约串");
return false;
}
}

private void outputProcess(Stack opStack, String signTemp, String[] strings, int index, String action) {
if (num == 0) {
System.out.println("步骤栈当前符号剩余符号动作");
}
StringBuilder sbStack = new StringBuilder();
StringBuilder sbStrs = new StringBuilder();
Stack temp = new Stack<>();
while (!opStack.isEmpty()) {
temp.push(opStack.pop());
}
while (!temp.isEmpty()) {
sbStack.append(temp.peek());
opStack.push(temp.pop());
}
for (int i = index; i < strings.length; i++) {
sbStrs.append(strings[i]);
}
num++;
System.out.printf("%-5d" + "" + "%-20s" + "" + "%-10s" + "" + "%-20s" + "" + action + "\n", num, sbStack, signTemp, sbStrs, action);
}
}
转载于:https://www.cnblogs.com/GG-Bond/p/11220979.html

    推荐阅读


    上一篇：SpringBoot的入门搭建（五）

    下一篇：玩转Android嵌套滚动