1. 컴파일러 입문
제 7 장
LL 구문 분석

2. 7.1 결정적 구문 분석 Deterministic Top-Down Parsing One pass nobackup
::= deterministic selection of production rules to be applied in
top-down syntax analysis.
One pass nobackup
1. Input string is scanned once from left to right.
2. Parsing process is deterministic.
Top-down parsing with nobackup
::= deterministic top-down parsing.
called LL parsing.
“Left to right scanning and Left parse”
LL Parsing

3. How to decide which production is to be applied:
sentential form : 1 2 … i-1Xα
input string : 1 2 … i-1 i i+1 … n
X  1 | 2 ... | k ∈ P일 때,
i를 보고 X-production 중에 unique하게 결정.
the condition for no backtracking : FIRST와 FOLLOW가 필요.
(=> LL condition)

4. FIRST
FIRST()
::= the set of terminals that begin the strings derived from .
if   , then  is also in FIRST().
FIRST(A) ::= { a∈VT∪{} | A  a,  ∈ V* }.
Computation of FIRST(X), where X ∈ V.
1) if X∈VT, then FIRST(X) = {X}
2) if X∈VN and X  a∈P, then FIRST(X) = FIRST(X) ∪ {a}
if X   ∈ P, then FIRST(X) = FIRST(X) ∪ {}
3) if X  Y1Y2 …Yk ∈ P and Y1Y2 …Yi-1  ,
then FIRST(X) = FIRST(X) ∪ (∪ FIRST(Yj) - {}).
if Y1Y2 …Yk   , then FIRST(X) = FIRST(X) ∪{}. *
j=1 i *

5. FIRST 구하는 예제 [1/2] ex1) E  TE E  +TE |  T  FT T  FT | 
F  (E) | id
FIRST(E) = FIRST(T) = FIRST(F) = {(, id}
FIRST(E) = {+, }
FIRST(T) = {, }
ex2) PROGRAM  begin d semi X end
X  d semi X
X  s Y
Y  semi s Y | 
FIRST(PROGRAM) = {begin}
FIRST(X) = {d,s}
FIRST(Y) = {semi, }

6. FOLLOW FOLLOW(A) Computation of FOLLOW(A)
::= the set of terminals that can appear immediately to
the right of A in some sentential form. If A can be
the rightmost symbol in some sentential form, then
$ is in FOLLOW(A).
::= {a ∈ VT∪{$} | S  Aa, ,  ∈ V*}.
※ $ is the input right marker.
Computation of FOLLOW(A)
1) FOLLOW(S) = {$}
2) if A  B ∈ P and  ,
then FOLLOW(B) = FOLLOW(B) ∪ (FIRST() - )
3) if A  B ∈ P or A  B and   ,
then FOLLOW(B) = FOLLOW(B) ∪ FOLLOW(A). *

7. FOLLOW 구하는 예제 [1/2] E’  +TE |  T  FT T’  FT |  F  (E) | id
Nullable = { E, T }
FIRST(E) = FIRST(T) = FIRST(F) = {(, id}
FIRST(E) = {+, } FIRST(T) = {, }
FOLLOW(E) = {),$} FOLLOW(E') = {),$}
FOLLOW(T) = {+,),$} FOLLOW(T') = {+,),$}
FOLLOW(F) = {,+,),$}

8. FOLLOW 구하는 예제 [2/2]
연습문제 7.4 (3) - p.307
(3) S  aAa | 
A  abS | c

9. LL condition 기본적 개념 정의: A   | ∈ P,
::= no backup condition
::= the condition for deterministic parsing of top-down method.
input : 12 ... i-1i ...n
derived string : 12...i-1X
X  1 | 2 ... | m
 i를 보고 X-production들 중에서 X를 확장할 rule을
결정적으로 선택.
정의: A   | ∈ P,
1. FIRST() ∩ FIRST() = 
2. if   , FOLLOW(A) ∩ FIRST() = 
if ∈ FIRST(), FOLLOW(A) ∩ FIRST() =  *

10. LL condition 예제 A  aBc | Bc | dAa B  bB | 
FIRST(A) = {a,b,c,d} FOLLOW(A) = {$,a}
FIRST(B) = {b, } FOLLOW(B) = {c}
LL condition 검사
1) A  aBc | Bc | dAa에서,
FIRST(aBc) ∩ FIRST(Bc) ∩ FIRST(dAa)
= {a} ∩ {b,c} ∩ {d} = 
2) B  bB |  에서,
FIRST(bB) ∩ FOLLOW(B) = {b} ∩ {c} = 
1), 2)에 의해 LL 조건을 만족한다.

11. 7.2 Recursive-descent 파서 Recursive-descent parsing
::= A top-down method that uses a set of recursive procedures to
recognize its input with no backtracking.
Create a procedure for each nonterminal.
ex) G : S  aA | bB
A  aA | c
B  bB | d
procedure pS;
begin if nextSymbol = ta then
begin getNextSymbol; pA end
else if nextSymbol = tb then
begin getNextSymbol; pB end
else error
end;

12. procedure pA;
begin if nextSymbol = ta then begin getNextSymbol; pA end
else if nextSymbol = tc then getNextSymbol
else error
end;
procedure pB; ...
/* main */
begin getNextSymbol;
pS;
if nextSymbol = '$' then accept else error
end.
※ procedure call sequence ::= leftmost derivation
 = aac$

13. LOOKAHEAD of a production
The main problem in constructing a recursive-descent syntax analyzer is the choice of productions when a procedure is first entered. To resolve this problem, we can compute the lookahead of each production.
LOOKAHEAD of a production
Definition : LOOKAHEAD(A)
= FIRST({ | S  A    ∈ VT*}).
Meaning : the set of terminals which can be generated by
 and if  , then FOLLOW(A) is added to the set.
Computing formula: LOOKAHEAD(A  X1X2...Xn)
= FIRST(X1X2...Xn)  FOLLOW(A) *

14. LOOKAHEAD 구하는 예제 S  aSA |  A  c Nullable Set = {S}
FIRST(S) = {a, } FOLLOW(S) = {$,c}
FIRST(A) = {c} FOLLOW(A) = {$,c}
LOOKAHEAD(S  aSA) = FIRST(aSA)  FOLLOW(S) = {a}
LOOKAHEAD(S  ) = FIRST()  FOLLOW(S) = {$,c}
LOOKAHEAD(A  c) = FIRST(c)  FOLLOW(A) = {c}
※ LOOKAHEAD를 구하는 순서 :
Nullable => FIRST => FOLLOW => LOOKAHEAD

15. Strong LL condition Definition : A   |  ∈ P,
LOOKAHEAD(A  ) ∩ LOOKAHEAD(A  ) = .
Meaning : for each distinct pair of productions with the same
left-hand side, it can select the unique alternate that
derives a string beginning with the input symbol.
The grammar G is said to be strong LL(1)
if it satisfies the strong LL condition.
ex) G : S  aSA | 
A  c
LOOKAHEAD(S  aSA) = {a}
LOOKAHEAD(S  ) = FOLLOW(S) = {$, c}
LOOKAHEAD(S  aSA) ∩ LOOKAHEAD(S  ) = 
 G는 strong LL(1)이다.

16. Implementation of Recursive-descent parser
If a grammar is strong LL(1), we can construct a parser for sentences of the grammar using the following scheme.
Terminal procedure:
a ∈ VT,
procedure pa; /* getNextSymbol => scanner */
begin
if nextSymbol = ta then getNextSymbol
else error
end;
※ getNextSymbol : 스캐너에 해당하는 루틴으로 입력 스트림으로부터 토큰 한 개를 만들어 변수 nextSymbol에 배정한다.

17. Nonterminal procedure
A ∈ VN,
procedure pA;
var i: integer;
begin
case nextSymbol of
LOOKAHEAD(A  X1X2...Xm): for i := 1 to m do pXi;
LOOKAHEAD(A  Y1Y2...Yn): for i := 1 to n do pYi; :
LOOKAHEAD(A  Z1Z2...Zr): for i := 1 to r do pZi;
LOOKAHEAD(A  ): ;
otherwise: error
end /* case */
end;
LL Parsing

18. Model of a predictive parser[1/3]
※ The input buffer contains the string to be parsed, followed by $.

19. Model of a predictive parser[2/3]
Current input symbol과 stack top symbol사이의 관계에 따라 parsing.
Initial configuration : STACK INPUT
$S $
Parsing table(LL) : parsing action을 결정지어 줌.
※ M[X,a] = r : stack top symbol이 X이고 current symbol이 a일 때, r번 생성 규칙으로 expand.

20. Model of a predictive parser[3/3]
Parsing Actions
X : stack top symbol, a : current input symbol
1. if X = a = $, then accept.
2. if X = a, then pop X and advance input.
3. if X ∈ VN, then if M[X,a] = r (XABC), then replace X by ABC
else error.

21. Predictive parsing algorithm
Algorithm Predictive_Parser_Action;
begin
// set ip to point to the first symbol of $;
repeat
// let X be the top stack symbol and a the symbol pointed to by ip;
if X is a terminal or $ then
if X = a then
pop X from the stack and advance ip
else error(1)
else /* X is nonterminal */
if M[X,a] = X  Y1Y2...Yk then
begin pop X from the stack;
push YkYk-1,...,Y1 onto the stack, with Y1 on top;
output the production X  Y1Y2...Yk
end
else error(2)
until X = a = $ /* stack is empty */
end.

22. 예제 – text p.290 [1/2] • G : 1. S  aSb 2. S  bA 3. A  Aa 4. A  b
string : aabbbb
• Parsing Table:
terminals
nonterminal a b $ S 1 2 . A 3 4

23. 예제 – text p.290 [2/2] STACK INPUT ACTIONS OUTPUT $S $bSa $bS $bbSa
$bbAb
$bbA
$bbb
$bb $b $
aabbbb$
abbbb$
bbbb$
bbb$
bb$ b$
expand 1
pop a and advance expand 1
pop a and advance
expand 2
pop b and advance
expand 4
Accept 1 2 4
※ How to construct a predictive parsing table for the grammar.
$bbA bbb$ expand
$bbb bbb$ pop b and advance
$bb bb$ pop b and advance
$b b$ pop b and advance
$ $ Accept

24. 7.4 Predictive 파싱 테이블의 구성
main idea : If A   is a production with a in FIRST(), then the parser will expand A by  when the
current input symbol is a. And if   , then
we should again expand A by  when the
current input symbol is in FOLLOW(A).
parsing table(LL):
M[X,a] = r : expand X with r-production
blank : error *

25. Construction Algorithm :
for each production A,
1. a ∈ FIRST(), M[A,a] := <A>
2. if  * , then
b ∈ FOLLOW(A), M[A,b] := <A>.

26. 예제 – text p.297 [1/2] G: 1. E  TE’ 2. E’ +TE’ 3. E’  
4. T  FT’ 5. T’ FT’ T’ 
7. F  (E) F  id
FIRST(E) = FIRST(T) = FIRST(F) = { ( , id }
FIRST(E’) = { + ,  }
FIRST(T’) = {  ,  }
FOLLOW(E) = FOLLOW(E’) = { ) , $ }
FOLLOW(T) = FOLLOW(T’) = { + , ) , $ }
FOLLOW(F) = { + ,  , ) , $ }

27. 예제 – text p.297 [2/2] Parsing Table: id + * ( ) $ E 1 E’ 2 3 T 4 T’ 6
Terminal
Nonterminal id + * ( ) $ E 1 E’ 2 3 T 4 T’ 6 5 F 8 7

28. LL 문법 및 조건 LL(1) Grammar LL(1) condition:
::= a grammar whose parsing table has no multiply-defined entries.
 multiply 정의되면 어느 rule로 expand해야 할 지 결정할 수 없기 때문에 deterministic하게 parsing할 수 없다.
LL(1) condition:
A   | ,
1. FIRST( ) ∩ FIRST() = .
2. if   , then FOLLOW(A) ∩ FIRST() = . *

29. Not LL(1)의 예 [1/2] G : 1. S  iCtSS’ 2. S  a
3. S’  eS S’   C  b
FIRST(S) = {i,a} FIRST(S') = {e, } FIRST(C) = {b}
FOLLOW(S) = {$,e} FOLLOW(S') = {$,e} FOLLOW(C) = {t}
Parsing Table:
M[S',e] := <3,4>로 중복으로 정의되었음.
여기서, stack top이 S'이고 input symbol이 e일 때 3번 rule로 expand해야 할 지, 4번 rule로 expand해야 하는지 알 수 없다. 그러므로 G는 LL(1) grammar가 아니다.
Terminals
Nonterminals a b e i t $ S 2 1 S’
3,4 4 C 5

30. Not LL(1)의 예 [2/2] [예제 7.15] --- text p.298 G : S  aA | abA
 : abab