+(defun ensure-list (x)
+ (if (listp x)
+ x
+ (list x)))
+
+
(defun !reduce (func list initial)
(if (null list)
initial
((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))
(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)
(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)))
(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)))))
(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))
(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))
";
"))
(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)
(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)
(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) "\"}"))
(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))
#+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)
`((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.
(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)"))
+ (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) "}"))
(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) "}"))
(define-compilation eq (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 "("
(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*))
((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)
#+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")))
projects / jscl.git / blobdiff