实验1-3-《编译原理》词法分析程序设计方案
编译原理词法分析程序实现实验报告
编译原理词法分析程序实现实验报告实验一词法分析程序实现一、实验内容选取无符号数的算术四则运算中的各类单词为识别对象，要求将其中的各个单词识别出来。
输入:由无符号数和+，,，*，/, ( , ) 构成的算术表达式，如1.5E+2,100。
输出:对识别出的每一单词均单行输出其类别码(无符号数的值暂不要求计算)。
二、设计部分因为需要选取无符号数的算术四则运算中的各类单词为识别对象，要求将其中的各个单词识别出来，而其中的关键则为无符号数的识别，它不仅包括了一般情况下的整数和小数，还有以E为底数的指数运算，其中关于词法分析的无符号数的识别过程流程图如下:输入字符p指向第一个字符符号识别*p=+||-||*||/YYNN*p=0~9*p=E*p=0~9||"."N无效符号Y*p=“.”GOTO 2GOTO 1GOTO 1:NY无符号数GOTO 1*p=0~9*p='/0'YNP++NNP++*p=E*p='+'||'-'YYP++P++continueYY*p=0~9*p=0~9NN无符号数无符号数P++P++continuecontinueGOTO 2:GOTO 2*p=EcontinueY无符号数P++continue三、源程序代码部分#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~9 int 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=='.') return 1;else return 0;}void DistinguishSign(char *p) { int Class;char ch=*p;switch(ch){case '+':Output(PLUS,p,p);Type[count++]=PLUS;break;case '-':Output(SUBTRACT,p,p);Type[count++]=SUBTRACT;break; case '*':Output(MULTIPLY,p,p);Type[count++]=MULTIPLY;break; case '/':Output(DIVIDE,p,p);Type[count++]=DIVIDE;break; case '(':Output(LEFTBRACKET,p,p);Type[count++]=LEFTBRACKET;break; case ')':Output(RIGHTBRACKET,p,p);Type[count++]=RIGHTBRACKET;break; default:break;}}void TypyDistinguish(){printf("词法开始，分析结果如下:\n");char *p;p=&Store[0];while(*p!='\0'){if(Sign(p)){DistinguishSign(p++);continue;}else if(UnsignedNum(p)||*p=='.'){char *p1=p;if(UnsignedNum(p)){while(UnsignedNum(p))p++;if(*p=='\0'){Output(UNSIGNEDNUMBER,p1,--p); Type[count++]=UNSIGNEDNUMBER; p++;continue;}else if(*p=='E'){p++;if(UnsignedNum(p)){while(UnsignedNum(p))p++;Output(UNSIGNEDNUMBER,p1,--p); Type[count++]=UNSIGNEDNUMBER; p++;continue;}else if(*p=='+'||*p=='-'){p++;while(UnsignedNum(p))p++;Output(UNSIGNEDNUMBER,p1,--p);Type[count++]=UNSIGNEDNUMBER;p++;continue;}else{Output(INEFFICACIOUSLABEL,p1,--p);printf("输入的这个符号是不合法的～"); break; Type[count++]=INEFFICACIOUSLABEL;p++;continue;}}else if(*p=='.'){p++;while(UnsignedNum(p))p++;if(*p=='\0'){Output(UNSIGNEDNUMBER,p1,--p);Type[count++]=UNSIGNEDNUMBER; p++;continue;}else if(*p=='E'){p++;if(UnsignedNum(p)){while(UnsignedNum(p))p++;Output(UNSIGNEDNUMBER,p1,--p); Type[count++]=UNSIGNEDNUMBER; p++;continue;}else if(*p=='+'||*p=='-'){p++;if(UnsignedNum(p)){while(UnsignedNum(p))p++;Output(UNSIGNEDNUMBER,p1,--p);Type[count++]=UNSIGNEDNUMBER;p++;continue;}else{Output(INEFFICACIOUSLABEL,p1,--p);printf("输入的这个符号是不合法的～ /n");break;Type[count++]=INEFFICACIOUSLABEL;p++;continue;}}else{Output(INEFFICACIOUSLABEL,p1,--p);printf("输入的这个符号是不合法的～因为他的后面既不是0~9也不是“+”或者“-…");break;//1.5E*2这样的字符串不是无符号数Type[count++]=INEFFICACIOUSLABEL;p++;continue;}}else{Output(UNSIGNEDNUMBER,p1,--p); Type[count++]=UNSIGNEDNUMBER; p++;continue;}}else{Output(UNSIGNEDNUMBER,p1,--p); Type[count++]=UNSIGNEDNUMBER; p++;continue;}}if(*p=='.'){p++;if(UnsignedNum(p)){p++;while(UnsignedNum(p))p++;if(*p=='\0'){Output(UNSIGNEDNUMBER,p1,--p); Type[count++]=UNSIGNEDNUMBER; p++;continue;}else if(*p=='E'){p++;if(UnsignedNum(p)){while(UnsignedNum(p))p++;Output(UNSIGNEDNUMBER,p1,--p); Type[count++]=UNSIGNEDNUMBER; p++;continue;}else if(*p=='+'||*p=='-'){p++;while(UnsignedNum(p))p++;Output(UNSIGNEDNUMBER,p1,--p);Type[count++]=UNSIGNEDNUMBER;p++;continue;}}else{Output(UNSIGNEDNUMBER,p1,--p);Type[count++]=UNSIGNEDNUMBER;p++;continue;}}else{Output(INEFFICACIOUSLABEL,p1,--p);printf("输入的这个符号是不合法的～"); break; Type[count++]=INEFFICACIOUSLABEL;p++;continue;}}}else if(*p=='E'){Output(INEFFICACIOUSLABEL,p,p); break;Type[count++]=INEFFICACIOUSLABEL;printf("输入的这个符号是不合法的～");p++;continue;}}printf("\n\n词法分析完毕～");}void ShowType()//将类别码存储在Type[100]中，为语法分析做准备{printf("\n用类别码表示输入的字符如下:\n");int i;printf("\n");for(i=0;Type[i]!=FINISH;i++){printf("%d",Type[i]);}printf("\n\n");}void main(){//词法分析部分StoreStr();ShowStore();TypyDistinguish();Type[count]=FINISH;ShowType();}四、实验结果正确的结果:错误的结果:输入的字符串中有1.5E*2因为实验是以文件的形式进行读取的所以，在读取不合法的过程中只是将存在project 中的a.txt 中的内容改变改为1.5E*2+100*555实验结果如下:结果分析:对于正确的结果，我以二元式的形式输出，包括他的值和他的类别码，其中将类别码存放在另外的一个数组中，为了在实验二中的语法识别打下基础。
编译原理词法分析实验报告
编译原理词法分析实验报告实验名称:词法分析器的设计与实现一、实验目的：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对象。
五、实验总结：通过本次实验，我熟悉了编译原理中词法分析的基本概念和原理，并掌握了正则表达式的使用方法。
我成功完成了一个简单的词法分析器的设计与实现，实现了源代码中每个词法单元的识别与输出。
这次实验对我深化了对编译原理中词法分析的理解，并提高了我的编程能力。
编译原理综合性实验：词法分析的设计
对数字常数的处理如下：先查符号表 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。
编译原理实习设计——词法分析程序
图三：实数的识别
} 27 { * 26 * 25 ] * 24 [ * 23 ( * 22 ) * 21 ; *
20 , * * | 19 18 非| 17 | * * 16 & 15 非& 14 & * = 13 * 12 非＝ 11 = * 10 # * 9 ＝ * 8 非＝ 7 %
* 6 ^ * 5 ＝ * 4 非＝ 3 ！ * 2
if(c=='>' || c=='"') { Output("$ID", string); for(int p=0; p<k; p++) { string[p]=NULL; } break; } else if( c=='.' || IsLetter(c) IsDigit(c) ) { string[k++]=c; } } break; } j++; } c=Get_ch(++j); } if(IsLetter(c) || c=='_') { k=0; string[k++]=c; j++; while(1) { c=Get_ch(j); if(IsLetter(c) || c=='_' || IsDigit(c)) { string[k++]=c; } else { if(IsKeyword(string) ) { Output("$keyword", string); }
!= ^ % %= = == && & | || , ; ( ) [ ] { } + ++ += － ―― －＝ * *= / /=
编译原理-词法语法分析实验报告
编译原理词法分析一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。
二、实验要求2.1 待分析的简单的词法（1）关键字：begin if then while do end所有的关键字都是小写。
（2）运算符和界符：= + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。
空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码：2.3 词法分析程序的功能：输入：所给文法的源程序字符串。
输出：二元组（syn,token或sum）构成的序列。
其中：syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。
例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的C语言程序源代码：#include <stdio.h>#include <string.h>char prog[80],token[8],ch;int syn,p,m,n,sum;char *rwtab[6]={"begin","if","then","while","do","end"};scaner();void scanner_example (FILE *fp);main(){FILE *fp;fp=fopen("D:\\1.txt","r");//打开文件scanner_example (fp);scaner();}void scanner_example (FILE *fp){do{ch=fgetc (fp);prog[p++]=ch;}while (ch!='#');p=0;do{scaner();switch(syn){case 11:printf("( %-10d%5d )\n",sum,syn);break;case -1:printf("you have input a wrong string\n");default: printf("( %-10s%5d )\n",token,syn);break;}}while(syn!=0);}scaner(){ sum=0;for(m=0;m<8;m++)token[m++]=NULL;ch=prog[p++];m=0;while((ch==' ')||(ch=='\n'))ch=prog[p++];if(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))){ while(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))||((ch>='0')&&(ch<='9'))) {token[m++]=ch;ch=prog[p++];}p--;syn=10;for(n=0;n<6;n++)if(strcmp(token,rwtab[n])==0){ syn=n+1;break;}}else if((ch>='0')&&(ch<='9')){ while((ch>='0')&&(ch<='9')){ sum=sum*10+ch-'0';ch=prog[p++];}p--;syn=11;}else switch(ch){ case '<':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=22;token[m++]=ch;}else{ syn=20;p--;}break;case '>':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=24;token[m++]=ch;}else{ syn=23;p--;}break;case '+': token[m++]=ch;ch=prog[p++];if(ch=='+'){ syn=17;token[m++]=ch;}else{ syn=13;p--;}break;case '-':token[m++]=ch;ch=prog[p++];if(ch=='-'){ syn=29;token[m++]=ch;}else{ syn=14;p--;}break;case '!':ch=prog[p++];if(ch=='='){ syn=21;token[m++]=ch;}else{ syn=31;p--;}break;case '=':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=25;token[m++]=ch;}else{ syn=18;p--;}break;case '*': syn=15;token[m++]=ch;break;case '/': syn=16;token[m++]=ch;break;case '(': syn=27;token[m++]=ch;break;case ')': syn=28;token[m++]=ch;break;case '{': syn=5;token[m++]=ch;break;case '}': syn=6;token[m++]=ch;break;case ';': syn=26;token[m++]=ch;break;case '\"': syn=30;token[m++]=ch;break;case '#': syn=0;token[m++]=ch;break;case ':':syn=17;token[m++]=ch;break;default: syn=-1;break;}token[m++]='\0';}四、结果分析：输入begin x:=9: if x>9 then x:=2*x+1/3; end # 后经词法分析输出如下序列：(begin 1)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图所示：五、总结：词法分析的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。
编译原理词法分析实验报告
编译原理词法分析实验报告实验一词法分析一、实验目的通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
二、实验内容（1）功能描述：该程序是实现一个词法分析器，词法分析器的功能是输入源程序，输出单词符号。
词法分析器的单词符号常常表示成以下的二元式(单词种别码，单词符号的属性值)。
本实验中，采用的是将单词分为五种的方法。
识别关键字：main、if、int、for、while、do、return、break、continue；单词种别码为1。
标识符：单词种别码为2。
常数：为无符号整形数；单词种别码为3。
运算符：包括：+、-、*、/、=、>、<、>=、<=、!= ；单词种别码为4。
分隔符：包括：,、;、{、}、(、)；单词种别码为5。
（2）程序结构描述：输入：从控制台输入一段源程序代码，对输入的代码进行词法分析,处理：分离出关键字、标识符、数值、运算符和界符。
输出：在词法分析结果表中输出每个单词所在行号、类型以及它所对应的编码。
其中，编码是自定义的,一种类型对应一个编码。
词法分析结果显示在控制台上。
（3）程序设计思路1、定义编码表，用ArrayList集合存放单词，如：关键字、运算符、分界符。
这三种单词是固定的，标示符和数字这两种单词不存放在集合中。
编码表是固定的，只需要初始化一次就够了，所以将集合定义为static类型，使其在类加载时，进行一次初始化。
2、static char allstr[] = new char[100000];该数组用于存储用户从控制台输入的所有字符。
3、//从键盘获取一个一个的字符public char Getchar() {try {ch = (char) System.in.read();} catch (Exception e) {e.printStackTrace();}return ch;}4、用while循环遍历allstr数组中存放的字符，判断分离出关键字、标示符、数字、运算符、标示符。
编译原理实验-词法分析器的设计
集美大学计算机工程学院实验报告课程名称：编译原理班级：指导教师：姓名：实验项目编号：实验一学号：实验项目名称：词法分析器的设计实验成绩：一、实验目的通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
二、实验内容编写一个词法分析器，从输入的源程序（编写的语言为C语言的一个子集）中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续显示）三、实验要求1、词法分析器的功能和输出格式词法分析器的功能是输入源程序，输出单词符号。
词法分析器的单词符号常常表示成以下的二元式(单词种别码，单词符号的属性值)。
单词示例单词种别码要求保留字if、else、int、while、do 每个保留字的单词种别都单独为一种标识符以字母开头且包含字母和数字的字符串标识符作为一种常数（只识别无符号整数）123、343 无符号整数作为一种运算符+、-、*、/、=、= = 、!=、> 、<、>=、<= 每符一种，也可以每一类符号一种分隔符,、;、{、}、(、) 每符一种2、上述要求仅为基本要求，可以在此基础上扩充，例如删除注释，增加识别单词的类型，将标识符和常量分别插入到相应的符号表中，增加错误处理等。
3、编程语言不限。
四、实验设计方案1、数据字典本实验用到的数据字典如下表所示：单词示例标识ID1 保留字void、if、else、for、while、do、return、break、main、int、float、char、double、String标识符以字母开头且包含字母和数字的字符串 2无符号整数和小数 3 常数（只识别无符号整数）运算符+、-、*、/、=、> 、<、 4分隔符,、;、{、}、(、) 5 本实验所使用的开发语言是C语言,在Test2类中定义了以下几个函数：2.程序流程图：YNY NNY YN Y N Y YN NN Y YN N N Y Y开始读入文件，把内容存入string 中，m=0，check=ture ，error=false从string 中读出一个字符放入ch 中输出str ，标识为无法识别的串check=ture ，error=falsech 是运算符？error=ture ？ check=false ？ 输出str ，标识为标示符check=ture 输出str ，标识为运算符输出str ，标识为无法识别的串check=ture ，error=falseerror=ture ？ check=false ？ 输出str ，标识为标示符check=ture 输出str ，标识为分隔符ch 是分隔符？ch 是数字？check=ture ？清空str ，ch 加到str 中，check=false ch 加到str 中Ch 是字母？check=ture ？清空str ，ch 加到str 中，check=falsech 加到str 中打印出错ch 是最后一个字符？ 结束YN Y N3、实验程序#include<stdio.h> #include<string.h> #include<ctype.h> #include<windows.h>//判断读入的字符是否为字母 bool isLetter(char c){if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')){ return true; } else return false; }//判断读入的字符是否为数字 bool isDigit(char c){if(c >='0' && c <= '9'){ return true; } else return false; }//判断是否为关键字 bool isKey(char *string) { if(!strcmp(string,"void")|| !strcmp(string,"if")|| !strcmp(string,"for")|| !strcmp(string,"while")|| !strcmp(string,"do")|| !strcmp(string,"return")|| !strcmp(string,"break")|| !strcmp(string,"main")|| !strcmp(string,"int")|| !strcmp(string,"float")|| !st rcmp(string,"char") || !strcmp(string,"double")|| !strcmp(string,"String")) { return true;ch 是数字？ch 加到str 中，error=true ch 是关键字？ 输出str ，标识为关键字，check=true}else return false;}bool isError(char ch){if(ch == '@' || ch == '$' || ch == '&' || ch == '#' || ch == '~' || ch == '^'){return true;}elsereturn false;}void main(){char string[500]="";//存放文件中读出来的字符串char str[10]="";//存放需要对比的字符串char ch,c;//ch存放文件中的单个字符（翻译时用），c存放文件中的单个字符（从文件中提取信息时用）char filename[20];//文件名int j=0;printf("请输入文件名进行词法翻译：");scanf("%s",filename);FILE *cfPtr;if((cfPtr=fopen(filename,"r"))==NULL)printf("文件未找到！");else{while(!feof(cfPtr)){if(isspace(c=fgetc(cfPtr))){//判断是否是字符串;}else{string[j]=c;//从文件中一一提取字符j++;}}}int m = 0,k=0;//m翻译时用，k是str数组的下标string[j]=' ';j++;bool check=true,error=false;//用于判断标识for(int i = 0;i < j;i++){//实现语法翻译器switch (m){ch = string[i];if(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '='|| ch == '>' || ch == '<'){if(error){printf("%s,此字符无法是识别！\n",str);error=false;check=true;}else if(!check){printf("(2,%s)标示符\n",str);check=true;}m = 4;}else if(ch == ',' || ch == ';' || ch == '{' || ch == '}' || ch == '(' || ch == ')'){if(error){printf("%s此字符无法识别\n",str);error=false;check=true;}else if(!check){printf("(2,%s)标示符\n",str);check=true;}m = 5;}else if ( isDigit((ch =string[i]) ) ){if(check){memset(str, 0, strlen(str));//清空k=0;str[k]=ch;k++;m = 3;check=false;} else{str[k]=ch;k++;}}else if ( isLetter(ch = string[i]) )if(check){check=false;memset(str, 0, strlen(str));k=0;str[k]=ch;k++;}else{str[k]=ch;k++;if(isKey(str)){printf("(1,%s)关键字\n",str);check=true;}}}else if(isError(ch = string[i])){if(check){memset(str, 0, strlen(str));//清空k=0;str[k]=ch;k++;check=false;error=true;}else{str[k]=ch;k++;error=true;}}else{}break;case 3:if(isLetter(ch =string[i])){printf("程序有错误！！！\n");str[k] = ch;k++;error=true;m = 0;break;}if(isError(ch = string[i])){printf("程序有错误！！！\n");str[k] = ch;k++;error=true;m = 0;break;}if (isDigit((ch =string[i] ) )){str[k] = ch;k++;}else if(ch=='.'){str[k]=ch;k++;}else{printf("( 3，%s) 数字\n",str);i --;m = 0;check=true;}break;case 4:i--;printf("( 4 ，%c) 运算符\n",ch);m = 0;break;case 5:i --;printf("( 5 ，%c) 分隔符\n",ch);m = 0;break;}}return;}五、实验结果六、实验小结本次实验中，运用C语言进行实验，实验刚开始的时候，能够对输入的字符进行判断，但是却不能排错以及只能识别全是字母的标识符，后来经过修改程序代码和编程的逻辑最终实现了，既能排错又能分析句子；通过实验掌握了词法分析，能实现对普通程序的语法分析翻译。
编译原理实验 词法分析&语法分析程序
编译原理实验词法分析程序实验一：词法分析程序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-3-《编译原理》词法分析程序设计方案
实验1－3 《编译原理》S语言词法分析程序设计方案一、实验目的了解词法分析程序的两种设计方法之一:根据状态转换图直接编程的方式;二、实验内容ﻩ1．根据状态转换图直接编程编写一个词法分析程序，它从左到右逐个字符的对源程序进行扫描,产生一个个的单词的二元式，形成二元式(记号）流文件输出。
在此,词法分析程序作为单独的一遍，如下图所示。
具体任务有:（1)组织源程序的输入(２)拼出单词并查找其类别编号，形成二元式输出,得到单词流文件（3）删除注释、空格和无用符号（4)发现并定位词法错误,需要输出错误的位置在源程序中的第几行。
将错误信息输出到屏幕上。
（5）对于普通标识符和常量,分别建立标识符表和常量表(使用线性表存储），当遇到一个标识符或常量时,查找标识符表或常量表,若存在，则返回位置，否则返回０并且填写符号表或常量表。
标识符表结构:变量名，类型（整型、实型、字符型),分配的数据区地址注：词法分析阶段只填写变量名,其它部分在语法分析、语义分析、代码生成等阶段逐步填入。
常量表结构：常量名，常量值三、实验要求1.能对任何S语言源程序进行分析ﻩ在运行词法分析程序时,应该用问答形式输入要被分析的S源语言程序的文件名,然后对该程序完成词法分析任务。
2．能检查并处理某些词法分析错误词法分析程序能给出的错误信息包括：总的出错个数，每个错误所在的行号,错误的编号及错误信息。
本实验要求处理以下两种错误（编号分别为1,2)：1:非法字符:单词表中不存在的字符处理为非法字符,处理方式是删除该字符，给出错误信息,“某某字符非法”。
２:源程序文件结束而注释未结束。
注释格式为:/* …… */四、保留字和特殊符号表单词的构词规则:字母=[A-Za-z]数字=[0-９]标识符=(字母｜＿)（字母|数字）*数字=数字（数字)＊(.数字+| )四、Ｓ语言表达式和语句说明ﻩ1.算术表达式：+、－、*、/、%ﻩ2．关系运算符：>、>＝、<、<＝、==、！＝3.赋值运算符:=,＋=、-＝、＊=、／=、％=ﻩ4．变量说明:类型标识符变量名表;5.类型标识符:int char flｏaｔﻩ6．If语句：iｆ表达式tｈen 语句[ｅlsｅ语句] ﻩ７.For语句：for(表达式１;表达式２；表达式３) 语句ﻩ8.Whilｅ语句：whｉle表达式ｄo 语句9.S语言程序：由函数构成,函数不能嵌套定义。
编译原理词法分析实验
编译原理词法分析实验一、实验目的本实验旨在通过编写一个简单的词法分析器，了解编译原理中词法分析的基本原理和实现方法。
二、实验材料1. 计算机编程环境2. 编程语言三、实验步骤1. 了解词法分析的概念和作用。
词法分析是编译器中的第一个阶段，它的主要任务是将源代码中的字符序列转化为有意义的标识符，如关键字、操作符、常量和标识符等。
2. 设计词法分析器的流程和算法。
词法分析器的主要原理是通过有限状态自动机来识别和提取标识符。
在设计过程中，需考虑各种可能出现的字符序列，并定义相应的状态转移规则。
3. 根据设计的流程和算法，使用编程语言编写词法分析器的代码。
4. 编译并运行词法分析器程序，输入待分析的源代码文件，观察程序的输出结果。
5. 分析输出结果，检查程序是否正确地提取了源代码中的标识符。
四、实验结果经过词法分析器的处理，源代码将被成功地转化为有意义的标识符。
结果可以通过以下几个方面来验证：1. 关键字和操作符是否被正确识别和提取。
2. 常量和标识符是否被正确识别和提取。
3. 检查程序的错误处理能力，如能否发现非法字符或非法标识符。
4. 输出结果是否符合预期，可与自己编写的语法规则进行对比。
5. 对于特殊情况，如转义字符等是否正确处理。
五、实验总结通过本次实验，我深入了解了编译原理中词法分析的重要性和基本原理。
编写词法分析器的过程中，我学会了使用有限状态自动机来识别和提取标识符，并通过实践巩固了相关知识。
此外，我还对源代码的结构有了更深入的了解，并且掌握了如何运用编程语言来实现词法分析器。
通过本次实验，我不仅提升了自己的编程技术，也对编译原理有了更深入的认识和理解。
六、实验心得通过实验，我深刻体会到了词法分析在编译过程中的重要性。
合理设计和实现词法分析器，可以大大提高编译器的效率和准确性。
同时，通过编写词法分析器的代码，我不仅锻炼了自己的编程能力，还提升了对编译原理的理解和掌握。
这次实验让我更加深入地了解了编译原理中的词法分析，也为我今后在编程领域的发展打下了坚实的基础。
编译原理实验报告(一)----词法分析程序
结束
是 转关键字和标识符处理
是 转数字处理
是 转运算符处理
)[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"};
编译原理词法分析,语法分析实验报告
编译原理实验报告一．LL(1)文法分析1.设计要求（1）对输入文法，它能判断是否为LL(1)文法，若是，则转（2）；否则报错并终止；（2）输入已知文法，由程序自动生成它的LL(1)分析表；（3）对于给定的输入串，应能判断识别该串是否为给定文法的句型。
2.分析该程序可分为如下几步：（1）读入文法（2）判断正误（3）若无误，判断是否为LL(1)文法（4）若是，构造分析表；（5）由总控算法判断输入符号串是否为该文法的句型。
3.流程图开始读入文法有效？是是LL(1)文法？是判断句型报错结束4.源程序/*******************************************语法分析程序作者：xxx学号：xxx********************************************/#include<stdlib.h>#include<stdio.h>#include<string.h>/*******************************************/int count=0; /*分解的产生式的个数*/int number; /*所有终结符和非终结符的总数*/char start; /*开始符号*/char termin[50]; /*终结符号*/char non_ter[50]; /*非终结符号*/char v[50]; /*所有符号*/char left[50]; /*左部*/char right[50][50]; /*右部*/char first[50][50],follow[50][50]; /*各产生式右部的FIRST和左部的FOLLOW集合*/ char first1[50][50]; /*所有单个符号的FIRST集合*/char select[50][50]; /*各单个产生式的SELECT集合*/char f[50],F[50]; /*记录各符号的FIRST和FOLLOW是否已求过*/char empty[20]; /*记录可直接推出^的符号*/char TEMP[50]; /*求FOLLOW时存放某一符号串的FIRST集合*/int validity=1; /*表示输入文法是否有效*/int ll=1; /*表示输入文法是否为LL(1)文法*/int M[20][20]; /*分析表*/char choose; /*用户输入时使用*/char empt[20]; /*求_emp()时使用*/char fo[20]; /*求FOLLOW集合时使用*//*******************************************判断一个字符是否在指定字符串中********************************************/int in(char c,char *p){int i;if(strlen(p)==0)return(0);for(i=0;;i++){if(p[i]==c)return(1); /*若在，返回1*/if(i==strlen(p))return(0); /*若不在，返回0*/}}/*******************************************得到一个不是非终结符的符号********************************************/char c(){char c='A';while(in(c,non_ter)==1)c++;return(c);}/*******************************************分解含有左递归的产生式********************************************/void recur(char *point){ /*完整的产生式在point[]中*/int j,m=0,n=3,k;char temp[20],ch;ch=c(); /*得到一个非终结符*/k=strlen(non_ter);non_ter[k]=ch;non_ter[k+1]='\0';for(j=0;j<=strlen(point)-1;j++){if(point[n]==point[0]){ /*如果‘|’后的首符号和左部相同*/ for(j=n+1;j<=strlen(point)-1;j++){while(point[j]!='|'&&point[j]!='\0')temp[m++]=point[j++];left[count]=ch;memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';m=0;count++;if(point[j]=='|'){n=j+1;break;}}}else{ /*如果‘|’后的首符号和左部不同*/ left[count]=ch;right[count][0]='^';right[count][1]='\0';count++;for(j=n;j<=strlen(point)-1;j++){if(point[j]!='|')temp[m++]=point[j];else{left[count]=point[0];memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';printf(" count=%d ",count);m=0;count++;}}left[count]=point[0];memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';count++;m=0;}}}/*******************************************分解不含有左递归的产生式********************************************/void non_re(char *point){int m=0,j;char temp[20];for(j=3;j<=strlen(point)-1;j++){if(point[j]!='|')temp[m++]=point[j];else{left[count]=point[0];memcpy(right[count],temp,m);right[count][m]='\0';m=0;count++;}}left[count]=point[0];memcpy(right[count],temp,m);right[count][m]='\0';count++;m=0;}/*******************************************读入一个文法********************************************/ char grammer(char *t,char *n,char *left,char right[50][50]) {char vn[50],vt[50];char s;char p[50][50];int i,j,k;printf("\n请输入文法的非终结符号串：");scanf("%s",vn);getchar();i=strlen(vn);memcpy(n,vn,i);n[i]='\0';printf("请输入文法的终结符号串：");scanf("%s",vt);getchar();i=strlen(vt);memcpy(t,vt,i);t[i]='\0';printf("请输入文法的开始符号：");scanf("%c",&s);getchar();printf("请输入文法产生式的条数：");scanf("%d",&i);getchar();for(j=1;j<=i;j++){printf("请输入文法的第%d条（共%d条）产生式：",j,i);scanf("%s",p[j-1]);getchar();}for(j=0;j<=i-1;j++)if(p[j][1]!='-'||p[j][2]!='>'){ printf("\ninput error!");validity=0;return('\0');} /*检测输入错误*/for(k=0;k<=i-1;k++){ /*分解输入的各产生式*/if(p[k][3]==p[k][0])recur(p[k]);elsenon_re(p[k]);}return(s);}/*******************************************将单个符号或符号串并入另一符号串********************************************/void merge(char *d,char *s,int type){ /*d是目标符号串，s是源串，type＝1，源串中的‘^ ’一并并入目串；type＝2，源串中的‘^ ’不并入目串*/int i,j;for(i=0;i<=strlen(s)-1;i++){if(type==2&&s[i]=='^');else{for(j=0;;j++){if(j<strlen(d)&&s[i]==d[j])break;if(j==strlen(d)){d[j]=s[i];d[j+1]='\0';}}}}}/*******************************************求所有能直接推出^的符号********************************************/void emp(char c){ /*即求所有由‘^ ’推出的符号*/ char temp[10];int i;for(i=0;i<=count-1;i++){if(right[i][0]==c&&strlen(right[i])==1){temp[0]=left[i];temp[1]='\0';merge(empty,temp,1);emp(left[i]);}}}/*******************************************求某一符号能否推出‘^ ’********************************************/int _emp(char c){ /*若能推出，返回1；否则，返回0*/ int i,j,k,result=1,mark=0;char temp[20];temp[0]=c;temp[1]='\0';merge(empt,temp,1);if(in(c,empty)==1)return(1);for(i=0;;i++){if(i==count)return(0);if(left[i]==c) /*找一个左部为c的产生式*/{j=strlen(right[i]); /*j为右部的长度*/if(j==1&&in(right[i][0],empty)==1)else if(j==1&&in(right[i][0],termin)==1)return(0);else{for(k=0;k<=j-1;k++)if(in(right[i][k],empt)==1)mark=1;if(mark==1)continue;else{for(k=0;k<=j-1;k++){result*=_emp(right[i][k]);temp[0]=right[i][k];temp[1]='\0';merge(empt,temp,1);}}}if(result==0&&i<count)continue;else if(result==1&&i<count)return(1);}}}/*******************************************判断读入的文法是否正确********************************************/int judge(){int i,j;for(i=0;i<=count-1;i++){if(in(left[i],non_ter)==0){ /*若左部不在非终结符中，报错*/ printf("\nerror1!");validity=0;return(0);}for(j=0;j<=strlen(right[i])-1;j++){if(in(right[i][j],non_ter)==0&&in(right[i][j],termin)==0&&right[i][j]!='^'){ /*若右部某一符号不在非终结符、终结符中且不为‘^ ’，报错*/ printf("\nerror2!");validity=0;return(0);}}}return(1);}/*******************************************求单个符号的FIRST********************************************/void first2(int i){ /*i为符号在所有输入符号中的序号*/char c,temp[20];int j,k,m;c=v[i];char ch='^';emp(ch);if(in(c,termin)==1) /*若为终结符*/{first1[i][0]=c;first1[i][1]='\0';}else if(in(c,non_ter)==1) /*若为非终结符*/{for(j=0;j<=count-1;j++){if(left[j]==c){if(in(right[j][0],termin)==1||right[j][0]=='^'){temp[0]=right[j][0];temp[1]='\0';merge(first1[i],temp,1);}else if(in(right[j][0],non_ter)==1){if(right[j][0]==c)continue;for(k=0;;k++)if(v[k]==right[j][0])break;if(f[k]=='0'){first2(k);f[k]='1';}merge(first1[i],first1[k],2);for(k=0;k<=strlen(right[j])-1;k++){empt[0]='\0';if(_emp(right[j][k])==1&&k<strlen(right[j])-1){for(m=0;;m++)if(v[m]==right[j][k+1])break;if(f[m]=='0'){first2(m);f[m]='1';}merge(first1[i],first1[m],2);}else if(_emp(right[j][k])==1&&k==strlen(right[j])-1){temp[0]='^';temp[1]='\0';merge(first1[i],temp,1);}elsebreak;}}}}}f[i]='1';}/*******************************************求各产生式右部的FIRST********************************************/void FIRST(int i,char *p){int length;int j,k,m;char temp[20];length=strlen(p);if(length==1) /*如果右部为单个符号*/ {if(p[0]=='^'){if(i>=0){first[i][0]='^';first[i][1]='\0';}else{TEMP[0]='^';TEMP[1]='\0';}}else{for(j=0;;j++)if(v[j]==p[0])break;if(i>=0){memcpy(first[i],first1[j],strlen(first1[j]));first[i][strlen(first1[j])]='\0';}else{memcpy(TEMP,first1[j],strlen(first1[j]));TEMP[strlen(first1[j])]='\0';}}}else /*如果右部为符号串*/{for(j=0;;j++)if(v[j]==p[0])break;if(i>=0)merge(first[i],first1[j],2);elsemerge(TEMP,first1[j],2);for(k=0;k<=length-1;k++){empt[0]='\0';if(_emp(p[k])==1&&k<length-1){for(m=0;;m++)if(v[m]==right[i][k+1])break;if(i>=0)merge(first[i],first1[m],2);elsemerge(TEMP,first1[m],2);}else if(_emp(p[k])==1&&k==length-1){temp[0]='^';temp[1]='\0';if(i>=0)merge(first[i],temp,1);elsemerge(TEMP,temp,1);}else if(_emp(p[k])==0)break;}}}/*******************************************求各产生式左部的FOLLOW********************************************/ void FOLLOW(int i){int j,k,m,n,result=1;char c,temp[20];c=non_ter[i]; /*c为待求的非终结符*/ temp[0]=c;temp[1]='\0';merge(fo,temp,1);if(c==start){ /*若为开始符号*/temp[0]='#';temp[1]='\0';merge(follow[i],temp,1);}for(j=0;j<=count-1;j++){if(in(c,right[j])==1) /*找一个右部含有c的产生式*/{for(k=0;;k++)if(right[j][k]==c)break; /*k为c在该产生式右部的序号*/for(m=0;;m++)if(v[m]==left[j])break; /*m为产生式左部非终结符在所有符号中的序号*/ if(k==strlen(right[j])-1){ /*如果c在产生式右部的最后*/if(in(v[m],fo)==1){merge(follow[i],follow[m],1);continue;}if(F[m]=='0'){FOLLOW(m);F[m]='1';}merge(follow[i],follow[m],1);}else{ /*如果c不在产生式右部的最后*/for(n=k+1;n<=strlen(right[j])-1;n++){empt[0]='\0';result*=_emp(right[j][n]);}if(result==1){ /*如果右部c后面的符号串能推出^*/if(in(v[m],fo)==1){ /*避免循环递归*/merge(follow[i],follow[m],1);continue;}if(F[m]=='0'){FOLLOW(m);F[m]='1';}merge(follow[i],follow[m],1);}for(n=k+1;n<=strlen(right[j])-1;n++)temp[n-k-1]=right[j][n];temp[strlen(right[j])-k-1]='\0';FIRST(-1,temp);merge(follow[i],TEMP,2);}}}F[i]='1';}/*******************************************判断读入文法是否为一个LL(1)文法********************************************/int ll1(){int i,j,length,result=1;char temp[50];for(j=0;j<=49;j++){ /*初始化*/first[j][0]='\0';follow[j][0]='\0';first1[j][0]='\0';select[j][0]='\0';TEMP[j]='\0';temp[j]='\0';f[j]='0';F[j]='0';}for(j=0;j<=strlen(v)-1;j++)first2(j); /*求单个符号的FIRST集合*/ printf("\nfirst1:");for(j=0;j<=strlen(v)-1;j++)printf("%c:%s ",v[j],first1[j]);printf("\nempty:%s",empty);printf("\n:::\n_emp:");for(j=0;j<=strlen(v)-1;j++)printf("%d ",_emp(v[j]));for(i=0;i<=count-1;i++)FIRST(i,right[i]); /*求FIRST*/printf("\n");for(j=0;j<=strlen(non_ter)-1;j++){ /*求FOLLOW*/if(fo[j]==0){fo[0]='\0';FOLLOW(j);}}printf("\nfirst:");for(i=0;i<=count-1;i++)printf("%s ",first[i]);printf("\nfollow:");for(i=0;i<=strlen(non_ter)-1;i++)printf("%s ",follow[i]);for(i=0;i<=count-1;i++){ /*求每一产生式的SELECT集合*/ memcpy(select[i],first[i],strlen(first[i]));select[i][strlen(first[i])]='\0';for(j=0;j<=strlen(right[i])-1;j++)result*=_emp(right[i][j]);if(strlen(right[i])==1&&right[i][0]=='^')result=1;if(result==1){for(j=0;;j++)if(v[j]==left[i])break;merge(select[i],follow[j],1);}}printf("\nselect:");for(i=0;i<=count-1;i++)printf("%s ",select[i]);memcpy(temp,select[0],strlen(select[0]));temp[strlen(select[0])]='\0';for(i=1;i<=count-1;i++){ /*判断输入文法是否为LL(1)文法*/ length=strlen(temp);if(left[i]==left[i-1]){merge(temp,select[i],1);if(strlen(temp)<length+strlen(select[i]))return(0);}else{temp[0]='\0';memcpy(temp,select[i],strlen(select[i]));temp[strlen(select[i])]='\0';}}return(1);}/*******************************************构造分析表M********************************************/void MM(){int i,j,k,m;for(i=0;i<=19;i++)for(j=0;j<=19;j++)M[i][j]=-1;i=strlen(termin);termin[i]='#'; /*将#加入终结符数组*/termin[i+1]='\0';for(i=0;i<=count-1;i++){for(m=0;;m++)if(non_ter[m]==left[i])break; /*m为产生式左部非终结符的序号*/for(j=0;j<=strlen(select[i])-1;j++){if(in(select[i][j],termin)==1){for(k=0;;k++)if(termin[k]==select[i][j])break; /*k为产生式右部终结符的序号*/ M[m][k]=i;}}}}/*******************************************总控算法********************************************/void syntax(){int i,j,k,m,n,p,q;char ch;char S[50],str[50];printf("请输入该文法的句型：");scanf("%s",str);getchar();i=strlen(str);str[i]='#';str[i+1]='\0';S[0]='#';S[1]=start;S[2]='\0';j=0;ch=str[j];while(1){if(in(S[strlen(S)-1],termin)==1){if(S[strlen(S)-1]!=ch){printf("\n该符号串不是文法的句型！");return;}else if(S[strlen(S)-1]=='#'){printf("\n该符号串是文法的句型.");return;}else{S[strlen(S)-1]='\0';j++;ch=str[j];}}else{for(i=0;;i++)if(non_ter[i]==S[strlen(S)-1])break;for(k=0;;k++){if(termin[k]==ch)break;if(k==strlen(termin)){printf("\n词法错误！");return;}}if(M[i][k]==-1){printf("\n语法错误！");return;}else{m=M[i][k];if(right[m][0]=='^')S[strlen(S)-1]='\0';else{p=strlen(S)-1;q=p;for(n=strlen(right[m])-1;n>=0;n--)S[p++]=right[m][n];S[q+strlen(right[m])]='\0';}}}printf("\nS:%s str:",S);for(p=j;p<=strlen(str)-1;p++)printf("%c",str[p]);printf(" ");}}/*******************************************一个用户调用函数********************************************/void menu(){syntax();printf("\n是否继续？(y or n):");scanf("%c",&choose);getchar();while(choose=='y'){menu();}}/*******************************************主函数********************************************/void main(){int i,j;start=grammer(termin,non_ter,left,right); /*读入一个文法*/ printf("count=%d",count);printf("\nstart:%c",start);strcpy(v,non_ter);strcat(v,termin);printf("\nv:%s",v);printf("\nnon_ter:%s",non_ter);printf("\ntermin:%s",termin);printf("\nright:");for(i=0;i<=count-1;i++)printf("%s ",right[i]);printf("\nleft:");for(i=0;i<=count-1;i++)printf("%c ",left[i]);if(validity==1)validity=judge();printf("\nvalidity=%d",validity);if(validity==1){printf("\n文法有效");ll=ll1();printf("\nll=%d",ll);if(ll==0)printf("\n该文法不是一个LL1文法！");else{MM();printf("\n");for(i=0;i<=19;i++)for(j=0;j<=19;j++)if(M[i][j]>=0)printf("M[%d][%d]=%d ",i,j,M[i][j]);printf("\n");menu();}}}5.执行结果（1）输入一个文法（2）输入一个符号串（3）再次输入一个符号串，然后退出程序二．词法分析一、问题描述识别简单语言的单词符号识别简单语言的基本字、标识符、无符号整数、运算符和界符。
《编译原理》课程实验报告(词法分析)完整版
《编译原理》课程实验报告题目词法分析专业计算机指导教师签名华东理工大学信息学院计算机系2013年4月10日一.实验序号：《编译原理》第一次实验二.实验题目：词法分析三.实验日期：2013.3.27-2013.4.10四.实验环境（操作系统，开发语言）操作系统：Windows开发语言：C五.实验要求●修改词法：1)将标识符的词法改为“以大写字母或小写字母开头，后面可以跟大写字母或小写字母或数字或下划线”。
把while ((isalpha(buffer))||(isdigit(buffer)))改成while ((isalpha(buffer))||(isdigit(buffer))||buffer==’_’)2)将<条件>中的表示相等关系的单词“=”改为“= =”char *relation[6]={"<","<=","=",">",">=","<>"};把其中的=改成==即可3)将原来无小数的数改为可以有小数的数把while (isdigit(buffer))改成while (isdigit(buffer)||buffer==’.’)●用C语言开发词法分析程序。
读入用PL/0语言编写的测试用例源程序，将识别出的一个个单词组成单词流依序同时输出到屏幕和文件中。
六.实验步骤1)根据修改词法后的PL/0语言编写测试用例源程序。
2)用C语言编写词法分析程序。
读入PL/0语言的测试用例源程序，进行词法分析，将识别出的一个个单词组成单词流依序同时输出到屏幕和文件中。
3)设立断点，单步运行词法分析程序，依次单个输出单词。
分析和理解词法分析程序，解释词法分析程序中的数据和变量变化的原因和输出结果。
七.实验结果（测试用例源程序，运行结果部分截图，词法分析函数主要部分源程序PL0程序：const a=6,b=81;var x,y;procEdure p;procedure q;x:=2;beginx:=1;write(x);end;begincall p;end.C程序：#include <stdio.h>#include <ctype.h>#include <malloc.h>#include <stdlib.h>#include <string.h>#define NULL 0FILE *fp;char cbuffer;char*key[19]={"auto","break","case","char","const","continue","default","do"," double","else","enum","extern","float","for","goto","if","int","long","register"};char *border[6]={",",";","{","}","(",")"};char *arithmetic[4]={"+","-","*","/"};char *relation[6]={"<","<=","=",">",">=","<>"};char *consts[11]={"0","1","2","3","4","5","6","7","8","9","."};char *label[20];int labelnum=0;int search(char searchchar[],int wordtype){ int i=0;switch (wordtype) {case 1:for (i=0;i<=18;i++){ if (strcmp(key[i],searchchar)==0){return(1);}}return(0);break;case 2:{for (i=0;i<=5;i++){ if (strcmp(border[i],searchchar)==0)return(i+1);} return(0);}break;case 3:{for (i=0;i<=3;i++){ if (strcmp(arithmetic[i],searchchar)==0){ return(1);}}return(0);}break;case 4:{for (i=0;i<=5;i++){ if (strcmp(relation[i],searchchar)==0){ return(1);}}return(0);}break;case 5:{for (i=0;i<=10;i++){ if (strcmp(consts[i],searchchar)==0){return;}}return(0);}break;}}char alphaprocess(char buffer){ int atype;int i=-1;char alphatp[20];while ((isalpha(buffer))||(isdigit(buffer))){ alphatp[++i]=buffer;buffer=fgetc(fp);}alphatp[i+1]='\0';atype=search(alphatp,1);if(atype==1){printf("%s \t 保留字\n",alphatp);}//结束if(atype==0){printf("%s \t 标示符\n",alphatp);}return(buffer);}char digitprocess(char buffer){ int i=-1;char digittp[20];int dtype;while (isdigit(buffer)){ digittp[++i]=buffer;buffer=fgetc(fp);}digittp[i+1]='\0';dtype=search(digittp,5);if(dtype==1)printf("%s \t 数字\t %s\n",digittp,digittp);return(buffer);}char otherprocess(char buffer){ int i=-1;char othertp[20];int otype,otypetp;othertp[0]=buffer;othertp[1]='\0';otype=search(othertp,3);if (otype==1){ printf("%s \t 运算符\n",othertp);buffer=fgetc(fp);goto out;}otype=search(othertp,4);if (otype==1){ buffer=fgetc(fp);othertp[1]=buffer;othertp[2]='\0';otypetp=search(othertp,4);if (otypetp==1){ printf("%s \t 运算符\n",othertp);goto out;}elseothertp[1]='\0';printf("%s \t 运算符\n",othertp);goto out;}if (buffer==':'){ buffer=fgetc(fp);if (buffer=='=')printf(":= \t 运算符\n");buffer=fgetc(fp);goto out;}else{ if (otype=search(othertp,2)){ printf("%s \t 界符\n",othertp);buffer=fgetc(fp);goto out;}}if ((buffer!='\n')&&(buffer!=' '))printf("%c error,not a word\n",buffer);buffer=fgetc(fp);out: return(buffer);}void main(){if ((fp=fopen("example.txt","r"))==NULL)printf("error");else{cbuffer = fgetc(fp);while (cbuffer!=EOF){if (isalpha(cbuffer))cbuffer=alphaprocess(cbuffer);else if (isdigit(cbuffer))cbuffer=digitprocess(cbuffer);elsecbuffer=otherprocess(cbuffer);}printf("over\n");getchar();}}八.实验体会（词法分析程序修改的地方，解决问题的方法、心得体会等）通过本次试验，了解了词法分析的主要步骤，就是把标识符，保留字区分，并且能识别出空格，并把数据能从文件中读出来，主要识别标识符和保留字，主要通过比较参照一个事先建好的数组，里面包含了所有的保留字，不在其中的便是标识符。
编译原理实验报告：实验一编写词法分析程序
编译原理实验报告实验名称：实验一编写词法分析程序实验类型：验证型实验指导教师：***专业班级：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）。
编译原理实验(词法分析程序设计)
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++语言的用途的理解。以后我会更加专心的研究计算机知识，不断将现实中遇到的实际问题，向程序方面转变，做到灵活运用所学知识。
编译原理实验报告 词法分析
编译原理实验一·词法分析一、实验目的通过动手实践，使学生对构造编译系统的基本理论、编译程序的基本结构有更为深入的理解和掌握；使学生掌握编译程序设计的基本方法和步骤；能够设计实现编译系统的重要环节。
同时增强编写和调试程序的能力。
二、实验内容及要求对某特定语言A ，构造其词法规则。
该语言的单词符号包括：保留字(见左下表)、标识符（字母大小写不敏感）、整型常数、界符及运算符(见右下表) 。
功能要求如下所示：·按单词符号出现的顺序，返回二元组序列，并输出。
·出现的标识符存放在标识符表，整型常数存放在常数表，并输出这两个表格。
·如果出现词法错误，报出：错误类型，位置（行，列）。
·处理段注释（/* */），行注释（//）。
·有段注释时仍可以正确指出词法错误位置（行，列）。
三、实验过程1、词法形式化描述使用正则文法进行描述，则可以得到如下的正规式:其中ID表示标识符，NUM表示整型常量，RES表示保留字，DEL表示界符，OPR表示运算符。
A→(ID | NUM | RES | DEL | OPR) *ID→letter(letter | didit)*NUM→digit digit*letter→a | …| z | A | …| Zdigit→0 | …| 9RES→program | begin | end | var | int | and | or | not | if | then | else | while | doDEL→( | ) | . | ; | ,OPR→+ | * | := | > | < | = | >= | <= | <>如果关键字、标识符和常数之间没有确定的算符或界符作间隔，则至少用一个空格作间隔。
空格由空白、制表符和换行符组成。
2、单词种别定义；3、状态转换图；语言A的词法分析的状态转换图如下所示：空格符，制表符或回车符字母或数字4、运行环境介绍；本次实验采用win-tc进行代码的编写和编译及运行程序的运行环境为windows5、关键算法的流程图及文字解释；程序中用到的函数列表：变量ch储存当前最新读进的字符的地址strToken存放当前字符串voidmain（） //主函数struct binary *lexicalAnalyze(); //词法分析的主函数，返回一个二元组的指针void GetBC(); //检查ch指向的字符是否为空格、制表或回车符，如果是则调用GetChar（）直至不是上述字符void GetChar(); //ch前移一个地址单元int ConCat(); //将ch指向的字符连接到strToken之后int isLetter(); //判断ch指向的字符是否字母int isDigit(); //判断ch指向的字符是否数字int insertId(); //向标识符表中插入当前strToken的字符串int insertConst(); //将strToken的常数插入常数表中int Reserved(); //检测当前strToken中的字符串是否保留字,若是,则返回编码,否则返回0int isId(); //检测当前strToken中的字符串是否在标识符表中已存在,若是,则返回其编号,否则返回0int isConst(); //检测当前strToken中的字符串是否在常数表中已存在,若是,则返回其编号,否则返回0void errProc(int errType); //出错处理过程,errType是错误类型,将错误信息加入错误表中main（）函数的流程图如下:lexicalAnalyze（）函数的流程图如下所示：Reserved()、isId()和isConst()函数均采用了对链表的遍历算法，errProc()函数通过识别不同的错误编号，向错误链表中添加相应的错误信息。
(完整)编译原理实验报告(词法分析器 语法分析器)
编译原理实验报告实验一一、实验名称：词法分析器的设计二、实验目的：1，词法分析器能够识别简单语言的单词符号2，识别出并输出简单语言的基本字。
标示符。
无符号整数.运算符.和界符。
三、实验要求：给出一个简单语言单词符号的种别编码词法分析器四、实验原理: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）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验1-3-《编译原理》词法分析程序设计方案实验1-3 《编译原理》S语言词法分析程序设计方案一、实验目的了解词法分析程序的两种设计方法之一：根据状态转换图直接编程的方式；二、实验内容1．根据状态转换图直接编程编写一个词法分析程序，它从左到右逐个字符的对源程序进行扫描，产生一个个的单词的二元式，形成二元式（记号）流文件输出。
在此，词法分析程序作为单独的一遍，如下图所示。
源程序词法分析程序二元式文件具体任务有：（1）组织源程序的输入（2）拼出单词并查找其类别编号，形成二元式输出，得到单词流文件（3）删除注释、空格和无用符号（4）发现并定位词法错误，需要输出错误的位置在源程序中的第几行。
将错误信息输出到屏幕上。
（5）对于普通标识符和常量，分别建立标识符表和常量表（使用线性表存储），当遇到一个标识符或常量时，查找标识符表或常量表，若存在，则返回位置，否则返回0并且填写符号表或常量表。
标识符表结构：变量名，类型（整型、实型、字符型），分配的数据区地址注：词法分析阶段只填写变量名，其它部分在语法分析、语义分析、代码生成等阶段逐步填入。
常量表结构：常量名，常量值三、实验要求1．能对任何S语言源程序进行分析在运行词法分析程序时，应该用问答形式输入要被分析的S源语言程序的文件名，然后对该程序完成词法分析任务。
2．能检查并处理某些词法分析错误词法分析程序能给出的错误信息包括：总的出错个数，每个错误所在的行号，错误的编号及错误信息。
本实验要求处理以下两种错误（编号分别为1，2）：1：非法字符：单词表中不存在的字符处理为非法字符，处理方式是删除该字符，给出错误信息，“某某字符非法”。
2：源程序文件结束而注释未结束。
注释格式为：/* …… */四、保留字和特殊符号表单词代码1 2 3 4 5 6 7 8 9单词int char floatvoidconstforif else then单词助记符int charfloatvoidconstforif else then内码值- - - - - - - - -单词代码10 11 12 13 14 15 16 17 18单词while switchbreakbeginend 标识符数字（包括整数和实数）单词助记符whileswitchbreakbeginend id num内码值- - - - - 在符号表中的位置在常数表中的位置单词代码19 20 21 22 23 24 25 26 27 单词+ - * / % ( ) [ ] 单词助记符+ - * / % ( ) [ ]内码值- - - - - - - - -单词代码28 28 29 30 单词!= < > <= >= == ；{ }单词助记符rlop ；{ }内码值!= < > <= >= == - -单词代码37 38 39 40 41 42 43 44 45单词/= += -= *= %= || &&! =单词助记符/= += -= *= %= or andnot =内码值- - - - - - - - -单词的构词规则：字母=[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语言程序：由函数构成，函数不能嵌套定义。
函数格式为：返回值函数名（参数）{数据说明语句}五、程序参考结构说明Scanner closeIsalpha Isnumber Isanotation Output IsotherError主函数Initscanner Lexscan1．Initscanner 函数：程序初始化：输入并打开源程序文件和目标程序文件，初始化保留字表 2．Scanner 函数：若文件未结束，反复调用lexscan 函数识别单词。
3．Lexscan 函数：根据读入的单词的第一个字符确定调用不同的单词识别函数 4．Isalpha 函数：识别保留字和标识符 5．Isnumber 函数：识别整数，如有精力，可加入识别实数部分工功能6．Isanotation 函数：处理除号/和注释 7．Isother 函数识别其他特殊字符8．Output 函数：输出单词的二元式到目标文件，输出格式（单词助记符，单词内码值），如（int，-）（rlop，>）……9．Error函数：输出错误信息到屏幕10．除此之外，还可以设置查符号表，填写符号表等函数，学生可自行设计。
实验中，可以将某些类型的单词识别过程利用DFA算法实现，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（“不接受”）；}六、实验过程说明1．每人单独完成。
2．完成后，由老师验收，并给出成绩。
3．实验完成后，写出实验报告（要求交打印稿）。
报告内容要求如下：完成人：班级、学号、姓名一、实验名称：简化S语言词法分析器二、实验目的：通过手工编写简化C语言词法分析器，熟悉并深入理解编译程序词法分析器2．设计词法分析器模块调用结构图和各模块流程图。
3．程序源代码。
七、测试源程序示例：//aa.cvoid aa( ){float rate,circle;rate=3;circle=3.14*rate*rate;}输出结果：（1）输出结果文件：（void,-）(id, 0) ((,-) (),-) ({,- ) ( float,-) (id,1)……（2）标识符的符号表：Name type address0 aa1 rate2 circle345（3）常数表：Namevalue0 31 3.1423实验地点：教10五楼计算机学院软一机房实验时间:第4周周二3单元、周四1单元、第五周周二3单元八、实验代码#include<stdio.h>#include<stdlib.h>#include<ctype.h>#include<string.h>#define MAX 10//保留字符号长度#define MAXSIZE 45//保留字和特殊符号表长#define NUM 30//标识符和常数的个数FILE *in,*out;// 指向文件的指针char infile[MAX];//文件名字char token[MAX];char Word[NUM][MAX];//标识符char consts[NUM][MAX];//常数charlownum[NUM][MAX]={"0","1","2","3","4"," 5","6","7","8","9","10","11","12","13","14","15","16","17"," 18","19""20","21","22","23","24","25","26","27"," 28","29"}; //自定义表int n=1;//行号int num=0; //错误统计数typedef struct Key_word//保留字和特殊符号表结构//int keyNum;char keyWord[MAX];char keySign[MAX];char keyValue[MAX];}Key_word;//初始化保留字表Key_wordKey[MAXSIZE]={{"int","int","-"},{"char","c har","-"},{"float","float","-"},{"void","void","-"},{"const","const","-"},{" for","for","-"},{"if","if","-"},{"else","else","-"},{"then","t hen","-"},{"while","while","-"},{"switch","switch","-"},{"break","break","-"},{"begin","begin","-"},{"end","end","-"},{""{"","",""},{"","id",""},{"","num",""},{"+","+","-"},{"-","-","-"},{"*","*","-"}, {"/","/","-"},{"%","%","-"},{"(","(","-"}, {")",")","-"},{"[","[","-"},{"]","]","-"},{"","",""},{"<","rlop","<"},{">","rlop","> "},{"<=","rlop","<="},{">=","rlop",">="},{"= ","rlop","="},{"!=","rlop","!="},{";",";","-"},{"","",""},{"/=","/=","-"},{"+=","+=","-"},{"-=","-=", "-"},{"*=","*=","-"},{"%=","%=","-"},{"||","or{"&&","and","-"},{"!","not","-"},{"=","=", "-"}};//打开关闭文件int Initscanner(){printf("请输入要输入的文件:\n");scanf("%s",infile);if((in=fopen(infile,"r"))==NULL){printf("cannot open infile!\n");return 0;}if((out=fopen("word.txt","a+"))==NULL) {printf("cannot open outfile!\n");return 0;}return 0;}//写入文件void Output(int n,int m){fputs("(",out);fputs(Key[n].keySign,out);fputs(",",out);if(m==-1)fputs(Key[n].keyValue,out);elsefputs(lownum[m],out);//下标fputs(")",out);}//Isalpha函数：识别保留字和标识符int Isalpha(){int i;for(i=0;i<16;i++)//关键字{if(strcmp(token,Key[i].keyWord)==0){Output(i,-1);return 0;}}//标识符Word[NUM][MAX]for(i=0;i<NUM;i++){if((Word[i][0]!=NULL)&&strcmp(token,Wor d[i])==0){Output(16,i);return 0;}if(Word[i][0]==NULL){strcpy(Word[i],token);Output(16,i);return 0;}}return 0;}int Isnumber()//Isnumber函数:consts[NUM][MAX]{int i;for(i=0;i<NUM;i++){if((consts[i][0]!=NULL)&&strcmp(token,cons ts[i])==0){Output(17,i);return 0;}if(consts[i][0]==NULL){strcpy(consts[i],token);Output(17,i);return 0;}}return 0;}void remove() //扫描指针回退一个字符{fseek(in,-1,SEEK_CUR);}//Isanotation函数：处理除号/和注释void Isanotation() //提示第一个字符已经存为/了{char ch,pre;ch=getc(in);if(ch=='=')// "/="Output(36,-1);else if(ch=='*')// "/*"{ch=getc(in);do{if(feof(in)){num++;printf("\n第(%d)行: 注释错误: /*后面的字符全部当做注释，缺少结束注释*/\n",n);break;}pre=ch;ch=getc(in);}while(pre!='*'||ch!='/');}else// "/"{remove(); //指针回退一个字符Output(21,-1);}}//Isother函数识别其他特殊字符void Isother(){ int i=1;int j=0;char ch;if(token[0]=='<'||token[0]=='>'||token[0]=='!'|| token[0]=='%'){ch=getc(in);if(ch=='=')token[i++]=ch;elseremove(); }else i f(token[0]=='|') {ch=getc(in);if(ch=='|')token[i++]=ch;elseremove();}else if(token[0]=='&') {c h=getc(in);if(ch=='&')token[i++]=ch;elseremove();}token[i]='\0';for(i=18;i<45;i++){if(strcmp(token,Key[i].keyWord)==0){Output(i,-1);break;}}if(i==45){num++;printf("\n第(%d)行: 字符错误: %s字符非法\n",n,token);}}void Scanner(){char ch;int i;ch=getc(in);while(!feof(in)){while(ch==' '||ch=='\t'||ch=='\n') //先统计行数{if(ch=='\n')++n;ch=getc(in);}if(((ch>='a')&&(ch<='z'))||(ch=='_'))//标识符isalpha(ch)单词{i=1;token[0]=ch;ch=getc(in);while(((ch>='a')&&(ch<='z'))||((ch>='0')&&(c h<='9')))//word number{token[i++]=ch;ch=getc(in);}token[i]='\0';Isalpha();}else if((ch>='0')&&(ch<='9'))//整数{i=1;token[0]=ch;ch=getc(in);while(isdigit(ch)){token[i++]=ch;ch=getc(in);}token[i]='\0';Isnumber();}else if(ch=='/')//区分"/" , "/=" , "/*" {token[0]=ch;Isanotation();ch=getc(in);}else //特殊字符{token[0]=ch;Isother();ch=getc(in);}}}void show(){int i;char ch;printf("\n二元式:\n");rewind(out);while(!feof(out)){printf("%c",getc(out));}printf("\n标志符表\n");for(i=0;i<NUM;i++){if(Word[i][0]!=NULL)printf("%d,%s\n",i,Word[i]);}printf("\n常数表\n");for(i=0;i<NUM;i++){if(consts[i][0]!=NULL)printf("%d,%s\n",i,consts[i]);}}void main(){Initscanner();Scanner();printf("\n共有%d个错误\n",num); show();fclose(in);fclose(out);}九、实验结果输入文件void aa( ) begin float rate,circle; rate=3;circle=3.14*rate;/******/end 输出文件(void,-) (id,0) ((,-) (),-) (begin,-) (float,-) (id,1) (id,2) (;,-) (id,1) (rlop,=) (num,0) (;,-) (id,2) (rlop,=) (num,0) (num,1) (*,-) (id,1) (;,-) (end,-)实验1-3 词法分析器实验十、实验总结经过此次实验，了解了程序的词法构词规则和词法分析过程。