origen_testers 0.41.0 → 0.42.0

data/lib/origen_testers/decompiler/nodes.rb

@@ -0,0 +1,141 @@
+module OrigenTesters
+  module Decompiler
+    module Nodes
+      class Node
+        attr_reader :context
+        attr_reader :type
+
+        def self.inherited(subclass)
+          if subclass.const_defined?(:PLATFORM_NODES)
+            subclass.const_get(:PLATFORM_NODES).each do |n|
+              subclass.define_instance_method(n) do
+                instance_variable_get(":@#{n}")
+              end
+            end
+          end
+        end
+
+        def initialize(context:, type:, **nodes)
+          @context = context
+          if type
+            @type = type
+          elsif @type.nil?
+            type = self.class.underscore
+          end
+
+          unless platform_nodes.empty?
+            platform_nodes.each do |n|
+              define_singleton_method(n) do
+                instance_variable_get("@#{n}".to_sym)
+              end
+            end
+          end
+        end
+
+        def execute?
+          @execute
+        end
+
+        def platform_nodes
+          self.class.const_defined?(:PLATFORM_NODES) ? self.class.const_get(:PLATFORM_NODES) : []
+        end
+      end
+
+      class CommentBlock < OrigenTesters::Decompiler::Nodes::Node
+        attr_reader :comments
+
+        def initialize(comments:, context:)
+          @comments = comments
+          super(context: context, type: :comment_block)
+        end
+
+        def execute?
+          true
+        end
+
+        def execute!(context)
+          @comments.each { |c| cc(c) }
+        end
+      end
+
+      class Vector < OrigenTesters::Decompiler::Nodes::Node
+        attr_reader :repeat
+        attr_reader :timeset
+        attr_reader :pin_states
+        attr_reader :comment
+
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(repeat:, timeset:, pin_states:, comment:, context:, **nodes)
+          @execute = true
+
+          @repeat = repeat
+          @timeset = timeset
+          @pin_states = pin_states
+          @comment = comment
+
+          super(context: context, type: :vector)
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        def execute!(context)
+          # Apply a timeset switch, if needed.
+          unless Origen.tester.timeset.name == timeset
+            Origen.tester.set_timeset(timeset)
+          end
+
+          # Apply the comment
+          unless comment.empty?
+            cc(comment)
+          end
+
+          # Apply the pin states
+          context.pinlist.each_with_index do |pin, i|
+            dut.pins(pin).vector_formatted_value = pin_states[i]
+          end
+
+          # Cycle the tester
+          repeat.cycles
+        end
+      end
+
+      class Pinlist < OrigenTesters::Decompiler::Nodes::Node
+        attr_reader :pins
+        alias_method :pinlist, :pins
+
+        def initialize(pins:, context:)
+          @pins = pins.map(&:to_sym)
+          super(context: context, type: :pinlist)
+        end
+      end
+
+      class Frontmatter < OrigenTesters::Decompiler::Nodes::Node
+        attr_reader :comments
+        attr_reader :pattern_header
+
+        alias_method :header, :pattern_header
+        alias_method :comment_header, :pattern_header
+
+        def initialize(pattern_header: nil, comments: nil, context:)
+          @pattern_header = pattern_header
+          @comments = comments || []
+
+          super(context: context, type: :frontmatter)
+        end
+
+        def execute!(context)
+          pattern_header.each do |c|
+            cc(c)
+          end
+
+          comments.each do |c|
+            cc(c)
+          end
+        end
+
+        def execute?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/decompiler/pattern.rb

@@ -0,0 +1,304 @@
+module OrigenTesters
+  module Decompiler
+    require_relative './pattern/elements/base'
+    require_relative './pattern/elements/comment_block'
+    require_relative './pattern/elements/frontmatter'
+    require_relative './pattern/elements/pinlist'
+    require_relative './pattern/elements/vector_body_element'
+    require_relative './pattern/elements/vector'
+    require_relative './pattern/vector_delimiter_base'
+    require_relative './pattern/enumerable_ext'
+    require_relative './pattern/parsers'
+    require_relative './pattern/splitter'
+    require_relative './pattern/spec_helpers'
+
+    class ParseError < Origen::OrigenError
+    end
+
+    class SubclassError < Origen::OrigenError
+    end
+
+    class NoFirstVectorAvailable < Origen::OrigenError
+    end
+
+    class NoSuchSource < Origen::OrigenError
+    end
+
+    class NoSuitableDecompiler < Origen::OrigenError
+    end
+
+    class NoMethodError < Origen::OrigenError
+    end
+
+    class NoAvailableProcessor < Origen::OrigenError
+    end
+
+    class Pattern
+      class << self
+        attr_reader :splitter_config
+        attr_reader :parser_config
+        attr_reader :platform_tokens
+        attr_reader :platform
+        attr_reader :no_verify
+      end
+
+      attr_reader :source
+      attr_reader :decompiled
+      attr_reader :direct_source
+
+      include Splitter
+      include Parsers
+      include EnumerableExt
+      include SpecHelpers
+
+      def initialize(source, direct_source: false, no_verify: false)
+        if source.is_a?(File)
+          source = source.path
+        end
+
+        if direct_source
+          @source = source
+          @direct_source = true
+        else
+          @source = Pathname(source)
+          unless @source.exist?
+            message = "Cannot find pattern source '#{@source}'"
+            Origen.log.error(message)
+            Origen.app!.fail(exception_class: OrigenTesters::Decompiler::NoSuchSource, message: message)
+          end
+          @direct_source = false
+        end
+        @decompiled = false
+
+        unless no_verify || self.class.no_verify
+          verify_subclass_configuration
+        end
+      end
+
+      def platform
+        self.class.platform
+      end
+      alias_method :tester, :platform
+
+      def platform?(p = nil)
+        if p
+          platform == p
+        else
+          platform == tester.name.to_s
+        end
+      end
+      alias_method :tester?, :platform?
+
+      def decompiler
+        self.class
+      end
+
+      def decompiler?(d)
+        decompiler == d
+      end
+
+      def parser_config
+        self.class.parser_config || {}
+      end
+
+      def platform_tokens
+        self.class.platform_tokens
+      end
+      alias_method :decompiler_tokens, :platform_tokens
+
+      def comment_start
+        self.class.platform_tokens[:comment_start]
+      end
+      alias_method :comment_token, :comment_start
+
+      def splitter_config
+        self.class.splitter_config
+      end
+
+      def method_parse_frontmatter
+        if self.class.respond_to?(:parse_frontmatter)
+          self.class.method(:parse_frontmatter)
+        end
+      end
+
+      def method_parse_pinlist
+        if self.class.respond_to?(:parse_pinlist)
+          self.class.method(:parse_pinlist)
+        end
+      end
+
+      def method_parse_vector
+        if self.class.respond_to?(:parse_vector)
+          self.class.method(:parse_vector)
+        end
+      end
+
+      def verify_subclass_configuration
+        if method_parse_frontmatter.nil?
+          subclass_error('Missing class method #parse_frontmatter')
+        elsif method_parse_pinlist.nil?
+          subclass_error('Missing class method #parse_pinlist')
+        elsif method_parse_vector.nil?
+          subclass_error('Missing class method #parse_vector')
+        elsif splitter_config.nil?
+          subclass_error('Missing class variable :splitter_config')
+        elsif !(Splitter::REQUIRED_KEYS - splitter_config.keys).empty?
+          subclass_error("Splitter config is missing required keys: #{(Splitter::REQUIRED_KEYS - splitter_config.keys).map { |k| ':' + k.to_s }.join(', ')}")
+        elsif !(splitter_config.keys - Splitter::REQUIRED_KEYS - Splitter::OPTIONAL_KEYS).empty?
+          subclass_error("Splitter config contains extra keys: #{(splitter_config.keys - Splitter::REQUIRED_KEYS - Splitter::OPTIONAL_KEYS).map { |k| ':' + k.to_s }.join(', ')}")
+        end
+      end
+
+      def subclass_error(message)
+        Origen.log.error("#{self.class.name} failed to subclasss OrigenTesters::DecompilerPattern: #{message}")
+        fail(SubclassError, "#{self.class.name} failed to subclasss OrigenTesters::DecompilerPattern: #{message}")
+      end
+
+      def decompiled?
+        @decompiled
+      end
+
+      def direct_source?
+        @direct_source
+      end
+
+      def first_vector
+        @first_vector || begin
+          each_vector do |v|
+            if v.vector?
+              @first_vector = v.element
+              break
+            end
+          end
+          if @first_vector.nil?
+            fail OrigenTesters::Decompiler::ParseError, "Could not locate the first vector in pattern #{@source}"
+          end
+          @first_vector
+        end
+      end
+
+      def first_timeset
+        first_vector.timeset
+      end
+      alias_method :initial_timeset, :first_timeset
+
+      def first_pin_states_mapped
+        pins.each.with_index.with_object({}) do |(pin, i), hash|
+          hash[pin] = initial_pin_states[i]
+        end
+      end
+      alias_method :initial_pin_states_mapped, :first_pin_states_mapped
+
+      def first_pin_states
+        first_vector.pin_states
+      end
+      alias_method :initial_pin_states, :first_pin_states
+
+      def pinlist_size
+        pinlist.pins.size
+      end
+      alias_method :num_pins, :pinlist_size
+      alias_method :number_of_pins, :pinlist_size
+
+      def pins
+        pinlist.pins
+      end
+
+      def decompile(options = {})
+        # Read the pattern and split it into sections then parse and store the
+        # frontmatter and pinlist models
+        split!
+        @frontmatter = _parse_frontmatter_
+        @pinlist = _parse_pinlist_
+
+        @decompiled = true
+        self
+      end
+
+      def frontmatter
+        @frontmatter
+      end
+
+      def pinlist
+        @pinlist
+      end
+
+      def vectors
+        @vector_handler ||= vector_start
+      end
+
+      def current_vector_index
+        @current_vector_index
+      end
+
+      # Resolves the size of each pin in the pinlist using the initial pin states.
+      # @return [Hash] Hash wherein the keys are the pin names and each value is
+      #   the corresponding size.
+      def pin_sizes
+        # initial_pin_states.map { |pin, state| state.size }
+        initial_pin_states_mapped.map { |pin, state| [pin, state.size] }.to_h
+        # pins.each.with_index.with_object({}) do |(pin, i), hash|
+        #  hash[pin] = initial_pin_states[i].size
+        # end
+      end
+
+      def first_vector?
+        first_vector
+      rescue OrigenTesters::Decompiler::ParseError
+        return false
+      end
+
+      # Adds any pins in the decompiled pattern to the DUT which are not already present.
+      # @return [Array] Any pin names that were added to the DUT.
+      def add_pins
+        #        pin_sizes = pat_model.pattern_model.pin_sizes
+        #        pat_model.pinlist.each_with_index do |(name, pin), i|
+        #          dut.add_pin(name, size: pin_sizes[i]) unless dut.has_pin?(name)
+        #        end
+        retn = []
+        if first_vector?
+          pin_sizes.each do |pin, size|
+            unless dut.has_pin?(pin)
+              dut.add_pin(pin, size: size)
+              retn << pin
+            end
+          end
+        else
+          fail(NoFirstVectorAvailable, "No first vector available for pattern '#{source}'. Cannot add pins to the DUT '#{dut.class.name}'")
+        end
+        retn
+      end
+
+      # @note <code>line</code> is this context is delimited by the given separator.
+      #   This may or may not be a true newline-delimited, line.
+      # def number_of_lines
+      #  fail
+      # end
+
+      # Executing a pattern consist of:
+      #  1. Doing some initial setup (timesets, initial pin states, etc.)
+      #  2. Executing anything that can be executed in the frontmatter
+      #  3. Executing the vectors 1-by-1.
+      def execute(options = {})
+        if Origen.tester.timeset.nil?
+          if first_vector?
+            Origen.tester.set_timeset(first_timeset, 40)
+          else
+            Origen.log.error 'No first vector available and the timeset has not already been set!'
+            Origen.log.error 'Please set the timeset yourself prior to calling #execute! in a pattern that does not contain a first vector.'
+            fail(NoFirstVectorAvailable, "No first vector available for pattern '#{source}'. Cannot set a timeset to execute the pattern.")
+          end
+        end
+        frontmatter.execute!
+        each_vector_with_index do |vec, i|
+          if Origen.debug?
+            Origen.log.info("OrigenTesters: Executing Vector #{i}")
+          end
+          vec.execute!
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/origen_testers/decompiler/pattern/elements/base.rb

@@ -0,0 +1,44 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      class Base
+        attr_reader :context
+        alias_method :decompiled_pattern, :context
+
+        attr_reader :node
+        alias_method :processor, :node
+
+        def initialize(node:, context:, **options)
+          @context = context
+          @node = node
+        end
+
+        def [](node)
+          node.find(node)
+        end
+
+        def platform_nodes
+          node.platform_nodes
+        end
+
+        def method_missing(m, *args, &block)
+          if platform_nodes.include?(m) || node.respond_to?(m)
+            node.send(m)
+          else
+            super
+          end
+        end
+
+        def execute!
+          if node.execute?
+            node.execute!(self)
+          end
+        end
+
+        def pinlist
+          decompiled_pattern.pinlist.pinlist
+        end
+      end
+    end
+  end
+end