#+ecmalisp
(progn
-
- 'defmacro
(eval-when-compile
(%compile-defmacro 'defmacro
'(lambda (name args &rest body)
,@body)))
',name))))
+ (setq nil 'nil)
+ (setq t 't)
+
+ (defmacro when (condition &body body)
+ `(if ,condition (progn ,@body) nil))
+
+ (defmacro unless (condition &body body)
+ `(if ,condition nil (progn ,@body)))
+
(defmacro defvar (name value)
`(progn
+ (unless (boundp ',name)
+ (setq ,name ,value))
+ ',name))
+
+ (defmacro defparameter (name value)
+ `(progn
(setq ,name ,value)
',name))
- (defmacro named-lambda (name args &body body)
+ (defmacro named-lambda (name args &rest body)
(let ((x (gensym "FN")))
`(let ((,x (lambda ,args ,@body)))
(oset ,x "fname" ,name)
,x)))
- (defmacro defun (name args &body body)
+ (defmacro defun (name args &rest body)
`(progn
- (eval-when-compile
- (%compile-defun ',name))
- (fsetq ,name (named-lambda ,(symbol-name name) ,args
- (block ,name ,@body)))
+ (fset ',name
+ (named-lambda ,(symbol-name name)
+ ,args
+ (block ,name ,@body)))
',name))
(defvar *package* (new))
- (defvar nil 'nil)
- (defvar t 't)
-
(defun null (x)
(eq x nil))
(setq *gensym-counter* (+ *gensym-counter* 1))
(make-symbol (concat-two prefix (integer-to-string *gensym-counter*))))
+ (defun boundp (x)
+ (boundp x))
+
;; Basic functions
(defun = (x y) (= x y))
(defun + (x y) (+ x y))
(defmacro push (x place)
`(setq ,place (cons ,x ,place)))
- (defmacro when (condition &body body)
- `(if ,condition (progn ,@body) nil))
-
- (defmacro unless (condition &body body)
- `(if ,condition nil (progn ,@body)))
-
(defmacro dolist (iter &body body)
(let ((var (first iter))
(g!list (gensym)))
(car alist))
(defun string= (s1 s2)
- (equal s1 s2)))
+ (equal s1 s2))
+
+ (defun fdefinition (x)
+ (cond
+ ((functionp x)
+ x)
+ ((symbolp x)
+ (symbol-function x))
+ (t
+ (error "Invalid function"))))
+
+ (defun disassemble (function)
+ (write-line (lambda-code (fdefinition function)))
+ nil))
;;; The compiler offers some primitives and special forms which are
(let ((b (make-binding symbol 'lexical-variable (gvarname symbol) t)))
(push-to-lexenv b new 'variable)))))
-(defvar *function-counter* 0)
-(defun lookup-function (symbol env)
- (or (lookup-in-lexenv symbol env 'function)
- (lookup-in-lexenv symbol *environment* 'function)
- (let ((name (symbol-name symbol))
- (binding
- (make-binding symbol
- 'function
- (concat "f" (integer-to-string (incf *function-counter*)))
- nil)))
- (push-to-lexenv binding *environment* 'function)
- (push (lambda ()
- (let ((b (lookup-in-lexenv symbol *environment* 'function)))
- (unless (binding-declared b)
- (error (concat "Undefined function `" name "'")))))
- *compilation-unit-checks*)
- binding)))
-
-(defun lookup-function-translation (symbol env)
- (binding-translation (lookup-function symbol env)))
-
;;; Toplevel compilations
(defvar *toplevel-compilations* nil)
(defun get-toplevel-compilations ()
(reverse (remove-if #'null-or-empty-p *toplevel-compilations*)))
-(defun %compile-defun (name)
- (let ((b (lookup-function name *environment*)))
- (mark-binding-as-declared b)
- (toplevel-compilation (concat "var " (binding-translation b)))))
-
(defun %compile-defmacro (name lambda)
+ (toplevel-compilation (ls-compile `',name))
(push-to-lexenv (make-binding name 'macro lambda t) *environment* 'function))
(defvar *compilations* nil)
(defun ls-compile-block (sexps env)
(join-trailing
- (remove-if #'null
- (mapcar (lambda (x) (ls-compile x env)) sexps))
+ (remove-if #'null-or-empty-p
+ (mapcar (lambda (x) (ls-compile x env)) sexps))
(concat ";" *newline*)))
(defmacro define-compilation (name args &body body)
"return " (ls-compile (car (last body)) new-env) ";")) *newline*
"})"))))
-(define-compilation fsetq (var val)
- (concat (lookup-function-translation var env)
- " = "
- (ls-compile val env)))
-
(define-compilation setq (var val)
(let ((b (lookup-in-lexenv var env 'variable)))
(if (eq (binding-type b) 'lexical-variable)
((integerp sexp) (integer-to-string sexp))
((stringp sexp) (concat "\"" (escape-string sexp) "\""))
((symbolp sexp)
- #+common-lisp
(or (cdr (assoc sexp *literal-symbols*))
(let ((v (genlit))
- (s (concat "{name: \"" (escape-string (symbol-name sexp)) "\"}")))
+ (s #+common-lisp (concat "{name: \"" (escape-string (symbol-name sexp)) "\"}")
+ #+ecmalisp (ls-compile `(intern ,(symbol-name sexp)))))
(push (cons sexp v) *literal-symbols*)
(toplevel-compilation (concat "var " v " = " s))
- v))
- #+ecmalisp
- (let ((v (genlit))
- (s (ls-compile `(intern ,(symbol-name sexp)))))
- (toplevel-compilation (concat "var " v " = " s))
- v))
+ v)))
((consp sexp)
(let ((c (concat "{car: " (literal (car sexp) t) ", "
"cdr: " (literal (cdr sexp) t) "}")))
((and (listp x) (eq (car x) 'lambda))
(ls-compile x env))
((symbolp x)
- (lookup-function-translation x env))))
+ (ls-compile `(symbol-function ',x))
+ ;; TODO: Add lexical functions
+ ;;(lookup-function-translation x env)
+ )))
(define-compilation eval-when-compile (&rest body)
(eval (cons 'progn body))
(ls-compile-block (butlast body) env)
"return " (ls-compile (car (last body)) env) ";" *newline*))
+
+(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*)))
+
+
(define-compilation let (bindings &rest body)
(let ((bindings (mapcar #'ensure-list bindings)))
(let ((variables (mapcar #'first bindings))
(values (mapcar #'second bindings)))
- (let ((new-env (extend-local-env variables env)))
+ (let ((new-env (extend-local-env (remove-if #'boundp variables) env))
+ (dynamic-bindings))
(concat "(function("
(join (mapcar (lambda (x)
- (translate-variable x new-env))
+ (if (boundp x)
+ (let ((v (gvarname x)))
+ (push (cons x v) dynamic-bindings)
+ v)
+ (translate-variable x new-env)))
variables)
",")
"){" *newline*
- (indent (ls-compile-block (butlast body) new-env)
- "return " (ls-compile (car (last body)) new-env)
- ";" *newline*)
+ (let ((body
+ (concat (ls-compile-block (butlast body) new-env)
+ "return " (ls-compile (car (last body)) new-env)
+ ";" *newline*)))
+ (indent (dynamic-binding-wrapper dynamic-bindings body)))
"})(" (join (mapcar (lambda (x) (ls-compile x env))
values)
",")
;;; Primitives
(defmacro define-builtin (name args &body body)
- `(define-compilation ,name ,args
- (let ,(mapcar (lambda (arg) `(,arg (ls-compile ,arg env))) args)
- ,@body)))
+ `(progn
+ (define-compilation ,name ,args
+ (let ,(mapcar (lambda (arg) `(,arg (ls-compile ,arg env))) args)
+ ,@body))))
;;; DECLS is a list of (JSVARNAME TYPE LISPFORM) declarations.
(defmacro type-check (decls &body body)
(concat "(" x ").name"))
(define-builtin set (symbol value)
- (concat "(" symbol ").value =" value))
+ (concat "(" symbol ").value = " value))
+
+(define-builtin fset (symbol value)
+ (concat "(" symbol ").function = " value))
+
+(define-builtin boundp (x)
+ (js!bool (concat "(" x ".value !== undefined)")))
(define-builtin symbol-value (x)
(js!selfcall
"return value;" *newline*))
(define-builtin symbol-function (x)
- (concat "(" x ").function"))
+ (js!selfcall
+ "var symbol = " x ";" *newline*
+ "var func = symbol.function;" *newline*
+ "if (func === undefined) throw \"Function `\" + symbol.name + \"' is undefined.\";" *newline*
+ "return func;" *newline*))
+
+(define-builtin symbol-plist (x)
+ (concat "((" x ").plist || " (ls-compile nil) ")"))
+
+(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 ")")))
(type-check (("x" "string" x))
"lisp.write(x)"))
-(defun macrop (x)
- (and (symbolp x) (eq (binding-type (lookup-function x *environment*)) 'macro)))
+(defun macro (x)
+ (and (symbolp x)
+ (let ((b (lookup-in-lexenv x *environment* 'function)))
+ (and (eq (binding-type b) 'macro)
+ b))))
-(defun ls-macroexpand-1 (form env)
- (if (macrop (car form))
- (let ((binding (lookup-function (car form) *environment*)))
- (if (eq (binding-type binding) 'macro)
- (apply (eval (binding-translation binding)) (cdr form))
- form))
- form))
+(defun ls-macroexpand-1 (form)
+ (let ((macro-binding (macro (car form))))
+ (if macro-binding
+ (apply (eval (binding-translation macro-binding)) (cdr form))
+ form)))
(defun compile-funcall (function args env)
- (cond
- ((symbolp function)
- (concat (lookup-function-translation function env)
- "("
- (join (mapcar (lambda (x) (ls-compile x env)) args)
- ", ")
- ")"))
- ((and (listp function) (eq (car function) 'lambda))
- (concat "(" (ls-compile function env) ")("
- (join (mapcar (lambda (x) (ls-compile x env)) args)
- ", ")
- ")"))
- (t
- (error (concat "Invalid function designator " (symbol-name function))))))
+ (concat (ls-compile `#',function) "("
+ (join (mapcar (lambda (x) (ls-compile x env)) args)
+ ", ")
+ ")"))
(defun ls-compile (sexp &optional (env (make-lexenv)))
(cond
(if (assoc (car sexp) *compilations*)
(let ((comp (second (assoc (car sexp) *compilations*))))
(apply comp env (cdr sexp)))
- (if (macrop (car sexp))
- (ls-compile (ls-macroexpand-1 sexp env) env)
+ (if (macro (car sexp))
+ (ls-compile (ls-macroexpand-1 sexp) env)
(compile-funcall (car sexp) (cdr sexp) env))))))
(defun ls-compile-toplevel (sexp)
- (setq *toplevel-compilations* nil)
- (cond
- ((and (consp sexp) (eq (car sexp) 'progn))
- (let ((subs (mapcar #'ls-compile-toplevel (cdr sexp))))
- (join (remove-if #'null-or-empty-p subs))))
- (t
- (let ((code (ls-compile sexp)))
- (prog1
- (concat (join-trailing (get-toplevel-compilations) (concat ";" *newline*))
- (if code
- (concat code ";" *newline*)
- ""))
- (setq *toplevel-compilations* nil))))))
+ (let ((*toplevel-compilations* nil))
+ (cond
+ ((and (consp sexp) (eq (car sexp) 'progn))
+ (let ((subs (mapcar #'ls-compile-toplevel (cdr sexp))))
+ (join (remove-if #'null-or-empty-p subs))))
+ (t
+ (let ((code (ls-compile sexp)))
+ (concat (join-trailing (get-toplevel-compilations)
+ (concat ";" *newline*))
+ (if code
+ (concat code ";" *newline*)
+ "")))))))
;;; Once we have the compiler, we define the runtime environment and
`(oset *package* ,(symbol-name (car s))
(js-vref ,(cdr s))))
*literal-symbols*)
+ (setq *literal-symbols* ',*literal-symbols*)
(setq *environment* ',*environment*)
(setq *variable-counter* ,*variable-counter*)
- (setq *function-counter* ,*function-counter*)
(setq *gensym-counter* ,*gensym-counter*)
(setq *block-counter* ,*block-counter*)))))
(eval-when-compile
(toplevel-compilation
- (ls-compile `(setq *literal-counter* ,*literal-counter*)))))
+ (ls-compile
+ `(setq *literal-counter* ,*literal-counter*)))))
;;; Finally, we provide a couple of functions to easily bootstrap
(setq *literal-symbols* nil)
(setq *variable-counter* 0
*gensym-counter* 0
- *function-counter* 0
*literal-counter* 0
*block-counter* 0)
(ls-compile-file "ecmalisp.lisp" "ecmalisp.js")))
projects / jscl.git / blobdiff