C-语言词法分析器与语法分析器（二）

最新推荐文章于 2024-03-06 14:23:12 发布
VIP文章 最新推荐文章于 2024-03-06 14:23:12 发布
阅读量3.6k 收藏 47
点赞数 8
文章标签： 语法分析器 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IuSpet/article/details/101513465
版权

说明：

为实践《编译原理》中的相关知识，认真完成了课程设计，实现了C-语言的词法分析器与语法分析器

C-语言是C语言的一个子集，语法包括：

整型变量与函数的声明

if else 分支语句

while 循环语句

本篇介绍语法分析器的实现

将利用将文法改写为LL(1)文法的技术实现语法分析器

流程：

  1. 去除左递归
  2. 提取左公因子
  3. 获取FIRST, FOLLOW集合
  4. 构造预测分析表
  5. 匹配词法分析器产生的token构造语法树

数据结构：

因为要对文法中的产生式频繁的删改，最开始用了std::list<std::list<std::string>>，内层的每个list存产生式，因为在判断产生式是几个终结符、非终结符并列时，要逐字符判断空格，后面将数据结构换成std::vector<std::vector<std::vector<std::string>>>储存文法，最内层是符号，外面一层是一个产生式，再外面一层是一条文法，最外层是所有文法

去除左递归：

先将文法左端的前面文法的非终结符替换为该非终结符的产生式

再去除左递归

将A -> Aα| β改为

 A -> βA1

A1 -> αA1

提取左公因子：

因为LL(1)文法每次的产生式是确定的，而两个产生式会导致选择是产生分歧，故要去除公因子

将A -> αB| αC

改为A -> αA'

A' -> B | C

在最开始，我以为难点主要在去左递归，提取左公因子看起来很直观很好操作，后面踩了坑发现提取左公因子是最难的一步，因为一个可能两个产生式虽然不一样，但他们产生的非终结符是相同的，而提取左公因子就要把左公终结符全部提取出来，但是直接把一个非终结符充分展开显然非常麻烦。

在判断是否是LL(1)文法是会求FIRST集合，而通过FIRST集合判断LL(1)文法就是在找是否有公因子

我的做法是两两比较一个非终结符的所有产生式，如果有明显的左公因子，即字符相同的Vn&Vt，先将明显的左公因子提取出来，将新的文法加入所有文法，回到算法开头重新开始。如果没有明显的左公因子，算一次FIRST集合，判断有没有隐藏在产生式中的左公因子，有的话就展开当前比较的两条产生式，然后再回到算法开头重新开始。直到遍历完所有文法找不到左共因子，就提取出了所有左公因子

获取FIRST, FOLLOW集合

FIRST(α)被定义为可从α推导得到的串的首符号的集合，其中α是任意的文法符号串。

对于产生式 α -> βγ

在计算FIRST(α)时，要先知道FIRST(β)，故想到采用递归解决，根据规则，如果FIRST(β)中含有ε，再继续求FIRST(γ)，若FIRST(γ)中也含有ε，则将ε加入FIRST(α)

对于非终结符A，FOLLOW(A)被定义为可能在某些句型中紧跟在A右边的终结符号的集合

规则是

（1）将$放到FOLLOW(S)中，其中S是开始符号，而$是输入右端的结束标记

（2）如果存在一个产生式A -> αBβ，那么FIRST(β)中除ε之外的所有符号都在FOLLOW(B)中

（3）如果存在一个产生式A -> αB，或存在产生式A -> αBβ且FIRST(β)包含ε，那么FOLLOW(A)中的所有符号都在FOLLOW(B)中

根据规则，在计算完FIRST集合后，扫一遍所有产生式即可计算出FOLLOW集合

FIRST集合和FOLLOW集合正好可以用std::set存储

构造预测分析表

对于文法G的每个产生式A -> α，进行如下处理：

（1）对于FIRST(α)中的每个终结符号a， 将A -> α加入到M [A, a]中。

（2）如果ε在FIRST(α)中，那么对于FOLLOW(A)中的每个终结服符号b，将A -> α加入到M [A, b]中。如果ε在FIRST(α)中，且$在FOLLOW(A)中，也将A -> α加入到M [A, $]中。

在求出FIRST集合和FOLLOW集合后，根据规则很容易求出预测分析表

因为这一步将一个非终结符到一个终结符的推导映射到一个产生式上，可以用std::map存储

匹配词法分析器产生的token构造语法树

预测分析表构造好后，就可以拿来处理词法分析器得出的token，如果文法是处理正确的LL(1)文法，且源代码也没有语法错误，那么这一步将会把所有的token构造出一棵语法树。

详细代码：

//Parser.h
//作者：IuSpet
//作用：将一般文法转变为LL(1)文法并构建语法分析树

#ifndef Parser_h
#define Parser_h
#include"utlib.h"

//语法树的节点
struct node
{
	node *Parent;
	std::string type;
	std::string value;
	std::list<node*> sons;
};
class Parser
{
public:
	Parser();
	
	void get_LL1_grammar();						//得到LL（1）文法
	void Parse();								//解析，匹配文法与token，建树

	~Parser()
	{
		tokenfile.close();
	}
	
private:
	std::list<std::list<std::string>> grammar;		//文法	
	std::vector<std::vector<std::vector<std::string>>> final_grammar;	//处理后的LL(1)文法
	std::map<std::string, bool> can_produce_empty;
	std::map<std::string, bool> is_Vn;
	std::map<std::string, std::set<std::string>> FIRST, FOLLOW;
	//预测分析表,结构为		predictive_table[非终结符号，终结符号] = 产生式
	std::map<std::pair<std::string, std::string>, std::vector<std::string>> predictive_table;		
	const char *grammar_file;
	const char *token_file;
	FILE* f;
	int filepos;
	node root;										//语法树根
	std::ifstream tokenfile;


	void get_grammar();								//获取初始文法
	void Eliminate_left_recursion();				//消除左递归
	void get_FIRST();								//获取FIRST集合
	void get_FOLLOW();								//获取FOLLOW集合
	bool judge_LL1_grammar();						//判断是不是LL(1)文法
	bool cmp_set(const std::set<std::string> s1, const std::set<std::string> s2);	//判断两个set是否有交集
	void get_predict_table();						//计算预测分析表
	void get_left_common_factor();					//提取左公因子
	void get_all_Vn();								//找出所有非终结符
	void reconsitution();							//换个方便的数据结构。。。
	std::string get_next_token();					//不断获得下一个token
	void print_grammar0();							//打印初始文法
	void print_grammar1();							//打印去除左递归后的文法
	void print_grammar2();							//打印提取左公因子后的文法
	void print_final_grammar();						//打印重构后的文法，测试
	std::set<std::string> cal_first(std::string Vn);//用于递归计算FIRST集
	void print_FIRST();								//打印FIRST集合
	void print_FOLLOW();							//打印FOLLOW集合
	void print_predictive_table();					//打印预测分析表
	void print_tree();								//打印语法树
	void string_to_vector(std::string &s, std::vector<std::string> &v);		//将string表示的产生式转为vector
	void vector_to_string(std::string &s, std::vector<std::string> &v);		//将vector表示的产生式转为string
	bool has_common_prefix(std::vector<std::string> &gm1, std::vector<std::string> &gm2);	//判断两个产生式有无左公因子
	std::set<std::string> get_left(std::vector<std::string> & tmp);		//返回左端，即first集，用于查看是否有左公因子
	void get_token_value(std::string &token, std::string &value, std::string &type);		//获取token属性
	void deep_print(std::ofstream &out, int r, node *t);				//递归打印树
};
#endif // !Parser_h
#pragma once

 

//Parser.cpp
//作者：IuSpet
//作用：将一般文法转变为LL(1)文法并构建语法分析树

#include "Parser.h"
const int BUFFERLENGTH = 4096;

//构造函数指定文法文件和token文件
Parser::Parser()
{
	grammar_file = "D://cminus//grammar.txt";
	token_file = "D://cminus//token.txt";
	tokenfile.open(token_file);
	filepos = 0;
	//语法树根
	root.Parent = NULL;
	root.type = "non-terminal";
	root.value = "program";
}

void Parser::get_LL1_grammar()
{
	get_grammar();						//读文法
	print_grammar0();
	Eliminate_left_recursion();			//去左递归
	print_grammar1();
	get_all_Vn();						//标记所有非终结符
	get_left_common_factor();			//消除左公因子
	print_grammar2();
	reconsitution();					//重构存储文法的数据结构
	print_final_grammar();
	get_FIRST();						//计算FIRST集合
	print_FIRST();
	get_FOLLOW();						//计算FOLLOW集合
	print_FOLLOW();
	if (!judge_LL1_grammar())
	{
		std::cout << "不是LL(1)文法" << std::endl;
		//system("pause");
	}
	else
	{
		std::cout << "是LL(1)文法" << std::endl;
		//system("pause");
	}
	get_predict_table();				//构造预测分析表
	print_predictive_table();
}

//解析token，构造语法树
void Parser::Parse()
{
	std::ofstream outfile("D://cminus//matching_process.txt");
	outfile << std::setiosflags(std::ios::left);
	outfile << std::setw(30) << "Stack" << std::setw(20) << "Input" << "Action" << std::endl;
	std::stack<node*> match;
	//std::stack<std::string> match;

	node end;
	end.Parent = NULL;
	end.type = "";
	end.value = "$";

	match.push(&end);
	match.push(&root);

	std::string type;
	std::string value;
	std::string out;
	std::string token = get_next_token();
	get_token_value(token, value, type);

	while (true)
	{
		node &top = *match.top();
		match.pop();
		//token读取完了
		if (token == "$")
		{
			//匹配成功
			if (match.size() == 1)
			{
				outfile << std::setw(30) << "$" << std::setw(20) << "$" << "accept" << std::endl;
				match.pop();
				break;
			}
			else
			{
				//栈顶是非终结符，符号或保留字，匹配值存在value中
				bool choose = true;
				if (top.type == "RESERVED WORD" || top.type == "SYMBOL" || top.type == "non-terminal")
				{
					out = top.value + " ... " + "$";
					outfile << std::setw(30) << out << std::setw(20) << "$" << "output" << top.value;
				}
				//栈顶是标识符或运算符，匹配值存在type中
				else
				{
					out = top.type + " ... " + "$";
					outfile << std::setw(30) << out << std::setw(20) << "$" << "output" << top.value;
					choose = false;
				}

				//查表获取操作
				std::vector<std::string> &pro = choose ? predictive_table[std::make_pair(top.value, value)] : predictive_table[std::make_pair(top.type, value)];
				out.clear();
				vector_to_string(out, pro);
				outfile << " -> " << out << std::endl;

				//空的情况
				if (out == "empty")
				{
					continue;
				}

				//往栈中压入新值,并连接节点建树
				for (int i = pro.size() - 1; i >= 1; i--)
				{
					node *son;
					son = new node;
					//新节点是原栈顶的子节点
					top.sons.push_back(son);
					son->Parent = &top;

					//根据新压入符号不同构造节点
					if (is_Vn[pro[i]])
					{
						son->type = "non-terminal";
						son->value = pro[i];
					}
					else
					{
						if (pro[i] == "ID" || pro[i] == "NUM")
						{
							son->type = pro[i];
							son->value = "";
						}
						else
						{
							if (pro[i][0] >= 'a' && pro[i][0] <= 'z')
							{
								son->type = "RESERVED WORD";
								son->value = pro[i];
							}
							else
							{
								son->type = "SYMBOL";
								son->value = pro[i];
							}
						}
					}
					match.push(son);
				}
			}
		}		
		else
		{
			bool choose = true;
			if (top.type == "RESERVED WORD" || top.type == "SYMBOL" || top.type == "non-terminal")
			{
				out = top.value + " ... " + "$";
				outfile << std::setw(30) << out;
			}
			//栈顶是标识符或运算符，匹配值存在type中
			else
			{
				out = top.type + " ... " + "$";
				outfile << std::setw(30) << out;
				choose = false;
			}

			//token是关键字或符号
			if (type == "RESERVED WORD" || type == "SYMBOL")
			{
				out = value + " ... " + "$";
				outfile << std::setw(20) << out;
				//匹配，读取下一个token
				if (top.value == value)
				{
					outfile << "match" << std::endl;
					token.clear();
					token = get_next_token();
					get_token_value(token, value, type);
					continue;
				}
				//不匹配，查表
				else
				{
					std::vector<std::string> &pro = choose ? predictive_table[std::make_pair(top.value, value)] : predictive_table[std::make_pair(top.type, value)];
					if (pro.size() == 0)
					{
						outfile << "error" << std::endl;
						exit(1);
					}
					if (choose)
					{
						outfile << "output: " << top.value << " -> ";
					}
					else
					{
						outfile << "output: " << top.type << " -> ";
					}
					out.clear();
					vector_to_string(out, pro);
					outfile << out << std::endl;

					//空的情况
					if (out == "empty")
					{
						continue;
					}

					//往栈中压入新值,并连接节点建树
					for (int i = pro.size() - 1; i >= 0; i--)
					{
						node *son;
						son = new node;
						//新节点是原栈顶的子节点
						top.sons.push_back(son);
						son->Parent = &top;

						//根据新压入符号不同构造节点
						if (is_Vn[pro[i]])
						{
							son->type = "non-terminal";
							son->value = pro[i];
						}
						else
						{
							if (pro[i] == "ID" || pro[i] == "NUM")
							{
								son->type = pro[i];
								son->value = "";
							}
							else
							{
								//保留字
								if (pro[i][0] >= 'a' && pro[i][0] <= 'z')
								{
									son->type = "RESERVED WORD";
									son->value = pro[i];
								}
								//运算符
								else
								{
									son->type = "SYMBOL";
									son->value = pro[i];
								}
							}
						}
						match.push(son);
					}
				}
			}
			//token是标识符或数字
			else
			{
				out = type + " ... " + "$";
				outfile << std::setw(20) << out;
				//匹配，节点加入值，读取下一个token
				if (top.type == type)
				{
					outfile << "match" << std::endl;
					top.value = value;
					token.clear();
					token = get_next_token();
					get_token_value(token, value, type);
					continue;
				}
				else
				{
					std::vector<std::string> &pro = choose ? predictive_table[std::make_pair(top.value, type)] : predictive_table[std::make_pair(top.type, type)];

					if (choose)
					{
						outfile << "output: " << top.value << " -> ";
					}
					else
					{
						outfile << "output: " << top.type << " -> ";
					}

					out.clear();
					vector_to_string(out, pro
最低0.47元/天 解锁文章
luSpet
关注
  • 8
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 25
    评论
专栏目录
编译原理C--语法分析（C++代码）
04-29
用C++语言编写的，采用递归下降方法，可以识别C--语法规则的语法分析程序。压缩包中含有全部说明。语法分析是编译器的重要组成部分，是编译原理课程的核心部分，从简单入手，知晓编译器的工作原理，对编写大型编译器必有帮助。通过阅读本程序，也可加深对编译原理课程的理解，作为自己编写课程语法分析实验的一种参考。
用java开发C语言解释器：创建语法执行树
tyler_download的专栏
11-23 2577
我们已经成功解析了C语言的语法，接下来我们计划分两步走，一是开发一个C语言的解释器，也就是不编译，读取足够的源代码后直接执行。二是开发一个C语言的编译器，将C语言转换为java字节码，然后用java虚拟机来执行编译后的C程序。从这节开始，我们逐步实现解释器的开发。
深入理解编译器设计中的词法分析、语法分析和语义分析
最新发布
weixin_44112822的博客
03-06 502
在编译器设计领域，词法分析、语法分析和语义分析是将源代码转换为机器可执行代码的三个关键阶段。每个阶段在确保编译过程的正确性和效率方面都起着重要作用。本博客旨在全面解释这些概念及它们在编译过程中的相互作。词法分析、语法分析和语义分析是编译过程的重要组成部分。理解这些概念对于任何对编译器设计、编程语言实现或语言处理感兴趣的人都是至关重要的。它们构成了将源代码转换为可执行程序的基础，保证正确性并实现优化。通过深入探讨这些阶段之间的复杂关系，开发人员可以提高编程技能，并更深入地了解其喜爱编程语言的基本机制。
语法分析自上而下分析c语言算法,实验5-LL(1)语法分析程序的设计与实现(C语言).doc...
weixin_32513585的博客
05-23 722
班级: 学号: 姓名:PAGE 19实验五 LL(1)文法识别程序设计一、实验目的通过LL(1)文法识别程序的设计理解自顶向下的语法分析思想。二、实验重难点FIRST集合、FOLLOW集合、SELECT集合元素的求解，预测分析表的构造。三、实验内容与要求实验内容：阅读并理解实验案例中LL(1)文法判别的程序实现；参考实验案例，完成简...
C语言实现表达式的语法树生成
weixin_60522059的博客
10-27 1249
​ 紧跟上一篇计算器的文章，笔者这次基于完全相同的思想再做一个表达式语法树生成吧
c语言实现一个编译器生成语法树,GitHub - wolf1981/cCompiler: c语言编译器，用 lex 和 yacc 工具完成词法分析与语法分析并生成语法树，C++实现了语 法树的解析并生...
weixin_39619170的博客
05-18 416
C语言编译器lex和yacc编写的c语言编译器实现了C语言除了struct和指针几乎所有的语法。运行环境要求：flex bison g++11 python3中间代码生成windows命令行输入：flex compiler.lbison -vdty compiler.yg++ -std=c++11 -o compiler tree.cpp Praser.cpp innerCode.cpp tool...
编译原理--词法分析器+语法分析器 源代码
01-07
词法分析器：1) 定义目标语言的可用符号表和构词规则； 2) 依次读入源程序符号，对源程序进行单词切分和识别，直到源程序结束； 3) 对正确的单词，按照它的种别以<种别码，值>的形式保存在符号表中； 4) 对不正确的...
简易sql词法分析器和语法分析器.zip
07-14
完成 SQL 语言的词法分析器，要求采用课程教授方法，实现有限状态机确定化，最小化算法。词法分析器的输入为 SQL 语言源代码，输出识别出单词的二元属性，填写符号表。单词符号的类型包括关键字、标识符、界符、...
基于C语言实现词法分析器和语法分析器【100011954】
04-19
词法分析要求： 创建一个词法分析程序，它支持对正规文法的分析。必须使用 DFA（确定性有限自动机）或 NFA（非确定性有限自动机）来实现这一项目。该程序的输入是一个文本文件，包括一组由该正规文法产生的产生式...
C语言开发课程设计词法分析器源代码.zip
06-08
设计任务： 使用词法分析的自动生成工具 Flex 生成 C/C++语言的词法分析器 ,当输入C/C++源代码文件时，即后缀为 c/cpp 的文件，程序输出后缀为 tok 的文本性文件。涉及知识点：词法分析，Flex 工具使用。 环境配置：...
对C--语言的词法分析器、语法分析器.zip
10-19
对C--语言的词法分析器、语法分析器.zip
一个带界面的词法分析+语法分析语法树生成
05-21
带界面的java实现词法分析器、错误信息、语法分析器、错误信息和语法树生成
java模拟编译器,实现词法,语法分析,生成语法树
07-10
java模拟编译器,实现词法,语法分析,生成语法树
编译原理LL（1）文法-判断，first，follow，select，分析字符串
weixin_43864170的博客
06-02 3137
编译原理LL（1）文法-判断，first，follow，select，分析字符串 好久不更新了，U盘格式化了，之前的代码都丢了，诶，好久了才想起来有个CSDN还没更新过，以后会坚持更新的，这次先挂上LLI文法吧，之后补上之前总结的算法，之后的内容大都是跟着课堂的，然后再根据自己跟大佬自学的东西，进行更新吧 —————————————————————————————————————————— 这是实...
【C++实现】编译原理 LL(1)文法求First集合、Follow集合并实现实现LL(1)的非递归自上而下预测分析器
m0_72376577的博客
11-03 2653
1、掌握上下文无关文法的表示；2、掌握First、Follow函数的求法；3、学会构建LL(1)预测分析表；4、掌握LL(1)的非递归的自上而下预测分析器的设计方法。建议使用Visual C++ 6.0；windows系列操作系统。1、输入LL(1)文法，求出文法中所有非终结符的First集合、Follow集合并输出；2、设计算法构造文法的LL(1)预测分析表并输出；3、设计算法实现LL(1)的非递归自上而下预测分析器，判断输入的串是否是给定文法可以接受的，并按栈、输入、输出列表输出预测分析过程。
编译原理头歌实验：实验1《词法分析程序设计与实现》（C语言版）
qq_62899367的博客
12-01 1643
他们具有标识符的形式，但他们不是由用户而是由语言定义的，其意义是约定的。多数语言中规定，他们不能作为标识符或者标识符的前缀，即用户不能使用它们来定义用户使用的名字，故我们称它为保留字，这些语言如 Pascal 和 C 等。最后是其他字符的判断，它们被一一定义好的判断进行识别，这样所有的字符便被识别出来了。词法分析程序( Lexical analyzer，简称 Lexer )，负责从左到右逐个字符地对源程序进行扫描和分解，根据语言的词法规则识别出一个个的单词符号。对不正确的单词，做出错误处理。
C语言实现LL(1)文法分析器的构造
qq_40406916的博客
11-27 9220
实验任务：构造一个LL(1)文法分析器 思路是： 1.用map<char,int>逐个对终结符与非终结符标识 2.把产生式分条压栈 3.得到Fisrt和Follow集 4.构建预测分析表 5.分析输入的合法性 整体代码如下 #include<iostream> #include<stdio.h> #include<vector> #include&l...
构造使用类C语言的脚本引擎(5)语法检查,生成语法树,代码生成。
Kevin_qing的专栏
06-24 3593
构造使用类C语言的脚本引擎(5)作者 :kevin_qing转贴请注明语法检查,常量合并和生成语法树是在reduce规约函数中实现语法树节点定义struct GTreeNode{uint32_t type; uint32_t value;};struct GTreeNode1:public GTreeNode{GTreeNode* child1;};struct GTreeNode2:public
编译原理实验二------基于LL(1)方法的语法分析程序
Mr1998520的博客
11-20 5080
目的：设计、编制和调试一个典型的语法分析方法，进一步掌握常用的语法分析方法。 要求： （1）根据LL(1)分析法编写一个语法分析程序，可根据自己实际情况，选择以下一项作为分析算法的输入： a.直接输入根据已知文法构造的分析表M; b.输入文法的FIRST(α)和FOLLOW(U)集合，由程序自动生成文法的分析表M； c.输入已知文法，由程序自动构造文法的分析表M。 (2)程序具有通用性...
Keysight N9000B CXA 信号分析仪器的用户手册。
05-05
您可以在Keysight官网上找到N9000B CXA信号分析仪器的用户手册。 以下是步骤： 1. 打开Keysight官网（https://www.keysight.com/zh_CN/index.html）。 2. 在搜索框中输入“N9000B CXA”。 3. 点击“搜索”。 4. 在搜索结果中找到“N9000B CXA系列 X 系列信号分析仪”，并点击进入产品页面。 5. 在页面中找到“文献”一栏，点击“用户手册”。 6. 您将被引导到一个新页面，其中包含了所有可用的用户手册和快速入门指南。选择您需要的语言和版本，然后点击下载按钮即可获取用户手册。 希望这能帮到您！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值