编译原理实验（2）——递归下降语法分析器

最新推荐文章于 2024-05-22 22:41:19 发布
最新推荐文章于 2024-05-22 22:41:19 发布
阅读量6.9k 收藏 65
点赞数 5
分类专栏： 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43423892/article/details/102888355
版权

编译实验——递归下降语法分析器

实验内容：

根据课堂讲授的形式化算法，编制程序实现递归下降分析器，能对常见的语句进行分析。
要求实现以下语法的递归下降分析：
在这里插入图片描述

算法分析：

1. 算法设计：

  • 递归下降的语法分析首先应该消除左递归和提取左公因子，从逻辑上检测避免死循环和低效处理，得到产生式如下：

    program -> block
    block -> {stmts}
    stmts -> stmt stmts|null
    stmt -> id=expr;|if(bool)stmt stmt1|while(bool)stmt|do stmt while(bool)|break|block
    stmt1 -> null|else stmt
    bool -> expr bool1
    bool1 -> <expr|<=expr|>expr|>=expr|null
    epxr -> term expr1
    expr1 -> +term expr1|-term expr1|null
    term -> factor term1
    term1 -> *factor term1|/factor term1|null
    factor -> (expr)|id|num

  • 将实验一词法分析器的输出文件token.txt作为输入，逐个读入单词，采用每个产生式的左边的文法符号对应一个函数的形式，实现递归下降分析器。

  • 将最左推导的过程逐步完整输出，具体实现方式是将上一行的输出存储在一个字符串变量Ans中，每次用产生式的右部替换字符串最左非终结符再输出。
    这一步利用到了C++ stl中string头文件中定义的函数erase(),insert(),find()。
    以推导步骤stmts --> stmt stmts为例 ：
    在这里插入图片描述
    2. 输出展示：
    在这里插入图片描述

源代码

#include<iostream>
#include<fstream>
#include<sstream>
#include<string>
#include<algorithm>
using namespace std;
int sym[10000];
string token[10000];
string Ans;
int Pos;
int p = 0;//p指向当前正在处理的单词
int flag = 0;
void error();
void program();
void block();
void stmts();
void stmt();
void stmt1();
void booL();
void booL1();
void expr();
void expr1();
void term();
void term1();
void factor();
/*
根据上一实验词法分析器规定：

保留字，一符一类，种类码0~21：
"if","else","while","do","break","main","int","float","double","return","const","void","continue","char","unsigned","enum","long","switch","case","unsigned","auto","static"

特殊符号，一符一类，种类码22~38，种类码39~44为==,!=,&&,||,>=,<=：
"+","-",",","/","=","<",">","{","}",";","(",")","&","!","#","[","]"

ID，种类码101

数字，种类码98~100(十进制，八进制，十六进制)
*/
int main()
{
	ifstream file("token.txt", ios::in);
	if (!file)
	{
		cerr << "文件打开失败！" << endl;
		exit(1);
	}
	char ch;
	string source="";
	file.get(ch);
	do {
		source += ch;
		file.get(ch);
	} while (!file.eof());
	stringstream ss(source);
	int i = 0;
	while (ss>>sym[i])
	{
		ss >> token[i];
		//cout << sym[i] << " " << token[i] << endl;
		i++;
	}
	program();
	if (flag == 0)
		cout << "\n语法分析成功！" << endl;
	return 0;
}
void error()
{
	cout << "语法分析出错！" << endl;
}
void program()
{
	cout << "program";
	Ans = "--> block\n       ";
	cout << Ans;
	block();
}
void block()
{
	if (token[p++] == "{")
	{
		//cout << "block --> { stmts }" << endl;
		Pos = Ans.find("block");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "{stmts}");
		cout << Ans;
		stmts();
		if (flag == 1)
		{
			error();
			return;
		}
		if (token[p++] != "}")
			error();
	}
	else
		error();
}
void stmts()
{
	if (sym[p] == 101 || token[p] == "if" || token[p] == "while" || token[p] == "do" || token[p] == "break" || token[p] == "{")
	{
		//cout << "stmts --> stmt stmts" << endl;
		Pos = Ans.find("stmts");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "stmtstmts");
		cout << Ans;
		stmt();
		if (flag == 1) return;
		stmts();
		if (flag == 1) return;
	}
	else
	{
		//cout << "stmts --> null" << endl;
		Pos = Ans.find("stmts");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "");
		cout << Ans;
		return;
	}	
}
void stmt()
{
	if (sym[p] == 101)
	{
		//cout << "stmt --> id = expr ;" << endl;
		Pos = Ans.find("stmt");
		Ans.erase(Pos, 4);
		Ans.insert(Pos, "id=expr;");
		cout << Ans;
		p++;
		if (token[p++] == "=")
		{
			expr();
			if (flag == 1) return;
			if (token[p++] != ";")
				flag = 1;
		}
		else
			flag = 1;
	}
	else if (token[p] == "while")
	{
		//cout << "stmt --> while (bool) stmt" << endl;
		Pos = Ans.find("stmt");
		Ans.erase(Pos, 4);
		Ans.insert(Pos, "while(bool)stmt");
		cout << Ans;
		p++;
		if (token[p++] == "(")
		{
			booL();
			if (token[p++] == ")")
			{
				stmt();
				if (flag == 1) return;
			}
			else
				flag = 1;
		}
		else
			flag = 1;
	}
	else if (token[p] == "do")
	{
		//cout << "stmt --> do stmt while (bool)" << endl;
		Pos = Ans.find("stmt");
		Ans.erase(Pos, 4);
		Ans.insert(Pos, "dostmtwhile(bool)"); 
		cout << Ans;
		p++;
		stmt();
		if (flag == 1) return;
		if (token[p++] == "while" && token[p++] == "(")
		{
			booL();
			if (flag == 1) return;
			if (token[p++] != ")")
				flag = 1;
		}
		else
			flag = 1;
	}
	else if (token[p] == "break")
	{
		//cout << "stmt --> break" << endl;
		Pos = Ans.find("stmt");
		Ans.erase(Pos, 4);
		Ans.insert(Pos, "break");
		cout << Ans;
		p++;
	}
	else if (token[p] == "{")
	{
		//cout << "stmt --> block" << endl;
		Pos = Ans.find("stmt");
		Ans.erase(Pos, 4);
		Ans.insert(Pos, "block");
		cout << Ans;
		block();
	}
	else if (token[p++] == "if" && token[p++] == "(")
	{
		//cout << "stmt --> if (bool) stmt stmt1" << endl;
		Pos = Ans.find("stmt");
		Ans.erase(Pos, 4);
		Ans.insert(Pos, "if(bool)stmt stmt1");
		cout << Ans;
		stmt();
		if (flag == 1) return;
		stmt1();
		if (flag == 1) return;
	}
	else
		flag = 1;
}
void stmt1()
{
	if (token[p++] == "else")
	{
		//cout << "stmt1 --> else stmt" << endl;
		Pos = Ans.find("stmt1");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "else stmt");
		cout << Ans;
		stmt();
		if (flag == 1) return;
	}
	else
		return;
}
void booL()
{
	//cout << "bool --> expr bool1" << endl;
	Pos = Ans.find("bool");
	Ans.erase(Pos, 4);
	Ans.insert(Pos, "exprbool1");
	cout << Ans;
	expr();
	if (flag == 1) return;
	booL1();
	if (flag == 1) return;
}
void booL1()
{
	if (token[p] == "<" || token[p] == "<=" || token[p] == ">" || token[p] == ">=")
	{
		//cout << "bool1 --> " << token[p] << " expr" << endl;
		Pos = Ans.find("bool1");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, token[p]+"expr");
		cout << Ans;
		p++;
		expr();
		if (flag == 1) return;
	}
}
void expr()
{
	//cout << "expr --> term expr1" << endl;
	Pos = Ans.find("expr");
	Ans.erase(Pos, 4);
	Ans.insert(Pos, "termexpr1");
	cout << Ans;
	term();
	if (flag == 1) return;
	expr1();
	if (flag == 1) return;
}
void expr1()
{
	if (token[p] == "+")
	{
		//cout << "expr1 --> + term" << endl;
		Pos = Ans.find("expr1");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "+term");
		cout << Ans;
		p++;
		term();
		if(flag == 1) return;
	}
	else if (token[p] == "-")
	{
		//cout << "expr1 --> - term" << endl;
		Pos = Ans.find("expr1");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "-term");
		cout << Ans;
		p++;
		term();
		if (flag == 1) return;
	}
	else
	{
		//cout << "expr1 --> null" << endl;
		Pos = Ans.find("expr1");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "");
		cout << Ans;
		return;
	}
}
void term()
{
	//cout << "term --> factor term1" << endl;
	Pos = Ans.find("term");
	Ans.erase(Pos, 4);
	Ans.insert(Pos, "factorterm1");
	cout << Ans;
	factor();
	if (flag == 1) return;
	term1();
	if (flag == 1) return;
}
void term1()
{
	if (token[p] == "*")
	{
		//cout << "term1 --> * factor" << endl;
		Pos = Ans.find("term1");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "*factor");
		cout << Ans;
		p++;
		factor();
		if (flag == 1) return;
	}
	else if (token[p] == "/")
	{
		//cout << "term1 --> / factor" << endl;
		Pos = Ans.find("term1");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "/factor");
		cout << Ans;
		p++;
		factor();
		if (flag == 1) return;
	}
	else
	{
		//cout << "term1 --> null" << endl;
		Pos = Ans.find("term1");
		Ans.erase(Pos, 5);
		Ans.insert(Pos, "");
		cout << Ans;
		return;
	}
}
void factor()
{
	if (token[p] == "(")
	{
		//cout << "factor --> (expr)" << endl;
		Pos = Ans.find("factor");
		Ans.erase(Pos, 6);
		Ans.insert(Pos, "(expr)");
		cout << Ans;
		p++;
		expr();
		if (flag == 1) return;
		if (token[p++] != ")")
			flag = 1;
	}
	else if (sym[p] == 101)
	{
		//cout << "factor --> id" << endl;
		Pos = Ans.find("factor");
		Ans.erase(Pos, 6);
		Ans.insert(Pos, "id");
		cout << Ans;
		p++;
	}
	else if (sym[p] >= 98 && sym[p] <= 100)
	{
		//cout << "factor --> num" << endl;
		Pos = Ans.find("factor");
		Ans.erase(Pos, 6);
		Ans.insert(Pos, "num");
		cout << Ans;
		p++;
	}
	else
		flag = 1;
}
Tnut
关注
  • 5
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++实现递归下降语法分析器（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-26 567
C++实现递归下降语法分析器（附完整源码）
编译原理之语法分析（自顶向下递归下降法 Pl/0语言文法 打印语法树）
勿忘初心的博客
11-28 6049
先调用词法分析程序后将单词保存到一个全局的字符串数组result中，并声明全局int变量ip，指向当前的单词下标，然后调用程序函数，即可完成一步步的递归，最后分析出能否规约为一颗语法树。 下面的代码是语法分析部分： /函数声明 void subProgram(); void conExplain(); void varExplain(); void processExplain();...
编译原理实验-递归下降的方法实现语法分析器
09-22
（使用Python实现，注释详尽）在词法分析器的基础上，采用递归下降的方法实现算术表达式的语法分析器，以加深对自上而下语法分析过程的理解。 1、对算术表达式文法： E→TE' E'→+TE'| -TE' |ε T→FT' T'→*FT'| /FT' |ε F→(E) | id |num 构造其递归下降分析程序。
编译原理实验3 递归下降法的语法分析器
qq_43527659的博客
12-29 5510
实验3 递归下降法的语法分析器 一、实验目的 学习用递归下降法构造语法分析器的原理，掌握递归下降法的编程方法。 二、实验内容 用递归下降法编写一个语法分析程序，使之与词法分析器结合，能够根据语言的上下文无关文法，识别输入的单词序列是否文法的句子。 这里只要求实现部分产生式，文法的开始符号为program。 program → block block → { stmts } stmts →stmt stmts |  stmt → id = expr ; | if ( bool ) stmt | i
编译原理-语法分析器的设计与实现（递归下降）
最新发布
m0_64847413的博客
05-22 1861
预测分析法（LL(1)方法）的基本思想是：从文法开始符S 出发，从左到右扫描源程序，每次通过向前查看 1 个字符，选择合适的产生式，生成句子的最左推导。自顶向下分析也称面向目标的分析方法，也就是从文法的开始符出发，试图推导出与输入单词串相匹配的句子，分为确定的自顶向下分析和不确定的自顶向下分析两种，LL分析法属于确定的自顶向下分析。但是实验平台事先给出的各个子程序的命名与非终结符却不对应，导致在编写代码时十分的别扭，可以把每个子函数的名字都改成与非终结符相同的符号。用于跟踪当前在分析的输入字符串的位置。
递归下降分析程序，识别if语句，赋值表达式，逻辑表达式，布尔表达式，带java源码
weixin_41705703的博客
05-13 4199
实验要求： 1、[实验项目] 完成以下描述赋值语句的LL(1)文法的递归下降分析程序 G[S]： S→V=E E→TE′ E′→ATE′|ε T→FT′ T′→MFT′|ε F→ (E)|i A→+|- M→*|/ V→i 2、[设计说明] 终结符号i为用户定义的简单变量，即标识符的定义。 3、[设计要求] （1）输入串应是词法分析的输出二元式序列，即某算术表达式“专题1”的输出结果，输出为输...
编译原理五：语法分析
to_the_Future的博客
07-04 4302
上下文无关文法（Context-Free Grammar，CFG）是一种形式语言，它可以用于描述一类特定的语言结构。CFG 的一个典型应用是在编译器中，用于描述编程语言的语法规则。在 CFG 中，一个非终结符号可以被表示为一组产生式，每个产生式由一个非终结符号和若干个终结符号组成。终结符号非终结符号产生式和开始符号。终结符号是 CFG 中的最基本元素，它表示语言中的一个基本单元，如数字、标识符、运算符等。非终结符号表示语言中的一个复合单元，它可以由一个或多个终结符号或其他非终结符号组成。
编译原理-递归下降语法分析器（Java）
热门推荐
natural_live的博客
04-25 2万+
递归下降语法分析器：判断语法是否正确。 以简单的加减乘除和括号为例。首先我们先分析它的语法。 括号要有一对出现，不能出现单个括号不能出现连续的算术符号，比如两个加号必须以字符开头和字符结尾 我们算术表达式默认的是变量都为字符，不为数字。比如a+b，a*(a+b)。 递归下降的语法分析的思想是：分为几个子程序，每个子程序对应一个非终结符。 每一个子程序的功能是：
东北大学2022编译原理实验课——递归下降分析简单算术表达式（C++）
05-11
东北大学2022编译原理实验课——递归下降分析简单算术表达式（C++） 【问题描述】 1．设计简单算数表达式语法分析器算法；（用递归下降分析来实现） 2．编写代码并上机调试运行通过。 【输入形式】 简单算数表达式 ...
杭电编译原理实验——递归下降分析子程序
09-20
本实验“杭电编译原理实验——递归下降分析子程序”旨在帮助学生深入理解和掌握这一核心概念。 1. **递归下降分析概述**：递归下降分析是一种自顶向下的解析策略，它通过将文法规则转化为一系列的函数，每个函数...
编译原理实验课程设计 ——词法语法分析综合设计.rar
06-07
本次实验采用C语言编写词法语法分析器，要求通过数字调用之前做的两次手动实验。通过输入数字1，实现C语言子集符号的识别，通过输入数字2，对之前输入的单词符号进行语法分析。词法分析通过状态转换图实现，语法分析...
编译原理递归下降实验和报告
06-02
一、实验目的： 根据某一文法编制调试递归下降分析程序，以便对任意输入的符号串进行分析。本次实验的目的主要是加深对递归下降分析法的理解。 二、实验预习提示 1、递归下降分析法的功能 词法分析器的功能是利用函数之间的递归调用模拟语法树自上而下的构造过程。 2、递归下降分析法的前提 改造文法：消除二义性、消除左递归、提取左因子，判断是否为LL（1）文法， 3、递归下降分析法实验设计思想及算法 为G的每个非终结符号U构造一个递归过程,不妨命名为U。 U的产生式的右边指出这个过程的代码结构： (1)若是终结符号，则和向前看符号对照， 若匹配则向前进一个符号；否则出错。 (2)若是非终结符号，则调用与此非终结符对应的过程。当A的右部有多个产生式时,可用选择结构实现。 具体为： （1）对于每个非终结符号U->u1|u2|…|un处理的方法如下： U( ) { ch=当前符号; if(ch可能是u1字的开头) 处理u1的程序部分; else if(ch可能是u2字的开头)处理u2的程序部分; … else error() }
编译原理——语法分析器（递归下降分析法 ）
05-05
词法分析器的功能是利用函数之间的递归调用模拟语法树自上而下的构造过程。 2、递归下降分析法的前提 改造文法：消除二义性、消除左递归、提取左因子，判断是否为LL（1）文法， 3、递归下降分析法实验设计思想及算法...
编译原理实验二——算符优先分析法设计与实现
08-29
- **分析程序**：使用算符优先分析法进行语法分析，可能涉及递归下降解析或使用栈操作。 - **表达式求值**：实现表达式的计算逻辑，例如，对于算术表达式，可能需要一个求值函数来处理运算符的优先级和结合性。 - **...
自己动手写编译器:中间代码生成1
tyler_download的专栏
04-17 1896
我们到了简单编译器开发的最后一个阶段，也就是生成中间代码。以前我们提到过编译器分为两部分，分别为前端和后端，所谓前端就是将代码转译成中间语言，后端负责进行优化和转译成目标平台的机器指令，现在我们来到了前端的最后一个阶段。由于中间代码生成是当前所有阶段中逻辑最为复杂的部分，因此我们需要将其分解成多个容易理解的小部分，逐个击破。我们的计划是这样，首先完成比较简单的代码的中间代码生成，然后不断的提升目标代码的复杂度，然后生成更加复杂的中间代码。 本节我们要完成的如下目标代码的中间代码生成： { int a; in
一个完整的编译器前端-A.1 源语言
dengtiaolu0407的博客
01-17 243
这个语言的一个程序由一个块组成，该块中包含可选的声明和语句。语法符号basic表示基本类型。 program –> block block –> { decls stmts } decls -> desls decl | ε decl -> type id; type -> type [num] | basic stmts...
递归下降语法分析
weixin_47500703的博客
07-04 1552
递归下降语法分析
编译原理-5-LL(1)语法分析器
SpriCoder的博客
02-26 8894
5-LL(1)语法分析器
编译原理——语法分析器（C/C++代码实现）
qq_58773908的博客
01-03 1万+
根据编译原理理论课中学习的算术表达式文法，以及该文法LL（1）分析表，用C语言编写接受算术表达式为输入的语法分析器，以控制台（或文本文件，也可以结合词法分析器完成）为输入，控制台（或文件）输出产生式序列形式的分析结果。
编译原理实验2——语法分析java
05-23
语法分析是编译原理中的重要部分，它的作用是将词法分析阶段得到的词法单元序列转换成抽象语法树（AST）或语法分析树（Parse Tree），以便于后续的语义分析、中间代码生成和目标代码生成等环节的进行。在本次实验中，我们将使用Java语言实现一个简单的语法分析器。 实验要求： 1. 实现自顶向下的递归下降分析器。 2. 支持的文法如下： ``` <program> ::= <stmts_list> <stmts_list> ::= <stmt> | <stmts_list> <stmt> <stmt> ::= <if_stmt> | <while_stmt> | <assign_stmt> <if_stmt> ::= if <condition> then <stmts_list> end <while_stmt> ::= while <condition> do <stmts_list> end <assign_stmt> ::= <id> = <expr> <condition> ::= <expr> <relop> <expr> <expr> ::= <term> | <expr> <addop> <term> <term> ::= <factor> | <term> <mulop> <factor> <factor> ::= <id> | <number> | '(' <expr> ')' <relop> ::= '<' | '>' | '=' | '<=' | '>=' | '<>' <addop> ::= '+' | '-' <mulop> ::= '*' | '/' <id> ::= <letter> | <id> <letter> | <id> <digit> <number> ::= <digit> | <number> <digit> <letter> ::= A | B | ... | Z | a | b | ... | z <digit> ::= 0 | 1 | ... | 9 ``` 注意：文法中的关键字 if、then、end、while、do、and 等均为保留字。 3. 实现的语法分析器应具备以下功能： - 能够识别出语法正确的程序，并输出相应的语法分析树或抽象语法树。 - 能够识别出语法错误的程序，并给出相应的错误提示信息。 - 能够处理注释和空格等无意义的字符。 4. 实验提交要求： - 实验报告，包括程序设计和实验结果分析。 - 程序源代码。 实验设计思路： 1. 根据给定的文法，设计语法分析器的语法规则和对应的产生式。 2. 编写相应的Java代码，将文法转换为递归下降分析器所需要的形式。 3. 实现从输入的源代码中读取词法单元序列的功能。 4. 实现递归下降分析器的核心算法，对输入的词法单元序列进行语法分析，并构建相应的语法分析树或抽象语法树。 5. 在语法分析过程中，需要处理注释和空格等无意义的字符，以便于正确识别语法错误。 6. 在语法分析过程中，需要对输入的源代码进行错误检查，并给出相应的错误提示信息。 7. 输出语法分析树或抽象语法树，以便于后续的语义分析、中间代码生成和目标代码生成等环节的进行。 实验结果分析： 经过实验测试，我们的语法分析器能够正确地识别出合法的程序，并输出相应的语法分析树或抽象语法树。同时，它也能够正确地识别出语法错误的程序，并给出相应的错误提示信息。总的来说，本次实验取得了较好的实验效果。 实验源代码： 见下方代码框：

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值