anchor.diff:                      (cffi:callback method-invocation-callback)
                       (cffi:callback child-callback)))
           (incf *n-modules*)
  +        (initialize-string-table idx)
           idx))))
   
   (defun unload ()
  
positive.code: (deflistify list-methodmap-methods map-methodmap-methods
    <methodmap>)
  
  (defun name-ref (<module> idx)
    (declare (type module-number <module>))
    (declare (type index idx))
    (cffi:mem-aref (data-methodnames (data-ref <module>))
                   :string
                   idx))
  
  (declaim (inline methodmap-name-index))
  (defun methodmap-name-index (<methodmap>)
  
negative.code: (defvar *module-data-table*
    (make-array (ash 1 +module-bits+) :initial-element nil))
  
  (defvar *string-table-table*
    (make-array (ash 1 +module-bits+) :initial-element nil))
  
  (declaim (type (simple-array t (#.(expt 2 +module-bits+)))
                 *module-table*
                 *module-data-table*
                 *string-table-table*))
  
  (declaim (inline module-ref))
  (defun module-ref (i) (svref *module-table* i))
  
  (declaim (inline data-ref))
  (defun data-ref (i) (svref *module-data-table* i))
  
  (declaim (inline string-table-ref))
  (defun string-table-ref (i) (svref *string-table-table* i))
  
  ;;;;
  ;;;; Bit bashing
  