LR(1) 项 DFA - 计算前瞻答案

【问题标题】：LR(1) Item DFA - Computing LookaheadsLR(1) 项 DFA - 计算前瞻
【发布时间】：2012-12-15 16:58:43
【问题描述】：

我无法理解如何计算 LR(1) 项的前瞻。

假设我有这个语法：

S -> AB
A -> aAb | a
B -> d

LR(1)-item 是一个具有前瞻功能的 LR(0) 项目。所以我们将得到以下状态 0 的 LR(0)-item：

S -> .AB , {lookahead} 
A -> .aAb,  {lookahead} 
A -> .a,  {lookahead}

状态：1

A ->  a.Ab, {lookahead} 
A ->  a. ,{lookahead} 
A -> .aAb ,{lookahead} 
A ->.a ,{lookahead}

有人可以解释如何计算前瞻吗？一般的做法是什么？

提前谢谢你

【问题讨论】：

标签： parsing context-free-grammar lookahead dfa lr

【解决方案1】：

LR(1) 解析器中使用的前瞻计算如下。首先，开始状态有一个表单项

S -> .w  ($)

对于每个产生式 S -> w，其中 S 是开始符号。这里，$ 标记表示输入的结束。

接下来，对于包含 A -> x.By (t) 形式的项目的任何状态，其中 x 是终端和非终端的任意字符串，B 是非终端，添加一个 B 形式的项目 - > .w (s) 对于每个产生式 B -> w 和集合 FIRST(yt) 中的每个终端。（这里，FIRST 指的是FIRST sets，通常是在谈论 LL 解析器时介绍。如果您以前没有见过它们，我会花几分钟时间看一下那些讲义。

让我们在你的语法上试试这个。我们首先创建一个包含

的项目集

S -> .AB ($)

接下来，使用我们的第二条规则，对于 A 的每个产生式，我们添加一个与该产生式相对应的新项目，并在 FIRST(B$) 中包含每个终端的前瞻。由于 B 总是产生字符串 d，FIRST(B$) = d，所以我们介绍的所有产生式都会有前瞻 d。这给了

S -> .AB ($)
A -> .aAb (d)
A -> .a (d)

现在，让我们构建与在此初始状态下看到“a”相对应的状态。我们首先将每个以 a 开头的产品的点移到一个步骤上：

A -> a.Ab (d)
A -> a. (d)

现在，由于第一项在非终结符之前有一个点，我们使用我们的规则为 A 的每个产生式添加一个项，使这些项先行 FIRST(bd) = b。这给了

A -> a.Ab (d)
A -> a. (d)
A -> .aAb (b)
A -> .a (b)

继续这个过程最终会为这个 LR(1) 解析器构造所有的 LR(1) 状态。此处显示：

[0]
S -> .AB  ($)
A -> .aAb (d)
A -> .a   (d)

[1]
A -> a.Ab (d)
A -> a.   (d)
A -> .aAb (b)
A -> .a   (b)

[2]
A -> a.Ab (b)
A -> a.   (b)
A -> .aAb (b)
A -> .a   (b)

[3]
A -> aA.b (d)

[4]
A -> aAb. (d)

[5]
S -> A.B  ($)
B -> .d   ($)

[6]
B -> d.   ($)

[7]
S -> AB.  ($)

[8]
A -> aA.b (b)

[9]
A -> aAb. (b)

如果有帮助，我去年夏天教了一门编译器课程，并且拥有 all the lecture slides available online。自底向上解析的幻灯片应该涵盖了 LR 解析和解析表构建的所有细节，希望对您有用！

希望这会有所帮助！

【讨论】：

谢谢。您能解释一下为什么 $ 包含在以下语法中的前瞻集中，但它不在 FIRST($A) 中吗？ S → •A {$} A → • AA {$, b} A → • bc {$ ,b }
@mrjasmin- 我需要了解更多语法才能知道 FIRST 和前瞻集应该是什么；你能多发点吗？另外，请注意，您不应该在任何地方计算 FIRST($A)。如果您有 A -> .AA ($)，则结果项的前瞻将是 FIRST(A$) 中的终端，而不是 FIRST($A)。这有帮助吗？
嗨！这个问题来自考试，给出的只是： S -> .A {$} A -> .AA { } A -> .bc { } 学生应该找到前瞻集 - 答案是在上面发帖。我不明白 $ 是如何预测的
@mrjasmin- 最初的 $ 可能来自于 S 是开始符号的事实，因此它的产生总是在事后用 $ 标记。因此，产生式 A -> .AA 最初将 $ 作为前瞻，A -> bc 也是如此。接下来，由于 A -> .AA ($) 是一个项目，您将为 A 的每个产生式添加新项目，并带有前瞻 FIRST(A$)。因为 A -> bc 是 A 的产生式，所以 FIRST(A$) 的唯一元素是 b。因此，您将 A -> .AA (b) 和 A -> .bc (b) 添加到项目集中。将这些与 A -> .AA ($) 和 A -> .bc ($) 合并得到 A -> .AA ($, b) 和 A -> .bc ($, b)。这有意义吗？
为什么生产 A -> .AA 最初有 $ 作为前瞻？不应该 A -> aAb | a 最初也有 $ 呢？谢谢

【解决方案2】：

这里是语法的 LR(1) 自动机，如下所示我认为尝试绘制自动机有助于理解，并且流程将使前瞻的想法更加清晰

【讨论】：

【解决方案3】：

你构建的 LR(1) 项目集应该还有两个项目。

I8 A--> aA.b , b 来自 I2

I9 A--> aAb。 , b 来自 I8

【讨论】：

【解决方案4】：

我也有 11 个州，而不是 8 个：

State 0
        S: .A B ["$"]
        A: .a A b ["d"]
        A: .a ["d"]
    Transitions
        S -> 1
        A -> 2
        a -> 5
    Reductions
        none
State 1
        S_Prime: S .$ ["$"]
    Transitions
        none
    Reductions
        none
State 2
        S: A .B ["$"]
        B: .d ["$"]
    Transitions
        B -> 3
        d -> 4
    Reductions
        none
State 3
        S: A B .["$"]
    Transitions
        none
    Reductions
        $ => S: A B .
State 4
        B: d .["$"]
    Transitions
        none
    Reductions
        $ => B: d .
State 5
        A: a .A b ["d"]
        A: .a A b ["b"]
        A: .a ["b"]
        A: a .["d"]
    Transitions
        A -> 6
        a -> 8
    Reductions
        d => A: a .
State 6
        A: a A .b ["d"]
    Transitions
        b -> 7
    Reductions
        none
State 7
        A: a A b .["d"]
    Transitions
        none
    Reductions
        d => A: a A b .
State 8
        A: a .A b ["b"]
        A: .a A b ["b"]
        A: .a ["b"]
        A: a .["b"]
    Transitions
        A -> 9
        a -> 8
    Reductions
        b => A: a .
State 9
        A: a A .b ["b"]
    Transitions
        b -> 10
    Reductions
        none
State 10
        A: a A b .["b"]
    Transitions
        none
    Reductions
        b => A: a A b .

【讨论】：