词法分析器实验报告
词法分析器实验报告
词法分析器实验报告实验名称: 编写词法分析器实验类型: 验证型实验指导教师:专业班级:姓名:学号:电子邮件:实验地点:实验成绩:日期: 2012 年3 月 22 日目录一、实验目的。
2 二、实验过程。
21、背景知识。
22、程序总体设计。
23、各种类型表。
4、程序流程图。
5 4三、试验结果。
5 四、讨论与分析。
6 五、附录。
7 六、试验者自评。
131一、实验目的通过设计、调试词法分析程序，实现从源程序中分出各种单词的方法;熟悉词法分析程序所用的工具自动机，进一步理解自动机理论。
掌握文法转换成自动机的技术及有穷自动机实现的方法。
确定词法分析器的输出形式及标识符与关键字的区分方法。
加深对课堂教学的理解;提高词法分析方法的实践能力。
通过本实验，掌握从源程序文件中读取有效字符的方法和产生源程序的内部表示文件的方法以及掌握词法分析的实现方法，并可以成功的上机调试编出的词法分析程序。
二、实验过程我们在设计词法分析器时，应该首先对词法分析器相关的背景知识有足够的了解以及熟练的掌握。
从而在脑海里形成词法分析的一般方案，根据方案一步步所要实现的目的，形成对词法分析器程序的模块划分和整体规划。
1、背景知识词法分析是作为相对独立的阶段来完成的(对源程序或中间结果从头到尾扫描一次，并作相应的加工处理，生成新的中间结果或目标程序)。
在词法分析过程中，编译程序是通过操作系统从外部介质中读取源程序文件中的各个字符的。
同时，为正确地识别单词，有时还需进行超前搜索和回退字符等操作。
因此，为了提高读盘效率和便于扫描器进行工作，通常可采用缓冲输入的方案，即在内存中设置一个适当大小的输入缓冲区，让操作系统直接将磁盘上的源程序字符串分批送入此缓冲区中，供扫描器进行处理。
程序总体设计 2、主程序的说明部分为各种表格和变量安排空间。
二维数组k:关键字表，采用定长的方式，较短的关键字后面补空格。
一维数组p:分界符表。
一维数组s: 运算符表。
二维数组id:存放标识符，在程序运行中，产生标示符表二维数组ci:存放常数。
词法分析程序实验报告
词法分析程序实验报告篇一：词法分析器_实验报告词法分析器实验报告实验目的：设计、编制、调试一个词法分析子程序－识别单词，加深对词法分析原理的理解。
实验要求：该程序要实现的是一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分界符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（一）实验内容（1）功能描述：对给定的程序通过词法分析器弄够识别一个个单词符号，并以二元式(单词种别码，单词符号的属性值)显示。
而本程序则是通过对给定路径的文件的分析后以单词符号和文字提示显示。
（2）程序结构描述：函数调用格式:参数含义：String string;存放读入的字符串 String str; 存放暂时读入的字符串 char ch; 存放读入的字符 int rs 判断读入的文件是否为空 char []data 存放文件中的数据 int m；通过switch用来判断字符类型，函数之间的调用关系图:函数功能：Judgement（）判断输入的字符并输出单词符号，返回值为空； getChar() 读取文件的，返回值为空；isLetter(char c) 判断读入的字符是否为字母的，返回值为Boolean类型； switch (m) 判断跳转输出返回值为空；isOperator(char c)判断是否为运算符的，返回值为Boolean类型； isKey(String string)判断是否为关键字的，返回值为Boolean类型； isDigit(char c) 判断读入的字符是否为数字的，返回值为Boolean类型。
（二）实验过程记录：本次实验出错3次，第一次无法输出双运算符，于是采用双重if条件句进行判断，此方法失败，出现了重复输出，继续修改if语句，仍没有成功。
然后就采用了直接方法调用解决此问题。
对于变量的判断，开始忘了考虑字母和数字组成的变量，结果让字母和数字分家了，不过改变if语句的条件，解决了此问题。
实验一词法分析器实验报告示例
词法分析器实验报告一.需求分析1.C语言关键字的子集，以文件形式保存，待判断的C语言语句以文件形式保存。
2.关键字文件包括标识符、基本字、常数、运算符和界符以及相应的种别码。
3.在计算机终端顺次输出各词法单位的种别码和值。
若为标识符，其值为该标识符在标识符表中的位置；若为常数，其值为该常数在常数表中的位置；其余值为-1。
非法输入单词的种别码为-1，值为-2。
4.“单词”定义：C语言中最小的语法单位。
“标识符”定义：用户自定义的标志符。
5.测试数据：文本文件为unknowedword.text二.概要设计1.单词种别码设计如表一所示：A标识符及关键字如图一所示：图一.标识符状态转换图B实数如图二所示：图二.实数状态转换图C图三.运算符状态转换图D其它与运算符雷同，此处略3. 数据结构know[N] 用来存放构成单词符号的字符串；unknow[N]用来存放待辨别的字符串；chartab[T][N] 用来存放识别出的标识符；keytab[M][N] 用来存放从文件中读入的基本字；consttab[T] 用来存放识别出的实数。
以上均设为全局变量。
4.基本操作Getchar()初始条件：unknow中读入了一串待辨别的字符串。
操作结果：从unknow读入一个字符到ch中，指向unknow的指针加1。
Getbc()初始条件：unknow中读入了一串待辨别的字符串。
操作结果：从unknow中读入不是空格的下一个字符。
Concat()初始条件：know中为字母且ch中为字母，或know中为数字（包括小数点）ch中也为数字。
操作结果：将ch中的字符连接到know中。
Isletter()初始条件：ch中已经读入了一个新的字符。
操作结果：判断ch中的字符是否字母。
Isdigit()初始条件：ch中已经读入了一个新的字符。
操作结果：判断ch中的字符是否数字。
Keyword()初始条件：已判断出know中的字符串为标识符。
词法分析器实验报告
词法分析器实验报告引言：词法分析器（Lexical Analyzer）是编译器的重要组成部分，其主要任务是将源代码转化为一个个独立的词法单元，为语法分析器提供输入。
在本次实验中，我们设计并实现了一个简单的词法分析器，通过对其功能和性能的测试，评估其在不同场景下的表现。
实验目的：1. 确定词法分析器的输入和输出要求；2. 通过构建适当的正则表达式规则，匹配不同类型的词法单元；3. 实现一个高效的词法分析器，确保在处理大型源代码时性能不受影响；4. 对词法分析器的功能和性能进行测试和评估。
实验过程：1. 设计词法分析器的接口：1.1 确定输入：源代码字符串。
1.2 确定输出：词法单元流，每个词法单元包含类型和对应的字符串值。
2. 构建正则表达式规则：2.1 识别关键字：根据编程语言的关键字列表构建正则表达式规则，将关键字与标识符区分开。
2.2 识别标识符：一般由字母、下划线和数字组成，且以字母或下划线开头。
2.3 识别数字：整数和浮点数可以使用不同的规则来识别。
2.4 识别字符串：使用引号（单引号或双引号）包裹的字符序列。
2.5 识别特殊符号：各类操作符、括号、分号等特殊符号需要单独进行规则设计。
3. 实现词法分析器：3.1 读取源代码字符串：逐个字符读取源代码字符串，并根据正则表达式规则进行匹配。
3.2 保存词法单元：将匹配到的词法单元保存到一个词法单元流中。
3.3 返回词法单元流：将词法单元流返回给调用者。
4. 功能测试：4.1 编写测试用例：针对不同类型的词法单元编写测试用例，包括关键字、标识符、数字、字符串和特殊符号。
4.2 执行测试用例：将测试用例作为输入传递给词法分析器，并检查输出是否和预期一致。
4.3 处理错误情况：测试词法分析器对于错误输入的处理情况，如非法字符等。
5. 性能测试：5.1 构建大型源代码文件：生成包含大量代码行数的源代码文件。
5.2 执行词法分析：使用大型源代码文件作为输入，测试词法分析器的性能。
词法分析器实验报告
词法分析器实验报告词法分析器设计一、二、实验目的：对C语言的一个子集设计并实现一个简单的词法分析器，掌握利用状态转换图设计词法分析器的基本方法。
利用该词法分析器完成对源程序字符串的词法分析。
输出形式是源程序的单词符号二元式的代码，并保存到文件中。
二、实验内容：1. 设计原理词法分析的任务：从左至右逐个字符地对源程序进行扫描，产生一个个单词符号。
理论基础：有限自动机、正规文法、正规式词法分析器(Lexical Analyzer) 又称扫描器(Scanner)：执行词法分析的程序2. 词法分析器的功能和输出形式功能:输入源程序、输出单词符号程序语言的单词符号一般分为以下五种：关键字、标识符、常数、运算符,界符3. 输出的单词符号的表示形式:单词种别用整数编码，关键字一字一种，标识符统归为一种，常数一种，各种符号各一种。
4. 词法分析器的结构5. 状态转换图实现三、程序设计1．总体模块设计/*用来存储目标文件名*/string file_name;/*提取文本文件中的信息。
*/string GetText();/*获得一个单词符号,从位置i开始查找。
并且有一个引用参数j，用来返回这个单词最后一个字符在str的位置。
*/string GetWord(string str,int i,int& j);/*这个函数用来除去字符串中连续的空格和换行int DeleteNull(string str,int i);/*判断i当前所指的字符是否为一个分界符，是的话返回真，反之假*/bool IsBoundary(string str,int i);/*判断i当前所指的字符是否为一个运算符，是的话返回真，反之假*/bool IsOperation(string str,int i);/*此函数将一个pair数组输出到一个文件中*/void OutFile(vector<pair<int,string> > v);/*此函数接受一个字符串数组，对它进行词法分析，返回一个pair型数组*/vector<pair<int,string> > analyst(vector<string> vec);/*此函数判断传递的参数是否为关键字，是的话，返回真，反之返回假*/bool IsKey(string str);2．各模块设计（1）.首先根据上面单词符号表及ID和NUM的正规定义式，构造出状态转换图；（2）.定义相关的变量和数据结构。
词法分析器实验报告
词法分析器实验报告⼀、实验⽬的通过设计⼀个词法分析程序，对词法进⾏分析，加强对词法的理解，掌握对程序设计语⾔的分解和理解。
⼆、实验内容和要求在原程序中输⼊源代码对字符串表⽰的源程序从左到右进⾏扫描和分解根据词法规则识别出⼀个⼀个具有独⽴意义的单词符号以供语法分析之⽤发现词法错误，则返回出错信息在源程序中，⾃动识别单词，把单词分为五种，并输出对应的单词种别码。
1. 识别关键字：main if int for while do return break continue，该类的单词码为1.2. 识别标识符：表⽰各种名字，如变量名、数组名、函数名等，如char ch, int syn, token,sum，该类的单词码为2.3. 运算符：+、-、*、/、=、>、<、>=、<=、!=4. 分隔符：,、;、{、}、(、)5. 常数，例：123各种单词符号对应的种别码。
输出形式：⼆元式– （单词种别，单词⾃⾝的值）单词种别，表明单词的种类，语法分析需要的重要信息– 整数码关键字、运算符、界符：⼀符⼀码标识符：10, 常数：11单词⾃⾝的值– 标识符token、常数sum– 关键字、运算符、界符token三、实验⽅法、步骤及结果测试1.源程序#include <stdio.h>#include <string.h>char string[80],simbol[8],ch;int wordID,index,m,n,sum;char *rwtab[6]={"begin","if","then","while","do","end"};void scaner(void);main(){int index=0;printf("请输⼊代码，并以串#号键结束:\n");do{scanf("%c",&ch);string[index++]=ch;}while(ch!='#');index=0;do{scaner();switch(wordID)case11:printf("( %-10d%5d )\n",sum,wordID);break;case -1:printf("错误\n");return0;break;default:printf("( %-10s%5d )\n",simbol,wordID);break;}}while(wordID!=0);return0;}void scaner(void){sum=0;for(m=0;m<8;m++)simbol[m++]= NULL;ch=string[index++];m=0;while((ch=='')||(ch=='\n'))ch=string[index++];if(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A')))//判断输⼊的字符是否为英⽂字母 {while(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))||((ch>='0')&&(ch<='9'))){simbol[m++]=ch;ch=string[index++];}index--;wordID=10;for(n=0;n<6;n++)if(strcmp(simbol,rwtab[n])==0){wordID=n+1;break;}}else if((ch>='0')&&(ch<='9'))//判断输⼊的字符是否为数字{while((ch>='0')&&(ch<='9')){sum=sum*10+ch-'0';ch=string[index++];}index--;wordID=11;}else{switch(ch)//通过循环判断输⼊的字符是否为运算符{case'<':simbol[m++]=ch;ch=string[index++];if(ch=='='){wordID=22;simbol[m++]=ch;}else{wordID=20;index--;}break;case'>':simbol[m++]=ch;ch=string[index++];if(ch=='='){wordID=24;simbol[m++]=ch;else{wordID=23;index--;}break;case'+':simbol[m++]=ch;ch=string[index++];if(ch=='+'){wordID=17;simbol[m++]=ch;}else{wordID=13;index--;}break;case'-':simbol[m++]=ch;ch=string[index++];if(ch=='-'){wordID=29;simbol[m++]=ch;}else{wordID=14;index--;}break;case'!':ch=string[index++];if(ch=='='){wordID=21;simbol[m++]=ch;}else{wordID=31;index--;}break;case'=':simbol[m++]=ch;ch=string[index++];if(ch=='='){wordID=25;simbol[m++]=ch;}else{wordID=18;index--;}break;case'*':wordID=15;simbol[m++]=ch;break;case'/':wordID=16;simbol[m++]=ch;break;case'('://判断输⼊的字符是否为分隔符 wordID=27;simbol[m++]=ch;break;case')':wordID=28;simbol[m++]=ch;break;case'{':wordID=5;simbol[m++]=ch;break;case'}':wordID=6;simbol[m++]=ch;break;case';':wordID=26;simbol[m++]=ch;break;case'\"':wordID=30;simbol[m++]=ch;break;case'#':wordID=0;simbol[m++]=ch;break;case':':wordID=17;simbol[m++]=ch;break;default:wordID=-1;break;}}simbol[m++]='\0'; }四.运⾏结果及分析。
词法分析器实验报告
词法分析器实验报告词法分析器实验报告一、引言词法分析器是编译器中的重要组成部分，它负责将源代码分解成一个个的词法单元，为之后的语法分析提供基础。
本实验旨在设计和实现一个简单的词法分析器，以深入理解其工作原理和实现过程。
二、实验目标本实验的目标是设计和实现一个能够对C语言代码进行词法分析的程序。
该程序能够将源代码分解成关键字、标识符、常量、运算符等各种词法单元，并输出其对应的词法类别。
三、实验方法1. 设计词法规则：根据C语言的词法规则，设计相应的正则表达式来描述各种词法单元的模式。
2. 实现词法分析器：利用编程语言（如Python）实现词法分析器，将源代码作为输入，根据词法规则将其分解成各种词法单元，并输出其类别。
3. 测试和调试：编写测试用例，对词法分析器进行测试和调试，确保其能够正确地识别和输出各种词法单元。
四、实验过程1. 设计词法规则：根据C语言的词法规则，我们需要设计正则表达式来描述各种词法单元的模式。
例如，关键字可以使用'|'操作符将所有关键字列举出来，标识符可以使用[a-zA-Z_][a-zA-Z0-9_]*的模式来匹配，常量可以使用[0-9]+的模式来匹配等等。
2. 实现词法分析器：我们选择使用Python来实现词法分析器。
首先，我们需要读取源代码文件，并将其按行分解。
然后，针对每一行的代码，我们使用正则表达式进行匹配，以识别各种词法单元。
最后，我们将识别出的词法单元输出到一个结果文件中。
3. 测试和调试：我们编写了一系列的测试用例，包括各种不同的C语言代码片段，以测试词法分析器的正确性和鲁棒性。
通过逐个测试用例的运行结果，我们可以发现和解决词法分析器中的问题，并进行相应的调试。
五、实验结果经过多次测试和调试，我们的词法分析器能够正确地将C语言代码分解成各种词法单元，并输出其对应的类别。
例如，对于输入的代码片段：```cint main() {int a = 10;printf("Hello, world!\n");return 0;}```我们的词法分析器将输出以下结果：```关键字：int标识符：main运算符：(运算符：)运算符：{关键字：int标识符：a运算符：=常量：10运算符：;标识符：printf运算符：(常量："Hello, world!\n"运算符：)运算符：;关键字：return常量：0运算符：;```可以看到，词法分析器能够正确地将代码分解成各种词法单元，并输出其对应的类别。
词法分析器的实验报告
词法分析器的实验报告词法分析器的实验报告引言：词法分析器是编译原理中的重要组成部分，它负责将源代码中的字符序列转换为有意义的词法单元，为后续的语法分析提供基础。
本实验旨在设计和实现一个简单的词法分析器，并对其进行测试和评估。
实验设计：1. 词法规则设计：在开始实验之前，我们首先需要设计词法规则，即定义源代码中的合法词法单元。
例如，对于一门类C的语言，我们可以定义关键字（如if、while、int等）、标识符、运算符（如+、-、*等）、分隔符（如()、{}等）等。
2. 有限自动机（DFA）的设计：基于词法规则，我们可以设计一个有限自动机，用于识别和分析源代码中的词法单元。
有限自动机是一个状态转换图，其中每个状态代表一种词法单元，而边表示输入字符的转换关系。
3. 实现代码：根据有限自动机的设计，我们可以使用编程语言（如Python、C++等）实现词法分析器的代码。
代码的主要功能包括读取源代码文件、逐个字符进行词法分析、识别和输出词法单元。
实验过程：1. 词法规则设计：我们以一门简单的算术表达式语言为例，设计了以下词法规则：- 数字：由0-9组成的整数或浮点数。
- 运算符：包括+、-、*、/等。
- 分隔符：包括括号()和逗号,。
- 标识符：以字母开头，由字母和数字组成的字符串。
2. 有限自动机（DFA）的设计：我们基于词法规则，设计了一个简单的有限自动机。
该自动机包含以下状态：- 初始状态：用于读取和识别源代码中的字符。
- 数字状态：用于识别和输出数字。
- 运算符状态：用于识别和输出运算符。
- 分隔符状态：用于识别和输出分隔符。
- 标识符状态：用于识别和输出标识符。
3. 实现代码：我们使用Python编程语言实现了词法分析器的代码。
代码主要包括以下功能：- 读取源代码文件。
- 逐个字符进行词法分析，根据有限自动机的设计进行状态转换。
- 识别和输出词法单元。
实验结果：我们对几个测试样例进行了词法分析，并对结果进行了评估。
编译原理实验报告——词法分析器(内含源代码)
编译原理实验（一）——词法分析器一．实验描述运行环境：vc++2008对某特定语言A ，构造其词法规则。
该语言的单词符号包括：12状态转换图3程序流程：词法分析作成一个子程序，由另一个主程序调用，每次调用返回一个单词对应的二元组，输出标识符表、常数表由主程序来完成。
二．实验目的通过动手实践，使学生对构造编译系统的基本理论、编译程序的基本结构有更为深入的理解和掌握；使学生掌握编译程序设计的基本方法和步骤；能够设计实现编译系统的重要环节。
同时增强编写和调试程序的能力。
三．实验任务编制程序实现要求的功能，并能完成对测试样例程序的分析。
四．实验原理char set[1000],str[500],strtaken[20];//set[]存储代码,strtaken[]存储当前字符char sign[50][10],constant[50][10];//存储标识符和常量定义了一个Analyzer类class Analyzer{public:Analyzer(); //构造函数 ~Analyzer(); //析构函数int IsLetter(char ch); //判断是否是字母，是则返回 1，否则返回 0。
int IsDigit(char ch); //判断是否为数字，是则返回 1，否则返回 0。
void GetChar(char *ch); //将下一个输入字符读到ch中。
void GetBC(char *ch); //检查ch中的字符是否为空白，若是，则调用GetChar直至ch进入一个非空白字符。
void Concat(char *strTaken, char *ch); //将ch中的字符连接到strToken之后。
int Reserve(char *strTaken); //对strTaken中的字符串查找保留字表，若是一个保留字返回它的数码，否则返回0。
void Retract(char *ch) ; //将搜索指针器回调一个字符位置，将ch置为空白字符。
词法分析器实验报告_4
实验一词法分析1．实验要求（1）从源程序文件中读取有效字符和并将其转换成二元组内部表示形式输出。
（2）掌握词法分析的实现方法。
（3）实验时间4学时。
（4）实验完成后，要上交实验报告（包括源程序清单）。
2．实验内容2.1主程序设计考虑：主程序的说明部分为各种表格和变量安排空间（关键字和特殊符号表）。
id 和ci 数组分别存放标识符和常数；还有一些为造表填表设置的变量。
主程序的工作部分建议设计成便于调试的循环结构。
每个循环处理一个单词；接收键盘上送来的一个单词；调用词法分析过程；输出每个单词的内部码（种别编码，属性值）。
2.2词法分析过程考虑该过程根据输入单词的第一个有效字符（有时还需读第二个字符），判断单词种别，产生种别编码。
对于标识符和常数，需分别与标识符表和常数表中已登记的元素相比较，如表中已有该元素，则记录其在表中的位置，如未出现过，将标识符按顺序填入数组id 中，将常数存入数组中ci 中，并记录其在表中的位置。
注：所有识别出的单词都用二元组表示。
第一个表示单词的种别编码。
例如：关键字的t=1；标识符的t=2；常数t=3；运算符t=4；界符t=5。
第二个为该单词在各自表中的指针或内部码值（常数表和标识符表是在编译过程中建立起来的。
其i 值是根据它们在源程序中出现的顺序确定的）。
将词法分析程序设计成独立一遍扫描源程序的结构。
其主流程图如下：图1 词法分析程序流程图程序源代码：#include<stdio.h>#include<stdlib.h>#include<string.h>char *keychar[14]={"int","char","float","void","const","if", "else","do","while","scanf","printf","return","main","read"};//关键字表，全局变量(种别编码为1)char *operatchar[18]={"+","-","*","/","%","=","==",">","<","!=",">=","<=","&&","||","!","<>","++","--"};//运算符表，全局变量（种别编码为2）char *boundschar[8]={"(",")","{","}",";",",","\"","'"};//保留字表，全局变量（种别编码为3）char *markchar[40];//标示符数组（种别编码为4）int markc=0;//记录已经记录的标示符的个数char *conster[40];//常数数组（种别编码为5）int markn=0;//记录已经记录的常数的个数char tempchar[40];//临时用来存放读入的字符int already=0;//全局变量，记录从文件中读出字符的个数char Read()//从文件中读出一个字符{FILE * fcode;char temp;if((fcode=fopen("code.txt","r"))==NULL){printf("无法打开此文件！\n");exit(0);}fseek(fcode,already*sizeof(char),0);//将文件位置移动到标记位置while(!feof(fcode)){already++;temp=fgetc(fcode);if(feof(fcode)){fclose(fcode);exit(0);}fclose(fcode);return temp;}}void ShowCode()//显示文件中的代码{printf("文件中的代码为：\n\n");FILE * fcode;if((fcode=fopen("code.txt","r"))==NULL){printf("无法打开此文件！\n");exit(0);}rewind(fcode);while(!feof(fcode)){putchar(fgetc(fcode));}putchar('\n');fclose(fcode);}void FirstLetter()//处理当程序的首字符为字母时的情况{void Judge();int i=1;char tempch;tempch=Read();while (((tempch>='A'&&tempch<='Z')||(tempch>='a'&&tempch<='z')) ||tempch>='0'&&tempch<='9'){tempchar[i]=tempch;tempch=Read();i++;}if (tempch!=' '){already--;//读出的文件的位置退1}printf("读出的字符为：%s\n",tempchar);int flag=0;for (int j=0;j<14;j++){if (!(strcmp(keychar[j],tempchar)))//若该字符串为关键字{printf("该字符为关键字,二元组为：");printf("<%s,->\n\n",tempchar);flag=1;break;}}if (flag==0)//若字符串为标示符{int flag1=0;char *p;for (int k=0;k<markc;k++)//查找标示符表，是否已存在该标示符{if (!(strcmp(markchar[k],tempchar))){p=markchar[k];flag1=1;break;}if (flag1==0){markchar[markc]=(char*)malloc(strlen(tempchar));strcpy(markchar[markc],tempchar);p=markchar[markc];markc++;}printf("该字符为标示符，二元组为：");printf("<2,%d>\n\n",p);}int l0=strlen(tempchar);for (int l=0;l<l0;l++)//将临时字符数组清零{tempchar[l]='\0';}Judge();}void FirstNum()//处理当程序的首字符为数字时的情况{void Judge();char *p;int i=1;char tempch;tempch=Read();while ((tempch>='0'&&tempch<='9')||tempch=='.'){tempchar[i]=tempch;tempch=Read();i++;}if (tempch!=' '){already--;//读出的文件的位置退1}int flag=0;printf("读出的字符为：%s\n",tempchar);for (int j=0;j<markn;j++){if (!strcmp(conster[j],tempchar)){p=conster[j];flag=1;break;}if (flag==0){conster[markn]=(char*)malloc(strlen(tempchar));strcpy(conster[markn],tempchar);p=conster[markn];markn++;}printf("该字符为常数，二元组为：");printf("<3,%d>\n\n",p);int l0=strlen(tempchar);for (int l=0;l<l0;l++)//将临时字符数组清零{tempchar[l]='\0';}Judge();}void FirstBound()//处理处理当程序的首字符为界符时的情况{void Judge();int i=0;printf("读出的字符为：%s\n",tempchar);printf("该字符为界符，二元组为：");printf("<%s,->\n\n",tempchar);if(tempchar[0]=='"'){do{i++;tempchar[i]=Read();} while (tempchar[i]!='"');if (tempchar[i-1]!='\\'){char*temp1=(char*)malloc(i*sizeof(char));int n=0;for (int j=0;j<i-1;++j){*(temp1+j)=tempchar[j+1];n++;}temp1[i-1]='\0';printf("读出的字符为：%s\n",temp1);conster[markn]=(char*)malloc((i-1)*sizeof(char));strcpy(conster[markn],temp1);char*p=conster[markn];markn++;printf("该字符为常量，二元组为：<3,%d>\n\n",p);free(temp1);}printf("读出的字符为：%c\n",tempchar[i]);printf("该字符为界符，二元组为：<%c,->\n\n",tempchar[i]);}for (int j=0;j<=i;j++){tempchar[j]='\0';}Judge();}void Firstoperat()//处理处理当程序的首字符为界符时的情况{void Judge();tempchar[1]=Read();int flag=0;for (int i=0;i<18;i++){if(!strcmp(tempchar,operatchar[i])){printf("读出的字符为：%s\n",operatchar[i]);printf("该字符为运算符，二元组为：<%s,->\n\n",operatchar[i]);tempchar[1]='\0';flag=1;break;}}if (flag==0){already--;tempchar[1]='\0';for (int i=0;i<18;i++){if (!strcmp(tempchar,operatchar[i])){printf("读出的字符为：%s\n",operatchar[i]);printf("该字符为运算符，二元组为：<%s,->\n\n",operatchar[i]);flag=2;break;}if (flag==0){printf("读出的字符为：%s\n",tempchar);printf("警告！该字符无法识别！\n\n");}}tempchar[0]='\0';Judge();}void Judge() //用来判断第一个读入的字符是数字，字母或者其他字符{do{tempchar[0]=Read();}while ((tempchar[0]==' ')||(tempchar[0]=='\n'));//判断字符类型，并作出处理if ((tempchar[0]>='A'&&tempchar[0]<='Z')||(tempchar[0]>='a'&&tempchar[0]<='z')){FirstLetter();}else if (tempchar[0]>='0'&&tempchar[0]<='9'){FirstNum();}elseif(tempchar[0]=='('||tempchar[0]==')'||tempchar[0]=='{'||tempchar[0]=='}'||tempchar[0]==';'||tempchar[0]==',' ||tempchar[0]=='"'||tempchar[0]=='\''){FirstBound();}else{Firstoperat();}}void main(){ShowCode();Judge();}实验心得：通过此次上机实验，是我掌握了词法分析器的实现过程，以前只是在课堂上学习词法分析器的理论，通过实践，也真正了解到了它的原理，为以后的语法分析打下基础，同时也熟悉了C语言，夯实了C语言的功底！。
词法分析器实验报告
词法分析器实验报告一、实验内容设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。
1.待分析的简单词法（1）关键字：所有的关键字都是小写begin if then while do end（2）运算符和界符: := + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（NUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。
空格一般用来分隔ID、NUM、运算符、界符和关键字，词法分析阶段通常被忽略。
2. 各种单词符号对应的种别码：表1 各种单词符号对应的种别码3. 词法分析程序的功能：输入：所给文法的源程序字符串。
输出：二元组（syn,token或num）构成的序列。
其中：syn为单词种别码；token为存放的单词自身字符串；num为整型常数。
例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin) (10,x) (18,:=) (11,9) (26,;) (2,if)……二、实验设计和实现关键字：定义全局字符串型数组key[6]={"begin","if","then","while","do","end"}，字符串与关键字匹配成功即为关键字。
判断关键字的函数及代码如下：bool isKey(string str,int &syn){int i;for(i=0;i<6;i++){if(str==key[i]){syn=i+1;return true;}}return false;}判断字母函数：bool isLetter(char c){if((c>='A'&&c<='Z')||(c>='a'&&c<='z')){return true;}else{return false;}}判断数字函数：bool isDigit(char c){if(c>='0'&&c<='9'){return true;}else{return false;}}词法判断流程简略图：继续②、③、④↑空格↑①NUM（数字）←读入字符不为空→字母→包括普通字母构成的字符串，ID以及关键字②↓④③运算符和界符三、实验结果与分析判断词法的具体代码：void analyse(FILE *fileP){int n;char c;string str="";while((c=fgetc(fileP))!=EOF){loop: if(c==' '||c=='\t'||c=='\n')//空格{continue;}else if(isDigit(c))//数字{while(isDigit(c)){str+=c;c=fgetc(fileP);if(isLetter(c)){while(isLetter(c)){str+=c;c=fgetc(fileP);}cout<<"(error,"<<str<<")"<<endl;str="";goto loop;}}fseek(fileP,-1,SEEK_CUR);cout<<"(11,"<<str<<")"<<endl;str="";}else if(isLetter(c))//字母开头{while(isDigit(c)||isLetter(c)){str+=c;c=fgetc(fileP);}fseek(fileP,-1,SEEK_CUR);if(isKey(str,n))//关键字的情况{cout<<"("<<n<<","<<str<<")"<<endl;}else//标识符{cout<<"(10,"<<str<<")"<<endl;}str="";}else//运算符和界符{switch(c){case '+':cout<<"(13,+)"<<endl;break;case '-':cout<<"(14,-)"<<endl;break;case '*':cout<<"(15,*)"<<endl;break;case '/':cout<<"(16,/)"<<endl;break;case ':':{c=fgetc(fileP);if(c=='='){cout<<"(18,:=)"<<endl;}else{cout<<"(17,:)"<<endl;fseek(fileP,-1,SEEK_CUR);}}break;case '<':{c=fgetc(fileP);if(c=='='){cout<<"(22,<=)"<<endl;}else if(c=='>'){cout<<"(21,<>)"<<endl;}else{cout<<"(20,<)"<<endl;fseek(fileP,-1,SEEK_CUR);}}break;case '>':{c=fgetc(fileP);if(c=='='){cout<<"(24,>=)"<<endl;}else{cout<<"(23,>)"<<endl;fseek(fileP,-1,SEEK_CUR);}}break;case '=':cout<<"(25,=)"<<endl;break;case ';':cout<<"(26,;)"<<endl;break;case '(':cout<<"(27,()"<<endl;break;case ')':cout<<"(28,))"<<endl;break;case '#':cout<<"(0,#)"<<endl;break;}}}}主函数部分：int main(){char filec[30];FILE *fileP;cout<<"input the name of your file:"<<endl;for(;;){cin>>filec;if((fileP=fopen(filec,"r"))!=NULL)break;elsecout<<"error input,input once more!"<<endl;}cout<<endl;cout<<"output the result:"<<endl;analyse(fileP);fclose(fileP);return 0;}结果：测试数据1：begin x:=9; if x>9 then x:=2*x+1/3; end #测试数据2：begin 9xy:=+9; if x>9 then x:=2*x+1/3; end #四、实验总结和体会通过此次实验，让我了解到如何设计、编制并调试词法分析程序，加深对词法分析原理的理解；熟悉了构造词法分析程序的手工方式的相关原理，根据识别语言单词的状态转换图，使用某种高级语言（例如C++语言）直接编写此法分析程序。
词法分析器实验报告
实验报告【实验过程记录（源程序、测试用例、测试结果及心得体会等）】1、程序源代码：#include "fstream.h"#include "iostream.h"#include "string.h"#include "ctype.h"char ch ; // 存放当前的输入字符int lineno = 1; // 记录当前的行号void main()//主函数{void Reserve(ifstream&);ifstream fin("input.txt",ios::nocreate); //用ifstream的对象fin打开input文件，文件不存在时，不创建if (fin.fail()) cout << "找不到文件" << endl;Reserve(fin);fin.close();//fout.close();// ferr.close();}int judge(char *string) // 判断是否为关键字{char *keywords[1000]={"if","int","else","for","while","do","return","break","continue"};//关键字表，按相应类型号排序for(int i = 0;i <= 8;i++) //遍历keywords数组{if (!strcmp(string,*(keywords+i))){return 1; //是关键字，返回对应的类型值}}return 0; //不是关键字，返回0}void Reserve(ifstream &fin) //词法分析程序,用引用传递参数{char temp[100]; // 临时存放已读入但无法判断类型的字符int j = 0;int value_judge ;//存放函数judge的返回值while (fin.get(ch)){if (ch == '\n') {lineno += 1; }else if (ch == '\t'||ch == ' ') {} //排除制表、空格字符else if (isalpha(ch)) //当前输入符为字母{while (isalpha(ch)||isdigit(ch)){temp[j] = ch;j++;fin.get(ch);}temp[j] = '\0'; //标志字符串结束j = 0;if (value_judge = judge(temp)) // 判断是否为关键字{cout << "(1, "<< "\""<<temp<<"\")" << endl;}else cout << "(2, "<< "\""<<temp<<"\")" << endl;fin.seekg(-1,ios::cur); //回退1个字符}else if (isdigit(ch)){while (isdigit(ch)){temp[j] = ch;j++;fin.get(ch);}temp[j] = '\0'; //标志字符串结束j = 0;cout << "(3, "<< "\""<<temp<<"\")" << endl;fin.seekg(-1,ios::cur); //回退一个字符}//+、-、*、/、=、>、<、>=、<=、<>else if (ch == '+') cout << "(4, "<< "\"+\")" << endl;else if (ch == '-') cout << "(4, "<< "\"-\")" << endl;else if (ch == '*') cout << "(4, "<< "\"*\")" << endl;else if (ch == '/') cout << "(4, "<< "\"/\")" << endl;else if (ch == '=') cout << "(4, "<< "\"=\")" << endl;else if (ch == '>') cout << "(4, "<< "\">\")" << endl;else if (ch == '<') cout << "(4, "<< "\"<\")" << endl;else if (ch == '>=') cout << "(4, "<< "\">=\")" << endl;else if (ch == '<=') cout << "(4, "<< "\"<=\")" << endl;else if (ch == '<>') cout << "(4, "<< "\"<>\")" << endl;//,、;、{、}、(、)else if (ch == ',') cout << "(5, "<< "\",\")" << endl;else if (ch == ';') cout << "(5, "<< "\";\")" << endl;else if (ch == '(') cout << "(5, "<< "\"(\")" << endl;else if (ch == ')') cout << "(5, "<< "\")\")" << endl;else if (ch == '{') cout << "(5, "<< "\"{\")" << endl;else if (ch == '}') cout << "(5, "<< "\"}\")" << endl;ch = '\0';}}2、程序设计截图3、程序运行结果截图。
词法分析器实验报告
词法分析器实验报告一、实验目的本实验旨在通过构建一个简单的词法分析器来加深对编译原理中词法分析的理解，并掌握基本的词法分析算法和程序设计技巧。
二、实验环境操作系统：Windows 10编程语言：C/C++开发环境：Visual Studio 2019三、实验内容1. 设计并实现一个词法分析器，要求具备以下功能：（1）能够识别并区分关键字、标识符、字符常量、字符串常量、整型常量和浮点型常量等基本单词；（2）能够跳过注释、空格、制表符和换行符等无用字符；（3）能够给出错误提示并指明错误所在位置。
2. 对设计的词法分析器进行测试，并记录测试结果，分析测试结果的正确性和效率。
四、实验方法1. 分析待处理的源程序，并确定需要识别的词法单元；2. 设计状态转换图或状态转换表，并将其转化为程序代码；3. 开发测试程序，对所设计的词法分析器进行测试。
五、实验结果1. 实现的词法分析器程序可以正确识别出源程序中的各个单词，并能够跳过无用字符；2. 在测试过程中发现了一些错误，比如未能正确识别一些特殊情况下的单词，或者给出了错误的错误提示等。
经过修改后，程序可以正确识别这些情况，并给出正确的错误提示信息；3. 程序的效率较高，能够在短时间内对源程序进行词法分析。
六、实验体会通过本次实验，我对编译原理中词法分析的概念、算法和程序设计技巧有了更加深入的了解和掌握。
在实践中，我遇到了许多问题，比如如何设计状态转换图，如何正确识别一些特殊的单词等。
这些问题一一解决后，我对词法分析有了更加深刻的理解。
通过本次实验，我还深刻体会到了编译器设计过程中的思维方式和技术要求。
编译器是计算机科学中的一项重要技术，对于提高程序运行效率、保证程序安全性、增强程序可读性和扩展程序功能等都有重要作用。
因此，编译原理作为计算机科学的重要组成部分，对于我以后的学习和研究具有重要意义。
实现词法分析实验报告
实现词法分析实验报告一、实验目的本次实验的目的是通过编写代码实现一个简单的词法分析器，可以对一段输入的代码进行词法分析，识别出其中的各种标识符、关键字、常数和运算符等。
二、实验原理词法分析是编译过程中的第一个阶段，它负责将源代码按照规定的规则划分为一个个的单词（Token），每个单词代表一个最基本的语法单元。
在词法分析中，我们通过预先定义好的正则表达式规则来描述各个单词类型，并自动从源代码中提取出这些单词。
本次实验采用基于正则表达式的文法描述方式，针对不同的单词类型，使用不同的正则表达式来匹配。
通过遍历源代码字符串，逐一尝试匹配各个正则表达式，从而实现对单词的划分。
在匹配过程中，我们使用一个状态机来记录当前的匹配状态，以便处理不同的情况。
三、实验过程1. 定义Token的数据结构，包括单词类型和单词值两个字段。
使用枚举类型来表示所有的单词类型，如关键字、标识符、常数等。
2. 编写正则表达式的匹配函数，用于判断给定的字符串是否符合某个模式。
在这个函数中，使用系统提供的正则表达式库或者手动实现正则表达式匹配算法。
3. 设计一个状态机，用于记录当前匹配的状态。
状态机的状态包括开始、正在匹配、匹配成功和匹配失败等。
在状态机中，根据当前字符和当前状态进行不同的处理。
4. 在状态机中，当一个完整的Token被匹配出时，根据其类型和值创建一个Token对象，并将其添加到Token列表中。
5. 将源代码字符串按照换行符划分成多行，逐行进行处理。
对于每一行，调用状态机进行匹配，将得到的Token添加到Token列表中。
6. 输出Token列表，观察结果。
四、实验结果经过实验，我们成功实现了一个简单的词法分析器。
通过对输入的代码进行词法分析，我们可以得到每个单词的类型和值。
在本次实验中，我们测试了一段C语言代码，并成功提取出其中的关键字、标识符、常数和运算符等。
五、实验总结本次实验让我初步了解了词法分析的原理和过程。
词法分析器实验报告
词法分析器实验报告词法分析器是编译器的一个重要组成部分，用于将输入的字符流转换成一个个词法单元（token）。
本次实验使用Python语言实现了一个简单的词法分析器。
主要包括以下几个步骤：1. 预处理：去除源代码中的空格、换行符等无意义字符，并进行必要的错误检查。
2. 正则表达式定义词法单元：利用正则表达式定义源代码可以被识别为词法单元的模式。
例如，整数可以定义为由数字组成的串，标识符可以定义为以字母或下划线开头，后面跟着任意个字母、数字或下划线的串。
3. 正则表达式匹配：利用Python的re模块，使用定义好的正则表达式对预处理后的源代码进行匹配。
如果匹配成功，则生成对应的词法单元，并存储起来。
4. 输出词法单元：将生成的词法单元按照一定的格式输出。
实验结果：通过对不同的源代码进行测试，可以得到正确的词法单元输出。
例如，对于以下的源代码：```pythonx = 123 + 456 * (789 - 100)```经过词法分析器处理后，可以得到以下的词法单元输出：```Token(ID, 'x')Token(ASSIGN, '=')Token(INT, '123')Token(PLUS, '+')Token(INT, '456')Token(LPAREN, '(')Token(INT, '789')Token(MINUS, '-')Token(INT, '100')Token(RPAREN, ')')```总结与收获：通过本次实验，我对词法分析器的基本原理和实现方法有了更深入的了解。
同时，我学会了如何使用正则表达式进行模式匹配，以及如何使用Python的re模块进行正则表达式匹配。
这对于我进一步学习和理解编译原理以及编译器的工作原理有很大帮助。
词法分析器实验报告_5
一、实验目的1.1总体目的1.1.1 掌握词法分析的基本原理；1.1.2.理解词法分析在编译程序过程中的作用；1.1.3.熟悉关键字表等相关的数据结构与单词的分类方法.1.1.4.加深对编译原理的理解，掌握词法分析器的实现方法和技术，同时，将JA V A 的理论知识结合实际，锻炼编程技术，强调良好的程序设计风格。
1.2程序目的利用JAVA语言针对C语言编制一个一遍扫描的编译程序。
从文件中识别出各个单词, 识别出所取的单词的类型, 并且对代码中的词法错误进行提示。
二、实验内容根据编译原理中的词法分析原理, 利用Java语言针对C语言编写一个词法分析程序: 输入: 打开一个C语言程序的源代码文件, 将其读入程序输入框。
处理: 对输入框中的代码进行词法分析,分离出关键字、标识符、数值、运算符和界符。
输出：在词法分析结果表中输出每个单词所在行号、类型以及它所对应的编码。
其中, 编码是自定义的,一种类型对应一组编码。
词法分析结果显示在词法分析错误信息栏, 提示错误个数、错误所在行号, 并对某些词法错误原因进行说明。
三、实验需求针对C语言程序代码进行词法分析器, 从指定文件中读入预分析的源程序, 从左至右扫描源程序的字符串, 按照词法规则（正则文法规则）识别出一个个正确的单词, 并转换成该单词相应的二元式（种别码、属性值）以便之后进行语法分析使用。
同时, 按照给定的规则, 识别出单词符号作为输出, 发现其中的语法错误, 不同类别的字符通过相应的函数模块来分析识别, 使程序能够正确识别文法所规定的任何组织形式的字符组合, 将所有的分析状态显示在词法分析器中。
最后在错误分析栏中显示该文件中C语言代码的词法错误个数、错误所在行, 并对错误原因进行说明。
四、主要数据结构介绍4.1关键字编码4.2标识符统一编码1004.3数值统一编码2004.4界符编码4.5运算符编码4.6全局变量含义int row: 语法错误出现的所在列数int line: 语法错误出现的所在行数int err: 语法错误的个数int begin: 当前程序扫描在字符串中的开始位置int end: 当前程序扫描在字符串中的结束位置4.7局部变量定义int i: 选择第i 个字符进行检测 int state: 单词类型判断标志 int N: 文件长度char c: 当前遍历的字符 string str: 输入字符串 int flag: 退出标志五、主要模块算法介绍5.1总体流程介绍说明: state 为输入字符状态标志, 根据输入字符不同类型选择不同处理。
编译原理实验报告——词法分析器
编译原理实验报告姓名：关海超学号：200807010209专业：计算机科学与技术班级：08—02班一、实验目的通过设计调试词法分析程序，实现从源程序中分出各种单词的方法；加深对课堂教学的理解；提高词法分析方法的实践能力。
二、词法分析器的实现1、词法分析过程的考虑词法分析器的任务是将程序源代码看做一个字符串，只需从中分离出一个个具有独立意义的单词（包括标识符，符号和常量）即可，而无需考虑其在上下文环境中的正确性。
基于此认识，词法分析的过程可如下描述：本程序中用户源程序存储在文件“E:\prog.txt”文件中，程序首先调用readFromFile()函数将源程序代码从文件中读出，放到数组中暂存，然后主函数调用scaner()函数对其进行逐个扫描，分离出的每个独立单词进行分类判断，构成二元组形式，再将其输出的文件“E:\result.txt”中进行保存。
2、各种单词符号对应的种别码0 标识符21 ret 42 ++ 63 ||1 整型常量22 sho 43 -- 64 ?:2 auto 23 sig 44 - 65 =3 brea 24 siz 45 * 66 +=4 case 25 sta 46 & 67 -=5 char 26 str 47 / 68 *=6 cons 27 swi 48 % 69 /=7 cont 28 typ 49 + 70 %=8 defa 29 uni 50 - 71 >>=9 do 30 uns 51 << 72 <<=10 dou 31 voi 52 >> 73 &=11 els 32 vol 53 < 74 ^=12 enu 33 whi 54 <= 75 |=13 ext 34 ( 55 > 76 ,14 flo 35 ) 56 >= 77 '15 for 36 [ 57 == 78 ;16 got 37 ] 58 != 79 :17 if 38 -> 59 & 80 \{18 int 39 . 60 ^ 81 }19 lon 40 ! 61 | 82 //20 reg 41 ~ 62 &&3、关键数据结构的描述计数器count：将二元组写入文件时通过count判断是否是首次写入，若是则清空文件，否则追加写入；字符串常量endStr：其值为“end”，在分析判断每一单词的种类时，该字符串作为rwtab表的结束标志；数组prog[200]：暂存从文件中读取的源程序代码，该词法分析器约定源代码长度不超过199；数组token[20]：暂存每次分离出的单个具有独立意义的单词，该词法分析器约定每个单词的长度不超过19；结构体result：存放一个单词的种别码和单词本身的值，在写入文件时以结构体中的元素为单位依次写入；4、程序结构的描述本程序采用结构化设计方法，共有两个文件，六个模块，分别介绍如下：rwtab.h文件包含一个模块，即各种单词符号对应的种别码，作为外部文件被main.cpp文件引用。
编译原理词法分析器实验报告
编译原理词法分析器实验报告篇一：编译原理词法分析器实验报告曲阜师范大学实验报告计算机系2008年级软件工程一班组日期2010年10月17日星期日姓名陈金金同组者姓名课程编译原理成绩实验名称：教师签章词法分析器一、实验目的：1·掌握词法分析的原理。
2·熟悉保留字表等相关的数据结构与单词的分类方法。
3·掌握词法分析器的设计与调试。
二、实验内容：根据编译中的分词原理，编写一个词法分析程序：1. 输入：任意一个C 语言程序的源代码。
2. 处理：对输入进行分析，分离出保留字、标识符、常量、算符和界符。
3. 输出：对应的二元式（种别编码自定，可暂编为一类对应一个编码）。
三、实验要求：1. 任选C/C++/Java 中的一种高级程序语言编程完成词法分析器。
2. 词法分析器应以教材所述分词原理为依据，使用恰当的数据结构和方法，结构清晰、高效。
四、实验环境：WindowsXp操作系统，J2SE，Eclipse 集成开发环境五、实验分析：将源代码作为长字符串进行读入，之后通过switch语句，及状态转换图进行词素识别，并对识别的词素进行分类整理以二元式的形式输出。
六、实验过程：1、建立词法分析器界面，很简单：输入框，输出框，执行分析按钮，清空按钮，退出程序按钮。
主要的地方是，考虑mvc开发模式，为model及controller 提供接口。
实现界面如下所示：2、核心代码的编写，考虑到需要进行词素的匹配，创建符号表类SymTable。
提供两个变量，分别存放如下内容：并提供方法insert，lookUp，分别负责标志符的插入和查找。
3.、根据语法规则书写状态转换图，并用switch语句实现：需要注意的地方是，begin和forward 两个指针的移动：通过swith语句识别词素，并在符号表中进行匹配，匹配成功，则返回相应的记号，否则返回id。
七、实验结论：实验过程还算顺利，遇到的一系列问题都得到比较好的解决，当然分析器还有很大的改进空间，这里只是简单的实现了词素的识别及简单的判断。
(完整)编译原理实验报告(词法分析器 语法分析器)
编译原理实验报告实验一一、实验名称：词法分析器的设计二、实验目的：1，词法分析器能够识别简单语言的单词符号2，识别出并输出简单语言的基本字。
标示符。
无符号整数.运算符.和界符。
三、实验要求：给出一个简单语言单词符号的种别编码词法分析器四、实验原理:1、词法分析程序的算法思想算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号.2、程序流程图(1）主程序（2）扫描子程序3、各种单词符号对应的种别码五、实验内容:1、实验分析编写程序时，先定义几个全局变量a[]、token[]（均为字符串数组)，c,s( char型)，i,j,k（int型），a［］用来存放输入的字符串,token[]另一个则用来帮助识别单词符号,s用来表示正在分析的字符.字符串输入之后，逐个分析输入字符,判断其是否‘#’,若是表示字符串输入分析完毕，结束分析程序,若否则通过int digit(char c）、int letter(char c）判断其是数字，字符还是算术符,分别为用以判断数字或字符的情况，算术符的判断可以在switch语句中进行，还要通过函数int lookup(char token［])来判断标识符和保留字。
2 实验词法分析器源程序:＃include 〈stdio.h〉＃include <math.h>#include <string。
h>int i,j,k;char c,s,a［20]，token[20]=｛’0’｝;int letter(char s){if（(s〉=97)&&（s〈=122）) return(1);else return（0);｝int digit（char s）｛if（(s〉=48）＆＆（s<=57）) return(1)；else return(0);}void get(){s=a［i];i=i+1；｝void retract()｛i=i-1；}int lookup（char token[20］)｛if（strcmp（token，"while"）==0） return（1）;else if(strcmp(token,"if"）==0) return（2）;else if(strcmp(token,"else”）==0） return(3）;else if（strcmp（token，"switch”)==0） return(4）；else if（strcmp（token,"case")==0） return（5）;else return（0）;｝void main(）｛printf（”please input string ：\n"）；i=0;do{i=i+1；scanf("%c",＆a［i]）;｝while（a[i］!=’#’)；i=1;j=0;get();while(s!=’#')｛ memset(token，0，20);switch（s)｛case 'a':case ’b'：case ’c'：case ’d':case ’e’：case ’f’:case 'g’:case ’h'：case 'i'：case ’j'：case 'k’:case ’l':case 'm’：case 'n':case ’o'：case ’p'：case ’q’：case 'r’:case 's’：case 't’:case ’u’：case ’v’:case ’w’:case ’x'：case ’y':case ’z’：while（letter(s）||digit(s)）{token[j］=s;j=j+1；get()；｝retract();k=lookup（token）;if（k==0)printf（"（%d,％s）”,6,token）;else printf("（%d,—)"，k);break;case ’0':case ’1’:case ’2'：case ’3':case '4’：case '5’：case ’6'：case ’7’：case ’8’:case '9’：while（digit(s）)｛token[j]=s;j=j+1；get（）;｝retract(）;printf(”％d,％s",7,token）；break;case '+'：printf(”（’+',NULL)”）；break;case ’-':printf("（’-'，null）"）;break；case ’＊':printf（”（'＊’，null）"）;break;case '<':get()；if(s=='=’） printf（”（relop,LE)”）；else｛retract(）；printf（"（relop，LT)"）;｝break;case ’='：get（）;if(s=='=’）printf（"(relop,EQ)"）；else{retract（）；printf(”('=',null）”)；｝break；case ’；'：printf（”（；,null)")；break；case ' ’：break；default:printf（"！\n”)；}j=0;get(）；｝ }六：实验结果：实验二一、实验名称：语法分析器的设计二、实验目的：用C语言编写对一个算术表达式实现语法分析的语法分析程序，并以四元式的形式输出，以加深对语法语义分析原理的理解,掌握语法分析程序的实现方法和技术.三、实验原理：1、算术表达式语法分析程序的算法思想首先通过关系图法构造出终结符间的左右优先函数f(a)，g(a）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
词法分析器实验报告词法分析器设计一、实验目的：对C语言的一个子集设计并实现一个简单的词法分析器，掌握利用状态转换图设计词法分析器的基本方法。
利用该词法分析器完成对源程序字符串的词法分析。
输出形式是源程序的单词符号二元式的代码，并保存到文件中。
二、实验内容：1. 设计原理词法分析的任务：从左至右逐个字符地对源程序进行扫描，产生一个个单词符号。
理论基础：有限自动机、正规文法、正规式词法分析器(Lexical Analyzer) 又称扫描器(Scanner)：执行词法分析的程序2. 词法分析器的功能和输出形式功能:输入源程序、输出单词符号程序语言的单词符号一般分为以下五种：关键字、标识符、常数、运算符,界符3. 输出的单词符号的表示形式:单词种别用整数编码，关键字一字一种，标识符统归为一种，常数一种，各种符号各一种。
4. 词法分析器的结构单词符号5. 状态转换图实现三、程序设计1．总体模块设计/*用来存储目标文件名*/string file_name;/*提取文本文件中的信息。
*/string GetText();/*获得一个单词符号,从位置i开始查找。
并且有一个引用参数j，用来返回这个单词最后一个字符在str的位置。
*/string GetWord(string str,int i,int& j);/*这个函数用来除去字符串中连续的空格和换行int DeleteNull(string str,int i);/*判断i当前所指的字符是否为一个分界符，是的话返回真，反之假*/ bool IsBoundary(string str,int i);/*判断i当前所指的字符是否为一个运算符，是的话返回真，反之假*/ bool IsOperation(string str,int i);/*此函数将一个pair数组输出到一个文件中*/void OutFile(vector<pair<int,string> > v);/*此函数接受一个字符串数组，对它进行词法分析，返回一个pair型数组*/vector<pair<int,string> > analyst(vector<string> vec);/*此函数判断传递的参数是否为关键字，是的话，返回真，反之返回假*/ bool IsKey(string str);2．各模块设计（1）.首先根据上面单词符号表及ID和NUM的正规定义式，构造出状态转换图；（2）.定义相关的变量和数据结构。
关键字作为特殊标识符处理，把它们预先安排在一张表格中（称为关键字表），当扫描程序识别出标识符时，查关键字表。
如能查到匹配的单词，则该单词为关键字，否则为一般标识符。
关键字表为一个字符串数组，其描述如下：char KEY_WORDS[7]={″main″,″int″,″char″,″if″,″else″,″for″,″while″}；用以存放单词符号二元式的数据结构可如下定义：class Word_Analyzer{public:char Content[MAXLENGTH] ;int val ;void print();} ;（3）.按照编译程序一遍扫描的要求，把词法分析器Scaner作为一个独立的子程序来设计，通过对Scaner的反复调用识别出所有的单词符号；（4）.当Scaner识别出一个单词符号时，则将该单词符号的二元式写入到输出文件中。
若Scaner无法识别出一个单词符号时，则调用错误处理程序PrintError，显示当前扫描到的字符及其所在行、列位置，并跳过该字符重新开始识别单词符号。
四、程序代码#include <iostream>#include <vector>#include <string>#include <fstream>using namespace std;/*用来存储目标文件名*/string file_name;/*提取文本文件中的信息。
*/string GetText();/*获得一个单词符号,从位置i开始查找。
//并且有一个引用参数j，用来返回这个单词最后一个字符在str的位置。
*/string GetWord(string str,int i,int& j);/*这个函数用来除去字符串中连续的空格和换行//第一个参数为目标字符串，第二个参数为开始位置//返回值为连续的空格和换行后的第一个有效字符在字符串的位置*/ int DeleteNull(string str,int i);/*判断i当前所指的字符是否为一个分界符，是的话返回真，反之假*/ bool IsBoundary(string str,int i);/*判断i当前所指的字符是否为一个运算符，是的话返回真，反之假*/ bool IsOperation(string str,int i);/*此函数将一个pair数组输出到一个文件中*/void OutFile(vector<pair<int,string> > v);/*次函数将参数str,digit添加到temp中*/void add(string str,int digit,vector<pair<int,string> > temp);/*此函数接受一个字符串数组，对它进行词法分析，返回一个pair型数组*/vector<pair<int,string> > analyst(vector<string> vec);/*此函数判断传递的参数是否为关键字，是的话，返回真，反之返回假*/ bool IsKey(string str);int main(){cout<<"*********************************************** **********\n";cout<<"*************编译原理课程设计--词法编译器ver 1.0*********\n";cout<<"************************************************** *******\n";cout<<endl;string com1=" ";string com2="\n";string fileline=GetText();int begin=0,end=0;vector<string> array;do{begin=DeleteNull(fileline,begin);string nowString;nowString=GetWord(fileline,begin,end);if(end==-1)break;if(pare(com1)&&pare(com2)) array.push_back(nowString);begin=end+1;}while(true);vector<pair<int,string> > mid_result;mid_result=analyst(array);OutFile(mid_result);cout<<"************************************************** *******\n";cout<<"*程序已完成词法分析，分析结果已经存储在文件"<<file_name<<"中！！！*\n";cout<<"************************************************** *******\n";cout<<"感谢使用，谢谢再见！"<<endl;system("pause");return 0;}/*提取文本文件中的信息*/string GetText(){string file_name1;cout<<"请输入源文件名（包括路径和后缀名）：";cin>>file_name1;ifstream infile(file_name1.c_str(),ios::in);if (!infile){cerr<<"无法打开文件!"<<file_name1.c_str()<<" "<<endl;exit(-1);}cout<<endl;char f[1000];infile.getline(f,1000,EOF);infile.close();printf(f);cout<<endl;return f;}/*获得一个单词符号,从位置i开始查找。
//并且有一个引用参数j，用来返回这个单词最后一个字符在原字符串的位置。
*/string GetWord(string str,int i,int& j){string no_use("(){} , ;\n+=*/-<>\"");j=str.find_first_of(no_use,i);if(j==-1)return "";if(i!=j)j--;return str.substr(i,j-i+1);}/*这个函数用来除去字符串中连续的空格和换行//第一个参数为目标字符串，第二个参数为开始位置//返回值为连续的空格和换行后的第一个有效字符在字符串的位置*/int DeleteNull(string str,int i){for(;;i++)if(str[i]!=' '&&str[i]!='\n')return i;}/*判断i当前所指的字符是否为一个分界符，是的话返回真，反之假*/bool IsBoundary(string str,int i){int t;char arr[7]={',',';','{','}','(',')',':'};for (t=0;t<7;t++)if(str[i]==arr[t])return true;return false;}/*判断i当前所指的字符是否为一个运算符，是的话返回真，反之假*/bool IsOperation(string str,int i){int t;char arr[8]={'+','-','*','/','=','<','>','&'};for (t=0;t<8;t++)if(str[i]==arr[t])return true;return false;}/*此函数将一个个字符串数组输出到一个文件中*/void OutFile(vector<pair<int,string> > v){cout<<"请输入目标文件名（包括路径和后缀名）：";cin>>file_name;ofstream outfile(file_name.c_str(),ios::out);if (!outfile){cerr<<"无法打开文件!"<<file_name.c_str()<<" "<<endl;exit(-1);}cout<<endl;int i;for(i=0;i<v.size();i++){outfile<<"<"<<v[i].first<<" ,\""<<v[i].second<<"\">"<<endl;cout<<"<"<<v[i].first<<" ,\""<<v[i].second<<"\">"<<endl;}outfile<<"\n\n*********************************\n";outfile.close();return;}/*此函数判断传递的参数是否为关键字，是的话，返回真，反之返回假*/bool IsKey(string str){stringp[7]={"main","int","char","if","else","for","while"};vector<string> ppp(p,p+7);int u;for(u=0;u<ppp.size();u++)if(!pare(ppp[u]))return true;return false;}/*此函数接受一个字符串数组，对它进行词法分析，返回一个pair型数组*/vector<pair<int,string> > analyst(vector<string> vec){vector<pair<int,string> > temp; int i;for(i=0;i<vec.size();i++){if(vec[i].size()==1){if(vec[i]==">"&&vec[i+1]=="="){string jk=vec[i];jk.append(vec[++i],0,1);pair<int,string> pp(37,jk);temp.push_back(pp);continue;}if(vec[i]=="<"&&vec[i+1]=="="){string jk=vec[i];jk.append(vec[++i],0,1);pair<int,string> pp(38,jk);temp.push_back(pp);continue;}if(vec[i]=="="&&vec[i+1]=="="){string jk=vec[i];jk.append(vec[++i],0,1);pair<int,string> pp(39,jk);temp.push_back(pp);continue;}if(vec[i]=="!"&&vec[i+1]=="="){string jk=vec[i];jk.append(vec[++i],0,1);pair<int,string> pp(40,jk);temp.push_back(pp);continue;}if(vec[i]=="&"&&vec[i+1]=="&"){string jk=vec[i];jk.append(vec[++i],0,1);pair<int,string> pp(42,jk);temp.push_back(pp);continue;}if(vec[i]=="|"&&vec[i+1]=="|"){string jk=vec[i];jk.append(vec[++i],0,1);pair<int,string> pp(43,jk);temp.push_back(pp);continue;}if(IsBoundary(vec[i],0)){if(vec[i]==","){pair<int,string> pp1(32,vec[i]);temp.push_back(pp1);}if(vec[i]==";"){pair<int,string> pp2(34,vec[i]);temp.push_back(pp2);}if(vec[i]=="{"){pair<int,string> pp3(30,vec[i]);temp.push_back(pp3);}if(vec[i]=="}"){pair<int,string> pp4(31,vec[i]);temp.push_back(pp4);}if(vec[i]=="("){pair<int,string> pp5(26,vec[i]);temp.push_back(pp5);}if(vec[i]==")"){pair<int,string> pp6(27,vec[i]);temp.push_back(pp6);}if(vec[i]==":"){pair<int,string> pp7(33,vec[i]);temp.push_back(pp7);}}else if(IsOperation(vec[i],0)){if(vec[i]=="+"){pair<int,string> pp8(22,vec[i]);temp.push_back(pp8);}if(vec[i]=="-"){pair<int,string> pp9(23,vec[i]);temp.push_back(pp9);}if(vec[i]=="*"){pair<int,string> pp10(24,vec[i]);temp.push_back(pp10);}if(vec[i]=="/"){pair<int,string> pp11(25,vec[i]);temp.push_back(pp11);}if(vec[i]=="="){pair<int,string> pp12(21,vec[i]);temp.push_back(pp12);}if(vec[i]==">"){pair<int,string> pp13(35,vec[i]);temp.push_back(pp13);}if(vec[i]=="<"){pair<int,string> pp14(36,vec[i]);temp.push_back(pp14);}if(vec[i]=="&"){pair<int,string> pp26(41,vec[i]);temp.push_back(pp26);}}else if(vec[i][0]<='9'&&vec[i][0]>='0') {pair<int,string> pp24(10,vec[i]);temp.push_back(pp24);}else{pair<int,string> pp25(10,vec[i]);temp.push_back(pp25);}}else if(vec[i][0]<='9'&&vec[i][0]>='0'){pair<int,string> pp23(3,vec[i]);temp.push_back(pp23);}else if(IsKey(vec[i])){if(vec[i]=="main"){pair<int,string> pp15(1,vec[i]);temp.push_back(pp15);}if(vec[i]=="int"){pair<int,string> pp16(2,vec[i]);temp.push_back(pp16);}if(vec[i]=="char"){pair<int,string> pp17(3,vec[i]);temp.push_back(pp17);}if(vec[i]=="else"){pair<int,string> pp18(4,vec[i]);temp.push_back(pp18);}if(vec[i]=="if"){pair<int,string> pp19(5,vec[i]);temp.push_back(pp19);}if(vec[i]=="for"){pair<int,string> pp20(6,vec[i]);temp.push_back(pp20);}if(vec[i]=="while"){pair<int,string> pp21(7,vec[i]);temp.push_back(pp21);}}else{pair<int,string> pp22(10,vec[i]);temp.push_back(pp22);}}return temp;}/*finished*/五、运行调试六、实验心得该词法分析器功能良好，可以完成预定的要求。