emf 0.1.2 → 0.2.0

data/lib/emf/conformance/rules/emf_plus_fields.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+require_relative "emf_plus_common"
+
+# Per-field enumeration and range rules for the decoded EMF+ graphics objects
+# (MS-EMFPLUS 2.2.1). CHECKS is a table of object type => check lambda; each
+# lambda gets the decoded object and returns the problems it finds. Only a
+# clause that says a value "MUST" be, or "is defined in", an enumeration is an
+# error here; the bounds of the payload are emfplus.object.payload's.
+module Emf
+  module Conformance
+    module EmfPlusFields
+      Objects = Emf::EmfPlus::Objects
+      Support = EmfPlusSupport
+
+      # Enumerations, MS-EMFPLUS 2.1.1. LineCapType lists AnchorMask (0xF0) among its values, and a real producer writes it
+      # as an EndCap (LibreOffice emfio TestEmfPlusDrawLineWithCaps).
+      BRUSH_TYPE = (0..4)
+      HATCH_STYLE = (0..0x34)
+      WRAP_MODE = (0..4)
+      UNIT_TYPE = (0..6)
+      LINE_CAP = [0, 1, 2, 3, 0x10, 0x11, 0x12, 0x13, 0x14, 0xF0, 0xFF].freeze
+      LINE_JOIN = (0..3)
+      LINE_STYLE = (0..5)
+      DASHED_LINE_CAP = [0, 2, 3].freeze # DashedLineCapType has no value 1
+      PEN_ALIGNMENT = (0..4)
+      CUSTOM_LINE_CAP_TYPE = (0..1)
+      # Flags, MS-EMFPLUS 2.1.2: every defined bit.
+      BRUSH_DATA_FLAGS = 0x1DF # BrushData 0x01..0x10, 0x40, 0x80, 0x100 (0x20 is undefined)
+      PEN_DATA_FLAGS = 0x1FFF
+      CUSTOM_LINE_CAP_DATA_FLAGS = 0x3
+
+      module_function
+
+      def hex(value) = format("0x%X", value)
+
+      def in_domain(label, value, domain, name)
+        return if value.nil?
+
+        ok = domain.is_a?(Array) ? domain.include?(value) : domain.cover?(value)
+        return if ok
+
+        shown = domain.is_a?(Array) ? domain.map { |v| hex(v) }.join(", ") : "#{hex(domain.first)}..#{hex(domain.last)}"
+        "#{label} #{value} is not a #{name} value (#{shown})"
+      end
+
+      def flags_within(label, value, mask, name)
+        return if value.nil? || value.nobits?(~mask)
+
+        "#{label} #{hex(value)} sets bits outside the defined #{name} flags (#{hex(mask)})"
+      end
+
+      def zero_point(label, point)
+        return if point.nil? || (point.x.to_f.zero? && point.y.to_f.zero?)
+
+        "#{label} is {#{point.x}, #{point.y}}, MUST be {0.0, 0.0}"
+      end
+
+      # --- Brush, Pen, CustomLineCap ------------------------------------------
+
+      def brush(object)
+        type = object.brush_type
+        problems = [in_domain("EmfPlusBrush Type", type, BRUSH_TYPE, "BrushType")]
+        data = object.data
+        case type
+        when Objects::Brush::HATCH
+          problems << in_domain("EmfPlusHatchBrushData HatchStyle", data.hatch_style, HATCH_STYLE, "HatchStyle")
+        when Objects::Brush::TEXTURE, Objects::Brush::PATH_GRADIENT, Objects::Brush::LINEAR_GRADIENT
+          problems << flags_within("BrushDataFlags", data.brush_data_flags, BRUSH_DATA_FLAGS, "BrushData")
+          problems << in_domain("WrapMode", data.wrap_mode, WRAP_MODE, "WrapMode")
+        end
+        problems
+      end
+
+      def pen(object)
+        flags = object.pen_data_flags
+        [("EmfPlusPen Type is #{object.pen_type}, MUST be 0" unless object.pen_type.zero?),
+         flags_within("PenDataFlags", flags, PEN_DATA_FLAGS, "PenData"),
+         in_domain("PenUnit", object.pen_unit, UNIT_TYPE, "UnitType"),
+         in_domain("StartCap", object.start_cap, LINE_CAP, "LineCapType"),
+         in_domain("EndCap", object.end_cap, LINE_CAP, "LineCapType"),
+         in_domain("PenAlignment", object.pen_alignment, PEN_ALIGNMENT, "PenAlignment"),
+         *[object.custom_start_cap, object.custom_end_cap].compact.flat_map { |cap| custom_line_cap(cap) }]
+      end
+
+      # Join, LineStyle and DashedLineCapType: corrupt-by-design LibreOffice fuzz regressions write garbage here and
+      # are expected to stay readable, so this group alone is waived in tolerant (see PEN_LINE_WAIVER).
+      def pen_line(object)
+        [in_domain("Join", object.join, LINE_JOIN, "LineJoinType"),
+         in_domain("LineStyle", object.line_style, LINE_STYLE, "LineStyle"),
+         in_domain("DashedLineCapType", object.dashed_line_cap, DASHED_LINE_CAP, "DashedLineCapType")]
+      end
+
+      def custom_line_cap(object)
+        data = object.data
+        problems = [in_domain("EmfPlusCustomLineCap Type", object.cap_type, CUSTOM_LINE_CAP_TYPE, "CustomLineCapDataType")]
+        case object.cap_type
+        when Objects::CustomLineCap::DEFAULT
+          problems.concat(custom_line_cap_default(data))
+        when Objects::CustomLineCap::ADJUSTABLE_ARROW
+          problems.concat(custom_line_cap_arrow(data))
+        end
+        problems
+      end
+
+      def custom_line_cap_default(data)
+        [flags_within("CustomLineCapDataFlags", data.custom_line_cap_data_flags, CUSTOM_LINE_CAP_DATA_FLAGS, "CustomLineCapData"),
+         in_domain("BaseCap", data.base_cap, LINE_CAP, "LineCapType"),
+         in_domain("StrokeStartCap", data.stroke_start_cap, LINE_CAP, "LineCapType"),
+         in_domain("StrokeEndCap", data.stroke_end_cap, LINE_CAP, "LineCapType"),
+         in_domain("StrokeJoin", data.stroke_join, LINE_JOIN, "LineJoinType"),
+         zero_point("FillHotSpot", data.fill_hot_spot), zero_point("StrokeHotSpot", data.stroke_hot_spot)]
+      end
+
+      def custom_line_cap_arrow(data)
+        [in_domain("LineStartCap", data.line_start_cap, LINE_CAP, "LineCapType"),
+         in_domain("LineEndCap", data.line_end_cap, LINE_CAP, "LineCapType"),
+         in_domain("LineJoin", data.line_join, LINE_JOIN, "LineJoinType"),
+         zero_point("FillHotSpot", data.fill_hot_spot), zero_point("LineHotSpot", data.line_hot_spot)]
+      end
+
+      # Object type => check. Each group below owns its own entries.
+      CHECKS = {
+        # Brush, Pen, CustomLineCap
+        Objects::BRUSH => method(:brush),
+        Objects::PEN => method(:pen),
+        Objects::CUSTOM_LINE_CAP => method(:custom_line_cap),
+        # Path, Region, Font, StringFormat, ImageAttributes
+        **[Objects::PATH, Objects::REGION, Objects::FONT, Objects::STRING_FORMAT, Objects::IMAGE_ATTRIBUTES]
+               .to_h { |type| [type, ->(object) { EmfPlusFieldsB.findings_for(object) }] }
+      }.freeze
+
+      # Same shape as CHECKS, for the fields a real corpus file violates.
+      WAIVED_CHECKS = {
+        # Brush, Pen, CustomLineCap
+        Objects::PEN => method(:pen_line)
+      }.freeze
+
+      PEN_LINE_WAIVER = "fuzz-regression files LibreOffice ships as readable inputs write out-of-domain pen Join / " \
+                        "DashedLineCapType values (vcl graphicfilter emf_fail_crash-2, emf_pass_crash-1, emf_fail_hang-1, " \
+                        "emf_fail_hang-2); importers ignore them and keep drawing"
+
+      def object_fields(stream, located, table = CHECKS)
+        logical = EmfPlusPayloads.completed_object(stream, located)
+        check = logical && table[logical.object_type]
+        return unless check
+
+        label = "EmfPlusObject (object type #{logical.object_type}, ID #{logical.emf_object_id})"
+        check.call(logical.body).compact.map { |problem| "#{label} #{problem}" }
+      rescue Emf::ParseError
+        nil # reported by emfplus.object.payload
+      end
+    end
+
+    Registry.loading.register(id: "emfplus.object.fields", formats: [:emf_plus], citation: "MS-EMFPLUS 2.2.1",
+                              kind: :object_fields, tolerant_reason: nil) do |context|
+      EmfPlusPayloads.per_object(context) { |stream, located| EmfPlusFields.object_fields(stream, located) }
+    end
+
+    Registry.loading.register(id: "emfplus.object.pen_line_fields", formats: [:emf_plus], citation: "MS-EMFPLUS 2.2.2.34",
+                              kind: :object_pen_line, tolerant_reason: EmfPlusFields::PEN_LINE_WAIVER) do |context|
+      EmfPlusPayloads.per_object(context) do |stream, located|
+        EmfPlusFields.object_fields(stream, located, EmfPlusFields::WAIVED_CHECKS)
+      end
+    end
+  end
+end

data/lib/emf/conformance/rules/emf_plus_fields_b.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+# Field-domain checks of the Path, Region, Font, StringFormat and ImageAttributes graphics objects
+# (MS-EMFPLUS 2.2.1.3, 2.2.1.5, 2.2.1.6, 2.2.1.8, 2.2.1.9). No rule is registered here: the shared
+# "emfplus.object.fields" rule (emf_plus_fields.rb) calls findings_for(object) for each completed object.
+# Only MUST-level domains are reported. SHOULD-level text (HotkeyPrefix/StringFormat flag descriptions,
+# "Windows never uses UnitTypeDisplay" in Font SizeUnit) is not an error and is not reported.
+module Emf
+  module Conformance
+    module EmfPlusFieldsB
+      Objects = Emf::EmfPlus::Objects
+
+      UNIT_TYPE = (0..6) # 2.1.1.32; 2.2.1.3 SizeUnit "is in the UnitType enumeration"
+      FONT_STYLE_MASK = 0xF # 2.1.2.4: Bold, Italic, Underline, Strikeout
+      PATH_POINT_TYPES = [0x0, 0x1, 0x3].freeze # 2.1.1.22: Start, Line, Bezier
+      PATH_POINT_FLAGS_MASK = 0x0B # 2.1.2.6 (high nibble): DashMode 0x1, PathMarker 0x2, CloseSubpath 0x8
+      WRAP_MODE = (0..4) # 2.1.1.33
+      OBJECT_CLAMP = (0..1) # 2.2.1.5 "MUST be one of": RectClamp, BitmapClamp
+      STRING_ALIGNMENT = (0..2) # 2.1.1.28
+      DIGIT_SUBSTITUTION = (0..3) # 2.1.1.29
+      HOTKEY_PREFIX = (0..2) # 2.1.1.14
+      STRING_TRIMMING = (0..5) # 2.1.1.30
+      # 2.1.2.8: DirectionRightToLeft, DirectionVertical, NoFitBlackBox, DisplayFormatControl, NoFontFallback,
+      # MeasureTrailingSpaces, NoWrap, LineLimit, NoClip, BypassGDI.
+      STRING_FORMAT_FLAGS_MASK = 0x1 | 0x2 | 0x4 | 0x20 | 0x400 | 0x800 | 0x1000 | 0x2000 | 0x4000 | 0x80000000
+
+      module_function
+
+      # `object` is a completed logical object (object_type, body) or an already decoded Objects::Typed.
+      def findings_for(object)
+        typed = object.is_a?(Objects::Typed) ? object : object.body
+        case typed
+        when Objects::Path then path(typed)
+        when Objects::Region then region(typed)
+        when Objects::Font then font(typed)
+        when Objects::StringFormat then string_format(typed)
+        when Objects::ImageAttributes then image_attributes(typed)
+        else []
+        end
+      end
+
+      def domain(label, value, allowed)
+        return [] if allowed.cover?(value)
+
+        ["#{label} #{value} is outside #{allowed.first}..#{allowed.last}"]
+      end
+
+      def path(path)
+        types = path.point_types.flat_map { |entry| entry.respond_to?(:point_type) ? [entry.point_type] : [entry] }
+        types.flat_map { |type| path_point_type(type) }.uniq.map { |message| "EmfPlusPath #{message}" }
+      end
+
+      def path_point_type(type)
+        messages = []
+        messages << "PathPointType #{type.type} is not Start (0), Line (1) or Bezier (3)" unless PATH_POINT_TYPES.include?(type.type)
+        unless type.flags.nobits?(~PATH_POINT_FLAGS_MASK)
+          messages << "PathPointType flags 0x#{format('%X', type.flags)} hold bits other than DashMode, PathMarker and CloseSubpath"
+        end
+        messages
+      end
+
+      # 2.2.1.8: RegionNode is an array of RegionNodeCount + 1 nodes; the tree read from the data must hold exactly that many.
+      def region(region)
+        expected = region.node_count + 1
+        actual = region.root.node_count
+        return [] if actual == expected
+
+        ["EmfPlusRegion RegionNodeCount #{region.node_count} declares #{expected} nodes but the node tree holds #{actual}"]
+      end
+
+      def font(font)
+        messages = domain("EmfPlusFont SizeUnit", font.size_unit, UNIT_TYPE)
+        unless font.style_flags.nobits?(~FONT_STYLE_MASK)
+          messages << "EmfPlusFont FontStyleFlags 0x#{format('%X',
+                                                             font.style_flags & 0xFFFFFFFF)} sets undefined bits"
+        end
+        messages
+      end
+
+      def string_format(object)
+        body = object.body
+        messages = []
+        messages.concat(domain("EmfPlusStringFormat StringAlignment", body.string_alignment, STRING_ALIGNMENT))
+        messages.concat(domain("EmfPlusStringFormat LineAlign", body.line_align, STRING_ALIGNMENT))
+        messages.concat(domain("EmfPlusStringFormat DigitSubstitution", body.digit_substitution, DIGIT_SUBSTITUTION))
+        messages.concat(domain("EmfPlusStringFormat HotkeyPrefix", body.hotkey_prefix, HOTKEY_PREFIX))
+        messages.concat(domain("EmfPlusStringFormat Trimming", body.trimming, STRING_TRIMMING))
+        unless object.flags.nobits?(~STRING_FORMAT_FLAGS_MASK)
+          messages << "EmfPlusStringFormat StringFormatFlags 0x#{format('%X', object.flags)} sets bits that are not StringFormat flags"
+        end
+        messages
+      end
+
+      def image_attributes(attributes)
+        domain("EmfPlusImageAttributes WrapMode", attributes.wrap_mode, WRAP_MODE) +
+          domain("EmfPlusImageAttributes ObjectClamp", attributes.object_clamp, OBJECT_CLAMP)
+      end
+    end
+  end
+end

data/lib/emf/conformance/rules/emf_plus_framing.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+require_relative "emf_plus_common"
+
+# EMF+ framing and control rules beyond emf_plus.rb: fixed Size/DataSize values,
+# DataSize consistency, undecodable bodies, the Header signature and
+# EndOfFile placement.
+module Emf
+  module Conformance
+    module EmfPlusFraming
+      Records = Emf::EmfPlus::Records
+      Support = EmfPlusSupport
+
+      # DataSize each record type MUST have (Size is then 12 + DataSize), as stated in MS-EMFPLUS 2.3.x.
+      FIXED_DATA_SIZE = {
+        Records::OffsetClip => 8, Records::ResetClip => 0, Records::SetClipPath => 0, Records::SetClipRect => 16,
+        Records::SetClipRegion => 0, Records::EndOfFile => 0, Records::GetDC => 0, Records::Header => 16,
+        Records::Clear => 4, Records::DrawPath => 4, Records::FillPath => 4, Records::FillRegion => 4,
+        Records::SetAntiAliasMode => 0, Records::SetCompositingMode => 0, Records::SetCompositingQuality => 0,
+        Records::SetInterpolationMode => 0, Records::SetPixelOffsetMode => 0, Records::SetRenderingOrigin => 8,
+        Records::SetTextContrast => 0, Records::SetTextRenderingHint => 0, Records::BeginContainer => 36,
+        Records::BeginContainerNoParams => 4, Records::EndContainer => 4, Records::Restore => 4, Records::Save => 4,
+        Records::MultiplyWorldTransform => 24, Records::ResetWorldTransform => 0, Records::RotateWorldTransform => 4,
+        Records::ScaleWorldTransform => 8, Records::SetPageTransform => 4, Records::SetWorldTransform => 24,
+        Records::TranslateWorldTransform => 8
+      }.transform_keys { |klass| klass::TYPE }.freeze
+      # The spec gives SetAntiAliasMode a DataSize only, not a Size.
+      SIZE_UNSPECIFIED = [Records::SetAntiAliasMode::TYPE].freeze
+
+      # Records whose Size and DataSize a formula rule states exactly: type => [rule module, check method]. Where that
+      # check names a DataSize problem, the generic emfplus.record.data_size and emfplus.record.body_bounds stay silent.
+      FORMULA_OWNERS = {
+        Records::DrawEllipse::TYPE => %i[EmfPlusDrawing ellipse_size], Records::FillEllipse::TYPE => %i[EmfPlusDrawing ellipse_size],
+        Records::DrawDriverString::TYPE => %i[EmfPlusPayloads driver_string_size],
+        Records::DrawString::TYPE => %i[EmfPlusPayloads draw_string_size],
+        Records::DrawImage::TYPE => %i[EmfPlusPayloads draw_image_size],
+        Records::DrawImagePoints::TYPE => %i[EmfPlusPayloads draw_image_size],
+        Records::SerializableObject::TYPE => %i[EmfPlusPayloads serializable_size],
+        Records::SetTSClip::TYPE => %i[EmfPlusPayloads ts_clip_size], Records::SetTSGraphics::TYPE => %i[EmfPlusPayloads ts_graphics_size]
+      }.freeze
+
+      module_function
+
+      def formula_owned?(located)
+        owner, check = FORMULA_OWNERS[located.record.type]
+        owner && Conformance.const_get(owner).public_send(check, located).to_s.include?("DataSize")
+      end
+
+      def fixed_size(located)
+        record = located.record
+        expected = FIXED_DATA_SIZE[record.type]
+        return unless expected
+
+        return if page_transform_bodyless?(record)
+
+        size = Support.size_of(record)
+        data_size = Support.data_size_of(record)
+        problems = []
+        problems << "DataSize is #{data_size}, MUST be #{expected}" unless data_size == expected
+        problems << "Size is #{size}, MUST be #{expected + 12}" unless size == expected + 12 || SIZE_UNSPECIFIED.include?(record.type)
+        "#{Support.type_name(record)} #{problems.join(' and ')}" unless problems.empty?
+      end
+
+      # The exact body-less SetPageTransform: Size 12, DataSize 0 (the spec says Size 16, DataSize 4).
+      def page_transform_bodyless?(record)
+        record.type == Records::SetPageTransform::TYPE && Support.data_size_of(record).zero? && Support.size_of(record) == 12
+      end
+
+      def page_transform_bodyless(located)
+        record = located.record
+        return unless page_transform_bodyless?(record)
+
+        "#{Support.type_name(record)} has Size 12 and DataSize 0, MUST be Size 16 and DataSize 4 (its PageScale is missing)"
+      end
+
+      # A defined record whose fields (padded to 4) decode to fewer bytes than DataSize leaves bytes unaccounted for.
+      # DataSize is 32-bit aligned (MS-EMFPLUS 2.3.3), so padding after an odd-length field is not a surplus.
+      def data_size_mismatch(located)
+        record = located.record
+        return unless Support.typed?(record) && !FIXED_DATA_SIZE.key?(record.type)
+
+        used = record.body.num_bytes
+        # An unaligned DataSize is emfplus.record.data_size_alignment's; compare what it rounds up to.
+        return if ((record.data_size + 3) & ~3) == ((used + 3) & ~3) || formula_owned?(located)
+
+        "#{Support.type_name(record)} DataSize is #{record.data_size} but its fields occupy #{used} bytes"
+      end
+
+      def data_size_alignment(located)
+        data_size = Support.data_size_of(located.record)
+        return if (data_size % 4).zero?
+
+        "#{Support.type_name(located.record)} DataSize #{data_size} is not a multiple of 4"
+      end
+
+      def undecodable(located)
+        record = located.record
+        return if Support.typed?(record) || !Records.registry.key?(record.type) || formula_owned?(located)
+
+        "#{Support.type_name(record)} body does not fit in its DataSize #{record.frame.data_size} " \
+          "(a count or length field runs past the record)"
+      end
+
+      def header_signature(located)
+        record = located.record
+        return unless record.is_a?(Records::Header) && !record.valid_signature?
+
+        format("EmfPlusHeader MetafileSignature is 0x%05X, MUST be 0xDBC01", record.graphics_signature)
+      end
+
+      def eof_findings(context)
+        located = Support.records(context)
+        return [] if located.empty?
+
+        eof_at = located.rindex { |item| item.record.is_a?(Records::EndOfFile) }
+        return [missing_eof(located.last)] unless eof_at
+
+        eof = located.fetch(eof_at)
+        problems = []
+        problems << "records follow it in the stream" if eof_at < located.size - 1
+        problems << "its EMR_COMMENT is not the record immediately before EMR_EOF" unless last_comment?(context, eof)
+        if problems.empty?
+          []
+        else
+          [Support.finding(eof,
+                           "EmfPlusEndOfFile MUST be the last EMF+ record, in the EMF record before EMR_EOF; #{problems.join(' and ')}")]
+        end
+      end
+
+      def missing_eof(last)
+        Support.finding(last, "no EmfPlusEndOfFile: the last EMF+ record MUST be EmfPlusEndOfFile")
+      end
+
+      def last_comment?(context, eof)
+        context.records.size >= 2 && eof.comment_index == context.records.size - 2
+      end
+    end
+
+    registry = Registry.loading
+    EmfPlusSupport.per_record(id: "emfplus.record.fixed_size", citation: "MS-EMFPLUS 2.3", kind: :record_fixed_size) do |located|
+      EmfPlusFraming.fixed_size(located)
+    end
+    EmfPlusSupport.per_record(id: "emfplus.record.page_transform_bodyless", citation: "MS-EMFPLUS 2.3",
+                              kind: :record_page_transform_bodyless,
+                              tolerant_reason: "LibreOffice's TestAlignRtlReading and tdf93750 carry a body-less SetPageTransform and " \
+                                               "import; the record is kept with its bytes intact") do |located|
+      EmfPlusFraming.page_transform_bodyless(located)
+    end
+    EmfPlusSupport.per_record(id: "emfplus.record.data_size", citation: "MS-EMFPLUS 2.3", kind: :record_data_size,
+                              tolerant_reason: "the surplus bytes stay in the record's trailing data, so nothing is dropped") do |located|
+      EmfPlusFraming.data_size_mismatch(located)
+    end
+    EmfPlusSupport.per_record(id: "emfplus.record.data_size_alignment", citation: "MS-EMFPLUS 2.3.3",
+                              kind: :record_data_size_alignment,
+                              tolerant_reason: "DataSize is informational once Size is aligned; the record frames and decodes") do |located|
+      EmfPlusFraming.data_size_alignment(located)
+    end
+    EmfPlusSupport.per_record(id: "emfplus.record.body_bounds", citation: "MS-EMFPLUS 2.3", kind: :record_body_bounds,
+                              tolerant_reason: "the record is kept as an unknown record with its bytes intact") do |located|
+      EmfPlusFraming.undecodable(located)
+    end
+    EmfPlusSupport.per_record(id: "emfplus.header.signature", citation: "MS-EMFPLUS 2.2.2.19", kind: :header_signature) do |located|
+      EmfPlusFraming.header_signature(located)
+    end
+    registry.register(id: "emfplus.eof.placement", formats: [:emf_plus], citation: "MS-EMFPLUS 1.3", kind: :eof_placement,
+                      tolerant_reason: "records after the EMF+ end of file stay readable and are kept") do |context|
+      EmfPlusFraming.eof_findings(context)
+    end
+  end
+end

data/lib/emf/conformance/rules/emf_plus_objects.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+require_relative "emf_plus_common"
+
+# Turns the public object-resolution results (Stream#resolve -> ObjectTable::Resolution)
+# into diagnostics at the referring record. The resolver itself is not copied.
+# Object-definition problems (incomplete chains, definition IDs out of range) are
+# ObjectTable#errors, which emf_plus.rb already reports as emfplus.stream.framing.
+module Emf
+  module Conformance
+    module EmfPlusObjects
+      Support = EmfPlusSupport
+
+      OPTIONAL_REFERENCE = "the referenced object (StringFormatId, ImageAttributesID, a clip Region) is optional or absent and " \
+                           "producers write 0xFFFFFFFF, 0 or a never-defined slot for none; importers skip it and keep drawing " \
+                           "(corpus: LibreOffice emfio TestDrawStringTransparent, TestDrawImagePointsTypeBitmap, " \
+                           "TestDrawStringWithBrush, cppcanvas fdo77229, graphicfilter pass_fdo38580-3)"
+
+      KINDS = {
+        empty_slot: ["emfplus.object.empty_slot", "refers to an object slot with no object defined before this record"],
+        wrong_type: ["emfplus.object.wrong_type", "refers to a slot holding an object of a different type"],
+        object_id_out_of_range: ["emfplus.object.id_range", "has an object ID outside 0..63"]
+      }.freeze
+
+      # Optional references (MS-EMFPLUS: StringFormatId, ImageAttributesID; the clip Region of SetClipRegion as
+      # written by the corpus producers). Every other role (pen, brush, path, font, image, fill region) is mandatory.
+      OPTIONAL_ROLES = %i[string_format image_attributes].freeze
+
+      OPTIONAL_KINDS = {
+        empty_slot: ["emfplus.object.optional_empty_slot",
+                     "refers to an optional object slot with no object defined before this record"],
+        object_id_out_of_range: ["emfplus.object.optional_id_range",
+                                 "has an optional object reference with an ID outside 0..63"]
+      }.freeze
+
+      module_function
+
+      # A SetClipRegion naming a never-defined slot is a measured producer pattern (LibreOffice fdo38580-3); an
+      # out-of-range id is not, and MS-EMFPLUS 2.3.1.5 limits the Region ObjectID to 0..63, so it stays mandatory.
+      def optional?(located, resolution)
+        return true if OPTIONAL_ROLES.include?(resolution.role)
+
+        located.record.is_a?(Emf::EmfPlus::Records::SetClipRegion) && resolution.diagnostic&.kind == :empty_slot
+      end
+
+      def findings(context, kind, optional: false)
+        stream = context.metafile.emf_plus_stream
+        return [] unless stream
+
+        Support.records(context).flat_map do |located|
+          stream.resolve(located.handle).filter_map do |resolution|
+            next unless resolution.diagnostic&.kind == kind
+            next unless kind == :wrong_type || optional?(located, resolution) == optional
+
+            Support.finding(located, "#{Support.type_name(located.record)} #{resolution.role} reference " \
+                                     "#{resolution.raw_id} #{(optional ? OPTIONAL_KINDS : KINDS).fetch(kind).last}")
+          end
+        end
+      end
+    end
+
+    # MS-EMFPLUS 2.3.4.9: an E-flag DrawImagePoints needs an Effect specified in an earlier
+    # SerializableObject. Stream#effect_for is the public link (the immediately preceding record).
+    Registry.loading.register(id: "emfplus.object.effect_missing", formats: [:emf_plus], citation: "MS-EMFPLUS 2.3.4.9",
+                              kind: :effect_link, tolerant_reason: nil) do |context|
+      stream = context.metafile.emf_plus_stream
+      next [] unless stream
+
+      located_records = EmfPlusSupport.records(context)
+      located_records.each_with_index.filter_map do |located, index|
+        # Type and flags come from the record frame, so an E-flag draw whose body does not decode is still checked.
+        record = located.record
+        draw = Emf::EmfPlus::Records::DrawImagePoints
+        next unless record.type == draw::TYPE && record.flags.anybits?(draw::EFFECT_FLAG)
+        next if stream.effect_for(located.handle)
+        # The clause says "an earlier" SerializableObject, not the immediately preceding one.
+        next if located_records.first(index).any? { |earlier| earlier.record.type == Emf::EmfPlus::Records::SerializableObject::TYPE }
+
+        EmfPlusSupport.finding(located, "DrawImagePoints has the effect flag but no SerializableObject record precedes it")
+      end
+    end
+
+    EmfPlusObjects::KINDS.each do |kind, (id, _)|
+      Registry.loading.register(id: id, formats: [:emf_plus], citation: "MS-EMFPLUS 2.3.4", kind: kind,
+                                tolerant_reason: nil) { |context| EmfPlusObjects.findings(context, kind) }
+    end
+
+    EmfPlusObjects::OPTIONAL_KINDS.each do |kind, (id, _)|
+      Registry.loading.register(id: id, formats: [:emf_plus], citation: "MS-EMFPLUS 2.3.4", kind: :"optional_#{kind}",
+                                tolerant_reason: EmfPlusObjects::OPTIONAL_REFERENCE) do |context|
+        EmfPlusObjects.findings(context, kind, optional: true)
+      end
+    end
+  end
+end