编译原理构造递归下降分析程序
㈠ 高分求编译原理递归下降语法分析设计原理
lz，最好改成这种形式，不要直接消左递归：
E -> TAE
T -> FMT
F -> (E) | i
A-> +|- M->*|/
㈡ 编译原理
FIRST(begin d ；X end)={begin}
FIRST(d ； X)={d}
FIRST(sY)={s}
FIRST(ε)={ε}
FOLLOW(P)={#}
FOLLOW(X)={end}
FOLLOW(Y)={end}
㈢ 求解编译原理题 构造递归下降分析程序
兄弟，其实这个问题不难，只是我感觉你给的问题不完全，不知道怎么给你解决，要不我给你个递归下降分析方法分析文法的例子吧，你先看看。我估计你看了这个后绝对就明白整体的分析思想了～
文法如下:
S->do s1 begin s2 end while s2
s1->s2mB
s2->AmB
A->B
B->VAL //VAL是所有非关键字的字符字符组和数字
m->+｜-｜*｜/｜>｜<｜=
/////////////*语法递归分析*/////////////////
int B(int * c,int & q)
{
if(c[q]==13)
{ q++;
return 1;
}
else if(c[q]==5)
{ q++;
return 1;
}
else {cout<<"error 'B'"<<endl;return 0;}
}
int A(int * b,int & o)
{
if(B(b,o))
{
return 1;
}
else {cout<<"error 'A'"<<endl;return 0;}
}
int OP(int *r,int & v)
{
if(r[v]==6)
{
v++;
return 1;
}
else if(r[v]==7)
{
v++;
return 1;
}
else if(r[v]==8)
{
v++;
return 1;
}
else if(r[v]==9)
{
v++;
return 1;
}
else if(r[v]==10)
{
v++;
return 1;
}
else if(r[v]==11)
{
v++;
return 1;
}
else if(r[v]==12)
{
v++;
return 1;
}
else {cout<<"error 'OP'"<<endl;return 0;}
}
int S2(int * d,int & h)
{
if(A(d,h))
{
if(OP(d,h))
{
if(B(d,h))
return 1;
else {cout<<"条件语句右部出错 "<<endl;return 0;}
}
else {cout<<"条件语句缺少运算符 "<<endl;return 0;}
}
else {cout<<"条件语句左部出错 "<<endl;return 0;}
}
int S1(int * d,int & h)
{
if(S2(d,h))
{
if(OP(d,h))
{
if(B(d,h))
return 1;
else {cout<<"循环语句右部出错 "<<endl;return 0;}
}
else {cout<<"循环语句缺少运算符 "<<endl;return 0;}
}
else {cout<<"循环语句左部出错 "<<endl;return 0;}
}
int S(int *a,int & z)
{
if (a[z++]==1)
{
if (S1(a,z))
{
if (a[z++]==2)
{
if (S2(a,z))
{
if(a[z++]==3)
{
if(a[z++]==4)
{
if(S2(a,z))
{
cout<<"语法分析成功!"<<endl;
return 1;
}
else return 0;
}
else {cout<<"error 'while'"<<endl; return 0;}
}
else {cout<<"error 'end'"<<endl; return 0;}
}
else return 0;
}
else {cout<<"error 'begin'"<<endl; return 0;}
}
else return 0;
}
else {cout<<"error 'do'"<<endl; return 0;}
}
/////////////////////// 语法分析结束 ////////////////////////
词法分析中单词代号 词法分析中可识别到的所有单词
1 do
2 begin
3 end
4 while
5 除关键字以外的所有字符或字符串
6 +
7 -
8 *
9 /
10 =
11 >
12 <
13 数字
14 结束标识符“#”
自己好好琢磨琢磨吧，其实思想挺简单的～
㈣ 用某种高级语言写出
FIRST(begin d ；X end)={begin}
FIRST(d ； X)={d}
FIRST(sY)={s}
FIRST(ε)={ε}
FOLLOW(P)={#}
FOLLOW(X)={end}
FOLLOW(Y)={end}
㈤ 编译原理 递归下降分析器
自顶向下分析法(递归下降分析程序构造)
E-->T/E+T
T-->F/T*F
F-->i/(E)
步骤 栈 输入字符串 状态
0 #E i1*(i2+i3)# 初始化
1 #T i1*(i2+i3)# E-->T
2 #T*F i1*(i2+i3)# T-->T*F
3 #T*i i1*(i2+i3)# F-->i
4 #F* *(i2+i3)# 匹配
5 #F (i2+i3)# 匹配
6 #(E) (i2+i3)# E-->(E)
7 #(E i2+i3)# 匹配
8 #(E+T i2+i3)# E-->E+T
9 #(E+F i2+i3)# T-->F
10 #(E+i i2+i3)# F-->i
11 #(E+ +i3)# 匹配
12 #(E i3)# 匹配
13 #(T i3)# E-->T
14 #(F i3)# T-->F
15 #(i i3)# F-->i
16 #( )# 匹配
17 # # 接受
所以可以写出
PROCEDURE E
BEGIN
T;
WHILE SYM='+' THEN ADVANCE;T END
END;
PROCEDURE T
BEGIN
F;
WHILE SYM='*' THEN ADVANCE;F END
END;
PROCEDURE F
BEGIN
IF SYM='i' THEN ADVANCE END
ELSE
IF SYM='(' THEN
BEGIN ADVANCE;E;
IF SYM=')' THEN ADVANCE;
ELSE ERROR;END
END;
㈥ 编译递归下降分析法
#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]='#';
}
这是我们用到的程序，看看对你有没有帮助。
至于下面的两个问题，很简单，可以容易做出来吧！
不会可以和我交流！
祝 进步！
㈦ 编译原理，递归下降子程序语法分析
没学过编译原理，看描述，是让写一个脚本执行软件。
终结符我查了下，就是不可再分的。比如iε。
输入是EGTSFI*/ε组成的字符串。
规则需要预处理。注意转意符在字符串中的效果。因为有/字符。
不会c或c++，只会c#。你可以到贴吧发帖。强人工智能吧 就挺好。算法吧有点乱。
最重要的，不要钱。
㈧ 编译原理,急
1. L(A)|L(A)=L(A) => A|A=A 2. A=b|aA => L(A)= {b或任意个a开头，以b结束的字符串} => A=a*b 同理：A=a*b => A=b|aA 所以：A=b|aA当且仅当A=a*b 3. ....有点麻烦
㈨ 编译原理：构造产生此语言的上下文无关文法G
对于文法G=(V, T, S, P)，如果产生式的形式如下：
A -> xB
A -> x
其中A, B属于V，x属于T*，则称为右线性文法；相似的，如果产生式的形式如下：
A -> Bx
A -> x
则称为左线性文法。右线性文法和左线性文法统称为正则文法。
正则表达式的表达能力等价于正则文法，正则表达式的定义如下：
字母表中的任意字母是正则表达式，空串和空集也是正则表达式；
如果r, s是正则表达式，那么r|s, rs, r*, (r)也是正则表达式。
正则表达式的扩展：
r+：一个或多个重复
. ：任意字符
[a-z]：字符范围
[^abc]：不在给定集合中的任意字符
r?：可选
正则表达式只能使用终结符（字母表中的字符），因而很容易变得复杂又难懂，实际中，经常使用正则描述，正则描述允许使用非终结符定义表达式，很像EBNF，但是它限制在未完全定义之前，不能使用非终结符，也就是说不允许递归或自嵌套。
像正则表达式的表达能力等价于正则文法一样，BNF范式的表达能力等价于上下文无关文法。BNF是“Backus Naur Form”的缩写。John Backus和Peter Naur首次引入一种形式化符号来描述给定语言的语法。
BNF的元符号：
::= 表示“定义为 ”，有的书上用-->
| 表示“或者”
< > 尖括号用于括起非终结符。
BNF的扩展EBNF：
可选项被括在元符号“[”和“]”中
重复项（零个或者多个）被括在元符号“{”和“}”中
仅一个字符的终结符用引号（"）引起来，以和元符号区别开来
上述操作符不是严格限定的，有的人喜欢直接使用扩展正则表达式的操作符描述EBNF。除了方便表达以外，引入EBNF的另一个主要原因是为了更紧密地把文法映射到递归下降分析程序的真实代码。当需要手动构造归下降分析程序的时候，通常把上下文无关文法改写为EBNF是必需的。
如果一个上下文无关文法G不是自嵌套或自递归的，即不存在如下推导：
U =>* xUy
那么L(G)是正则语言。自嵌套的上下文无关文法不一定是正则语言。事实上，一个上下文无关文法是严格的，既不可能由正则文法产生，当且仅当该语言的一切文法都是自嵌套的。
如果一个上下文无关文法G不是自嵌套或自递归的，即不存在如下推导：
U =>* xUy
那么L(G)是正则语言。自嵌套的上下文无关文法不一定是正则语言。事实上，一个上下文无关文法是严格的，既不可能由正则文法产生，当且仅当该语言的一切文法都是自嵌套的。
BNF的扩展EBNF：
可选项被括在元符号“[”和“]”中
重复项（零个或者多个）被括在元符号“{”和“}”中
仅一个字符的终结符用引号（"）引起来，以和元符号区别开来
上述操作符不是严格限定的，有的人喜欢直接使用扩展正则表达式的操作符描述EBNF。除了方便表达以外，引入EBNF的另一个主要原因是为了更紧密地把文法映射到递归下降分析程序的真实代码。当需要手动构造归下降分析程序的时候，通常把上下文无关文法改写为EBNF是必需的。
如果一个上下文无关文法G不是自嵌套或自递归的，即不存在如下推导：
U =>* xUy
那么L(G)是正则语言。自嵌套的上下文无关文法不一定是正则语言。事实上，一个上下文无关文法是严格的，既不可能由正则文法产生，当且仅当该语言的一切文法都是自嵌套的。
如上所述，上下文无关文法的递归性，对其分析方法也有很大影响。首先，用作识别这些结构的算法必须使用递归调用或显式管理的分析栈。其次，用作表示语言语义结构的数据结构现在也必须是递归的（通常是一颗分析树），而不再是线性的（如同用于词法和记号中的一样）了。
在程序设计语言中，通常用正则表达式描述词法规则。但是正则表示式的表达能力有限，她无法表达括号配对等语法形式，因而，需要引入表达能力更强的上下文无关文法。编译程序中常用正则文法表示词法，用上下文无关文法表示语法。那么程序语言中那些属于词法哪些属于语法呢？一个简单的办法，把所有能用正则文法表示的规则成为词法，即我们用尽可能的使用正则文法表示更多的东西，那些无法用正则表示式表示的成为句法，如C语言中的{ statement; }语法形式。语言中有些规则使用上下文无关文法仍然无法描述，例如变量的定义在使用之前，类型匹配等等，这些通常称为（静态）语义，它们在编译程序的静态语义检查阶段进行检测。
如果一个上下文无关文法G不是自嵌套或自递归的，即不存在如下推导：
U =>* xUy
那么L(G)是正则语言。自嵌套的上下文无关文法不一定是正则语言。事实上，一个上下文无关文法是严格的，既不可能由正则文法产生，当且仅当该语言的一切文法都是自嵌套的。