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

最新推荐文章于 2024-07-02 22:22:32 发布
最新推荐文章于 2024-07-02 22:22:32 发布
阅读量1w 收藏 56
点赞数 12
文章标签： 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IuSpet/article/details/90599648
版权

说明：

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

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

整型变量与函数的声明

if else 分支语句

while 循环语句

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

流程：

  1. 写出该语言的词法规则与正则表达式
  2. 构造DFA
  3. 代码实现

该语言词法规则与正则表达式

1.保留字

int   void   if   else   return   while   

正则表达式即为原串，在代码中当作标识符匹配，匹配完后再与保留字比较

2.标识符

letter = [a-z | A-Z]

digit = [0-9]

正则表达式 letter (letter | digit )*

3.数字

digit = [1-9]

D = 0 | digit

整型：

正则表达式：digit D*

浮点型：

正则表达式：digit (. D*)? (e -? digit D*)?

4.符号

+   -   *   /   %   >   >=   <   <=   [   ]   (   )   {   }   !=   ==    ,    ;

正则表达式即符号本身

5.注释

C = 所有字符

//型：

正则表达式：// C*

/**/型：

正则表达式：/* C* */

构造DFA

标识符：

(不考虑带 _ 的标识符，画多了）

整型：

浮点数：

//型注释：

/**/型注释：

代码实现

用switch case实现DFA

伪代码为：

​switch(state)
{
    case 1:
        c = getnextchar();
        state = goto(state, c);    //根据当前状态与字符判断跳转到哪一个状态
        token.push_back(c);        //将字符保存进token
        break;
    case 2:
        c = getnextchar();
        state = goto(state, c);    //根据当前状态与字符判断跳转到哪一个状态
        token.push_back(c);        //将字符保存进token
        break;
    case 接受状态:
        print(token);              //打印保存token
        break;
    ……
}

​

​

在状态转移的过程中，需要向前额外看一位，判断是否接受当前的token

如在匹配int a = 123;的过程中，匹配到a时，向前看一位是=，于是将a保存为一个token，同时指针退一位，下次从=开始匹配

详细代码：

//Scanner.h
//作者：IuSpet
//作用：将c-源代码转化为token输出

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

class Scanner
{
private:
	//char buffer[4096];		//读入源程序的缓冲区
	std::string buffer;
	int pos;						//缓冲区位置
	int syn;						//token类别
	int state;						//DFA中的状态
	std::string sourcename;
	int filepos;
	std::ifstream infile;
	//int tsss;
	const int BUFFERLENGTH = 4096;
public:
	Scanner(const char* s)
	{
		//if (source = fopen(s, "r"));
		//else exit(1);
		sourcename = s;
		infile.open(s);
		pos = 0;
		syn = -1;
		state = 0;
		filepos = 0;
		//fgets(buffer, BUFFERLENGTH, source);
		
	}
	void GetToken();				//在DFA上转移，识别token
	bool IsNum(const char c);
	bool IsLetter(const char c);
	char GetNext();					//获取下一个字符
	void Back();					//向前看完后回溯
	~Scanner()
	{
		infile.close();
	}
};


#endif // !Scaner_h
#pragma once

//Scanner.cpp
//作者：IuSpet
//作用：将c-源代码转化为token输出

#include "scanner.h"


void Scanner::GetToken()
{
	char ch;
	constexpr int TOKENLENGTH = 256;
	char token[TOKENLENGTH];
	memset(token, 0, TOKENLENGTH);
	int tokenpos = 0;
	std::ofstream outfile("D://cminus//token.txt");
	while ((ch = GetNext()) != EOF)
	{
		//todo: 标识符，关键字，整型，浮点数运算符，注释，界符，字符串的dfa
		while (state != 100)
			switch (state)
			{
			case 0:									//开始状态
				if (ch == '+') state = 1;
				else if (ch == '-') state = 2;
				else if (ch == '*') state = 3;
				else if (ch == '/') state = 4;
				else if (ch == '<') state = 5;
				else if (ch == '>') state = 6;
				else if (ch == '=') state = 7;
				else if (ch == ';') state = 8;
				else if (ch == '!') state = 9;
				else if (ch == '[') state = 10;
				else if (ch == ']') state = 11;
				else if (ch == '(') state = 12;
				else if (ch == ')') state = 13;
				else if (ch == '{') state = 14;
				else if (ch == '}') state = 15;
				else if (ch == '"') state = 16;
				else if (ch == ',')state = 17;
				else if (IsLetter(ch)) state = 18;
				else if (IsNum(ch)) state = 19;
				else if (ch == ' ' || ch == '\t' || ch == '\n') state = 100;
				else state = 99;			//异常
				break;
			case 1:									//匹配到 +
				token[tokenpos++] = ch;
				ch = GetNext();
				if (IsNum(ch)) state = 19;
				else
				{
					Back();
					syn = 8;
					state = 100;
				}				
				break;
			case 2:									//匹配到 -
				token[tokenpos++] = ch;
				syn = 9;
				state = 100;
				break;
			case 3:									//匹配到 *
				token[tokenpos++] = ch;
				syn = 10;
				state = 100;
				break;
			case 4:									//匹配到 /
				token[tokenpos++] = ch;
				ch = GetNext();
				if (ch == '/') state = 20;
				else if (ch == '*') state = 21;
				else
				{
					Back();
					state = 100;
					syn = 11;
				}
				break;
			case 20:								//匹配到 //
				while ((ch = GetNext()) != '\n');
				syn = 31;
				state = 100;
				break;
			case 21:								// 匹配到 /*
				ch = GetNext();
				if (ch == '*') state = 22;
				else state = 21;
				break;
			case 22:								//匹配到 /**
				ch = GetNext();
				if (ch == '*') state = 22;
				else if (ch == '/')state = 23;
				else state = 21;
				break;
			case 23:								//匹配到 /**/
				state = 100;
				syn = 32;
				break;
			case 5:									//匹配到 <
				token[tokenpos++] = ch;
				ch = GetNext();
				if (ch == '=') state = 24;
				else
				{
					Back();;
					state = 100;
					syn = 12;
				}
				break;
			case 24:								//匹配到 <=
				token[tokenpos++] = ch;
				state = 100;
				syn = 23;
				break;
			case 6:									//匹配到 >
				token[tokenpos++] = ch;
				ch = GetNext();
				if (ch == '=') state = 25;
				else
				{
					Back();
					state = 100;
					syn = 13;
				}
				break;
			case 25:								//匹配到 >=
				token[tokenpos++] = ch;
				state = 100;
				syn = 24;
				break;
			case 7:									//匹配到 =
				token[tokenpos++] = ch;
				ch = GetNext();
				if (ch == '=') state = 26;
				else
				{
					Back();
					state = 100;
					syn = 14;
				}
				break;
			case 26:								//匹配到 ==
				token[tokenpos++] = ch;
				state = 100;
				syn = 25;
				break;
			case 8:									//匹配到 ；
				token[tokenpos++] = ch;
				state = 100;
				syn = 15;
				break;
			case 9:									//匹配到 !
				token[tokenpos++] = ch;
				ch = GetNext();
				if (ch == '=') state = 27;
				else state = 99;
				break;
			case 27:								//匹配到 !=
				token[tokenpos++] = ch;
				state = 100;
				syn = 26;
				break;
			case 10:									//匹配到 [
				token[tokenpos++] = ch;
				state = 100;
				syn = 17;
				break;
			case 11:									//匹配到 ]
				token[tokenpos++] = ch;
				state = 100;
				syn = 18;
				break;
			case 12:									//匹配到 (
				token[tokenpos++] = ch;
				state = 100;
				syn = 19;
				break;
			case 13:									//匹配到 )
				token[tokenpos++] = ch;
				state = 100;
				syn = 20;
				break;
			case 14:									//匹配到 {
				token[tokenpos++] = ch;
				state = 100;
				syn = 21;
				break;
			case 15:									//匹配到 }
				token[tokenpos++] = ch;
				state = 100;
				syn = 22;
				break;
			case 16:									//匹配到 "……
				token[tokenpos++] = ch;
				ch = GetNext();
				if (ch == '"') state = 28;
				else state = 16;
				break;
			case 28:									//匹配到 "……"
				token[tokenpos++] = ch;
				state = 100;
				syn = 30;
				break;
			case 17:									//匹配到 ,
				token[tokenpos++] = ch;
				state = 100;
				syn = 16;
				break;
			case 18:									//匹配到字母
				token[tokenpos++] = ch;
				ch = GetNext();
				if (IsLetter(ch) || IsNum(ch)) state = 18;	//向前看一位还是数字或字母
				else
				{
					Back();
					state = 29;							//向前看一位不属于标识符
				}
				break;
			case 29:									//判断匹配到的标识符是不是关键字
				if (strcmp(token, "if") == 0)
				{
					state = 100;
					syn = 0;
				}
				else if (strcmp(token, "else") == 0)
				{
					state = 100;
					syn = 1;
				}
				else if (strcmp(token, "int") == 0)
				{
					state = 100;
					syn = 2;
				}
				else if (strcmp(token, "double") == 0)
				{
					state = 100;
					syn = 3;
				}
				else if (strcmp(token, "return") == 0)
				{
					state = 100;
					syn = 4;
				}
				else if (strcmp(token, "void") == 0)
				{
					state = 100;
					syn = 5;
				}
				else if (strcmp(token, "while") == 0)
				{
					state = 100;
					syn = 6;
				}
				else if (strcmp(token, "char") == 0)
				{
					state = 100;
					syn = 7;
				}
				else
				{
					state = 100;
					syn = 27;
				}
				break;
			case 19:									//匹配到的是数字
				token[tokenpos++] = ch;
				ch = GetNext();
				if (IsNum(ch)) state = 19;				//下一位还是数字
				else if (ch == '.') state = 30;			//下一位是.
				else
				{
					Back();
					state = 100;
					syn = 28;
				}
				break;
			case 30:									//匹配到 digit D* .
				token[tokenpos++] = ch;
				ch = GetNext();
				if (IsNum(ch)) state = 30;
				else if (ch == 'e') state = 31;
				else
				{
					Back();
					state = 100;
					syn = 29;
				}
				break;
			case 31:									//匹配到 digit D* . D* e
				token[tokenpos++] = ch;
				ch = GetNext();
				if (IsNum(ch)) state = 32;
				else if (ch == '-')state = 33;
				else
				{
					Back();
					state = 99;
				}
				break;
			case 32:									//匹配到 digit D* . D* e
				token[tokenpos++] = ch;
				ch = GetNext();
				if (IsNum(ch)) state = 32;
				else
				{
					Back();
					state = 100;
					syn = 29;
				}
				break;
			case 33:									//匹配到 digit D* . D* e -
				token[tokenpos++] = ch;
				ch = GetNext();
				if (IsNum(ch)) state = 32;
				else
				{
					Back();
					state = 99;
				}
				break;
			case 99:									//匹配中出错
				std::cout << std::endl;
				std::cout << "error" << std::endl;
				std::cout << (int)ch << " " << ch << std::endl;
				ch = GetNext();
				while (ch != ' '&&ch != '\t'&&ch != '\n'&&ch != ';') ch = GetNext();
				Back();
				state = 100;
				syn = -1;
			}
		if (state == 100 && syn != -1)					//接受状态
		{
			switch (syn)
			{
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			case 7:
				outfile << "<" << "RESERVED WORD," << token << ">" << std::endl;
				//outfile << "<" << token << ">" << std::endl;
				break;
			case 27:
				outfile << "<" << "ID," << token << ">" << std::endl;
				break;
			case 28:
				outfile << "<" << "NUM," << token << ">" << std::endl;
				break;
			case 29:
				outfile << "<" << "DOUBLE," << token << ">" << std::endl;
				break;
			case 30:
				outfile << "<" << "STRING," << token << ">" << std::endl;
				break;
			case 31:
			case 32:
				break;
			default:
				outfile << "<" << "SYMBOL," << token << ">" << std::endl;
				//outfile << "<" << token << ">" << std::endl;
			}
			memset(token, 0, TOKENLENGTH);
			tokenpos = 0;
			state = 0;
			syn = -1;
		}
		if (state = 100) state = 0;
	}
	outfile.close();
}

bool Scanner::IsNum(const char c)
{
	return (c >= '0' && c <= '9');
}

bool Scanner::IsLetter(const char c)
{
	return c >= 'a'&&c <= 'z' || c >= 'A'&&c <= 'Z';
}


char Scanner::GetNext()
{
	if (pos < buffer.length())
	{
		return buffer[pos++];
	}
	else
	{
		if (std::getline(infile, buffer))
		{
			buffer.push_back('\n');
		}
		else
		{
			return EOF;
		}
		pos = 0;
		return buffer[pos++];
	}
}

void Scanner::Back()
{
	pos -= 1;
}

测试

测试源码：

int main()
{
	//annotation1
	int a = 123;
	double b = 12.2e-2;
	char str = "hello world";
	if(a != 123)
	{
		return 1;
	}
	/****
	annotation2
	****/
	else
	{
		b = a * b + a / b;
	}
	return 0;
}

测试结果：

<RESERVED WORD,int>
<ID,main>
<SYMBOL,(>
<SYMBOL,)>
<SYMBOL,{>
<RESERVED WORD,int>
<ID,a>
<SYMBOL,=>
<NUM,123>
<SYMBOL,;>
<RESERVED WORD,double>
<ID,b>
<SYMBOL,=>
<DOUBLE,12.2e-2>
<SYMBOL,;>
<RESERVED WORD,char>
<ID,str>
<SYMBOL,=>
<STRING,"hello world">
<SYMBOL,;>
<RESERVED WORD,if>
<SYMBOL,(>
<ID,a>
<SYMBOL,!=>
<NUM,123>
<SYMBOL,)>
<SYMBOL,{>
<RESERVED WORD,return>
<NUM,1>
<SYMBOL,;>
<SYMBOL,}>

全部源码

luSpet
关注
专栏目录
词法分析器与语法分析器
06-03
JAVA 实现的词法分析器与语法分析器。 输出有词法二元表
C语言语法分析器
12-15
编译原理实验课的语法分析器，可以实现基本的语法识别任务，适合计算机科学与技术专业的同学学习分享
C语言小项目-词法分析器
最新发布
qq_42037383的博客
07-02 1465
词法分析器是编译器中的第一个阶段，其主要任务是扫描输入的源代码字符流，并将字符组成的序列转换为有意义的标记（Token）。每个 Token 包含一个词法单元的信息，如关键字、标识符、运算符、常量等。例如，对于表达式int a = 10;，词法分析器会生成诸如INTASSIGNNUMBER(10)和SEMICOLON等 Token。一个完整的编译器，大致会经历如下几个阶段：各个阶段的职责，简单描述如下：1.词法分析：对源文件进行扫描，将源文件的字符划分为一个一个的记号 (token) (
一个简单的C语言词法分析与语法分析器【原】
热门推荐
余璜的技术博客
06-20 2万+
词法分析 可识别内容: 标识符：id 数字：num 关键字：int,char,if,else,while,do,for 标号：, ， . ，  ; 算术运算符号：=，+，-，*，/，&，!，|，&&，|| 关系运算符：=，>，==，!= 注释：// 内码定义： 单个符号，如{，+，*，> 等，均使用其ascii码做内码，占双或多个字节的符号（包括保留字，标号，数字，运算符等）为
编译原理C语言实现词法和语法分析器
酷毙甲壳虫的博客
12-28 3981
实验一：词法分析器 词法分析器的思路： 1.首先是对关键词的识别 可以做一个数组存放关键词的所有单词，例如下列程序的 char *rwtab[6]={"begin","if","then","while","do","end"}; 2.然后是主程序的逻辑： * 循环输入缓存中的字母放进输入数组中 * 调用scaner函数对每一个词进行分析 * 为数字则拼在一起作为一个数输出 * 为关键字符或者变量时，拼成字符串输出 3.scaner函数的思路： * token临时数组存放完成后的数字或字符串 * prog
LLVM学习日志4——Kaleidoscope：词法分析器和语法分析器
tristan_tian的博客
08-13 5127
要实现一门语言，第一要务就是要能够处理文本文件，搞明白其中究竟写了些什么。传统上，我们会先利用“词法分析器”（也称为“扫描器”）将输入切成“语元（token）”，然后再做处理。词法分析器返回的每个语元都带有一个语元编号，此外可能还会附带一些元数据（比如某个数值）。 看了词法分析器的教程，第一章大概就是讲了如何用语元（token）来表示每个词，使用函数不断读取每个词，并且判断和分类。 词法分析器...
编译原理大作业-词法分析器、语法分析器源码（java实现）.zip
03-15
编译原理大作业-词法分析器、语法分析器源码（java实现）.zip编译原理大作业-词法分析器、语法分析器源码（java实现）.zip编译原理大作业-词法分析器、语法分析器源码（java实现）.zip编译原理大作业-词法分析器、...
对C--语言的词法分析器、语法分析器.zip
10-19
本文将深入探讨C--语言的词法分析器和语法分析器，以及它们在编译过程中的作用。 首先，我们从词法分析器开始。词法分析器负责读取源代码，将其分解成一系列有意义的单元，这些单元被称为标记（tokens）。标记通常...
编译原理课程设计自制C-语言词法分析和语法分析器.zip
04-17
这份"编译原理课程设计自制C-语言词法分析和语法分析器.zip"文件包含了一个实际的项目，旨在帮助学习者理解并实践这两个核心概念。 词法分析（Lexical Analysis）： 词法分析器，也称为扫描器，它的主要任务是从源...
简单的词法分析器和语法分析器 LL(1) 正确无误版
04-20
自己编写的一个简单的词法分析器和语法分析器，程序入口在词法分析器 lexer.java 的main方法 。语法分析器识别的文法是文件夹下的一个pdf文件的第四题定义的文法，使用LL(1)，构造预测分析表来实现判断。
语法分析器-C语言
10-28
关于编译原理的试验程序
java 实现词法分析器以及语法分析器
06-29
由于这学期学了编译原理这门课，实验要求写词法分析器以及语法分析器，这才写的，不同网络其他的代码，我采用的是java实现的，也算费了好多脑细胞，希望能大伙看看咋样，不喜勿喷哦，各自学习就是了！
语法分析器
06-05
内容很好。　　　手工模拟控制程序计算,对源程序进行LR语法分析 int col(char); //列定位函数原型 void main() { int state[50]={0}; //状态栈初值 char symbol[50]={'#'}; //符号栈初值 int top=0; //栈顶指针初值 ofstream cout("par_r.txt"); //语法分析结果输出至文件par_r.txt ifstream cin("lex_r.txt"); // lex_r.txt存放词法分析结果，语法分析器从该文件输入数据。 struct code_val t; //结构变量，存放单词二元式。 cin>>t.code>>t.val; //读一单词 int action; int i,j=0; //输出时使用的计数器，并非必要。 cout<<"step"<<'\t'<<"状态栈"<<'\t'<<"符号栈"<<'\t'<<"输入符号"<<endl;//输出标题并非必要。 do{ cout<<j++<<')'<<'\t'; //输出step，并非必要。 for(i=0;i<=top;i++)cout<<state[i];cout<<'\t';//输出状态栈内容，并非必要。 for(i=0;i<=top;i++)cout<<symbol[i]; //输出符号栈内容，并非必要。 cout<<'\t'<<t.code<<endl; //输出当前输入符号（单词种别），并非必要。 action=M[state[top]][col(t.code)]; if(action>0 && action!=99){ //移进 state[++top]=action; symbol[top]=t.code; cin>>t.code>>t.val; //读一单词 }
编译原理--词法分析器+语法分析器 源代码
01-07
词法分析器：1) 定义目标语言的可用符号表和构词规则； 2) 依次读入源程序符号，对源程序进行单词切分和识别，直到源程序结束； 3) 对正确的单词，按照它的种别以<种别码，值>的形式保存在符号表中； 4) 对不正确的...
python实现的对C--语言的词法分析、语法分析.zip
04-17
python实现的对C--语言的词法分析、语法分析 在Python中实现一个对C–语言的词法分析和语法分析的...设计一系列测试用例，用于测试词法分析和语法分析器的正确性。 测试用例应该包括合法的C–代码和包含错误的代码。
C语言词法分析和语法分析
qq_31605553的博客
12-17 4298
编译原理 词法和语法分析
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值