编译原理语法分析器实验lr1

A. 编译原理用C语言实现基于LR(1)或SLR（1）语法分析程序代码，最好还有报告，急。。。

这个是精简的语法分析程序，如果符合的话，hi我
给你实验报告

#include <stdio.h>
#include<dos.h>
#include<stdlib.h>
#include<string.h>
char a[50] ,b[50];
char ch;
int n1,i1=0,n=5;
int E();int T();int E1();int T1();int F();
void main() /*递归分析*/
{
int f,j=0;
printf("请输入字符串(长度<50,以#号结束）\n");
do{
scanf("%c",&ch);
a[j]=ch;
j++;
}while(ch!='#');
n1=j;
ch=b[0]=a[0];
f=E();
if (f==0) return;
if (ch=='#') printf("accept\n");
else printf("error\n");
}

int E() // E→TE'
{ int f,t;
f=T();
if (f==0) return(0);
t=E1();
if (t==0) return(0);
else return(1);
}

int T() // T→FT'
{ int f,t;
f=F();
if (f==0) return(0);
t=T1();
if (t==0) return(0);
else return(1);
}

int E1()/*E’*/ // E'→+TE'
{ int f;
if(ch=='+') {
b[i1]=ch;
ch=a[++i1];
f=T();
if (f==0) return(0);
E1();
return(1);
}
return(1);
}

int T1()/*T’*/ // T'→*FT'
{
int f,t;
if(ch=='*') {
b[i1]=ch;
ch=a[++i1];
f=F();
if (f==0) return(0);
t=T1();
if (t==0) return(0);
else return(1);}
a[i1]=ch;
return(1);
}

int F() // F→(E)
{ int f;
if(ch=='(') {
b[i1]=ch;
ch=a[++i1];
f=E();
if (f==0) return(0);
if(ch==')') {
b[i1]=ch;
ch=a[++i1];
}
else {
printf("error\n");
return(0);
}
}
else if(ch=='i') {
b[i1]=ch;
ch=a[++i1];
}
else {printf("error\n");return(0);}
return(1);
}

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

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

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

例如：

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

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

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

C. 编译原理LR（1）中的R和1分别是什么意思

优质解答
LR分析法是一种自下而上进行规范归约的语法分析法,L指从左到右扫描输入符号串,R是指构造最右推导的逆过程.LR(1)中的1是每次搜索符号需要向前参考一步,即参考下一个符号确定当前构造.
L：Left (左) R：Right (右)

D. 编译原理——LR分析表

自底向上的语法分析

LR分析表的结构如上，其分为两个部分 Action Goto

两个参数状态i，终结符号a（s(i)代表第i个状态，r(i)代表第i条表达式）

Goto[i,A]=j

文法

容易得知这个文法可以推出 0 1 00 01 等的字符串。因为它是 左递归 。不适用于 LL 文法分析，只能使用 LR 分析。

因为本题入口有两个—— S → L·L S → L ，所以需要构造额外的产生式 S'->S

2.1 第一次遍历

我们从 [S -> . L·L] 开始，构造这个状态的闭包，也就是加上所有能从这个产生式推出的表项。

首先，判断 . 后面是否为 非终结符号A 。如果是，那我们就得找所有由 A-> 推出的产生式，并将它们添加进入 闭包 里(也就是State包里)。循环做即可。

因此我们可以得到 State 0 有

下一步，就是我的 . 往下一位移动。对每个符号X后有个 . 的项，都可以从 State 0 过渡到其他状态。

由以上6条式子可以得知下一位符号可以是 S L B 0 1 。所以自然可以得到5个状态。

State 1 是由 State 0 通过 S 转移到这里的，所以我们找出所有 State 0 中在 S 前有 . 的项。

此状态作为结束状态 Accept ，不需要继续状态转移了。

State 2 是由 State 0 通过 L 转移到这里的，所以我们找出所有 State 0 中在 L 前有 . 的项。

S -> . L·L S -> . L L -> . LB

有3条式子，现在我们将 . 向后推一格，就得到 State 1 的项了。

但是 . 之后的符号分别是 · $ B ， B 为非终结符号，我们得包含 B -> 的项

State 3 是由 State 0 通过 B 转移到这里的，所以我们找出所有 State 0 中在 B 前有 . 的项。

因为 . 后没有其他符号了，因此这个状态不需要继续转移了。

State 4 是由 State 0 通过 0 转移到这里的，所以我们找出所有 State 0 中在 0 前有 . 的项。

因为 . 后没有其他符号了，因此这个状态不需要继续转移了。

很简单，同样的道理找 State 5

State 5 是由 State 0 通过 1 转移到这里的，所以我们找出所有 State 0 中在 1 前有 . 的项。

因为 . 后没有其他符号了，因此这个状态不需要继续转移了。

好的，现在我们第一次遍历完成。

2.2 第二次遍历

第二次遍历自然从 State 2 开始。

我们回到 State2 ，可以看出 . 之后的符号有 · B 0 1 。

State 6 是由 State 2 通过 · 转移到这里的，所以我们找出所有 State 2 中在 · 前有 . 的项。

S -> L. ·L 只有1条，我们往后移发现 L 又为非终结符号，参考 State 0 做的操作，我们得找出所有的式子。

共有5条式子，共同组成 State 6 ，由上面的式子可以看出我们还得继续下一次遍历。先不管着，我们进行下一次状态查找。

State 7 是由 State 2 通过 B 转移到这里的，所以我们找出所有 State 2 中在 B 前有 . 的项。

L -> L. B 也是只有1条，我们往后移发现没有非终结符号了，那就不需要再继续添加其他式子了。

这个状态也不需要继续进行转移了。

接下来很关键，因为我们通过 State2 的 . 后的符号找出了 State 6 State 7 ，接下来还差符号 0 1 ，那么是否像之前一样按例添加状态呢， 答案是不是的 ，因为我们发现通过 0 1 找到的闭包集分别是 B -> 0 B -> 1 ，这与我们的之前的 State 4 State 5 相同。所以我们得将其整合起来，相当于 State 2 通过 0 1 符号找到了 State 4 State 5 状态。

2.3 第三次遍历

回头看第二次遍历，可以看出只有 State 6 可以进行状态转移了。

那么就将 State 6 作为第三次遍历的源头，可以看出 . 之后的符号有 L B 0 1 。

State 8 是由 State 6 通过 L 转移到这里的，所以我们找出所有 State 6 在 L 前有 . 的项。

S -> L· .L L -> . LB 有两条式子，往后移发现有非终结符号 B ，所以经过整合可以得到

可以看出 . 的后面还有一个符号，所以这里我们还得再进行一次遍历。

接下来，又是遇到重复的包的情况，可以看出我们由 State 6 通过 B 0 1 得到的闭包分别是 L->B B->0 B->1 ，很明显，这分别对应于 State 3 State 4 State 5 。

第三次遍历也就结束了。

2.4 第四次遍历

回看第三次遍历，可以看出只有 State 8 可以进行状态转移，其 . 之后的符号分别是 B 0 1 。

诶，感觉很熟悉，就是上面几行刚说的情况，也就是说通过这三个符号找到的闭包是我们之前遇到的状态，分别是 State 3 State 4 State 5 。

做到这里，我们发现我们已经全部遍历完毕！

总共有8个状态，通过以上流程做成个图是什么样子的？来看看！

这么一看就很清晰明了了，我们就可以通过这个图做出我们的 LR分析表

其实就是我们之前呈现的表

在状态 I2 和 I8 中，既有 移入 项目，也有 规约 项目，存在 移入 - 规约的冲突 ，所以不是 LR(0) 文法，但是因为 FOLLOW(S) ∩ {0, 1} = ∅，所以可以用 FOLLOW 集解决冲突，所以该文法是 SLR(1) 文法。

上表我们发现还有 r1，r2，r3 等。这个其实就是代表状态停止转移时为 第几条表达式 ，r3代表第三条表达式 L -> LB 。

当我们构建了表之后，我们如何运用起来呢？

下面我们通过一个例子来说明

以上字符串是如何被SLR分析器识别的呢？

E. [高分,急!]编译原理LR(1)分析表题目

I0： S->.T,# T->.T(T),#
I1: S->T.,# T->T.(T),#
I2: S->T(.T),# T->.T(T),) T->.ε,)
I3: S->T(T.),# T->T.(T),)

(1,() 是s2
(1,#) 是acc (就是接受)
T下1 是1
T下3 是3

F. 编译原理中LR（1） 那个向前搜索符怎么求的 跪求高手解答 复制粘贴或者答非所问的别来

1、首先第一步就是项目[S’-> . S,]，自动生成搜索符]，自动生成搜索符]，自动生成搜索符，从项目[A->α.Bβ,?]生成项目[B->…,first(β)]。

G. 编译原理笔记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)）但这会让问题更加复杂，故一般不采用。而二义文法无论向前看多少个终结符都无法解决二义性。

H. 编译原理题，在建立LL(1)语法分析器时，提左因子和消除左递归的目的是什么

消除左递归是因为LL文法不能处理含有左递归的文法。
提左因子只是推后产生式的选择决定，等到获取足够多的输入再作选择。

I. 编译原理实验二 LL(1)分析法

通过完成预测分析法的语法分析程序，了解预测分析法和递归子程序法的区别和联系。使学生了解语法分析的功能，掌握语法分析程序设计的原理和构造方法，训练学生掌握开发应用程序的基本方法。有利于提高学生的专业素质，为培养适应社会多方面需要的能力。

根据某一文法编制调试 LL(1)分析程序，以便对任意输入的符号串进行分析。
构造预测分析表，并利用分析表和一个栈来实现对上述程序设计语言的分析程序。
分析法的功能是利用LL(1)控制程序根据显示栈栈顶内容、向前看符号以及LL(1)分析表，对输入符号串自上而下的分析过程。

对文法 的句子进行不含回溯的自上向下语法分析的充分必要条件是：
（1）文法不含左递归；
（2）对于文法中的每一个非终结符 的各个产生式的候选首符集两两不相交，即，若

Follow集合构造：
对于文法 的每个非终结符 构造 的算法是，连续使用下面的规则，直至每个 不再增大为止：

仅给出核心部分
(1) GrammerSymbol.java

(2) GrammerSymbols.java

(3) Grammer.java

(4) LL1Grammer.java