Migrate GET-INTERNAL-REAL-TIME

[jscl.git] / src / compiler.lisp

diff --git a/src/compiler.lisp b/src/compiler.lisp
index 57a7e79..86fc874 100644 (file)
--- a/src/compiler.lisp
+++ b/src/compiler.lisp
@@ -1184,9 +1184,11 @@
 
 (define-builtin stringp (x)
   (js!bool
-   (js!selfcall
-     "var x = " x ";"
-     "return typeof(x) == 'object' && 'length' in x && x.stringp == 1;")))
+   (js!selfcall*
+     `(var (x ,x))
+     `(return (and (and (===(typeof x) "object")
+                        (in "length" x))
+                   (== (get x "stringp") 1))))))
 
 (define-raw-builtin funcall (func &rest args)
   (js!selfcall
@@ -1222,22 +1224,22 @@
 
 (define-builtin js-eval (string)
   (if *multiple-value-p*
-      (js!selfcall
-        "var v = globalEval(xstring(" string "));"
-        "return values.apply(this, forcemv(v));" )
-      `(code "globalEval(xstring(" ,string "))")))
+      (js!selfcall*
+        `(var (v (call |globalEval| (call |xstring| ,string))))
+        `(return (call (get |values| "apply") this (call |forcemv| v))))
+      `(call |globalEval| (call |xstring| ,string))))
 
 (define-builtin %throw (string)
-  (js!selfcall "throw " string ";" ))
+  (js!selfcall* `(throw ,string)))
 
 (define-builtin functionp (x)
-  (js!bool `(code "(typeof " ,x " == 'function')")))
+  (js!bool `(=== (typeof ,x) "function")))
 
 (define-builtin %write-string (x)
-  `(code "lisp.write(" ,x ")"))
+  `(call (get |lisp| "write") ,x))
 
 (define-builtin /debug (x)
-  `(code "console.log(xstring(" ,x "))"))
+  `(call (get |console| "log") (call |xstring| ,x)))
 
 
 ;;; Storage vectors. They are used to implement arrays and (in the
@@ -1245,45 +1247,46 @@
 
 (define-builtin storage-vector-p (x)
   (js!bool
-   (js!selfcall
-     "var x = " x ";"
-     "return typeof x === 'object' && 'length' in x;")))
+   (js!selfcall*
+     `(var (x ,x))
+     `(return (and (=== (typeof x) "object") (in "length" x))))))
 
 (define-builtin make-storage-vector (n)
-  (js!selfcall
-    "var r = [];"
-    "r.length = " n ";"
-    "return r;" ))
+  (js!selfcall*
+    `(var (r #()))
+    `(= (get r "length") ,n)
+    `(return r)))
 
 (define-builtin storage-vector-size (x)
-  `(code ,x ".length"))
+  `(get ,x "length"))
 
 (define-builtin resize-storage-vector (vector new-size)
-  `(code "(" ,vector ".length = " ,new-size ")"))
+  `(= (get ,vector "length") ,new-size))
 
 (define-builtin storage-vector-ref (vector n)
-  (js!selfcall
-    "var x = " "(" vector ")[" n "];"
-    "if (x === undefined) throw 'Out of range';"
-    "return x;" ))
+  (js!selfcall*
+    `(var (x (get ,vector ,n)))
+    `(if (=== x undefined) (throw "Out of range."))
+    `(return x)))
 
 (define-builtin storage-vector-set (vector n value)
-  (js!selfcall
-    "var x = " vector ";"
-    "var i = " n ";"
-    "if (i < 0 || i >= x.length) throw 'Out of range';"
-    "return x[i] = " value ";" ))
+  (js!selfcall*
+    `(var (x ,vector))
+    `(var (i ,n))
+    `(if (or (< i 0) (>= i (get x "length")))
+         (throw "Out of range."))
+    `(return (= (property x i) ,value))))
 
 (define-builtin concatenate-storage-vector (sv1 sv2)
-  (js!selfcall
-    "var sv1 = " sv1 ";"
-    "var r = sv1.concat(" sv2 ");"
-    "r.type = sv1.type;"
-    "r.stringp = sv1.stringp;"
-    "return r;" ))
+  (js!selfcall*
+    `(var (sv1 ,sv1))
+    `(var (r (call (get sv1 "concat") ,sv2)))
+    `(= (get r "type") (get sv1 "type"))
+    `(= (get r "stringp") (get sv1 "stringp"))
+    `(return r)))
 
 (define-builtin get-internal-real-time ()
-  "(new Date()).getTime()")
+  `(call (get (new (call Date)) "getTime")))
 
 (define-builtin values-array (array)
   (if *multiple-value-p*