CS 3723 -- Review for Mid-Term Exam

CS 3723 Programming Languages
Spring 2002 -- Review for Mid-Term Exam
Exam is Wednesday, 20 March 2002

Topics:

The Quadruple Machine:
- Target language for a simple compiler.
- Details of the machine. Quadruple machine.
- An interpreter for quadruples (Project 0). Project 0.
Finite Automata (DFAs and NFAs):
- The definition of NFA and DFA.
- The language accepted by (or recognized by) an FA.
- Simple examples.
- The algorithm to convert an NFA to a DFA that recognizes the same language. (We stated without proof that there is always a unique DFA with a minimal number of states that recognizes the language recognized by any FA.)
- Homework.
Scanners and the Use of Automata:
- Constructing a scanner based on a DFA (using either gotos or a while loop and select based on a state variable).
- Practical examples, including the DFA for the "course" language, and the construction of an actual scanner (Project I).
Formal Grammars and Languages:
- Definition of formal grammar (start symbol, terminal symbols, non-terminal symbols, grammar rules). (Also called a context-free grammar or a BNF grammar.)
- Derivation sequences (leftmost and rightmost).
- Language accepted by (or recognized by) a formal grammar.
- Parse trees. (Each derivation sequence determines a unique parse tree, but a parse tree might have many derivations.)
- Ambiguity. (Definition: There is a sentence with more than one parse tree, or with more than one leftmost derivation, or with more than one rightmost derivation.)
  - Ambiguity is bad.
  - Remove ambiguity by either:
    - rewriting the grammar, such as changing
```
   E  ---->  E + E       (AMBIGUOUS)
   E  ---->  E * E
   E  ---->  ( E )
   E  ---->  id
```
      to
```
   E  ---->  E + T       (NOT AMBIGUOUS)
   E  ---->  T
   T  ---->  T * F
   T  ---->  F
   F  ---->  ( E )
   F  ---->  id
```
    - introducing special rules, such as
      - Precedence of one operator over another. (Present with + and * in the first example above.)
      - Associativity of an operator (left-to right or right-to-left). (Present with both + and * in the first example above.)
      - Rule that an else matches then nearest unmatched if. (Present in the following example:
        stmt ----> "if" "(" expr ")" stat (AMBIGUOUS) stmt ----> "if" "(" expr ")" stat "else" stat
Parsers and the Use of Grammars:
- Recursive Descent Parsers:
  - Top-down parser, starts with the start symbol and works down toward the given sentence (string of terminal symbols), constructing a leftmost derivation).
  - Must rewrite grammar to avoid left recursion. (There are other possible problems also, beyond the scope of this course.) The simple grammar above would be rewritten:
```
   E  ---->  T { "+" T }          ({} means "zero of more times")
   T  ---->  F { "*" F }          (terminals are in quotes or id)
   F  ---->  "(" E ")"
   F  ---->  id
```
  - Write a function corresponding to each non-terminal symbol in the grammar. The code of the function mirrors the right side of the rule.
  - Examples for simple arithmetic expressions, for Lisp S-expressions, and eventually for the language of the course (due later as Project II).
- Simple Shift-Reduce Parsers:
  - A simple version of the methods in the text. The text's methods don't require the grammar to be rewritten as often as recursive descent does.
  - Carries out the parse working backwards from an initial sentence to the start symbol. Constructs a rightmost derivation backwards.
  - Uses a stack for symbols. Input symbols are always (eventually) shifted onto the stack, but in some circumstances a string of one or more symbols (mixed terminals or non-terminals) might be "reduced", that is, matched with the right side of a grammar rule that is used for backwards replacement on the stack by the single non-terminal on the left side of the rule.
  - Whether to shift or reduce is controlled by a table which says what to do based on the symbol on the top of the stack and on the "current" symbol. (The text's methods are similar but more complicated.)
  - See the review exercise below to help understand this material.
Use of Parsers to Carry Out Translation or Other Tasks:
- Add extra code (semantic actions) to the parser, either
  - In with the code of the functions representing each non-terminal in recursive descent.
  - Code attached to each grammar rule in shift-reduce. The code is executed each time a rule is used in a reduction.
- A number of examples based on recursive descent parser of arithmetic expressions or of Lisp S-expressions:
  - Translate to RPN (in C), C source.
    Translate to RPN (in Java) Java source.
  - Evaluator for arithmetic expressions. C source for evaluator.
  - Translate ordinary arithmetic expressions to prefix form (as in Lisp) Text with run, or to fully parenthesized form.
- We talked a little about how one would carry out the same translations using shift-reduce parsers.
Other topics:
- Comiler overview.
- Contrasts:
  - syntax versus semantics,
  - run-time versus compile-time,
  - translation versus interpretation.

Review Exercises.

Shift-Reduce Parsers:


        S ---> b M b              ("S" is the start symbol)
        M ---> ( L
        M ---> a
        L ---> M a )


           |  b  |  a  |  (  |  )  |  $   |
      -----+-----+-----+-----+-----+------+
        S  |     |     |     |     |  acc |     ( "s" means "shift")
        M  |  s  |  s  |     |     |      |
        L  |  r  |  r  |     |     |      |     ( "r" means "reduce")
        b  |     |  s  |  s  |     |  r   |
        a  |  r  |  r  |     |  s  |      |     ( "acc" means "accept")
        (  |  s  |  s  |  s  |     |      |
        )  |  r  |  r  |     |     |      |

Carry out the shift-reduce parse of the following sentence, showing the stack, current symbol, remaining symbols, and next action to take at each stage. (This sentence has the extra artifical symbol $ stuck in at the beginning and the end.)
```
     $ b ( ( a a ) a ) b $
```
(Remember that you should initially shift the starting $ and then shift the next symbol.)
Give the resulting parse tree.

Recursive Descent Parser and Translator:
1. Adapt the parser for arithmetic expressions handed out in class to this slightly larger language, so that you can parse the input above.
  (Here is the original parser: In C, In Java.
  Here is the same original parser with extra debug output: In C, In Java.)
  Consider the following simplified symbolic form of quadruples:
  - Operators are just single characters: '=' for ASG, '+' for ADD, '-' for SUB, '*' for MUL, '/' for DIV, and '#' for LIT. along with the new operator '^'.
  - Constant operands are just single digits.
  - Variable operands are just single lower-case characters.
  - Temporary variable operands are just single upper-case characters, taken in sequence, 'A', 'B', 'C', etc.
  With these conventions, the sample program above becomes the following as a sequence of symbolic quadruples.
```
     (#,4, ,A)
     (=,A, ,a)
     (#,3, ,B)
     (+,B,a,C)
     (#,6, ,D)
     (*,C,D,E)
     (=,E, ,b)
     (#,2, ,F)
     (^,a,F,G)
     (#,2, ,H)
     (^,b,H,I)
     (+,G,I,J)
     (=,J, ,c)
```
2. By hand, translate the following input to this special form, following the pattern above:
```
     x = 12;
     y = 13;
     z = x^2 + y^2;
     $
```

Revision date: 2001-10-18. (Please use ISO 8601, the International Standard.)

CS 3723 Programming Languages Spring 2002 -- Review for Mid-Term Exam Exam is Wednesday, 20 March 2002

CS 3723 Programming Languages
Spring 2002 -- Review for Mid-Term Exam
Exam is Wednesday, 20 March 2002