origen 0.0.1 → 0.0.2

data/lib/origen/tester/j750/j750_hpt.rb

@@ -0,0 +1,35 @@
+module Origen
+  module Tester
+    # rubocop:disable ClassAndModuleCamelCase
+
+    # Tester model to generate .atp patterns for the Teradyne J750 in HPT mode
+    #
+    # == Basic Usage
+    #   $tester = J750_HPT.new
+    #   $tester.cycle       # Generate a vector
+    #
+    # Many more methods exist to generate J750 specific micro-code, see J750
+    # parent class definition for details.
+    #
+    # *Also note that this class inherits from the base Tester class and so all methods
+    # described there are also available*
+    class J750_HPT < J750
+      def initialize
+        super
+        @@hpt_mode = true
+        @drive_hi_state = '.1'
+        @drive_lo_state = '.0'
+        @expect_hi_state = '.H'
+        @expect_lo_state = '.L'
+        @dont_care_state = '.X'
+        @overlay_state = '.V'
+        @drive_very_hi_state = '.2'
+        @drive_mem_state = '.D'
+        @expect_mem_state = '.E'
+        @name = 'j750_hpt'
+      end
+    end
+
+    # rubocop:enable ClassAndModuleCamelCase
+  end
+end

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

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

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

@@ -0,0 +1,36 @@
+module Origen
+  module Tester
+    class J750
+      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/j750/parser/dc_specs.rb

@@ -0,0 +1,50 @@
+module Origen
+  module Tester
+    class J750
+      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/j750/parser/descriptions.rb

@@ -0,0 +1,340 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        # Extracts embedded test and flow descriptions (comments) from test
+        # program source files
+        class Descriptions
+          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 J750 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

data/lib/origen/tester/j750/parser/flow.rb

@@ -0,0 +1,111 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        class Flow < Origen::Tester::Parser::SearchableArray
+          require 'pathname'
+
+          attr_accessor :parser, :file
+
+          def initialize(file, options = {})  # :nodoc:
+            @parser = options[:parser]
+            @file = Pathname.new(file)
+            parse
+          end
+
+          def description
+            @parser.descriptions.flow_summary(file: file)
+          end
+          alias_method :summary, :description
+
+          # Returns the filename of the sheet that contained the current flow
+          def filename
+            @file.basename.to_s
+          end
+          alias_method :name, :filename
+
+          # Returns all flow lines that are tests, optionally supply a context to
+          # have only the test that will execute in that context returned
+          #
+          #   $tester.flow.first.tests.size
+          #     => 20
+          #   $tester.flow.first.tests(:job => "P1").size
+          #     => 10
+          #   $tester.flow.first.tests(:job => "P1", :enable => "data_collection").size
+          #     => 15
+          def tests(context = {})
+            run_context(context)
+          end
+
+          # Returns all tests in the current flow, regardless of context
+          def all_tests
+            where(opcode: %w(Test characterize), exact: true)
+          end
+
+          def run_context(context)  # :nodoc:
+            capture = true
+            waiting_for_label = false
+            select do |line|
+              if capture
+                if !waiting_for_label || waiting_for_label == line.label
+                  waiting_for_label = false
+                  case line.type
+                  when 'Test', 'characterize'
+                    line.executes_under_context?(context)
+                  when 'set-device', 'stop'
+                    capture = false if line.executes_under_context?(context)
+                    false
+                  when 'enable-flow-word'
+                    if line.executes_under_context?(context)
+                      context[:enable] = [context[:enable]].flatten
+                      context[:enable] << line.parameter
+                    end
+                    false
+                  when 'flag-true'
+                    if line.executes_under_context?(context)
+                      context[:true_flags] = [context[:true_flags]].flatten
+                      context[:true_flags] << line.parameter
+                    end
+                    false
+                  when 'flag-false'
+                    if line.executes_under_context?(context)
+                      context[:false_flags] = [context[:false_flags]].flatten
+                      context[:false_flags] << line.parameter
+                    end
+                    false
+                  when 'disable-flow-word'
+                    if line.executes_under_context?(context)
+                      context[:enable] = [context[:enable]].flatten
+                      context[:enable].delete(line.parameter)
+                    end
+                    false
+                  when 'logprint', 'nop', 'print'
+                    false
+                  when 'goto'
+                    waiting_for_label = line.parameter
+                    false
+                  else
+                    fail "Don't know how to process: #{line.type}, in file #{filename}"
+                  end
+                else
+                  false
+                end
+              end
+            end
+          end
+
+          def parse  # :nodoc:
+            File.readlines(@file).each do |line|
+              l = FlowLine.new(line, parser: parser, flow: self)
+              self << l if l.valid?
+            end
+          end
+
+          def inspect  # :nodoc:
+            "<TestFlow: #{filename}, Lines: #{size}>"
+          end
+        end
+      end
+    end
+  end
+end