origen_testers 0.41.0 → 0.42.0

data/lib/origen_testers/decompiler/pattern/parsers.rb

@@ -0,0 +1,111 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      module Parsers
+        # @abstract This requires the child to supply:
+        #   A method #parse_frontmatter(raw_frontmatter) which returns
+        #   a node with the frontmatter parsed.
+        def _parse_frontmatter_
+          begin
+            n = method_parse_frontmatter.call(raw_frontmatter: raw_frontmatter, context: self)
+          rescue ParseError => e
+            # If parsing threw a ParseError, the platform found the error.
+            # Raise this as normal.
+            raise(e)
+          rescue Exception => e
+            # Anything else, raise a parse error and provide the error raised
+            # by parsing.
+            m = "Error encountered while parsing the frontmatter: #{e.class}"
+            Origen.log.error(m)
+            Origen.log.error(e.message)
+            Origen.log.error(e.backtrace.join("\n\t"))
+            Origen.app!.fail(exception_class: ParseError, message: m)
+          end
+
+          # Seperate this out so that errors creating the frontmatter class
+          # aren't confused with parsing errors.
+          @frontmatter = Frontmatter.new(node: n, context: self)
+        end
+
+        # @abstract This requires the child to supply:
+        #   A method #parse_pinlist(raw_pinlist) which returns a node with
+        #   the pinlist parsed.
+        #
+        #   The node should have a #pins method, which returns an array of
+        #   the pin names (as Strings).
+        #   Example:
+        #     parse_pinlist('vector ($tset, tclk, tdi, tdo, tms)')
+        #       #=> ['tclk', 'tdi', 'tdo', 'tms']
+        def _parse_pinlist_
+          begin
+            n = method_parse_pinlist.call(raw_pinlist: raw_pinlist, context: self)
+          rescue ParseError => e
+            # If parsing threw a ParseError, the platform found the error.
+            # Raise this as normal.
+            raise(e)
+          rescue Exception => e
+            # Anything else, raise a parse error and provide the error raised by parsing.
+            m = "Error encountered while parsing the pinlist: #{e.class}"
+            Origen.log.error(m)
+            Origen.log.error(e.message)
+            Origen.log.error(e.backtrace.join("\n\t"))
+            Origen.app!.fail(exception_class: ParseError, message: m)
+          end
+
+          # Seperate this out so that errors creating the pinlist class
+          # aren't confused with parsing errors.
+          @pinlist = Pinlist.new(node: n, context: self)
+        end
+
+        # This will parse vectors line-by-line, so multi-line vectors will
+        # need to take this into account.
+        # @abstract This requires the child to supply:
+        #   A method #parse_vector(raw_vector) which returns a node with
+        #   the vector parsed.
+        #
+        #   This node should have the following:
+        #     - type
+        #     - platform_nodes
+        #
+        #   In the even the type is vector, it should also have:
+        #     - timeset
+        #       - This should return the timeset of the vector as a String.
+        #     - pin states
+        #       - This should return an array of strings, where each string
+        #         corresponds to the pin state of a pin indicated by its offset
+        #         into the pin header array.
+        #     - comment
+        #         The comment in this line. This can be either String,
+        #         an Array of Strings (for multiline comments, if supported), or
+        #         nil, if there is no comment.
+        #     - comment
+        #         A true/false value that indicates if this entire line is a comment.
+        #         If true, operations, timeset, pin states, can be nil.
+        #   If the type is something else (platform specifc, such as a 'starb label',for the J750),
+        #     all contents can be in the 'platform_nodes'.
+        def _parse_vector_(raw_vector, options = {})
+          begin
+            v = method_parse_vector.call(raw_vector: raw_vector, context: self, meta: (@vector_meta ||= {}))
+          rescue ParseError => e
+            # If parsing threw a ParseError, the platform found the error.
+            # Raise this as normal.
+            raise(e)
+          rescue Exception => e
+            # Anything else, raise a parse error and provide the error raised by parsing.
+            m = "Error encountered while parsing the vector at index #{options[:vector_index]}: #{e.class}"
+            Origen.log.error(m)
+            Origen.log.error('While parsing:')
+            Origen.log.error("  #{raw_vector}")
+            Origen.log.error(e.message)
+            Origen.log.error(e.backtrace.join("\n\t"))
+            Origen.app!.fail(exception_class: ParseError, message: m)
+          end
+
+          # Seperate this out so that errors creating the vector body element class
+          # aren't confused with parsing errors.
+          @current_vector = VectorBodyElement.new(node: v, context: self, **options)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/decompiler/pattern/spec_helpers.rb

@@ -0,0 +1,41 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      module SpecHelpers
+        def to_yaml_hash(options = {})
+          {
+            pattern:     @path,
+            timestamp:   Time.now.to_s,
+            class:       self.class.to_s,
+            # ... Add in the variables here
+
+            frontmatter: frontmatter.to_yaml_hash,
+            pinlist:     pinlist.to_yaml_hash,
+            vectors:     collect_vectors { |v, i| v.to_yaml_hash }
+          }
+        end
+
+        def to_spec_yaml(options = {})
+          to_yaml_hash.to_yaml
+        end
+
+        def spec_yaml_output
+          "#{Origen.app!.root}/output/#{platform}/decompiler/models/#{source.basename}.yaml"
+        end
+
+        def spec_yaml_approved
+          "#{Origen.app!.root}/approved/#{platform}/decompiler/models/#{source.basename}.yaml"
+        end
+
+        def write_spec_yaml(options = {})
+          path = options[:approved] ? spec_yaml_approved : spec_yaml_output
+          unless Dir.exist?(File.dirname(path))
+            FileUtils.mkdir_p(File.dirname(path))
+          end
+          File.open(path, 'w').puts(to_spec_yaml(options))
+          path
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/decompiler/pattern/splitter.rb

@@ -0,0 +1,166 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      module Splitter
+        REQUIRED_KEYS = [:pinlist_start, :vectors_start, :vectors_end]
+        OPTIONAL_KEYS = [:separator, :vectors_include_start_line, :vectors_include_end_line]
+
+        def section_indices
+          @section_indices
+        end
+
+        def raw_lines(start, stop, &block)
+          retn_lines = []
+          _run_line_ = lambda do |line, index, retn_lines, &block|
+            if index > stop
+              break
+            elsif index >= start
+              if block_given?
+                yield
+              else
+                retn_lines << line
+              end
+            end
+          end
+
+          if direct_source?
+            source.split("\n").map { |l| "#{l}\n" }.each_with_index do |line, index|
+              _run_line_.call(line, index, retn_lines, &block)
+            end
+          else
+            File.foreach(source).each_with_index do |line, index|
+              _run_line_.call(line, index, retn_lines, &block)
+            end
+          end
+          retn_lines
+        end
+
+        def raw_frontmatter
+          raw_lines(section_indices[:frontmatter_start], section_indices[:frontmatter_end])
+        end
+
+        def raw_pinlist
+          raw_lines(section_indices[:pinlist_start], section_indices[:pinlist_end])
+        end
+
+        def raw_vectors(&block)
+          raw_lines(section_indices[:vectors_start], section_indices[:vectors_end])
+        end
+
+        def raw_endmatter
+          raw_lines(section_indices[:endmatter_start], section_indices[:endmatter_end])
+        end
+
+        def split!
+          section_indices = split(splitter_config)
+
+          # Check that we found each section in the pattern.
+          if section_indices[:pinlist_start].nil?
+            Origen.log.error('Parsing Error!')
+            Origen.log.error("Could not locate the pinlist start in pattern #{source}")
+            Origen.log.error("Expected a pattern line to match '#{splitter_config[:pinlist_start]}'")
+
+            fail OrigenTesters::Decompiler::ParseError, "Parsing Error! Could not locate the pinlist start in pattern #{source}"
+          elsif section_indices[:vectors_start].nil?
+            Origen.log.error('Parsing Error!')
+            Origen.log.error("Could not locate the vector start in pattern #{source}")
+            Origen.log.error("Expected a pattern line to match '#{splitter_config[:vector_start]}'")
+
+            fail OrigenTesters::Decompiler::ParseError, "Parsing Error! Could not locate the vector body in pattern #{source}"
+          elsif section_indices[:vectors_end].nil?
+            Origen.log.error('Parsing Error!')
+            Origen.log.error("Could not locate the vector body end in pattern #{source}")
+            Origen.log.error("Expected a pattern line to match '#{splitter_config[:vector_end]}'")
+
+            fail OrigenTesters::Decompiler::ParseError, "Parsing Error! Could not locate the vector body end in pattern #{source}"
+          end
+
+          @section_indices = section_indices
+          @section_indices
+        end
+
+        # Splits the pattern into gour secionts using regexes:
+        #  1. Frontmatter
+        #  2. Pin List
+        #  3. Vectors
+        #  4. Endmatter
+        # The idea is that each section can be delimited by a line that matches some
+        # regex (and is not considered a comment line).
+        # The pattern will be read line-by-line, looking for the regexes.
+        # We're defining the pattern section as such:
+        #  - Frontmatter starts at the beginning of the pattern and ends at the start of the pattern header.
+        #  - Vectors start from the end of the pattern header and go until the end of the vectors.
+        #  - Endmatter starts at the end of the vectors and ends at the end of the file.
+        #    - Its possible (and fine) for endmatter to be non-existant, or even not allowed.
+        #    - In the latter case, the endvector symbol should the EoF symbol.
+        # @return (Hash)
+        # rubocop:disable Metrics/ParameterLists
+        def split(pinlist_start:, vectors_start:, vectors_end:, vectors_include_start_line: false, vectors_include_end_line: false, &block)
+          def check_match(matcher, line, index, indices)
+            if matcher.respond_to?(:call)
+              matcher.call(line: line, index: index, current_indices: indices)
+            elsif matcher.is_a?(Regexp)
+              line =~ matcher
+            elsif matcher.is_a?(String)
+              line.start_with?(matcher)
+            else
+              fail "Splitter does not know how to match given matcher of class #{matcher.class}"
+            end
+          end
+
+          if File.zero?(source)
+            Origen.log.error('Parsing Error!')
+            Origen.log.error("Pattern #{source} has size zero!")
+            Origen.log.error('Decompiling empty files is not supported.')
+
+            fail(OrigenTesters::Decompiler::ParseError, "Empty or non-readable pattern file #{source}")
+          end
+
+          indices = {
+            frontmatter_start: 0,
+            endmatter_end:     -1
+          }
+          if block_given?
+            fail 'Blocks are not yet supported!'
+          else
+            if vectors_end == -1
+              indices[:vectors_end] = -1
+              indices[:endmatter_start] = -1
+            end
+            _split_ = lambda do |line, index, indices|
+              if !indices[:pinlist_start]
+                if check_match(pinlist_start, line, index, indices)
+                  indices[:frontmatter_end] = index - 1
+                  indices[:pinlist_start] = index
+                end
+              elsif !indices[:vectors_start]
+                if check_match(vectors_start, line, index, indices)
+                  indices[:pinlist_end] = index - 1
+                  vectors_include_start_line ? indices[:vectors_start] = index : indices[:vectors_start] = index + 1
+                end
+              elsif !indices[:vectors_end]
+                if check_match(vectors_end, line, index, indices)
+                  vectors_include_end_line ? indices[:vectors_end] = index : indices[:vectors_end] = index - 1
+                  indices[:endmatter_start] = index
+                end
+              end
+            end
+
+            if direct_source?
+              source.split("\n").each_with_index do |line, index|
+                _split_.call(line, index, indices)
+              end
+            else
+              File.foreach(source).each_with_index do |line, index|
+                _split_.call(line, index, indices)
+              end
+            end
+
+            indices
+          end
+          # rubocop:enable Metrics/ParameterLists
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/decompiler/pattern/vector_delimiter_base.rb

@@ -0,0 +1,70 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      class VectorDelimiterBase
+        attr_reader :current_vector
+        attr_reader :parent
+
+        def initialize(parent)
+          @current_vector = []
+          @delimited = false
+          @in_comment_block = false
+
+          @parent = parent
+        end
+
+        def comment_start
+          parent.comment_start
+        end
+
+        def in_comment_block?
+          @in_comment_block
+        end
+
+        def shift(line)
+          if @in_comment_block
+            if !line.strip.start_with?(comment_start)
+              # End of the comment block.
+              # Signal that this vector is over, but don't include the
+              # newly shifted line.
+              @delimited = true
+              @include_last_line = false
+            else
+              @current_vector << line
+            end
+          else
+            if current_vector.empty? && line.strip.start_with?(comment_start)
+              # Currently in an empty vector and encountered a comment.
+              # Start a new comment block.
+              @in_comment_block = true
+              @current_vector << line
+            elsif !current_vector.empty? && line.strip.start_with?(comment_start)
+              # Not in an empty vector, but not in a comment block.
+              # Signal the end of this vector and start a new one with
+              # this vector.
+              @delimited = true
+              @include_last_line = false
+            else
+              # Standard single vector
+              @delimited = true
+              @include_last_line = true
+              @current_vector << line
+            end
+          end
+        end
+
+        def current_vector!
+          current_vector.join('')
+        end
+
+        def delimited?
+          @delimited
+        end
+
+        def include_last_line?
+          @include_last_line
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester.rb

@@ -4,6 +4,9 @@ module OrigenTesters
     autoload :J750,                'origen_testers/igxl_based_tester/j750.rb'
     autoload :J750_HPT,            'origen_testers/igxl_based_tester/j750_hpt.rb'
     autoload :UltraFLEX,           'origen_testers/igxl_based_tester/ultraflex.rb'
+
+    require 'origen_testers/igxl_based_tester/base.rb'
+    require 'origen_testers/igxl_based_tester/decompiler'
   end
   # Convenience/Legacy names without the IGXLBasedTester namespace
   autoload :J750,                  'origen_testers/igxl_based_tester/j750.rb'

data/lib/origen_testers/igxl_based_tester/base.rb

@@ -1,5 +1,12 @@
 module OrigenTesters
   module IGXLBasedTester
+    class << self
+      attr_reader :pat_extension
+      attr_reader :comment_char
+    end
+    @pat_extension = 'atp'
+    @comment_char = '//'
+
     # This is the base class of all IGXL-based testers
     class Base
       include VectorBasedTester
@@ -27,7 +34,7 @@ module OrigenTesters
         @counter_msb_bits = 0
         @max_repeat_loop = 65_535 # 16 bits
         @min_repeat_loop = 2
-        @pat_extension = 'atp'
+        @pat_extension = OrigenTesters::IGXLBasedTester.pat_extension
         @active_loads = true
         @pipeline_depth = 34
         @software_version = ''