anchor.diff:             "DESTROY-OBJECT" "GET-OBJECT-SIZE" "GET-ATTRIBUTE-VALUE"
              "SET-ATTRIBUTE-VALUE" "FIND-OBJECTS-INIT" "FIND-OBJECTS"
              "FIND-OBJECTS-FINAL" "FIND-ALL-OBJECTS" "OBJECT-GET-ALL-ATTRIBUTES"
  +           "OBJECT-GET-ATTRIBUTES"
              "SEED-RANDOM" "GENERATE-RANDOM" "LOAD-LIBRARY"
              "CALL-LOGGED-IN" "DO-LOGGED-IN")
   
  
positive.code:                     (base-ltype (base-ltype-p ltype))
                      (len (attr-> attribute %ck:value-len))
                      (val (attr-> attribute %ck:value)))
                 (if (or (unavailable-information-p type) (invalid-pointer-p val))
                     :unavailable-information
                     (case base-ltype
                       ((:ulong)
                        (assert (= (foreign-type-size :ulong) len))
                        (mem-ref val :ulong))
                       ((:bool)
                        (assert (= (foreign-type-size :uchar) len))
                        (mem-ref val :uchar))
                       ((:bytes :bytes-noint :big-integer)
                        (foreign-vector-copy-to val :uchar len (make-array len :element-type 'octet)))
                       ((:string)
  
negative.code:          :append objects)
      (find-objects-final session)))
  
  (defun template-from-attribute-type-map (attribute-type-map)
    (mapcar (lambda (entry)
              ;; This CONS here matches attribute-decode CONS.
              (cons (first entry)
                    (let ((type (second entry)))
                      (if (atom type)
                          (ecase type
                            ((:ulong)       0)
                            ((:bool)        nil)
                            ((:string)      nil)
                            ((:bytes :bytes-noint :big-integer)  nil)
                            ((:date)        "0000000000000000"))
                          (ecase (first type)
                            ((:ulong)       0)
                            ((:big-integer) nil)
                            ((:array)       nil))))))
            attribute-type-map))
  
  (defun object-get-all-attributes (session object)
    (check-type session    session-handle)
    (check-type object     object-handle)
    (get-attribute-value session object
                         (template-from-attribute-type-map *attribute-type-map*)))
  
  (defun object-get-attributes (session object attributes)
    (check-type session    session-handle)
    (check-type object     object-handle)
      (get-attribute-value session object
                           (template-from-attribute-type-map
                            (remove-if-not (lambda (entry)
                                             (member (first entry) attributes))
                                           *attribute-type-map*))))
  
  ;;; Encryption
  
  