X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=lispstrack.lisp;h=7a0b9b88a802fe5c00a423fcb6623be44541dcc6;hb=b88e51178beb03271b59cfa329568a8db16e25c9;hp=3f85b93c5361b6ca00fdf6f68aa4f070cd61569d;hpb=370dbb9ff46bd350e178b733ab9ea1d6f7b9a1da;p=jscl.git

diff --git a/lispstrack.lisp b/lispstrack.lisp
index 3f85b93..7a0b9b8 100644
--- a/lispstrack.lisp
+++ b/lispstrack.lisp
@@ -1,65 +1,7 @@
-#+lispstrack
-(progn
-  (eval-when-compile
-    (%compile-defmacro 'defmacro
-                       (lambda (name args &rest body)
-                         `(eval-when-compile
-                            (%compile-defmacro ',name (lambda ,args ,@body))))))
-
-  (defmacro defvar (name value)
-    `(progn
-       (eval-when-compile
-         (%compile-defvar ',name))
-       (setq ,name ,value)))
-
-  (defmacro defun (name args &rest body)
-    `(progn
-       (eval-when-compile
-         (%compile-defun ',name))
-       (fsetq ,name (lambda ,args ,@body))))
-
-  (defun = (x y) (= x y))
-  (defun + (x y) (+ x y))
-  (defun - (x y) (- x y))
-  (defun * (x y) (* x y))
-  (defun / (x y) (/ x y))
-  (defun 1+ (x) (+ x 1))
-  (defun 1- (x) (- x 1))
-  (defun cons (x y) (cons x y))
-  (defun car (x) (car x))
-  (defun cdr (x) (cdr x))
-
-  (defun append (list1 list2)
-    (if (null list1)
-        list2
-        (cons (car list1)
-              (append (cdr list1) list2))))
-
-  (defun reverse-aux (list acc)
-    (if (null list)
-        acc
-        (reverse-aux (cdr list) (cons (car list) acc))))
-
-  (defun reverse (list)
-    (reverse-aux list '()))
-
-  (defun mapcar (func list)
-    (if (null list)
-        '()
-        (cons (funcall func (car list))
-              (mapcar func (cdr list)))))
-
-  (defmacro push (x place)
-    `(setq ,place (cons ,x ,place)))
-
-
-  (defvar *package* (new))
-
-  (defun intern (name)
-    (set *package* name (make-symbol name)))
-
-  (defun find-symbol (name)
-    (get *package* name)))
+(defun ensure-list (x)
+  (if (listp x)
+      x
+      (list x)))
 
 
 (defun !reduce (func list initial)
@@ -78,12 +20,15 @@
          ((not ,condition))
        ,@body))
 
-  #+common-lisp
   (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* "
-")
+(defvar *newline* (string (code-char 10)))
 
 (defun concat (&rest strs)
   (!reduce (lambda (s1 s2) (concat-two s1 s2))
@@ -103,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)
@@ -128,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)))
@@ -218,11 +163,17 @@
        (ecase (%read-char stream)
          (#\'
           (list 'function (ls-read stream)))
+         (#\\
+          (let ((cname (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))
@@ -251,9 +202,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))
                  ";
 "))
 
@@ -263,18 +215,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)
@@ -307,7 +259,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)
@@ -354,9 +308,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))
@@ -380,10 +336,9 @@
 
 #+common-lisp
 (defmacro eval-when-compile (&body body)
-  `(eval-when (:compile-toplevel :execute)
+  `(eval-when (:compile-toplevel :load-toplevel :execute)
      ,@body))
 
-(defvar *eval-when-compilations*)
 (define-compilation eval-when-compile (&rest body)
   (eval (cons 'progn body))
   nil)
@@ -396,8 +351,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.
@@ -448,9 +404,18 @@
 (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) "))"))
 
+(define-compilation mod (x y)
+  (concat "((" (ls-compile x env fenv) ") % (" (ls-compile y env fenv) "))"))
+
+(define-compilation floor (x)
+  (concat "(Math.floor(" (ls-compile x env fenv) "))"))
+
 (define-compilation null (x)
   (concat "(" (ls-compile x env fenv) "== undefined)"))
 
@@ -463,6 +428,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) "}"))
 
@@ -472,11 +444,8 @@
 (define-compilation eq (x y)
   (concat "(" (ls-compile x env fenv) " === " (ls-compile y env fenv) ")"))
 
-(define-compilation eql (x y)
-  (concat "(" (ls-compile x env fenv) " == " (ls-compile y env fenv) ")"))
-
-(define-compilation code-char (x)
-  (concat "String.fromCharCode( " (ls-compile x env fenv) ")"))
+(define-compilation string (x)
+  (concat "String.fromCharCode(" (ls-compile x env fenv) ")"))
 
 (define-compilation char (string index)
   (concat "("
@@ -509,18 +478,22 @@
   (concat "(" (ls-compile object env fenv) ")[" (ls-compile key env fenv) "]"))
 
 (define-compilation set (object key value)
-  (concat "(" (ls-compile object env fenv) ")[" (ls-compile key env fenv) "]")
-  " = " (ls-compile value env fenv))
-
+  (concat "(("
+          (ls-compile object env fenv)
+          ")["
+          (ls-compile key env fenv) "]"
+          " = " (ls-compile value env fenv) ")"))
 
 
 (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*))
@@ -553,11 +526,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)
@@ -571,13 +547,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")))