编译原理课设（词法分析，语法分析，语义分析）

最新推荐文章于 2022-04-17 13:57:09 发布
最新推荐文章于 2022-04-17 13:57:09 发布
阅读量1.1k 收藏 9
点赞数
分类专栏： 数据结构 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43596969/article/details/119444878
版权

语法分析，有LL1语法分析，以及自顶向上   2种。

predict是程序自动生成和手动添加两种

语义分析：全局表

#include<iostream>
#include<stdio.h>
#include<stack>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<string>
using namespace std;
const int maxn = 10000;
/*
* 类型声明
*/
enum Terminal {
	/* 簿记单词符号 */
	ENDFILE, ERROR,
	/* 保留字 */
	PROGRAM, PROCEDURE, TYPE, VAR, IF,
	THEN, ELSE, FI, WHILE, DO,
	ENDWH, BEGIN, END, READ, WRITE,
	ARRAY, OF, RECORD, RETURN,
	/*类型*/
	INTEGER, CHAR,
	/* 多字符单词符号 */
	ID, INTC, CHARC,
	/*特殊符号 */
	ASSIGN, EQ, LT, PLUS, MINUS,
	TIMES, OVER, LPAREN, RPAREN, DOT,
	COLON, SEMI, COMMA, LMIDPAREN, RMIDPAREN,
	UNDERANGE
};
enum NonTerminal {
	//总程序
	Program = 50,
	//程序头
	ProgramHead, ProgramName,
	//程序声明
	DeclarePart,
	//类型声明
	TypeDecpart, TypeDec, TypeDecList, TypeDecMore, TypeId,
	//类型
	TypeDef, BaseType, StructureType, ArrayType,
	Low, Top, RecType, FieldDecList, FieldDecMore, IdList, IdMore,
	//变量声明
	VarDecpart, VarDec, VarDecList, VarDecMore, VarIdList, VarIdMore,
	//过程声明
	ProcDecpart, ProcDec, ProcDecMore, ProcName,
	//参数声明
	ParamList, ParamDecList, ParamMore, Param, FormList, FidMore,
	//过程中的声明部分
	ProcDecPart,
	//过程体
	ProcBody,
	//主程序体
	ProgramBody,
	//语句序列
	StmList, StmMore,
	//语句
	Stm, AssCall,
	//赋值语句
	AssignmentRest,
	//条件语句
	ConditionalStm,
	//循环语句
	LoopStm,
	//输入语句
	InputStm, Invar,
	//输出语句
	OutputStm,
	//返回语句
	ReturnStm,
	//过程调用语句
	CallStmRest, ActParamList, ActParamMore,
	//条件表达式
	RelExp, OtherRelE,
	//算术表达式
	Exp, OtherTerm,
	//项
	Term, OtherFactor,
	//因子
	Factor, Variable, VariMore, FieldVar, FieldVarMore, CmpOp, AddOp, MultOp
};
map<int, string>Map;
void initmap() {
	//终极符
	Map.insert(make_pair(0, "ENDFILE"));
	Map.insert(make_pair(1, "ERROR"));
	Map.insert(make_pair(2, "PROGRAM"));
	Map.insert(make_pair(3, "PROCEDURE"));
	Map.insert(make_pair(4, "TYPE"));
	Map.insert(make_pair(5, "VAR"));
	Map.insert(make_pair(6, "IF"));
	Map.insert(make_pair(7, "THEN"));
	Map.insert(make_pair(8, "ELSE"));
	Map.insert(make_pair(9, "FI"));
	Map.insert(make_pair(10, "WHILE"));
	Map.insert(make_pair(11, "DO"));
	Map.insert(make_pair(12, "ENDWH"));
	Map.insert(make_pair(13, "BEGIN"));
	Map.insert(make_pair(14, "END"));
	Map.insert(make_pair(15, "READ"));
	Map.insert(make_pair(16, "WRITE"));
	Map.insert(make_pair(17, "ARRAY"));
	Map.insert(make_pair(18, "OF"));
	Map.insert(make_pair(19, "RECORD"));
	Map.insert(make_pair(20, "RETURN"));
	Map.insert(make_pair(21, "INTEGER"));
	Map.insert(make_pair(22, "CHAR"));
	Map.insert(make_pair(23, "ID"));
	Map.insert(make_pair(24, "INTC"));
	Map.insert(make_pair(25, "CHARC"));
	Map.insert(make_pair(26, "ASSIGN"));
	Map.insert(make_pair(27, "EQ"));
	Map.insert(make_pair(28, "LT"));
	Map.insert(make_pair(29, "PLUS"));
	Map.insert(make_pair(30, "MINUS"));
	Map.insert(make_pair(31, "TIMES"));
	Map.insert(make_pair(32, "OVER"));
	Map.insert(make_pair(33, "LPAREN"));
	Map.insert(make_pair(34, "RPAREN"));
	Map.insert(make_pair(35, "DOT"));
	Map.insert(make_pair(36, "COLON"));
	Map.insert(make_pair(37, "SEMI"));
	Map.insert(make_pair(38, "COMMA"));
	Map.insert(make_pair(39, "LMIDPAREN"));
	Map.insert(make_pair(40, "RMIDPAREN"));
	Map.insert(make_pair(41, "UNDERANGE"));
	//非终极符
	Map.insert(make_pair(50, "Program"));
	Map.insert(make_pair(51, "ProgramHead"));
	Map.insert(make_pair(52, "ProgramName"));
	Map.insert(make_pair(53, "DeclarePart"));
	Map.insert(make_pair(54, "TypeDecpart"));
	Map.insert(make_pair(55, "TypeDec"));
	Map.insert(make_pair(56, "TypeDecList"));
	Map.insert(make_pair(57, "TypeDecMore"));
	Map.insert(make_pair(58, "TypeId"));
	Map.insert(make_pair(59, "TypeDef"));
	Map.insert(make_pair(60, "BaseType"));
	Map.insert(make_pair(61, "StructureType"));
	Map.insert(make_pair(62, "ArrayType"));
	Map.insert(make_pair(63, "Low"));
	Map.insert(make_pair(64, "Top"));
	Map.insert(make_pair(65, "RecType"));
	Map.insert(make_pair(66, "FieldDecList"));
	Map.insert(make_pair(67, "FieldDecMore"));
	Map.insert(make_pair(68, "IdList"));
	Map.insert(make_pair(69, "IdMore"));
	Map.insert(make_pair(70, "VarDecpart"));
	Map.insert(make_pair(71, "VarDec"));
	Map.insert(make_pair(72, "VarDecList"));
	Map.insert(make_pair(73, "VarDecMore"));
	Map.insert(make_pair(74, "VarIdList"));
	Map.insert(make_pair(75, "VarIdMore"));
	Map.insert(make_pair(76, "ProcDecpart"));
	Map.insert(make_pair(77, "ProcDec"));
	Map.insert(make_pair(78, "ProcDecMore"));
	Map.insert(make_pair(79, "ProcName"));
	Map.insert(make_pair(80, "ParamList"));
	Map.insert(make_pair(81, "ParamDecList"));
	Map.insert(make_pair(82, "ParamMore"));
	Map.insert(make_pair(83, "Param"));
	Map.insert(make_pair(84, "FormList"));
	Map.insert(make_pair(85, "FidMore"));
	Map.insert(make_pair(86, "ProcDecPart"));
	Map.insert(make_pair(87, "ProcBody"));
	Map.insert(make_pair(88, "ProgramBody"));
	Map.insert(make_pair(89, "StmList"));
	Map.insert(make_pair(90, "StmMore"));
	Map.insert(make_pair(91, "Stm"));
	Map.insert(make_pair(92, "AssCall"));
	Map.insert(make_pair(93, "AssignmentRest"));
	Map.insert(make_pair(94, "ConditionalStm"));
	Map.insert(make_pair(95, "LoopStm"));
	Map.insert(make_pair(96, "InputStm"));
	Map.insert(make_pair(97, "Invar"));
	Map.insert(make_pair(98, "OutputStm"));
	Map.insert(make_pair(99, "ReturnStm"));
	Map.insert(make_pair(100, "CallStmRest"));
	Map.insert(make_pair(101, "ActParamList"));
	Map.insert(make_pair(102, "ActParamMore"));
	Map.insert(make_pair(103, "RelExp"));
	Map.insert(make_pair(104, "OtherRelE"));
	Map.insert(make_pair(105, "Exp"));
	Map.insert(make_pair(106, "OtherTerm"));
	Map.insert(make_pair(107, "Term"));
	Map.insert(make_pair(108, "OtherFactor"));
	Map.insert(make_pair(109, "Factor"));
	Map.insert(make_pair(110, "Variable"));
	Map.insert(make_pair(111, "VariMore"));
	Map.insert(make_pair(112, "FieldVar"));
	Map.insert(make_pair(113, "FieldVarMore"));
	Map.insert(make_pair(114, "CmpOp"));
	Map.insert(make_pair(115, "AddOp"));
	Map.insert(make_pair(116, "MultOp"));
}
struct Token {
	int hang;
	Terminal Tname;
	int flag;//0是终极符，1非终极符
	NonTerminal  nonTname;
	int name;
	string tokenname;  //token的名字 比如有个char型变量叫sss，那么存的就是"sss"
};
/*
* 结构体构建区
*/
struct Tree {
	int sonnum;
	int hang;
	int height = 0;
	Terminal Tname;
	int flag;//0是终极符，1非终极符
	NonTerminal  nonTname;
	Tree() {
		sonnum = 0;
	}
	Tree* son[100];
	Tree* father;
	~Tree() {
		for (int i = 0; i < sonnum; i++) {
			delete(son[i]);
		}
	}
};
struct Product {
	NonTerminal  nonTname;
	int flag;
	Terminal Tname;
	Terminal getTerminalname() { return Tname; }
	NonTerminal getNonTerminalname() { return nonTname; }
	void setTerminalname(Terminal name) { Tname = name; }
	void setNonTerminalname(NonTerminal name) { nonTname = name; }
};
struct Production {
	Product product[100];
	NonTerminal Headname;
	void setHead(NonTerminal name) { Headname = name; }
	int num;
	Production() { num = 0; }
	void setProduction(Terminal ter) {
		product[num].setTerminalname(ter); product[num++].flag = 0;

	}
	void setProduction(NonTerminal nonter) { product[num].setNonTerminalname(nonter); product[num++].flag = 1; }
	NonTerminal getHeadname() { return Headname; }
	Product get(int i) { return product[i]; }

};
struct Predict {
	Terminal name[100];
	Terminal ter[100];
	int num = 0;
	void setPredict(Terminal nonter) { name[num++] = nonter; }
	Terminal get(int i) { return name[i]; }
};
struct RecBody {
	string name;
	union {
		struct {
			int Size;
			Terminal kind;
		} CommonVar;
		struct {
			int Size;//Size=(up-low+1)*sizeof(ElemType)
			Terminal kind;
			int low;
			int up;
			Terminal ElemType;
		} ArrayVar;
		struct {
			int Size;
			Terminal kind;
			RecBody* recbody;
		} RecVar;
	} type;
	RecBody* link;
};
struct ParameTable {
	string name;
	Terminal kind;
	int level;
	ParameTable* next;
};
struct SymTable {
	string name;
	Terminal kind;
	int level;
	union {
		struct {
			int Size;
			Terminal kind;
		} CommonVar;
		struct {
			int Size;//Size=(up-low+1)*sizeof(ElemType)
			Terminal kind;
			int low;
			int up;
			Terminal ElemType;
		} ArrayVar;
		struct {
			int Size;
			Terminal kind;
			RecBody* recbody;
		} RecVar;
	} type;
	ParameTable* Parame = NULL;
	SymTable* next;
};
/*
* 全局变量区
*/
Token tokenlist[maxn];
int tokenlen;
Production product[141];
Predict predict[141];
int error = 0;
Tree* root = new Tree();
int hangshu = 1;  //此时所扫描token所在行数
Tree* tree[1000];
int Level = 0;//分别表示当前层数和符号表最大下标
vector<SymTable*> symArr;
vector<SymTable*> scope;
/*
*  词法分析阶段
*/
int IsOther(char ch)
{
	if (ch >= 'A' && ch <= 'Z')
		return 0;
	if (ch >= 'a' && ch <= 'z')
		return 0;
	if (ch >= '0' && ch <= '9')
		return 0;
	return 1;
}
//判断是否为关键字
int IsKeyWord(string str, Token* pToken)
{
	if (str == "endfile")
	{
		pToken->flag = 0;
		pToken->Tname = ENDFILE;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "error")
	{
		pToken->flag = 0;
		pToken->Tname = ERROR;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "integer")
	{
		pToken->flag = 0;
		pToken->Tname = INTEGER;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "char")
	{
		pToken->flag = 0;
		pToken->Tname = CHAR;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "program")
	{
		pToken->flag = 0;
		pToken->Tname = PROGRAM;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "array")
	{
		pToken->flag = 0;
		pToken->Tname = ARRAY;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "of")
	{
		pToken->flag = 0;
		pToken->Tname = OF;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "record")
	{
		pToken->flag = 0;
		pToken->Tname = RECORD;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "end")
	{
		pToken->flag = 0;
		pToken->Tname = END;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "var")
	{
		pToken->flag = 0;
		pToken->Tname = VAR;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "procedure")
	{
		pToken->flag = 0;
		pToken->Tname = PROCEDURE;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "begin")
	{
		pToken->flag = 0;
		pToken->Tname = BEGIN;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "if")
	{
		pToken->flag = 0;
		pToken->Tname = IF;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "then")
	{
		pToken->flag = 0;
		pToken->Tname = THEN;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "else")
	{
		pToken->flag = 0;
		pToken->Tname = ELSE;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "fi")
	{
		pToken->flag = 0;
		pToken->Tname = FI;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "while")
	{
		pToken->flag = 0;
		pToken->Tname = WHILE;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "do")
	{
		pToken->flag = 0;
		pToken->Tname = DO;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "endwh")
	{
		pToken->flag = 0;
		pToken->Tname = ENDWH;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "read")
	{
		pToken->flag = 0;
		pToken->Tname = READ;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "write")
	{
		pToken->flag = 0;
		pToken->Tname = WRITE;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "return")
	{
		pToken->flag = 0;
		pToken->Tname = RETURN;
		pToken->tokenname = str;
		return 1;
	}
	else if (str == "type")
	{
		pToken->flag = 0;
		pToken->Tname = TYPE;
		pToken->tokenname = str;
		return 1;
	}
	else return 0;
}
Token* Scanner(FILE* pf)
{
	char ch;
	string tmpStr = "";
	Token* pToken = new Token();
	/*用于检测标识符是否合法*/
	char biaozhi[50] = { '\0' };
	int pb = 0;
LS0://根据第一个字符确定程序走向
	{
		ch = fgetc(pf);
		if (ch != EOF)      //没有读到文件末尾
		{
			if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
				goto LS1;
			if (ch >= '0' && ch <= '9')
				goto LS2;
			if (ch == '+')
				goto LS3;
			if (ch == '-')
				goto LS4;
			if (ch == '*')
				goto LS5;
			if (ch == '/')
				goto LS6;
			if (ch == '<')
				goto LS7;
			if (ch == ';')
				goto LS8;
			if (ch == ':')
				goto LS9;
			if (ch == ',')
				goto LS10;
			if (ch == '.')
				goto LS11;
			if (ch == '=')
				goto LS12;
			if (ch == '[')
				goto LS13;
			if (ch == ']')
				goto LS14;
			if (ch == '(')
				goto LS15;
			if (ch == ')')
				goto LS16;
			if (ch == '\'')
				goto LS17;
			if (ch == ' ')
				goto LS18;
			if (ch == '\n' || ch == '\r' || ch == '\t')
				goto LS19;
			goto LS20;
		}
		else
		{
			return NULL;
		}
	}
LS1://若字母开头，可能为标示符或关键字
	{
		tmpStr += ch;
		biaozhi[pb] = ch;
		pb++;
		int flag;
		ch = fgetc(pf);                                    //读取下一个字符
		if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9'))
			goto LS1;
		if ((flag = IsOther(ch)) == 1)                     //如果读到了除字母数字以外的
		{
			ungetc(ch, pf);                                //把读到的字符放回到文件流中
			if ((flag = IsKeyWord(tmpStr, pToken)) == 1)   //如果判断字符串是关键字
			{
				//char数组清零
				for (int s = 0; s < 50; s++)
					biaozhi[s] = '\0';
				pb = 0;
				//放入token序列
				pToken->hang = hangshu;
				return pToken;
			}
			else
			{
最低0.47元/天 解锁文章
初，梦
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
编译原理词法分析，语法分析，语义分析（源代码和实验报告）
01-04
编译原理词法分析，语法分析，语义分析（源代码和实验报告），已经测试运行，绝对对得起10分（本人的承诺）。
词法分析、语法分析、语义分析
rv0p111
05-27 1万+
这里就是拿翻译句子来举例子，从英语翻译到汉语，我们需要分析句子的语义，要划分句子的成分要想进行语义分析就要划分句子成分，比如说划分为人、铁锤、窗户等等我们要想划分句子当中的各类成分，就要用语法分析来识别出句子中的各类短语，这个过程称之为语法分析根据词性来识别出句子中的各类短语，这一过程称之为词法分析其实关于词法分析、语法分析、语义分析我们可以这样理解，就好比我们要翻译一句英文，先要分析单词的词性比...
编译原理【1】概述：词法分析、语法分析、语义分析
cprimesplus的博客
04-24 1万+
什么是编译？ 编译就是将高级语言程序转换成汇编语言程序/及其语言程序的过程。 编译，说白了就是翻译，对比精细的人工英译汉的步骤： 词法分析：分析词性：每个词属于名词？形容词？动词？介词… 语法分析：分析各种介词短语、名词短语、动词短语… 语义分析：以上两个步骤的意义就是为语义分析做铺垫，通过将语法展开成下图树的形式，可以最终根据根节点分析出整个句子的意思是什么。 编译的步骤也和人工翻译是一样...
[编译原理]词法分析器的分析与实现
热门推荐
童凌的技术博客
06-16 5万+
词法分析概述：编译程序要对高级语言编写的源程序进行分析和合成，生成目标程序。词法分析是对源程序进行的首次分析，实现词法分析的程序成为词法分析程序(或词法分析器)，也称扫描器。 像用自然语言书写的文章一样，源程序是由一系列的句子组成的，句子是由单词符号按一定的规则构成的，而单词符号又是由字符按照一定的规则构成。因此，源程序实际上是由满足程序语言规范发字符按照一定的规则组合起来构成的一个字符串。 词法
编译原理 实验二 简单计算器的设计与实现
qq_37354060的博客
04-17 2772
实验二 简单计算器的设计与实现 JAVA实现 一、实验目的   综合运行词法分析器、语法分析器等原理实现一个具有加、乘功能的简单计算器，该计算器满足乘法优先级高于加法优先级，且仅处理非负整数。 二、实验内容   1. 对输入的符号串首先进行词法分析，提取操作数及操作符，以输出的单词符号为输入进行语法分析。   2. 要求以算符优先分析的方法完成语法分析工作，识别输入串是否是文法描述语言的句子。   3. 对句子进行求值，求值方式可以是遍历语法树或者是建立一个逆波兰式，对逆波兰式进行求值。
编译原理（七）——自顶向下语法分析概述
很注重数学和408
09-21 1177
自定向下语法分析 从起始符出发，按照所给规则进行尝试性推导看是否能够得到当前所给字符串abbd 每一步从第一条规则进行匹配，如果没有匹配上则回溯，一直回溯到起点如果没有找到相应的字符串则当前字符串不符合规则（注意不要遗漏情况） 先分析所给子串具有的特点然后再去选择对应的规则进行归约。把不可能实现的内容直接删除，在分析的过程中考虑输入流的信息。 First集（alpha短语） 根据串进行定义的，可以根据一个串来求first集，指的是能用这个串推出来的所有可以作为终极符的集合。推出以哪些终极符作为开头的串，这
编译原理词法分析+语法分析课设
04-09
编译原理课设，已实现词法分析和语法分析，代码注释详细，验证无误。
编译原理课设代码：词法分析，语法分析，语义分析，
08-06
最全代码，课设代码已验证可以直接运行，语法分析用了两种方式实现：LL1以及递归下降分别实现，Predict集也有两种方式实现，具体详见代码。注释全面。
词法、语法、语义分析编译原理设计.zip
10-20
资源包含文件：课程论文word+设计任务PPT+项目...分析程序、语法分析程序、语义分析程序、中间代码生成程序、代码优化程序和目标代码生成程序。详细介绍参考：https://blog.csdn.net/newlw/article/details/126659566
编译原理实验 词法、语法、语义分析
10-19
这是我本科编译原理课上完成的实验(C语言编写)，文件打包了从词法分析、语法分析到语义分析的代码，使用codeblock编写。
编译原理实验，包括词法分析、语法分析、语义分析、代码生成等
05-27
本课程中所实现的程序为普通C或C++程序，在Windows环境下，属于控制台应用程序。
编译原理实验报告 语法分析 语义分析 词法分析 详细的源程序
11-06
附录c 编译程序实验 实验目的：用c语言对一个简单语言的子集编制一个一遍扫描的编译程序，以加深对编译原理的理解,掌握编译程序的实现方法和技术。 语法分析 C2.1 实验目的 编制一个递归下降分析程序,实现对词法分析程序所提供的单词序列的语法检查和结构分析. C2.2 实验要求 利用C语言编制递归下降分析程序,并对简单语言进行语法分析. C2.2.1待分析的简单语言的语法 实验目的 通过上机实习,加深对语法制导翻译原理的理解,掌握将语法分析所识别的语法成分变换为中间代码的语义翻译方法. 实验要求 采用递归下降语法制导翻译法,对算术表达式、赋值语句进行语义分析并生成四元式序列。 实验的输入和输出 输入是语法分析提供的正确的单词串，输出为三地址指令形式的四元式序列。 例如：对于语句串 begin a:=2+3*4;x:=(a+b)/c end# 输出的三地址指令如下： （1） t1=3*4 （2） t2=2+t1 （3） a=t2 （4） t3=a+b （5） t4=t3/c （6） x=t4 算法思想 1设置语义过程 （1） emit(char *result,char *arg1,char *op,char *ag2) 该函数功能是生成一个三地址语句送到四元式表中。 四元式表的结构如下： struct {char result[8]; char ag1[8]; char op[8]; char ag2[8]; }quad[20]; (2)char *newtemp() 该函数回送一个新的临时变量名，临时变量名产生的顺序为T1,T2,…. Char *newtemp(void) { char *p; char m[8]; p=(char *)malloc(8); k++; itoa(k,m,10); strcpy(p+1,m); p[0]=’t’; return(p); } (2)主程序示意图如图c.10所示。 （2） 函数lrparser在原来语法分析的基础上插入相应的语义动作：将输入串翻译成四元式序列。在实验中我们只对表达式、赋值语句进行翻译。 语义分析程序的C语言程序框架 int lrparser() { int schain=0; kk=0; if(syn=1) { 读下一个单词符号； schain=yucu; /调用语句串分析函数进行分析/ if(syn=6) { 读下一个单词符号； if(syn=0 && (kk==0)) 输出（“success”）; } else { if(kk!=1 ) 输出 ‘缺end’ 错误；kk=1;} else{输出’begin’错误；kk=1;} } return(schain); int yucu() { int schain=0; schain=statement();/调用语句分析函数进行分析/ while(syn=26) {读下一个单词符号； schain=statement(); /调用语句分析函数进行分析/ } return(schain); } int statement() { char tt[8],eplace[8]; int schain=0; {switch(syn) {case 10: strcpy(tt,token); scanner(); if(syn=18) {读下一个单词符号； strcpy(eplace,expression()); emit(tt,eplace,””,””); schain=0; } else {输出’缺少赋值号’的错误；kk=1; } return(schain); break; } } char *expression(void) {char *tp,*ep2,*eplace,*tt; tp=(char *)malloc(12);/分配空间/ ep2=(char *)malloc(12); eplace=(char *)malloc(12); tt =(char )malloc(12); strcpy(eplace,term ());／调用term分析产生表达式计算的第一项eplace／ while(syn=13 or 14) { 操作符 tt= ‘+’或者‘—’； 读下一个单词符号； strcpy(ep2,term());／调用term分析产生表达式计算的第二项ep2／ strcpy(tp,newtemp());/调用newtemp产生临时变量tp存储计算结果/ emit(tp,eplace,tt,ep2);／生成四元式送入四元式表／ strcpy(eplace,tp); } return(eplace); } char *term(void)／仿照函数expression编写／ char *factor(void) {char *fplace; fplace=(char *)malloc(12); strcpy(fplace, “ ”); if(syn=10) {strcpy(fplace,,token);／将标识符token的值赋给fplace／ 读下一个单词符号； } else if(syn=11) {itoa(sum,fplace,10); 读下一个单词符号； } else if (syn=27) {读下一个单词符号； fplace=expression();/调用expression分析返回表达式的值/ if(syn=28) 读下一个单词符号； else{输出‘}’错误；kk=1; } } else{输出‘（’错误；kk=1; } return(fplace); }
SNL 编译器 编译原理 包含 词法分析 语法分析 语义分析.zip
最新发布
04-17
本资源位课程设计希望对你有帮助
编译原理-简单计算器(词法分析/语法分析)-含源码
春夜喜雨的专栏
08-31 1万+
编译原理-简单计算器(词法分析/语法分析)-含源码： 之前大学的时候，编译原理课程有一个做计算器的任务，当时没有做，只顾做一个漂亮计算器界面。 想来当时是买椟还珠了，有点小遗憾，觉得编译原理没有实践，没有理解透彻。 趁这周末有空，就把编译器重新做一做。
编译原理--词法分析器（python语言实现）
m0_54759841的博客
03-15 1万+
词法分析器 最近在学习编译原理。由于实验要求有词法分析器，这里我就先记录一下词法分析器实现过程以及具体思路。 目标语言 此处我选择的目标语言是c语言的子集来进行词法分析。 实现语言 此处我选用的语言是python，主要还是考虑到python的数据结构比较强大而且包容性强。并且我pyqt用的比较熟练，很容易设计出GUI界面。 ...
【编译原理】计算器实现（C语言）
Electro1ux的博客
03-12 6466
【编译原理】计算器实现（C语言）题目要求简单分析（1）读文件（2）词法分析（3）语法分析(4)后缀表达式求值总结 这几天编译原理课留了个编写一个简单的计算器，要求能够检查错误并进行计算。其实也就是完成词法分析，语法分析，再完成一个后缀表达式的计算就好了。 这里找到了一个比较简单的方法，这里记录一下。 题目要求 简单分析 整个程序其实整体上大致分成四部分去做 1.读文件存储内容（这里的文本是以字符...
编译原理四元式实验_记一次编译原理实验——词法+语法&语义分析(Python实现)...
weixin_36035992的博客
01-20 2134
记一次编译原理实验——词法+语法&语义分析(Python实现)编译原理是每个CS学子的必修课。编译原理的实验课对提高我们对编译过程的理解很重要。本文章写于实验结束后，所有代码已上传至Github : https://github.com/kabu1204/compilation。建议拉到底下点击阅读原文，微信排版不行，表格内的公式加载不出来，而且LATEX的换行符失效。水平有限，...
编译原理 (二)词法分析、语法分析、语义分析以及中间代码生成器的基本概念
weixin_44415928的博客
02-17 8374
1.词法分析 词法分析的过程中，源代码程序被输入到了一个叫做扫描器的东西中，扫描器的任务就是进行词法分析。他应用了一种叫做有限状态机的算法把源代码分割成一个一个的记号，举例比如array[index] = (index + 4) * (2 + 3)这行代码，经过扫描就会变成如下的一个个记号： 记号 类型 array 标识符 [ 左方括号 index 标识符 ] 右方括号...
编译原理——词法，语法，语义分析
yulingzheng的博客
10-03 3312
一: 词法分析 词法分析的主要任务： 从左向右逐行扫描源程序的字符，识别出各个单词，确定单词的类型 将识别出的单词转换成统一的机内表示——词法单元(token)形式 token:<种别码，属性值> 单词类型 种别 种别码 关键字 program.if、 else、then、… 一词一码 标识符 变量名、数组名、记录名、过程名、… 多词一码 常量 整型、浮点型、字符型、布尔型、… 一型一码 运算符 算术（± * │++ – )关系（> <== != >
编译原理词法分析语法分析语义分析c++
06-06
编译原理是计算机科学中的一个重要分支，它研究的是将高级程序源代码转化为机器能够执行的目标代码的过程。其中，词法分析、语法分析和语义分析是编译过程中的三个重要步骤。 词法分析是将输入的程序源代码按照词法规则分解成一个个单词（token）。C++中的词法分析器会识别程序中的关键字、标识符、常量、运算符等单词，并按照一定的方式进行分类和组织。 语法分析是将分解后的单词序列按照语法规则组织成一个语法树。C++中的语法分析器会检查程序中语法错误，如括号不匹配、缺少分号等，并生成语法树，以便后续的分析和转换。 语义分析是在语法树的基础上对程序进行语义检查和语义分析，以确保程序的正确性。C++中的语义分析器会进行类型检查、函数重载、作用域嵌套等语义分析，以确保程序的正确性。 总之，词法分析、语法分析和语义分析是编译原理中非常重要的三个步骤，它们是将高级程序源代码转化为机器能够执行的目标代码的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

初，梦

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

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

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

打赏作者

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

抵扣说明：

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

余额充值