320 likes | 589 Views
컴파일러 입문. 제 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.
E N D
컴파일러 입문 제 7 장 LL 구문 분석
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”
How to decide which production is to be applied: sentential form : 1 2 …i-1Xα input string : 1 2 …i-1 ii+1 …n • X 1 | 2... | k ∈ P일 때, i를 보고 X-production 중에unique하게 결정. • the condition forno backtracking: FIRST와 FOLLOW가 필요. (=> LL condition)
* * 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) ∪{}. *
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) ::= 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).
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) = {,+,),$}
FOLLOW 구하는예제 [2/2] • 연습문제 7.4 (3) - p.307 (3) S aAa | A abS | c
LL condition • 기본적 개념 ::= no backup condition ::= the condition for deterministic parsing of top-down method. input : 12 ... i-1i ...n derived string: 12...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 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 ifnextSymbol = tathen begin getNextSymbol; pAend else if nextSymbol = tb then begin getNextSymbol; pB end else error end;
= aac$ procedure pA; begin if nextSymbol = tathen begin getNextSymbol; pA end elseifnextSymbol = tcthengetNextSymbol else error end; procedure pB; ... /* main */ begin getNextSymbol; pS; if nextSymbol = '$' then accept else error end. ※ procedure call sequence ::= leftmost derivation
* * * 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)
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 ifnextSymbol = tathengetNextSymbol else error end; ※getNextSymbol : 스캐너에 해당하는 루틴으로 입력 스트림으로부터토큰 한 개를 만들어 변수 nextSymbol에 배정한다.
LL Parsing Nonterminal procedure • A ∈ VN, procedure pA; vari: integer; begin casenextSymbolof 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;
※ The input buffer contains the string to be parsed, followed by $. Model of a predictive parser[1/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[2/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 (XABC), then replace X by ABC else error. Model of a predictive parser[3/3]
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) untilX = a = $ /* stack is empty */ end.
• G : 1. S aSb 2. S bA 3. A Aa 4. A b string : aabbbb • Parsing Table: 예제– text p.290 [1/2]
예제– text p.290 [2/2] ※ How to construct a predictive parsing table for the grammar.
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 파싱 테이블의 구성 *
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:
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() = . *
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가 아니다.
[예제 7.15] --- text p.298 G : S aA | abA A Ab | a : abab Not LL(1)의 예 [2/2]