X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=ecmalisp.lisp;h=05ef19c6787eebd4335fcad3e47ef5560f1ed9e1;hb=1c8b1cc2bde530d701c9dfd0c590b47708b76608;hp=4d42329d9e31a198dc5698e19b8cdd1eb6fca3c9;hpb=3bdebbdae839ed59ce4da43c7e6228a67d9cf6cf;p=jscl.git

diff --git a/ecmalisp.lisp b/ecmalisp.lisp
index 4d42329..05ef19c 100644
--- a/ecmalisp.lisp
+++ b/ecmalisp.lisp
@@ -40,7 +40,7 @@
     `(eval-when-compile
        ,@(mapcar (lambda (decl) `(!proclaim ',decl)) decls)))
 
-  (declaim (constant nil t))
+  (declaim (constant nil t) (special t nil))
   (setq nil 'nil)
   (setq t 't)
 
@@ -52,6 +52,7 @@
 
   (defmacro defvar (name value &optional docstring)
     `(progn
+       (declaim (special ,name))
        (unless (boundp ',name) (setq ,name ,value))
        ,@(when (stringp docstring) `((oset ',name "vardoc" ,docstring)))
        ',name))
@@ -1000,6 +1001,10 @@
 
 (defun !proclaim (decl)
   (case (car decl)
+    (special
+     (dolist (name (cdr decl))
+       (let ((b (global-binding name 'variable 'variable)))
+         (push-binding-declaration 'special b))))
     (notinline
      (dolist (name (cdr decl))
        (let ((b (global-binding name 'function 'function)))
@@ -1223,43 +1228,46 @@
 (define-compilation progn (&rest body)
   (js!selfcall (ls-compile-block body t)))
 
-(defun dynamic-binding-wrapper (bindings body)
-  (if (null bindings)
-      body
-      (concat
-       "try {" *newline*
-       (indent
-        "var tmp;" *newline*
-        (join
-         (mapcar (lambda (b)
-                   (let ((s (ls-compile `(quote ,(car b)))))
-                     (concat "tmp = " s ".value;" *newline*
-                             s ".value = " (cdr b) ";" *newline*
-                             (cdr b) " = tmp;" *newline*)))
-                 bindings))
-        body)
-       "}" *newline*
-       "finally {"  *newline*
-       (indent
-        (join-trailing
-         (mapcar (lambda (b)
-                   (let ((s (ls-compile `(quote ,(car b)))))
-                     (concat s ".value" " = " (cdr b))))
-                 bindings)
-         (concat ";" *newline*)))
-       "}" *newline*)))
-
+(defun special-variable-p (x)
+  (claimp x 'variable 'special))
+
+;;; Wrap CODE to restore the symbol values of the dynamic
+;;; bindings. BINDINGS is a list of pairs of the form
+;;; (SYMBOL . PLACE),  where PLACE is a Javascript variable
+;;; name to initialize the symbol value and where to stored
+;;; the old value.
+(defun let-binding-wrapper (bindings body)
+  (when (null bindings)
+    (return-from let-binding-wrapper body))
+  (concat
+   "try {" *newline*
+   (indent "var tmp;" *newline*
+           (mapconcat
+            (lambda (b)
+              (let ((s (ls-compile `(quote ,(car b)))))
+                (concat "tmp = " s ".value;" *newline*
+                        s ".value = " (cdr b) ";" *newline*
+                        (cdr b) " = tmp;" *newline*)))
+            bindings)
+           body *newline*)
+   "}" *newline*
+   "finally {"  *newline*
+   (indent
+    (mapconcat (lambda (b)
+                 (let ((s (ls-compile `(quote ,(car b)))))
+                   (concat s ".value" " = " (cdr b) ";" *newline*)))
+               bindings))
+   "}" *newline*))
 
 (define-compilation let (bindings &rest body)
   (let ((bindings (mapcar #'ensure-list bindings)))
-    (let ((variables (mapcar #'first bindings))
-          (values    (mapcar #'second bindings)))
-      (let ((cvalues (mapcar #'ls-compile values))
-            (*environment* (extend-local-env (remove-if #'boundp variables)))
+    (let ((variables (mapcar #'first bindings)))
+      (let ((cvalues (mapcar #'ls-compile (mapcar #'second bindings)))
+            (*environment* (extend-local-env (remove-if #'special-variable-p variables)))
             (dynamic-bindings))
         (concat "(function("
                 (join (mapcar (lambda (x)
-                                (if (boundp x)
+                                (if (special-variable-p x)
                                     (let ((v (gvarname x)))
                                       (push (cons x v) dynamic-bindings)
                                       v)
@@ -1268,10 +1276,58 @@
                       ",")
                 "){" *newline*
                 (let ((body (ls-compile-block body t)))
-                  (indent (dynamic-binding-wrapper dynamic-bindings body)))
+                  (indent (let-binding-wrapper dynamic-bindings body)))
                 "})(" (join cvalues ",") ")")))))
 
 
+;;; Return the code to initialize BINDING, and push it extending the
+;;; current lexical environment if the variable is special.
+(defun let*-initialize-value (binding)
+  (let ((var (first binding))
+        (value (second binding)))
+    (if (special-variable-p var)
+        (concat (ls-compile `(setq ,var ,value)) ";" *newline*)
+        (let ((v (gvarname var)))
+          (let ((b (make-binding var 'variable v)))
+            (prog1 (concat "var " v " = " (ls-compile value) ";" *newline*)
+              (push-to-lexenv b *environment* 'variable)))))))
+
+;;; Wrap BODY to restore the symbol values of SYMBOLS after body. It
+;;; DOES NOT generate code to initialize the value of the symbols,
+;;; unlike let-binding-wrapper.
+(defun let*-binding-wrapper (symbols body)
+  (when (null symbols)
+    (return-from let*-binding-wrapper body))
+  (let ((store (mapcar (lambda (s) (cons s (gvarname s)))
+                       (remove-if-not #'special-variable-p symbols))))
+    (concat
+     "try {" *newline*
+     (indent
+      (mapconcat (lambda (b)
+                   (let ((s (ls-compile `(quote ,(car b)))))
+                     (concat "var " (cdr b) " = " s ".value;" *newline*)))
+                 store)
+      body)
+     "}" *newline*
+     "finally {" *newline*
+     (indent
+      (mapconcat (lambda (b)
+                   (let ((s (ls-compile `(quote ,(car b)))))
+                     (concat s ".value" " = " (cdr b) ";" *newline*)))
+                 store))
+     "}" *newline*)))
+
+
+(define-compilation let* (bindings &rest body)
+  (let ((bindings (mapcar #'ensure-list bindings))
+        (*environment* (copy-lexenv *environment*)))
+    (js!selfcall
+      (let ((specials (remove-if-not #'special-variable-p (mapcar #'first bindings)))
+            (body (concat (mapconcat #'let*-initialize-value bindings)
+                          (ls-compile-block body t))))
+        (let*-binding-wrapper specials body)))))
+
+
 (defvar *block-counter* 0)
 
 (define-compilation block (name &rest body)
@@ -1478,31 +1534,75 @@
                decls)
      (concat "return " (progn ,@body) ";" *newline*)))
 
+;;; VARIABLE-ARITY compiles variable arity operations. ARGS stands for
+;;; a variable which holds a list of forms. It will compile them and
+;;; store the result in some Javascript variables. BODY is evaluated
+;;; with ARGS bound to the list of these variables to generate the
+;;; code which performs the transformation on these variables.
+
+(defun variable-arity-call (args function)
+  (unless (consp args)
+    (error "ARGS must be a non-empty list"))
+  (let ((counter 0)
+        (variables '())
+        (prelude))
+    (dolist (x args)
+      (let ((v (concat "x" (integer-to-string (incf counter)))))
+        (push v variables)
+        (concatf prelude
+                 (concat "var " v " = " (ls-compile x) ";" *newline*
+                         "if (typeof " v " !=== 'number') throw 'Not a number!';"
+                         *newline*))))
+    (js!selfcall prelude (funcall function (reverse variables)))))
+
+
+(defmacro variable-arity (args &body body)
+  (unless (symbolp args)
+    (error "Bad usage of VARIABLE-ARITY, you must pass a symbol"))
+  `(variable-arity-call ,args
+                        (lambda (,args)
+                          (concat "return " ,@body ";" *newline*))))
+
+
+(define-raw-builtin plus (&rest numbers)
+  (variable-arity numbers
+    (join numbers "+")))
+
+(define-raw-builtin minus (x &rest others)
+  (let ((args (cons x others)))
+	      (variable-arity args
+		(if (null others)
+		    (concat "-" (car args))
+		    (join args "+")))))
+  
+
 (defun num-op-num (x op y)
   (type-check (("x" "number" x) ("y" "number" y))
     (concat "x" op "y")))
 
-(defmacro define-builtin-arithmetic (op)
-`(define-raw-builtin ,op (&rest args)
-  (if args
-      (let ((res (ls-compile (car args))))
-	(dolist (x (cdr args))
-	  (setq res (num-op-num res ,(symbol-name op) (ls-compile x))))
-	res)
-       "0")))
-
-(define-builtin-arithmetic +)
-(define-builtin-arithmetic -)
-(define-builtin-arithmetic *)
-(define-builtin-arithmetic /)
+(define-builtin + (x y) (num-op-num x "+" y))
+(define-builtin - (x y) (num-op-num x "-" y))
+(define-builtin * (x y) (num-op-num x "*" y))
+(define-builtin / (x y) (num-op-num x "/" y))
 
 (define-builtin mod (x y) (num-op-num x "%" y))
 
-(define-builtin < (x y)  (js!bool (num-op-num x "<" y)))
-(define-builtin > (x y)  (js!bool (num-op-num x ">" y)))
-(define-builtin = (x y)  (js!bool (num-op-num x "==" y)))
-(define-builtin <= (x y) (js!bool (num-op-num x "<=" y)))
-(define-builtin >= (x y) (js!bool (num-op-num x ">=" y)))
+(defmacro define-builtin-comparison (op sym)
+  `(define-raw-builtin ,op (&rest args)
+     (js!bool
+      (let ((x (car args))
+	    (res "true"))
+	(dolist (y (cdr args))
+	  (setq res (concat "("
+		     (ls-compile x) " " ,sym " " (ls-compile y) ")" " && " res))
+	  (setq x y))
+	res))))
+
+(define-builtin-comparison > ">")
+(define-builtin-comparison < "<")
+(define-builtin-comparison >= ">=")
+(define-builtin-comparison <= "<=")
+(define-builtin-comparison = "==")
 
 (define-builtin numberp (x)
   (js!bool (concat "(typeof (" x ") == \"number\")")))
@@ -1584,7 +1684,6 @@
 (define-builtin lambda-code (x)
   (concat "(" x ").toString()"))
 
-
 (define-builtin eq    (x y) (js!bool (concat "(" x " === " y ")")))
 (define-builtin equal (x y) (js!bool (concat "(" x  " == " y ")")))
 
@@ -1725,9 +1824,10 @@
     ((symbolp sexp)
      (let ((b (lookup-in-lexenv sexp *environment* 'variable)))
        (cond
-         ((eq (binding-type b) 'lexical-variable)
+         ((and b (not (member 'special (binding-declarations b))))
           (binding-value b))
-         ((or (keywordp sexp) (claimp sexp 'variable 'constant))
+         ((or (keywordp sexp)
+              (member 'constant (binding-declarations b)))
           (concat (ls-compile `',sexp) ".value"))
          (t
           (ls-compile `(symbol-value ',sexp))))))
@@ -1786,26 +1886,25 @@
                (ls-compile-toplevel x))))
       (js-eval code)))
 
-  (export '(* *gensym-counter* *package* + - / 1+ 1- < <= = = > >= and append
-            apply assoc atom block boundp boundp butlast caar cadddr
-            caddr cadr car car case catch cdar cdddr cddr cdr cdr char
-            char-code char= code-char cond cons consp copy-list decf
-            declaim defparameter defun defvar digit-char-p disassemble
-            documentation dolist dotimes ecase eq eql equal error eval
-            every export fdefinition find-package find-symbol first
-            fourth fset funcall function functionp gensym go identity
-            if in-package incf integerp integerp intern keywordp
-            lambda-code last length let list-all-packages list listp
-            make-package make-symbol mapcar member minusp mod nil not
-            nth nthcdr null numberp or package-name package-use-list
-            packagep plusp prin1-to-string print proclaim prog1 prog2
-            pron push quote remove remove-if remove-if-not return
-            return-from revappend reverse second set setq some
-            string-upcase string string= stringp subseq
-            symbol-function symbol-name symbol-package symbol-plist
-            symbol-value symbolp t tagbody third throw truncate unless
-            unwind-protect variable warn when write-line write-string
-            zerop))
+  (export '(&rest &optional &body * *gensym-counter* *package* + - / 1+ 1- < <= =
+= > >= and append apply assoc atom block boundp boundp butlast caar
+cadddr caddr cadr car car case catch cdar cdddr cddr cdr cdr char
+char-code char= code-char cond cons consp copy-list decf declaim
+defparameter defun defvar digit-char-p disassemble documentation
+dolist dotimes ecase eq eql equal error eval every export fdefinition
+find-package find-symbol first fourth fset funcall function functionp
+gensym go identity if in-package incf integerp integerp intern
+keywordp lambda last length let let* list-all-packages list listp
+make-package make-symbol mapcar member minusp mod nil not nth nthcdr
+null numberp or package-name package-use-list packagep plusp
+prin1-to-string print proclaim prog1 prog2 pron push quote remove
+remove-if remove-if-not return return-from revappend reverse second
+set setq some string-upcase string string= stringp subseq
+symbol-function symbol-name symbol-package symbol-plist symbol-value
+symbolp t tagbody third throw truncate unless unwind-protect variable
+warn when write-line write-string zerop
+arithmetic plus minus
+))
 
   (setq *package* *user-package*)