4.7.5 Efficient Construction of LALR Parsing Tables

4.7.5 Efficient Construction of LALR Parsing Tables

There are several modifications we can make to Algorithm 4.59 to avoid constructing the full collection of sets of LR(1) items in the process of creating an LALR(1) parsing table.

• First, we can represent any set of LR(0) or LR(1) items I by its kernel, that is, by those items that are either the initial item -- [S’→@S] or [S’→@S,$] -- or that have the dot somewhere other than at the beginning of the production body.

• We can construct the LALR(1)-item kernels from the LR(0)-item kernels by a process of propagation and spontaneous generation of lookaheads, that we shall describe shortly.

• If we have the LALR(1) kernels, we can generate the LALR(1) parsing table by closing each kernel, using the function CLOSURE of Fig. 4.40, and then computing table entries by Algorithm 4.56, as if the LALR(1) sets of items were canonical LR(1) sets of items.

Example 4.61: We shall use as an example of the efficient LALR(1) table-construction method the non-SLR grammar from Example 4.48, which we reproduce below in its augmented form:

S’→S

S→L = R | R

L→*R | id

R→L

The complete sets of LR(0) items for this grammar were shown in Fig. 4.39. The kernels of these items are shown in Fig. 4.44.

I0:	S’→@S	I5:	L→id@
I1:	S’→S@	I6:	S→L = @R
I2:	S→L@ = R R→L@	I7:	L→*R@
I3:	S→R@	I8:	R→L@
I4:	L→*@R	I9:	S→L = R@

Figure 4.44: Kernels of the sets of LR(0) items for grammar (4.49)

□

Now we must attach the proper lookaheads to the LR(0) items in the kernels, to create the kernels of the sets of LALR(1) items. There are two ways a lookahead b can get attached to an LR(0) item B→γ@δ in some set of LALR(1) items J :

1. There is a set of items I, with a kernel item A→α@β, a, and J=GOTO(I, X), and the construction of

GOTO(CLOSURE({[A→α@β, a]}), X)

as given in Fig. 4.40, contains [B→γ@δ, b], regardless of a. Such a lookahead b is said to be generated spontaneously for B→γ@δ. As a special case, lookahead $ is generated spontaneously for the item S’→@S in the initial set of items.

2. All is as in (1), but a = b, and GOTO(CLOSURE({[A→α@β, a]}), X), as given in Fig. 4.40, contains [B→γ@δ, b] only because A→α@β has b as one of its associated lookaheads. In such a case, we say that lookaheads propagate from A→α@β in the kernel of I to B→γ@δ in the kernel of J. Note that propagation does not depend on the particular lookahead symbol; either all lookaheads propagate from one item to another, or none do.

We need to determine the spontaneously generated lookaheads for each set of LR(0) items, and also to determine which items propagate lookaheads from which. The test is actually quite simple. Let # be a symbol not in the grammar at hand. Let A→α@β be a kernel LR(0) item in set I. Compute, for each X, J = GOTO(CLOSURE({[A→α@β, #]}), X).

For each kernel item in J, we examine its set of lookaheads. If # is a lookahead, then lookaheads propagate to that item from A→α@β. Any other lookahead is spontaneously generated. These ideas are made precise in the following algorithm, which also makes use of the fact that the only kernel items in J must have X immediately to the left of the dot; that is, they must be of the form B→γX@δ.

Algorithm 4.62: Determining lookaheads.

INPUT: The kernel K of a set of LR(0) items I and a grammar symbol X.

OUTPUT: The lookaheads spontaneously generated by items in I for kernel items in GOTO(I, X) and the items in I from which lookaheads are propagated to kernel items in GOTO(I, X).

METHOD: The algorithm is given in Fig. 4.45. □

for ( each item A→α@β in K ) {

J := CLOSURE({[A→α@β, #]});

if ( [B→γX@δ, a] is in J, and a is not # )

conclude that lookahead a is generated spontaneously for item

B→γX@δin GOTO(I, X);

if ( [B→γX@δ, #] is in J)

conclude that lookaheads propagate from A→α@β in I to

B→γ@δ in GOTO (I, X);

}

Figure 4.45: Discovering propagated and spontaneous lookaheads

We are now ready to attach lookaheads to the kernels of the sets of LR(0) items to form the sets of LALR(1) items. First, we know that $ is a lookahead for S 0→S in the initial set of LR(0) items. Algorithm 4.62 gives us all the lookaheads generated spontaneously. After listing all those lookaheads, we must allow them to propagate until no further propagation is possible. There are many different approaches, all of which in some sense keep track of “new” lookaheads that have propagated into an item but which have not yet propagated out. The next algorithm describes one technique to propagate lookaheads to all items.

Algorithm 4.63: Efficient computation of the kernels of the LALR(1) collection of sets of items.

INPUT: An augmented grammar G’.

OUTPUT: The kernels of the LALR(1) collection of sets of items for G’.

METHOD:

1. Construct the kernels of the sets of LR(0) items for G. If space is not at a premium, the simplest way is to construct the LR(0) sets of items, as in Section 4.6.2, and then remove the nonkernel items. If space is severely constrained, we may wish instead to store only the kernel items for each set, and compute GOTO for a set of items I by first computing the closure of I.

2. Apply Algorithm 4.62 to the kernel of each set of LR(0) items and grammar symbol X to determine which lookaheads are spontaneously generated for kernel items in GOTO(I, X), and from which items in I lookaheads are propagated to kernel items in GOTO(I, X).

3. Initialize a table that gives, for each kernel item in each set of items, the associated lookaheads. Initially, each item has associated with it only those lookaheads that we determined in step (2) were generated spontaneously.

4. Make repeated passes over the kernel items in all sets. When we visit an item i, we lo ok up the kernel items to which i propagates its lookaheads, using information tabulated in step (2). The current set of lookaheads for i is added to those already associated with each of the items to which i propagates its lookaheads. We continue making passes over the kernel items until no more new lookaheads are propagated.

□

Example 4.64: Let us construct the kernels of the LALR(1) items for the grammar of Example 4.61. The kernels of the LR(0) items were shown in Fig. 4.44. When we apply Algorithm 4.62 to the kernel of set of items I0, we first compute CLOSURE ({[S’→@S, #]}), which is

S’→@S, # S→@L = R, # S→@R, #

L→@*R, #/= L→@id, #/= R→@L, #

Among the items in the closure, we see two where the lookahead = has been generated spontaneously. The first of these is L→@*R. This item, with * to the right of the dot, gives rise to [L→@*R, =]. That is, = is a spontaneously generated lookahead for L→@*R, which is in set of items I4. Similarly, [L→@id, =] tells us that = is a spontaneously generated lookahead for L→id@ in I5.

As # is a lookahead for all six items in the closure, we determine that the item S’→@S in I0 propagates lookaheads to the following six items:

S’→ S@ in I1 S→L@ = R in I2 S→R@ in I3

L→*@R in I4 L→id@ in I5 R→L@ in I2

---

FROM	TO
I0: S’→@S	I1: S’→S@ I2: S→L@ = R I2: R→L@ I3: S→R@ I4: L→*@R I5: L→id@
I2: S→L@ = R	I6: S→L = @R
I4: L→*@R	I4: L→*@R I5: L→id@ I7: L→*R@ I8: R→L@
I6: S→L = @R	I4: L→*@R I5: L→id@ I8: R→L@ I9: S→L = R@

Figure 4.46: Propagation of lookaheads

In Fig. 4.47, we show steps (3) and (4) of Algorithm 4.63. The column labeled INIT shows the spontaneously generated lookaheads for each kernel item. These are only the two occurrences of = discussed earlier, and the spontaneous lookahead $ for the initial item S’→@S.

On the first pass, the lookahead $ propagates from S’→@S in I0 to the six items listed in Fig. 4.46. The lookahead = propagates from L→*@R in I4 to items L→*R@ in I7 and R→L@ in I8. It also propagates to itself and to L→id@ in I5, but these lookaheads are already present. In the second and third passes, the only new lookahead propagated is $, discovered for the successors of I2 and I4 on pass 2 and for the successor of I6 on pass 3. No new lookaheads are propagated on pass 4, so the final set of lookaheads is shown in the rightmost column of Fig. 4.47.

Note that the shift/reduce conflict found in Example 4.48 using the SLR method has disappeared with the LALR technique. The reason is that only lookahead $ is associated with R→L@ in I2, so there is no conflict with the parsing action of shift on = generated by item S→L@=R in I2.

□

SET	ITEM	LOOKAHEADS
		INIT	PASS 1	PASS 2	PASS 3
I0:	S’→@S	$	$	$	$
I1:	S’→S@		$	$	$
I2:	S→L@ = R		$	$	$
	R→L@		$	$	$
I3:	S→R@		$	$	$
I4:	L→*@R	=	=/$	=/$	=/$
I5:	L→id@	=	=/$	=/$	=/$
I6:	S→L = @R			$	$
I7:	L→*R@		=	=/$	=/$
I8:	R→L@		=	=/$	=/$
I9:	S→L = R@				$

Figure 4.47: Computation of lookaheads