Building A Recursive Descent Parser. Example: CSX-Lite. match terminals, and calling parsing procedures to match nonterminals.

Size: px

Start display at page:

Download "Building A Recursive Descent Parser. Example: CSX-Lite. match terminals, and calling parsing procedures to match nonterminals."

Gwendoline Burns
6 years ago
Views:

1 Building A Recursive Descent Parser We start with a procedure Match, that matches the current input token against a predicted token: vo Match(Terminal a) { if (a == currenttoken) currenttoken = Scanner() else SyntaxErrror() To build a parsing procedure for a non-terminal A, we look at all productions with A on the lefthand se: A X 1...X n A Y 1...Y m... We use predict sets to dece which production to match (LL(1) grammars always have disjoint predict sets). We match a production s righthand se by calling Match to match terminals, and calling parsing procedures to match nonterminals. The general form of a parsing procedure for A X 1...X n A Y 1...Y m... is vo A() { if (currenttoken in Predict(A X 1...X n )) for(i=1i<=ni++) if (X[i] is a terminal) Match(X[i]) else X[i]() else if (currenttoken in Predict(A Y 1...Y m )) for(i=1i<=mi++) if (Y[i] is a terminal) Match(Y[i]) else Y[i]() else // Handle other A... productions else // No production predicted SyntaxError() Usually this general form isn t used. Instead, each production is macro-expanded into a sequence of Match and parsing procedure calls. Example: CSX-Lite Production Predict Set Prog { { Stmt if λ Stmt = Stmt if ( ) Stmt if λ )

2 CSX-Lite Parsing Procedures vo Prog() { Match("{") vo () { if (currenttoken == currenttoken == if){ Stmt() else { vo () { Match() () vo () { if (currenttoken == "+") { Match("+") else if (currenttoken == "-"){ Match("-") else { vo Stmt() { if (currenttoken == ){ Match() Match("=") else { Match(if) Match("(") Match(")") Stmt() Let s use recursive descent to parse { a = b + c We start by calling Prog() since this represents the start symbol. Prog() Match("{") Stmt() Match() Match("=") { a = b + c { a = b + c a = b + c a = b + c a = b + c Match("=") Match() () () = b + c b + c b + c + c

3 Match("+") + c c Match() () () c Done! All input matched Syntax Errors in Recursive Descent Parsing In recursive descent parsing, syntax errors are automatically detected. In fact, they are detected as soon as possible (as soon as the first illegal token is seen). How? When an illegal token is seen by the parser, either it fails to predict any val production or it fails to match an expected token in a call to Match. Let s see how the following illegal CSX-lite program is parsed: { b + c = a (Where should the first syntax error be detected?) Prog() Match("{") Stmt() Match() Match("=") { b + c = a { b + c = a b + c = a b + c = a b + c = a

4 Match("=") + c = a Call to Match fails! + c = a Table-Driven Top-Down Parsers Recursive descent parsers have many attractive features. They are actual pieces of code that can be read by programmers and extended. This makes it fairly easy to understand how parsing is done. Parsing procedures are also convenient places to add code to build ASTs, or to do typechecking, or to generate code. A major drawback of recursive descent is that it is quite inconvenient to change the grammar being parsed. Any change, even a minor one, may force parsing procedures to be reprogrammed, as productions and predict sets are modified. To a less extent, recursive descent parsing is less efficient than it might be, since subprograms are called just to match a single token or to recognize a righthand se. An alternative to parsing procedures is to encode all prediction in a parsing table. A pre-programed driver program can use a parse table (and list of productions) to parse any LL(1) grammar. If a grammar is changed, the parse table and list of productions will change, but the driver need not be changed. LL(1) Parse Tables An LL(1) parse table, T, is a twodimensional array. Entries in T are production numbers or blank (error) entries. T is indexed by: A, a non-terminal. A is the nonterminal we want to expand. CT, the current token that is to be matched. T[A][CT] = A X 1...X n if CT is in Predict(A X 1...X n ) T[A][CT] = error if CT predicts no production with A as its lefthand se

5 CSX-lite Example LL(1) Parser Driver Production Predict Set 1 Prog { { 2 Stmt if 3 λ 4 Stmt = 5 Stmt if ( ) Stmt if λ ) { if ( ) = + - eof Prog Stmt Here is the driver we ll use with the LL(1) parse table. We ll also use a parse stack that remembers symbols we have yet to match. vo LLDriver(){ Push(StartSymbol) while(! stackempty()){ //Let X=Top symbol on parse stack //Let CT = current token to match if (isterminal(x)) { match(x) //CT is updated pop() //X is updated else if (T[X][CT]!= Error){ //Let T[X][CT] = X Y 1...Y m Replace X with Y 1...Y m on parse stack else SyntaxError(CT) Example of LL(1) Parsing We ll again parse { a = b + c We start by placing Prog (the start symbol) on the parse stack. Parse Stack Prog { Stmt { a = b + c { a = b + c a = b + c a = b + c Parse Stack = = a = b + c = b + c b + c b + c

6 Parse Stack Parse Stack + c + + c c c Done! All input matched

LL(1) Grammars. Example. Recursive Descent Parsers. S A a {b,d,a} A B D {b, d, a} B b { b } B λ {d, a} D d { d } D λ { a }

LL(1) Grammars. Example. Recursive Descent Parsers. S A a {b,d,a} A B D {b, d, a} B b { b } B λ {d, a} D d { d } D λ { a } LL(1) Grammars A context-free grammar whose Predict sets are always disjoint (for the same non-terminal) is said to be LL(1). LL(1) grammars are ideally suited for top-down parsing because it is always