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 type)
            (glsl-name name)))
  
  ;;; Either something is a C/C++ style operator or it is actually a
  ;;; function call. If it is a C/C++ style operator then it's either a
  ;;; binary one that can be applied arbitrarily or a unary one that can
  ;;; only take one argument.
  (defun glsl-operator (symbol l)
    (let ((first-elt (glsl-element (first l)))
          (rest-elt (mapcar #'glsl-element (rest l))))
      (case symbol
        ((:+) (binary-op "+" first-elt rest-elt))
        ((:*) (binary-op "*" first-elt rest-elt))
        ((:/) (binary-op "/" first-elt rest-elt))
        ((:>) (binary-op ">" first-elt rest-elt))
        ((:<) (binary-op "<" first-elt rest-elt))
        ((:>=) (binary-op ">=" first-elt rest-elt))
        ((:<=) (binary-op "<=" first-elt rest-elt))
        ((:and) (binary-op "&&" first-elt rest-elt))
        ((:or) (binary-op "||" first-elt rest-elt))
        ((:not) (unary-op "!" first-elt))
        ((:-) (if (= (length rest-elt) 0)
                  (unary-op "-" first-elt)
                  (binary-op "-" first-elt rest-elt)))
        ;; Call function SYMBOL with optional first parameter and
        ;; optional later parameters.
        (otherwise (format nil "~A(~@[~A~]~{, ~A~})" (glsl-name symbol) first-elt rest-elt)))))
  
  ;;; The s-expressions are a one-line-operation, a function, or an
  ;;; in-line operation or function call.
  (defun glsl-line (l)
    (let ((symbol (elt l 0)))
      (case symbol
        ((:version) (format nil "#version ~D~%~%" (elt l 1)))
        ((:defvar) (glsl-var (elt l 1) (elt l 2)
                             :storage (getf (nthcdr 3 l) :storage)
                             :location (getf (nthcdr 3 l) :location)))
        ((:setf) (format nil "~A = ~A;~%" (glsl-name (elt l 1)) (glsl-element (elt l 2))))
        ((:defun) (glsl-function (elt l 1) (elt l 2) (elt l 3) (nthcdr 4 l)))
        (otherwise (glsl-operator symbol (rest l))))))
  
  ;;; Use this to make a shaders string from a list of lists.
  (defun make-glsl-shader (l)
    (format nil "~{~A~}" (mapcar #'glsl-line (cons '(:version 330) l))))
  
  (defclass shader ()
    ((source
  
negative.code:             (glsl-name name)
              (if first-arg (glsl-function-argument first-arg))
              (if rest-args (mapcar #'glsl-function-argument rest-args))
              (mapcar #'(lambda (l) (glsl-line (first l) (rest l))) 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
  