编译原理实验-(词法语法分析-附源代码
编译原理实验报告——词法分析器(内含源代码)
编译原理实验（一）——词法分析器一．实验描述运行环境：vc++2020对某特定语言A ，构造其词法规那么。
该语言的单词符号包括：1该程序能识别的单词符号及类别说明表2状态转换图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。
【编译原理】词法分析（CC++源代码+实验报告）
【编译原理】词法分析（CC++源代码+实验报告）⽂章⽬录1 实验⽬的和内容1.1实验⽬的（1）根据 PL/0 语⾔的⽂法规范，编写PL/0语⾔的词法分析程序；或者调研词法分析程序的⾃动⽣成⼯具LEX或FLEX，设计并实现⼀个能够输出单词序列的词法分析器。
（2）通过设计调试词法分析程序，实现从源程序中分离出各种类型的单词；加深对课堂教学的理解；提⾼词法分析⽅法的实践能⼒。
（3）掌握从源程序⽂件中读取有效字符的⽅法和产⽣源程序的内部表⽰⽂件的⽅法。
（4）掌握词法分析的实现⽅法。
（5）上机调试编出的词法分析程序。
1.2实验内容根据PL/0语⾔的⽂法规范，编写PL/0语⾔的词法分析程序。
要求：（1）把词法分析器设计成⼀个独⽴⼀遍的过程。
（2）词法分析器的输出形式采⽤⼆元式序列，即：(单词种类, 单词的值)2 设计思想2.1单词种类及其正规式（1）基本字单词的值单词类型正规式rbegin beginsym begincall callsym callconst constsym constdo dosym doend endsym endif ifsym ifodd oddsym oddprocedure proceduresym procedureread readsym readthen thensym thenvar varsym varwhile whilesym whilewrite writesym write（2）标识符单词的值单词类型正规式r标识符ident(字母)(字母|数字)*（3）常数单词的值单词类型正规式r常数number(数字)(数字)*（4）运算符单词的值单词类型正规式r+plus+-minus-*times*/slash/=eql=<>neq<><lss<<=leq<=>gtr>>=geq>=:=becomes:=（5）界符单词的值单词类型正规式r(lparen()rparen)，comma，；semicolon；.period.2.2 根据正规式构造NFA下⾯我们根据上述的正规式来构造该⽂法的NFA，如下图所⽰，其中状态0为初态，凡带双圈的状态均为终态，状态24是识别不出单词符号的出错情形，其他状态的识别情况如下图中右边的注释所⽰。
词法分析实验报告代码
一、实验目的1. 理解词法分析的概念和作用。
2. 掌握词法分析器的设计和实现方法。
3. 通过实验加深对编译原理中词法分析阶段的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 设计一个简单的词法分析器，能够识别并输出源代码中的单词。
2. 实现词法分析器的关键功能，包括：- 字符串预处理- 单词识别- 生成词法分析表四、实验步骤1. 字符串预处理- 读取源代码字符串。
- 移除字符串中的空白字符（空格、制表符、换行符等）。
- 转义字符串中的特殊字符。
2. 单词识别- 使用正则表达式匹配单词。
- 根据正则表达式匹配结果，将单词分类为关键字、标识符、常量等。
3. 生成词法分析表- 创建一个列表，用于存储词法分析表中的每个单词及其对应的类别。
- 遍历源代码字符串，将识别出的单词添加到词法分析表中。
五、实验代码```pythonimport re# 定义词法分析表结构class Token:def __init__(self, type, value):self.type = typeself.value = value# 单词识别函数def tokenize(source_code):# 移除空白字符source_code = re.sub(r'\s+', '', source_code)# 转义特殊字符source_code = re.sub(r'\\', '\\\\', source_code)# 使用正则表达式匹配单词tokens = re.findall(r'\b\w+\b', source_code)# 生成词法分析表token_table = []for token in tokens:if re.match(r'\bint\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bfloat\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bchar\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bif\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\belse\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\breturn\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\b\w+\b', token):token_table.append(Token('IDENTIFIER', token)) else:token_table.append(Token('CONSTANT', token)) return token_table# 主函数def main():# 读取源代码source_code = '''int main() {int a = 10;float b = 3.14;char c = 'A';if (a > b) {return a;} else {return b;}}'''# 进行词法分析token_table = tokenize(source_code)# 输出词法分析结果for token in token_table:print(f'Type: {token.type}, Value: {token.value}') if __name__ == '__main__':main()```六、实验结果运行实验代码后，输出如下：```Type: KEYWORD, Value: intType: IDENTIFIER, Value: mainType: KEYWORD, Value: (Type: KEYWORD, Value: )Type: KEYWORD, Value: intType: IDENTIFIER, Value: a Type: KEYWORD, Value: = Type: CONSTANT, Value: 10 Type: KEYWORD, Value: ; Type: KEYWORD, Value: float Type: IDENTIFIER, Value: b Type: KEYWORD, Value: = Type: CONSTANT, Value: 3.14 Type: KEYWORD, Value: ; Type: KEYWORD, Value: char Type: IDENTIFIER, Value: c Type: KEYWORD, Value: = Type: CONSTANT, Value: A Type: KEYWORD, Value: ; Type: KEYWORD, Value: if Type: IDENTIFIER, Value: ( Type: IDENTIFIER, Value: a Type: KEYWORD, Value: > Type: IDENTIFIER, Value: b Type: KEYWORD, Value: ) Type: KEYWORD, Value: { Type: KEYWORD, Value: return Type: IDENTIFIER, Value: aType: KEYWORD, Value: ;Type: KEYWORD, Value: }Type: KEYWORD, Value: elseType: KEYWORD, Value: {Type: KEYWORD, Value: returnType: IDENTIFIER, Value: bType: KEYWORD, Value: ;Type: KEYWORD, Value: }```七、实验总结通过本次实验，我们成功地设计并实现了一个简单的词法分析器，能够识别并输出源代码中的单词。
编译原理词法分析和语法分析
{ syn=21;
token[m++]=ch;
}
else
{ syn=31;
p--;
}
break;
case '=':token[m++]=ch;
ch=prog[p++];
if(ch=='=')
{ syn=25;
token[m++]=ch;
}
else
{ syn=18;
p--;
}
break;
break;
case -1:printf("you have input a wrong string\n");
getch();
exit(0);
default: printf("( %-10s%5d )\n",token,syn);
break;
}
}while(syn!=0);
getch();
}
scaner()
printf("success!\n");
}
else { if(kk!=1) printf("the string haven't got a 'end'!\n");
kk=1;
}
}
else { printf("haven't got a 'begin'!\n");
kk=1;
}
return;
}
yucu()
if(syn==18)
{ scaner();/*读下一个单词符号*/
编译原理 实验 词法分析 程序源码
csu
cout<<"open file failed!"<<endl; exit(1); }
//从文件将源程序全部输入到字符缓冲区中 while((ch = fgetc(fp)) != EOF) {
buffer += ch; } cout<<buffer<<endl;
//词法分析过程 for(int i=0; i<buffer.size(); i++) {
"int",
"long",
"short", "double", "float",
"char", "wchar_t", "true",
"false", "bool",
"signed", "unsigned", "define",
"struct","enum", "union", "new",
"delete",
if (token.size() != 0) {
cout<<"(1, \""<<token<<"\")"<<endl; token = ""; } } //判断 token 是否为常量，若是则输出 token 并置空 else if ( isConstant(token) ) { if (token.size() != 0) {
编译原理实验报告——词法分析器(内含源代码)
编译原理实验（一）——词法分析器一．实验描述运行环境：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置为空白字符。
编译原理实验 (词法语法分析 附源代码
编译原理实验报告******************************************************************************* ******************************************************************************* PL0语言功能简单、结构清晰、可读性强，而又具备了一般高级程序设计语言的必须部分，因而PL0语言的编译程序能充分体现一个高级语言编译程序实现的基本方法和技术。
PL/0语言文法的EBNF表示如下：<程序>::=<分程序>.<分程序> ::=[<常量说明>][<变量说明>][<过程说明>]<语句><常量说明> ::=CONST<常量定义>{，<常量定义>};<常量定义> ::=<标识符>=<无符号整数><无符号整数> ::= <数字>{<数字>}<变量说明> ::=V AR <标识符>{, <标识符>};<标识符> ::=<字母>{<字母>|<数字>}<过程说明> ::=<过程首部><分程序>{; <过程说明> };<过程首部> ::=PROCEDURE <标识符>;<语句> ::=<赋值语句>|<条件语句>|<当循环语句>|<过程调用语句>|<复合语句>|<读语句><写语句>|<空><赋值语句> ::=<标识符>:=<表达式><复合语句> ::=BEGIN <语句> {;<语句> }END<条件语句> ::= <表达式> <关系运算符> <表达式> |ODD<表达式><表达式> ::= [+|-]<项>{<加法运算符> <项>}<项> ::= <因子>{<乘法运算符> <因子>}<因子> ::= <标识符>|<无符号整数>| ‘(’<表达式>‘)’<加法运算符> ::= +|-<乘法运算符> ::= *|/<关系运算符> ::= =|#|<|<=|>|>=<条件语句> ::= IF <条件> THEN <语句><过程调用语句> ::= CALL 标识符<当循环语句> ::= WHILE <条件> DO <语句><读语句> ::= READ‘(’<标识符>{,<标识符>}‘)’<写语句> ::= WRITE‘(’<表达式>{,<表达式>}‘)’<字母> ::= a|b|…|X|Y|Z<数字> ::= 0|1|…|8|9【预处理】对于一个pl0文法首先应该进行一定的预处理，提取左公因式，消除左递归（直接或间接），接着就可以根据所得的文法进行编写代码。
编译原理词法分析和语法分析报告+代码(C语言版)[1]
![编译原理词法分析和语法分析报告+代码(C语言版)[1]](https://img.taocdn.com/s3/m/6a025cd1240c844769eaee6f.png)
词法分析一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。
二、实验要求2.1 待分析的简单的词法（1）关键字：begin if then while do end所有的关键字都是小写。
（2）运算符和界符：= + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。
空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码：输入：所给文法的源程序字符串。
输出：二元组（syn,token或sum）构成的序列。
其中：syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。
例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想：算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。
3.1 主程序示意图：主程序示意图如图3-1所示。
其中初始包括以下两个方面：⑴关键字表的初值。
关键字作为特殊标识符处理，把它们预先安排在一张表格中（称为关键字表），当扫描程序识别出标识符时，查关键字表。
如能查到匹配的单词，则该单词为关键字，否则为一般标识符。
关键字表为一个字符串数组，其描述如下：Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};图3-1（2）程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想：首先设置3个变量：①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn用来存放单词符号的种别码。
编译原理词法和语法分析报告+源码
词法分析一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。
二、实验要求2.1 待分析的简单的词法（1）关键字：begin if then while do end所有的关键字都是小写。
（2）运算符和界符：= + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。
空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码：输入：所给文法的源程序字符串。
输出：二元组（syn,token或sum）构成的序列。
其中：syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。
例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想：算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。
3.1 主程序示意图：主程序示意图如图3-1所示。
其中初始包括以下两个方面：⑴关键字表的初值。
关键字作为特殊标识符处理，把它们预先安排在一张表格中（称为关键字表），当扫描程序识别出标识符时，查关键字表。
如能查到匹配的单词，则该单词为关键字，否则为一般标识符。
关键字表为一个字符串数组，其描述如下：Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};图3-1（2）程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想：首先设置3个变量：①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn用来存放单词符号的种别码。
编译原理词法分析和语法分析报告+代码(C语言版)[1]
![编译原理词法分析和语法分析报告+代码(C语言版)[1]](https://img.taocdn.com/s3/m/3eed6f446ad97f192279168884868762cbaebb15.png)
词法分析一、实验目的二、设计、编制并调试一个词法分析程序, 加深对词法分析原理的理解。
三、实验要求2.1 待分析的简单的词法（1）关键字:begin if then while do end所有的关键字都是小写。
（2）运算符和界符: = + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM）, 通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。
空格一般用来分隔ID.SUM、运算符、界符和关键字, 词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码:输入: 所给文法的源程序字符串。
输出: 二元组（syn,token或sum）构成的序列。
其中: syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。
例如: 对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件, 经过词法分析后输出如下序列:(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想:算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号, 其基本思想是根据扫描到单词符号的第一个字符的种类, 拼出相应的单词符号。
3.1 主程序示意图:主程序示意图如图3-1所示。
其中初始包括以下两个方面:⑴关键字表的初值。
关键字作为特殊标识符处理, 把它们预先安排在一张表格中（称为关键字表）, 当扫描程序识别出标识符时, 查关键字表。
如能查到匹配的单词, 则该单词为关键字, 否则为一般标识符。
关键字表为一个字符串数组, 其描述如下:Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};图3-1（2）程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想:首先设置3个变量: ①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn 用来存放单词符号的种别码。
编译原理-词法分析(附源码)
词法分析实验报告一、实验项目名称词法分析二、实验目的通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
三、实验环境Windows 10Microsoft Visual Studio 2015四、实验内容编制一个读单词过程，源程序为一个文件，读取该文件，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、界符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
单词的内部编码如下：1、保留字：if、int、for、while、do、return、break、continue；单词种别码为1；2、标识符：除保留字外的以字母开头，后跟字母、数字的字符序列；单词种别码为2；3、常数为无符号整形数；单词种别码为3；4、运算符包括：+、-、*、/、=；单词种别码为4；5、分隔符包括：,、;、{、}、(、)；单词种别码为5。
五、实验步骤在词法分析中，自文件头开始扫描源程序字符，一旦发现符合“单词”定义的源程序字符串时，将它翻译成固定长度的单词内部表示，并填入适当的信息表。
经过词法分析后，源程序字符串（源程序的外部表示）被翻译成具有等长信息的单词串（源程序的内部表示），并产生两个表格：常数表和标识符表，它们分别包含了源程序中的所有常数和所有标识符。
(1) 定义部分：定义常量、变量、数据结构。
(2) 初始化：从文件将源程序全部输入到字符缓冲区中。
(3) 取单词前：去掉多余空白。
(4) 取单词：利用实验一的成果读出单词的每一个字符，组成单词，分析类型。
(5) 显示结果六、源程序清单、测试数据、结果#include<iostream>#include<string>#include<fstream>#define MAX 100using namespace std;void main(){//二维char数组主存储的初始化char a[MAX][15], ch = 'a', before;int i = 0, j = 0;for (i = 0; i < MAX; i++){for (j = 0; j < 15; j++){a[i][j] = NULL;}}i = 0;j = 0;fstream file;//文件打开并读入字符file.open("D:\\text.txt",ios::in);if (file){cout <<"文件打开成功"<< endl;}while (!file.eof())//换行是10，空格是32{before = ch;file.read(&ch, 1);//**********************************************************************符号*******************************************************************||||*************************************************************前一字符为符号当前为字母数字*************************************************************************************** *******************************************************************||if ( ((ch >= 32 && ch <= 47) || (ch == 10) || (ch >= 58 && ch <= 64) ||(ch >= 91 && ch <= 94 )||(ch==96)||( ch >= 123 && ch <= 126)) || (((before >= 32 && before <= 47) || (before == 10) || (before >= 58 && before <= 64) || (before >= 91 && before <= 94) || (before == 96) || (before >= 123 && before <= 126))) && (ch > 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch>=48 && ch<=57) ){if (ch != 32 && ch != 10){i++;j = 0;}}if (ch != 32 && ch != 10){a[i][j] = ch;j++;}}file.close();ofstream fileout("D:\\out.txt", ios::ate);//判断字符串并输出for (int k = 0; k < i; k++){if (a[k][0] >= 65 && a[k][0] <= 90 || a[k][0] >= 97 && a[k][0] <= 122)//判断第一个字符是字母{if (a[k][1] >= 65 && a[k][1] <= 90 || a[k][1] >= 97 && a[k][1] <= 122)//判断第二个字符是字母{//判断是不是保留字string AA(a[k]);if (pare("if") == 0){cout <<"(1,\"if\")"<< endl;fileout <<"(1,\"if\")\n";}else if (pare("int") == 0){cout <<"(1,\"int\")"<< endl;fileout <<"(1,\"int\")\n";}else if (pare("for") == 0){cout <<"(1,\"for\")"<< endl;fileout <<"(1,\"for\")\n";}else if (pare("while") == 0){cout <<"(1,\"while\")"<< endl;fileout <<"(1,\"while\")\n";}else if (pare("do") == 0){cout <<"(1,\"do\")"<< endl;fileout <<"(1,\"do\")\n";}else if (pare("return") == 0){cout <<"(1,\"return\")"<< endl;fileout <<"(1,\"return\")\n";}else if (pare("break") == 0){cout <<"(1,\"break\")"<< endl;fileout <<"(1,\"break\")\n";}else if (pare("continue") == 0){cout <<"(1,\"continue\")"<< endl;fileout <<"(1,\"break\")\n";}else{cout <<"(2,\""<< AA <<"\")"<< endl;fileout <<"(2,\""<< AA <<"\")\n";}}else if (a[k][1] >= '0' || a[k][1] <= '9'){string AA(a[k]);cout <<"(2,\""<< AA <<"\")"<< endl;fileout <<"(2,\""<< AA <<"\")\n";}}else if (a[k][0] >= '0' && a[k][0] <= '9'){int judge = 0;int sss = 1;while(a[k][sss]!=NULL){if (a[k][sss] < '0' || a[k][sss] > '9' ){judge = 1;}sss++;}string AA(a[k]);if (judge == 0){cout <<"(3,\""<< AA <<"\")"<< endl;fileout <<"(3,\""<< AA <<"\")\n";}else{cout <<"(错误的单词:"<< AA <<"\")"<< endl;fileout <<"(错误的单词:"<< AA <<"\")\n";}}else if (a[k][0] == 42 || a[k][0] == 43|| a[k][0] == 45 || a[k][0] == 47 ||a[k][0] == 61){string AA(a[k]);cout <<"(4,\""<< AA <<"\")"<< endl;fileout <<"(4,\""<< AA <<"\")\n";}else if (a[k][0] == 44 || a[k][0] == 59 || a[k][0] == 40 || a[k][0] == 41 || a[k][0] == 123 || a[k][0] == 125){string AA(a[k]);cout <<"(5,\""<< AA <<"\")"<< endl;fileout <<"(5,\""<< AA <<"\")\n";}else if(a[k][0]!=NULL){string AA(a[k]);cout <<"(不支持的符号："<< AA <<"\")"<< endl;fileout <<"(不支持的符号："<< AA <<"\")\n";}}fileout.close();}七、实验小结和思考在本次实验中，我遇到了很多小问题，值得一提的是在拆输入的字符串时如何拆分成正确的单词，这很重要，拆分单词时我用的是识别字符的ACSCii码以及字符前后的组合，将识别出的单词存入已初始化的字符数组中。
编译原理词法分析和语法分析报告+代码[C语言版]
![编译原理词法分析和语法分析报告+代码[C语言版]](https://img.taocdn.com/s3/m/72d7b73c02020740bf1e9b36.png)
词法分析一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。
二、实验要求2.1 待分析的简单的词法（1）关键字：begin if then while do end所有的关键字都是小写。
（2）运算符和界符：= + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。
空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码：表2.1 各种单词符号对应的种别码2.3 词法分析程序的功能：输入：所给文法的源程序字符串。
输出：二元组（syn,token或sum）构成的序列。
其中：syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。
例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想：算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。
3.1 主程序示意图：主程序示意图如图3-1所示。
其中初始包括以下两个方面：⑴关键字表的初值。
关键字作为特殊标识符处理，把它们预先安排在一张表格中（称为关键字表），当扫描程序识别出标识符时，查关键字表。
如能查到匹配的单词，则该单词为关键字，否则为一般标识符。
关键字表为一个字符串数组，其描述如下：Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};是图3-1（2）程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想：首先设置3个变量：①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn用来存放单词符号的种别码。
编译原理--词法分析实验(含代码)备课讲稿
编译原理--词法分析实验(含代码)计算机编译原理实验班级：计算机科学与技术113班姓名：学号：南昌大学信息工程学院计算机系实验1 词法分析程序的设计一、实验目的掌握计算机语言的词法分析程序的开发方法。
二、实验内容编制一个能够分析三种整数、标识符、主要运算符和主要关键字的词法分析程序。
三、实验要求1、根据以下的正规式，编制正规文法，画出状态图；标识符<字母>(<字母>|<数字字符>)*十进制整数0 |（1|2|3|4|5|6|7|8|9）（0|1|2|3|4|5|6|7|8|9）*如有余力，则进一步分析八进制和十六进制整数，其正规式如下：八进制整数0（1|2|3|4|5|6|7）（0|1|2|3|4|5|6|7）*十六进制整数0x（0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f）（0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f）*运算符和界符+ - * / > < = <= >= ( ) ； { }关键字main if then else while do int (可根据需要添加)2、根据状态图，设计词法分析函数int scan( )，完成以下功能：1）从文本文件中读入测试源代码，根据状态转换图，分析出一个单词，2）以二元式形式输出单词<单词种类，单词属性>其中单词种类用整数表示：0：标识符1：十进制整数2：八进制整数3：十六进制整数运算符和界符，关键字采用一字一符，不编码其中单词属性表示如下：标识符，整数由于采用一类一符，属性用单词表示运算符和界符，关键字采用一字一符，属性为空3、编写测试程序，反复调用函数scan( )，输出单词种别和属性。
四、实验环境PC微机DOS操作系统或 Windows 操作系统Turbo C 程序集成环境或 Visual C++ 程序集成环境五、实验步骤1、根据正规式，画出状态转换图；2、根据状态图，设计词法分析算法；3、采用C或C++语言，设计函数scan( )，实现该算法；4、编制测试程序（主函数main）；5、调试程序：读入文本文件program.txt，运行程序得到输出结果result.txt，并检查输出结果是否正确。
编译原理词法分析与语法分析实验报告
实验三词法分析与语法分析程序设计实验日期: 2011 年11 月11日评分批阅教师签字一、实验目的基本掌握计算机语言的词法分析程序和语法分析程序的设计方法二、实验内容实验要求：1．根据以下的正规式，画出状态图；标识符：<字母>(<字母>|<数字字符>)*关键字：if then else while do十进制整数：0 | （1|2|3|4|5|6|7|8|9）（0|1|2|3|4|5|6|7|8|9）*运算符和分隔符：+ - * / > < = ( ) ；2．根据状态图，设计词法分析函数int scan( )，从键盘读入数据，分析出一个单词。
3．对于只含有+、*运算的算术表达式的如下文法，编写相应的语法分析程序，要求用LL(1)分析表实现，并以id+id*id为例进行测试：E —＞TE′E′—＞+TE′|εT —＞FT′T′—＞*FT′|εF —＞（E）| id实验步骤1 根据状态图，设计词法分析算法2 采用C++语言，实现该算法3 调试程序：输入一组单词，检查输出结果。
4 编制给定文法的非递归的预测分析程序，并加以测试。
三、实验环境计算机、Windows 操作系统、V isual C++ 程序集成环境。
四、实验原理（或程序框图）及步骤LL(1)中的第一个L表示从左到右扫描输入，第二个L表示产生最右推导，而‘1’则表示在每一步中只需要向前看一个输入符号来决定语法分析动作。
构造一个预测分析表如下：输入：文法G输出：预测分析表M方法：对于文法G的每个产生式A→α，进行如下处理：1）：对于FIRST（α）中的每个终结符a，将A→α加入到M[A, α]中。
2）：如果ε在FIRST（α）中，那么对于FOLLOW（A）中的每个终结符b，将A→α加入到M[A, α]中。
如果ε在FIRST（α）中，且$在FOLLOW（A）中，也将A→α加入到M[A, $]中。
完成上面操作之后，如果M[A, α]中没有产生式，那么将M[A, α]设置为error。
编译原理词法分析报告+代码(C语言版)[1]
![编译原理词法分析报告+代码(C语言版)[1]](https://img.taocdn.com/s3/m/6b0c31e5551810a6f5248614.png)
词法分析一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。
二、实验要求2.1 待分析的简单的词法（1）关键字：begin if then while do end（2）运算符和界符：= + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。
空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码：2.3 词法分析程序的功能：输入：所给文法的源程序字符串。
输出：二元组（syn,token或sum）构成的序列。
其中：syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。
例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想：算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。
3.1 主程序示意图：主程序示意图如图3-1所示。
其中初始包括以下两个方面：⑴关键字表的初值。
关键字作为特殊标识符处理，把它们预先安排在一张表格中（称为关键字表），当扫描程序识别出标识符时，查关键字表。
如能查到匹配的单词，则该单词为关键字，否则为一般标识符。
关键字表为一个字符串数组，其描述如下：Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};图3-1（2）程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想：首先设置3个变量：①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn用来存放单词符号的种别码。
(完整)编译原理实验报告(词法分析器 语法分析器)
编译原理实验报告实验一一、实验名称：词法分析器的设计二、实验目的：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）。
编译原理实验词法分析语法分析
本代码只供学习参考：词法分析源代码：#include<iostream>#include<fstream>#include<string>using namespace std;string key[8]={"do","end","for","if","printf","scanf","then","while"}; string optr[4]={"+","-","*","/"};string separator[6]={",",";","{","}","(",")"};char ch;//判断是否为保留字bool IsKey(string ss) {int i;for(i=0;i<8;i++)if(!strcmp(key[i].c_str(),ss.c_str()))return true;return false;}//字母判断函数bool IsLetter(char c) {if(((c>='a')&&(c<='z'))||((c>='A')&&(c<='Z')))return true;return false;}//数字判断函数bool IsDigit(char c) {if(c>='0'&&c<='9')return true;return false;}//运算符判断函数bool IsOptr(string ss) {int i;for(i=0;i<4;i++)if(!strcmp(optr[i].c_str(),ss.c_str()))return true ;return false;}//分界符判断函数bool IsSeparator(string ss) {int i;for(i=0;i<6;i++)if(!strcmp(separator[i].c_str(),ss.c_str()))return true;return false;}void analyse(ifstream &in) {string st="";char ch;int line=1,row=0;while((in.get(ch))) {st="";if((ch==' ')||(ch=='\t')){} //空格，tab健elseif(ch=='\n') {line++;row=0; } //换行行数加一处理elseif(IsLetter(ch)) //关键字、标识符的处理{row++;while(IsLetter(ch)||IsDigit(ch)){st+=ch;in.get(ch);}in.seekg(-1,ios::cur);//文件指针（光标）后退一个字节if(IsKey(st)) //判断是否为关键字查询关键字表；cout<<st<<"\t("<<st<<","<<1<<")"<<'\t'<<'\t'<<"关键字"<<'\t'<<"("<<line<<","<<row<<")"<<endl;else //否则为标示符cout<<st<<"\t("<<st<<","<<2<<")"<<'\t'<<'\t'<<"标识符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;}elseif(IsDigit(ch)) //无符号整数处理{row++;while(IsDigit(ch)){st+=ch;ch=in.get();}in.seekg(-1,ios::cur);cout<<st<<"\t("<<st<<","<<3<<")"<<'\t'<<'\t'<<"常数"<<'\t'<<"("<<line<<","<<row<<")"<<endl;// break;}else{st="";st+=ch;if(IsOptr(st)) //运算符处理{row++;cout<<st<<"\t("<<st<<","<<4<<")"<<'\t'<<'\t'<<"运算符"<<"("<<line<<","<<row<<")"<<endl;}elseif(IsSeparator(st))//分隔符处理{ row++;cout<<st<<"\t("<<st<<","<<5<<")"<<'\t'<<'\t'<<"分界符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;}else{switch(ch){row++;case'=' : {row++;cout<<"="<<"\t("<<"="<<","<<"6"<<")"<<'\t'<<"\t关系运算符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;}case'>' :{row++;ch=in.get();if(ch=='=')cout<<">="<<'\t'<<"("<<">="<<","<<"6"<<")"<<'\t'<<"\t关系运算符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;else {cout<<">"<<"\t("<<">"<<","<<"6"<<")"<<'\t'<<"\t关系运算符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;in.seekg(-1,ios::cur);}} break;case'<' :{row++;ch=in.get();if(ch=='=')cout<<"<="<<'\t'<<"("<<"="<<","<<"6"<<")"<<"\t关系运算符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;else if(ch=='>') cout<<"<>"<<'\t'<<"("<<"<>"<<","<<"6"<<")"<<'\t'<<"\t关系运算符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;else{cout<<"<"<<"\t("<<"<"<<","<<"6"<<")"<<"\t"<<"\t关系运算符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;in.seekg(-1,ios::cur);}}break;default :{row++; cout<<ch<<'\t'<<"\t$无法识别字符"<<'\t'<<"("<<line<<","<<row<<")"<<endl;}}}}}}int main(){ifstream in;in.open("test.txt",ios::in);cout<<"关键字-》1 标识符-》2 常数-》3 运算符-》4 分隔符-》5"<<endl;if(in.is_open()){analyse(in);in.close();system("pause");}elsecout<<"文件操作出错"<<endl;}语法分析实验源代码LL#include<iostream>using namespace std;const int MaxLen=20; //初始化栈的长度const int Length=20;//初始化数组长度char Vn[5]={'E','G','T','S','F'};//非终结符数组char Vt[8]={'i','(',')','+','-','*','/','#'};//终结符数组char ch,X;//ch读当前字符，X获取栈顶元素char strToken[Length];//存储规约表达式struct LL//ll(1)分析表的构造字初始化{char*c;};LL E[8]={"TG","TG","error","error","error","error","error","error"};LL G[8]={"error","error","null","+TG","-TG","error","error","null"};LL T[8]={"FS","FS","error","error","error","error","error","error"};LL S[8]={"error","error","null","null","null","*FS","/FS","null"};LL F[8]={"i","(E)","error","error","error","error","error","error"};class stack//栈的构造及初始化{public:stack();//初始化bool empty() const;//是否为空bool full() const;//是否已满bool get_top(char &c)const;//取栈顶元素bool push(const char c);//入栈bool pop();//删除栈顶元素void out();//输出栈中元素~stack(){}//析构private:int count;//栈长度char data[MaxLen];//栈中元素};stack::stack(){count=0;}bool stack::empty() const{if(count==0)return true;return false;}bool stack::full() const{if(count==MaxLen)return true;return false;}bool stack::get_top(char &c)const{if(empty())return false;else{c=data[count-1];return true;}}bool stack::push(const char c){if(full())return false;data[count++]=c;return true;}bool stack::pop(){if(empty())return false;count--;return true;}void stack::out(){for(int i=0;i<count;i++)cout<<data[i];cout<<'\t';}int length(char *c){int l=0;for(int i=0;c[i]!='\0';i++)l++;return l;}void print(int i,char*c)//剩余输入串的输出{for(int j=i;j<Length;j++)cout<<c[j];cout<<'\t';}void run(){bool flag=true;//循环条件int step=0,point=0;//步骤、指针int len;//长度cout<<"输入规约的字符串："<<endl;cin>>strToken;ch=strToken[point++];//读取第一个字符stack s;s.push('#');//栈中数据初始化s.push('E');s.get_top(X);//取栈顶元素cout<<"步骤\t"<<"分析栈\t"<<"剩余输入串\t\t"<<"所用产生式\t"<<"动作"<<endl;cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<'\t'<<"初始化"<<endl;while(flag){if((X==Vt[0])||(X==Vt[1])||(X==Vt[2])||(X==Vt[3])||(X==Vt[4])||(X==Vt[5])||(X==Vt[6])) //判断是否为终结符（不包括#）{if(X==ch)//终结符,识别，进行下一字符规约{s.pop();s.get_top(X);ch=strToken[point++];cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<'\t'<<"GETNEXT(I)"<<endl;}else{flag=false;}}else if(X=='#')//规约结束{if(X==ch){cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<X<<"->"<<ch<<'\t'<<"结束"<<endl;s.pop();flag=false;}else{flag=false;}}else if(X==Vn[0]) //非终结符E{for(int i=0;i<8;i++)//查分析表if(ch==Vt[i]){if(strcmp(E[i].c,"error")==0)//出错{flag=false;}else{ //对形如X->X1X2的产生式进行入栈操作s.pop();len=length(E[i].c)-1;for(int j=len;j>=0;j--)s.push(E[i].c[j]);cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<X<<"->"<<E[i].c<<'\t'<<"POP,PUSH(";for(int j=len;j>=0;j--)cout<<E[i].c[j];cout<<")"<<endl;s.get_top(X);}}}else if(X==Vn[1]) //同上，处理G{for(int i=0;i<8;i++)if(ch==Vt[i]){if(strcmp(G[i].c,"null")==0){s.pop();cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<X<<"->"<<"ε"<<'\t'<<"POP"<<endl;s.get_top(X);}else if(strcmp(G[i].c,"error")==0){flag=false;}else{s.pop();len=length(G[i].c)-1;for(int j=len;j>=0;j--)s.push(G[i].c[j]);cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<X<<"->"<<G[i].c<<'\t'<<"POP,PUSH(";for(int j=len;j>=0;j--)cout<<G[i].c[j];cout<<")"<<endl;s.get_top(X);}}}else if(X==Vn[2]) //同上处理T{for(int i=0;i<8;i++)if(ch==Vt[i]){if(strcmp(T[i].c,"error")==0){flag=false;}else{s.pop();len=length(T[i].c)-1;for(int j=len;j>=0;j--)s.push(T[i].c[j]);cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<X<<"->"<<T[i].c<<'\t'<<"POP,PUSH(";for(int j=len;j>=0;j--)cout<<T[i].c[j];cout<<")"<<endl;s.get_top(X);}}}else if(X==Vn[3])//同上处理S{for(int i=0;i<8;i++)if(ch==Vt[i]){if(strcmp(S[i].c,"null")==0){s.pop();cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<X<<"->"<<"ε"<<'\t'<<"POP"<<endl;s.get_top(X);}else if(strcmp(S[i].c,"error")==0){flag=false;}else{s.pop();len=length(S[i].c)-1;for(int j=len;j>=0;j--)s.push(S[i].c[j]);cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<X<<"->"<<S[i].c<<'\t'<<"POP,PUSH(";for(int j=len;j>=0;j--)cout<<S[i].c[j];cout<<")"<<endl;s.get_top(X);}}}else if(X==Vn[4]) //同上处理F{for(int i=0;i<7;i++)if(ch==Vt[i]){if(strcmp(F[i].c,"error")==0){flag=false;}else{s.pop();len=length(F[i].c)-1;for(int j=len;j>=0;j--)s.push(F[i].c[j]);cout<<step++<<'\t';s.out();print(point-1,strToken);cout<<X<<"->"<<F[i].c<<'\t'<<"POP,PUSH(";for(int j=len;j>=0;j--)cout<<F[i].c[j];cout<<")"<<endl;s.get_top(X);}}}else //出错处理{flag= false;}}}int main(){cout<<"实验二"<<endl;run();system("pause");return 0;}语法实验源代码LR#include<iostream>using namespace std;const int MaxLen=20; //初始化栈的长度const int Length=20;//初始化数组长度char ch,Y;//全局变量，ch用于读当前字符，Y用于获取栈顶元素char strToken[Length];//存储规约表达式bool flag=true;//循环条件int point=0,step=1;//步骤、指针class stack//栈的构造及初始化{public:stack();//初始化bool empty() const;//是否为空bool full() const;//是否已满bool get_top(char &c)const;//取栈顶元素bool push(const char c);//入栈bool pop();void out();//输出栈中元素void out1();~stack(){}//析构private:int count;//栈长度char data[MaxLen];//栈中元素};stack l,r;//l代表符号栈，r代表状态栈stack::stack(){count=0;}bool stack::empty() const{if(count==0)return true;return false;}bool stack::full() const{if(count==MaxLen)return true;return false;}bool stack::get_top(char &c)const{if(empty())return false;else{c=data[count-1];return true;}}bool stack::push(const char c){if(full())return false;data[count++]=c;return true;}bool stack::pop(){if(empty())return false;count--;return true;}void stack::out(){for(int i=0;i<count;i++)cout<<data[i];cout<<'\t';}void stack::out1(){for(int i=0;i<count;i++)cout<<int(data[i]);cout<<'\t';}void print(int i,char*c)//剩余输入串的输出{for(int j=i;j<Length;j++)cout<<c[j];cout<<'\t';}void Goto(int i,char c)//状态转换函数,对应于表中GOTO {if(i==0){if(c=='E'){r.push(1);cout<<",GOTO(0,E)=1入栈"<<endl;}else if(c=='T'){r.push(2);cout<<",GOTO(0,T)=2入栈"<<endl;}else if(c=='F'){r.push(3);cout<<",GOTO(0,F)=3入栈"<<endl;}elseflag=false;}else if(i==4){if(c=='E'){r.push(8);cout<<",GOTO(4,E)=8入栈"<<endl;}else if(c=='T'){r.push(2);cout<<",GOTO(4,T)=2入栈"<<endl;}else if(c=='F'){r.push(3);cout<<",GOTO(4,F)=3入栈"<<endl;}elseflag=false;}else if(i==6){if(c=='T'){r.push(9);cout<<",GOTO(6,T)=9入栈"<<endl;}else if(c=='F'){r.push(3);cout<<",GOTO(6,F)=3入栈"<<endl;}elseflag=false;}else if(i==7){if(c=='F'){r.push(10);cout<<",GOTO(7,F)=10入栈"<<endl;}elseflag=false;}elseflag=false;}void Action0()//状态0时{if(ch=='i')//下一个操作符为i ,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[0,i]=S5,状态5入栈"<<endl;r.push(5);l.push(ch);ch=strToken[point++];}else if(ch=='(')//下一个操作符为( ,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[0,(]=S4,状态4入栈"<<endl;r.push(4);l.push(ch);ch=strToken[point++];}elseflag=false;}void Action1()//状态1{if(ch=='+')//下一个操作符为i ,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[1,+]=S6,状态6入栈"<<endl;r.push(6);l.push(ch);ch=strToken[point++];}else if(ch=='#')//分析成功{flag=false;cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"Acc：分析成功"<<endl;}elseflag=false;}void Action2() //状态2{if(ch=='*')//下一个操作符为* ,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[2,*]=S7,状态7入栈"<<endl;r.push(7);l.push(ch);ch=strToken[point++];}else if((ch=='+')||(ch==')')||(ch=='#'))//下一个操作符为+，），#规约{cout<<step++<<'\t';r.out1();l.out();l.pop();l.push('E');print(point-1,strToken);cout<<"r2: E→T归约";r.pop();r.get_top(Y);Goto(int(Y),'E');}elseflag=false;}void Action3()//状态3{if((ch=='+')||(ch=='*')||(ch==')')||(ch=='#'))//下一个操作符为+，*,），#规约{cout<<step++<<'\t';r.out1();l.out();l.pop();l.push('T');print(point-1,strToken);cout<<"r4: T→F归约";r.pop();r.get_top(Y);Goto(int(Y),'T');}elseflag=false;}void Action4_6_7(int x)//状态4,6,7{if(ch=='i')//下一个操作符为i ,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[";cout<<x<<",i]=S5,状态5入栈"<<endl;r.push(5);l.push(ch);ch=strToken[point++];}else if(ch=='(')//下一个操作符为（,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[";cout<<x<<",(]=S4,状态4入栈"<<endl;r.push(4);l.push(ch);ch=strToken[point++];}elseflag=false;}void Action5()//状态5{if((ch=='+')||(ch=='*')||(ch==')')||(ch=='#'))//下一个操作符为+，*,），#规约{cout<<step++<<'\t';r.out1();l.out();l.pop();l.push('F');print(point-1,strToken);cout<<"r6: F→i归约";r.pop();r.get_top(Y);Goto(int(Y),'F');}elseflag=false;}void Action8()//状态8{if(ch=='+')//下一个操作符为+ ,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[8,+]=S6,状态6入栈"<<endl;r.push(6);l.push(ch);ch=strToken[point++];}else if(ch==')')//下一个操作符为）,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[8,)]=S11,状态11入栈"<<endl;r.push(11);ch=strToken[point++];}elseflag=false;}void Action9()//状态9{if(ch=='*')//下一个操作符为* ,移进{cout<<step++<<'\t';r.out1();l.out();print(point-1,strToken);cout<<"ACTION[9,*]=S7,状态7入栈"<<endl;r.push(7);l.push(ch);ch=strToken[point++];}else if((ch=='+')||(ch==')')||(ch=='#'))//下一个操作符为+，,），#规约{cout<<step++<<'\t';r.out1();l.out();l.pop();l.pop();l.pop();l.push('E');print(point-1,strToken);cout<<"r1: E→E+T归约";r.pop();r.pop();r.pop();r.get_top(Y);Goto(int(Y),'E');}elseflag=false;}void Action10()//状态10{if((ch=='+')||(ch=='*')||(ch==')')||(ch=='#'))//下一个操作符为+，*,），#规约{cout<<step++<<'\t';l.out();l.pop();l.pop();l.pop();l.push('T');print(point-1,strToken);cout<<"r3: T→T*F归约";r.pop();r.pop();r.pop();r.get_top(Y);Goto(int(Y),'T');}elseflag=false;}void Action11()//状态11{if((ch=='+')||(ch=='*')||(ch==')')||(ch=='#'))//下一个操作符为+，*,），#规约{cout<<step++<<'\t';r.out1();l.out();l.pop();l.pop();l.pop();l.push('F');print(point-1,strToken);cout<<"r5: F→(E)归约";r.pop();r.pop();r.pop();r.get_top(Y);Goto(int(Y),'F');}elseflag=false;}void run()//规约{cout<<"请输入要规约的字符串："<<endl;cin>>strToken;cout<<"步骤\t"<<"状态栈\t"<<"符号栈\t"<<"输入串\t\t"<<"动作说明"<<endl;ch=strToken[point++];//读取第一个字符l.push('#');r.push(0);r.get_top(Y);while(flag)//循环规约{if(int(Y)==0)Action0();else if(int(Y)==1)Action1();else if(int(Y)==2)Action2();else if(int(Y)==3)Action3();else if((int(Y)==4)||(int(Y)==6)||(int(Y)==7))Action4_6_7(int(Y));else if(int(Y)==5)Action5();else if(int(Y)==8)Action8();else if(int(Y)==9)Action9();else if(int(Y)==10)Action10();else if(int(Y)==11)Action11();elseflag=false;r.get_top(Y);}}int main(){cout<<"实验三"<<endl;run();system("pause");return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
编译原理实验报告******************************************************************************* ******************************************************************************* PL0语言功能简单、结构清晰、可读性强，而又具备了一般高级程序设计语言的必须部分，因而PL0语言的编译程序能充分体现一个高级语言编译程序实现的基本方法和技术。
PL/0语言文法的EBNF表示如下：<程序>::=<分程序>.<分程序> ::=[<常量说明>][<变量说明>][<过程说明>]<语句><常量说明> ::=CONST<常量定义>{，<常量定义>};<常量定义> ::=<标识符>=<无符号整数><无符号整数> ::= <数字>{<数字>}】<变量说明> ::=VAR <标识符>{, <标识符>};<标识符> ::=<字母>{<字母>|<数字>}<过程说明> ::=<过程首部><分程序>{; <过程说明> };<过程首部> ::=PROCEDURE <标识符>;<语句> ::=<赋值语句>|<条件语句>|<当循环语句>|<过程调用语句>|<复合语句>|<读语句><写语句>|<空><赋值语句> ::=<标识符>:=<表达式><复合语句> ::=BEGIN <语句> {;<语句> }END<条件语句> ::= <表达式> <关系运算符> <表达式> |ODD<表达式><表达式> ::= [+|-]<项>{<加法运算符> <项>};<项> ::= <因子>{<乘法运算符> <因子>}<因子> ::= <标识符>|<无符号整数>| ‘(’<表达式>‘)’<加法运算符> ::= +|-<乘法运算符> ::= *|/<关系运算符> ::= =|#|<|<=|>|>=<条件语句> ::= IF <条件> THEN <语句><过程调用语句> ::= CALL 标识符<当循环语句> ::= WHILE <条件> DO <语句><读语句> ::= READ‘(’<标识符>{,<标识符>}‘)’<写语句> ::= WRITE‘(’<表达式>{,<表达式>}‘)’￥<字母> ::= a|b|…|X|Y|Z<数字> ::= 0|1|…|8|9【预处理】对于一个pl0文法首先应该进行一定的预处理，提取左公因式，消除左递归（直接或间接），接着就可以根据所得的文法进行编写代码。
【实验一】词法分析【实验目的】给出PL/0文法规范，要求编写PL/0语言的词法分析程序。
【实验内容】已给PL/0语言文法，输出单词（关键字、专用符号以及其它标记）。
@【实验要求】1.确定编译中使用的表格、标识符与关键字的区分方法等。
2.把词法分析器设计成一个独立一遍的过程。
3.词法分析器的输出形式采用二元式序列，例如：(ident, a)(plus, + )(number, 15)(times, * )(ident, b )【输入输出】（输入：PL/0源程序。
例: a+15*b输出：(ident, a)(plus, + )(number, 15)(times, * )(ident, b )【实验结果】实验结果与实验要求相同，没有异议，对输入字符采取一个一个读入，到达句柄时，则采取LL(1)文法进行规约。
—实验结果如下：实验结果用文本来进行输入输出，所以在工程目录下还会有一个文本输入，输出文件。
分别为【实验体会】在编写这段代码的过程中，比较麻烦得还是之前的语法预处理阶段，将不满足ll(1)文法的语法转化为标准的ll(1)文法。
程序在处理词法分析的过程就是不断通过getsym()这个函数来条用getch()，不断形成一个一个的词汇，供下面语法分析时使用。
记录词汇类型的sym是一个枚举类型。
使用起来会方便许多，比较系统。
其中还用到了文本输入输出的技巧，把读出的词汇保存起来。
词法分析还是比较简单，在编写代码的时候没有太大的阻碍。
通过此次实验，让我了解到如何设计、编制并调试词法分析程序，加深对词法分析原理的理解；熟悉了构造词法分析程序的手工方式的相关原理，使用某种高级语言（例如C++语言）直接编写此法分析程序。
另外，也让我重新熟悉了C++语言的相关内容，加深了对C++语言的用途的理解。
、【实验二】语法分析【实验目的】给出PL/0文法规范，要求编写PL/0语言的语法分析程序。
【实验内容】已给PL/0语言文法，构造表达式部分的语法分析器。
【实验要求】1.将实验一“词法分析”的输出结果，作为表达式语法分析器的输入，进行语法解析，对于语法正确的表达式，报告“语法正确”；对于语法错误的表达式，报告“语法错误”，指出错误原因。
2.把语法分析器设计成一个独立一遍的过程。
3.语法分析器的编写方法采用递归子程序法。
`【输入输出】输入：PL/0表达式，用实验一的输出形式作为输入。
例如: 对于PL/0表达式，a+15*b用下列形式作为输入：(ident, a)(plus, + )(number, 15)(times, * )(ident, b )输出：对于语法正确的表达式，报告“语法正确”；"对于语法错误的表达式，报告“语法错误”，指出错误原因。
【实验结果】实验结果与实验要求相同，没有异议，对输入字符采取一个一个读入，对输入的一个语句进行判断，判断语法的正误，采用对算法的判断，若全为数字则进行最后的计算【实验体会】|通过语法分析可以判断当前输入语句是否正确，实验通过对数学式的处理来进行对语句的判断是否正确，若正确则只要输入“语句正确”即可，若语句错误则需要根据错误的原因输出错误的理由，以方便编译员修改自己的代码。
实现方法是通过对文本文件的输入，当前数据与即将输入的字符串进行匹配，若不符合LL（1）文法则判定为错误，若符合则继续向下完成语法分析。
【源代码】#include <>#include <>#include <>#include <>#include <iostream>#include <stack>-#include <string>#include <fstream>using namespace std;ifstream fin("");ofstream fout("");enum symbol{ ]=period;ssym['#']=neq;//not equal|ssym[';']=semicolon;strcpy(&symwork[plus][0],"plus");strcpy(&symwork[minus][0],"minus");strcpy(&symwork[times][0],"times");strcpy(&symwork[slash][0],"slash");strcpy(&symwork[lparen][0],"lparen");strcpy(&symwork[rparen][0],"rparen");strcpy(&symwork[eql][0],"eql");strcpy(&symwork[comma][0],"comma");…strcpy(&symwork[neq][0],"neq");strcpy(&symwork[period][0],"period");strcpy(&symwork[semicolon][0],"semicolon");strcpy(&word[0][0],"begin");//关键字小写字母strcpy(&word[1][0],"call");strcpy(&word[2][0],"const");strcpy(&word[3][0],"do");strcpy(&word[4][0],"end");strcpy(&word[5][0],"if");:strcpy(&word[6][0],"odd");strcpy(&word[7][0],"procedure");strcpy(&word[8][0],"read");strcpy(&word[9][0],"then");strcpy(&word[10][0],"var");strcpy(&word[11][0],"while");strcpy(&word[12][0],"write");wsym[0]=beginsym;wsym[1]=callsym;-wsym[2]=constsym;wsym[3]=dosym;wsym[4]=endsym;wsym[5]=ifsym;wsym[6]=oddsym;wsym[7]=procsym;wsym[8]=readsym;wsym[9]=thensym;wsym[10]=varsym;wsym[11]=whilesym;,wsym[12]=writesym;}void WordAnalyse(){switch(sym){case <<"( "<<"nul"<<" , "<<ID<<" )"<<endl;]break;case ident:fout <<"( "<<"ident"<<" , "<<ID<<" )"<<endl;cout<<"( "<<"ident"<<" , "<<ID<<" )"<<endl;break;case number:fout <<"( "<<"number"<<" , "<<num<<" )"<<endl;cout<<"( "<<"number"<<" , "<<num<<" )"<<endl;break;case plus:fout <<"( "<<"plus"<<" , "<<ID<<" )"<<endl;cout<<"( "<<"plus"<<" , "<<ID<<" )"<<endl;break;case minus:fout <<"( "<<"minus"<<" , "<<ID<<" )"<<endl;cout<<"( "<<"minus"<<" , "<<ID<<" )"<<endl;break;case times:fout <<"( "<<"times"<<" , "<<ID<<" )"<<endl; ~cout<<"( "<<"times"<<" , "<<ID<<" )"<<endl;break;case slash:fout <<"( "<<"slash"<<" , "<<ID<<" )"<<endl;cout<<"( "<<"slash"<<" , "<<ID<<" )"<<endl;break;case oddsym:fout <<"( "<<"oddsym"<<" , "<<ID<<" )"<<endl;cout<<"( "<<"oddsym"<<" , "<<ID<<" )"<<endl;break;case lss:fout <<"( "<<"lss"<<" , "<<ID<<" )"<<endl;cout<<"( "<<"lsst"<<" , "<<ID<<" )"<<endl;break;case eql:fout <<"( "<<"eql"<<" , "<<ID<<" )"<<endl;cout<<"( "<<"eql"<<" , "<<ID<<" )"<<endl;break;case neq:fout <<"( "<<"neq"<<" , "<<ID<<" )"<<endl;。