Method readString

src/lib/json_buffer.ts:387–454

(ptr: number)

  }

  private readString(ptr: number): string {
    if (this.stringCache.has(ptr)) {
      return this.stringCache.get(ptr)!;
    }

    const len = this.u32[ptr >> 2]!;
    const offset = ptr + 4;

    // Optimization: SWAR (SIMD Within A Register) for short strings.
    // TextDecoder has high overhead for short strings (< ~64 chars).
    // Manual decoding is faster, provided we can process 4 bytes at a time.
    if (len < 64) {
      let res = "";
      let i = 0;

      // We can safely read u32 from 'offset' because 'ptr' is 8-byte aligned,
      // making 'offset' (ptr + 4) always 4-byte aligned.
      const u32Index = offset >> 2;
      const loopLimit = len - 3; // Ensure we have a full 4-byte chunk

      for (; i < loopLimit; i += 4) {
        const chunk = this.u32[u32Index + (i >> 2)]!;

        // Magic Mask: 0x80808080
        // Checks bit 7 of all 4 bytes simultaneously.
        // If ANY bit is set, it's UTF-8 (multibyte), so we bail to TextDecoder.
        if ((chunk & 0x80808080) !== 0) {
          i = -1; // Flag as failed
          break;
        }

        // Fast Decode: We verified all 4 bytes are ASCII.
        // Unpack Little-Endian u32 into characters.
        res += String.fromCharCode(
          chunk & 0xff,
          (chunk >> 8) & 0xff,
          (chunk >> 16) & 0xff,
          chunk >>> 24,
        );
      }

      // Handle trailing bytes (0 to 3 bytes remainder) or check failure
      if (i !== -1) {
        for (; i < len; i++) {
          const code = this.u8[offset + i]!;
          if (code & 0x80) {
            i = -1;
            break;
          }
          res += String.fromCharCode(code);
        }
      }

      // If i != -1, we successfully decoded everything as ASCII
      if (i !== -1) {
        this.stringCache.set(ptr, res);
        return res;
      }