origen 0.2.6 → 0.3.0

data/lib/origen/tester/j750/generator/flow.rb

@@ -1,123 +0,0 @@
-module Origen
-  module Tester
-    class J750
-      module Generator
-        class Flow
-          include Origen::Tester::Generator
-          include Origen::Tester::Generator::FlowControlAPI
-
-          TEMPLATE = "#{Origen.top}/lib/origen/tester/j750/generator/templates/flow.txt.erb"
-          OUTPUT_POSTFIX = 'flow'
-
-          def add(type, options = {})
-            ins = false
-            options = save_context(options) if [:test, :cz].include?(type)
-            branch_unless_enabled(options) do |options|
-              ins = track_relationships(options) do |options|
-                FlowLine.new(type, options)
-              end
-              collection << ins unless Origen.interface.resources_mode?
-              if ins.test?
-                c = Origen.interface.consume_comments
-                unless Origen.interface.resources_mode?
-                  Origen.interface.descriptions.add_for_test_usage(ins.parameter, Origen.interface.top_level_flow, c)
-                end
-              else
-                Origen.interface.discard_comments
-              end
-            end
-            ins
-          end
-
-          def logprint(message, options = {})
-            message.gsub!(/\s/, '_')
-            add(:logprint, options.merge(parameter: message))
-          end
-
-          def test(instance, options = {})
-            add(:test, options.merge(parameter: instance))
-          end
-
-          def cz(instance, cz_setup, options = {})
-            add(:cz, options.merge(parameter: instance, cz_setup: cz_setup))
-          end
-
-          def goto(label, options = {})
-            add(:goto, options.merge(parameter: label))
-          end
-
-          def nop(options = {})
-            add(:nop, options.merge(parameter: nil))
-          end
-
-          def set_device(options = {})
-            add(:set_device, options)
-          end
-
-          def set_error_bin(options = {})
-            add(:set_error_bin, options)
-          end
-
-          def enable_flow_word(word, options = {})
-            add(:enable_flow_word, options.merge(parameter: word))
-          end
-
-          def disable_flow_word(word, options = {})
-            add(:disable_flow_word, options.merge(parameter: word))
-          end
-
-          # All tests generated will not run unless the given enable word is asserted.
-          #
-          # This is specially implemented for J750 since it does not have a native
-          # support for flow word not enabled.
-          # It will generate a goto branch around the tests contained with the block
-          # if the given flow word is enabled.
-          def unless_enable(word, options = {})
-            if options[:or]
-              yield
-            else
-              @unless_enable_block = word
-              options = options.merge(unless_enable: word)
-              branch_unless_enabled(options.merge(_force_unless_enable: true)) do
-                yield
-              end
-              @unless_enable_block = nil
-            end
-          end
-          alias_method :unless_enabled, :unless_enable
-
-          def start_flow_branch(identifier, options = {})
-            goto(identifier, options)
-          end
-
-          def skip(identifier = nil, options = {})
-            identifier, options = nil, identifier if identifier.is_a?(Hash)
-            identifier = generate_unique_label(identifier)
-            goto(identifier, options)
-            yield
-            nop(label: identifier)
-          end
-
-          private
-
-          # If the test has an unless_enable then branch around it
-          def branch_unless_enabled(options)
-            word = options.delete(:unless_enable) || options.delete(:unless_enabled)
-            if word && (word != @unless_enable_block || options.delete(:_force_unless_enable))
-              # Not sure if this is really required, but duplicating these hashes here to ensure
-              # that all other flow context keys are preserved and applied to the branch lines
-              orig_options = options.merge({})
-              close_options = options.merge({})
-              label = generate_unique_label
-              goto(label, options.merge(if_enable: word))
-              yield orig_options
-              nop(close_options.merge(label: label))
-            else
-              yield options
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/j750/generator/flow_line.rb

@@ -1,288 +0,0 @@
-module Origen
-  module Tester
-    class J750
-      module Generator
-        class FlowLine
-          attr_accessor :type, :id, :cz_setup # cz_setup is a virtual attrib since it is not part of the regular flow line
-          # cz_setup combine with instance name when characterize opcode is used
-
-          # Attributes for each flow line, these must be declared in the order they are to be output
-          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
-                  )
-
-          # Map any aliases to the official names here, multiple aliases for a given attribute
-          # are allowed
-          ALIASES = {
-            bin:            :bin_fail,
-            softbin:        :sort_fail,
-            soft_bin:       :sort_fail,
-            name:           :tname,
-            number:         :tnum,
-            if_enable:      :enable,
-            if_enabled:     :enable,
-            enabled:        :enable,
-            # Aliases can also be used to set defaults on multiple attributes like this,
-            # use :value to refer to the value passed in to the given alias
-            flag_false:     { device_condition: 'flag-false',
-                              device_name:      :value
-                           },
-            flag_true:      { device_condition: 'flag-true',
-                              device_name:      :value
-                           },
-            flag_false_any: { group_specifier: 'any-active',
-                              group_condition: 'flag-false',
-                              group_name:      :value
-                               },
-            flag_false_all: { group_specifier: 'all-active',
-                              group_condition: 'flag-false',
-                              group_name:      :value
-                               },
-            flag_true_any:  { group_specifier: 'any-active',
-                              group_condition: 'flag-true',
-                              group_name:      :value
-                              },
-            flag_true_all:  { group_specifier: 'all-active',
-                              group_condition: 'flag-true',
-                              group_name:      :value
-                              },
-            flag_clear:     { device_condition: 'flag-clear',
-                              device_name:      :value
-                           }
-          }
-
-          # Assign attribute defaults here, generally this should match whatever defaults
-          # Teradyne has set whenever you create a new test instance, etc.
-          DEFAULTS = {
-            test:              {
-              opcode: 'Test',
-              result: 'Fail'
-            },
-            cz:                {
-              opcode: 'characterize',
-              result: 'None'
-            },
-            goto:              {
-              opcode: 'goto'
-            },
-            nop:               {
-              opcode: 'nop'
-            },
-            set_device:        {
-              opcode: 'set-device'
-            },
-            set_error_bin:     {
-              opcode: 'set-error-bin'
-            },
-            enable_flow_word:  {
-              opcode: 'enable-flow-word'
-            },
-            disable_flow_word: {
-              opcode: 'disable-flow-word'
-            },
-            logprint:          {
-              opcode: 'logprint'
-            }
-          }
-
-          # Generate accessors for all attributes and their aliases
-          ATTRS.each do |attr|
-            attr_accessor attr.to_sym
-          end
-
-          ALIASES.each do |_alias, val|
-            if val.is_a? Hash
-              define_method("#{_alias}=") do |v|
-                val.each do |k, _v|
-                  myval = _v == :value ? v : _v
-                  send("#{k}=", myval)
-                end
-              end
-            else
-              define_method("#{_alias}=") do |v|
-                send("#{val}=", v)
-              end
-              define_method("#{_alias}") do
-                send(val)
-              end
-            end
-          end
-
-          def initialize(type, attrs = {})
-            @ignore_missing_instance = attrs.delete(:instance_not_available)
-            self.cz_setup = attrs.delete(:cz_setup)
-            @type = type
-            # Set the defaults
-            DEFAULTS[@type.to_sym].each do |k, v|
-              send("#{k}=", v) if self.respond_to?("#{k}=")
-            end
-            # Then the values that have been supplied
-            attrs.each do |k, v|
-              send("#{k}=", v) if self.respond_to?("#{k}=")
-            end
-          end
-
-          def parameter=(value)
-            if (@type == :test || @test == :cz) && !@ignore_missing_instance
-              if value.is_a?(String) || value.is_a?(Symbol)
-                fail "You must supply the actual test instance object for #{value} when adding it to the flow"
-              end
-            end
-            @parameter = value
-          end
-
-          def parameter
-            # When referring to the test instance take the opportunity to refresh the current
-            # version of the test instance
-            @parameter = Origen.interface.identity_map.current_version_of(@parameter)
-          end
-
-          # Returns the fully formatted flow line for insertion into a flow sheet
-          def to_s
-            l = "\t"
-            ATTRS.each do |attr|
-              if attr == 'parameter'
-                ins = parameter
-                if ins.respond_to?(:name)
-                  l += "#{ins.name}"
-                else
-                  l += "#{ins}"
-                end
-                if cz_setup
-                  l += " #{cz_setup}\t"
-                else
-                  l += "\t"
-                end
-              else
-                l += "#{send(attr)}\t"
-              end
-            end
-            "#{l}"
-          end
-
-          def job
-            if !if_jobs.empty? && !unless_jobs.empty?
-              fail "Both if and unless jobs have been defined for test: #{parameter}"
-            elsif !if_jobs.empty?
-              if_jobs.join(',')
-            elsif !unless_jobs.empty?
-              unless_jobs.map { |j| "!#{j}" }.join(',')
-            else
-              ''
-            end
-          end
-          alias_method :jobs, :job
-
-          def unless_enable=(*_args)
-          end
-          alias_method :unless_enabled=, :unless_enable=
-
-          def if_jobs
-            @if_jobs ||= []
-          end
-
-          def unless_jobs
-            @unless_jobs ||= []
-          end
-
-          def if_job=(jobs)
-            [jobs].flatten.compact.each do |job|
-              job = job.to_s.upcase
-              if job =~ /!/
-                self.unless_job = job
-              else
-                if_jobs << job unless if_jobs.include?(job)
-              end
-            end
-          end
-          alias_method :if_jobs=, :if_job=
-          alias_method :add_if_jobs, :if_job=
-          alias_method :add_if_job, :if_job=
-
-          def unless_job=(jobs)
-            [jobs].flatten.compact.each do |job|
-              job = job.to_s.upcase
-              job.gsub!('!', '')
-              unless_jobs << job unless unless_jobs.include?(job)
-            end
-          end
-          alias_method :unless_jobs=, :unless_job=
-          alias_method :add_unless_jobs, :unless_job=
-          alias_method :add_unless_job, :unless_job=
-
-          def continue_on_fail
-            self.result = 'None'
-          end
-
-          def continue_pass
-            self.result = 'Pass'
-          end
-
-          def debug_assume_pass
-            self.debug_assume = 'Pass'
-          end
-
-          def debug_assume_fail
-            self.debug_assume = 'Fail'
-          end
-
-          #          def debug_sites
-          #            self.debug_sites = "All"
-          #          end
-
-          def set_flag_on_fail
-            self.flag_fail = "#{id}_FAILED"
-          end
-
-          def set_flag_on_pass
-            self.flag_pass = "#{id}_PASSED"
-          end
-
-          def set_flag_on_ran
-            self.flag_pass = "#{id}_RAN"
-          end
-
-          def run_if_any_passed(parent)
-            parent.continue_on_fail
-            self.flag_true_any = parent.set_flag_on_pass
-          end
-
-          def run_if_all_passed(parent)
-            parent.continue_on_fail
-            self.flag_true_all = parent.set_flag_on_pass
-          end
-
-          def run_if_any_failed(parent)
-            parent.continue_on_fail
-            self.flag_true_any = parent.set_flag_on_fail
-          end
-
-          def run_if_all_failed(parent)
-            parent.continue_on_fail
-            self.flag_true_all = parent.set_flag_on_fail
-          end
-
-          def id
-            @id || "#{parameter}_#{unique_counter}"
-          end
-
-          def unique_counter
-            @unique_counter ||= self.class.unique_counter
-          end
-
-          def self.unique_counter
-            @ix ||= -1
-            @ix += 1
-          end
-
-          def test?
-            @type == :test
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/j750/generator/patgroup.rb

@@ -1,111 +0,0 @@
-module Origen
-  module Tester
-    class J750
-      module Generator
-        class Patgroup
-          attr_accessor :index
-
-          class Pattern
-            ATTRS = %w(group_name pattern_file comment)
-
-            ALIASES = {
-              pattern: :pattern_file
-            }
-
-            DEFAULTS = {
-            }
-
-            # Generate accessors for all attributes and their aliases
-            ATTRS.each do |attr|
-              attr_accessor attr.to_sym
-            end
-
-            ALIASES.each do |_alias, val|
-              define_method("#{_alias}=") do |v|
-                send("#{val}=", v)
-              end
-              define_method("#{_alias}") do
-                send(val)
-              end
-            end
-
-            def initialize(patgroup, attrs = {})
-              # Set the defaults
-              DEFAULTS.each do |k, v|
-                send("#{k}=", v)
-              end
-              # Then the values that have been supplied
-              self.group_name = patgroup
-              attrs.each do |k, v|
-                send("#{k}=", v)
-              end
-            end
-
-            def to_s
-              l = "\t"
-              ATTRS.each do |attr|
-                l += "#{send(attr)}\t"
-              end
-              "#{l}"
-            end
-          end
-
-          # Specify multiple patterns by passing an array of attributes
-          # as the 2nd argument:
-          #
-          #   Patset.new("mrd1_pgrp", :pattern => "nvm_mrd1.PAT")
-          #
-          #   Patset.new("mrd1_pgrp", [{:pattern => "nvm_mrd1.PAT"},
-          #                            {:pattern => "nvm_global_subs.PAT},
-          #                           ])
-          def initialize(name, attrs = {})
-            attrs = [attrs] unless attrs.is_a? Array
-            attrs.each do |pattrs|
-              if pattrs[:pattern]
-                pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
-                Origen.interface.referenced_patterns << pat
-              end
-              lines << Pattern.new(name, pattrs)
-            end
-            self.name = name
-          end
-
-          def ==(other_patgroup)
-            self.class == other_patgroup.class &&
-              name.to_s == other_patgroup.name.to_s &&
-              sorted_pattern_files == other_patgroup.sorted_pattern_files
-          end
-
-          def name
-            @name
-          end
-
-          def name=(n)
-            @name = n
-            lines.each { |l| l.group_name = n }
-            n
-          end
-
-          # Returns all lines in the pattern set
-          def lines
-            @lines ||= []
-          end
-
-          # Returns all pattern files in the pattern set in alphabetical order
-          def sorted_pattern_files
-            @lines.map(&:file_name).sort
-          end
-
-          # Returns the fully formatted pattern group for insertion into a patgroups sheet
-          def to_s
-            l = ''
-            lines.each do |line|
-              l += "#{line}\r\n"
-            end
-            l.chomp
-          end
-        end
-      end
-    end
-  end
-end