origen 0.0.1 → 0.0.2

data/lib/origen/tester/ultraflex/parser/pattern_set.rb

@@ -0,0 +1,94 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        class PatternSet
+          class Pattern
+            attr_accessor :parser
+
+            ATTRS = %w(pattern_set file_name start_label stop_label comment)
+
+            ALIASES = {
+              pattern: :file_name,
+              file:    :file_name,
+              name:    :file_name
+            }
+
+            # Generate readers for all attributes and their aliases
+            ATTRS.each do |attr|
+              attr_reader attr.to_sym
+            end
+
+            ALIASES.each do |_alias, attr|
+              define_method("#{_alias}") do
+                send(attr)
+              end
+            end
+
+            def initialize(line)
+              @line = line
+              parse
+              if valid?
+                ATTRS.each_with_index do |attr, i|
+                  instance_variable_set("@#{attr}", components[i + 1])
+                end
+              end
+            end
+
+            def parse
+              @components = @line.split("\t") unless @line.strip.empty?
+            end
+
+            def valid?
+              components[1] && !components[1].empty? && components[1] != 'Pattern Set' &&
+                components[2] && !components[2].empty?
+            end
+
+            def components
+              @components ||= []
+            end
+          end
+
+          def initialize(line, options = {})
+            @parser = options[:parser]
+            p = add_pattern_line(line)
+            @name = p.pattern_set if p.valid?
+          end
+
+          def inspect  # :nodoc:
+            "<PatternSet: #{name}>"
+          end
+
+          def name
+            @name
+          end
+
+          def patterns
+            @patterns ||= []
+          end
+
+          def self.extract_name(line)
+            new(line).name
+          end
+
+          def add_pattern_line(line)
+            p = Pattern.new(line)
+            patterns << Pattern.new(line) if p.valid?
+            p
+          end
+
+          def valid?
+            patterns.all?(&:valid?)
+          end
+
+          # Returns an array containing all pattern names contained in this
+          # pattern set
+          def pattern_names
+            # This removes the path and extensions
+            patterns.map { |pat| pat.name.gsub(/.*[\\\/]/, '').gsub(/\..*/, '') }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/parser/pattern_sets.rb

@@ -0,0 +1,33 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        class PatternSets < Origen::Tester::Parser::SearchableHash
+          attr_accessor :parser
+
+          def initialize(options = {})
+            @parser = options[:parser]
+          end
+
+          def import(file)
+            File.readlines(file).each do |line|
+              name = PatternSet.extract_name(line)
+              if name
+                if self[name]
+                  self[name].add_pattern_line(line)
+                else
+                  l = PatternSet.new(line, parser: parser)
+                  self[l.name] = l if l.valid?
+                end
+              end
+            end
+          end
+
+          def inspect
+            "<Patsets: #{size}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/parser/test_instance.rb

@@ -0,0 +1,262 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        class TestInstance
+          attr_accessor :parser
+
+          TYPES = %w(
+            functional board_pmu empty pin_pmu power_supply
+          )
+
+          TYPE_ALIASES = {
+            functional_t:         :functional,
+            boardpmu_t:           :board_pmu,
+            nvmboardpmucal_t:     :board_pmu,
+            nvmboardpmumeasure_t: :board_pmu,
+            empty_t:              :empty,
+            pinpmu_t:             :pin_pmu,
+            nvmpinpmucal_t:       :pin_pmu,
+            nvmpinpmumeas_t:      :pin_pmu,
+            powersupply_t:        :power_supply
+          }
+
+          attributes = %w(
+            test_name proc_type proc_name proc_called_as dc_category dc_selector ac_category ac_selector
+            time_sets edge_sets pin_levels overlay
+          )
+          80.times do |i|
+            attributes << "arg#{i}"
+          end
+          attributes << 'comment'
+
+          ATTRS = attributes
+
+          ALIASES = {
+            name:       :test_name,
+
+            functional: {
+              pattern:             :arg0,
+              start_func:          :arg1,
+              pre_pat_func:        :arg2,
+              pre_test_func:       :arg3,
+              post_test_func:      :arg4,
+              post_pat_func:       :arg5,
+              end_func:            :arg6,
+              set_pass_fail:       :arg7,
+              start_func_args:     :arg13,
+              pre_pat_func_args:   :arg14,
+              pre_test_func_args:  :arg15,
+              post_test_func_args: :arg16,
+              post_pat_func_args:  :arg17,
+              end_func_args:       :arg18,
+              wait_flags:          :arg21,
+              wait_time:           :arg22,
+              pat_flag_func:       :arg23,
+              pat_flag_func_args:  :arg24,
+              relay_mode:          :arg25,
+              threading:           :arg26,
+              match_all_sites:     :arg27,
+              capture_mode:        :arg30,
+              capture_what:        :arg31,
+              capture_memory:      :arg32,
+              capture_size:        :arg33,
+              datalog_mode:        :arg34,
+              data_type:           :arg35
+            },
+
+            board_pmu:  {
+              hsp_start:           :arg0,
+              start_func:          :arg1,
+              pre_pat_func:        :arg2,
+              pre_test_func:       :arg3,
+              post_test_func:      :arg4,
+              post_pat_func:       :arg5,
+              end_func:            :arg6,
+              precond_pat:         :arg7,
+              hold_state_pat:      :arg8,
+              holdstate_pat:       :arg8,
+              pattern:             :arg8,
+              pcp_stop:            :arg9,
+              wait_flags:          :arg10,
+              start_lo:            :arg11,
+              init_lo:             :arg11,
+              start_hi:            :arg12,
+              init_hi:             :arg12,
+              start_hiz:           :arg13,
+              init_hiz:            :arg13,
+              float_pins:          :arg14,
+              pinlist:             :arg15,
+              measure_mode:        :arg16,
+              irange:              :arg17,
+              clamp:               :arg18,
+              vrange:              :arg19,
+              sampling_time:       :arg20,
+              samples:             :arg21,
+              setting_time:        :arg22,
+              hi_lo_lim_valid:     :arg23,
+              hi_limit:            :arg24,
+              lo_limit:            :arg25,
+              force_cond_1:        :arg26,
+              force_cond_2:        :arg27,
+              gang_pins_tested:    :arg28,
+              relay_mode:          :arg29,
+              wait_time_out:       :arg30,
+              start_func_args:     :arg31,
+              pre_pat_func_args:   :arg32,
+              pre_test_func_args:  :arg33,
+              post_test_func_args: :arg34,
+              post_pat_func_args:  :arg35,
+              end_func_args:       :arg36,
+              pcp_start:           :arg37,
+              pcp_check_pg:        :arg38,
+              hsp_stop:            :arg39,
+              hsp_check_pg:        :arg40,
+              resume_pat:          :arg41,
+              utility_pins_1:      :arg42,
+              utility_pins_0:      :arg43,
+              pre_charge_enable:   :arg44,
+              pre_charge:          :arg45,
+              threading:           :arg46
+            },
+
+            pin_pmu:    {
+              hsp_start:           :arg0,
+              start_func:          :arg1,
+              pre_pat_func:        :arg2,
+              pre_test_func:       :arg3,
+              post_test_func:      :arg4,
+              post_pat_func:       :arg5,
+              end_func:            :arg6,
+              precond_pat:         :arg7,
+              hold_state_pat:      :arg8,
+              holdstate_pat:       :arg8,
+              pattern:             :arg8,
+              pcp_stop:            :arg9,
+              wait_flags:          :arg10,
+              start_lo:            :arg11,
+              init_lo:             :arg11,
+              start_hi:            :arg12,
+              init_hi:             :arg12,
+              start_hiz:           :arg13,
+              init_hiz:            :arg13,
+              float_pins:          :arg14,
+              pinlist:             :arg15,
+              measure_mode:        :arg16,
+              irange:              :arg17,
+              setting_time:        :arg18,
+              hi_lo_lim_valid:     :arg19,
+              hi_limit:            :arg20,
+              lo_limit:            :arg21,
+              force_cond_1:        :arg22,
+              force_cond_2:        :arg23,
+              fload:               :arg24,
+              f_load:              :arg24,
+              relay_mode:          :arg25,
+              wait_time_out:       :arg26,
+              start_func_args:     :arg27,
+              pre_pat_func_args:   :arg28,
+              pre_test_func_args:  :arg29,
+              post_test_func_args: :arg30,
+              post_pat_func_args:  :arg31,
+              end_func_args:       :arg32,
+              pcp_start:           :arg33,
+              pcp_check_pg:        :arg34,
+              hsp_stop:            :arg35,
+              hsp_check_pg:        :arg36,
+              sampling_time:       :arg37,
+              samples:             :arg38,
+              resume_pat:          :arg39,
+              vcl:                 :arg40,
+              vch:                 :arg41,
+              utility_pins_1:      :arg42,
+              utility_pins_0:      :arg43,
+              pre_charge_enable:   :arg44,
+              pre_charge:          :arg45,
+              threading:           :arg46
+            }
+          }
+
+          # Make readers for each low level attribute
+          ATTRS.each do |attr|
+            attr_reader attr
+          end
+
+          # And the aliases
+          ALIASES.each do |alias_, attr|
+            define_method("#{alias_}") do
+              send(attr)
+            end
+          end
+
+          def initialize(line, options = {})
+            @parser = options[:parser]
+            @line = line
+            parse
+            if valid?
+              ATTRS.each_with_index do |attr, i|
+                instance_variable_set("@#{attr}", components[i + 1])
+              end
+              if ALIASES[type]
+                ALIASES[type].each do |alias_, attr|
+                  define_singleton_method("#{alias_}") do
+                    send(attr)
+                  end
+                end
+              end
+            end
+          end
+
+          def inspect  # :nodoc:
+            "<TestInstance: #{name}, Type: #{type}>"
+          end
+
+          def description
+            parser.descriptions.test_instance(name: name)
+          end
+
+          def type
+            TYPE_ALIASES[proc_name.downcase.to_sym] || :unsupported
+          end
+
+          def parse
+            @components = @line.split("\t") unless @line.strip.empty?
+          end
+
+          def valid?
+            components[4] && ['Excel Macro', 'VB DLL'].include?(components[4])
+          end
+
+          def components
+            @components ||= []
+          end
+
+          # Returns an array of all pattern names referenced in this test instance
+          def patterns
+            if self.respond_to?(:pattern)
+              pattern.split(',').map do |pat|
+                extract_pattern_from_patset(pat)
+              end.flatten.map { |pat| pat.gsub(/.*[\\\/]/, '').gsub(/\..*/, '') }
+            end
+          end
+
+          def extract_pattern_from_patset(patset)
+            pset = parser.pattern_sets.where(name: patset, exact: true)
+            if pset.size > 1
+              puts "Warning multiple pattern sets called #{patset} found, using the first one"
+            end
+            if pset.size == 0
+              patset
+            else
+              pset.first.pattern_names
+            end
+          end
+
+          def vdd
+            parser.dc_specs.where(name: 'VDD', exact: true).first.lookup(dc_category, dc_selector)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/parser/test_instances.rb

@@ -0,0 +1,26 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        class TestInstances < Origen::Tester::Parser::SearchableHash
+          attr_accessor :parser
+
+          def initialize(options = {})
+            @parser = options[:parser]
+          end
+
+          def import(file)
+            File.readlines(file).each do |line|
+              l = TestInstance.new(line, parser: parser)
+              self[l.name] = l if l.valid?
+            end
+          end
+
+          def inspect
+            "<TestInstances: #{size}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/parser/timeset.rb

@@ -0,0 +1,15 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        class Timeset
+          attr_accessor :parser
+
+          def initialize(options = {})
+            @parser = options[:parser]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/parser.rb

@@ -0,0 +1,104 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        autoload :Flows,   'origen/tester/ultraflex/parser/flows'
+        autoload :Flow,   'origen/tester/ultraflex/parser/flow'
+        autoload :FlowLine,   'origen/tester/ultraflex/parser/flow_line'
+        autoload :TestInstances,   'origen/tester/ultraflex/parser/test_instances'
+        autoload :TestInstance,   'origen/tester/ultraflex/parser/test_instance'
+        autoload :PatternSets,   'origen/tester/ultraflex/parser/pattern_sets'
+        autoload :PatternSet,   'origen/tester/ultraflex/parser/pattern_set'
+        autoload :DCSpecs,   'origen/tester/ultraflex/parser/dc_specs'
+        autoload :DCSpec,   'origen/tester/ultraflex/parser/dc_spec'
+        autoload :ACSpecs,   'origen/tester/ultraflex/parser/ac_specs'
+        autoload :ACSpec,   'origen/tester/ultraflex/parser/ac_spec'
+        autoload :Descriptions,   'origen/tester/ultraflex/parser/descriptions'
+
+        def reset
+          @flows = nil
+          @test_instances = nil
+          @pattern_sets = nil
+          @dc_specs = nil
+          @ac_specs = nil
+        end
+
+        def descriptions
+          @descriptions ||= Descriptions.new(parser: self)
+        end
+
+        # Returns an array of test flows
+        def flows
+          @flows ||= Flows.new(parser: self)
+        end
+
+        def test_instances
+          @test_instances ||= TestInstances.new(parser: self)
+        end
+        alias_method :instances, :test_instances
+
+        def pattern_sets
+          @pattern_sets ||= PatternSets.new(parser: self)
+        end
+        alias_method :patsets, :pattern_sets
+        alias_method :pat_sets, :pattern_sets
+
+        def dc_specs
+          @dc_specs ||= DCSpecs.new(parser: self)
+        end
+
+        def ac_specs
+          @ac_specs ||= ACSpecs.new(parser: self)
+        end
+
+        def inspect
+          "<Parsed Program: Flows: #{flows.size}>"
+        end
+
+        # Parse a file, array of files, or a directory.
+        #
+        # This can be called multiple times to add new files to the
+        # program model.
+        def parse(file)
+          Origen.log.info ''
+          Origen.log.info "Parsing Ultraflex test program from: #{file}"
+          Origen.log.info ''
+          reset
+          # Note use of local file handler here, this should be how it is
+          # done globally, otherwise we can run into hard to debug problems
+          # due to state/reference dir changes in the single Origen.file_handler
+          Origen::FileHandler.new.resolve_files(file) do |f|
+            parse_file(f)
+          end
+          Origen.log.info ''
+          self
+        end
+
+        def parse_file(file)
+          line = File.readlines(file).first
+          begin
+            if line =~ /Flow Table/
+              flows.import(file)
+            elsif line =~ /Instances/
+              test_instances.import(file)
+            elsif line =~ /Pattern Sets/
+              patsets.import(file)
+            elsif line =~ /DC Spec/
+              dc_specs.import(file)
+            else
+              puts "Skipped (un-supported file type): #{file}"
+            end
+          rescue Exception => e
+            if e.is_a?(ArgumentError) && e.message =~ /invalid byte sequence/
+              puts "Skipped (not ASCII): #{file}"
+            else
+              puts e.message
+              puts e.backtrace
+              exit 1
+            end
+          end
+        end
+      end
+    end
+  end
+end