automotive-ecu 0.1.10 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6ed1425651404fd10b15eca32ce4cf04ed030ba99d7272932c53b4ec10b9fbd
-  data.tar.gz: '08788f3221f54b377daa533e5911fb4e88aad96b1a5afa772f0e73f570931a89'
+  metadata.gz: 75ae19b7bbf77cd45e42cc9e6b5138d19e85101df900fe844e3102bf18ac2c79
+  data.tar.gz: ecbc4929534d9245169ca0eaa7518df4fb18a08727b66244f4b6382a053af827
 SHA512:
-  metadata.gz: 75d03a13154e6d75c963d2a32b7aacd553112df0cf2105c5bd82d2ceb4cf6ea9ba8cdc916e0e9c1abc610a41e985aba418d9e6ecc506d5cb19edf01c78370b31
-  data.tar.gz: cdf26bf590bf8f780da6724ca31563f5786580e241619e9c844d423e1496f078d5359e7ecf5868564f8235b600556b96b6b2ec4446a8a90746e521d18496f615
+  metadata.gz: ff02d2b04386b8129d249be984934bcda8d53bd5f24057541f36c555152cbda2b008ac9ee1d4bdfec90d67fdcbc2c0455c0eaac2d5df524f44b857d21cad0cf2
+  data.tar.gz: fef42ccdfe5947851955aad5fc2655cabd047576268310da2cc1b6606e3c4390f6db91907a21b24710140149dfafd8b74670ac2aa701009a9ba8c9f4625d872b

data/bin/sandbox

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/ecu/combined_list" 
+
+begin
+  list = Ecu::CombinedList.from_file('spec/fixtures/lab/advanced.lab')
+  list.labels.each do |item|
+    puts item
+  end
+  list.signals.each do |item|
+    puts item.description
+  end
+rescue Ecu::LabParserError => e
+  puts e.message
+  puts e.context
+end

data/lib/ecu/combined_list.rb

@@ -6,6 +6,15 @@ require_relative "interfaces/lab/combined_list"
 class Ecu
   class CombinedList
 
+    def self.from_file(file_path)
+      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 ".dbc" then self.from_dbc(File.read_encoded(file_path))
+      else fail "Unknown file extension: #{file_path}!"
+      end
+    end
+
     def initialize(signals=SignalList.new, labels=LabelList.new, headers=[], subheaders=[])
       @signals    = signals
       @labels     = labels

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 then # noop
+              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 :WERT        then start_property(:WERT,        :NUMERIC_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 :"ST/X"      then start_property(:"ST/X",      :NUMERIC_PROPERTY)
+              in :"ST/Y"      then start_property(:"ST/Y",      :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 :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,25 @@ 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)
+      DcmParser.new(str)
+        .then { _1.call }
+        .then { new(*_1, true) }
     end
 
-    def self.normalize_whitespace(line)
-      line.chomp.rstrip
+    def self.from_dcm_partial(str)
+      str
+        .then { DCM_HEADER + "\n\n" + _1 }
+        .then { from_dcm(_1) }
+        .first
     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/interfaces/json/label_list.rb

@@ -0,0 +1,9 @@
+require "json"
+
+class Ecu
+  class LabelList
+    def to_json
+      self.map(&:to_h).to_json
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ require_relative "label_list"
 class Ecu
   class CombinedList
     def self.from_lab(str)
-      signals, labels, headers, subheaders = LabParser.call(str)
+      signals, labels, headers, subheaders = LabParser.new(str).call
       new(signals, labels, headers, subheaders)
     end
 

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

@@ -0,0 +1,57 @@
+require "strscan"
+
+class Ecu
+  class LabLexer
+    attr_reader :doc
+    def initialize(doc)
+      @doc  = doc
+      @scan = StringScanner.new(doc)
+    end
+
+    KEYWORDS = [
+      "[SETTINGS]",
+      "[RAMCELL]",
+      "[Label]",
+    ].freeze
+
+    NEWLINE         = %r{ \r\n|\n }x
+    SETTINGS_HEADER = %r{ \[SETTINGS\]\s*#{NEWLINE} }x
+    LABELS_HEADER   = %r{ \[Label\]\s*#{NEWLINE}    }x
+    SIGNALS_HEADER  = %r{ \[RAMCELL\]\s*#{NEWLINE}  }x
+    STRING          = %r{ [^\r\n;]+ }x
+    WHITESPACE      = %r{ [ \t]+ }x
+    SEPARATOR       = %r{ [;] }x
+    COMMENT         = %r{ ^[;].*$ }x
+
+    def next_token(state)
+      @scan.skip(WHITESPACE)
+
+      return if @scan.eos?
+
+      case
+      when @scan.skip(SETTINGS_HEADER)                     then :SETTINGS_HEADER
+      when @scan.skip(LABELS_HEADER)                       then :LABELS_HEADER
+      when @scan.skip("[LABEL]\n")                         then :LABELS_HEADER
+      when @scan.skip(SIGNALS_HEADER)                      then :SIGNALS_HEADER
+      when @scan.skip(STRING)                              then :STRING
+      when @scan.beginning_of_line? && @scan.skip(COMMENT) then :COMMENT
+      when @scan.skip(SEPARATOR)                           then :SEPARATOR
+      when @scan.skip(NEWLINE)                             then :NEWLINE
+      when @scan.skip(ANYTHING)                            then :ANYTHING
+
+      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

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

@@ -1,61 +1,132 @@
 require_relative "../../labels"
 require_relative "../../signals"
 
-class LabParser
-  def self.call(str)
-    lines = str.lines
-
-    [
-      extract_signals(block_bounded_by(lines, "[RAMCELL]", /\A\[/)),
-      extract_labels(block_bounded_by(lines, "[Label]", /\A\[/)),
-      extract_headers(block_bounded_by(lines, 0, "[SETTINGS]")),
-      extract_headers(block_bounded_by(lines, "[SETTINGS]", /\A\[/)),
-    ]
-  end
+require_relative "lab_lexer"
+require_relative "lab_parser_error"
 
-  def self.extract_labels(lines)
-    Ecu::LabelList.new lines.
-      reject { |l| l.blank? }.
-      reject { |l| l.start_with?(";") }.
-      map { |l| Ecu::Label.from_lab(l) }
-  end
+class Ecu
+  class LabParser
 
-  def self.extract_signals(lines)
-    Ecu::SignalList.new lines.
-      reject { |l| l.blank? }.
-      reject { |l| l.start_with?(";") }.
-      map { |l| Ecu::Signal.from_lab(l) }
-  end
+    attr_reader :lexer, :state, :labels, :signals, :headers, :subheaders
+    def initialize(doc)
+      @lexer      = LabLexer.new(doc)
+      @state      = :NO_SECTION
+      @signals    = []
+      @labels     = []
+      @headers    = []
+      @subheaders = []
+      reset_entry!
+    end
 
-  def self.extract_headers(lines)
-    lines.
-      select { |l| l.match(/\A; /) }.
-      map { |l| l[2..-1].chomp }
-  end
+    def reset_entry!
+      @properties = {}
+    end
 
-  def self.block_bounded_by(lines, upper, lower)
-    upper = case upper
-            when Integer then upper
-            when String
-              return [] unless lines.any? { |l| l.strip.downcase == upper.downcase }
-              lines.index { |l| l.strip.downcase == upper.downcase } + 1
-            when Regexp
-              return [] unless lines.any? { |l| l.match?(upper) }
-              lines.index { |l| l.match?(upper) } + 1
+    def call
+      while tok = lexer.next_token(state)
+        begin
+          case state
+          in :NO_SECTION
+            case tok
+            in :SETTINGS_HEADER then next_state(:SETTINGS)
+            in :SIGNALS_HEADER  then next_state(:SIGNALS)
+            in :LABELS_HEADER   then next_state(:LABELS)
+            in :COMMENT         then add_header(lexer.token_value)
+            in :NEWLINE         then # noop
+            end
+          in :SETTINGS
+            case tok
+            in :SIGNALS_HEADER then next_state(:SIGNALS)
+            in :LABELS_HEADER  then next_state(:LABELS)
+            in :COMMENT        then add_subheader(lexer.token_value)
+            in :STRING         then # save that shit?
+            in :SEPARATOR      then # now comes the value
+            in :NEWLINE        then # next setting
+            end
+          in :LABELS
+            case tok
+            in :SIGNALS_HEADER then next_state(:SIGNALS)
+            in :STRING         then start_label(lexer.token_value)
+            in :COMMENT        then # noop
+            in :NEWLINE        then # noop
+            end
+          in :SIGNALS
+            case tok
+            in :LABELS_HEADER  then next_state(:LABELS)
+            in :STRING         then start_signal(lexer.token_value)
+            in :COMMENT        then # noop
+            in :NEWLINE        then # noop
+            end
+          in :LABEL
+            case tok
+            in :NEWLINE        then labels << finish_label
+            in :SEPARATOR      then # noop, sometimes used as end separator
             end
+          in :SIGNAL
+            case tok
+            in :STRING         then add_property(lexer.token_value)
+            in :SEPARATOR      then # noop, next property
+            in :NEWLINE        then signals << finish_signal
+            end
+          end
+        rescue NoMatchingPatternError => e
+          raise LabParserError.new("Unexpected token #{debug_token(tok)} (state: #{state})", lexer)
+        rescue StandardError => e
+          raise LabParserError.new("#{e.message} (state: #{@state})", lexer)
+        end
+      end
+      [signals, labels, headers, subheaders]
+    end
 
-    segment = lines[upper..-1]
+    def debug_token(tok)
+      "#{tok}: \"#{lexer.token_value}\" - #{@properties.inspect}"
+    end
 
-    lower = case lower
-            when Integer then lower
-            when String
-              return lines[upper..-1] unless segment.any? { |l| l.strip.downcase == lower.downcase }
-              upper + segment.index { |l| l.strip.downcase == lower.downcase }
-            when Regexp
-              return lines[upper..-1] unless segment.any? { |l| l.match?(lower) }
-              upper + segment.index { |l| l.match?(lower) }
-            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(name)
+      next_state(:LABEL) do
+        @properties[:name] = name
+      end
+    end
+
+    def finish_label
+      Festwert.new(**@properties, value: nil).tap do
+        reset_entry!
+        next_state(:LABELS)
+      end
+    end
+
+    def start_signal(name)
+      next_state(:SIGNAL) do
+        @properties[:name] = name
+      end
+    end
+
+    def finish_signal
+      Signal.new(**@properties).tap do
+        reset_entry!
+        next_state(:SIGNALS)
+      end
+    end
 
-    lines[upper...lower]
+    def add_property(str)
+      case @properties
+      in { task:, description: } then @properties[:description] << " " << str
+      in { task:               } then @properties[:description] = str.strip
+      in { **                  } then @properties[:task] = str.split("&").first
+      end
+    end
   end
 end

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

@@ -0,0 +1,38 @@
+# TODO: This is exactly the same as the DcmParserError, maybe pull these
+# together?
+
+class Ecu
+  class LabParserError < 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/lab/label.rb

@@ -1,19 +1,5 @@
 class Ecu
   class Label
-
-    # This is a silly hack, since the *.lab file doesn't contain any information
-    # about the label in question (just the name). Subsequently, just initialize
-    # a Festwert with no value and hope if does the job correctly
-
-    def self.from_lab(line)
-      name, description = line.strip.split(";")
-      if description.nil?
-        Festwert.new(name: name, value: nil)
-      else
-        Festwert.new(name: name, value: nil, description: description)
-      end
-    end
-
     def to_lab
       "#{name};#{description}"
     end

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

@@ -4,7 +4,7 @@ require_relative "lab_parser"
 class Ecu
   class LabelList
     def self.from_lab(str)
-      _, labels, headers, subheaders = LabParser.call(str)
+      _, labels, headers, subheaders = LabParser.new(str).call
       new(labels, headers, subheaders)
     end
 

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

@@ -1,13 +1,5 @@
 class Ecu
   class Signal
-    def self.from_lab(line)
-      name, tasks, comment = line.strip.split(";")
-      maintask             = tasks.split("&").first rescue nil
-      new(name: name,
-          task: maintask,
-          description: comment&.strip)
-    end
-
     def to_lab
       "#{name};#{task};#{description}"
     end

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

@@ -4,7 +4,7 @@ require_relative "lab_parser"
 class Ecu
   class SignalList
     def self.from_lab(str)
-      signals, _, headers, subheaders = LabParser.call(str)
+      signals, _, headers, subheaders = LabParser.new(str).call
       new(signals, headers, subheaders)
     end
 

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/labels/label_list.rb

@@ -10,6 +10,7 @@ require_relative "../interfaces/dcm/label_list"
 require_relative "../interfaces/lab/label_list"
 require_relative "../interfaces/a2l/label_list"
 require_relative "../interfaces/mfile/label_list"
+require_relative "../interfaces/json/label_list"
 
 require "set"
 require_relative "../../core_ext"

data/lib/ecu/version.rb

@@ -1,3 +1,3 @@
 class Ecu
-  VERSION = "0.1.10"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: automotive-ecu
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.2
 platform: ruby
 authors:
 - Jonas Mueller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-29 00:00:00.000000000 Z
+date: 2025-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: terminal-table
@@ -97,6 +97,7 @@ files:
 - bin/pry
 - bin/rake
 - bin/rspec
+- bin/sandbox
 - bin/setup
 - lib/core_ext.rb
 - lib/ecu.rb
@@ -105,23 +106,25 @@ 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/json/label_list.rb
 - lib/ecu/interfaces/lab/combined_list.rb
+- lib/ecu/interfaces/lab/lab_lexer.rb
 - lib/ecu/interfaces/lab/lab_parser.rb
+- lib/ecu/interfaces/lab/lab_parser_error.rb
 - lib/ecu/interfaces/lab/label.rb
 - lib/ecu/interfaces/lab/label_list.rb
 - lib/ecu/interfaces/lab/signal.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