automotive-ecu 0.4.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e5446929b1a5bedccd68a5e669c148a0386663feda51949c8ebaee2fe143db3
-  data.tar.gz: ede842831f425f87c3092be6cd72185b82f5eb8b2a7d50ccc635ba23ec85b661
+  metadata.gz: cbc3b625690b9f5d8d6bf67e86b3ce6134cd35ae10240f1b02a2708c2a63fd8f
+  data.tar.gz: 337197db174176a05b20c762edc9ed31f7f9cdaa5ec9ccc7d4a4e28c2a70e491
 SHA512:
-  metadata.gz: 4b408ab9515e6909db8d4f9efa029ffd9cfa498afb9f5d5ecbff14a6283338741b6d8cc931db4b2b5eec52096ecb77b20e8072890d7e229b8b0f1fb1f176e02a
-  data.tar.gz: 7a9bed9c8d5568bccd4423f0578c28062e8e769b4a0c5bc44770d2356307bc1f8e33dcbebac0d430e48a6f8578021032d2c79c7072c42194828b269e4a52b445
+  metadata.gz: 790eaa6e0abc424b844153076789a6847a35806af182ee502fc7105d63de02b0778128f70ea6b774a235eff166b9480624aead5919122706389f0f0f5f620003
+  data.tar.gz: 2712b9924613bddac8486f4dfeb69b0a7ff52172067e8ab0c198cd6f6bdad4f65a025f4734f543e45020e8fe74871fb52355ee6ac8820df2395025f3eba20bd4

data/lib/ecu/interfaces/a2l/a2l_conversion.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require_relative "a2l_parser_error"
+
+class Ecu
+  class LabelList
+    class A2lConversion
+      def initialize(blocks)
+        @methods = {}
+        @tables = {}
+        @units = {}
+        index(blocks)
+      end
+
+      def convert(name, value)
+        return value if name == "NO_COMPU_METHOD"
+
+        method = lookup(@methods, name)
+        case method.values[2]
+        when "IDENTICAL"
+          value
+        when "LINEAR"
+          slope, offset = coefficients(method, "COEFFS_LINEAR", 2)
+          number(number(value) * slope + offset)
+        when "RAT_FUNC"
+          rational(method, number(value))
+        when "TAB_VERB", "TAB_INTP", "TAB_NOINTP"
+          table_value(method, number(value))
+        else
+          fail_conversion("Unsupported conversion #{method.values[2]}: #{name}")
+        end
+      end
+
+      def unit(name)
+        return nil if name == "NO_COMPU_METHOD"
+
+        method = lookup(@methods, name)
+        reference = option(method, "REF_UNIT")
+        return method.values[4] unless reference
+
+        lookup(@units, reference.first).values[2]
+      end
+
+      private
+
+      def fail_conversion(message)
+        raise Ecu::A2lParserError, message
+      end
+
+      def index(blocks)
+        blocks.each do |block|
+          registry = case block.kind
+                     when "COMPU_METHOD" then @methods
+                     when "COMPU_TAB", "COMPU_VTAB", "COMPU_VTAB_RANGE" then @tables
+                     when "UNIT" then @units
+                     end
+          if registry
+            name = block.values.first
+            fail_conversion("Duplicate #{block.kind} #{name}") if registry.key?(name)
+            registry[name] = block
+          else
+            index(block.children)
+          end
+        end
+      end
+
+      def lookup(registry, name)
+        registry.fetch(name) { fail_conversion("Missing reference #{name}") }
+      end
+
+      def option(block, name)
+        child = block.children.find { |entry| entry.kind == name }
+        return child.values if child
+
+        # Header fields can contain arbitrary quoted text, including keywords.
+        start = case block.kind
+                when "COMPU_METHOD" then 5
+                when "COMPU_VTAB_RANGE" then 3 + table_count(block, 2) * 3
+                when "COMPU_TAB", "COMPU_VTAB" then 4 + table_count(block, 3) * 2
+                else 0
+                end
+        position = (start...block.values.length).find { |i| block.values[i] == name }
+        block.values[(position + 1)..-1] if position
+      end
+
+      def number(value)
+        return value if value.is_a?(Integer)
+        return Integer(value, 10) if value.is_a?(String) && /\A[+-]?[0-9]+\z/.match?(value)
+        return Integer(value, 16) if value.is_a?(String) && /\A[+-]?0[xX][0-9A-Fa-f]+\z/.match?(value)
+
+        result = Float(value)
+        fail_conversion("Non-finite numeric value #{value}") unless result.finite?
+        result
+      rescue ArgumentError, TypeError
+        fail_conversion("Invalid numeric value #{value.inspect}")
+      end
+
+      def coefficients(block, keyword, count)
+        values = option(block, keyword)
+        fail_conversion("Missing #{keyword} for #{block.values.first}") unless values && values.size >= count
+        values.first(count).map { |value| number(number(value).to_f) }
+      end
+
+      def rational(method, internal)
+        a, b, c, d, e, f = coefficients(method, "COEFFS", 6)
+        fail_conversion("Zero rational denominator") if [d, e, f].all?(&:zero?)
+        scale = normalization_scale([a, b, c, d, e, f])
+        a, b, c, d, e, f = [a, b, c, d, e, f].map { |coefficient| coefficient / scale }
+        # internal = (a*x*x + b*x + c) / (d*x*x + e*x + f)
+        internal = number(internal.to_f)
+        scale = normalization_scale([internal, 1.0])
+        aa, bb, cc = a / scale - internal / scale * d,
+                     b / scale - internal / scale * e,
+                     c / scale - internal / scale * f
+        scale = normalization_scale([aa, bb, cc])
+        aa, bb, cc = [aa, bb, cc].map { |coefficient| coefficient / scale }
+        if aa.zero?
+          fail_conversion(cc.zero? ? "ambiguous rational inverse" : "Rational domain error") if bb.zero?
+          roots = [-cc / bb]
+        else
+          discriminant = bb * bb - 4 * aa * cc
+          fail_conversion("Rational domain error") if discriminant < 0
+          if discriminant.zero?
+            roots = [-bb / (2 * aa)]
+          else
+            # Stable quadratic evaluation avoids subtracting nearly equal numbers.
+            q = -0.5 * (bb + (bb < 0 ? -Math.sqrt(discriminant) : Math.sqrt(discriminant)))
+            roots = [q / aa, cc / q]
+          end
+        end
+        roots = roots.uniq.select { |root| root.finite? && !(d * root * root + e * root + f).zero? }
+        fail_conversion("Zero rational denominator or domain error") if roots.empty?
+        fail_conversion("ambiguous rational inverse") if roots.length > 1
+        roots.first
+      end
+
+      def normalization_scale(values)
+        # Power-of-two scaling avoids rounding ordinary coefficients while keeping
+        # the discriminant away from overflow and underflow.
+        Math.ldexp(1.0, Math.frexp(values.map(&:abs).max).last - 1)
+      end
+
+      def table_count(table, position)
+        count = Integer(table.values[position], 10)
+        fail_conversion("Invalid table count") if count < 0
+        count
+      rescue ArgumentError, TypeError
+        fail_conversion("Invalid table count")
+      end
+
+      def table_value(method, value)
+        reference = option(method, "COMPU_TAB_REF")
+        fail_conversion("Missing COMPU_TAB_REF for #{method.values.first}") unless reference
+        table = lookup(@tables, reference.first)
+        verbal = method.values[2] == "TAB_VERB"
+        if table.kind == "COMPU_VTAB_RANGE" && verbal
+          count = table_count(table, 2)
+          rows = table.values.slice(3, count * 3)
+          fail_conversion("Malformed verbal ranges") unless rows && rows.length == count * 3
+          entries = rows.each_slice(3).map do |low, high, label|
+            low, high = number(low), number(high)
+            fail_conversion("Invalid verbal range") if low > high || label.nil?
+            [low, high, label]
+          end
+          matches = entries.select { |low, high, _| value >= low && value <= high }
+          fail_conversion("Ambiguous verbal range") if matches.size > 1
+          return matches.first[2] unless matches.empty?
+        else
+          expected = verbal ? "COMPU_VTAB" : "COMPU_TAB"
+          fail_conversion("Invalid table type #{table.kind}") unless table.kind == expected
+          count = table_count(table, 3)
+          rows = table.values.slice(4, count * 2)
+          fail_conversion("Malformed conversion table") unless rows && rows.length == count * 2
+          entries = rows.each_slice(2).map { |input, output| [number(input), verbal ? output : number(output)] }
+          fail_conversion("Duplicate table input") unless entries.map(&:first).uniq.size == entries.size
+          exact = entries.find { |input, _| input == value }
+          return exact[1] if exact
+          if method.values[2] == "TAB_INTP"
+            pair = entries.sort_by(&:first).each_cons(2).find { |left, right| value > left[0] && value < right[0] }
+            if pair
+              left, right = pair
+              # Subtract integer keys before converting, preserving adjacent 64-bit inputs.
+              distance, width = value - left[0], right[0] - left[0]
+              if distance.finite? && width.finite?
+                fraction = distance.fdiv(width)
+              else
+                scale = [value.abs, left[0].abs, right[0].abs].max
+                fraction = (value / scale - left[0] / scale) / (right[0] / scale - left[0] / scale)
+              end
+              return number(left[1] * (1.0 - fraction) + right[1] * fraction)
+            end
+          end
+        end
+        default = option(table, verbal ? "DEFAULT_VALUE" : "DEFAULT_VALUE_NUMERIC")
+        return verbal ? default.first : number(default.first) if default && !default.empty?
+
+        fail_conversion("No table entry or default for #{value}")
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/a2l/a2l_document.rb

@@ -0,0 +1,103 @@
+require "strscan"
+require_relative "a2l_parser_error"
+
+class Ecu
+  class LabelList
+    class A2lDocument
+      Block = Struct.new(:kind, :values, :children, :line, keyword_init: true)
+
+      def initialize(text = nil, **keywords)
+        @text = keywords.fetch(:text, text)
+      end
+
+      def call
+        unless @text.is_a?(String) && @text.valid_encoding? && @text.encoding.ascii_compatible?
+          raise A2lParserError, "Invalid A2L text encoding at line 1"
+        end
+
+        @scanner = StringScanner.new(@text)
+        @line = 1
+        stack = []
+        modules = []
+        while (token = next_token)
+          value, line, quoted = token
+          if !quoted && value == "/begin"
+            kind = block_name(line)
+            ignored = (!stack.empty? && stack.last[2].nil?) ||
+              %w[MEASUREMENT A2ML IF_DATA].include?(kind)
+            block = ignored ? nil : Block.new(kind: kind, values: [], children: [], line: line)
+            stack.last[2].children << block if block && !stack.empty? && stack.last[2]
+            modules << block if block && kind == "MODULE"
+            stack << [kind, line, block]
+          elsif !quoted && value == "/end"
+            kind = block_name(line)
+            if stack.empty? || stack.last[0] != kind
+              expected = stack.empty? ? "no open block" : stack.last[0]
+              raise A2lParserError, "At line #{line}: /end #{kind}, expected #{expected}"
+            end
+            stack.pop
+          elsif !stack.empty? && stack.last[2]
+            stack.last[2].values << value
+          end
+        end
+        unless stack.empty?
+          kind, line = stack.last
+          raise A2lParserError, "Unclosed #{kind} block opened at line #{line}"
+        end
+        modules
+      ensure
+        @scanner = nil
+      end
+
+      private
+
+      def block_name(line)
+        token = next_token
+        unless token && !token[2] && token[0].match?(/\A[A-Za-z_][A-Za-z_0-9]*\z/)
+          raise A2lParserError, "Expected block name at line #{line}"
+        end
+        token[0]
+      end
+
+      def next_token
+        loop do
+          return if @scanner.eos?
+          if (space = @scanner.scan(/\s+/))
+            @line += space.count("\n")
+          elsif @scanner.scan(%r{//[^\n]*})
+            next
+          elsif @scanner.scan(%r{/\*})
+            line = @line
+            comment = @scanner.scan_until(%r{\*/})
+            raise A2lParserError, "Unclosed comment at line #{line}" unless comment
+            @line += comment.count("\n")
+          else
+            break
+          end
+        end
+
+        line = @line
+        if @scanner.peek(1) == '"'
+          text = @scanner.scan(/"(?:\\.|[^"\\])*"/m)
+          raise A2lParserError, "Unclosed string at line #{line}" unless text
+          @line += text.count("\n")
+          value = text[1...-1].gsub(/\\(.)/m) do
+            escaped = Regexp.last_match(1)
+            case escaped
+            when '"', "'", "\\" then escaped
+            when "n" then "\n"
+            when "r" then "\r"
+            when "t" then "\t"
+            else "\\#{escaped}"
+            end
+          end
+          [value, line, true]
+        else
+          text = @scanner.scan(/(?:(?!\/[\/\*])[^\s"])+/)
+          raise A2lParserError, "Invalid token at line #{line}" unless text
+          [text, line, false]
+        end
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/a2l/a2l_parser.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require_relative "a2l_parser_error"
+require_relative "../../labels/festwert"
+require_relative "../../labels/festwerteblock"
+require_relative "../../labels/kennlinie"
+require_relative "../../labels/kennfeld"
+require_relative "../../labels/stuetzstellenverteilung"
+
+class Ecu
+  class LabelList
+    class A2lParser
+      def initialize(a2l, s19, address_map: nil)
+        @a2l, @s19, @address_map = a2l, s19, address_map
+      end
+
+      def call
+        require_relative "a2l_document" unless defined?(A2lDocument)
+        require_relative "s19_image" unless defined?(S19Image)
+        require_relative "a2l_conversion" unless defined?(A2lConversion)
+        @image = S19Image.new(@s19, address_map: @address_map)
+        A2lDocument.new(@a2l).call.flat_map { |mod| decode_module(mod) }
+      end
+
+      private
+
+      def decode_module(mod)
+        @layouts = index(mod.children, "RECORD_LAYOUT")
+        @shared = index(mod.children, "AXIS_PTS")
+        index(mod.children, "CHARACTERISTIC")
+        @common = mod.children.find { |b| b.kind == "MOD_COMMON" }
+        @conversion = A2lConversion.new(mod.children)
+        @axis_cache = {}
+        @functions = {}
+        mod.children.select { |b| b.kind == "FUNCTION" }.each do |function|
+          function.children.select { |b| %w[DEF_CHARACTERISTIC REF_CHARACTERISTIC].include?(b.kind) }.each do |refs|
+            refs.values.each { |name| @functions[name] ||= function.values.first }
+          end
+        end
+        mod.children.select { |b| %w[CHARACTERISTIC AXIS_PTS].include?(b.kind) }.map do |object|
+          begin
+            object.kind == "AXIS_PTS" ? shared_axis(object.values.first, []) : characteristic(object)
+          rescue Ecu::A2lParserError, ArgumentError, KeyError => e
+            raise Ecu::A2lParserError, "#{object.values.first} at #{object.values[object.kind == 'AXIS_PTS' ? 2 : 3]} (line #{object.line}): #{e.message}"
+          end
+        end
+      end
+
+      def index(blocks, kind)
+        blocks.select { |b| b.kind == kind }.each_with_object({}) do |b, result|
+          name = b.values.first
+          fail_format("Duplicate #{kind} #{name} (line #{b.line})") if result.key?(name)
+          result[name] = b
+        end
+      end
+
+      def fail_format(message)
+        raise Ecu::A2lParserError, message
+      end
+
+      def number(value)
+        fail_format("Missing number") if value.nil?
+        value.to_s.match?(/\A[+-]?0x/i) ? Integer(value, 16) : Integer(value, 10)
+      end
+
+      def numeric(value)
+        return number(value) if value.to_s.match?(/\A[+-]?(?:0x[0-9a-f]+|\d+)\z/i)
+        result = Float(value)
+        fail_format("Nonfinite fixed axis parameter") unless result.finite?
+        result
+      end
+
+      def options(block)
+        return [] unless block
+        offset = {"CHARACTERISTIC" => 9, "AXIS_PTS" => 10, "AXIS_DESCR" => 6, "MOD_COMMON" => 1}.fetch(block.kind, 0)
+        block.values.drop(offset)
+      end
+
+      def option(block, key, length = 1)
+        return nil unless block
+        child = block.children.find { |b| b.kind == key }
+        return child.values.first(length) if child
+        values = options(block)
+        i = values.index(key)
+        i ? values.slice(i + 1, length) : nil
+      end
+
+      def unit(block, conversion)
+        option(block, "PHYS_UNIT")&.first || @conversion.unit(conversion)
+      end
+
+      def metadata(block)
+        {name: block.values[0], description: block.values[1], function: @functions[block.values[0]]}
+      end
+
+      def byte_order(block)
+        order = option(block, "BYTE_ORDER")&.first || option(@common, "BYTE_ORDER")&.first || "MSB_LAST"
+        fail_format("Unsupported BYTE_ORDER #{order}") unless %w[MSB_LAST MSB_FIRST].include?(order)
+        order
+      end
+
+      def layout(block, name)
+        fail_format("Unsupported DEPOSIT RELATIVE") if option(block, "DEPOSIT")&.first == "RELATIVE"
+        definition = @layouts[name] || fail_format("Unknown RECORD_LAYOUT #{name}")
+        values = definition.values.drop(1)
+        fields, alignments = [], {}
+        until values.empty?
+          kind = values.shift
+          if kind.start_with?("ALIGNMENT_")
+            fail_format("Unsupported critical RECORD_LAYOUT field #{kind}") unless %w[
+              ALIGNMENT_BYTE ALIGNMENT_WORD ALIGNMENT_LONG ALIGNMENT_INT64
+              ALIGNMENT_FLOAT32_IEEE ALIGNMENT_FLOAT64_IEEE
+            ].include?(kind)
+            alignments[kind] = number(values.shift)
+          elsif kind == "FNC_VALUES" || %w[AXIS_PTS_X AXIS_PTS_Y].include?(kind)
+            position, type, direction, addressing = values.shift(4)
+            fail_format("Unsupported pointer addressing #{addressing}") unless addressing == "DIRECT"
+            allowed = kind == "FNC_VALUES" ? %w[ROW_DIR COLUMN_DIR] : %w[INDEX_INCR INDEX_DECR]
+            fail_format("Unsupported #{kind} direction #{direction}") unless allowed.include?(direction)
+            fields << [kind, number(position), type, direction]
+          elsif %w[NO_AXIS_PTS_X NO_AXIS_PTS_Y].include?(kind)
+            position, type = values.shift(2)
+            fields << [kind, number(position), type, nil]
+          else
+            fail_format("Unsupported critical RECORD_LAYOUT field #{kind}")
+          end
+        end
+        fail_format("Duplicate RECORD_LAYOUT component") unless fields.map(&:first).uniq.size == fields.size &&
+          fields.map { |f| f[1] }.uniq.size == fields.size
+        fail_format("Invalid RECORD_LAYOUT component position") unless fields.all? { |f| f[1].positive? }
+        fields.each do |kind, position, _type, _direction|
+          next unless kind.start_with?("NO_AXIS_PTS_")
+          axis_kind = kind.sub("NO_", "")
+          consumers = fields.select { |f| [axis_kind, "FNC_VALUES"].include?(f[0]) }
+          fail_format("Runtime axis count must precede dependent components") unless consumers.all? { |f| position < f[1] }
+        end
+        [fields.sort_by { |f| f[1] }, alignments]
+      end
+
+      def alignment(type, local)
+        key = case type
+              when "UBYTE", "SBYTE" then "ALIGNMENT_BYTE"
+              when "UWORD", "SWORD" then "ALIGNMENT_WORD"
+              when "ULONG", "SLONG" then "ALIGNMENT_LONG"
+              when "A_UINT64", "A_INT64" then "ALIGNMENT_INT64"
+              when "FLOAT32_IEEE" then "ALIGNMENT_FLOAT32_IEEE"
+              when "FLOAT64_IEEE" then "ALIGNMENT_FLOAT64_IEEE"
+              else fail_format("Unknown data type #{type}")
+              end
+        value = local[key] || number(option(@common, key)&.first || "1")
+        fail_format("Invalid #{key} #{value}") unless value.positive?
+        value
+      end
+
+      def deposit(block, name, address, dimensions, ascii: false)
+        fail_format("Invalid dimensions #{dimensions.inspect}") unless dimensions.all? { |d| d.is_a?(Integer) && d.positive? }
+        fields, local = layout(block, name)
+        data = {}
+        cursor = number(address)
+        fields.each do |kind, _position, type, direction|
+          size = S19Image::TYPES.fetch(type) { fail_format("Unknown data type #{type}") }.first
+          align = alignment(type, local)
+          cursor = (cursor + align - 1) / align * align
+          count = case kind
+                  when "NO_AXIS_PTS_X", "NO_AXIS_PTS_Y" then 1
+                  when "AXIS_PTS_X" then dimensions[0]
+                  when "AXIS_PTS_Y" then dimensions[1]
+                  else dimensions.reduce(:*)
+                  end
+          fail_format("Invalid element count #{count}") unless count && count.positive?
+          data[kind] = if ascii && kind == "FNC_VALUES"
+                         fail_format("ASCII requires byte storage") unless size == 1
+                         @image.read(cursor, count)
+                       else
+                         @image.values(cursor, type, count, byte_order(block))
+                       end
+          cursor += size * count
+          if kind.start_with?("NO_AXIS_PTS_")
+            i = kind.end_with?("X") ? 0 : 1
+            actual = data[kind].first
+            fail_format("Invalid runtime axis count #{actual}") unless actual.is_a?(Integer) && actual.positive? && actual <= dimensions[i]
+            dimensions[i] = actual
+          elsif kind.start_with?("AXIS_PTS_") && direction == "INDEX_DECR"
+            data[kind].reverse!
+          end
+          data["direction"] = direction if kind == "FNC_VALUES"
+        end
+        data
+      end
+
+      def converted(block, values, conversion)
+        mask = option(block, "BIT_MASK")&.first
+        if mask
+          mask = number(mask)
+          fail_format("Invalid BIT_MASK") unless mask.positive?
+          shift = 0
+          shift += 1 while (mask & (1 << shift)).zero?
+          values = values.map do |v|
+            fail_format("BIT_MASK requires integer storage") unless v.is_a?(Integer)
+            (v & mask) >> shift
+          end
+        end
+        values.map { |v| @conversion.convert(conversion, v) }
+      end
+
+      def shared_axis(name, stack)
+        fail_format("Shared axis cycle #{(stack + [name]).join(' -> ')}") if stack.include?(name)
+        return @axis_cache[name] if @axis_cache.key?(name)
+        block = @shared[name] || fail_format("Unknown AXIS_PTS_REF #{name}")
+        reference = option(block, "AXIS_PTS_REF")&.first
+        if reference
+          other = shared_axis(reference, stack + [name])
+          values = other.xvalue
+        else
+          dims = [number(block.values[7]), 1]
+          data = deposit(block, block.values[4], block.values[2], dims)
+          raw = data["AXIS_PTS_X"] || fail_format("Missing AXIS_PTS_X for #{name}")
+          values = converted(block, raw, block.values[6])
+        end
+        maximum = number(block.values[7])
+        fail_format("Shared axis count exceeds maximum") unless maximum.positive? && values.size <= maximum
+        @axis_cache[name] = Ecu::Stuetzstellenverteilung.new(**metadata(block), xdim: values.size,
+          xvalue: values, xunit: unit(block, block.values[6]))
+      end
+
+      def fixed_axis(axis, count)
+        list = axis.children.find { |b| b.kind == "FIX_AXIS_PAR_LIST" }&.values
+        if list
+          fail_format("Fixed axis count mismatch") unless list.size == count
+          return list.map { |v| numeric(v) }
+        end
+        if (params = option(axis, "FIX_AXIS_PAR", 3))
+          offset, shift, size = params.map { |v| number(v) }
+          fail_format("Nonfinite fixed axis distance") if shift > 1023
+          distance = shift.negative? ? 2.0**shift : 2**shift
+        elsif (params = option(axis, "FIX_AXIS_PAR_DIST", 3))
+          offset, distance = params.first(2).map { |v| numeric(v) }
+          size = number(params[2])
+        else
+          fail_format("Missing fixed axis parameters")
+        end
+        fail_format("Fixed axis count mismatch") unless size == count
+        count.times.map do |i|
+          value = offset + i * distance
+          fail_format("Nonfinite fixed axis value") if value.is_a?(Float) && !value.finite?
+          value
+        end
+      end
+
+      def axis_values(axis, count, raw)
+        fail_format("Unsupported DEPOSIT RELATIVE") if option(axis, "DEPOSIT")&.first == "RELATIVE"
+        conversion = axis.values[2]
+        case axis.values.first
+        when "STD_AXIS"
+          fail_format("Missing inline axis points") unless raw
+          fail_format("Inline axis count mismatch") unless raw.size == count
+          [converted(axis, raw, conversion), unit(axis, conversion)]
+        when "COM_AXIS"
+          reference = option(axis, "AXIS_PTS_REF")&.first || fail_format("Missing AXIS_PTS_REF")
+          shared = shared_axis(reference, [])
+          fail_format("Shared axis count mismatch") unless shared.xdim == count
+          [shared.xvalue, shared.xunit]
+        when "FIX_AXIS"
+          [converted(axis, fixed_axis(axis, count), conversion), unit(axis, conversion)]
+        else
+          fail_format("Unsupported axis type #{axis.values.first}")
+        end
+      end
+
+      def rows(values, dimensions, direction)
+        x, y = dimensions
+        direction == "COLUMN_DIR" ? y.times.map { |j| x.times.map { |i| values[i * y + j] } } : values.each_slice(x).to_a
+      end
+
+      def characteristic(block)
+        type, address, record, conversion = block.values.values_at(2, 3, 4, 6)
+        fail_format("Unsupported calibration type #{type}") unless %w[VALUE ASCII VAL_BLK CURVE MAP].include?(type)
+        axes = block.children.select { |b| b.kind == "AXIS_DESCR" }
+        matrix = option(block, "MATRIX_DIM", 3)
+        if matrix
+          matrix = matrix.take_while { |v| v.match?(/\A[+-]?(?:0x[0-9a-f]+|\d+)\z/i) }.map { |v| number(v) }
+          fail_format("Invalid array dimensions") if matrix.empty? || matrix.any? { |d| d <= 0 }
+          fail_format("Unsupported array dimensions") if matrix.drop(2).any? { |d| d != 1 }
+          fail_format("Unsupported scalar dimensions") if type == "VALUE" && matrix.any? { |d| d != 1 }
+          fail_format("Unsupported ASCII dimensions") if type == "ASCII" && matrix.drop(1).any? { |d| d != 1 }
+        end
+        dimensions = if %w[CURVE MAP].include?(type)
+                       expected = type == "CURVE" ? 1 : 2
+                       fail_format("Unsupported axis dimensions") unless axes.size == expected
+                       axes.map { |axis| number(axis.values[3]) }.tap { |d| d << 1 if d.size == 1 }
+                     elsif type == "VALUE"
+                       [1, 1]
+                     else
+                       dims = matrix
+                       dims ||= [number(option(block, "NUMBER")&.first || fail_format("Missing NUMBER/MATRIX_DIM"))]
+                       fail_format("Unsupported array dimensions") if dims.drop(2).any? { |d| d != 1 }
+                       [dims[0], dims[1] || 1]
+                     end
+        if matrix && %w[CURVE MAP].include?(type)
+          fail_format("MATRIX_DIM axis dimensions mismatch") unless [matrix[0], matrix[1] || 1] == dimensions
+        end
+        axes.each_with_index do |axis, i|
+          next unless axis.values.first == "COM_AXIS"
+          reference = option(axis, "AXIS_PTS_REF")&.first || fail_format("Missing AXIS_PTS_REF")
+          count = shared_axis(reference, []).xdim
+          fail_format("Shared axis count exceeds maximum") if count > dimensions[i]
+          dimensions[i] = count
+        end
+        data = deposit(block, record, address, dimensions, ascii: type == "ASCII")
+        raw = data["FNC_VALUES"] || fail_format("Missing FNC_VALUES")
+        meta = metadata(block).merge(unit: unit(block, conversion))
+        return Ecu::Festwert.new(**meta, value: raw.split("\0", 2).first || "") if type == "ASCII"
+        values = converted(block, raw, conversion)
+        case type
+        when "VALUE" then Ecu::Festwert.new(**meta, value: values.first)
+        when "VAL_BLK"
+          Ecu::Festwerteblock.new(**meta, xdim: dimensions[0], ydim: dimensions[1],
+                                 value: rows(values, dimensions, data["direction"]))
+        else
+          xvalue, xunit = axis_values(axes[0], dimensions[0], data["AXIS_PTS_X"])
+          meta.merge!(xdim: dimensions[0], xvalue: xvalue, xunit: xunit)
+          if type == "CURVE"
+            Ecu::Kennlinie.new(**meta, value: values)
+          else
+            yvalue, yunit = axis_values(axes[1], dimensions[1], data["AXIS_PTS_Y"])
+            Ecu::Kennfeld.new(**meta, ydim: dimensions[1], yvalue: yvalue, yunit: yunit,
+                             value: rows(values, dimensions, data["direction"]))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/a2l/a2l_parser_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Ecu
+  class A2lParserError < StandardError
+  end
+end

data/lib/ecu/interfaces/a2l/label_list.rb

@@ -1,18 +1,10 @@
-require_relative "../../../core_ext"
+require_relative "a2l_parser"
 
 class Ecu
   class LabelList
-    A2LREGEXP = %r{/begin CHARACTERISTIC\s+([\S]+)\s+"([^"]*)"}
-
-    def self.from_a2l(str)
-      str.gsub!(%r{/\*.*?\*/}, "")
-      labels = str.scan(A2LREGEXP).map do |name, description|
-        # Ugly hack: Create dummy Festwert until better parsing
-        # is implemented
-        Ecu::Festwert.new(name: name, description: description, value: 0)
-      end
-      new(labels)
+    def self.from_a2l(a2l_text, s19_text = nil, address_map: nil)
+      raise ArgumentError, "S19 text is required for A2L calibration values" if s19_text.nil?
+      new(A2lParser.new(a2l_text, s19_text, address_map: address_map).call)
     end
   end
 end
-

data/lib/ecu/interfaces/a2l/s19_image.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "a2l_parser_error"
+
+class Ecu
+  class LabelList
+    class S19Image
+      TYPES = {
+        "UBYTE" => [1, "C", "C"],
+        "SBYTE" => [1, "c", "c"],
+        "UWORD" => [2, "S<", "S>"],
+        "SWORD" => [2, "s<", "s>"],
+        "ULONG" => [4, "L<", "L>"],
+        "SLONG" => [4, "l<", "l>"],
+        "A_UINT64" => [8, "Q<", "Q>"],
+        "A_INT64" => [8, "q<", "q>"],
+        "FLOAT32_IEEE" => [4, "e", "g"],
+        "FLOAT64_IEEE" => [8, "E", "G"]
+      }.transform_values(&:freeze).freeze
+
+      ADDRESS_SIZES = { 0 => 2, 1 => 2, 2 => 3, 3 => 4, 5 => 2, 6 => 3, 7 => 4, 8 => 3, 9 => 2 }.freeze
+      private_constant :ADDRESS_SIZES
+
+      def initialize(text, address_map: nil)
+        fail A2lParserError, "S19 text must be a String" unless text.is_a?(String)
+        unless text.encoding.ascii_compatible? && text.valid_encoding?
+          fail A2lParserError, "Invalid S19 text encoding"
+        end
+        unless address_map.nil? || address_map.respond_to?(:call)
+          fail A2lParserError, "S19 address mapper must be callable"
+        end
+        @address_map = address_map
+        segments = []
+        counts = []
+        data_records = 0
+        text.each_line.with_index(1) do |line, number|
+          line = line.strip
+          next if line.empty?
+          type, address, data = parse_record(line, number)
+          case type
+          when 1, 2, 3
+            data_records += 1
+            segments << [address, data, number] unless data.empty?
+          when 5, 6
+            counts << [address, number]
+          end
+        end
+        counts.each do |count, line|
+          fail A2lParserError, "S19 data record count mismatch at line #{line}" unless count == data_records
+        end
+        fail A2lParserError, "S19 image contains no data" if segments.empty?
+        @segments = normalize_segments(segments).freeze
+      end
+
+      def read(address, length)
+        validate_integer(address, "address")
+        validate_integer(length, "length")
+        address = mapped_address(address)
+        return "".b if length.zero?
+
+        # Find the first segment whose end is beyond the requested address.
+        index = @segments.bsearch_index { |start, data| start + data.bytesize > address }
+        result = "".b
+        remaining = length
+        while remaining.positive?
+          segment = index && @segments[index]
+          unless segment && segment[0] <= address
+            fail A2lParserError, "S19 missing bytes at address 0x#{address.to_s(16)}"
+          end
+          start, data = segment
+          offset = address - start
+          size = [remaining, data.bytesize - offset].min
+          result << data.byteslice(offset, size)
+          remaining -= size
+          address += size
+          index += 1
+        end
+        result
+      end
+
+      def values(address, type, count, byte_order)
+        definition = TYPES[type]
+        fail A2lParserError, "Unsupported S19 data type #{type.inspect}" unless definition
+        unless ["MSB_LAST", "MSB_FIRST"].include?(byte_order)
+          fail A2lParserError, "Unsupported S19 byte order #{byte_order.inspect}"
+        end
+        validate_integer(count, "count")
+        size, little, big = definition
+        read(address, size * count).unpack("#{byte_order == 'MSB_LAST' ? little : big}*")
+      end
+
+      private
+
+      def validate_integer(value, name)
+        unless value.is_a?(Integer) && value >= 0
+          fail A2lParserError, "S19 #{name} must be a nonnegative Integer"
+        end
+      end
+
+      def mapped_address(address)
+        return address unless @address_map
+        mapped = @address_map.call(address)
+        validate_integer(mapped, "mapped address")
+        mapped
+      end
+
+      def parse_record(line, number)
+        unless /\AS[0-9][0-9A-Fa-f]+\z/.match?(line) && (line.bytesize - 2).even?
+          fail A2lParserError, "Invalid S19 hex record at line #{number}"
+        end
+        type = line.getbyte(1) - 48
+        width = ADDRESS_SIZES[type]
+        fail A2lParserError, "Unknown S19 record type S#{type} at line #{number}" unless width
+        bytes = [line.byteslice(2..)].pack("H*").bytes
+        count = bytes.first
+        unless count == bytes.length - 1 && count >= width + 1
+          fail A2lParserError, "S19 record count/length mismatch at line #{number}"
+        end
+        unless (bytes.sum & 255) == 255
+          fail A2lParserError, "S19 checksum mismatch at line #{number}"
+        end
+        address = bytes.slice(1, width).reduce(0) { |value, byte| (value << 8) | byte }
+        data = bytes.slice(width + 1, count - width - 1).pack("C*")
+        if type >= 5 && !data.empty?
+          fail A2lParserError, "Invalid S19 metadata payload length at line #{number}"
+        end
+        [type, address, data]
+      end
+
+      def normalize_segments(segments)
+        normalized = []
+        segments.sort_by! { |start, _, _| start }
+        segments.each do |start, data, line|
+          index = normalized.bsearch_index { |position, bytes| position + bytes.bytesize > start }
+          consumed = 0
+          while index && index < normalized.length && consumed < data.bytesize
+            previous_start, previous_data = normalized[index]
+            overlap = [previous_start + previous_data.bytesize - start, data.bytesize - consumed].min
+            unless previous_data.byteslice(start - previous_start, overlap) == data.byteslice(consumed, overlap)
+              fail A2lParserError, "Conflicting S19 overlap at address 0x#{start.to_s(16)}, line #{line}"
+            end
+            start += overlap
+            consumed += overlap
+            index += 1
+          end
+          data = data.byteslice(consumed..) if consumed.positive?
+          normalized << [start, data.freeze].freeze unless data.empty?
+        end
+        normalized
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/lab/combined_list.rb

@@ -5,7 +5,9 @@ class Ecu
   class CombinedList
     def self.from_lab(str)
       signals, labels, headers, subheaders = LabParser.new(str).call
-      new(signals, labels, headers, subheaders)
+      new(SignalList.new(signals, headers, subheaders),
+          LabelList.new(labels, headers, subheaders),
+          headers, subheaders)
     end
 
     def to_lab
@@ -26,7 +28,7 @@ class Ecu
       out.append("[Label]")
       out.append(*labels.map(&:to_lab))
 
-      out.join("\n")
+      out.join("\n") + "\n"
     end
   end
 end

data/lib/ecu/labels/label_list.rb

@@ -19,10 +19,12 @@ class Ecu
   class LabelList
     include Enumerable
 
-    def self.from_file(file_path)
+    def self.from_file(file_path, s19_path: nil, address_map: nil)
       case File.extname(file_path)
       when ".lab" then self.from_lab(File.read_encoded(file_path))
-      when ".a2l" then self.from_a2l(File.read_encoded(file_path))
+      when ".a2l"
+        raise ArgumentError, "S19 path is required for A2L calibration values" if s19_path.nil?
+        self.from_a2l(File.read_encoded(file_path), File.read_encoded(s19_path), address_map: address_map)
       when ".dcm" then self.from_dcm(File.read_encoded(file_path))
       else fail "Unknown file extension: #{file_path}!"
       end

data/lib/ecu/signals/signal_list_comparison.rb

@@ -6,8 +6,8 @@ class Ecu
         fail "Can only merge SignalLists (left: #{left.class}, right: #{right.class})!"
       end
 
-      @left               = left.map(&:name)
-      @right              = right.map(&:name)
+      @left               = left.map(&:name).zip(left).to_h
+      @right              = right.map(&:name).zip(right).to_h
       @unified_headers    = left.headers + right.headers
       @unified_subheaders = left.subheaders + right.subheaders
       @names              = Hash.new
@@ -16,10 +16,10 @@ class Ecu
     def names(criterion)
       @names[criterion] ||= \
         case criterion
-        when :left_exclusive  then left - right
-        when :right_exclusive then right - left
-        when :common          then left & right
-        when :equal           then left & right
+        when :left_exclusive  then left.keys - right.keys
+        when :right_exclusive then right.keys - left.keys
+        when :common          then left.keys & right.keys
+        when :equal           then left.keys & right.keys
         when :nonequal        then []
         else fail "Unknown criterion #{criterion}"
         end
@@ -38,7 +38,7 @@ class Ecu
         (
          names(:left_exclusive).map  { |n| left.fetch(n) } +
          names(:right_exclusive).map { |n| right.fetch(n) } +
-         names(:common).map { |n| left.fetch(n) }
+         names(:common).map { |n| (priority == :right ? right : left).fetch(n) }
         ),
         @unified_headers,
         @unified_subheaders

data/lib/ecu/version.rb

@@ -1,3 +1,3 @@
 class Ecu
-  VERSION = "0.4.1"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: automotive-ecu
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.1
 platform: ruby
 authors:
 - Jonas Mueller
@@ -96,7 +96,12 @@ files:
 - lib/ecu.rb
 - lib/ecu/combined_list.rb
 - lib/ecu/combined_list_comparison.rb
+- lib/ecu/interfaces/a2l/a2l_conversion.rb
+- lib/ecu/interfaces/a2l/a2l_document.rb
+- lib/ecu/interfaces/a2l/a2l_parser.rb
+- lib/ecu/interfaces/a2l/a2l_parser_error.rb
 - lib/ecu/interfaces/a2l/label_list.rb
+- lib/ecu/interfaces/a2l/s19_image.rb
 - lib/ecu/interfaces/a2l/signal_list.rb
 - lib/ecu/interfaces/dbc/signal_list.rb
 - lib/ecu/interfaces/dcm/dcm_parser.rb