origen_testers 0.13.1 → 0.13.2

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

@@ -1,69 +1,69 @@
-require 'pathname'
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      class PatternMaster
-        include OrigenTesters::Generator
-
-        attr_reader :flow, :paths
-        attr_accessor :filename, :id
-
-        def initialize(flow = nil)
-          @flow = flow
-          @paths = {}
-        end
-
-        def filename
-          @filename || flow.filename.sub('.tf', '.pmfl')
-        end
-
-        def subdirectory
-          'vectors'
-        end
-
-        def paths
-          { '../vectors' => patterns }
-        end
-
-        # def add(name, options = {})
-        #  name, subdir = extract_subdir(name, options)
-        #  name += '.binl.gz' unless name =~ /binl.gz$/
-        #  # Don't want to ask Origen to compile these, but do want them in the v93k
-        #  # compile list
-        #  if name =~ /_part\d+\.binl\.gz$/
-        #    Origen.interface.pattern_compiler.part_patterns << name
-        #  else
-        #    Origen.interface.referenced_patterns << name
-        #  end
-        #  paths[subdir] ||= []
-        #  # Just add it, duplicates will be removed at render time
-        #  paths[subdir] << name unless paths[subdir].include?(name)
-        # end
-
-        def patterns
-          (references[:subroutine][:all] + references[:subroutine][:ate] +
-            references[:main][:all] + references[:main][:ate]).map do |p|
-            p = p.strip
-            p += '.binl.gz' unless p =~ /binl.gz$/
-          end.uniq
-        end
-
-        def references
-          Origen.interface.all_pattern_references[id]
-        end
-
-        private
-
-        def extract_subdir(name, options = {})
-          p = Pathname.new(name.to_s)
-          name = p.basename.to_s
-          subdir = p.dirname.to_s
-          # if subdir == '.'
-          #  # In future may support setting a default subdir via the interface
-          # end
-          [name, subdir]
-        end
-      end
-    end
-  end
-end
+require 'pathname'
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class PatternMaster
+        include OrigenTesters::Generator
+
+        attr_reader :flow, :paths
+        attr_accessor :filename, :id
+
+        def initialize(flow = nil)
+          @flow = flow
+          @paths = {}
+        end
+
+        def filename
+          @filename || flow.filename.sub('.tf', '.pmfl')
+        end
+
+        def subdirectory
+          'vectors'
+        end
+
+        def paths
+          { '../vectors' => patterns }
+        end
+
+        # def add(name, options = {})
+        #  name, subdir = extract_subdir(name, options)
+        #  name += '.binl.gz' unless name =~ /binl.gz$/
+        #  # Don't want to ask Origen to compile these, but do want them in the v93k
+        #  # compile list
+        #  if name =~ /_part\d+\.binl\.gz$/
+        #    Origen.interface.pattern_compiler.part_patterns << name
+        #  else
+        #    Origen.interface.referenced_patterns << name
+        #  end
+        #  paths[subdir] ||= []
+        #  # Just add it, duplicates will be removed at render time
+        #  paths[subdir] << name unless paths[subdir].include?(name)
+        # end
+
+        def patterns
+          (references[:subroutine][:all] + references[:subroutine][:ate] +
+            references[:main][:all] + references[:main][:ate]).map do |p|
+            p = p.strip
+            p += '.binl.gz' unless p =~ /binl.gz$/
+          end.uniq
+        end
+
+        def references
+          Origen.interface.all_pattern_references[id]
+        end
+
+        private
+
+        def extract_subdir(name, options = {})
+          p = Pathname.new(name.to_s)
+          name = p.basename.to_s
+          subdir = p.dirname.to_s
+          # if subdir == '.'
+          #  # In future may support setting a default subdir via the interface
+          # end
+          [name, subdir]
+        end
+      end
+    end
+  end
+end

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

@@ -1,16 +1,16 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # Include any V93K specific AST processors here
-        autoload :IfRanCleaner, 'origen_testers/smartest_based_tester/base/processors/if_ran_cleaner'
-        autoload :EmptyBranchCleaner, 'origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner'
-        autoload :FlagOptimizer, 'origen_testers/smartest_based_tester/base/processors/flag_optimizer'
-        autoload :ExtractSetVariables, 'origen_testers/smartest_based_tester/base/processors/extract_set_variables'
-        autoload :AdjacentIfCombiner, 'origen_testers/smartest_based_tester/base/processors/adjacent_if_combiner'
-        autoload :ContinueImplementer, 'origen_testers/smartest_based_tester/base/processors/continue_implementer'
-        autoload :ExtractRunFlagTable, 'origen_testers/smartest_based_tester/base/processors/extract_run_flag_table'
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Include any V93K specific AST processors here
+        autoload :IfRanCleaner, 'origen_testers/smartest_based_tester/base/processors/if_ran_cleaner'
+        autoload :EmptyBranchCleaner, 'origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner'
+        autoload :FlagOptimizer, 'origen_testers/smartest_based_tester/base/processors/flag_optimizer'
+        autoload :ExtractSetVariables, 'origen_testers/smartest_based_tester/base/processors/extract_set_variables'
+        autoload :AdjacentIfCombiner, 'origen_testers/smartest_based_tester/base/processors/adjacent_if_combiner'
+        autoload :ContinueImplementer, 'origen_testers/smartest_based_tester/base/processors/continue_implementer'
+        autoload :ExtractRunFlagTable, 'origen_testers/smartest_based_tester/base/processors/extract_run_flag_table'
+      end
+    end
+  end
+end

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

@@ -1,106 +1,106 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # This combines adjacent if flag nodes where the flag is in the opposite state
-        #
-        #   s(:flow,
-        #     s(:name, "prb1"),
-        #     s(:run_flag, "SOME_FLAG", true,
-        #       s(:test,
-        #         s(:name, "test1"))),
-        #     s(:run_flag, "SOME_FLAG", false,
-        #       s(:test,
-        #         s(:name, "test2"))))
-        #
-        #   s(:flow,
-        #     s(:name, "prb1"),
-        #     s(:run_flag, "SOME_FLAG",
-        #       s(:flag_true,
-        #         s(:test,
-        #           s(:name, "test1"))),
-        #       s(:flag_false,
-        #         s(:test,
-        #           s(:name, "test2")))))
-        #
-        # See here for an example of the kind of flow level effect it has:
-        # https://github.com/Origen-SDK/origen_testers/issues/43
-        class AdjacentIfCombiner < ATP::Processor
-          class SetRunFlagFinder < ATP::Processor
-            def contains?(node, flag_name)
-              @result = false
-              @flag_name = flag_name
-              process_all(node)
-              @result
-            end
-
-            def on_set_run_flag(node)
-              if node.to_a[0] == @flag_name
-                @result = true
-              end
-            end
-            alias_method :on_set_flow_flag, :on_set_run_flag
-          end
-
-          def on_unnamed_collection(node)
-            node.updated(nil, optimize(process_all(node.children)))
-          end
-          alias_method :on_on_fail, :on_unnamed_collection
-          alias_method :on_on_pass, :on_unnamed_collection
-
-          def on_named_collection(node)
-            name, *nodes = *node
-            node.updated(nil, [name] + optimize(process_all(nodes)))
-          end
-          alias_method :on_flow, :on_named_collection
-          alias_method :on_group, :on_named_collection
-
-          def on_group(node)
-            name, *nodes = *node
-            node.updated(nil, [name] + optimize(process_all(nodes)))
-          end
-
-          def optimize(nodes)
-            results = []
-            node1 = nil
-            nodes.each do |node2|
-              if node1
-                if opposite_flag_states?(node1, node2) && safe_to_combine?(node1, node2)
-                  results << combine(node1, node2)
-                  node1 = nil
-                else
-                  results << node1
-                  node1 = node2
-                end
-              else
-                node1 = node2
-              end
-            end
-            results << node1 if node1
-            results
-          end
-
-          def combine(node1, node2)
-            true_node = node1.to_a[1] ? node1 : node2
-            false_node = node1.to_a[1] ? node2 : node1
-            true_node = n(:flag_true, process_all(true_node.to_a[2..-1]))
-            false_node = n(:flag_false, process_all(false_node.to_a[2..-1]))
-
-            n(node1.type, [node1.to_a[0], true_node, false_node])
-          end
-
-          def opposite_flag_states?(node1, node2)
-            ((node1.type == :run_flag && node2.type == :run_flag) || (node1.type == :flow_flag && node2.type == :flow_flag)) &&
-              node1.to_a[0] == node2.to_a[0] && node1.to_a[1] != node2.to_a[1]
-          end
-
-          def safe_to_combine?(node1, node2)
-            # Nodes won't be collapsed if node1 touches the shared run flag, i.e. if there is any chance
-            # that by the time it would naturally execute node2, the flag could have been changed by node1
-            !SetRunFlagFinder.new.contains?(node1, node1.to_a[0])
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # This combines adjacent if flag nodes where the flag is in the opposite state
+        #
+        #   s(:flow,
+        #     s(:name, "prb1"),
+        #     s(:run_flag, "SOME_FLAG", true,
+        #       s(:test,
+        #         s(:name, "test1"))),
+        #     s(:run_flag, "SOME_FLAG", false,
+        #       s(:test,
+        #         s(:name, "test2"))))
+        #
+        #   s(:flow,
+        #     s(:name, "prb1"),
+        #     s(:run_flag, "SOME_FLAG",
+        #       s(:flag_true,
+        #         s(:test,
+        #           s(:name, "test1"))),
+        #       s(:flag_false,
+        #         s(:test,
+        #           s(:name, "test2")))))
+        #
+        # See here for an example of the kind of flow level effect it has:
+        # https://github.com/Origen-SDK/origen_testers/issues/43
+        class AdjacentIfCombiner < ATP::Processor
+          class SetRunFlagFinder < ATP::Processor
+            def contains?(node, flag_name)
+              @result = false
+              @flag_name = flag_name
+              process_all(node)
+              @result
+            end
+
+            def on_set_run_flag(node)
+              if node.to_a[0] == @flag_name
+                @result = true
+              end
+            end
+            alias_method :on_set_flow_flag, :on_set_run_flag
+          end
+
+          def on_unnamed_collection(node)
+            node.updated(nil, optimize(process_all(node.children)))
+          end
+          alias_method :on_on_fail, :on_unnamed_collection
+          alias_method :on_on_pass, :on_unnamed_collection
+
+          def on_named_collection(node)
+            name, *nodes = *node
+            node.updated(nil, [name] + optimize(process_all(nodes)))
+          end
+          alias_method :on_flow, :on_named_collection
+          alias_method :on_group, :on_named_collection
+
+          def on_group(node)
+            name, *nodes = *node
+            node.updated(nil, [name] + optimize(process_all(nodes)))
+          end
+
+          def optimize(nodes)
+            results = []
+            node1 = nil
+            nodes.each do |node2|
+              if node1
+                if opposite_flag_states?(node1, node2) && safe_to_combine?(node1, node2)
+                  results << combine(node1, node2)
+                  node1 = nil
+                else
+                  results << node1
+                  node1 = node2
+                end
+              else
+                node1 = node2
+              end
+            end
+            results << node1 if node1
+            results
+          end
+
+          def combine(node1, node2)
+            true_node = node1.to_a[1] ? node1 : node2
+            false_node = node1.to_a[1] ? node2 : node1
+            true_node = n(:flag_true, process_all(true_node.to_a[2..-1]))
+            false_node = n(:flag_false, process_all(false_node.to_a[2..-1]))
+
+            n(node1.type, [node1.to_a[0], true_node, false_node])
+          end
+
+          def opposite_flag_states?(node1, node2)
+            ((node1.type == :run_flag && node2.type == :run_flag) || (node1.type == :flow_flag && node2.type == :flow_flag)) &&
+              node1.to_a[0] == node2.to_a[0] && node1.to_a[1] != node2.to_a[1]
+          end
+
+          def safe_to_combine?(node1, node2)
+            # Nodes won't be collapsed if node1 touches the shared run flag, i.e. if there is any chance
+            # that by the time it would naturally execute node2, the flag could have been changed by node1
+            !SetRunFlagFinder.new.contains?(node1, node1.to_a[0])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,39 +1,39 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # Implements continue on a fail branch for V93K by removing any bin nodes that are
-        # siblings of continue nodes. The continue nodes are also removed in the process since
-        # they have now served their function.
-        class ContinueImplementer < ATP::Processor
-          # Delete any on-fail child if it's 'empty'
-          def on_on_fail(node)
-            if cont = node.find(:continue) || @continue
-              node = node.updated(nil, node.children - [cont] - node.find_all(:set_result))
-            end
-            node.updated(nil, process_all(node.children))
-          end
-
-          def on_group(node)
-            f = node.find(:on_fail)
-            if f && f.find(:continue)
-              with_continue do
-                node = node.updated(nil, process_all(node.children))
-              end
-              node
-            else
-              node.updated(nil, process_all(node.children))
-            end
-          end
-
-          def with_continue
-            orig = @continue
-            @continue = true
-            yield
-            @continue = orig
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Implements continue on a fail branch for V93K by removing any bin nodes that are
+        # siblings of continue nodes. The continue nodes are also removed in the process since
+        # they have now served their function.
+        class ContinueImplementer < ATP::Processor
+          # Delete any on-fail child if it's 'empty'
+          def on_on_fail(node)
+            if cont = node.find(:continue) || @continue
+              node = node.updated(nil, node.children - [cont] - node.find_all(:set_result))
+            end
+            node.updated(nil, process_all(node.children))
+          end
+
+          def on_group(node)
+            f = node.find(:on_fail)
+            if f && f.find(:continue)
+              with_continue do
+                node = node.updated(nil, process_all(node.children))
+              end
+              node
+            else
+              node.updated(nil, process_all(node.children))
+            end
+          end
+
+          def with_continue
+            orig = @continue
+            @continue = true
+            yield
+            @continue = orig
+          end
+        end
+      end
+    end
+  end
+end