origen_testers 0.41.0 → 0.42.0

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

@@ -0,0 +1,28 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      require_relative './base'
+
+      class CommentBlock < Base
+        def initialize(parent)
+          super(node: parent, context: parent.context)
+        end
+
+        def comments
+          processor.comments
+        end
+
+        def to_yaml_hash(options = {})
+          {
+            class:          self.class.to_s,
+            index:          (node.respond_to?(:index) ? node.index : nil),
+            type:           node.type,
+            processor:      node.class.to_s,
+            comments:       comments,
+            platform_nodes: _platform_nodes_
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      require_relative './base'
+
+      class Frontmatter < Base
+        def initialize(node:, context:)
+          @source = :frontmatter
+          super
+        end
+
+        # Returns the topmost comment block.
+        # @return [Array] Array representing the topmost common, split by the <code> separator</code>.
+        #   If there is no comment header, an empty array is returned.
+        def pattern_header
+          processor.pattern_header
+        end
+
+        # Returns all the comments, in the order they appear.
+        # @return [Array] Returns an array of comment blocks, where
+        #   a comment block is an array of strings found in that block.
+        #   The comment block can be recontructed into raw text by joining the
+        #   array with the <code>separator</code>.
+        #   If no comments were found, an empty array is returned.
+        # @note This will <u>NOT</u> include the <code>comment_header</code>.
+        def comments
+          processor.comments
+        end
+
+        def to_yaml_hash
+          {
+            class:          self.class.to_s,
+            processor:      processor.class.to_s,
+            pattern_header: pattern_header,
+            comments:       comments,
+            platform_nodes: _platform_nodes_
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      require_relative './base'
+
+      class Pinlist < Base
+        def initialize(node:, context:)
+          @source = :pinlist
+          super
+        end
+
+        # Returns the pinlist as an ordered list.
+        # @return [Array] Array of strings where each array element is the
+        #   corresponding pin in that position.
+        # @example Return the pinlist.
+        #   # (Teradyne ATP format) vector ($tset, tclk, tdi, tdo, tms)
+        #   pinlist #=> ['tclk', 'tdi', 'tdo', 'tms']
+        def pinlist
+          processor.pins
+        end
+
+        def pins
+          processor.pins
+        end
+
+        # Returns the size of the pinlist.
+        # @return [Integer] Size of the pinlist.
+        def pinlist_size
+          processor.pinlist.size
+        end
+        alias_method :size, :pinlist_size
+
+        def to_yaml_hash
+          {
+            class:          self.class.to_s,
+            processor:      processor.class.to_s,
+            pinlist:        pinlist,
+            platform_nodes: _platform_nodes_
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      require_relative './base'
+
+      # Represents a single Vector's AST.
+      class Vector < Base
+        alias_method :parent, :node
+
+        def initialize(parent, options = {})
+          super(node: parent, context: parent.context)
+        end
+
+        def timeset
+          processor.timeset
+        end
+
+        def repeat
+          processor.repeat
+        end
+
+        def pin_states
+          processor.pin_states
+        end
+
+        def comment
+          processor.comment
+        end
+
+        def vector_index
+          parent.vector_index
+        end
+
+        def to_yaml_hash(options = {})
+          if parent.type == :vector
+            {
+              class:          self.class.to_s,
+              vector_index:   (parent.respond_to?(:vector_index) ? parent.vector_index : nil),
+              type:           parent.type,
+              processor:      processor.class.to_s,
+              timeset:        timeset,
+              repeat:         repeat,
+              pin_states:     pin_states,
+              comment:        comment,
+              platform_nodes: _platform_nodes_
+            }
+          else
+            {
+              class:        self.class.to_s,
+              vector_index: (parent.respond_to?(:vector_index) ? parent.vector_index : nil),
+              type:         parent.type,
+              processor:    processor.class.to_s
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      require_relative './base'
+
+      class VectorBodyElement < Base
+        # The known vector element types, supported regardless of the tester/platform.
+        BASE_ELEMENTS = [:vector, :comment_block]
+
+        attr_reader :type
+        attr_reader :element
+        attr_reader :vector_index
+
+        def initialize(node:, context:, **options)
+          @source = :vector_body_element
+          super(node: node, context: context)
+          @type = node.type
+          @vector_index = options[:vector_index]
+
+          # If the processor is a :vector or a comment_block, we can deal with
+          # this automatically. We also know that neither of these elemnts are
+          # platform specific.
+          @element = (BASE_ELEMENTS.include?(type)) ? to_element : false
+        end
+
+        # Returns an element class (e.g., Vector) that casts itself to a known vector-element type.
+        # For example, if this element's processor is a 'vector', then it can cast itself to a Vector class,
+        #   to expose functionality (e.g., #timeset) on the class itself. Otherwise, the functionality will remain
+        #   on the processor and its up to the user to know what the processor has.
+        # @note Calling this not required, as this is just an interface to a known processor type.
+        def to_element
+          if type == :comment_block
+            CommentBlock.new(self)
+          elsif type == :vector
+            Vector.new(self)
+          else
+            fail "Could not cast platform-specific vector body element type :#{type} to a standalone class!"
+          end
+        end
+
+        def to_yaml_hash(options = {})
+          {
+            class:        self.class.to_s,
+            vector_index: vector_index
+          }.merge(
+            begin
+              if element
+                element.to_yaml_hash(options)
+              else
+                # If this element couldn't be matched, provide a simple yaml hash
+                # including some basic elements.
+                {
+                  type:           type,
+                  processor:      processor.class.to_s,
+                  platform_nodes: _platform_nodes_
+                }
+              end
+            end
+          )
+        end
+
+        def is_a_vector?
+          type == :vector
+        end
+        alias_method :is_vector?, :is_a_vector?
+        alias_method :vector?, :is_a_vector?
+
+        def platform
+          decompiled_pattern.platform
+        end
+        alias_method :tester, :platform
+
+        def platform?(p = nil)
+          decompiled_pattern.platform?(p)
+        end
+        alias_method :tester?, :platform?
+
+        def decompiler
+          decompiled_pattern.platform
+        end
+
+        def decompiler?(d = nil)
+          decompiled_pattern.decompiler?(d)
+        end
+
+        def is_a_comment?
+          type == :comment || type == :comment_block
+        end
+        alias_method :is_comment?, :is_a_comment?
+
+        def is_tester_specific?
+          platform_nodes.include?(type)
+        end
+        alias_method :is_tester_specific_element?, :is_tester_specific?
+        alias_method :is_platform_specific?, :is_tester_specific?
+        alias_method :is_platform_specific_element?, :is_tester_specific?
+        alias_method :is_decompiler_specific?, :is_tester_specific?
+        alias_method :is_decompiler_specific_element?, :is_tester_specific?
+        alias_method :is_a_tester_specific_element?, :is_tester_specific?
+        alias_method :is_a_platform_specific_element?, :is_tester_specific?
+        alias_method :is_a_decompiler_specific_element?, :is_tester_specific?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+module OrigenTesters
+  module Decompiler
+    class Pattern
+      # We can't use Ruby's enumerable mix-in directly, as our each method
+      # isn't a true implementation, as the mix-in expects.
+      # Instead, we'll provide our own enumerable methods as needed that use
+      # our own each method.
+      module EnumerableExt
+        # Iterate through the vectors one by one.
+        # We'll begin reading the file from the vector start until the regex/block
+        # vector_delimiter is met.
+        # This delimiter can include multiple lines.
+        # Once the delimiter finishes, those lines will be sent to the treetop
+        # parser for conversion to an AST.
+        # Lastly, the next vector will start where the previous one left off.
+        def each(**options, &block)
+          unless decompiled?
+            Origen.app!.fail(message: 'Pattern has not yet been decompiled! Cannot iterate through vectors or query pattern aspects!')
+          end
+          vectors_started = false
+          delimiter_klass = VectorDelimiterBase
+          v = delimiter_klass.new(self)
+          vector_index = 0
+
+          if direct_source?
+            kickoff = 'source.split("\n")'
+          else
+            kickoff = 'File.foreach(source)'
+          end
+
+          eval(kickoff).each_with_index do |line, index|
+            # Get to the point in the file where the vectors begin
+            if index > section_indices[:vectors_end] && section_indices[:vectors_end] != -1
+              break
+            elsif index < section_indices[:vectors_start]
+              next
+            end
+
+            v.shift(line)
+            if v.delimited?
+              # index starts at 0, but most file editors start the line numbers at 1.
+              yield(_parse_vector_(v.current_vector!, vector_index: vector_index, line: index + 1))
+              vector_index += 1
+
+              if v.include_last_line?
+                # The last line is included in the current vector.
+                v = delimiter_klass.new(self)
+              else
+                # The last line shouldn't be included in this vector.
+                # Shift it into a new one.
+                v = delimiter_klass.new(self)
+                v.shift(line)
+
+                # Check if this new vector is delimited before grabbing
+                # the next line.
+                if v.delimited?
+                  yield(_parse_vector_(v.current_vector!, vector_index: vector_index))
+                  v = delimiter_klass.new(self)
+                  vector_index += 1
+                end
+              end
+            end
+          end
+        end
+        alias_method :each_vector, :each
+
+        def each_vector_with_index(&block)
+          i = 0
+          each_vector do |v|
+            yield(v, i)
+            i += 1
+          end
+        end
+
+        def vector_at(index, &block)
+          each_vector_with_index do |v, i|
+            if i == index
+              return v
+            end
+          end
+          nil
+        end
+
+        def collect(&block)
+          vectors = []
+          each_vector do |v|
+            if block_given?
+              vectors << yield(v)
+            else
+              vectors << v
+            end
+          end
+          vectors
+        end
+        alias_method :collect_vectors, :collect
+        alias_method :map, :collect
+        alias_method :map_vectors, :collect
+
+        def collect_with_index(&block)
+          vectors = []
+          each_vector_with_index do |v, i|
+            if block_given?
+              vectors << yield(v, i)
+            else
+              vectors << v
+            end
+          end
+          vectors
+        end
+        alias_method :collect_vectors_with_index, :collect_with_index
+
+        def find_all(&block)
+          vectors = []
+          if block_given?
+            each_vector { |v| vectors << v if yield(v) }
+          end
+          vectors
+        end
+        alias_method :select, :find_all
+        alias_method :filter, :find_all
+
+        def find(&block)
+          if block_given?
+            each_vector { |v| return v if yield(v) }
+          end
+        end
+        alias_method :detect, :find
+
+        def find_index(&block)
+          find(&block).vector_index
+        end
+
+        def count(&block)
+          cnt = 0
+          if block_given?
+            each_vector { |v| cnt += 1 if yield(v) }
+          else
+            each_vector { |v| cnt += 1 }
+          end
+          cnt
+        end
+        alias_method :size, :count
+
+        def reject(&block)
+          vectors = []
+          if block_given?
+            each_vector { |v| vectors << v unless yield(v) }
+          end
+          vectors
+        end
+
+        def first(n = nil)
+          if n
+            if n <= 0
+              return nil
+            end
+
+            vectors = []
+            each_vector_with_index do |v, i|
+              vectors << v
+              if n == (i - 1)
+                return vectors
+              end
+            end
+            vectors
+          else
+            each_vector { |v| return v }
+          end
+        end
+      end
+    end
+  end
+end