origen_testers 0.4.0

data/lib/origen_testers/igxl_based_tester/parser/flow.rb

@@ -0,0 +1,109 @@
+module OrigenTesters
+  class IGXLBasedTester
+    class Parser
+      class Flow < ::OrigenTesters::Parser::SearchableArray
+        require 'pathname'
+
+        attr_accessor :parser, :file
+
+        def initialize(file, options = {})  # :nodoc:
+          @parser = options[:parser]
+          @file = Pathname.new(file)
+          parse
+        end
+
+        def description
+          @parser.descriptions.flow_summary(file: file)
+        end
+        alias_method :summary, :description
+
+        # Returns the filename of the sheet that contained the current flow
+        def filename
+          @file.basename.to_s
+        end
+        alias_method :name, :filename
+
+        # Returns all flow lines that are tests, optionally supply a context to
+        # have only the test that will execute in that context returned
+        #
+        #   $tester.flow.first.tests.size
+        #     => 20
+        #   $tester.flow.first.tests(:job => "P1").size
+        #     => 10
+        #   $tester.flow.first.tests(:job => "P1", :enable => "data_collection").size
+        #     => 15
+        def tests(context = {})
+          run_context(context)
+        end
+
+        # Returns all tests in the current flow, regardless of context
+        def all_tests
+          where(opcode: %w(Test characterize), exact: true)
+        end
+
+        def run_context(context)  # :nodoc:
+          capture = true
+          waiting_for_label = false
+          select do |line|
+            if capture
+              if !waiting_for_label || waiting_for_label == line.label
+                waiting_for_label = false
+                case line.type
+                when 'Test', 'characterize'
+                  line.executes_under_context?(context)
+                when 'set-device', 'stop'
+                  capture = false if line.executes_under_context?(context)
+                  false
+                when 'enable-flow-word'
+                  if line.executes_under_context?(context)
+                    context[:enable] = [context[:enable]].flatten
+                    context[:enable] << line.parameter
+                  end
+                  false
+                when 'flag-true'
+                  if line.executes_under_context?(context)
+                    context[:true_flags] = [context[:true_flags]].flatten
+                    context[:true_flags] << line.parameter
+                  end
+                  false
+                when 'flag-false'
+                  if line.executes_under_context?(context)
+                    context[:false_flags] = [context[:false_flags]].flatten
+                    context[:false_flags] << line.parameter
+                  end
+                  false
+                when 'disable-flow-word'
+                  if line.executes_under_context?(context)
+                    context[:enable] = [context[:enable]].flatten
+                    context[:enable].delete(line.parameter)
+                  end
+                  false
+                when 'logprint', 'nop', 'print'
+                  false
+                when 'goto'
+                  waiting_for_label = line.parameter
+                  false
+                else
+                  fail "Don't know how to process: #{line.type}, in file #{filename}"
+                end
+              else
+                false
+              end
+            end
+          end
+        end
+
+        def parse  # :nodoc:
+          File.readlines(@file).each do |line|
+            l = FlowLine.new(line, parser: parser, flow: self)
+            self << l if l.valid?
+          end
+        end
+
+        def inspect  # :nodoc:
+          "<TestFlow: #{filename}, Lines: #{size}>"
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/parser/flow_line.rb

@@ -0,0 +1,203 @@
+module OrigenTesters
+  class IGXLBasedTester
+    class Parser
+      class FlowLine
+        attr_accessor :parser, :flow, :line
+
+        TYPES = %w(
+          Test characterize defaults enable-flow-word disable-flow-word error-print goto
+          goto-on-all-done goto-on-all-lastfail goto-on-all-lastfaildoall logprint modify
+          nop print reset set-device set-device-new set-error-bin set-retest-bin skip
+          stop assign-integer create-integer delete-integer create-site-var assign-site-var
+          flag-clear flag-clear-all flag-false flag-false-all flag-true flag-true-all
+          state-clear-all state-false-all state-true-all
+        )
+
+        ATTRS = %w(
+          label enable job part env opcode parameter
+          tname tnum bin_pass bin_fail sort_pass sort_fail result flag_pass
+          flag_fail state group_specifier group_sense group_condition group_name
+          device_sense device_condition device_name debug_assume debug_sites
+          comment
+        )
+
+        ALIASES = {
+          bin:         :bin_fail,
+          softbin:     :sort_fail,
+          soft_bin:    :sort_fail,
+          name:        :tname,
+          number:      :tnum,
+          test_number: :tnum,
+          test_num:    :tnum,
+          type:        :opcode
+        }
+
+        # Make readers for each low level attribute
+        ATTRS.each do |attr|
+          attr_reader attr
+        end
+
+        # And the aliases
+        ALIASES.each do |_alias, attr|
+          define_method("#{_alias}") do
+            send(attr)
+          end
+        end
+
+        # Returns the test instance called by the given line or nil
+        def self.extract_test(line)
+          l = new(line)
+          if l.valid? && l.test?
+            l.test_instance_name
+          end
+        end
+
+        def initialize(line, options = {})
+          @parser = options[:parser]
+          @flow = options[:flow]
+          @line = line
+          parse
+          if valid?
+            ATTRS.each_with_index do |attr, i|
+              instance_variable_set("@#{attr}", components[i + 1])
+            end
+          end
+        end
+
+        def inspect  # :nodoc:
+          "<FlowLine: #{type}, Parameter: #{parameter}>"
+        end
+
+        def description
+          from_instance = test_instance ? test_instance.description : ''
+          from_flow = parser.descriptions.flow_line(name: test_instance_name, flow: flow.file)
+          if !from_instance.empty? && !from_flow.empty?
+            [from_instance, "\n", from_flow].flatten
+          elsif from_instance.empty?
+            from_flow
+          else
+            from_instance
+          end
+        end
+
+        def parse
+          @components = @line.split("\t") unless @line.strip.empty?
+        end
+
+        def valid?
+          components[6] && TYPES.include?(components[6])
+        end
+
+        def components
+          @components ||= []
+        end
+
+        def test?
+          %w(Test characterize).include? opcode
+        end
+
+        def executes_under_context?(context)
+          enable_conditions_met?(context) &&
+            job_conditions_met?(context) &&
+            part_conditions_met?(context) &&
+            env_conditions_met?(context)
+        end
+
+        def enable_conditions_met?(context)
+          conditions_met?(enable, context[:enable])
+        end
+
+        def job_conditions_met?(context)
+          conditions_met?(job, context[:job])
+        end
+
+        def part_conditions_met?(context)
+          conditions_met?(part, context[:part])
+        end
+
+        def env_conditions_met?(context)
+          conditions_met?(env, context[:env])
+        end
+
+        def conditions_met?(conditions, values)
+          if conditions.empty?
+            true
+          else
+            values = [values].flatten
+            conditions = conditions.split(',').map(&:strip)
+            not_conditions = conditions.select { |c| c =~ /^!/ }
+            conditions = conditions - not_conditions
+            # Make sure all -ve conditions are not met
+            if not_conditions.all? do |c|
+                 c =~ /^!(.*)/
+                 c = Regexp.last_match[1]
+                 !values.include?(c)
+               end
+              # And then any +ve conditions
+              if conditions.empty?
+                true
+              else
+                values.any? { |v| conditions.include?(v) }
+              end
+            else
+              false
+            end
+          end
+        end
+
+        def test_instance_name
+          parameter
+        end
+        alias_method :instance_name, :test_instance_name
+
+        def test_instance
+          instances = parser.test_instances.where(name: parameter, exact: true)
+          if instances.size > 1
+            puts "Warning multiple instances of #{name} found, using the first one"
+          end
+          if instances.size == 0
+            nil
+          else
+            instances.first
+          end
+        end
+        alias_method :instance, :test_instance
+
+        # Returns an array of patterns used by the given test, if there are none
+        # an empty array is returned.
+        # Optionally supply patterns to exclude if you want to ignore common subroutine
+        # patterns for example.
+        def patterns(options = {})
+          if i = test_instance
+            pats = i.patterns
+            if options[:ignore] && pats
+              pats.reject { |p| [options[:ignore]].flatten.include?(p) }
+            else
+              []
+            end
+          else
+            []
+          end
+        end
+        alias_method :pattern, :patterns
+
+        # Returns a string summarizing any conditions (enable words, jobs, etc.) that
+        # gate the execution of this line
+        def conditions
+          c = []
+          c << "Enable: #{enable}" unless enable.empty?
+          c << "Job: #{job}" unless job.empty?
+          c << "Part: #{part}" unless part.empty?
+          c << "Env: #{env}" unless env.empty?
+          c.join('; ')
+        end
+
+        def vdd
+          if i = test_instance
+            i.vdd
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/parser/flows.rb

@@ -0,0 +1,21 @@
+module OrigenTesters
+  class IGXLBasedTester
+    class Parser
+      class Flows < ::OrigenTesters::Parser::SearchableArray
+        attr_accessor :parser
+
+        def initialize(options = {})
+          @parser = options[:parser]
+        end
+
+        def import(file)
+          self << Flow.new(file, parser: parser)
+        end
+
+        def inspect
+          "<TestFlows: #{size}>"
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/parser/pattern_set.rb

@@ -0,0 +1,92 @@
+module OrigenTesters
+  class IGXLBasedTester
+    class Parser
+      class PatternSet
+        class Pattern
+          attr_accessor :parser
+
+          ATTRS = %w(pattern_set file_name start_label stop_label comment)
+
+          ALIASES = {
+            pattern: :file_name,
+            file:    :file_name,
+            name:    :file_name
+          }
+
+          # Generate readers for all attributes and their aliases
+          ATTRS.each do |attr|
+            attr_reader attr.to_sym
+          end
+
+          ALIASES.each do |_alias, attr|
+            define_method("#{_alias}") do
+              send(attr)
+            end
+          end
+
+          def initialize(line)
+            @line = line
+            parse
+            if valid?
+              ATTRS.each_with_index do |attr, i|
+                instance_variable_set("@#{attr}", components[i + 1])
+              end
+            end
+          end
+
+          def parse
+            @components = @line.split("\t") unless @line.strip.empty?
+          end
+
+          def valid?
+            components[1] && !components[1].empty? && components[1] != 'Pattern Set' &&
+              components[2] && !components[2].empty?
+          end
+
+          def components
+            @components ||= []
+          end
+        end
+
+        def initialize(line, options = {})
+          @parser = options[:parser]
+          p = add_pattern_line(line)
+          @name = p.pattern_set if p.valid?
+        end
+
+        def inspect  # :nodoc:
+          "<PatternSet: #{name}>"
+        end
+
+        def name
+          @name
+        end
+
+        def patterns
+          @patterns ||= []
+        end
+
+        def self.extract_name(line)
+          new(line).name
+        end
+
+        def add_pattern_line(line)
+          p = Pattern.new(line)
+          patterns << Pattern.new(line) if p.valid?
+          p
+        end
+
+        def valid?
+          patterns.all?(&:valid?)
+        end
+
+        # Returns an array containing all pattern names contained in this
+        # pattern set
+        def pattern_names
+          # This removes the path and extensions
+          patterns.map { |pat| pat.name.gsub(/.*[\\\/]/, '').gsub(/\..*/, '') }
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/parser/pattern_sets.rb

@@ -0,0 +1,31 @@
+module OrigenTesters
+  class IGXLBasedTester
+    class Parser
+      class PatternSets < ::OrigenTesters::Parser::SearchableHash
+        attr_accessor :parser
+
+        def initialize(options = {})
+          @parser = options[:parser]
+        end
+
+        def import(file)
+          File.readlines(file).each do |line|
+            name = PatternSet.extract_name(line)
+            if name
+              if self[name]
+                self[name].add_pattern_line(line)
+              else
+                l = PatternSet.new(line, parser: parser)
+                self[l.name] = l if l.valid?
+              end
+            end
+          end
+        end
+
+        def inspect
+          "<Patsets: #{size}>"
+        end
+      end
+    end
+  end
+end