实验二 语法分析1——递归子程序法

已于 2022-05-19 15:25:11 修改
阅读量5.3k 收藏 46
点赞数 6
分类专栏： 编译原理 文章标签： 编译原理 语法分析 c++
于 2022-04-15 11:08:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45816954/article/details/124190233
版权

目的和内容

1、 实验目的：通过完成语法分析程序，了解语法分析的过程和作用
2、 实验内容：用递归子程序法实现对pascal的子集程序设计语言的分析程序
3、 实验要求：对源程序的内码流进行分析，如为文法定义的句子输出”是”否则输出”否”,根据需要处理说明语句填写写相应的符号表供以后代码生成时使用

文法的改变

为适合递归子程序法，对实验一中的文法改写成无左递归和无左共因子的ＢＮＦ如下：
<程序>→<程序首部><分程序>.
<程序首部>→PROGRAM标识符；
<分程序>→<常量说明部分><变量说明部分><过程说明部分> <复合语句>
<常量说明部>→CONST<常量定义><常量定义后缀> |ε
<常量定义>→标识符=无符号整数
<常量定义后缀>→，<常量定义><常量定义后缀> |ε
<变量说明部分>→VAR<变量定义><变量定义后缀> |ε
<变量定义>→标识符<标识符后缀>：<类型>；
<标识符后缀>→，标识符<标识符后缀> |ε
<变量定义后缀>→<变量定义><变量定义后缀> |ε
<类型>→INTEGER | LONG
<过程说明部分>→<过程首部><分程序>；<过程说明部分后缀>|ε
<过程首部>→PROCEDURE标识符<参数部分>；
<参数部分>→(标识符： <类型>)|ε
<过程说明部分后缀>→<过程首部><分程序>；<过程说明部分后缀>|ε
<语句>→<赋值或调用语句>|<条件语句>|<当型循环语句>|<读语句>
|<写语句>|<复合语句>|ε
<赋值或调用语句>→标识符<后缀>
<后缀>→：=<表达式>|(<表达式>)|ε
<条件语句>→IF<条件>THEN<语句>
<当型循环语句>→WHILE<条件>DO <语句>
<读语句>→READ（标识符<标识符后缀>）
<写语句>→WRITE（<表达式><表达式后缀>）
<表达式后缀>→，<表过式><表达式后缀>|ε
<复合语句>→BEGIN<语句><语句后缀>END
<语句后缀>→；<语句><语句后缀>|ε
<条件>→<表达式><关系运算符><表达式>|ODD<表达式>
<表达式>→+<项><项后缀>|-<项><项后缀>|<项><项后缀>
<项后缀>→<加型运算符><项><项后缀>|ε
<项>→<因子><因子后缀>
<因子后缀>→<乘型运算符><因子><因子后缀>|e
<因子>→标识符|无符号整数|（<表达式>）
<加型运算符>→+|-
<乘型运算型>→*|/
<关系运算符>→ =|<>|<|<=|>|>=

非终结符和函数名对照表

为适用递归子程序，下表为非终结符和函数名对照表

非终结符

函数名

非终结符

函数名

<程序>

program

<程序首部>

proghead

<分程序>

block

<常量说明部分>

consexpl

<常量定义>

consdefi

<变量说明部分>

varexl

<常量定义后缀>

conssuff

<变量定义>

vardefi

<变量定义后缀>

varsuff

<>过程说明部分>

procdefi

<类型>

typeil

<过程首部>

procedh

<过程说明部分后缀>

procsuff

<赋值或调用语句>

assipro

<语句>

sentence

<后缀>

suffix

<条件语句>

ifsent

<读语句>

read

<当型循环语句>

whilsent

<标识符后缀>

idsuff

<写语句>

Write

<复合语句>

compsent

<表达式后缀>

Exprsuff

<语句后缀>

sentsuff

<条件>

Conditio

<项后缀>

termsuff

<表达式>

Express

<项>

term

<因子后缀>

Factsuff

<参数部分>

argument

<因子>

Factor

<加型运算符>

addoper

<乘型运算符>

Muloper

<关系运算符>

respoper

递归子程序的设计思想

为每个非终结符设计一个识别的子程序，寻找该非终结符也就是调用相应的子程序。由于单词在语法分析中作为一个整体，故在语法识别中仅使用其内码。在这里将词法分析作为语法分析的一个子程序，当语法分析需要单词时，就调用相应的词法分析程序获得一个单词。语法分析的作用是识别输入符号串是否是文法上定义的句子，即判断输入符号串是否是满足“程序”定义的要求。也就是当语法识别程序从正常退出表示输入符号串是正确的“程序”；若从出错退出，则输入符号串不是正确的“程序”。出错时，可以根据读字符的位置判断出错的位置。

实验流程

下面是部分子程序的流程图
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验代码

#include<bits/stdc++.h>
using namespace std;
#define PROGRAM 1
#define CONST 2
#define VAR 3
#define INTEGER 4
#define LONG 5
#define PROCEDURE 6
#define IF 7
#define THEN 8
#define WHILE 9
#define DO 10
#define READ 11
#define WRITE 12
#define BEGIN 13
#define END 14
#define ODD 15
#define ADD 16
#define SUB 17
#define MUL 18
#define DIV 19
#define EQU 20
#define NEQ 21
#define LES 22
#define LEQ 23
#define LAG 24
#define GEQ 25
#define DOT 26
#define COM 27
#define SEM 28
#define COL 29
#define ASS 30
#define LBR 31
#define RBR 32
#define INT 33
#define ID 34
#define EIN 35
#define lenth1 15
#define lenth2 17
struct Ident
{
	char name[21];
	int type;
	int addr;
};
Ident indent[1000]; // 定义标识符表
struct St
{
	char name[21];
	int code;
};
St sym;

int lenth = 0;  // 表示标识符表长度
FILE* f1, * f2; //f1、f2分别指向输入输出文件

int line = 0, row = 0, val;
void getsym();char getchr();void error(int);
void program(); void proghead();
void block(); void consexpl();
void consdefi(); void varexpl();
void conssuff(); void vardefi();
void varsuff(); void procdefi();
void typeil(); void procedh();
void procsuff(); void assipro();
void sentence(); void suffix();
void ifsent(); void read();
void whilsent(); void idsuff();
void write(); void compsent();
void exprsuff(); void sentsuff();
void conditio(); void termsuff();
void express(); void term();
void factsuff(); void argument();
void factor(); void addoper();
void muloper(); void respoper();

int main(int argc, char* argv[]) {
	if ((f1 = fopen(argv[1], "r")) == NULL) {  // 打开输入文件流
		cout << "can not open the input file!" << endl;
		exit(0);
	}
	getsym();
	program();
	cout << "该程序通过语法分析！" << endl;
	fclose(f1);
	return 0;
}

void getsym() {
	static char a[lenth1][10] = {
		"program","const","var","integer","long","procedure","if",
		"then","while","do","read","write","begin","end","odd"
	},
		d[lenth2][3] = { "+","-","*","/","=","<>","<","<=",">",">=",
						".",",",";",":",":=","(",")" },
		str[21], ch = ' ';
	int i, n; // n判断单词长度,i判断是哪个关键字
	while (isspace(ch))
	{
		ch = getchr();
	}
	if (isalpha(ch)) { //判断字母开头的字符
		n = 0;
		while (isalpha(ch) || isdigit(ch)) {
			if (isalpha(ch))
				ch = tolower(ch);
			str[n++] = ch;
			ch = getchr();
		}
		str[n] = '\0';
		for (i = 0;i < lenth1;i++) {
			if (!strcmp(str, a[i]))
				break;
		}
		if (i < lenth1) { //找到匹配关键字
			strcpy(sym.name, a[i]);
			sym.code = i + 1;
		}
		else {
			for (i = 0;i < lenth;i++) { //遍历已记录的标识符记录表
				if (!strcmp(str, indent[i].name))
					break;
			}
			if (i == lenth) {
				strcpy(indent[i].name, str);
			}
			strcpy(sym.name, indent[i].name);
			sym.code = 34;
		}
	}
	else if (isdigit(ch)) { // 判断数字开头的字符
		val = 0;n = 0;
		while (isdigit(ch)) {
			val = val * 10 + ch - '0';
			sym.name[n++] = ch;
			ch = getchr();
		}
		sym.name[n] = '\0';
		sym.code = 33;
	}
	else {  // 判断特殊字符
		if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '=' ||
			ch == '.' || ch == ',' || ch == ';' || ch == '(' || ch == ')') {
			str[0] = ch; str[1] = '\0';
			ch = getchr();
			for (i = 0;i < lenth2;i++) {
				if (!strcmp(str, d[i])) {
					strcpy(sym.name, str);
					sym.code = i + 16;
					break;
				}
			}
		}
		else if (ch == '#') {
			str[0] = ch; str[1] = '\0';
			ch = getchr();
			strcpy(sym.name, str);
			sym.code = 35;
		}
		else if (ch == '<') {
			char b = getchr();
			if (b == '>') {
				str[0] = '<';str[1] = '>';str[2] = '\0';
				strcpy(sym.name, str);
				sym.code = 21;
				ch = getchr();
			}
			else if (b == '=') {
				str[0] = '<';str[1] = '=';str[2] = '\0';
				strcpy(sym.name, str);
				sym.code = 23;
				ch = getchr();
			}
			else {
				str[0] = '<';str[1] = '\0';
				strcpy(sym.name, str);
				sym.code = 22;
				ch = b;
			}
		}
		else if (ch == '>') {
			char b = getchr();
			if (b == '=') {
				str[0] = '>';str[1] = '=';str[2] = '\0';
				strcpy(sym.name, str);
				sym.code = 25;
				ch = getchr();
			}
			else {
				str[0] = '>';str[1] = '\0';
				strcpy(sym.name, str);
				sym.code = 24;
				ch = b;
			}
		}
		else if (ch == ':') {
			char b = getchr();
			if (b == '=') {
				str[0] = ch;str[1] = b;str[2] = '\0';
				strcpy(sym.name, str);
				sym.code = 30;
				ch = getchr();
			}
			else {
				str[0] = ch;str[1] = '\0';
				strcpy(sym.name, str);
				sym.code = 29;
				ch = b;
			}
		}
	}
}


char getchr() {  // 从文件中获取下一个非空字符
	char ch = fgetc(f1);
	if (ch == '\n') {
		row = 1;
		line++;
	}
	else {
		if (ch != ' ' && ch != '\t') {
			row++;
		}
	}
	return ch;
}

void error(int n) {
	printf("There are %d-error\n", n);
	exit(0);
}

void program() { // 程序
	proghead();block();
	cout<<sym.code<<" "<<sym.name<<endl;
	cout<<!feof(f1)<<endl;
	if (sym.code == DOT && feof(f1)) {
		return ;
	}
	else {
		error(2);
	}
}

void proghead() { // 程序首部
	if (sym.code == PROGRAM) {
		getsym(); // 获取next token
		if (sym.code == ID) {
			getsym();
			if (sym.code == SEM)
				getsym();
			else
				error(5);
		}
		else
			error(4);
	}
	else
		error(3);
}

void block() {  // 分程序
	consexpl();
	varexpl();
	procdefi();
	compsent();
}

void consexpl() { // 常量说明部分
	if (sym.code == CONST) {
		getsym();
		consdefi();
		conssuff();
		if (sym.code == SEM)
			getsym();
		else
			error(6);
	} // 无else表示可以为空
}

void consdefi() {   // 常量定义
	if (sym.code == ID) {
		getsym();
		if (sym.code == EQU) {
			getsym();
			if (sym.code == INT)
				getsym();
			else
				error(9);
		}
		else
			error(8);
	}
	else
		error(7);
}

void conssuff() {  // 常量定义后缀
	if (sym.code == COM) {
		getsym();
		consdefi();
		conssuff();
//		if (sym.code == SEM)
	//		getsym();
		//else
			//error(10);
	}// 无else表示可以为空
}
void varexpl() {  // 变量说明部分
	if (sym.code == VAR) {
		getsym();
		vardefi();
		varsuff();
	}// 无else表示可以为空
}

void vardefi() {  // 变量定义
	if (sym.code == ID) {
		getsym();
		idsuff();
		if (sym.code == COL) {
			getsym();
			typeil();
			if (sym.code == SEM)
				getsym();
			else
				error(12);
		}
		else
			error(11);
	}
	//	else
	//		error(10);
}

void varsuff() {
	if (sym.code == ID) {
		vardefi();
		varsuff();
	}// 无else表示可以为空
}

void typeil() {
	if (sym.code == INTEGER || sym.code == LONG)
		getsym();
	else
		error(13);
}

void procdefi() {
	if (sym.code == PROCEDURE)
	{
		procedh();
		block();
		if (sym.code == SEM) {
			procsuff();
		}
		else
			error(14);
	}// 无else表示可以为空
}

void procedh() {
	if (sym.code == PROCEDURE) {
		getsym();
		if (sym.code == ID) {
			getsym();
			argument();
			if (sym.code == SEM)
				getsym();
			else
				error(16);
		}
		else
			error(15);
	}
}

void argument() {
	if (sym.code == LBR) {
		getsym();
		if (sym.code == ID) {
			getsym();
			if (sym.code == COL) {
				getsym();
				if (sym.code == RBR)
					getsym();
				else
					error(19);
			}
			else
				error(18);
		}
		error(17);
	}
}

void procsuff() {
	if (sym.code == PROCEDURE) {
		procedh();
		block();
		if (sym.code == SEM) {
			getsym();
			procsuff();
		}
		else
			error(20);
	}
}

void assipro() {
	if (sym.code == ID) {
		getsym();
		suffix();
	}
	else
		error(21);
}

void sentence() {
	if (sym.code == ID) {
		assipro();
	}
	else if (sym.code == IF) {
		ifsent();
	}
	else if (sym.code == WHILE)
		whilsent();
	else if (sym.code == READ)
		read();
	else if (sym.code == WRITE)
		write();
	else if (sym.code == BEGIN)
		compsent();
}

void suffix() {
	if (sym.code == ASS) {
		getsym();
		express();
	}
	else if (sym.code == LBR) {
		getsym();
		express();
		if (sym.code == RBR)
			getsym();
		else error(22);
	}
}

void ifsent() {
	if (sym.code == IF) {
		getsym();
		conditio();
		if (sym.code == THEN) {
			getsym();
			sentence();
		}
		else
			error(24);
	}
	else
		error(23);
}

void whilsent() {
	if (sym.code == WHILE) {
		getsym();
		conditio();
		if (sym.code == DO) {
			getsym();
			sentence();
		}
		else
			error(26);
	}
	else
		error(25);
}

void read() {
	if (sym.code == READ) {
		getsym();
		if (sym.code == LBR) {
			getsym();
			if (sym.code == ID) {
				getsym();
				idsuff();
				if (sym.code == RBR)
					getsym();
				else error(27);
			}
			else
				error(30);
		}
		else error(29);
	}
	else error(28);
}

void idsuff() {
	if (sym.code == COM) {
		getsym();
		if (sym.code == ID) {
			getsym();
			idsuff();
		}
		else
			error(30);
	} // 无else表示可以为空
}

void write() {
	if (sym.code == WRITE) {
		getsym();
		if (sym.code == LBR) {
			getsym();
			express();
			exprsuff();
			if (sym.code == RBR)
				getsym();
			else error(34);
		}
		else error(33);
	}
	else error(32);
}

void compsent() {
	if (sym.code == BEGIN) {
		getsym();
		sentence();
		sentsuff();
		if (sym.code == END)
			getsym();
		else error(36);
	}
	else error(35);
}

void exprsuff() {
	if (sym.code == COM) {
		getsym();
		express();
		exprsuff();
	}
}

void sentsuff() {
	if (sym.code == SEM) {
		getsym();
		sentence();
		sentsuff();
	}
}

void conditio() {
	if (sym.code == ODD) {
		getsym();
		express();
	}
	else {
		express();
		respoper();
		express();
	}
}

void express() {
	if (sym.code == ADD || sym.code == SUB)
		getsym();
	term();
	termsuff();
}

void term() {
	factor();
	factsuff();
}

void termsuff() {
	if (sym.code == ADD || sym.code == SUB) {
		getsym();
		factor();
		factsuff();
	}
}

void factsuff() {
	if (sym.code == MUL || sym.code == DIV) {
		getsym();
		factor();
		factsuff();
	}
}

void factor() {
	if (sym.code == ID) {
		getsym();
//		factsuff();
	}
	else if (sym.code == INT) {
		getsym();
	}
	else if (sym.code == LBR) {
		getsym();
		express();
		if (sym.code == RBR)
			getsym();
		else error(38);
	}
	else error(37);
}

void addoper() {
	if (sym.code == ADD || sym.code == SUB)
		getsym();
	else
		error(39);
}

void muloper() {
	if (sym.code == MUL || sym.code == DIV)
		getsym();
	else
		error(40);
}

void respoper() {
	if (sym.code >= EQU && sym.code <= GEQ)
		getsym();
	else
		error(41);
}

实验结果

待分析代码

program main;
const x = 1, y=2,z=444;
var z,x:long;xx:long;
a:long;
begin
z := z*3/2;
read(xx,dsaf);
write(dsaf,xx);
if x > y
then
x := x+1;
begin
x := x+1;
y:= xx -12;
x := +123;
x := (1+2);
x:= 213 * 3 + 21/x;
y := y/2 +2;
begin
while x<=10
do
y:=y+1;
end
end
end.

以上代码只是单纯为了检测是否能够通过语法分析，并没有什么实际含义(o゜▽゜)o
在这里插入图片描述

在这里插入图片描述
语法分析检测通过！

Andy-wen
关注
  • 6
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java自顶向下语法分析——递归子程序
06-26
本文将深入探讨如何利用递归子程序来实现这一过程，并在分析过程中打印出语法分析树，以帮助我们更好地理解和调试编译器。 首先，我们需要理解自顶向下的语法分析策略。这种分析方法是从文法规则的起始符号开始，...
语法分析器 递归子程序法
05-25
分析语法功能，输出字符流，中间代码生成，递归子程序法
C语言表达式语法分析——递归子程序法
xiaomingming99的博客
10-20 2798
表达式语法分析——递归子程序法 Description 递归子程序法是一种确定的自顶向下语法分析方法，要求文法是LL(1)文法。它的实现思想是对应文法中每个非终结符编写一个递归过程，每个过程的功能是识别由该非终结符推出的串，当某非终结符的产生式有多个候选式时能够按LL(1)形式唯一地确定选择某个候选式进行推导。请根据下面的表达式LL(1)文法，构造递归子程序，完成对表达式的语法分析。 表达式文法如下： E→TG G→+TG|ε T→FS S→*FS|...
实验3《递归下降分析法设计与实现》（java版）
最新发布
qwertf123的博客
05-03 591
实验3《递归下降分析法设计与实现》（java版）
【编译原理】第4章 LL(1)文法及其分析程序
小羊咩咩的博客
04-10 5626
4 LL(1)文法及其分析程序 目录一、自顶向下分析的问题二、LL(1)文法FIRST集、FOLLOW集和SELECT集LL(1)文法定义LL(1)分析程序实现三、非LL(1)文法的改造 语法分析任务：在词法分析识别出单词符号串的基础上，分析并判定程序的语法结构是否符合语法规则 分析算法分类（语法分析方法）： 自上而下分析法：从文法的开始符号出发，反复使用各种产生式，寻找与输入符号匹配的最...
编译原理递归子程序语法分析
weixin_43824521的博客
11-28 5532
编译原理递归子程序语法分析 递归子程序法也称为递归下降分析法。该方法的实现思想是：对文法中的每个非终结符号U都编写出一个子程序，以完成该非终结符号所对应的语法成分的分析和识别任务。高级程序设计语言的语法规则通常都是用上下文无关文法来描述的，文法中的符号分为终结符号和非终结符号。 本分析程序所分析的文法如下： G[E]： E→eBaA A→a|bAcB B→dEd|aC C→e|dC 可以求...
递归子程序法实现语法分析器
m0_68447809的博客
03-14 1344
在本次实验中，使用递归子程序法实现了一个简单的语法分析器，能够对输入的程序代码进行语法分析，并输出相应的语法树。本次实验让我深刻认识到了语法分析的重要性，掌握了递归子程序法的实现方法和技巧，对于加深对编译原理的理解和掌握具有重要意义。本次实验的任务是使用递归子程序法实现一个简单的语法分析器，能够对输入的程序代码进行语法分析，并输出相应的语法树。通过本次实验，深入了解了递归子程序法和LL(1)分析表的原理和实现方法，掌握了语法分析的基本技术和方法，同时对编译原理的理论和实践都有了更深入的了解和认识。
递归
hsy_666的博客
06-09 1005
递归的定义：                 递归就是子程序（或函数）直接调用自己或通过一系列调用语句间接调用自己，是一种描述问题和解决问题的基本方                   法。递归常用来解决结构相似的问题递归有两个基本要素：                                 1. 边界条件：确定递归到何时终止，也称为递归出口                       ...
实验二-语法分析程序设计与实现.pdf
11-23
实验内容包括选择一种代表性的语法分析方法，如算符优先法、递归下降法、LL(1)、SLR(1)、LR(1)等，设计并实现一个语法分析程序，对实验一所得扫描器提供的单词序列进行语法检查和结构分析。 实验目的： 1. 了解...
东北大学2022编译原理实验课——递归下降分析简单算术表达式（C++）
05-11
东北大学2022编译原理实验课——递归下降分析简单算术表达式（C++） 【问题描述】 1．设计简单算数表达式语法分析器算法；（用递归下降分析来实现） 2．编写代码并上机调试运行通过。 【输入形式】 简单算数表达式 ...
编译原理——语法分析器（递归下降分析法 ）
05-05
本次实验的目的主要是加深对递归下降分析法的理解。 二、实验说明 1、递归下降分析法的功能 词法分析器的功能是利用函数之间的递归调用模拟语法树自上而下的构造过程。 2、递归下降分析法的前提 改造文法：消除二义...
语法分析器——Cminus/tiny
05-23
《深入理解语法分析器——以Cminus/tiny为例》 语法分析器是编译器设计中的核心组成部分，它负责将源代码转换成中间形式，以便后续的编译阶段处理。在这个过程中，我们通常会遇到诸如词法分析、语法分析、语义分析...
语法分析：自上而下分析
热门推荐
松子茶的专栏
10-18 1万+
概述本节将介绍编译程序构造中的一些典型的语法分析方法。语法分析器的功能，自上而下分析面临的问题，LL（1）分析法语法分析器的功能语法分析是编译过程的核心部分。它的任务是在词法分析识别出单词符号串的基础上，分析并判定程序的语法结构是否符合语法规则。语言的语法结构是用上下文无关文法描述的。因此，语法分析器的工作本质上就是按文法的产生式，识别输入符号串是否为一个句子。这里所说的输入串是指由单词符号（文法的
八皇后问题
GCGH159的博客
02-04 466
八皇后回溯问题 八皇后问题解决 说明一下我没有使用二维数组来写而是使用一维，因为这样看起来更简单 @Author: JinChongLi @Description: @Date: Created in 20:40 2021/2/3 @Modified By: */ public class 八皇后问题 { static class Queue8 { //定义一个max表示共有多少个皇后 int max = 8; //定义数组array, 保存皇后放置位置的结果,比如 arr = {0 , 4
表达式语法分析——递归子程序法
爱敲代码的小黄
11-19 635
欢迎访问我的个人博客： 苦酒的个人小站 题目介绍 题目思路 题目给的表达式文法为： E→TG G→+TG | ε T→FS S→*FS | ε F→(E) | i 例如：i+i*i是文法能生成的一个表达式,输出格式举例： 0 E–>TG 1 T–>FS 2 F–>i 3 S–>& 4 G–>+TG 5 T–>FS 6 F–>i 7 S–&g...
【编译原理】递归下降语法分析设计原理与实现
somia的博客
07-20 4316
编译原理递归下降分析算法，有分析过程和完整代码。
C语言表达式语法分析-递归子程序法
weixin_40220242的博客
11-20 102
递归子程序
怎样写出一个递归程序
南方以北
07-22 1224
如何写一个递归程序 　　总是听到大大们说递归递归的，自己写程序的时候却用不到递归。其中的原因，一个是害怕写递归，另一个就是不知道什么时候用递归。这篇文章就浅析一下，希望看完之后不再害怕递归，这就是本文最大的目的。 　　递归到底有什么意义？ 　　在说怎么写递归之前必须要说一下它的意义，其实这就是为什么大多数人在看了许多递归的例子后还是不明所以的原因。可以肯定的是，递归是个十分强大的工具，有许多算法...
如何写递归
熊與貓v
06-16 4513
1. 递归的定义 编程语言中，函数 Func(Type a,……)直接或间接调用函数本身，则该函数称为「递归函数」。在实现递归函数之前，有两件重要的事情需要弄清楚:递推关系：一个问题的结果与其子问题的结果之间的关系。 基本情况：不需要进一步的递归调用就可以直接计算答案的情况。可理解为递归跳出条件。 一旦我们计算出以上两个元素，再想要实现一个递归函数，就只需要根据递推关系调用函数本身，直到其抵达基本情况。1.1 递推关系 下面的插图给出了一个 5 行的帕斯卡三角，根据上面的定义，我们生成一个具有确定行数的帕斯
语法分析器递归下降分析程序的数据结构
05-11
语法分析器递归下降分析程序的数据结构主要包括： 1. 符号表：用于保存程序中出现的所有标识符及其相关信息，如变量名、类型、作用域等。 2. 词法分析器：将源代码转换成词法单元序列，并返回给语法分析器。 3. 语法分析树：语法分析器根据语法规则，将词法单元序列组织成一棵树状结构，用于表示程序的语法结构。 4. 预测分析表：用于存储语法分析器中的预测分析表，包括非终结符和终结符的FIRST集和FOLLOW集。 5. 语法分析器栈：用于存储语法分析器运行时的状态信息，包括当前的非终结符和已处理的词法单元序列等。 6. 语法分析器动作表：用于存储语法分析器中的动作表，包括移进、规约和出错处理等动作。 7. 错误处理模块：用于检测语法错误，并进行适当的错误处理，如报错、恢复等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Andy-wen

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

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

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

打赏作者

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

抵扣说明：

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

余额充值