编译原理 词法分析器 C++

最新推荐文章于 2023-03-24 20:56:28 发布
最新推荐文章于 2023-03-24 20:56:28 发布
阅读量298 收藏 1
点赞数
文章标签： c++ 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43943281/article/details/109165867
版权 
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
using namespace std;


const char Monocular_operator[15] = { '+','-','*','/','!','%','~','&','|','^','=','<','>',':','?' }; //单目运算符
const string Binocular_operator[] = { "++","--","&&","||","<=","!=","==",">=","+=","-=","*=","/=" }; //双目运算符
const char Delimiter[8] = { ',','(',')','{','}',';','[',']' }; //界符
const string Keyword[19] = { "break","case","continue","do","default","else",
				"for","if","include","main","return","switch","typedef","void","while","#","unsigned","true","false" };//控制关键字
const string Variable_type[7] = { "int","byte","long","short","float","double","char" }; //基本类型
const string typeName[] = { "单目运算符","双目运算符","界符","控制关键字","基本类型","变量名","字符","数值","注释" };
const string errTypeName[] = { "标识符表示错误","缺少右引号","数值表示错误","无法识别的标记" };

typedef struct LexItem {
	int rowNum;
	int typeId;           //1:单目运算符  2:双目运算符  3:界符    4：控制关键字   5：基本类型   6 :变量名  7 字符  8 数值    9注释
	string value;
	LexItem(int x, int y, string z) :rowNum(x), typeId(y), value(z) {}
};

/*异常错误信息项*/
typedef struct errItem {
	int rowNum;
	int typeId;     //1. 标识符表示错误   2.字符或字符串出错 3. 无法识别标记
	string  value;
	errItem(int x, int y, string z) :rowNum(x), typeId(y), value(z) {}
};

/** 最终分析结果 */
vector<LexItem> analyResult;
/** 分析数据缓存 */
vector<string> fileMessage;    //文件信息
/*文件名*/
string fileName;
/*错误信息汇总*/
vector<errItem>errMessage;


/*读取txt分析文件 将其存入 @fileMeessage*/
void readSourceFile();
/*词法分析入口*/
void LexAnalysis();
/*寻找界符下表*/
int  findDelimiter(char c);   //寻找界符下表
/*寻找单目运算符下表*/
int findMonOperator(char c);
/*寻找string 的下表*/
int  findStrIndex(string str, const string  strarray[], int length);
/*结果展示*/
void showResult();
/*写入文件*/
void writeLexFile();
/*@strarray里是否包含@str*/
int findHasStrIndex(string str, const string strarray[], int lenth);
/*是否到达结束点*/
bool isComplete(char c);
/*找到多行注释结尾*/
bool findMulNoteLocation(int line, int i, int res[]);
/*找到多行注释的值*/
string findmulNoteVal(int startline, int starpoint, int loc[]);
/*通过类型获取不同类型的符号表*/
vector<LexItem> getLexitemByType(int typeId);
/*找到结束点*/
int findCompleteIndex(string str);
/*判断变量名是否合法*/
bool judgeIdisLegal(string str);
/*获取字符 ’  “的结尾*/
int findstrCompleteIndex(string str);
/*获取数字的结尾*/
bool judgeNumlegal(string str);
/*主分析函数*/
void  LexAnalysis();

int  main() {
	readSourceFile();
	LexAnalysis();
	showResult();
	writeLexFile();

}

void  LexAnalysis() {
	int offset = 0;
	for (int index = 0; index < fileMessage.size(); index++) {
		string line = fileMessage[index];
		if (offset >= line.length()) { offset = 0; continue; }
		for (int i = 0 + offset; i < line.length(); i++) {
			if (offset > 0) offset = 0;
			//注释单独判断
			if (line[i] == '/') {
				if (i < line.size() - 1) {
					if (line[i + 1] == '/') { //单行注释
						string val = "";
						if (i != line.size() - 2) { val = line.substr(i + 2); } //非单行末尾
						LexItem  SNote(index, 9, val);
						analyResult.push_back(SNote);
						break;
					}
					else if (line[i + 1] == '*') { //多行注释
						int loc[] = { 0,0 };
						if (findMulNoteLocation(index, i + 2, loc) == false) {  //多行注释出错  程序直接终止
							showResult();
							cout << "第 " << index << " 行 ，注释出错，未找到注解结尾，程序终止！" << endl;
							exit(-1);
						}
						string mval = findmulNoteVal(index, i + 2, loc);
						LexItem MNote(index, 9, mval);
						analyResult.push_back(MNote);
						index = loc[0] - 1;
						offset = loc[1] + 3;
						if (offset == 3) {
							offset = 2;
						}
						break;
					}
				}
			}

			if (line[i] == ' ' || line[i] == '\t') { continue; } //过滤空格 和制表符
			else if (line[0] == '#') { break; } //过滤头文件
			else if (findDelimiter(line[i]) != -1) {   //界符
				string temp = " "; temp[0] = line[i];
				LexItem delimiter(index, 3, temp);
				analyResult.push_back(delimiter);
			}
			else if (findMonOperator(line[i]) != -1) {     //运算符   
				if (i != line.length() - 1) {   //是否为为本行最后一个字符
					string str = line.substr(i, 2);
					if (findStrIndex(str, Binocular_operator, 12) != -1) {  //双目运算符
						LexItem Bopt(index, 2, Binocular_operator[findStrIndex(str, Binocular_operator, 12)]);
						analyResult.push_back(Bopt); i++;
					}
					else {                      //单目运算符
						string temp = " "; temp[0] = line[i];
						LexItem opt(index, 1, temp);
						analyResult.push_back(opt);

						int s = 10;
					}
				}
				else {  //单目运算符
					string temp = " "; temp[0] = line[i];
					LexItem opt1(index, 1, temp);
					analyResult.push_back(opt1);
				}
			}
			else if (((char)line[i] >= 'a' && (char)line[i] <= 'z') || ((char)line[i] >= 'A' && (char)line[i] <= 'Z') || (char)line[i] == '_') { //控制关键字   基本类型   变量名
				int K = findHasStrIndex(line.substr(i), Keyword, 19);
				int V = findHasStrIndex(line.substr(i), Variable_type, 7);
				if (K != -1) {   //可能为控制关键字
					if (i + K - 1 == line.size() || isComplete(line[i + K])) {
						LexItem kw(index, 4, line.substr(i, K));
						analyResult.push_back(kw);
						i += K - 1;
					}
				}
				else if (V != -1) { //可能为基本类型
					if (i + V - 1 == line.size() || isComplete(line[i + V])) {
						LexItem variable(index, 5, line.substr(i, V));
						analyResult.push_back(variable);
						i += V - 1;
					}
				}
				else {//变量名  ID
					int IDI = findCompleteIndex(line.substr(i));
					string IDval = line.substr(i, IDI);
					if (judgeIdisLegal(IDval)) {    //合法标识符
						LexItem id(index, 6, IDval);
						analyResult.push_back(id);
					}
					else {
						errItem iderr(index, 1, IDval);  //非法标识符
						errMessage.push_back(iderr);
					}
					i += IDI - 1;
				}
			}
			else if (line[i] >= 48 && line[i] <= 57) { //数值        
				int NID = findCompleteIndex(line.substr(i));
				string numVal = line.substr(i, NID);
				if (judgeNumlegal(numVal)) {
					LexItem num(index, 8, numVal);
					analyResult.push_back(num);
				}
				else {
					errItem numerr(index, 3, numVal);
					errMessage.push_back(numerr);
				}
				i += NID - 1;
			}
			else if (line[i] == '\'' || line[i] == '"') {  //字符    C语言字符串只能放在一行  不能拆开  即 “ 或 ‘  不能出现在不同的行数
				int backindex = findstrCompleteIndex(line.substr(i));
				if (backindex == -1) {   //字符或字符串出错  缺少右引号
					errItem Serr(index, 2, line.substr(i));
					errMessage.push_back(Serr);
					break;
				}
				else {
					LexItem str(index, 7, line.substr(i, backindex));
					analyResult.push_back(str);
					i += backindex - 1;
				}
			}
			else {   //无法识别标记
				int c = findCompleteIndex(line.substr(i));
				errItem value(index, 4, line.substr(i,c));
				errMessage.push_back(value);
				i += c - 1;
			}
		}

	}
}

void readSourceFile() {
	std::cout << "请输入要分析的源代码文件  :  ";
	cin >> fileName;
	ifstream file(fileName);

	if (!file.is_open()) {
		cout << "文件打开错误！请检查文件路径：" << fileName << endl;
		exit(1);
	}
	char buffer[255];
	while (!file.eof()) {
		file.getline(buffer, 255);
		fileMessage.push_back(buffer);
	}
	file.close();
}

void writeLexFile() {
	string outfile = fileName.substr(0, fileName.size() - 4) + "Out.txt";
	ofstream file(outfile);
	for (int i = 0; i < analyResult.size(); i++) {
		file << "< " << analyResult[i].rowNum << " , " << analyResult[i].value << " , " << typeName[analyResult[i].typeId - 1] << " >" << endl;
	}
	file.close();
}

int  findDelimiter(char c) {
	for (int i = 0; i < strlen(Delimiter); i++) {
		if (Delimiter[i] == c)return i;
	}
	return -1;
}

int findMonOperator(char c) {
	for (int i = 0; i < strlen(Monocular_operator); i++) {
		if (Monocular_operator[i] == c)return i;
	}
	return -1;
}

int  findStrIndex(string str, const string  strarray[], int length) {
	for (int i = 0; i < length; i++) {
		if (strarray[i] == str)return i;
	}
	return -1;
}

/*@strarray里是否包含@str*/
int findHasStrIndex(string str, const string strarray[], int lenth) {
	int maxlength = str.size();
	for (int i = 0; i < lenth; i++) {
		if (strarray[i].size() <= maxlength) {
			if (strarray[i] == str.substr(0, strarray[i].size()))return strarray[i].size();
		}
	}
	return -1;
}

/*是否到达结束点*/
bool isComplete(char c) {
	if (c == ' ')return true;
	for (int i = 0; i < strlen(Delimiter); i++) {
		if (Delimiter[i] == c)return true;
	}
	for (int i = 0; i < strlen(Monocular_operator); i++) {
		if (Monocular_operator[i] == c)return true;
	}
	return false;
}

/*找到结束点*/
int findCompleteIndex(string str) {
	for (int i = 0; i < str.length(); i++) {
		if (isComplete(str[i]))return i;
	}
	return str.length();
}

int findstrCompleteIndex(string str) {
	for (int i = 1; i < str.length(); i++) {
		if (str[i] == '\'' || str[i] == '"')return i+1;
	}
	return -1;
}
/*找到多行注释结尾*/
bool findMulNoteLocation(int line, int i, int res[]) {

	for (int first = i; first < fileMessage[line].size(); first++) {//在同一行
		if (first < fileMessage[line].size() - 1) {
			if (fileMessage[line][first] == '*' && fileMessage[line][first + 1] == '/') {
				res[0] = line;
				res[1] = first - 1;
				return true;
			}
		}
	}
	for (int index = line + 1; index < fileMessage.size(); index++) {
		for (int j = 0; j < fileMessage[index].size(); j++) {
			if (index < fileMessage.size() - 1) {
				if (fileMessage[index][j] == '*' && fileMessage[index][j + 1] == '/') {
					res[0] = index;
					res[1] = j - 1; if (res[1] < 0)res[1] = 0;
					return true;
				}
			}
		}
	}

	return false;
}

/*找到多行注释的值*/
string findmulNoteVal(int startline, int starpoint, int loc[]) {
	string mulvalue = "";
	if (starpoint <= loc[1]) mulvalue += fileMessage[startline].substr(starpoint, loc[1] - starpoint + 1);

	for (int index = startline + 1; index <= loc[0]; index++) {
		if (index == loc[0]) {
			mulvalue += fileMessage[index].substr(0, loc[1]);
		}
		else {
			mulvalue += fileMessage[index];
		}
	}

	return mulvalue;

}

void showResult() {
	for (int i = 0; i < analyResult.size(); i++) {
		cout << "< " << analyResult[i].rowNum << " , " << analyResult[i].value << " , " << typeName[analyResult[i].typeId - 1] << " >" << endl;
	}
	if (errMessage.size() != 0) { //错误信息
		cout << "编译过程出现错误:" << endl;
		for (int i = 0; i < errMessage.size(); i++) {
			cout << "< " << errMessage[i].rowNum << " , " << errMessage[i].value << " , " << errTypeName[errMessage[i].typeId - 1] << " >" << endl;
		}
	}
}

/*通过类型获取不同类型的符号表*/
vector<LexItem> getLexitemByType(int typeId) {
	vector<LexItem> ans;
	for (auto item : analyResult) {
		if (item.typeId == typeId)ans.push_back(item);
	}
	return ans;

}

bool judgeIdisLegal(string str) {
	for (auto c : str) {
		if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || (c >= 48 && c <= 57))continue;
		return false;
	}
	return true;
}

bool judgeNumlegal(string str) {
	for (int i = 0; i < str.size(); i++) {
		if (str[i] >= 48 && str[i] <= 57) { continue; }
		else if (str[i] == '.' && i != str.size()) { continue; }
		else { return false; }
	}
	return true;
}
ASJA
关注
编译原理 C++ 词法分析器
chengxu_xuexi的博客
05-27 881
词法分析器 C++ 实验一 词法分析器 参考课本 p44-3.2.4，设计词法分析器，识别下列单词符号： 关键字：while if else in标识符 常数：整常数 运算符：+ - * / % = > < <= >= == != && || 界符：( ) ; [ ] { } 单词符号的表示形式: (单词种别，单词符号的属性值) 单词种别使用整数编码，如： ...
【编译原理与技术】词法分析器（C++实现）
Slimshady的博客
06-26 2367
目录注：单词：实现功能：C++代码：运行结果： 注： 为了简化程序的编写，做了如下的限制： （1） 空白符仅仅是空格、回车符、制表符。 （2） 代码是自由格式。 （3） 注释不允许嵌套。 单词： 根据要求，可以自行添加其他保留字或者特殊符号 实现功能： 识别单词并给出其类型 删除注释行 删除空白符 (空格、回车符、制表符) 在单词的前面加上行号 发现并定位错误。 C++代码： #...
编译原理词法分析器（C++版）源代码
01-05
自己实现的编译原理的词法分析器，是自己的实验作业，用Vs2017实现，可以直接运行，代码注释丰富，希望与大家交流学习！欢迎大家下载！
编译原理词法分析器报告（c++）
06-14
设计一个简单的词法分析器，从而进一步加深对词法分析器工作原理 的理解。本实验的重点是理解词法分析器的输入与输出；难点是常数的识别。
编译原理词法分析器（C/C++）
热门推荐
沉在海里的鱼的博客
03-24 1万+
词法分析器不用多说，一开始我还不知道是什么样的，看了下别人的博客，再看看书，原来是输出二元组，这不就是字符串操作嘛。然后细看几篇博客，发现大都是用暴力判断来写的。我对代码重复性比较高的方法不太感冒，不是说我编程有多好，就是单纯的不喜欢。于是我就想到了用偏移量的方法，先弄好单词分类器，再用几个数组将关键字、运算符、界符的所有定义的字符串保存为全局变量，顺序要按单词分类器的顺序，然后根据这三种字符串在表中的位置，定一个偏移量。
词法分析器 【编译原理】C++实现}
sddya的博客
05-24 4948
通过文件输入输出
编译原理词法分析器的c++实现
weixin_42529594的博客
04-19 5668
一、题目的理解和说明 编译原理这门课是计算机专业的核心课程之一，是一门研究软件是什么，为什么可以运行，以及怎么运行的学科。编译系统的改进将会直接对其上层的应用程序的执行效率，执行原理产生深刻的影响。编译原理的目的是将源语言翻译成目标语言。其过程分为词法分析、语法分析、语义分析中间代码生成、中间代码优化、代码生成等五个阶段。而本次实验所解决的问题是编译程序的第一个阶段–词法分析。 实验要求实现一个可...
编译原理 词法分析器 c++实现
12-05
参考附录C.1设计一个简单语言的词法分析程序，要求能够处理换行回车、注释（自定义注释格式）、部分符合运算符（如>= 、 等）。 注意： 附录C.1采用的是控制台输入输出的方式，测试数据要用文本文件保存好。
编译原理词法分析器和语法分析器的实现（C++）.zip
最新发布
04-17
编译原理词法分析器和语法分析器的实现（C++） 编译原理中的词法分析器和语法分析器是编译器的重要组成部分，它们分别负责将源代码转换为词法单元和抽象语法树。以下是一个简化的项目介绍，描述了如何使用C++实现这...
编译原理词法分析器C++语言实现
03-19
1、 关键字、标识符、数字等： 1.begin 2.if 3.then 4.while 5.do 6.end 10.标识符 11.数字 13.+ 14.- 15.* 16./ 17.: 18.:= 20.< 21.<> 22.<= 23.> 24.>= 25.= 26.;...
编译原理-词法分析器-C++
04-16
编译原理-词法分析器-C++
编译原理词法分析器c++语言
05-04
这个词法分析程序主要是从键盘输入程序语句，输出结果为二元组！含注释！用c++编写！
编译原理词法分析器_编译原理_词法分析_
09-30
a) 启动程序，请求输入测试程序名，键入程序名后自动开始词法分析并输出结果；b) 输出结果为单词的二元式序列（样式见样板输出1和2）；c) 要求能发现下列词法错误和指出错误性质和位置：非法字符，即不是SAMPLE字符集的符号；字符常数缺右边的单引号（字符常数要求左、右边用单引号界定，不能跨行）；注释部分缺右边的界符*/（注释要求左右边分别用/*和*/界定，不能跨行）
编译原理--词法分析器
11-23
C语言编写 包含：源代码和报告 1. 实验目的 设计，编制并调试一个词法分析程序，加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即关键字、其他标识符、整型常数、运算符、界符五大类。并依次输出各个单词的内部编码及单词符号自身值。（遇到错误时可显示“Error”，然后跳过错误部分继续显示）
编译原理——词法分析器
07-31
读入文件中的信息，根据需求输出对应的二元式，如果有错误提示！首先新建11.txt的文本，输入一串表达式或句子，以#结束，然后运行程序！
基于C++的编译原理词法分析器.zip
04-17
基于C++的编译原理词法分析器 基于C++的编译原理词法分析器是一个使用C++编写的程序，它能够读取C++源代码，并从中识别出一系列的词法单元（tokens）。这些词法单元是编程语言的基本语法构建块，包括关键字、标识符...
【编译原理】C++简单词法分析器的实现
PengZyi的博客
04-29 3291
编译原理中确定的有限无穷DFA的C++实现，识别字符串，可进行错误处理。
编译原理：C++词法分析器
weixin_44219441的博客
10-15 1813
编译原理之C++词法分析器 1.明确实验目的： 对于每一个以文件形式给出的C或C++项目，对其进行词法分析 如图所示 2.分析实验需求： 第一：需要对文件进行读取，则需要用到文件读取流 第二：既然是词法分析，那就涉及到需要对每一个字符进行分析和归类 第三：既然是对每个字符进行分析，那代码的架构就是基于每一个字符，所以函数的编写是基于读取到的每一个字符。 3.进行实验： 首先我需要对所有的 首先我需要写出实验中所要用到的函数名和它的功能 bool isKey() //判断是否为关键字的嵌套函数，给出C++中
C++：编译原理实验之词法分析器
壹玖二一
12-01 3078
一、实验目的 学会针对DFA转换图实现相应的高级语言源程序。 深刻领会状态转换图的含义，逐步理解有限自动机。 掌握手工生成词法分析器的方法，了解词法分析器的内部工作原理。 加强对C语言的掌握 二、实验内容 C计算机语言的编译程序的词法分析部分实现。 从左到右扫描每行该语言源程序的符号，拼成单词，换成统一的内部表示（token）送给语法分析程序。 为了简化程序的编写，有具体的要求如下： 空白符仅仅是空格、回车符、制表符。 代码是自由格式。 注释应放在花括号之内，并且不允许嵌套 C语言的单词
编译原理 词法分析器 c++
09-20
编译原理的词法分析器是一种用于将源代码中的字符序列转化为有意义的词法单元（tokens）的程序。它的作用是将源代码分解成一个个的词法单元，如标识符、关键字、运算符、常量等，并为每个词法单元指定一个类型。编译...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值