编译原理课设

一、课程设计内容

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 分析动作(移进/归约)

private void outputProcess(Stack opStack, String signTemp, String[] strings, int index, String action)

4.8、流程图

 

五、测试数据设计

输入串：#(((a,a),x,(a)),a)#

六、程序输出结果分析

七、设计重点难点分析

八、参考文献

九、附录

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