精华内容
下载资源
问答
  • 文法文法分类

    2019-09-27 12:07:05
    文法文法是定义和阐明语言的一种规格化方法,也可以说是有穷的集合刻画无穷的集合的一种工具 20世纪50年代,美国语言学家乔姆斯基提出一个短语结构文法,同时还根据产生语言的文法的产生式的不同将文法和对应的...

    文法

    文法的定义

    文法:文法是定义和阐明语言的一种规格化方法,也可以说是以有穷的集合刻画无穷的集合的一种工具

    20世纪50年代,美国语言学家乔姆斯基提出一个短语结构文法,同时还根据产生语言的文法的产生式的不同将文法和对应的语言分为三大类

    一个短语结构文法grammer)(简称)文法G包括:

    • 一个有限集合N,其元素称为非终结符号
    • 一个有限集合T,其元素称为终结符号
    • {(N∪T)* - T*} x (N∪T)* 的一个有限子集P,称为产生式的集合
    • 一个开始符号σ∈N 

    记作G=(N,T,P,σ)

    产生式:产生式(α,β)∈P通常写成α→β。在产生式中a∈(N∪T)* - T*,于是α至少包含一个非终结符号,而β能够由终结符号和非终结符号的任意组合构成。

    α称为这个产生式的左部,β称为这个产生式的右部

    文法的推导

    (1)设G=(N,T,P,σ)是一个文法,如果α→β是一个产生式且xαy∈(N∪T)* ,这里x,y∈(N∪T)* ,则称xβy可直接从xαy推导,并写成xαy=>xβy

    (2)如果对于αi∈(N∪T)*(i=1,2,...,n),都有αi+1∈(N∪T)*(i=1,2,...,n-1)可直接从αi推出,则称αn可从α1推导,并写成αn=>α1,我们称α1=>α2=>...=>αnαn的推导

    一个约定:(N∪T)*的任意元素都是自身可推导的。w∈T*称为文法正确的当且仅当σ=>w

    可见推导是是(N∪T)*上的关系,而且具有传递性

    注意,“文法正确”不一定“语意正确”

    文法到语言

    文法G生成的语言是指σ可推导的T上所有字符串组成的集合,记作L(G)

    例如:

    (1)文法G=({σ},{x},{σ→xσ,σ→x},σ)生成的语言是L(G)={xn | n≥1}

    (2)文法G=({σ},{x},{σ→xσ,σ→λ},σ)生成的语言是L(G)={xn | n≥0}

    (3)文法G=({σ},{x},{σ→xσy,σ→xy},σ)生成的语言是L(G)={xnyn | n≥1}

    文法的等价

    如果L(G)=L(G’),则称文法G和G’等价

    例如:

    (1)文法G=({σ},{x},{σ→xσ,σ→x},σ)生成的语言是L(G)={xn | n≥1}

    (2)文法G=({σ},{x},{σ→σx,σ→x},σ)生成的语言是L(G)={xn | n≥1}

    这两个语言相同,所以这两个文法等价

     

    文法的分类

    设G=(N,T,P,σ)是一个文法并设λ是空串。

    • 产生式的两端无任何限制的为0型文法,0型文法产生的语言称为0型语言或称递归可数语言
    • 如果每个产生式σAβ→αδβ,其中α,β∈(N∪T)*,A∈N,δ∈(N∪T)*-{λ}。则称G为上下文相关(1型)文法
    • 如果每个产生式为A→δ,其中A∈N,δ∈(N∪T)*,则称G为上下文无关(2型)文法
    • 如果每个产生式形式为A→a或A→aB或A→λ,其中A,B∈N,a∈T,则称G为正则(3型)文法

    为什么“1型”文法称为上下文相关文法?

    在上下文相关文法中,产生式σAβ→αδβ表明只有当非终止符号A的前后为α、β的条件下(即所谓的“上下文”),A才可以改写成δ

    而在上下文无关文法中,产生式A→δ表明任何时候都可以将A替换成δ.

    正则文法的产生非常简单,右部为一个终结符号、一个终结符号跟一个非终结符号或者为一个空串

    例如:

    (1)设N={σ,A,B,C,D,E},T={a,b,c},P={σ→aB,A→aAC,CD→CE,Cc→Dcc},则G={N,T,P,σ}是一个上下文相关文法

    (2)G=({σ},{0,1,+,x},{σ→0,σ→1,σ→σ+σ,σ→σxσ}P,σ)是一个上下文无关文法

    (3)可以证明L(G)={anbncn | n≥1}不是正则的

    (4)N={σ,S},T={a,b},P={σ→bσ,σ→aS,S→bS,S→b},则G={N,T,P,σ}是一个正则文法

    分析树

    分析树(parse tree),也称作派生树或具体语法树,它使用位置根树的形式描述一个上下文无关文法中句子的推导结果

    假设G={N,T,P,σ}是一个上下文无关文法。则

    • 对树中的每一个顶点使用N∪T中的一个符号进行表示
    • 跟的标号为σ
    • 树的叶子结点都是终结结点
    • 树的非叶子结点都是非终结结点
    • 若顶点A的子女结点从左到右依次B1、B2、... 、Bn,则必有产生式A→B1B2...Bn
    • 从左到右读出每个叶子节点的标号

    例如:

    正则文法G=(N,T,P,σ),N={σ,S},T={a,b},P={σ→bσ,σ→aS,S→bS,S→b},易知这是一个上下文无关文法

    从σ唯一推导的是

    $\sigma =>b\sigma =>...=>b^n\sigma \\=>b^naS=>...=>b^nan^{m-1}S\\=>b^nab^m$

    看一个具体的例子字符串bba可从σ可推导的,写成

    $\sigma =>b\sigma =>...=>b^n\sigma \\=>b^naS=>...=>b^nan^{m-1}S\\=>b^nab^m$

    所以它的分析树如下:

    歧义文法

    设G=(N,T,P,σ)是一个上下文无关文法,若存在x∈L(G),使得有两个(或两个以上)的分析树可以产生x,则称G为一个有歧义的文法,简称为歧义文法。

    有定理表明:上下文无关文法是否有歧义性是不可判定的。

    1961年帕克里(Rohit Parikh)证明一些文法具有固有的歧义性,即每个与之等价的文法都是歧义文法。

     

     

    参考资料:中国大学mooc  刘铎  离散数学

     

    转载于:https://www.cnblogs.com/lfri/p/10323446.html

    展开全文
  • 根据文法规则,判断文法类型

    千次阅读 2019-03-23 20:47:02
    四元组的形式展示出来: 文法G 定义为四元组G={Vn,Vt ,P,S} Vn :非终结符集 Vt :终结符集 P :产生式集合(规则集合) S :开始符号(识别符号) 文法类型: 文法类型分为四种:0型文法、1型文法、2型文法和3型...

    根据文法规则,判断文法类型

    1、实验要求

    输入:文法规则

    输出:文法类型

    2、实验原理

    文法规则:
    以四元组的形式展示出来:
    文法G 定义为四元组G={Vn,Vt ,P,S}
    Vn :非终结符集
    Vt :终结符集
    P :产生式集合(规则集合)
    S :开始符号(识别符号)

    文法类型:
    文法类型分为四种:0型文法、1型文法、2型文法和3型文法

    • 0型文法:通俗的说,写出来的文法规则都输出0型文法
    • 1型文法:又称上下文有关文法。
      满足条件:0型文法的基础上,右边字符个数不小于左边字符个数
      例如:S->aBC
      a->Bb
      C->c
    • 2型文法:又称上下文无关文法。
      满足条件:在1型文法的基础上,左部只有一个非终结符
      例如:S->aBC
      B->b
      C->c
    • 3型文法:又称规范文法。
      满足条件:在2型文法的基础上,产生式的右边字符数不超过2个且所有产生式要么都是左递归,要么都是右递归
      例如:S->aB
      B->bC
      C->c
      注:
      S->aB
      B->Cb
      C->c
      不成立,因为字符串既有左递归,又有右递归

    四种文法的关系可用如下图表示:
    在这里插入图片描述

    3、实验步骤

    1. 从键盘上输入文法规则(字符串)
    2. 对字符串进行按行比较,判断其所属的文法类型(先逐行判断文法类型1,然后再逐行判断文法类型2,最后在整个字符串判断文法类型3)
    3. 显示出结果(文法类型)

    4、实验过程

    1. 首先是进行结构体的构建,并且为了方便实用定义了全局变量
    //结构体 
    struct Rule{
    	char str[10];
    	int k;//记录局部文法类型 
    	int left;//记录产生式左边长度 
    	int right;//记录产生式右边长度 
    }r[10];
    
    int temp;//记录字符串行数 
    int level=0;//记录文法类型 
    
    
    1. 主函数运到了5个调用函数,分别是输入板块、文法类型1判断板块、文法类型2判断板块、文法类型3判断板块和输出板块
    //主函数 
    int main(){
    	Input();//输入文法规则 
    	Transform1();//类型1判断 
    	Transform2();//文法类型2判断 
    	Transform3();//文法类型3判断 
        Output();//输出文法类型 
    	return 0;
    } 
    
    1. 在输入板块进行了文法规则的输入,一字符串的形式从键盘输入,存储到结构体中
    //输入文法规则 
    void Input(){
    	int i,j;
    	printf("输入文法规则:\n");
    	printf("大写字母为非终止符,小写字母为终止符,第一个产生式左边为开始符,结束用$表示\n");
    	for(i=0;i<10;i++){
    		scanf("%s",r[i].str);
    		j=0;
    		if(r[i].str[j]=='$')
    		break;
    	}
    	temp=i; 
    }
    
    1. 文法类型1板块时进行判断文法规则的类型是否符合类型1,符合之后才能进行类型2的判断
    //判断文法类型1
    void Transform1(){
    	int i,j;
    	int length;
    	for(i=0;i<temp;i++){
    		r[i].k=0;
    		length=strlen(r[i].str);//字符串长度 
    		r[i].left=0;
    		for(j=0;r[i].str[j]!='-';j++)//左边长度 
    		r[i].left++;
    		r[i].right=length-r[i].left-2;//右边长度,减2表示减去字符'-'和'>' 
    		if(r[i].right>=r[i].left)
    		r[i].k=1;
    	}
    }
    
    1. 文法类型2板块时进行判断文法规则的类型是否符合类型2,符合之后才能进行类型3的判断
    //判断文法类型2
    void Transform2(){
    	int i,j,ss=0;
    	for(i=0;i<temp;i++){//判断是否字符串是否都为类型1 
    		if(r[i].k!=1)
    		ss=1;
    	}
    	if(ss==0)//字符串都为类型1,进行类型2的判断 
    	for(i=0;i<temp;i++){
    		j=0;
    	    if(r[i].left==1)//左边只有一个且是非终结符的类型1,则为类型2 
    	    if(r[i].str[j]>='A'&&r[i].str[j]<='Z')
    	    r[i].k=2;
    	}
    	level=1;	
    }
    
    1. 文法类型3板块时进行判断文法规则的类型是否符合类型3
    //判断文法类型3
    void Transform3(){
    	int i,j,t,m,n=0,sum=0,ss=0;
    	for(i=0;i<temp;i++){//判断是否字符串是否都为类型2 
    		if(r[i].k!=2)
    		ss=1; 
    	} 
    	if(ss==0){//字符串都为类型2,进行类型3的判断 
    		level=2;
        	for(i=0;i<temp;i++){
    	    	m=r[i].left+2;//产生式右边第一个字符 
         	    if(r[i].str[m]>='a'&&r[i].str[m]<='z')
    	    	t=1;
    	    	if(r[i].str[m]>='A'&&r[i].str[m]<='Z')
    	    	t=0;
    	    	sum+=t;
    	    	if(r[i].right>2)
    	    	n=1;
        	}
         	if(n==0)//保证产生式右边不超过2个字符 
        	if(sum==temp|sum==0)//保证产生式右边是左递归或右递归 
        	level=3;
        }
    }
    

    7.在输出板块需要注意的是,不仅要将文法的类型输出,小编也将该四元组进行显示出来

    //输出文法类型
    void Output(){
    	int i,j,m=0,n=0;
    	int t,p,ss;
    	char S,V1[100],V2[100],Vn[10]={},Vt[10]={};
    	S=r[0].str[0];//开始符 
    	for(i=0;i<temp;i++){
    		for(j=0;j<strlen(r[i].str);j++){
    			if(r[i].str[j]>='a'&&r[i].str[j]<='z')
    			V1[m++]=r[i].str[j];
    			if(r[i].str[j]>='A'&&r[i].str[j]<='Z')
    			V2[n++]=r[i].str[j]; 
    		}
    	}
    	t=0;
    	for(i=0;i<m;i++){//终止符 
    		ss=1;
    		for(j=0;j<t;j++){
         		if(V1[i]==Vt[j])
    	    	ss=0;
    	    }
    	    if(ss==1)
    	    Vt[t++]=V1[i];
    	}
    	p=0;
    	for(i=0;i<n;i++){//非终止符 
    		ss=1;
    		for(j=0;j<p;j++){
         		if(V2[i]==Vn[j])
    	    	ss=0;
    	    }
    	    if(ss==1)
    	    Vn[p++]=V2[i];
    	}
    	printf("该文法为第%d类型\n",level);//输出 
    	printf("该文法的四元组为:\n");
    	printf("S:%c\n",S); 
    	printf("Vn=");
    	for(i=0;i<p;i++)
    	printf("%2c",Vn[i]);
    	printf("\nVt=");
    	for(i=0;i<t;i++)
    	printf("%2c",Vt[i]);
    	printf("\nP:\n");
    	for(i=0;i<temp;i++)
    	printf("%s\n",r[i].str);	
    } 
    

    5、源代码和截图

    代码已经过调试,无编译错误

    #include<stdio.h>
    #include<string.h>
    
    //结构体 
    struct Rule{
    	char str[10];
    	int k;//记录局部文法类型 
    	int left;//记录产生式左边长度 
    	int right;//记录产生式右边长度 
    }r[10];
    
    int temp;//记录字符串行数 
    int level=0;//记录文法类型 
    
    //输入文法规则 
    void Input(){
    	int i,j;
    	printf("输入文法规则:\n");
    	printf("大写字母为非终止符,小写字母为终止符,第一个产生式左边为开始符,结束用$表示\n");
    	for(i=0;i<10;i++){
    		scanf("%s",r[i].str);
    		j=0;
    		if(r[i].str[j]=='$')
    		break;
    	}
    	temp=i; 
    }
    
    //输出文法类型
    void Output(){
    	int i,j,m=0,n=0;
    	int t,p,ss;
    	char S,V1[100],V2[100],Vn[10]={},Vt[10]={};
    	S=r[0].str[0];//开始符 
    	for(i=0;i<temp;i++){
    		for(j=0;j<strlen(r[i].str);j++){
    			if(r[i].str[j]>='a'&&r[i].str[j]<='z')
    			V1[m++]=r[i].str[j];
    			if(r[i].str[j]>='A'&&r[i].str[j]<='Z')
    			V2[n++]=r[i].str[j]; 
    		}
    	}
    	t=0;
    	for(i=0;i<m;i++){//终止符 
    		ss=1;
    		for(j=0;j<t;j++){
         		if(V1[i]==Vt[j])
    	    	ss=0;
    	    }
    	    if(ss==1)
    	    Vt[t++]=V1[i];
    	}
    	p=0;
    	for(i=0;i<n;i++){//非终止符 
    		ss=1;
    		for(j=0;j<p;j++){
         		if(V2[i]==Vn[j])
    	    	ss=0;
    	    }
    	    if(ss==1)
    	    Vn[p++]=V2[i];
    	}
    	printf("该文法为第%d类型\n",level);//输出 
    	printf("该文法的四元组为:\n");
    	printf("S:%c\n",S); 
    	printf("Vn=");
    	for(i=0;i<p;i++)
    	printf("%2c",Vn[i]);
    	printf("\nVt=");
    	for(i=0;i<t;i++)
    	printf("%2c",Vt[i]);
    	printf("\nP:\n");
    	for(i=0;i<temp;i++)
    	printf("%s\n",r[i].str);	
    } 
    
    //判断文法类型3
    void Transform3(){
    	int i,j,t,m,n=0,sum=0,ss=0;
    	for(i=0;i<temp;i++){//判断是否字符串是否都为类型2 
    		if(r[i].k!=2)
    		ss=1; 
    	} 
    	if(ss==0){//字符串都为类型2,进行类型3的判断 
    		level=2;
        	for(i=0;i<temp;i++){
    	    	m=r[i].left+2;//产生式右边第一个字符 
         	    if(r[i].str[m]>='a'&&r[i].str[m]<='z')
    	    	t=1;
    	    	if(r[i].str[m]>='A'&&r[i].str[m]<='Z')
    	    	t=0;
    	    	sum+=t;
    	    	if(r[i].right>2)
    	    	n=1;
        	}
         	if(n==0)//保证产生式右边不超过2个字符 
        	if(sum==temp|sum==0)//保证产生式右边是左递归或右递归 
        	level=3;
        }
    } 
    
    //判断文法类型2
    void Transform2(){
    	int i,j,ss=0;
    	for(i=0;i<temp;i++){//判断是否字符串是否都为类型1 
    		if(r[i].k!=1)
    		ss=1;
    	}
    	if(ss==0)//字符串都为类型1,进行类型2的判断 
    	for(i=0;i<temp;i++){
    		j=0;
    	    if(r[i].left==1)//左边只有一个且是非终结符的类型1,则为类型2 
    	    if(r[i].str[j]>='A'&&r[i].str[j]<='Z')
    	    r[i].k=2;
    	}
    	level=1;	
    }
    
    //判断文法类型1
    void Transform1(){
    	int i,j;
    	int length;
    	for(i=0;i<temp;i++){
    		r[i].k=0;
    		length=strlen(r[i].str);//字符串长度 
    		r[i].left=0;
    		for(j=0;r[i].str[j]!='-';j++)//左边长度 
    		r[i].left++;
    		r[i].right=length-r[i].left-2;//右边长度,减2表示减去字符'-'和'>' 
    		if(r[i].right>=r[i].left)
    		r[i].k=1;
    	}
    }	
    
    //主函数 
    int main(){
    	Input();//输入文法规则 
    	Transform1();//类型1判断 
    	Transform2();//文法类型2判断 
    	Transform3();//文法类型3判断 
        Output();//输出文法类型 
    	return 0;
    } 
    
    
    
    
    
    

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • 四种文法的判断非常简单,说到到,四种文法就是规定产生式的左和右边的字符的组成规则不同而已,其它的不能理解就不要去想了,你只要知道判断的时候就是产生式的左边和右边符合的规则进行判断。下面解释一下如何...

    引用:
    ====================
    S-> aaS|a是什么型的,为什么
    S-> aSb|ab是什么型的,为什么
    S-> SaS|b是什么型的,为什么
    =====================

    答:三种文法都属于上下文无关文法。

    四种文法的判断非常简单,说到到,四种文法就是规定产生式的左和右边的字符的组成规则不同而已,其它的不能理解就不要去想了,你只要知道判断的时候就是以产生式的左边和右边符合的规则进行判断。下面解释一下如何根据产生式左边和右边的特征来进行判断。

    首先,应该明确,四种文法,从0型到3型,其规则和约定越来越多,限制条件也越来越多,所以,我们判断时可以从最复杂的3型进行判断,依次向下判断,如果不符合3型的,那再看是不是2型的,不是2型的,再看是不是1型的,当然,对于作题作的熟的朋友,不用这么复杂,可以一眼直接看出来。

    3型文法遵循什么规范呢?
    第一点:左边必须只有一个字符,且必须是非终结符;
    第二点:其右边最多只能有两个字符,且当有两个字符时必须有一个为终结符而另一个为非终结符。当右边只有一个字符时,此字符必须为终结符。
    第三点:对于3型文法中的所有产生式,其右边有两个字符的产生式,这些产生式右边两个字符中终结符和非终结符的相对位置一定要固定,也就是说如果一个产生式右边的两个字符的排列是:终结符+非终结符,那么所有产生式右边只要有两个字符的,都必须前面是终结符而后面是非终结符。反之亦然,要么,就全是:非终结符+终结符。

    依以上规则判断,你所给的三个文法显然都不属于3型文法。

    再看2型文法如何判断:
    第一点:与3型文法的第一点相同,即:左边必须有且仅有一个非终结符。
    第二点:2型文法所有产生式的右边可以含有若干个终结符和非终结符(只要是有限的就行,没有个数限制)。

    依2型文法的判断规则,你的三个文法都属于2型文法,即:上下文无关文法。

    再看1型文法如何判断:
    第一点:1型文法所有产生式左边可以含有一个、两个或两个以上的字符,但其中必须至少有一个非终结符。
    第二点:与2型文法第二点相同。

    依1型文法判断规则,显然,你的文法也是属于1型的。

    最后是0型文法,这个就不用看了,只要你能描述出来,都属于这个类型,即0型。

    所以,取其最高的符合规则,最后的答案是其符合:上下文无关文法规则,即2型。

    转自:http://hi.baidu.com/topman8023/item/f0e0df6eb26300196895e608

    作者:Elaine
    出处:http://www.cnblogs.com/ITGirl00/

    展开全文
  • 简单文法c语言为例) //程序 <program> : external_declaration //外部声明 | body program//函数主体 程序 //外部声明 <external_declaration>: decla...

    简单文法(以c语言为例)

     

    //程序

    <program>                       

    external_declaration   //外部声明

    | body  program                       //函数主体 程序 

     

    //外部声明

    <external_declaration>       

    declaration external_declaration                //头文件声明 外部声明

    | function_definition  external_declaration     //函数声明  外部声明

    | program                                     //程序

     

    //头文件声明

    <declaration>   

    Symbol  identifier  bracket   identifier  bracket  declaration  //符号  标识符符号头文件 符号 头文件声明

    |type_specifier   variate ‘;’  declaration        //数据类型 变量  头文件声明

      (全局变量)

    | type_specifier  variate  type_specifier  variate ,type_specifier  variate  program                     //数据类型 变量(函数名) 参数   程序 (自定义函数的声明)  

                          

     

     //函数

    <function_definition>      

    type_specifier  declarator           //类型 头文件声明 

    compound_statement              //混合声明

     

      //函数主体

    <body>  

    identifier  bracket   body                     //main

    |type_specifier  variate ‘;’        //数据类型  变量 

    |initializer        //初始化

    |statement //声明、陈述

     

     

      //初始化

    <initializer>   

    variate Initializer                      //变量   初始化

    |Symbol Initializer                   //符号   初始化

    |unction_definition                   //函数  (函数调用)

     

    //数据类型

    <type_specifier>     

    Void

    |char

    |int

    |float

    |double

     

     //标识符 头文件

    <identifier>       

    Include

    | define

    |stdio.h

    |math.h

    |stdlib.h

    |time.h

    |string.h

    |main ‘(‘ ‘)’ 

     

     //声明、陈述

    <statement>    

    judge_statement          //判断

    |jump_statement //跳转符

    |iteration_statement //循环

    |selection_statement   //选择

     

      //判断

    <Judge_statement>    

    if Body

    |Body

     

       //循环

    <iteration_statement> 

     while Body

    | for Body

    | do Body while 

    |Body

     

     

     

      //跳转符

    <jump_statement>    

    Continue body

    |break body

    |return body

    |return  body

    |body

     

       //符号

    <Symbol >       

    #   

    |+ bracket 

    |=  bracket  

    |- bracket 

    | bracket 

    |bracket

    |

    |空串

     

     

     //括号

    <bracket>    

    (   bracket

    |)  bracket

    |{  bracket

    |}  bracket

    |<  bracket

    |>  bracket

    |空串

     

      //指针

    <Pointer >   

    '*'

    | '*' variate             //变量

     

      //变量

    <variate > 

    a  variate

    |b  variate

    |c  variate

    |.....

    |z  variate  

     

    //数字

    <figure>

    0  figure

    |1 figure

    |2 figure

    ......

    |9 figure

     

     

     

     

    转载于:https://www.cnblogs.com/veol/p/6127549.html

    展开全文
  • S_文法 条件: 每个产生式的右部都终结符开始 同一非终结符的各个候选式的首终结符都不同 局限性: 右部不能包含ε产生式 q_文法 引入SELECT集和FOLLOW集 q_文法中SELECT集的定义: 条件: 每个产生式的...
  • 编译原理之文法

    2014-04-22 12:58:56
    如果存在以文法为 基础的语言的实现,这些新结构的加入就更方便。   详细参加:http://zhidao.baidu.com/question/124218285.html(英文的) 七、小结:  上面描述的 (4)语言也是逐渐...
  • 错误之处还请指出来,共同学习! 1、从自然语言处理角度上来分析: 用“”“本来”造句如下: 本来这个进球就是违例的,但你不肯承认也没办法 我有一本来自美国的花花公子杂志 拿我的笔记本来 如果汉语是...
  • LR(0)文法如下:G[E]:E→aA∣bBA→cA∣dB→cB∣d改写为扩展文法后进行分析。#include #include #include #include #include #include #include #include ...//创建文法的有限状态自动机,并表格形式打印到屏幕voi...
  • D->aS|c第一步,求出能推出ε的非终结符首先建立一个以文法的非终结符为上界的一维数组,其数组元素为非终结符,对应每一非终结符有一个标志位,用以记录能否推出ε。如下表 非终结符 S A B C D 初值 未定 ...
  • 左递归文法

    千次阅读 2015-09-05 12:49:52
    一个文法G,若存在P经过一次或多次推导得到Pa(即能推导出P开头的式子), 则称G是左递归的。 左递归分为直接左递归和间接左递归。  直接左递归经过一次推导就可以看出文法存在左递归,如P→Pa|b。  间接左...
  • 编译原理-文法

    2018-09-02 22:47:19
    文法 大写表示非终结符 小写 终结符 0型文法也称为短语文法: ... 对0型文法产生式的形式作某些限制,给出1,2和3型文法的定义。 (注意) 文法G 定义为四元组(VN ,VT ,P,S) ¨VN :非终结符集 ...
  • byyl - 文法及语言

    2020-05-08 11:51:52
    目录 文法为什么出现? 文法的表示形式 文法的分类 BB...BBC类型文法 ABB...BBC类型文法 语言是什么?... 等价文法 已知文法求语言 ...文法有穷集合刻画无穷集合的一个工具; 2> 文法的表示形式...
  • TPL基础文法

    2019-05-07 11:45:20
    操作符(规则组合) R1 + R2 R1 + R2 表示顺序匹配:匹配 R1 ...编译原理中一般 R1 R2 表示(很遗憾,C++没有operator空格)。这应该是使用最多的文法了。 例如:要匹配html标签开始,也就是<tag>,这样写...
  • 说明:文法的空字符串@表示 实现:大写字母和小写字母分别表示终结符号以及非终结符号。(只能识别字母) 用<>和不带<> 分别表示终结符号以及非终结符号 产生式可以用->,::=表示 代码的部分...
  • 消除左递归文法

    2019-09-13 12:12:55
    一个文法G,若存在P经过一次或多次推导得到Pa(即能推导出P开头的式子), 则称G是左递归的。 左递归分为直接左递归和间接左递归。 直接左递归经过一次推导就可以看出文法存在左递归,如P→Pa|b。 间接左递归侧需...
  • c#开源 文法分析 语法在许多需要定期书写或处理大量单词的教师,学生,商人和其他人员中很流行。 这是一个有用的工具,但是您需要注册并登录才能使用它,而且我很少将网站登录数据保留在缓存中。 我经常处理单词...
  • 关于文法的分析

    2016-10-28 15:44:00
     在这次文法分析中是C语言的文法结构为标准的,由于受限于能力所以只是写出了该文法的一小部分,其中若有不当之处,请指正批评。  下面为文法分析: <程序> → <程序> <外部声明> | <外部...
  • 在形式语言学中,我们一般将语言形式化定义为:给定一组符号,称为字母表,Σ表示,又Σ∗表示由Σ中字母组成的所有字符串的集合,则Σ∗的每个子集都是Σ上的一个语言。二,Chomsky形式文法对语言形式定义后,...
  • LR(1)文法

    2019-11-20 21:11:55
    LR(1)文法 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 已知文法G[S]的表达式求文法的LR(1)的项目集和Go函数.要求使用广度优先搜索,同时按照字典序进行转换,保证项目集的序号正确. Input 单...
  • 本博客代码为主,代码中会有详细的注释。相关文章将会发布在我的个人博客专栏《Python自然语言处理》,欢迎大家关注。 文法在自然语言处理中可以提高处理的准确度,属于很关键的一环。 ''' 文法分析 ''' ...
  • 当一个文法是左递归文法时,采用自上而下分析法会使分析过程进入...其中 α、βα、βα、β 是任意的符号串,ααα 不等于 εεε,βββ 不 AAA 开头 (2)对A的规则可改写成如下右递归形式: 改写以后的形式...
  • 三种文法

    2010-03-11 10:03:00
    S->aaS|a是什么型的,为什么 S->aSb|ab是什么型... 四种文法的判断非常简单,说到到,四种文法就是规定产生式的左和右边的字符的组成规则不同而已,其它的不能理解就不要去想了,你只要知道判断的时候就是产生式的左
  • 编译原理文法

    千次阅读 2014-12-27 11:20:02
    文法:起描述作用的元语言,元语言是判断句子结构是否符合规范的依据 语言: 1. 语义(Semantics):单个元素的含义 2. 语法(Syntax):各个元素之间的组合规律 3. 语用(Pragmatics):语句和使用者之间的关系 ...
  • 左递归文法笔记

    千次阅读 2014-08-11 11:35:50
    一个文法G,若存在P经过一次或多次推导得到Pa(即能推导出P开头的式子), 则称G是左递归的。  左递归分为直接左递归和间接左递归。  直接左递归经过一次推导就可以看出文法存在左递归,如P→Pa|b。  间接左...
  • 属性文法和语法制导翻译一、概述属性文法,也称为属性翻译文法 “上下文无关文法” 为基础,扩充了以下两部分内容:每个文法符号(终结符或非终结符)有 “值”(属性)每个产生式有一组属性的语义规则,对属性...
  • 文法构造习题

    2020-03-04 16:01:59
    1、{ an | n >= 0 } G[S]:S -> aaaS | ε\varepsilonε 考虑边界,ε\varepsilonε为空(即n=0时) 2、{ anb2m-1 | m,n >=1 } 2m-1:b的个数为奇数个 ... b | bbB 使一个b开头,两...
  • 文法和语言总结与梳理 1.... ...第二章的主题是文法和语言,我觉得可以说一个程序设计语言是一个记号系统,包括语法和语义两个方面,而阐明语法的一个工具就是文法,所以说语言和文法是... 文法有穷的集合...
  • 编译原理之文法

    万次阅读 2018-09-17 19:23:14
    文法有穷的集合描述无穷的计划的工具。 字母表:元素的非空有穷集合,其中的元素称为符号,因此也叫符号集。 符号串:由字母表中的元素组成的任何有穷序列,串中的元素个数叫做符号串的长度,空符号串ε,长度...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 739
精华内容 295
关键字:

以文法