Presentation is loading. Please wait.

Presentation is loading. Please wait.

Parsing Strategies Eric Roberts CS 106B March 6, 2013.

Published byPeter McDaniel Modified over 9 years ago

Similar presentations

Presentation on theme: "Parsing Strategies Eric Roberts CS 106B March 6, 2013."— Presentation transcript:

1 Parsing Strategies Eric Roberts CS 106B March 6, 2013

2 Contest Results The CS106B Recursion Contest March 2013

3 Recursion Contest Results First place (algorithmic):Dylan Moore, Connect Four Runner-up (algorithmic):Vineeth Gangaram, Heuristic Sudoku Runner-up (algorithmic):Harry Simon, Sudoku Generator First place (aesthetic):Matt Lathrop, Recursive Artist Grand prize (both categories):Gio Jacuzzi, Kaleidoscope Runner-up (aesthetic):Xiaolin Lin, L-Systems Runner-up (aesthetic):Jed Paul, Camouflage Creator Honorable mention:Brad Girardeau, The Game of Life Honorable mention:Christina Lee, Because Everyone Loves Sudoku Honorable mention:Thaminda Edirisooriya, Fractal Hero

4 The Problem of Parsing The rules for forming an expression can be expressed in the form of a grammar, as follows: E  constant E  identifier E  E op E E  ( E ) The process of translating an expression from a string to its internal form is called parsing.

5 A Two-Level Grammar The problem of parsing an expression can be simplified by changing the grammar to one that has two levels: –An expression is either a term or two expressions joined by an operator. –A term is either a constant, an identifier, or an expression enclosed in parentheses. This design is reflected in the following revised grammar. T  constant T  identifier E  E op E T  ( E ) E  T

6 Ambiguity in Parse Structures Although the two-level grammar from the preceding slide can recognize any expression, it is ambiguous because the same input string can generate more than one parse tree. x+2*y TTT E E x+2*y TTT E E Ambiguity in grammars is typically resolved by providing the parser with information about the precedence of the operators. The text describes two strategies: Iversonian precedence, in which the operators all group to the right, and operator precedence, in which each operator is associated with an integer that defines its place in the precedence hierarchy.

7 Exercise: Parsing an Expression Diagram the expression tree that results from the input string 2*n+1odd= IDENTIFIER odd CONSTANT 2 1 IDENTIFIER n COMPOUND * + =

8 /* * Implementation notes: readE * Usage: exp = readE(scanner, prec); * ---------------------------------- * This function reads the next expression from the scanner by * matching the input to the following ambiguous grammar: * * E -> T * E -> E op E * * This version of the method uses precedence to resolve ambiguity. */ Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } The parser.cpp Implementation

9 /* * Implementation notes: readE * Usage: exp = readE(scanner, prec); * ---------------------------------- * This function reads the next expression from the scanner by * matching the input to the following ambiguous grammar: * * E -> T * E -> E op E * * This version of the method uses precedence to resolve ambiguity. */ Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } /* * Function: readT * Usage: exp = readT(scanner); * ---------------------------- * This function reads a single term from the scanner. */ Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } The parser.cpp Implementation

10 /* * Function: readT * Usage: exp = readT(scanner); * ---------------------------- * This function reads a single term from the scanner. */ Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } /* * Function: precedence * Usage: prec = precedence(token); * -------------------------------- * This function returns the precedence of the specified operator * token. If the token is not an operator, precedence returns 0. */ int precedence(string token) { if (token == "=") return 1; if (token == "+" || token == "-") return 2; if (token == "*" || token == "/") return 3; return 0; } The parser.cpp Implementation

11 Tracing the Precedence Parser skip simulation int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); scanner.scanNumbers(); Expression *exp = readE(scanner, 0);... } scannerexp odd = 2 * n + 1 ^

12 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); scanner.scanNumbers(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 0

13 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 0 Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } scannertokenexp type odd = 2 * n + 1 ^^ odd WORD

14 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } scannertokenexp type

15 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 0 odd ID ^ = 1

16 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 1

17 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 1 Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } scannertokenexp type odd = 2 * n + 1 ^^ 2 NUMBER

18 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 1 Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } scannertokenexp type

19 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 1 2 CONST ^ 3 *

20 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 odd ID ^ = Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 3 * = Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 3

21 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 2 * odd = 2 * n + 1 0 = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 3 Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } scannertokenexp type odd = 2 * n + 1 ^^ n WORD

22 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 2 * odd = 2 * n + 1 0 = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 3 Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } scannertokenexp type

23 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd ID Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs 2 CONST 2 * odd = 2 * n + 1 0 = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 3 n ID ^ 2 +

24 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd ID Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs 2 CONST 3 odd = 2 * n + 1 0 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs n ID

25 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 1 2 CONST ^ 3 * n ID * COMP 2 +

26 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 3 * n ID * COMP 2 + Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 2

27 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 3 * n ID * COMP 2 + Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 2 Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } scannertokenexp type odd = 2 * n + 1 ^^ 1NUMBER

28 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 3 * n ID * COMP 2 + Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 2 1 CONST Expression *readT(TokenScanner & scanner) { string token = scanner.nextToken(); TokenType type = scanner.getTokenType(token); if (type == WORD) return new IdentifierExp(token); if (type == NUMBER) return new ConstantExp(stringToInteger(token)); if (token != "(") error("Illegal term in expression"); Expression *exp = readE(scanner, 0); if (scanner.nextToken() != ")") { error("Unbalanced parentheses in expression"); } return exp; } scannertokenexp type

29 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 3 * n ID * COMP 2 + Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 ^ 2 1 CONST 0

30 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 3 * n ID * COMP 2 + Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs 1 CONST

31 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 1 2 CONST ^ 2 + n ID * COMP 0 1 CONST + COMP

32 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs 2 CONST n ID * COMP 1 CONST + COMP

33 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); Expression *exp = readE(scanner, 0);... } Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd = 2 * n + 1 0 odd ID ^ = 1 2 CONST n ID * COMP 1 CONST + COMP 0 =

34 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); scanner.scanNumbers(); Expression *exp = readE(scanner, 0);... } scannerexp odd = 2 * n + 1 ^ Expression *readE(TokenScanner & scanner, int prec) { Expression *exp = readT(scanner); string token; while (true) { token = scanner.nextToken(); int tprec = precedence(token); if (tprec <= prec) break; Expression *rhs = readE(scanner, tprec); exp = new CompoundExp(token, exp, rhs); } scanner.saveToken(token); return exp; } scannerprectprectokenexprhs odd ID 2 CONST n ID * COMP 1 CONST + COMP =

35 Tracing the Precedence Parser int main() { TokenScanner scanner = new TokenScanner(); scanner.setInput("odd = 2 * n + 1"); scanner.ignoreWhitespace(); scanner.scanNumbers(); Expression *exp = readE(scanner, 0);... } odd ID 2 CONST n ID * COMP 1 CONST + COMP = scannerexp odd = 2 * n + 1 ^

36

37 Exercise: Coding a BASIC Program On the second practice midterm, one of the problems concerned the hailstone sequence. For any positive integer n, you compute the terms in the hailstone sequence by repeatedly executing the following steps: –If n is equal to 1, you’ve reached the end of the sequence and can stop. –If n is even, divide it by two. –If n is odd, multiply it by three and add one. Write a BASIC program that reads in an integer and prints out its hailstone sequence.

38 The Basic Starter Project

39 Modules in the Starter Folder Basic.cpp You write this one, but it’s short. exp.h exp.cpp You need to remove the = operator and add a few things to EvaluationContext. parser.h parser.cpp You need to remove the = operator. program.h program.cpp You’re given the interface, but need to write the private section and the implementation. statement.h statement.cpp You’re given the interface and need to supply the implementation.

40 Your Primary Tasks Figure out how the pieces of the program go together and what you need to do. 1. Code the Program class, keeping in mind what methods need to run in constant time. 2. Implement the Statement class hierarchy:3.

41 The End

Download ppt "Parsing Strategies Eric Roberts CS 106B March 6, 2013."

Similar presentations

JavaCUP JavaCUP (Construct Useful Parser) is a parser generator

JavaCUP JavaCUP (Construct Useful Parser) is a parser generator
Lesson 6 CDT301 – Compiler Theory, Spring 2011 Teacher: Linus Källberg.

Lesson 6 CDT301 – Compiler Theory, Spring 2011 Teacher: Linus Källberg.
Abstract Syntax Mooly Sagiv html://www.cs.tau.ac.il/~msagiv/courses/wcc13.html 1.

Abstract Syntax Mooly Sagiv html:// 1.
1 JavaCUP JavaCUP (Construct Useful Parser) is a parser generator Produce a parser written in java, itself is also written in Java; There are many parser.

1 JavaCUP JavaCUP (Construct Useful Parser) is a parser generator Produce a parser written in java, itself is also written in Java; There are many parser.
Translator Architecture Code Generator ParserTokenizer string of characters (source code) string of tokens abstract program string of integers (object.

Translator Architecture Code Generator ParserTokenizer string of characters (source code) string of tokens abstract program string of integers (object.
1 Conditional Statement. 2 Conditional Statements Allow different sets of instructions to be executed depending on truth or falsity of a logical condition.

1 Conditional Statement. 2 Conditional Statements Allow different sets of instructions to be executed depending on truth or falsity of a logical condition.
Exercise 1: Balanced Parentheses Show that the following balanced parentheses grammar is ambiguous (by finding two parse trees for some input sequence)

Exercise 1: Balanced Parentheses Show that the following balanced parentheses grammar is ambiguous (by finding two parse trees for some input sequence)
6/12/2015Prof. Hilfinger CS164 Lecture 111 Bottom-Up Parsing Lecture 11-12 (From slides by G. Necula & R. Bodik)

6/12/2015Prof. Hilfinger CS164 Lecture 111 Bottom-Up Parsing Lecture (From slides by G. Necula & R. Bodik)
1 Chapter 5 Compilers Source Code (with macro) Macro Processor Expanded Code Compiler or Assembler obj.

1 Chapter 5 Compilers Source Code (with macro) Macro Processor Expanded Code Compiler or Assembler obj.
Context-Free Grammars Lecture 7

Context-Free Grammars Lecture 7
Fall 2007CS 2251 Miscellaneous Topics Deque Recursion and Grammars.

Fall 2007CS 2251 Miscellaneous Topics Deque Recursion and Grammars.
Environments and Evaluation

Environments and Evaluation
CS 280 Data Structures Professor John Peterson. Lexer Project Questions? Must be in by Friday – solutions will be posted after class The next project.

CS 280 Data Structures Professor John Peterson. Lexer Project Questions? Must be in by Friday – solutions will be posted after class The next project.
CS 536 Spring 20011 Ambiguity Lecture 8. CS 536 Spring 20012 Announcement Reading Assignment –“Context-Free Grammars” (Sections 4.1, 4.2) Programming.

CS 536 Spring Ambiguity Lecture 8. CS 536 Spring Announcement Reading Assignment –“Context-Free Grammars” (Sections 4.1, 4.2) Programming.
1 Chapter 3 Context-Free Grammars and Parsing. 2 Parsing: Syntax Analysis decides which part of the incoming token stream should be grouped together.

1 Chapter 3 Context-Free Grammars and Parsing. 2 Parsing: Syntax Analysis decides which part of the incoming token stream should be grouped together.
Invitation to Computer Science 5th Edition

Invitation to Computer Science 5th Edition
2.2 A Simple Syntax-Directed Translator 1. 2 2.3 Syntax-Directed Translation 2.4 Parsing 2.5 A Translator for Simple Expressions 2.6 Lexical Analysis.

2.2 A Simple Syntax-Directed Translator Syntax-Directed Translation 2.4 Parsing 2.5 A Translator for Simple Expressions 2.6 Lexical Analysis.
CPSC 388 – Compiler Design and Construction Parsers – Context Free Grammars.

CPSC 388 – Compiler Design and Construction Parsers – Context Free Grammars.
Syntax Analysis (Chapter 4) 1 Course Overview PART I: overview material 1Introduction 2Language processors (tombstone diagrams, bootstrapping) 3Architecture.

Syntax Analysis (Chapter 4) 1 Course Overview PART I: overview material 1Introduction 2Language processors (tombstone diagrams, bootstrapping) 3Architecture.
LEX and YACC work as a team

LEX and YACC work as a team

Similar presentations

Ads by Google