1 / 30

제 7 장 LL 구문 분석

컴파일러 입문. 제 7 장 LL 구문 분석. 7.1 결정적 구문 분석. Deterministic Top-Down Parsing ::= 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.

saima
Download Presentation

제 7 장 LL 구문 분석

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  2. LL Parsing 7.1 결정적 구문 분석 • Deterministic Top-Down Parsing ::= deterministic selectionof production rules to be applied in top-down syntax analysis. • One passnobackup 1. Input string is scannedonce 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 Leftparse”

  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 forno backtracking: FIRST와 FOLLOW가 필요. (=> LL condition)

  4. * * i j=1 * 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) ∪{}. *

  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) ::= the set of terminals that can appear immediately to the right of A in some sententialform. 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 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 • 기본적 개념 ::= 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 recursiveprocedures 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 = tathen begin getNextSymbol; pAend else if nextSymbol = tb then begin getNextSymbol; pB end else error end;

  12.  = aac$ procedure pA; begin if nextSymbol = tathen begin getNextSymbol; pA end elseif 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

  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 lookaheadof each production. • LOOKAHEADof 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 = tathen getNextSymbol else error end; ※ getNextSymbol : 스캐너에 해당하는 루틴으로 입력 스트림으로부터 토큰 한 개를 만들어 변수 nextSymbol에 배정한다.

  17. LL Parsing 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;

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

  19. 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[2/3]

  20. 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. Model of a predictive parser[3/3]

  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. • G : 1. S  aSb 2. S  bA 3. A  Aa 4. A  b string : aabbbb • Parsing Table: 예제– text p.290 [1/2]

  23. 예제– text p.290 [2/2] ※ How to construct a predictive parsing table for the grammar.

  24. 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 7.4 Predictive 파싱 테이블의 구성 *

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

  27. 예제– text p.297 [2/2] • Parsing Table:

  28. LL 문법 및 조건 • LL(1) Grammar ::= 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 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가 아니다.

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

More Related