编译原理实验题目及报告要求
编译原理实验报告(C语言)
编译原理实验报告实验项目1：词法分析程序实验一、实验的目的与任务：编译原理是计算机类专业特别是计算机软件专业的一门重要专业课。
设置该课程的目的在于系统地向学生讲述编译系统的结构、工作流程及编译程序各组成部分的设计原理和实现方法，使学生通过学习既掌握编译理论和方法方面的基本知识，也具有设计、实现、分析和维护编译程序等方面的初步能力。
编译原理是一门理论性和实践性都比较强的课程。
进行上机实验的目的是使学生通过完成上机实验题目加深对课堂教学内容的理解。
同时培养学生实际动手能力。
编译实验由三个独立实验组成，按照由浅入深进行排列，希望通过本实验使学生更深学习并理解编译的主要过程和相关方法。
词法分析的目的是将输入的源程序进行划分，给出基本符号（token）的序列，并掠过注解和空格等分隔符号。
基本符号是与输入的语言定义的词法所规定的终结符。
本实验要求学生编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续进行）二、题目分析1.这里采用C语言编写的源程序作为词法分析程序的输入数据，输入数据保存在“in.txt”记事本中，将分析结果存在“out.txt”记事本中。
词法分析器的源代码使用C语言编写。
2.下面就词法分析程序中的主要变量进行说明：主函数main()：打开要分析的C语言源程序，若不能正确打开，则报错。
先从源程序中读入一个字符ch，然后进行如下处理：1、cp消耗掉空格，制表符，换行符后，cp数组复位，开始检测cp；2、数字检测,对照符号表输出，若匹配成功，则返回序号；3、字符串检测, 对照符号表输出，若匹配成功，则返回序号；4、基本保留字检测,对照符号表输出，若匹配成功，则返回序号；5、运算符检测，对照符号表输出，若匹配成功，则返回序号；注意这里碰到‘/’时，要判断后面是否跟着是注释语句。
编译原理实验报告
编译原理实验报告一、实验目的和要求本次实验旨在对PL_0语言进行功能扩充，添加新的语法特性，进一步提高编译器的功能和实用性。
具体要求如下：1.扩展PL_0语言的语法规则，添加新的语法特性；2.实现对新语法的词法分析和语法分析功能；3.对扩展语法规则进行语义分析，并生成中间代码；4.验证扩展功能的正确性。
二、实验内容1.扩展语法规则本次实验选择扩展PL_0语言的语句部分，添加新的控制语句，switch语句。
其语法规则如下：<switch_stmt> -> SWITCH <expression> CASE <case_list><default_stmt> ENDSWITCH<case_list> -> <case_stmt> ， <case_stmt> <case_list><case_stmt> -> CASE <constant> : <statement><default_stmt> -> DEFAULT : <statement> ，ε2.词法分析和语法分析根据扩展的语法规则，需要对新的关键字和符号进行词法分析，识别出符号类型和记号类型。
然后进行语法分析，建立语法树。
3.语义分析在语义分析阶段，首先对switch语句的表达式进行求值，判断其类型是否为整型。
然后对case语句和default语句中的常量进行求值，判断是否与表达式的值相等。
最后将语句部分生成中间代码。
4.中间代码生成根据语法树和语义分析的结果，生成对应的中间代码。
例如，生成switch语句的跳转表，根据表达式的值选择相应的跳转目标。
5.验证功能的正确性设计一些测试用例，验证新语法的正确性和扩展功能的实用性。
三、实验步骤与结果1.扩展语法规则，更新PL_0语法分析器的词法规则和语法规则。
编译原理实验报告
编译原理实验报告一、实验目的本次编译原理实验的主要目的是通过实践加深对编译原理中词法分析、语法分析、语义分析和代码生成等关键环节的理解，并提高实际动手能力和问题解决能力。
二、实验环境本次实验使用的编程语言为 C/C+＋，开发工具为 Visual Studio 2019，操作系统为 Windows 10。
三、实验内容（一）词法分析器的设计与实现词法分析是编译过程的第一个阶段，其任务是从输入的源程序中识别出一个个具有独立意义的单词符号。
在本次实验中，我们使用有限自动机的理论来设计词法分析器。
首先，我们定义了单词的种类，包括关键字、标识符、常量、运算符和分隔符等。
然后，根据这些定义，构建了相应的状态转换图，并将其转换为程序代码。
在实现过程中，我们使用了字符扫描和状态转移的方法，逐步读取输入的字符，判断其所属的单词类型，并将其输出。
（二）语法分析器的设计与实现语法分析是编译过程的核心环节之一，其任务是在词法分析的基础上，根据给定的语法规则，判断输入的单词序列是否构成一个合法的句子。
在本次实验中，我们采用了自顶向下的递归下降分析法来实现语法分析器。
首先，我们根据给定的语法规则，编写了相应的递归函数。
每个函数对应一种语法结构，通过对输入单词的判断和递归调用，来确定语法的正确性。
在实现过程中，我们遇到了一些语法歧义的问题，通过仔细分析语法规则和调整函数的实现逻辑，最终解决了这些问题。
（三）语义分析与中间代码生成语义分析的任务是对语法分析所产生的语法树进行语义检查，并生成中间代码。
在本次实验中，我们使用了四元式作为中间代码的表示形式。
在语义分析过程中，我们检查了变量的定义和使用是否合法，类型是否匹配等问题。
同时，根据语法树的结构，生成相应的四元式中间代码。
（四）代码优化代码优化的目的是提高生成代码的质量和效率。
在本次实验中，我们实现了一些基本的代码优化算法，如常量折叠、公共子表达式消除等。
通过对中间代码进行分析和转换，减少了代码的冗余和计算量，提高了代码的执行效率。
编译原理语法分析实验报告
编译原理语法分析实验报告第一篇：编译原理语法分析实验报告实验2：语法分析1.实验题目和要求题目：语法分析程序的设计与实现。
实验内容：编写语法分析程序，实现对算术表达式的语法分析。
要求所分析算术表达式由如下的文法产生。
E→E+T|E-T|TT→T*F|T/F|F F→id|(E)|num实验要求：在对输入表达式进行分析的过程中，输出所采用的产生式。
方法1：编写递归调用程序实现自顶向下的分析。
方法2：编写LL(1)语法分析程序，要求如下。
(1)编程实现算法4.2，为给定文法自动构造预测分析表。
(2)编程实现算法4.1，构造LL(1)预测分析程序。
方法3：编写语法分析程序实现自底向上的分析，要求如下。
(1)构造识别所有活前缀的DFA。
(2)构造LR分析表。
(3)编程实现算法4.3，构造LR分析程序。
方法4：利用YACC自动生成语法分析程序，调用LEX自动生成的词法分析程序。
实现（采用方法1）1.1.步骤：1)对文法消除左递归E→TE'E'→+TE'|-TE'|εT→FT'T'→*FT'|/FT'|εF→id|(E)|num2)画出状态转换图化简得：3)源程序在程序中I表示id N表示num1.2.例子：a)例子1 输入:I+(N*N)输出：b)例子2 输入：I-NN 输出：第二篇：编译原理实验报告编译原理实验报告报告完成日期 2018.5.30一．组内分工与贡献介绍二．系统功能概述；我们使用了自动生成系统来完成我们的实验内容。
我们设计的系统在完成了实验基本要求的前提下，进行了一部分的扩展。
增加了声明变量类型、类型赋值判定和声明的变量被引用时作用域的判断。
从而使得我们的实验结果呈现的更加清晰和易懂。
三．分系统报告；一、词法分析子系统词法的正规式：标识符(|)* 十进制整数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)* 运算符和分隔符 +| * | / | > | < | = |(|)| <=|>=|==；对于标识符和关键字: A5—〉 B5C5 B5—〉a | b |⋯⋯| y | z C5—〉(a | b |⋯⋯| y | z |0|1|2|3|4|5|6|7|8|9)C5|ε综上正规文法为: S—〉I1|I2|I3|A4|A5 I1—〉0|A1 A1—〉B1C1|ε C1—〉E1D1|ε D1—〉E1C1|εE1—〉0|1|2|3|4|5|6|7|8|9 B1—〉1|2|3|4|5|6|7|8|9 I2—〉0A2 A2—〉0|B2 B2—〉C2D2 D2—〉F2E2|ε E2—〉F2D2|εC2—〉1|2|3|4|5|6|7 F2—〉0|1|2|3|4|5|6|7 I3—〉0xA3 A3—〉B3C3 B3—〉0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f C3—〉(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)|C3|εA4—〉+ |-| * | / | > | < | = |(|)| <=|>=|==； A5—〉 B5C5 B5—〉a | b |⋯⋯| y | z C5—〉(a | b |⋯⋯| y | z |0|1|2|3|4|5|6|7|8|9)C5|ε状态图流程图：词法分析程序的主要数据结构与算法考虑到报告的整洁性和整体观感，此处我们仅展示主要的程序代码和算法，具体的全部代码将在整体的压缩包中一并呈现另外我们考虑到后续实验中，如果在bison语法树生成的时候推不出目标的产生式时，我们设计了报错提示，在这个词的位置出现错误提示，将记录切割出来的词在code.txt中保存，并记录他们的位置。
实验报告编译原理
北京科技大学计算机与通信工程学院实验报告实验名称：_________编译原理实验报告_______学生姓名：_________ ________________专业：_________ _________________班级：_________ _________________学号：_________________________指导教师：_________ _________________实验成绩：________________________________实验地点：________________________________实验时间：____2015___年___07__月_______日一、实验目的与实验要求1、实验目的通过一个词法分析程序将一段给出的C语言代码的词法部分分析出来；通过一个语法分析程序将一段给出的C语言代码的语法分析出来。
2、实验要求二、实验设备（环境）及要求Win7家庭普通版；Visual Studio 2013；三、实验内容与步骤1、实验1（1）实验内容对于给定一段代码，通过词法分析程序将程序中的各个类型的字表分析，包括保留字、分隔符表、运算符表、标识符、整型数、浮点类型数、字符类型、字符串类型等表文件。
（2）主要步骤通过读入程序的文本文件，然后将分析的结果一次保存在本地文本文件。
然后通过指定的命令来将分析的结果读取出来。
附录：源码#include<stdio.h>#include<string.h>#include<stdlib.h>char*key0[] = { " ", "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "int", "long", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "_Complex", "_Imaginary", "union", "unsigned", "void", "volatile", "while" };/*保留字表*/char *key1[] = { " ", "(", ")", "[", "]", "{", "}", ",", ";", "'" };/*分隔符表*/char *key2[] = { " ", "+", "-", "*", "/", "%", "<", ">", "==", ">=", "<=", "!=", "!", "&&", "||", "<<", ">>", "~", "|", "^", "&", "=", "?:", "->", "++", "--", ".", "+=", "-=", "*=", "/=" };/*运算符表*/int xx0[35], xx1[10], xx2[31];int temp_key3 = 0, temp_c40 = 0, temp_c41 = 0, temp_c42 = 0, temp_c43 = 0;/******* 初始化函数 *******/void load(){int mm;for (mm = 0; mm <= 34; mm++){xx0[mm] = 0;}for (mm = 0; mm <= 9; mm++){xx1[mm] = 0;}for (mm = 0; mm <= 30; mm++){xx2[mm] = 0;}FILE *floading;if ((floading = fopen("key0.txt", "w")) == NULL){printf("Error! Can't create file : key0.txt");return;}fclose(floading);/*建立保留字表文件：key0.txt*/if ((floading = fopen("key1.txt", "w")) == NULL){printf("Error! Can't create file : key1.txt");return;}/*建立分隔符表文件：key1.txt*/if ((floading = fopen("key2.txt", "w")) == NULL){printf("Error! Can't create file : key2.txt");return;}fclose(floading);/*建立运算符表文件：key2.txt*/if ((floading = fopen("key3.txt", "w")) == NULL){printf("Error! Can't create file : key3.txt");return;}fclose(floading);/*建立标识符表文件：key3.txt*/if ((floading = fopen("c40.txt", "w")) == NULL){printf("Error! Can't create file : c40.txt");return;}fclose(floading);/*建立整数类型常量表文件：c40.txt*/if ((floading = fopen("c41.txt", "w")) == NULL){printf("Error! Can't create file : c41.txt");return;}fclose(floading);/*建立浮点类型常量表文件：c41.txt*/if ((floading = fopen("c42.txt", "w")) == NULL){printf("Error! Can't create file : c42.txt");return;}fclose(floading);/*建立字符类型常量表文件：c42.txt*/if ((floading = fopen("c43.txt", "w")) == NULL){printf("Error! Can't create file : c43.txt");return;}fclose(floading);/*建立字符串类型常量表文件：c43.txt*/if ((floading = fopen("defination.txt", "w")) == NULL) {printf("Error! Can't create file : defination.txt");return;}fclose(floading);/*建立注释文件：defination.txt*/if ((floading = fopen("output.txt", "w")) == NULL){printf("Error! Can't create file : output.txt");return;}fclose(floading);/*建立内部码文件：output.txt*/if ((floading = fopen("temp_key1", "w")) == NULL){printf("Error! Can't create file : temp_key1");return;}fclose(floading);/*建立保留字临时表文件：temp_key1*/if ((floading = fopen("temp_key3", "w")) == NULL){printf("Error! Can't create file : temp_key3");return;}fclose(floading);/*建立标识符临时文件：temp_key3*/if ((floading = fopen("temp_c40", "w")) == NULL){printf("Error! Can't create file : temp_c40");return;}fclose(floading);/*建立整数类型常量临时文件：temp_c40*/if ((floading = fopen("temp_c41", "w")) == NULL){printf("Error! Can't create file : temp_c41");return;}fclose(floading);/*建立浮点类型常量临时文件：temp_c41*/if ((floading = fopen("temp_c42", "w")) == NULL){printf("Error! Can't create file : temp_c42");return;}fclose(floading);/*建立字符类型常量临时文件：temp_c42*/if ((floading = fopen("temp_c43", "w")) == NULL){printf("Error! Can't create file : temp_c43");return;}fclose(floading);/*建立字符串类型常量临时文件：temp_c43*/}/******* 保留字及标识符判断函数 *******/void char_search(char *word){int m, line = 0, csi = 0;int value = 0;int value2 = 0;char c, cs[100];FILE *foutput, *finput;for (m = 1; m <= 34; m++){if (strcmp(word, key0[m]) == 0){value = 1;break;}}if (value == 1){if (xx0[m] == 0){foutput = fopen("key0.txt", "a");fprintf(foutput, "0\t%d\t\t%s\n", m, word);fclose(foutput);xx0[m] = 1;}foutput = fopen("output.txt", "a");fprintf(foutput, "0\t%d\t\t%s\n", m, word);fclose(foutput);}else{if (temp_key3 == 0){foutput = fopen("temp_key3", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_key3++;foutput = fopen("key3.txt", "a");fprintf(foutput, "3\t1\t\t%s\n", word);fclose(foutput);}finput = fopen("temp_key3", "r");c = fgetc(finput);while (c != EOF){while (c != '\n'){cs[csi++] = c;c = fgetc(finput);}cs[csi] = '\0';csi = 0;line++;if ((strcmp(cs, word)) == 0){value2 = 1;break;}else{value2 = 0;c = fgetc(finput);}}fclose(finput);if (value2 == 1){foutput = fopen("output.txt", "a");fprintf(foutput, "3\t%d\t\t%s\n", line, word);fclose(foutput);}else{foutput = fopen("temp_key3", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_key3++;foutput = fopen("output.txt", "a");fprintf(foutput, "3\t%d\t\t%s\n", temp_key3, word);fclose(foutput);foutput = fopen("key3.txt", "a");fprintf(foutput, "3\t%d\t\t%s\n", temp_key3, word);fclose(foutput);}}}/******* 整数类型判断函数 *******/void inta_search(char *word){FILE *foutput, *finput;char c;char cs[100];int csi = 0;int line = 0;int value2 = 0;if (temp_c40 == 0){foutput = fopen("temp_c40", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_c40++;foutput = fopen("c40.txt", "a");fprintf(foutput, "4\t0\t1\t%s\n", word);fclose(foutput);}finput = fopen("temp_c40", "r");c = fgetc(finput);while (c != EOF){while (c != '\n'){cs[csi++] = c;c = fgetc(finput);}cs[csi] = '\0';csi = 0;line++;if (strcmp(cs, word) == 0){value2 = 1;break;}c = fgetc(finput);}fclose(finput);if (value2 == 1){foutput = fopen("output.txt", "a");fprintf(foutput, "4\t0\t%d\t%s\n", line, word);fclose(foutput);}else{foutput = fopen("temp_c40", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_c40++;foutput = fopen("output.txt", "a");fprintf(foutput, "4\t0\t%d\t%s\n", temp_c40, word);fclose(foutput);foutput = fopen("c40.txt", "a");fprintf(foutput, "4\t0\t%d\t%s\n", temp_c40, word);fclose(foutput);}}/******* 浮点类型判断函数 *******/void intb_search(char *word){FILE *foutput, *finput;char c;char cs[100];int csi = 0;int line = 0;int value2 = 0;if (temp_c41 == 0){foutput = fopen("temp_c41", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_c41++;foutput = fopen("c41.txt", "a");fprintf(foutput, "4\t1\t1\t%s\n", word);fclose(foutput);}finput = fopen("temp_c41", "r");c = fgetc(finput);while (c != EOF){while (c != '\n'){cs[csi++] = c;c = fgetc(finput);}cs[csi] = '\0';csi = 0;line++;if (strcmp(cs, word) == 0){value2 = 1;break;}c = fgetc(finput);}fclose(finput);if (value2 == 1){foutput = fopen("output.txt", "a");fprintf(foutput, "4\t1\t%d\t%s\n", line, word);fclose(foutput);}else{foutput = fopen("temp_c41", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_c41++;foutput = fopen("output.txt", "a");fprintf(foutput, "4\t1\t%d\t%s\n", temp_c41, word);fclose(foutput);foutput = fopen("c40.txt", "a");fprintf(foutput, "4\t1\t%d\t%s\n", temp_c41, word);fclose(foutput);}}/******* 字符串常量判断函数 *******/void cc_search(char *word){FILE *foutput, *finput;char c;char cs[100];int csi = 0;int line = 0;int value2 = 0;if (temp_c43 == 0){foutput = fopen("temp_c43", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_c43++;foutput = fopen("c43.txt", "a");fprintf(foutput, "4\t3\t1\t%s\n", word);fclose(foutput);}finput = fopen("temp_c43", "r");c = fgetc(finput);while (c != EOF){while (c != '\n'){cs[csi++] = c;c = fgetc(finput);}cs[csi] = '\0';csi = 0;line++;if (strcmp(cs, word) == 0){value2 = 1;break;}c = fgetc(finput);}fclose(finput);if (value2 == 1){foutput = fopen("output.txt", "a");fprintf(foutput, "4\t3\t%d\t%s\n", line, word);fclose(foutput);}else{foutput = fopen("temp_c43", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_c43++;foutput = fopen("output.txt", "a");fprintf(foutput, "4\t3\t%d\t%s\n", temp_c43, word);fclose(foutput);foutput = fopen("c43.txt", "a");fprintf(foutput, "4\t3\t%d\t%s\n", temp_c43, word);fclose(foutput);}}/******* 字符常量判断函数 *******/void c_search(char *word){FILE *foutput, *finput;char c;char cs[100];int csi = 0;int line = 0;int value2 = 0;if (temp_c42 == 0){foutput = fopen("temp_c42", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_c42++;foutput = fopen("c42.txt", "a");fprintf(foutput, "4\t2\t1\t%s\n", word);fclose(foutput);}finput = fopen("temp_c42", "r");c = fgetc(finput);while (c != EOF){while (c != '\n'){cs[csi++] = c;c = fgetc(finput);}cs[csi] = '\0';csi = 0;line++;if (strcmp(cs, word) == 0){value2 = 1;break;}c = fgetc(finput);}fclose(finput);if (value2 == 1){foutput = fopen("output.txt", "a");fprintf(foutput, "4\t2\t%d\t%s\n", line, word);fclose(foutput);}else{foutput = fopen("temp_c42", "a");fprintf(foutput, "%s\n", word);fclose(foutput);temp_c42++;foutput = fopen("output.txt", "a");fprintf(foutput, "4\t2\t%d\t%s\n", temp_c42, word);fclose(foutput);foutput = fopen("c42.txt", "a");fprintf(foutput, "4\t2\t%d\t%s\n", temp_c42, word);fclose(foutput);}}/******* 主扫描函数 *******/void scan(){int count;char chin;FILE *fin;FILE *fout;char filename[50];char temp[100];char target[3] = "'";printf("请输入文件名：");scanf("%s", filename);if ((fin = fopen(filename, "r")) == NULL){printf("Error! Can't open file : %s\n", filename);return;}chin = fgetc(fin);while (chin != EOF){/*对文件包含、宏定义进行处理*/if (chin == '#'){while (chin != '>')chin = fgetc(fin);/*chin=fgetc(fin);*/}/*对空格符、水平制表符进行处理*/else if ((chin == ' ') || (chin == '\t')){;}/*对回车符进行处理*/else if (chin == '\n'){;}/*对单引号内的字符常量进行处理*/else if (chin == target[0]){if (xx1[9] == 0){fout = fopen("key1.txt", "a");fprintf(fout, "1\t9\t\t%c\n", target[0]);fclose(fout);xx1[9] = 1;}temp[0] = chin;chin = fgetc(fin);temp[1] = chin;chin = fgetc(fin);if (chin != target[0]){temp[2] = chin;chin = fgetc(fin);temp[3] = chin;temp[4] = '\0';}else{temp[2] = chin;temp[3] = '\0';}c_search(temp);}/*对双引号内的字符串常量进行处理*/else if (chin == '"'){int i = 0;temp[i++] = '"';chin = fgetc(fin);while (chin != '"'){temp[i++] = chin;chin = fgetc(fin);}temp[i] = '"';temp[i + 1] = '\0';cc_search(temp);}/*对保留字、标识符进行处理*/else if (((chin >= 'A') && (chin <= 'Z')) || ((chin >= 'a') && (chin <= 'z')) || (chin == '_')){int i = 0;while (((chin >= 'A') && (chin <= 'Z')) || ((chin >= 'a') && (chin <= 'z')) || (chin == '_') || ((chin >= '0') && (chin <= '9'))){temp[i++] = chin;chin = fgetc(fin);}temp[i] = '\0';char_search(temp);if (chin != EOF)fseek(fin, -1L, SEEK_CUR);}/*对整型、浮点型数据进行处理*/else if ((chin >= '0') && (chin <= '9')){int dotcount = 0;int i = 0;while (((chin >= '0') && (chin <= '9')) || (chin == '.')){if (chin == '.')dotcount++;if (dotcount == 2)break;temp[i++] = chin;chin = fgetc(fin);}temp[i] = '\0';if (dotcount == 1)intb_search(temp);elseinta_search(temp);if (chin != EOF)fseek(fin, -1L, SEEK_CUR);}/*对注释进行处理*/else if (chin == '/'){chin = fgetc(fin);if (chin == '='){fout = fopen("output.txt", "a");fprintf(fout, "2\t30\t\t/=\n");fclose(fout);}else if (chin != '*'){fout = fopen("output.txt", "a");fprintf(fout, "2\t4\t\t/\n");fclose(fout);fseek(fin, -1L, SEEK_CUR);}else if (chin == '*'){count = 0;chin = fgetc(fin);fout = fopen("defination.txt", "a");fprintf(fout, "/*");while (count != 2){count = 0;while (chin != '*'){fprintf(fout, "%c", chin);chin = fgetc(fin);}count++;fprintf(fout, "%c", chin);chin = fgetc(fin);if (chin == '/'){count++;fprintf(fout, "%c\n", chin);}else{fprintf(fout, "%c", chin);chin = fgetc(fin);}}}}/*对运算符、分隔符进行处理*/else{int time = 0;int firstblood = 0;temp[0] = chin;chin = fgetc(fin);if (chin != EOF){temp[1] = chin;temp[2] = '\0';for (time = 1; time <= 30; time++){if (strcmp(temp, key2[time]) == 0){firstblood = 1;if (xx2[time] == 0){fout = fopen("key2.txt", "a");fprintf(fout, "2\t%d\t\t%s\n", time, temp);fclose(fout);xx2[time] = 1;}fout = fopen("output.txt", "a");fprintf(fout, "2\t%d\t\t%s\n", time, temp);fclose(fout);break;}}if (firstblood != 1){fseek(fin, -1L, SEEK_CUR);temp[1] = '\0';for (time = 1; time <= 9; time++){if (strcmp(temp, key1[time]) == 0){if (xx1[time] == 0){fout = fopen("key1.txt", "a");fprintf(fout, "1\t%d\t\t%s\n", time, temp);fclose(fout);xx1[time] = 1;}fout = fopen("output.txt", "a");fprintf(fout, "1\t%d\t\t%s\n", time, temp);fclose(fout);break;}}for (time = 1; time <= 30; time++){if (strcmp(temp, key2[time]) == 0){if (xx2[time] == 0){fout = fopen("key2.txt", "a");fprintf(fout, "2\t%d\t\t%s\n", time, temp);fclose(fout);xx2[time] = 1;}fout = fopen("output.txt", "a");fprintf(fout, "2\t%d\t\t%s\n", time, temp);fclose(fout);break;}}}}}chin = fgetc(fin);}fout = fopen("output.txt", "a");fprintf(fout, "1\t6\t\t}\n");fclose(fout);}/******* Main函数 *******/void main(){FILE *fread;char charin;char command = 'Q';printf("\n");printf("******************** 词法分析 ********************\n");printf("* *\n");printf("* *\n");printf("* 0 --> 查看保留字表文件 *\n");printf("* 1 --> 查看分隔符表文件 *\n");printf("* 2 --> 查看运算符表文件 *\n");printf("* 3 --> 查看标识符表文件 *\n");printf("* 4 --> 查看整数类型常量表 *\n");printf("* 5 --> 查看浮点类型常量表 *\n");printf("* 6 --> 查看字符类型常量表 *\n");printf("* 7 --> 查看字符串类型常量表 *\n");//printf("* 8 --> 查看注释文件 *\n");printf("* 9 --> 查看内部码文件 *\n");printf("* -------------------------- *\n");printf("* Q --> 退出 *\n");printf("***************************************************************\n");printf("\n");load();scan();printf("\n");printf("分析完成！\n");getchar();printf("\n");printf("请输入命令：");command = getchar();while ((command != 'Q') && (command != 'q')){switch (command){case'0':{printf("*************************\n");printf("\n");fread = fopen("key0.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'1':{printf("*************************\n");printf("\n");fread = fopen("key1.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'2':{printf("*************************\n");printf("\n");fread = fopen("key2.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'3':{printf("*************************\n");printf("\n");fread = fopen("key3.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'4':{printf("*************************\n");printf("\n");fread = fopen("c40.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'5':{printf("*************************\n");printf("\n");fread = fopen("c41.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'6':{printf("*************************\n");printf("\n");fread = fopen("c42.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'7':{printf("*************************\n");printf("\n");fread = fopen("c43.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'8':{printf("*************************\n");printf("\n");fread = fopen("defination.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}case'9':{printf("*************************\n");printf("\n");fread = fopen("output.txt", "r");charin = fgetc(fread);while (charin != EOF){putchar(charin);charin = fgetc(fread);}printf("\n");printf("*************************\n");printf("\n");printf("请输入命令：");break;}}command = getchar();}}2、实验2（1）实验内容输入单词串，以”#”结束，如果是文法正确的句子，则输出成功信息，打印“success”,否则输出”error”例如:输入： begin a:=9;b:=0 end #输出： success输入： begin a=9 end #输出： error（2）主要步骤附录：源码#include<stdio.h>#include<string.h>#include<ctype.h>#include<stdlib.h>char GetChar(char *input, int *index, int length);int ClearBlank(char *input, int(*index), int length);int reserve(char *s);void lrparser(char *input, int inputLength, int *index);void yucu(char *input, int inputLength, int *index);void factor(char *input, int inputLength, int *index);void statement(char *input, int inputLength, int *index);void expression(char *input, int inputLength, int *index);void term(char *input, int inputLength, int *index);char *retab[6] = { "begin", "if", "then", "while", "do", "end" };//关键字int syn = 0;int myIsAlpha(char ch){if (islower(ch) == 2 || isupper(ch) == 1){return 1;}else{return 0;}}void scaner(char *input, int inputLength, int *index){char s[256] = ""; //保存当前的字符char ch = GetChar(input, index, inputLength);int nowPosition = 0;int j = 0;if (myIsAlpha(ch) == 1) //如果是字母{while(((ch >= '0'&& ch <= '9') || (myIsAlpha(ch) == 1)) && *index<= inputLength) {s[nowPosition] = ch; //添加到当前字符串中nowPosition++;ch = GetChar(input, index, inputLength);}if ((ch <'0' || ch>'9') && (myIsAlpha(ch) == 0))//进行回退操作，并输出结果{s[nowPosition] = '\0';//添加结束标志j = reserve(s);if (j == 0){syn = 10;}else{syn = j;}(*index)--;return;}else//超过范围{s[nowPosition++] = ch;s[nowPosition] = '\0';//添加结束标志j = reserve(s);if (j == 0){syn = 10;}else{syn = j;}getchar();exit(0);return;}}elseif (ch >= '0' && ch <= '9') //如果是数字{while (ch >= '0' && ch <= '9'&& *index <= inputLength) {s[nowPosition] = ch; //添加到当前字符串中nowPosition++;ch = GetChar(input, index, inputLength);}if (ch<'0' || ch>'9')//进行回退操作{(*index)--;syn = 11;return;}else//超过范围时{s[nowPosition] = ch;syn = 11;return;}}else{switch (ch){case'+':{syn = 13;return;}case'-':{syn = 14;return;}case'*':{syn = 15;return;}case'/':{syn = 16;return;}case'<':{ch = GetChar(input, index, inputLength);if (ch == '='){syn = 22;return;}elseif (ch == '>'){syn = 21;return;}else{syn = 20;if (*index>inputLength){return;}else{(*index)--;return;}}case'>':{ch = GetChar(input, index, inputLength);if (ch == '='){syn = 24;return;}else{syn = 23;if (*index>inputLength){return;}else{(*index)--;return;}}}case':':{ch = GetChar(input, index, inputLength);if (ch == '='){syn = 18;return;}else{if (*index>inputLength){return;}else(*index)--;return;}}}case'=':{syn = 25;return;}case';':{syn = 26;return;}case'(':{syn = 27;return;}case')':{syn = 28;return;}case'#':{syn = 0;return;}case' ':{syn = -1;return;}default:{printf("(非法符号)");。
编译原理实验报告
编译原理实验报告班级姓名：学号：自我评定：实验一词法分析程序实现一、实验目的与要求通过编写和调试一个词法分析程序，掌握在对程序设计语言的源程序进行扫描的过程中，将字符形式的源程序流转化为一个由各类单词符号组成的流的词法分析方法。
二、实验内容根据教学要求并结合学生自己的兴趣和具体情况，从具有代表性的高级程序设计语言的各类典型单词中，选取一个适当大小的子集。
例如，可以完成无符号常数这一类典型单词的识别后，再完成一个尽可能兼顾到各种常数、关键字、标识符和各种运算符的扫描器的设计和实现。
输入：由符合或不符合所规定的单词类别结构的各类单词组成的源程序。
输出：把单词的字符形式的表示翻译成编译器的内部表示，即确定单词串的输出形式。
例如，所输出的每一单词均按形如（CLASS，VALUE）的二元式编码。
对于变量和常数，CLASS字段为相应的类别码；VALUE字段则是该标识符、常数的具体值或在其符号表中登记项的序号（要求在变量名表登记项中存放该标识符的字符串；常数表登记项中则存放该常数的二进制形式）。
对于关键字和运算符，采用一词一类的编码形式；由于采用一词一类的编码方式，所以仅需在二元式的CLASS字段上放置相应的单词的类别码，VALUE字段则为“空”。
另外，为便于查看由词法分析程序所输出的单词串，要求在CLASS字段上放置单词类别的助记符。
三、实现方法与环境词法分析是编译程序的第一个处理阶段，可以通过两种途径来构造词法分析程序。
其一是根据对语言中各类单词的某种描述或定义（如BNF），用手工的方式（例如可用C语言）构造词法分析程序。
一般地，可以根据文法或状态转换图构造相应的状态矩阵，该状态矩阵同控制程序便组成了编译器的词法分析程序；也可以根据文法或状态转换图直接编写词法分析程序。
构造词法分析程序的另外一种途径是所谓的词法分析程序的自动生成，即首先用正规式对语言中的各类单词符号进行词型描述，并分别指出在识别单词时，词法分析程序所应进行的语义处理工作，然后由一个所谓词法分析程序的构造程序对上述信息进行加工。
编译原理实验报告3
编译原理实验报告——表达式语法分析 ——表达式语法分析表达式语法分析实验报告一、实验题目设计一个简单的表达式语法分析器 （采用递归下降方法设计实现）二、实验目的1、 了解形式语言基础及其文法运算； 2、 熟悉语法分析原理及 4 种常用的语法分析方法； 其中： 四种算法为 （1）设计算术表达式的递归下降子程序分析算法 （2）设计算术表达式的 LL(1) 分析算法 （3）设计算术表达式的简单优先分析算法 （4）设计算术表达式的 SLR(1) 分析算法 3、选择上述一种方法并设计一个表达式的语法分析器。
（本实验设计的是递归下降的表达式语法分析器）三、实验内容1．设计递归下降语法分析器算法； 2．编写代码并上机调试运行通过； 3、写出试验体会及心得。
四、实验要求1、 给出算术表达式文法 2、 进行适当的文法变换 3、 选择一种语法分析的方法，并说明其原理 4、 根据原理给出相应的算法设计，说明主要的数据结构并画出算法流 程图 5、 编写代码并上机调试运行通过 6、 写出程序运行结果 7、 写出相应的文档以及代码注释 8、输入——表达式； 输出——表达式语法是否正确。
五、递归下降的表达式语法分析器设计概要1．算术表达式文法 ． G(E)： E T F 2．文法变换： 文法变换： G’(E)： E->TE' E'->+TE'|ε T->FT' T'->*FT'|ε F->(E)|I E +T | T T* F | F i | (E)3. 递归下降子程序框图： 递归下降子程序框图：六、实验设计源程序#include <iostream.h>char inputstream[50]; int temp=0; int right; void e(); void e1(); void t(); void t1(); void f(); void main() { right=1;//存储输入句子//数组下标 //判断输出信息cout<<"请输入您要分析的字符串以#结束(^为空字符)："<<endl; cin>>inputstream; e(); if((inputstream[temp]=='#')&&right) cout<<"分析成功"<<endl; else cout<<"分析失败"<<endl; } void e() { cout<<"E->TE'"<<endl; t(); e1(); } void e1() { if(inputstream[temp]=='+') { cout<<"E'->+TE'"<<endl; temp++; t();e1(); } else if (inputstream[temp]!='#'||inputstream[temp]!=')') { cout<<"T'->^"<<endl; return ; } else right=0; } void t() { cout<<"T->FT'"<<endl; f(); t1(); } void t1() { if(inputstream[temp]=='*') { cout<<"T'->*FT'"<<endl; temp++; f(); t1(); } else if (inputstream[temp]!='#'&&inputstream[temp]!=')'&&inputstream[temp ]!='+') { cout<<"T'->^"<<endl; right=0;} } void f() { if(inputstream[temp]=='i') { cout<<"F->i"<<endl; temp++; } elseif(inputstream[temp]=='(') { cout<<"F->(E)"<<endl; temp++; e(); if(inputstream[temp]==')') { cout<<"F->(E)"<<endl; temp++; } else right=0; } else right =0; }七、运行结果八、实验思考题语法分析的任务是什么？ 语法分析的任务是什么？ 答：语法分析器的任务是识别和处理比单词更大的语法单位，如：程序设 计语言中的表达式、各种说明和语句乃至全部源程序，指出其中的语法错误； 必要时，可生成内部形式，便于下一阶段处理。
编译原理实验报告_15
编译原理实验报告实验一词法分析器的设计与实现 (1)1）实验目的 (1)2）实验内容 (1)3）实验要求 (1)4）实验原理 (1)5）实验步骤 (1)6）状态转化图及词法分析程序 (2)7）测试 (7)实验二语法分析器的设计与实现 (9)1）实验目的 (9)2）实验内容 (9)3）实验要求 (9)4）实验原理 (9)5）实验步骤 (9)6）语法分析程序 (10)7）测试 (16)编译原理实验报告专业：计算机科学与技术学生姓名：学号： 48完成时间：2020年11月25日实验一词法分析器的设计与实现1）实验目的①掌握正规式、状态转换图、C语言单词符号的划分及词法分析器的实现②掌握词法分析程序的作用和接口。
2）实验内容设计及实现C语言程序的词法分析器。
3）实验要求①对任给的一个C语言源程序，能够虑掉空格、回车换行符、tab键及注释。
②识别各类单词符号，如关键字、标识符、运算符、常数、界符，结果以二元式形式输出。
并构造符号表。
③输出有词法错误的单词及所在行号。
4）实验原理根据扫描到的单词符号的第一个字符的种类，分别转到相应的程序进行处理。
这些程序的功能就是识别以相应字符开头的各类单词符号。
5）实验步骤①根据C语言各类单词的正规式，构造能识别各类单词的状态转换图。
②根据状态转换图，构造识别各类单词的词法分析器。
6）状态转化图及词法分析程序#include ""#include ""#include ""FILE *fp;int id;void main(){char cbuffer;char alphaprocess(char buffer);char digitprocess(char buffer);char otherprocess(char buffer);if ((fp=fopen("","r"))==NULL) /*以只读方式打开文件""，NULL在文件中已被定义为0*/printf("error");else{cbuffer=fgetc(fp); /*文件不为空则从文件中取字符*/while (cbuffer!=EOF) /*EOF文件结束标志*/{if(cbuffer==' '||cbuffer=='\n') /*掠过空格和回车符*/{cbuffer=fgetc(fp);id=4;}else if(isalpha(cbuffer))cbuffer=alphaprocess(cbuffer); /*检查cbuffer是否为字母，是则调用alphaprocess()函数*/else if (isdigit(cbuffer))cbuffer=digitprocess(cbuffer); /*检查cbuffer是否为数字0～9，是则调用digitprocess()函数*/else cbuffer=otherprocess(cbuffer); /*非上述两者则调用otherprocess()函数*/}}}char alphaprocess(char buffer){int search(char searchchar[],int wordtype); /*函数声明*/int atype;int i=-1;char alphatp[20]; /*字符数组存储从文件中读取的字符*/while((isalpha(buffer))||(isdigit(buffer))||buffer=='_') /*标识符的组成成分*/{alphatp[++i]=buffer; /*将当前读取的字符存如数组*/buffer=fgetc(fp); /*读取下一个字符*/}alphatp[i+1]='\0'; /*字符串以'\0'作为结束标志*/atype=search(alphatp,1); /*调用函数，判断当前字符串是否为关键字*/if(atype!=0) /*是关键字则输出该关键字，编号为1，并输出该关键字在关键字表中的位子*/{printf("(%s, (1,%d))\n",alphatp,atype);id=1; /*关键字的ID为1*/}else{printf("(%s ,2)\n",alphatp); /*为标识符时，编号为2*/id=2; /*标识符的ID为2*/}return(buffer);}/*判断字符串是否为关键字*/int search(char searchchar[],int wordtype){char * key[32]={"auto","break","case","char","const","continue","default","d o", "double","else","enum","extern","float","for","goto","if","int","long ", "register","return","short","signed","sizeof","static","struct", "volatile","while","switch","typedef","union","unsigned","void"};/*设置数组指针存储c语言中的32个关键字*/int i;int p;switch (wordtype){case 1:for (i=0;i{if (strcmp(key[i],searchchar)==0) /*比较字符串，为关键字则定位该关键字的序号*/{ p=i+1; break; }else p=0;}return(p);}}char digitprocess(char buffer){int i=-1;char digittp[20];while ((isdigit(buffer))||buffer=='.'||buffer=='e'||buffer=='E')//考虑数字为小数和指数时的情况{digittp[++i]=buffer;buffer=fgetc(fp); /*同上*/}digittp[i+1]='\0';printf("(%s ,3)\n",digittp); /*输出该数字，编号为3*/ id=3; /*设置ID 为3*/return(buffer);}char otherprocess(char buffer){int n=0;char ch[20];ch[0]=buffer;ch[1]='\0';if(ch[0]=='%'||ch[0]=='\\'){ buffer=fgetc(fp);ch[1]=buffer;ch[2]='\0';printf("(%s ,5)\n",ch);id=4;buffer=fgetc(fp);return(buffer);}if(ch[0]=='&'){buffer=fgetc(fp);if(buffer!='&')printf("(%s ,5)\n",ch);id=4;return(buffer);}if(buffer=='&'){ch[1]=buffer;ch[2]='\0';printf("(%s ,4)\n",ch);id=3;buffer=fgetc(fp);return(buffer);}}if(ch[0]==','||ch[0]==';'||ch[0]=='{'||ch[0]=='}'||ch[0]=='('||ch[0]= =')') {printf("(%s ,5)\n",ch);buffer=fgetc(fp);id=4;return(buffer);}if(ch[0]=='*'||ch[0]=='/')printf("(%s ,4)\n",ch);buffer=fgetc(fp);id=4;return(buffer);}if(ch[0]=='='||ch[0]=='!'||ch[0]==''){buffer=fgetc(fp);if(buffer=='=') /*防止'==','!=','='符号的分离*/ { ch[1]=buffer;ch[2]='\0';printf("(%s ,4)\n",ch);}else{printf("(%s ,4)\n",ch);id=4;return(buffer);}buffer=fgetc(fp);id=4;return(buffer);-全文完-。
编译原理实验报告
编译原理实验报告一、实验目的编译原理是计算机科学中的重要学科，它涉及到将高级编程语言转换为计算机能够理解和执行的机器语言。
本次实验的目的是通过实际操作和编程实践，深入理解编译原理中的词法分析、语法分析、语义分析以及中间代码生成等关键环节，提高我们对编译过程的认识和编程能力。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
此外，还使用了一些相关的编译工具和调试工具，如 GDB 等。
三、实验内容（一）词法分析器的实现词法分析是编译过程的第一步，其任务是将输入的源程序分解为一个个单词符号。
在本次实验中，我们使用有限自动机的理论来设计和实现词法分析器。
首先，定义了各种单词符号的类别，如标识符、关键字、常量、运算符等。
然后，根据这些类别设计了相应的状态转换图，并将其转换为代码实现。
在实现过程中，使用了正则表达式来匹配输入字符串中的单词符号。
对于标识符和常量等需要进一步处理的单词符号，使用了相应的规则进行解析和转换。
（二）语法分析器的实现语法分析是编译过程的核心环节之一，其任务是根据给定的语法规则，分析输入的单词符号序列是否符合语法结构。
在本次实验中，我们使用了递归下降的语法分析方法。
首先，根据实验要求定义了语法规则，并将其转换为相应的递归函数。
在递归函数中，通过对输入单词符号的判断和处理，逐步分析语法结构。
为了处理语法错误，在分析过程中添加了错误检测和处理机制。
当遇到不符合语法规则的输入时，能够输出相应的错误信息，并尝试进行恢复。
（三）语义分析及中间代码生成语义分析的目的是对语法分析得到的语法树进行语义检查和语义处理，生成中间代码。
在本次实验中，我们使用了三地址码作为中间代码的表示形式。
在语义分析过程中，对变量的定义和使用、表达式的计算、控制流语句等进行了语义检查和处理。
对于符合语义规则的语法结构，生成相应的三地址码指令。
四、实验步骤（一）词法分析器的实现步骤1、定义单词符号的类别和对应的正则表达式。
编译原理实验报告
编译原理实验报告编译原理实验报告一、实验目的1. 了解编译器的基本原理和工作过程；2. 掌握编译器设计和实现的基本方法和技巧；3. 通过设计和实现一个简单的编译器，加深对编程语言和计算机系统的理解和认识。
二、实验原理编译器是将高级语言程序翻译成机器语言程序的一种软件工具。
它由编译程序、汇编程序、链接程序等几个阶段组成。
本次实验主要涉及到的是编译程序的设计和实现。
编译程序的基本原理是将高级语言程序转换为中间代码，再将中间代码转换为目标代码。
整个过程可以分为词法分析、语法分析、语义分析、代码生成和代码优化几个阶段。
三、实验内容本次实验的设计目标是实现一个简单的四则运算表达式的编译器。
1. 词法分析根据规定的语法规则，编写正则表达式将输入的字符串进行词法分析，将输入的四则运算表达式划分成若干个单词（Token），例如：运算符、操作数等。
2. 语法分析根据定义的语法规则，编写语法分析程序，将词法分析得到的Token序列还原成语法结构，构建抽象语法树（AST）。
3. 语义分析对AST进行遍历，进行语义分析，判断表达式是否符合语法规则，检查语义错误并给出相应的提示。
4. 代码生成根据AST生成目标代码，目标代码可以是汇编代码或者机器码。
四、实验过程和结果1. 首先，根据输入的表达式，进行词法分析。
根据所定义的正则表达式，将输入的字符串划分成Token序列。
例如：输入表达式“2+3”，经过词法分析得到的Token序列为["2", "+", "3"]。
2. 然后，根据语法规则，进行语法分析。
根据输入的Token序列，构建抽象语法树。
3. 接着，对抽象语法树进行语义分析。
检查表达式是否符合语法规则，给出相应的提示。
4. 最后，根据抽象语法树生成目标代码。
根据目标代码的要求，生成汇编代码或者机器码。
五、实验总结通过本次实验，我对编译器的工作原理有了更深入的认识，掌握了编译器设计和实现的基本方法和技巧。
编译原理_实验报告实验二__语法分析(算符优先) 2
华北水利水电学院编译原理实验报告一、实验题目：语法分析（算符优先分析程序）（1）选择最有代表性的语法分析方法算符优先法；（2）选择对各种常见程序语言都用的语法结构，如赋值语句（尤指表达式）作为分析对象，并且与所选语法分析方法要比较贴切。
二、实验内容（1）根据给定文法，先求出FirstVt和LastVt集合，构造算符优先关系表（要求算符优先关系表输出到屏幕或者输出到文件）；（2）根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式（要求输出归约过程）（3）给定表达式文法为：G(E’): E’→#E#E→E+T | TT→T*F |FF→(E)|i(4) 分析的句子为:(i+i)*i和i+i)*i三、程序源代#include<stdlib.h>#include<stdio.h>#include<string.h>#include<iostream.h>#define SIZE 128char priority[6][6]; //算符优先关系表数组char input[SIZE]; //存放输入的要进行分析的句子char remain[SIZE]; //存放剩余串char AnalyseStack[SIZE]; //分析栈void analyse();int testchar(char x); //判断字符X在算符优先关系表中的位置void remainString(); //移进时处理剩余字符串，即去掉剩余字符串第一个字符int k;void init()//构造算符优先关系表，并将其存入数组中{priority[0][2]='<';priority[0][3]='<';priority[0][4]='>';priority[0][5]='>';priority[1][0]='>';priority[1][1]='>';priority[1][2]='<';priority[1][3]='<';priority[1][4]='>';priority[1][5]='>';priority[2][0]='>';priority[2][1]='>';priority[2][2]='$';//无优先关系的用$表示priority[2][3]='$';priority[2][4]='>';priority[2][5]='>';priority[3][0]='<';priority[3][1]='<';priority[3][2]='<';priority[3][3]='<';priority[3][4]='=';priority[3][5]='$';priority[4][0]='>';priority[4][1]='>';priority[4][2]='$';priority[4][3]='$';priority[4][4]='>';priority[4][5]='>';priority[5][0]='<';priority[5][3]='<';priority[5][4]='$';priority[5][5]='=';}void analyse()//对所输入的句子进行算符优先分析过程的函数{FILE *fp;fp=fopen("li","a");int i,j,f,z,z1,n,n1,z2,n2;int count=0;//操作的步骤数char a; //用于存放正在分析的字符char p,Q,p1,p2;f=strlen(input); //测出数组的长度for(i=0;i<=f;i++){a=input[i];if(i==0)remainString();if(AnalyseStack[k]=='+'||AnalyseStack[k]=='*'||AnalyseStack[k]=='i'||Analy seStack[k]=='('||AnalyseStack[k]==')'||AnalyseStack[k]=='#')j=k;elsej=k-1;z=testchar(AnalyseStack[j]);//从优先关系表中查出s[j]和a的优先关系if(a=='+'||a=='*'||a=='i'||a=='('||a==')'||a=='#')n=testchar(a);else //如果句子含有不是终结符集合里的其它字符，不合法{printf("错误！该句子不是该文法的合法句子！\n");break;}if(p=='$'){printf("错误！该句子不是该文法的合法句子！\n");return;}if(p=='>'){ for( ; ; ){Q=AnalyseStack[j];if(AnalyseStack[j-1]=='+'||AnalyseStack[j-1]=='*'||AnalyseStack[j-1]=='i'||AnalyseStack[j-1]=='('||AnalyseStack[j-1]==')'||AnalyseStack[j-1]=='#')j=j-1;elsej=j-2;z1=testchar(AnalyseStack[j]);n1=testchar(Q);p1=priority[z1][n1];if(p1=='<') //把AnalyseStack[j+1]~AnalyseStack[k]归约为N{count++;printf("(%d) %s\t%10c\t%5c%17s\t 归约\n",count,AnalyseStack,p,a,remain);fprintf(fp,"(%d) %s\t%17s\t %s\n",count,AnalyseStack,remain,"归约");k=j+1;i--;AnalyseStack[k]='N';int r,r1;r=strlen(AnalyseStack);for(r1=k+1;r1<r;r1++)AnalyseStack[r1]='\0';break;}else}}else{if(p=='<') //表示移进{count++;printf("(%d) %s\t%10c\t%5c%17s\t 移进\n",count,AnalyseStack,p,a,remain);fprintf(fp,"(%d) %s\t%17s\t %s\n",count,AnalyseStack,remain,"移进");k=k+1;AnalyseStack[k]=a;remainString();}else{if(p=='='){z2=testchar(AnalyseStack[j]);n2=testchar('#');p2=priority[z2][n2];if(p2=='='){count++;printf("(%d) %s\t%10c\t%5c%17s\t 接受\n",count,AnalyseStack,p,a,remain);fprintf(fp,"(%d) %s\t%17s\t %s\n",count,AnalyseStack,remain,"接受");printf("该句子是该文法的合法句子。
计算机编译原理实验报告
编译原理实验报告实验一词法分析设计一、实验功能：1、对输入的txt文件内的内容进行词法分析：2、由文件流输入test.txt中的内容，对文件中的各类字符进行词法分析3、打印出分析后的结果；二、程序结构描述：（源代码见附录）1、分别利用k[],s1[],s2[],s3[]构造关键字表，分界符表，算术运算符表和关系运算符表。
2、bool isletter(){} 用来判断其是否为字母，是则返回true，否则返回false；bool isdigit(){} 用来判断其是否为数字，是则返回true，否则返回false；bool iscalcu(){} 用来判断是否为算术运算符，是则返回true，否则返回false；bool reserve(string a[]){} 用来判断某字符是否在上述四个表中，是则返回true，否则返回false；void concat(){} 用来连接字符串；void getn(){} 用来读取字符；void getb(){} 用来对空格进行处理；void retract(){}某些必要的退格处理；int analysis(){} 对一个单词的单词种别进行具体判断；在主函数中用switch决定输出。
三、实验结果四、实验总结词法分析器一眼看上去很复杂，但深入的去做就会发现并没有一开始想象的那么困难。
对于一个字符的种别和类型可以用bool函数来判断，对于关键字和标示符的识别（尤其是3b）则费了一番功夫，最后对于常数的小数点问题处理更是麻烦。
另外，这个实验要设定好时候退格，否则将会导致字符漏读甚至造成字符重复读取。
我认为，这个实验在程序实现上大体不算困难，但在细节的处理上则需要好好地下功夫去想，否则最后的程序很可能会出现看上去没有问题，但实际上漏洞百出的状况。
将学过的知识应用到实际中并不简单，只有自己不断尝试将知识转化成程序才能避免眼高手低，对于知识的理解也必将更加深刻。
实验二LL(1)分析法一、实验原理：1、写出LL（1）分析法的思想：当一个文法满足LL(1)条件时，我们就可以为它构造一个不带回溯的自上而下的分析程序，这个分析程序是有一组递归过程组成的，每个过程对应文法的一个非终结符。
编译原理实验报告
实验一词法分析一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。
二、实验要求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 各种单词符号对应的种别码单词符号种别码单词符号种别码bgin 1 ：17If 2 ：= 18Then 3 < 20wile 4 <> 21do 5 <= 22end 6 > 23lettet（letter|digit）* 10 >= 24 dight dight* 11 = 25 + 13 ；26—14 ( 27* 15 ) 28/ 16 # 02.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所示。
编译原理实验报告
实验一词法分析一、实验目的通过设计、编写和调试词法分析程序，了解词法分析程序的作用，组成结构，不同种类单词的识别方法，掌握由单词的词法规则出发，画出识别单词的状态转换图，然后在用程序实现词法分析程序设计方法。
二、词法规则1、注释用{和}括起来。
注释体中不能有{。
注释可以出现在任何记号的后面。
2、记号间的空格可有可无，但关键字前后必须有空格、换行、程序的开头或者结尾的原点。
3、标识符的记号id 与以字母开头的字母数字串相匹配：Letter->[a-zA-Z]Digit->[0-9]Id->letter (letter | digit)*4、记号num与无符号整数相匹配：Digits->digit digit*Optional_fraction -> . Digits | ɛOptional_exponent->(E(+ | - | ɛ ) digits) | ɛNum ->digits optional_fraction optional_exponent5、关键字要被保留且在文法中以黑体出现6、关系运算符（relop）指：=、<、<>、<=、>=、>7、Addop: + 、 - 、or8、Mulop：*、/ 、div、mod、and9、Assignop： :=三、词法分析程序详细设计及判别状态图1、无符号数（可带小数和指数）的状态转换图：2、标识符/关键字的状态转换图：字母或数程序详细设计：四、开发环境本程序在Microsoft Visual C++ 6.0环境中编写，无特殊编译要求。
五、函数清单void LexcialAnalysis(FILE *fp);//词法分析主函数int JudgeFirstLetter(char ch);//判断单词的第一个字符int IsDigit(char ch);//判断是否为数字int IsLetter(char ch);//判断是否为字母int IsSpecialPunc(char ch);//判断是否为特殊标点void RecogDigit(char StrLine[]);//用状态图识别无符号数字void RecogIdentifier(char strLine[]);//用状态图识别标识符void RecogPunc(char strLine[]);//识别特殊标点int IsKeyWord(string str);//判断标识符是否为关键字void error();//出错处理六、测试程序program example(input, output);{comments goes here!}var x, y: integer;function gcd(a, b: integer): integer;beginif b =1.2e3 then gcd := aelse gcd := gcd(b, a mod b)end;beginread(x, y);write(gcd(x, y));end.七、运行效果八、实验总结通过这次编译器词法分析程序的编写，我更好地了解了词法分析的作用及工作原理，讲课本中的知识融入到程序编写过程中，理论结合了实际。
编译原理语法分析实验报告
编译原理语法分析实验报告编译原理实验报告二、语法分析(一) 实验题目编写程序，实现对词法分析程序所提供的单词序列进行语法检查和结构分析。
(二) 实验内容和要求1. 要求程序至少能分析的语言的内容有:1) 变量说明语句2) 赋值语句3) 条件转移语句4) 表达式(算术表达式和逻辑表达式)5) 循环语句6) 过程调用语句2. 此外要处理:包括依据文法对句子进行分析;出错处理;输出结果的构造。
3. 输入输出的格式:输入:单词文件(词法分析的结果)输出:语法成分列表或语法树(都用文件表示)，错误文件(对于不合文法的句子)。
4. 实现方法:可以采用递归下降分析法，LL(1)分析法，算符优先法或LR分析法的任何一种，也可以针对不同的句子采用不同的分析方法。
(三) 实验分析与设计过程1. 待分析的C语言子集的语法:该语法为一个缩减了的C语言文法，估计是整个C语言所有文法的60%(各种关键字的定义都和词法分析中的一样)，具体的文法如下:语法:100: program -> declaration_list101: declaration_list -> declaration_list declaration | declaration 102: declaration -> var_declaration|fun_declaration103: var_declaration -> type_specifier ID;|type_specifier ID[NUM]; 104: type_specifier -> int|void|float|char|long|double|105: fun_declaration -> type_specifier ID (params)|compound_stmt 106: params -> params_list|void107: param_list ->param_list,param|param108: param -> type-spectifier ID|type_specifier ID[]109: compound_stmt -> {local_declarations statement_list}110: local_declarations -> local_declarations var_declaration|empty 111: statement_list -> statement_list statement|empty11编译原理实验报告112: statement -> epresion_stmt|compound_stmt|selection_stmt|iteration_stmt|return_stmt113: expression_stmt -> expression;|;114: selection_stmt -> if{expression)statement|if(expression)statement else statement115: iteration_stmt -> while{expression)statement116: return_stmt -> return;|return expression;117: expression -> var = expression|simple-expression118: var -> ID |ID[expression]119: simple_expression ->additive_expression relop additive_expression|additive_expression 120: relop -> <=|<|>|>=|= =|!=121: additive_expression -> additive_expression addop term | term 122: addop -> + | -123: term -> term mulop factor | factor124: mulop -> *|/125: factor -> (expression)|var|call|NUM126: call -> ID(args)127: args -> arg_list|empty128: arg_list -> arg_list,expression|expression该文法满足了实验的要求，而且多了很多的内容，相当于一个小型的文法说明:把文法标号从100到128是为了程序中便于找到原来的文法。
编译原理教程实验报告
一、实验目的本次实验旨在使学生通过编译原理的学习，了解编译程序的设计原理及实现技术，掌握编译程序的各个阶段，并能将所学知识应用于实际编程中。
二、实验内容1. 词法分析2. 语法分析3. 语义分析4. 中间代码生成5. 代码优化6. 目标代码生成三、实验步骤1. 词法分析（1）设计词法分析器，识别输入源代码中的各种词法单元；（2）使用C语言实现词法分析器，并进行测试。
2. 语法分析（1）根据文法规则设计语法分析器，识别输入源代码的语法结构；（2）使用C语言实现语法分析器，并进行测试。
3. 语义分析（1）设计语义分析器，检查语法分析后的语法树，确保语义正确；（2）使用C语言实现语义分析器，并进行测试。
4. 中间代码生成（1）设计中间代码生成器，将语义分析后的语法树转换为中间代码；（2）使用C语言实现中间代码生成器，并进行测试。
5. 代码优化（1）设计代码优化器，对中间代码进行优化，提高程序性能；（2）使用C语言实现代码优化器，并进行测试。
6. 目标代码生成（1）设计目标代码生成器，将优化后的中间代码转换为特定目标机的汇编语言；（2）使用C语言实现目标代码生成器，并进行测试。
四、实验结果与分析1. 词法分析实验结果：成功识别输入源代码中的各种词法单元，包括标识符、关键字、运算符、常量等。
2. 语法分析实验结果：成功识别输入源代码的语法结构，包括表达式、语句、程序等。
3. 语义分析实验结果：成功检查语法分析后的语法树，确保语义正确。
4. 中间代码生成实验结果：成功将语义分析后的语法树转换为中间代码，为后续优化和目标代码生成提供基础。
5. 代码优化实验结果：成功对中间代码进行优化，提高程序性能。
6. 目标代码生成实验结果：成功将优化后的中间代码转换为特定目标机的汇编语言，为程序在目标机上运行做准备。
五、实验心得1. 编译原理是一门理论与实践相结合的课程，通过本次实验，我对编译程序的设计原理及实现技术有了更深入的了解。
编译原理实验报告
实验五： 设计一个算法，求出任一上下文无关文法中所有导空符号，并输出。
实验六： 检查某段C源程序中，标识符的使用是否正确，即是否先声明后使用，或重复声明。假设数据类型只有int，float，double，char。
break;
}
if(temp[n*13+n2]=='k'&&zt[m]==0) //那些不能推出 空，但是因为要加入 其他非终结符的first集 而可能含有 空
n2++;
else if(n3>=n1) //for循环结束是因为n3而不是break ,即无相同字符
while(temp[n*13+n2]!='\0') //把z[n]对应的first加入temp[m*13+n1]这个first中，每个字符依次加在最后
{
for(n3=0;n3<n1;n3++) //循环判定是否有相同的字符
{
if(temp[m*13+n3]==temp[n*13+n2])
}
n++;
}
break; //break位于if(gs[n]==z2[m]),对于gs[n]已找到z2[m]完成任务跳出for循环
}
}
n2=m; //存放该for循环中m的值
n++;
}
//进一步处理集除去非终结符
m=0;n=0;n1=0;n2=0;
else n2++;
编译原理实验报告（一）
编译原理实验报告（一）一、实验题目：简单词法分析器的设计二、实验目的：熟悉并实现一个简单的扫描器三、实验内容：1．设计扫描器的自动机；2．设计翻译、生成Token的算法；3．编写代码并上机调试运行通过。
要求：输入——源程序文件；输出——（1）相应的Token序列；（2）关键字、界符表，符号表，常数表。
四、扫描器设计：自动机：关键字表和界符表单词编码program 3procedure 4④－begin 5end 6while 7do 8+ 9* 10⑧－：11:= 12⑨－= 13，14；15五、概要设计：（1）各模块概要设计1．判断当前读入的字符是字母还是数字int IsLetter(char ch) //判断ch是否为字母 { if (ch是A～Z或a～z) return 1;else return 0;}int IsDigit(char ch) //判断ch是否为数字{ if (ch是0～9) return 1;else return 0;}2．将读入的字符连接成单词或数while (IsLetter(ch)||IsDigit(ch)){ Concat(); //将ch中的字符拼接到strToken中ch=GetChar();}3．查表判断当前的独立串是关键字、标示符还是常数4．求出当前的独立串的code 和value（2）程序说明：1、关键字表、界符表和常数表中初始化后都有元素，即都不是空表。
而符号表则是空的。
它用来存放用户自己定义的变量名，按输入的被识别串中的顺序依次标识其value的值的1，2，3，……，n。
2、value=-1用来标识它是一个关键字；value=1用来标识它是一个界符常数的code值一定为2六、程序源代码及注释：#include "stdio.h"#include "string.h"#define N 15struct TokenType{ int code,value; };char*keywords[]={"program","procedure","begin","end","while","do","+","*",":",":=","=",",",";","(",")",}; //关键字表、界符表char ID[10][10]; //符号表int m;int Cons[10]; //常数表int n;void print(struct TokenTykpe token) //输出Token{ printf("( %d %d)\n",token.code,token.value);}void ProcError(){ printf("Error! You haven't defined it!");}int IsLetter(char ch) //判断ch是否为字母¸{ if (ch>='A' && ch<='Z' || ch>='a' && ch<='z')return 1; else return 0;}int IsDigit(char ch) //判断ch是否为数字{ if (ch>='0' && ch<='9') return 1;else return 0;}int Reserve(char *strToken) //用strToken中的单词去查关键字表。
(完整)编译原理实验报告(词法分析器 语法分析器)
编译原理实验报告实验一一、实验名称：词法分析器的设计二、实验目的：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）。
编译原理实验报告要求
编译原理实验报告学 院：专业班级：学生学号：学生姓名： 年 月 日 实验一：词法分析程序的设计与实现一实验目的基本掌握计算机语言的词法分析程序的开发方法。
二 实验内容编制一个能够分析整数、标识符、主要运算符和主要关键字的词法分析程序。
三.实验要求根据教材第四章内容设计词法分析程序。
四. 实验环境PC微机DOS操作系统或 Windows 操作系统Turbo C 程序集成环境或 Visual C++ 程序集成环境五. 实验步骤1. 根据状态图，设计词法分析算法或者根据GETSYM设计。
2. 采用C语言，设计函数getsym( )，实现该算法3. 编制测试程序（主函数main）。
4. 调试程序：输入一组单词，检查输出结果。
六. 基本测试数据输入数据例：正确结果：七. 实验报告要求实验报告应需要说明以下几个部分：1.词法分析程序设计思路2.词法分析程序的数据结构与算法3.关键程序说明、技术要点4.存在的问题及改进办法实验二：递归子程序实现语法分析一实验目的基本掌握计算机语言的语法分析程序的自顶向下分析方法。
二 实验内容编制一个能够分析表达式文法的递归分析程序。
三.实验要求采用递归子程序法，改写文法，构造语法分析程序表达式文法为：E → E + T | TT →T * F | FF →( E ) | i四. 实验环境PC微机DOS操作系统或 Windows 操作系统Turbo C 程序集成环境或 Visual C++ 程序集成环境五. 实验步骤1．考虑给定的文法，消除左递归，提取左因子。
2．编制递归子程序的算法3．连接实验一的词法分析函数getsym( )，进行测试4．编制测试程序（main函数）5．调试程序：输入一个语句，检查输出的结果六. 基本测试数据输入数据例：正确结果：七. 实验报告要求实验报告应需要说明以下几个部分：1.语法分析程序设计思路2.程序的数据结构与算法3.关键程序说明、技术要点4.存在的问题及改进办法实验三：算符优先分析实现 一实验目的基本掌握计算机语言的语法分析程序的自底向上分析方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
编译原理上机实验试题
一、实验目的
通过本实验使学生进一步熟悉和掌握程序设计语言的词法分析程序的设计原理及相关的设计技术，
如何针对确定的有限状态自动机进行编程序；熟悉和
掌握程序设计语言的语法分析程序的设计原理、熟悉
和掌握算符优先分析方法。
二、实验要求
本实验要求：①要求能熟练使用程序设计语言编程；②在上机之前要有详细的设计报告（预习报告）；
③要编写出完成相应任务的程序并在计算机上准确
地运行；④实验结束后要写出上机实验报告。
三、实验题目
针对下面文法G(S)：
S→v = E
E→E+E│E-E│E*E│E/E│（E）│v │i 其中，v为标识符，i为整型或实型数。
要求完成
①使用自动机技术实现一个词法分析程序；
②使用算符优先分析方法实现其语法分析程序，在
语法分析过程中同时完成常量表达式的计算。
1、题目（见“编译原理---实验题目.doc，“实验题目”中的第一项）
2、目的与要求（见“编译原理---实验题目.doc”）
3、设计原理：
(1)单词分类：标识符，保留字，常数，运算符，分隔符等等
(2)单词类型编码
(3)自动机
4、程序流程框图
5、函数原型（参数，返回值）
6、关键代码（可打印，只打印关键代码）
7、调试：
（1）调试过程中遇到的错误，如何改进的；
（2）需要准备测试用例（至少3个，包含输入和输出）——（可打印）
8、思考：
(1)你编写的程序有哪些要求是没有完成的，你觉得该采用什么方法去完成；
(2)或者是你觉得程序有哪些地方可以进一步完善，简述你的完善方案。
1、题目（见“编译原理---实验题目.doc，“实验题目”中的第二项）
2、目的与要求（见“编译原理---实验题目.doc”）
3、设计原理：构造出算法优先关系表
4、程序流程框图
5、函数原型（参数，返回值）
6、关键代码（可打印，只打印关键代码）
7、调试：
（1）调试过程中遇到的错误，如何改进的；
（2）需要准备测试用例（至少3个，包含输入和输出）——（可打印）
8、思考：
(1)你编写的程序有哪些要求是没有完成的，你觉得该采用什么方法去完成；
(2)或者是你觉得程序有哪些地方可以进一步完善，简述你的完善方案。