词法分析实验报告(实验一)
词法分析实验报告
词法分析实验报告词法分析实验报告引言词法分析是自然语言处理中的一个重要环节，它负责将输入的文本分割成一个个的词语，并确定每个词语的词性。
本次实验旨在通过实现一个简单的词法分析器，来探索词法分析的原理和实践。
实验内容本次实验中，我们使用Python编程语言来实现词法分析器。
我们选取了一段简单的英文文本作为输入，以便更好地理解和演示词法分析的过程。
1. 文本预处理在进行词法分析之前，我们首先需要对输入文本进行预处理。
预处理的目的是去除文本中的标点符号、空格和其他无关的字符，以便更好地进行后续的分词操作。
2. 分词分词是词法分析的核心步骤之一。
在这个步骤中，我们将文本分割成一个个的词语。
常见的分词方法包括基于规则的分词和基于统计的分词。
在本次实验中，我们选择了基于规则的分词方法。
基于规则的分词方法通过事先定义一系列的分词规则来进行分词。
这些规则可以是基于语法的，也可以是基于词典的。
在实验中，我们使用了一个简单的基于词典的分词规则，即根据英文单词的常见前缀和后缀来进行分词。
3. 词性标注词性标注是词法分析的另一个重要步骤。
在这个步骤中，我们为每个词语确定其词性。
词性标注可以通过事先定义的规则和模型来进行。
在本次实验中，我们使用了一个简单的基于规则的词性标注方法。
基于规则的词性标注方法通过定义一系列的词性标注规则来进行词性标注。
这些规则可以是基于词法的，也可以是基于语法的。
在实验中，我们使用了一个简单的基于词法的词性标注规则，即根据英文单词的后缀来确定其词性。
实验结果经过实验，我们得到了输入文本的分词结果和词性标注结果。
分词结果如下：- I- love- natural- language- processing词性标注结果如下：- I (代词)- love (动词)- natural (形容词)- language (名词)- processing (名词)讨论与总结通过本次实验，我们深入了解了词法分析的原理和实践。
实验一词法分析器实验报告示例
词法分析器实验报告一.需求分析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中的字符串为标识符。
编译原理实验词法分析实验报告
编译原理实验词法分析实验报告一、实验目的词法分析是编译过程的第一个阶段，其主要任务是从左到右逐个字符地对源程序进行扫描，产生一个个单词符号。
本次实验的目的在于通过实践，深入理解词法分析的原理和方法，掌握如何使用程序设计语言实现词法分析器，提高对编译原理的综合应用能力。
二、实验环境本次实验使用的编程语言为_____，开发工具为_____。
三、实验原理词法分析的基本原理是根据编程语言的词法规则，将输入的字符流转换为单词符号序列。
单词符号通常包括关键字、标识符、常量、运算符和界符等。
词法分析器的实现方法有多种，常见的有状态转换图法和正则表达式法。
在本次实验中，我们采用了状态转换图法。
状态转换图是一种有向图，其中节点表示状态，有向边表示在当前状态下输入字符的可能转移。
通过定义不同的状态和转移规则，可以实现对各种单词符号的识别。
四、实验步骤1、定义单词符号的类别和编码首先，确定实验中要识别的单词符号种类，如关键字（if、else、while 等）、标识符、整数常量、浮点数常量、运算符（＋、、、／等）和界符（括号、逗号等）。
为每个单词符号类别分配一个唯一的编码，以便后续处理。
2、设计状态转换图根据单词符号的词法规则，绘制状态转换图。
例如，对于标识符的识别，起始状态为“起始状态”，当输入为字母时进入“标识符中间状态”，在“标识符中间状态”中，若输入为字母或数字则继续保持该状态，直到遇到非字母数字字符时结束识别，确定为一个标识符。
3、编写词法分析程序根据状态转换图，使用所选编程语言实现词法分析器。
在程序中，通过不断读取输入字符，根据当前状态进行转移，并在适当的时候输出识别到的单词符号。
4、测试词法分析程序准备一组包含各种单词符号的测试用例。
将测试用例输入到词法分析程序中，检查输出的单词符号是否正确。
五、实验代码以下是本次实验中实现词法分析器的核心代码部分：｀｀｀include ＜stdioh>include ＜ctypeh>／／单词符号类别定义typedef enum ｛KEYWORD,IDENTIFIER,INTEGER_CONSTANT,FLOAT_CONSTANT,OPERATOR,DELIMITER｝ TokenType;／／关键字列表char keywords ＝｛＂if"，＂else"，＂while"，＂for"，＂int"，＂float"，＂void"｝；／／状态定义typedef enum ｛START,IN_IDENTIFIER,IN_INTEGER,IN_FLOAT,IN_OPERATOR｝ State;／／词法分析函数TokenType getToken(char token, int tokenLength) ｛State state ＝ START;int i ＝ 0;while （1) ｛char c ＝ getchar(）；switch （state) ｛case START:if （isalpha(c)）｛state ＝ IN_IDENTIFIER;tokeni+＋＝ c;｝ else if （isdigit(c)）｛state ＝ IN_INTEGER;tokeni+＋＝ c;｝ else if （c ＝＝＇＋＇｜｜ c ＝＝＇＇｜｜ c ＝＝＇＇｜｜ c ＝＝＇／＇｜｜ c ＝＝＇（＇｜｜ c ＝＝＇）＇｜｜ c ＝＝＇；＇｜｜ c ＝＝＇，＇）｛state ＝ IN_OPERATOR;tokeni+＋＝ c;｝ else if （c ＝＝＇＇）｛state ＝ IN_FLOAT;tokeni+＋＝ c;｝ else if （c ＝＝ EOF) ｛tokeni ＝＇＼0'；tokenLength ＝ i;return －1;｝ else ｛tokeni ＝＇＼0'；tokenLength ＝ i;return －2;｝break;case IN_IDENTIFIER:if （isalpha(c) ｜｜ isdigit(c)）｛tokeni+＋＝ c;｝ else ｛ungetc(c, stdin)；tokeni ＝＇＼0'；tokenLength ＝ i;／／检查是否为关键字for （int j ＝ 0; j ＜ sizeof(keywords) ／ sizeof(keywords0)； j+＋）｛if （strcmp(token, keywordsj) ＝＝ 0) ｛return KEYWORD;｝｝return IDENTIFIER;｝break;case IN_INTEGER:if （isdigit(c)）｛tokeni+＋＝ c;｝ else if （c ＝＝＇＇）｛state ＝ IN_FLOAT;tokeni+＋＝ c;｝ else ｛ungetc(c, stdin)；tokeni ＝＇＼0'；tokenLength ＝ i;return INTEGER_CONSTANT;｝break;case IN_FLOAT:if （isdigit(c)）｛tokeni+＋＝ c;｝ else ｛ungetc(c, stdin)；tokeni ＝＇＼0'；tokenLength ＝ i;return FLOAT_CONSTANT;｝break;case IN_OPERATOR: tokeni ＝＇＼0'；tokenLength ＝ i;return OPERATOR; break;｝｝｝int main(）｛char token100;int tokenLength;TokenType tokenType;while （（tokenType ＝ getToken(token, ＆tokenLength)）！＝－1) ｛switch （tokenType) ｛case KEYWORD:printf(＂Keyword: ％s\n"， token)；break;case IDENTIFIER:printf(＂Identifier: ％s\n"， token)；break;case INTEGER_CONSTANT:printf(＂Integer Constant: ％s\n"， token)；break;case FLOAT_CONSTANT:printf(＂Float Constant: ％s\n"， token)；break;case OPERATOR:printf(＂Operator: ％s\n"， token)；break;case DELIMITER:printf(＂Delimiter: ％s\n"， token)；break;｝｝return 0;｝｀｀｀六、实验结果对准备的测试用例进行输入，得到的词法分析结果如下：测试用例 1：｀｀｀int main(）｛int num ＝ 10;float pi ＝ 314;if （num ＞ 5) ｛printf(＂Hello, World!＼n"）；｝｝｀｀｀词法分析结果：｀｀｀Keyword: int Identifier: main Delimiter: （Delimiter: ）｛Identifier: num Operator: ＝Integer Constant: 10；Identifier: float Identifier: pi Operator: ＝Float Constant: 314；Keyword: ifDelimiter: （Identifier: numOperator: ＞Integer Constant: 5）｛Identifier: printfDelimiter: （String: ＂Hello, World!＼n" Delimiter: ）；｝｀｀｀测试用例 2：｀｀｀for （int i ＝ 0; i ＜ 10; i+＋）｛double result ＝ i 25;｀｀｀词法分析结果：｀｀｀Keyword: for Delimiter: （Keyword: int Identifier: i Operator: ＝Integer Constant: 0；Identifier: i Operator: ＜Integer Constant: 10；Identifier: i Operator: ＋＋）Identifier: doubleIdentifier: resultOperator: ＝Identifier: iOperator:Float Constant: 25；｝｀｀｀通过对多个测试用例的分析，词法分析器能够正确识别出各种单词符号，实验结果符合预期。
编译原理词法分析实验报告
编译原理词法分析实验报告实验一词法分析一、实验目的通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
二、实验内容（1）功能描述：该程序是实现一个词法分析器，词法分析器的功能是输入源程序，输出单词符号。
词法分析器的单词符号常常表示成以下的二元式(单词种别码，单词符号的属性值)。
本实验中，采用的是将单词分为五种的方法。
识别关键字：main、if、int、for、while、do、return、break、continue；单词种别码为1。
标识符：单词种别码为2。
常数：为无符号整形数；单词种别码为3。
运算符：包括：+、-、*、/、=、>、<、>=、<=、!= ；单词种别码为4。
分隔符：包括：,、;、{、}、(、)；单词种别码为5。
（2）程序结构描述：输入：从控制台输入一段源程序代码，对输入的代码进行词法分析,处理：分离出关键字、标识符、数值、运算符和界符。
输出：在词法分析结果表中输出每个单词所在行号、类型以及它所对应的编码。
其中，编码是自定义的,一种类型对应一个编码。
词法分析结果显示在控制台上。
（3）程序设计思路1、定义编码表，用ArrayList集合存放单词，如：关键字、运算符、分界符。
这三种单词是固定的，标示符和数字这两种单词不存放在集合中。
编码表是固定的，只需要初始化一次就够了，所以将集合定义为static类型，使其在类加载时，进行一次初始化。
2、static char allstr[] = new char[100000];该数组用于存储用户从控制台输入的所有字符。
3、//从键盘获取一个一个的字符public char Getchar() {try {ch = (char) System.in.read();} catch (Exception e) {e.printStackTrace();}return ch;}4、用while循环遍历allstr数组中存放的字符，判断分离出关键字、标示符、数字、运算符、标示符。
词法分析实验报告范文
词法分析实验报告范文一、实验目得::通过设计编制调试一个具体得词法分析程序,加深对词法分析原理得理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词得词法分析方法。
编制一个读单词过程，从输入得源程序中，识别出各个具有独立意义得单词,即基本保留字、标识符、常数、运算符、分隔符五大类.并依次输出各个单词得内部编码及单词符号自身值。
二、实验要求如源程序为C语言．输入如下一段:mａin(){inｔa，b；ａ=10;；02+a=ｂﻩ}#要求输出如右图.要求：1、将单词分为五种识别关键字:mａin、iｆ、ｉnt、for、while、ｄo、ｒeｔurｎ、break、continｕe；单词种别码为1．标识符;单词种别码为２。
常数为无符号整形数；单词种别码为3。
运算符包括:+、－、某、／、=、〉、<、＞=、<=、!＝;单词种别码为4。
分隔符包括:,、;、{、｝、（、）;单词种别码为5。
2、使用一符一种得分法关键字、运算符与分界符可以每一个均为一种标识符与常数仍然一类一种三、实验内容1、功能描述改程序就是一个实现词法分析得功能,能识别5种单词，其她单词报错。
2、程序结构描述iｎtIｓＫey（ｃhar某Word)关键字匹配函数,查询就是否为关键字,若就是,返回值为1，否则为0。
inｔIＡlpha(charc)查瞧就是否为字母，若就是,返回值为1,否则为0。
iｎｔINum（ｃharc)查瞧就是否为数字，若就是,返回值为1,否则为０。
voｉdcanner(FIＬE某ｆp)扫描函数，扫描程序中得字符串并调用上述三种函数检查就是否就是字母、数字,就是否就是关键字，并输出。
ｆｓeek（fp,—１,1）回退一个字符。
fgetｃ（fp）从数据流中区下一个字符。
fopeｎ文件打开函数,返回指向文件第一个字符得指针四、实验结果测试内容为maｉn（)(1,”main”)(5,”(“)(5,”)“)(5,”{“)(1,”int”)(2,”a”)(5 ,”,”)(2,”b”)(5,”;”)(2,”a”)(4,”=”)(3,”10”)(5,”;”)(2 ,”b”)(4,”=”)(2,”a”)(4,”+”)(3,”20”)(5,”;”)(5,”}“)｛iｎta，b；a=10;ｂ=a+20;｝#结果测试代码为voｉdｍain()｛ｉnta,ｂ;if(a=10;)b＋=20；c=％;｝#结果为测试代码maｉn（)｛inｔa，b；iｆ(ａ<=”10"）ｂ＋＝20;c＝%;rｅturｎ０；｝#结果五、实验过程记录1、因为用到回退函数ｆeek()，而以前没有用过这个函数,所以开始时很苦恼,不知道如何回退一个字符,后来问了同学,才明白原来有这么一个函数，顿时豁然开朗。
实验一词法分析实验报告1
实验一词法分析一、实验目的通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码与单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续显示）二、实验要求使用一符一种的分法关键字、运算符和分界符可以每一个均为一种标识符和常数仍然一类一种三、实验内容功能描述：1、待分析的简单语言的词法（1）关键字：begin if then while do end（2）运算符和界符：（3）其他单词是标识符（ID）和整型常数（NUM），通过以下正规式定义：ID=letter（letter| digit）*NUM=digit digit *（4）空格由空白、制表符和换行符组成。
空格一般用来分隔ID、NUM,运算符、界符和关键字，词法分析阶段通常被忽略。
2、各种单词符号对应的种别码图 1程序结构描述：符号界符等符号四、实验结果输入begin x:=9: if x>9 then x:=2*x+1/3; end # 后经词法分析输出如下序列：(begin 1)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图3所示：图3输入private x:=9;if x>0 then x:=2*x+1/3; end#后经词法分析输出如下序列：(private 10)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图4所示：图4显然，private是关键字，却被识别成了标示符，这是因为图1中没有定义private关键字的种别码，所以把private当成了标示符。
输入private x:=9;if x>0 then x:=2*x+1/3; @ end#后经词法分析输出如下序列：(private 10)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图5所示图5显然，@没有在图一中定义种别，所以输出了“Error in row 1!”的报错信息。
实验1 词法分析实验报告
p=0;
row=1;
cout<<"Please input string:"<<endl;
do
{
cin.get(ch);
prog[p++]=ch;
}
while(ch!='#');
p=0;
do
{
scaner();
switch(syn)
{
case 11: cout<<"("<<syn<<","<<sum<<")"<<endl; break;
实验二时发现怎么出结果都会出现一个缺:=错误，便回头检查代码才发现实验一时的scaner()函数最后的:和:=的种别码互相写错了，所以回过头来重新修正了代码和实验结果图。
case -1: cout<<"Error in row"<<row<<"!"<<endl; break;
case -2: row=row++;break;
default: cout<<"("<<syn<<","<<token<<")"<<endl;break;
}
}
while (syn!=0);
}
四、结果验证
{
syn=21;
token[m++]=ch;
}
else if(ch=='=')
词法分析实验报告
词法分析实验报告一、实验目的和背景词法分析是编译原理中的重要部分之一，其主要作用是将源程序中的字符序列转化为有意义的单词序列，以便于后续的处理和分析。
为了更好地理解词法分析的实现原理以及掌握相关算法和工具，本次词法分析实验旨在通过手动编写正则表达式、确定有限自动机的状态转移函数和实现词法分析程序来实现词法分析。
二、实验内容在本次实验中，我们需要完成以下任务：1.手动编写正则表达式；2.确定有限自动机的状态转移函数；3.实现词法分析程序。
三、实验过程1.手动编写正则表达式对于给定的源程序，我们首先需要根据其语法规则手动编写正则表达式。
例如，对于一个简单的算术表达式，其正则表达式可以如下所示：i. 数字（0-9）：[0-9]+ii. 加号（+）：\+iii. 减号（-）：-iv. 乘号（*）：\*v. 除号（/）：/vi. 左括号（（）：\(vii. 右括号（））：\)2.确定有限自动机的状态转移函数根据正则表达式，我们可以确定有限自动机的状态转移函数。
例如，对于上述算术表达式的正则表达式，其有限自动机的状态转移函数如下所示：i. 初始状态（S）：判断下一个字符，如果是数字则进入数字状态，如果是左括号则进入左括号状态；ii. 数字状态（D）：继续判断下一个字符，如果是数字则保持在数字状态，如果是运算符则输出数字记号，返回初始状态，如果是右括号则输出数字记号，返回初始状态；iii. 左括号状态（L）：输出左括号记号，返回初始状态；iv. 右括号状态（R）：输出右括号记号，返回初始状态。
3.实现词法分析程序根据以上的正则表达式和有限自动机的状态转移函数，我们可以编写一个简单的词法分析程序。
该程序的主要流程如下所示：i. 读取源程序的字符序列；ii. 根据有限自动机的状态转移函数，逐个字符进行状态转移；iii. 如果当前状态为接受状态，则输出相应的记号；iv. 继续进行状态转移，直至读取完整个源程序。
四、实验结果通过以上步骤，我们成功完成了对给定源程序的词法分析。
词法分析实验报告(实验一)
编译原理词法分析实验报告软工082班兰洁200831104044一、实验内容二、实验目的三、实验预期四、程序规定五、实验原理●程序流程图●判别浮点功能扩展流程图●状态转换图六、程序代码与浮点判别功能扩展七、测试用例●扩展功能测试用例；●普通功能测试用例八、输出结果九、实验心得一、实验内容：词法分析：1、识别简单语言的单词符号；2、识别关键字、标识符、数字、运算符等。
并扩展浮点识别功能。
二、实验目的调试词法分析程序，加深对词法分析原理的理解，掌握编写简单词法分析程序的一般步骤。
三、实验预期结果：经过调试源代码程序，程序能够成功运行编译，对输入的简单字符串，能够别关键字、标识符、数字、运算符等，并且给出单词符号的对应编码。
四、程序规定：1、关键字："function","if","then","while","do","endfunc"；2、算术运算符：”+”,”-”,”*”,”/”,”=”；3、关系运算符："<" ">" "<=" ">=" "==" "!="；4、界符："(" ")" ";" "#"；5、标识符规定以字母开头,字母均为小写；6、空格和换行符跳过；7、单词对应编码：十、实验原理：输入串--------------------〉词法分析程序————————〉单词符号串输入：字符串以#结束。
输出：单词的二元组(syn，token/sum)程序流程图分析浮点数功能扩展部分流程图：shuzi()函数状态转换图六、程序代码：备注：红色字体部分为程序功能的功能扩展，使程序能够分析浮点数！我把浮点数的syn设置为80！/*词法分析源代码*/#include<stdio.h>#include<string.h>scaner();char prog[80],token[8];char ch;int syn,p,m,n,sum;char * rwtab[6]={"function","if","then","while","do","endfunc"}; int i=0,k,c,sumint,f;char fenshu[80],sum1[80];double sumf=0,fudian;int shuzi(){if(ch>='0' && ch<='9')syn=80;elsesyn=-2;return syn;}main(){p=0;printf("\n please input string :\n");do{scanf("%c",&ch);prog[++p]=ch;}while(ch!='#');p=0;do{scaner();switch(syn){ case 11:printf("\n(%d,%d)",syn,sum);break;case -1:printf("\n error");break;case 80:printf("\n(%d,%f)",syn,fudian);break; default:printf("\n(%d,%s)",syn,token);}}while(syn!=0);}scaner(){for(n=0;n<8;n++)token[n]=NULL;//if(1+2!=3)ch=prog[++p];while(ch==' ' || ch=='\n')ch=prog[++p];//跳过空格if(ch>='a' && ch<='z'){m=0;while(ch>='a' && ch<='z' || ch>='0' && ch<='9') {token[m++]=ch;//token[0]=f,m=1ch=prog[++p];}token[m]='\0';ch=prog[--p];syn=10;for(n=0;n<6;n++){if(strcmp(token,rwtab[n])==0){syn=n+1;break;}}}elseif(ch>='0' && ch<='9'){c=p;k=0;do{ sum1[k]=ch;ch=prog[++c]; //ch取后一个数字k++;shuzi();//这个函数用来分析浮点数的整数部分是否已经输入到数组里f=syn;} while(f==80)if(ch=='.'){for(n=0;n<k;n++){sumint=sumint*10+sum1[n]-'0';} //计算整数部分i=0;do{ch=prog[++c];fenshu[i]=ch;i++;shuzi();//这个函数用来分析浮点数的小数部分是否已经输入到数组里} while(syn==80);sumf=0;for(k=i-2;k>=0;k--){sumf=sumf*0.1+(fenshu[k]-'0')*0.1;} //计算浮点数的小数部分fudian=sumint+sumf; //浮点数计算syn=80;p=--c;}else{ch=prog[p];//若是整数，ch等于原来的值 sum=0;while(ch>='0' && ch<='9'){sum=sum*10+ch-'0';ch=prog[++p];}ch=prog[--p];syn=11;}}elseswitch(ch){case'<':m=0;token[m++]=ch;ch=prog[++p];if(ch=='='){syn=22;token[m++]=ch;}elseif(ch=='>'){syn=21;token[m++]=ch;}else{syn=20;ch=prog[--p];}break;case'>':m=0;token[m++]=ch;ch=prog[++p];if(ch=='='){syn=24;token[m++]=ch;}else{syn=23;ch=prog[--p];}break;case'=':m=0;token[m++]=ch;ch=prog[++p];if(ch=='='){syn=25;token[m++]=ch;}else{syn=18;ch=prog[--p];}break;case'!':m=0;token[m++]=ch;ch=prog[++p];if(ch=='='){syn=22;token[m++]=ch;}else{syn=-1;p--;}break;case'+':syn=13;token[0]=ch;break;case'-':syn=14;token[0]=ch;break;case'*':syn=15;token[0]=ch;break;case'/':syn=16;token[0]=ch;break;case';':syn=26;token[0]=ch;break;case'(':syn=27;token[0]=ch;break;case')':syn=28;token[0]=ch;break; case'#':syn=0;token[0]=ch;break;default:syn=-1;}}七、测试用例：补充：功能扩展测试用例：八、程序输出结果：功能扩展测试用例输出结果用例一：用例二：用例三：普通功能测试用例显示结果九、实验心得通过编译原理实验一词法分析实验，使得自己对词法分析的流程有了更深刻的了解，虽然源代码并非由自己设计，但是在调试程序的过程中，尤其是进行测序功能扩展的过程中，想了很多种办法，终于找到了最合适的方法，而且还进行了代码的优化，这个过程虽然有时有些枯燥，但是更多时候是欣喜的，不仅复习了c语言的许多内容，并且有了更深的理解。
编译原理-实验报告1-词法分析
计算机硬件实验室实验报告姓名学号班级词法分析成绩设备名称及软件环境一、实验目的：通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续显示）二、实验要求：识别保留字：if、int、for、while、do、return、break、continue，等C语言的保留字；单词种别码为1。
其他的都识别为标识符；单词种别码为2。
常数为无符号整形数；单词种别码为3。
运算符包括：+、-、*、/、=、>、<、>=、<=、!=；单词种别码为4。
分隔符包括：,、;、{、}、(、)、[、]；单词种别码为5。
三、实验过程：根据题目要求，初步完成程序过程的设计，模块的划分、变量类型分配。
#inlclude<stdio.h>int main(){int d,a,c;a=10;c=a+b;printf("%d%d",a,b);;return 0;}用以上定义的C语言子集的源程序作为词法分析程序的输入数据。
在词法分析中，自文件头开始扫描源程序字符，一旦发现符合“单词”定义的源程序字符串时，将它翻译成固定长度的单词内部表示，并查填适当的信息表。
经过词法分析后，源程序字符串（源程序的外部表示）被翻译成具有等长信息的单词串（源程序的内部表示），并产生两个表格：常数表和标识符表，它们分别包含了源程序中的所有常数和所有标识符。
0.定义部分：定义常量、变量、数据结构。
1.初始化：从文件将源程序全部输入到字符缓冲区中。
2.取单词前：去掉多余空白。
3.取单词：利用实验一的成果读出单词的每一个字符，组成单词，分析类型。
词法分析报告
编译原理实验报告实验一词法分析程序的设计与实现指导教师：姓名：学号：班级：一、实验目的基本掌握计算机语言的词法分析程序的开发方法。
二、实验内容编制一个能够分析三种整数、标识符、主要运算符和主要关键字的词法分析程序。
三、实验要求1．根据以下的正规式，编制正规文法，画出状态图；标识符<字母>(<字母>|<数字字符>)*十进制整数0 | (1|2|3|4|5|6|7|8|9) (0|1|2|3|4|5|6|7|8|9)*八进制整数0 (0|1|2|3|4|5|6|7) (0|1|2|3|4|5|6|7)*十六进制整数0 (x|X) (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)*运算符和分隔符+ - * / > < = ( ) ;关键字if then else while do2．根据状态图，设计词法分析函数int scan( )，完成以下功能：（1）从输入流（键盘或文件）读入数据，分析出一个单词。
（2）返回单词种别（用整数表示），（3）返回单词属性（不同的属性可以放在不同的全局变量中）。
3．编写测试程序，循环调用函数scan( )，每次调用，获得一个单词的信息。
在测试程序中，打印输出单词种别、属性（注意：不要在词法分析函数scan 中打印输出！）。
四、实验环境微型计算机。
Windows 操作系统/Linux 操作系统。
编程语言：C/C++/Java/C#。
建议使用Visual C++/Netbeans/Eclipse 集成开发环境。
五、实验步骤1. 根据状态图，设计词法分析算法2. 设计函数scan( )，实现该算法3. 编制测试程序（在本试验中，可以是主函数main( ) ）。
4. 调试程序：输入一组单词，检查输出结果。
六、状态图七. 测试数据：0 92+data> 0x3f00 while八．测试结果九,思考题1.词法分析能否采用空格来区分单词？答：不能，因为比如abc+bcd中没有空格，但这是三个单词。
实验一 词法分析报告
实验一词法分析1．实验要求（1）从源程序文件中读取有效字符并将其转换成二元组内部表示形式输出。
（2）掌握词法分析的实现方法。
（3）实验时间4学时。
（4）实验完成后，要提交实验报告（包括源程序清单）。
2．实验内容2.1主程序设计考虑：主程序的说明部分为各种表格和变量安排空间（关键字和特殊符号表）。
id 和ci 数组分别存放标识符和常数；还有一些为造表填表设置的变量。
主程序的工作部分建议设计成便于调试的循环结构。
每个循环处理一个单词；调用词法分析过程；输出每个单词的内部码（种别编码，属性值）。
建议从文件中读取要分析的符号串。
2.2词法分析过程考虑该过程根据输入单词的第一个有效字符（有时还需读第二个字符），判断单词种别，产生种别编码。
对于标识符和常数，需分别与标识符表和常数表中已登记的元素相比较，如表中已有该元素，则记录其在表中的位置，如未出现过，将标识符按顺序填入数组id 中，将三：主流程图如下：四：实验思路（1）我首先把这个单词的种类分成了五类，包括：关键字、标识符、常数、算符、界符。
然后利用状态转换图进行单词的识别（2）对于关键字、算符、界符。
因为这些单词的个数有限。
所以我单独给每个单词一个种别编码。
能够做到每个单词的种别编码是不一样的。
而对于常数和标识符，我先把它们分别单独的作为一类，然后定义一个二维数组，分别存放这个单词的名称和编码。
而这个编码就是这个单词在这个二维数组中的位置；当遇到新的标识符或常数，就把这个单词放入到相应的数组中。
（3）然后构造一个状态转换图的程序。
把每次得到的单词先暂时存放在temp 二维数组中。
然后用这个临时的二维数组去确定这个单词是何种类别五：实验代码using System;using System.Collections.Generic;using ponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;namespace Word{public partial class Form1 : Form{public Form1(){InitializeComponent();}char[] receive; //从输入得到的源程序char ch; //这是从源程序读取的一个字符string cache; //暂存的单词int index; //记录取到哪个位置了key_word temp; //用来临时存放得到这个单词struct key_word{public string key_name;public int number;}struct num_word{public string num_name;public int number;}struct ID_word{public string ID_name;public int number;}public int num_index;public int ID_index;DataTable dt;private void button1_Click(object sender, EventArgs e){dt = new DataTable();dt.Columns.Add("助记符");dt.Columns.Add("外部编码");dt.Columns.Add("内部编码");dt.Columns.Add("类型");receive = textBox1.Text.ToCharArray();index = 0;num_index = 0;ID_index = 0;;while (index < receive.Length){cache = null;Get_Word();if (temp.number == 1){int i = 0;int flag = 0;if (num_index == 0){Num[num_index].num_name = temp.key_name;Num[num_index].number = num_index;num_index++;}else{for (i = 0; i < num_index; i++){if (Num[i].num_name == temp.key_name){flag = i;break;}}if (i >= num_index){Num[num_index].num_name = temp.key_name;Num[num_index].number = num_index;flag = num_index;num_index++;}}DataRow dr = dt.NewRow();dt.Rows.Add(dr);dr["助记符"] = temp.key_name;dr["内部编码"] = +Num[flag].number;dr["类型"] = "常数";}else if (temp.number == 0){int i = 0;int flag = 0;if (ID_index == 0){ID[ID_index].ID_name = temp.key_name;ID[ID_index].number = ID_index;ID_index++;}else{for (i = 0; i < ID_index; i++){if (ID[i].ID_name == temp.key_name){flag = i;break;}}if (i >= ID_index){ID[ID_index].ID_name = temp.key_name;ID[ID_index].number = ID_index;flag = ID_index;ID_index++;}}DataRow dr = dt.NewRow();dt.Rows.Add(dr);dr["助记符"] = temp.key_name;dr["外部编码"] = temp.number;dr["内部编码"] = ID[flag].number;dr["类型"] = "标识符";}else{DataRow dr = dt.NewRow();dt.Rows.Add(dr);dr["助记符"] = temp.key_name;if (temp.number >= 15 && temp.number <= 30){dr["类型"] = "运算符";}else if (temp.number >= 31 && temp.number <= 40){dr["类型"] = "界符";}else{dr["类型"] = "关键字";}}}this.dataGridView1.DataSource = dt;}key_word[] Key;num_word[] Num;ID_word[] ID;private void Form1_Load(object sender, EventArgs e){index = 0;Key = new key_word[41];Key[0].key_name = "$ID"; Key[0].number = 0; //标识符Key[1].key_name = "$INT"; Key[1].number = 1; //数Key[2].key_name = "int"; Key[2].number = 2; Key[3].key_name = "float"; K ey[3].number = 3;Key[4].key_name = "void"; Key[4].number = 4; Key[5].key_name = "const"; Key[5].number = 5; Key[6].key_name = "if"; Key[6].number = 6; Key[7].key_name = "el se"; Key[7].number = 7;Key[8].key_name = "do"; Key[8].number = 8; Key[9].key_name = "while"; Key[9].number = 9; Key[10].key_name = "scanf"; Key[10].number = 10; Key[11].key_nam e = "printf"; Key[11].number = 11;Key[12].key_name = "return"; Key[12].number = 12; Key[13].key_name = " main"; Key[13].number = 13; Key[14].key_name = "read"; Key[14].number = 14;Key[15].key_name = "+"; Key[15].number = 15;Key[16].key_name = "-"; Key[16].number = 16; Key[17].key_name = "*"; K ey[17].number = 17; Key[18].key_name = "/"; Key[18].number = 18; Key[19].key_name = "%"; Key[19].number = 19;Key[20].key_name = "="; Key[20].number = 20; Key[21].key_name = "=="; Key[21].number = 21; Key[22].key_name = ">"; Key[22].number = 22; Key[23].key_name = "<"; Key[23].number = 23;Key[24].key_name = "!="; Key[24].number = 24; Key[25].key_name = ">="; Key[25].number = 25; Key[26].key_name = "<="; Key[26].number = 26; Key[27].key_na me = "&&"; Key[27].number = 27;Key[28].key_name = "||"; Key[28].number = 28; Key[29].key_name = "!"; K ey[29].number = 29; Key[30].key_name = "<>";Key[30].number = 30;Key[31].key_name = "("; Key[31].number = 31;Key[32].key_name = ")"; Key[32].number = 32; Key[33].key_name = "{"; K ey[33].number = 33;Key[34].key_name = "}"; Key[34].number = 34; Key[35].key_name = ";"; K ey[35].number = 35;Key[36].key_name = ","; Key[36].number = 36; Key[37].key_name = "\""; K ey[37].number = 37; Key[38].key_name = "'"; Key[38].number = 38; Key[39].key_name = "++"; Key[39].number = 39;Key[40].key_name = "--"; Key[40].number = 40;Num = new num_word[1024];ID = new ID_word[1024];}public void GetChar() //得到一个字符{if (index < receive.Length){ch = receive[index];index++;}else{ch = '\0';}}public void GetNotKong() //得到一个不是空的字符{while (index < receive.Length){ch = receive[index];index++;if (ch != ' ' && ch != '\r' && ch != '\0' && ch != '\n'){break;}}}public void ConCat() //连接{cache += ch;}public bool IsLetter() //判断是不是字母{if (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z') {return true;}else{return false;}}public bool IsDigit() //判断是不是数字{if (ch >= '0' && ch <= '9'){return true;}else{return false;}}public int Get_Number() //得到这个单词的编码{for (int i = 0; i < 41; i++){if (string.Equals(cache, Key[i].key_name)){return Key[i].number;}}{return 0;}}public void retrace() //退回一个单词{if (ch != '\0'){index--;}private void Get_Word(){int count;GetNotKong();if (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z') {ConCat();GetChar();while (IsLetter() || IsDigit()){ConCat();GetChar();}retrace();count = Get_Number();temp.key_name = cache;if (count == 0){temp.number = 0;}else{temp.number = Key[count].number;}}else if (ch >= '0' && ch <= '9'){ConCat();GetChar();while (IsDigit()){ConCat();GetChar();}retrace();temp.key_name = cache;temp.number = 1;}else if (ch == '+')ConCat();GetChar();if (ch == '+'){ConCat();temp.key_name = cache;temp.number = 39;}else{retrace();temp.key_name = cache;temp.number = Get_Number();}}else if (ch == '-'){ConCat();GetChar();if (ch == '-'){ConCat();temp.key_name = cache;temp.number = 40;}else{retrace();temp.key_name = cache;temp.number = Get_Number();}}else if (ch == '<'){ConCat();GetChar();if (ch == '='){ConCat();temp.key_name = cache;temp.number = 26;}else{retrace();temp.key_name = cache;temp.number = Get_Number();}}else if (ch == '>'){ConCat();GetChar();if (ch == '='){ConCat();temp.key_name = cache;temp.number = 25;}else{retrace();temp.key_name = cache;temp.number = Get_Number();}}else if (ch == '='){ConCat();GetChar();if (ch == '='){ConCat();temp.key_name = cache;temp.number = 21;}else{retrace();temp.key_name = cache;temp.number = Get_Number();}}else if (ch == '!'){ConCat();GetChar();if (ch == '='){ConCat();temp.key_name = cache;temp.number = 24;}else{retrace();temp.key_name = cache;temp.number = Get_Number();}}else if (ch == '&'){ConCat();GetChar();if (ch == '&'){ConCat();temp.key_name = cache;temp.number = 27;}else{retrace();temp.key_name = cache;temp.number = Get_Number();}}else if (ch == '|'){ConCat();GetChar();if (ch == '|'){ConCat();temp.key_name = cache;temp.number = 28;}else{retrace();temp.key_name = cache;temp.number = Get_Number();}}else{ConCat();temp.key_name = cache;temp.number = Get_Number();}}}}六：实验截图（1）我测试的程序为void main(){ int a=20;int b=15;if(a==20)printf("A");if(b==20)printf("B");}七：实验心得通过这次实验、我对于词法分析需要做的任务有了一个更加深刻的理解。
实验一 词法分析实验报告
题目
词法分析》实验报告
2012-10-28
词法分析
组员：陈俊杰 swe10031 组员：许冬青 swe10033 组员：王吉 swe10028
姓名及 （组长）康黎明 swe10029 日期 分工
一、 实验目的 通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。并掌握在对程 序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词(token)，即基 本保留字、标识符、常量、运算符、分隔符五大类，并依次输出各个单词的内部编码及单词符 号自身值。（遇到错误时可显示“Error”，然后跳过错误部分继续显示）
四、内部编码说明、主要函数介绍：
void concatenation() { token[n]=character;
n++; token[n]='\0';
//字符串结束标志
} 将 token 中字符串与 character 中字符连接作为 token 中的新字符串。 void retract() { fseek(input,-1,1); } 扫描指针回退一个字符, 同时将 character 置为空白。 int reserve() { if (strcmp(token,"if")==1) return 1; else if (strcmp(token,"int")==1) return 1; else if (strcmp(token,"for")==1) return 1; else if (strcmp(token,"while")==1) return 1; else if (strcmp(token,"do")==1) return 1; else if (strcmp(token,"return")==1) return 1; else if (strcmp(token,"break")==1) return 1; else if (strcmp(token,"continue")==1) return 1; else if (strcmp(token,"void")==1) return 1; else return 0; } 按 token 数组中的字符串查保留字表, 若是保留字则返回其编码,否则返回 0。
词法分析实验报告心得(3篇)
第1篇一、实验背景词法分析是编译原理中的一项基本任务，它将源程序中的字符序列转换成一系列具有独立意义的记号（Token）。
本次实验旨在通过词法分析实验，加深对词法分析过程的理解，掌握词法分析器的实现方法，并提高编程能力。
二、实验目的1. 理解词法分析的基本概念和过程。
2. 掌握词法分析器的实现方法。
3. 提高编程能力，为后续编译原理的学习打下基础。
三、实验内容本次实验采用Java语言编写词法分析器，实现了对C语言源程序的词法分析功能。
具体实验内容包括：1. 定义词法分析器类，包含状态转移表、符号表等数据结构。
2. 设计状态转移函数，实现字符序列到Token的转换。
3. 实现词法分析器的入口函数，接收源程序字符串，输出Token序列。
四、实验步骤1. 创建词法分析器类，定义状态转移表、符号表等数据结构。
2. 设计状态转移函数，根据输入字符和当前状态，输出下一个状态和对应的Token。
3. 实现词法分析器的入口函数，接收源程序字符串，初始化状态和位置指针，遍历源程序字符序列。
4. 在遍历过程中，根据状态转移函数输出Token，并更新状态和位置指针。
5. 当遇到输入字符串结束时，输出剩余的Token，并结束词法分析过程。
五、实验心得1. 词法分析是编译过程中的第一步，它将源程序中的字符序列转换成具有独立意义的Token，为后续的语法分析和语义分析提供基础。
2. 在实现词法分析器时，需要仔细分析源程序中的字符序列，确定状态转移表和符号表的内容。
这有助于提高词法分析器的准确性和效率。
3. 在编写状态转移函数时，要考虑各种可能的输入情况，确保能够正确处理各种字符序列。
同时，要注意状态转移函数的健壮性，避免出现错误。
4. 在实现词法分析器时，需要关注数据结构的组织方式。
合理的数据结构可以提高程序的可读性和可维护性。
5. 通过本次实验，我深刻体会到编程的乐趣和挑战。
在实现词法分析器过程中，我不断学习新的知识，提高了解决问题的能力。
词法分析实验报告
编译原理实验报告实验名称：______编译原理词法分析___实验类型：________________________ _指导教师：___ 曾立胜______________ 专业班级：___ _软件1105________ ___ 姓名：_____ 王永强______________ 学号：______ 20111598____________ 实验地点：______东六E109___ ________ 实验成绩：____________________________日期：2013 年4 月2日实验一词法分析一、实验目的运用理论课中的知识编写一段程序，此程序能对于给定的源程序，从组成源程序的字符行中寻找出单词，并给出它们的种别和属性——输出二元组序列。
以便提供给语法分析的时候使用。
要求能识别所有的关键字，标志符等，并且能够对出先的一些词法规则的错误进行判断和必要的处理。
通过此次试验能对实验环境更加熟悉，对程序的编写和调试更加熟练，能把理论知识和代码相结合。
二、实验设计1.原理：读入源程序，得到单词表如图所示源程序单词表2.设计方法：在扫描源程序字符串时一旦识别出关键字、分隔符、标识符、无符号之一，即以单词形式，各类单词均采用相同的结构，即二元式编码形式存储。
每次调用词法分析程序，它均能自动继续扫描下去，形成下一个单词，直至整个源程序全部扫描完毕并形成相应的单词表。
3.设计过程：通过test语言的词法规则，把规则转化为一种方法，再将此方法用代码编写出来。
4.设计结果：得到一个能识别test语言词法的源程序代码，可以通过此代码分析由test语言编写的源程序是否有语法错误，并且指出错误位置。
最终得到与源程序代码对应的单词表，为接下来的语法分析和语义分析奠基。
三、实验过程过程：1.根据书中test语言代码，得到一个基本的词法分析代码。
2.根据实验要求，修改词法分析代码得到符合要求的代码。
3.修改过程中遇到问题，及时更正。
编译原理实验词法分析实验报告
编译原理实验词法分析实验报告一、实验目的词法分析是编译过程中的第一个阶段，其主要任务是从输入的源程序中识别出具有独立意义的单词符号，并将其转换为内部编码形式。
本次实验的目的是通过设计和实现一个简单的词法分析程序，深入理解词法分析的基本原理和方法，提高对编程语言语法结构的认识和编程能力。
二、实验原理词法分析的基本原理是根据编程语言的词法规则，使用有限自动机或正则表达式等技术来识别单词符号。
在本次实验中，我们采用了状态转换图的方法来设计词法分析器。
状态转换图是一种用于描述有限自动机的图形表示方法，它由状态节点和有向边组成。
每个状态节点表示自动机的一个状态，有向边表示状态之间的转换条件。
当输入字符与当前状态的转换条件匹配时，自动机将从当前状态转换到下一个状态。
当到达一个终态时，表示识别出了一个单词符号。
三、实验环境本次实验使用了 Python 编程语言，并在 PyCharm 集成开发环境中进行开发和调试。
四、实验内容1、定义单词符号的种类和编码关键字：如｀if`、｀else`、｀while` 等标识符：由字母、数字和下划线组成，且以字母或下划线开头常数：包括整数和浮点数运算符：如｀＋｀、｀｀、｀｀、｀／｀等分隔符：如｀（）｛｝，；｀等2、设计状态转换图根据单词符号的定义，设计了相应的状态转换图，用于识别不同类型的单词符号。
例如，对于标识符的识别，从起始状态开始，当输入字符为字母或下划线时，进入标识符状态，继续输入字母、数字或下划线，直到遇到非标识符字符为止，此时到达终态，识别出一个标识符。
3、实现词法分析程序使用 Python 语言实现了基于状态转换图的词法分析程序。
程序首先读取输入的源程序文本，然后逐个字符进行处理，根据当前状态和输入字符进行状态转换，当到达终态时，输出识别出的单词符号及其编码。
4、进行测试编写了一些测试用例，包括包含各种单词符号的源程序代码。
运行词法分析程序对测试用例进行分析，检查输出结果是否正确。
词法分析实验报告(实验一)
词法分析实验报告（鲍小伟20032320）一．实验目的：通过设计、编程、调试出一个具体词法分析程序，加深对词法分析原理的理解，掌握其设计方法。
二．实验内容：用C/C++实现对PASCAL的子集程序设计语言的词法识别程序。
三．实验要求与原理：（1）实验要求：将该语言的源程序，即相应字符流转换成内部表示，并对标识符填写相应的符号表供编译程序以后各阶段使用，输出的单词符号格式为二元组（单词种别，单词在标识符表中的地址），标识符表格式有“序号”和“标识符本身的值”两项。
写出设计报告，内容为：状态转换图、单词符号及内部表示、符号表、出错处理、编程方法等。
（2）实验原理：状态转换图：空白8923单词符号及内部表示：标志符表和常数表：void getchar();//将下一输入字符读到ch中，指针后移一字符位置void getbc();//保证ch是一个非空白字符void concat();//将ch连接到字符串stroken的末尾void retract();//置ch为空白字符，指针前移一字符位置int isdigit();//判断是否整数int isletter();//首字母的判断int reserve();//对stroken进行关键字表的查找，返回其编码值int insertid();//将stroken中的标识符插入符号表，返回在符号表中的位置int insertconst();//将stroken中的常数插入常数表，返回在常数表中的位置四．主要源代码：Scanner::Scanner(char str[], int n) //构造函数{strcpy(buffer, str);length = n;i = j = 0;}int Scanner::isdigit()//判断是否整数{if(ch>='0' && ch<='9')return 1;elsereturn 0;}int Scanner::isletter()//首字母的判断{if((ch>='a' && ch<='z') || (ch>='A' && ch<='Z'))return 1;elsereturn 0;}void Scanner::getchar() //将下一输入字符读到ch中，指针后移一字符位置{ch = buffer[i];i++;}void Scanner::getbc() //保证ch是一个非空白字符{while(ch == ' ')getchar();}void Scanner::concat() //将ch连接到字符串stroken的末尾{strtoken[j] = ch;j++;}void Scanner::retract() //置ch为空白字符，指针前移一字符位置{ch = ' ';i--;}int Scanner::reserve() //对stroken进行关键字表的查找，返回其编码值{int i, flag = 0;for(i=0; i<15; i++){if( strncmp(reservechar[i],strupr(strtoken), j) == 0 ){flag = 1;break;}}if(flag == 1) return i+1;else return 0;}int Scanner::insertid() //将stroken中的标识符插入符号表，返回在符号表中的位置{for(int a = 0; a < m; a++)for(int b = 0; b < x[a]; b++)if( strncmp(&id[a][0], strtoken, j) == 0 ){return m+1;break;}for(a = 0; a < j; a++)id[m][a] = strtoken[a];x[m] = j;m++;return m;}int Scanner::insertconst() //将stroken中的常数插入常数表，返回在常数表中的位置{for(int i = 0; i < j; i++)cst[n][i] = strtoken[i];y[n] = j;n++;return n;}void Scanner::scan(){while(i < length){j = 0;int code, value;strcpy(strtoken, " "); //置strtoken为空串getchar();getbc();if(isletter()) //如果打头的是字母{while(isletter() || isdigit()){concat();getchar();}retract();code = reserve();if(code == 0) //如果扫描到的是标识符{value = insertid();cout<<"<34,"<<value<<">"<<'\n';}else cout<<"<"<<code<<",*>"<<'\n'; //如果扫描到的是关键字}else if(isdigit()) //如果打头的是数字{while(isdigit()){concat();getchar();}retract();value = insertconst();cout<<"<33,"<<value<<">"<<'\n';}else if(ch == '+')cout<<"<16,*>"<<'\n';else if(ch == '-')cout<<"<17,*>"<<'\n';else if(ch == '*')cout<<"<18,*>"<<'\n';else if(ch == '/')cout<<"<19,*>"<<'\n';else if(ch == '=')cout<<"<20,*>"<<'\n';else if(ch == '<'){getchar();if(ch == '>')cout<<"<21,*>"<<'\n';else if(ch == '=')cout<<"<23,*>"<<'\n';else{retract();cout<<"<22,*>"<<'\n';}}else if(ch == '>'){getchar();if(ch == '=')cout<<"<25,*>"<<'\n';else{retract();cout<<"<24,*>"<<'\n';}}else if(ch == '.')cout<<"<26,*>"<<'\n';else if(ch == ',')cout<<"<27,*>"<<'\n';else if(ch == ';')cout<<"<28,*>"<<'\n';else if(ch == ':'){getchar();if(ch == '=')cout<<"<30,*>"<<'\n';else{retract();cout<<"<29,*>"<<'\n';}}else if(ch == '(')cout<<"<31,*>"<<'\n';else if(ch == ')')cout<<"<32,*>"<<'\n';else if(ch == '{'){while(ch != '}')getchar();}else cout<<"出错！"<<'\n';}}void main(void){fstream file;file.open("F:/20032320/20032320.txt", ios::in||ios::nocreate); //以只读方式打开file.unsetf(ios::skipws); //不跳过文本中的空格char buffer[100]; //缓冲区定义cout<<"扫描结果如下所示"<<'\n';while(file.getline(buffer, 100)){Scanner SS(buffer, strlen(buffer));SS.scan();}cout<<"标识符表如下：\n"<<"编号\t"<<"值\n";for(int i=0; i<m; i++){cout<<i+1<<'\t';for(int j=0; j<x[i]; j++)cout<<id[i][j];cout<<'\n';}cout<<"常数表如下：\n"<<"编号\t"<<"值\n";for(i=0; i<n; i++){cout<<i+1<<'\t';for(int j=0; j<y[i]; j++)cout<<cst[i][j];cout<<'\n';}}五．运行结果：程序的运行结果如下图所示：。
词法分析~实验报告
词法分析~实验报告实验⼀、词法分析实验专业商业软件3班姓名陈笑璞学号 201506110218⼀、实验⽬的（1）编制⼀个词法分析程序（2）词法分析是编译的第⼀个阶段，主要任务是从左⾄右逐个字符地对源程序进⾏扫描，产⽣⼀个个单词序列，⽤于语法分析。
（3）通过词法分析的练习，能够进⼀步了解编译原理。
（4）通过了解词法分析程序的设计原则、单词的描述技术、识别机制及词法分析程序的⾃动构造原理。
⼆、实验内容和要求（1）输⼊：源程序字符串（2）输出：⼆元组（种别，单词符号本⾝）。
三、实验⽅法、步骤及结果测试实验⽅法、步骤：（1）对字符串表⽰的源程序（2）从左到右进⾏扫描和分解（3）根据词法规则（4）识别出⼀个⼀个具有独⽴意义的单词符号（5）以供语法分析之⽤（6）发现词法错误，则返回出错信息2、原理分析: 我的设计思路是利⽤链队列（好处：先进先出且不浪费存储空间）进⾏存储⽤户输⼊字符串，以回车键结束(其中必须以⾮数字结尾，否则程序出错)（这是我在后来的编程⾥遇到的问题，我知道问题出在哪⾥，但我现在还解决不了，因为我是通过申请⼦针域来存储，所以我是利⽤p->next来作为判断结束条件，如果以数字结束，那p->next指向未知领域，程序出错，同时这也是很危险的），然后我是利⽤出队列来判断，如果是字母存进数组⾥，直到下⼀个字符不是字母，调⽤函数判断数组的字符串，利⽤strcmp来判断，输出数组，再清空数组；void Print(char str[])//调⽤函数来判断关键字与标识符并输出{int i=0;if(strcmp(str,"begin")==0)printf("（1，'%s'）\n",str);else if(strcmp(str,"if")==0)printf("（2，'%s'）\n",str);else if(strcmp(str,"then")==0)printf("（3，'%s'）\n",str);else if(strcmp(str,"while")==0)printf("（4，'%s'）\n",str);else if(strcmp(str,"do")==0)printf("（5，'%s'）\n",str);else if(strcmp(str,"end")==0)printf("（6，'%s'）\n",str);else{if(str[0]=='\0')return;printf("（10，'%s'）\n",str);}memset(str,0,N);//清空数组str⾥的所有元素}结果测试：四、实验总结说实话，通过这次的编译原理词法分析的实验，我遇到了不少问题，也学到了不少的东西，因为这次实验我是想⽤我⾃⼰的想法来编写程序，我是⽤链队列来存储字符串的，也许⽤数组来存储字符串会简单点，但我不想，我还是想利⽤链队列来存储字符串，这样可以节约存储空间，还可以利⽤队列先进先出的特点，不好就是利⽤队列不够灵活，每次都要出栈判断、存储，释放p的⼦针域；虽然在编写过程中，遇到不少问题，遇到⼀个，就想办法解决⼀个，通过问朋友⽼师等，也通过发朋友圈问，还通过发博客来问⼤神们，这种途径是最有效的，也是最好的；所以每次就差⼀点就做好了，⼜会遇到⼀个新的问题，就要想办法去解决它，如今除了字符串是以数字结尾会出现问题外（暂时没找到好的⽅法），其他问题已解决。
编译原理实验报告 词法分析
编译原理实验一·词法分析一、实验目的通过动手实践，使学生对构造编译系统的基本理论、编译程序的基本结构有更为深入的理解和掌握；使学生掌握编译程序设计的基本方法和步骤；能够设计实现编译系统的重要环节。
同时增强编写和调试程序的能力。
二、实验内容及要求对某特定语言A ，构造其词法规则。
该语言的单词符号包括：保留字(见左下表)、标识符（字母大小写不敏感）、整型常数、界符及运算符(见右下表) 。
功能要求如下所示：·按单词符号出现的顺序，返回二元组序列，并输出。
·出现的标识符存放在标识符表，整型常数存放在常数表，并输出这两个表格。
·如果出现词法错误，报出：错误类型，位置（行，列）。
·处理段注释（/* */），行注释（//）。
·有段注释时仍可以正确指出词法错误位置（行，列）。
三、实验过程1、词法形式化描述使用正则文法进行描述，则可以得到如下的正规式:其中ID表示标识符，NUM表示整型常量，RES表示保留字，DEL表示界符，OPR表示运算符。
A→(ID | NUM | RES | DEL | OPR) *ID→letter(letter | didit)*NUM→digit digit*letter→a | …| z | A | …| Zdigit→0 | …| 9RES→program | begin | end | var | int | and | or | not | if | then | else | while | doDEL→( | ) | . | ; | ,OPR→+ | * | := | > | < | = | >= | <= | <>如果关键字、标识符和常数之间没有确定的算符或界符作间隔，则至少用一个空格作间隔。
空格由空白、制表符和换行符组成。
2、单词种别定义；3、状态转换图；语言A的词法分析的状态转换图如下所示：空格符，制表符或回车符字母或数字4、运行环境介绍；本次实验采用win-tc进行代码的编写和编译及运行程序的运行环境为windows5、关键算法的流程图及文字解释；程序中用到的函数列表：变量ch储存当前最新读进的字符的地址strToken存放当前字符串voidmain（） //主函数struct binary *lexicalAnalyze(); //词法分析的主函数，返回一个二元组的指针void GetBC(); //检查ch指向的字符是否为空格、制表或回车符，如果是则调用GetChar（）直至不是上述字符void GetChar(); //ch前移一个地址单元int ConCat(); //将ch指向的字符连接到strToken之后int isLetter(); //判断ch指向的字符是否字母int isDigit(); //判断ch指向的字符是否数字int insertId(); //向标识符表中插入当前strToken的字符串int insertConst(); //将strToken的常数插入常数表中int Reserved(); //检测当前strToken中的字符串是否保留字,若是,则返回编码,否则返回0int isId(); //检测当前strToken中的字符串是否在标识符表中已存在,若是,则返回其编号,否则返回0int isConst(); //检测当前strToken中的字符串是否在常数表中已存在,若是,则返回其编号,否则返回0void errProc(int errType); //出错处理过程,errType是错误类型,将错误信息加入错误表中main（）函数的流程图如下:lexicalAnalyze（）函数的流程图如下所示：Reserved()、isId()和isConst()函数均采用了对链表的遍历算法，errProc()函数通过识别不同的错误编号，向错误链表中添加相应的错误信息。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
编译原理词法分析实验报告软工082班兰洁200831104044一、实验内容二、实验目的三、实验预期四、程序规定五、实验原理●程序流程图●判别浮点功能扩展流程图●状态转换图六、程序代码与浮点判别功能扩展七、测试用例●扩展功能测试用例；●普通功能测试用例八、输出结果九、实验心得一、实验内容：词法分析：1、识别简单语言的单词符号；2、识别关键字、标识符、数字、运算符等。
并扩展浮点识别功能。
二、实验目的调试词法分析程序，加深对词法分析原理的理解，掌握编写简单词法分析程序的一般步骤。
三、实验预期结果：经过调试源代码程序，程序能够成功运行编译，对输入的简单字符串，能够别关键字、标识符、数字、运算符等，并且给出单词符号的对应编码。
四、程序规定：1、关键字："function","if","then","while","do","endfunc"；2、算术运算符：”+”,”-”,”*”,”/”,”=”；3、关系运算符："<" ">" "<=" ">=" "==" "!="；4、界符："(" ")" ";" "#"；5、标识符规定以字母开头,字母均为小写；6、空格和换行符跳过；7、单词对应编码：十、实验原理：输入串--------------------〉词法分析程序————————〉单词符号串输入：字符串以#结束。
输出：单词的二元组(syn，token/sum)程序流程图分析浮点数功能扩展部分流程图：shuzi()函数状态转换图六、程序代码：备注：红色字体部分为程序功能的功能扩展，使程序能够分析浮点数！我把浮点数的syn设置为80！/*词法分析源代码*/#include<stdio.h>#include<string.h>scaner();char prog[80],token[8];char ch;int syn,p,m,n,sum;char * rwtab[6]={"function","if","then","while","do","endfunc"}; int i=0,k,c,sumint,f;char fenshu[80],sum1[80];double sumf=0,fudian;int shuzi(){if(ch>='0' && ch<='9')syn=80;elsesyn=-2;return syn;}main(){p=0;printf("\n please input string :\n");do{scanf("%c",&ch);prog[++p]=ch;}while(ch!='#');p=0;do{scaner();switch(syn){ case 11:printf("\n(%d,%d)",syn,sum);break;case -1:printf("\n error");break;case 80:printf("\n(%d,%f)",syn,fudian);break; default:printf("\n(%d,%s)",syn,token);}}while(syn!=0);}scaner(){for(n=0;n<8;n++)token[n]=NULL;//if(1+2!=3)ch=prog[++p];while(ch==' ' || ch=='\n')ch=prog[++p];//跳过空格if(ch>='a' && ch<='z'){m=0;while(ch>='a' && ch<='z' || ch>='0' && ch<='9') {token[m++]=ch;//token[0]=f,m=1ch=prog[++p];}token[m]='\0';ch=prog[--p];syn=10;for(n=0;n<6;n++){if(strcmp(token,rwtab[n])==0){syn=n+1;break;}}}elseif(ch>='0' && ch<='9'){c=p;k=0;do{ sum1[k]=ch;ch=prog[++c]; //ch取后一个数字k++;shuzi();//这个函数用来分析浮点数的整数部分是否已经输入到数组里f=syn;} while(f==80)if(ch=='.'){for(n=0;n<k;n++){sumint=sumint*10+sum1[n]-'0';} //计算整数部分i=0;do{ch=prog[++c];fenshu[i]=ch;i++;shuzi();//这个函数用来分析浮点数的小数部分是否已经输入到数组里} while(syn==80);sumf=0;for(k=i-2;k>=0;k--){sumf=sumf*0.1+(fenshu[k]-'0')*0.1;} //计算浮点数的小数部分fudian=sumint+sumf; //浮点数计算syn=80;p=--c;}else{ch=prog[p];//若是整数，ch等于原来的值 sum=0;while(ch>='0' && ch<='9'){sum=sum*10+ch-'0';ch=prog[++p];}ch=prog[--p];syn=11;}}elseswitch(ch){case'<':m=0;token[m++]=ch;ch=prog[++p];if(ch=='='){syn=22;token[m++]=ch;}elseif(ch=='>'){syn=21;token[m++]=ch;}else{syn=20;ch=prog[--p];}break;case'>':m=0;token[m++]=ch;ch=prog[++p];if(ch=='='){syn=24;token[m++]=ch;}else{syn=23;ch=prog[--p];}break;case'=':m=0;token[m++]=ch;ch=prog[++p];if(ch=='='){syn=25;token[m++]=ch;}else{syn=18;ch=prog[--p];}break;case'!':m=0;token[m++]=ch;ch=prog[++p];if(ch=='='){syn=22;token[m++]=ch;}else{syn=-1;p--;}break;case'+':syn=13;token[0]=ch;break;case'-':syn=14;token[0]=ch;break;case'*':syn=15;token[0]=ch;break;case'/':syn=16;token[0]=ch;break;case';':syn=26;token[0]=ch;break;case'(':syn=27;token[0]=ch;break;case')':syn=28;token[0]=ch;break; case'#':syn=0;token[0]=ch;break;default:syn=-1;}}七、测试用例：补充：功能扩展测试用例：(80,2.300000)(0,#)(18,=)(80,3.300000)(0,#)八、程序输出结果：功能扩展测试用例输出结果用例一：用例二：用例三：普通功能测试用例显示结果九、实验心得通过编译原理实验一词法分析实验，使得自己对词法分析的流程有了更深刻的了解，虽然源代码并非由自己设计，但是在调试程序的过程中，尤其是进行测序功能扩展的过程中，想了很多种办法，终于找到了最合适的方法，而且还进行了代码的优化，这个过程虽然有时有些枯燥，但是更多时候是欣喜的，不仅复习了c语言的许多内容，并且有了更深的理解。
很好的理解了程序的思想，理清了词法分析程序的思路。
从一开始对程序的陌生，到后来逐步了解程序的流程，当我耐心的一步一步理解程序思想，一次次的更改测试用例，一遍遍的调试，最终终于得到了预期的答案。
这次实验使我对理论的词法分析的理解更加具体清晰，收获很大。