实验3--词法分析-FA的应用
实验三词法分析——有穷自动机的应用
实验目的：一：输入正则文法
二：FA
1．生成FA(DFA或NFA)
2．运行FA，DFA（自动）；NFA（交互）
3．**NFA→DFA
实验设想：对输入的文法存储并判断是确定的有穷状态自动机还是不确定是有穷状态自动机，并给出标准的表示形式，若是DFA，可直接测试一
个符号串是否是文法的句子，即能否被有穷状态机接受，给出过程
及结果；若是NFA，首先将其转化为DFA，再测试一个符号串是否
是文法的句子，亦即是否能被DFA接受。
例如：
输入文法规则的数目：7
输入开始状态: S
输入文法Z::=Za Z::=Bb Z::=Aa B::=Ab B::=b A::=Ba A::=a
此为确定有穷状态自动机!
DFA D=({Z,A,B},{a,b},M,S,{Z})
其中M:
M(Z,a)=Z
M(B,b)=Z
M(B,a)=A
M(A,a)=Z
M(A,b)=B
M(S,b)=B
M(S,a)=A
输入要推导的符号串:ababaa
M(S,ababaa)
=M(M(S,a),babaa)
=M(A,babaa)
=M(M(A,b),abaa)
=M(B,abaa)
=M(M(B,a),baa)
=M(A,baa)
=M(M(A,b),aa)
=M(B,aa)
=M(M(B,a),a)
=M(A,a)
=Z
该符号串能被有穷状态所接受!
输入文法规则的数目：7
输入开始状态: S
输入规则:Z::=Ab Z::=Ba Z::=Zc A::=Ba A::=a B::=Ab B::=b 文法规则存储完毕!
此为非确定有穷状态自动机!
NFA N=({Z,B,A},{b,a,c},M,{S},{Z})
其中M:
M(A,a)=$
M(A,b)={Z,B}
M(A,c)=$
M(B,a)={Z,A}
M(B,b)=$
M(B,c)=$
M(Z,a)=$
M(Z,b)=$
M(Z,c)={Z}
M(S,a)={A}
M(S,b)={B}
M(S,c)=$
将NFA转化为DFA!
DFA N'=({[S],[B],[A],[AZ],[BZ],[Z]},{[b],[a],[c]}, M',[S],F')
其中M':
M'([S],b)=[B]
M'([S],a)=[A]
M'([B],a)=[AZ]
M'([A],b)=[BZ]
M'([AZ],b)=[BZ]
M'([AZ],c)=[Z]
M'([BZ],a)=[AZ]
M'([BZ],c)=[Z]
M'([Z],c)=[Z]
其中F'={[AZ],[BZ],[Z]}
输入要推导的字符串:ababc
M'([S],ababc)
=M'(M'([S],a),babc)
=M'([A],babc)
=M'(M'([A],b),abc)
=M'([BZ],abc)
=M'(M'([BZ],a),bc)
=M'([AZ],bc)
=M'(M'([AZ],b),c)
=M'([BZ],c)
=[Z]
[Z]属于终止状态集合!
该字符串能被有穷状态所接受!
参考程序
#include
#include
struct LeftItem;
struct RightNode //存储状态转换关系中弧与终止状态结点结构
{
char tran;
char nextstate;
RightNode* nextsibling;
RightNode(char x,char y)
{
tran=x; nextstate=y; nextsibling=NULL;
}
};
struct LeftItem //存储状态转换关系中初始状态结点结构
{
char state;
RightNode* link;
};
struct StateItem //存放确定化的NFA状态结点结构
{
char newstates[10];
StateItem()
{
newstates[0]='\0';
}
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int CheckState(LeftItem Array[],int size)
{
RightNode* p;
RightNode* q;
for(int i=0;i { p=Array[i].link; q=p->nextsibling; if(q==NULL) return 1; while(q!=NULL) { if(p->tran==q->tran) return 0; q=q->nextsibling; } } return 1; } int CheckExist(StateItem SArray[],int& length,char temp[]) //将NFA确定化创建二维矩阵时判别新产生的状态是否在状态数组中存储过{ int i=0,k,m; while(i<=length) { if(strlen(SArray[i].newstates)==strlen(temp)) { if(strcmp(SArray[i].newstates,temp)==0) { k=i; break; } } i++; } if(i>length) { length++; m=length; return m; } else return k; } int getcount1(LeftItem Array[],int size) //取得FA中状态的个数{ char temp[20]; int len=0,count=0; int i,j; RightNode* pNode; for(i=0;i { pNode=Array[i].link; while(pNode) { for(j=0;j if(pNode->nextstate==temp[j]) break; if(j==len) { count++; temp[len]=pNode->nextstate; len++; } pNode=pNode->nextsibling; } } return count; } int getcount2(LeftItem Array[],int size) //取得FA中输入字母的个数{ char temp[20]; int len=0,count=0; int i,j; RightNode* pNode; for(i=0;i { pNode=Array[i].link; while(pNode) { for(j=0;j if(pNode->tran==temp[j]) break; if(j==len) { count++; temp[len]=pNode->tran; len++; } pNode=pNode->nextsibling; } } return count; } int getstate(RightNode* pNode,char arc) //判定一个状态是否能通过一条弧进入下一状态{ while(pNode) { if(pNode->tran==arc) return 1; pNode=pNode->nextsibling; } return 0; } void Sort(char A[],int n) //将取得的新状态进行排序 { for(int i=n-1;i>0;i--) for(int j=0;j { if(A[j+1] { char temp=A[j+1]; A[j+1]=A[j]; A[j]=temp; } } } void Bianli1(LeftItem Array[],int size) //输出FA中有穷非空的状态集合 { char temp[20]; int len=0; int i,j; RightNode* pNode; for(i=0;i { pNode=Array[i].link; while(pNode) { for(j=0;j if(pNode->nextstate==temp[j]) break; if(j==len) { if(len==0) cout< else cout<<","< temp[len]=pNode->nextstate; len++; } pNode=pNode->nextsibling; } } } void Bianli2(LeftItem Array[],int size) //输出FA中有穷的输入字母表 { char temp[20]; int len=0; int i,j; RightNode* pNode; for(i=0;i { pNode=Array[i].link; while(pNode) { for(j=0;j if(pNode->tran==temp[j]) break; if(j==len) { if(len==0) cout< else cout<<","< temp[len]=pNode->tran; len++; } pNode=pNode->nextsibling; } } } void Bianli31(LeftItem Array[],int size) //输出DFA状态转换关系的集合M { int i; RightNode* pNode; for(i=0;i { pNode=Array[i].link; while(pNode!=NULL) { cout<<" M("< <<")="< pNode=pNode->nextsibling; } } } void Bianli32(LeftItem Array[],int size) //输出NFA状态转换关系集合M { char K[20]; int len=0; int i,j; RightNode* pNode; RightNode* qNode; for(i=0;i { pNode=Array[i].link; while(pNode) { for(j=0;j if(pNode->tran==K[j]) break; if(j==len) { K[len]=pNode->tran; len++; } pNode=pNode->nextsibling; } } Sort(K,len); for(i=0;i { for(j=0;j { pNode=Array[i].link; cout<<" M("< if(getstate(pNode,K[j])) { cout<<"{"; while(pNode) { if(pNode->tran==K[j]) { qNode=pNode->nextsibling; cout< break; } pNode=pNode->nextsibling; } while(qNode) { if(qNode->tran==K[j]) cout<<","< qNode=qNode->nextsibling; } cout<<"}"< } else cout<<"$"< } } } void Initiate(LeftItem Array[],int size,char TArray[]) //将FA中的输入字母表存入数组TArray[] { int len=0; int i,j; RightNode* pNode; for(i=0;i { pNode=Array[i].link; while(pNode) { for(j=0;j if(pNode->tran==TArray[j]) break; if(j==len) { TArray[len]=pNode->tran; len++; } pNode=pNode->nextsibling; } } } void GetState(LeftItem Array[],int size,char nstate[],char arc,char temp[]) //将NFA确定化创建二维矩阵时取得新状态 { int i=0; while(nstate[i]!='\0') { for(int j=0;j { if(Array[j].state==nstate[i]) { RightNode* p=Array[j].link; while(p!=NULL) { if(p->tran==arc) { int k=0; while(temp[k]!='\0') { if(p->nextstate==temp[k]) break; k++; } if(temp[k]=='\0') { temp[k]=p->nextstate; temp[k+1]='\0'; } } p=p->nextsibling; } } } i++; } } void Change(StateItem SArray[],char temp[],int& length,int MArray[][20],int index,int i) //取得新状态后对状态数组以及状态转换矩阵进行对应变化 { int k; if(temp[0]!='\0') { k=CheckExist(SArray,length,temp); MArray[index][i]=k; if(k==length) strcpy(SArray[length].newstates,temp); } } char FindNewState(LeftItem Array[],int size,char S,char arc) //得到当前状态的下一状态{ int i; for(i=0;i { if(Array[i].state==S) { RightNode* p=Array[i].link; while(p!=NULL) { if(p->tran==arc) return p->nextstate; p=p->nextsibling; } } } return NULL; } int Findy(char TArray[],char s) //取得输入字母在字母表中的下表{ int i=0; while(TArray[i]!='\0') { if(TArray[i]==s) return i; i++; } } void CreateFA1(LeftItem Array[],int size,char start,char end) //根据输入文法创建FA { if(CheckState(Array,size)) { cout<<"此为确定有穷状态自动机!"< cout<<"DFA D=("; } else { cout<<"此为非确定有穷状态自动机!"< cout<<"NFA N=("; } cout<<"{"; Bianli1(Array,size); cout<<"},{"; Bianli2(Array,size); cout<<"},M,"; if(CheckState(Array,size)) cout< else cout<<"{"< cout<<","<<"{"< cout<<"其中M:"< if(CheckState(Array,size)) Bianli31(Array,size); else Bianli32(Array,size); } void CreateFA2(LeftItem Array[],int size,char start,char end,StateItem SArray[],char TArray[],int& length,int MArray[][20]) //将NFA转换为DFA { char temp[20]; int index=0; int i; do { i=0; while(TArray[i]!='\0') { temp[0]='\0'; GetState(Array,size,SArray[index].newstates,TArray[i],temp); Sort(temp,strlen(temp)); Change(SArray,temp,length,MArray,index,i); i++; } index++; }while(index<=length); } void Display(StateItem SArray[],char TArray[],int MArray[][20],int x,int y,char start,char end) //输出确定化的NFA { int i,j,k; cout<<"将NFA转化为DFA!"< cout<<"DFA N'=({"; for(i=0;i { if(i==0) cout<<"["< else cout<<",["< } cout<<"},{"; for(i=0;i { if(i==0) cout<<"["< else cout<<",["< } cout<<"}, M',["< cout<<"其中M':"< for(i=0;i for(j=0;j { if(MArray[i][j]!=-1) { k=MArray[i][j]; cout<<" M'(["< } } cout<<"其中F'={"; k=0; for(i=0;i { j=0; while(SArray[i].newstates[j]!='\0') { if(SArray[i].newstates[j]==end) break; j++; } if(SArray[i].newstates[j]!='\0') { if(k==0) cout<<"["< else cout<<",["< k++; } } cout<<"}"< } void RunFA1(LeftItem Array[],int size,char start,char end) { char TD[20]; int i=0,j; char s=start; cout<<"请输入要推导的符号串:"; cin>>TD; cout<<" M("< for(j=0;TD[j]!='\0';j++) cout< cout<<")"< while(TD[i]!='\0') { if(TD[i+1]!='\0') { cout<<"=M(M("< for(j=i+1;TD[j]!='\0';j++) cout< cout<<")"< } s=FindNewState(Array,size,s,TD[i]); if(s==NULL) break; if(TD[i+1]=='\0') cout<<"="< else { cout<<"=M("< for(j=i+1;TD[j]!='\0';j++) cout< cout<<")"< } i++; } if(TD[i]=='\0') { if(s==end) cout<<"该符号串能被有穷状态所接受!"< else cout<<"该符号串不能被有穷状态所接受!"< } else cout<<"该符号串不能被有穷状态所接受!"< } void RunFA2(StateItem SArray[],char TArray[],int start,int end,int MArray[][20]) { char TD[20]; int i,j,k,x,y; char s=start; cout<<"请输入要推导的字符串:"; cin>>TD; cout<<" M'(["< for(i=0;TD[i]!='\0';i++) cout< cout<<")"< x=0; i=0; while(TD[i]!='\0') { if(TD[i+1]!='\0') { cout<<"=M'(M'(["; cout< cout<<"]"; cout<<","< for(j=i+1;TD[j]!='\0';j++) cout< cout<<")"< } y=Findy(TArray,TD[i]); x=MArray[x][y]; if(x==-1) break; if(TD[i+1]=='\0') { cout<<"="; cout<<"["< } else { cout<<"=M'("; cout<<"["< for(j=i+1;TD[j]!='\0';j++) cout< cout<<")"< } i++; } if(TD[i]=='\0') { for(k=0;SArray[x].newstates[k]!='\0';k++) if(SArray[x].newstates[k]==end) break; if(SArray[x].newstates[k]!='\0') { cout<<"["< cout<<"该字符串能被有穷状态所接受!"< } else cout<<"该字符串不能被有穷状态所接受!"< } else cout<<"该字符串不能被有穷状态所接受!"< } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void main() { int size=0,sign=0; int i,j,n,sel; int count1,count2; int length=0; char start; char end; char temp[10]; int MArray[20][20]; RightNode* p; cout<<"请输入文法规则的数目："; cin>>n; cout<<"请输入开始状态: "; cin>>start; //得到初始状态 LeftItem* Array=new LeftItem[n]; for(i=0;i { do { cout<<"请输入第"< cin>>temp; }while(strlen(temp)>6); if(strlen(temp)==6) { for(j=0;j if(Array[j].state==temp[4]) break; if(j==size) { Array[size].state=temp[4]; Array[size].link=new RightNode(temp[5],temp[0]); size++; } else { for(p=Array[j].link;p->nextsibling!=NULL;p=p->nextsibling) {} p->nextsibling=new RightNode(temp[5],temp[0]); } } else { for(j=0;j if(Array[j].state==start) break; if(j==size) { Array[size].state=start; Array[size].link=new RightNode(temp[4],temp[0]); size++; } else { for(p=Array[j].link;p->nextsibling!=NULL;p=p->nextsibling) {} p->nextsibling=new RightNode(temp[4],temp[0]); } } } end=Array[0].link->nextstate; //得到终止状态 cout< count1=getcount1(Array,size); count2=getcount2(Array,size); StateItem* SArray=new StateItem[100]; char* TArray=new char[count2+1]; SArray[0].newstates[0]=start; SArray[0].newstates[1]='\0'; Initiate(Array,size,TArray); TArray[count2]='\0'; for(i=0;i<20;i++) for(j=0;j<20;j++) MArray[i][j]=-1; cout< aaa: cout<<"-----生成FA请按1-----"< cout<<"-----运行FA请按2-----"< cout<<"-----退出请按3-------"< do { cin>>sel; }while(sel!=1&&sel!=2&&sel!=3); switch(sel) { case 1: CreateFA1(Array,size,start,end); //根据输入文法建立FA if(!CheckState(Array,size)) //将NFA确定化 { CreateFA2(Array,size,start,end,SArray,TArray,length,MArray); Display(SArray,TArray,MArray,length+1,count2,start,end); } sign++; break; case 2: if(sign==0) { cout<<"请先生成FA!"< goto aaa; } if(CheckState(Array,size)) RunFA1(Array,size,start,end); //运行DFA else RunFA2(SArray,TArray,start,end,MArray); //运行确定化的NFA break; case 3: break; } if(sel!=3) goto aaa; } 实验一词法分析器的设计 (2) 1.1 词法分析器的结构和主要任务 (2) 1.1.1 输入输出接口 (2) 1.1.2 条件限制 (2) 1.2 词法分析程序的总体设计 (3) 1.3 词法分析程序的详细设计 (4) 1.4实验步骤 (5) 1.5输入数据 (15) 1.6结果输出 (15) 实验一词法分析器的设计 实验目的：掌握词法分析的概念，设计方法，熟悉高级语言中词法的定义，词法分析程序的编写。 实验要求：在8学时内实现SAMPLE语言的词法分析器，要求用VC窗口界面实现。 实验内容：分为4次实验完成。 1.1 词法分析器的结构和主要任务 1.1.1 输入输出接口 图1-1词法分析器的输入输出界面 词法分析程序的主要任务是从左到右扫描每行源程序，拼成单词，换成统一的内部表示(token)输出，送给语法分析器。具体包括： 1.组织源程序的输入； 2.按规则拼单词，并转换成二元形式； 3.滤掉空白符，跳过注释、换行符及一些无用的符号(如字符常数的引号) 4.进行行列计数，用于指出出错的行列号，并复制出错部分； 5.列表打印源程序； 6.发现并定位词法错误； 7.生成符号表。 token文件和符号表用作语法分析的输入部分。 1.1.2 条件限制 本实验可以作如下假定： (1) 假定SAMPLE语言采用自由格式书写； (2) 可以使用注解，用/*……*/或者{……}标识，但注解不能插在单词内部，注解要在一行内结束，若一行结束，没有遇到注释后面的结束标记，自动认为注释也结束； (3) 一行可以有多个语句，一个语句也可以分布在多行中，单词之间和语句之间可以插入任意空格，单词中间不能有空白符号，单词中间也不能有回车换行符，即单词不能跨行书写； (4) 关键字都是保留字。 实验一词法分析 一、实验目的 通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。并依次输出各个单词的内部编码及单词符号自身值。（遇到错误时可显示“Error”，然后跳过错误部分继续显示） 二、实验要求 使用一符一种的分法 关键字、运算符和分界符可以每一个均为一种 标识符和常数仍然一类一种 三、实验内容 功能描述： 1、待分析的简单语言的词法 （1）关键字： begin if then while do end （2）运算符和界符： := + –* / < <= <> > >= = ; ( ) # （3）其他单词是标识符（ID）和整型常数（NUM），通过以下正规式定义： ID=letter（letter| digit）* NUM=digit digit * （4）空格由空白、制表符和换行符组成。空格一般用来分隔ID、NUM,运算符、界符和关键字，词法分析阶段通常被忽略。 2、各种单词符号对应的种别码 图 1 程序结构描述： 图 2 四、实验结果 输入begin x:=9: if x>9 then x:=2*x+1/3; end # 后经词法分析输出如下序列：(begin 1)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图3所示： 图3 输入private x:=9;if x>0 then x:=2*x+1/3; end#后经词法分析输出如下序列：(private 10)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图4所示： 图4 显然，private是关键字，却被识别成了标示符，这是因为图1中没有定义private关键字的种别码，所以把private当成了标示符。 输入private x:=9;if x>0 then x:=2*x+1/3; @ end#后经词法分析输出如下序列：(private 10)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图5所示 编译技术 班级网络0802 学号3080610052姓名叶晨舟 指导老师朱玉全2011年 7 月 4 日 一、目的 编译技术是理论与实践并重的课程，而其实验课要综合运用一、二年级所学的多门课程的内容，用来完成一个小型编译程序。从而巩固和加强对词法分析、语法分析、语义分析、代码生成和报错处理等理论的认识和理解；培养学生对完整系统的独立分析和设计的能力，进一步培养学生的独立编程能力。 二、任务及要求 基本要求： 1．词法分析器产生下述小语言的单词序列 这个小语言的所有的单词符号，以及它们的种别编码和内部值如下表： 单词符号种别编码助记符内码值 DIM IF DO STOP END 标识符 常数（整）= + * ** ， （ ）1 2 3 4 5 6 7 8 9 10 11 12 13 14 $DIM $IF $DO $STOP $END $ID $INT $ASSIGN $PLUS $STAR $POWER $COMMA $LPAR $RPAR - - - - - - 内部字符串 标准二进形式 - - - - - - 对于这个小语言，有几点重要的限制： 首先，所有的关键字（如IF﹑WHILE等）都是“保留字”。所谓的保留字的意思是，用户不得使用它们作为自己定义的标示符。例如，下面的写法是绝对禁止的： IF（5）=x 其次，由于把关键字作为保留字，故可以把关键字作为一类特殊标示符来处理。也就是说，对于关键字不专设对应的转换图。但把它们（及其种别编码）预先安排在一张表格中（此表叫作保留字表）。当转换图识别出一个标识符时，就去查对这张表，确定它是否为一个关键字。 再次，如果关键字、标识符和常数之间没有确定的运算符或界符作间隔，则必须至少用一个空白符作间隔（此时，空白符不再是完全没有意义的了）。例如，一个条件语句应写为 编译原理实验--词法分析器 实验一词法分析器设计 【实验目的】 1(熟悉词法分析的基本原理，词法分析的过程以及词法分析中要注意的问题。 2(复习高级语言，进一步加强用高级语言来解决实际问题的能力。 3(通过完成词法分析程序，了解词法分析的过程。 【实验内容】 用C语言编写一个PL/0词法分析器，为语法语义分析提供单词，使之能把输入的字符 串形式的源程序分割成一个个单词符号传递给语法语义分析，并把分析结果(基本字， 运算符，标识符，常数以及界符)输出。 【实验流程图】 【实验步骤】 1(提取pl/0文件中基本字的源代码 while((ch=fgetc(stream))!='.') { int k=-1; char a[SIZE]; int s=0; while(ch>='a' && ch<='z'||ch>='A' && ch<='Z') { if(ch>='A' && ch<='Z') ch+=32; a[++k]=(char)ch; ch=fgetc(stream); } for(int m=0;m<=12&&k!=-1;m++) for(int n=0;n<=k;n++) { if(a[n]==wsym[m][n]) ++s; else s=0; if(s==(strlen(wsym[m]))) {printf("%s\t",wsym[m]);m=14;n=k+1;} } 2(提取pl/0文件中标识符的源代码 while((ch=fgetc(stream))!='.') { int k=-1; char a[SIZE]=" "; int s=0; while(ch>='a' && ch<='z'||ch>='A' && ch<='Z') { if(ch>='A' && ch<='Z') ch+=32; a[++k]=(char)ch; ch=fgetc(stream); } for(int m=0;m<=12&&k!=-1;m++) for(int n=0;n<=k;n++) { if(a[n]==wsym[m][n]) ++s; else s=0; if(s==(strlen(wsym[m]))) {m=14;n=k+1;} } if(m==13) for(m=0;a[m]!=NULL;m++) printf("%c ",a[m]); 实验一词法分析实验报告 实验一词法分析 一、实验目的 通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。并依次输出各个单词的内部编码及单词符号自身值。（遇到错误时可显示“Error”，然后跳过错误部分继续显示） 二、实验要求 使用一符一种的分法 关键字、运算符和分界符可以每一个均为一种标识符和常数仍然一类一种 三、实验内容 功能描述： 1、待分析的简单语言的词法 （1）关键字： begin if then while do end （2）运算符和界符： := + –* / < <= <> > > = = ; ( ) # （3）其他单词是标识符（ID）和整型常数（NUM），通过以下正规式定义： ID=letter（letter| digit）* NUM=digit digit * （4）空格由空白、制表符和换行符组成。空格一般用来分隔ID、NUM,运算符、界符和关键字，词法分析阶段通常被忽略。 2、各种单词符号对应的种别码 图 1 程序结构描述： 是 否 是 调用scanner() 字母 数 其他 运算符、 符号 界符等符号 否 是 图 2 四、实验结果 输入begin x:=9: if x>9 then x:=2*x+1/3; end # 后经词法分析输出如 变量忽略 是否输入返 拼数 syn=11返 对不同报拼字是否关syn 为对syn=10 . 编译原理实验专业：13级网络工程 语法分析器1 一、实现方法描述 所给文法为G【E】； E->TE’ E’->+TE’|空 T->FT’ T’->*FT’|空 F->i|(E) 递归子程序法： 首先计算出五个非终结符的first集合follow集，然后根据五个产生式定义了五个函数。定义字符数组vocabulary来存储输入的句子，字符指针ch指向vocabulary。从非终结符E函数出发，如果首字符属于E的first集，则依次进入T函数和E’函数，开始递归调用。在每个函数中，都要判断指针所指字符是否属于该非终结符的first集，属于则根据产生式进入下一个函数进行调用，若first集中有空字符，还要判断是否属于该非终结符的follow集。以分号作为结束符。 二、实现代码 头文件shiyan3.h #include #include int a=0; cout<<"按1结束程序"< 青岛理工大学 实 验 报 告 实验课程： 编译原理 实验日期： 2014 年 5月28 日 交报告日期：2014 年6月4日 成绩： 实验地点：现代教育技术中心101（计算机实验室） 计算机工程 学院，计算机科学与技术 专业， 班级：计算113 实验指导教师： 批阅教师： 一、实验目的 设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。 二、实验要求 1. 待分析的简单语言的词法 1) 关键字： begin if then while do end 所有关键字都是小写。 2) 运算符和界符： : = + – * / < <= <> > >= = ; ( ) # 3) 其他单词是标识符（ID ）和整型常数（NUM ），通过以下正规式定义： ID=letter （letter| digit ）* NUM=digit digit * 4) 空格由空白、制表符和换行符组成。空格一般用来分隔ID 、NUM,运算符、界符和关 键字，词法分析阶段通常被忽略。 2.各种单词符号对应的种别码 3.词法分析程序的功能 输入：所给文法的源程序字符串。 输出：二元组（syn，token或sum）构成的序列。 其中：syn为单词种别码；token为存放的单词自身字符串；sum为常数。 例如：对源程序 begin x:=9; if x>0 then x:=2*x+1/3; end# 经词法分析后输出如下序列：(1,beigin) (10,x) (18,:=) (11,9) (26,;) (2,if)...... 三、算法思想 1.主程序示意图 主程序示意图如下所示： 其中初值包括如下两个方面。 1)关键字表的初值。 关键字作为特殊标识符处理，把它们预先安排在关键字表，当扫描程序识别出标识符时，查关键字表。若查到匹配的单词，则该单词为关键字，否则为一般标识符。关键字表作为一个字符串数组，其描述如下： char *rwtab[22] = {"begin","if","else","then","while","do","for","switch","case", "until","break","goto","constant","return", "int","float","double","string","char","short","long","end"}; 2)程序中的主要变量为syn，token和sum。 2.扫描子程序的算法思想 首先设置3个变量： ①token用于存放构成单词符号的字符串； ②sum用于存放整型单词； ③syn用于存放单词符号的种别码。 编译原理实验报告 实验名称：分析调试语义分析程序 TEST抽象机模拟器完整程序 保证能用！！！！！ 一、实验目的 通过分析调试TEST语言的语义分析和中间代码生成程序，加深对语法制导翻译思想的理解，掌握将语法分析所识别的语法范畴变换为中间代码的语义翻译方法。 二、实验设计 程序流程图 extern int TESTScan(FILE *fin,FILE *fout); FILE *fin,*fout; //用于指定输入输出文件的指针 int main() { char szFinName[300]; char szFoutName[300]; printf("请输入源程序文件名（包括路径）:"); scanf("%s",szFinName); printf("请输入词法分析输出文件名（包括路径）："); scanf("%s",szFoutName); if( (fin = fopen(szFinName,"r")) == NULL) { printf("\n打开词法分析输入文件出错！\n"); return 0; } if( (fout = fopen(szFoutName,"w")) == NULL) { printf("\n创建词法分析输出文件出错！\n"); return 0; } int es = TESTScan(fin,fout); fclose(fin); fclose(fout); if(es > 0) printf("词法分析有错，编译停止！共有%d个错误！\n",es); else if(es == 0) { printf("词法分析成功！\n"); int es = 0; 词法分析器实验报告 词法分析器设计 一、实验目的： 对C语言的一个子集设计并实现一个简单的词法分析器，掌握利用状 态转换图设计词法分析器的基本方法。利用该词法分析器完成对源程 序字符串的词法分析。输出形式是源程序的单词符号二元式的代码， 并保存到文件中。 二、实验内容： 1. 设计原理 词法分析的任务：从左至右逐个字符地对源程序进行扫描，产生一个个单词符号。 理论基础：有限自动机、正规文法、正规式 词法分析器(Lexical Analyzer) 又称扫描器(Scanner)：执行词法分析的程序 2. 词法分析器的功能和输出形式 功能:输入源程序、输出单词符号 程序语言的单词符号一般分为以下五种：关键字、标识符、常数、运算符,界符 3. 输出的单词符号的表示形式: 单词种别用整数编码，关键字一字一种，标识符统归为一种，常数一种，各种符号各一种。 4. 词法分析器的结构 单词符号 5. 状态转换图实现 三、程序设计 1．总体模块设计 /*用来存储目标文件名*/ string file_name; /*提取文本文件中的信息。*/ string GetText(); /*获得一个单词符号,从位置i开始查找。并且有一个引用参数j，用来返回这个单词最后一个字符在str的位置。*/ string GetWord(string str,int i,int& j); /*这个函数用来除去字符串中连续的空格和换行 int DeleteNull(string str,int i); /*判断i当前所指的字符是否为一个分界符，是的话返回真，反之假*/ bool IsBoundary(string str,int i); /*判断i当前所指的字符是否为一个运算符，是的话返回真，反之假*/ bool IsOperation(string str,int i); 词法分析器实验报告 词法分析器实验报告实验目的: 设计、编制、调试一个词法分析子程序,识别单词，加深对词法分析原理的理 解。 实验要求: 该程序要实现的是一个读单词过程，从输入的源程序中，识别出各个具有独立 意义的单词，即基本保留字、标识符、常数、运算符、分界符五大类。并依次输出 各个单词的内部编码及单词符号自身值。 (一)实验内容 (1)功能描述:对给定的程序通过词法分析器弄够识别一个个单词符号，并以二 元式(单词种别码，单词符号的属性值)显示。而本程序则是通过对给定路径的文件 的分析后以单词符号和文字提示显示。 (2)程序结构描述: 函数调用格式: 函数调用格式函数名(实在参数表 ) Switch(m)、 isKey(String string)、isLetter(char c)、实参 isDigit(char c)、isOperator(char c) isKey(String string)、isLetter(char c)、调作为表达式 isDigit(char c)、isOperator(char c) 用 方 作为语句 getChar()、judgement()、 法 函数的递归调用 isOperator(char c) 、isLetter(char c)、isDigit(char c) 参数含义: 1 String string;存放读入的字符串 String str; 存放暂时读入的字符串 char ch; 存放读入的字符 int rs 判断读入的文件是否为空 char []data 存放文件中的数据 int m;通过switch用来判断字符类型， 函数之间的调用关系图: main Complier..judgement isOperate() M=0 getChar( ) isDigit() M=4 For(ch ) isLet ter() M=2 Switch(m) isKey() M=3 函数功能: Judgement()判断输入的字符并输出单词符号，返回值为空; getChar() 读取文件的，返回值为空; isLetter(char c) 判断读入的字符是否为字母的，返回值为Boolean类型; switch (m) 判断跳转输出返回值为空; isOperator(char c)判断是否为运算符的，返回值为Boolean类型; isKey(String string)判断是否为关键字的，返回值为Boolean类型; isDigit(char c) 判断读入的字符是否为数字的，返回值为Boolean类型。测试结果: 词法分析设计 1. 实验目的 通过本实验的编程实践，了解词法分析的任务，掌握词法分析程序设计的原理和构造方法，对编译的基本概念、原理和方法有完整的和清楚的理解，并能正确地、熟练地运用。 2. 实验内容 用C++语言实现对C++语言子集的源程序进行词法分析。通过输入源程序从左到右对字符串进行扫描和分解，依次输出各个单词的内部编码及单词符号自身值；若遇到错误则显示“Error”，然后跳过错误部分继续显示；同时进行标识符登记符号表的管理。 3. 实验原理 本次实验采用NFA->DFA->DFA0的过程: 对待分析的简单的词法（关键词/id/num/运算符/空白符等）先分别建立自己的FA，然后将他们用产生式连接起来并设置一个唯一的开始符，终结符不合并。 待分析的简单的词法 （1）关键字： "asm","auto","bool","break","case","catch","char","class"," const","const_cast"等 （2）界符（查表） ";",",","(",")","[","]","{","}" （3）运算符 "*","/","%","+","-","<<","=",">>","&","^","|","++","--"," +=","-=","*=","/=","%=","&=","^=","|=" relop： （4）其他单词是标识符（ID）和整型常数（SUM），通过正规式定义。 id/keywords: digit: （5）空格有空白、制表符和换行符组成。空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。 词法分析器实验报告 一、实验目的及要求 本次实验通过用C语言设计、编制、调试一个词法分析子程序，识别单词，实现一个C语言词法分析器，经过此过程可以加深对编译器解析单词流的过程的了解。 运行环境： 硬件：windows xp 软件：visual c++6.0 二、实验步骤 1.查询资料，了解词法分析器的工作过程与原理。 2.分析题目，整理出基本设计思路。 3.实践编码，将设计思想转换用c语言编码实现，编译运行。 4.测试功能，多次设置包含不同字符，关键字的待解析文件，仔细察看运行结果，检测该分析器的分析结果是否正确。通过最终的测试发现问题，逐渐完善代码中设置的分析对象与关键字表，拓宽分析范围提高分析能力。 三、实验内容 本实验中将c语言单词符号分成了四类：关键字key（特别的将main说明为主函数）、普通标示符、常数和界符。将关键字初始化在一个字符型指针数组*key[]中，将界符分别由程序中的case列出。在词法分析过程中，关键字表和case列出的界符的内容是固定不变的（由程序中的初始化确定），因此，从源文件字符串中识别出现的关键字，界符只能从其中选取。标识符、常数是在分析过程中不断形成的。 对于一个具体源程序而言，在扫描字符串时识别出一个单词，若这个单词的类型是关键字、普通标示符、常数或界符中之一，那么就将此单词以文字说明的形式输出．每次调用词法分析程序，它均能自动继续扫描下去，形成下一个单词，直到整个源程序全部扫描完毕，从而形成相应的单词串。 输出形式例如：void $关键字 流程图、程序流程图： 程序： #include 《词法分析》实验报告 目录 目录错误!未定义书签。 1 实验目的错误!未定义书签。 2 实验内容错误!未定义书签。 TINY计算机语言描述错误!未定义书签。 实验要求错误!未定义书签。 3 此法分析器的程序实现错误!未定义书签。状态转换图错误!未定义书签。 程序源码错误!未定义书签。 实验运行效果截图错误!未定义书签。 4 实验体会错误!未定义书签。 实验目的 1、学会针对DFA转换图实现相应的高级语言源程序。 2、深刻领会状态转换图的含义，逐步理解有限自动机。 3、掌握手工生成词法分析器的方法，了解词法分析器的内部工作原理。 实验内容 TINY计算机语言描述 TINY计算机语言的编译程序的词法分析部分实现。 从左到右扫描每行该语言源程序的符号，拼成单词，换成统一的内部表示（token）送给语法分析程序。 为了简化程序的编写，有具体的要求如下： 1、数仅仅是整数。 2、空白符仅仅是空格、回车符、制表符。 3、代码是自由格式。 4、注释应放在花括号之内，并且不允许嵌套 ＴＩＮＹ语言的单词 要求实现编译器的以下功能 1、按规则拼单词,并转换成二元式形式 2、删除注释行 3、删除空白符(空格、回车符、制表符) 4、列表打印源程序，按照源程序的行打印，在每行的前面加上行号，并且打印出每行包含的记号的二元形式 5、发现并定位错误 词法分析进行具体的要求 1、记号的二元式形式中种类采用枚举方法定义；其中保留字和特殊字符是每个都一个种类，标示符自己是一类，数字是一类；单词的属性就是表示的字符串值。 2、词法分析的具体功能实现是一个函数GetToken()，每次调用都对剩余的字符串分析得到一个单词或记号识别其种类，收集该记号的符号串属性，当识别一个单词完毕，采用返回值的形式返回符号的种类，同时采用程序变量的形式提供当前识别出记号的属性值。这样配合语法分析程序的分析需要的记号及其属性，生成一个语法树。 编译原理语法分析器实验报告 班级： 学号： 姓名： 实验名称语法分析器 一、实验目的 1、根据某一文法编制调试LL（1）分析程序，以便对任意输入的符号串进行分析。 2、本次实验的目的主要是加深对自上而下分析法的理解。 二、实验内容 [问题描述] 递归下降分析法： 0.定义部分：定义常量、变量、数据结构。 1.初始化：从文件将输入符号串输入到字符缓冲区中。 2.利用递归下降分析法分析，对每个非终结符编写函数，在主函数中调用文法开始符号的函数。 LL（1）分析法： 模块结构： 1、定义部分：定义常量、变量、数据结构。 2、初始化：设立LL(1)分析表、初始化变量空间（包括堆栈、结构体等）； 3、运行程序：让程序分析一个text文件，判断输入的字符串是否符合文法定义的规则； 4、利用LL(1)分析算法进行表达式处理：根据LL(1)分析表对表达式 符号串进行堆栈（或其他）操作，输出分析结果，如果遇到错误则显示简 单的错误提示。 [基本要求] 1. 对数据输入读取 2. 格式化输出分析结果 2．简单的程序实现词法分析 public static void main(String args[]) { LL l = new LL(); l.setP(); String input = ""; boolean flag = true; while (flag) { try { InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); System.out.println(); System.out.print("请输入字符串(输入exit退出)："); input = br.readLine(); } catch (Exception e) { e.printStackTrace(); } if(input.equals("exit")){ flag = false; }else{ l.setInputString(input); l.setCount(1, 1, 0, 0); l.setFenxi(); System.out.println(); System.out.println("分析过程"); System.out.println("----------------------------------------------------------------------"); System.out.println(" 步骤| 分析栈 | 剩余输入串| 所用产生式"); System.out.println("----------------------------------------------------------------------"); boolean b = l.judge(); System.out.println("----------------------------------------------------------------------"); if(b){ System.out.println("您输入的字符串"+input+"是该文法的一个句子"); }else{ System.out.println("您输入的字符串"+input+"有词法错误！"); (此文档为word格式，下载后您可任意编辑修改！) 编译技术 班级网络0802 学号 姓名叶晨舟 指导老师朱玉全 2011年 7 月 4 日 一、目的 编译技术是理论与实践并重的课程，而其实验课要综合运用一、二年级所学的多门课程的内容，用来完成一个小型编译程序。从而巩固和加强对词法分析、语法分析、语义分析、代码生成和报错处理等理论的认识和理解；培养学生对完整系统的独立分析和设计的能力，进一步培养学生的独立编程能力。 二、任务及要求 基本要求： 1．词法分析器产生下述小语言的单词序列 这个小语言的所有的单词符号，以及它们的种别编码和内部值如下表： 单词符号种别编码助记符内码值 DIM IF DO STOP END 标识符 常数（整）= + * ** ， （ ）1 2 3 4 5 6 7 8 9 10 11 12 13 14 $DIM $IF $DO $STOP $END $ID $INT $ASSIGN $PLUS $STAR $POWER $COMMA $LPAR $RPAR - - - - - - 内部字符串 标准二进形式 - - - - - - 对于这个小语言，有几点重要的限制： 首先，所有的关键字（如IF﹑WHILE等）都是“保留字”。所谓的保留字的意思是，用户不得使用它们作为自己定义的标示符。例如，下面的写法是绝对禁止的： IF（5）=x 其次，由于把关键字作为保留字，故可以把关键字作为一类特殊标示符来处理。也就是说，对于关键字不专设对应的转换图。但把它们（及其种别编码）预先安排在一张表格中（此表叫作保留字表）。当转换图识别出一个标识符时，就去查对这张表，确定它是否为一个关键字。 再次，如果关键字、标识符和常数之间没有确定的运算符或界符作间隔，则必须至少用一个空白符作间隔（此时，空白符不再是完全没有意义的了）。例如，一个条件语句应写为 IF i>0 i= 1; 编译原理实验一 姓名：朱彦荣 学号： 专业：软件工程2 实验题目：词法分析 完成语言：C/C++ 上级系统：VC++6.0 日期：2015/11/7 词法分析 设计题目：手工设计c语言的词法分析器 （可以是c语言的子集） 设计内容： 处理c语言源程序，过滤掉无用符号，判断源程序中单词的合法性，并分解出正确的单词，以二元组形式存放在文件中。 设计目的： 了解高级语言单词的分类，了解状态图以及如何表示并识别单词规则，掌握状态图到识别程序的编程。 结果要求：课程设计报告。 完成日期：第十五周提交报告 一．分析 要想手工设计词法分析器，实现C语言子集的识别，就要明白什么是词法 主要是对源程序进行编译预处理（去除注释、无用的回车换行找到包含的文件等）之后，对整个源程序进行分解，分解成一个个单词，这些单词有且只有五类，分别是标识符、保留字、常数、运算符、界符。以便为下面的语法分析和语义分析做准备。可以说词法分析面向的对象是单个的字符，目的是把它们组成有效的单词（字符串）；而语法的分析则是利用词法分析的结果作为输入来分析是否符合语法规则并且进行语法制导下的语义分析，最后产生四元组(中间代码)，进行优化（可有可无）之后最终生成目标代码。可见词法分析是所有后续工作的基础，如果这一步出错，比如明明是‘<=’却被拆分成‘<’和‘=’就会对下文造成不可挽回的影响。因此，在进行词法分析的时候一定要定义好这五种符号的集合。下面是我构造的一个C语言子集。 第一类：标识符letter(letter | digit)* 无穷集 第二类：常数(digit)+ 无穷集 第三类：保留字(32) 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 第四类：界符‘/*’、‘//’、() { } [ ] " " ' 等 第五类：运算符<、<=、>、>=、=、+、-、*、/、^、等 对所有可数符号进行编码： <$,0> 语法分析器的设计实验报告 一、实验内容 语法分析程序用LL(1)语法分析方法。首先输入定义好的文法书写文件(所用的文法可以用LL(1)分析)，先求出所输入的文法的每个非终结符是否能推出空，再分别计算非终结符号的FIRST集合，每个非终结符号的FOLLOW集合，以及每个规则的SELECT集合，并判断任意一个非终结符号的任意两个规则的SELECT 集的交集是不是都为空，如果是，则输入文法符合LL(1)文法，可以进行分析。对于文法： G[E]: E->E+T|T T->T*F|F F->i|(E) 分析句子i+i*i是否符合文法。 二、基本思想 1、语法分析器实现 语法分析是编译过程的核心部分，它的主要任务是按照程序的语法规则，从由词法分析输出的源程序符号串中识别出各类语法成分，同时进行词法检查，为语义分析和代码生成作准备。这里采用自顶向下的LL(1)分析方法。 语法分析程序的流程图如图5-4所示。 语法分析程序流程图 该程序可分为如下几步： （1）读入文法 （2）判断正误 （3）若无误，判断是否为LL(1)文法 （4）若是，构造分析表； （5）由句型判别算法判断输入符号串是为该文法的句型。 三、核心思想 该分析程序有15部分组成： （1）首先定义各种需要用到的常量和变量； （2）判断一个字符是否在指定字符串中； （3）读入一个文法； （4）将单个符号或符号串并入另一符号串； （5）求所有能直接推出&的符号； （6）求某一符号能否推出‘& ’； （7）判断读入的文法是否正确； （8）求单个符号的FIRST； （9）求各产生式右部的FIRST； （10）求各产生式左部的FOLLOW； （11）判断读入文法是否为一个LL(1)文法； （12）构造分析表M； （13）句型判别算法； （14）一个用户调用函数； （15）主函数； 下面是其中几部分程序段的算法思想： 1、求能推出空的非终结符集 Ⅰ、实例中求直接推出空的empty集的算法描述如下： void emp(char c){ 参数c为空符号 char temp[10];定义临时数组 int i; for(i=0;i<=count-1;i++)从文法的第一个产生式开始查找 { if 产生式右部第一个符号是空符号并且右部长度为1, then将该条产生式左部符号保存在临时数组temp中 将临时数组中的元素合并到记录可推出&符号的数组empty中。 } Ⅱ、求某一符号能否推出'&' int _emp(char c) { //若能推出&，返回1；否则，返回0 int i,j,k,result=1,mark=0; char temp[20]; temp[0]=c; temp[1]='\0'; 存放到一个临时数组empt里,标识此字符已查找其是否可推出空字 如果c在可直接推出空字的empty[]中,返回1 for(i=0;;i++) { if(i==count) return(0); 找一个左部为c的产生式 j=strlen(right[i]); //j为c所在产生式右部的长度 if 右部长度为1且右部第一个字符在empty[]中. then返回1(A->B,B可推出空) if 右部长度为1但第一个字符为终结符,then 返回0(A->a,a为终结符) else 语法分析器的设计实验报告 一、实验容 语法分析程序用LL(1)语法分析方法。首先输入定义好的文法书写文件(所用的文法可以用LL(1)分析)，先求出所输入的文法的每个非终结符是否能推出空，再分别计算非终结符号的FIRST集合，每个非终结符号的FOLLOW集合，以及每个规则的SELECT集合，并判断任意一个非终结符号的任意两个规则的SELECT 集的交集是不是都为空，如果是，则输入文法符合LL(1)文法，可以进行分析。对于文法： G[E]: E->E+T|T T->T*F|F F->i|(E) 分析句子i+i*i是否符合文法。 二、基本思想 1、语法分析器实现 语法分析是编译过程的核心部分，它的主要任务是按照程序的语法规则，从由词法分析输出的源程序符号串中识别出各类语法成分，同时进行词法检查，为语义分析和代码生成作准备。这里采用自顶向下的LL(1)分析方法。 语法分析程序的流程图如图5-4所示。 语法分析程序流程图 该程序可分为如下几步： （1）读入文法 （2）判断正误 （3）若无误，判断是否为LL(1)文法 （4）若是，构造分析表； （5）由句型判别算法判断输入符号串是为该文法的句型。 三、核心思想 该分析程序有15部分组成： （1）首先定义各种需要用到的常量和变量； （2）判断一个字符是否在指定字符串中； （3）读入一个文法； （4）将单个符号或符号串并入另一符号串； （5）求所有能直接推出&的符号； （6）求某一符号能否推出‘& ’； （7）判断读入的文法是否正确； （8）求单个符号的FIRST； （9）求各产生式右部的FIRST； （10）求各产生式左部的FOLLOW； （11）判断读入文法是否为一个LL(1)文法； （12）构造分析表M； （13）句型判别算法； （14）一个用户调用函数； （15）主函数； 下面是其中几部分程序段的算法思想： 1、求能推出空的非终结符集 Ⅰ、实例中求直接推出空的empty集的算法描述如下： void emp(char c){ 参数c为空符号 char temp[10];定义临时数组 int i; for(i=0;i<=count-1;i++)从文法的第一个产生式开始查找 { if 产生式右部第一个符号是空符号并且右部长度为1, then将该条产生式左部符号保存在临时数组temp中 将临时数组中的元素合并到记录可推出&符号的数组empty中。 } Ⅱ、求某一符号能否推出'&' int _emp(char c) { //若能推出&，返回1；否则，返回0 int i,j,k,result=1,mark=0; char temp[20]; temp[0]=c; temp[1]='\0'; 存放到一个临时数组empt里,标识此字符已查找其是否可推出空字 如果c在可直接推出空字的empty[]中,返回1 for(i=0;;i++) { if(i==count) return(0); 找一个左部为c的产生式 j=strlen(right[i]); //j为c所在产生式右部的长度 if 右部长度为1且右部第一个字符在empty[]中. then返回1(A->B,B可推出空) if 右部长度为1但第一个字符为终结符,then 返回0(A->a,a为终结符) else 编译系统课程实验报告实验1：词法分析 常数： digits -> digit digit* optionalFraction -> .digits|ε optionalExponent -> E(+|-|ε)digits|ε number -> digits optionalFraction optionalExponent 运算符： （除/，/=外的）op -> + | - | * | += | -= | *= | % | ++ | -- | != | == | > | < | >= | <= | >> | << | ^ | | | & | && | || | ! | != （以/开头的）op->/|/= 界符：Boundary -> { | } | [ | ] | ( | ) | , | ; | : | ? |~ 行//注释：Comment->//(除\n外的字符)*\n 块/**/注释：Comment->/*(除*/外的字符)*/ 8进制：OCT -> 0(1|2|3|4|5|6|7)(0|1|2|3|4|5|6|7)* 16进制：HEX -> 0x(1|…|9|a|…|f) (0|…|9|a|…|f)* 字符常数：char -> ' (a|b|c|...|z|A|B|C|...|Z|_) ' 字符串常数：string-> "((((除\和”外的字符)*|\(所有字符)+)(除\和”外的字符|\”))*)"（2）各类单词的转换图 标识符： 8进制，16进制，10进制常数： 运算符： 界符： 行//注释： 块/**/注释：字符常数：字符串常数：实验一 词法分析器的设计
实验一词法分析实验报告
编译原理词法分析器语法分析器实验报告
编译原理实验--词法分析器
实验一词法分析实验报告
编译原理实验报告(语法分析器)
实验1 词法分析器
TEST语言 -语法分析,词法分析实验报告
词法分析器实验报告
词法分析器实验报告
东南大学编译原理词法分析器实验报告
词法分析器实验报告
词法分析的实验报告
编译原理语法分析器实验报告
编译原理词法分析器语法分析器实验报告
词法分析实验报告
语法分析器实验报告
语法分析器实验报告
词法分析器实验报告代码
- 编译原理实验报告(词法分析器语法分析器)
- (完整版)词法分析器实验报告
- 编译原理_词法分析器实验报告
- 词法分析器的设计与实现
- c词法分析器实验报告
- 编译原理词法分析器实验报告
- 编译原理实验报告(词法分析器 语法分析器)
- 语法分析器实验报告
- 东南大学编译原理词法分析器实验报告
- (最新版)编译原理词法分析器语法分析器实验报告
- 词法分析器实验报告
- 词法分析器实验报告
- 编译原理实验报告 实验一编写词法分析程序
- 词法分析实验报告审批稿
- 编译原理实验报告一简单样本语言的词法分析器
- 编译原理词法分析器语法分析器实验报告
- 词法分析器实验报告代码
- 编译原理词法分析器实验报告
- 编译原理实验报告(词法分析器语法分析器)
- 词法分析器(含完整源码)