Objectives: parsing lectures. CSE401: Parsing. Parsing: two jobs. Parsing. CFG terminology. Context-free grammars (CFGs) Understand:

Transcription

1 Objectives: parsig lectures CSE401: Parsig Larry Syder Sprig 2003 Slides by Chambers, Eggers, Notki, Ruzzo, Syder ad others L. Syder & UW CSE Uderstad: Theory ad practice of parsig Uderlyig laguage theory (CFGs,...) Top-dow parsig (ad be able to do it) Bottom-up parsig (time permittig) Today s focus: grammars ad ambiguity 2 Parsig Parsig: two jobs sequece of tokes Abstract Sytax Tree (AST) Captures hierarchical structure of the program Is the primary represetatio of the program used by the rest of the compiler Parser abstract sytax tree (AST) It gets augmeted ad aotated, but the basic structure of the AST is used throughout Is the program sytactically correct? a := 3 * (5 + 4) if x > y the m := x a := 3 * / 4 if x < y else m := x If so, build the correspodig AST := a * if > := x y m x 3 4 all laguages Cotext-free grammars (CFGs) Turig-computable laguages cotext-free laguages regular laguages For lexig, we used regular expressios as the uderlyig otatio For parsig, we use cotext-free grammars i much the same way Regular expressios are ot powerful eough Ituitively, ca t express balace/estig (a b, pares) More geeral grammars are more powerful tha we eed Well, we could use more power, but istead we delay some checkig to sematic aalysis istead of doig all the aalysis based o the (geeral, but slow) grammar 5 CFG termiology Termials: alphabet, or set of legal tokes Notermials: represet abstract sytax uits Productios: rules defiig otermials i terms of a fiite sequece of termials ad otermials Start symbol: root symbol defiig the laguage Program ::= Stmt Stmt ::= if Expr the Stmt else Stmt ed Stmt ::= while Expr do Stmt ed 6 CSE401, Sp '03, L. Syder ad UW CSE

2 EBNF descriptio of PL/0 Program ::= module Id Block Id. Block ::= DeclList begi StmtList ed DeclList ::= { Decl Decl ::= CostDecl ProcDecl VarDecl CostDecl ::= cost CostDeclItem {, CostDeclItem CostDeclItem ::= Id : Type = CostExpr CostExpr ::= Id Iteger VarDecl ::= var VarDeclItem {, VarDeclItem VarDeclItem ::= Id : Type EBNF descriptio of PL/0 ProcDecl ::= procedure Id ( [ FormalDecl {, FormalDecl ] ) Block Id FormalDecl ::= Id : Type Type ::= it StmtList ::= { Stmt Stmt ::= CallStmt AssigStmt OutStmt IfStmt WhileStmt CallStmt ::= Id ( [ Exprs ] ) AssigStmt ::= Lvalue := Expr Lvalue ::= Id 7 8 EBNF descriptio of PL/0 Exercise: produce a sytax tree for squares.0 OutStmt ::= output := Expr IfStmt ::= if Test the StmtList ed WhileStmt ::= while Test do StmtList ed Test ::= odd Sum Sum Relop Sum Relop ::= <= <> < >= > = Exprs ::= Expr {, Expr Expr ::= Sum Sum ::= Term { (+ -) Term Term ::= Factor { (* /) Factor Factor ::= - Factor LValue Iteger iput ( Expr ) 9 module mai var x:it, squareret:it procedure square(:it) begi squareret := * ed square begi x := iput while x <> 0 do square(x) output := squareret x := iput ed ed mai. 10 Derivatios ad parsig Derivatio A sequece of expasio steps, Begiig with the start symbol, Leadig to a strig of termials Parsig: iverse of derivatio Give a target strig of termials, Recover otermials/productios represetig structure Parse trees We represet derivatios ad parses as parse trees Cocrete sytax tree Exact reflectio of the grammar Abstract sytax tree Simplified versio, reflectig key structural iformatio E.g., omit superfluous puctuatio & keywords CSE401, Sp '03, L. Syder ad UW CSE

3 a := 3 *(4+5) Cocrete Sytax Tree AStmt Lval := Expr a (Id) Sum Term Fact * Fact ( Expr ) 3 (it) Sum Term + Term 4 (it) 5 (it) Abstract sytax trees Cocrete sytax tree Abstract sytax tree a := 3 *(4+5) AStmt Lval := Expr a (Id) Sum Term Fact 3 (it) * Fact Expr ( ) Sum := a * Term + Term 13 4 (it) 5 (it) 14 Ex: A expressio grammar Ambiguity E ::= E Op E - E ( E ) it Op ::= + - * / Usig this grammar, fid parse trees for: 3 * * 5 Some grammars are ambiguous Differet parse trees with the same fial strig (Some laguages are ambiguous, with o possible o-ambiguous grammar but we avoid them) The structure of the parse tree captures some of the meaig of a program Ambiguity is bad sice it implies multiple possible meaigs for the same program Cosider the example o the previous slide Aother famous ambiguity: daglig else Stmt ::= if Expr the Stmt if Expr the Stmt else Stmt if e1 the if e2 the s1 else s2 To which the does the else belog? The compiler is t goig to be cofused However, if the compiler chooses a meaig differet from what the programmer iteded, it could get ugly Ay ideas for overcomig this problem? Resolvig ambiguity: #1 ΠAdd a meta-rule For istace, else associates with the closest previous umatched if This works ad keeps the origial grammar itact But it s ad hoc ad iformal CSE401, Sp '03, L. Syder ad UW CSE

4 Resolvig ambiguity: #2 Rewrite the grammar to resolve it explicitly Stmt ::= MatchedStmt UmatchedStmt MatchedStmt ::= if Expr the MatchedStmt else MatchedStmt UmatchedStmt ::= if Expr the Stmt if Expr the MatchStmt else UmatchedStmt Resolvig ambiguity: #2 (cot.) Stmt ::= MatchedStmt UmatchedStmt MatchedStmt ::= if Expr the MatchedStmt else MatchedStmt UmatchedStmt ::= if Expr the Stmt if Expr the MatchStmt else UmatchedStmt ΠFormal, o additioal meta-rules Somewhat more obscure grammar if e1 the if e2 the s1 else s Resolvig ambiguity: #3 ΠRedesig the programmig laguage to remove the ambiguity Stmt ::= if Expr the Stmt ed if Expr the Stmt else Stmt ed Formal, clear, elegat Allows StmtList i the ad else brach, without addig begi/ed Extra ed required for every if statemet What about that expressio grammar? How to resolve its ambiguity? Optio #1: add meta-rules for precedece ad associativity Optio #2: modify the grammar to explicitly resolve the ambiguity Optio #3: redefie the laguage Optio #1: add meta-rules Optio #2: ew BNF E ::= E+T T T ::= T*F F F ::= id (E) Add meta-rules for precedece ad associativity E ::= E+E E-E E*E E/E E^E (E) -E +,- < *,/ < uary - < ^ etc. +,-,*,/ left-associative ^ right associative Simple, ituitive ΠBut ot all parsers ca support this yacc does 23 Create a otermial for each precedece level Expr is the lowest precedece otermial Each otermial ca be rewritte with higher precedece operator Highest precedece operator icludes atomic expressios At each precedece level use Left recursio for left-associative operators Right recursio for right-associative operators No recursio for o-associative operators 24 CSE401, Sp '03, L. Syder ad UW CSE

5 Optio #2: example E ::= E+T T T ::= T*F F F ::= id (E) Optio #3: New laguage Require pares E.g., i APL all exprs evaluated left-to-right uless parethesized Forbid pares E.g.: RPN calculators w + x + y * z Desigig a grammar: o what basis? Parsig algorithms Accuracy Readability, clarity Uambiguity Limitatios of CFGs Similarity to desired AST structure Ability to be parsed by a particular parsig algorithm Top-dow parser => LL(k) grammar Bottom-up parser => LR(k) grammar Give iput (sequece of tokes) ad grammar, how do we fid a AST that represets the structure of the iput with respect to that grammar? Two basic kids of algorithms Top-dow: expad from grammar s start symbol util a legal program is produced Bottom-up: create sub-trees that are merged ito larger sub-trees, fially leadig to the start symbol Top-dow parsig Predictive parser Build AST from top (start symbol) to leaves (termials) Represets a leftmost derivatio (e.g., always expad leftmost otermial) Basic issue: whe replacig a o-termial with a right-had side (rhs), which rhs should you use? Basic solutio: Look at ext iput tokes Stmt ::= Call Assig If Call ::= Id Assig::= Id := Expr If ::= if Test the Stmts ed If ::= if Test the Stmts else Stmts ed 29 A top-dow parser that ca select the correct rhs lookig at the ext k tokes (lookahead) Efficiet No backtrackig is eeded Liear time to parse Implemetatio Table-drive: pushdow automato (PDA) like table-drive FSA plus stack for recursive FSA calls Recursive-descet parser [used i PL/0] Each o-termial parsed by a procedure Call other procedures to parse sub-o-termials, recursively 30 CSE401, Sp '03, L. Syder ad UW CSE

6 LL(k), LR(k),? These parsers have geerally sazzy ames The simpler oes look like the oes i the title of this slide The first L meas process tokes left to right The secod letter meas produce a (Right / Left)most derivatio Leftmost => top-dow Rightmost => bottom-up The k meas k tokes of lookahead We wo t discuss LALR(k), SLR, ad lots more parsig algorithms 31 LL(k) grammars It s easy to costruct a predictive parser if a grammar is LL(k) Left-to-right sca o iput, Leftmost derivatio, k tokes of lookahead Restrictios iclude Uambiguous No commo prefixes of legth k No left recursio (more details later) Collectively, the restrictios guaratee that, give k iput tokes, oe ca always select the correct rhs to expad Commo prefix S ::= if Test the Stmts ed if Test the Stmts else Stmts ed Left recursio E ::= E op E 32 Elimiatig commo prefixes Elimiatig left recursio: ΠLeft factor them, creatig a ew o-termial for the commo prefix ad/or differet suffixes Before If ::= if Test the Stmts ed if Test the Stmts else Stmts ed After If ::= if Test the Stmts IfCot IfCot ::= ed else Stmts ed Grammar is a bit uglier Easy to do maually i a recursive-descet parser Before E ::= E + T T T ::= T * F F F ::= id ( E ) After E ::= T ECot ECot ::= + T ECot T ::= F TCot TCot ::= * F TCot F ::= id ( E ) Just add sugar ΠE ::= T { + T T ::= F { * F F ::= id ( E ) Sugared form is still pretty readable Easy to implemet i had-writte recursive descet parser Cocrete sytax tree is ot as close to abstract sytax tree LL(1) Parsig Theory Goal: Formal, rigorous descriptio of those grammars for which I ca figure out how to do a top-dow parse by lookig ahead just oe toke, plus correspodig algorithms. Notatio: T = Set of Termials (Tokes) N = Set of Notermials $ = Ed-of-file character (T-like, but ot i N T) CSE401, Sp '03, L. Syder ad UW CSE

7 Table-drive predictive parser Example 1 Automatically compute PREDICT table from grammar PREDICT(otermial,iput-symbol) Ł actio, e.g. which rhs or error Stmt ::= if expr the Stmt else Stmt while Expr do Stmt begi Stmts ed Stmts ::= Stmt Stmts Expr ::= id if the else while do begi ed id $ Stmt Stmts Expr 37 empty = error 38 LL(1) Parsig Algorithm Costructig PREDICT: overview push S$ /* S is start symbol */ while Stack ot empty X := pop(stack) a := peek at ext toke /* assume EOF = $ */ if X is termial or $ If X==a, read toke a else abort else look at PREDICT(X, a) /* X is otermial */ Empty : abort rule X : push Compute FIRST set for each rhs All tokes that ca appear first i a derivatio from that rhs I case rhs ca be empty, compute FOLLOW set for each o-termial All tokes that ca appear right after that otermial i a derivatio Costructios of FIRST ad FOLLOW sets are iterdepedet PREDICT depeds o both If ot at ed of iput, abort Example 1 (cot.) FIRST() 1 st toke from S ::= if E the S else S while E do S FIRST FOLLOW Defiitio: For ay strig of termials ad otermials, FIRST() is the set of termials that begi strigs derived from, together with, if ca derive. More precisely: begi Ss ed Ss ::= S Ss E ::= id For ay (N T)*, FIRST() = { a T * a for some (N T)* {, if * CSE401, Sp '03, L. Syder ad UW CSE

8 Computig FIRST 4 cases 1. FIRST() = { 2. For all a T, FIRST(a) = {a 3. For all A N, repeat util o chage If there is a rule A, add() to FIRST(A) For all rules A Y 1 Y k add(first(y 1 ) - {) if FIRST(Y 1 ) the add(first(y 2 ) - {) if FIRST(Y 1 Y 2 ) the add(first(y 3 ) - {) if FIRST(Y 1 Y 2...Y k ) the add() 43 Computig FIRST (Cot.) 4. For all ay strig Y 1 Y k (N T)*, similar: add(first(y 1 ) - {) if FIRST(Y 1 ) the add(first(y 2 ) - {) if FIRST(Y 1 Y 2 ) the add(first(y 3 ) - {) if FIRST(Y 1 Y 2...Y k ) the add() [Note: defied for all strigs really oly care about FIRST(right had sides).] 44 FOLLOW(B) Next toke after B Defiitio: for ay o-termial B, FOLLOW(B) is the set of termials that ca appear immediately after B i some derivatio from the start symbol, together with $, if B ca be the ed of such a derivatio. ($ represets ed of iput.) More precisely: For all B N, FOLLOW(B) = { a (T {$) S$*B a for some, (N T {$)* (S is the Start symbol of the grammar.) 45 Computig FOLLOW(B) Add $ to FOLLOW(S) Repeat util o chage For all rules A B [i.e. all rules with a B i r.h.s], Add (FIRST( ) - {) to FOLLOW(B) If FIRST( ) [i particular, if is empty] the Add FOLLOW(A) to FOLLOW(B) Assume for all A that S * A for some, (N T)*, else A irrelevat 46 PREDICT Give lhs, which rhs? For all rules A For all a FIRST() - { Add(A ) to PREDICT(A,a) If FIRST() the For all b FOLLOW(A) Add(A ) to PREDICT(A,b) Def: G is LL(1) iff every cell has 1 etry 47 Properties of LL(1) Grammars Clearly, give a coflict-free PREDICT table ( 1 etry/cell), the parser will do somethig uique with every iput Key fact is, if the table is built as above, that somethig is the correct thig I.e., the PREDICT table will reliably guide the LL(1) parsig algorithm so that it will Fid a derivatio for every strig i the laguage Declare a error o every strig ot i the laguage 48 CSE401, Sp '03, L. Syder ad UW CSE

9 Exercises (1 st especially recommeded) Easy: Pick some grammar with commo prefixes, left recursio, ad/or ambiguity. Build PREDICT it will have coflicts Harder: prove that every grammar with 1 of those properties will have PREDICT coflicts Harder: Fid a grammar with oe of those features that evertheless gives coflicts. I.e., absece of those features is ecessary but ot sufficiet for a grammar to be LL(1). Harder, for theoryheads: if the table has coflicts, ad the parser chooses amog them odetermiistically, it will work correctly 49 Example 2 E ::= T { + T T ::= F { * F F ::= - F id ( E ) E ::= T E E ::= + T E T ::= F T T ::= * F T F ::= - F id ( E ) Sugared Usugared 50 Example 2 (cot.) Example 2: PREDICT E ::= T E FIRST FOLLOW id + - * / ( ) $ E ::= + T E T ::= F T E E T ::= * F T F ::= - F T T id ( E ) F PREDICT ad LL(1) Recursive descet parsers The PREDICT table has at most oe etry i each cell if ad oly if the grammar is LL(1) there is oly oe choice (it s predictive), makig it fast to parse ad easy to implemet Multiple etries i a cell Arise with left recursio, ambiguity, commo prefixes, etc. Ca patch by had, if you kow what to do Or use more powerful parser (LL(2), or LR(k), or?) Or chage the grammar Write procedure for each o-termial Each procedure selects the correct right-had side by peekig at the iput tokes The the r.h.s. is cosumed If it s a termial symbol, verify it is ext ad the advace through the toke stream If it s a o-termial, call correspodig procedure Build ad retur AST represetig the r.h.s CSE401, Sp '03, L. Syder ad UW CSE

10 Recursive descet example Stmt ::= if expr the Stmt else Stmt while Expr do Stmt begi Stmts ed Stmts ::= Stmt Stmts Expr ::= id ParseStmt() { switch (ext toke) { "begi": ParseStmts()read "ed" break "while": ParseExpr() read "do" ParseStmt() break "if": ParseExpr() read "the" ParseStmt() read "else" ParseStmt() break default: abort 55 LL(1) ad Recursive Descet If the grammar is LL(1), it s easy to build a recursive descet parser Oe otermial/row oe procedure Use 1 toke lookahead to decide which rhs Table-drive parser's stack recursive call stack Recursive descet ca hadle some o-ll(1) features, too. 56 Example LL(1) & recursive descet Stmt Stmts Expr if the else while do begi ed id $ Example o-ll(1) & recursive descet Stmt Stmts Expr if the else while do begi ed id $ Stmt ::= if expr the Stmt else Stmt while Expr do Stmt begi Stmts ed Stmts ::= Stmt Stmts Expr ::= id ParseStmt() { switch (ext toke) { "begi": ParseStmts()read "ed" break "while": ParseExpr() read "do" ParseStmt() break "if": ParseExpr() read "the" ParseStmt() read "else" ParseStmt() break default: abort 57 Stmt ::= if expr the Stmt if expr the Stmt else Stmt while Expr do Stmt begi Stmts ed Stmts ::= Expr ::= Stmt Stmts id The daglig else ambiguity & commo prefixes ParseStmt() { switch (ext toke) { "if": ParseExpr() read "the" ParseStmt() if(ext toke == "else") {read "else" ParseStmt() break "begi": It s demo time Let s look at some of the PL/0 code to see how the recursive descet parsig works i practice 59 Parser::ParseStmts() <stmt list> ::= { <stmt> <stmt> ::= <id stmt> <out stmt> <if stmt> <while stmt> StmtArray* Parser::ParseStmts() { StmtArray* stmts = ew StmtArray Stmt* stmt for () { Toke t = scaer->peek() switch (t->kid()) { case IDENT: stmt = ParseIdetStmt() break case OUTPUT: stmt = ParseOutputStmt() break case IF: stmt = ParseIfStmt() break case WHILE: stmt = ParseWhileStmt() break default: retur stmts // o more stmts stmts->add(stmt) scaer->read(semicolon) 60 CSE401, Sp '03, L. Syder ad UW CSE

11 Parser::ParseIfStmt() <if stmt> ::= if <test> the <stmt list> ed <while stmt> ::= while <test> do <stmt list> ed Parser::ParseWhileStmt() Stmt* Parser::ParseIfStmt() { scaer->read(if) Expr* test = ParseTest() scaer->read(then) StmtArray* stmts = ParseStmts() scaer->read(end) retur ew IfStmt(test, stmts) Stmt* Parser::ParseWhileStmt() { scaer->read(while) Expr* test = ParseTest() scaer->read(do) StmtArray* stmts = ParseStmts() scaer->read(end) retur ew WhileStmt(test, stmts) Parser:: ParseIdetStmt() <id stmt> ::= <call stmt> <assig stmt> <call stmt> ::= IDENT "(" [ <exprs> ] ")" <assig stmt>::= <lvalue> := <expr> <lvalue> ::= IDENT Parser::ParseSum() <sum> ::= <term> { (+ -) <term> Stmt* Parser:: ParseIdetStmt() { Toke* id = scaer->read(ident) if (scaer->codread(lparen)){ ExprArray* args if (scaer->codread(rparen)){ args = NULL else { args = ParseExprs() scaer->read(rparen) retur ew CallStmt(id->idet(), args) else { LValue* lvalue = ew VarRef(id->idet()) scaer->read(gets) retur ew AssigStmt(lvalue, ParseExpr()) 63 Expr* Parser::ParseSum() { Expr* expr = ParseTerm() for () { Toke* t = scaer->peek() if (t->kid() == PLUS t->kid() == MINUS) { scaer->get() // eat the toke Expr* expr2 = ParseTerm() expr = ew BiOp(t->kid(), expr, expr2) else { retur expr 64 <term> ::= <factor> { (* /) <factor> Parser::ParseTerm() Yacc A bottom-up-parser geerator Expr* Parser::ParseTerm() { Expr* expr = ParseFactor() for () { Toke* t = scaer->peek() if (t->kid() == MUL t->kid() == DIVIDE) { scaer->get() // eat the toke Expr* expr2 = ParseFactor() expr = ew BiOp(t->kid(), expr, expr2) else { retur expr 65 yet aother compiler-compiler Iput: grammar, possibly augmeted with actio code Output: C code to parse it ad perform actios LALR(1) parser geerator practical bottom-up parser more powerful tha LL(1) moder updates of yacc yacc++, biso, byacc, 66 CSE401, Sp '03, L. Syder ad UW CSE

12 Yacc iput grammar Example Yacc with actios assigstmt: IDENT GETS expr ifstmt: IF test THEN stmts END IF test THEN stmts ELSE stmts END expr: term expr '+' term expr '-' term factor: '-' factor IDENT INTEGER INPUT '(' expr ')' 67 assigstmt: IDENT GETS expr { $$ = ew AssigStmt($1, $3) ifstmt: IF be THEN stmts END { $$ = ew IfStmt($2,$4,NULL) IF be THEN stmts ELSE stmts END { $$ = ew IfStmt($2,$4,$6) expr: term { $$ = $1 expr '+' term { $$ = ew BiOp(PLUS, $1, $3) expr '-' term { $$ = ew BiOp(MINUS, $1, $3) factor: '-' factor { $$ = ew UOp(MINUS, $2) IDENT { $$ = ew VarRef($1) INTEGER { $$ = ew ItLiteral($1) INPUT { $$ = ew IputExpr '(' expr ')' { $$ = $2 68 Parsig summary Parsig summary Techical details you should kow Discover/impose a useful (hierarchical) structure o flat toke sequece Represeted by Abstract Sytax Tree Validity check sytax of iput Could build cocrete sytax tree (but do't) May methods available Top-dow: LL(1)/recursive descet commo for simple, by-had projects Bottom-up: LR(1)/LALR(1)/SLR(1) commo for more complex projects parser geerator (e.g., yacc) almost ecessary Cotext-free grammars Defiitios Maipulatios (algorithmic) Left factor commo prefixes Elimiatig left recursio Ambiguity & (semiheuristic) fixes meta-rules (code/ precedece tables) rewrite grammar chage laguage Buildig a table-drive predictive parser LL(1) grammar: defiitio & commo obstacles PREDICT(otermial, iput symbol) FIRST(RHS) FOLLOW(otermial) Buildig a recursive descet parser Icludig AST Objectives: today Ambiguity Issues i desigig a grammar AST extesios for the 401 project Overview of parsig algorithms Motivatio ad details of top-dow, predictive parsers Recursive descet parsig Today++: a walk through the PL/0 parser Objectives: today Recap ad clarify PREDICT table Describe computatio of FIRST ad FOLLOW Ad the relatioship to PREDICT Recursive descet parsig High-level issues ad (time-permittig) a walk through the PL/0 parser CSE401, Sp '03, L. Syder ad UW CSE

13 Program ::= module Id Block Id. Block ::= DeclList begi StmtList ed DeclList ::= { Decl Decl ::= CostDecl ProcDecl VarDecl CostDecl ::= cost CostDeclItem {, CostDeclItem CostDeclItem ::= Id : Type = CostExpr CostExpr ::= Id Iteger VarDecl ::= var VarDeclItem {, VarDeclItem VarDeclItem ::= Id : Type ProcDecl ::= procedure Id ( [ FormalDecl {, FormalDecl ] ) Block Id FormalDecl ::= Id : Type Type ::= it StmtList ::= { Stmt Stmt ::= CallStmt AssigStmt OutStmt IfStmt WhileStmt CallStmt ::= Id ( [ Exprs ] ) AssigStmt ::= Lvalue := Expr Lvalue ::= Id OutStmt ::= output := Expr IfStmt ::= if Test the StmtList ed WhileStmt ::= while Test do StmtList ed Test ::= odd Sum Sum Relop Sum Relop ::= <= <> < >= > = Exprs ::= Expr {, Expr Expr ::= Sum Sum ::= Term { (+ -) Term Term ::= Factor { (* /) Factor Factor ::= - Factor LValue Iteger iput ( Expr ) EBNF descriptio of PL/0 73 AST extesios i project Expressios true ad false costats array idex expressio (a lvalue) fuctio call expressio ad ad or operators tests are expressios costat expressios Statemets Declaratios procedures with result types var parameters Types bool array for break retur if with else 74 if id the begi ed else while id do begi ed ed Productio applied Stmt 1. if Expr the Stmt else Stmt ed 6. if id the Stmt else Stmt ed 3. if id the begi Stmts ed else Stmt ed 5. if id the begi ed else Stmt ed 2. if id the begi ed else while Expr do Stmt ed 6. if id the begi ed else while id do Stmt ed 3. if id the begi ed else while id do begi Stmts ed ed 5. if id the begi ed else while id do begi ed ed 75 CSE401, Sp '03, L. Syder ad UW CSE