anchor.diff:  (defun glsl-element (element)
     (cond
       ((null element) nil)
  -    ((listp element) (glsl-operator (first element) (rest element)))
  +    ((listp element) (glsl-line (first element) (rest element)))
       ((symbolp element) (glsl-name element))
       (t element)))
   
  -(defun binary-op (symbol-string first-elt rest-elt)
  -  (let ((control-string (format nil "(~~A~~{ ~A ~~A~~})" symbol-string)))
  +(defun binary-op (symbol first-elt rest-elt)
  +  (let ((control-string (format nil "(~~A~~{ ~A ~~A~~})" (case symbol
  +                                                           ((:and) "&&")
  +                                                           ((:or) "||")
  +                                                           (otherwise symbol)))))
       (format nil control-string first-elt rest-elt)))
   
   (defun unary-op (symbol-string first-elt)
  
positive.code:             (glsl-name name)
              (if first-arg (glsl-function-argument first-arg))
              (if rest-args (mapcar #'glsl-function-argument rest-args))
              (mapcar #'glsl-line body))))
  
  ;;; This line is used to define a GLSL variable of a type and name. If
  ;;; a location integer is given then the proper syntax is provided for
  
negative.code:           (glsl-name type)
            (glsl-name name)))
  
  ;;; FIXME: *Now* this name doesn't make sense.
  (defun glsl-line (symbol l)
    (let ((first-elt (first l))
          (rest-elt (rest l)))
      (case symbol
        ((:defun) (glsl-function (elt l 0) (elt l 1) (elt l 2) (nthcdr 3 l)))
        ((:defvar) (glsl-var first-elt (first rest-elt)
                             :storage (getf (rest rest-elt) :storage)
                             :location (getf (rest rest-elt) :location)))
        (otherwise (let ((first-elt (glsl-element first-elt))
                         (rest-elt (mapcar #'glsl-element rest-elt)))
                     (case symbol
                       ((:version) (format nil "#version ~D~%~%" first-elt))
                       ((:setf) (format nil "~A = ~A;~%" first-elt (first rest-elt)))
                       ((:+ :* :/ :> :< :>= :<= :and :or) (binary-op symbol first-elt rest-elt))
                       ((:not) (unary-op "!" first-elt))
                       ((:-) (if (= (length rest-elt) 0)
                                 (unary-op symbol first-elt)
                                 (binary-op symbol first-elt rest-elt)))
                       (otherwise (format nil "~A(~@[~A~]~{, ~A~})" (glsl-name symbol) first-elt rest-elt))))))))
  
  ;;; Use this to make a shaders string from a list of lists.
  (defun make-glsl-shader (l)
    (format nil "~{~A~}" (mapcar #'(lambda (l) (glsl-line (first l) (rest l))) (cons '(:version 330) l))))
  
  (defclass shader ()
    ((source
  