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

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

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)

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 *

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

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

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

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

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

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

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;

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$

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

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

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

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

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

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

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.

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.

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.

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

예제 – 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 4 4 $bbb bbb$ pop b and advance $bb bb$ pop b and advance $b b$ pop b and advance $ $ Accept

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 *

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

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

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

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

Not LL(1)의 예 [1/2] G : 1. S  iCtSS’ 2. S  a 3. S’  eS 4. S’   5. 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

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