origen 0.2.6 → 0.3.0

data/lib/origen/tester/ultraflex/generator/test_instance_group.rb

@@ -1,60 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class TestInstanceGroup
-          attr_accessor :name, :version, :append_version
-
-          include Enumerable
-
-          def initialize(name, _options = {})
-            @name = name
-            @store = []
-            @append_version = true
-          end
-
-          def name
-            if unversioned_name
-              if version && @append_version
-                "#{unversioned_name}_v#{version}"
-              else
-                unversioned_name.to_s
-              end
-            end
-          end
-
-          def unversioned_name
-            if @name
-              if @name =~ /grp$/
-                @name
-              else
-                "#{@name}_grp"
-              end
-            end
-          end
-
-          def <<(instance)
-            @store << instance
-          end
-
-          def size
-            @store.size
-          end
-
-          def each
-            @store.each { |ins| yield ins }
-          end
-
-          def ==(other_instance_group)
-            self.class == other_instance_group.class &&
-              unversioned_name.to_s == other_instance_group.unversioned_name.to_s &&
-              size == other_instance_group.size &&
-              self.all? do |ins|
-                other_instance_group.any? { |other_ins| ins == other_ins }
-              end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,174 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class TestInstances
-          include Origen::Tester::Generator
-
-          TEMPLATE = "#{Origen.top}/lib/origen/tester/ultraflex/generator/templates/instances.txt.erb"
-          OUTPUT_POSTFIX = 'instances'
-
-          class IndexedString < ::String
-            attr_accessor :index
-
-            def name
-              self
-            end
-          end
-
-          def add(name, type, options = {})
-            options = {
-              test_instance_class: TestInstance
-            }.merge(options)
-            ins = options.delete(:test_instance_class).new(name, type, options)
-            if @current_group
-              @current_group << ins
-            else
-              collection << ins
-            end
-            c = Origen.interface.consume_comments
-            Origen.interface.descriptions.add_for_test_definition(name, c)
-            ins
-          end
-
-          # IG-XL doesn't have a formal instance group type and instead declares them anonymously
-          # whenever test instances of the same name appear consecutively in the test instance sheet.
-          # However when it comes to generating a test program life becomes much easier if we have
-          # a way to explicitly declare instances as part of a group - this makes duplicate tracking
-          # and sorting of the test instance sheet much easier.
-          #
-          # Use this method to generate instance groups via a block. Within the the block you should
-          # generate instances as normal and they will automatically be assigned to the current group.
-          # Note that the name of the instances generated within the group is discarded and replaced
-          # with the name of the group. Origen automatically appends "grp" to this name to highlight
-          # instances that were generated as part of the group.
-          #
-          #   test_instances.group("erase_all_blocks") do |group|
-          #     # Generate instances here as normal
-          #     test_instances.functional("erase_blk0")
-          #     test_instances.functional("erase_blk1")
-          #   end
-          #
-          # The group object is passed into the block but usually you should not need to interact
-          # with this directly except maybe to set the name if it is not yet established at the point
-          # where the group is initiated:
-          #
-          #   test_instances.group do |group|
-          #     # Generate instances here as normal
-          #     group.name = "group_blah"
-          #   end
-          #
-          # A common way to generate groups is to create a helper method in your application which
-          # is responsible for creating groups as required:
-          #
-          #   def group_wrapper(name, options)
-          #     if options[:by_block]
-          #       test_instances.group(name) do |group|
-          #         yield group
-          #       end
-          #     else
-          #       yield
-          #     end
-          #   end
-          #
-          # In that case the group argument becomes quite useful for branching based on whether you
-          # are generating a group or standalone instances:
-          #
-          #  group_wrapper(name, options) do |group|
-          #    if group
-          #      # Generate group instances
-          #    else
-          #      # Generate standalone instances
-          #    end
-          #  end
-          def group(name = nil, options = {})
-            name, options = nil, name if name.is_a?(Hash)
-            @current_group = TestInstanceGroup.new(name, options)
-            collection << @current_group
-            yield @current_group
-            @current_group = nil
-          end
-          alias_method :add_group, :group
-
-          def finalize(_options = {}) # :nodoc:
-            uniq!
-            sort!
-          end
-
-          def uniq! # :nodoc:
-            uniques = []
-            versions = {}
-            multi_version_tests = {}
-            collection.each do |instance|
-              # If a uniquely named instance is found add it, otherwise update the version
-              # of the current instance to match that of the existing instance that it duplicates
-              unless uniques.any? do |i|
-                if i == instance
-                  instance.version = i.version
-                  true
-                else
-                  false
-                end
-              end
-                if instance.respond_to?(:version=)
-                  versions[instance.unversioned_name] ||= 0
-                  versions[instance.unversioned_name] += 1
-                  if versions[instance.unversioned_name] > 1
-                    multi_version_tests[instance.unversioned_name] = true
-                  end
-                  instance.version = versions[instance.unversioned_name]
-                end
-                uniques << instance
-              end
-            end
-            # This final loop disables the version identifier for tests that have only a single version,
-            # this makes it clearer when multiple versions exist - whenever you see a v1 you know there
-            # is at least a v2 also.
-            collection.map! do |instance|
-              if instance.respond_to?(:version=)
-                unless multi_version_tests[instance.unversioned_name]
-                  instance.append_version = false
-                end
-              end
-              instance
-            end
-            self.collection = uniques
-          end
-
-          def sort! # :nodoc:
-            # Present the instances in the final sheet in alphabetical order
-            collection.map!.with_index do |ins, _i|
-              if ins.is_a?(String)   # Can happen if content has been rendered in from a template
-                ins = IndexedString.new(ins)
-              end
-              ins
-            end
-            collection.sort! { |a, b| [a.name.to_s] <=> [b.name.to_s] }
-          end
-
-          def bpmu(name, options = {})
-            add(name, :board_pmu, options)
-          end
-          alias_method :board_pmu, :bpmu
-
-          def ppmu(name, options = {})
-            add(name, :pin_pmu, options)
-          end
-          alias_method :pin_pmu, :ppmu
-
-          def functional(name, options = {})
-            add(name, :functional, options)
-          end
-
-          def empty(name, options = {})
-            add(name, :empty, options)
-          end
-
-          def other(name, options = {})
-            add(name, :other, options)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,104 +0,0 @@
-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

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

@@ -1,11 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      class Parser
-        class ACSpec
-          attr_accessor :collection
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      class Parser
-        class DCSpec
-          attr_accessor :parser
-          attr_accessor :name, :categories
-          alias_method :symbol, :name
-
-          def initialize(name, categories, options = {})
-            @parser = options[:parser]
-            @name = name
-            @categories = categories
-            @values = {}
-          end
-
-          def add_values(components)
-            @categories.each_with_index do |category, i|
-              @values[category] ||= {}
-              @values[category]['Typ'] ||= components[5 + (i * 3) + 0]
-              @values[category]['Min'] ||= components[5 + (i * 3) + 1]
-              @values[category]['Max'] ||= components[5 + (i * 3) + 2]
-            end
-          end
-
-          def lookup(category, selector)
-            v = @values[category]
-            if v
-              v[selector]
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      class Parser
-        class DCSpecs < Origen::Tester::Parser::SearchableHash
-          attr_accessor :parser
-
-          def initialize(options = {})
-            @parser = options[:parser]
-          end
-
-          def import(file)
-            @categories = []
-            File.readlines(file).each do |line|
-              unless line.strip.empty?
-                components = line.split("\t")
-                if components[3] == 'Selector'
-                  extract_categories(components)
-                else
-                  unless components[1] == 'DC Specs' || components[1] == 'Symbol'
-                    extract_spec(components)
-                  end
-                end
-              end
-            end
-          end
-
-          def inspect
-            "<DCSpecs: #{size}>"
-          end
-
-          def extract_categories(components)
-            components.each_with_index do |val, i|
-              if i > 4
-                @categories << val unless val.strip.empty?
-              end
-            end
-            @categories.uniq!
-          end
-
-          def extract_spec(components)
-            name = components[1]
-            self[name] ||= DCSpec.new(name, @categories, parser: parser)
-            self[name].add_values(components)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,342 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      class Parser
-        # Extracts embedded test and flow descriptions (comments) from test
-        # program source files
-        class Descriptions
-          require 'fileutils'
-
-          attr_accessor :source_directories, :template_directories, :parser
-
-          SCRATCH_DIR = "#{Origen.root}/.j750_scratch"
-
-          # All descriptions are stored in this lookup table
-          def lookup
-            return @lookup if @lookup
-            # Use the one from the interface if present, program generation will
-            # automatically push descriptions in here
-            if Origen.interface_present?
-              @lookup = Origen.interface.descriptions
-            else
-              @lookup = Origen::Tester::Parser::DescriptionLookup.new
-            end
-          end
-
-          def initialize(options = {})
-            @parser = options[:parser]
-            FileUtils.rm_rf(SCRATCH_DIR) if File.exist?(SCRATCH_DIR)
-            parse_program
-            true
-          end
-
-          # Returns the description for the given flow
-          def flow_summary(options = {})
-            lookup.for_flow(options[:file])
-          end
-
-          # Returns the description of the given test from the test
-          # instance sheet declaration
-          def test_instance(options = {})
-            lookup.for_test_definition(options[:name])
-          end
-
-          # Returns the description of the given test from the test
-          # flow
-          def flow_line(options = {})
-            lookup.for_test_usage(options[:name], options[:flow])
-          end
-
-          def parse_program
-            Origen.file_handler.preserve_state do
-              generate_program_files
-              # Comments must be extracted manually for any compiled files, for
-              # generated files the comments will already be in the lookup
-              extract_flow_summaries
-              extract_test_instance_descriptions
-              extract_flow_line_descriptions
-            end
-          end
-
-          def source_directories
-            [@source_directories, Origen.config.test_program_source_directory].compact.flatten
-          end
-
-          def template_directories
-            [@template_directories, Origen.config.test_program_template_directory].compact.flatten
-          end
-
-          def extract_flow_summaries
-            Origen.file_handler.resolve_files(compiled_dir) do |file|
-              if flow_file?(file)
-                lookup.add_for_flow(file, parse_flow_summary(file))
-              end
-            end
-          end
-
-          # Parses a compiled template for marked up comments
-          def extract_test_instance_descriptions
-            Origen.file_handler.resolve_files(compiled_dir) do |file|
-              if instance_file?(file)
-                comments = []
-                File.readlines(file).each do |line|
-                  if line =~ /^<comment>(.*)/
-                    comments << Regexp.last_match[1].gsub("\r", '')
-                  else
-                    fields = line.split("\t")
-                    unless ['Test Instances', '', 'Test Name'].include? fields[1]
-                      lookup.add_for_test_definition(fields[1], comments)
-                    end
-                    comments = []
-                  end
-                end
-              end
-            end
-          end
-
-          def extract_flow_line_descriptions
-            Origen.file_handler.resolve_files(compiled_dir) do |file|
-              if flow_file?(file)
-                f = file.basename('.txt').to_s
-                comments = []
-                header_line = true
-                File.readlines(file).each do |line|
-                  if header_line
-                    header_line = false if line =~ /^\s*Label/
-                  else
-                    if line =~ /^<comment>(.*)/
-                      comments << Regexp.last_match[1].gsub("\r", '')
-                    else
-                      t = FlowLine.extract_test(line)
-                      if t
-                        lookup.add_for_test_usage(t, file, comments)
-                      end
-                      comments = []
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          def generate_program_files
-            a = generate_program
-            b = compile_program
-            unless a || b
-              fail 'No source or template files declared from which to parse descriptions!'
-            end
-          end
-
-          # Parses the given flow file for summary text and returns it, summary
-          # text must be the very first thing in the file.
-          # Returns an array of strings each representing a line of text.
-          def parse_flow_summary(file)
-            desc = []
-            File.readlines(file).each do |line|
-              if line =~ /%?\s*<comment>(.*)/
-                desc << Regexp.last_match[1].gsub("\r", '')
-              else
-                break
-              end
-            end
-            desc
-          end
-
-          # Generate a scratch version of the program for parsing
-          def generate_program
-            if source_directories.size > 0
-              unless @program_generated
-                Origen.log.info ''
-                Origen.log.info 'Extracting embedded comments:'
-                Origen.log.info ''
-                copy_source_files_to_scratch
-                markup_source_file_comments
-                # Compile the flow file, with Ruby comments now preserved and marked up
-                desc = Origen.app.runner.generate(program: true, patterns: ungenerated_dir, output: generated_dir,
-                                                check_for_changes: false, collect_stats: false, quiet: true,
-                                                collect_descriptions: true)
-                Origen.log.info ''
-              end
-              @program_generated = true
-            else
-              false
-            end
-          end
-
-          # Compile a scratch version of the program for parsing
-          def compile_program
-            if template_directories.size > 0
-              unless @program_compiled
-                Origen.log.info ''
-                Origen.log.info 'Extracting embedded comments:'
-                Origen.log.info ''
-                copy_templates_to_scratch
-                markup_template_comments
-                # Compile the flow file, with Ruby comments now preserved and marked up
-                Origen.app.runner.generate(compile: true, patterns: uncompiled_dir, output: compiled_dir,
-                                         check_for_changes: false, collect_stats: false, quiet: true)
-                Origen.log.info ''
-              end
-              @program_compiled = true
-            else
-              false
-            end
-          end
-
-          # Copy all flow and instance template files to the scratch dir
-          def copy_templates_to_scratch
-            uncompiled_dir(true)
-            template_directories.each do |dir|
-              Origen.file_handler.resolve_files(dir) do |file|
-                subdir = file.relative_path_from(Pathname.new(dir)).dirname.to_s
-                cpydir = "#{uncompiled_dir}/#{subdir}"
-                FileUtils.mkdir_p(cpydir) unless File.exist?(cpydir)
-                FileUtils.copy(file, cpydir) if flow_or_instance_file?(file)
-              end
-            end
-            `chmod -R 777 #{uncompiled_dir}/*` unless Dir["#{uncompiled_dir}/*"].empty?
-          end
-
-          # Copy all flow and instance source files to the scratch dir
-          def copy_source_files_to_scratch
-            source_directories.each do |dir|
-              Origen.file_handler.resolve_files(dir) do |file|
-                subdir = file.relative_path_from(Pathname.new(dir)).dirname.to_s
-                cpydir = "#{ungenerated_dir}/#{subdir}"
-                FileUtils.mkdir_p(cpydir) unless File.exist?(cpydir)
-                FileUtils.copy(file, cpydir)
-              end
-            end
-          end
-
-          def uncompiled_dir(force_make = false)
-            @uncompiled_dir ||= "#{SCRATCH_DIR}/uncompiled"
-            if force_make
-              FileUtils.rm_rf(@uncompiled_dir) if File.exist?(@uncompiled_dir)
-              @uncompiled_dir_created = false
-            end
-            unless @uncompiled_dir_created
-              FileUtils.mkdir_p(@uncompiled_dir) unless File.exist?(@uncompiled_dir)
-              @uncompiled_dir_created = true
-            end
-            @uncompiled_dir
-          end
-
-          def ungenerated_dir
-            @ungenerated_dir ||= "#{SCRATCH_DIR}/ungenerated"
-            unless @ungenerated_dir_created
-              FileUtils.mkdir_p(@ungenerated_dir) unless File.exist?(@ungenerated_dir)
-              @ungenerated_dir_created = true
-            end
-            @ungenerated_dir
-          end
-
-          def compiled_dir
-            @compiled_dir ||= "#{SCRATCH_DIR}/compiled"
-            unless @compiled_dir_created
-              FileUtils.mkdir_p(@compiled_dir) unless File.exist?(@compiled_dir)
-              @compiled_dir_created = true
-            end
-            @compiled_dir
-          end
-
-          def generated_dir
-            @generated_dir ||= "#{SCRATCH_DIR}/generated"
-            unless @generated_dir_created
-              FileUtils.mkdir_p(@generated_dir) unless File.exist?(@generated_dir)
-              @generated_dir_created = true
-            end
-            @generated_dir
-          end
-
-          # Returns true if the given file looks like a Ultraflex flow file, works for
-          # templates to
-          def flow_or_instance_file?(file, options = {})
-            options = { flow:     true,
-                        instance: true
-            }.merge(options)
-            if options[:flow] && options[:instance]
-              match = 'Flow|Instances'
-            elsif options[:flow]
-              match = 'Flow'
-            else
-              match = 'Instances'
-            end
-            # Not sure the best way to determine the file type of a partial, just
-            # return true for now to play it safe
-            return true if file.basename.to_s =~ /^_/
-            File.readlines(file).each do |line|
-              begin
-                unless line =~ /^%/ || line =~ /^\s*<comment>/
-                  return !!(line =~ /#{match}/)
-                end
-              rescue Exception => e
-                if e.is_a?(ArgumentError) && e.message =~ /invalid byte sequence/
-                  return false
-                else
-                  puts e.message
-                  puts e.backtrace
-                  exit 1
-                end
-              end
-            end
-          end
-
-          def flow_file?(file)
-            flow_or_instance_file?(file, instance: false)
-          end
-
-          def instance_file?(file)
-            flow_or_instance_file?(file, flow: false)
-          end
-
-          # Substitute Ruby line comments so they are preserved by compilation
-          def markup_template_comments
-            Origen.file_handler.resolve_files(uncompiled_dir) do |file|
-              lines = File.readlines(file)
-              File.open(file, 'w') do |f|
-                lines.each do |line|
-                  if line =~ /^%\s*#\s?(.*)/ # Remove single leading whitespace from comment if it exists
-                    comment = Regexp.last_match[1]
-                    # If comment starts with a '#-' it should be removed by compilation
-                    if line =~ /^%\s*#-.*/
-                      f.write line
-                    # Otherwise preserve it
-                    else
-                      f.write "<comment>#{comment}\n"
-                    end
-                  else
-                    f.write line
-                  end
-                end
-              end
-            end
-          end
-
-          # Substitute Ruby line comments so they are preserved by generation
-          def markup_source_file_comments
-            Origen.file_handler.resolve_files(ungenerated_dir) do |file|
-              lines = File.readlines(file)
-              File.open(file, 'w') do |f|
-                lines.each do |line|
-                  if line =~ /^\s*#\s?(.*)/ # Remove single leading whitespace from comment if it exists
-                    comment = Regexp.last_match[1]
-                    # If comment starts with a '#-' it should be removed by generation
-                    if line =~ /^\s*#-.*/
-                      f.write line
-                    # Otherwise preserve it
-                    else
-                      f.write "Origen.interface.comment '#{comment}'\n"
-                    end
-                  else
-                    f.write line
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end