yeptris 0.6.16.1-s390x-linux

data/lib/yeptris/json/descriptor.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+# The Descriptor plan walk (yeptris#293 slice two, over the C plan
+# ABI of libyeptris v0.6.3): compile a row shape once, then apply it
+# to a JSON document in ONE native pass producing typed COLUMNS —
+# the engine never materializes the intermediate Ruby Hash/Array
+# tree (lutaml-model's hydration reads columns, not trees).
+#
+#     descriptor = Yeptris::JSON::Descriptor.build(
+#       kind: :seq, # or :map with path: — the rows container
+#       children: [
+#         { name: "id", kind: :int },
+#         { name: "name", kind: :str },
+#       ])
+#     result = descriptor.walk(json)
+#     result.column("id") # => [1, 2, ...] (nil where null/missing)
+#     result.to_a        # => [{ "id" => 1, "name" => "x" }, ...]
+#
+# Vocabulary alignment with Leptris::XML::Descriptor (the shape
+# vocabulary lutaml-model shares across engines): :collection at the
+# root is the rows container (the seq form), :scalar is the string
+# leaf. Slice one covers rows of scalar leaves — nested plans, the
+# YAML leg, and partial descriptors ride the board item
+# (TODO.restructure/87).
+class Yeptris::JSON::Descriptor
+  class Error < ::Yeptris::JSON::Error; end
+
+  # spec leaf kinds → the C column kind codes (plan.h)
+  LEAF_KINDS = {
+    int: 0,
+    float: 1,
+    str: 2,
+    bool: 3,
+    scalar: 2, # leptris's string-value row kind
+  }.freeze
+  private_constant :LEAF_KINDS
+
+  # root forms: the rows container's shape (:collection is leptris's
+  # name for a repeated-rows container)
+  ROOT_KINDS = %i[seq map collection].freeze
+  private_constant :ROOT_KINDS
+
+  LEAF_SPEC_NAMES = %w[int float str bool].freeze
+  private_constant :LEAF_SPEC_NAMES
+
+  class Handle < ::FFI::AutoPointer
+    def self.release(ptr)
+      ::Yeptris::FFI.yeptris_plan_free(ptr)
+    end
+  end
+
+  # +kind+: :seq (rows are the root array) or :map (rows live under
+  # +path:+'s value). +path+: a String, or an Array of Strings for a
+  # segmented (nested) path. +children+: the leaf columns; each row
+  # is a mapping, every child names one typed column.
+  def self.build(kind:, path: nil, children:)
+    handle, names = compile_handle(kind, path, children)
+    new(handle, names)
+  end
+
+  # The compile half of .build (shared with the YAML subclass's
+  # build — ONE owner of the spec grammar). Returns the owned handle
+  # and the leaf names.
+  def self.compile_handle(kind, path, children)
+    unless ROOT_KINDS.include?(kind)
+      raise ArgumentError, "kind must be one of #{ROOT_KINDS.inspect}, got #{kind.inspect}"
+    end
+    unless children.is_a?(::Array) && !children.empty?
+      raise ArgumentError, "children must be a non-empty Array"
+    end
+
+    leaves = children.map do |child|
+      name = child[:name]
+      code = LEAF_KINDS[child[:kind]]
+      if code.nil?
+        raise ArgumentError,
+              "leaf kind must be one of #{LEAF_KINDS.keys.inspect}, got #{child[:kind].inspect}"
+      end
+      unless name.is_a?(::String) && !name.empty?
+        raise ArgumentError, "leaf name must be a non-empty String, got #{name.inspect}"
+      end
+
+      { "name" => name, "kind" => LEAF_SPEC_NAMES[code] }
+    end
+
+    case path
+    when nil then nil
+    when ::String then spec_path = path
+    when ::Array
+      unless path.all? { |seg| seg.is_a?(::String) && !seg.empty? }
+        raise ArgumentError, "path segments must be non-empty Strings"
+      end
+      spec_path = path
+    else
+      raise ArgumentError, "path must be a String or an Array of Strings"
+    end
+
+    spec = { "kind" => kind == :map ? "map" : "seq", "children" => leaves }
+    spec["path"] = spec_path unless spec_path.nil?
+
+    # the spec is strict JSON (the C compiler parses it through the
+    # strict JSON DOM); compile once, the engine owns the copy
+    spec_json = ::JSON.generate(spec)
+    st = ::FFI::MemoryPointer.new(:int)
+    raw = ::Yeptris::FFI.yeptris_plan_compile(spec_json, spec_json.bytesize, st)
+    if raw.null?
+      raise Error, "plan compile failed (status=#{st.read_int}): #{spec_json}"
+    end
+
+    [Handle.new(raw), leaves.map { |leaf| leaf["name"] }]
+  end
+  private_class_method :compile_handle
+
+  attr_reader :names # the planned leaf names, in spec order
+
+  # @api private — handles come from .build
+  def initialize(handle, names)
+    @handle = handle
+    @names = names.dup.freeze
+  end
+
+  # Applies the plan to +json+ (String or IO): parse the tape, one C
+  # plan pass, bulk-read the typed columns. The returned PlanResult
+  # is standalone Ruby (nothing borrowed from the document).
+  def walk(json)
+    src = ::Yeptris.read_input(json).to_s
+    tape = ::Yeptris::FFI::JsonTape.new
+    rc = ::Yeptris::FFI.yeptris_parse_json_tape(src, src.bytesize, tape)
+    raise ::Yeptris::JSON::ParseError, ::Yeptris::FFI.last_error_message if rc != ::Yeptris::FFI::OK
+
+    begin
+      st = ::FFI::MemoryPointer.new(:int)
+      raw = ::Yeptris::FFI.yeptris_tape_plan_walk(tape, @handle, st)
+      if raw.null?
+        raise Error,
+              "plan walk failed (status=#{st.read_int}) — the document shape " \
+              "disagrees with the plan"
+      end
+
+      begin
+        PlanResult.read(raw, src, @names)
+      ensure
+        ::Yeptris::FFI.yeptris_plan_result_free(raw)
+      end
+    ensure
+      ::Yeptris::FFI.yeptris_tape_free(tape)
+    end
+  end
+
+  def column_count
+    ::Yeptris::FFI.yeptris_plan_column_count(@handle)
+  end
+
+  # The eager columnar result of Descriptor#walk: typed Ruby columns
+  # keyed by leaf name, plus the row-hash conveniences. Nothing here
+  # borrows C memory.
+  class PlanResult
+    # @api private — one bulk read per column; the C result is freed
+    # on return (PlanResult owns plain Ruby data)
+    def self.read(raw, src, names)
+      rows = ::Yeptris::FFI.yeptris_plan_result_rows(raw)
+      columns = {}
+      names.each_with_index do |name, c|
+        kind = ::Yeptris::FFI.yeptris_plan_result_kind(raw, c)
+        columns[name] = read_column(raw, c, kind, rows, src)
+      end
+      new(rows, names, columns)
+    end
+
+    def self.read_column(raw, c, kind, rows, src)
+      return [] if rows.zero?
+
+      nulls = ::Yeptris::FFI.yeptris_plan_result_nulls(raw, c).read_bytes(rows).unpack("C*")
+      has_nulls = nulls.include?(1)
+      case kind
+      when 0 # int: the unpacked lane IS the column when no nulls
+        ints = ::Yeptris::FFI.yeptris_plan_result_ints(raw, c).read_bytes(rows * 8).unpack("q<*")
+        return ints unless has_nulls
+
+        Array.new(rows) { |i| nulls[i] == 1 ? nil : ints[i] }
+      when 1
+        floats = ::Yeptris::FFI.yeptris_plan_result_floats(raw, c).read_bytes(rows * 8).unpack("E*")
+        return floats unless has_nulls
+
+        Array.new(rows) { |i| nulls[i] == 1 ? nil : floats[i] }
+      when 3 # bool: 0/1 → false/true (always maps)
+        ints = ::Yeptris::FFI.yeptris_plan_result_ints(raw, c).read_bytes(rows * 8).unpack("q<*")
+        Array.new(rows) { |i| nulls[i] == 1 ? nil : ints[i] == 1 }
+      else # str: spans into the source, escapes decoded on the Ruby side
+        offs = ::Yeptris::FFI.yeptris_plan_result_str_offs(raw, c).read_bytes(rows * 4).unpack("V*")
+        lens = ::Yeptris::FFI.yeptris_plan_result_str_lens(raw, c).read_bytes(rows * 4).unpack("V*")
+        decode = ::Yeptris::JSON.method(:decode_span)
+        Array.new(rows) { |i| nulls[i] == 1 ? nil : decode.call(src, offs[i], lens[i]) }
+      end
+    end
+    private_class_method :read_column
+
+    # @api private — the DOM leg's read: typed lanes as above; str
+    # columns materialize from the (ptr,len) views into the document
+    def self.read_dom(raw, names)
+      rows = ::Yeptris::FFI.yeptris_plan_result_rows(raw)
+      columns = {}
+      names.each_with_index do |name, c|
+        kind = ::Yeptris::FFI.yeptris_plan_result_kind(raw, c)
+        if kind == 2
+          nulls = ::Yeptris::FFI.yeptris_plan_result_nulls(raw, c).read_bytes(rows).unpack("C*")
+          base = ::FFI::Pointer.new(::Yeptris::FFI.yeptris_plan_result_strs(raw, c))
+          stride = ::Yeptris::FFI::PlanStr.size
+          columns[name] = Array.new(rows) do |i|
+            next nil if nulls[i] == 1
+
+            v = ::Yeptris::FFI::PlanStr.new(base + i * stride)
+            v[:p].read_bytes(v[:len]).force_encoding(Encoding::UTF_8)
+          end
+        else
+          columns[name] = read_column(raw, c, kind, rows, nil)
+        end
+      end
+      new(rows, names, columns)
+    end
+
+    def initialize(rows, names, columns)
+      @rows = rows
+      @names = names
+      @columns = columns
+    end
+
+    def rows
+      @rows
+    end
+    alias count rows
+
+    # The planned leaf names, in spec order.
+    def names
+      @names.dup
+    end
+
+    # One typed column: an Array of rows values (nil where the leaf
+    # was null, missing, or shape-mismatched).
+    def column(name)
+      @columns.fetch(name) { raise ArgumentError, "no planned column #{name.inspect}" }
+    end
+
+    # Row +i+ as a Hash of the planned leaves (nil out of range).
+    def at(i)
+      return nil if i >= @rows || i.negative?
+
+      row = {}
+      @names.each { |n| row[n] = @columns[n][i] }
+      row
+    end
+
+    # Rows as Hashes — the tree-shaped convenience; column readers
+    # are the allocation-lean path.
+    def to_a
+      Array.new(@rows) { |i| at(i) }
+    end
+    alias to_ruby to_a # leptris's eager-tree vocabulary
+
+    def each_row(&block)
+      return enum_for(:each_row) unless block
+
+      @rows.times { |i| block.call(at(i)) }
+    end
+  end
+end

data/lib/yeptris/json.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+module Yeptris
+  # The STRICT JSON surface (TODO.restructure/31).
+  #
+  # `Yeptris::JSON.load` targets EXACT `JSON.parse` semantics — that
+  # is its parity target, spec-pinned (spec/json_parity_spec.rb).
+  # It is deliberately separate from Yeptris::YAML: the YAML surface
+  # keeps the Psych contract for every input (JSON-shaped included),
+  # so the two never drift into each other's semantics.
+  #
+  # Engines, fastest first (both exact — the parity spec runs against
+  # whichever is loaded):
+  # 1. the native materializer (fused C scan → VALUE; opt-in build)
+  # 2. the record drain + strict conversion walk (always available)
+  module JSON
+    class Error < ::Yeptris::Error; end
+    class ParseError < Error; end
+
+    autoload :Descriptor, "yeptris/json/descriptor"
+
+    # json gem 3.0 made duplicate keys an error by DEFAULT; 2.x is
+    # last-wins. The parity target is the RESOLVED json gem's own
+    # behavior — strictness follows it (issue #37, found by canon's
+    # CI where json 3.0.0 resolved while the dev box had 2.x).
+    require "json"
+    require "date" # place_obj's `when Date` — psych loads it elsewhere, JSON.dump must not depend on that
+    STRICT_DUPLICATE_KEYS = Gem::Version.new(::JSON::VERSION) >= Gem::Version.new("3")
+
+    module_function
+
+    def load(source)
+      source = ::Yeptris.read_input(source)
+      source = source.to_s
+      if defined?(::Yeptris::Native)
+        begin
+          return ::Yeptris::Native.load_json(source, STRICT_DUPLICATE_KEYS)
+        rescue ::Yeptris::ParseError => e
+          raise ParseError, e.message
+        end
+      end
+      tape_engine(source)
+    end
+
+    # The tape engine (issue #81): ONE call validates and materializes
+    # the record stream; the walk reads four bulk columns and slices
+    # strings straight out of the caller's source — no gate document,
+    # no recorder transform, no arena copy (the drain path paid all
+    # three, which is where medium/large throughput went).
+    T_DOC = 0
+    T_NULL = 1
+    T_TRUE = 2
+    T_FALSE = 3
+    T_INT = 4
+    T_FLOAT = 5
+    T_STR = 6
+    T_SEQ_OPEN = 7
+    T_MAP_OPEN = 8
+    T_CLOSE = 9
+
+    # The tape keeps RAW string spans (escapes untouched — the C
+    # contract); the walk decodes them here. The hot path (no
+    # backslash) returns the slice untouched.
+    SIMPLE_ESCAPES = {
+      '"' => '"'.b, "\\" => "\\".b, "/" => "/".b, "b" => "\b".b, "f" => "\f".b,
+      "n" => "\n".b, "r" => "\r".b, "t" => "\t".b
+    }.freeze
+
+    def decode_span(src, off, len)
+      s = src.byteslice(off, len)
+      s.force_encoding(Encoding::UTF_8)
+      return s unless s.include?("\\")
+
+      b = s.b
+      out = String.new(encoding: Encoding::BINARY)
+      i = 0
+      n = b.bytesize
+      while i < n
+        c = b.getbyte(i)
+        if c != 0x5C || i + 1 >= n
+          out << c
+          i += 1
+          next
+        end
+        e = b.getbyte(i + 1)
+        if e != 0x75 # simple escape
+          ch = e.chr
+          out << (SIMPLE_ESCAPES[ch] || ch)
+          i += 2
+          next
+        end
+        cp = b.byteslice(i + 2, 4).to_i(16)
+        if cp >= 0xD800 && cp <= 0xDBFF && i + 12 <= n &&
+           b.getbyte(i + 6) == 0x5C && b.getbyte(i + 7) == 0x75
+          lo = b.byteslice(i + 8, 4).to_i(16)
+          if lo >= 0xDC00 && lo <= 0xDFFF
+            cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00)
+            i += 12
+          else
+            i += 6
+          end
+        else
+          i += 6
+        end
+        out << [cp].pack("U").b
+      end
+      out.force_encoding(Encoding::UTF_8)
+    end
+
+    def tape_engine(source)
+      tape = ::Yeptris::FFI::JsonTape.new
+      rc = ::Yeptris::FFI.yeptris_parse_json_tape(source, source.bytesize, tape)
+      raise ParseError, ::Yeptris::FFI.last_error_message if rc != ::Yeptris::FFI::OK
+
+      begin
+        walk_tape(source, tape)
+      ensure
+        ::Yeptris::FFI.yeptris_tape_free(tape)
+      end
+    end
+
+    def walk_tape(src, tape)
+      n = tape[:count]
+      kinds = tape[:kinds].read_bytes(n).unpack("C*")
+      offs = tape[:offs].read_bytes(n * 4).unpack("V*")
+      lens = tape[:lens].read_bytes(n * 4).unpack("V*")
+      # v2: parse records number spans only — ONE bulk convert call
+      # materializes them (per-number FFI calls would sink the ladder)
+      ivp = ::FFI::MemoryPointer.new(:int64, n, true)
+      dvp = ::FFI::MemoryPointer.new(:double, n, true)
+      ::Yeptris::FFI.yeptris_tape_convert(tape, 0, n, ivp, dvp)
+      vals_i = ivp.read_bytes(n * 8).unpack("q<*")
+      vals_f = dvp.read_bytes(n * 8).unpack("E*")
+      # any integer text beyond int64: every INT rebuilds from its span
+      # (exact Bignum; JSON.parse parity) — int_min is set by the
+      # convert call above
+      exact_ints = !tape[:int_min].zero?
+      utf8 = src.encoding == Encoding::UTF_8
+
+      docs = [nil] # record 0 (DOC) pre-consumed — the root's slot
+      stack = []
+      key_sets = STRICT_DUPLICATE_KEYS ? [{}] : nil
+      pending_key = nil
+      i = 1
+      while i < n
+        case kinds[i]
+        when T_SEQ_OPEN
+          place(docs, stack, pending_key) { [] }
+          pending_key = nil
+        when T_MAP_OPEN
+          key_sets&.push({})
+          place(docs, stack, pending_key) { {} }
+          pending_key = nil
+        when T_CLOSE
+          stack.pop
+          key_sets&.pop
+        when T_STR
+          # empty-string literals are frozen+shared since Ruby 3.4
+          # (and `+""` binds after the method chain anyway), so the
+          # fresh copy must come from the encoding call itself
+          text = lens[i] == 0 ? String.new(encoding: Encoding::UTF_8) : decode_span(src, offs[i], lens[i])
+          if pending_key.nil? && !stack.empty? && stack.last.is_a?(Hash)
+            if key_sets && key_sets.last.key?(text)
+              raise ParseError, %(duplicate key "#{text}" in JSON object)
+            end
+            key_sets&.last&.store(text, true)
+            pending_key = text
+          else
+            place(docs, stack, pending_key) { text }
+            pending_key = nil
+          end
+        when T_INT
+          if exact_ints
+            place(docs, stack, pending_key) { Integer(src.byteslice(offs[i], lens[i]), 10) }
+          else
+            v = vals_i[i]
+            place(docs, stack, pending_key) { v }
+          end
+          pending_key = nil
+        when T_FLOAT
+          v = vals_f[i]
+          place(docs, stack, pending_key) { v }
+          pending_key = nil
+        when T_TRUE, T_FALSE # v2: the kind IS the value
+          place(docs, stack, pending_key) { kinds[i] == T_TRUE }
+          pending_key = nil
+        when T_NULL
+          place(docs, stack, pending_key) { nil }
+          pending_key = nil
+        else
+          raise Error, "internal: impossible tape record #{kinds[i]}"
+        end
+        i += 1
+      end
+      docs.empty? ? nil : docs.first
+    end
+
+    # The always-available engine: the strict-JSON validator gates
+    # (parse_json raises on anything RFC 8259 rejects), then the
+    # value records convert WITHOUT the Psych quirk table — floats
+    # are always Floats, bools always bools ("1e3" is 1000.0 here
+    # and a String on the YAML surface; each surface is its own
+    # contract).
+    def strict_fallback(source)
+      begin
+        gate = ::Yeptris::Document.parse_json(source)
+      rescue ::Yeptris::ParseError => e
+        raise ParseError, e.message
+      end
+      begin
+        cols = ::Yeptris::FFI::ValueColumns.new
+        st = ::Yeptris::FFI.yeptris_value_drain_columns(
+          source, source.bytesize, ::Yeptris::FFI::SCHEMA_12_CORE, cols
+        )
+        raise ParseError, ::Yeptris::FFI.last_error_message if st != ::Yeptris::FFI::OK
+
+        begin
+          walk_strict(cols, STRICT_DUPLICATE_KEYS)
+        ensure
+          ::Yeptris::FFI.yeptris_value_free_columns(cols)
+        end
+      ensure
+        gate.free
+      end
+    end
+
+    # Placement mechanics mirror ValueML.walk_columns; the CONVERSION
+    # is the strict-JSON one (no ':sym' scan, no y/n quirk, no
+    # dot-required floats). Anchors/aliases/timestamps cannot occur
+    # in strict JSON — reaching them is an internal error.
+    def walk_strict(cols, strict_dup = STRICT_DUPLICATE_KEYS)
+      n = cols[:count]
+      kinds = cols[:kinds].read_bytes(n).unpack("C*")
+      ikeys = cols[:is_keys].read_bytes(n).unpack("C*")
+      bools = cols[:bools].read_bytes(n).unpack("C*")
+      offs = cols[:offs].read_bytes(n * 4).unpack("V*")
+      lens = cols[:lens].read_bytes(n * 4).unpack("V*")
+      pays = cols[:payloads].read_bytes(n * 8).unpack("q<*")
+      arena = cols[:arena_len].zero? ? +"" : cols[:arena].read_bytes(cols[:arena_len])
+      arena.force_encoding(Encoding::UTF_8)
+
+      docs = []
+      stack = []
+      key_sets = strict_dup ? [{}] : nil
+      pending_key = nil
+      i = 0
+      while i < n
+        case kinds[i]
+        when ValueML::DOC
+          docs.push(nil)
+        when ValueML::SEQ_OPEN
+          place(docs, stack, pending_key) { [] }
+          pending_key = nil
+        when ValueML::MAP_OPEN
+          key_sets&.push({})
+          place(docs, stack, pending_key) { {} }
+          pending_key = nil
+        when ValueML::CLOSE
+          stack.pop
+          key_sets&.pop
+        when ValueML::V_STR
+          text = arena.byteslice(offs[i], lens[i])
+          if ikeys[i] == 1 && !stack.empty? && stack.last.is_a?(Hash)
+            if strict_dup && key_sets.last.key?(text)
+              raise ParseError, %(duplicate key "#{text}" in JSON object)
+            end
+            key_sets&.last&.store(text, true)
+            pending_key = text
+          else
+            # Records carry int64 payloads: an integer-beyond-int64
+            # degrades to a PLAIN string (b==1). In strict JSON a
+            # plain (unquoted) scalar can ONLY be a number — every
+            # real string is quoted and arrives b==0 — so rebuild the
+            # exact Integer (JSON.parse parity, Bignum included).
+            if bools[i] == 1
+              place(docs, stack, pending_key) { Integer(text, 10) }
+            else
+              place(docs, stack, pending_key) { text }
+            end
+            pending_key = nil
+          end
+        when ValueML::V_INT
+          place(docs, stack, pending_key) { pays[i] }
+          pending_key = nil
+        when ValueML::V_FLOAT
+          place(docs, stack, pending_key) { [pays[i]].pack("q<").unpack1("E") }
+          pending_key = nil
+        when ValueML::V_BOOL
+          place(docs, stack, pending_key) { bools[i] == 1 }
+          pending_key = nil
+        when ValueML::V_NULL
+          place(docs, stack, pending_key) { nil }
+          pending_key = nil
+        else
+          raise Error, "internal: impossible record #{kinds[i]} in strict JSON"
+        end
+        i += 1
+      end
+      docs.empty? ? nil : docs.first
+    end
+
+    # ---- generation (issue #81) ------------------------------------------
+    #
+    # `dump` targets JSON.generate semantics for the core types: the
+    # object walk reuses YAML.dump's packed-entry bulk builder (one
+    # FFI build call), then the strict-JSON writer serializes —
+    # Strings ride DOUBLE_QUOTED (a "42" stays quoted; numbers, bools
+    # and null stay plain), Symbols become their name.
+    class DumpError < Error; end
+
+    def dump(obj)
+      parts = String.new(encoding: Encoding::BINARY,
+                         capacity: 12 * 16) # 12-byte entries, appended in place
+      blob = String.new(encoding: Encoding::BINARY)
+      off = [0]
+      place_obj(obj, parts, blob, off)
+      doc = ::Yeptris::Document.create
+      # FFI passes String args BY REFERENCE — no MemoryPointer copies
+      rc = doc.build_entries(parts, parts.bytesize / 12, blob, blob.bytesize)
+      raise DumpError, "document_build failed: #{rc}" unless rc == ::Yeptris::FFI::OK
+      out = ::Yeptris::FFI::JSON_EX ? doc.serialize_json_compact : doc.serialize_json
+      # JSON.generate emits no trailing newline (the document writer does)
+      out.end_with?("\n") ? out[0, out.bytesize - 1] : out
+    ensure
+      doc&.free
+    end
+
+    F = ::Yeptris::FFI
+    MAP_E = [F::BUILD_MAP, 0, 0, 0].pack("CCx2VV").freeze
+    SEQ_E = [F::BUILD_SEQ, 0, 0, 0].pack("CCx2VV").freeze
+    END_E = [F::BUILD_END, 0, 0, 0].pack("CCx2VV").freeze
+    DQ = F::STYLE_DOUBLE_QUOTED
+    PL = F::STYLE_PLAIN
+    SC_DQ = [F::BUILD_SCALAR, DQ].pack("CCx2").freeze
+    SC_PL = [F::BUILD_SCALAR, PL].pack("CCx2").freeze
+
+    def place_obj(obj, parts, blob, off)
+      case obj
+      when Hash
+        parts << MAP_E
+        obj.each do |k, v|
+          key = k.is_a?(String) ? k : k.is_a?(Symbol) ? k.name : k.to_s
+          scalar_json(key, SC_DQ, parts, blob, off)
+          place_obj(v, parts, blob, off)
+        end
+        parts << END_E
+      when Array
+        parts << SEQ_E
+        obj.each { |e| place_obj(e, parts, blob, off) }
+        parts << END_E
+      when String
+        scalar_json(obj, SC_DQ, parts, blob, off)
+      when Symbol
+        scalar_json(obj.name, SC_DQ, parts, blob, off)
+      when Integer, Float
+        scalar_json(obj.to_s, SC_PL, parts, blob, off)
+      when true
+        scalar_json("true", SC_PL, parts, blob, off)
+      when false
+        scalar_json("false", SC_PL, parts, blob, off)
+      when nil
+        scalar_json("null", SC_PL, parts, blob, off)
+      when Date, Time
+        scalar_json(obj.iso8601, SC_DQ, parts, blob, off)
+      else
+        raise DumpError, "cannot dump #{obj.class}: unsupported object " \
+                         "(JSON.generate calls to_json on custom types)"
+      end
+    end
+
+    def scalar_json(text, prefix, parts, blob, off)
+      parts << (prefix + [off[0], text.bytesize].pack("VV"))
+      blob << text
+      off[0] += text.bytesize
+    end
+
+    def place(docs, stack, key)
+      v = yield
+      if stack.empty?
+        docs[-1] = v
+      elsif key
+        stack.last[key] = v
+      else
+        stack.last.push(v)
+      end
+      stack.push(v) if v.is_a?(Array) || v.is_a?(Hash)
+      v
+    end
+  end
+end