@amritk/nish-x86_64-linux 0.16.0 → 0.18.0

package/std/json.ts

@@ -1,5 +1,5 @@
 /**
- * `std/json` — the value of one field of one flat JSON object.
+ * `std/json` — the value of a field, or of several, of one flat JSON object.
  *
  * It exists because the compiler's own machine-readable surface is JSON: under
  * `--json` every diagnostic is one flat object on a line of stdout, whose `code`
@@ -26,10 +26,10 @@
  *     whether the whole line was well-formed is asking a question this does not
  *     answer.
  *
- * There is one exported function on purpose. A `std/` module is compiled into
- * the program that imports it and the symbol namespace is flat
+ * There are two exported functions, and few on purpose. A `std/` module is
+ * compiled into the program that imports it and the symbol namespace is flat
  * (`std/README.md`), so every name here is a name its importer cannot use: the
- * helpers are `json`-prefixed and the reader is the only export. Splitting a
+ * helpers are `json`-prefixed and the readers are the only exports. Splitting a
  * stream into lines and picking the ones that start with `{` is two calls the
  * caller already has — `splitLines` from `std/text` and `startsWith` — and
  * duplicating them here would cost more names than it saves.
@@ -46,6 +46,16 @@
  *       }
  *     }
  *
+ * `jsonField` scans from the start of the line on every call, so a caller that
+ * wants three fields of each line reads each line three times. `jsonFields`
+ * reads it once: `jsonFields(line, ["code", "line", "message"])` answers an
+ * array whose slot `k` is exactly what `jsonField(line, names[k])` answers —
+ * absent, first-of-a-duplicate and malformed input included — because the two
+ * share the step that reads one member (`jsonReadMember`) and stop at the same
+ * one. Its array goes back to the caller with the values in it, so a loop that
+ * calls it keeps its per-pass arena release, as one calling `jsonField` does;
+ * `jsonFields`' own comment says when that holds.
+ *
  * Every offset here is a **byte** offset and every width is spelled, with each
  * length and byte a builtin answers read through `toI32` — `.length` and
  * `charCodeAt` answer `number`, which is `f64` under `--number-mode f64`, so the
@@ -53,14 +63,17 @@
  * (`docs/wp26-stdlib.md` §4).
  */
 
+const JSON_BACKSPACE: i32 = 8
 const JSON_TAB: i32 = 9
 const JSON_NEWLINE: i32 = 10
+const JSON_FORM_FEED: i32 = 12
 const JSON_CARRIAGE_RETURN: i32 = 13
 const JSON_SPACE: i32 = 32
 const JSON_QUOTE: i32 = 34
 const JSON_COMMA: i32 = 44
 const JSON_COLON: i32 = 58
 const JSON_BACKSLASH: i32 = 92
+const JSON_LETTER_U: i32 = 117
 const JSON_OPEN_BRACKET: i32 = 91
 const JSON_CLOSE_BRACKET: i32 = 93
 const JSON_OPEN_BRACE: i32 = 123
@@ -261,6 +274,37 @@ const jsonUtf8 = (code: i32): string => {
   return `${lead}${middle}${String.fromCharCode(JSON_UTF8_CONTINUATION + (code & JSON_UTF8_LOW_SIX))}`
 }
 
+/** The number of bytes `jsonUtf8(code)` answers. */
+const jsonUtf8Width = (code: i32): i32 => {
+  if (code < JSON_UTF8_TWO_BYTE_FLOOR) {
+    return 1
+  }
+  if (code < JSON_UTF8_THREE_BYTE_FLOOR) {
+    return 2
+  }
+  return 3
+}
+
+/**
+ * Byte `k` of the `width` bytes `jsonUtf8(code)` answers: its arithmetic, one
+ * byte at a time, for a caller that compares the bytes rather than keeps them.
+ */
+const jsonUtf8Byte = (code: i32, width: i32, k: i32): i32 => {
+  if (width === 1) {
+    return code
+  }
+  if (k === 0) {
+    if (width === 2) {
+      return JSON_UTF8_TWO_BYTE_LEAD + (code >> 6)
+    }
+    return JSON_UTF8_THREE_BYTE_LEAD + (code >> 12)
+  }
+  if (k === width - 1) {
+    return JSON_UTF8_CONTINUATION + (code & JSON_UTF8_LOW_SIX)
+  }
+  return JSON_UTF8_CONTINUATION + ((code >> 6) & JSON_UTF8_LOW_SIX)
+}
+
 /**
  * The bytes of `text[at..end)` with the JSON escapes decoded — the body of a
  * string literal, without its quotes.
@@ -343,6 +387,190 @@ const jsonUnescape = (text: string, at: i32, end: i32): string => {
   return parts.join("")
 }
 
+/** Whether byte `j` of `name` is `code`; an index past either end is not. */
+const jsonNameHas = (name: string, j: i32, code: i32): boolean =>
+  j >= 0 && j < toI32(name.length) && toI32(name.charCodeAt(j)) === code
+
+/**
+ * Whether `jsonUnescape(text, at, end)` would answer `name`, decided without
+ * building it.
+ *
+ * `jsonField` and `jsonFields` ask this of every key they walk past, and almost
+ * every answer is no, so the question is answered the way it is asked: the literal and `name`
+ * are walked together, each escape decoded where it stands, and the first byte
+ * that differs ends the walk. Every escape reads as `jsonUnescape` reads it —
+ * the short forms, a `\u` as the bytes `jsonUtf8` would build, a broken `\u`
+ * as the two bytes `\u`, a backslash with no letter after it as itself, and
+ * any other escape as the byte it escapes — so a key matches here exactly when
+ * its decoded text would.
+ */
+const jsonKeyEquals = (text: string, at: i32, end: i32, name: string): boolean => {
+  // `jsonUnescape`'s guard, for the same reason: every caller passes the
+  // inside of a key `jsonReadMember` found with `jsonEndOfString`.
+  if (at < 0 || end > toI32(text.length)) {
+    return false
+  }
+  let i: i32 = at
+  let j: i32 = 0
+  while (i < end) {
+    const code: i32 = toI32(text.charCodeAt(i))
+    if (code !== JSON_BACKSLASH) {
+      if (!jsonNameHas(name, j, code)) {
+        return false
+      }
+      i += 1
+      j += 1
+      continue
+    }
+    const letter: i32 = i + 1 < end ? toI32(text.charCodeAt(i + 1)) : 0
+    if (letter === JSON_LETTER_U) {
+      const point: i32 = jsonHex4(text, i + 2, end)
+      if (point < 0) {
+        if (!jsonNameHas(name, j, JSON_BACKSLASH) || !jsonNameHas(name, j + 1, JSON_LETTER_U)) {
+          return false
+        }
+        i += 2
+        j += 2
+        continue
+      }
+      const width: i32 = jsonUtf8Width(point)
+      let k: i32 = 0
+      while (k < width) {
+        if (!jsonNameHas(name, j + k, jsonUtf8Byte(point, width, k))) {
+          return false
+        }
+        k += 1
+      }
+      i += 6
+      j += width
+      continue
+    }
+    // Every other escape decodes to one byte.
+    let decoded: i32 = letter
+    if (letter === 110) {
+      decoded = JSON_NEWLINE
+    } else if (letter === 116) {
+      decoded = JSON_TAB
+    } else if (letter === 114) {
+      decoded = JSON_CARRIAGE_RETURN
+    } else if (letter === 98) {
+      decoded = JSON_BACKSPACE
+    } else if (letter === 102) {
+      decoded = JSON_FORM_FEED
+    } else if (letter === 0) {
+      decoded = JSON_BACKSLASH
+    }
+    if (!jsonNameHas(name, j, decoded)) {
+      return false
+    }
+    // A backslash with no letter after it is one byte of the literal and every
+    // other escape two. The steps are constants rather than a variable because
+    // a cursor moved by a variable is one the bounds proof stops following.
+    if (letter === 0) {
+      i += 1
+    } else {
+      i += 2
+    }
+    j += 1
+  }
+  return j === toI32(name.length)
+}
+
+/**
+ * Where one member of an object lies, as `jsonReadMember` found it: the inside
+ * of its key literal, its value, and the opening quote of the key after it.
+ *
+ * It is a class so that one step can answer the four offsets together, and
+ * each reader allocates exactly one, which never leaves the reader: that is
+ * what keeps it a stack slot rather than an arena allocation.
+ */
+class JsonMember {
+  keyAt: i32 = 0
+  keyEnd: i32 = 0
+  valueAt: i32 = 0
+  valueEnd: i32 = 0
+  /** The opening quote of the next key, or `-1` when no comma follows the value. */
+  next: i32 = -1
+}
+
+/**
+ * The opening quote of the first key of `object`, or `-1` when `object` does
+ * not start, past any blanks, with a `{`.
+ */
+const jsonFirstKey = (object: string): i32 => {
+  const length: i32 = toI32(object.length)
+  const i: i32 = jsonSkipBlank(object, 0)
+  if (i >= length || toI32(object.charCodeAt(i)) !== JSON_OPEN_BRACE) {
+    return -1
+  }
+  return jsonSkipBlank(object, i + 1)
+}
+
+/**
+ * Reads the member whose key's opening quote is at `at` into `member`, and
+ * answers whether there was one.
+ *
+ * This is the per-key step `jsonField` and `jsonFields` share, so they cannot
+ * disagree about where a member ends: `false` for anything that is not a key,
+ * a colon and a whole value in that order, which is the point at which both
+ * stop. A value need not be followed by a comma — a truncated object still
+ * answers the fields before the cut — so a missing one only sets `next` to
+ * `-1`, and the read that follows answers `false`.
+ */
+const jsonReadMember = (object: string, at: i32, member: JsonMember): boolean => {
+  const length: i32 = toI32(object.length)
+  // `jsonSkipBlank` never answers a negative index for a non-negative one, but
+  // the bounds proof does not look inside a callee, so every cursor it answers
+  // is tested for `i < 0` beside `i >= length`: the pair is what lets each read
+  // below go without a check.
+  if (at < 0 || at >= length || toI32(object.charCodeAt(at)) !== JSON_QUOTE) {
+    return false
+  }
+  const keyEnd: i32 = jsonEndOfString(object, at)
+  if (keyEnd < 0) {
+    return false
+  }
+  const colon: i32 = jsonSkipBlank(object, keyEnd)
+  if (colon < 0 || colon >= length || toI32(object.charCodeAt(colon)) !== JSON_COLON) {
+    return false
+  }
+  const valueAt: i32 = jsonSkipBlank(object, colon + 1)
+  const valueEnd: i32 = jsonEndOfValue(object, valueAt)
+  if (valueEnd < 0) {
+    return false
+  }
+  member.keyAt = at + 1
+  member.keyEnd = keyEnd - 1
+  member.valueAt = valueAt
+  member.valueEnd = valueEnd
+  const comma: i32 = jsonSkipBlank(object, valueEnd)
+  if (comma < 0 || comma >= length || toI32(object.charCodeAt(comma)) !== JSON_COMMA) {
+    member.next = -1
+  } else {
+    member.next = jsonSkipBlank(object, comma + 1)
+  }
+  return true
+}
+
+/**
+ * The text a member's value answers: a string unquoted and unescaped, anything
+ * else as the bytes it was written with.
+ */
+const jsonValueText = (object: string, member: JsonMember): string => {
+  const valueAt: i32 = member.valueAt
+  const valueEnd: i32 = member.valueEnd
+  // `jsonReadMember` only fills in a value `jsonEndOfValue` ended, which starts
+  // inside the object and never ends past it, so this changes no answer: it is
+  // the range the value's first byte and its `substring` are proved in.
+  if (valueAt < 0 || valueAt >= valueEnd || valueEnd > toI32(object.length)) {
+    return ""
+  }
+  if (toI32(object.charCodeAt(valueAt)) === JSON_QUOTE) {
+    return jsonUnescape(object, valueAt + 1, valueEnd - 1)
+  }
+  return object.substring(valueAt, valueEnd)
+}
+
 /**
  * The value of `name` in `object`, or `null` when the object does not have that
  * field.
@@ -358,45 +586,73 @@ const jsonUnescape = (text: string, at: i32, end: i32): string => {
  * and it is the shape the compiler's `--json` line has.
  */
 export const jsonField = (object: string, name: string): string | null => {
-  const length: i32 = toI32(object.length)
-  let i: i32 = jsonSkipBlank(object, 0)
-  if (i >= length || toI32(object.charCodeAt(i)) !== JSON_OPEN_BRACE) {
-    return null
-  }
-  i = jsonSkipBlank(object, i + 1)
-  // `jsonSkipBlank` never answers a negative index for a non-negative one, but
-  // the bounds proof does not look inside a callee, so every cursor it answers
-  // is tested for `i < 0` beside `i >= length`: the pair is what lets each read
-  // below go without a check.
-  while (i >= 0 && i < length && toI32(object.charCodeAt(i)) === JSON_QUOTE) {
-    const keyEnd: i32 = jsonEndOfString(object, i)
-    if (keyEnd < 0) {
-      return null
-    }
-    const key: string = jsonUnescape(object, i + 1, keyEnd - 1)
-    i = jsonSkipBlank(object, keyEnd)
-    if (i < 0 || i >= length || toI32(object.charCodeAt(i)) !== JSON_COLON) {
-      return null
+  const member: JsonMember = new JsonMember()
+  let at: i32 = jsonFirstKey(object)
+  while (jsonReadMember(object, at, member)) {
+    // The key is compared where it stands rather than unescaped into a string
+    // first: every key before the one asked for is a no, and a no should not
+    // cost an allocation.
+    if (jsonKeyEquals(object, member.keyAt, member.keyEnd, name)) {
+      return jsonValueText(object, member)
     }
-    const valueAt: i32 = jsonSkipBlank(object, i + 1)
-    const valueEnd: i32 = jsonEndOfValue(object, valueAt)
-    // `jsonEndOfValue` answers `-1` for a `valueAt` outside the object and never
-    // answers past its end, so the last three tests change no answer: they are
-    // the range the value's first byte and its `substring` are proved in.
-    if (valueEnd < 0 || valueAt < 0 || valueAt >= length || valueEnd > toI32(object.length)) {
-      return null
-    }
-    if (key === name) {
-      if (toI32(object.charCodeAt(valueAt)) === JSON_QUOTE) {
-        return jsonUnescape(object, valueAt + 1, valueEnd - 1)
+    at = member.next
+  }
+  return null
+}
+
+/**
+ * The value of every one of `names` in `object`, in the order of `names`: slot
+ * `k` is exactly what `jsonField(object, names[k])` answers.
+ *
+ * It is for a caller that wants several fields of one line — a diagnostic's
+ * `code`, `line` and `message` — and would otherwise scan the line once per
+ * field. This scans it once, left to right, and stops as soon as every name has
+ * answered: a speed path and nothing more, since a slot is filled only once
+ * and reading on could change no answer. Each slot keeps the **first** field of its name, as `jsonField`
+ * does; a name asked for twice answers in both slots; and a malformed object
+ * answers in each slot what `jsonField` answers for that name, because both
+ * stop at the same member.
+ *
+ * The answer is a fresh array and the only allocation besides the values. Each
+ * value is stored into it by a plain `values[k] = text` statement, and the
+ * array is only stored into, tested and returned, so the values travel with
+ * the array: the call lets nothing else out (LANGUAGE.md, "Memory model", a
+ * value stored into an array that is returned with it). A loop calling this
+ * keeps its per-pass release on a line older than the pass, as `jsonField`'s
+ * does, and a `using a = arena()` block may hold the call. On a line built in
+ * the pass neither reader keeps the release (LANGUAGE.md, "Memory model").
+ * Reading `values` back, passing it to a function, or storing it anywhere
+ * before the return would undo this; `tests/link/std_json` pins the flat
+ * arena and the `using` block.
+ */
+export const jsonFields = (object: string, names: string[]): (string | null)[] => {
+  const count: i32 = toI32(names.length)
+  const values: (string | null)[] = new Array<string | null>(count)
+  const member: JsonMember = new JsonMember()
+  let missing: i32 = count
+  let at: i32 = jsonFirstKey(object)
+  while (missing > 0 && jsonReadMember(object, at, member)) {
+    // A value is built once per member however many names it answers, and
+    // only when one of them does.
+    let text: string | null = null
+    let k: i32 = 0
+    // Bounded by both lengths, which are the same, because the bounds proof
+    // follows each array by its own length and not by `count`.
+    while (k < toI32(values.length) && k < toI32(names.length)) {
+      if (values[k] === null && jsonKeyEquals(object, member.keyAt, member.keyEnd, names[k])) {
+        if (text === null) {
+          text = jsonValueText(object, member)
+        }
+        // Always true: the loop's own test. A call stands between it and the
+        // store, and a call is where the bounds proof forgets a length.
+        if (k < toI32(values.length)) {
+          values[k] = text
+        }
+        missing -= 1
       }
-      return object.substring(valueAt, valueEnd)
-    }
-    i = jsonSkipBlank(object, valueEnd)
-    if (i < 0 || i >= length || toI32(object.charCodeAt(i)) !== JSON_COMMA) {
-      return null
+      k += 1
     }
-    i = jsonSkipBlank(object, i + 1)
+    at = member.next
   }
-  return null
+  return values
 }