@amritk/nish-x86_64-linux 0.20.0 → 0.21.0

package/std/json-value.ts

@@ -53,7 +53,8 @@
  *
  * **Numbers are lossless.** A number keeps its source text, and is read as
  * whatever the caller asks for when it asks: `i64` and `u64` when the text is
- * an integer that fits (`isI64`, `isU64`), the nearest `f64` (`f64`, correctly
+ * an integer that fits (`isI64`, `isU64`), whether its value is whole at all
+ * (`isIntegral`, so `1.0` and `1e2` are), the nearest `f64` (`f64`, correctly
  * rounded, the tokenizer's `numberF64`), or the text itself (`numberText`).
  * Writing it back copies the text. So `18446744073709551616`, wider than any
  * integer type, and `0.1000000000000000055511151231257827`, more digits than an
@@ -748,7 +749,11 @@ export class JsonDocument {
     return this.textOf(jsonValueGet(this.first, x), jsonValueGet(this.count, x))
   }
 
-  /** Whether `v` is a number written without a fraction or an exponent whose value fits an `i64`. */
+  /**
+   * Whether `v` is a number written without a fraction or an exponent whose
+   * value fits an `i64`: the spelling, so `1.0` is not one. `isIntegral(v)`
+   * asks whether the value is whole.
+   */
   isI64(v: JsonValue): boolean {
     return this.readNumber(this.index(v)) && this.numbers.isInteger()
   }
@@ -759,7 +764,10 @@ export class JsonDocument {
     return this.readNumber(this.index(v)) ? this.numbers.numberI64() : toI64(0)
   }
 
-  /** Whether `v` is a number written without a sign, a fraction or an exponent whose value fits a `u64`. */
+  /**
+   * Whether `v` is a number written without a sign, a fraction or an exponent
+   * whose value fits a `u64`: the spelling, as `isI64(v)` is.
+   */
   isU64(v: JsonValue): boolean {
     this.unsigned(this.index(v))
     return this.unsignedFits
@@ -804,6 +812,17 @@ export class JsonDocument {
     return acc
   }
 
+  /**
+   * Whether `v` is a number whose value is whole, however it is written:
+   * JSON Schema 2020-12's "integer", the tokenizer's `isIntegral`. `1.0`,
+   * `1e2` and `1e400` are, where `isI64(v)` and `isU64(v)` go by spelling and
+   * by range and answer `false` for all three. `false` for any other kind and
+   * for a handle from an earlier parse.
+   */
+  isIntegral(v: JsonValue): boolean {
+    return this.readNumber(this.index(v)) && this.numbers.isIntegral()
+  }
+
   /** A number's nearest `f64`, ties to even, as `JSON.parse` reads it; `0` for any other value. */
   f64(v: JsonValue): f64 {
     if (!this.readNumber(this.index(v))) {

package/std/json.ts

@@ -109,6 +109,8 @@
  * (`docs/wp26-stdlib.md` §4).
  */
 
+import { copyBytes, skipJsonPlain } from "nish/bytes"
+
 const JSON_BACKSPACE: i32 = 8
 const JSON_TAB: i32 = 9
 const JSON_NEWLINE: i32 = 10
@@ -1576,14 +1578,26 @@ const jsonWriterPutString = (w: JsonWriter, s: string): boolean => {
   return true
 }
 
+/**
+ * The shortest window `jsonWriterPutBytes` hands to `skipJsonPlain` and
+ * `copyBytes`; a shorter one keeps the byte loop, where the two calls cost
+ * more than the bytes they would save (docs/wp38-simd.md, "JsonWriter's byte
+ * writers").
+ */
+const JSON_PLAIN_RUN_MIN: i32 = 16
+
 /**
  * `jsonWriterPutString` over `bytes[off .. off + len)`, a window the caller
  * has checked: the same quotes and escapes, from the same three helpers, so
  * the two write the same bytes for the same text. The loop is its own rather
  * than shared with the string one, so that `string` and `key` keep the code
- * they had.
+ * they had. A window of `JSON_PLAIN_RUN_MIN` bytes or more goes to
+ * `jsonWriterPutRuns` instead.
  */
 const jsonWriterPutBytes = (w: JsonWriter, bytes: u8[], off: i32, len: i32): boolean => {
+  if (len >= JSON_PLAIN_RUN_MIN) {
+    return jsonWriterPutRuns(w, bytes, off, len)
+  }
   const buf: u8[] = w.buf
   const cap: i32 = toI32(buf.length)
   let at: i32 = w.end
@@ -1637,6 +1651,74 @@ const jsonWriterPutBytes = (w: JsonWriter, bytes: u8[], off: i32, len: i32): boo
   return true
 }
 
+/**
+ * `jsonWriterPutBytes` a run at a time: `skipJsonPlain` finds where the bytes
+ * that need no escape end, `copyBytes` moves them in one copy, and only the
+ * byte the walk stopped at is escaped. The same bytes as the byte loop, the
+ * same all-or-nothing on a full buffer. Variable-time, as the loop is: this
+ * writes text, never key material.
+ */
+const jsonWriterPutRuns = (w: JsonWriter, bytes: u8[], off: i32, len: i32): boolean => {
+  const buf: u8[] = w.buf
+  const cap: i32 = toI32(buf.length)
+  let at: i32 = w.end
+  if (at < 0 || at >= cap) {
+    w.failed = JSON_WRITE_FULL
+    return false
+  }
+  buf[at] = toU8(JSON_QUOTE)
+  at += 1
+  const stop: i32 = off + len
+  let i: i32 = off
+  while (i >= 0 && i < stop && i < toI32(bytes.length)) {
+    const run: i32 = skipJsonPlain(bytes, i, stop)
+    const count: i32 = run - i
+    if (count > 0) {
+      if (at > cap - count) {
+        w.failed = JSON_WRITE_FULL
+        return false
+      }
+      copyBytes(buf, at, bytes, i, count)
+      at += count
+      i = run
+    }
+    if (i < 0 || i >= stop || i >= toI32(bytes.length)) {
+      break
+    }
+    const code: i32 = toI32(bytes[i])
+    i += 1
+    const letter: i32 = jsonShortEscape(code)
+    if (letter !== 0) {
+      if (at < 0 || at + 1 >= cap) {
+        w.failed = JSON_WRITE_FULL
+        return false
+      }
+      buf[at] = toU8(JSON_BACKSLASH)
+      buf[at + 1] = toU8(letter)
+      at += 2
+      continue
+    }
+    if (at < 0 || at + 5 >= cap) {
+      w.failed = JSON_WRITE_FULL
+      return false
+    }
+    buf[at] = toU8(JSON_BACKSLASH)
+    buf[at + 1] = toU8(JSON_LETTER_U)
+    buf[at + 2] = toU8(JSON_DIGIT_ZERO)
+    buf[at + 3] = toU8(JSON_DIGIT_ZERO)
+    buf[at + 4] = toU8(jsonHexByte(code >> 4))
+    buf[at + 5] = toU8(jsonHexByte(code & 15))
+    at += 6
+  }
+  if (at >= cap) {
+    w.failed = JSON_WRITE_FULL
+    return false
+  }
+  buf[at] = toU8(JSON_QUOTE)
+  w.end = at + 1
+  return true
+}
+
 /**
  * The decimal digits of `v`, then `suffix` as one more digit when it is not
  * negative, at the cursor; all of them or, with `JSON_WRITE_FULL`, none.