词法编译器报告
编译技术实验报告词法(3篇)
第1篇一、实验目的本次实验旨在通过实践加深对编译技术中词法分析阶段的理解，掌握词法分析的基本原理和方法，能够实现一个简单的词法分析器，并对源代码进行初步的符号化处理。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse IDE4. 实验素材：实验提供的C语言源代码三、实验原理词法分析是编译过程中的第一个阶段，其主要任务是将源代码中的字符序列转换成一系列的词法单元（Token）。
词法单元是构成源程序的基本单位，如标识符、关键字、运算符等。
词法分析的基本原理如下：1. 字符流：从源代码中逐个读取字符，形成字符流。
2. 状态转换：根据字符流中的字符，在有限状态自动机（FSM）中转换状态。
3. 词法单元生成：当状态转换完成后，生成对应的词法单元。
4. 错误处理：在分析过程中，如果遇到无法识别的字符或状态，进行错误处理。
四、实验步骤1. 设计词法分析器：根据C语言的语法规则，设计有限状态自动机，定义状态转换图。
2. 实现状态转换函数：根据状态转换图，实现状态转换函数，用于将字符流转换为词法单元。
3. 实现词法单元生成函数：根据状态转换结果，生成对应的词法单元。
4. 测试词法分析器：使用实验提供的C语言源代码，测试词法分析器的正确性。
五、实验结果与分析1. 词法分析器设计：根据C语言的语法规则，设计了一个包含26个状态的状态转换图。
状态转换图包括以下状态：- 初始状态：用于开始分析。
- 标识符状态：用于分析标识符。
- 关键字状态：用于分析关键字。
- 运算符状态：用于分析运算符。
- 数字状态：用于分析数字。
- 字符串状态：用于分析字符串。
- 错误状态：用于处理非法字符。
2. 状态转换函数实现：根据状态转换图，实现了状态转换函数。
该函数用于将字符流转换为词法单元。
3. 词法单元生成函数实现：根据状态转换结果，实现了词法单元生成函数。
该函数用于生成对应的词法单元。
编译原理词法分析实验报告
编译原理词法分析实验报告实验名称:词法分析器的设计与实现一、实验目的：1.熟悉编译原理中词法分析的基本概念和原理；2.掌握正则表达式的使用方法；3.实现一个简单的词法分析器。
二、实验内容：1.设计一个简单的编程语言，包含如下几种类型的词法单元：关键字、标识符、常量、运算符和界符。
2.使用正则表达式定义每种词法单元的模式。
3.设计一个词法分析器，将源代码中的每个词法单元识别出来并输出。
三、实验步骤：1. 确定编程语言的词法单元类型和正则表达式模式，定义相应的单词类型（如 TokenType）和模式（如 regex）。
2. 实现一个词法分析器的类 Lexer，包含以下方法：(1)一个构造方法，用于初始化词法分析器的输入源代码。
(2) 一个getNextToken方法，用于获取源代码中的下一个词法单元。
3. 在getNextToken方法中，使用正则表达式逐个识别源代码中的词法单元，并返回相应的Token对象。
4. 设计一个Token类，包含以下属性：词法单元类型、词法单元的值和位置信息等。
5.在主程序中使用词法分析器，将源代码中的每个词法单元识别出来并输出。
四、实验结果：1.设计一个简单的编程语言，包含如下词法单元类型（示例）：(1) 关键字：if、else、while、for等；(2)标识符：变量名等；(3)常量：整数、浮点数、字符串等；(4)运算符：+、-、*、/、=等；(5)界符：(、)、{、}、;等。
2. 实现一个词法分析器，识别出源代码中的每个词法单元，并输出相应的Token对象。
五、实验总结：通过本次实验，我熟悉了编译原理中词法分析的基本概念和原理，并掌握了正则表达式的使用方法。
我成功完成了一个简单的词法分析器的设计与实现，实现了源代码中每个词法单元的识别与输出。
这次实验对我深化了对编译原理中词法分析的理解，并提高了我的编程能力。
编译实验词法分析
词法分析器实验报告院系：专业：小组成员：学号：日期：一、实验的目的与任务词法分析的目的是将输入的源程序进行划分，给出基本符号（token）的序列，并掠过注解和空格等分隔符号。
基本符号是与输入的语言定义的词法所规定的终结符。
本实验要求学生编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续进行）。
二、实验所要识别的单词分类1．关键字。
*key[53]={ "auto", "bool", "break", "case", "catch", "char", "class", "const", "continue", "default", "delete", "do", "double", "else", "enum", "extern", "false", "float", "for", "friend", "goto", "if", "inline", "int", "long", "namespace", "new", "operator", "private","protected", "public", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch","template", "this", "throw", "true", "try", "typedef", "typename", "union", "unsigned", "using", "virtual", "void", "volatile", "while"};2．标识符。
编译原理实验词法分析实验报告
编译原理实验词法分析实验报告一、实验目的词法分析是编译过程的第一个阶段，其主要任务是从左到右逐个字符地对源程序进行扫描，产生一个个单词符号。
本次实验的目的在于通过实践，深入理解词法分析的原理和方法，掌握如何使用程序设计语言实现词法分析器，提高对编译原理的综合应用能力。
二、实验环境本次实验使用的编程语言为_____，开发工具为_____。
三、实验原理词法分析的基本原理是根据编程语言的词法规则，将输入的字符流转换为单词符号序列。
单词符号通常包括关键字、标识符、常量、运算符和界符等。
词法分析器的实现方法有多种，常见的有状态转换图法和正则表达式法。
在本次实验中，我们采用了状态转换图法。
状态转换图是一种有向图，其中节点表示状态，有向边表示在当前状态下输入字符的可能转移。
通过定义不同的状态和转移规则，可以实现对各种单词符号的识别。
四、实验步骤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.1 编译器的基本原理编译器主要由两个阶段组成：前端和后端。
前端负责将源代码转换为中间代码，后端则将中间代码转换为目标机器代码。
1.2 词法分析词法分析是编译器的第一个阶段，它将源代码分解为一个个词法单元，如标识符、关键字、运算符等。
词法分析器通过正则表达式和有限自动机来实现。
1.3 语法分析语法分析是编译器的第二个阶段，它将词法单元按照语法规则组织成语法树。
语法分析器通常使用上下文无关文法和递归下降分析来实现。
二、实验设计2.1 实验目标本次实验的目标是设计一个简单的编译器，能够将一种自定义的高级语言转换为目标机器代码。
我们选取了一种类C语言的语法作为实验对象。
2.2 实验流程首先，我们需要编写词法分析器，将源代码分解为词法单元。
然后，我们使用语法分析器将词法单元组织成语法树。
接下来，我们需要进行语义分析，检查代码是否符合语义规则。
最后，我们将中间代码转换为目标机器代码。
三、实验过程3.1 词法分析在词法分析阶段，我们使用正则表达式和有限自动机来实现词法分析器。
我们定义了一系列正则表达式来匹配不同的词法单元，如标识符、关键字、运算符等。
通过扫描源代码，词法分析器能够将源代码分解为一个个词法单元。
3.2 语法分析在语法分析阶段，我们使用上下文无关文法和递归下降分析来实现语法分析器。
我们定义了一系列文法规则来描述语法结构，如函数声明、条件语句、循环语句等。
语法分析器能够将词法单元组织成语法树。
3.3 语义分析在语义分析阶段，我们检查代码是否符合语义规则。
例如，我们检查变量是否声明过、函数是否调用正确等。
如果发现错误，我们将生成错误信息并终止编译过程。
3.4 代码生成在代码生成阶段，我们将中间代码转换为目标机器代码。
词法分析器实验报告
词法分析器实验报告词法分析器实验报告一、引言词法分析器是编译器中的重要组成部分，它负责将源代码分解成一个个的词法单元，为之后的语法分析提供基础。
本实验旨在设计和实现一个简单的词法分析器，以深入理解其工作原理和实现过程。
二、实验目标本实验的目标是设计和实现一个能够对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一、题目：词法分析器二、运行环境：JAVA jdk1.6.0_21三、设计思路：编译程序的工作过程一般划分为五个阶段：词法分析、语法分析、语义分析与中间代码产生、优化、目标代码生成。
作为本次课程设计的词法分析器的主要任务是，对输入的源程序字符串进行扫描和分解，识别出一个个的单词，如基本字(include、if、while、for等)，标识符、常数、算符和界符。
本次课程设计词法分析我选取的目标语言为C语言。
关于种别码的分配，我对关键字采用一字一种，对运算符采用一符一种，对界符采用一符一种，整型常量为一种，浮点常量为一种，字符常量为一种，字符串常量为一种。
(详情参加附录1)本次词法分析器工作的第一步是输入源程序文本。
通过调用预处理子程序去除程序两端多余的空格、注释，再将处理得到的串存放在一个缓冲区中。
第二步是对关键字、标示符、数字以及算符和界符的识别过程，并返回识别出的单词的种别码和内容（单词值，种别码），在过程中进行必要的出错处理。
第三步即将所识别出来的单词及种别码输出到文件保存。
四、基本工具UML及JAVA语言五、状态转换图：六、程序源码：import java.util.ArrayList;import java.io.*;//记法分析器类class Lex{char ch[] = new char[300];String token;int flag;ArrayList<String> buffer = new ArrayList<String>();ArrayList<String> errorqueue = new ArrayList<String>();ArrayList<String> queue = new ArrayList<String>();int buffer_current,buffer_advance,index_queue,index_error,line,buffersize;public Lex(){buffer_current=buffer_advance=index_queue=index_error = buffersize = 0;line = 1;flag = 0;}//判断是否为字母public boolean isletter(char cc){if ((cc>='a'&&cc<='z')||(cc>='A'&&cc<='Z')){return true;}else{return false;}}//判断是否为数字public boolean isdigit(char cc){if (cc>='0'&&cc<='9'){return true;}else{return false;}}//预处理子程序，读入源程序,并装入bufferpublic void prepare(){int k ;String sub;try{FileReader filein = new FileReader("in.txt");filein.read(ch);String str = new String(ch);k = 0;while(k<300){buffer.add(sub);buffersize++;k++;filein.close();}}catch (Exception e){String err = e.toString();System.out.println(err);}}//result_out函数将所有识别了的单词输出到文件out.txt public void result_out(){int k;if (index_queue == 0){System.out.println("The queue is empty!");return;}try{FileWriter fileout = new FileWriter("out.txt");fileout.write("\t符号(值)\t种别码\n");for (k =0; k<index_queue ; k++ ){fileout.write(queue.get(k));}fileout.close();}catch (Exception e){String err = e.toString();System.out.println(err);}}//error_out函数将所有识别了的错误情形输出到文件error.txtpublic void error_out(){int k;if (index_error == 0){System.out.println("The errorqueue is empty!");return;}try{FileWriter errorout = new FileWriter("error.txt");for (k =0; k<index_error ; k++ ){errorout.write(queue.get(k));}errorout.close();}catch (Exception e){String err = e.toString();System.out.println(err);}}//判断是否为保留字public int isreserve(String s){String str[] = {"define","include","char","double","enum","float","int","long","short","signed","struct","union","unsigned","void","for","do","while","break","continue","if", "else","goto","switch","case","default","return","auto","extern","register","static","const","sizeof","typedef","volatile"};int k;for ( k =0 ; k < 34 ; k++ ){if (str[k].equals(s)){return (k+4);}}return 0;}//往queue队列添加一个新识别的单词public void insert_queue(String s){queue.add(s);index_queue++;}//往errorqueue队列添加一个新发现的错误public void insert_error(String s){errorqueue.add(s);index_error++;}//读掉空格public void space(){String s;do{s = queue.get(buffer_advance);if (s.equals(" ")){if (buffer_advance+1 == buffersize){flag = 1;return;}buffer_advance++;}else{break;}}while(true);buffer_current = buffer_advance;}// 读掉形如的//.... \n 注释public void comment1(){String s;do{s = queue.get(buffer_advance);if (s.equals("\n")){line++;break;}{if (buffer_advance+1 == buffersize){flag = 1;return;}buffer_advance++;}}while(true);buffer_current = buffer_advance;}// 读掉形如的/*.... */ 注释public void comment2(){String s1,s2;do{s1 = queue.get(buffer_advance);s2 = queue.get(buffer_advance+1);if (s1.equals("\n")){buffer_advance++;line++;}else if (s1.equals("*")&&s2.equals("/")){buffer_advance = buffer_advance + 2;break;}else{if (buffer_advance+1 == buffersize){flag = 1;return;}buffer_advance++;}}while(true);buffer_current = buffer_advance;}//实现单词识别public void dfa(){int flag2;String s1,s2;prepare();while ( flag == 0 ){flag2 = 0;token = "";//存放识别出来的单词space();do{s1 = queue.get(buffer_advance);s2 = queue.get(buffer_advance+1);if (s1.equals("/")&&s2.equals("/")){if (buffer_advance+2 == buffersize){flag = 1;break;}buffer_advance = buffer_advance+2;comment1();}else if (s1.equals("/")&&s2.equals("*")){if (buffer_advance+2 == buffersize){flag = 1;break;}buffer_advance = buffer_advance+2;comment2();}else if (s1.equals("\n")){if (buffer_advance+1 == buffersize){flag = 1;break;}buffer_advance++;line++;}else{break;}space();}while (true);//下面是数值常量识别主要是实数和整数的识别if (isdigit(s1.charAt(0))){flag2 = 2;token = token + s1;buffer_advance++;s1 = buffer.get(buffer_advance);while (isdigit(s1.charAt(0))){token = token + s1;if (buffer_advance+1 != buffersize){buffer_advance++;s1 = buffer.get(buffer_advance);}else{insert_queue("\t"+token+"\t2\n");break;}}/*如果数字后碰到小数点，小数点后不是数字，则要捕捉错误异常;如果还是数字，则和上面的方法一样，将一串数字连为一个实数*/if(s1.equals(".")){flag = 3;token = token + s1;buffer_advance++;s1 = buffer.get(buffer_advance);if (!isdigit(s1.charAt(0))){insert_error("\n程序第("+line+")行有错误错误单词为："+token+"\n");continue;}while (isdigit(s1.charAt(0))){token = token + s1;if (buffer_advance+1 != buffersize){buffer_advance++;s1 = buffer.get(buffer_advance);}else{insert_queue("\t"+token+"\t3\n");break;}}}//如果碰到科学计数法中的e，要取出它面的符号，然后再取出数值部分if (s1.equalsIgnoreCase("e")){token = token + s1;buffer_advance++;if (buffer_advance!= buffersize){s1 = buffer.get(buffer_advance);}else{insert_queue("\t"+token+"\t3\n");break;}if (s1.equals("-")){token = token + s1;buffer_advance++;if (buffer_advance != buffersize){s1 = buffer.get(buffer_advance);}else{insert_error("\n程序第("+line+")行有错误错误单词为："+token+"\n");break;}}else if (s1.equals("+")){token = token + s1;buffer_advance++;if (buffer_advance != buffersize){s1 = buffer.get(buffer_advance);}else{insert_error("\n程序第("+line+")行有错误错误单词为："+token+"\n");break;}}if (!isdigit(s1.charAt(0))){insert_error("\n程序第("+line+")行有错误错误单词为："+token+"\n");continue;}while (isdigit(s1.charAt(0))){flag = 3;token = token + s1;buffer_advance++;if (buffer_advance != buffersize){s1 = buffer.get(buffer_advance);}else{insert_queue("\t"+token+"\t3\n");continue;}}}//科学eif(flag == 2){insert_queue("\t"+token+"\t2\n");continue;}if(flag == 3){insert_queue("\t"+token+"\t3\n");continue;}}//数字识别//下面是标志符及保留字识别if (isletter(s1.charAt(0))||s1.charAt(0)=='_'){token = token +s1;int t;do{buffer_advance++;if (buffer_advance!=buffersize){s1 = buffer.get(buffer_advance);}else{break;}if (isletter(s1.charAt(0))||s1.charAt(0)=='_'||isdigit(s1.charAt(0))){token = token +s1;}else{break;}}while (true);if ((t = isreserve(token))!=0){insert_queue("\t"+token+"\t"+t+"\n");}else{insert_queue("\t"+token+"\t71\n");}continue;}// if (isletter(s1.charAt(0))||s1.charAt(0)=='_')//下面是识别字符常量如'a'if (s1.charAt(0) == '\''){token = token + s1;if (buffer_advance +2>=buffersize){insert_error("\n程序第("+line+")行有错误错误单词为："+token+"\n");continue;}else{buffer_advance++;s1 = buffer.get(buffer_advance);token = token + s1;}s2 = buffer.get(buffer_advance);if (s2.charAt(0)== '\''){token = s1;buffer_advance++;insert_queue("\t"+token+"\t0\n");}else{insert_error("\n程序第("+line+")行有错误错误单词为："+token+"\n");}continue;}// 下面是识别字符串常量if (s1.charAt(0) == '\"'){do{buffer_advance++;s1 = queue.get(buffer_advance);if (s1.equals("\"")){insert_queue("\t"+token+"\t1\n");buffer_advance++;break;}else{if (buffer_advance+1 == buffersize){insert_error("\n程序第("+line+")行有错误错误单词为："+token+"\n");flag = 1;break;}token = token + s1;}}while(true);continue;}//下面是识别运算符+ 或++if (s1.charAt(0)=='+'){token =token + s1;buffer_advance++;{insert_queue("\t+"+"\t38\n");break;}else{s1 = buffer.get(buffer_advance);if (s1.equals("+")){buffer_advance++;insert_queue("\t++"+"\t46\n");}else{insert_queue("\t+"+"\t38\n");}}continue;}//下面是识别运算符- 或-- 或->if (s1.charAt(0)=='-'){token =token + s1;buffer_advance++;if (buffer_advance == buffersize){insert_queue("\t-"+"\t39\n");break;}else{s1 = buffer.get(buffer_advance);if (s1.equals("-")){buffer_advance++;insert_queue("\t--"+"\t47\n");}else if (s1.equals(">")){buffer_advance++;insert_queue("\t->"+"\t68\n");}else{}}continue;}//下面是识别运算符* 或者**if (s1.charAt(0)=='*'){token =token + s1;buffer_advance++;if (buffer_advance == buffersize){insert_queue("\t*"+"\t40\n");break;}else{s1 = buffer.get(buffer_advance);if (s1.equals("*")){buffer_advance++;insert_queue("\t**"+"\t50\n");}else{insert_queue("\t*"+"\t40\n");}}continue;}//下面是识别运算符/if (s1.charAt(0)=='/'){insert_queue("\t/"+"\t41\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别运算符& 或者&&if (s1.charAt(0)=='&'){token =token + s1;if (buffer_advance == buffersize){insert_queue("\t&"+"\t42\n");break;}else{s1 = buffer.get(buffer_advance);if (s1.equals("&")){buffer_advance++;insert_queue("\t&&"+"\t48\n");}else{insert_queue("\t&"+"\t42\n");}}continue;}//下面是识别运算符| 或者||if (s1.charAt(0)=='|'){token =token + s1;buffer_advance++;if (buffer_advance == buffersize){insert_queue("\t|"+"\t43\n");break;}else{s1 = buffer.get(buffer_advance);if (s1.equals("|")){buffer_advance++;insert_queue("\t||"+"\t49\n");}else{insert_queue("\t|"+"\t43\n");}}continue;//下面是识别运算符! 或者!=if (s1.charAt(0)=='!'){token =token + s1;buffer_advance++;if (buffer_advance == buffersize){insert_queue("\t!"+"\t44\n");break;}else{s1 = buffer.get(buffer_advance);if (s1.equals("=")){buffer_advance++;insert_queue("\t!="+"\t54\n");}else{insert_queue("\t!"+"\t44\n");}}continue;}//下面是识别运算符%if (s1.charAt(0)=='%'){insert_queue("\t%"+"\t45\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别运算符> 或者>=if (s1.charAt(0)=='>'){token =token + s1;buffer_advance++;if (buffer_advance == buffersize){insert_queue("\t>"+"\t51\n");}else{s1 = buffer.get(buffer_advance);if (s1.equals("=")){buffer_advance++;insert_queue("\t>="+"\t56\n");}else{insert_queue("\t>"+"\t51\n");}}continue;}//下面是识别运算符< 或者<=if (s1.charAt(0)=='<'){token =token + s1;buffer_advance++;if (buffer_advance == buffersize){insert_queue("\t<"+"\t52\n");break;}else{s1 = buffer.get(buffer_advance);if (s1.equals("=")){buffer_advance++;insert_queue("\t<="+"\t57\n");}else{insert_queue("\t<"+"\t52\n");}}continue;}//下面是识别运算符= 或者==if (s1.charAt(0)=='='){buffer_advance++;if (buffer_advance == buffersize){insert_queue("\t="+"\t53\n");break;}else{s1 = buffer.get(buffer_advance);if (s1.equals("=")){buffer_advance++;insert_queue("\t=="+"\t55\n");}else{insert_queue("\t="+"\t53\n");}}continue;}//下面是识别界符(if (s1.charAt(0)=='('){insert_queue("\t("+"\t58\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符)if (s1.charAt(0)==')'){insert_queue("\t)"+"\t59\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符#insert_queue("\t#"+"\t60\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符;if (s1.charAt(0)==';'){insert_queue("\t;"+"\t61\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符,if (s1.charAt(0)==','){insert_queue("\t,"+"\t62\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符:if (s1.charAt(0)==':'){insert_queue("\t:"+"\t63\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符{insert_queue("\t{"+"\t64\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符}if (s1.charAt(0)=='}'){insert_queue("\t}"+"\t65\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符[if (s1.charAt(0)=='['){insert_queue("\t["+"\t66\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符]if (s1.charAt(0)==']'){insert_queue("\t]"+"\t67\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}//下面是识别界符.if (s1.charAt(0)=='.')insert_queue("\t."+"\t69\n");buffer_advance++;if (buffer_advance == buffersize){break;}continue;}}//while(flag == 1)if (index_queue>0){result_out();}if (index_error>0){error_out();}}}public class startLex{public static void main ( String args[] ){Lex l = new Lex();l.dfa();}}七、运行结果：运行前源程序存放在in.txt中，如图(1)所示，运行后得到的识别单词结果存放在out.txt中，如图(2)所示，识别过程中发现的错误存放在error.txt中，如图(3)所示。
编译原理报告—词法分析器
词法分析器的作用词法分析是编译的第一阶段。
词法分析器的主要任务是读入源程序的输入字符，将它们组成词素，生成并输出一个词法单元序列，这个词法单元序列被输出到语法分析器进行语法分析。
另外，由于词法分析器在编译器中负责读取源程序，因此除了识别词素之外，它还会完成一些其他任务，比如过滤掉源程序中的注释和空白，将编译器生成的错误消息与源程序的位置关联起来等。
总而言之，词法分析器的作用如下：1.读入源程序的输入字符，将它们组成词素，生成并输出一个词法单元序列；2.过滤掉源程序中的注释和空白；3.将编译器生成的错误消息与源程序的位置关联起来；4.其它。
词法分析过程首先，对某个正则语言L，构造能够描述其的正则表达式r；然后，需要将r 转换成一个有穷自动机。
这里有三种方法，一是直接转换成NFA，而是直接转换成DFA，三是先转换成NFA，再把NFA 转换成DFA；最后，如果将r 转换成了一个DFA，需要将此DFA 的状态数最小化。
正则表达式正则表达式可以用来描述词素的模式，一个正则表达式可以由较小的正则表达式递归的构建。
对于符号集合∑={a，b}，有：-正则表达式a 表示语言{a}；-正则表达式a|b 表示语言{a，b}；-正则表达式(a|b)(a|b)表示语言{aa，ab，ba，bb}；-正则表达式a*表示语言{ε，a，aa，aaa，…}；-正则表达式(a|b)*表示语言{ε，a，b，aa，ab，ba，bb，aaa，…}；-正则表达式a|a*b 表示语言{a，b，ab，aab，aaab，…}。
上面通过基本的并、连接和闭包运算递归定义了正则表达式有穷自动机一个有穷自动机可以把一个描述词素的模式变成一个词法分析器，从本质上来讲，有穷自动机是与状态转换图相类似的图，它有以下特点：有穷自动机是一个识别器，它只能对每个输入符号串简单的输出“yes”或“no”，表示是否能够识别此符号串；有穷自动机和状态转换图类似，它具有有限个数的结点，每个结点表示一个状态，并且这些状态中有一个初始状态和若干个终止状态。
编译原理实验报告——词法分析器(内含源代码)
编译原理实验（一）——词法分析器一．实验描述运行环境：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置为空白字符。
编译原理词法分析报告
实验一：词法分析一、实验目的：1、通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
2、编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本关键字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续显示）二、实验预习提示1、词法分析器的功能和输出格式词法分析器的功能是输入源程序，输出单词符号。
词法分析器的单词符号常常表示成以下的二元式(单词种别码，单词符号的属性值)。
本实验中，采用的是一类符号一种别码的方式。
2、单词的BNF表示<标识符>-> <字母><字母数字串><字母数字串>-><字母><字母数字串>|<数字><字母数字串>|<下划线><字母数字串>|ε<无符号整数>-> <数字><数字串><数字串>-> <数字><数字串> |ε<加法运算符>-> +<减法运算符>->-<大于关系运算符>->><大于等于关系运算符>-> >=3、“超前搜索”方法词法分析时，常常会用到超前搜索方法。
如当前待分析字符串为“a>+”,当前字符为’>’，此时，分析器到底是将其分析为大于关系运算符还是大于等于关系运算符呢？显然，只有知道下一个字符是什么才能下结论。
于是分析器读入下一个字符’+’，这时可知应将’>’解释为大于运算符。
但此时，超前读了一个字符’+’，所以要回退一个字符，词法分析器才能正常运行。
在分析标识符，无符号整数等时也有类似情况。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
单词分类
保留字：
if|then|else|int|float|double|bool|char|printf|scanf|return|main|while|do|for|struct|void|break|const|static|auto|short|long|union|enum|typedef|unsigned|signed|extern|register|volatile|switch|case|goto|continue|default|sizeof|include
标识符：[a-z_A-Z][a-来自_A-Z0-9]*常量：
1）字符串常量：\"[^"\n]+\"
2）整型常量：([-+]?[1-9][0-9]*)|0
3）浮点常量：[-+]?[0-9]*\.[0-9]+
4）字符常量：\'[^'\n]+\'
特殊符号：
([\=\+\-\*\/\&\!\|\%\.])|([\+\-\*\/\%\<\>\=][=])
限界符：
[\{\}\[\]\(\)\,\;]
注释判断：
\/\/[^\n]*\n
\/\*(.)*\*\/
利用yylineno来记录程序分析时所在行号，yytext记录当前正在分析的串；
Analyse.l文件编写思路：
当遇到上述分类中的匹配就输出对于行号和正在分析的串，当遇到空格、Tab及注释就直接跳过；没遇到一次’\n’则yylineno就增加1，如果都没有匹配成功则最后可以输出该字符不是C语言字符集里面的符号。
编译原理——C语言词法分析器
学号
21131603
姓名
黎红波
1、实验内容与要求
基于C语言的字符集，编写C语言的词法分析器；
要求能检查出输入程序中的不合法字符，输出该非法字符并显示所在行号；
要求输出词法分析后的结果，并显示对应Token所在程序中的行号；
要求能够过滤掉注释内容；
2、实验方法
利用flex工具进行分词，写出各种单词分类的正则表达式，利用flex工具自带的功能在linux下通过编写.l文件生成相应具有C语言词法分析功能的程序；
}
测试截图如下：
5、不足
1、程序中略过了已#开头的行，对include和宏定义没有进行分析；
2、对于/* */格式的注释，利用yylineno记录行数时只能记录在程序中的行号，没有包括注释中所包括的行号；
6、源码展示（仅展示.l文件里面的内容）
analyse.l:
%{
#include "stdio.h"
LIM [\{\}\[\]\(\)\,\;]
%%
\#[^\n]*\n {}
\/\/[^\n]*\n {}
\/\*(.)*\*\/ {}
{INTEGER} {printf("Line %d: (Integer,%s)\n",yylineno,yytext);}
{FLOAT} {printf("Line %d: (Float,%s)\n",yylineno,yytext);}
{SPEC} {printf("Line %d: (Special,%s)\n",yylineno,yytext);}
{LIM} {printf("Line %d: (LimitDomain,%s)\n",yylineno,yytext);}
[\t]+ {}
" " {}
\n {yylineno++;}
. {printf("Line %d: illegal character %s\n",yylineno,yytext);
}
%%
intyywrap()
{
return 1;
}
void main(intargc,char**argv)
{
if(argc> 1)
yyin=fopen(argv[1],"r");
4、实验结果与分析
对程序data.c进行分析：
data.c:
#include <stdio.h>
intmain()
{
inta = 0;
intb += a; //这是注释，编译期间会被忽略
itnc = 3.14;
c = a + b;
d = "hello world";
c = 'c';
return 0;
else
yyin=stdin;
yylex();
}
#include "stdlib.h"
%}
INTEGER ([-+]?[1-9][0-9]*)|0
FLOAT [-+]?[0-9]*\.[0-9]+
STR \"[^"\n]+\"
CHAR \'[^'\n]+\'
ID [a-z_A-Z][a-z_A-Z0-9]*
SPEC ([\=\+\-\*\/\&\!\|\%\.])|([\+\-\*\/\%\<\>\=][=])
{STR} {printf("Line %d: (Str,%s)\n",yylineno,yytext);}
{CHAR} {printf("Line %d: (Char,%s)\n",yylineno,yytext);}
{ID} {printf("Line %d: (Id,%s)\n",yylineno,yytext);}
if|then|else|int|float|double|bool|char|printf|scanf|return|main|while|do|for|struct|void|break|const|static|auto|short|long|union|enum|typedef|unsigned|signed|extern|register|volatile|switch|case|goto|continue|default|sizeof|include {printf("Line %d: (KeyWords,%s)\n",yylineno,yytext);}