1 / 22

Compiler Design Midterm Solutions - Data Types, Symbol Tables, and Interpretation

Explore in-depth solutions to midterms questions on symbol tables, data types, loops, error handling, and more in compiler design. Gain insights into back-end processes and the importance of runtime displays.

betsye
Download Presentation

Compiler Design Midterm Solutions - Data Types, Symbol Tables, and Interpretation

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CMPE 152: Compiler DesignOctober 15 Class Meeting Department of Computer EngineeringSan Jose State UniversityFall 2019Instructor: Ron Mak www.cs.sjsu.edu/~mak

  2. Midterm Solution: Question #1 • How does data type information get entered into the symbol table? • The symbol table entry of each identifier has a pointer to the type specification object of its type. If the type is named, the type specification object is created when the name of the type is entered into the symbol table. If the type is unnamed, the type specification object is created when the variable that has that type is entered into the symbol table.

  3. Midterm Solution: Question #2 • You created a new built-in datatype for Pascal++ that will be used by a deeply nested level 4 function. Where is the information about this new datatype kept? • Since it’s a built-in type, the information about the new datatype will be kept in the global symbol table. The information can then be used by any function, no matter how deeply nested.

  4. Midterm Solution: Question #3 • Why is it important for the symbol table entry of the name of a function maintain a pointer to the function's symbol table and parse tree? • The back end uses only parse trees and symbol tables. It accesses them via the symbol table entries of the function’s name. The symbol table entry has pointers to the function’s symbol table and parse tree.

  5. Midterm Solution: Question #4 • When you implemented the new LOOP AGAIN statement, what changes if any did you need to make to the StatementParser class and why? • The parse() method needs to have new cases for the LOOP and WHEN reserved words in order to create the parsers for those statements.

  6. Midterm Solution: Question #5 • Explain how the interpreter's executor in the back end handles syntax and type errors. • The back end never sees syntax and type errors, since they are caught and handled in the front end by the parser. If there were any errors caught by the front end, the back end is not invoked.

  7. Midterm Solution: Question #6 • Briefly explain how the runtime display helps runtime performance in general. For what kinds of Pascal programs will having the runtime display hurt performance? • The nth of the runtime display points to the topmost nth-level activation record on the runtime stack. This improves the performance of accessing the values of nonlocal variables when executing the statements of a function. • There is extra work to maintain the runtime display and the back links of the activation records. If there are many function calls and returns and few statements are executed within each function, then the cost of maintaining the runtime display and the back links will exceed the performance improvement.

  8. Midterm Solution: Question #7 • How does an interpreter’s executor know what variables to include in each activation record that it pushes onto the stack? • Whenever a function is called, the executor looks in the function’s symbol table to see what memory cells it needs to create for the function’s parameters and local variables.

  9. Midterm Solution: Question #8 • Describe the steps required to make time a new built-in Pascal datatype. • Create an entry for the identifier time in the global symbol table. • Designate the symbol table entry as the name of a datatype. • Create a type specification object for a record type. • Create a symbol table for the record type and link the type specification object to it. • Create an entry for the identifier “hour” in the record’s symbol table. • Designate the symbol table entry as the name of a field. • Create a type specification object for a subrange type and set its base type to the predefined integer type, its minimum value to 0, and its maximum value to 23. • Link the hour symbol table entry to this subrange type specification object. • Repeat the previous three steps for each of the identifiers “minute” and “second”. These two can share a subrange type specification object for an integer subrange 0 through 59. • Create the crosslinks between the time symbol table entry and the record type specification object.

  10. Minimum Acceptable Compiler Project • At least two data types with type checking. • Basic arithmetic operations with operator precedence. • Assignment statements. • At least one conditional control statement (e.g., IF). • At least one looping control statement. • Procedures or functions with calls and returns. • Parameters passed by value or by reference. • Basic error recovery (skip to semicolon or end of line). • “Nontrivial” sample programs written in the source language. • Generate Jasmin code that can be assembled. • Execute the resulting .class file standalone (preferred) or with a test harness. • No crashes (e.g., null pointer exceptions). 70 points/100

  11. Ideas for Programming Languages • A language that works with a database such as MySQL • Combines Pascal and SQL for writing database applications. • Compiled code hides JDBC calls from the programmer. • Not PL/SQL – use the language to write client programs. • A language that can access web pages • Statements that “scrape” pages to extract information. • A language for generating business reports • A Pascal-like language with features that make it easy to generate reports. • A string-processing language • Combines Pascal and Perl for writing applications that involve pattern matching and string transformations. DSL = Domain-Specific Language

  12. Can We Build a Better Scanner? • Our scanner in the front end is relatively easy to understand and follow. • Separate scanner classes for each token type. • However, it’s big and slow. • Separate scanner classes for each token type. • Creates lots of objects and makes lots of method calls. • We can write a more compact and faster scanner. • However, it may be harder to understand and follow.

  13. letter letter [other] 1 2 3 digit Deterministic Finite Automata (DFA) • Pascal identifier • Regular expression: <letter> ( <letter> | <digit> )* • Implement the regular expression with a finite automaton (AKA finite state machine):

  14. letter letter [other] 1 2 3 digit Deterministic Finite Automata (DFA) • This automaton is a deterministic finite automaton (DFA). • At each state, the next input characteruniquely determines which transition to take to the next state. accepting state start state transition

  15. letter letter [other] 1 2 3 digit State-Transition Matrix • Represent the behavior of a DFA by a state-transition matrix:

  16. E digit 12 5 8 digit digit digit . + + [other] digit digit digit E 0 4 6 7 9 10 11 3 - - [other] [other] digit DFA for a Pascal Number Note that this diagram allows only an upper-case E for an exponent. What changes are required to also allow a lower-case e?

  17. letter [other] letter 0 1 digit - digit + E digit digit digit digit . + [other] digit digit E 4 6 7 9 10 11 3 8 2 5 12 - digit [other] [other] DFA for a Pascal Identifier or Number constintSimpleDFAScanner::matrix[13][7] = {     /*        letterdigit   +    -    .    E other */     /*  0 */ {   1,    4,    3,   3, ERR,   1, ERR },     /*  1 */ {   1,    1,   -2,  -2,  -2,   1,  -2 },     /*  2 */ { ERR,  ERR,  ERR, ERR, ERR, ERR, ERR },     /*  3 */ { ERR,    4,  ERR, ERR, ERR, ERR, ERR },     /*  4 */ {  -5,    4,   -5,  -5,   6,   9,  -5 },     /*  5 */ { ERR,  ERR,  ERR, ERR, ERR, ERR, ERR },     /*  6 */ { ERR,    7,  ERR, ERR, ERR, ERR, ERR },     /*  7 */ {  -8,    7,   -8,  -8,  -8,   9,  -8 },     /*  8 */ { ERR,  ERR,  ERR, ERR, ERR, ERR, ERR },     /*  9 */ { ERR,   11,   10,  10, ERR, ERR, ERR },     /* 10 */ { ERR,   11,  ERR, ERR, ERR, ERR, ERR },     /* 11 */ { -12,   11,  -12, -12, -12, -12, -12 },     /* 12 */ { ERR,  ERR,  ERR, ERR, ERR, ERR, ERR }, }; Negative numbers in the matrix are the accepting states. Notice how the letter E is handled!

  18. A Simple DFA Scanner class SimpleDFAScanner { public: SimpleDFAScanner(string source_path);     virtual ~SimpleDFAScanner();     /**      * Scan the source file.      */     void scan() throw(string); private:     // Input characters.     static constint LETTER = 0;     static constint DIGIT  = 1;     static constint PLUS   = 2;     static constint MINUS  = 3;     static constint DOT    = 4;     static constint E      = 5;     static constint OTHER  = 6;     // Error state.     static constint ERR = -99999;

  19. A Simple DFA Scanner, cont’d     // State-transition matrix (acceptance states < 0)     static constintmatrix[13][7];     char ch;    // current input character int state;  // current state ifstream reader;     string line; intline_number; intline_pos;

  20. A Simple DFA Scanner, cont’d int SimpleDFAScanner::type_of(char ch) {     return   (ch == 'E')  ? E            : isalpha(ch)  ? LETTER            : isdigit(ch)  ? DIGIT            : (ch == '+')  ? PLUS            : (ch == '-')  ? MINUS            : (ch == '.')  ? DOT            :                OTHER; }

  21. A Simple DFA Scanner, cont’d string SimpleDFAScanner::next_token() throw(string) {     // Skip blanks.     while (isspace(ch)) next_char();     // At EOF?     if (reader.fail()) return "";     state = 0;  // start state     string buffer;     // Loop to do state transitions.     while (state >= 0)  // not acceptance state     { state = matrix[state][type_of(ch)];  // transition         if ((state >= 0) || (state == ERR))         {             buffer += ch;  // build token string next_char();         }     }     return buffer; } This is the heart of the scanner. Table-driven scanners can be very fast!

  22. A Simple DFA Scanner, cont’d void SimpleDFAScanner::scan() throw(string) {     next_char();     while (ch != 0)  // EOF?     {         string token = next_token();         if (token != "")         {             cout << "=====> \"" << token << "\" ";             string token_type = (state ==  -2) ? "IDENTIFIER"                 : (state ==  -5) ? "INTEGER"                 : (state ==  -8) ? "REAL (fraction only)"                 : (state == -12) ? "REAL"                 :                  "*** ERROR ***";             cout << token_type << endl;         }     } } How do we know which token we just got? Demo

More Related