CODEWITHSUNDEEP
common-lisp
mwgkgk
mwgkgk

Reputation: 173

How to set *package* from file?

Sounds deceptively easy. This doesn't work:

~/.sbclrc

(load #P"~/in-package.lisp")

~/in-package.lisp

(in-package 'stored-package)

The package change only applies to the file in-package.lisp itself.

Try different approach: store just the name.

(defmacro recall-package (&optional (filename #p"~/lisp-package.lisp"))
  "IN-PACKAGE the contents of the FILENAME"
  (let ((p (car (uiop:read-file-lines filename))))
    `(in-package ,p)))

This works, but only from ~/.sbclrc. Files which it LOADs expand the macro within their own context, and so it doesn't work.

SBCL reads it's .sbclrc like this:

      (restart-case
          (flet ((process-init-file (kind specified-pathname default-function)
                   (awhen (or specified-pathname (funcall default-function))
                     (with-open-file (stream (if specified-pathname
                                                 (parse-native-namestring it)
                                                 (pathname it))
                                             :if-does-not-exist nil)
                       (cond (stream
                              (sb-fasl::call-with-load-bindings
                               (lambda (stream kind) (load-as-source stream :context kind))
                               stream kind stream))
                             (specified-pathname
                              (cerror "Ignore missing init file"
                                      "The specified ~A file ~A was not found."
                                      kind specified-pathname)))))))
            (unless no-sysinit
              (process-init-file "sysinit" sysinit *sysinit-pathname-function*))
            (unless no-userinit
              (process-init-file "userinit" userinit *userinit-pathname-function*))

Using these fancy sb-fasl::call-with-load-bindings and sb-int:load-as-source yields similar results to the above.

Upvotes: 0

Views: 121

Answers (1)

ignis volens
ignis volens

Reputation: 9252

You can't do this with load, because

load binds *readtable* and *package* to the values they held before loading the file.

Function load

This means that any changes made to the values of these variables within a file being loaded are local to the file. That's almost always a good thing. In particular it means that there is no way at all (or no portable way: if you had access to the guts of the dynamic binding mechanism of the implementation this might not be true) that any changes made to the current package (ie the dynamic value of *package*) can ever propagate up through calls to load.

If all you want to do is set the package based on some name in a file, then this is relatively easy, with something like the below:

(defpackage :empty-package
  (:use))

(defun set-package-from-file (f)
  (let ((pn
          (with-standard-io-syntax
            ;; EP just in case the file does somehow manage to smash
            ;; *package*)
            (let* ((ep (find-package :empty-package))
                   (*package* ep)
                   (*read-eval* nil))
              (unwind-protect
                  (with-open-file (in f)
                    (string (read in)))
                ;; Clean up EP to avoid leakage
                (do-symbols (s ep)
                  (unintern s ep)))))))
    (let ((p (find-package pn)))
      (unless p (error "no package ~A" pn))
      (setf *package* p))))

This is probably both overly-protective and thus will contain some horrible unexpected bug which I should have thought about (I know it's not safe against interning symbols in other packages). However the idea is that the file contains a single string-designator which should be the package name.

If you had time on your hands you could fairly easily write a version of load which would not rebind *package* &c, and which would work for source files. I think you can't portably write one which would work for FASL files.

Here's one reason why the behaviour the language specifies is the right behaviour: it makes compilation a lot easier. Consider a file which contains:

(in-package ...)
(defun foo (...) ...)
(load ...)
(defun bar (...)
  (foo ...)
  ...)

If *package* could propagate up through load then compiling this file would be, at best, interesting.

Upvotes: 4

Related Questions