郑州大学编译原理实验二语法分析器JAVA

最新推荐文章于 2024-05-03 11:47:20 发布
最新推荐文章于 2024-05-03 11:47:20 发布
阅读量1.6w 收藏 3
点赞数 1
分类专栏： 编译原理实验 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54884881/article/details/127696067
版权

实验二 预测分析算法的设计与实现

一、实验目的

通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。

二、实验内容

输入文法及待分析的输入串，输出其预测分析过程及结果。

  1. 参考数据结构
    (1)/定义产生式的语法集结构/
    typedef struct{
    char formula[200];//产生式
    }grammarElement;
    grammarElement gramOldSet[200];//原始文法的产生式集
    (2)/变量定义/
    char terSymbol[200];//终结符号
    char non_ter[200];//非终结符号
    char allSymbol[400];//所有符号
    char firstSET[100][100];//各产生式右部的FIRST集
    char followSET[100][100];//各产生式左部的FOLLOW集
    int M[200][200];//分析表
  2. 判断文法的左递归性，将左递归文法转换成非左递归文法。（该步骤可以省略，直接输入非左递归文法）。
  3. 根据文法求FIRST集和FOLLOW集。
    （1）/求 First 集的算法/

（2）/求 FOLLOW 集的算法/

  1. 构造预测分析表。

  2. 构造总控程序。
    程序流程图如下图1所示：

在这里插入图片描述

  1. 对给定的输入串，给出分析过程及结果。
package StringToJAVA;

import java.io.*;
import java.util.*;

/**
 * @author [25'h]
 * @datetime 2022.10.28
 * 注意：程序中将ε默认为终结符，在输入的文本文件中需要标出
 */
public class Parsing {
    public static String startLabel;//开始符
    public static ArrayList<String> terSymbol = new ArrayList<>();// 终结符
    public static ArrayList<String> non_ter = new ArrayList<>();// 非终结符
    public static HashMap<String, List<String>> formula = new HashMap<>();//产生式
    public static HashMap<String, HashMap<String, String>[]> firstAndFollow = new HashMap<>();//FIRST  和  FOLLOW
    /*
        firstAndFollow的数据含义：
            - key : 非终结符
            - value : 非终结符对应的FIRST  和  FOLLOW 集及其产生原因的产生式右部
                - 1     非终结符对应的FIRST
                    - key   FIRST集
                    - value FIRST集的产生右部
                - 2     非终结符对应的FOLLOW
                    - key   FOLLOW集
                    - value 无意义
    */
    public static boolean[] booleansFirst;// 辅助变量
    public static boolean[] booleansFollow;
    public static String objString;// 目标匹配字符串


    public static void main(String[] args) {
        File file = new File("src/StringToJAVA/test3.txt");
        BufferedReader bufferedReader;
        try {
            // 读取文法和目标式子
            bufferedReader = new BufferedReader(new FileReader(file));
            startLabel = bufferedReader.readLine();
            // 读取非终结符
            non_ter.addAll(Arrays.asList(bufferedReader.readLine().split(" ")));
            booleansFirst = new boolean[non_ter.size()];// 初始化辅助变量
            booleansFollow = new boolean[non_ter.size()];
            // 初始化firstAndFollow中的Map对象
            for (String s : non_ter) {
                firstAndFollow.put(s, new HashMap[]{new HashMap<String, String>(), new HashMap<String, String>()});
            }
            // 读取终结符
            terSymbol.addAll(Arrays.asList(bufferedReader.readLine().split(" ")));
            //将产生式右部或表达式分离
            String s;
            while ((s = bufferedReader.readLine()).contains("->")) {
                String[] split = s.split("->");
                formula.put(split[0], Arrays.asList(split[1].split("\\|")));
            }

            objString = s;
            generateFirstSET();// 生成FIRST集
            generateFollowSET();// 生成FOLLOW集
            show();// 显示FIRST和FOLLOW信息
            match();// 匹配

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    private static void match() {
        System.out.println("\n匹配过程");
        int index = 0;//objString匹配位置标记
        Stack<String> stack = new Stack<>();
        stack.push("#");
        stack.push(startLabel);
        while (!stack.isEmpty()) {
            showDetail(stack, index);
            String peek = stack.peek();
            String sub = objString.substring(index, index + 1);
            if (peek.equals("#") && sub.equals("#")) break;//到结尾符号了
            if (peek.equals("#")) throw new RuntimeException("匹配错误");// 堆栈到结尾了，objString没有到
            // 注意："#"符号绝不能进入下面的程序，会将"#"识别为非终结符，造成空指针

            if (terSymbol.contains(peek)) {// 若栈顶为终结符，必须匹配，否则出错
                if (peek.equals(sub)) {// 成功匹配
                    index++;
                    stack.pop();
                } else {
                    throw new RuntimeException("匹配错误");
                }
            } else {// 栈顶为非终结符
                HashMap<String, String>[] hashMaps = firstAndFollow.get(peek);// 去除该非终结符的FIRST和FOLLOW集
                String s = hashMaps[0].get(sub);// 非终结符peek和sub组合需要的产生式为s
                if (s != null) {// 不为空就反向压入栈中
                    stack.pop();
                    for (int i = s.length() - 1; i >= 0; i--) {
                        stack.push(s.substring(i, i + 1));
                    }
                } else {// s为空说明FIRST没有sub，就需要判断peek的FIRST集中是否存在空，这样可以进一步查看FOLLOW是否存在sub
                    if (hashMaps[0].containsKey("空")) {//peek的FIRST集中存在空
                        if (hashMaps[1].containsKey(sub)) {//FOLLOW集中存在sub，就用FIRST中产生空的产生式
                            String ve = hashMaps[0].get("空");//FIRST中产生空的产生式
                            stack.pop();
                            //将替换掉peek换成产生式ve，注意若是空，则跳过
                            for (int i = ve.length() - 1; i >= 0; i--) {
                                String substring = ve.substring(i, i + 1);
                                if (!substring.equals("空")) {
                                    stack.push(substring);
                                }
                            }
                        } else {
                            throw new RuntimeException("匹配错误");
                        }

                    } else {
                        throw new RuntimeException("匹配错误");
                    }
                }
            }
        }
        System.out.println("成功");
    }

    /**
     * @param stack 堆栈中现在的状态
     * @param index 匹配到objString的第index个字符了
     * 显示匹配过程信息
     */
    private static void showDetail(Stack<String> stack, int index) {
        StringBuffer buffer= new StringBuffer();
        for (String s : stack) {
            buffer.append(s);
        }
        System.out.printf("%-10s%-10s", buffer.toString(), objString.substring(index));
        System.out.println();

    }

    /**
     * 生成FOLLOW集
     */
    private static void generateFollowSET() {
        firstAndFollow.get(startLabel)[1].put("#", null);// 起始符FOLLOW定有"#"
        for (String s : non_ter) {//对于每一个非终结符
            if (!booleansFollow[non_ter.indexOf(s)])// 没有计算过就计算
                generateEveryFollowSET(s);
        }
    }

    /**
     * @param curNonTer 当前计算Follow的非终结符
     */
    public static void generateEveryFollowSET(String curNonTer) {
        //s左部
        for (String s : formula.keySet()) {
            // 对于每一个右部
            for (String eachRight : formula.get(s)) {
                //右部不存在该非终结符
                if (!eachRight.contains(curNonTer)) continue;
                modifyFollow(curNonTer, s, eachRight);
            }

        }
        booleansFollow[non_ter.indexOf(curNonTer)] = true;
    }

    /**
     * @param curNonTer FOLLOW  目标非终结符
     * @param left      左部
     * @param eachRight 右部
     */
    private static void modifyFollow(String curNonTer, String left, String eachRight) {
        int index = eachRight.indexOf(curNonTer);// 目标非终结符所在索引
        if (index == eachRight.length() - 1) {//若curNonTer在右部最后，添加FOLLOW(left)--->FOLLOW(curNonTer)
            if (left.equals(curNonTer)) return;//若一样，没必要算，算了就会死递归
            if (!booleansFollow[non_ter.indexOf(left)]) {//未计算过，就先计算
                generateEveryFollowSET(left);
            }
            firstAndFollow.get(curNonTer)[1].putAll(firstAndFollow.get(left)[1]);
        } else {// 若curNonTer不在右部最后
            if (terSymbol.contains(eachRight.substring(index + 1, index + 2))) {// 紧接的后面是终结符
                firstAndFollow.get(curNonTer)[1].put(eachRight.substring(index + 1, index + 2), null);
            } else {//紧接的后面是非终结符
                func(curNonTer, left, eachRight, index + 1);
            }
        }
    }

    /**
     * @param curNonTer FOLLOW  目标非终结符
     * @param left      当前产生式左部
     * @param eachRight 当前产生式右部
     * @param index     当前计算位置标记
     */
    private static void func(String curNonTer, String left, String eachRight, int index) {
        HashMap<String, String> curFollow = firstAndFollow.get(curNonTer)[1];
        if (eachRight.length() == index) {// eachRight中curNonTer后均是非终结符，且其中的所有非终结符均能推导出空，成功到了最后，就可以将左部的FOLLOW添加进来
            if (left.equals(curNonTer)) return;
            if (!booleansFollow[non_ter.indexOf(left)]) {// 未计算过，就先计算
                generateEveryFollowSET(left);
            }
            curFollow.putAll(firstAndFollow.get(left)[1]);
            return;
        }
        String sub = eachRight.substring(index, index + 1);// eachRight中curNonTer后的字符依次取出
        if (terSymbol.contains(sub)) {// 终结符
            curFollow.put(sub, null);
            return;
        }
        // 不能添加空
        if (curFollow.containsKey("空")) {
            curFollow.putAll(firstAndFollow.get(sub)[0]);
        } else {
            curFollow.putAll(firstAndFollow.get(sub)[0]);
            curFollow.remove("空");
        }
        // eachRight中curNonTer后的非终结符能推出空
        if (firstAndFollow.get(sub)[0].containsKey("空")) {
            func(curNonTer, left, eachRight, index + 1);
        }
    }

    /**
     * 生成FIRST集
     */
    public static void generateFirstSET() {
        for (String s : non_ter) {
            if (!booleansFirst[non_ter.indexOf(s)])
                generateEveryFirstSET(s);
        }
    }

    /**
     * @param curNonTer 生成curNonTer的FIRST集
     */
    public static void generateEveryFirstSET(String curNonTer) {
        List<String> list = formula.get(curNonTer);// 所有右部
        HashMap<String, String> curFirst = firstAndFollow.get(curNonTer)[0];//先将curNonTer的FIRST集提出来
        for (String eachRightFormula : list) {// 对于每一个右部
            String firstChar = eachRightFormula.substring(0, 1);//第一个终结符或者非终结符
            if (terSymbol.contains(firstChar)) {//是终结符
                curFirst.put(firstChar, eachRightFormula);
            } else {//非终结符号
                modify(firstAndFollow.get(curNonTer)[0], curNonTer, eachRightFormula, 0);
            }
        }
        booleansFirst[non_ter.indexOf(curNonTer)] = true;
    }

    /**
     * @param curFirst         curNonTe的FIRST集
     * @param curNonTer        FIRST  目标非终结符
     * @param eachRightFormula 产生式右部
     * @param index            处理的位置索引
     *                         产生式右部从左边开始的非终结符进行逐步递归处理
     */
    public static void modify(HashMap<String, String> curFirst, String curNonTer, String eachRightFormula, int index) {
        if (index >= eachRightFormula.length()) {//所有的符号均为非终结符，并且均可推出空（可以说是FIRST中有空）
            curFirst.put("空", eachRightFormula);// 添加空
            return;
        }
        String firstChar = eachRightFormula.substring(index, index + 1);// 处理的当前的非终结符
        if (firstChar.equals(curNonTer)) return;// 防止死递归
        if (!booleansFirst[non_ter.indexOf(firstChar)]) {// 未存在，先处理
            generateEveryFirstSET(firstChar);
        }
        // 不是最后不能添加firstAndLast.get(firstChar)[0]中的空
        // 注意这里只需要添加键值，value不能添加，需要赋值当前产生式右部，在创建FOLLOW时并不用，因为FOLLOW的value用不到，随意赋值
        if (curFirst.containsKey("空")) {
            for (String s : firstAndFollow.get(firstChar)[0].keySet()) {
                curFirst.put(s, eachRightFormula);
            }
        } else {
            for (String s : firstAndFollow.get(firstChar)[0].keySet()) {
                curFirst.put(s, eachRightFormula);
            }
            curFirst.remove("空");
        }
        // 若能推出空，就会持续向后扩展
        if (firstAndFollow.get(firstChar)[0].containsKey("空")) {
            modify(curFirst, curNonTer, eachRightFormula, index + 1);
        }
    }


    public static void show() {
        System.out.println("开始符号:" + startLabel);
        System.out.println("非终结符:" + Arrays.toString(non_ter.toArray()));
        System.out.println("终结符" + Arrays.toString(terSymbol.toArray()));
        System.out.println("文法:");
        for (String obj : formula.keySet()) {
            System.out.println(obj + "--->" + Arrays.toString(formula.get(obj).toArray()));
        }
        System.out.println("\n非终结符号的FIRST和FOLLOW集:");
        for (String s : firstAndFollow.keySet()) {
            System.out.println(s + "\t" + Arrays.toString(firstAndFollow.get(s)[0].keySet().toArray()) + Arrays.toString(firstAndFollow.get(s)[1].keySet().toArray()));
        }
        System.out.println("\n每个非终结符的FIRST集对应的原因:");
        for (String s : firstAndFollow.keySet()) {
            System.out.println(s + "\t" + Arrays.toString(firstAndFollow.get(s)[0].values().toArray()));
        }
    }
}

示例

test2.txt:

E
E T A F B
+ * ( ) i 空
E->TA
A->+TA|空
T->FB
B->*FB|空
F->(E)|i
(i+i)#

输出：

"D:\Program Files\Java\jdk1.8.0_291\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1\lib\idea_rt.jar=55037:D:\IntelliJ IDEA 2020.1\bin" -Dfile.encoding=UTF-8 -classpath "D:\Program Files\Java\jdk1.8.0_291\jre\lib\charsets.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\deploy.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\access-bridge-64.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\cldrdata.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\dnsns.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jaccess.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jfxrt.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\localedata.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\nashorn.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunec.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunjce_provider.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunmscapi.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunpkcs11.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\zipfs.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\javaws.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\jce.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\jfr.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\jfxswt.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\jsse.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\management-agent.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\plugin.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\resources.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\rt.jar;D:\code_management\algorithm\out\production\algorithm" StringToJAVA.Parsing
开始符号:E
非终结符:[E, T, A, F, B]
终结符[+, *, (, ), i, 空]
文法:
A--->[+TA, 空]
B--->[*FB, 空]
T--->[FB]
E--->[TA]
F--->[(E), i]

非终结符号的FIRST和FOLLOW集:
A	[空, +][), #]
B	[*, 空][), +, #]
T	[(, i][), +, #]
E	[(, i][#, )]
F	[(, i][), *, +, #]

每个非终结符的FIRST集对应的原因:
A	[空, +TA]
B	[*FB, 空]
T	[FB, FB]
E	[TA, TA]
F	[(E), i]

匹配过程
#E        (i+i)#    
#AT       (i+i)#    
#ABF      (i+i)#    
#AB)E(    (i+i)#    
#AB)E     i+i)#     
#AB)AT    i+i)#     
#AB)ABF   i+i)#     
#AB)ABi   i+i)#     
#AB)AB    +i)#      
#AB)A     +i)#      
#AB)AT+   +i)#      
#AB)AT    i)#       
#AB)ABF   i)#       
#AB)ABi   i)#       
#AB)AB    )#        
#AB)A     )#        
#AB)      )#        
#AB       #         
#A        #         
#         #         
成功

Process finished with exit code 0
「 25' h 」
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
编译原理实验二语法分析java代码JavaCC
06-28
设计MiniC的上下文无关文法，利用JavaCC生成调试递归下降分析程序，以便对任意输入的符号串进行分析。本次实验的目的主要是加深对递归下降分析法的理解。 按照MiniC语言的语法规则检查词法分析输出的记号流是否符合这些规则，并根据这些规则所体现出的语言中的各种语法结构的层次性。把规则写入到JavaCC的 .jjt文件中，可以生成树状的层次结构。
编译原理 实验二 LL(1)分析法 Java版
qq_52814098的博客
07-29 1076
编译原理 实验二 LL(1)分析法 Java版，带界面
编译原理实验二分析
一窍不通只会复制粘贴的Java工程师
01-18 3007
对于 编译原理实验二 实验二主要分析实验一中的得到的多元式是进行计算器的语义分析 需要从实验1中获取分析成功的多元（种别码，字符串原貌，Value属性，Type属性）式序列 根据多元式中的Type属性获取类型（int、double、运算符等）然后逐步分析所有的多元式，是否符合语义 如果符合则分析下一个，如果不符合，则跳出 如：2+4.2*（5+6） 编写代码控制台将依次输出一下信息 ...
北邮编译原理实验二：语法分析程序的设计与实现
11-19
北邮编译原理实验二：语法分析程序的设计与实现，源代码和实验报告
编译原理实验二 自上而下的语法分析器(算术表达式)
m0_54167558的博客
04-27 1882
自上而下的算术表达式语法分析器
郑州大学编译原理实验一词法分析器JAVA
[ 25'h ]
11-04 1534
郑州大学编译原理实验一词法分析器JAVA
郑州大学编译原理实验四LR(0)分析算法JAVA
[ 25'h ]
11-04 1061
郑州大学编译原理实验四LR(0)分析算法JAVA
【Java基础系列教程】第二章 Java语言概述、配置环境变量
波哩个波的博客
02-08 4149
1、计算机编程语言概述； 2、Java语言概述：概述、发展史、技术体系平台、Java在各领域的应用、语言特点； 3、Java环境搭建：JDK/JRE、下载和安装； 4、Java HelloWorld； 5、Java程序的运行：DOS命令、转义符、注释； 6、Java程序运行原理：运行流程、Java两大核心机制、垃圾回收机制 - Java与C/C++； 7、Java开发工具； 8、Java API帮助文档； 9、课后练习
Java就业面试问题大全
slny1921394421的博客
07-19 2924
Java就业面试问题汇总
java
fanfan12138的博客
05-21 2114
视频网站 https://edu.51cto.com/lecturer/2086101.html 网址 https://blog.csdn.net/zhangchen124 1 Java 面试宝典 2020 版 前言…13 一. Java 基础部分…14 1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？ …14 2、Java 有没有 goto?..14 3、说说&和&&的区别。 …14 4、switch 语句能否作用在 byte 上，能否作用在 long
大学编译原理实验语法分析器.java
07-19
a) 启动程序后，先输出作者姓名、班级、学号（可用汉语、英语或拼音）...b) 请求输入测试程序名，键入程序名后自动开始编译。 c) 输出四元式中间代码（样式见样板输出3和4）。 d) 能发现程序的语法错误并输出出错信息。
编译原理词法分析器及语法分析器实验报告，JAVA实现
06-26
编译原理语法分析与词法分析器实验报告，词法分析可分析保留字、关键词、浮点数、处理多行注释、常数、运算符。语法分析采用预测表分析法
哈工大编译原理实验二语法分析
11-19
这是哈工大编译原理课程的第二次实验语法分析的实验报告书。
聊城大学编译原理实验二语法分析器.doc
10-03
聊城大学编译原理实验二语法分析器.doc
东北大学编译原理实验2 语法分析
06-19
东北大学编译原理实验2 语法分析 实验报告，有代码。
Java经典面试题
热门推荐
九天之凤
11-10 7万+
摘自张孝祥itcast 从享受生活的角度上来说：“程序员并不是一种最好的职业，我认为两种人可以做程序员，第一，你不做程序员，你就没有什么工作可做，或者说是即使有可以做的工作但是你非常不愿意去做；第二，你非常痴迷和爱好程序，并且在这方面有一些天赋和优势。程序员的结局也是有两种：第一，默默退休，第二以程序员为起点或跳板，注意积累，跟对了好的老板或团队，找到和很好的搭档自己创业，成为IT金领和富翁
java 面试题
liuhenglucky的专栏
02-13 1437
从享受生活的角度上来说：“程序员并不是一种最好的职业，我认为两种人可以做程序员，第一，你不做程序员，你就没有什么工作可做，或者说是即使有可以做的工作但是你非常不愿意去做；第二，你非常痴迷和爱好程序，并且在这方面有一些天赋和优势。程序员的结局也是有两种：第一，默默退休，第二以程序员为起点或跳板，注意积累，跟对了好的老板或团队，找到和很好的搭档自己创业，成为IT金领和富翁。” 人们在时间面前是平等的
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
最新发布
XING的博客
05-03 1200
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1075
介绍了Java泛型中的重要知识点——通配泛型及其应用。
用C语言编译编译原理实验LL1语法分析器
05-29
下面是一个简单的基于C语言实现的LL(1)语法分析器示例代码，仅供参考： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_BUF_SIZE 1024 #define MAX_STACK_SIZE 1024 // 预测分析表 char parsing_table[10][10] = { /* E T F + * ( ) i $ */ {'1', ' ', ' ', ' ', ' ', '2', ' ', '3', ' ', ' '}, // E {' ', '4', ' ', '5', ' ', ' ', ' ', ' ', '6', ' '}, // T {'7', ' ', '8', ' ', ' ', '9', ' ', ' ', '10', ' '}, // F }; // 符号栈 char stack[MAX_STACK_SIZE]; int top = -1; // 输入缓冲区 char buffer[MAX_BUF_SIZE]; int buf_idx = 0; // 读入输入 char read_input() { if (buf_idx == strlen(buffer)) { return '$'; } return buffer[buf_idx++]; } // 获取栈顶元素 char get_top() { if (top >= 0) { return stack[top]; } return ' '; } // 弹出栈顶元素 void pop() { if (top >= 0) { top--; } } // 压入元素到栈顶 void push(char c) { if (top < MAX_STACK_SIZE-1) { stack[++top] = c; } } // LL(1)语法分析 void parse() { push('$'); push('E'); char lookahead = read_input(); while (top >= 0) { char top_char = get_top(); if (top_char == lookahead) { printf("Match %c\n", lookahead); pop(); lookahead = read_input(); } else if (top_char >= 'A' && top_char <= 'Z') { int row = top_char - 'A'; int col = lookahead - '0'; char *production = parsing_table[row][col]; if (production == ' ') { printf("Error: Parsing table entry is empty!\n"); exit(1); } else { printf("Apply production %c -> %s\n", top_char, production); pop(); int i; for (i = strlen(production)-1; i >= 0; i--) { push(production[i]); } } } else { printf("Error: Invalid character %c on stack!\n", top_char); exit(1); } } } int main() { printf("Enter input string: "); fgets(buffer, MAX_BUF_SIZE, stdin); buffer[strlen(buffer)-1] = '\0'; // 去掉换行符 parse(); return 0; } ``` 该代码实现了一个简单的LL(1)语法分析器，其基本思路是：使用一个符号栈来模拟语法分析过程，根据预测分析表进行分析，将分析结果输出为语法树。用户需要输入一个待分析的字符串，程序将输出分析过程中的每个步骤，包括匹配、应用产生式等。需要注意的是，该代码只能处理特定的文法，如果需要处理其他文法，需要修改预测分析表和产生式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

「 25' h 」

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值