NTH-VALUE macro

[jscl.git] / src / compiler.lisp

diff --git a/src/compiler.lisp b/src/compiler.lisp
index 2d51fb2..7d3f60c 100644 (file)
--- a/src/compiler.lisp
+++ b/src/compiler.lisp
@@ -50,7 +50,7 @@
 ;;; 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
@@ -58,10 +58,7 @@
 ;;; 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
@@ -193,10 +190,9 @@
          *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))
 
@@ -1330,20 +1326,20 @@
       "return tmp === undefined? " (ls-compile nil) " : tmp;" )))
 
 (define-raw-builtin oget (object key &rest keys)
-  `(code "js_to_lisp(" ,(ls-compile `(oget* ,object ,key ,@keys)) ")"))
+  `(call js_to_lisp ,(ls-compile `(oget* ,object ,key ,@keys))))
 
 (define-raw-builtin oset (value object key &rest keys)
   (ls-compile `(oset* (lisp-to-js ,value) ,object ,key ,@keys)))
 
 (define-builtin objectp (x)
-  (js!bool `(code "(typeof (" ,x ") === 'object')")))
+  (js!bool `(=== (typeof ,x) "object")))
 
-(define-builtin lisp-to-js (x) `(code "lisp_to_js(" ,x ")"))
-(define-builtin js-to-lisp (x) `(code "js_to_lisp(" ,x ")"))
+(define-builtin lisp-to-js (x) `(call lisp_to_js ,x))
+(define-builtin js-to-lisp (x) `(call js_to_lisp ,x))
 
 
 (define-builtin in (key object)
-  (js!bool `(code "(xstring(" ,key ") in (" ,object "))")))
+  (js!bool `(in (call xstring ,key) ,object)))
 
 (define-builtin map-for-in (function object)
   (js!selfcall
@@ -1455,10 +1451,10 @@
 " *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
@@ -1492,6 +1488,9 @@
         (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)