+(defun ensure-list (x)
+ (if (listp x)
+ x
+ (list x)))
+
+
(defun !reduce (func list initial)
(if (null list)
initial
,@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)))
(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))
";
"))
(define-compilation if (condition true false)
(concat "("
- (ls-compile condition env fenv) " == undefined"
+ (ls-compile condition env fenv)
" ? "
(ls-compile true env fenv)
" : "
(defun literal->js (sexp)
(cond
- ((null sexp) "unspecified")
+ ((null sexp) "false")
((integerp sexp) (integer-to-string sexp))
((stringp sexp) (concat "\"" sexp "\""))
((symbolp sexp) (concat "{name: \"" (symbol-name sexp) "\"}"))
`((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) "))"))
(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) "}"))
(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 "("
", ")
")"))
+(define-compilation error (string)
+ (concat "console.error(" (ls-compile string env fenv) ")"))
+
+
(define-compilation new ()
"{}")
((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")))