jz 0.5.0 → 0.6.0

package/module/console.js

@@ -23,16 +23,13 @@
  * @module console
  */
 
-import { typed, asF64, asI64, mkPtrIR, NULL_NAN, UNDEF_NAN } from '../src/ir.js'
-import { emit } from '../src/emit.js'
-import { valTypeOf, VAL, exprType } from '../src/analyze.js'
+import { typed, asF64, asI64, mkPtrIR, NULL_NAN, UNDEF_NAN, FALSE_NAN, TRUE_NAN } from '../src/ir.js'
+import { emit, deps, reg, hostImport } from '../src/bridge.js'
+import { valTypeOf } from '../src/kind.js'
+import { exprType } from '../src/type.js'
+import { VAL } from '../src/reps.js'
 import { inc, PTR, LAYOUT } from '../src/ctx.js'
 
-const addImportOnce = (ctx, mod, name, fn) => {
-  if (ctx.module.imports.some(i => i[1] === `"${mod}"` && i[2] === `"${name}"`)) return
-  ctx.module.imports.push(['import', `"${mod}"`, `"${name}"`, fn])
-}
-
 // Template-literal concat chains (`a${x}b`) lower to ['()', ['.', X, 'concat'], Y]
 // in prepare. Walking left from the chain root recovers the parts in order; if the
 // base is a `['str', ...]` it's a template-shaped chain (vs an arbitrary user
@@ -52,7 +49,7 @@ const flattenTemplateConcat = (node) => {
 }
 
 const setupWasi = (ctx) => {
-  Object.assign(ctx.core.stdlibDeps, {
+  deps({
     __write_val: ['__ptr_type', '__write_str', '__write_num', '__write_int', '__write_byte', '__static_str'],
     __write_num: ['__ftoa', '__write_str'],
     __write_int: ['__itoa', '__mkstr', '__write_str'],
@@ -60,10 +57,10 @@ const setupWasi = (ctx) => {
     __read_stdin: ['__mkstr'],
   })
 
-  const needFdWrite = () => addImportOnce(ctx, 'wasi_snapshot_preview1', 'fd_write',
+  const needFdWrite = () => hostImport('wasi_snapshot_preview1', 'fd_write',
     ['func', '$__fd_write', ['param', 'i32'], ['param', 'i32'], ['param', 'i32'], ['param', 'i32'], ['result', 'i32']])
 
-  const needFdRead = () => addImportOnce(ctx, 'wasi_snapshot_preview1', 'fd_read',
+  const needFdRead = () => hostImport('wasi_snapshot_preview1', 'fd_read',
     ['func', '$__fd_read', ['param', 'i32'], ['param', 'i32'], ['param', 'i32'], ['param', 'i32'], ['result', 'i32']])
 
   ctx.core.stdlib['__write_str'] = `(func $__write_str (param $fd i32) (param $ptr i64)
@@ -114,6 +111,10 @@ const setupWasi = (ctx) => {
       (then (call $__write_str (local.get $fd) (i64.reinterpret_f64 (call $__static_str (i32.const 5)))) (return)))
     (if (i64.eq (local.get $val) (i64.const ${UNDEF_NAN}))
       (then (call $__write_str (local.get $fd) (i64.reinterpret_f64 (call $__static_str (i32.const 6)))) (return)))
+    (if (i64.eq (local.get $val) (i64.const ${TRUE_NAN}))
+      (then (call $__write_str (local.get $fd) (i64.reinterpret_f64 (call $__static_str (i32.const 3)))) (return)))
+    (if (i64.eq (local.get $val) (i64.const ${FALSE_NAN}))
+      (then (call $__write_str (local.get $fd) (i64.reinterpret_f64 (call $__static_str (i32.const 4)))) (return)))
     (local.set $type (call $__ptr_type (local.get $val)))
     (if (i32.eqz (local.get $type))
       (then (call $__write_str (local.get $fd) (i64.reinterpret_f64 (call $__static_str (i32.const 0)))) (return)))
@@ -123,28 +124,36 @@ const setupWasi = (ctx) => {
       (if (result i32) (i32.eq (local.get $type) (i32.const 1))
         (then (i32.const 7)) (else (i32.const 8)))))))`
 
-  ctx.core.stdlib['__read_stdin'] = `(func $__read_stdin (result f64)
-    (local $iov i32) (local $nio i32) (local $buf i32) (local $total i32) (local $n i32)
+  reg('readStdin', {
+    deps: ['__read_stdin'],
+    wat: `(func $__read_stdin (result f64)
+    (local $iov i32) (local $nio i32) (local $buf i32) (local $cap i32)
+    (local $total i32) (local $n i32) (local $new i32)
     (local.set $iov (call $__alloc (i32.const 8)))
     (local.set $nio (call $__alloc (i32.const 4)))
-    (local.set $buf (call $__alloc (i32.const 65536)))
+    (local.set $cap (i32.const 65536))
+    (local.set $buf (call $__alloc (local.get $cap)))
     (local.set $total (i32.const 0))
     (block $eof (loop $read
+      (if (i32.ge_u (local.get $total) (local.get $cap))
+        (then
+          (local.set $new (call $__alloc (i32.shl (local.get $cap) (i32.const 1))))
+          (memory.copy (local.get $new) (local.get $buf) (local.get $total))
+          (local.set $buf (local.get $new))
+          (local.set $cap (i32.shl (local.get $cap) (i32.const 1)))))
       (i32.store (local.get $iov) (i32.add (local.get $buf) (local.get $total)))
-      (i32.store offset=4 (local.get $iov) (i32.sub (i32.const 65536) (local.get $total)))
+      (i32.store offset=4 (local.get $iov) (i32.sub (local.get $cap) (local.get $total)))
       (drop (call $__fd_read (i32.const 0) (local.get $iov) (i32.const 1) (local.get $nio)))
       (local.set $n (i32.load (local.get $nio)))
       (br_if $eof (i32.eqz (local.get $n)))
       (local.set $total (i32.add (local.get $total) (local.get $n)))
-      (br_if $eof (i32.ge_s (local.get $total) (i32.const 65536)))
       (br $read)))
-    (call $__mkstr (local.get $buf) (local.get $total)))`
-
-  ctx.core.emit['readStdin'] = () => {
-    needFdRead()
-    inc('__read_stdin')
-    return typed(['call', '$__read_stdin'], 'f64')
-  }
+    (call $__mkstr (local.get $buf) (local.get $total)))`,
+    emit: () => {
+      needFdRead()
+      return typed(['call', '$__read_stdin'], 'f64')
+    },
+  })
 
   const makeConsole = (method, fd) => {
     ctx.core.emit[`console.${method}`] = (...args) => {
@@ -186,31 +195,34 @@ const setupWasi = (ctx) => {
   makeConsole('warn', 2)
   makeConsole('error', 2)
 
-  const needClock = () => addImportOnce(ctx, 'wasi_snapshot_preview1', 'clock_time_get',
+  const needClock = () => hostImport('wasi_snapshot_preview1', 'clock_time_get',
     ['func', '$__clock_time_get', ['param', 'i32'], ['param', 'i64'], ['param', 'i32'], ['result', 'i32']])
 
-  ctx.core.stdlib['__time_ms'] = `(func $__time_ms (param $clock i32) (result f64)
+  reg('Date.now', {
+    deps: ['__time_ms'],
+    wat: `(func $__time_ms (param $clock i32) (result f64)
     (drop (call $__clock_time_get (local.get $clock) (i64.const 1000) (i32.const 0)))
-    (f64.div (f64.convert_i64_u (i64.load (i32.const 0))) (f64.const 1000000)))`
-
-  ctx.core.emit['Date.now'] = () => {
-    needClock()
-    inc('__time_ms')
-    return typed(['call', '$__time_ms', ['i32.const', 0]], 'f64')
-  }
-  ctx.core.emit['performance.now'] = () => {
-    needClock()
-    inc('__time_ms')
-    return typed(['call', '$__time_ms', ['i32.const', 1]], 'f64')
-  }
+    (f64.div (f64.convert_i64_u (i64.load (i32.const 0))) (f64.const 1000000)))`,
+    emit: () => {
+      needClock()
+      return typed(['call', '$__time_ms', ['i32.const', 0]], 'f64')
+    },
+  })
+  reg('performance.now', {
+    deps: ['__time_ms'],
+    emit: () => {
+      needClock()
+      return typed(['call', '$__time_ms', ['i32.const', 1]], 'f64')
+    },
+  })
   ctx.core.emit['console.now'] = ctx.core.emit['Date.now']
   ctx.core.emit['console.perfNow'] = ctx.core.emit['performance.now']
 }
 
 const setupJsHost = (ctx) => {
-  const needPrint = () => addImportOnce(ctx, 'env', 'print',
+  const needPrint = () => hostImport('env', 'print',
     ['func', '$__print', ['param', 'i64'], ['param', 'i32'], ['param', 'i32']])
-  const needNow = () => addImportOnce(ctx, 'env', 'now',
+  const needNow = () => hostImport('env', 'now',
     ['func', '$__now', ['param', 'i32'], ['result', 'f64']])
 
   // Empty SSO string ("") for zero-arg console.log() — host reads as "".
@@ -255,14 +267,14 @@ const setupJsHost = (ctx) => {
   makeConsole('warn', 2)
   makeConsole('error', 2)
 
-  ctx.core.emit['Date.now'] = () => {
+  reg('Date.now', [], () => {
     needNow()
     return typed(['call', '$__now', ['i32.const', 0]], 'f64')
-  }
-  ctx.core.emit['performance.now'] = () => {
+  })
+  reg('performance.now', [], () => {
     needNow()
     return typed(['call', '$__now', ['i32.const', 1]], 'f64')
-  }
+  })
   ctx.core.emit['console.now'] = ctx.core.emit['Date.now']
   ctx.core.emit['console.perfNow'] = ctx.core.emit['performance.now']
 }