origen_testers 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b2dcc656f1e0eea888097e0ebd1402d29d74f1f
-  data.tar.gz: 99f3b89c7c42d55fba2a6fab344f01704ef7482e
+  metadata.gz: 432b93c069da178e789ff6d40afa25e4ba34eb02
+  data.tar.gz: 080a839243c3058dfb450dccbf5c63f06172dd9f
 SHA512:
-  metadata.gz: f5e93bc0820e794e54c1e7563e55210f3770751a689dc76f53d32ec9f0d84d6cf9656a0c9a7834a0ccb0efbe3492f24c3f1dd3415b92a71fc74edf352221d6fa
-  data.tar.gz: 791cc935f5ade96b8eecdba8cc8f3da5fcdf399f55e1744832521beab41147485f3baf8211f63c041c3ee557d8bfa6cfe879db67d9778862fa2bd3402acd5d82
+  metadata.gz: 2c5e2ed553068517cb0ceb2ac5caef371083adb5db690922e4ae9826f7ea077116dfe3eda974d263ad7c45f6551942ece6cbc00b043cd8b2928a5f64a7c4b294
+  data.tar.gz: 71d64f91fcd9eb494155dbc426de044db5fc1e3b27edd0f7687cc954bc74be50b1a4aef22414ae5e21ab5045439341a7428c576470cb4ae7ce1ba4f70c79d78d

data/config/shared_commands.rb

@@ -23,32 +23,24 @@ case @command
   #  require "#{Origen.root(:testers)}/lib/commands/latpc"
   # Need to see if --compile is included and setup compiler
   when "generate"
-  @application_options << ["--compile", "Compile the current pattern or the list"]
-  @application_options << ["-v", "--vector_comments", "Add the vector and cycle number to the vector comments"]
-  if ARGV.include?('--compile')
-    compiler_instance_name = ARGV[ARGV.index('--compile')+1]
-    if compiler_instance_name.nil?
-      $compiler = :use_app_default
-    else
-      ARGV.delete(compiler_instance_name) 
-      $compiler = compiler_instance_name.to_sym
-    end
-    ARGV.delete("--compile")
-  end
-  $_testers_enable_vector_comments = ARGV.delete("-v") || ARGV.delete("--vector_comments")
-  $_testers_no_inline_comments = ARGV.delete("--no_inline_comments")
+    @application_options << ['--compile', 'Compile the current pattern or the list', ->(options) { options[:testers_compile_pat] = true }]
+    @application_options << ['--compiler NAME', String, 'Override the default application pattern compiler', ->(options, compiler) { options[:testers_compiler_instance_name] = compiler.to_sym }]
+    @application_options << ['--no_inline_comments', 'Disable the duplication of comments inline (V93k patterns)', ->(options) { options[:testers_no_inline_comments] = true }]
+    @application_options << ['-v', '--vector_comments', 'Add the vector and cycle number to the vector comments', lambda { |options| options[:testers_enable_vector_comments] = true }]
+
+    $_testers_enable_vector_comments = ARGV.delete("-v") || ARGV.delete("--vector_comments")
+    $_testers_no_inline_comments = ARGV.delete("--no_inline_comments")
 
   when "testers:build"
-   require "#{Origen.root!}/lib/commands/build"
+    require "#{Origen.root!}/lib/commands/build"
     exit 0
 
   when "testers:run"
-   require "#{Origen.root!}/lib/commands/run"
+    require "#{Origen.root!}/lib/commands/run"
     exit 0
 
-
   else
-  @plugin_commands << " testers:build   Build a test program from a collection of sub-programs"
-  @plugin_commands << " testers:run     Run the last test program generated for the current target"
+    @plugin_commands << " testers:build   Build a test program from a collection of sub-programs"
+    @plugin_commands << " testers:run     Run the last test program generated for the current target"
 
 end 

data/config/version.rb

@@ -1,6 +1,6 @@
 module OrigenTesters
   MAJOR = 0
-  MINOR = 14
+  MINOR = 15
   BUGFIX = 0
   DEV = nil
 

data/lib/origen_testers.rb

@@ -4,6 +4,7 @@ require_relative '../config/application.rb'
 require 'active_support/concern'
 require 'require_all'
 require 'atp'
+require 'pathname'
 require 'origen_testers/origen_ext/generator/flow'
 require 'origen_testers/origen_ext/generator/resources'
 require 'origen_testers/origen_ext/application/runner'
@@ -42,6 +43,7 @@ require 'origen_testers/igxl_based_tester'
 require 'origen_testers/smartest_based_tester'
 require 'origen_testers/labview_based_tester'
 require 'origen_testers/pattern_compilers'
+require 'origen_testers/pattern_compilers/runner'
 
 require 'origen_testers/callback_handlers'
 require 'origen_testers/origen_ext/pins/pin'

data/lib/origen_testers/callback_handlers.rb

@@ -4,9 +4,13 @@ module OrigenTesters
 
     # Snoop the pattern path that was just created and then compile it
     # if the compiler was passed on the command line
-    def pattern_generated(path_to_generated_pattern)
-      current_compiler = select_compiler
-      run_compiler(current_compiler, path_to_generated_pattern)
+    def pattern_generated(path_to_generated_pattern, job_options = {})
+      if job_options[:testers_compile_pat]
+        opts = {}
+        opts[:compiler_instance] = job_options[:testers_compiler_instance_name]
+        opts[:pattern_generated] = true
+        OrigenTesters::PatternCompilers::Runner.run_compiler(path_to_generated_pattern, opts)
+      end
     end
 
     # Listen for a pattern with .atp or .atp.gz extension.  If found then compile the fileand kill the 'origen g' command
@@ -29,28 +33,6 @@ module OrigenTesters
       end
       true
     end
-
-    private
-
-    def select_compiler
-      current_compiler = nil
-      if $compiler == :use_app_default
-        current_compiler = $dut.compiler
-        fail "DUT compiler '#{current_compiler}' is not instantiated" if $dut.pattern_compilers[current_compiler].nil?
-      elsif $compiler.is_a? Symbol
-        current_compiler = $compiler
-        fail "Command line compiler '#{current_compiler}' is not instantiated" if $dut.pattern_compilers[current_compiler].nil?
-      end
-      current_compiler
-    end
-
-    def run_compiler(current_compiler, pattern)
-      unless current_compiler.nil?
-        debug "Compiling pattern #{pattern} with compiler '#{current_compiler}'..."
-        $dut.pattern_compilers[current_compiler].find_jobs(pattern)
-        $dut.pattern_compilers[current_compiler].run
-      end
-    end
   end
 
   # Instantiate an instance of this class immediately when this file is required, this object will

data/lib/origen_testers/origen_ext/generator.rb

@@ -24,7 +24,7 @@ module Origen
         else
           file = Origen.config.referenced_pattern_list
         end
-        puts "Referenced pattern list written to: #{Pathname.new(file).relative_path_from(Pathname.pwd)}"
+        Origen.log.info "Referenced pattern list written to: #{Pathname.new(file).relative_path_from(Pathname.pwd)}"
         dir = Pathname.new(file).dirname
         FileUtils.mkdir_p(dir) unless dir.exist?
         File.open(file, 'w') do |f|

data/lib/origen_testers/pattern_compilers.rb

@@ -1,116 +1,170 @@
 module OrigenTesters
   module PatternCompilers
-    require 'pathname'
-    require_relative 'pattern_compilers/ultraflex_pattern_compiler'
-
-    PLATFORMS = [:ultraflex]
-
-    # Linux compiler executable path
-    LINUX_PATTERN_COMPILER = "#{Origen.root!}/bin/latest/bin/atpcompiler"
-
-    # Windows compiler executable path
-    WINDOWS_PATTERN_COMPILER = "#{ENV['IGXLROOT']}/bin/apc.exe"
-
-    # Hash wrapper for compiler instances, defaults to display currently enabled
-    # tester platform.  If none is set then user must supply a valid tester platform argument
-    def pattern_compilers(id = nil)
+    require 'origen_testers/pattern_compilers/base'
+    require 'origen_testers/pattern_compilers/igxl_based'
+    require 'origen_testers/pattern_compilers/ultraflex'
+    require 'origen_testers/pattern_compilers/j750'
+    require 'origen_testers/pattern_compilers/v93k'
+
+    PLATFORMS = {
+      ultraflex: 'UltraFLEX',
+      j750:      'J750',
+      v93k:      'V93K'
+    }
+
+    # Hash wrapper for compiler instances, defaults to display currently enabled tester platform.
+    # If no tester is set then user must supply a valid tester platform argument
+    # User can also supply alternate tester platform (i.e. not the current tester target)
+    #  pattern_compilers()                    => hash of compilers for current tester platform
+    #  pattern_compilers(id1)                 => inspect options of compiler 'id1' for current tester platfrom
+    #  pattern_compiler(platform: :v93k)      => hash of compilers for specified tester platfrom (v93k)
+    #  pattern_compiler(id2, platform: :v93k) => inspect options of compiler 'id2' for specified tester platfrom (v93k)
+    def pattern_compilers(id = nil, options = {})
+      id, options = nil, id if id.is_a? Hash
+      plat = options[:platform] || platform     # use platform option or current tester platform
+
+      # Build up empty hash structure for all supported plaforms
       @pattern_compilers ||= begin
         hash = {}
-        PLATFORMS.each { |platform| hash[platform] = {} }
+        PLATFORMS.keys.each { |p| hash[p] = {} }
         hash
       end
+
+      @default_pattern_compiler ||= begin
+        hash = {}
+        PLATFORMS.keys.each { |p| hash[p] = nil }
+        hash
+      end
+
       if id.nil?
-        @pattern_compilers[platform]
+        @pattern_compilers[plat]
       else
-        @pattern_compilers[platform][id].inspect_options
+        @pattern_compilers[plat][id].inspect_options
       end
     end
-    alias_method :compilers, :pattern_compilers
+    # alias_method :compilers, :pattern_compilers     # DEPRECATING
+
+    # Add a compiler for a particular tester platform and pattern type
+    def add_pattern_compiler(id, plat, options = {})
+      pattern_compilers
+      id = id.to_sym
+      plat = plat.to_sym
+      options[:location] = options[:location].to_sym unless options[:location].nil?
+
+      verify_unique_platform_id(id, plat)    # do not allow duplicate ids for a given platform
+      @pattern_compilers[plat][id] = platform_compiler(plat).new(id, options)
+
+      default = options[:default] || false
+      @default_pattern_compiler[plat] = id if default
+    end
+    # alias_method :add_compiler, :add_pattern_compiler     # DEPRECATING
+
+    # Get the default pattern compiler for the current of speficied platform
+    def default_pattern_compiler(p = platform)
+      @default_pattern_compiler[p.to_sym]
+    end
+
+    # Set a (already created) pattern compiler as the default for current or specified platform
+    def set_default_pattern_compiler(id, p = platform)
+      @default_pattern_compiler[p.to_sym] = id
+    end
 
+    # All platforms that have supported pattern compilers (returns Array)
     def pattern_compiler_platforms
-      PLATFORMS
+      PLATFORMS.keys.sort
     end
-    alias_method :compiler_platforms, :pattern_compiler_platforms
+    # alias_method :compiler_platforms, :pattern_compiler_platforms     # DEPRECATING
 
-    # Delete pattern compiler instances.  If no argument default to current platform
+    # Delete all pattern compiler instances for a given platform.  If no
+    #   argument default to current platform
     def delete_pattern_compilers(p = platform)
       @pattern_compilers[p].delete_if { |k, v| true }
     end
-    alias_method :delete_compilers, :delete_pattern_compilers
+    # alias_method :delete_compilers, :delete_pattern_compilers     # DEPRECATING
 
     # Delete a pattern compiler instance.
-    def delete_pattern_compiler(id)
-      @pattern_compilers[platform].delete(id)
+    def delete_pattern_compiler(id, p = platform)
+      @pattern_compilers[p].delete(id)
     end
-    alias_method :delete_compiler, :delete_pattern_compiler
-
-    # Add a compiler for a particular tester platform and pattern type
-    def add_pattern_compiler(id, platform, options = {})
-      pattern_compilers
-      id = id.to_sym
-      platform = platform.to_sym
-      options[:location] = options[:location].to_sym unless options[:location].nil?
-      case platform
-      when :ultraflex
-        fail "Compiler ID #{id} for platform #{platform} already exists!  Pick another name, delete the compiler, or clear all compilers" if @pattern_compilers[platform].keys.include? id
-        @pattern_compilers[platform][id] = UltraFlexPatternCompiler.new(id, options)
-      else
-        fail "Platform #{platform} is not valid, please choose from #{PLATFORMS.join(', ')}"
+    # alias_method :delete_compiler, :delete_pattern_compiler     # DEPRECATING
+
+    # Check compiler instance name is unique for given platform
+    def verify_unique_platform_id(id, platform, options = {})
+      if @pattern_compilers[platform].keys.include? id
+        fail_msg = "Compiler ID #{id} for platform #{platform} already exists! "
+        fail_msg += 'Pick another name, delete the compiler, or clear all compilers'
+        fail fail_msg
       end
     end
-    alias_method :add_compiler, :add_pattern_compiler
 
     # Returns an array of the pattern compiler instance ids
     # for the currently selected tester platform.
     def pattern_compiler_instances(p = platform)
       # Check if nil which means no tester is defined so ask user to supply it
-      fail "No tester platform defined so supply one of the following as an argument: #{PLATFORMS.join(', ')}" if p.nil?
+      if p.nil?
+        fail "No tester platform defined, supply one of the following as an argument: #{PLATFORMS.keys.sort.join(', ')}"
+      end
       p = p.to_sym
       @pattern_compilers[p].keys
     end
-    alias_method :compiler_instances, :pattern_compiler_instances
+    # alias_method :compiler_instances, :pattern_compiler_instances       # DEPRECATING
+
+    # Return the Compiler Class of the current or specified platform
+    def platform_compiler(p = platform)
+      if pattern_compiler_supported?(p)
+        "OrigenTesters::PatternCompilers::#{PLATFORMS[p]}PatternCompiler".constantize
+      else
+        fail "Platform #{platform} is not valid, please choose from #{PLATFORMS.keys.sort.join(', ')}"
+      end
+    end
 
-    def pattern_compiler_options
-      cmd = ''
-      running_on_windows? ? cmd = "#{WINDOWS_PATTERN_COMPILER} -help" : cmd = "#{LINUX_PATTERN_COMPILER} -help"
-      system cmd
+    # Execute the compiler with 'help' switch
+    def pattern_compiler_options(p = platform)
+      system("#{platform_compiler(p).compiler_options}")
     end
-    alias_method :compiler_options, :pattern_compiler_options
+    # alias_method :compiler_options, :pattern_compiler_options           # DEPRECATING
 
-    def pattern_compiler_version
-      cmd = ''
-      running_on_windows? ? cmd = "#{WINDOWS_PATTERN_COMPILER} -version" : cmd = "#{LINUX_PATTERN_COMPILER} -version"
-      system cmd
+    # Execute the compiler with 'version' swtich
+    def pattern_compiler_version(p = platform)
+      system("#{platform_compiler(p).compiler_version}")
     end
-    alias_method :compiler_version, :pattern_compiler_version
+    # alias_method :compiler_version, :pattern_compiler_version           # DEPRECATING
 
     # Check if the current tester is supported
-    def pattern_compiler_supported?
-      PLATFORMS.include? platform ? true : false
+    def pattern_compiler_supported?(p = platform)
+      PLATFORMS.keys.include?(p) ? true : false
     end
-    alias_method :compiler_supported?, :pattern_compiler_supported?
+    # alias_method :compiler_supported?, :pattern_compiler_supported?     # DEPRECATING
 
     private
 
-    def running_on_windows?
-      RUBY_PLATFORM == 'i386-mingw32'
-    end
+    # # Check if the current tester is an Ultraflex
+    # def is_ultraflex?
+    #   platform == :ultraflex ? true : false
+    # end
 
-    # Check if the current tester is an Ultraflex
-    def is_ultraflex?
-      platform == :ultraflex ? true : false
-    end
+    # # Check if the current tester is an Ultraflex
+    # def is_j750?
+    #   platform == :j750 ? true : false
+    # end
 
+    # # Check if the current tester is an Ultraflex
+    # def is_v93k?
+    #   platform == :v93k ? true : false
+    # end
+
+    # Return the current tester target
     def platform
-      if $tester.nil?
+      if tester.nil?
         fail 'No tester instantiated, $tester is set to nil'
       else
-        $tester.class.to_s.downcase.split('::').last.to_sym
+        tester.class.to_s.downcase.split('::').last.to_sym
       end
     end
 
-    def target_enabled?
-      Origen.target.name.nil? ? true : false
-    end
+    # # Check if a target has been set
+    # def target_enabled?
+    #   Origen.target.name.nil? ? true : false
+    # end
   end
 end

data/lib/origen_testers/pattern_compilers/assembler.rb

@@ -1,17 +1,19 @@
 module OrigenTesters
   module PatternCompilers
-    class UltraFlexPatternCompiler
+    class BasePatternCompiler
       private
 
-      # Check the file extension of a file, return status can be 'atp', 'list', or nil
+      # Check the file extension of a file, return status can be 'atp', 'avc', 'list', or nil
       def check_file_ext(file)
         status = nil
         ext = file.extname
         name = file.basename
         if ext == '.atp'
           status = 'atp'
+        elsif ext == '.avc'
+          status = 'avc'
         elsif ext == '.gz'
-          # Ensure we have a .atp.gz
+          # Ensure we have a .atp.gz or .avc.gz
           sub_ext = name.to_s.split('.')[-2]
           if sub_ext == 'atp'
             status = 'atp'
@@ -52,6 +54,8 @@ module OrigenTesters
         case check_file_ext(file)
           when 'atp'
             files << file unless files.include?(file)
+          when 'avc'
+            files << file unless files.include?(file)
           when 'list'
             parse_list(file, files)
           end

data/lib/origen_testers/pattern_compilers/base.rb

@@ -0,0 +1,266 @@
+require 'digest/md5'
+module OrigenTesters
+  module PatternCompilers
+    class BasePatternCompiler
+      require 'origen_testers/pattern_compilers/assembler'
+      require 'origen_testers/pattern_compilers/job'
+
+      # ID will allow users to set default configurations for the compiler for unique pattern types
+      attr_accessor :id
+
+      # Compiler commands array
+      attr_accessor :jobs
+
+      def initialize(id, options = {})
+        unless Origen.site_config.origen_testers
+          fail 'Adding a pattern compiler without site config specifying bin location not allowed'
+        end
+
+        @id = id.to_sym
+
+        # The following are pattern compiler options that are common between all platforms, the specific platforms
+        #   can add on additional options in their respective initialize methods.
+        @user_options = {
+          path:                nil,     # required: will be passed in or parsed from a .list file
+          reference_directory: nil,     # optional: will be set to @path or Origen.app.config.pattern_output_directory
+          target:              nil,     # optional: allows user to temporarily set target and run compilation
+          recursive:           false,   # optional: controls whether to look for patterns in a directory recursively
+        }
+
+        @job_options = {
+          id:               @id,        # required
+          location:         :local,     # optional: controls whether the commands go to the LSF or run locally
+          clean:            false,      # optional: controls whether compiler log files are deleted after compilation
+          output_directory: nil,        # optional:
+          verbose:          false,      # optional: controls whether the compiler output gets put to STDOUT
+        }
+        @compiler_options = {}
+        @compiler_options_with_args = {}
+
+        # Compiler jobs
+        @jobs = []
+        @files = []
+      end
+
+      # Return the id/name of the compiler instance
+      def name
+        @id
+      end
+
+      # Returns the number of jobs in the compiler
+      def count
+        @jobs.size
+      end
+
+      # Checks if the compiler queue is empty
+      def empty?
+        @jobs.empty?
+      end
+
+      # Allow users to search for a pattern in the job queue or default to return all jobs
+      def jobs(search = nil)
+        found = false
+        if search.nil?
+          inspect_jobs
+          found = true
+        elsif search.is_a? String
+          @jobs.each_with_index do |job, index|
+            if job.pattern.to_s.match(search)
+              inspect_jobs(index)
+              found = true
+            else
+              puts "No match found for #{search}"
+            end
+          end
+        elsif search.is_a? Regexp
+          @jobs.each_with_index do |job, index|
+            if search.match(job.pattern.to_s)
+              inspect_jobs(index)
+              found = true
+            else
+              puts "No match found for #{search}"
+            end
+          end
+        elsif search.is_a? Integer
+          if @jobs[search].nil?
+            puts "The compiler queue does not contain a job at index #{search}"
+          else
+            inspect_jobs(search)
+            found = true
+          end
+        else
+          fail 'Search argument must be of type String, Regexp, or Integer'
+        end
+        found
+      end
+
+      # Clear the job queue
+      def clear
+        @jobs = []
+        @files = []
+      end
+
+      def platform
+        if tester.nil?
+          fail 'No tester instantiated, $tester is set to nil'
+        else
+          tester.class.to_s.downcase.split('::').last.to_sym
+        end
+      end
+
+      # Check if the current tester is an Ultraflex
+      def is_ultraflex?
+        platform == :ultraflex ? true : false
+      end
+
+      # Check if the current tester is an J750
+      def is_j750?
+        platform == :j750 ? true : false
+      end
+
+      # Check if the current tester is an V93K
+      def is_v93k?
+        platform == :v93k ? true : false
+      end
+
+      # Output the compiler options to the console
+      def inspect_options(verbose = nil)
+        desc = []
+        # Find the longest option argument string
+        my_job_options = @job_options
+        my_job_options.delete(:compiler)
+        all_arguments = @user_options.values + my_job_options.values + @compiler_options.values + @compiler_options_with_args.values
+        min_argument_padding = 'Argument'.length + 2
+        argument_padding = all_arguments.max_by { |e| e.to_s.length }.to_s.length + 3
+        argument_padding = min_argument_padding if argument_padding < min_argument_padding
+        puts "\n"
+        header = '| Option              ' + '| Argument'.ljust(argument_padding) + '| Required |'
+        desc << header
+        desc << '-' * header.length
+        [@user_options, my_job_options, @compiler_options, @compiler_options_with_args].each do |opt|
+          opt.each_pair do |k, v|
+            if k.match(/pinmap_workbook|path|id|directory|clean|location|recursive/i)
+              req = 'true '
+            else
+              next if v.nil? || v == false
+              req = 'false'
+            end
+            desc << "| #{k}".ljust(22) + "| #{v}".ljust(argument_padding) + "| #{req}    |"
+          end
+        end
+        puts desc
+      end
+
+      private
+
+      def update_common_options(options = {})
+        @user_options.update_common(options)
+        @job_options.update_common(options)
+        @compiler_options.update_common(options)
+        @compiler_options_with_args.update_common(options)
+      end
+
+      def clean_and_verify_options
+        verify_exclusive_compiler_options
+        clean_path_options
+        set_reference_directory
+        create_output_directory
+
+        # Logfile is optional
+        unless @compiler_options[:logfile].nil?
+          @compiler_options[:logfile] = convert_to_pathname(@compiler_options[:logfile])
+        end
+
+        # Check if the LSF is setup in the application
+        if Origen.app.config.lsf.project.nil? || Origen.app.config.lsf.project.empty?
+          msg = 'LSF is not set at Origen.app.config.lsf.project, changing to local compilation'
+          Origen.log.warn msg
+          @job_options[:location] = :local
+        end
+      end
+
+      # Check to make sure @compiler_options and @compiler_options_with_args do not have any keys in common
+      def verify_exclusive_compiler_options
+        if @compiler_options.intersect? @compiler_options_with_args
+          fail_msg = 'Error: @compiler_options and @compiler_options_with_args share keys '
+          fail_msg += "#{@compiler_options.intersections(@compiler_options_with_args)}.  "
+          fail_msg += 'They should be mutually exclusive, exiting...'
+          fail fail_msg
+        end
+      end
+
+      def clean_path_options
+        unless @user_options[:path].nil?
+          if @user_options[:path].is_a? Pathname
+            @path = @user_options[:path]
+          else
+            @path = Pathname.new(@user_options[:path])
+          end
+          @path = @path.expand_path
+          # path is set but output_directory is not so set output_directory to path
+          @job_options[:output_directory] = @path if @job_options[:output_directory].nil?
+        end
+      end
+
+      def set_reference_directory
+        if @user_options[:reference_directory].nil?
+          # Nothing passed for reference directory so set it to Origen.app.config.pattern_output_directory if valid
+          if File.directory? Origen.app.config.pattern_output_directory
+            @user_options[:reference_directory] = Pathname.new(Origen.app.config.pattern_output_directory)
+          elsif @path
+            if @path.directory?
+              @user_options[:reference_directory] = @path
+            else
+              @user_options[:reference_directory] = @path.dirname
+            end
+          end
+        elsif File.directory?(@user_options[:reference_directory])
+          @user_options[:reference_directory] = Pathname.new(@user_options[:reference_directory])
+        else
+          debug 'Reference directory not set, creating it...'
+          @user_options[:reference_directory] = Pathname.new(@user_options[:reference_directory])
+          FileUtils.mkdir_p(@user_options[:reference_directory])
+        end
+        @user_options[:reference_directory] = @user_options[:reference_directory].expand_path
+        # reference_directory must be a subset of @path. if it is not then set to @path if @path exists
+        unless @path.nil?
+          if @path.directory?
+            @user_options[:reference_directory] = @path unless @path.to_s.include? @user_options[:reference_directory].to_s
+          elsif @path.file?
+            @user_options[:reference_directory] = @path.dirname
+          else
+            fail "Path is set to #{@path} which is not a valid directory or file!"
+          end
+        end
+      end
+
+      def create_output_directory
+        # if output directory given, create it now, otherwise it will be created on the fly later
+        unless @job_options[:output_directory].nil?
+          @job_options[:output_directory] = convert_to_pathname(@job_options[:output_directory])
+          # output_directory can not exist, will create for user
+          unless @job_options[:output_directory].directory?
+            puts "Output directory #{@job_options[:output_directory]} does not exist, creating it..."
+            FileUtils.mkdir_p(@job_options[:output_directory])
+          end
+        end
+      end
+
+      def empty_msg
+        puts "No compiler jobs created, check the compiler options\n" if self.empty?
+      end
+
+      def convert_to_pathname(opt)
+        if opt.is_a? String
+          opt = Pathname.new(opt)
+          opt = opt.expand_path
+        elsif opt.is_a? Pathname
+          opt = opt.expand_path
+        else
+          fail "Option #{opt} is not a String, cannot convert to Pathname"
+        end
+        opt
+      end
+    end
+  end
+end