automotive-ecu 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afdcb21c88b030d3a51419219dbc4ebf34c11cdfa22bcb4878b10980bd1758f8
-  data.tar.gz: 7ba90b0782418f2ae411ced1846292dc3cf69c281efcdbdd55a2bb10d2faca1b
+  metadata.gz: d05b1f41faab9eb4a9ffb33697b015f0242d64450f25bedf6ce47aef2aac08ca
+  data.tar.gz: ecdc24755f8244e51a2bc20ee9efef50f3e40be5f6a2d5f678d5bdea462f5c8b
 SHA512:
-  metadata.gz: 634a92da870fde03b29b91fd52572c13e68cb4265e3570a90e53e83f0653c970ec9f4b2b690a13e3e4454e3ee622c5ab647a1809dcf5f5a388b4db90ec023320
-  data.tar.gz: df6ac03c377110ef7f663339eccf5a2f3a1989dfb95ce52d5845631ddc9f132def6aed90c9788ecf2ab185ec909b8c2c7c2d10a3f57a451db3f87bc0bedc51c2
+  metadata.gz: 1b92c416a9dacb5dd9c28afd30bdf9de68e31390977612752bf23365cf9a9b93894d7e4641bb5629832debb237d549fb4f38c475b2b55ad812c271b99b193e52
+  data.tar.gz: f8548dd035ac77f453d2b36717f398107d16207febfb886bc26964a6c84ef1582b0e41ea1039fed4b3afc0ebd48a8230e21eb47255d1064c71ae6f5ab90c9e74

data/lib/ecu/interfaces/dcm/dcm_lexer.rb

@@ -0,0 +1,78 @@
+require "strscan"
+
+class Ecu
+  class LabelList
+    class DcmLexer
+      attr_reader :doc
+      def initialize(doc)
+        @doc  = doc
+        @scan = StringScanner.new(doc)
+      end
+
+      KEYWORDS = [
+        "FUNKTIONEN", "FESTWERT", "FESTWERTEBLOCK", "KENNLINIE", "GRUPPENKENNLINIE", "FESTKENNLINIE",
+        "KENNFELD", "GRUPPENKENNFELD", "FESTKENNFELD", "STUETZSTELLENVERTEILUNG",
+        "FKT",
+        "ST/X", "ST/Y", "WERT", "ST_TX/X", "ST_TX/Y", "TEXT",
+        "FUNKTION",
+        "EINHEIT_X", "EINHEIT_Y", "EINHEIT_W",
+        "LANGNAME", "DISPLAYNAME",
+        "END",
+      ].freeze
+
+      HEADER         = "KONSERVIERUNG_FORMAT 2.0"
+      WHITESPACE     = %r{ [ \t]+ }x
+      NEWLINE        = %r{ \r\n|\n }x
+      COMMENT        = %r{ ^\*.*$ }x
+      DIMENSIONS_SEP = %r{ @ }x
+      QUOTED_TEXT    = %r{ "[^"]*" }x
+      IDENTIFIER     = %r{ [A-Za-z][A-Za-z0-9_\.]* }x
+      UNSIGNED_INT   = %r{ [0]|[1-9][0-9]* }x
+      INT            = %r{ [-]?#{UNSIGNED_INT} }x
+      FLOAT_EXP      = %r{ [eE][+-]?[0-9]+ }x
+      FLOAT          = %r{
+                            [-+]?
+                            (?:
+                               #{UNSIGNED_INT}?[.][0-9]+#{FLOAT_EXP} |      # 1.23e10 or .45e3
+                               #{UNSIGNED_INT}          #{FLOAT_EXP} |      # 3e4
+                               #{UNSIGNED_INT}?[.][0-9]+             |      # 7.3 or .50
+                               #{UNSIGNED_INT} [.][0-9]*                    # 3.02 or 9.
+                            )
+                       }x
+      KW_RE          = /#{Regexp.union(KEYWORDS.sort)}\b/
+      KW_TABLE       = Hash[KEYWORDS.map { [_1, _1.upcase.to_sym] }]
+
+
+      def next_token
+        @scan.skip(WHITESPACE)
+
+        return if @scan.eos?
+
+        case
+        when @scan.skip(NEWLINE)        then :NEWLINE
+        when s = @scan.scan(KW_RE)      then KW_TABLE[s]
+        when @scan.skip(QUOTED_TEXT)    then :QUOTED_TEXT
+        when @scan.skip(COMMENT)        then :COMMENT
+        when @scan.skip(DIMENSIONS_SEP) then :DIMENSIONS_SEP
+        when @scan.skip(HEADER)         then :HEADER
+        when @scan.skip(IDENTIFIER)     then :IDENTIFIER
+        when @scan.skip(FLOAT)          then :FLOAT
+        when @scan.skip(INT)            then :INT
+
+        else
+          @scan.getch
+          :UNKNOWN_CHAR
+        end
+      end
+
+      def token_value
+        @doc.byteslice(@scan.pos - @scan.matched_size, @scan.matched_size)
+      end
+
+      def lineno
+        @doc.byteslice(0, @scan.pos).count("\n") +
+          (@scan.beginning_of_line? ? 0 : 1)
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/dcm/dcm_parser.rb

@@ -0,0 +1,215 @@
+require_relative "dcm_lexer"
+require_relative "dcm_parser_error"
+
+class Ecu
+  class LabelList
+    class DcmParser
+
+      ARY_PROPERTIES = %i( xvalue yvalue value )
+      KEY_MAPPING = {
+        "ST/X":         :xvalue,
+        "ST/Y":         :yvalue,
+        "WERT":         :value,
+        "ST_TX/X":      :xvalue,
+        "ST_TX/Y":      :yvalue,
+        "TEXT":         :value,
+        "FUNKTION":     :function,
+        "DISPLAYNAME":  :displayname,
+        "EINHEIT_X":    :xunit,
+        "EINHEIT_Y":    :yunit,
+        "EINHEIT_W":    :unit,
+        "LANGNAME":     :description,
+      }
+
+      attr_reader :lexer, :state, :labels, :headers, :subheaders
+      def initialize(doc)
+        @lexer      = DcmLexer.new(doc)
+        @state      = :PRE_HEADER
+        @labels     = []
+        @headers    = []
+        @subheaders = []
+        reset_label!
+      end
+
+      def call
+        while tok = lexer.next_token
+          begin
+            case @state
+            in :PRE_HEADER
+              case tok
+              in :HEADER  then next_state(:POST_HEADER)
+              in :COMMENT then add_header(lexer.token_value)
+              in :NEWLINE
+              end
+            in :POST_HEADER
+              case tok
+              in :FUNKTIONEN              then next_state(:FUNCTIONS_CONTENT)
+              in :FESTWERT                then start_label(Festwert)
+              in :FESTWERTEBLOCK          then start_label(Festwerteblock)
+              in :KENNLINIE               then start_label(Kennlinie)
+              in :GRUPPENKENNLINIE        then start_label(Gruppenkennlinie)
+              in :FESTKENNLINIE           then start_label(Festkennlinie)
+              in :KENNFELD                then start_label(Kennfeld)
+              in :GRUPPENKENNFELD         then start_label(Gruppenkennfeld)
+              in :FESTKENNFELD            then start_label(Festkennfeld)
+              in :STUETZSTELLENVERTEILUNG then start_label(Stuetzstellenverteilung)
+              in :COMMENT                 then add_subheader(lexer.token_value)
+              in :NEWLINE                 then # noop
+              end
+            in :FUNCTIONS_CONTENT
+              case tok
+              in :FKT     then next_state(:FUNCTION_CONTENT)
+              in :NEWLINE then # noop
+              in :END     then next_state(:POST_HEADER)
+              end
+            in :FUNCTION_CONTENT
+              case tok
+              in :IDENTIFIER  then # append that shit?
+              in :QUOTED_TEXT then # append that shit as well?
+              in :NEWLINE     then next_state(:FUNCTIONS_CONTENT)
+              end
+            in :LABEL_HEADLINE
+              case tok
+              in :IDENTIFIER     then add_name(lexer.token_value)
+              in :DIMENSIONS_SEP then # noop, order handled by #add_dimension
+              in :INT            then add_dimension(lexer.token_value.to_i)
+              in :NEWLINE        then next_state(:LABEL_CONTENT)
+              end
+            in :LABEL_CONTENT
+              case tok
+              in :"ST/X"      then start_property(:"ST/X",      :NUMERIC_PROPERTY)
+              in :"ST/Y"      then start_property(:"ST/Y",      :NUMERIC_PROPERTY)
+              in :WERT        then start_property(:WERT,        :NUMERIC_PROPERTY)
+              in :"ST_TX/X"   then start_property(:"ST_TX/X",   :TEXT_PROPERTY)
+              in :"ST_TX/Y"   then start_property(:"ST_TX/Y",   :TEXT_PROPERTY)
+              in :TEXT        then start_property(:TEXT,        :TEXT_PROPERTY)
+              in :EINHEIT_X   then start_property(:EINHEIT_X,   :TEXT_PROPERTY)
+              in :EINHEIT_Y   then start_property(:EINHEIT_Y,   :TEXT_PROPERTY)
+              in :EINHEIT_W   then start_property(:EINHEIT_W,   :TEXT_PROPERTY)
+              in :LANGNAME    then start_property(:LANGNAME,    :TEXT_PROPERTY)
+              in :FUNKTION    then start_property(:FUNKTION,    :ID_PROPERTY)
+              in :DISPLAYNAME then start_property(:DISPLAYNAME, :ID_PROPERTY)
+              in :END         then labels << finish_label
+              in :NEWLINE     then # noop, DCM badly formatted
+              in :COMMENT     then # noop, some programs add SST in comments
+              end
+            in :NUMERIC_PROPERTY
+              case tok
+              in :FLOAT       then append_property(lexer.token_value.to_f)
+              in :INT         then append_property(lexer.token_value.to_i)
+              in :NEWLINE     then finish_property
+              end
+            in :TEXT_PROPERTY
+              case tok
+              in :QUOTED_TEXT then append_property(lexer.token_value[1..-2])
+              in :NEWLINE     then finish_property
+              end
+            in :ID_PROPERTY
+              case tok
+              in :IDENTIFIER  then append_property(lexer.token_value)
+              in :NEWLINE     then finish_property
+              end
+            end
+          rescue NoMatchingPatternError => e
+            raise DcmParserError.new("Unexpected token #{debug_token(tok)} (state: #{state})", lexer)
+          rescue StandardError => e
+            raise DcmParserError.new("#{e.message} (state: #{@state})", lexer)
+          end
+        end
+        [labels, headers, subheaders]
+      end
+
+      def debug_token(tok)
+        if tok == :UNKNOWN_CHAR
+          "UNKNOWN_CHAR: #{lexer.token_value}"
+        else
+          tok
+        end
+      end
+
+      def next_state(newstate)
+        @state = newstate
+        yield if block_given?
+      end
+
+      def add_header(str)
+        @headers << str[1..].strip
+      end
+
+      def add_subheader(str)
+        @subheaders << str[1..].strip
+      end
+
+      def start_label(constructor)
+        next_state(:LABEL_HEADLINE) do
+          @constructor = constructor
+        end
+      end
+
+      def finish_label
+        next_state(:POST_HEADER) do
+          @properties
+            .except(:displayname)
+            .then { @constructor.new(**_1) }
+            .tap { reset_label! }
+        end
+      end
+
+      def add_name(str)
+        fail "Duplicate name" if @properties.key?(:name)
+
+        @properties[:name] = str
+      end
+
+      def add_dimension(n)
+        fail "Wrong order name/dimensions" unless @properties.key?(:name)
+        fail "Too many dimensions" if @properties.key?(:xdim) && @properties.key?(:ydim)
+
+        if @properties.key?(:xdim)
+          @properties[:ydim] = n
+        else
+          @properties[:xdim] = n
+        end
+      end
+
+      def start_property(key, newstate)
+        next_state(newstate) do
+          @key   = KEY_MAPPING[key]
+          @value = ARY_PROPERTIES.include?(@key) ? [] : nil
+        end
+      end
+
+      def append_property(value)
+        # TODO: Check if constructor allows array values
+        if ARY_PROPERTIES.include?(@key)
+          @value << value
+        else
+          fail "Multiple definitions for #{@key}" if @value
+
+          @value = value
+        end
+      end
+
+      def finish_property
+        next_state(:LABEL_CONTENT) do
+          @properties.merge!({ @key => @value }, &method(:merge_property))
+        end
+      end
+
+      def merge_property(key, old, new)
+        fail "Multiple property lines not allowed for #{key}" unless ARY_PROPERTIES.include?(key)
+
+        old + new
+      end
+
+      def reset_label!
+        @constructor = nil
+        @properties  = {}
+        @key         = nil
+        @value       = nil
+      end
+
+    end
+
+  end
+end

data/lib/ecu/interfaces/dcm/dcm_parser_error.rb

@@ -0,0 +1,35 @@
+class Ecu
+  class DcmParserError < StandardError
+
+    CTXLENGHT = 5
+
+    attr_reader :doc, :lineno
+    def initialize(msg, lexer)
+      @msg    = msg
+      @doc    = lexer.doc
+      @lineno = lexer.lineno
+    end
+
+    def message = @msg
+    def context
+      @doc
+        .lines[ctx_startline..ctx_endline]
+        .each
+        .with_index(ctx_startline + 1)
+        .map { |line, n| present(line, n, n == lineno) }
+    end
+
+    def present(line, n, highlight)
+      case highlight
+        when true  then fmt(n) + " => | " + line
+        when false then fmt(n) + "    | " + line
+      end
+    end
+
+    def ctx_startline = [0, lineno - CTXLENGHT].max
+    def ctx_endline   = @endline ||= [doc.lines.count - 1, lineno + CTXLENGHT].min
+    def fmt_str = "%#{(ctx_endline + 1).to_s.length}d"
+    def fmt(n)  = fmt_str % n
+
+  end
+end

data/lib/ecu/interfaces/dcm/festkennfeld.rb

@@ -2,8 +2,5 @@ require_relative "kennfeld"
 
 class Ecu
   class Festkennfeld < Kennfeld
-    def self.dcm_header
-      %r{^FESTKENNFELD\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)\s+(?<ydim>\d+)}
-    end
   end
 end

data/lib/ecu/interfaces/dcm/festkennlinie.rb

@@ -2,8 +2,5 @@ require_relative "kennlinie"
 
 class Ecu
   class Festkennlinie < Kennlinie
-    def self.dcm_header
-      %r{^FESTKENNLINIE\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)}
-    end
   end
 end

data/lib/ecu/interfaces/dcm/festwert.rb

@@ -1,9 +1,5 @@
 class Ecu
   class Festwert < Label
-    def self.dcm_header
-      %r{FESTWERT\s+(?<name>[A-Za-z0-9\._]+)}
-    end
-
     def to_dcm(indented=false)
       fmtstr = indented ? "%-25s%s\n" : "%s %s\n"
 

data/lib/ecu/interfaces/dcm/festwerteblock.rb

@@ -2,10 +2,6 @@ require_relative "../../../core_ext"
 
 class Ecu
   class Festwerteblock < Label
-    def self.dcm_header
-      %r{^FESTWERTEBLOCK\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)(?:\s+@\s+(?<ydim>\d+))?}
-    end
-
     def to_dcm(indented=false)
       fmtstr = indented ? "%-25s%s %s" : "%s %s %d"
 

data/lib/ecu/interfaces/dcm/gruppenkennfeld.rb

@@ -2,8 +2,5 @@ require_relative "kennfeld"
 
 class Ecu
   class Gruppenkennfeld < Kennfeld
-    def self.dcm_header
-      %r{^GRUPPENKENNFELD\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)\s+(?<ydim>\d+)}
-    end
   end
 end

data/lib/ecu/interfaces/dcm/gruppenkennlinie.rb

@@ -2,8 +2,5 @@ require_relative "kennlinie"
 
 class Ecu
   class Gruppenkennlinie < Kennlinie
-    def self.dcm_header
-      %r{^GRUPPENKENNLINIE\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)}
-    end
   end
 end

data/lib/ecu/interfaces/dcm/kennfeld.rb

@@ -1,9 +1,5 @@
 class Ecu
   class Kennfeld < Label
-    def self.dcm_header
-      %r{^KENNFELD\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)\s+(?<ydim>\d+)}
-    end
-
     def to_dcm(indented=false)
       fmtstr = indented ? "%-25s%s %s %s\n" : "%s %s %d %d\n"
 

data/lib/ecu/interfaces/dcm/kennlinie.rb

@@ -1,9 +1,5 @@
 class Ecu
   class Kennlinie < Label
-    def self.dcm_header
-      %r{^KENNLINIE\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)}
-    end
-
     def to_dcm(indented=false)
       fmtstr = indented ? "%-25s%s %s\n" : "%s %s %d\n"
 

data/lib/ecu/interfaces/dcm/label.rb

@@ -1,25 +1,7 @@
-require_relative "property_parser"
-
 class Ecu
   class Label
-    def self.from_dcm(input)
-      lines = case input
-              in Array  then input
-              in String then input.lines
-              end
-      hsh = dcm_header.extract_captures(lines.first)
-
-      hsh[:xdim] = hsh[:xdim].to_i if hsh.key?(:xdim)
-      hsh[:ydim] = hsh[:ydim].to_i if hsh.key?(:ydim)
-
-      fail "Malformed DCM" if hsh.empty?
-      fail "Malformed DCM" unless lines.last.match?(/^END$/)
-
-      lines[1..-2]
-        .map { DcmPropertyParser.call(_1) }
-        .each { hsh.merge!(_1) { |_, old, new| old + new } }
-
-      new(**hsh)
+    def to_dcm
+      fail "To be defined by child classes"
     end
   end
 end

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

@@ -1,4 +1,3 @@
-require_relative "functions"
 require_relative "festwert"
 require_relative "festwerteblock"
 require_relative "kennlinie"
@@ -8,69 +7,18 @@ require_relative "kennfeld"
 require_relative "gruppenkennfeld"
 require_relative "festkennfeld"
 require_relative "stuetzstellenverteilung"
-require_relative "malformed_dcm_error"
-require_relative "buffer"
+
+require_relative "dcm_parser"
 
 class Ecu
   class LabelList
 
-    DCM_HEADER      = "KONSERVIERUNG_FORMAT 2.0"
-    BLANKLINE_REGEX = /^\s*$/
-    COMMENT_REGEX   = /^\*.*/
+    DCM_HEADER = "KONSERVIERUNG_FORMAT 2.0"
 
     def self.from_dcm(str)
-      buffer     = DcmBuffer.new
-      headers    = []
-      subheaders = []
-      functions  = []
-      labels     = {}
-
-      str.each_line.lazy.with_index(1).each do |line, n|
-        line = normalize_whitespace(line)
-        case line
-        when BLANKLINE_REGEX then next
-        when COMMENT_REGEX
-          case buffer.header
-          when :pre   then headers << line[1..].strip
-          when :after then subheaders << line[1..].strip
-          when :done  then # Header time over, do nothing
-          end
-        when DCM_HEADER                         then buffer.header_seen!
-        when Functions.dcm_header               then buffer.start!(Functions, [line])
-        when Festwert.dcm_header                then buffer.start!(Festwert, [line])
-        when Festwerteblock.dcm_header          then buffer.start!(Festwerteblock, [line])
-        when Kennlinie.dcm_header               then buffer.start!(Kennlinie, [line])
-        when Gruppenkennlinie.dcm_header        then buffer.start!(Gruppenkennlinie, [line])
-        when Festkennlinie.dcm_header           then buffer.start!(Festkennlinie, [line])
-        when Kennfeld.dcm_header                then buffer.start!(Kennfeld, [line])
-        when Gruppenkennfeld.dcm_header         then buffer.start!(Gruppenkennfeld, [line])
-        when Festkennfeld.dcm_header            then buffer.start!(Festkennfeld, [line])
-        when Stuetzstellenverteilung.dcm_header then buffer.start!(Stuetzstellenverteilung, [line])
-        when "END"                              then
-          case obj = buffer.finish!(line)
-          when Label
-            fail "Duplicate label #{obj.name}" unless labels[obj.name].nil?
-
-            labels[obj.name] = obj
-          when Functions
-            fail "Duplicate functions definition" unless functions.empty?
-
-            functions = obj
-          else
-            fail "Unknown object #{obj}"
-          end
-        else
-          buffer.append!(line)
-        end
-      rescue StandardError => e
-        raise MalformedDcmError.new(e.message, n, str), e.message
-      end
-
-      new(labels.values, headers, subheaders, true)
-    end
-
-    def self.normalize_whitespace(line)
-      line.chomp.gsub(/[[:space:]]/, " ").rstrip
+      DcmParser.new(str)
+        .then { _1.call }
+        .then { new(*_1, true) }
     end
 
     def to_dcm(indented=false)

data/lib/ecu/interfaces/dcm/stuetzstellenverteilung.rb

@@ -1,9 +1,5 @@
 class Ecu
   class Stuetzstellenverteilung < Label
-    def self.dcm_header
-      %r{STUETZSTELLENVERTEILUNG\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)}
-    end
-
     def to_dcm(indented=false)
       fmtstr = indented ? "%-25s%s %s\n" : "%s %s %d\n"
 

data/lib/ecu/labels/label.rb

@@ -13,7 +13,15 @@ class Ecu
     attr_reader :name, :function, :description
 
     def init_error(message)
-      fail ArgumentError, "Error creating #{name}: " + message
+      fail ArgumentError, "Error creating #{name}: " +
+        message + "\n" +
+        inspect_instance_vars + "\n\n"
+    end
+
+    def inspect_instance_vars
+      instance_variables
+        .map { "#{_1} = #{instance_variable_get(_1)}" }
+        .join("\n")
     end
 
     def type

data/lib/ecu/version.rb

@@ -1,3 +1,3 @@
 class Ecu
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: automotive-ecu
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - Jonas Mueller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-21 00:00:00.000000000 Z
+date: 2025-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: terminal-table
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Provides an interface for exporting/importing signals and labels to various
   automotive formats (*.lab, *.dcm)
 email:
@@ -91,20 +105,19 @@ files:
 - lib/ecu/interfaces/a2l/label_list.rb
 - lib/ecu/interfaces/a2l/signal_list.rb
 - lib/ecu/interfaces/dbc/signal_list.rb
-- lib/ecu/interfaces/dcm/buffer.rb
+- lib/ecu/interfaces/dcm/dcm_lexer.rb
+- lib/ecu/interfaces/dcm/dcm_parser.rb
+- lib/ecu/interfaces/dcm/dcm_parser_error.rb
 - lib/ecu/interfaces/dcm/festkennfeld.rb
 - lib/ecu/interfaces/dcm/festkennlinie.rb
 - lib/ecu/interfaces/dcm/festwert.rb
 - lib/ecu/interfaces/dcm/festwerteblock.rb
-- lib/ecu/interfaces/dcm/functions.rb
 - lib/ecu/interfaces/dcm/gruppenkennfeld.rb
 - lib/ecu/interfaces/dcm/gruppenkennlinie.rb
 - lib/ecu/interfaces/dcm/kennfeld.rb
 - lib/ecu/interfaces/dcm/kennlinie.rb
 - lib/ecu/interfaces/dcm/label.rb
 - lib/ecu/interfaces/dcm/label_list.rb
-- lib/ecu/interfaces/dcm/malformed_dcm_error.rb
-- lib/ecu/interfaces/dcm/property_parser.rb
 - lib/ecu/interfaces/dcm/stuetzstellenverteilung.rb
 - lib/ecu/interfaces/lab/combined_list.rb
 - lib/ecu/interfaces/lab/lab_parser.rb

data/lib/ecu/interfaces/dcm/buffer.rb

@@ -1,39 +0,0 @@
-class DcmBuffer
-  attr_reader :buffer, :header, :constructor
-  def initialize
-    @constructor = nil
-    @header      = :pre
-    @buffer      = []
-  end
-
-  def start!(constructor, buffer)
-    fail "Nested parameter" unless self.buffer.empty?
-    fail "Missing DCM header" if self.header == :pre
-
-    @header      = :done
-    @constructor = constructor
-    @buffer      = buffer
-  end
-
-  def finish!(line)
-    fail "Unexpected END" if constructor.nil?
-    append!(line)
-
-    constructor.from_dcm(buffer).tap { reset! }
-  end
-
-  def reset!
-    @constructor = nil
-    @buffer      = []
-  end
-
-  def header_seen!
-    @header = :after
-  end
-
-  def append!(line)
-    fail "No label started" if constructor.nil?
-
-    @buffer << line
-  end
-end

data/lib/ecu/interfaces/dcm/functions.rb

@@ -1,13 +0,0 @@
-require_relative "property_parser"
-
-class Ecu
-  class Functions
-    def self.dcm_header
-      /FUNKTIONEN.*/
-    end
-
-    def self.from_dcm(input)
-      new
-    end
-  end
-end

data/lib/ecu/interfaces/dcm/malformed_dcm_error.rb

@@ -1,34 +0,0 @@
-class Ecu
-  class MalformedDcmError < StandardError
-    attr_reader :lineno, :filecontent
-    def initialize(msg, lineno, filecontent)
-      super(msg)
-      @lineno      = lineno
-      @filecontent = filecontent
-    end
-
-    def to_s = "Malformed DCM: #{super} near line ##{lineno}"
-    def to_str = to_s
-
-    def context
-      filecontent
-        .lines
-        .each
-        .with_index(1)
-        .map { |line, n| present(line, n, n == lineno) }
-        .then { _1[ctx_startline..ctx_endline] }
-    end
-
-    def present(line, n, highlight)
-      case highlight
-        when true  then fmt(n) + " => | " + line
-        when false then fmt(n) + "    | " + line
-      end
-    end
-
-    def ctx_startline = [0, lineno - 7].max
-    def ctx_endline   = @endline ||= [filecontent.lines.count - 1, lineno + 3].min
-    def fmt_str       = "%#{(ctx_endline + 1).to_s.length}d"
-    def fmt(n)        = fmt_str % n
-  end
-end

data/lib/ecu/interfaces/dcm/property_parser.rb

@@ -1,50 +0,0 @@
-class Ecu
-  class DcmPropertyParser
-
-    def self.call(line)
-      key, _, value = line.strip.partition(/\s+/)
-      eval_property(key, value)
-    end
-
-    private
-
-    def self.eval_property(key, value)
-      case key
-      when "ST/X"        then { xvalue:      numeric_array(value) }
-      when "ST/Y"        then { yvalue:      numeric_array(value) }
-      when "WERT"        then { value:       numeric_array(value) }
-      when "ST_TX/X"     then { xvalue:      string_array(value) }
-      when "ST_TX/Y"     then { yvalue:      string_array(value) }
-      when "TEXT"        then { value:       string_array(value) }
-      when "FUNKTION"    then { function:    value }
-      when "EINHEIT_X"   then { xunit:       string_value(value) }
-      when "EINHEIT_Y"   then { yunit:       string_value(value) }
-      when "EINHEIT_W"   then { unit:        string_value(value) }
-      when "LANGNAME"    then { description: string_value(value) }
-      when "DISPLAYNAME" then { }
-      else fail ArgumentError, "Unknown key #{key}"
-      end
-    end
-
-    def self.string_value(str)
-      str.delete_surrounding('"')
-    end
-
-    def self.numeric_array(str)
-      str.split.map { numeric_value(_1) }
-    end
-
-    def self.string_array(str)
-      str.scan(/"([^"]*)"/).flatten
-    end
-
-    def self.numeric_value(str)
-      case str
-      in /^\d+$/   then str.to_i
-      in /^\d+\.$/ then str.to_f
-      else              Float(str)
-      end
-    end
-
-  end
-end