;;; Wrap X with a Javascript code to convert the result from
;;; Javascript generalized booleans to T or NIL.
(defun js!bool (x)
- `(code "(" ,x "?" ,(ls-compile t) ": " ,(ls-compile nil) ")"))
+ `(if ,x ,(ls-compile t) ,(ls-compile nil)))
;;; Concatenate the arguments and wrap them with a self-calling
;;; Javascript anonymous function. It is used to make some Javascript
;;; It could be defined as function, but we could do some
;;; preprocessing in the future.
(defmacro js!selfcall (&body body)
- ``(code "(function(){" ,*newline*
- (code ,,@body)
- ,*newline*
- "})()"))
+ ``(call (function nil (code ,,@body))))
;;; Like CODE, but prefix each line with four spaces. Two versions
;;; of this function are available, because the Ecmalisp version is
(defun gvarname (symbol)
(declare (ignore symbol))
- (format nil "v~d" (incf *variable-counter*)))
+ (code "v" (incf *variable-counter*)))
(defun translate-variable (symbol)
(awhen (lookup-in-lexenv symbol *environment* 'variable)
*compilations*))
(define-compilation if (condition true &optional false)
- `(code "(" ,(ls-compile condition) " !== " ,(ls-compile nil)
- " ? " ,(ls-compile true *multiple-value-p*)
- " : " ,(ls-compile false *multiple-value-p*)
- ")"))
+ `(if (!== ,(ls-compile condition) ,(ls-compile nil))
+ ,(ls-compile true *multiple-value-p*)
+ ,(ls-compile false *multiple-value-p*)))
(defvar *ll-keywords* '(&optional &rest &key))
(defvar *literal-counter* 0)
(defun genlit ()
- (format nil "l~d" (incf *literal-counter*)))
+ (code "l" (incf *literal-counter*)))
(defun dump-symbol (symbol)
#-jscl
,@(interleave (mapcar #'translate-function fnames) ",")
"){"
,(ls-compile-block body t)
- "})(" ,@cfuncs ")")))
+ "})(" ,@(interleave cfuncs ",") ")")))
(define-compilation labels (definitions &rest body)
(let* ((fnames (mapcar #'car definitions))
(cond
((floatp x) (push (float-to-string x) fargs))
((numberp x) (push (integer-to-string x) fargs))
- (t (let ((v (format nil "x~d" (incf counter))))
+ (t (let ((v (code "x" (incf counter))))
(push v fargs)
(push `(code "var " ,v " = " ,(ls-compile x) ";"
"if (typeof " ,v " !== 'number') throw 'Not a number!';")
" *newline*)
";" ,*newline*))))
-(defun ls-compile (sexp &optional multiple-value-p)
+(defun ls-compile* (sexp &optional multiple-value-p)
(multiple-value-bind (sexp expandedp) (!macroexpand-1 sexp)
(when expandedp
- (return-from ls-compile (ls-compile sexp multiple-value-p)))
+ (return-from ls-compile* (ls-compile sexp multiple-value-p)))
;; The expression has been macroexpanded. Now compile it!
(let ((*multiple-value-p* multiple-value-p))
(cond
(t
(error "How should I compile `~S'?" sexp))))))
+(defun ls-compile (sexp &optional multiple-value-p)
+ `(code "(" ,(ls-compile* sexp multiple-value-p) ")"))
+
(defvar *compile-print-toplevels* nil)