anchor.diff:  (defun query-enum-values (type)
     (%query-enum-or-flags-values #'%enum-class-values '%enum-value type))
   
  -(defun enum-int (enum type)
  -  (funcall (to-alien-function type) enum))
  -
  -(defun int-enum (int type)
  -  (funcall (from-alien-function type) int))
  -
  -(defun enum-mapping (type)
  -  (rest (type-expand-to 'enum type)))
  -
  -
  -;;;; Named enum types
  -
  -(defmacro define-enum-type (name &rest args)
  -  (let ((enum-int (intern (format nil "~A-TO-INT" name)))
  -	(int-enum (intern (format nil "INT-TO-~A" name))))
  -    `(progn
  -       (deftype ,name () '(enum ,@args))
  -       (defun ,enum-int (value)
  -	 (ecase value
  -	   ,@(%map-enum args :enum-int)))
  -       (defun ,int-enum (value)
  -	 (ecase value
  -	   ,@(%map-enum args :int-enum)))
  -       (defmethod to-alien-form (form (type (eql ',name)) &rest args)
  -	 (declare (ignore type args))
  -	 (list ',enum-int form))
  -       (defmethod from-alien-form (form (type (eql ',name)) &rest args)
  -	 (declare (ignore type args))
  -	 (list ',int-enum form))
  -       (defmethod to-alien-function ((type (eql ',name)) &rest args)
  -	 (declare (ignore type args))
  -	 #',enum-int)
  -       (defmethod from-alien-function ((type (eql ',name)) &rest args)
  -	 (declare (ignore type args))
  -	 #',int-enum)
  -       (defmethod writer-function ((type (eql ',name)) &rest args)
  -	 (declare (ignore type args))
  -	 (let ((writer (writer-function 'signed)))
  -	   #'(lambda (enum location &optional (offset 0))
  -	       (funcall writer (,enum-int enum) location offset))))    
  -       (defmethod reader-function ((type (eql ',name)) &rest args)
  -	 (declare (ignore type args))
  -	 (let ((reader (reader-function 'signed)))
  -	   #'(lambda (location &optional (offset 0))
  -	       (,int-enum (funcall reader location offset))))))))
  -
  -
  -;;;;  Generic flags type
  -
  -(deftype flags (&rest args)
  -  `(or null (cons (member ,@(%map-enum args :symbols)) list)))
  -
  -(defmethod alien-type ((type (eql 'flags)) &rest args)
  -  (declare (ignore type args))
  -  (alien-type 'unsigned))
  -
  -(defmethod size-of ((type (eql 'flags)) &rest args)
  -  (declare (ignore type args))
  -  (size-of 'unsigned))
  -
  -(defmethod to-alien-form (flags (type (eql 'flags)) &rest args)
  -  `(loop
  -    with value = 0
  -    with flags = ,flags
  -    for flag in (mklist flags)
  -    do (let ((flagval
  -	      (or
  -	       (second (assoc flag ',(%map-enum args :flags-int)))
  -	       (error "~S is not of type ~S" flags '(,type ,@args)))))
  -	 (setq value (logior value flagval)))
  -    finally (return value)))
  -
  -(defmethod from-alien-form (int (type (eql 'flags)) &rest args)
  -  (declare (ignore type))
  -  `(loop
  -    for mapping in ',(%map-enum args :int-flags)
  -    unless (zerop (logand ,int (first mapping)))
  -    collect (second mapping)))
  -
  -(defmethod to-alien-function ((type (eql 'flags)) &rest args)
  -  (let ((mappings (%map-enum args :flags-int)))
  -    #'(lambda (flags)	
  -	(loop
  -	 with value = 0
  -	 for flag in (mklist flags)
  -	 do (let ((flagval (or
  -		    (second (assoc flag mappings))
  -		    (error "~S is not of type ~S" flags (cons type args)))))
  -	      (setq value (logior value flagval)))
  -	 finally (return value)))))
  -
  -(defmethod from-alien-function ((type (eql 'flags)) &rest args)
  -  (declare (ignore type))
  -  (let ((mappings (%map-enum args :int-flags)))
  -    #'(lambda (int)
  -	(loop
  -	 for mapping in mappings
  -	 unless (zerop (logand int (first mapping)))
  -	 collect (second mapping)))))
  -
  -(defmethod writer-function ((type (eql 'flags)) &rest args)
  -  (declare (ignore type))
  -  (let ((writer (writer-function 'unsigned))
  -	(function (apply #'to-alien-function 'flags args)))
  -    #'(lambda (flags location &optional (offset 0))
  -	(funcall writer (funcall function flags) location offset))))
  -    
  -(defmethod reader-function ((type (eql 'flags)) &rest args)
  -  (declare (ignore type))
  -  (let ((reader (reader-function 'unsigned))
  -	(function (apply #'from-alien-function 'flags args)))
  -    #'(lambda (location &optional (offset 0))
  -	(funcall function (funcall reader location offset)))))
  -
  -
   
   (defclass %flags-value (struct)
     ((value :allocation :alien :type unsigned-int)
  
positive.code: ;; License along with this library; if not, write to the Free Software
  ;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
  ;; $Id: genums.lisp,v 1.8 2005-02-10 20:27:54 espen Exp $
  
  (in-package "GLIB")
  
  
  (defun %map-enum (args op)
    (let ((current-value 0))
      (mapcar
       #'(lambda (mapping)
  	 (destructuring-bind (symbol &optional (value current-value))
  	     (mklist mapping)
  	   (setf current-value (1+ value))
  	   (case op
  	     (:enum-int (list symbol value))
  	     (:flags-int (list symbol value))
  	     (:int-enum (list value symbol))
  	     (:int-flags (list value symbol))
  	     (:symbols symbol))))
       args)))
  
  (defun %query-enum-or-flags-values (query-function class type)
    (multiple-value-bind (sap length)
  
negative.code: 	    value)
  	   values)))
        values)))
  
  
  (defclass %enum-value (struct)
  