   (cond
    (or (nil? exp)
        (and (coll? exp) (empty? exp)))
-   `((VM_IVAL ~(make-nil)))
+   `((:VM_IVAL ~(make-nil)))
    ;;
    (or (= 't exp) (= 't exp))
-   `((VM_IVAL ~(make-t)))
+   `((:VM_IVAL ~(make-t)))
    ;;
    (symbol? exp)
-   `((VM_VREF ~(make-sym exp)))
+   `((:VM_VREF ~(make-sym exp)))
    ;;
    (number? exp)
-   `((VM_IVAL ~(make-num exp)))
+   `((:VM_IVAL ~(make-num exp)))
    ;;
    (coll? exp)
    (match exp
 	  ('quote x)	(compile-quote x)
 	  ;;
 	  ('progn & body)	(if (empty? body)
-			    `((VM_IVAL ~(make-nil)))
+			    `((:VM_IVAL ~(make-nil)))
 			    (apply concat (map compile-pass1 body)))
 	  ;;
 	  ('let bindings & body)	(compile-let bindings body)
 	  ;;
 	  ('setq sym val)	`(~@(compile-pass1 val)
-				  (VM_VSET ~(make-sym sym)))
+				  (:VM_VSET ~(make-sym sym)))
 	  ;;
 	  ('if pred then-body else-body)
 	  (let [end-label (gensym),
 		else-label (gensym)]
 	    `(~@(compile-pass1 pred)
-	       (VM_BIFN ~else-label)
+	       (:VM_BIFN ~else-label)
 	       ~@(compile-pass1 then-body)
-	       (VM_JMP ~end-label)
+	       (:VM_JMP ~end-label)
 	       ~else-label
 	       ~@(compile-pass1 else-body)
 	       ~end-label))

(defn pp-program [insts]
  (dotimes [i (count insts)]
    (let [inst (nth insts i),
	  inst-name (unqualify-symbol (first inst))
	  inst-spec (some (fn [spec] (and (= inst-name (first spec)) spec))
			  *vm-inst-list*)
	  inst-operand (second inst)

   (or (and (coll? exp)
	    (empty? exp))
       (= 'nil exp))
   `((:VM_IVAL ~(make-nil)))
   ;;
   (or (= 't exp) (= 'T exp))		`((:VM_IVAL ~(make-t)))
   (symbol? exp)			`((:VM_IVAL ~(make-sym exp)))
   (number? exp)			`((:VM_IVAL ~(make-num exp)))
   (coll? exp)				`(~@(compile-quote (first exp))
					  (:VM_PUSH)
					  ~@(compile-quote (rest exp))
					  (:VM_CONS))
   ))

(defn compile-let [bindings body]
  `(~@(apply concat
       (map (fn [binding]
	      `(~@(compile-pass1 (second binding))
		(:VM_BIND ~(make-sym (first binding)))))
	    bindings))
    ~@(apply concat
	     (map compile-pass1 body))
    (:VM_UNBIND ~(count bindings))))

(defn builtin-fun-id [fname]
  (index (fn [pair] (= (first pair) fname))
	 *vm-builtin-funs*))

(defn compile-funcall [fname args]
  `((:VM_PUSH_FRAME)
    ~@(apply concat
       (map (fn [arg] (concat (compile-pass1 arg)
			      `((:VM_PUSH))))
	    (reverse args)))
    (:VM_FUNCALL ~(if (some (fn [fun-spec] (= (first fun-spec) fname))
			   *vm-builtin-funs*)
		   (make-num (builtin-fun-id fname))
		   (make-sym fname)))))
