LR (1) Пункт DFA - Вычисление Lookaheads

Мне трудно понять, как вычислить образы для элементов LR (1).

Давайте скажем, что у меня есть эта грамматика:

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

A LR (1) -это элемент LR (0) с lookahead. Итак, мы получим следующий LR (0) -этот для состояния 0:

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

Состояние: 1

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

Может кто-нибудь объяснить, как вычислить взгляды? Каков общий подход?

Заранее благодарю

ОТВЕТЫ

Ответ 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.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)

В случае, если это помогает, я преподавал курс компиляторов прошлым летом и имел все слайды лекций, доступные в Интернете. Слайды при синтаксическом анализе снизу вверх должны охватывать все детали построения пар Ling и parse table, и я надеюсь, что вы найдете их полезными!

Надеюсь, это поможет!

Ответ 2

вот автомат LR (1) для грамматики, как было сделано выше Я думаю, что лучше понять, что нужно попытаться привлечь автомат, и поток сделает концепцию взглядов более ясной.

here is the automaton for the grammar

Ответ 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 .