❶ 编译过程分为哪几个阶段各阶段的遵循的原则、识别机构、使用的文法编译原理
编译原理中的遍概念
编译阶段也常常划分为两大步骤，分析步骤和综合步骤 分析步骤和综合步骤 分析步骤是指对源程序的分析 －线性分析(词法分析或扫描) －层次分析(语法分析) －语义分析 综合步骤是指后端的工作，为目标程序的生成而进行的综合
你分析过吗？若按照这种组合方式实现编译程序，可以设想，某一编译程序的前端加上相应不同的后 端则可以为不同的机器构成同一个源语言的编译程序。也可以设想，不同语言编译的前端生成同一种中间 语言，再使用一个共同的后端，则可为同一机器生成几个语言的编译程序。
一个编译过程可由一遍、两遍或多遍完成。所谓"遍"，也称作"趟"，是对源程序或其等价的中间语言程 序从头到尾扫视并完成规定任务的过程。每一遍扫视可完成上述一个阶段或多个阶段的工作。例如一遍可 以只完成词法分析工作；一遍完成词法分析和语法分析工作；甚至一遍完成整个编译工作。对于多遍的编 译程序，第一遍的输入是用户书写的源程序，最后一遍的输出是目标语言程序，其余是上一遍的输出为下 一遍的输入。
在实际的编译系统的设计中，编译的几个阶段的工作究竟应该怎样组合，即编译程序究竟分成几遍， 参考的因素主要是源语言和机器(目标机)的特征。比如源语言的结构直接影响编译的遍的划分；像 PL/1 或 ALGOL 68 那样的语言，允许名字的说明出现在名字的使用之后，那么在看到名字之前是不便为包含该名 字的表达式生成代码的，这种语言的编译程序至少分成两遍才容易生成代码。另外机器的情况，即编译程 序工作的环境也影响编译程序的遍数的划分。遍数多一点，整个编译程序的逻辑结构可能清晰些，但遍数 多即意味着增加读写中间文件的次数，势必消耗较多时间，一般会比一遍的编译要慢。
❷ 编译原理中，形式语言里怎么区分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型文法。
❸ 在编译原理中： 文法S——>SS+|SS*|a能产生什么语言，并验证！ 求高人指导！
为了使问题简化，我们考虑文法S->ss+|a，考虑s->ss*时，只要把+换成*即可。
0层递归是，s->a,文法的语言是{a}。是后缀表达式。
1层以内递归时，文法语言是{a,aa+}。是后缀表达式。
2层以内递归时，文法语言是{a,aa+}.{a,aa+}.{+}。其中.表示连接，是后缀表达式。
依此类推，多少层的递归都是后缀表达式。
把表达式的+换成*后依然为后缀表达式。
下面证明文法产生的语言是所有的以a为变量，以+和*为运算符的后缀表达式。
因为每个表达式都对应一个常规的表达式（如1*2+3就是常规表达式），下面只需证明语言能产生的后缀表达式对应所有的常规表达式。当常规表达式只有一个运算符，对应aa+或aa*。当常规表达式有两个运算符，可写成(表达式1）.{+|*}.(表达式2），因为表达式1和2都只含一个运算符，所以可以用语言表示，上述常规表达式可用后缀表达式（表达式1）.（表达式2）.{+l*}表示。所以不管常规表达式有多少个运算符，都可以由语言的后缀表达式对应。
❹ 编译原理的文法是什么
文法是描述语言规则的形式规则。实际上就是用一个四元组G=(VT,VN,S,P)定义的一个推理方式。其中VT是终结符，VN是非终结符，S是开始符号，P是一组产生规则。
❺ 编译原理这门课程第三章语法分析的知识点有哪些
编译原理这门课第三章语法分析的知识点包含章节导引,第一节上下文无关文法,第二节语言和文法,第三节自上而下分析,第四节自下而上分析,第五节LR分析器,第六节二义文法的应用,课后练习,。
❻ 编译原理，文法G1是不是算符优先文法
G1是算符优先文法，它是1）不含空产生式的上下文无关文法，2）没有形如U-->...VW...其中V,W属于非终结符。
0)S'->#S#
1)S->S-T
2)S->T
3)T->T/F
4)T->F
5)F->(S)
6)S->e
1. 找到‘=’关系
由0和5得 #=# （=）
2. 找到”<“关系
#S，则：#<FirstVT(S)
-T，则：-<FirstVT(T)
/F，则：/<FirstVT(F)
(S，则：(<<FirstVT(S)
3. 找到”>“关系
S# ，则：LastVT(S)>#
S-，则：LastVT(S)>-
T/，则：LastVT(T)>/
S)，则：LastVT(S)>）
而
S'的FirstVT={ # } LastVT = { # }
S的FirstVT={- / ( e} LastVT = { - / ) e}
T的FirstVT= { /( e} LastVT = { /) e}
F的FirstVT= { ( e} LastVT = { ) e}
| - | / | ( | ) | e | #
- | > | < | < | > | < |>
/ | > | > | < | > | < |>
( | < | < | < | = | < |>
) | > | > | | > | |
e | > | > | | > | |>
# | < | < | < | | < |=
证明：任意二个终结符间至多只有一种算符优先关系存在，所以该文法为算符优先文法。
❼ 编译原理中 文法 文法G定义为四元组（Vn ,Vt,P,S）这4个是什么意思 另外 终结符和非终结符是什么意思
文法G是一个四元式（Vt,Vn,S,P）
其中Vt是一个非空有限集，它的每个元素称为终结符号
Vn是一个非空有限集，它的每个元素称为非终结符号（Vt和Vn的交集为空）
S是一个非终结符号，称为开始符号
P是一个产生式集合（有限），每个产生式的形式是P-->a
开始S必须在某个产生式的左部出现一次
终结符指组成语言的基本符号（如基本字、标识符、常数、算符、界符）
非终结符号（也称语法变量）表示一定符号串的集合。
你看到小写字母一般是终结符，大写字母肯定是非终结符
不明白可以联系。
❽ 编译原理:考虑文法G[S]
考虑文法：
(1)消去左递归后:
S→a|∧|(T)
T→ST’
T’ →,ST’|ε
(2)计算每个非终结符的FIRST集合和FOLLOW集合:
FIRST(S)={a,∧,(}
FIRST(T)={ a,∧,(}
FIRST(T’)={,ε}
FOLLOW(S)={,#}
FOLLOW(T)={ )}
FOLLOW(T’)={ )}
预测分析表如下:
\x09a\x09∧\x09(\x09)\x09,\x09#
S\x09S→a\x09S→∧\x09S→(T)\x09\x09\x09
T\x09T→ST’\x09T→ST’\x09T→ST’\x09\x09\x09
T’\x09\x09\x09\x09T’ →ε\x09T’ →,ST’\x09
构造的预测分析表中没有多重入口,所以改造后的文法是LL(1)文法.
❾ 编译原理文法分析
改完了,能文法分析出来了!!
大概 跟你说下 你的错误吧:
出错地点:
1.声明的stack[50]没有初始化;
2.stack的入栈是错误的,按照你的方式,如果原来有TM,再加入T->FN,则M就被挤出来了.(这里很关键,你对照我给你改的再看看)
3.s指针在你入栈操作以后并没有指向栈顶,而是保持了不变,这肯定是有问题的.(传入push函数的时候直接传参数s就好了.)
4.if(*s==*p){***}else{}的else的右括号管辖的范围 有错误
不嫌弃的话,可以去http://blog.csdn.net/fangguanya,我的BLOG,不怎么充实,呵呵,有这个程序的运行结果的. 谢谢 呵呵.
总之你对照我给你改的再看看吧. 我把我的测试输出 也给保留了.你好对照点.
(PS.我用的vs2005,用的时候你改下头申明,其他一样)
// grammar.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include<iostream>
using namespace std;
char * spush(char *stack,char *pt);
bool analyse(char *p);
void main()
{
//将分析串存放在二维数组中
char input[5][10]={"i+i#",
"i*(i+i)#",
"i*i+i#",
"i+*#",
"+i*i#"};
bool flag; //定义一个布尔型的标记量
for(int h=0;h<5;++h)
{
flag=analyse(input[h]);
if(flag) cout<<"恭喜你！"<<input[h]<<"语法分析成功，合法！"<<endl;
else cout<<"对不起！"<<input[h]<<"语法分析失败，非法！"<<endl;
}
int aaa;
cin>>aaa;
}
//定义各一将串逆序入栈的函数
char * spush(char *stack,char *pt)
{
int l=0;
//while循环的作用是将指针指向字符串的末尾，然后再由后向前入栈，从而实现逆序
while(*pt!='\0')
{
pt++;
l++;
}
if (*stack == '#')
{
stack++;
}
while(l)
{
pt--;
char cTempIntoStack = (*pt);
*stack=cTempIntoStack;
stack++;
l--;
}
stack--; //由于前面向前加了一位,要返回
////////////////
return stack;
///////////////////////////////////
}
/*LL(1)分析表
i + * ( ) #
E TM +TM
F i (E)
M TM e e
N e *FN e e
T FN FN
*/
//分析函数
bool analyse(char *p){
char analyseTable[5][6][4]={
"TM", "", "", "TM", "", "",
"i", "", "", "(E)", "", "",
"", "+TM", "", "", "e", "e",
"", "e", "*FN", "", "e", "e",
"FN", "", "", "TN", "", ""
};
char *stack = new char[50]; //定义一个栈空间
for (int iStack = 0;iStack<50 ;iStack++)
{
stack[iStack] = 0;
}
char *s=stack; //用指针*s指向栈的起始地址
*s='#'; //将“#”入栈
s++; //指针加1
*s='E'; //将“E”入栈
//下面的while循环实现字符串的词法分析操作
int count = 0;
while(*s!='#' || *p!='#'){
count++;
char * temp = s;
cout<<"NO."<<count<<endl;
cout<<"STACK"<<endl;
while (*temp != '#')
{
cout<<*temp<<" ";
temp--;
}
cout<<endl;
int x,y;
//若果栈顶数据和分析串的字符匹配，则将符号栈的栈顶数据出栈（即将栈顶指针减1）
if(*s==*p){
cout<<"Before :"<<*s<<endl;
s--;
p++;
cout<<"After :"<<*s<<endl;
}
//当符号栈和分析串的字符不匹配时，查分析表
else {
switch(*s){
case 'E':x=0;break;
case 'F':x=1;break;
case 'M':x=2;break;
case 'N':x=3;break;
case 'T':x=4;break;
default:return false;
}
switch(*p){
case 'i':y=0;break;
case '+':y=1;break;
case '*':y=2;break;
case '(':y=3;break;
case ')':y=4;break;
case '#':y=5;break;
default:return false;
}
//若果对应的为空，则分析串非法，退出
if(analyseTable[x][y][0]=='\0') return false;
//若查表所对应的为'e'，则将符号栈的栈顶数据出栈
else if(analyseTable[x][y][0]=='e') s--;
//其它，这时将查表所得的项逆序入符号栈
else {
s=spush(s,analyseTable[x][y]);
}
}
}
return true; //分析成功，返回
}