origen 0.2.6 → 0.3.0

data/lib/origen/tester/ultraflex/parser/flow.rb

@@ -1,111 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      class Parser
-        class Flow < Origen::Tester::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
-end

data/lib/origen/tester/ultraflex/parser/flow_line.rb

@@ -1,207 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      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 = {})
-            i = test_instance
-            if i
-              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
-            i = test_instance
-            if i
-              i.vdd
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/ultraflex/parser/flows.rb

@@ -1,23 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      class Parser
-        class Flows < Origen::Tester::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
-end

data/lib/origen/tester/ultraflex/parser/pattern_set.rb

@@ -1,94 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      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
-end

data/lib/origen/tester/ultraflex/parser/pattern_sets.rb

@@ -1,33 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      class Parser
-        class PatternSets < Origen::Tester::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
-end