Section notes: Week 9

CS 164, Fall 2005

General

• HW due this week: Add assignment (=) to the typechecker from last time
• Questions about assignment 5?
• Questions in general?

Warm-up

In C-style array initializers, commas can serve to separate items or to end items; for example, I could write

    int foo[3] = {0,1,2};
    int bar[3] = {0,1,2,};
  

• Can you write a grammar for initializer lists for integer arrays? Your grammar should be LALR(1), and should allow both forms of the array initializer (with or without the final comma).
• When would you check the arrays to make sure that the initializer was the right size? And what constitutes the right size?

MJ data structures

(defstruct mj-env
  stdout   ; standard output stream
  stderr   ; error output stream
  parents  ; class-name -> parent class-name assoc
  classes  ; class-name -> class layout hash
  methods  ; (class-name . method-name) -> method info hash
  stack)   ; Run-time stack

(defstruct mj-method
  class       ; Name of this class (for setting 'this' type)
  name        ; Method name
  formals     ; Formal parameter list (as an (id . type) assoc list)
  layout      ; Stack frame layout
  code        ; Statement list
  type        ; Return value type
  value)      ; Return value expression

;; Variable layouts are hash tables with
;;   *count* -> current number of variables
;;   name    -> stack of (index . type) pairs

• I want to rewrite my AST so that variable references result in nodes like (LocalVar i) or (ClassVar i). How should I do it?
• It's sometimes convenient to perform a computation for each variable in a stack frame or in a class. I define a function map-visible-vars which does this. What do you think this function looks like?
• It's awkward to use a field *count* in a variable layout table in order to refer to the number of variables seen so far. Could I do this differently? How?
• Appel advocates using the Visitor pattern to write passes that walk over the AST. Does this help you in Common Lisp? How might you implement this pattern? (A cultural aside: the Visitor pattern provides a mechanism for multiple dispatch, which is supported directly in Common Lisp using defgeneric. Many patterns are not equally applicable in all languages.)

Dynamic dispatch: take 2

class Week9 {
    public static void main(String[] a) {
         System.out.println(new Counter().Init(1).Next());
    }
}

class Counter {
    int count;
    public Counter Init(int c) { count = c; return this; }
    public int     Next()      { count = count + 1; return count; }
}

;; === Translated from ../notes/week9 ===
(unless (boundp '*mj-stdout*) (setf *mj-stdout* t))

;; Counter::Init
(DEFUN |mjl-Counter-Init| (THIS L1) (LET () (SETF (ELT THIS 1) L1) THIS))

;; Counter::Next
(DEFUN |mjl-Counter-Next| (THIS)
  (LET () (SETF (ELT THIS 1) (+ (ELT THIS 1) 1)) (ELT THIS 1)))

;; Vtable for Counter
(SETF |mjl-Counter| (MAKE-HASH-TABLE))
(SETF (GETHASH '|Next| |mjl-Counter|) #'|mjl-Counter-Next|)
(SETF (GETHASH '|Init| |mjl-Counter|) #'|mjl-Counter-Init|)

;; Constructor for Counter
(DEFUN |mjl-Counter+| ()
  (LET ((OBJ (MAKE-ARRAY '(2))))
    (SETF (ELT OBJ 0) |mjl-Counter|)
    (SETF (ELT OBJ 1) 0)
    OBJ))

;; Main routine
(FORMAT *MJ-STDOUT*
        "~A~%"
        (LET* ((OBJ
                (LET* ((OBJ (|mjl-Counter+|)) (VTABLE (ELT OBJ 0)))
                  (FUNCALL (GETHASH '|Init| VTABLE) OBJ 1)))
               (VTABLE (ELT OBJ 0)))
          (FUNCALL (GETHASH '|Next| VTABLE) OBJ)))