(progn
 
 
(defun loadfn fexpr (l)
 (status (45 0))
 (mapc '(lambda (fn) (prog (f) (loadfun fn))) l)
 (status (45 1))
 t)
 
 
(defun loadfun (fn)
 (or (memq fn f)
     (prog (index buffer loadmap topcalls library list entry form name)
           (setq f (cons fn f))
           (cond ((loadsetup fn)
                   (and (setq entry (assq fn topcalls)) (rplacd entry (add1 (cdr entry))) (return nil))
                   (nconc topcalls (list (cons fn 1)))
                   (mapc '(lambda (line) (cond ((numberp line) (loadfun# line)) ((loadfun line)))) list))
                 (t (prin1 fn errout)
                    (prin1 '"isn't in librarys:" errout)
                    (prin1 #librarylist# errout)
                    (terpri errout))))))
 
 
(defun loadfun# (line)
 (cond ((setq entry (assq line loadmap)) (rplacd (cdr entry) (add1 (cddr entry))))
       (t (readfrom buffer line)
          (setq form (read buffer) name (and (eq (car form) 'defun) (cadr form)))
          (nconc loadmap (list (cons line (cons name 1))))
          (eval form))))
 
 
(defun loadsetup (fn)
 (mapc '(lambda (lib)
                (cond ((setq index (get lib '".index." '(loadindex lib))
                             list (cdr (assq fn index '(return nil 'cond)))
                             buffer (get lib '".buffer.")
                             loadmap (get lib '".loadmap.")
                             topcalls (get lib '".topcalls.")
                             library lib)
                        (return t 'loadsetup))))
       #librarylist#))
 
 
(defun loadindex (lib)
 (prog (buffer index)
       (apply1 'open (list 'buffer 255 lib))
       (readfrom buffer -1000000)
       (setq index (cdr (read buffer)))
       (put lib '".buffer." buffer)
       (put lib '".index." index)
       (put lib '".loadmap." (list nil))
       (put lib '".topcalls." (list nil))
       (return index)))
 
 
(defun readfrom (buffer line)
 (prog (status)
       (apply1 'status '(16 buffer 2) (list 15 'buffer (fix (times 1000 line))))
       (setq status (status (12 buffer (lambda x (return nil 'readline)))))
       (readline buffer)
       (apply1 'status (list 12 'buffer status) '(16 buffer 0))
     nil))
 
 
(setq #librarylist# (list 'cs:library)) 
 
 
(defun *putob fexpr (l)
 (mapc '(lambda (l) (set (putob (copy l)) nil)) l))
 
 
(put '*remob 'nsubr (getfn 'remob)) 
 
 
(defun |err| ()
 (and (eq (status 29) 68) ?autoload (|library-err|))
 (and ?debug (|debug-err|))
 (uneval '|err| '(dump 7)))
 
 
(setq ?debug nil ?autoload t *err* '(|err|) *attn* '(|err|))
 
 
(defun |library-err| ()
 (prog (#fn# f)
       (setq #fn# (status 28))
       (cond ((mapc '(lambda (lib)
                             (and (assq #fn# (get lib '".index." '(loadindex lib))) (return t 'mapc)))
                    #librarylist#)
               (prin1 'loading:)
               (prin1 #fn#)
               (terpri)
               (status (45 0))
               (loadfun #fn#)
               (status (45 1))
               (cond ((eq #fn# '|debug-err|)
                       (cond ((atom (uneval 12))(uneval 12 t))
                             (t (uneval 11 t))))
                     ((atom (uneval #fn#)) (uneval #fn# '(uneval 1 t)))
                     (t (uneval #fn# t)))))))
 
 
(status (32 4) (45 1)) 
 
 
'loader)
 
 
 ; oct 24, 1975 21:27:18
