origen_testers 0.40.0 → 0.41.0

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

@@ -11,6 +11,9 @@ module Origen
       # 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)
+        options = {
+          reload_target: true
+        }.merge(options)
         # Patch for Windows operation since the path can start with something like "C:/"
         if caller[0] =~ /(:(\/|\\))/
           orig_separator = Regexp.last_match(1)
@@ -89,10 +92,9 @@ module Origen
 
       # @api private
       def _create(options = {}, &block)
-        # Refresh the target to start all settings from scratch each time
-        # This is an easy way to reset all registered values
-        Origen.app.reload_target!
-        Origen.tester.generating = :program
+        options = {
+          reload_target: true
+        }.merge(options)
         # Make the top level flow globally available, this helps to assign test descriptions
         # to the correct flow whenever tests are instantiated from sub-flows
         if Origen.interface_loaded? && Origen.interface.top_level_flow
@@ -106,6 +108,10 @@ module Origen
         job.output_file_body = options.delete(:name).to_s if options[:name]
         if sub_flow
           interface = Origen.interface
+          if reload_target?(interface, options)
+            Origen.app.reload_target!
+            Origen.tester.generating = :program
+          end
           opts = Origen.generator.option_pipeline.pop || {}
           Origen.interface.startup(options) if Origen.interface.respond_to?(:startup)
           interface.instance_exec(opts, &block)
@@ -117,6 +123,10 @@ module Origen
         else
           Origen.log.info "Generating... #{Origen.file_handler.current_file.basename}"
           interface = Origen.reset_interface(options)
+          if reload_target?(interface, options)
+            Origen.app.reload_target!
+            Origen.tester.generating = :program
+          end
           Origen.interface.set_top_level_flow
           Origen.interface.flow_generator.set_flow_description(Origen.interface.consume_comments)
           options[:top_level] = true
@@ -171,6 +181,24 @@ module Origen
         end
         [flow_comments, comments]
       end
+
+      private
+
+      def reload_target?(interface, options)
+        if interface.respond_to?(:reload_target)
+          # If the test interface cares about reloading the target,
+          # it can veto the default behavior of reloading the target
+          if interface.reload_target && options[:reload_target]
+            true
+          else
+            false
+          end
+        elsif options[:reload_target]
+          true
+        else
+          false
+        end
+      end
     end
   end
 

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

@@ -5,6 +5,15 @@ module OrigenTesters
       class Flow < ATP::Formatter
         include OrigenTesters::Flow
 
+        RELATIONAL_OPERATOR_STRINGS = {
+          eq: '==',
+          ne: '!=',
+          gt: '>',
+          ge: '>=',
+          lt: '<',
+          le: '<='
+        }
+
         attr_accessor :test_suites, :test_methods, :lines, :stack, :var_filename
         # Returns an array containing all runtime variables which get set by the flow
         attr_reader :set_runtime_variables
@@ -424,6 +433,72 @@ module OrigenTesters
         end
         alias_method :on_unless_flag, :on_if_flag
 
+        def on_whenever(node)
+          expressions, *nodes = *node
+
+          case node.type
+          when :whenever_all
+            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(' and ')
+          when :whenever_any
+            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(' or ')
+          else
+            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join('ERROR')
+          end
+
+          line "if #{condition} then"
+          line '{'
+          @indent += 1
+          process_all(node.children)
+          @indent -= 1
+          line '}'
+          line 'else'
+          line '{'
+          line '}'
+        end
+        alias_method :on_whenever_any, :on_whenever
+        alias_method :on_whenever_all, :on_whenever
+
+        def generate_expr_string(node, options = {})
+          return node unless node.respond_to?(:type)
+          case node.type
+          when :eq, :ne, :gt, :ge, :lt, :le
+            result = "#{generate_expr_term(node.to_a[0])} "             # operand 1
+            result += "#{RELATIONAL_OPERATOR_STRINGS[node.type]} "      # relational condition
+            result += "#{generate_expr_term(node.to_a[1])}"             # operand 2
+            result
+          else
+            fail "Relational operator '#{node.type}' not  supported"
+          end
+        end
+
+        def generate_expr_term(val)
+          return val if val.is_a?(Fixnum) || val.is_a?(Integer) || val.is_a?(Float)
+          case val[0]
+          when '$'
+            if smt8?
+              "#{val[1..-1]}"
+            else
+              "@#{val[1..-1]}"
+            end
+          else
+            if val.is_a? String
+              "\"#{val}\""
+            else
+              val
+            end
+          end
+        end
+
+        def on_set(node)
+          flag = generate_flag_name(node.to_a[0])
+          val = generate_expr_term(node.to_a[1])
+          if smt8?
+            line "#{flag} = #{val};"
+          else
+            line "@#{flag} = #{val};"
+          end
+        end
+
         def on_enable(node)
           flag = node.value.upcase
           if smt8?

data/lib/origen_testers/smartest_based_tester/base/processors/extract_flow_vars.rb

@@ -21,7 +21,12 @@ module OrigenTesters
             process(node)
             OWNERS.each do |t|
               CATEGORIES.each do |c|
-                @variables[t][c] = @variables[t][c].to_a.sort do |x, y|
+                curr_vars = @variables[t][c].to_a.dup
+                flag_classes = curr_vars.map(&:class)
+                if flag_classes.include?(String) && flag_classes.include?(Symbol)
+                  curr_vars.map!(&:to_s)
+                end
+                @variables[t][c] = curr_vars.sort do |x, y|
                   x = x[0] if x.is_a?(Array)
                   y = y[0] if y.is_a?(Array)
                   x <=> y
@@ -82,6 +87,11 @@ module OrigenTesters
           end
           alias_method :on_disable, :on_enable
 
+          def on_set(node)
+            flag = generate_flag_name(node.to_a[0])
+            add flag, :set_enables
+          end
+
           private
 
           def in_sub_flow?

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

@@ -29,6 +29,7 @@ module OrigenTesters
           @parameters = {}
           @limits_id = options[:methods].delete(:limits_id) || options[:methods].delete(:limit_id)
           @limits = TestMethods::Limits.new(self)
+          @limits.render = false if options[:methods].delete(:render_limits_in_tf) == false
           # Add any methods
           if options[:methods][:methods]
             methods = options[:methods][:methods]