Compiler Construction

Transcription

1 Compiler Contruction Lecture 6 - An Introduction to Bottom- Up Paring 3 Robert M. Siegfried All right reerved Bottom-up Paring Bottom-up parer pare a program from the leave of a pare tree, collecting the piece until the entire pare tree i built all the way to the root. Bottom-up parer emulate puhdown automata: requiring both a tate machine (to keep track of what you are looking for in the grammar) and a tack (to keep track of what you have already read in the program). making it fairly eay to automate the proce of creating the parer enuring that all context-free grammar can be pared by thi method.

2 Bottom-up parer a hift-reduce parer Bottom-up parer are frequently called hift-reduce parer becaue of their two baic operation: A hift involve moving puhing the current input token onto the tack and fetching the next input token. A reduce involve popping all the variable that comprie the right-entential form for a nonterminal and replacing them on the tack with the equivalent nonterminal that appear on the left-hand ide of that production. While hifting involve puhing and reducing involve popping, do not think of them a equivalent: a hift alo involve advancing the input token tream and a reduce involve zero or more pop followed by a puh. Bottom-up Paring a an Emulation of Puhdown Automata Mot bottom-up parer are table-driven, with the table encoding the neceary information about the grammar. he parer decide what action to perform baed on the combination of current tate and current input token. A tate in the machine which the computer i emulating reflect both what the machine ha already pared and that which it i expect to ee in the input token tream. Several parer generator have been created baed on thi theoretical machine, the bet known of which i YACC (Yet Another Compiler Compiler), i available on many UNIX ytem and it public domain lookalike Bion.

3 LR(k) grammar Bottom-up grammar are referred to a LR(k) grammar: he firt L indicate Left-to-Right canning. he econd L indicate Right-mot derivation he k indicate k lookahead character. here hould be no need for anything more than a ingle lookahead, i.e, an LR() grammar. An example - a LR() grammar An LR() grammar doe not ue a lookahead character to determine the action that it will take - the current token will be ued to determine the tate into which it will go. Conider the following grammar: E ::= E ::= - ::= id cont

4 An example - a LR() grammar (continued) Let write out our grammar and add to it a pecial firt production with a pecial tart ymbol S: S ::= E $ (indicate that the expreion i followed by EO) E ::= E 3 E ::= 4 ::= 5 ::= - 6 ::= 7 ::= id 8 ::= cont he LR() pare table GOO tate ACION r3 r6 r7 r8 r4 r r5 acc - id cont $ E

5 racing LR() paring here are 3 paring operation: Shift - moving a token and tate onto the tack (we find the tate uing the GOO table). Reduce n - we pop enuogh item from the tack to form the right ide of production n and then we puh the nonterminal on it left ide of production n on to thetack, together with thetate indicated by the GOO table Accept - we accept the program a completely and correctly pared and terminate execution. racing LR() paring - an example Example - the expreion -7 x 5 - $ We place the tate and the EO marker $ on the tack. he action for tate i hift. We place the - and GOO(, -) = 5 on the tack 7 cont he action for tate 5 i hift. We place the contant on 5 - the tack together with GOO(5, cont) = 7. $ he action for tate 7 i reduce by production 8. Pop 5 - the cont (and tate 7). Puh and GOO(5,) = $

6 racing LR() paring - an example (continued) $ he action for tate i reduce by production 5. Pop the - and (along with tate 5 and ) and puh the together with GOO(,) = E $ 8 E $ he action for tate i reduce by production 3. Pop the (and tate ). Puh the E and GOO(,E) =. he action for tate i hift. We move the onto the tack together with GOO(, ) = 8. racing LR() paring - an example (continued) 6 id 8 E $ 3 8 E $ he action for tate 8 i hift. We move the id and GOO(8, id) = 6 onto the tack. he action for tate 6 i reduce by production 7. We pop the id and tate 6. We puh and GOO(8, ) = 3 he action for tate 3 i reduce by production 6. We 8 E $ pop the and tate 3. We puh and GOO(8, ) =.

7 racing LR() paring - an example (continued) E $ he action for tate i reduce by production. We pop the (and tate), the (and tate8) and the E (and tate). We puh the E and GOO(,E) =. $ E $ he action for tate i hift. We puh the $ and GOO (,E) = onto the tack. he action for tate i accept. he only item on the tack (excluding the $) i E, which i the tart ymbol in our expreion grammar Right entential form A right entential form i a partially formed entence (or program). It can contain the variable on the right- hand ide of a production or phrae derived from it. Right entential form are derived from the rightmot derivation. ormally, if S => * β, then β i a right entential form.

8 Handle In performing a reduce operation, we mut decide which variable in a right-entential form will be popped and replaced on the tack by the nonterminal on the production left-hand ide. hee variable are collectively called the handle. If A => β, then β would be handle for the production. Item An item i a production, with a dot added to it indicating how much of the production ha been matched up o far. Example: nothing in the production ha been matched yet. E ::= E. we have matched the E and the

9 What we would expect to the State Machine to look like id cont E 8-5 $ Contructing the State Machine We already know that proceing context-free language require a puhdown automaton. A we prepare to match token in the item S ::=.E$ we have no way of knowing what collection of token repreent E We will have to conider all poible way of repreenting an expreion: E ::=.E E ::=.

10 Contructing the State Machine (continued) Since matche a collection of token to E may mean matching it to, we mut know what to look for here a well: ::=. ::=. Contructing the State Machine (continued) Since matche a collection of token to may mean matching it to, we mut know what to look for here a well: ::=.id ::=.cont Since we know exactly how to match id and cont to token (ince they are terminal), we don t need any additional item.

11 Contructing the State Machine Initial State State alway contain an item howing the pecial tart ymbol deriving the regular tart ymbol followed by EO Contructing the State Machine Initial State S ::=. E $ E ::=. he dot indicate that we mut proce an Expreion next hi mean that we need to know what can comprie an expreion

12 Contructing the State Machine Initial State E ::=. he dot indicate that we mut proce a erm next hi mean that we need to know what can comprie a term Contructing the State Machine Initial State E ::= ::=.id ::=. cont Here we know exactly what we re proceing we re looking for the token (or -) he dot indicate that we mut proce a actor next hi mean that we need to know what can comprie a factor

13 he LR() State Machine E ::=. ::=. cont Contructing he Next Set of State E ::=. ::=. cont E S ::= E. $ E ::= E.

14 Contructing he Next Set of State E ::=. ::=. cont E S ::= E. $ E ::= E. E ::=. Contructing he Next Set of State E ::=. ::=. cont E S ::= E. $ E ::= E. E ::=. 3 ::=.

15 Contructing he Next Set of State E ::=. ::=. cont 3 ::=. E S ::= E. $ E ::= E. E ::=. We now need two item indicating how to match 4 ::=. ::=. cont Contructing he Next Set of State E ::=. ::=. cont 3 ::=. E S ::= E. $ E ::= E. E ::=. - We now need two item indicating how to match 4 ::=. ::=. cont ::= -. ::=. cont 5

16 he LR() State Machine E ::=. ::=.id ::=. cont E S ::= E. $ E :: E. 4 ::=. ::=. cont - E ::=. cont id 5 ::= -. ::=. cont 3 ::=. 6 ::= id. 7 ::= cont. he LR() State Machine E ::=. ::=.id ::=. cont E ::=. 3 ::=. cont E S ::= E. $ E :: E. 9 ::=. 4 ::=. 6 ::=. cont 7 id - id ::= -. 5 ::= -. ::=. cont 6 ::= id. id cont 7 cont $ S ::= E $. 8 E ::= E. ::=. cont 7 ::= cont.

17 he LR() State Machine E ::=. ::=.id ::=. cont E S ::= E. $ E :: E. 9 ::=. 4 ::=. 6 ::=. cont 7 id - ::= -. - $ cont S ::= E $. 8 E ::= E. ::=. cont E ::=. cont id 5 ::= -. ::=. cont 7 id E ::= E. 3 ::=. 6 ::= id. cont 7 ::= cont. he LR() pare table GOO tate ACION r3 r6 r7 - id cont $ E ollow the tranition to the next tate 7 r r4 r r5 acc

18 he LR() pare table GOO tate ACION - id cont $ E r3 r6 r7 r8 r hi i a final tate becaue of the item E ::=. r r5 acc he LR Parer Driver Perform the Action aociated with the current tate and token REPEA I the Action i: Shift: Reduce n: Acecept Error Shift the current token on the tack with the new tate Popall the variable of the right entential form together with the tate. Puh the nonterminal from the left ide of the production together with GOO(tate, Nonterminal). Clean up Any error handling procedure UNIL Action for the current tate and token i ACCEP