See homework: Scanner

• Basic definitions of NFAs and DFAs. (Text, Section 2.6.)
• Algorithm to convert an NFA into a DFA accepting the same language. (Text, pp. 117-121.)
• Epsilon-moves and the closuer operator. (Text, Section 3.6.)
• Regular expressions. (Text, pp. 94-96.)
• Conversion of an arbitrary regular expressions to an NFA with epsilon moves. (Text, pp. 121-125.)
• Conversion of an arbitrary regular expressions to a NFA that is non-returning and has no epsilon moves. (Class notes.)
• Conversion of an NFA (possible with epsilon moves) to a regular expression. (Class notes.)

See homework: Automata Homework.

• Basic definitions of formal grammars, with quite a bit of notation. (Text, Section 4.2.)
• Parse trees, derivations, etc. (Text, pp. 169-171.)
• Ambiguity, with simple examples and the example of an if-then with optional else. (Text, p. 171, pp. 173-175.)
• Regular languages: described by NFAs, DFAs, regular expressions. These are just a simple subset of languages described by context-free grammars. (Text, pp. 172-173.)

See homework: Grammar Homework.

• Overview of parsing and of the parsing problem.
• Bottom-up parsing in general, and shift-reduce parsers in particular. Construct a rightmost derivation backwards starting with the input sentence of terminals. Use an auxiliary stack, onto which terminals are shifted, and on top of which right sides of grammar rules are reduced to the left sides. (Text, pp. 195-203.)
• Top-down parsing. May need to rewrite the grammar, in particular, to eliminate left recursion. There is a table-driven form, but we emphasized recursive descent. (Text, Section 2.4, Section 4.4 (each with much more than what we covered).)
• Various examples of recursive descent parsers for simple languages, including especially arithmetic expressions. In particular, start with the following grammar:

  P ---> E '#'
  E ---> T {('+'|'-') T}
  T ---> S {('*'|'/') S}
  S ---> F '^' S | F
  F ---> '(' E ')' | char
  

  Here is a recursive descent parser for this language, showing a run:
     .c, .txt, .html, .ps, .pdf.
     .java, .txt

See homework: Recursive-descent parser.

Here are some example programs:

Translator of arithmetic expressions to RPN:
   .c, .txt, .html, .ps, .pdf.
   .java, .txt, .ps, .pdf.

Here is another example of semantic actions: an evaluator of arithmetic expressions, producing a double:
   .c .txt, .html, .ps, .pdf.

See homework: Translating Assignments.

This is the method used in this course. We discussed this from a theoretical point of view, based on the parse tree. One attaches attributes (values) to each node of the tree. Then the issue is how the attribute values are defined.

Synthesized attributes get their values from nodes below the given node in the parse tree. Thus in the terms of a recursive descent parser, these attributes come as values returned by functions called during the parse. These synthesized attributes are the most common ones and are the ones we emphasized.

Inherited attributes are more complicated, and don't just come from the children of a given node, but come from the parent as well. In a recursive descent parser, one would pass a parameter from the parent to the child to help give a value to an inherited attribute. (Text, pp. 279-287.)

See homework: while, if, relational, logical.

• Memory use at run time (code, static data, stack-allocated data, heap-allocated data). (Text, p. 297.)
• Storage in old-fashioned Fortran, where all storage was static. (Text, pp. 401-402.)
• Activation records for function calls and stack allocation. (Text, pp. 398-399, pp. 404-409.)
• Levels of allocation in block-structured languages, including especially Pascal. The use of a stack of symbol tables at compile time. (Class notes.)
• The problem of dangling references. (Text, p. 409.)
• Heap allocation, using explicit calls, such as malloc and free in C, or new and delete in C++. (See The C Programming Language by Kernighan and Ritchie, pp. 185-188, for a discussion of a simple malloc implementation that we discussed in class.)
• Heap allocation, using garbage collection as in Java. The mark-sweep algorithm. Reference counts to avoid dangling references (that can cause run time crashes). (Class notes.)

See homework: Functions.

We covered the so-called W-grammars or 2-level grammars. This material was pretty hard, so I guess I'll leave it off the final.

• Use of LR action and goto tables to carry out a shift-reduce parse, pushing alternating symbols and state numbers on the stack. (Text, pp. 215-221.)
• LR(0) items, with the sets-of-items consturction, and the closure and goto functions. Construction of the parsing DFA, and its use to carry out simple parses. (Text, pp. 221-228.)
• LR(1) items, with a new similar sets-of-items construction, and similar closure and goto functions. (Text, pp. 230-232.)
• A specific example, showing a 10 state LR(1) parser and a 7-state LR(0) parser for the same language. (Text, pp. 233-236.)