origen_testers 0.51.4 → 0.52.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09276262e65db795a4ffe2fe26e6836607fd2c75bf279d652baacc35c3fdcdf4'
-  data.tar.gz: 3216437c32107ef156b639005c153529ee19d53871a2330f62c0a2816f17caa2
+  metadata.gz: 806f6c174a2b26a0ead003ab2a26ad6874ab43ceaeb1f72b90183f0c549f0b0f
+  data.tar.gz: 997ca9d806de6b205cf98013f9260b5b44e2e0a82dda42b2aa98020a9a9c961c
 SHA512:
-  metadata.gz: 5bdb430e032bdf00efb5f4c67b9b18c5c4f3fae20d5413c48f31052d99560f42a9d18bcabe291bf3223f067abb34eeb857813f73c05fa40a2180e3ef2c728ed6
-  data.tar.gz: 17d7dbe630c36fba16baa9154d976a628899587632ad8d3b4ecd7edcb4283e127c09e82cd9cb5891ce7b4a2e939a82a1c18bafc82dd98e6a9ebcfca0f3b3e69d
+  metadata.gz: 79ade702c6acb3876aa888ca66570afea165a48a52c08fb0d19f41707f0f02a6c32151d694fd4d4a4cbff45dd1b53c73ca27c5e2e56bd733a48975452a4f8f66
+  data.tar.gz: d84b6632197fb9305b4fb7032eecf5620a424fb292ab46c6b24376116f7701aff2dabeec31a11c5b18214285adbfab98fc38f739a720c62feb9494389c2ff2f3

data/config/commands.rb

@@ -200,7 +200,7 @@ when "examples", "test"
     puts
     puts "To approve any diffs in the reference.list files run the following command:"
     puts
-    platforms = %w(j750 j750_literals j750_hpt ultraflex ultraflex_literals v93k v93k_multiport v93k_enable_flow v93k_disable_flow v93k_limits_file v93k_global v93k_smt8) # put here the various platforms used in examples/program_generator.rb
+    platforms = %w(j750 j750_literals j750_hpt ultraflex ultraflex_literals v93k v93k_multiport v93k_enable_flow v93k_disable_flow v93k_limits_file v93k_global v93k_smt8 v93k_flowgrouping) # put here the various platforms used in examples/program_generator.rb
     reflist_command = ''
     platforms.each do |platform|
       unless reflist_command == ''

data/config/version.rb

@@ -1,7 +1,7 @@
 module OrigenTesters
   MAJOR = 0
-  MINOR = 51
-  BUGFIX = 4
+  MINOR = 52
+  BUGFIX = 0
   DEV = nil
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
 end

data/lib/origen_testers/atp/flow.rb

@@ -479,6 +479,21 @@ module OrigenTesters::ATP
       end
     end
 
+    def add_auxiliary_flow(name, options = {})
+      if tester.smt8?
+        if name.to_s != options[:path].split('.').last.to_s
+          fail "Auxiliary flow path does not end in '#{name}'. The path instead is '#{options[:path]}'. Please update the path to align with the provided name."
+        end
+        extract_meta!(options) do
+          apply_conditions(options) do
+            n2(:auxiliary_flow, n1(:name, name), n1(:path, options[:path]))
+          end
+        end
+      else
+        fail 'Auxiliary flow API is only usable in SMT8.'
+      end
+    end
+
     def bin(number, options = {})
       if number.is_a?(Hash)
         fail 'The bin number must be passed as the first argument'
@@ -547,6 +562,22 @@ module OrigenTesters::ATP
       end
     end
 
+    def unset_flag(flag, options = {})
+      extract_meta!(options) do
+        apply_conditions(options) do
+          unset_flag_node(flag)
+        end
+      end
+    end
+
+    def add_flag(flag, options = {})
+      extract_meta!(options) do
+        apply_conditions(options) do
+          add_flag_node(flag)
+        end
+      end
+    end
+
     def set(var, val, options = {})
       extract_meta!(options) do
         apply_conditions(options) do
@@ -938,6 +969,14 @@ module OrigenTesters::ATP
       n1(:set_flag, flag)
     end
 
+    def unset_flag_node(flag)
+      n1(:unset_flag, flag)
+    end
+
+    def add_flag_node(flag)
+      n1(:add_flag, flag)
+    end
+
     # Ensures the flow ast has a volatile node, then adds the
     # given flags to it
     def add_volatile_flags(node, flags)

data/lib/origen_testers/atp/flow_api.rb

@@ -8,8 +8,8 @@ module OrigenTesters::ATP
       @atp
     end
 
-    ([:test, :bin, :pass, :continue, :cz, :log, :sub_test, :volatile, :add_global_flag, :set_flag, :set, :enable, :disable, :render,
-      :context_changed?, :ids, :describe_bin, :describe_softbin, :describe_soft_bin, :loop] +
+    ([:test, :bin, :pass, :continue, :cz, :log, :sub_test, :volatile, :add_global_flag, :set_flag, :unset_flag, :add_flag, :set, :enable, :disable, :render,
+      :context_changed?, :ids, :describe_bin, :describe_softbin, :describe_soft_bin, :loop, :add_auxiliary_flow] +
       OrigenTesters::ATP::Flow::CONDITION_KEYS.keys + OrigenTesters::ATP::Flow::RELATIONAL_OPERATORS).each do |method|
       define_method method do |*args, &block|
         options = args.pop if args.last.is_a?(Hash)

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

@@ -50,7 +50,12 @@ module OrigenTesters
                 parents.unshift(File.basename(f.filename, '.*').to_s.downcase)
                 f = f.parent
               end
-              File.join tester.package_namespace, 'flows', *parents
+              # need to variablize this for internal usage!!
+              if Origen.interface.respond_to?(:insertion)
+                File.join tester.package_namespace, Origen.interface.insertion.to_s, 'flows', *parents
+              else
+                File.join tester.package_namespace, 'flows', *parents
+              end
             else
               'testflow/mfh.testflow.group'
             end
@@ -447,17 +452,26 @@ module OrigenTesters
 
         def on_whenever(node)
           expressions, *nodes = *node
-
+          and_string = ' and '
+          or_string  = ' or '
+          if smt8?
+            and_string = ' && '
+            or_string  = ' || '
+          end
           case node.type
           when :whenever_all
-            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(' and ')
+            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(and_string)
           when :whenever_any
-            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(' or ')
+            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(or_string)
           else
             condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join('ERROR')
           end
 
-          line "if #{condition} then"
+          if smt8?
+            line "if (#{condition})"
+          else
+            line "if #{condition} then"
+          end
           line '{'
           @indent += 1
           process_all(node.children)
@@ -471,13 +485,23 @@ module OrigenTesters
         alias_method :on_whenever_all, :on_whenever
 
         def on_loop(node, options = {})
-          # TODO: don't have the SMT8 way to do this yet
-          if smt8?
-            fail 'Flow loop control not yet supported for SMT8!'
-          end
           start = node.to_a[0]
+          if start.is_a?(String)
+            start = generate_flag_name(start)
+            unless smt8?
+              start = "@#{start}"
+            end
+          end
           stop = node.to_a[1]
+          if stop.is_a?(String) && smt8?
+            stop = generate_flag_name(stop)
+          elsif stop.is_a?(String)
+            fail 'loops with \'stop\' defined as a variable cannot be supported in the defined environments.'
+          end
           step = node.to_a[2]
+          if smt8? && !(step == -1 || step == 1)
+            fail 'SMT8 does not support steps other than -1 or 1.'
+          end
           if node.to_a[3].nil?
             fail 'You must supply a loop variable name!'
           else
@@ -487,7 +511,7 @@ module OrigenTesters
           unless smt8?
             var = "@#{var}"
           end
-          num = (stop - start) / step + 1
+          # num = (stop - start) / step + 1
           # Handle increment/decrement
           if step < 0
             compare = '>'
@@ -496,13 +520,24 @@ module OrigenTesters
             compare = '<'
             incdec = "+ #{step}"
           end
-          line "for #{var} = #{start}; #{var} #{compare} #{stop + step} ; #{var} = #{var} #{incdec}; do"
-          line "test_number_loop_increment = #{test_num_inc}"
-          line '{'
-          @indent += 1
-          process_all(node.children)
-          @indent -= 1
-          line '}'
+          if tester.smt7?
+            line "for #{var} = #{start}; #{var} #{compare} #{stop + step} ; #{var} = #{var} #{incdec}; do"
+            line "test_number_loop_increment = #{test_num_inc}"
+            line '{'
+            @indent += 1
+            process_all(node.children)
+            @indent -= 1
+            line '}'
+          elsif smt8?
+            line "for (#{var} : #{start}..#{stop})"
+            line '{'
+            @indent += 1
+            process_all(node.children)
+            @indent -= 1
+            line '}'
+          else
+            fail 'Environment was not supported for flow loops.'
+          end
         end
 
         def generate_expr_string(node, options = {})
@@ -614,6 +649,15 @@ module OrigenTesters
           end
         end
 
+        def on_unset_flag(node)
+          flag = generate_flag_name(node.value)
+          if smt8?
+            line "#{flag} = 0;"
+          else
+            line "@#{flag} = 0;"
+          end
+        end
+
         # Note that for smt8?, this should never be hit anymore since groups are now generated as sub-flows
         def on_group(node)
           on_fail = node.children.find { |n| n.try(:type) == :on_fail }

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

@@ -88,7 +88,11 @@ module OrigenTesters
           return flow_sheets[id] if flow_sheets[id] # will return flow if already existing
           p = platform::Flow.new
           p.inhibit_output if Origen.interface.resources_mode?
-          p.filename = filename
+          if id == Origen.file_handler.current_file.basename('.rb').to_s && Origen.interface.try(:use_flow_name_for_top_level)
+            p.filename = Origen.interface.flow_name
+          else
+            p.filename = filename
+          end
           p.test_suites ||= platform::TestSuites.new(p)
           p.test_methods ||= platform::TestMethods.new(p)
           flow_sheets[id] = p

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

@@ -7,7 +7,8 @@ module OrigenTesters
         # and their default values
         class ExtractFlowVars < ATP::Processor
           OWNERS = [:all, :this_flow, :sub_flows]
-          CATEGORIES = [:jobs, :referenced_flags, :set_flags, :set_flags_extern,
+          CATEGORIES = [:jobs, :referenced_flags, :set_flags, :unset_flags, :add_flags,
+                        :set_flags_extern, :unset_flags_extern, :add_flags_extern,
                         :referenced_enables, :set_enables]
 
           def run(node, options = {})
@@ -72,6 +73,22 @@ module OrigenTesters
             end
           end
 
+          def on_unset_flag(node)
+            add generate_flag_name(node.value), :unset_flags
+            # Also separate flags which have been set and which should be externally visible
+            if !node.to_a.include?('auto_generated') || node.to_a.include?('extern')
+              add generate_flag_name(node.value), :unset_flags_extern
+            end
+          end
+
+          def on_add_flag(node)
+            add generate_flag_name(node.value), :add_flags
+            # Also separate flags which have been set and which should be externally visible
+            if !node.to_a.include?('auto_generated') || node.to_a.include?('extern')
+              add generate_flag_name(node.value), :add_flags_extern
+            end
+          end
+
           def on_if_enabled(node)
             flag, *nodes = *node
             [flag].flatten.each do |f|

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

@@ -2,7 +2,7 @@ module OrigenTesters
   module SmartestBasedTester
     class Base
       class TestMethod
-        FORMAT_TYPES = [:current, :voltage, :time, :string, :integer, :double, :boolean]
+        FORMAT_TYPES = [:current, :voltage, :time, :string, :integer, :double, :boolean, :class, :list_strings, :list_classes]
 
         # Returns the object representing the test method library that the
         # given test method is defined in
@@ -107,10 +107,20 @@ module OrigenTesters
               type = send(name)
             elsif respond_to?(name.sub(/b$/, ''))
               type = inverse_of(send(name.sub(/b$/, '')))
+            elsif parameters[attr].is_a?(Hash) || parameters[attr.to_sym].is_a?(Hash)
+              type = :hash
             else
               fail "Unknown attribute type: #{parameters[attr]}"
             end
           end
+          if val.nil? && !tester.print_all_params
+            nil
+          else
+            handle_val_type(val, type, attr)
+          end
+        end
+
+        def handle_val_type(val, type, attr)
           case type
           when :current, 'CURR'
             "#{val}[A]"
@@ -126,9 +136,9 @@ module OrigenTesters
             val
           when :boolean
             # Check for valid values
-            if [0, 1, true, false].include?(val)
+            if [0, 1, true, false, 'true', 'false'].include?(val)
               # Use true/false for smt8 and 0/1 for smt7
-              if [1, true].include?(val)
+              if [1, true, 'true'].include?(val)
                 tester.smt8? ? true : 1
               else
                 tester.smt8? ? false : 0
@@ -136,6 +146,18 @@ module OrigenTesters
             else
               fail "Unknown boolean value for attribute #{attr}: #{val}"
             end
+          when :hash, :class
+            val
+          when :list_strings
+            unless val.is_a?(Array)
+              fail "#{val} is not an Array. List_strings must have Array values"
+            end
+            "##{val}"
+          when :list_classes
+            unless val.is_a?(Array)
+              fail "#{val} is not an Array. List_classes must have Array values"
+            end
+            "##{val.to_s.gsub('"', '')}"
           else
             fail "Unknown type for attribute #{attr}: #{type}"
           end

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

@@ -48,7 +48,7 @@ module OrigenTesters
         # What SMT7 calls a declaration
         def declarations
           if variables
-            (variables[:all][:jobs] + variables[:all][:referenced_flags] + variables[:all][:set_flags]).uniq.sort do |x, y|
+            (variables[:all][:jobs] + variables[:all][:referenced_flags] + variables[:all][:set_flags] + variables[:all][:unset_flags] + variables[:all][:add_flags]).uniq.sort do |x, y|
               x = x[0] if x.is_a?(Array)
               y = y[0] if y.is_a?(Array)
               # Need to use strings for the comparison as some declarations can be a string and some a symbol

data/lib/origen_testers/smartest_based_tester/base.rb

@@ -19,6 +19,9 @@ module OrigenTesters
       # flow, the default value is :signature
       attr_reader :unique_test_names
 
+      # use flow variable grouping or not
+      attr_accessor :flow_variable_grouping
+
       # Returns the SMT version, defaults to 7
       attr_reader :smt_version
 
@@ -66,6 +69,8 @@ module OrigenTesters
       # defaults to the application's namespace if not defined (SMT8 only)
       attr_writer :package_namespace
 
+      attr_writer :spec_path, :seq_path
+
       # When set to true, the bins and softbins sheets from the limits spreadsheet will
       # be written out to a standalone (spreadsheet) file instead (SMT8 only)
       attr_accessor :separate_bins_file
@@ -74,6 +79,10 @@ module OrigenTesters
       # format (SMT8 only)
       attr_accessor :zip_patterns
 
+      # When set to true (the default), parameters will be generated in the flow file regardless if the default is selected
+      # (SMT8 only)
+      attr_accessor :print_all_params
+
       def initialize(options = {})
         options = {
           # whether to use multiport bursts or not, if so this indicates the name of the port to use
@@ -104,6 +113,7 @@ module OrigenTesters
         if smt8?
           @pat_extension = 'pat'
           @program_comment_char = ['println', '//']
+          @print_all_params = options[:print_all_params].nil? ? true : options[:print_all_params]
         else
           @pat_extension = 'avc'
           @program_comment_char = ['print_dl', '//']
@@ -135,15 +145,20 @@ module OrigenTesters
             @unique_test_names = :signature
           end
         end
-        if smt8?
-          @create_limits_file = true
+        if options.key?(:create_limits_file)
+          @create_limits_file = options[:create_limits_file]
         else
-          if options.key?(:create_limits_file)
-            @create_limits_file = options[:create_limits_file]
+          if smt8?
+            @create_limits_file = true
           else
             @create_limits_file = false
           end
         end
+
+        if options.key?(:flow_variable_grouping)
+          @flow_variable_grouping = options[:flow_variable_grouping]
+        end
+
         if options[:literal_flags]
           @literal_flags = true
         end
@@ -152,6 +167,8 @@ module OrigenTesters
         end
 
         @package_namespace = options.delete(:package_namespace)
+        @spec_path = options.delete(:spec_path)
+        @seq_path = options.delete(:seq_path)
         self.limitfile_test_modes = options[:limitfile_test_modes] || options[:limitsfile_test_modes]
         self.force_pass_on_continue = options[:force_pass_on_continue]
         self.delayed_binning = options[:delayed_binning]
@@ -167,6 +184,13 @@ module OrigenTesters
         @package_namespace || Origen.app.namespace
       end
 
+      def spec_path
+        @spec_path || 'specs'
+      end
+
+      def seq_path
+        @seq_path || 'specs'
+      end
       # Set the test mode(s) that you want to see in the limits files, supply an array of mode names
       # to set multiple.
       def limitfile_test_modes=(val)

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

@@ -4,6 +4,7 @@ module OrigenTesters
       require 'origen_testers/smartest_based_tester/base/flow'
       class Flow < Base::Flow
         TEMPLATE = "#{Origen.root!}/lib/origen_testers/smartest_based_tester/v93k_smt8/templates/template.flow.erb"
+        IN_IDENTIFIER = '_AUTOIN'
 
         def on_test(node)
           test_suite = node.find(:object).to_a[0]
@@ -93,18 +94,44 @@ module OrigenTesters
           @sub_flows ||= {}
           path = Pathname.new(node.find(:path).value)
           name = path.basename('.*').to_s
+          path = Origen.interface.sub_flow_path_overwrite(path) if Origen.interface.respond_to? :sub_flow_path_overwrite
           @sub_flows[name] = "#{path.dirname}.#{name}".gsub(/(\/|\\)/, '.')
           # Pass down all input variables before executing
+          if sub_flow.input_variables.size > 0 && tester.flow_variable_grouping
+            line "// #{name} sub-flow input variables"
+            line '{'
+            @indent += 1
+          end
           sub_flow.input_variables.each do |var|
-            var = var[0] if var.is_a?(Array)
-            line "#{name}.#{var} = #{var};"
+            # Handle the inout variables
+            # Get the main value into the temporary input variable
+            if sub_flow.inout_variables.keys.include?(var)
+              var = var[0] if var.is_a?(Array)
+              line "#{name}.#{var} = #{sub_flow.inout_variables[var]};"
+            else
+              var = var[0] if var.is_a?(Array)
+              line "#{name}.#{var} = #{var};"
+            end
+          end
+          if sub_flow.input_variables.size > 0 && tester.flow_variable_grouping
+            @indent -= 1
+            line '}'
           end
           line "#{name}.execute();"
           # And then retrieve all common output variables
+          if (output_variables & sub_flow.output_variables).size > 0 && tester.flow_variable_grouping
+            line "// #{name} sub-flow output variables"
+            line '{'
+            @indent += 1
+          end
           (output_variables & sub_flow.output_variables).sort.each do |var|
             var = var[0] if var.is_a?(Array)
             line "#{var} = #{name}.#{var};"
           end
+          if (output_variables & sub_flow.output_variables).size > 0 && tester.flow_variable_grouping
+            @indent -= 1
+            line '}'
+          end
           if on_pass = node.find(:on_pass)
             pass_lines = capture_lines do
               @indent += 1
@@ -146,20 +173,48 @@ module OrigenTesters
           end
         end
 
+        def on_auxiliary_flow(node)
+          @auxiliary_flows ||= {}
+          path = node.find(:path).value
+          name = node.find(:name).value
+          @auxiliary_flows[name] = "#{path}"
+          line "#{name}.execute();"
+        end
+
         def sub_flows
           @sub_flows || {}
         end
 
+        def auxiliary_flows
+          @auxiliary_flows || {}
+        end
+
+        def inout_variables
+          @inout_variables || {}
+        end
+
         # Variables which should be defined as an input to the current flow
         def input_variables
           vars = flow_variables
           # Jobs and enables flow into a sub-flow
-          (vars[:all][:jobs] + vars[:all][:referenced_enables] + vars[:all][:set_enables] +
+          in_var_array = (vars[:all][:jobs] + vars[:all][:referenced_enables] + vars[:all][:set_enables] +
             # As do any flags which are referenced by it but which are not set within it
-            (vars[:all][:referenced_flags] - vars[:all][:set_flags])).uniq.sort do |x, y|
+            (vars[:all][:referenced_flags] - vars[:all][:set_flags] - vars[:all][:unset_flags])).uniq
+          identified_inout_variables = in_var_array.select { |e| output_variables.include?(e) }
+          result = in_var_array.reject { |e| output_variables.include?(e) }
+          @inout_variables = {}
+          # create inout variables with unique ids to reduce user conflicts
+          identified_inout_variables.each do |var|
+            unique_id = 0
+            var.each_byte { |n| unique_id += n }
+            identifier = IN_IDENTIFIER + "_#{unique_id.to_s[0..4]}"
+            @inout_variables[:"#{var}#{identifier}"] = var
+          end
+          result += @inout_variables.keys
+          result.uniq.sort do |x, y|
             x = x[0] if x.is_a?(Array)
             y = y[0] if y.is_a?(Array)
-            x <=> y
+            x.to_s <=> y.to_s
           end
         end
 
@@ -170,6 +225,10 @@ module OrigenTesters
           (vars[:this_flow][:set_flags] +
            # As do any flags set by its children which are marked as external
            vars[:all][:set_flags_extern] +
+           # Other test methods are setting the flags
+           vars[:this_flow][:add_flags] +
+           # Other test methods are set in the children
+           vars[:all][:add_flags_extern] +
            # And any flags which are set by a child and referenced in this flow
            (vars[:this_flow][:referenced_flags] & vars[:sub_flows][:set_flags]) +
            # And also intermediate flags, those are flags which are set by a child and referenced
@@ -217,6 +276,11 @@ module OrigenTesters
               h << i + "#{var} = -1;"
             end
           end
+          # Handle the inout variables
+          # Use the original variable name and get the value out of the temporary input variable
+          inout_variables.each do |inout_var, orig_var|
+            h << i + "#{orig_var} = #{inout_var};"
+          end
           h << '' unless flow_variables[:this_flow][:set_flags].empty?
           h
         end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/limits_workbook.rb

@@ -65,35 +65,37 @@ module OrigenTesters
           Origen.log.info "Writing... #{output_file}"
           spreadsheet = RODF::Spreadsheet.new
           Origen.interface.flow_sheets.each do |name, flow|
-            if flow.limits_file
-              limits_name = flow.limits_file.filename.sub('.csv', '')
-              table = spreadsheet.table limits_name
-              flow.limits_file.output_file.readlines.each_with_index do |line, i|
-                # Need to fix the first row, SMT8 won't allow the Low/High limits cells not to be merged
-                if i == 0
-                  row = table.row
-                  x = nil
-                  line.chomp.split(',').each do |word|
-                    if word == 'Low Limit'
-                      x = 0
-                    elsif word == 'High Limit'
-                      row.cell 'Low Limit', span: x + 1
-                      x = 0
-                    elsif word == 'Unit'
-                      row.cell 'High Limit', span: x + 1
-                      row.cell word
-                      x = nil
-                    elsif x
-                      x += 1
-                    else
+            if tester.create_limits_file
+              if flow.limits_file
+                limits_name = flow.limits_file.filename.sub('.csv', '')
+                table = spreadsheet.table limits_name
+                flow.limits_file.output_file.readlines.each_with_index do |line, i|
+                  # Need to fix the first row, SMT8 won't allow the Low/High limits cells not to be merged
+                  if i == 0
+                    row = table.row
+                    x = nil
+                    line.chomp.split(',').each do |word|
+                      if word == 'Low Limit'
+                        x = 0
+                      elsif word == 'High Limit'
+                        row.cell 'Low Limit', span: x + 1
+                        x = 0
+                      elsif word == 'Unit'
+                        row.cell 'High Limit', span: x + 1
+                        row.cell word
+                        x = nil
+                      elsif x
+                        x += 1
+                      else
+                        row.cell word
+                      end
+                    end
+                  else
+                    row = table.row
+                    line.chomp.split(',').each do |word|
                       row.cell word
                     end
                   end
-                else
-                  row = table.row
-                  line.chomp.split(',').each do |word|
-                    row.cell word
-                  end
                 end
               end
             end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/templates/template.flow.erb

@@ -21,6 +21,9 @@ flow <%= flow_name %> {
         <%= line %>
 %   end
 
+% end
+% auxiliary_flows.each do |name, path|
+        flow <%= name %> calls <%= path %> {}
 % end
 % sub_flows.each do |name, path|
         flow <%= name %> calls <%= path %> { }