anchor.diff:                           (mixedcaps->lcdash i))))
       (format out "))~%~%"))
   
  +  ;; print out changes
  +  (let ((new-bindings (load-bindings gl-dir))
  +        (new-enums (load-enums gl-dir)))
  +    (flet ((eb (x)
  +             (ecase (first x)
  +               (defbitfield "bitfield")
  +               (defcenum "enum"))))
  +      ;; todo: check for changed types of enums/bitfields? (should
  +      ;; only be :unsigned-int currently, so not bothering for no)
  +      (format t "checking for removed enums/bitfields:~%")
  +      (loop for k being the hash-keys of old-enums using (hash-value v)
  +            unless (gethash k new-enums)
  +              do (format t "removed ~a ~s~%" (eb v) k))
  +      (format t "checking for new or modified enums/bitfields:~%")
  +      (loop for k1 being the hash-keys of new-enums using (hash-value new-form)
  +            for old-form = (gethash k1 old-enums nil)
  +            for k = (if (consp k1) (car k1) k)
  +            do (cond
  +                 ((not old-form)
  +                  (format t "new ~a ~s~%" (eb new-form) k))
  +                 ((not (eql (car new-form) (car old-form)))
  +                  (format t "~a ~s changed to ~a~%"
  +                          (eb old-form) k (eb new-form)))
  +                 ((not (equal new-form old-form))
  +                  (let ((removed (set-difference
  +                                  (mapcar 'first (cddr old-form))
  +                                  (mapcar 'first (cddr new-form)))))
  +                    (loop for i in removed
  +                          do (format t "~a ~s: removed ~s~%"
  +                                     (eb new-form) k i)))
  +                  (loop with h = (alexandria:alist-hash-table (cddr old-form))
  +                        for (name value) in (cddr new-form)
  +                        for (old-value) = (gethash name h)
  +                        when (not old-value)
  +                          do  (format t "~a ~s: added ~s = #x~x~%"
  +                                     (eb new-form) k name value)
  +                        else when (/= value old-value)
  +                        do  (format t "~a ~s: ~s value changed from #x~x to #x~x~%"
  +                                     (eb new-form) k name old-value value))))))
  +
  +    (format t "checking for removed bindings:~%")
  +    (loop for k being the hash-keys of old-bindings
  +          unless (gethash k new-bindings)
  +            do (format t "removed binding ~s~%" k))
  +    (format t "checking for new or modified bindings:~%")
  +    (loop for k being the hash-keys of new-bindings using (hash-value v)
  +          for (new-file new-form) = v
  +          for (old-file old-form) = (gethash k old-bindings nil)
  +          do (cond
  +               ((not old-file)
  +                (format t "+~a ~{~s -> ~s~}~%" new-file (second new-form)))
  +               ((not (equal new-file old-file))
  +                (format t "binding ~s moves from ~s to ~s~%"
  +                        k old-file new-file))
  +               ((not (equal new-form old-form))
  +                ;; todo: ignore changes in names of args
  +                (format t "definition of binding ~s changed:~%from: ~s~%to:   ~s~%" k old-form new-form))))
  +
  +
  +
  +)
  +
     (force-output)
     nil)
  
positive.code:           when (and (consp i) (member (car i) '(defctype defcstruct)))
              collect (second i))))
  
  (defparameter *base-types*
    '(("int"            . ":int")
      ("unsigned int"   . ":unsigned-int")
  
negative.code:        (bitfields  (make-hash-table :test 'equal))
         (enums (make-hash-table :test 'equal))
         (funcs (make-hash-table :test 'equal))
         (function-apis (make-hash-table :test 'equal))
         (old-bindings (load-bindings gl-dir))
         (old-enums (load-enums gl-dir)))
  
    ;; remove some other text from the comment if present
    (let ((s (search "This file, gl.xml, is the OpenGL and OpenGL API Registry."
  