编译原理-仅供参考

最新推荐文章于 2023-12-17 21:09:31 发布
最新推荐文章于 2023-12-17 21:09:31 发布
阅读量487 收藏 5
点赞数 3
分类专栏： Java 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43821834/article/details/119730351
版权

实验目的

1）理解LR（0）分析的原理；

2）掌握LR（0）分析识别符号串的方法；

3）掌握LR（0）分析表的运用；

4）能够编写程序实现LR（0）语法分析；

实验要求：

1）理解和掌握LR(0)文法的判断和分析过程。

2）本实验要求设计一个LR(0)语法分析程序。

3）本实验要求自己独立完成,不允许抄袭别人的实验结果。

4）用C#或JAVA语言实现；

实验报告以及实验程序的提交：

1）在实验任务截止时间以前将实验程序和实验报告的word文档打包上传超星网络教学平台。

2）每个同学的文件压缩包命名为：学号_姓名_5.rar

3）压缩包中应包含两个文件夹，一个存放程序，另一个存放实验报告的word文件。

实验内容：

1．设计LR(0)语法分析程序。

选择课本P136的文法和P136的LR(0)分析表

2．应用设计的分析程序对输入串bccd#进行一次LR(0)分析，并输出分析过程和结果(如P137的表6.4所示)

检验分析程序的正确性。

设计要求：

（1）为了方便文法的输入，将产生式中的“->”可以由“：”

（2）对于非终结符和终结符可以用一维数组VN[100]和VT[100]存储，对于文法G[S]可以由二维数组G[100][100]存储，对于LR(1)的动作表和转换表分别由ACTION和GOTO数组表示。

（3）LR(0)分析表为课本P136的表6.3。

主要分析流程如下:

置ip指向输入串w的第一个符号

令S为栈顶状态

a是ip指向的符号

重复 begin

if ACTION[S,a]=Sj

then

begin PUSH j,a(进栈)

           ip 前进(指向下一输入符号)

    end

else

if ACTION[S,a]=rj (用第j条产生式归约A->e)

then

begin

按产生式|e|的长度，

将对应的符号和状态出栈

令当前栈顶状态为S’

push GOTO[S’,A]和A(进栈)

end

else

if ACTION[s,a]=acc

then

return (成功）

else

error

end.

重复

public class Main {

    //非终结符
    private static final String[] vn = new String[]{"S\\'", "A", "B", "E"};

    //终结符
    private static final String[] vt = new String[]{"a", "b", "c", "d", "#"};

    //状态栈
    private static final Stack<String> state = new Stack();

    //符号栈
    private static final Stack<String> symbol = new Stack();

    //输入栈
    private static final Stack<Character> input = new Stack();

    //文法
    private static final List<String> grammar = new ArrayList<>();

    private static final HashMap<String, String> grammarMap = new HashMap<>();

    //分析表
    private static final HashMap<String, HashMap<String, String>> analysisTable = new HashMap<>();

    //初始化数据
    public static void initData() {
        grammar.add("S\\':E");
        grammar.add("E:aA");
        grammar.add("E:bB");
        grammar.add("A:cA");
        grammar.add("A:d");
        grammar.add("B:cB");
        grammar.add("B:d");

        HashMap<String, String> zero = new HashMap<>() {
            {
                put("a", "S2");
                put("b", "S3");
                put("c", "null");
                put("d", "null");
                put("#", "null");
                put("E", "1");
                put("A", "null");
                put("B", "null");
            }
        };

        HashMap<String, String> one = new HashMap<>() {
            {
                put("a", "null");
                put("b", "null");
                put("c", "null");
                put("d", "null");
                put("#", "acc");
                put("E", "null");
                put("A", "null");
                put("B", "null");
            }
        };

        HashMap<String, String> two = new HashMap<>() {
            {
                put("a", "null");
                put("b", "null");
                put("c", "S4");
                put("d", "S10");
                put("#", "null");
                put("E", "null");
                put("A", "6");
                put("B", "null");
            }
        };

        HashMap<String, String> three = new HashMap<>() {
            {
                put("a", "null");
                put("b", "null");
                put("c", "S5");
                put("d", "S11");
                put("#", "null");
                put("E", "null");
                put("A", "null");
                put("B", "7");
            }
        };

        HashMap<String, String> four = new HashMap<>() {
            {
                put("a", "null");
                put("b", "null");
                put("c", "S4");
                put("d", "S10");
                put("#", "null");
                put("E", "null");
                put("A", "8");
                put("B", "null");
            }
        };

        HashMap<String, String> five = new HashMap<>() {
            {
                put("a", "null");
                put("b", "null");
                put("c", "S5");
                put("d", "S11");
                put("#", "null");
                put("E", "null");
                put("A", "null");
                put("B", "9");
            }
        };

        HashMap<String, String> six = new HashMap<>() {
            {
                put("a", "r1");
                put("b", "r1");
                put("c", "r1");
                put("d", "r1");
                put("#", "r1");
                put("E", "null");
                put("A", "null");
                put("B", "null");
            }
        };

        HashMap<String, String> seven = new HashMap<>() {
            {
                put("a", "r2");
                put("b", "r2");
                put("c", "r2");
                put("d", "r2");
                put("#", "r2");
                put("E", "null");
                put("A", "null");
                put("B", "null");
            }
        };

        HashMap<String, String> eight = new HashMap<>() {
            {
                put("a", "r3");
                put("b", "r3");
                put("c", "r3");
                put("d", "r3");
                put("#", "r3");
                put("E", "null");
                put("A", "null");
                put("B", "null");
            }
        };

        HashMap<String, String> nine = new HashMap<>() {
            {
                put("a", "r5");
                put("b", "r5");
                put("c", "r5");
                put("d", "r5");
                put("#", "r5");
                put("E", "null");
                put("A", "null");
                put("B", "null");
            }
        };

        HashMap<String, String> ten = new HashMap<>() {
            {
                put("a", "r4");
                put("b", "r4");
                put("c", "r4");
                put("d", "r4");
                put("#", "r4");
                put("E", "null");
                put("A", "null");
                put("B", "null");
            }
        };

        HashMap<String, String> eleven = new HashMap<>() {
            {
                put("a", "r6");
                put("b", "r6");
                put("c", "r6");
                put("d", "r6");
                put("#", "r6");
                put("E", "null");
                put("A", "null");
                put("B", "null");
            }
        };

        analysisTable.put("0", zero);
        analysisTable.put("1", one);
        analysisTable.put("2", two);
        analysisTable.put("3", three);
        analysisTable.put("4", four);
        analysisTable.put("5", five);
        analysisTable.put("6", six);
        analysisTable.put("7", seven);
        analysisTable.put("8", eight);
        analysisTable.put("9", nine);
        analysisTable.put("10", ten);
        analysisTable.put("11", eleven);
    }

    public static void main(String[] args) {
        initData();
        String content = "";
        Scanner scanner = new Scanner(System.in);
        ArrayList<Character> characters = new ArrayList<>();
        while (true) {
            symbol.clear();
            state.clear();
            symbol.push("#");
            state.push("0");
            System.out.println("请输入需要分析的字符串(请不要包含空格，请以#结尾):");
            content = scanner.nextLine();
            characters.clear();
            for (int i = 0; i < content.length(); i++) {
                characters.add(content.charAt(i));
            }
            input.clear();
            for (int i = characters.size() - 1; i >= 0; i--) {
                input.push(content.charAt(i));
            }
            if (inputIsLegal()) {
                System.out.println(String.format("%-10s", "步骤") + String.format("%-10s", "状态栈") + String.format("%-10s", "符号栈") + String.format("%-10s", "输入串") + String.format("%-10s", "ACTION") + String.format("%-10s", "GOTO"));
                analysisContent();
            } else {
                System.out.println("输入非法!!!!");
            }
        }
    }

    static public void analysisContent() {
        Character temp = 'Q';
        String temp3 = "";
        String result = "";
        String stateString = "";
        int steps = 0;
        while (true) {
            //输入栈 栈顶元素
            steps++;
            temp = input.peek();
            //输入串栈顶元素
            temp3 = String.valueOf(temp);
            //栈顶状态
            stateString = state.peek();

            result = analysisTable.get(stateString).get(temp3);
            if (result.equals("null")) {
                showResult(steps, "报错", "报错");
                break;
            }
            //使用action  移进
            else if (result.contains("S")) {
                showResult(steps, result, "");
                state.push(result.substring(1));
                symbol.push(temp3);
                input.pop();
                continue;
            }
            //使用goto
            else if (result.replaceAll("%d", "").length() == 0) {
                continue;
            } else if (result.equals("acc")) {
                if (symbol.size() == 2 && input.size() == 1) {
                    showResult(steps, result, "");
                    break;
                }
                continue;
            }
            //规约
            else if (result.contains("r")) {
                String tempGrammar = grammar.get(Integer.parseInt(result.substring(1)));
                String[] tempArray = tempGrammar.split(":");
                Stack<String> tempState = new Stack<>();
                Stack<String> tempSymbol = new Stack<>();
                for (int i = 0; i < state.size(); i++) {

                    tempState.push(state.get(i));
                }
                for (int i = 0; i < symbol.size(); i++) {
                    tempSymbol.push(symbol.get(i));
                }
                for (int i = 0; i < tempArray[1].length(); i++) {
                    tempState.pop();
                    tempSymbol.pop();
                }
                stateString = tempState.peek();
                String gotoResult = analysisTable.get(stateString).get(tempArray[0]);
                showResult(steps, result, gotoResult);
                tempSymbol.push(tempArray[0]);
                tempState.push(gotoResult);
                state.clear();
                symbol.clear();
                for (int i = 0; i < tempState.size(); i++) {
                    state.push(tempState.get(i));
                }
                for (int i = 0; i < tempSymbol.size(); i++) {
                    symbol.add(tempSymbol.get(i));
                }
                continue;
            } else {
                continue;
            }

        }
    }

    static public void showResult(int steps, String action, String goTo) {
        System.out.println();
        String id = steps + "";
        id = String.format("%-10s", id);
        System.out.print(id);
        browseState();
        browseAnalysis();
        browseInput();
        System.out.print(String.format("%-10s", action));
        System.out.print(String.format("%-10s", goTo));
        System.out.println();
    }

    static public void browseAnalysis() {
        String analysisStr = "";
        for (int i = 0; i < symbol.size(); i++) {
            analysisStr = analysisStr + symbol.get(i) + "";
        }
        analysisStr = String.format("%-10s", analysisStr);
        System.out.print(analysisStr);
        System.out.print("   ");
    }

    static public void browseState() {
        String stateStr = "";
        for (int i = 0; i < state.size(); i++) {
            stateStr = stateStr + state.get(i) + "";
        }
        stateStr = String.format("%-10s", stateStr);
        System.out.print(stateStr);
        System.out.print("   ");
    }

    static public void browseInput() {
        String inputStr = "";
        for (int i = 0; i < input.size(); i++) {
            inputStr = inputStr + input.get(input.size() - i - 1) + "";
        }
        inputStr = String.format("%-10s", inputStr);
        System.out.print(inputStr);
        System.out.print("   ");
    }

    static public boolean inputIsLegal() {
        boolean flag = false;
        int num = 0;
        for (Character character : input) {
            num++;
            for (String s : vt) {
                if (String.valueOf(character).equals(s)) {
                    flag = true;
                }
            }
            if (!flag) {
                return flag;
            }
            if (num == input.size()) {
                return flag;
            } else {
                flag = false;
            }
        }
        return false;
    }

}
♬ 烟消云散♪…
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编译原理 一、编译原理概述
shenginx的博客
09-09 306
什么是编译程序 从功能上看，一个编译程序就是一个语言翻译程序，它把一种语言（源语言）翻译成另一种语言（目标语言）。 编译过程概述 编译的过程：词法分析 -> 语法分析 -> 语义分析 -> 中间代码生成 -> 代码优化 -> 目标代码生成。 词法分析：扫描、分解源程序，识别单词（基本字、标识符、常数、运算符、界限符），并给予种别（属性）和内部形式（值），构成单词的内部表示。 语法分析：词法分析的基础上将单词序列分解成各类语法短语，如程序，语句 ，表达式等等。一般这种语法短语，也
编译原理之概述
李达
10-04 3276
正在学文法，单纯学文法，不知其所属、不知其用，学的实在是难受，其实文法是编译原理中编译原理的一部分，所以从编译原理开始学，先从高处看这些知识，对这些知识有宏观的把控，在细学其中的知识点，即“自上而下、逐级分解” 。     编译原理的职能是把程序设计语言的程序翻译为等价的机器语言程序，包括语言和文法、词法分析、语法分析、语法制导翻译、中间代码生成、存储管理、代码优化和目标代码生成，各部分之间的关
编译原理课程设计——基于LR（0）方法的语法分析程序
07-20
计算机专业编译原理课程设计 基于LR（0）方法的语法分析程序
编译原理
太阳
05-06 518
【文法】 分类 设G=（VN，VT，P，S），如果它的每个产生式α→β是这样一种结构：α∈(VN∪VT)且至少含有一个非终结符，而β∈(VN∪VT)，则G是一个0型文法。 0型文法也称短语文法。一个非常重要的理论结果是： 0型文法的能力相当于图灵机(Turing)。或者说，任何0型文语言都是递归可枚举的，反之，递归可枚举集必定是一个0型语言。0型文法是这几类文法中，限制最少的一个，所以...
编译原理--实验3-基于-LR(0)方法的语法分析
weixin_45775703的博客
04-02 4799
文章目录前言1.1实验目的1.2 实验任务1.3 实验内容1.3.1 输入格式：1.3.2 输出格式：1.3.3 样例1.4 程序1.4.1 程序流程图1.4.2 算法描述1.4.3 程序源码 前言 编译原理课程实验的实验课内容—构造自底向上LR（0）的语法分析程序。通过本次实验，可以熟练掌握对于LR(0)分析表的构造方法。 1.1实验目的 （1）掌握 LR(0)分析表的构造方法。 （2）掌握设计、编制和调试典型的语法分析程序，进一步掌握常用的语法分析方法。 （3）理解语法分析在编译程序中的作用。 1.2
编译原理-实验四-LR(0)语法分析程序的设计
wys5的博客
12-20 3万+
一、实验目的 了解LR(0)语法分析算法的基本思想，掌握LR(0)语法分析程序的构造方法。 二、实验内容 根据LR(0)语法分析算法的基本思想，设计一个对给定文法进行LR(0)语法分析的程序，并用C、C++或Java语言编程实现。要求程序能够对从键盘输入的任意字符串进行分析处理，判断出该输入串是否是给定文法的有效句子，并针对该串给出具体的LR(0)语法分析过程。 三、实验要求 1、已知文...
实验三 LR(0)语法分析法设计与实现
m0_74102824的博客
12-17 888
按照LR(0)分析算法的步骤进行分析过程，依次读取输入串中的字符，根据当前状态和输入字符，在表格中查找对应的动作。如果是归约操作，则根据归约规则退栈，并将归约后的非终结符入栈；在分析过程中，输出每一步的状态栈、符号栈、剩余输入串、动作和GOTO值。掌握LR(0)分析表的构造方法；如果使用已知的分析表，实验分数会降低。1.实现LR(0)分析算法，根据某一文法编制调试LR(0)分析程序，以便对任意输入的符号串进行分析。4.LR(0)文法分析器的实现，用于分析给定的输入串是否符合指定的文法规则。
第五章 LR分析法
热门推荐
yongchaocsdn的博客
12-03 3万+
LR分析法也是一种“移进—归约”的自底向上语法分析方法，其本质是规范归约，具有以下特点： (1)应用面广：能够用LR分析程序识别绝大多数的程序设计语言的语法结构； (2)实现效率高：虽构造方法复杂，但是实现（执行）效率高。 (3)查错准确：LR分析器能够及时发现语法错误并准确指出错误位置。 LR(k)分析方法中L是指自左(Left)向右扫描输入单词串，R指分析过程是最右(Right)推
【LR(0)分析】LR（0）算法的分析与设计
LKW-Ulrikh的博客
07-04 2934
【LR(0)分析】LR（0）算法的分析与设计
编译原理-语法分析实验（c++版）
05-22
【问题描述】 请根据给定的文法设计并实现语法分析程序，能基于上次作业的词法分析程序所识别出的单词，识别出各类语法成分。输入输出及处理要求如下： ...该代码在CG实验平台上满分通过，仅供参考！
编译原理课程设计 LR(0)分析表和分析器的构造和程序实现
01-12
LR（0）分析表算法的程序实现 1. 对任意给定的文法 ，完成识别文法活前缀的 、 的状态转化矩阵及 项目集规范族的构造； 2. 判断该文法是否为 文法，实现 分析表的构造，并输出到指定文件中； 3. 实现 分析器总控程序，对输入的表达式进行文法分析。
编译原理LR0分析代码完整
07-08
(1)根据LR(0)分析法编写一个语法分析程序，输入已知文法，由程序自动构造项目集规范族； (2)根据输入文法，自动构造文法的分析表M，能判断该文法是否为LR(0)文法，若不是则能够指出其存在的冲突； (3)对于输入的文法和符号串，所编制的语法分析程序应能正确判断此串是否为文法的句子，并输出分析过程。
编译原理作业——LR（k）分析器
06-13
根据课本的LR分析器模型和LR分析算法，完成LR分析。对要求中的错误信息提示，指的是对应分析表中的空白处，每一个空白的地方都应该有对应的错误情况，因而有相应的错误信息。注意这里的语法分析，是在词法分析的基础上进行的
编译原理课程设计 LR（0）类文法的判断及分析表的构造
01-01
编译原理课程设计 LR（0）类文法的判断及分析表的构造
LR(0)完整的语法分析方法(拓广文法、识别活前缀状态机、LR0表、识别字符串)内有word详细说明
01-07
LR(0)完整的语法分析方法(拓广文法、识别活前缀状态机、LR0表、识别字符串)内有word详细说明
编译原理期末总结（仅供参考）
最新发布
05-18
编译原理期末总结（仅供参考）
编译原理-课程设计-基于编译原理的公式计算器设计与实现（QT&C++实现）
06-30
编译原理-课程设计-基于编译原理的公式计算器设计与实现包含以下三部分文件： 1.【报告】分为七章进行展示，包括摘要、参考文献，正文部分为包括概述、使用的基本概念和原理、总体设计、详细设计...文件仅供参考学习。
编译原理-讨论课-编译程序是如何开发的
06-30
编译原理-讨论课-编译程序是如何开发的包含以下两部分文件： 1.【报告】分为四章进行展示，包括摘要、参考文献，正文部分为包括第一个编译程序、早期编译程序开发、目前编译程序开发，以及总结。...文件仅供参考学习。
编译原理实验报告（仅供学习参考）
10-21
实验一 词法分析程序设计与实现 1 一．实验设计 1 二．代码程序 3 三．实验结果分析 9 实验二 语法分析程序设计与实现 11 一．实验设计 11 二．代码程序 12 三．实验结果分析 20 ...一．...二．...三．...实验总结 30
编译原理课后习题答案黄贤英
03-22
很抱歉，我无法提供特定教材的习题答案。编译原理是一门涉及编译器设计和实现的课程，主要包括词法分析、语法分析、语义...请注意，以上问题的回答仅供参考，具体内容可能需要根据您所学习的教材或课程来进行深入讨论。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值