X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=lispstrack.lisp;h=ee1aab7294fe0b4b081ca27e0e535cd8bc50224b;hb=137ff928aab4f5b9dcc6f3b927c4ea92cf1d0a82;hp=a9fba973f69b2a334053416be4a579c00ff5a47b;hpb=c8b4a139f7e11f5a7d0a29b6d4428174e4cd361c;p=jscl.git

diff --git a/lispstrack.lisp b/lispstrack.lisp
index a9fba97..ee1aab7 100644
--- a/lispstrack.lisp
+++ b/lispstrack.lisp
@@ -1,3 +1,9 @@
+(defun ensure-list (x)
+  (if (listp x)
+      x
+      (list x)))
+
+
 (defun !reduce (func list initial)
   (if (null list)
       initial
@@ -15,7 +21,12 @@
        ,@body))
 
   (defun concat-two (s1 s2)
-    (concatenate 'string s1 s2)))
+    (concatenate 'string s1 s2))
+
+  (defun setcar (cons new)
+    (setf (car cons) new))
+  (defun setcdr (cons new)
+    (setf (cdr cons) new)))
 
 (defvar *newline* (string (code-char 10)))
 
@@ -37,9 +48,13 @@
              (join (cdr list) separator)))))
 
 (defun join-trailing (list separator)
-  (if (null list)
-      ""
-      (concat (car list) separator (join-trailing (cdr list) separator))))
+  (cond
+    ((null list)
+     "")
+    ((null (car list))
+     (join-trailing (cdr list) separator))
+    (t
+     (concat (car list) separator (join-trailing (cdr list) separator)))))
 
 (defun integer-to-string (x)
   (if (zerop x)
@@ -62,17 +77,13 @@
   (cons string 0))
 
 (defun %peek-char (stream)
-  (if (streamp stream)
-      (peek-char nil stream nil)
-      (and (< (cdr stream) (length (car stream)))
-           (char (car stream) (cdr stream)))))
+  (and (< (cdr stream) (length (car stream)))
+       (char (car stream) (cdr stream))))
 
 (defun %read-char (stream)
-  (if (streamp stream)
-      (read-char stream nil)
-      (and (< (cdr stream) (length (car stream)))
-           (prog1 (char (car stream) (cdr stream))
-             (incf (cdr stream))))))
+  (and (< (cdr stream) (length (car stream)))
+       (prog1 (char (car stream) (cdr stream))
+         (setcdr stream (1+ (cdr stream))))))
 
 (defun whitespacep (ch)
   (or (char= ch #\space) (char= ch #\newline) (char= ch #\tab)))
@@ -101,8 +112,8 @@
   (let (ch)
     (skip-whitespaces stream)
     (setq ch (%peek-char stream))
-    (while (and ch (eql ch #\;))
-      (read-until stream (lambda (x) (eql x #\newline)))
+    (while (and ch (char= ch #\;))
+      (read-until stream (lambda (x) (char= x #\newline)))
       (skip-whitespaces stream)
       (setq ch (%peek-char stream)))))
 
@@ -152,11 +163,19 @@
        (ecase (%read-char stream)
          (#\'
           (list 'function (ls-read stream)))
+         (#\\
+          (let ((cname
+		 (concat (string (%read-char stream))
+			 (read-until stream #'terminalp))))
+            (cond
+              ((string= cname "space") (char-code #\space))
+              ((string= cname "newline") (char-code #\newline))
+              (t (char-code (char cname 0))))))
          (#\+
           (let ((feature (read-until stream #'terminalp)))
             (cond
               ((string= feature "common-lisp")
-               (ls-read stream);ignore
+               (ls-read stream)         ;ignore
                (ls-read stream))
               ((string= feature "lispstrack")
                (ls-read stream))
@@ -185,9 +204,10 @@
 (defvar *compilations* nil)
 
 (defun ls-compile-block (sexps env fenv)
-  (join-trailing (mapcar (lambda (x)
-                           (ls-compile x env fenv))
-                         sexps)
+  (join-trailing
+   (remove nil (mapcar (lambda (x)
+                         (ls-compile x env fenv))
+                       sexps))
                  ";
 "))
 
@@ -197,18 +217,18 @@
 (defparameter *env* '())
 (defparameter *fenv* '())
 
-(defun ls-lookup (symbol env)
+(defun lookup (symbol env)
   (let ((binding (assoc symbol env)))
     (and binding (cdr binding))))
 
 (defun lookup-variable (symbol env)
-  (or (ls-lookup symbol env)
-      (ls-lookup symbol *env*)
+  (or (lookup symbol env)
+      (lookup symbol *env*)
       (error "Undefined variable `~a'"  symbol)))
 
 (defun lookup-function (symbol env)
-  (or (ls-lookup symbol env)
-      (ls-lookup symbol *fenv*)
+  (or (lookup symbol env)
+      (lookup symbol *fenv*)
       (error "Undefined function `~a'"  symbol)))
 
 (defmacro define-compilation (name args &body body)
@@ -241,7 +261,9 @@
 (define-compilation lambda (lambda-list &rest body)
   (let ((required-arguments (lambda-list-required-argument lambda-list))
         (rest-argument (lambda-list-rest-argument lambda-list)))
-    (let ((new-env (extend-env (cons rest-argument required-arguments) env)))
+    (let ((new-env (extend-env (append (if rest-argument (list rest-argument))
+                                       required-arguments)
+                               env)))
       (concat "(function ("
               (join (mapcar (lambda (x) (lookup-variable x new-env))
                             required-arguments)
@@ -277,7 +299,7 @@
 
 (defun literal->js (sexp)
   (cond
-    ((null sexp) "undefined")
+    ((null sexp) "false")
     ((integerp sexp) (integer-to-string sexp))
     ((stringp sexp) (concat "\"" sexp "\""))
     ((symbolp sexp) (concat "{name: \"" (symbol-name sexp) "\"}"))
@@ -288,9 +310,11 @@
 
 (let ((counter 0))
   (defun literal (form)
-    (let ((var (concat "l" (integer-to-string (incf counter)))))
-      (push (concat "var " var " = " (literal->js form)) *toplevel-compilations*)
-      var)))
+    (if (null form)
+        (literal->js form)
+        (let ((var (concat "l" (integer-to-string (incf counter)))))
+          (push (concat "var " var " = " (literal->js form)) *toplevel-compilations*)
+          var))))
 
 (define-compilation quote (sexp)
   (literal sexp))
@@ -329,8 +353,9 @@
   `((lambda () ,@body)))
 
 (define-transformation let (bindings &rest body)
-  `((lambda ,(mapcar 'car bindings) ,@body)
-    ,@(mapcar 'cadr bindings)))
+  (let ((bindings (mapcar #'ensure-list bindings)))
+    `((lambda ,(mapcar 'car bindings) ,@body)
+      ,@(mapcar 'cadr bindings))))
 
 ;;; A little backquote implementation without optimizations of any
 ;;; kind for lispstrack.
@@ -381,6 +406,9 @@
 (define-compilation / (x y)
   (concat "((" (ls-compile x env fenv) ") / (" (ls-compile y env fenv) "))"))
 
+(define-compilation < (x y)
+  (concat "((" (ls-compile x env fenv) ") < (" (ls-compile y env fenv) "))"))
+
 (define-compilation = (x y)
   (concat "((" (ls-compile x env fenv) ") == (" (ls-compile y env fenv) "))"))
 
@@ -391,7 +419,7 @@
   (concat "(Math.floor(" (ls-compile x env fenv) "))"))
 
 (define-compilation null (x)
-  (concat "(" (ls-compile x env fenv) "== undefined)"))
+  (concat "(" (ls-compile x env fenv) "== false)"))
 
 (define-compilation cons (x y)
   (concat "{car: " (ls-compile x env fenv) ", cdr: " (ls-compile y env fenv) "}"))
@@ -402,6 +430,13 @@
 (define-compilation cdr (x)
   (concat "(" (ls-compile x env fenv) ").cdr"))
 
+(define-compilation setcar (x new)
+  (concat "((" (ls-compile x env fenv) ").car = " (ls-compile new env fenv) ")"))
+
+(define-compilation setcdr (x new)
+  (concat "((" (ls-compile x env fenv) ").cdr = " (ls-compile new env fenv) ")"))
+
+
 (define-compilation make-symbol (name)
   (concat "{name: " (ls-compile name env fenv) "}"))
 
@@ -412,7 +447,7 @@
   (concat "(" (ls-compile x env fenv) " === " (ls-compile y env fenv) ")"))
 
 (define-compilation string (x)
-  (concat "String.fromCharCode( " (ls-compile x env fenv) ")"))
+  (concat "String.fromCharCode(" (ls-compile x env fenv) ")"))
 
 (define-compilation char (string index)
   (concat "("
@@ -453,12 +488,14 @@
 
 
 (defun %compile-defvar (name)
-  (push (make-var-binding name) *env*)
-  (push (concat "var " (lookup-variable name *env*)) *toplevel-compilations*))
+  (unless (lookup name *env*)
+    (push (make-var-binding name) *env*)
+    (push (concat "var " (lookup-variable name *env*)) *toplevel-compilations*)))
 
 (defun %compile-defun (name)
-  (push (make-func-binding name) *fenv*)
-  (push (concat "var " (lookup-variable name *fenv*)) *toplevel-compilations*))
+  (unless (lookup name *fenv*)
+    (push (make-func-binding name) *fenv*)
+    (push (concat "var " (lookup-variable name *fenv*)) *toplevel-compilations*)))
 
 (defun %compile-defmacro (name lambda)
   (push (cons name (cons 'macro lambda)) *fenv*))
@@ -491,11 +528,14 @@
     ((integerp sexp) (integer-to-string sexp))
     ((stringp sexp) (concat "\"" sexp "\""))
     ((listp sexp)
-     (let ((sexp (ls-macroexpand-1 sexp env fenv)))
-       (let ((compiler-func (second (assoc (car sexp) *compilations*))))
-         (if compiler-func
-             (apply compiler-func env fenv (cdr sexp))
-             (compile-funcall (car sexp) (cdr sexp) env fenv)))))))
+     (if (assoc (car sexp) *compilations*)
+         (let ((comp (second (assoc (car sexp) *compilations*))))
+           (apply comp env fenv (cdr sexp)))
+         (let ((fn (cdr (assoc (car sexp) *fenv*))))
+           (if (and (listp fn) (eq (car fn) 'macro))
+               (ls-compile (ls-macroexpand-1 sexp env fenv) env fenv)
+               (compile-funcall (car sexp) (cdr sexp) env fenv)))))))
+
 
 (defun ls-compile-toplevel (sexp)
   (setq *toplevel-compilations* nil)
@@ -509,13 +549,24 @@
 
 #+common-lisp
 (progn
-  (defun ls-compile-file (filename output)
+
+  (defun read-whole-file (filename)
     (with-open-file (in filename)
-      (with-open-file (out output :direction :output :if-exists :supersede)
+      (let ((seq (make-array (file-length in) :element-type 'character)))
+        (read-sequence seq in)
+        seq)))
+
+  (defun ls-compile-file (filename output)
+    (setq *env* nil *fenv* nil)
+    (with-open-file (out output :direction :output :if-exists :supersede)
+      (let* ((source (read-whole-file filename))
+             (in (make-string-stream source)))
         (loop
            for x = (ls-read in)
            until (eq x *eof*)
            for compilation = (ls-compile-toplevel x)
-           when compilation do (write-line (concat compilation "; ") out)))))
+           when (plusp (length compilation))
+           do (write-line (concat compilation "; ") out)))))
+
   (defun bootstrap ()
     (ls-compile-file "lispstrack.lisp" "lispstrack.js")))