词法分析及词法分析程序
词法分析及词法分析程序
– w,p,n初值为0,e初值为1;
– 处理整数部分时,对于每个di ,令w=w10+di ; – 处理小数部分时,对于每个di ,令w=w10+di ;及n++;
– 处理指数时,E后若有‘-’号,令e=-1;计算指数值 p=p10+d;
– 在出口处,令ICON=w或FCON=w10^(e(p-n)).
(2)设当前处在Ai状态,所扫描的字符为ai+1,在结点Ai所 射出的诸矢线中,寻找标记为ai+1的矢线(若不存在,则 表明w有语法错误),读入ai+1,并进入状态Ai+1;
(3)重复(2),直到w中所有字符被读完且恰好进入终态F 时,宣告整个识别结束,w可被接受.
28
例:G[Z]:
状态转换图:
Z→0U∣1V
{return ( ICON= w ); {n++; w=w*10+d;}
{return (FCON =w*pow(10,e*p-n) ) ;} {n++;w=w*10+d;} error {p=p*10+d;}
e=-1; error {p=p*10+d;} error {p=p*10+d;} {return (FCON=w*pow(10,e*p-n) );
(1)对于G中形如Aa 的产生式,引矢线RA,且标记
为a;
(2)对于G中形如ABa 的产生式,引矢线 BA,且标
记为a。
34
由左线性文法构造状态转换图
已给文法G=({S,U},{0,1},{SS1 |U1, UU0 | 0},S)
R0
0
1
U1 S
编译原理词法分析与语法分析的核心算法
编译原理词法分析与语法分析的核心算法编译原理是计算机科学与技术领域中的一门重要课程。
在编程中,我们常常需要将高级语言编写的程序翻译成机器语言,使计算机能够理解并执行我们编写的程序。
而编译原理中的词法分析和语法分析是编译器的两个核心算法。
一、词法分析词法分析是编译器的第一个阶段,它负责将输入的字符序列(源代码)划分为一个个的有意义的词素(Token),并生成相应的词法单元(Lexeme)。
词法分析的核心算法主要包括以下两个步骤:1. 正则表达式到有限自动机的转换:正则表达式是一种描述字符串匹配模式的表达式,它可以用来描述词法分析中各种词素的规则。
而有限自动机则是一种用来识别或匹配正则表达式所描述的模式的计算模型。
将正则表达式转换为有限自动机是词法分析的关键步骤之一。
2. 词法分析器的生成:在将正则表达式转换为有限自动机后,我们可以使用生成器工具(如Lex、Flex等)来生成词法分析器。
词法分析器可以按照预定的规则扫描源代码,并将识别出的词素转换成相应的词法单元,供后续的语法分析使用。
二、语法分析语法分析是编译器的第二个阶段,它负责分析和处理词法分析阶段生成的词法单元序列,并根据预定的语法规则确定语法正确的序列。
语法分析的核心算法主要包括以下两个步骤:1. 上下文无关文法的定义:上下文无关文法(Context-Free Grammar,简称CFG)是一种用于描述形式语言的文法。
它由一组产生式和终结符号组成,可以用于描述语法分析中的语法规则。
在语法分析中,我们需要根据具体编程语言的语法规则,编写相应的上下文无关文法。
2. 语法分析器的生成:通过使用生成器工具(如Yacc、Bison等),我们可以根据上下文无关文法生成语法分析器。
语法分析器可以根据预先定义的文法规则,对词法单元序列进行分析,并构建出语法树(Parse Tree)供后续的语义分析和代码生成使用。
综上所述,词法分析与语法分析是编译原理中的两个重要阶段,也是实现编译器的核心算法。
第三章 词法分析及词法分析程序 课后答案【khdaw_lxywyl】
课 后 答 案 网
第三章 词法分析及词法分析程序 1 试用某种高级语言编写一个 FORTRAN 源程序的预处理子程序,其功能是: 每调用它一次, 即把源程序中的一个完整语句送入扫描缓冲区。要求删去语句中的注释行;删去续行标记字 符,把语句中的各行连接起来,并在语句的末端加上语句结束符。此外,还要求此程序具有 组织源程序列表输出的功能。 2 画出用来识别如下三个关键字的状态转移图。 STEP STRING SWITCH 3 假定有一个猎人带着一只狼、一头山羊和一棵白菜来到一条河的左岸,拟摆渡过河,而岸 边只有一条小船,其 大小仅能装载人和其余三件东西中的一件,也就是说,每一次猎人只 能将随行者中的一件带到彼岸。若猎人将狼和山羊留在同一岸上而无人照管,那么,狼就会 将羊吃掉;如果猎人把山羊和白菜留在同一岸,山羊也会把白菜吃掉。现在,请你用状态转
试找出一个长度最小的输入串,使得:
h (1) 在识别此输入串的过程中,每一状态至少经历一次;
(2) 每一状态转换至少经历一次。 9 对于下列的状态转换矩阵:[]a[]bS[]A[]SA[]A[]BB[]B[]B(i) 初态:S
k 终态:B[][][]a[]bS[]A[]BA[]B[]AB[]B[]B(ii) 初态:S
26 指出下列 LEX 正规式所匹配的字符串:
. (1) "{" [^{]*"}"
(2) ^[^a-z][A-Z][0-9]$ (3) [^0-9]|[\r\n]
w (4) \′([^′\n]|\′\′)+\′
(5) \"([^"\n]|\\["\n])*\"
a 27 写出一个 LEX 正规式,它能匹配 C 语言的所有无符号整数 (例如:OX89ab,0123,45,
编译原理词法分析及词法分析程序
状态图=>右线性文法
文法G[0] 0->a1
d 0
S->aA A->dA A->b
a c
1 2
b
d
3
1->d1 1->b
0->c
0->c2 2->d
S->c
S->cB,2有出弧 B->d
左线性文法=>状态转换图
设G=(VN,VT,P,S)是一左线性文法,令|VN|=K, 1) 则所要构造的状态转换图共有K+1个状态. 2) VN中的每个符号分别表示K个状态 2.1) G的开始符S为终止状态 3) 起始状态,用R(VN)标记
识别符号串与归约
S
从初态R到下一状态A对应Ba,即终结 符a归约成非终结符B; U 从状态B转换到状态A对应ABa,即将 Ba归约为A; 状态A转换到状态S(终态)对应S Aa,即 U 将Aa归约为开始符S. 归约成功,恰好进入终态,即状态转换图识 U 别了(或接受)该符号串. 识别00011的例子的归约过程
f是转换函数,是在K×Σ →K上的映像,即:如果f(ki,a)=kj, (ki,kj∈K)意味着,当前状态为ki,输入字符为a时,将转换 为下一个状态kj,我们把kj称作ki的一个后继状态;
1.确定的有限自动机
通常把这五要素组成的五元式M=(K,∑,f, S0,Z)称为确定的 有限自动机(DFA),它是相应的状态转化图的一种形式描 述,或者说,是状态转换矩阵的另一种表示。 在状态转换的每一步,据DFA当前所处状态及扫视的输入 字符,能唯一确定下一状态。
例:文法G=({S,U},{0,1},{SS1 |U1,
词法分析程序
词法分析程序⼀、词法分析程序功能:词法分析器的功能为输⼊源程序,按照构词规则分解成⼀系列单词符号。
单词是语⾔中具有独⽴意义的最⼩单位,包括关键字、标识符、运算符、界符和常量等(1) 关键字是由程序语⾔定义的具有固定意义的标识符。
例如,Pascal 中的begin,end,if,while都是保留字。
这些字通常不⽤作⼀般标识符。
(2) 标识符⽤来表⽰各种名字,如变量名,数组名,过程名等等。
(3) 常数常数的类型⼀般有整型、实型、布尔型、⽂字型等。
(4) 运算符如+、-、*、/等等。
(5) 界符如逗号、分号、括号、等等。
⼆、符号与种别码对照表三、代码实现:#include <stdio.h>#include <stdlib.h>#include <string.h>#define SIZE 100char prog[SIZE],ch,token[8];int p=0,syn,n,i;char *keyword[6]={"begin","then","if","while","do","end"};//定义关键字数组void scaner();void main(){int select=-1;p=0;printf("请输⼊源程序字符串(以'#'结束):\n");do{ch=getchar();prog[p++]=ch;}while(ch!='#');p=0;do{scaner();switch(syn){case -1:printf("词法分析出错\n");break;default :printf("<%d,%s>\n",syn,token);break;}}while(syn!=0);printf("词法分析成功\n");getchar();}void scaner(){for(n=0;n<8;n++){token[n]='\0';}n=0;ch=prog[p++];while(ch==''){ch=prog[p++];}if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){do{token[n++]=ch;ch=prog[p++];}while((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')||(ch>='0'&&ch<='9'));syn=10;for(n=0;n<6;n++)//在六个关键字中对⽐{if(strcmp(token,keyword[n])==0)syn=n+1;}p--;}else if(ch>='0'&&ch<='9')//判断输⼊的是否为整数常数{p--;do{token[n++]=prog[p++];ch=prog[p];}while(ch>='0'&&ch<='9');syn=11;return;}else{switch(ch){case'+':syn=13;token[0]=ch;break;case'-':syn=14;token[0]=ch;break;case'*':syn=15;token[0]=ch;break;case'/':syn=16;token[0]=ch;break;case':':syn=17;token[0]=ch;ch=prog[p++];if(ch=='='){token[1]=ch;syn++;}else p--;break;case'<':syn=20;token[0]=ch;ch=prog[p++];if(ch=='>'){token[1]=ch;syn++;}else if(ch=='='){token[1]=ch;syn=syn+2;}else p--;break;case'>':syn=23;token[0]=ch;ch=prog[p++];if(ch=='='){token[1]=ch;syn++;}else p--;break;case'=':syn=25;token[0]=ch;break;case';':syn=26;token[0]=ch;break;case'(':syn=27;token[0]=ch;break;case')':syn=28;token[0]=ch;break;case'#':syn=0;token[0]=ch;break;default: printf("词法分析出错! 请检查是否输⼊⾮法字符\n");syn=-1;break; }}}四、程序运⾏结果截图:。
实验1:词法分析程序
实验1 词法分析程序一、实验目的与要求1.复习正规文法、正规式、有限自动机之间的相互转换的原理及技术;2.学会使用Visual C++等高级语言编程实现上述转换,并能合理显示结果;3.以C++的一个真子集为案例,具体分析词法分析程序的设计步骤、基本架构及代码编制,并通过一定实例验证其可行性,以加深对词法分析原理的理解;4.通过本次实验,使学生理解模块化程序设计的思想,从而从全局角度领会一个完整软件的设计精髓,为后续试验的顺利完成奠定坚实的基础。
二、实验仪器及设备1.微型电子计算机80台2.配置Windows 2000及以上版本操作系统3.安装Visual C++6.0/Visual C#2000/Delphi6.0等以上版本的开发环境三、实验内容及步骤(一)正规文法与有限自动机的相互转换1.正规文法⇒有限自动机已知某正规文法G[S]如下:S→aAS→bBS→εA→aBA→bAB→aSB→bAB→ε请编程实现:(1)将G[S]转换为NFA;(2)将上述得到的NFA确定化为DFA;(3)再将DFA最简化为MFA。
2.有限自动机⇒正规文法已知某有限自动机NFA M=(Q,∑,f,q0,Z)如下:状态集:Q={1,2,3,4,5,6,7,8,9}字母表:∑={a,b}转移函数:f(1,a)=5f(1,ε)=2f(1,a)=4f(5,ε)=6f(2,b)=3f(4,ε)=7f(6,ε)=2f(6,b)=9f(3,ε)=8f(8,a)=9f(7,b)=9初态:q0=1终态集:Z={6,7,9}请编程实现:(1)首先将此NFA确定化为DFA;(2)再将得到的DFA最简化为MFA;(3)最后,将MFA转化为正规文法(左线性或右线性均可)。
(二)编程实现MiniC++的词法分析这里的MiniC++为C++语言的一个真子集,其语法结构与C++类似。
基本组成如下:(1)关键字有18个,分别为:void、int、char、bool、float、double、if、else、switch、case、default、break、continue、do、while、for、return以及struct等。
编译原理中的词法分析与语法分析原理解析
编译原理中的词法分析与语法分析原理解析编译原理是计算机科学中的重要课程,它研究的是如何将源程序翻译成目标程序的过程。
而词法分析和语法分析则是编译过程中的两个重要阶段,它们负责将源程序转换成抽象语法树,为接下来的语义分析和代码生成阶段做准备。
本文将从词法分析和语法分析的原理、方法和实现技术角度进行详细解析,以期对读者有所帮助。
一、词法分析的原理1.词法分析的定义词法分析(Lexical Analysis)是编译过程中的第一个阶段,它负责将源程序中的字符流转换成标记流的过程。
源程序中的字符流是没有结构的,而编程语言是有一定结构的,因此需要通过词法分析将源程序中的字符流转换成有意义的标记流,以便之后的语法分析和语义分析的进行。
在词法分析的过程中,会将源程序中的字符划分成一系列的标记(Token),每个标记都包含了一定的语义信息,比如关键字、标识符、常量等等。
2.词法分析的原理词法分析的原理主要是通过有限状态自动机(Finite State Automaton,FSA)来实现的。
有限状态自动机是一个数学模型,它描述了一个自动机可以处于的所有可能的状态以及状态之间的转移关系。
在词法分析过程中,会将源程序中的字符逐个读取,并根据当前的状态和字符的输入来确定下一个状态。
最终,当字符读取完毕时,自动机会处于某一状态,这个状态就代表了当前的标记。
3.词法分析的实现技术词法分析的实现技术主要有两种,一种是手工实现,另一种是使用词法分析器生成工具。
手工实现词法分析器的过程通常需要编写一系列的正则表达式来描述不同类型的标记,并通过有限状态自动机来实现这些正则表达式的匹配过程。
这个过程需要大量的人力和时间,而且容易出错。
而使用词法分析器生成工具则可以自动生成词法分析器的代码,开发者只需要定义好源程序中的各种标记,然后通过这些工具自动生成对应的词法分析器。
常见的词法分析器生成工具有Lex和Flex等。
二、语法分析的原理1.语法分析的定义语法分析(Syntax Analysis)是编译过程中的第二个阶段,它负责将词法分析得到的标记流转换成抽象语法树的过程。
编译原理词法分析与语法分析的过程与方法
编译原理词法分析与语法分析的过程与方法编译原理是计算机科学领域中的重要内容之一,它研究如何将高级语言程序转化为机器语言的过程。
其中,词法分析和语法分析是编译原理中的两个重要阶段。
本文将详细介绍词法分析与语法分析的过程与方法。
一、词法分析的过程与方法词法分析是编译器的第一个阶段,其主要任务是将源程序的字符序列划分成有意义的语言单元,也就是词法单元。
以下是词法分析的过程与方法:1. 扫描:词法分析器从源程序中读取字符序列,并按照事先定义的规则进行扫描。
2. 划分词法单元:根据事先定义的规则,词法分析器将字符序列划分为不同的词法单元,如关键字、标识符、常量、运算符等。
3. 生成词法单元流:将划分好的词法单元按照顺序生成词法单元流,方便后续的语法分析阶段使用。
4. 错误处理:在词法分析过程中,如果发现了不符合规则的字符序列,词法分析器会进行错误处理,并向用户报告错误信息。
二、语法分析的过程与方法语法分析是编译器的第二个阶段,其主要任务是分析词法单元流,并判断是否符合语法规则。
以下是语法分析的过程与方法:1. 构建语法树:语法分析器根据语法规则构建抽象语法树(AST),用于表示源程序的语法结构。
2. 自顶向下分析:自顶向下分析是一种常用的语法分析方法,它从根节点开始,按照语法规则向下递归分析,直到生成叶子节点对应的词法单元。
3. 底部向上分析:底部向上分析是另一种常用的语法分析方法,它从词法单元开始,逐步合并为更高级的语法结构,直到生成抽象语法树的根节点。
4. 错误处理:在语法分析过程中,如果发现了不符合语法规则的词法单元流,语法分析器会进行错误处理,并向用户报告错误信息。
三、词法分析与语法分析的关系与区别词法分析和语法分析在编译原理中起着不同的作用:1. 关系:词法分析是语法分析的前置阶段,它为语法分析提供了有意义的词法单元流。
语法分析基于词法单元流构建语法树,判断源程序是否满足语法规则。
2. 区别:词法分析主要关注词法单元的划分和分类,它是基于字符序列的处理;而语法分析主要关注词法单元之间的组合和语法结构的判断,它是基于语法规则的处理。
编译原理实验 词法分析&语法分析程序
编译原理实验词法分析程序实验一:词法分析程序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循环,运算结束!。
第二章 词法分析
8
单词种别表示单词的种类, (1) 单词种别表示单词的种类,是语法分 析所需要的信息。 析所需要的信息。 一个语言的单词符号如何划分种类、 一个语言的单词符号如何划分种类、分为 几类、如何编码都属于技术性问题, 几类、如何编码都属于技术性问题,主要取 决于处理上的方便。 决于处理上的方便。 通常让每种单词对应一个整数码, 通常让每种单词对应一个整数码,这样可 最大限度地把各个单词区别开来。 最大限度地把各个单词区别开来。
6
(4) 运 算 符 : 如 “ +” 、 “ − ” 、 “ * ” 、 /”、 >”、 <”等 “/”、“>”、“<”等。 (5) 界符:在语言中是作为语法上的分界符 界符: 号使用的, 号使用的 , 如“ , ”、 “ ;” 、 “( ” 、 “ ) ” 等。 一个程序语言的保留字、 一个程序语言的保留字、运算符和界符 的个数是确定的, 的个数是确定的,而标识符或常数的使用则 不限定个数。 不限定个数。
24
终态一般对应一个return( 语句。 终态一般对应一个return( )语句。 return意味着从词法分析器返回到调用段 return意味着从词法分析器返回到调用段 一般指返回到语法分析器。 ,一般指返回到语法分析器。
图2–4 含有分支或回路的状态示意 (a) 含分支的状态 ;(b) 含回路的状态 含分支的状态i; 含回路的状态i
(3,’if’) (1,指向 的符号表入口) 指向i (1,指向i的符号表入口) (4,’=’) (2,’5’) (3,’then’) (1,指向 的符号表入口) 指向x (1,指向x的符号表入口) (4,’:=’) (1,指向 的符号表入口) 指向y (1,指向y的符号表入口) (5,’;’)
编译原理词法分析和语法分析报告+代码(C语言版)[1]
词法分析一、实验目的设计、编制并调试一个词法分析程序,加深对词法分析原理的理解。
二、实验要求2.1 待分析的简单的词法(1)关键字:begin if then while do end所有的关键字都是小写。
(2)运算符和界符:= + - * / < <= <> > >= = ; ( ) #(3)其他单词是标识符(ID)和整型常数(SUM),通过以下正规式定义:ID = letter (letter | digit)*NUM = digit digit*(4)空格有空白、制表符和换行符组成。
空格一般用来分隔ID、SUM、运算符、界符和关键字,词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码:输入:所给文法的源程序字符串。
输出:二元组(syn,token或sum)构成的序列。
其中:syn为单词种别码;token为存放的单词自身字符串;sum为整型常数。
例如:对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件,经过词法分析后输出如下序列:(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想:算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号,其基本思想是根据扫描到单词符号的第一个字符的种类,拼出相应的单词符号。
3.1 主程序示意图:主程序示意图如图3-1所示。
其中初始包括以下两个方面:⑴关键字表的初值。
关键字作为特殊标识符处理,把它们预先安排在一张表格中(称为关键字表),当扫描程序识别出标识符时,查关键字表。
如能查到匹配的单词,则该单词为关键字,否则为一般标识符。
关键字表为一个字符串数组,其描述如下:Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};图3-1(2)程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想:首先设置3个变量:①token用来存放构成单词符号的字符串;②sum用来整型单词;③syn用来存放单词符号的种别码。
编译原理词法分析和语法分析报告+代码(C语言版)[1]
词法分析一、实验目的二、设计、编制并调试一个词法分析程序, 加深对词法分析原理的理解。
三、实验要求2.1 待分析的简单的词法(1)关键字:begin if then while do end所有的关键字都是小写。
(2)运算符和界符: = + - * / < <= <> > >= = ; ( ) #(3)其他单词是标识符(ID)和整型常数(SUM), 通过以下正规式定义:ID = letter (letter | digit)*NUM = digit digit*(4)空格有空白、制表符和换行符组成。
空格一般用来分隔ID.SUM、运算符、界符和关键字, 词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码:输入: 所给文法的源程序字符串。
输出: 二元组(syn,token或sum)构成的序列。
其中: syn为单词种别码;token为存放的单词自身字符串;sum为整型常数。
例如: 对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件, 经过词法分析后输出如下序列:(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想:算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号, 其基本思想是根据扫描到单词符号的第一个字符的种类, 拼出相应的单词符号。
3.1 主程序示意图:主程序示意图如图3-1所示。
其中初始包括以下两个方面:⑴关键字表的初值。
关键字作为特殊标识符处理, 把它们预先安排在一张表格中(称为关键字表), 当扫描程序识别出标识符时, 查关键字表。
如能查到匹配的单词, 则该单词为关键字, 否则为一般标识符。
关键字表为一个字符串数组, 其描述如下:Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};图3-1(2)程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想:首先设置3个变量: ①token用来存放构成单词符号的字符串;②sum用来整型单词;③syn 用来存放单词符号的种别码。
北邮编译原理-词法分析文档和程序
实验报告班级:2011211314姓名: oneseven学号:一.题目:词法分析程序设计与实现二.实验内容:设计并实现 C 语言的词法分析程序,要求如下。
(1) 可以识别出用C语言编写的源程序中的每个单词符号,并以记号的形式输出每个单词符号。
(2) 可以识别并读取源程序中的注释。
(3) 可以统计源程序中的语句行数、单词个数和字符个数,其中标点和空格不计算为单词,并输出统计结果。
(4) 检查源程序中存在的非法字符错误,并可以报告错误所在的行列位置。
三.实现要求:采用C/C++作为实现语言,手工编写词法分析程序。
四.实现功能:基本完成了实验内容中要求的所有功能。
(1)识别出源程序中的每个单词符号,并以记号的形式输出每个单词符号(2)识别并读取源程序中的注释(3) 统计源程序中的语句行数、单词个数和字符个数(4) 检查源程序中存在的非法字符错误,并可以报告错误所在的行列位置。
注:本程序未把注释中的单词符号,“”中的单词符号统计在单词个数中。
单词个数只包括了标示符,关键字,无符号数。
五.实验原理:1.词法分析程序的功能:输入源程序,输出单词符号的记号形式,如图所示:源程序单词符号的记号形式2.处理过程:每次调用词法分析程序,它均能自动继续扫描下去,形成下一个单词,直至整个源程序全部扫描完毕,并形成相应的单词串形式的源程序。
六.代码#include<iostream>#include<fstream>#include<string>#include <iomanip>using namespace std;string keyword[32]={"auto","break","case","char","const", //关键字"continue","default","do","double","else","extern","enum","float","for","goto","if","int","long","return","register","static","short","signed","unsigned","struct","switch","sizeof","typedef","union","volatile","void","while"};int column=0,row=1,character=0,word=0;ifstream inf("test.txt",ios::in);char c;int find_key(string word) //匹配关键字{for(int i=0;i<32;i++)if(keyword[i].compare(word)==0)return 1;return 0;}void choice(){while(c=='\n'||c==' '||c=='\t') //不计空白符{if (c=='\n'){row++;column=0; //row清零,重新计数另一行}c=inf.get();column++;}return;}void get() //读取字符{character++;c=inf.get();column++;return;}int process(){string str="";if(inf.fail())cout<<"请创建test.txt并输入程序"<<endl;else{ofstream outf("out.txt");outf<<setw(10)<<"正规表达式"<<setw(30)<<"记号"<<setw(30)<<"属性"<<endl;c=inf.get();column++;while(c!=EOF){switch(c){ //匹配字符对应记号case 'a'...'z':case 'A'...'Z':case '_':word++;while(isalpha(c)||isdigit(c)||c=='_'){str+=c;get();}if(c=='@'||c=='?'||c=='$'||c=='#'){int tag=column;while(isalpha(c)||isdigit(c)||c=='_'||c=='@'||c=='?'||c=='$'||c=='#'){str+=c;get();}outf<<setw(10)<<str<<setw(30)<<"ERROR"<<setw(30)<<"错误在第"<<row<<"行第"<<tag<<"列"<<endl;str="";break;}if(find_key(str)){outf<<setw(10)<<str<<setw(30)<<str<<setw(30)<<"关键字"<<endl;str="";}else{outf<<setw(10)<<str<<setw(30)<<"id"<<setw(30)<<"标示符"<<endl;str="";}break;case '0'...'9':word++;while(isdigit(c)||c=='.'||c=='e'||c=='E'){str+=c;if(c=='e'||c=='E'){get();str+=c;}get();}if(isalpha(c)){int tag=column;while(isalpha(c)||c=='_'||isdigit(c)||c=='@'||c=='?'||c=='$'||c=='#'){str+=c;get();}outf<<setw(10)<<str<<setw(30)<<"ERROR"<<setw(30)<<"错误在第"<<row<<"行第"<<tag<<"列"<<endl;str="";break;}outf<<setw(10)<<str<<setw(30)<<"num"<<setw(30)<<"无符号数"<<endl;str="";break;case'>':get();if(c=='=')outf<<setw(10)<<">="<<setw(30)<<"relop"<<setw(30)<<"关系运算符"<<endl;else if(c=='>')outf<<setw(10)<<">>"<<setw(30)<<"bit_op"<<setw(30)<<"位运算符"<<endl;else{outf<<setw(10)<<">"<<setw(30)<<"relop"<<setw(30)<<"关系运算符"<<endl;break;}get();break;case'<':get();if(c=='=')outf<<setw(10)<<"<="<<setw(30)<<"relop"<<setw(30)<<"关系运算符"<<endl;else if(c=='<')outf<<setw(10)<<"<<"<<setw(30)<<"bit_op"<<setw(30)<<"位运算符"<<endl;else{outf<<setw(10)<<"<"<<setw(30)<<"relop"<<setw(30)<<"关系运算符"<<endl;break;}get();break;case'=':get();if(c=='=')outf<<setw(10)<<"=="<<setw(30)<<"relop"<<setw(30)<<"关系运算符"<<endl;else{outf<<setw(10)<<"="<<setw(30)<<"assign_op"<<setw(30)<<"赋值符"<<endl;break;}get();break;case'!':get();if(c=='=')outf<<setw(10)<<"!="<<setw(30)<<"relop"<<setw(30)<<"关系运算符"<<endl;else{outf<<setw(10)<<"!"<<setw(30)<<"logic_op"<<setw(30)<<"逻辑运算符"<<endl;break;}get();break;case'|':get();if(c=='|')outf<<setw(10)<<"||"<<setw(30)<<"relop"<<setw(30)<<"逻辑运算符"<<endl;else{outf<<setw(10)<<"|"<<setw(30)<<"logic_op"<<setw(30)<<"位运算符"<<endl;break;}get();break;case'&':get();if(c=='&')outf<<setw(10)<<"&&"<<setw(30)<<"relop"<<setw(30)<<"逻辑运算符"<<endl;else{outf<<setw(10)<<"&"<<setw(30)<<"logic_op"<<setw(30)<<"位运算符"<<endl;break;get();break;case'+':get();if(c=='+')outf<<setw(10)<<"++"<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;else if(c=='=')outf<<setw(10)<<"+="<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;else{outf<<setw(10)<<"+"<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;break;}get();break;case'-':get();if(c=='-')outf<<setw(10)<<"--"<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;else if(c=='=')outf<<setw(10)<<"-="<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;else{outf<<setw(10)<<"-"<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;break;}get();break;case'*':get();if(c=='=')outf<<setw(10)<<"*="<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;else{outf<<setw(10)<<"*"<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;break;}break;case '\"':str+=c;get();while(c!='\"'){str+=c;get();if(c==' '||c=='\t')character--;}str+='\"';outf<<setw(10)<<str<<setw(30)<<"literal"<<setw(30)<<"字符串"<<endl;str="";get();break;case'/':str+=c;get();if(c=='=')outf<<setw(10)<<"/="<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;else if(c=='/'){str+=c;get();while(c!='\n'&&c!=EOF){str+=c;get();}character--;outf<<setw(10)<<str<<setw(30)<<"annotation"<<setw(30)<<"注释"<<endl;}else if(c=='*'){str+=c;get();char tag=c;while(tag!='*'&&c!='/'&&c!=EOF){str+=c;tag=c;choice();get();}str+=c;outf<<setw(10)<<str<<setw(30)<<"annotation"<<setw(30)<<"注释"<<endl;}else{outf<<setw(10)<<"/"<<setw(30)<<"alg_op"<<setw(30)<<"运算符"<<endl;str="";break;}str="";get();break;case ' ':case '\n':case EOF:break;default:outf<<setw(10)<<c<<setw(30)<<c<<setw(30)<<"符号"<<endl;get();break;}choice();}outf<<"语句行数:"<<row<<endl;outf<<"单词个数:"<<word<<endl;outf<<"字符个数:"<<character<<endl;inf.close();outf.close();return 1;}inf.close();return 0;}int main(){int flag;flag=process();if(flag==1){cout<<"词法分析源程序详见test.txt"<<endl;cout<<"词法分析结果及错误分析详见out.txt"<<endl; //输出结果cout<<"语句行数:"<<row<<endl;cout<<"单词个数:"<<word<<endl;cout<<"字符个数:"<<character<<endl;}system("pause");return 0;}七.测试数据:(1)运行程序(2)测试代码test.txt(3)输出结果out.txt。
词法分析、语法分析、语义分析
词法分析、语法分析、语义分析词法分析(Lexical analysis或Scanning)和词法分析程序(Lexical analyzer或Scanner) 词法分析阶段是编译过程的第⼀个阶段。
这个阶段的任务是从左到右⼀个字符⼀个字符地读⼊源程序,即对构成源程序的字符流进⾏扫描然后根据构词规则识别单词(也称单词符号或符号)。
词法分析程序实现这个任务。
词法分析程序可以使⽤lex等⼯具⾃动⽣成。
语法分析(Syntax analysis或Parsing)和语法分析程序(Parser) 语法分析是编译过程的⼀个逻辑阶段。
语法分析的任务是在词法分析的基础上将单词序列组合成各类语法短语,如“程序”,“语句”,“表达式”等等.语法分析程序判断源程序在结构上是否正确.源程序的结构由上下⽂⽆关⽂法描述.语义分析(Syntax analysis) 语义分析是编译过程的⼀个逻辑阶段. 语义分析的任务是对结构上正确的源程序进⾏上下⽂有关性质的审查, 进⾏类型审查.例如⼀个C程序⽚断: int arr[2],b; b = arr * 10; 源程序的结构是正确的. 语义分析将审查类型并报告错误:不能在表达式中使⽤⼀个数组变量,赋值语句的右端和左端的类型不匹配.Lex ⼀个词法分析程序的⾃动⽣成⼯具。
它输⼊描述构词规则的⼀系列正规式,然后构建有穷⾃动机和这个有穷⾃动机的⼀个驱动程序,进⽽⽣成⼀个词法分析程序.Yacc ⼀个语法分析程序的⾃动⽣成⼯具。
它接受语⾔的⽂法,构造⼀个LALR(1)分析程序.因为它采⽤语法制导翻译的思想,还可以接受⽤C语⾔描述的语义动作,从⽽构造⼀个编译程序. Yacc 是 Yet another compiler compiler的缩写.源语⾔(Source language)和源程序(Source program) 被编译程序翻译的程序称为源程序,书写该程序的语⾔称为源语⾔.⽬标语⾔(Object language or Target language)和⽬标程序(Object program or Target program) 编译程序翻译源程序⽽得到的结果程序称为⽬标程序, 书写该程序的语⾔称为⽬标语⾔.中间语⾔(中间表⽰)(Intermediate language(representation)) 在进⾏了语法分析和语义分析阶段的⼯作之后,有的编译程序将源程序变成⼀种内部表⽰形式,这种内部表⽰形式叫做中间语⾔或中间表⽰或中间代码。
编译原理词法分析和语法分析报告+代码[C语言版]
词法分析一、实验目的设计、编制并调试一个词法分析程序,加深对词法分析原理的理解。
二、实验要求2.1 待分析的简单的词法(1)关键字:begin if then while do end所有的关键字都是小写。
(2)运算符和界符:= + - * / < <= <> > >= = ; ( ) #(3)其他单词是标识符(ID)和整型常数(SUM),通过以下正规式定义:ID = letter (letter | digit)*NUM = digit digit*(4)空格有空白、制表符和换行符组成。
空格一般用来分隔ID、SUM、运算符、界符和关键字,词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码:表2.1 各种单词符号对应的种别码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)……三、词法分析程序的算法思想:算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号,其基本思想是根据扫描到单词符号的第一个字符的种类,拼出相应的单词符号。
3.1 主程序示意图:主程序示意图如图3-1所示。
其中初始包括以下两个方面:⑴关键字表的初值。
关键字作为特殊标识符处理,把它们预先安排在一张表格中(称为关键字表),当扫描程序识别出标识符时,查关键字表。
如能查到匹配的单词,则该单词为关键字,否则为一般标识符。
关键字表为一个字符串数组,其描述如下:Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};是图3-1(2)程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想:首先设置3个变量:①token用来存放构成单词符号的字符串;②sum用来整型单词;③syn用来存放单词符号的种别码。
词法分析程序(c语言版)
源代码:1、词法分析/*cifa fenxi chengxu*/#include <stdio.h>#include <ctype.h>#include <alloc.h>#include <stdlib.h>#include <string.h>#define NULL 0FILE *fp;char cbuffer;char*key[8]={"if","else","for","while","do","return","break","continue"}; char *border[6]={",",";","{","}","(",")"};char *arithmetic[4]={"+","-","*","/"};char *relation[6]={"<","<=","=",">",">=","<>"};char *consts[20];char *label[20];int constnum=0,labelnum=0;int search(char searchchar[],int wordtype){int i=0;switch (wordtype) {case 1:for (i=0;i<=7;i++){if (strcmp(key[i],searchchar)==0)return(i+1);}case 2:{for (i=0;i<=5;i++){if (strcmp(border[i],searchchar)==0)return(i+1);} return(0);}case 3:{for (i=0;i<=3;i++){if (strcmp(arithmetic[i],searchchar)==0){return(i+1);}}return(0);}case 4:{for (i=0;i<=5;i++){if (strcmp(relation[i],searchchar)==0){return(i+1);}}return(0);}case 5:{for (i=0;i<=constnum;i++){if (strcmp(consts[i],searchchar)==0){return(i+1);}}consts[i-1]=(char *)malloc(sizeof(searchchar));strcpy(consts[i-1],searchchar);constnum++;return(i);}case 6:{for (i=0;i<=labelnum;i++){if (strcmp(label[i],searchchar)==0){return(i+1);}}label[i-1]=(char *)malloc(sizeof(searchchar));strcpy(label[i-1],searchchar);labelnum++;return(i);}}}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';if (atype=search(alphatp,1))printf("%s (1,%d)\n",alphatp,atype-1);else{atype=search(alphatp,6);printf("%s (6,%d)\n",alphatp,atype-1);}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);printf("%s (5,%d)\n",digittp,dtype-1);return(buffer);}char otherprocess(char buffer){int i=-1;char othertp[20];int otype,otypetp;othertp[0]=buffer;othertp[1]='\0';if (otype=search(othertp,3)){printf("%s (3,%d)\n",othertp,otype-1);buffer=fgetc(fp);goto out;}if (otype=search(othertp,4)){buffer=fgetc(fp);othertp[1]=buffer;othertp[2]='\0';if (otypetp=search(othertp,4)){printf("%s (4,%d)\n",othertp,otypetp-1);goto out;}elseothertp[1]='\0';printf("%s (4,%d)\n",othertp,otype-1);goto out;}if (buffer==':'){buffer=fgetc(fp);if (buffer=='=')printf(":= (2,2)\n");buffer=fgetc(fp);goto out;}else{if (otype=search(othertp,2)){printf("%s (2,%d)\n",othertp,otype-1);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(){int i;for (i=0;i<=20;i++){label[i]=NULL;consts[i]=NULL;};if ((fp=fopen("c:\\example.c","r"))==NULL)printf("error");else{cbuffer = fgetc(fp);while (cbuffer!=EOF){if (isalpha(cbuffer))cbuffer=alphaprocess(cbuffer);else if (isdigit(cbuffer))cbuffer=digitprocess(cbuffer);else cbuffer=otherprocess(cbuffer);}printf("over\n");getchar();}}2、递归向下分析#include <stdio.h>#include<dos.h>#include<stdlib.h>#include<string.h>char a[50] ,b[50],d[200],e[10];char ch;int n1,i1=0,flag=1,n=5;int E();int E1();int T();int G();int S();int F();void input();void input1();void output();void main() /*递归分析*/{int f,p,j=0;char x;d[0]='E';d[1]='=';d[2]='>';d[3]='T';d[4]='G';d[5]='#';printf("请输入字符串(长度<50,以#号结束)\n");do{scanf("%c",&ch);a[j]=ch;j++;}while(ch!='#');n1=j;ch=b[0]=a[0];printf("文法\t分析串\t\t分析字符\t剩余串\n");f=E1();if (f==0) return;if (ch=='#'){ printf("accept\n");p=0;x=d[p];while(x!='#') {printf("%c",x);p=p+1;x=d[p]; /*输出推导式*/}}else {printf("error\n");printf("回车返回\n");getchar();getchar();return;}printf("\n");printf("回车返回\n");getchar();getchar();}int E1(){ int f,t;printf("E TG\t");flag=1;input();input1();f=T();if (f==0) return(0);t=G();if (t==0) return(0);else return(1);}int E(){ int f,t;printf("E→TG\t");e[0]='E';e[1]='=';e[2]='>';e[3]='T';e[4]='G';e[5]='#';output();flag=1;input();input1();f=T();if (f==0) return(0);t=G();if (t==0) return(0);else return(1);}int T(){ int f,t;printf("T→FS\t");e[0]='T';e[1]='=';e[2]='>';e[3]='F';e[4]='S';e[5]='#';output();flag=1;input();input1();f=F();if (f==0) return(0);t=S();if (t==0) return(0);else return(1);}int G(){ int f;if(ch=='+') {b[i1]=ch;printf("G→+TG\t");e[0]='G';e[1]='=';e[2]='>';e[3]='+';e[4]='T';e[5]='G';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=T();if (f==0) return(0);G();return(1);}printf("G→^\t");e[0]='G';e[1]='=';e[2]='>';e[3]='^';e[4]='#';output();flag=1;input();input1();return(1);}int S(){int f,t;if(ch=='*') {b[i1]=ch;printf("S→*FS\t");e[0]='S';e[1]='=';e[2]='>';e[3]='*';e[4]='F';e[5]='S';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=F();if (f==0) return(0);t=S();if (t==0) return(0);else return(1);}printf("S→^\t");e[0]='S';e[1]='=';e[2]='>';e[3]='^';e[4]='#';output();flag=1;a[i1]=ch;input();input1();return(1);}int F(){ int f;if(ch=='(') {b[i1]=ch;printf("F→(E)\t");e[0]='F';e[1]='=';e[2]='>';e[3]='(';e[4]='E';e[5]=')';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=E();if (f==0) return(0);if(ch==')') {b[i1]=ch;printf("F→(E)\t");flag=0;input();input1();ch=a[++i1];}else {printf("error\n");return(0);}}else if(ch=='i') {b[i1]=ch;printf("F→i\t");e[0]='F';e[1]='=';e[2]='>';e[3]='i';e[4]='#';output();flag=0;input();input1();ch=a[++i1];}else {printf("error\n");return(0);}return(1);}void input(){int j=0;for (;j<=i1-flag;j++)printf("%c",b[j]); /*输出分析串*/printf("\t\t");printf("%c\t\t",ch); /*输出分析字符*/ }void input1(){int j;for (j=i1+1-flag;j<n1;j++)printf("%c",a[j]); /*输出剩余字符*/ printf("\n");void output(){ /*推导式计算*/ int m,k,j,q;int i=0;m=0;k=0;q=0;i=n;d[n]='=';d[n+1]='>';d[n+2]='#';n=n+2;i=n;i=i-2;while(d[i]!='>'&&i!=0) i=i-1;i=i+1;while(d[i]!=e[0]) i=i+1;q=i;m=q;k=q;while(d[m]!='>') m=m-1;m=m+1;while(m!=q) {d[n]=d[m];m=m+1;n=n+1;}d[n]='#';for(j=3;e[j]!='#';j++){d[n]=e[j];n=n+1;}k=k+1;while(d[k]!='=') {d[n]=d[k];n=n+1;k=k+1;}d[n]='#';}3、LL(1)/*LL(1)分析法源程序,只能在VC++中运行 */#include<stdio.h>#include<stdlib.h>#include<string.h>#include<dos.h>char A[20];/*分析栈*/char B[20];/*剩余串*/char v1[20]={'i','+','*','(',')','#'};/*终结符 */char v2[20]={'E','G','T','S','F'};/*非终结符 */int j=0,b=0,top=0,l;/*L为输入串长度 */typedef struct type/*产生式类型定义 */ {char origin;/*大写字符 */char array[5];/*产生式右边字符 */int length;/*字符个数 */}type;type e,t,g,g1,s,s1,f,f1;/*结构体变量 */ type C[10][10];/*预测分析表 */void print()/*输出分析栈 */{int a;/*指针*/for(a=0;a<=top+1;a++)printf("%c",A[a]);printf("\t\t");}/*print*/void print1()/*输出剩余串*/{int j;for(j=0;j<b;j++)/*输出对齐符*/printf(" ");for(j=b;j<=l;j++)printf("%c",B[j]);printf("\t\t\t");}/*print1*/void main(){int m,n,k=0,flag=0,finish=0;char ch,x;type cha;/*用来接受C[m][n]*//*把文法产生式赋值结构体*/e.origin='E';strcpy(e.array,"TG");e.length=2;t.origin='T';strcpy(t.array,"FS");t.length=2;g.origin='G';strcpy(g.array,"+TG");g.length=3;g1.origin='G';g1.array[0]='^';g1.length=1;s.origin='S';strcpy(s.array,"*FS");s.length=3;s1.origin='S';s1.array[0]='^';s1.length=1;f.origin='F';strcpy(f.array,"(E)");f.length=3;f1.origin='F';f1.array[0]='i';f1.length=1;for(m=0;m<=4;m++)/*初始化分析表*/for(n=0;n<=5;n++)C[m][n].origin='N';/*全部赋为空*//*填充分析表*/C[0][0]=e;C[0][3]=e;C[1][1]=g;C[1][4]=g1;C[1][5]=g1;C[2][0]=t;C[2][3]=t;C[3][1]=s1;C[3][2]=s;C[3][4]=C[3][5]=s1;C[4][0]=f1;C[4][3]=f;printf("提示:本程序只能对由'i','+','*','(',')'构成的以'#'结束的字符串进行分析,\n");printf("请输入要分析的字符串:");do/*读入分析串*/{scanf("%c",&ch);if ((ch!='i') &&(ch!='+')&&(ch!='*')&&(ch!='(')&&(ch!=')')&&(ch!='#')){printf("输入串中有非法字符\n");exit(1);}B[j]=ch;j++;}while(ch!='#');l=j;/*分析串长度*/ch=B[0];/*当前分析字符*/A[top]='#'; A[++top]='E';/*'#','E'进栈*/printf("步骤\t\t分析栈 \t\t剩余字符 \t\t所用产生式 \n"); do{x=A[top--];/*x为当前栈顶字符*/printf("%d",k++);printf("\t\t");for(j=0;j<=5;j++)/*判断是否为终结符*/if(x==v1[j]){flag=1;break;}if(flag==1)/*如果是终结符*/{if(x=='#'){finish=1;/*结束标记*/printf("acc!\n");/*接受 */getchar();getchar();exit(1);}/*if*/if(x==ch){print();print1();printf("%c匹配\n",ch);ch=B[++b];/*下一个输入字符*/flag=0;/*恢复标记*/}/*if*/else/*出错处理*/{print();print1();printf("%c出错\n",ch);/*输出出错终结符*/exit(1);}/*else*/}/*if*/else/*非终结符处理*/{for(j=0;j<=4;j++)if(x==v2[j]){m=j;/*行号*/break;}for(j=0;j<=5;j++)if(ch==v1[j]){n=j;/*列号*/break;}cha=C[m][n];if(cha.origin!='N')/*判断是否为空*/{print();print1();printf("%c->",cha.origin);/*输出产生式*/for(j=0;j<cha.length;j++)printf("%c",cha.array[j]);printf("\n");for(j=(cha.length-1);j=0;j--)/*产生式逆序入栈*/A[++top]=cha.array[j];if(A[top]=='^')/*为空则不进栈*/top--;}/*if*/else/*出错处理*/{print();print1();printf("%c出错\n",x);/*输出出错非终结符*/exit(1);}/*else*/}/*else*/}while(finish==0);}/*main*/4、LL(2)/*LL(1)分析法源程序,只能在VC++中运行 */#include<stdio.h>#include<stdlib.h>#include<string.h>#include<dos.h>char A[20];/*分析栈*/char B[20];/*剩余串*/char v1[20]={'i','+','*','(',')','#'};/*终结符 */ char v2[20]={'E','G','T','S','F'};/*非终结符 */int j=0,b=0,top=0,l;/*L为输入串长度 */typedef struct type/*产生式类型定义 */{char origin;/*大写字符 */char array[5];/*产生式右边字符 */int length;/*字符个数 */}type;type e,t,g,g1,s,s1,f,f1;/*结构体变量 */type C[10][10];/*预测分析表 */void print()/*输出分析栈 */{int a;/*指针*/for(a=0;a<=top;a++)printf("%c",A[a]);printf("\t\t");}/*print*/void print1()/*输出剩余串*/{int j;for(j=0;j<b;j++)/*输出对齐符*/printf(" ");for(j=b;j<=l;j++)printf("%c",B[j]);printf("\t\t\t");}/*print1*/void main(){int m,n,k=0,flag=0;char ch,x;type cha;/*用来接受C[m][n]*//*把文法产生式赋值结构体*/e.origin='E';strcpy(e.array,"TG");e.length=2;t.origin='T';strcpy(t.array,"FS");t.length=2;g.origin='G';strcpy(g.array,"+TG");g.length=3;g1.origin='G';g1.array[0]='^';g1.length=1;s.origin='S';strcpy(s.array,"*FS");s.length=3;s1.origin='S';s1.array[0]='^';s1.length=1;f.origin='F';strcpy(f.array,"(E)");f.length=3;f1.origin='F';f1.array[0]='i';f1.length=1;for(m=0;m<=4;m++)/*初始化分析表*/for(n=0;n<=5;n++)C[m][n].origin='N';/*全部赋为空*/ /*填充分析表*/C[0][0]=e;C[0][3]=e;C[1][1]=g;C[1][4]=g1;C[1][5]=g1;C[2][0]=t;C[2][3]=t;C[3][1]=s1;C[3][2]=s;C[3][4]=C[3][5]=s1;C[4][0]=f1;C[4][3]=f;printf("提示:本程序只能对由'i','+','*','(',')'构成的以'#'结束的字符串进行分析,\n");printf("请输入要分析的字符串:");do/*读入分析串*/{scanf("%c",&ch);if ((ch!='i') &&(ch!='+')&&(ch!='*')&&(ch!='(')&&(ch!=')')&&(ch!='#')){printf("输入串中有非法字符\n");exit(1);}B[j]=ch;j++;}while(ch!='#');l=j;/*分析串长度*/ch=B[0];/*当前分析字符*/A[top]='#';A[++top]='E';/*'#','E'进栈*/x=A[top];/*x为当前栈顶字符*/printf("步骤\t\t分析栈 \t\t剩余字符 \t\t所用产生式 \n");loop: printf("%d",k++);printf("\t\t");for(j=0;j<=5;j++)/*判断是否为终结符*/if(x==v1[j]) flag=1;if(flag==1)/*如果是终结符*/{if(x=='#'){printf("acc!\n");/*接受 */getchar();getchar();exit(1);}/*if*/if(x==ch){print();print1();printf("%c匹配\n",ch);top--;/*栈顶出栈*/ch=B[++b];/*下一个输入字符*/x=A[top];flag=0;/*恢复标记*/goto loop;}/*if*/else/*出错处理*/{print();print1();printf("%c出错\n",ch);/*输出出错终结符*/exit(0);}/*else*/}/*if*/else/*非终结符处理*/{for(j=0;j<=4;j++)if(x==v2[j])m=j;/*行号*/for(j=0;j<=5;j++)if(ch==v1[j])n=j;/*列号*/cha=C[m][n];if(cha.origin!='N')/*判断是否为空*/{print();print1();printf("%c-",cha.origin);/*输出产生式*/for(j=0;j<cha.length;j++)printf("%c",cha.array[j]);printf("\n");top--;for(j=(cha.length-1);j=0;j--)/*产生式逆序入栈*/A[++top]=cha.array[j];if(A[top]=='^')/*为空则不进栈*/top--;x=A[top];goto loop;}/*if*/else/*出错处理*/{print();print1();printf("%c出错\n",x);/*输出出错非终结符*/exit(0);}/*else*/}/*else*/}/*main*/5、逆波兰式include<stdio.h>#include<math.h>#define max 100char ex[max]; /*存储后缀表达式*/void trans(){ /*将算术表达式转化为后缀表达式*/char str[max]; /*存储原算术表达式*/char stack[max]; /*作为栈使用*/char ch;int sum,i,j,t,top=0;printf("*****************************************\n");printf("*输入一个求值的表达式,以#结束。
词法分析程序实验报告
词法分析程序实验报告词法分析程序实验报告班级:2013211306 学号:2013211321 姓名:严浩⼀)实验⽬的:(1)掌握词法分析程序的实现⽅法和技术:利⽤c语⾔描述了⼀个词法分析器,旨在对于词法分析的过程站在计算机的⾓度进⾏了解与体会。
(2)加深对有限⾃动机模型的理解:语法分析的过程就是⼀个对所碰到的单词符号进⾏⾃动机模拟的过程,碰到⼀个⾃⼰需要的字符就进⾏状态转换,并最终到达终⽌状态,即完成了⼀个运⽤源语⾔进⾏分析的过程。
(3)理解词法分析在编译程序中的作⽤:其主要任务是从左到右逐个字符的对源程序进⾏扫描,按照源语⾔的语法规则识别出⼀个个的单词符号,把识别出来的单词符号存⼊符号表中,并产⽣⽤于词法分析的记号序列。
(4)⽤c语⾔对⼀个简单语⾔的⼦集编制⼀个⼀遍扫描的编译程序,以加深对编译原理的理解,掌握编译程序的实现⽅法和技术。
⼆)实验环境Windows8.1 Cfree三)实验总结:1.⼀开始想⽤数组来存储每⼀⾏的字符串,后来发现极其不⽅便,尤其是当你要连接两段字符串的时候,所以后来改成了⽤链表来存储每⼀⾏的字符串,但每个单词还是⽤字符数组来存。
2.忘记了在扫描完⼀个单词后,指针要回退,否则会漏读字符,所以后来有加上了retract()函数。
3.⼀开始把运算符也当做单词,后来发现后,⽤总单词数减去运算符以及标点数才得到正确的单词数。
4.书上的伪代码不完整,只对⼀部分运算符进⾏了处理,像‘&’‘|’‘“’等都没有处理,还需要⾃⼰补充。
四)源代码:#include#include#include#include#define lensizeof(struct Node)struct Node{char data;struct Node *nextp;};struct Node *head,*p;//头指针和操作⽤的指针char token[255];//字符数组,存放读取的字符串intnum = 0;//⾮字符串单词数char * key[] = {"auto","double","int","struct","break","else","long", "switch","case","enum","register","typedef","char", "extern","return","union","const","float","short","unsigned", "continue","for","signed","void","default","goto", "sizeof","volatile","do","if","while","static" };//关键字查询表void get_char(){//读取字符C = p -> data;p = p ->nextp;}void get_nbc(){//.⼀直扫描,直到⾮空while(C == ' '){get_char();}}void concat(){// 将字符连接size_t i;i = strlen(token);token[i] = C;token[i + 1] = '\0';}int letter(char ch){//判断是否为字符returnisalpha((int) ch);}int digit(char ch){//判断是否为数字returnisdigit((int) ch);}void retract(){//指针回退struct Node *l;l = head ->nextp;while(l ->nextp != p){l = l ->nextp;}p = l;}for(keyjudge = 0; keyjudge<= 31 ; keyjudge ++){if(strcmp( key[keyjudge] , token) == 0){ returnkeyjudge;}}return 255;}//扫描缓冲区函数定义voidscaner(){int c;int j = 0;for( j = 0 ; j < 30 ; j ++){token[j] = '\0';}get_char();get_nbc();if(letter(C))//处理字符{while((letter(C)) || (digit(C)))//以字母开头的字母数字串{ concat(); //字符放⼊token数组中get_char(); //指针再往后读⼀个字符}retract(); //当出现除字母,数字外的字符时,指针回退c = reserve(); //字母数字串与保留字匹配if(c != 255)printf("(%s,-)\n",key[c]); //输出保留字记号else{printf("(%s,%d)\n",token, notkey);}}else if(digit(C)){while(digit(C))}retract();printf("(num,%d)\n",atoi(token)); }else{num ++;switch(C){case'+':get_char();if(C == '+')printf("(++,-)\n");else if(C == '=')printf("(+=,-)\n");else{retract();printf("(+,-)\n");}break;case'-':get_char();if(C == '-')printf("(--,-)\n");else if(C == '=')printf("(-=,-)\n");else if(C == '>')printf("(->,-)\n");else{retract();printf("(-,-)\n");}printf("(*=,-)\n"); else{retract();printf("(*,-)\n");}break;case'/':get_char();if(C == '/'){get_char(); printf("注释为:"); while(C != '\n'){printf("%c",C); get_char();}printf("\n");}else if(C == '*'){get_char(); printf("注释为:"); while(C != '*'){printf("%c",C); get_char();}printf("\n");get_char();}printf("(/=,-)\n"); break;}else{retract();printf("(/,-)\n");}break;case'%':get_char();if(C == '=')printf("%s\n","(%=,-)"); else{retract();printf("%s\n","(%,-)"); }break;case'<':get_char();if(C == '=')printf("(relop,LE)\n"); else{retract();printf("(relop,LT)\n"); }break;case'>':get_char();if(C == '=')printf("(relop,GE)\n");retract();printf("(relop,GT)\n"); }break;case'=':get_char();if(C == '=')printf("(relop,EQ)\n"); else{retract();printf("(assign-op,-)\n"); }break;case'!':get_char();if(C == '=')printf("(relop,NE)\n"); else{retract();printf("(logic,NOT)\n"); }break;case'&':get_char();if(C == '&')printf("(logic,AND)\n"); else{retract();printf("(&,-)\n");}case'|':get_char();if(C == '|')printf("(logic,OR)\n");else{retract();printf("(|,-)\n");}break;case'\n': printf("(enter-op,-)\n");break; case';': printf("(;,-)\n");break; case':': printf("(:,-)\n");break;case'{': printf("({,-)\n");break;case'}': printf("(},-)\n");break;case'(': printf("((,-)\n");break;case')': printf("(),-)\n");break;case'[': printf("([,-)\n");break;case']': printf("(],-)\n");break;case'.': printf("(.,-)\n");break;case',': printf("(,,-)\n");break;case'?': printf("(?,-)\n");break;default: printf("error"); break;}}}//主函数int main() {intrownum = 0;intbytenum = 0;int word = 0;head = (struct Node*)malloc(len);//头结点空间head -> data = ' ';head ->nextp = NULL;p = head;while(1){//以⾏为单位,读⼊代码,进⾏处int i = 0;char temp[260];// 假定每⾏字符数不超260gets(temp);if(temp[0] == '$')//如果读到第⼀字符为$,则做终⽌处理break; rownum ++;p ->nextp = (struct Node*)malloc(len);p = p ->nextp;while( temp[i] != '\0' && i < 260 ){p -> data = temp[i];p ->nextp = (struct Node*)malloc(len);if(!(p ->nextp)){printf("Error,don't have enough memory.\n");exit(1);}p = p ->nextp;i ++;bytenum ++;}p -> data = '\n';p ->nextp = NULL;}//扫描缓冲区,计算字符数和⾏数p=head->nextp;//指向本⾏C语⾔代码第⼀个字符while(p->nextp!=NULL) //循环直到本⾏打印结束,并计算单词数{printf("%c",p->data);p=p->nextp; //从头⾄尾遍历链表}printf("\n"); //显⽰最后⼀个回车p = head ->nextp;while( p ->nextp != NULL){scaner();//进⾏词法分析word++;if( reserve() == 255)}printf("This program has:%d lines. \n",rownum);printf("Besides note,there are %d words.\n",word - num);printf("There are %d bytes.\n",bytenum + rownum);//输出提⽰信息system("Pause"); return 0;}五)实验结果:。
第4章 词法分析
单词的描述工具--正规式
若两个正规式e1和e2所表示的正规集相同,则 称e1和e2等价,写作e1=e2。 例:
若e1=a|b,e2=b|a,则有e1=e2,a|b=b|a。 b(ab)*=(ba)*b (a|b)*=(a*b*)*
单词的描述工具--正规式
设r, s, t为正规式,正规式服从的代数规律有:
Z K是一个终态集,终态也称可接受状态或结束 状态。
有穷自动机
例:
DFA M=({S,U,V,Q},{a,b},f,S,{Q}) 其中 f 定义为: f(S,a)=U f(V,a)=U f(S,b)=V f(V,b)=Q f(U,a)=Q f(Q,a)=Q f(U,b)=V f(Q,b)=Q
有穷自动机
不断应用上述规则做变换, 直到每个产生式都符合正规文法 的形式。
正规文法与正规式的等价性
练习
将r=a(a|b)*转换成相应的正规文法。
转换规则: (1) 形如 Axy 改为 AxB, By,BVN (2) 形如 Axy 改为 AxB, Ay, BxB, By, BVN (3) 形如 Axy 改为 A x, A y
DFA 的状态图表示
a S U
a
a,b
b
a
Q
b
V
b
有穷自动机
DFA 的矩阵表示
状态 字符
S U V Q
a U Q U Q
b V V Q Q
0(非终态) 0(非终态) 0(非终态) 1(终态)
有穷自动机
∑*上的符号串t在DFA M上运行.. (我们将t表示成t1tx的形式, 其中t1∈∑,tx∈∑*) 在DFA M上运行的定义为: f(Q,t1tx)=f(f(Q,t1),tx),其中Q∈K。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
状态转换图
状态转换图:由一组矢线连接的有限个结点所 组成的有向图。
–每个结点代表在识别分析过程中扫描器所处的状态, 其中含有一个初始状态和若干个终态。在图中,状 态用圆圈表示,终态用双层圆圈表示。
–状态之间可用有向边连接,其上标记一字符a, 表示从有向边的射出状态出发,识别一字符a后, 将进入箭头所指状态(结点)
②此过程是一种推导过程.
Z=>0U=>01Z=>011V=>0110Z=>01100U=
>011001
32
右线性文法与状态转换图
设G是一右线性文法,M是相应的状态转换图,则从前面的讨 论可以看出如下事实:
(1)在利用M对符号串w进行识别时,M中每次状态的转换都模拟了一 步直接推导,即识别方法(或称分析方法) 是“”的;
的路径,此路径上各矢线的标记依次拼接起来所组成的符号串恰为 y。
33
由左线性文法构造状态转换图
设G=(VN,VT,P,S)是一左线性文法,构造相应的状态转换 图的方法是: 首先用VN中的非终结符标记M的结点,其中,开始符S 对应的结点为终态结点。引入一个新结点R(VN)标记初 态。矢线的连接规则为:
30
状态转换图与文法推导
用状态转换图识别符号串w的过程,就是为w建立一个 推导S* w的过程。
在第一步(在初始状态S下,扫描到a1而过渡到下一状 态A1),由状态转换图的构造规则可知,G中必有产生 式Sa1A1;
对于识别过程的后续步骤,由状态Ai 识别ai+1后过渡到 Ai+1恰好对应了使用产生式Ai ai+1Ai+1 。
(2)因右线性文法只有形如AaB、A a的产生式,所以推导的每
一步所得句型只含一个非终结符,且必出现在句型的最右端,所 以推导是规范推导,每步所得的句型也必为规范句型;
(3)对于M所识别的任一符号串x,必存在G中的一个推导S * x (即有 xL(G);反之,对于L(G)中任一句子y,必存在一条从初态S到终态F
第三章 词法分析及词法分析程序
1
词法分析程序设计的流程
1、各类单词表示成不同的正规文法Gi 2、求正规文法Gi对应的正规表达式 3、由各个正规表达式构造对应的-NFA 4、由各个-NFA组合成一个大的-NFA 5、大的-NFA确定化、最小化得到DFA M 6、DFA M就是构造词法分析程序的流程图 7、按照DFA M编写词法分析程序
24
例:G[Z]:
状态转换图:
Z→0U∣1V
U →1Z∣1
1
U
V →0Z∣0
0
1
初态
Z
F
1
0
0
V
25
利用状态转换图识别符号串的方法
对于已给的字符串w=a1a2…an,aiVT,利用状态转换图 对w 识别的步骤如下:
(1)从初始状态S出发,自左至右逐个扫描w的各个字符 (当前为a1),此时在结点S所射出的诸矢线中,寻找标 记为a1的矢线(若不存在,则表明w有语法错误),读入 a1并沿矢线所指方向前进,过渡到下一状态(设为A1).
19
3.2.1 由正规文法构造状态转换图
程序设计语言的单词都能用正规文法描述,例如, 标识符可定义为: <标识符><标识符>字母 <标识符><标识符>数字 <标识符> 字母
若把字母、数字视为终结符,则上述产生式为左 线性文法,是正规文法。
若我们用d表示0-9间的数字,则C语言的<无符 号数>的文法是右线性文法,也是正规文法(见 P48)
单词
运算符
MUL GT
词文 * >
模式 * >
界符
,
,
,
串常量
STRING
“hello” ‘there’
双(单)引号中间的字符 串(不包括引号本身)
7
3.2 正规文法和状态转换图
单词的描述:正规文法定义了3型语言,常见 的单词可由正规文法定义。 单词的识别:状态转换图可用于识别3型语言, 它是设计和实现扫描器的一种有效工具,是有 限自动机的直观图示。
最后在状态An-1识别an后到达终态F,对应了使用产生 式A an。
整个推导过程:S a1A1 a1a2A2 …… a1a2…an-1An-1 a1a2…an
31
例:G[Z]:
状态转换图:
Z→0U∣1V
U →1Z∣1 V →0Z∣0
1
U
0
1
初态
Z
F
1
0
0 V
例: ω=011001
通过状态图可以确定ω是文法的句子.
2
程序语言的单词(1)
单词:同类词文的总称 词文:源程序中能匹配某一记号的字符串 模式:描述用字符串构成单词的规则
单词
WHILE
关键字 FOR
标识符 ID
常数 NUM
词文 while
for temp, i,
max 3.14 100
模式 while
for 字母开头的字母数字串
数字串{.数字串}
6
程序语言的单词(2)
22
状态转换图的构造原则
①G的每一个非终结符号代表一结点(状态)
A
B
②开始符号S作为初始状态 S
设一符号F不属于V作为终止状态 F
③形如A→aB的规则 a
A
B
④形如A→a的规则
a
A
F
特别:A →ε 未曾在A的射出弧中 出现A过的终结符号
F
某些情况下也可考虑直接将A作为终态 A
23
例:G[Z]: Z→0U∣1V U →1Z∣1 V →0Z∣0
U →1Z∣1
1
U
V →0Z∣0
01Βιβλιοθήκη 初态ZF1
0
0
V
ω1=011001 ω2=111001
29
状态转换图识别的语言
显然,若从初态出发,分别沿一切可能的路径到达终态结 点,并将路径中矢线上所标记的字符依次连接起来,便得 到状态转换图所能识别的全部符号串,这些符号串组成 的集合构成了该状态转换图识别的语言。
(2)设当前处在Ai状态,所扫描的字符为ai+1,在结点Ai所 射出的诸矢线中,寻找标记为ai+1的矢线(若不存在,则 表明w有语法错误),读入ai+1,并进入状态Ai+1;
(3)重复(2),直到w中所有字符被读完且恰好进入终态F 时,宣告整个识别结束,w可被接受.
28
例:G[Z]:
状态转换图:
Z→0U∣1V
凡能用正规文法描述的语言,均可由某种有限 状态算法——状态转换图进行分析。
21
由右线性文法构造状态转换图
设G=(VN,VT,P,S)是一右线性文法,并设|VN|=k, 则所要构造的状态转换图共有k+1个状态(结 点)。用VN中的每个符号分别标记其中的k个 结点,且令G的开始符S为初态结点;余下 的一个结点作为终态结点,用F(VN)标记。