X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fpackage.lisp;h=317ab411d824f897202dde00caa7f9e9996eb12f;hb=9f8ed4bbc70fe2171bf116d60b80fed19fdef444;hp=5745d07dab6271756269f568047a7c1551faa794;hpb=7709a56a5467d8d78e1a2d86588be7dd60de3679;p=jscl.git

diff --git a/src/package.lisp b/src/package.lisp
index 5745d07..317ab41 100644
--- a/src/package.lisp
+++ b/src/package.lisp
@@ -13,18 +13,20 @@
 ;; You should have received a copy of the GNU General Public License
 ;; along with JSCL.  If not, see <http://www.gnu.org/licenses/>.
 
+(/debug "loading package.lisp!")
+
 (defvar *package-list* nil)
 
 (defun list-all-packages ()
-  *package-list*)
+  (copy-list *package-list*))
 
 (defun make-package (name &key use)
   (let ((package (new))
         (use (mapcar #'find-package-or-fail use)))
-    (oset package "packageName" name)
-    (oset package "symbols" (new))
-    (oset package "exports" (new))
-    (oset package "use" use)
+    (setf (oget package "packageName") name)
+    (setf (oget package "symbols") (new))
+    (setf (oget package "exports") (new))
+    (setf (oget package "use") use)
     (push package *package-list*)
     package))
 
@@ -62,9 +64,6 @@
 (defvar *common-lisp-package*
   (make-package "CL"))
 
-(defvar *js-package*
-  (make-package "JS"))
-
 (defvar *user-package*
   (make-package "CL-USER" :use (list *common-lisp-package*)))
 
@@ -76,9 +75,9 @@
 
 (defvar *package* *common-lisp-package*)
 
-(defmacro in-package (package-designator)
+(defmacro in-package (string-designator)
   `(eval-when-compile
-     (setq *package* (find-package-or-fail ,package-designator))))
+     (setq *package* (find-package-or-fail ',string-designator))))
 
 ;; This function is used internally to initialize the CL package
 ;; with the symbols built during bootstrap.
@@ -87,11 +86,14 @@
           (if (in "package" symbol)
               (find-package-or-fail (oget symbol "package"))
               *common-lisp-package*))
-         (symbols (%package-symbols package)))
-    (oset symbol "package" package)
+         (symbols (%package-symbols package))
+         (exports (%package-external-symbols package)))
+    (setf (oget symbol "package") package)
+    (setf (oget symbols (symbol-name symbol)) symbol)
+    ;; Turn keywords self-evaluated and export them.
     (when (eq package *keyword-package*)
-      (oset symbol "value" symbol))
-    (oset symbols (symbol-name symbol) symbol)))
+      (setf (oget symbol "value") symbol)
+      (setf (oget exports (symbol-name symbol)) symbol))))
 
 (defun find-symbol (name &optional (package *package*))
   (let* ((package (find-package-or-fail package))
@@ -108,6 +110,11 @@
            (when (in name exports)
              (return (values (oget exports name) :inherit)))))))))
 
+
+;;; It is a function to call when a symbol is interned. The function
+;;; is invoked with the already interned symbol as argument.
+(defvar *intern-hook* nil)
+
 (defun intern (name &optional (package *package*))
   (let ((package (find-package-or-fail package)))
     (multiple-value-bind (symbol foundp)
@@ -117,27 +124,13 @@
           (let ((symbols (%package-symbols package)))
             (oget symbols name)
             (let ((symbol (make-symbol name)))
-              (oset symbol "package" package)
+              (setf (oget symbol "package") package)
               (when (eq package *keyword-package*)
-                (oset symbol "value" symbol)
+                (setf (oget symbol "value") symbol)
                 (export (list symbol) package))
-              (when (eq package *js-package*)
-                (let ((sym-name (symbol-name symbol))
-                      (args (gensym)))
-                  ;; Generate a trampoline to call the JS function
-                  ;; properly. This trampoline is very inefficient,
-                  ;; but it still works. Ideas to optimize this are
-                  ;; provide a special lambda keyword
-                  ;; cl::&rest-vector to avoid list argument
-                  ;; consing, as well as allow inline declarations.
-                  (fset symbol
-                        (eval `(lambda (&rest ,args)
-                                 (let ((,args (list-to-vector ,args)))
-                                   (%js-call (%js-vref ,sym-name) ,args)))))
-                  ;; Define it as a symbol macro to access to the
-                  ;; Javascript variable literally.
-                  (%define-symbol-macro symbol `(%js-vref ,(string symbol)))))
-              (oset symbols name symbol)
+              (when *intern-hook*
+                (funcall *intern-hook* symbol))
+              (setf (oget symbols name) symbol)
               (values symbol nil)))))))
 
 (defun symbol-package (symbol)
@@ -148,4 +141,43 @@
 (defun export (symbols &optional (package *package*))
   (let ((exports (%package-external-symbols package)))
     (dolist (symb symbols t)
-      (oset exports (symbol-name symb) symb))))
+      (setf (oget exports (symbol-name symb)) symb))))
+
+(defun %map-external-symbols (function package)
+  (map-for-in function (%package-external-symbols package)))
+
+(defun %map-symbols (function package)
+  (map-for-in function (%package-symbols package))
+  (dolist (used (package-use-list package))
+    (%map-external-symbols function used)))
+
+(defun %map-all-symbols (function)
+  (dolist (package *package-list*)
+    (map-for-in function (%package-symbols package))))
+
+(defmacro do-symbols ((var &optional (package '*package*) result-form)
+                      &body body)
+  `(block nil
+     (%map-symbols
+      (lambda (,var) ,@body)
+      (find-package ,package))
+     ,result-form))
+
+(defmacro do-external-symbols ((var &optional (package '*package*)
+                                              result-form)
+                               &body body)
+  `(block nil
+     (%map-external-symbols
+      (lambda (,var) ,@body)
+      (find-package ,package))
+     ,result-form))
+
+(defmacro do-all-symbols ((var &optional result-form) &body body)
+  `(block nil (%map-all-symbols (lambda (,var) ,@body)) ,result-form))
+
+(defun find-all-symbols (string)
+  (let (symbols)
+    (dolist (package *package-list* symbols)
+      (multiple-value-bind (symbol status) (find-symbol string package)
+        (when status
+          (pushnew symbol symbols :test #'eq))))))