anchor.diff:    (clear-entries-with-slot-id slot-id)
     (values))
   
  -(defmacro with-open-session ((session-var slot-id &key flags application-reference notify-function
  + (defmacro with-open-session ((session-var slot-id &key flags application-reference notify-function
                                                       (if-open-session-fails :error)) &body body)
     (let ((vflags (gensym))
           (vsession (gensym)))
  
positive.code:          :append objects)
      (find-objects-final session)))
  
  (defun object-get-all-attributes (session object)
    (check-type session    session-handle)
    (check-type object     object-handle)
    (get-attribute-value session object
                         (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*)))
  
  ;;; Encryption
  
  
negative.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-p len))
                     :unavailable-information
                     (case base-ltype
                       ((:ulong)
                        (assert (= (foreign-type-size :ulong) len))
                        (mem-ref val :ulong))
                       ((:bool)
                        (if (zerop len)
                            0 ; libiaspkcs11 returns 0-length values…
                            (progn
                              (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)
  