編譯原理文法類型判斷實驗
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/**//*全局變數定義*/
char inputString[10]; /**//*用來存儲用戶輸入的字元串，最長為20個字元*/
char stack[10]; /**//*用來進行語法分析的棧結構*/
int base=0; /**//*棧底指針*/
int top=1; /**//*棧頂指針*/
char VT[4]={'a','d','b','e'}; /**//*用來存放5個終結符*/
char chanShengShi[10]; /**//*用來存放預測分析表M[A,a]中的一條產生式*/
int firstCharIntex=0; /**//*如果a匹配產生式，則每次firstCharIntex 自增 1 */
/**//*firstCharIntex用來存放用戶輸入串的第一個元素的下標*/
/**//*自定義函數聲明*/
char pop() ; /**//*彈出棧頂元素*/
int push(char) ; /**//*向棧內添加一個元素，成功返回1，若棧已滿則返回0*/
int search(char temp) ; /**//*查找非終結符集合VT中是否存在變數temp，存在返回1，不存在返回0*/
int M(char A, char a) ; /**//* 若預測分析表M[A,a]中存在產生式，
則將該產生式賦給字元數組chanShengShi[10]，並返回 1，
若M[A,a]中無定義產生式則返回 0
*/
void init() ; /**//*初始化數組inputString[10] 、棧 stack[10] 和 chanShengShi[10]*/
int yuCeFenXi() ; /**//* 進行輸入串的預測分析的主功能函數，
若輸入串滿足文法則返回 1，不滿足則返回0
*/
void printStack(); /**//*列印棧內元素 */
void printinputString(); /**//*列印用戶輸入串 */
/**//*進入主函數*/
void main()
{
system("cls");
yuCeFenXi(); /**//*調用語法預測分析函數*/
system("pause");
}
/**//*函數的定義*/
int yuCeFenXi()
{
char X; /**//*X變數存儲每次彈出的棧頂元素*/
char a; /**//*a變數存儲用戶輸入串的第一個元素*/
int i;
int counter=1; /**//*該變數記錄語法分析的步驟數*/
init(); /**//*初始化數組*/
printf("wen fa : \n"); /**//*輸出文法做為提示*/
printf("S -> aH \n");
printf("H -> aMd | d \n");
printf("M -> Ab | \n");
printf("A -> aM | e \n");
printf("\ninput string ,'#' is a end sign !!(aaabd#) \n"); /**//*提示用戶輸入將要測試的字元串*/
scanf("%s",inputString);
push('#');
push('S');
printf("\nCounter-----Stack---------------Input string \n"); /**//*輸出結果提示語句*/
while(1) /**//*while循環為語法分析主功能語句塊*/
{
printf(" ");
printf(" %d",counter); /**//*輸出分析步驟數*/
printf(" "); /**//*輸出格式控制語句*/
printStack(); /**//*輸出當前棧內所有元素*/
X=pop(); /**//*彈出棧頂元素賦給變數X*/
printinputString(); /**//*輸出當前用戶輸入的字元串*/
if( search(X)==0 ) /**//*在終結符集合VT中查找變數X的值，存在返回 1，否則返回 0*/
{
if(X == '#') /**//*棧已經彈空，語法分析結果正確，返回 1*/
{
printf("success \n"); /**//*語法分析結束，輸入字元串符合文法定義*/
return 1;
}
else
{
a = inputString[firstCharIntex];
if( M(X,a)==1 ) /**//*查看預測分析表M[A,a]是否存在產生式，存在返回1，不存在返回0*/
{
for(i=0;i<10;i++) /**//* '$'為產生式的結束符,for循環找出該產生式的最後一個元素的下標*/
{
if( chanShengShi[i]=='$' ) break;
}
i-- ; /**//*因為 '$' 不是產生式，只是一個產生式的結束標志，所以i自減1*/
while(i>=0)
{
push( chanShengShi[i] ); /**//*將當前產生式逆序壓入棧內*/
i-- ;
}
}
else
{
printf(" error(1) !!\n"); /**//*若預測分析表M[A,a]不存在產生式，說明語法錯誤*/
return 0;
}
}
}
else /**//*說明X為終結符*/
{
if( X==inputString[firstCharIntex] ) /**//*如果X等於a,說明a匹配*/
{
firstCharIntex++; /**//*輸入串的第一個元素被約去，下一個元素成為新的頭元素*/
}
else
{
printf(" error(2) !! \n");
return 0;
}
}
counter++;
}
}
void init()
{
int i;
for(i=0;i<10;i++)
{
inputString[i]=NULL; /**//*初始化數組inputString[10] */
stack[i]=NULL; /**//*初始化棧stack[10] */
chanShengShi[i]=NULL; /**//*初始化數組chanShengShi[10]*/
}
}
int M(char A, char a) /**//*文法定義因實際情況而定，該文法為課本例題的文法*/
{ /**//*該函數模擬預測分析表中的二維數組 */
if( A=='S'&& a=='a' ) { strcpy(&chanShengShi[0],"aH$"); return 1; }
if( A=='H'&& a=='a' ) { strcpy(&chanShengShi[0],"aMd$"); return 1; }
if( A=='H'&& a=='d' ) { strcpy(&chanShengShi[0],"d$"); return 1; }
if( A=='M'&& a=='a' ) { strcpy(&chanShengShi[0],"Ab$"); return 1; }
if( A=='M'&& a=='d' ) { strcpy(&chanShengShi[0],"$"); return 1; }
if( A=='M'&& a=='b' ) { strcpy(&chanShengShi[0],"$"); return 1; }
if( A=='M'&& a=='e' ) { strcpy(&chanShengShi[0],"Ab$"); return 1; }
if( A=='A'&& a=='a' ) { strcpy(&chanShengShi[0],"aM$"); return 1; }
if( A=='A'&& a=='e' ) { strcpy(&chanShengShi[0],"e$"); return 1; }
else return 0; /**//*沒有定義產生式則返回0*/
}
char pop() /**//*彈出棧頂元素，用topChar返回*/
{
char topChar;
topChar=stack[--top];
return topChar;
}
int push(char ch)
{
if( top>9 )
{
printf(" error : stack overflow "); /**//*棧空間溢出*/
return 0;
}
else
{
stack[top]=ch; /**//*給棧頂空間賦值*/
top++;
return 1;
}
}
int search(char temp)
{
int i,flag=0; /**//*flag變數做為標志，若找到temp則賦1，否則賦0*/
for(i=0;i<4;i++)
{
if( temp==VT[i] ) /**//*終結符集合中存在temp*/
{
flag=1;
break;
}
}
if(flag==1) return 1; /**//*flag==1說明已找到等於temp的元素*/
else return 0;
}
void printStack() /**//*輸出棧內內容*/
{
int temp;
for(temp=1;temp<top;temp++)
{
printf("%c",stack[temp]);
}
}
void printinputString() /**//*輸出用戶輸入的字元串*/
{
int temp=firstCharIntex ;
printf(" "); /**//*該句控制輸出格式*/
do{
printf("%c",inputString[temp]);
temp++;
}while(inputString[temp-1]!='#');
printf(" \n");
}
⑵ 編譯原理 LR0文法的判定
設G1、G2是兩個文法，若L(G1)=L(G2)
，則稱G1與G2等價，記作G1≡G2。
即：文法的等價性是指他們所定義的語言是一樣的。
文法的化簡是指消除如下無用產生式：
⒈
刪除
A->A
形式的產生式(自定己)；
⒉
刪除不能從其推導出終結符串的產生式(不終結)；
⒊
刪除在推導中永不使用的產生式(不可用)。
⑶ 編譯原理語法分析實驗問題
錯誤1：在3.txt中，第二個表達式x:=2*3，在編譯器裡面沒有對*符號進行解釋，這個應補充，或者改掉*為+。
錯誤2：代碼中出現3次類似syn==15||16的代碼，我理解應該是(syn==15)||(syn==16)
改掉這兩點後代碼可以正常運行。
建議：寫代碼是一項工作，更是一個創作過程，建議你按照代碼寫作規范來寫，這樣的代碼清晰易讀，易於交流和糾錯。
⑷ 編譯原理中，形式語言里怎麼區分2型文法與3型文法
二型文法如下:
S->Ac
S->Sc
A->ab
A->aAb
三型文法如下:
S->aS
A->bA
B->cB
B->c
A->Bb
A、2型文法是上下文無關文法，表現在產生式上就是產生式的左部只有一個非終結備運賀符；3型文法從廣義上仿派講包括左線形文法、右線形文法和正規文法悄褲
。
B、左線形文法產生式的右部要麼沒有非終結符，如果有非終結符也只能有一個，且必須位於產生式右部的最左端。
C、右線形文法產生式的右部要麼沒有非終結符，如果有非終結符也只能有一個，且必須位於產生式右部的最右端
。
D、正規文法是右線形文法的一個子集，其產生式右部只有三種情況：
1）空串
2）只有一個終結符
3）只有一個終結符後接一個非終結符
E、所有的3型文法都是2型文法。
⑸ 編譯原理中如何用c語言來編寫程序判斷輸入的字元串是否符合文法規則
scanf()有返回值，若返回值是0，則不符合文法規則
一般情況下，scanf()返回值是輸入的字元數
⑹ 編譯原理實驗報告
#include<stdio.h>
void main()
{
int m=0,n=0,n1=0,n2=0,n3=0,zg,fzg,flag;
int bz[7]=;/*狀態改變控制，1 表示可以改變狀態zt值，0 表示不可以*/
int zt[7]=;/*狀態值，2表示未定狀態，1表示 是，0表示 否*/
char temp[100]="\0";/*用於求first集*/
char z[7];/*非總結符*/
char z1[7];/*總結符*/
char z2[7]="\0";/*gs[]文法中出現的標記個數的輔助字元 01234*/
char gs[100]="\0";/*文法，按順序排成字元串*/
printf("請依次輸入非終結符(不超過7個):");
gets(z);
while(z[m]!='\0')
fzg=m;//zg是非終結符個數
while(n<m)
//生成01234輔助字元
printf("您輸入了:");
puts(z);
fflush(stdin);
printf("請依次輸入終結符(不超過7個):");
gets(z1);
while(z1[n1]!='\0')
zg=n1;
printf("您輸入了:");
puts(z1);
fflush(stdin);
printf("按照正確格式輸入所有文法(總長度不超過100格式如下):");
printf("如果文法為(字元'k'表示空):\n");
printf("S-->AB S-->bC A-->k A-->b\n");
printf("輸入:0SAB0SbC1Ak1Ab\n");
printf(" (注:數字01234表示第一二三四個非終結符)\n");
gets(gs);
fflush(stdin);
printf("您輸入了:");
puts(gs);
m=0;
//對於輸入文法字元串的轉換，將每個文法式左部去除
while(gs[m]!='\0')
{
n=m;
if(gs[m]>='0'&&gs[m]<='9')
{
m++;
while(gs[m]!='\0')
{
gs[m]=gs[m+1];
m++;
}
//gs[m-1]='\0';
}
m=++n;
}
m=0;
//puts(gs);
/*情況一，直接判定是 形如: (A-->k) */
while(gs[m]!='\0')
{
if(gs[m]=='k')
{
zt[gs[m-1]-48]=1;
bz[gs[m-1]-48]=0;
}
m++;
}
/*情況二，直接判定--否 形如: (D-->aS ,D-->c) */
for(n=0;n<fzg;n++)
{
if(bz[n]==1)
{
m=0;
n2=0;
while(gs[m]!='\0')
{
if(z2[n]==gs[m])
{
if(gs[m+1]>=z1[0]&&gs[m+1]<=z1[n1-1])
zt[n]=0;
else //gs[m+1] 是非終結符n2做標記
}
//跳出循環，無法解決該情況，推到下面情況三
m++;
}
if(n2!=99) //完成所有掃描，未出現非終結符，得出結論zt[n]=0.bz[n]=0不允許再改變zt[n]
}
}
/*情況三，最終判定*/
do
{
flag=0;
for(n=0;n<fzg;n++)
{
if(bz[n]==1) //未得到判定
{ m=0;
while(gs[m]!='\0')
{
if(gs[m]==z2[n]) //判定gs[m]是輔助字元0123
{
m++;
while(gs[m]>='A'&&gs[m]<='Z')
{
n1=0;
for(n2=0;n2<fzg;n2++) //循環查找是gs[m]哪個非終結符
{
if(gs[m]==z[n2])
{
if(zt[n2]==1) //這個非終結符能推出空
zt[n]=1;
else if(bz[n2]==1) //這個非終結符 現在 不能推出空，但它的狀態可改即它最終結果還未判定
else
//設 m1 做標記供下一if參考
break; //找到gs[m]是哪個非終結符,for循環完成任務，可以結束
}
}
if(n1==99) break;
m++;
}
}
m++;
}
if(zt[n]==1) bz[n]=0;
if(bz[n]==0) flag=1;//對應for下的第一個if（zt[n]==2）
}
}
}while(flag);
printf("結果是:\n");
for(m=0;m<5;m++)
{
switch(zt[m])
{
case 0:printf("%c---否\n",z[m]);break;
case 1:printf("%c---是\n",z[m]);break;
case 2:printf("%c---未定\n",z[m]);break;
}
}
/*
puts(gs);
puts(zt);
puts(z);
puts(z1);
puts(z2);
printf("%d,,,%d",fzg,zg);
*/
//下面求first集
//下面求first集
for(n=0;n<fzg;n++)
m=0;n=0;n1=0;n2=0;
while(gs[n]>='0'&&gs[n]<='9')
{
for(;m<fzg;m++)
{
if(n2!=m)
n1=0; //m=n2用於第二次以後的for循環中還原上次m的值
if(gs[n]==z2[m])
{
while(gs[n+1]>'9')
{
if(n1==0)
//如果是第一個直接保存
//不是第一個，先與字元數組中其它字元比較，沒相同的才保存
else if(gs[n]>='a'&&gs[n]<='z'&&gs[n+1]>='A'&&gs[n+1]<='Z') //gs[n]是終結符 且 gs[n+1]是非終結符
;//什麼也不做，程序繼續n++，掃描下一個gs[n]
else
{
for(n3=0;n3<=n1;n3++)
{
if(temp[m*13+n3]==gs[n+1])
break;
}
if(n3>n1) //for循環結束是因為n3而不是break
}
n++;
}
break; //break位於if(gs[n]==z2[m]),對於gs[n]已找到z2[m]完成任務跳出for循環
}
}
n2=m; //存放該for循環中m的值
n++;
}
//進一步處理集除去非終結符
m=0;n=0;n1=0;n2=0;
for(m=0;m<fzg;m++)
{
if(flag!=m)
n1=0; //m=flag用於第二次以後的for循環中還原上次m的值
while(temp[m*13+n1]!='\0')
{
while(temp[m*13+n1]>='A'&&temp[m*13+n1]<='Z') //搜索非終結符
{
for(n=0;n<fzg;n++) //確定是哪個非終結符
{if(temp[m*13+n1]==z[n])
break;
}
while(temp[m*13+n1]!='\0') //從temp[n*13+n1]開始每個字元依次往前移動一
n1--;
while(temp[n*13+n2]!='\0') //把z[n]對應的first加入temp[m*13+n1]這個first中，每個字元依次加在最後
{
for(n3=0;n3<n1;n3++) //循環判定是否有相同的字元
{
if(temp[m*13+n3]==temp[n*13+n2])
break;
}
if(temp[n*13+n2]=='k'&&zt[m]==0) //那些不能推出 空，但是因為要加入 其他非終結符的first集 而可能含有 空
n2++;
else if(n3>=n1) //for循環結束是因為n3而不是break ,即無相同字元
else n2++;
}
n1=0;
n2=0;
}
n1++;
}
flag=m; //存放該for循環中m的值
}
//非終結符的first集輸出
m=0;n1=0;
for(m=0;m<fzg;m++)
{
n1=0;
printf("非終結符 %c 的first集是: ",z[m]);
while(temp[m*13+n1]!='\0')
{
printf("%c",temp[m*13+n1]);
n1++;
}
printf("\n");
}
}
⑺ 編譯原理中,形式語言里怎麼區分2型文法與3型文法
通過演算法對文法的每一產生式進行分析,如果存在復雜遞歸,則必是上下文無關文法,否則就是正則文法.
1、像A->Aa|ε這樣的文法,雖然存在遞歸,但卻是單一的自遞歸,可以通過有窮自動機表示和分析處理,所以是正則文法；
2、但是像E->E+T,T->id|(E)這樣的文法顯然非單一的自遞歸,而是存在復雜遞歸,自動機是無法表示和處理的,必然是上下文無關文法.
另外還請注意：
1、正則文法是上下文文法的子集,正則文法也屬於上下文無法,但有的上下文文法不一定是正則文法；
2、同時再結合這兩個的形式定義認真揣摩必定能悟出一二.
⑻ 四種文法的類型(編譯原理)
喬姆斯基（Chomsky）按產生式的類型把文法分為四種類型：0、1、2、3型文法。
*在下文中的產生式中，箭頭左邊的大寫字母為嚴格的非終結符，而其左邊的小寫字母不嚴格要求為非終結符，如[0型文法]中的第2條產生式。
【0型文法】
產生式形式：α→β
要求：箭頭左邊的α 至少 含有 一個非終結符 ， 其餘 不加任何限制
例如，G：C→AaB
aA→a
B→b|Bb
【1型文法】
產生式形式：α→β
要求： |α|≤|β| (產生式左端的長度<=右端的長度)，S→ε除外。
例如G： C→aAB
aA→aBa
B→b|Bb
【2型文法】(上下文無關文法)
產生式形式：A→β，A∈VN(終結符) ，β∈V *(VN∪VT，即可為終結符也可為非終結符)
說明：當以β替換A時，與A的上下文環境無關；
大部分程序設計語言近似於2型文法。
【3型文法】(正規文法 / 右線性文法)
產生式形式：A→a，A→aB，
說明：a∈VT(終結符) ， A，B∈VN(非終結符)，即產生式右端的第一個符號必須為 終結符
例如 G：A→aB
B→b|bB
【其他說明】對於這四種類型的文法：
*包含關系：0 > 1 > 2 > 3 (以'>'代替包含符，'A>B'譯為A包含B)
*嚴格程度：3 > 2 > 1 > 0
*判斷文法所屬類型的順序：3 → 2 → 1 → 0
⑼ 編譯原理 文法類型
0型文法(Type-0 Grammar)
1型文法(Type-1 Grammar)
2型文法(Type-2 Grammar)
3型文法(Type-3 Grammar)
無限制文法(Unrestricted Grammar) /短語結構文法(Phrase Structure Grammar, PSG )
∀α → β∈P， α中至少包含1個非終結符
0型語言
由0型文法G生成的語言L(G )
上下文有關文法(Context-Sensitive Grammar , CSG )
∀α → β∈P，｜α｜≤｜β｜
產生式的一般形式： α1Aα2 → α1βα2 ( β≠ε )
上下文有關語言（1型語言）
由上下文有關文法(1型文法) G生成的語言L(G )
上下文無關文法(Context-Free Grammar, CFG )
∀α → β∈P，α ∈ VN
產生式的一般形式：A→β
上下文無關語言（2型語言）
由上下文無關文法(2型文法) G生成的語言L(G )
正則文法(Regular Grammar, RG )
右線性(Right Linear)文法： A→wB 或 A→w
左線性(Left Linear) 文法： A→Bw 或 A→w
左線性文法和右線性文法都稱為正則文法
0型文法：α中至少包含1個非終結符
1型文法（CSG） ：｜α｜≤｜β｜
2型文法（CFG） ：α ∈ VN
3型文法（RG）：A→wB 或 A→w (A→Bw 或A→w)
0型文法包含1型文法，1型文法包含2型文法，2型文法包含3型文法
⑽ 編譯原理實現判斷是不是一個文法的句子
構造LL(1)語法分析程序，任意輸入一個文法符號串，並判斷它是否為文法的一個句子。程序要求為該文法構造預測分析表，並按照預測分析演算法對輸入串進行語法分析，判別程序是否符合已知的語法規則，如果不符合（編譯出錯），則輸出錯誤信息。