1. 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”

2. 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)

3. 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 *

4. 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, }

5. 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). *

6. 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) = {,+,),$}

7. 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() =  *

8. 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 조건을 만족한다.

9. 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;

10. 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$

11. 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) *

12. 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

13. 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)이다.

14. 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에 배정한다.

15. 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;

16. RDP 최적화
Improving the efficiency and structure of recursive-descent parser
1) Eliminating terminal procedures
::= In practice it is better not to write a procedure for each
terminal. Instead the action of advancing the input marker
can always be initiated by the nonterminal procedures.
In this way many redundant tests can be eliminated.
ex) text p.285 [예제 7.9]
2) BNF  EBNF : reduce the number of productions and nonterminals.
① repetitive part : { }
② optional part : [ ]
③ alternation : ( | )

17. [예제 7.10] - text p.287
< if_st > ::= ‘ if ’ < cond > ‘ then ’ < st > [‘ else ’ < st > ] procedure pIF; begin if nextSymbol = tif then begin getNextSymbol; pCOND; if nextSymbol = tthen then begin getNextSymbol; pST end else error(10) end else error(11); if nextSymbol = telse then end;

18. [예제 7.11] - text p.288
<id_list> ::= ‘ id ’ {‘ , ’ ‘ id ’ } procedure pID_LIST; begin if nextSymbol = tid then begin getNextSymbol; while (nextSymbol = tcomma) do if nextSymbol = tid then getNextSymbol else error(100) end end;

19. 7.3 Predictive 파서 RDP의 단점 Predictive 파서 Predictive parsing
문법이 변경되면 프로그램을 수정해야 함.
Predictive 파서
프로그램과 테이블로 분리
Driver routine + Table
RDP의 단점을 극복
문법 변경 시 테이블만 재구성
Predictive parsing
::= a deterministic top-down parsing method using a stack.
The stack contains a sequence of grammar symbols.

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

21. 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.

22. 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.

23. 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.

24. 예제 – 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

25. 예제 – 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

26. 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 *

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

28. 예제 – 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) = { + ,  , ) , $ }

29. 예제 – 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