编译语法课件分析

Ⅰ 如何通俗易懂地解释编译原理中语法分析的过程

分成词法分析，语法分析（LL算法，递归下降算法，LR算法），语义分析，运行时环境，中间代码，代码生成，代码优化这些部分。其实现在很多编译原理的教材都是按照85,86出版的那本龙书来安排教学内容的，所以那本龙书的内容格式几乎成了现在编译原理教材的定式，包括国内的教材也是如此。一般来说，大学里面的本科教学是不可能把上面的所有部分都认真讲完的，而是比较偏重于前面几个部分。像代码优化那部分东西，就像个无底洞一样，如果要认真讲，就是单独开一个学期的课也不可能讲得清楚。所以，一般对于本科生，对词法分析和语法分析掌握要求就相对要高一点了。

词法分析相对来说比较简单。可能是词法分析程序本身实现起来很简单吧，很多没有学过编译原理的人也同样可以写出各种各样的词法分析程序。不过编译原理在讲解词法分析的时候，重点把正则表达式和自动机原理加了进来，然后以一种十分标准的方式来讲解词法分析程序的产生。这样的做法道理很明显，就是要让词法分析从程序上升到理论的地步。

语法分析部分就比较麻烦一点了。现在一般有两种语法分析算法，LL自顶向下算法和LR自底向上算法。LL算法还好说，到了LR算法的时候，困难就来了。很多自学编译原理的都是遇到LR算法的理解成问题后就放弃了自学。其实这些东西都是只要大家理解就可以了，又不是像词法分析那样非得自己写出来才算真正的会。像LR算法的语法分析器，一般都是用工具Yacc来生成，实践中完全没有比较自己来实现。对于LL算法中特殊的递归下降算法，因为其实践十分简单，那么就应该要求每个学生都能自己写。当然，现在也有不少好的LL算法的语法分析器，不过要是换在非C平台，比如Java,Delphi,你不能运用YACC工具了，那么你就只有自己来写语法分析器。

Ⅱ 编译的语法分析

编译程序的语法分析器以单词符号作为输入，分析单词符号串是否形成符合语法规则的语法单位，如表达式、赋值、循环等，最后看是否构成一个符合要求的程序，按该语言使用的语法规则分析检查每条语句是否有正确的逻辑结构，程序是最终的一个语法单位。编译程序的语法规则可用上下文无关文法来刻画。
语法分析的方法分为两种：自上而下分析法和自下而上分析法。自上而下就是从文法的开始符号出发，向下推导，推出句子。而自下而上分析法采用的是移进归约法，基本思想是：用一个寄存符号的先进后出栈，把输入符号一个一个地移进栈里，当栈顶形成某个产生式的一个候选式时，即把栈顶的这一部分归约成该产生式的左邻符号。

Ⅲ 编译原理文法分析

改完了,能文法分析出来了!!
大概 跟你说下 你的错误吧:
出错地点:
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; //分析成功，返回
}

Ⅳ 编译原理语法分析有哪几种方法

语法分析有自上而下和自下而上两种分析方法
其中
自上而下：递归下降，LL(1)
自下而上：LR(0),SLR(1),LR(1),LALR(1)

Ⅳ 【编译原理】第四章：语法分析

从分析树的根节点到叶节点方向构造分析树。
即从开始符号S推导出词串w的过程。

例：

总是选择每个句型的 最左非终结符 进行替换。

总是选择每个句型的 最右非终结符 进行替换。

在自底向上的分析中，总是采用 最左规约 的方式，因此把 最左规约 称为 规范规约 ，对应的 最右推导 称为 规范推导 。

最左推导、最右推导具有唯一性。

自顶向下的语法分析采用最左推导方试，总是选择每个句型的 最左非终结符 进行替换。

由一组 过程 组成，每一个过程对应一个 非终结符 。
从文法开始符号S开始，递归调用文法中的其他非终结符，最终扫描整个输入串，完成分析。

如果其间有不唯一的产生式，就可能需要退回上一步重新尝试的情况，称为 回溯 。

预测分析 是 递归下降分析 技术的一个特例，通过输入中向前看固定个数的符号选择正确的产生式。
如果一个文法可以构造出向前看k个符号的预测分析器，称为LL(k)文法 。

预测分析不需要回溯，具有确定性。

含有 形式产生式的文法称为是 直接左递归 的。
如果一个文法中有一个非终结符A使得对某个串存在推导 ，那么这个文法是 左递归 的。其中，经过两步或以上推导产生的左递归，称为 间接左递归 的。
左递归会使递归下降分析器陷入无限循环。

文法
即
该文法是直接左递归的，会陷入无限循环。

将以上文法转换为：


即可消除左递归。事实上，这个过程把左递归转换成了右递归。

消除直接左递归的一般形式

使用代入法。

对于一个文法，通过改写产生式来 推迟决定 ，等获得足够多的输入信息再做正确的决定。

例：文法：

可以改写为：

从文法的开始符号S开始，每一步推导根据当前句型的最左非终结符A和当前输入符号α，选择正确的A-产生式。为保证分析的确定性，选出的候选式必须是唯一的。

S_文法（简单的确定型文法）

可能在某个举行中紧跟在A后面的终结符a的集合，记为 FOLLOW(A) 。
如果A是某个句型的最右符号，则将结束符“ $ ”添加到FOLLOW(A)中。

例：文法：






中，FOLLOW(B) = {a, c}

产生式 的可选集是指可以选用该产生式进行推导时对应的输入符号的集合，记为 SELECT(A->β) 。
例如
SELECT(A -> aβ)={a}
SELECT(A -> aβ | bγ)={a, b}
SELECT(A -> ε)=FOLLOW(A)

q_文法

文法符号串α串首终结符的集合，记作 FIRST(A) 。

Ⅵ 编译原理中语法分析的作用是什么

语法分析是搞清楚语言含义的必要条件，只有语法搞清楚了，语句表达的意思才能得到准确理解，才能得到正确实现。

Ⅶ 编译原理笔记17：自下而上语法分析（4）LR(0)、SLR(1) 分析表的构造

（移进项目就是纳凯态指圆点右边是终结符的项目，规约项目指的就是圆点在右部最右端的项目）

LR(0) 文法可以直接通过识别活前缀的 DFA 来构造 LR 分析表

假定 C = {I ₀ , I ₁ , ... , I _n } （aka. LR(0) 项目规范族、DFA 状态集）

首先为文法产生式进行编号，拓广文法的产生式要标记为 0（这里就是后面分析表中 rj 的产生式编号 j 的由来）

然后令每个项目集 I _k 的下标 k 作为分析器洞源的状态（行首），包含 S' → .S 的集合下标为分析器的初态（也就是 DFA 的初态孙型，一般都是 0 ）。

下面用一个例子来说明 ACTION、GOTO 子表的构造：

SLR(1) 为解决冲突提出了一个简单的方法：通过识别活前缀的 DFA 和【简单向前看一个终结符】构造 SLR(1) 分析表。

如果我们的识别活前缀的 DFA 中存在移进-规约冲突、规约-规约冲突，都可以尝试使用这个方法来解决冲突。（这里说【尝试】，当然是因为 SLR 也只能解决一部分问题，并不是万能的灵丹妙药。。）

这里，我们拿前面那个 LR(0) 解决不了的文法来举例

该文法不是 LR(0) 文法，但是是 SLR(1) 文法。

观察上图 DFA 中的状态2，想象当我们的自动机正处于这个状态：次栈顶已经规约为 T 了，栈顶也是当前的状态 2 ，而当前剩余输入为 *。

如果这个自动机不会【往前多看一步】的话，那么对处于这个状态的自动机来说，看起来状态 2 中的移进项目和规约项目都是可选的。这就是移进-规约冲突。

想要解决这个冲突，就轮到【往前多看一步】上场了——把当前剩余输入考虑进来，辅助进行项目的选择：

对其他的冲突也使用同样的方法进行判断。

这种冲突性动作的解决办法叫做 SLR(1) 解决办法

准备工作部分，与 LR(0) 分析表的构造差不多：同样使用每个项目集的状态编号作为分析器的状态编号，也就同样用作行下标；同样使用拓广文法产生式作为 0 号产生式。

填表也和 LR(0) 类似，唯一的不同体现在对规约项的处理方法上：如果当前状态有项目 A → α.aβ 和 A → α. ，而次栈顶此时是 α 且读写头读到的是 a，那么当且仅当 a∈FOLLOW(A) 时，我们才会用 A → α 对 α 进行规约。

如果构造出来的表的每个入口都不含多重定义（也就是如上图中表格那样的，每个格子里面最多只有一个动作），那么该表就是该文法的 SLR(1) 表，这个文法就是 SLR(1) 文法。使用 SLR(1) 表的分析器叫做一个 SLR(1) 分析器。

任意的二义文法都不能构造出 SLR(1) 分析表

例：悬空 else

例：

这里的 L 可以理解为左值，R 可以理解为右值

经过计算可以确定其 DFA 如下图所示。

在 状态4 中，由于 "=" 同时存在于 FOLLOW(L) 与 FOLLOW(R) 中，因此该状态内存在移进-规约冲突，故该文法不是 SLR(1) 文法。

这样的非二义文法可以通过增加向前看终结符的个数来解决冲突（比如LL(2)、LR(2)）但这会让问题更加复杂，故一般不采用。而二义文法无论向前看多少个终结符都无法解决二义性。

Ⅷ 编译器笔记13-语法分析-LR分析法概述

可以用LR分析法分析的文法可以称为LR分析法。LR文法（ Knuth ，1963）是最大的、可以构造出相应移入- 归约语法分析器的文法类。

LR(k)分析，需要向前查看k个输入符号的LR分析，k=0 和 k=1 这两种情况具有实践意义，当省略(k)时，表示k=1。而在LR(k)这样的名称中，k代表的是分析时所需前瞻符号（lookahead symbol）的数量，也就是除了当前处理到的输入符号之外，还得再向右引用几个符号之意；省略 （k）时即视为LR(1)，而非LR(0)。

作为对比这里列出LL(1)文法的含义：

问：自底向上分析的关键问题是什么？
答：如何正确地识别句柄，句柄是逐步形成的，用“状态”表示句柄识别的进展程度。例如在 自底向上分析概述 中所提及到句柄识别错误的例子，通过状态跟下一个输入符号就可以判断出应该做出哪一个动作，而状态相当于一种记忆功能记录当前句柄识别到什么程度。

与移入分析器不同的是LR分析器多了一个与符号栈平行的状态栈。

之后的分析过程与上图类似，直至到如下状态，分析成功。可见分析时进行什么动作是由栈状态栈栈顶的状态和下一个输入符号决定。

输入：串w和LR语法分析表，该表描述了文法G的ACTION函数和GOTO函数。
输出：如果w在L(G)中，则输出w的自底向上语法分析过程中的归约步骤；否则给出一个错误指示。
方法：初始时，语法分析器栈中的内容为初始状态s0 ，输入缓冲区中的内容为w$。然后，语法分析器执行下面的程序：

先了解LR(0)项目和增广文法这两个概念

右部某位置标有圆点的产生式称为相应文法的一个LR(0)项目（简称为项目）：A → α1·α2

文法开始符号S表示的是语言中的最大成分。如下图当b出现时可以将它移入到分析栈中。b移进栈后我们期待归约出B。当归约出B时我们还期待再归约一个B。

如果G是一个以S为开始符号的文法，则G的增广文法G'就是在G中加上新开始符号S'和产生式S'→S而得到的文法

引入这个新的开始产生式的目的是使得文法开始符号仅出现在一个产生式的左边，从而使得分析器只有一个接受状态。

项目可以分为以下几类：

上图中S'对应的第一个项目称为初始项目，而S'对应的最后一个项目称之为接收项目在此状态下文法的开始符号已经被归约出来，因此可以接收了故称为接收项目。红色方框中的项目则被称为归约项目。

项目集闭包(Closure of Item Sets)

可以把等价的项目组成一个项目集(I)，称为项目集闭包，每个项目集闭包对应着自动机的一个状态。

先了解CLOSURE和GOTO这两个函数

项目集I的闭包的数学定义：

返回项目集I对应于文法符号X的后继项目集闭包

规范LR(0)项集族(Canonical LR(0) Collection)

说明： 该自动机的初始状态就是文法的初始项目的项目集闭包，其终止状态集合只有一个状态就是文法的接收项目的项目集闭包。

如果LR(0)分析表中没有语法分析动作冲突，那么给定的文法就称为LR(0)。不是所有CFG都能用LR(0)方法进行分析，也就是说，CFG不总是LR(0)文法。

为了解决移进/归约冲突和归约/归约冲突需要使用到 SLR分析法 和 LR(1)分析法 。

问: 为什么没有移进/移进冲突？
答: 首先只有在移进状态和待约状态下的项目才会有使用到移进操作。在0状态时所有项目都是移进状态根据LL文法显然不会产生移进/移进操作，因为每个产生式左部的SELECT集是没有交集的。而在其他具有待约状态项目的状态中，所有集合都是等价的。假若在某状态下输入终结符y时发生移进/移进冲突，即存在两个这样的项目A0→α0·yβ0，A1→α1·yβ1，但显然这两个项目是不等价的显然与同一状态下所有项目等价相矛盾，因此这种移进/移进冲突是不存在的。假若在某状态下输入非终结符X时发生移进/移进冲突，即存在两个这样的项目A0→α0·Xβ0，A1→α1·Xβ1，而A0与A1在同一状态下是等价的则两项目要么是A0→α0·Xβ0与X→.Xβ1(原项目A1变为X，α1变为ε)要么是A1→α1·Xβ1与X→.Xβ0(原项目A0变为X，α0变为ε)。显然X→Xβ0|Xβ1（左递归）是不符合LL文法的因此这种情况也是不可能出现。

综上移进/移进冲突在LR分析下是不存在的。

Ⅸ 编译原理笔记7：语法分析（1）语法分析器的任务、语法错误的处理

语法分析器的两项主要任务，分别：

源程序中的错误可以分为词法/语法错误、语义错误两类。前者主要形式是命名不合虚悄雹法、关键字书写错误、语法结构有问题（比如缺分号、该配对的东西不配对）等；后者则可分为静态/动态两种，静态例如类型使用错误、参数使用错误等，动态语义错误则是无穷递归这类逻辑性的问题。

例如：

紧急恢复：x = a+b+d; // 丢运芹弃掉 b 后的记号，直到遇到 +

短语级恢复： x = a+b; // 加入分号

在写程序时，要养成减少错误的好习惯：每次用变量、参数时，要在使用之前进行初始化，并在差帆直接使用之前检查一下是否出现值为空等问题，防止出现不可预知的错误