emf 0.1.2 → 0.2.0

data/lib/emf/native/header_errors.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # Native reports header truncation by byte position; the Ruby parser names the
+    # header's own nSize. When Ruby would reject the same input with a FormatError,
+    # report Ruby's wording, including an nSize too small for the fields it implies.
+    module HeaderErrors
+      module_function
+
+      def translate(error, input)
+        return error if input.bytesize < 8
+
+        size = input.unpack1("@4V")
+        return FormatError.new("EMF header nSize too small: #{size}") if size < 8
+        return FormatError.new("truncated EMF header (claimed #{size}, got #{input.bytesize})") if input.bytesize < size
+        return FormatError.new("EMF header nSize #{size} cannot hold its fields") unless ruby_header_fits?(input, size)
+
+        error
+      end
+
+      def ruby_header_fits?(input, size)
+        Emr::Binary::Header.read(input.byteslice(0, size))
+        true
+      rescue IOError
+        false
+      end
+    end
+  end
+end

data/lib/emf/native/hydrator.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "fields"
+require_relative "font_fields"
+require_relative "gradient_fields"
+require_relative "bitmap_fields"
+require_relative "small_text_fields"
+require_relative "poly_text_fields"
+require_relative "lazy_wire"
+require_relative "diagnostics"
+require_relative "emf_plus_source"
+
+module Emf
+  module Native
+    class Hydrator
+      SUPPORTED_TYPES = [*(2..68), *(70..98), 114, 115, 116, 118, 120].freeze
+      OPAQUE_BODY_TYPES = [23, 96, 97, *(99..106), *(109..113), 119, 121, 122].freeze
+
+      def initialize(snapshot, input)
+        @snapshot = snapshot
+        @input = input
+        # Filled wires read their fields from this frozen view, as Ruby-parsed wires do.
+        @data = input.frozen? ? input : input.dup.freeze
+      end
+
+      def call
+        diagnostics = Diagnostics.new(@snapshot, @input)
+        plus_candidates = []
+        records = hydrate_records(diagnostics, plus_candidates)
+        emf_plus = emf_plus_stream(diagnostics, plus_candidates)
+        Model::Metafile.new(
+          format: emf_plus.empty? ? :emf : :emf_plus, header: Header.new.call(@snapshot.header, @snapshot.raw_header), records: records,
+          errors: diagnostics.errors, emf_plus: emf_plus.empty? ? nil : emf_plus,
+          trailing: @snapshot.trailing + @snapshot.unframed, emf_plus_source: (EmfPlusSource.call(@input) unless emf_plus.empty?)
+        )
+      end
+
+      private
+
+      # One pass over the snapshot table. Records the Ruby parser reads from
+      # bytes alone become lazy wires straight from the table's own type,
+      # family and span; the rest take the field path.
+      def hydrate_records(diagnostics, plus_candidates)
+        table = @snapshot.table
+        recovering = diagnostics.recovering?
+        limit = @input.bytesize
+        Array.new(@snapshot.record_count) do |index|
+          base = index * 5
+          offset = table[base + 1]
+          length = table[base + 2]
+          type_family = table[base + 3]
+          plus_candidates << index if (recovered = recovering && diagnostics.recovered?(offset)) || type_family >> 32 == 4
+          adapter = diagnostics.adapter_at(offset) if recovered
+          next adapter if adapter
+
+          raise FormatError, "invalid native record span" unless length >= 8 && offset >= 0 && offset <= limit - length
+
+          filled = FilledWire.for(type_family, offset, length, @data)
+          next Model::Emr::Records::WireAdapter.lazy(source: filled, offset: offset) if filled
+
+          hydrate_record(@snapshot.record(index), offset, length)
+        end
+      end
+
+      def hydrate_record(record, offset, length)
+        raw = @input.byteslice(offset, length)
+
+        if record.fetch(:family) == 90
+          wire = FontFields.new(record.fetch(:payload), raw).call
+          return Model::Emr::Records::WireAdapter.new(wire: wire, offset: offset)
+        end
+
+        klass, fields = wire_fields(record, raw)
+        Model::Emr::Records::WireAdapter.lazy(source: LazyWire.new(klass, fields, raw, record), offset: offset)
+      end
+
+      def wire_fields(record, raw)
+        payload = record.fetch(:payload)
+        family = record.fetch(:family)
+        case family
+        when 93..103 then BitmapFields.call(payload, family, raw)
+        when 0 then raw_fields(record, raw)
+        when 1 then Fields.eof(payload, raw)
+        when 3, 45..53 then Fields.point_array(payload, record.fetch(:family))
+        when 54..57 then Fields.multi_point_array(payload, record.fetch(:family))
+        when 58, 59 then Fields.poly_draw(payload, record.fetch(:family))
+        when 4 then Fields.comment(payload, raw)
+        when 33
+          klass, fields = Fields.call(payload, 33)
+          [klass, fields.merge(trailing: raw.byteslice(12..))]
+        when 2, 5..44, 60..86, 91, 92, 104..106 then scalar_fields(record, raw)
+        else raise FormatError, "unsupported native snapshot record family #{record.fetch(:family)}"
+        end
+      end
+
+      def scalar_fields(record, raw)
+        family = record.fetch(:family)
+        return PolyTextFields.call(record.fetch(:payload), family, raw, record.fetch(:type)) if (104..106).cover?(family)
+
+        return PaletteFields.call(record.fetch(:payload), family, raw) if (82..86).cover?(family)
+
+        return Fields.extended_pen(record.fetch(:payload), raw) if family == 81
+
+        return Fields.region(record.fetch(:payload), family, raw) if (76..80).cover?(family)
+
+        return Fields.ext_text(record.fetch(:payload), family, raw) if [74, 75].include?(family)
+
+        if [91, 92].include?(family)
+          klass, fields = Fields.call(record.fetch(:payload), family)
+          fixed = family == 91 ? 24 : 16
+          raise FormatError, "invalid native state record length" if raw.bytesize < fixed
+
+          return [klass, fields.merge(trailing: raw.byteslice(fixed..))]
+        end
+
+        Fields.call(record.fetch(:payload), family)
+      end
+
+      def raw_fields(record, raw)
+        raise FormatError, "invalid native typed payload length" unless record.fetch(:payload).empty?
+
+        type = record.fetch(:type)
+        return SmallTextFields.call(raw) if type == 108
+
+        # Body-backed public classes also preserve malformed recognized records.
+        # Their family-0 snapshot carries no semantic fields; diagnostics report recovery.
+        return [Emr::Binary::Records.lookup(type), { body: raw.byteslice(8..) }] if OPAQUE_BODY_TYPES.include?(type)
+
+        if !SUPPORTED_TYPES.include?(type) && Emr::Binary::Records.lookup(type) != Emr::Binary::Records::Raw
+          raise FormatError, "native backend does not support typed EMR record #{type}"
+        end
+
+        [Emr::Binary::Records::Raw, { payload: raw.byteslice(8..) }]
+      end
+
+      # Only recovered records and COMMENTs can carry EMF+ bytes, in record order.
+      def emf_plus_stream(diagnostics, candidates)
+        table = @snapshot.table
+        candidates.filter_map do |index|
+          offset = table[(index * 5) + 1]
+          next diagnostics.emf_plus_at(offset) if diagnostics.recovered?(offset)
+          next unless table[(index * 5) + 3] >> 32 == 4
+
+          _klass, fields = Fields.comment(@snapshot.payload(index), @input.byteslice(offset, table[(index * 5) + 2]))
+          data = fields.fetch(:data)
+          data.byteslice(4..) if fields.fetch(:cb_data) >= 4 && data.start_with?("EMF+")
+        end.join.b
+      end
+    end
+  end
+end

data/lib/emf/native/lazy_wire.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # Owns validated Ruby values, never a native document or its hydrator.
+    class LazyWire
+      XFORM_LEAVES = %i[m11 m12 m21 m22 dx dy].each_with_index.map { |name, index| [[:xform, name], 8 + (index * 4)] }.freeze
+      TEXT_SCALE_LEAVES = [[[:ex_scale], 28], [[:ey_scale], 32]].freeze
+
+      # Whole-record byte offsets of each float32 leaf, header included.
+      FLOAT_LEAVES = {
+        Emr::Binary::Records::SetWorldTransform => XFORM_LEAVES,
+        Emr::Binary::Records::ModifyWorldTransform => XFORM_LEAVES,
+        Emr::Binary::Records::AngleArc => [[[:start_angle], 20], [[:sweep_angle], 24]],
+        Emr::Binary::Records::SetMiterLimit => [[[:miter_limit], 8]],
+        Emr::Binary::Records::ExtTextOutA => TEXT_SCALE_LEAVES,
+        Emr::Binary::Records::ExtTextOutW => TEXT_SCALE_LEAVES,
+        Emr::Binary::Records::SmallTextOut => TEXT_SCALE_LEAVES
+      }.freeze
+      private_constant :XFORM_LEAVES, :TEXT_SCALE_LEAVES, :FLOAT_LEAVES
+
+      def initialize(klass, fields, bytes, record)
+        @klass = klass
+        @fields = fields.merge(i_type: record.fetch(:type), n_size: bytes.bytesize)
+        @bytes = bytes
+      end
+
+      def type_id
+        @fields.fetch(:i_type)
+      end
+
+      def to_binary_s
+        @bytes
+      end
+
+      def append_to(out)
+        out << to_binary_s
+      end
+
+      def wire_class
+        @klass
+      end
+
+      # No byte reader: these fields come from the hydrator, which may
+      # disagree with the raw bytes (recovered records).
+      def value_source
+        nil
+      end
+
+      def materialize
+        @klass.new(**@fields).tap { |wire| restore_float_bits(wire) }
+      end
+
+      def suffix(wire)
+        Model::Emr::Records::WireAdapter.suffix_of(@bytes, wire)
+      end
+
+      private
+
+      # The constructor only receives Floats, and Ruby has already canonicalised
+      # any NaN payload on the way in; the record bytes still hold the original.
+      def restore_float_bits(wire)
+        FLOAT_LEAVES.fetch(@klass, []).each do |path, offset|
+          path.inject(wire) { |node, name| node.public_send(name) }
+              .assign_bits(@bytes.byteslice(offset, 4).unpack1("V"))
+        end
+      end
+    end
+
+    # Same contract as LazyWire for a fixed-layout record whose bytes alone
+    # define the wire: no per-record field Hash is built at parse time, and
+    # materialising reads the record bytes with the same FastFill the Ruby
+    # backend parses with. Float leaves keep their original bits there.
+    class FilledWire < Emr::FilledRecord
+      # Native records have always answered a plain Integer type id.
+      attr_reader :type_id
+
+      # Snapshot families whose records the Ruby backend's fillers read from
+      # bytes alone; any other family keeps its own validation in the Hydrator.
+      FAMILIES = Array.new(87) { |family| [2, 3, *5..32, *35..57, *60..86].include?(family) }.freeze
+      # The filler of each EMR type, indexed by type; types past the table have none.
+      FILLERS = Array.new(128) { |type| Emr::Binary::FastFill.for(type) || Emr::Binary::FastFill.for_points(type) }.freeze
+      private_constant :FAMILIES, :FILLERS
+
+      # The source for the fixed-layout or point-array record the snapshot
+      # places at `offset` of the frozen `data`, or nil. `type_family` is the
+      # snapshot table word, type | family << 32. The snapshot takes the type
+      # and `length` from the record's own header, so they are not read again.
+      # Recovered (family 0, including a count that overruns the bytes)
+      # records keep the field path. The caller has bounds-checked the span.
+      def self.for(type_family, offset, length, data)
+        type = type_family & 0xFFFF_FFFF
+        filler = FILLERS[type]
+        return unless filler && FAMILIES[type_family >> 32] && length >= filler.size
+
+        new(filler, data, offset, length, type)
+      end
+    end
+  end
+end

data/lib/emf/native/legacy_state_fields.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    module LegacyStateFields
+      def self.call(payload, family)
+        raise FormatError, "invalid native opaque payload length" if payload.bytesize < 8
+
+        count = payload.unpack1("Q<")
+        raise FormatError, "invalid native opaque payload length" unless payload.bytesize == 8 + count
+
+        body = payload.byteslice(8..)
+        semantic_family = family == 68 ? 91 : 92
+        length = semantic_family == 91 ? 16 : 8
+        return [Emr::Binary::Records::Raw, { payload: body }] if count < length
+
+        klass, fields = Fields.call(body.byteslice(0, length), semantic_family)
+        [klass, fields.merge(trailing: body.byteslice(length..))]
+      end
+    end
+  end
+end

data/lib/emf/native/library_path.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module Emf
+  module Native
+    class LibraryPath
+      def initialize(directory = __dir__)
+        @directory = directory
+      end
+
+      def call
+        override = ENV.fetch("EMF_NATIVE_LIBRARY", nil)
+        return override unless override.nil?
+
+        manifest_path = File.join(@directory, "platforms.json")
+        return unless File.exist?(manifest_path)
+
+        manifest = JSON.parse(File.read(manifest_path))
+        validate_manifest(manifest)
+        bundled_path(manifest)
+      rescue JSON::ParserError, SystemCallError => e
+        raise Unavailable, "native backend manifest could not load: #{e.message}"
+      end
+
+      private
+
+      def validate_manifest(manifest)
+        unless manifest.is_a?(Hash) && component?(manifest["platform"]) && component?(manifest["library"]) &&
+               manifest["sha256"].is_a?(String) && manifest["sha256"].match?(/\A[0-9a-f]{64}\z/)
+          raise Unavailable, "native backend manifest is invalid"
+        end
+        raise Unavailable, "native backend manifest platform mismatch" unless compatible_platform?(manifest["platform"])
+        return if manifest["abi_version"].is_a?(Integer) && manifest["abi_version"] == 1
+
+        raise Unavailable, "native backend manifest ABI version mismatch (expected 1)"
+      end
+
+      # The bundled library's platform is RubyGems' to match; without
+      # RubyGems (ruby --disable-gems) only EMF_NATIVE_LIBRARY can name one.
+      def compatible_platform?(platform)
+        raise Unavailable, "native backend needs RubyGems to match the bundled platform" unless defined?(::Gem)
+
+        require "rubygems/platform"
+        case Gem::Platform.local
+        when Gem::Platform.new(platform) then true
+        else false
+        end
+      end
+
+      def component?(value)
+        value.is_a?(String) && value.match?(/\A[a-zA-Z0-9_][a-zA-Z0-9_.-]*\z/)
+      end
+
+      def bundled_path(manifest)
+        root = File.realpath(@directory)
+        path = File.join(root, manifest.fetch("platform"), manifest.fetch("library"))
+        unless File.realpath(path).start_with?("#{root}#{File::SEPARATOR}")
+          raise Unavailable, "native backend library escapes its installation directory"
+        end
+        raise Unavailable, "native backend library checksum mismatch" unless Digest::SHA256.file(path).hexdigest == manifest.fetch("sha256")
+
+        path
+      end
+    end
+  end
+end

data/lib/emf/native/loader.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "fiddle"
+require_relative "wmf_loading"
+require_relative "resource_failure"
+
+module Emf
+  module Native
+    class Loader
+      include WmfLoading
+      include ResourceFailure
+
+      POINTER = Fiddle::TYPE_VOIDP
+      UINT64 = Fiddle::TYPE_LONG_LONG
+      # Version 1 status values from emf-ffi/include/emf.h.
+      STATUS_ERRORS = { 2 => FormatError,
+                        4 => SerializeError }.freeze
+      SIGNATURES = {
+        emf_parse: [[POINTER, UINT64, POINTER, POINTER, POINTER], Fiddle::TYPE_INT],
+        emf_document_snapshot: [[POINTER, POINTER, POINTER], Fiddle::TYPE_INT],
+        emf_record_bytes: [[POINTER, UINT64, POINTER, POINTER], Fiddle::TYPE_INT],
+        emf_buffer_view: [[POINTER, POINTER, POINTER], Fiddle::TYPE_INT],
+        emf_error_view: [[POINTER, POINTER], Fiddle::TYPE_INT],
+        emf_document_free: [[POINTER], Fiddle::TYPE_VOID],
+        emf_buffer_free: [[POINTER], Fiddle::TYPE_VOID],
+        emf_error_free: [[POINTER], Fiddle::TYPE_VOID]
+      }.freeze
+      # Present in newer libraries only; an older one keeps the schema 2 snapshot.
+      SNAPSHOT_V3 = :emf_document_snapshot_v3
+
+      def initialize(path)
+        raise Unavailable, "native backend requires a 64-bit process" unless Fiddle::SIZEOF_VOIDP == 8
+
+        @library = Fiddle.dlopen(path)
+        @functions = { emf_abi_version: Fiddle::Function.new(@library["emf_abi_version"], [], Fiddle::TYPE_INT) }
+        raise Unavailable, "native backend ABI version mismatch (expected 1)" unless invoke(:emf_abi_version) == 1
+
+        SIGNATURES.each do |name, (arguments, result)|
+          @functions[name] = Fiddle::Function.new(@library[name.to_s], arguments, result)
+        end
+        optional(:emf_error_resource_view, [POINTER, POINTER])
+        @snapshot_function = optional(SNAPSHOT_V3, [POINTER, POINTER, POINTER]) ? SNAPSHOT_V3 : :emf_document_snapshot
+      rescue Fiddle::DLError => e
+        raise Unavailable, "native backend could not load: #{e.message}"
+      end
+
+      def document(bytes)
+        output = slot
+        checked(:emf_parse, bytes, bytes.bytesize, 0, output)
+        yield pointer(output)
+      ensure
+        invoke(:emf_document_free, pointer(output)) if output && pointer(output) != 0
+      end
+
+      def snapshot(document)
+        buffer(@snapshot_function, document)
+      end
+
+      def record_bytes(document, index)
+        buffer(:emf_record_bytes, document, index)
+      end
+
+      private
+
+      def optional(name, arguments)
+        @functions[name] = Fiddle::Function.new(@library[name.to_s], arguments, Fiddle::TYPE_INT)
+      rescue Fiddle::DLError
+        nil
+      end
+
+      def invoke(name, *arguments)
+        @functions.fetch(name).call(*arguments)
+      end
+
+      def slot
+        Fiddle::Pointer["\0" * 8]
+      end
+
+      def pointer(output)
+        output[0, 8].unpack1("J")
+      end
+
+      def checked(name, *arguments)
+        error = slot
+        status = invoke(name, *arguments, error)
+        return if status.zero?
+
+        raise resource_failure(pointer(error)) if status == 3
+
+        message = error_message(pointer(error), status)
+        raise STATUS_ERRORS.fetch(status, Error), message
+      ensure
+        invoke(:emf_error_free, pointer(error)) if error && pointer(error) != 0
+      end
+
+      def error_message(error, status)
+        return "native operation failed (status #{status})" if error.zero?
+
+        info = Fiddle::Pointer[[48, 1].pack("L2") + ("\0" * 40)]
+        return "native operation failed (status #{status})" unless invoke(:emf_error_view, error, info).zero?
+
+        address, length = info[32, 16].unpack("JQ")
+        Fiddle::Pointer.new(address)[0, length].force_encoding(Encoding::UTF_8)
+      end
+
+      def buffer(name, *arguments)
+        output = slot
+        checked(name, *arguments, output)
+        data = slot
+        length = slot
+        status = invoke(:emf_buffer_view, pointer(output), data, length)
+        raise STATUS_ERRORS.fetch(status, Error), "native buffer view failed (status #{status})" unless status.zero?
+
+        Fiddle::Pointer.new(pointer(data))[0, pointer(length)]
+      ensure
+        invoke(:emf_buffer_free, pointer(output)) if output && pointer(output) != 0
+      end
+    end
+  end
+end

data/lib/emf/native/palette_fields.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    module PaletteFields
+      def self.call(payload, family, raw)
+        klass = [Emr::Binary::Records::SelectPalette, Emr::Binary::Records::CreatePalette,
+                 Emr::Binary::Records::SetPaletteEntries, Emr::Binary::Records::ResizePalette,
+                 Emr::Binary::Records::RealizePalette].fetch(family - 82)
+        return array_fields(payload, family, raw, klass) if [83, 84].include?(family)
+
+        fixed = { 82 => 4, 85 => 8, 86 => 0 }.fetch(family)
+        raise FormatError, "invalid native palette payload" unless payload.bytesize == fixed && raw.bytesize >= fixed + 8
+
+        fields = { trailing: raw.byteslice((fixed + 8)..) }
+        fields[:ih_pal] = payload.unpack1("V") if fixed.positive?
+        fields[:entry_count] = payload.byteslice(4, 4).unpack1("V") if family == 85
+        [klass, fields]
+      end
+
+      def self.palette_counts_valid?(family, scalar, count)
+        family != 83 || (scalar <= 0xFFFF && count <= 0xFFFF)
+      end
+
+      def self.array_fields(payload, family, raw, klass)
+        raise FormatError, "invalid native palette array payload" if payload.bytesize < 16
+
+        handle, scalar, count = payload.unpack("V2Q<")
+        fixed = family == 83 ? 16 : 20
+        valid = payload.bytesize == 16 + (count * 4) && raw.bytesize >= fixed + (count * 4)
+        valid &&= palette_counts_valid?(family, scalar, count)
+        raise FormatError, "invalid native palette array length" unless valid
+
+        ResourceLimits::EmfRecords.check_count(count) if family == 84
+
+        entries = payload.byteslice(16..).unpack("C*").each_slice(4).map do |red, green, blue, flags|
+          { red: red, green: green, blue: blue, flags: flags }
+        end
+        fields = { ih_pal: handle, entry_count: count, palette_entries: entries, trailing: raw.byteslice((fixed + (count * 4))..) }
+        fields[family == 83 ? :version : :start] = scalar
+        [klass, fields]
+      end
+    end
+  end
+end

data/lib/emf/native/poly_text_fields.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # Snapshot families 104/105 encode a 36-byte header and 52-byte entry
+    # headers followed by text units and Dx words. Family 106 is twelve words.
+    # Source gaps and suffixes remain authoritative for the public body API.
+    module PolyTextFields
+      def self.call(payload, family, raw, type)
+        expected_type = { 104 => 96, 105 => 97, 106 => 23 }.fetch(family)
+        valid_header = type == expected_type && raw.bytesize >= 8 && raw.unpack1("V") == type
+        reject! unless valid_header && raw.byteslice(4, 4).unpack1("V") == raw.bytesize
+
+        if family == 106
+          reject! unless payload.bytesize == 24 && raw.bytesize >= 32 && payload == raw.byteslice(8, 24)
+        else
+          TextValidator.new(payload, raw, family == 104 ? 1 : 2).call
+        end
+        [Emr::Binary::Records.lookup(type), { body: raw.byteslice(8..) }]
+      end
+
+      def self.reject!
+        raise FormatError, "invalid native PolyTextOut/COLORADJUSTMENT payload"
+      end
+
+      # The source descriptor table is variable width. Validate every semantic
+      # field and detached span before constructing the public body-backed wire.
+      class TextValidator
+        def initialize(payload, raw, width)
+          @payload = payload
+          @raw = raw
+          @width = width
+          @cursor = 36
+          @descriptor = 40
+          @spans = []
+        end
+
+        def call
+          count.times { entry }
+          reject! unless @cursor == @payload.bytesize
+
+          finish = @descriptor
+          @spans.sort.each do |start, stop|
+            reject! if start < finish
+            finish = stop
+          end
+        end
+
+        private
+
+        def count
+          reject! unless @payload.bytesize >= 36 && @raw.bytesize >= 40
+          reject! unless @payload.byteslice(0, 28) == @raw.byteslice(8, 28)
+
+          value = @payload.byteslice(28, 8).unpack1("Q<")
+          reject! unless value == @raw.byteslice(36, 4).unpack1("V")
+          reject! unless value <= (@payload.bytesize - 36) / 52 && value <= (@raw.bytesize - 40) / 24
+          value
+        end
+
+        def entry
+          reject! unless @cursor + 52 <= @payload.bytesize && @descriptor + 24 <= @raw.bytesize
+
+          options, has_rect = @payload.byteslice(@cursor + 8, 8).unpack("V2")
+          size = rectangle(options, has_rect)
+          reject! unless @payload.byteslice(@cursor, 8) == @raw.byteslice(@descriptor, 8)
+          reject! unless options == @raw.byteslice(@descriptor + 16, 4).unpack1("V")
+
+          chars, string = @raw.byteslice(@descriptor + 8, 8).unpack("V2")
+          dx = @raw.byteslice(@descriptor + size - 4, 4).unpack1("V")
+          dx_count = spacing_count(chars, dx, options)
+          @cursor += 52
+          buffer(string, chars * @width, @width, string.zero? && chars.zero?)
+          buffer(dx, dx_count * 4, 4, dx.zero?)
+          @descriptor += size
+        end
+
+        def rectangle(options, has_rect)
+          with_rect = options.nobits?(0x100)
+          size = with_rect ? 40 : 24
+          reject! unless has_rect == (with_rect ? 1 : 0) && @descriptor + size <= @raw.bytesize
+
+          bytes = with_rect ? @raw.byteslice(@descriptor + 20, 16) : "\0".b * 16
+          reject! unless @payload.byteslice(@cursor + 16, 16) == bytes
+          size
+        end
+
+        def spacing_count(chars, dx, options)
+          text_count, has_dx, dx_count = @payload.byteslice(@cursor + 32, 20).unpack("Q<VQ<")
+          reject! unless text_count == chars && has_dx == (dx.zero? ? 0 : 1)
+
+          multiplier = options.anybits?(0x2000) ? 2 : 1
+          expected = dx.zero? ? 0 : chars * multiplier
+          reject! unless dx_count == expected
+          dx_count
+        end
+
+        def buffer(offset, length, alignment, absent)
+          reject! unless length <= @payload.bytesize - @cursor
+          unless absent
+            reject! unless offset >= 40 && (offset % alignment).zero? && offset <= @raw.bytesize
+            reject! unless length <= @raw.bytesize - offset
+            reject! unless @payload.byteslice(@cursor, length) == @raw.byteslice(offset, length)
+
+            @spans << [offset, offset + length]
+          end
+          @cursor += length
+        end
+
+        def reject!
+          PolyTextFields.reject!
+        end
+      end
+    end
+  end
+end

data/lib/emf/native/resource_failure.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    module ResourceFailure
+      RESOURCES = { 1 => :input_bytes, 2 => :record_bytes, 3 => :record_count,
+                    4 => :allocated_bytes, 5 => :work_units, 6 => :output_bytes }.freeze
+
+      private
+
+      def resource_failure(error)
+        # Older ABI-1 libraries expose only the original status and message.
+        return FormatError.new(error_message(error, 3)) unless @functions.key?(:emf_error_resource_view)
+        return Error.new("native resource failure has no error detail") if error.zero?
+
+        info = Fiddle::Pointer[[32, 1].pack("L2") + ("\0" * 24)]
+        return Error.new("native resource failure detail is unreadable") unless invoke(:emf_error_resource_view, error, info).zero?
+
+        code = info[8, 4].unpack1("L")
+        resource = RESOURCES[code]
+        return Error.new("native resource failure has unknown resource #{code}") unless resource
+
+        limit, actual = info[16, 16].unpack("Q2")
+        ResourceLimitError.new(resource: resource, limit: limit, actual: actual)
+      end
+    end
+  end
+end