实验1-2 《编译原理》词法分析程序设计方案
编译原理实验报告2-词法分析程序的设计
实验2 词法分析程序的设计一、实验目的掌握计算机语言的词法分析程序的开发方法。
二、实验内容ﻩ编制一个能够分析三种整数、标识符、主要运算符和主要关键字的词法分析程序。
三、实验要求１、根据以下的正规式,编制正规文法,画出状态图;ﻩ标识符ﻩﻩﻩ<字母>(＜字母>｜＜数字字符>）*ﻩ十进制整数0 | (（1|2|3|4｜５|6｜7|8|９）（０|1|2｜3|4|５|６|7｜8|9）*）八进制整数0（1|2|３|４|５｜６｜７）（0|1｜２|3｜4｜5|6|7）＊十六进制整数0x(０|1|2｜3|4｜5|6|７｜8｜9｜ａ|b|c|d|e|f)(０|1｜2|３｜4｜５|6|7｜８|9｜a｜b|ｃ|d|e｜f）＊运算符和界符ﻩ+ －＊/ >< = ( ) ；ﻩﻩ关键字ﻩﻩｉf then ｅｌsｅwｈiｌe do2、根据状态图,设计词法分析函数iｎt scaｎ( )，完成以下功能:1）从文本文件中读入测试源代码,根据状态转换图,分析出一个单词,2）以二元式形式输出单词<单词种类，单词属性>其中单词种类用整数表示:０：标识符１:十进制整数2:八进制整数3:十六进制整数运算符和界符,关键字采用一字一符，不编码其中单词属性表示如下：标识符,整数由于采用一类一符,属性用单词表示运算符和界符,关键字采用一字一符,属性为空ﻩ3、编写测试程序,反复调用函数ｓcａn( )，输出单词种别和属性。
四、实验环境PＣ微机DＯS操作系统或Ｗindowｓ操作系统Tuｒbo C 程序集成环境或Ｖisｕal C++程序集成环境五、实验步骤1、根据正规式，画出状态转换图;2、根据状态图,设计词法分析算法；观察状态图,其中状态2、4、7、1０(右上角打了星号）需要回调一个字符。
声明一些变量和函数:ch：字符变量，存放最新读进的源程序字符。
ｓtrToｋen: 字符串变量，存放构成单词符号的字符串。
GｅtChar():ﻩ子函数，将下一输入字符读到ch中，搜索指示器前移一字符位置。
编译原理实验：词法分析
} void main() {
p=0; printf("\n please input string :\n"); do{
ch=getchar(); prog[p++]=ch; }while(ch!='#'); p=0; do { scaner(); switch(syn) {
case 11 : printf("(%d,%d)",syn,sum); break;
case -1 : printf(" error \n"); break;
default: printf("(%d,%s)",syn,token); } }while (syn!=0); } （备注：代码可以运行） 5.实验感想 通过此次实验，学习到了扫描程序的算法思想和具体的源代码的编 写，成功设计，编写，并调试了一个词法分析程序，使我加深了对词法 分析原理的理解，编写程序的过程中也是对学过的c语言的相关知识的 复习，加强了使用c语言编程的熟练程度，一定程度上也提高了自己的 动手能力。
ch=prog[p++]; if(ch == '>') {
syn=21; token[m++] = ch; } else if(ch == '=') { syn=22; token[m++] = ch;
} else{
syn = 20; p--; } break; case '>': m=0;token[m++] = ch; ch=prog[p++]; if(ch == '=') { syn=24; token[m++] = ch; } else{ syn=24; p--; } break; case ':': m=0;token[m++] = ch; ch=prog[p++]; if(ch == '=') {
编译原理实验 词法分析&语法分析程序
编译原理实验词法分析程序实验一：词法分析程序1、实验目的从左至右逐个字符的对源程序进行扫描，产生一个个单词符号，把字符串形式的源程序改造成单词符号形式的中间程序。
2、实验内容表C语言子集的单词符号及内码值单词符号种别编码助记符内码值while 1 while --if 2 if --else 3 else --switch 4 switch --case 5 case --标识符 6 id id在符号表中的位置常数7 num num在常数表中的位置+ 8 + --- 9 - --* 10 * --<= 11 relop LE< 11 relop LT== 11 relop LQ= 12 = --; 13 ; --输入源程序如下if a==1 a=a+1;else a=a+2;输出对应的单词符号形式的中间程序3、实验过程实验上机程序如下：#include "stdio.h"#include "string.h"int i,j,k;char s ,a[20],token[20];int letter(){if((s>=97)&&(s<=122))return 1;else return 0;}int Digit(){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(){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 you source program,end('#'):\n");i=0;do{i=i+1;scanf("%c",&a[i]);}while(a[i]!='#');i=1;memset(token,0,sizeof(char)*10);j=0;get();while(s!='#'){if(s==' '||s==10||s==13)get();else{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(Digit()||letter()){token[j]=s;j=j+1;get();}retract();k=lookup();if(k==0)printf("(6,%s)\n",token); elseprintf("(%d,null)\n",k); break;case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':while(Digit()){token[j]=s;j=j+1;get();}retract();printf("(%d,%s)\n",7,token); break;case'+':printf("(+,null)\n"); break;case'-':printf("(-,null)\n"); break;case'*':printf("(*,null)\n"); break;case'<':get();if(s=='=')printf("(relop,LE)\n"); else{retract();printf("(relop,LT)\n");}break;case'=':get();if(s=='=')printf("(relop,EQ)\n"); else{retract();printf("(=,null)\n");}break;case';':printf("(;,null)\n"); break;default:printf("(%c,error)\n",s);break;}memset(token,0,sizeof(char)*10);j=0;get();}}}4、实验结果实验结果分析：if是关键字，对应种别编码为2，输出（2，null）a是标识符，对应种别编码为6，值为a，输出（6，a）==的助记符是relop，内码值为LE，输出（relop，LE）1是常数，对应种别编码为7，值为1，输出（7，1）a是标识符，对应种别编码为6，值为a，输出（6，a）=是赋值符号，直接输出，（=，null）a是标识符，对应种别编码为6，值为a，输出（6，a）+是运算符，直接输出（=，null）1是常数，对应种别编码为7，值为1，输出（7，1）；是语句结束符号，直接输出（；，null）else是关键字，对应种别编码为3，输出（3，null）a是标识符，对应种别编码为6，值为a，输出（6，a）=是赋值符号，直接输出，（=，null）a是标识符，对应种别编码为6，值为a，输出（6，a）+是运算符，直接输出（=，null）2是常数，对应种别编码为7，值为2，输出（7，2）；是语句结束符号，直接输出（；，null）#是输入结束标志编译原理实验语法分析程序实验二：语法分析程序1、实验目的：将单词组成各类语法单位，讨论给类语法的形成规则，判断源程序是否符合语法规则3、实验内容：给定文法：G[E]:E→E+E|E-E|E*E|E/E|(E)E→0|1|2|3|4|5|6|7|8|9首先把G[E]构造为算符优先文法，即：G’[E]:E→E+T|TT→T-F|FF→F*G|GG→G/H|HH→(E)|i得到优先关系表如下：+ - * / i ( ) # + ·><·<·<·<·<··>·> - ·>·><·<·<·<··>·> * ·>·>·><·<·<··>·> / ·>·>·>·><·<··>·>i ·>·>·>·>·>·>( <·<·<·<·<·<·=) ·>·>·>·>·>·> # <·<·<·<·<·<·=构造出优先函数+ - * / i ( ) #f 6 8 10 12 12 2 12 2g 5 7 9 11 13 13 2 2要求输入算术表达式：（1+2）*3+2*（1+2）-4/2输出其对应的语法分析结果4、实验过程：上机程序如下：#include "stdio.h"#include "string.h"char a[20],optr[10],s,op;int i,j,k,opnd[10],x1,x2,x3;int operand(char s){if((s>=48)&&(s<=57))return 1;else return 0;}int f(char s){switch(s){case'+':return 6;case'-':return 8;case'*':return 10;case'/':return 12;case'(':return 2;case')':return 12;case'#':return 2;default:printf("error");}}int g(char s){switch(s){case'+':return 5;case'-':return 7;case'*':return 9;case'/':return 11;case'(':return 13;case')':return 2;case'#':return 2;default:printf("error");}}void get(){s=a[i];i=i+1;}void main(){printf("请输入算数表达式，并以‘#’结束:\n");i=0;do{scanf("%c",&a[i]);i++;}while(a[i-1]!='#');i=0;j=0;k=0;optr[j]='#';get();while((optr[j]!='#')||(s!='#')){if(operand(s)){opnd[k]=s-48;k=k+1;get();}else if(f(optr[j])<g(s)){j=j+1;optr[j]=s;get();}else if(f(optr[j])==g(s)){if(optr[j]=='('&&s==')'){j=j-1;get();}else if(optr[j]=='('&&s=='#'){printf("error\n");break;}else if(optr[j]=='#'&&s==')'){printf("error\n");break;}}else if(f(optr[j])>g(s)){op=optr[j];j=j-1;x2=opnd[k-1];x1=opnd[k-2];k=k-2;switch(op){case'+':x3=x1+x2;break;case'-':x3=x1-x2;break;case'*':x3=x1*x2;break;case'/':x3=x1/x2;break;}opnd[k]=x3;k=k+1;printf("(%c,%d,%d,%d)\n",op,x1,x2,x3);}else{printf("error\n");break;}}if(j!=0||k!=1)printf("error\n");}5、实验结果：实验结果分析：（1+2）*3+2*（1+2）-4/2#因为‘）’优先级大于‘*’，先计算1+2=3，并输出（+，1，2，3）原式变为：3*3+2*（1+2）-4/2#因为‘*’优先级大于‘+’，先计算3*3=9，并输出（*，3，3，9）原式变为：9+2*（1+2）-4/2#因为‘）’优先级大于‘-’，先计算1+2=3，并输出（+，1，2，3）原式变为：9+2*3-4/2#因为‘*’优先级大于‘-’，先计算2*3=6，并输出（*，2，3，6）原式变为：9+6-4/2#因为‘/’优先级大于‘#’，先计算4/2=2，并输出（/，4，2，2）原式变为：9+6-2#因为‘-’优先级大于‘#’，先计算6-2=4，并输出（-，6，2，4）原式变为：9+4#因为‘+’优先级大于‘#’，计算9+4=13，并输出（+，9，4，13）原式变为13#优先级等于#，跳出while循环，运算结束！。
编译原理词法分析实验
编译原理词法分析实验一、实验目的本实验旨在通过编写一个简单的词法分析器，了解编译原理中词法分析的基本原理和实现方法。
二、实验材料1. 计算机编程环境2. 编程语言三、实验步骤1. 了解词法分析的概念和作用。
词法分析是编译器中的第一个阶段，它的主要任务是将源代码中的字符序列转化为有意义的标识符，如关键字、操作符、常量和标识符等。
2. 设计词法分析器的流程和算法。
词法分析器的主要原理是通过有限状态自动机来识别和提取标识符。
在设计过程中，需考虑各种可能出现的字符序列，并定义相应的状态转移规则。
3. 根据设计的流程和算法，使用编程语言编写词法分析器的代码。
4. 编译并运行词法分析器程序，输入待分析的源代码文件，观察程序的输出结果。
5. 分析输出结果，检查程序是否正确地提取了源代码中的标识符。
四、实验结果经过词法分析器的处理，源代码将被成功地转化为有意义的标识符。
结果可以通过以下几个方面来验证：1. 关键字和操作符是否被正确识别和提取。
2. 常量和标识符是否被正确识别和提取。
3. 检查程序的错误处理能力，如能否发现非法字符或非法标识符。
4. 输出结果是否符合预期，可与自己编写的语法规则进行对比。
5. 对于特殊情况，如转义字符等是否正确处理。
五、实验总结通过本次实验，我深入了解了编译原理中词法分析的重要性和基本原理。
编写词法分析器的过程中，我学会了使用有限状态自动机来识别和提取标识符，并通过实践巩固了相关知识。
此外，我还对源代码的结构有了更深入的了解，并且掌握了如何运用编程语言来实现词法分析器。
通过本次实验，我不仅提升了自己的编程技术，也对编译原理有了更深入的认识和理解。
六、实验心得通过实验，我深刻体会到了词法分析在编译过程中的重要性。
合理设计和实现词法分析器，可以大大提高编译器的效率和准确性。
同时，通过编写词法分析器的代码，我不仅锻炼了自己的编程能力，还提升了对编译原理的理解和掌握。
这次实验让我更加深入地了解了编译原理中的词法分析，也为我今后在编程领域的发展打下了坚实的基础。
(完整word版)编译原理词法分析程序实现实验报告
(完整word版)编译原理词法分析程序实现实验报告实验一词法分析程序实现一、实验内容选取无符号数的算术四则运算中的各类单词为识别对象，要求将其中的各个单词识别出来。
输入：由无符号数和+，－，*，/, ( , ) 构成的算术表达式，如1.5E+2－100。
输出：对识别出的每一单词均单行输出其类别码（无符号数的值暂不要求计算）。
二、设计部分因为需要选取无符号数的算术四则运算中的各类单词为识别对象，要求将其中的各个单词识别出来，而其中的关键则为无符号数的识别，它不仅包括了一般情况下的整数和小数，还有以E为底数的指数运算，其中关于词法分析的无符号数的识别过程流程图如下：GOTO 1:(完整word版)编译原理词法分析程序实现实验报告GOTO 2:三、源程序代码部分#include <stdio.h>#include<stdlib.h>#include <math.h>#define MAX 100#define UNSIGNEDNUMBER 1#define PLUS 2#define SUBTRACT 3#define MULTIPLY 4#define DIVIDE 5#define LEFTBRACKET 6#define RIGHTBRACKET 7#define INEFFICACIOUSLABEL 8#define FINISH 111int count=0;int Class;void StoreType();int Type[100];char Store[20]={'\0'};void ShowStrFile();//已经将要识别的字符串存在文件a中void Output(int a,char *p1,char *p2);//字符的输出过程int Sign(char *p);//'+''-''*''/'整体识别过程int UnsignedNum(char *p);//是否适合合法的正整数0~9int LegalCharacter(char *p);//是否是合法的字符：Sign(p)||UnsignedNum(p)||'E'||'.' void DistinguishSign(char *p);//'+''-''*''/'具体识别过程void TypyDistinguish();//字符的识别过程void ShowType();//将类别码存储在Type[100]中，为语法分析做准备void ShowStrFile()//已经将要识别的字符串存在文件a中{FILE *fp_s;char ch;if((fp_s=fopen("a.txt","r"))==NULL){printf("The FILE cannot open!");exit(0);}elsech=fgetc(fp_s);while(ch!=EOF){putchar(ch);ch=fgetc(fp_s);}printf("\n");}void StoreStr()//将文件中的字符串存储到数组Store[i] {FILE *fp=fopen("a.txt","r");char str;int i=0;while(!feof(fp)){fscanf(fp,"%c",&str);if(str=='?'){Store[i]='\0';break;}Store[i]=str;i++;}Store[i]='\0';}void ShowStore(){int i;for (i=0;Store[i]!='\0';i++)printf("%c",Store[i]);printf("\n");}void Output(int a,char *p1,char *p2){printf("%3s\t%d\t%s\t","CLASS",a,"VALUE");while(p1<=p2){printf("%c",*p1);p1++;}printf("\n");}int Sign(char *p){char ch=*p;if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')') return 1;elsereturn 0;}int UnsignedNum(char *p){char ch=*p;if('0'<=ch&&ch<='9')return 1;elsereturn 0;}int LegalCharacter(char *p){char ch=*p;if(Sign(p)||UnsignedNum(p)||ch=='E'||ch=='.')。
编译原理实验 词法分析
实验一简单词法分析器构造（4学时）一实验目的1、掌握正则表达式、有限自动机2、构造简单的词法分析器二词法规则（C语言分析及状态转换图）1、C语言说明C语言有以下记号及单词（1）标识符：以字母或下划线开头的，后跟字母、数字或下划线组成的符号串。
（2）保留字：标识符的子集。
（3）无符号数：（4）关系运算符：>、<、>=、<= 、= = 、!=（5）标点符号：+、－、*、/、（、）、：、，、；等（6）赋值号：=（7）注释标记：以‘/*’开始，以‘*/’结束。
（8）单词符号间的分隔符：空格。
2、记号的正规表达式（学生完成）（1）标识符：（2）无符号数：（3）关系运算符：（4）赋值号：（5）标点符号：3、状态转换图为每种记号的文法构造出相应的状态转换图，让这些状态转换图共用一个初态，就可以得到词法分析器的状态转换图，如图1所示。
（部分）...图 1 （a）关系运算符的状态转换图（b）标识符的状态转换图（c）数字的状态转换图三、词法分析器的构造与实现1、词法分析器的算法框图在开始状态，首先要读进一个字符。
若读入的是一个空格（包括blank,tab,newline）就跳过它，再继续读字符，直到读进一个非空字符为止。
在标识符状态，识别并组合出一个标识符之后，还必须加入一些动作，以便查保留字表，确定识别出的单词符号是保留字，还是用户自定义标识符，并输出相应的记号。
在无符号数状态，可识别出各种常数，包括整数在内。
在组数的同时，还要做从十进制数到二进制数的转换。
.2、程序结构图：注：1 Scanner功能：完成初始化，并循环调用子模块完成单词的识别2 IsAlpha功能：识别保留字和标识符3 IsNumber功能：识别数字4 IsOther功能：识别其他字符5 OutPut功能：输出识别的单词（二元式）6 Error功能：出错处理程序代码（略）四. 源代码#include "stdafx.h"#include "stdio.h"#include "ctype.h"#include "string.h"#include "conio.h"#include "stdlib.h"#define KEYWORD_LEN 32#define STR_MAX_LEN 300#define PRO_MAX_LEN 20480#define STB_MAX_LEN 1000#define CTB_MAX_LEN 1000#define ERROR 0#define ID (KEYWORD_LEN+1)#define CONST (KEYWORD_LEN+2)#define OPERAT (KEYWORD_LEN+3)#define DIVIDE (KEYWORD_LEN+4)int errorLine=0;char proBuffer[PRO_MAX_LEN] = "";char ch;char wordget[STR_MAX_LEN];int point = 0;char signTab[STB_MAX_LEN][STR_MAX_LEN];int pointSTB = 0;char constTab[CTB_MAX_LEN][STR_MAX_LEN];int pointCTB = 0;char kwTab[KEYWORD_LEN][10]={ "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", "union", "unsigned", "void","volatile", "while"};char errorTab[][50]={/*0*/"未知错误", /*1*/"非法的字符", /*2*/"不正确的字符常量表达",/*3*/"不正确的字符串表达", /*4*/"不正确的数字表达", /*5*/"注释丢失'*/'"};typedef struct signDuality{int kind;int value;}*pDualistic, Dualistic;void pretreatment();void ProcError(int id);bool GetChar();bool GetBC();void Concat(char *str);int Reserve(char *str);void Retract();int InsertId(char *str);int InsertConst(char *str);bool wordAnalyse(pDualistic pDu);void pretreatment(){int lines=0;char tmp[PRO_MAX_LEN];int tmpp = 0;bool flg;char tmpc;point = 0;do{flg = GetChar();if(ch == '/'){flg = GetChar();switch(ch){case '/':do{flg = GetChar();}while(!(ch == '\n' || flg == false));if(ch == '\n')Retract();break;case '*':do{flg = GetChar();tmpc = ch;if(tmpc == '\n')tmp[tmpp++] = tmpc;flg = GetChar();Retract();}while(flg && !(flg && tmpc == '*' && ch == '/'));flg = GetChar();if (!flg){ProcError(5);}break;default:Retract();Retract();GetChar();tmp[tmpp++] = ch;flg = GetChar();tmp[tmpp++] = ch;}}else{tmp[tmpp++] = ch;}}while(flg);tmp[tmpp] = '\0';strcpy(proBuffer,tmp);//}void ProcError(int id){printf("\nError:第%d行,%s\n",errorLine, errorTab[id]); }bool GetChar(){if(point < PRO_MAX_LEN && proBuffer[point] != '\0') {ch = proBuffer[point++];if (ch == '\n')errorLine ++;return true;}ch = '\0';return false;}bool GetBC(){do{if(!GetChar()){ch = '\0';return false;}}while(isspace(ch));return true;}void Concat(char *str){int i;for(i=0; str[i]; ++i);str[i] = ch;str[i+1] = '\0';}int Reserve(char *str){int i;for(i=0; i<KEYWORD_LEN; ++i){if(0 == strcmp(kwTab[i], str))return i+1;}return 0;}void Retract(){if(proBuffer[point] == '\n' && errorLine > 0) errorLine --;point --;}int InsertId(char *str){int i;for(i=0; i < pointSTB; ++i)if(0 == strcmp(signTab[i], str))return i;strcpy(signTab[pointSTB++], str);return (pointSTB-1);}int InsertConst(char *str){int i;for(i=0; i < pointCTB; ++i)if(0 == strcmp(constTab[i], str))return i;strcpy(constTab[pointCTB++], str);return (pointCTB-1);}bool wordAnalyse(pDualistic pDu){int code, value;char judge;int i = 0;GetBC();judge = ch;if (isalpha(ch) || ch == '_') judge='L';if (isdigit(ch)) judge='D';switch(judge){case 'L':while(isalnum(ch) || ch == '_'){wordget[i++] = ch;GetChar();}wordget[i] = '\0';Retract();code = Reserve(wordget);if(code == 0){value = InsertId(wordget);pDu->kind = ID;pDu->value = value;}else{pDu->kind = code;pDu->value = -1;}return true;case 'D':while(isdigit(ch)){wordget[i++] = ch;GetChar();}wordget[i] = '\0';Retract();value = InsertConst(wordget);pDu->kind = CONST;pDu->value= value;return true;case '"':do{wordget[i++] = ch;GetChar();}while(ch != '"' && ch != '\0');wordget[i++] = ch; wordget[i] = '\0';if(ch == '\0'){printf("%s",wordget);ProcError(3);pDu->kind = ERROR;pDu->value = 0;}else{value = InsertConst(wordget);pDu->kind = CONST;pDu->value = value;}return true;case '\'':wordget[i++] = ch;GetChar();wordget[i++] = ch;if(ch == '\\'){GetChar();wordget[i++] = ch;}GetChar();wordget[i++] = ch;wordget[i] = '\0';if(ch != '\''){printf("%s",wordget);ProcError(2);pDu->kind = ERROR;pDu->value = 0;}else{value = InsertConst(wordget);pDu->kind = CONST;pDu->value = value;}return true;case '(':case ')':case '[':case ']':case '.':case ',':case '~':case '?':case ':':case ';':case '{':case '}':case '#':wordget[i++] = ch; wordget[i] = '\0';pDu->kind = DIVIDE;pDu->value = -1;return true;case '!':wordget[i++] = ch;GetChar();if (ch=='=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '<':wordget[i++] = ch;GetChar();if (ch == '<' || ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '>':wordget[i++] = ch;GetChar();if (ch == '>' || ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '=':wordget[i++] = ch;GetChar();if (ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '&':wordget[i++] = ch;GetChar();if (ch == '&' || ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '|':wordget[i++] = ch;GetChar();if (ch == '|' || ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '+':wordget[i++] = ch;GetChar();if (ch == '+' || ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '-':wordget[i++] = ch;GetChar();if (ch == '-' || ch == '=' || ch == '>') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '*':wordget[i++] = ch;GetChar();if (ch == '*' || ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '/':wordget[i++] = ch;GetChar();if (ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '%':wordget[i++] = ch;GetChar();if (ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '^':wordget[i++] = ch;GetChar();if (ch == '=') wordget[i++] = ch;else Retract();wordget[i]='\0';break;case '\0':return false;default:ProcError(1);return false;}pDu->kind = OPERAT;return true;}int main(int argc, char* argv[]){Dualistic tmp;pDualistic ptmp = &tmp;FILE *fin, *fout;int i;char c;printf("源代码读入\n");if ((fin=fopen("Test.c","r")) == NULL){printf("Cannot open infile\n");return 0;}i = 0;while((c = fgetc(fin)) != EOF){if(i >= PRO_MAX_LEN-1){printf("\n程序代码太长，无法处理\a");return 0;}proBuffer[i++] = c;}fclose(fin);proBuffer[i++] = '\0';printf("\n***************************\n源代码读入成功，源代码如下:\n%s",proBuffer);printf("\n按任意键继续\n"); getch();printf("\n预处理\n");pretreatment();printf("\n***************************\n预处理成功，去掉注释后的源代码为:\n%s",proBuffer);printf("\n按任意键继续\n"); getch();printf("\n词法分析\n");point = 0;if ((fout=fopen("Result.txt","wb")) == NULL){printf("建立文件Result.txt失败。
《编译原理》实验教学大纲
《编译原理》实验教学大纲一、实验目的和任务编译原理是计算机科学与技术专业的一门重要课程，它主要研究的是将高级语言程序翻译成机器语言程序的方法和技术。
通过本实验课程的学习，旨在使学生掌握编译原理的基本原理和方法，培养学生对编译器结构与构造技术的专门知识和技能，为学生今后进行编译器设计与实现打下基础。
二、实验设备和工具1.计算机和相关硬件设备2. 编程语言的开发环境，如C/C++或Java三、实验内容1.实验一：词法分析器设计与实现a)实验目的：学习词法分析器的原理和设计方法，掌握正则表达式、DFA和NFA的转换方法。
b)实验任务：i.设计并实现一个词法分析器的原型，能够正确地识别出给定的程序中的词法单元。
ii. 使用给定的正则表达式设计并实现识别给定程序中的关键字、标识符、常量等的词法分析器。
2.实验二：语法分析器设计与实现a)实验目的：学习语法分析器的原理和设计方法，掌握上下文无关文法和LR分析表的构造方法。
b)实验任务：i.学习并理解上下文无关文法和LR分析表的构造方法。
ii. 设计并实现一个简单的递归下降语法分析器。
3.实验三：语义分析器设计与实现a)实验目的：学习语义分析器的原理和设计方法，掌握语义动作的定义和处理方法。
b)实验任务：i.学习并理解语义分析器的原理和设计方法。
ii. 设计并实现一个简单的语义分析器，能够对给定的程序进行语义分析和语义动作的处理。
4.实验四：中间代码生成器设计与实现a)实验目的：学习中间代码生成器的原理和设计方法，掌握中间代码的生成和优化方法。
b)实验任务：i.学习并理解中间代码生成器的原理和设计方法。
ii. 设计并实现一个简单的中间代码生成器，能够将给定的程序翻译成中间代码。
5.实验五：目标代码生成器设计与实现a)实验目的：学习目标代码生成器的原理和设计方法，掌握目标代码的生成和优化方法。
b)实验任务：i.学习并理解目标代码生成器的原理和设计方法。
ii. 设计并实现一个简单的目标代码生成器，能够将中间代码翻译成目标代码。
编译原理实验报告(一)----词法分析程序
结束
是 转关键字和标识符处理
是 转数字处理
是 转运算符处理
)[p--8]
{[p--23] char[k--0] ch[i--5] ;[p--13]
关闭所有文件
下面简要分析一下词法分析程序的运行流程：
能否打开所要编译的 C 语言文 件
能
判断当前字符是否是文件结束符
否
报错 是
否
是
从源判程断序当中前读字入符一是行否到是数’组\n缓’ 冲区
否
判断当前字符是否是字母
否 判断当前字符是否是数字
否 判断当前字符是否是运算符
否
【程序调试】 现有源程序 a.c 清单如下： #include <stdio.h> int main(int argc, char *argv[]) {char ch; int i; ch='a'; ch=ch+32 ; i=ch; printf("%d id %c\n",i,ch);/*打印*/ return 0; } 运行词法分析程序后，显示如下结果： after_com.txt 文件： #[p--2] include[i--0] <[p--14] stdio.h[i--1] >[p--16]
"fclose","exit","r","read","close","w","fprintf"};
编译原理实验报告：实验一编写词法分析程序
编译原理实验报告实验名称：实验一编写词法分析程序实验类型：验证型实验指导教师：***专业班级：13软件四*名：**学号：电子邮箱：实验地点：秋白楼B720实验成绩：日期：2016年3 月18 日一、实验目的通过设计、调试词法分析程序，实现从源程序中分出各种单词的方法；熟悉词法分析程序所用的工具自动机，进一步理解自动机理论。
掌握文法转换成自动机的技术及有穷自动机实现的方法。
确定词法分析器的输出形式及标识符与关键字的区分方法。
加深对课堂教学的理解；提高词法分析方法的实践能力。
通过本实验，应达到以下目标：1、掌握从源程序文件中读取有效字符的方法和产生源程序的内部表示文件的方法。
2、掌握词法分析的实现方法。
3、上机调试编出的词法分析程序。
二、实验过程以编写PASCAL子集的词法分析程序为例1.理论部分（1）主程序设计考虑主程序的说明部分为各种表格和变量安排空间。
数组 k为关键字表，每个数组元素存放一个关键字。
采用定长的方式，较短的关键字后面补空格。
P数组存放分界符。
为了简单起见，分界符、算术运算符和关系运算符都放在 p表中（编程时，还应建立算术运算符表和关系运算符表，并且各有类号），合并成一类。
id和ci数组分别存放标识符和常数。
instring数组为输入源程序的单词缓存。
outtoken记录为输出内部表示缓存。
还有一些为造表填表设置的变量。
主程序开始后，先以人工方式输入关键字，造 k表；再输入分界符等造p表。
主程序的工作部分设计成便于调试的循环结构。
每个循环处理一个单词；接收键盘上送来的一个单词；调用词法分析过程；输出每个单词的内部码。
⑵词法分析过程考虑将词法分析程序设计成独立一遍扫描源程序的结构。
其流程图见图1-1。
图1-1该过程取名为 lexical，它根据输入单词的第一个字符（有时还需读第二个字符），判断单词类，产生类号：以字符 k表示关键字；i表示标识符；c表示常数；p表示分界符；s表示运算符（编程时类号分别为 1，2，3，4，5）。
实验《编译原理》词法分析程序设计方案
实验1-3 《编译原理》S语言词法分析程序设计方案一、实验目的了解词法分析程序的两种设计方法之一：根据状态转换图直接编程的方式；二、实验内容1．根据状态转换图直接编程编写一个词法分析程序，它从左到右逐个字符的对源程序进行扫描，产生一个个的单词的二元式，形成二元式（记号）流文件输出。
在此，词法分析程序作为单独的一遍，如下图所示。
具体任务有：（1）组织源程序的输入（2）拼出单词并查找其类别编号，形成二元式输出，得到单词流文件（3）删除注释、空格和无用符号（4）发现并定位词法错误，需要输出错误的位置在源程序中的第几行。
将错误信息输出到屏幕上。
（5）对于普通标识符和常量，分别建立标识符表和常量表（使用线性表存储），当遇到一个标识符或常量时，查找标识符表或常量表，若存在，则返回位置，否则返回0并且填写符号表或常量表。
标识符表结构：变量名，类型（整型、实型、字符型），分配的数据区地址注：词法分析阶段只填写变量名，其它部分在语法分析、语义分析、代码生成等阶段逐步填入。
常量表结构：常量名，常量值三、实验要求1．能对任何S语言源程序进行分析在运行词法分析程序时，应该用问答形式输入要被分析的S源语言程序的文件名，然后对该程序完成词法分析任务。
2．能检查并处理某些词法分析错误词法分析程序能给出的错误信息包括：总的出错个数，每个错误所在的行号，错误的编号及错误信息。
本实验要求处理以下两种错误（编号分别为1，2）：1：非法字符：单词表中不存在的字符处理为非法字符，处理方式是删除该字符，给出错误信息，“某某字符非法”。
2：源程序文件结束而注释未结束。
注释格式为：/* …… */单词的构词规则：字母=[A-Za-z]数字=[0-9]标识符=（字母|_）（字母|数字）*数字=数字(数字)*(.数字+|?)四、S语言表达式和语句说明1．算术表达式:+、-、*、/、%2．关系运算符：>、>=、<、<=、==、！=3．赋值运算符：=，+=、-=、*=、/=、%=4．变量说明：类型标识符变量名表；5．类型标识符：int char float6．If语句：if 表达式then 语句 [else 语句]7．For语句：for（表达式1；表达式2；表达式3）语句8．While语句：while 表达式 do 语句9．S语言程序：由函数构成，函数不能嵌套定义。
《编译原理》科学实验指导说明书
《编译原理》实验指导书实验一词法分析器的设计一、实验目的和要求加深对状态转换图的实现及词法分析器的理解。
熟悉词法分析器的主要算法及实现过程。
要求学生掌握词法分析器的设计过程，并实现词法分析。
二、实验基本内容给出一个简单语言的词法规则，画出状态转换图，并依据状态转换图编制出词法分析程序，能从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单Error”，然后跳过错误部分继续显示）词法规则如下：三、实验时间：上机三次。
第一次按照自己的思路设计一个程序。
第二、三次在理论课学习后修改程序，使得程序结构更加合理。
四、实验过程和指导：（一）准备：1.阅读课本有关章节（c/c++，数据结构），花一周时间明确语言的语法，写出基本算法以及采用的数据结构和要测试的程序例。
2.初步编制好程序。
3.准备好多组测试数据。
（二）上课上机：将源代码拷贝到机上调试，发现错误，再修改完善。
（三）程序要求：程序输入/输出示例：输入如下一段：main(){/*一个简单的c++程序*/int a,b; //定义变量a = 10;b = a + 20;}要求输出如右图。
要求：(1) 剔除注解符(2) 常数为无符号整数（可增加实型数，字符型数等）（四）练习该实验的目的和思路：程序开始变得复杂起来，可能是大家以前编过的程序中最复杂的，但相对于以后的程序来说还是简单的。
因此要认真把握这个过渡期的练习。
程序规模大概为200行及以上。
通过练习，掌握对字符进行灵活处理的方法。
（五）为了能设计好程序，注意以下事情：1.模块设计：将程序分成合理的多个模块（函数/类），每个模块（类）做具体的同一事情。
2.写出（画出）设计方案：模块关系简图、流程图、全局变量、函数接口等。
3.编程时注意编程风格：空行的使用、注释的使用、缩进的使用等。
4．程序设计语言不限，建议使用面向对象技术及可视化编程语言，如C++，VC,JA V A,VJ++等。
编译原理实验(词法分析程序设计)
int Iskey(string c){ //关键字判断
int i;
for(i=0;i<MAX;i++) {
if(key[i].compare(c)==0) return 1;
}
return 0;
if((ch<='Z')&&(ch>='A')) ch=ch+32;
arr=arr+ch;
ch=fgetc(fpin);
}
fseek(fpin,-1L,SEEK_CUR);
if (Iskey(arr)){cout<<arr<<"\t$关键字"<<endl;}
else cout<<arr<<"\t$普通标识符"<<endl;
analyse(fpin);
fclose(fpin);
}
实验记录
程序测试：
1、文件位置：f:\\11.txt
目标程序如下：
begin
x:=9
if x>0 then x:=x+1;
while a:=0 do
b:=2*x/3;
end;
2、运行结果：
实验总结
通过此次实验，让我了解到如何设计、编制并调试词法分析程序，加深对词法分析原理的理解；熟悉了构造词法分析程序的手工方式的相关原理，使用某种高级语言（例如C++语言）直接编写此法分析程序。另外，也让我重新熟悉了C++语言的相关内容，加深了对C++语言的用途的理解。以后我会更加专心的研究计算机知识，不断将现实中遇到的实际问题，向程序方面转变，做到灵活运用所学知识。
《编译原理实验》实验指导书
广州大学实验课程建设项目《编译原理实验》实验指导书广州大学信息与机电工程学院计算机系2006年10月目录实验1 Pascal 语言的编译器的使用 3 实验2 词法分析（一） 13 (调试一个词法分析程序)实验3 词法分析（二） 16 (设计、编制并调试一个词法分析程序)实验4 语法分析（一） 19 （调试一个语法分析程序，了解编译程序中LR分析表的作用）实验5 语法分析（二） 22（设计、编制并调试一个语法分析程序）实验6 语义分析 24实验7 编译原理综合实验 26 实验报告示例：词法分析程序 47考试考核方式 53实验一：Pascal 语言的编译器的使用实验目的:调试一个Pascal 语言的编译器，加深对语言编译器的理解实验内容：此程序为Pascal 语言的编译器，支持Proc ，Repeat，If，While，For，Fun函数结构代码的编译，能生成变量表、常量表和汇编程序。
界面如下：图1 Pascal 语言的编译器的使用界面下面给出软件所能编译的代码和编译出的结果。
―――――――――――――――――――――――――――――――――――Proc函数结构代码：vara, b, i: integer;procedure p1(arg1: integer; arg2: integer);begina := arg1 * arg2;end;beginb := 123;p1(3, b);――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]b = unsigned[静], OffPos = 0[3]i = unsigned[静], OffPos = 0[4]arg1 = unsigned[参], OffPos = 0[5]arg2 = unsigned[参], OffPos = 1常量[0]Number = 123[静], OffPos = 0[1]Number = 3[静], OffPos = 0方法ID = 1, Name = p1, MethodType = 过程, ParamList = (4, 5), DynaV arList = (), Addr = 2 ＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 369[静], OffPos = 0[2]b = 123[静], OffPos = 0[3]i = unsigned[静], OffPos = 0[4]arg1 = unsigned[参], OffPos = 0[5]arg2 = unsigned[参], OffPos = 1汇编语句：0:Goto 0, 71:Return 0, 02:Mov 0, 43:Mov 0, 54:Mul 0, 05:Sto 1, 16:Return 0, 07:LoadConst 0, 08:Sto 0, 29:LoadConst 0, 110:Mov 0, 211:Call 0, 1 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――For结构代码：vara, b, i: integer;a := 0;for i := 0 to 100 dobegina := a + i;end;end;――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]b = unsigned[静], OffPos = 0[3]i = unsigned[静], OffPos = 0常量[0]Number = 0[静], OffPos = 0[1]Number = 0[静], OffPos = 0[2]Number = 100[静], OffPos = 0方法ID = 0, Name = ShowMessage, MethodType = 过程, ParamList = (0), DynaV arList = (), Addr = 1＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 5050[静], OffPos = 0[2]b = unsigned[静], OffPos = 0[3]i = 101[静], OffPos = 0汇编语句：0:Goto 0, 21:Return 0, 02:LoadConst 0, 03:Sto 0, 14:LoadConst 0, 15:Sto 0, 36:LoadConst 0, 27:Mov 0, 38:>=? 0, 09:IfFalseGoto 0, 1810:Mov 0, 111:Mov 0, 312:Add 0, 013:Sto 0, 114:Mov 0, 315:IncV ar 0, 116:Sto 0, 317:Goto 0, 6 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――While函数结构代码：vara, i: integer;begini := 0;a := 0;while i <= 100 dobegina := a +i;i := i +1;end;end;――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]i = unsigned[静], OffPos = 0常量[0]Number = 0[静], OffPos = 0[1]Number = 0[静], OffPos = 0[2]Number = 100[静], OffPos = 0[3]Number = 1[静], OffPos = 0方法ID = 0, Name = ShowMessage, MethodType = 过程, ParamList = (0), DynaV arList = (), Addr = 1＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 5050[静], OffPos = 0[2]i = 101[静], OffPos = 0汇编语句：0:Goto 0, 21:Return 0, 02:LoadConst 0, 03:Sto 0, 24:LoadConst 0, 15:Sto 0, 16:Mov 0, 27:LoadConst 0, 28:<=? 0, 09:IfFalseGoto 0, 1910:Mov 0, 111:Mov 0, 212:Add 0, 013:Sto 0, 114:Mov 0, 215:LoadConst 0, 316:Add 0, 017:Sto 0, 218:Goto 0, 6 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――Repeat函数结构代码：vara, i: integer;begina := 0;i := 0;repeata := a + i;i := i + 1;until i > 100;end; ――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]i = unsigned[静], OffPos = 0常量[0]Number = 0[静], OffPos = 0[1]Number = 0[静], OffPos = 0[2]Number = 1[静], OffPos = 0[3]Number = 100[静], OffPos = 0方法ID = 0, Name = ShowMessage, MethodType = 过程, ParamList = (0), DynaV arList = (), Addr = 1＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 5050[静], OffPos = 0[2]i = 101[静], OffPos = 0汇编语句：0:Goto 0, 21:Return 0, 02:LoadConst 0, 03:Sto 0, 14:LoadConst 0, 15:Sto 0, 26:Mov 0, 17:Mov 0, 28:Add 0, 09:Sto 0, 110:Mov 0, 211:LoadConst 0, 212:Add 0, 013:Sto 0, 214:Mov 0, 215:LoadConst 0, 316:>? 0, 017:IfFalseGoto 0, 6 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――Fun函数结构代码：vara, i: integer;function fun1(arg1, arg2: integer): integer;beginResult := arg1 + arg2;end;begina := 0;for i := 1 to 100 dobegina := fun1(a, i);end;end;――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]i = unsigned[静], OffPos = 0[3]arg1 = unsigned[参], OffPos = 0[4]arg2 = unsigned[参], OffPos = 1[5]Result = unsigned[动], OffPos = 2常量[0]Number = 0[静], OffPos = 0[1]Number = 1[静], OffPos = 0[2]Number = 100[静], OffPos = 0方法ID = 1, Name = fun1, MethodType = 函数, ParamList = (3, 4), DynaV arList = (5), Addr = 2 ＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 5050[静], OffPos = 0[2]i = 101[静], OffPos = 0[3]arg1 = unsigned[参], OffPos = 0[4]arg2 = unsigned[参], OffPos = 1[5]Result = unsigned[动], OffPos = 2汇编语句：0:Goto 0, 71:Return 0, 02:Mov 0, 33:Mov 0, 44:Add 0, 05:Sto 0, 56:Return 0, 07:LoadConst 0, 08:Sto 0, 19:LoadConst 0, 110:Sto 0, 211:LoadConst 0, 212:Mov 0, 213:>=? 0, 014:IfFalseGoto 0, 2315:Mov 0, 116:Mov 0, 217:Call 0, 118:Sto 0, 119:Mov 0, 220:IncV ar 0, 121:Sto 0, 222:Goto 0, 11 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――If 结构代码：vara, i: integer;begina := 2;if a = 1 thenbegini := 10;endelse begini := 100;end;end;――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]i = unsigned[静], OffPos = 0常量[0]Number = 2[静], OffPos = 0[1]Number = 1[静], OffPos = 0[2]Number = 10[静], OffPos = 0[3]Number = 100[静], OffPos = 0方法ID = 0, Name = ShowMessage, MethodType = 过程, ParamList = (0), DynaV arList = (), Addr = 1 ＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 2[静], OffPos = 0[2]i = 100[静], OffPos = 0汇编语句：0:Goto 0, 21:Return 0, 02:LoadConst 0, 03:Sto 0, 14:Mov 0, 15:LoadConst 0, 16:=? 0, 07:IfFalseGoto 0, 118:LoadConst 0, 29:Sto 0, 210:Goto 0, 1311:LoadConst 0, 312:Sto 0, 2 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――递归结构代码：vara, b: integer;function f1(arg: integer): integer;beginif arg <= 1 thenbeginResult := 1;endelse beginResult := arg * f1(arg - 1);end;end;begina := 10;b := f1(a);ShowMessage(b);end; ――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]b = unsigned[静], OffPos = 0[3]arg = unsigned[参], OffPos = 0[4]Result = unsigned[动], OffPos = 1常量[0]Number = 1[静], OffPos = 0[1]Number = 1[静], OffPos = 0[2]Number = 1[静], OffPos = 0[3]Number = 10[静], OffPos = 0方法ID = 1, Name = f1, MethodType = 函数, ParamList = (3), DynaV arList = (4), Addr = 2 ＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量：无汇编语句：Goto 0, 171:Return 0, 02:Mov 0, 33:LoadConst 0, 04:<=? 0, 05:IfFalseGoto 0, 96:LoadConst 0, 17:Sto 0, 48:Goto 0, 169:Mov 0, 310:Mov 0, 311:LoadConst 0, 212:Sub 0, 013:Call 0, 114:Mul 0, 015:Sto 0, 416:Return 0, 017:LoadConst 0, 318:Sto 0, 119:Mov 0, 120:Call 0, 121:Sto 0, 222:Mov 0, 223:Call 0, 0 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――实验二：词法分析（一）实验目的:调试一个词法分析程序，加深对词法分析原理的理解实验内容：（1）设一小型编译程序关于高级语言有如下的规定：高级语言程序具有四种基本结构：顺序结构﹑选择结构﹑循环结构和过程。
编译原理词法分析实验
实验报告
课程名称编译原理实验名称词法分析实验
一、实验目的
1．掌握词法分析程序设计与实现的原理、思想和具体过程；
2．加深对文法概念、扫描器概念、DFA\NFA、带有з动作的NFA、以及NFA的确定化等概念的理解。
二、实验环境
1．硬件环境：PC机；
2．软件环境：Windows环境，C语言系统。
三、实验内容与步骤
1．实验内容
使用高级语言编写一具有识别若干单词的词法分析程序，也可以使用词法分析生成工具Lex构造相应程序，要求能够识别出如下单词：BEGIN,END,IF,THEN,ELSE,标识符，常量，+，-，*，/，=，>，<等单词符号。
2．实验步骤
（1）画出识别各类单词的NFA图；
（2）使用Lex工具编出程序；
（3）上机输入、调试；
（4）分析实验结果；
由实验结果可知，该程序能够识别出源单词文件！
四、实验思考题
1．DFA图如何转换为程序？
（1）可以使用词法分析工具生成
（2）可以手动编写高级语言代码实现
2．实现词法分析的技术有哪些？
（1）正规文法
（2）状态矩阵法
（3）子集法
3．怎样实现更为有效的词法分析程序？
定义正规表达式和正规集，规范词法分析程序。
编译原理实验报告 词法分析
编译原理实验一·词法分析一、实验目的通过动手实践，使学生对构造编译系统的基本理论、编译程序的基本结构有更为深入的理解和掌握；使学生掌握编译程序设计的基本方法和步骤；能够设计实现编译系统的重要环节。
同时增强编写和调试程序的能力。
二、实验内容及要求对某特定语言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-4 《编译原理》S语言词法分析程序设计方案一、实验目的了解词法分析程序的两种设计方法：1.根据状态转换图直接编程的方式；2.利用DFA 编写通用的词法分析程序。
二、实验内容1．根据状态转换图直接编程编写一个词法分析程序，它从左到右逐个字符的对源程序进行扫描，产生一个个的单词的二元式，形成二元式（记号）流文件输出。
在此，词法分析程序作为单独的一遍，如下图所示。
具体任务有：（1）组织源程序的输入（2）拼出单词并查找其类别编号，形成二元式输出，得到单词流文件（3）删除注释、空格和无用符号（4）发现并定位词法错误，需要输出错误的位置在源程序中的第几行。
将错误信息输出到屏幕上。
（5）对于普通标识符和常量，分别建立标识符表和常量表（使用线性表存储），当遇到一个标识符或常量时，查找标识符表或常量表，若存在，则返回位置，否则返回0并且填写符号表或常量表。
标识符表结构：变量名，类型（整型、实型、字符型），分配的数据区地址注：词法分析阶段只填写变量名，其它部分在语法分析、语义分析、代码生成等阶段逐步填入。
常量表结构：常量名，常量值2．编写DFA模拟程序算法如下：DFA（S=S0,MOVE[][],F[],ALPHABET[]）/*S为状态，初值为DFA的初态，MOVE[][]为状态转换矩阵，F[] 为终态集，ALPHABET[] 为字母表，其中的字母顺序与MOVE[][] 中列标题的字母顺序一致。
*/{Char Wordbuffer[10]=“”//单词缓冲区置空Nextchar=getchar（）；//读i=0；while（nextchar！=NULL）//NULL代表此类单词{ if （nextcha r！∈ALPHABET[]）{ERROR（“非法字符”），return（“非法字符”）；}S=MOVE[S][nextchar] //下一状态if（S=NULL）return（“不接受”）；//下一状态为空，不能识别，单词错误wordbuffer[i]=nextchar ；//保存单词符号i++；nextchar=getchar（）；}Wordbuffer[i]=‘\0’;If（S∈F）return（wordbuffer）；//接受Else return（“不接受”）；}该算法要求：实现DFA算法，给定一个DFA（初态、状态转换矩阵、终态集、字母表），调用DFA（），识别给定源程序中的单词，查看结果是否正确。
编译原理综合性实验：词法分析的设计
对数字常数的处理如下：先查符号表 VAL 栏，若发现相同的常数则直接输出其二元式。 若表内无相同的常数，则将数字常数填入符号表内，在 TYPE 栏内填入整型或实型，然后输 出其二元式。二元式中包含该常数在符号表中的入口。
1.3 词法分析程序的详细设计
图 1-3 的数据流图属于输入-变换-输出形式的变换型数据流图，但加工 1.3—1.9 构成了典型的事务处理型数据流图。根据数据流图，可以得到词法分析 程序的总体框架，如图 1-4。
图 1-3 词法分析程序的详细数据流图 在上面的数据流图中，各个加工处理完成的功能如下： 加工 1.1(读一行并打印)：收到读下一行命令后，从源程序读入一行，装入缓冲区，行计 数，并打印。在这里需要注意的是，回车换行在源程序（文本文件）中用两个字符 0D0AH 来表示，而用高级语言（C 语言）读入内存后，就用一个字符 0AH 来表示，这是在用高级
查找函数可以使用顺序查找，也可以使用折半查找。 例如：使用顺序查找方法查找给定单词 key 是否是关键字的函数原型和算法描述如下：
int iskeyword (char * str)/*设 keyword 为所有关键字列表*/ /*该函数返回 0 表示 str 不是关键字，不为 0 表示 str 是关键字*/
词不能跨行书写； (4) 关键字都是保留字。
1.2 词法分析程序的总体设计
图 1-2 词法分析程序的顶层数据流图 图 1-2 是词法分析程序的顶层数据流图，即是词法分析程序的输入输出界面图，由此可 以看出词法分析程序的功能就是从源程序中读入一个个字符，依据一定的构词规则，识别出 各类有用的单词。其中源程序清单和错误信息从屏幕、打印机或文件输出，其余文件均以顺 序文件的形式输出到外存储器上，以供下一阶段使用。由此可以得到更详细的数据流图，如 图 1-3。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验2-3 《编译原理》S语言词法分析程序设计方案
一、实验目的
了解词法分析程序的两种设计方法：根据状态转换图直接编程的方式；利用DFA编写通用的词法分析程序.
二、实验内容
1．根据状态转换图直接编程
编写一个词法分析程序，它从左到右逐个字符的对源程序进行扫描，产生一个个的单词的二元式，形成二元式（记号）流文件输出。
在此，词法分析程序作为单独的一遍，如下图所示。
具体任务有：
（1）组织源程序的输入
（2）拼出单词并查找其类别编号，形成二元式输出，得到单词流文件
（3）删除注释、空格和无用符号
（4）发现并定位词法错误，需要输出错误的位置在源程序中的第几行。
将错误信息输出到屏幕上。
（5）对于普通标识符和常量，分别建立标识符表和常量表（使用线性表存储），当遇到一个标识符或常量时，查找标识符表或常量表，若存在，则返回位置，否则返回0并且填写符号表或常量表。
标识符表结构：变量名，类型（整型、实型、字符型），分配的数据区地址
注：词法分析阶段只填写变量名，其它部分在语法分析、语义分析、代码生成等阶段逐步填入。
常量表结构：常量名，常量值
2. 编写DFA模拟程序
算法如下：
DFA（S=S0,MOVE[][],F[],ALPHABET[]，ALLS[]）
/*S为状态，初值为DFA的初态，MOVE[][]为状态转换矩阵，F[] 为终态集，ALPHABET[] 为字母表，其中的字母顺序与MOVE[][] 中列标题的字母顺序一致。
ALLS[]为状态集*/
{
Char Wordbuffer[10]=“”//单词缓冲区置空
Nextchar=getchar（）；//读字符
i=0；
while（nextchar！=NULL）//NULL代表此类单词
{ if （nextcha r！∈ALPHABET[]） {ERROR（“非法字符”），return（“非法字符”）；}
S=MOVE[S][nextchar] //下一状态
if（S=NULL）return（“不接受”）；//下一状态为空，不能识别，单词错误
wordbuffer[i]=nextchar ； //保存单词符号
i++；
nextchar=getchar（）；
}
Wordbuffer[i]=‘\0’;
If（S∈F）return（wordbuffer）； //接受
Else return（“不接受”）；
}
该算法要求：实现DFA算法，给定一个DFA（初态、状态转换矩阵、终态集、字母表、状态集），调用DFA（），识别给定源程序中的单词，查看结果是否正确。
三、实验要求
1．能对任何S语言源程序进行分析
在运行词法分析程序时，应该用问答形式输入要被分析的S源语言程序的文件名，然后对该程序完成词法分析任务。
----------------------------精品word文档值得下载值得拥有----------------------------------------------
2．能检查并处理某些词法分析错误
词法分析程序能给出的错误信息包括：总的出错个数，每个错误所在的行号，错误的编号及错误信息。
本实验要求处理以下两种错误（编号分别为1，2）：
1：非法字符：单词表中不存在的字符处理为非法字符，处理方式是删除该字符，给出错误信息，“某某字符非法”。
2：源程序文件结束而注释未结束。
注释格式为：/* …… */
单词的构词规则：
字母=[A-Za-z]
数字=[0-9]
----------------------------精品word文档值得下载值得拥有----------------------------------------------
标识符=（字母|_）（字母|数字）*
数字=数字(数字)*(.数字+| )
四、S语言表达式和语句说明
1．算术表达式:+、-、*、/、%
2．关系运算符：>、>=、<、<=、==、！=
3．赋值运算符：=，+=、-=、*=、/=、%=
4．变量说明：类型标识符变量名表；
5．类型标识符：int char float
6．If语句：if 表达式then 语句 [else 语句]
7．For语句：for（表达式1；表达式2；表达式3）语句
8．While语句：while 表达式 do 语句
9．S语言程序：由函数构成，函数不能嵌套定义。
函数格式为：
返回值函数名（参数）
{
数据说明
语句
}
五、程序参考结构说明
1．Initscanner函数：程序初始化：输入并打开源程序文件和目标程序文件，初始化保留字表
2．Scanner函数：若文件未结束，反复调用lexscan函数识别单词。
3．Lexscan函数：根据读入的单词的第一个字符确定调用不同的单词识别函数
4．Isalpha函数：识别保留字和标识符
5．Isnumber函数：识别整数，如有精力，可加入识别实数部分工功能
6．Isanotation函数：处理除号/和注释
7．Isother函数识别其他特殊字符
8．Output函数：输出单词的二元式到目标文件，输出格式（单词助记符，单词内码值），如（int，-）（rlop，>）……
9．Error函数：输出错误信息到屏幕
10．除此之外，还可以设置查符号表，填写符号表等函数，学生可自行设计。
六、实验过程说明
1．每人单独完成。
2．完成后，由老师验收，并给出成绩。
3．实验完成后，写出实验报告（要求交打印稿）。
报告内容要求如下：
----------------------------精品word文档值得下载值得拥有----------------------------------------------
----------------------------精品word 文档 值得下载 值得拥有---------------------------------------------- 七、测试源程序示例：
//aa.c
void aa( ) {
float rate,circle; rate=3;
circle=3.14*rate*rate; }
输出结果：
（1）输出结果文件：
（void,-）(id, 0) ((,-) (),-) ({,- ) ( float,-) (id,1)…… （2）标识符的符号表：
Name type address
0 1 2 3 4 5
（3）常数表：
0 1 2 3
实验地点：教10五楼计算机学院软一机房
实验时间:第5周周二、二单元、第六周周一、五单元（晚上7：30-9：00）。