LR(1) Item DFA - Computing Lookaheads

Question

I have trouble understanding how to compute the lookaheads for the LR(1)-items.

Lets say that I have this grammar:

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

A LR(1)-item is an LR(0) item with a lookahead. So we will get the following LR(0)-item for state 0:

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

State: 1

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

Can somebody explain how to compute the lookaheads ? What is the general approach ?

Thank you in advance

templatetypedef · Accepted Answer · 2015-10-29T18:00:48.303

36

The lookaheads used in an LR(1) parser are computed as follows. First, the start state has an item of the form

S -> .w  ($)

for every production S -> w, where S is the start symbol. Here, the $ marker denotes the end of the input.

Next, for any state that contains an item of the form A -> x.By (t), where x is an arbitrary string of terminals and nonterminals and B is a nonterminal, you add an item of the form B -> .w (s) for every production B -> w and for every terminal in the set FIRST(yt). (Here, FIRST refers to FIRST sets, which are usually introduced when talking about LL parsers. If you haven't seen them before, I would take a few minutes to look over those lecture notes).

Let's try this out on your grammar. We start off by creating an item set containing

S -> .AB ($)

Next, using our second rule, for every production of A, we add in a new item corresponding to that production and with lookaheads of every terminal in FIRST(B$). Since B always produces the string d, FIRST(B$) = d, so all of the productions we introduce will have lookahead d. This gives

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

Now, let's build the state corresponding to seeing an 'a' in this initial state. We start by moving the dot over one step for each production that starts with a:

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

Now, since the first item has a dot before a nonterminal, we use our rule to add one item for each production of A, giving those items lookahead FIRST(bd) = b. This gives

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

Continuing this process will ultimately construct all the LR(1) states for this LR(1) parser. This is shown here:

[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)

In case it helps, I taught a compilers course last summer and have all the lecture slides available online. The slides on bottom-up parsing should cover all of the details of LR parsing and parse table construction, and I hope that you find them useful!

Hope this helps!

edited Oct 29 '15 at 18:00

answered Jan 02 '13 at 18:35

templatetypedef

362,284
104
897
1,065

Thank you. Can you explain why $ is included in the lookahead sets in the following grammar, but it's not in FIRST($A) ? S → •A {$} A → • AA {$, b} A → • bc {$ ,b } – mrjasmin Jan 02 '13 at 23:47
1

@mrjasmin- I need to see more of the grammar to know what the FIRST and lookahead sets should be; can you post more? Also, note that you shouldn't be computing FIRST($A) anywhere. If you have A -> .AA ($), the lookaheads for the resulting items would be the terminals in FIRST(A$), not FIRST($A). Does that help at all? – templatetypedef Jan 02 '13 at 23:57
Hi ! This question is from an exam and all that is given is: S -> .A {$} A -> .AA { } A -> .bc { } The student is supposed to find the lookahead set- And the answer is the post above. I don't understand how $ is a lookahead – mrjasmin Jan 03 '13 at 00:01
@mrjasmin- The initial $ probably comes from the fact that S is the start symbol, so its production is always marked with a $ after the fact. The production A -> .AA would therefore initially have $ as a lookahead, as would A -> bc. Next, since A -> .AA ($) is an item, you'd add in new items for each production of A, with lookaheads FIRST(A$). Since A -> bc is a production of A, the only element of FIRST(A$) is b. Thus you'd add A -> .AA (b) and A -> .bc (b) to the item set. Merging these with A -> .AA ($) and A -> .bc ($) gives A -> .AA ($, b) and A -> .bc ($, b). Does that make sense? – templatetypedef Jan 03 '13 at 00:10
Why would the production A -> .AA initially have $ as a lookahead ? Shouldn't A -> aAb | a also have $ initially then ? Thanks – mrjasmin Jan 03 '13 at 00:19
1

@mrjasmin- No, those two shouldn't be followed by $. The production S -> AB means that the items for the A productions start with FIRST(B$), which is just d. The reason for the $ lookaheads in this second case is that the production S -> A has nothing after the A, so the lookahead is FIRST($), which is just $. – templatetypedef Jan 03 '13 at 03:30
3 more states are needed, as noted below. – tgoneil Oct 29 '15 at 07:34
1

@tgoneil I missed two of those states the first time around - thanks for spotting that! As for the third - it looks like you've augmented the grammar by adding in a production S' -> S while I haven't done that, so I think that third state depends on whether you do that or not. – templatetypedef Oct 29 '15 at 18:02
Yes it is augmented, so yes, would be one less state. :-) – tgoneil Oct 30 '15 at 02:38
Your link, and every other LALR parsing site on the web appears to mention the use of *follow sets* not *first sets* in creation of the item set, are you mistaken in your usage of first sets? https://web.stanford.edu/class/archive/cs/cs143/cs143.1128/handouts/140%20LALR%20Parsing.pdf and https://web.cs.dal.ca/~sjackson/lalr1.html – Krupip Oct 03 '17 at 17:59
1

@snb Generating a LALR(1) parser typically does use FOLLOW sets. However, this question is about LR(1) parsing, and typically LR(1) parsers are created using FIRST rather than FOLLOW sets. – templatetypedef Oct 03 '17 at 18:07
@templatetypedef Ah ok, I went backwards in learning about LR parsing. – Krupip Oct 03 '17 at 21:06
1

@snb No worries! LR parsing is often taught in the order of LR(0), then SLR(1), then LR(1), then LALR(1), though you sometimes see LALR(1) and LR(1) interchanged with one another. It can take some practice to get the hang of them! – templatetypedef Oct 03 '17 at 21:29
@templatetypedef https://parasol.tamu.edu/~rwerger/Courses/434/lec10.pdf for this tell why E->.T+E,$ – alhelal Mar 10 '18 at 16:55

score 4 · Answer 2 · answered Mar 14 '15 at 06:55

4

here is the LR(1) automaton for the grammar as the follow has been done above I think it's better for the understanding to trying draw the automaton and the flow will make the idea of the lookaheads clearer

here is the automaton for the grammar

answered Mar 14 '15 at 06:55

M.Alamer

55
8

score 0 · Answer 3 · answered Apr 03 '13 at 06:39

0

The LR(1) item set constructed by you should have two more items.

I8 A--> aA.b , b from I2

I9 A--> aAb. , b from I8

answered Apr 03 '13 at 06:39

Ajay

1

tgoneil · Answer 4 · 2015-10-29T21:39:16.627

I also get 11 states, not 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 .

LR(1) Item DFA - Computing Lookaheads

4 Answers4

Linked