origen_testers 0.5.7 → 0.6.0

data/lib/origen_testers/origen_ext/generator/flow.rb

@@ -0,0 +1,70 @@
+# This shim is temporary to help NXP transition to Origen from
+# our original internal version (RGen)
+if defined? RGen::ORIGENTRANSITION
+  require 'rgen/generator/flow'
+else
+  require 'origen/generator/flow'
+end
+module Origen
+  class Generator
+    class Flow
+      alias_method :orig_create, :create
+
+      # Create a call stack of flows so that we can work out where the nodes
+      # of the ATP AST originated from
+      def create(options = {}, &block)
+        file, line = *caller[0].split(':')
+        OrigenTesters::Flow.callstack << file
+        flow_comments, comments = *_extract_comments(OrigenTesters::Flow.callstack.last, line.to_i)
+        OrigenTesters::Flow.comment_stack << comments
+        if OrigenTesters::Flow.flow_comments
+          top = false
+          name = options[:name] || Pathname.new(file).basename('.rb').to_s.sub(/^_/, '')
+          Origen.interface.flow.group(name, description: flow_comments) do
+            orig_create(options, &block)
+          end
+        else
+          OrigenTesters::Flow.flow_comments = flow_comments
+          if options.key?(:unique_ids)
+            OrigenTesters::Flow.unique_ids = options.delete(:unique_ids)
+          else
+            OrigenTesters::Flow.unique_ids = true
+          end
+          top = true
+          orig_create(options, &block)
+        end
+        OrigenTesters::Flow.callstack.pop
+        OrigenTesters::Flow.comment_stack.pop
+        OrigenTesters::Flow.flow_comments = nil if top
+      end
+
+      def _extract_comments(file, flow_line)
+        flow_comments = []
+        comments = {}
+        comment = nil
+        File.readlines(file).each_with_index do |line, i|
+          if comment
+            if line =~ /^\s*#-(.*)/
+              # Nothing, just ignore but keep the comment open
+            elsif line =~ /^\s*#(.*)/
+              comment << Regexp.last_match(1).strip
+            else
+              comment = nil
+            end
+          else
+            if line =~ /^\s*#[^-](.*)/
+              if i < flow_line
+                comment = flow_comments
+              else
+                comment = []
+                comments[i + 1] = comment
+              end
+              comment << Regexp.last_match(1).strip
+            end
+          end
+        end
+        [flow_comments, comments]
+      end
+    end
+  end
+end

data/lib/origen_testers/origen_ext/generator/resources.rb

@@ -0,0 +1,21 @@
+# This shim is temporary to help NXP transition to Origen from
+# our original internal version (RGen)
+if defined? RGen::ORIGENTRANSITION
+  require 'rgen/generator/resources'
+else
+  require 'origen/generator/resources'
+end
+module Origen
+  class Generator
+    class Resources
+      alias_method :orig_create, :create
+
+      # Patching to make resources_mode apply much earlier
+      def create(options = {}, &block)
+        OrigenTesters::Interface.with_resources_mode do
+          orig_create(options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/program_generators.rb

@@ -12,7 +12,6 @@ module OrigenTesters
 
     included do
       Origen.add_interface(self)
-      include Generator::FlowControlAPI::Interface
     end
 
     module ClassMethods

data/lib/origen_testers/smartest_based_tester/base/flow.rb

@@ -1,11 +1,10 @@
 module OrigenTesters
   module SmartestBasedTester
     class Base
-      class Flow
-        include OrigenTesters::Generator
-        include OrigenTesters::Generator::FlowControlAPI
+      class Flow < ATP::Formatter
+        include OrigenTesters::Flow
 
-        attr_accessor :test_suites, :test_methods, :pattern_master
+        attr_accessor :test_suites, :test_methods, :pattern_master, :lines, :stack
 
         def subdirectory
           'testflow'
@@ -15,172 +14,197 @@ module OrigenTesters
           super.gsub('_flow', '')
         end
 
+        def hardware_bin_descriptions
+          @hardware_bin_descriptions ||= {}
+        end
+
+        def flow_control_variables
+          @flow_control_variables ||= []
+        end
+
+        def runtime_control_variables
+          @runtime_control_variables ||= []
+        end
+
         def finalize(options = {})
           super
-          flow_control_variables.uniq!
-          collection.each { |n| n.finalize if n.respond_to?(:finalize) }
           test_suites.finalize
           test_methods.finalize
+          @indent = 0
+          @lines = []
+          @stack = { on_fail: [], on_pass: [] }
+          process(model.ast)
+          flow_control_variables.uniq!
+          runtime_control_variables.uniq!
         end
 
-        # Convenience method that will automatically generate a run and branch if a :bin
-        # option is supplied. If no :bin option is present then it will generate a simple
-        # run entry in the flow.
-        def test(test_suite, options = {})
-          sbin = options[:sbin] || options[:softbin] || options[:soft_bin]
-          if (options[:bin] || sbin) && !options[:continue]
-            node = run_and_branch(test_suite, options)
-            options.delete(:id)
-            # Only pass options to configure the bin, don't pass flow control options, those apply to the main
-            # test only in this case
-            bin = bad_bin(options[:bin], options.slice(*(FlowNode::ATTRS[:bad_bin].keys + FlowNode::ALIASES[:bad_bin].keys)))
-            node.else_nodes << bin
-            node
-          else
-            run(test_suite, options)
-          end
+        def line(str)
+          @lines << (' ' * @indent * 2) + str
         end
 
-        # This module contains methods that correspond to the test flow primitives available
-        # in the palette window of the test flow editor
-        module Palette
-          def run(test_suite, options = {})
-            add(:run, { test_suite: test_suite }.merge(options))
-          end
-          alias_method :run_test, :run
-
-          def run_and_branch(test_suite, options = {})
-            add(:run_and_branch, { test_suite: test_suite }.merge(options))
-          end
-
-          def good_bin(number, options = {})
-            add(:good_bin, { bin: number }.merge(options))
-          end
-
-          def bad_bin(number, options = {})
-            add(:bad_bin, { bin: number }.merge(options))
-          end
-
-          def multi_bin(number, options = {})
-            fail 'V93K Flow#multi_bin method has not been implemented yet!'
-          end
-
-          def print(msg, options = {})
-            add(:print, { value: msg }.merge(options))
+        def on_test(node)
+          name = node.find(:object).to_a[0]
+          name = name.name unless name.is_a?(String)
+          if node.children.any? { |n| t = n.try(:type); t == :on_fail || t == :on_pass }
+            line "run_and_branch(#{name})"
+            process_all(node.to_a.reject { |n| t = n.try(:type); t == :on_fail || t == :on_pass })
+            line 'then'
+            line '{'
+            @indent += 1
+            on_pass = node.children.find { |n| n.try(:type) == :on_pass }
+            if on_pass
+              process_all(on_pass)
+              stack[:on_pass].each { |n| process_all(n) }
+            end
+            @indent -= 1
+            line '}'
+            line 'else'
+            line '{'
+            @indent += 1
+            on_fail = node.children.find { |n| n.try(:type) == :on_fail }
+            if on_fail
+              with_continue(on_fail.children.any? { |n| n.try(:type) == :continue }) do
+                process_all(on_fail)
+                stack[:on_fail].each { |n| process_all(n) }
+              end
+            end
+            @indent -= 1
+            line '}'
+          else
+            line "run(#{name});"
           end
+        end
 
-          def print_to_datalog(msg, options = {})
-            add(:print_to_datalog, { value: msg }.merge(options))
-          end
+        def on_job(node)
+          jobs, state, *nodes = *node
+          jobs = clean_job(jobs)
+          flow_control_variables << 'JOB'
+          condition = jobs.join(' or ')
+          line "if #{condition} then"
+          line '{'
+          @indent += 1
+          process_all(node) if state
+          @indent -= 1
+          line '}'
+          line 'else'
+          line '{'
+          @indent += 1
+          process_all(node) unless state
+          @indent -= 1
+          line '}'
+        end
 
-          def assign_value(variable, value, options = {})
-            add(:assign_value, { variable: variable, value: value }.merge(options))
-          end
+        def on_condition_flag(node)
+          flag, state, *nodes = *node
+          if flag.is_a?(Array)
+            condition = flag.map { |f| "@#{f.upcase} == 1" }.join(' or ')
+          else
+            condition = "@#{flag.upcase} == 1"
+          end
+          line "if #{condition} then"
+          line '{'
+          @indent += 1
+          process_all(nodes) if state
+          @indent -= 1
+          line '}'
+          line 'else'
+          line '{'
+          @indent += 1
+          process_all(nodes) unless state
+          @indent -= 1
+          line '}'
+        end
 
-          def if_then(condition, options = {})
-            add(:if_then, { condition: condition }.merge(options))
+        def on_flow_flag(node)
+          flag, state, *nodes = *node
+          [flag].flatten.each do |f|
+            flow_control_variables << f.upcase
           end
+          on_condition_flag(node)
+        end
 
-          def group(name, options = {})
-            name = make_unique(:group, name)
-            g = add(:group, { name: name }.merge(options))
-            if block_given?
-              open_groups << g
-              yield g
-              open_groups.pop
-            end
-            g
+        def on_run_flag(node)
+          flag, state, *nodes = *node
+          [flag].flatten.each do |f|
+            runtime_control_variables << f.upcase
           end
+          on_condition_flag(node)
         end
-        include Palette
 
-        # Convenience method to provide similar functionality to enabling a Teradyne flow word/variable
-        def enable_flow_word(variable, options = {})
-          assign_value(variable, 1, options)
+        def on_enable_flow_flag(node)
+          flag = node.value.upcase
+          flow_control_variables << flag
+          line "@#{flag} = 1;"
         end
 
-        def skip(identifier = nil, options = {})
-          identifier, options = nil, identifier if identifier.is_a?(Hash)
-          open_skips << []
-          yield
-          nodes = open_skips.pop
-          s = if_then(:skip, options)
-          s.else_nodes = nodes
+        def on_disable_flow_flag(node)
+          flag = node.value.upcase
+          flow_control_variables << flag
+          line "@#{flag} = 0;"
         end
 
-        def hardware_bin_descriptions
-          @hardware_bin_descriptions ||= {}
+        def on_set_run_flag(node)
+          flag = node.value.upcase
+          runtime_control_variables << flag
+          line "@#{flag} = 1;"
         end
 
-        def flow_control_variables
-          @flow_control_variables ||= []
+        def on_group(node)
+          on_fail = node.children.find { |n| n.try(:type) == :on_fail }
+          on_pass = node.children.find { |n| n.try(:type) == :on_pass }
+          with_continue(on_fail && on_fail.children.any? { |n| n.try(:type) == :continue }) do
+            line '{'
+            @indent += 1
+            stack[:on_fail] << on_fail if on_fail
+            stack[:on_pass] << on_pass if on_pass
+            process_all(node.children - [on_fail, on_pass])
+            stack[:on_fail].pop if on_fail
+            stack[:on_pass].pop if on_pass
+            @indent -= 1
+            line "}, open,\"#{unique_group_name(node.find(:name).value)}\", \"\""
+          end
         end
 
-        private
-
-        def add(type, options = {})
-          options = save_context(options) if [:run, :run_and_branch].include?(type)
-
-          # Delete the ID if a test within a group with the same ID to avoid a duplicate ID
-          # error.
-          if options[:id]
-            id = Origen.interface.filter_id(options[:id], options)
-            options.delete(:id) if group_opened? && open_groups.any? { |g| g.id == id }
-          end
-          node = track_relationships(options) do |options|
-            platform::FlowNode.create(self, type, options)
-          end
-          unless Origen.interface.resources_mode?
-            if skip_opened?
-              open_skips.last << node
-              node.parent = open_skips.last
-            else
-              if group_opened?
-                open_groups.last.nodes << node
-                node.parent = open_groups.last.nodes
-              else
-                collection << node
-              end
+        def on_set_result(node)
+          unless @continue
+            bin = node.find(:bin).try(:value)
+            sbin = node.find(:softbin).try(:value)
+            desc = node.find(:bin_description).try(:value)
+            if bin && desc
+              hardware_bin_descriptions[bin] ||= desc
             end
-          end
-          if node.test?
-            node.test_suite = options[:test_suite]
-            c = Origen.interface.consume_comments
-            unless Origen.interface.resources_mode?
-              Origen.interface.descriptions.add_for_test_usage(node.test_suite.name, Origen.interface.top_level_flow, c)
+            if node.to_a[0] == 'pass'
+              line "stop_bin \"#{sbin}\", \"\", , good, noreprobe, green, #{bin}, over_on;"
+            else
+              line "stop_bin \"#{sbin}\", \"fail\", , bad, noreprobe, red, #{bin}, over_on;"
             end
-          else
-            Origen.interface.discard_comments
           end
-          node
-        end
-
-        def open_skips
-          @open_skips ||= []
         end
 
-        def skip_opened?
-          open_skips.size > 0
+        def on_log(node)
+          line "print_dl(\"#{node.to_a[0]}\");"
         end
 
-        def open_groups
-          @open_groups ||= []
+        def unique_group_name(name)
+          @group_names ||= {}
+          if @group_names[name]
+            @group_names[name] += 1
+            "#{name}_#{@group_names[name]}"
+          else
+            @group_names[name] = 1
+            name
+          end
         end
 
-        def group_opened?
-          open_groups.size > 0
+        def clean_job(job)
+          [job].flatten.map { |j| "@JOB == \"#{j.to_s.upcase}\"" }
         end
 
-        def make_unique(type, name, options = {})
-          @uniques ||= {}
-          t = @uniques[type] ||= {}
-          t[name] ||= 0
-          t[name] += 1
-          if t[name] == 1
-            name
-          else
-            "#{name}_#{t[name]}"
-          end
+        def with_continue(value)
+          orig = @continue
+          @continue = true if value
+          yield
+          @continue = orig
         end
       end
     end

data/lib/origen_testers/smartest_based_tester/base/generator.rb

@@ -26,6 +26,7 @@ module OrigenTesters
 
         # @api private
         def at_flow_start
+          flow.at_flow_start
         end
 
         # @api private
@@ -40,9 +41,7 @@ module OrigenTesters
 
         def flow(filename = Origen.file_handler.current_file.basename('.rb').to_s)
           f = filename.to_sym
-          if Origen.interface.resources_mode?
-            f = f.to_s.sub(/_resources?/, '').to_sym
-          end
+          f = f.to_s.sub(/_resources?/, '').to_sym
           return flow_sheets[f] if flow_sheets[f] # will return flow if already existing
           p = platform::Flow.new
           p.inhibit_output if Origen.interface.resources_mode?