origen 0.20.3 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d0d658570a7bca8e87b0c6012b3508498779520
-  data.tar.gz: 713c7bb9a89325e9a478f2d0c37b623bff76c2e9
+  metadata.gz: 386c5e434e711ec01dd643a04282d2662f7ff312
+  data.tar.gz: fd0058e5748471a646a0e05fa582e7212fc50613
 SHA512:
-  metadata.gz: 5cc4a29abd85454d290410ab3640e4f381bcede00520848ff08370fa1390513345264b2b1d805a5a9ad3a9444cf600c3a823f7e1634a040eecc8ad3ce050e317
-  data.tar.gz: b06d42ab08d3690443780efae92bdf7262173fdf77e465e7b57640491a411bee5af94c605430b037395c87bbacecb69ab030ff6b536190e97c562c0dea759568
+  metadata.gz: 3d43b3346743a82f2144c9d6bc9b29f4aaab1c5af84d75e2d08fea74035680fabf7e851b1a6fb91c71cdb9dbaa32ee077c3cf3f0772f9ac408d62c1e7d979ec3
+  data.tar.gz: 399ad3393b90080cf5607d599e302de982edf1ce52340b8af4fb3f426eedca47ff45b82446bf7d1c6216cab797421254b4debda0690360d5cc09e41786d7b437

data/bin/fix_my_workspace

@@ -2,9 +2,17 @@
 $VERBOSE = nil  # Don't care about world writable dir warnings and the like
 
 if $_fix_my_workspace_version_check
-  $_fix_my_workspace_version = '0.5.0'
+  $_fix_my_workspace_version = '0.7.0'
 else
-  require 'origen'
+  if File.exist?(File.expand_path('../../lib/origen.rb', __FILE__))
+    # If this script is being run from within an origen-core workspace, use that Origen-core,
+    # not the system-installed origen-core version.
+    $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+    require 'origen'
+  else
+    # Use system-installed Origen (the gem in system Ruby)
+    require 'origen'
+  end
 
   if !Origen.site_config.gem_manage_bundler
     puts 'Sorry but you have opted to manage Bundler yourself via your Origen site config, and this means'
@@ -70,9 +78,23 @@ else
       fixed = true
     end
 
-    `chmod o-w #{ENV['BUNDLE_BIN']}` if File.exist?(ENV['BUNDLE_BIN'])
+    if File.exist?(ENV['BUNDLE_BIN'])
+      `chmod o-w #{ENV['BUNDLE_BIN']}`
+
+      # Make .bat versions of all executables, Bundler should really be doing this when running
+      # on windows
+      if Origen.os.windows?
+        Dir.glob("#{ENV['BUNDLE_BIN']}/*").each do |bin|
+          unless bin =~ /.bat$/
+            bat = "#{bin}.bat"
+            unless File.exist?(bat)
+              File.open(bat, 'w') { |f| f.write('@"ruby.exe" "%~dpn0" %*') }
+            end
+          end
+        end
+      end
+    end
 
     system 'origen -v' if fixed
-
   end
 end

data/bin/origen

@@ -56,9 +56,46 @@ if origen_root
     exec Gem.ruby, "#{origen_root}/lbin/origen", *ARGV
     exit 0
   end
+  
+  boot_app = true
+elsif Origen.site_config.gem_manage_bundler && (Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
+  # Force everyone to have a consistent way of installing gems with bundler.
+  # In this case, we aren't running from an Origen application, so build everything at Origen.home instead
+  # Have two options here: if user_install_enable is tru, use user_install_dir. Otherwise, use the tool_repo_install_dir
+  Origen.site_config.user_install_enable ? origen_root = File.expand_path(Origen.site_config.user_install_dir) : origen_root = File.expand_path(Origen.site_config.tool_repo_install_dir)
+  unless Dir.exists?(origen_root)
+    load File.expand_path('../../lib/origen/utility/input_capture.rb', __FILE__)
+    include Origen::Utility::InputCapture
+    
+    puts "Root directory '#{origen_root}' does not exist. Would you like to create it?"
+    if get_text(confirm: :return_boolean)
+      FileUtils.mkdir(origen_root)
+    else
+      puts "Exiting with creating Origen install"
+      exit!
+    end
+  end
+  
+  gemfile = File.join(origen_root, 'Gemfile')
+  unless File.exists?(gemfile)
+    # Create a default Gemfile that can be further customized by the user.
+    # Initial Gemfile only requires Origen. Nothing else. Essentially a blank installation.
+    Dir.chdir(origen_root) do
+      `bundle init`
+    end
+    # The above will give a general Gemfile from Bundler. We'll just append "gem 'origen' to the end.
+    File.open(gemfile, 'a') do |f|
+     f << "gem 'origen'\n"
+    end
+  end
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
+  ENV['BUNDLE_BIN'] = File.join(origen_root, 'lbin')
+  
+  boot_app = false
 end
 
-if origen_root && File.exist?(ENV['BUNDLE_GEMFILE']) && Origen.site_config.gem_manage_bundler
+if origen_root && File.exist?(ENV['BUNDLE_GEMFILE']) && Origen.site_config.gem_manage_bundler && (boot_app || Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
   # Overriding bundler here so that bundle install can be automated as required
   require 'bundler/shared_helpers'
   if Bundler::SharedHelpers.in_bundle?
@@ -131,7 +168,7 @@ begin
   # If this script has been invoked from within an Origen application then open
   # up all commands, if not then only allow the command to create a new Origen
   # application.
-  if origen_root
+  if origen_root && boot_app
     require 'origen/commands'
   else
     require 'origen/commands_global'

data/config/version.rb

@@ -1,7 +1,7 @@
 module Origen
   MAJOR = 0
-  MINOR = 20
-  BUGFIX = 3
+  MINOR = 21
+  BUGFIX = 0
   DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')

data/lib/option_parser/optparse.rb

@@ -7,6 +7,13 @@ class OptionParser
     lsf_options = ARGV.dup
     orig_parse!(*args)
     lsf_options -= ARGV  # Now contains all original options
-    Origen.app.lsf_manager.command_options = lsf_options
+
+    # Pick whether we should be using the application's LSF instance or Origen's
+    # global LSF instance
+    if Origen.running_globally?
+      Origen.lsf_manager.command_options = lsf_options
+    else
+      Origen.app.lsf_manager.command_options = lsf_options
+    end
   end
 end

data/lib/origen.rb

@@ -55,6 +55,9 @@ unless defined? RGen::ORIGENTRANSITION
     autoload :Netlist,   'origen/netlist'
     autoload :Models,    'origen/models'
     autoload :Errata,    'origen/errata'
+    autoload :LSF,           'origen/application/lsf'
+    autoload :LSFManager,    'origen/application/lsf_manager'
+    autoload :Fuses,     'origen/fuses'
 
     attr_reader :switch_user
 
@@ -264,6 +267,13 @@ unless defined? RGen::ORIGENTRANSITION
         !path.root?
       end
 
+      # Shortcut method to find if Origen was invoked from within an application or from
+      # the global Origen install. This is just the opposite of in_app_workspace?
+      def running_globally?
+        !in_app_workspace?
+      end
+      alias_method :invoked_globally?, :running_globally?
+
       def root(plugin = nil)
         if plugin
           app(plugin).root
@@ -277,7 +287,7 @@ unless defined? RGen::ORIGENTRANSITION
                 path = path.parent
               end
               if path.root?
-                fail 'Something went wrong resolving the application root!'
+                path = top
               end
               path
             end
@@ -586,10 +596,6 @@ unless defined? RGen::ORIGENTRANSITION
         end
       end
 
-      def lsf
-        application.lsf_manager
-      end
-
       def running_on_windows?
         Origen.os.windows?
       end
@@ -691,7 +697,25 @@ unless defined? RGen::ORIGENTRANSITION
 
       # Returns the home directory of Origen (i.e., the primary place that Origen operates out of)
       def home
-        "#{Dir.home}/.origen"
+        File.expand_path(Origen.site_config.home_dir)
+      end
+
+      def lsf_manager
+        @lsf_manager ||= Origen::Application::LSFManager.new
+      end
+
+      # Picks between either the global lsf_manager or the application's LSF manager
+      def lsf
+        if running_globally?
+          lsf_manager
+        else
+          application.lsf_manager
+        end
+      end
+
+      # Returns the Origen LSF instance, not the lsf_manager. Use Origen.lsf for that
+      def lsf!
+        @lsf ||= Origen::Application::LSF.new
       end
 
       private

data/lib/origen/application/lsf_manager.rb

@@ -17,6 +17,15 @@ module Origen
         end
       end
 
+      # Picks and returns either the application's LSF instance or the global LSF instance
+      def lsf
+        if Origen.running_globally?
+          Origen.lsf!
+        else
+          Origen.app.lsf
+        end
+      end
+
       def remote_jobs_file
         "#{Origen.root}/.lsf/remote_jobs"
       end
@@ -359,7 +368,7 @@ module Origen
         [log_file(job[:id]), passed_file(job[:id]), failed_file(job[:id]), started_file(job[:id])].each do |file|
           FileUtils.rm_f(file) if File.exist?(file)
         end
-        job[:lsf_id] = Origen.app.lsf.submit(command_prefix(job[:id], job[:dependents_ids]) + job[:command] + job[:switches], dependents: job[:dependents_lsf_ids])
+        job[:lsf_id] = lsf.submit(command_prefix(job[:id], job[:dependents_ids]) + job[:command] + job[:switches], dependents: job[:dependents_lsf_ids])
         job[:status] = nil
         job[:completed_at] = nil
         job[:submitted_at] = Time.now
@@ -374,7 +383,7 @@ module Origen
         id = generate_job_id
         dependents_ids = extract_ids([options[:depend], options[:depends], options[:dependent], options[:dependents]].flatten.compact)
         dependents_lsf_ids = dependents_ids.map { |dep_id| remote_jobs[dep_id][:lsf_id] }
-        lsf_id = Origen.app.lsf.submit(command_prefix(id, dependents_ids) + command + switches, dependents: dependents_lsf_ids)
+        lsf_id = lsf.submit(command_prefix(id, dependents_ids) + command + switches, dependents: dependents_lsf_ids)
         job_attrs = {
           id:                 id,
           lsf_id:             lsf_id,
@@ -481,8 +490,8 @@ module Origen
 
       def classify_jobs
         clear_caches
-        queuing_job_ids = Origen.app.lsf.queuing_job_ids
-        running_job_ids = Origen.app.lsf.running_job_ids
+        queuing_job_ids = lsf.queuing_job_ids
+        running_job_ids = lsf.running_job_ids
         remote_jobs.each do |_id, job|
           # If the status has already been determined send it straight to the bucket
           if job[:status]

data/lib/origen/commands.rb

@@ -24,6 +24,7 @@ ORIGEN_COMMAND_ALIASES = {
 
 @command = ARGV.shift
 @command = ORIGEN_COMMAND_ALIASES[@command] || @command
+@global_commands = []
 
 # Don't log to file during the save command since we need to preserve the last log,
 # this is done as early in the process as possible so any deprecation warnings during
@@ -215,6 +216,16 @@ if shared_commands && shared_commands.size != 0
   end
 end
 
+# Get a list of registered plugins and get the global launcher
+@global_launcher = Origen._applications_lookup[:name].map do |plugin_name, plugin|
+  shared = plugin.config.shared || {}
+  if shared[:global_launcher]
+    file = "#{plugin.root}/#{shared[:global_launcher]}"
+    require file
+    file
+  end
+end.compact
+
 case @command
 when 'generate', 'program', 'compile', 'merge', 'interactive', 'target', 'environment',
      'save', 'lsf', 'web', 'time', 'dispatch', 'rc', 'lint', 'plugin', 'fetch', 'mode' # , 'add'
@@ -274,6 +285,14 @@ EOT
     end
   end
 
+  if @global_launcher && !@global_launcher.empty?
+    puts ''
+    puts 'The following global commands are provided by plugins:'
+    @global_commands.each do |str|
+      puts str
+    end
+  end
+
   puts <<-EOT
 
 All commands can be run with -d (or --debugger) to enable the debugger.

data/lib/origen/commands_global.rb

@@ -8,8 +8,32 @@ aliases = {
   'f' => 'fetch'
 }
 
-command = ARGV.shift
-command = aliases[command] || command
+@command = ARGV.shift
+@command = aliases[@command] || @command
+
+@global_commands = []
+@application_options = []
+
+# Load all of the Gemfile's dependencies and grab any global commands.
+# If no Gemfile is defined, don't require any extra bundler stuff though we most likely won't register any global commands
+# if Origen.site_config.user_install_enable && File.exist?(File.join(File.expand_path(Origen.site_config.origen_install_dir), 'Gemfile'))
+if ENV['BUNDLE_GEMFILE']
+  # Load the Gemfile
+  Bundler.require
+  Bundler.require(:development)
+  Bundler.require(:runtime)
+  Bundler.require(:default)
+end
+
+# Get a list of registered plugins and get the global launcher
+@global_launcher = Origen._applications_lookup[:name].map do |plugin_name, plugin|
+  shared = plugin.config.shared || {}
+  if shared[:global_launcher]
+    file = "#{plugin.root}/#{shared[:global_launcher]}"
+    require file
+    file
+  end
+end.compact
 
 require 'origen/global_methods'
 include Origen::GlobalMethods
@@ -43,7 +67,7 @@ else
   end
 end
 
-case command
+case @command
 
 when 'new'
   require 'origen/commands/new'
@@ -61,7 +85,7 @@ when 'interactive'
   IRB.start
 
 else
-  puts 'Error: Command not recognized' unless ['-h', '--help'].include?(command)
+  puts 'Error: Command not recognized' unless ['-h', '--help'].include?(@command)
   puts <<-EOT
 Usage: origen COMMAND [ARGS]
 
@@ -70,6 +94,17 @@ The following commands are available:
               new origen application workspace in "./my_app"
  interactive  Start an interactive Origen console (short-cut alias: "i"), this is just
               IRB with the 'origen' lib loaded automatically
+  EOT
+
+  if @global_launcher && !@global_launcher.empty?
+    puts ''
+    puts 'The following global commands are provided by plugins:'
+    @global_commands.each do |str|
+      puts str
+    end
+  end
+
+  puts <<-EOT
 
 Many commands can be run with -h (or --help) for more information.
   EOT

data/lib/origen/core_ext/hash.rb

@@ -49,4 +49,33 @@ class Hash
   def longest_value
     values.map(&:to_s).max_by(&:length)
   end
+
+  def recursive_find_by_key(key)
+    search_results = {} # Used to store results when key is a Regexp
+    # Create a stack of hashes to search through for the needle which
+    # is initially this hash
+    stack = [self]
+    # So long as there are more haystacks to search...
+    while (to_search = stack.pop)
+      # ...keep searching for this particular key...
+      to_search.each do |k, v|
+        # If this value can be recursively searched...
+        if v.respond_to?(:recursive_find_by_key)
+          # ...push that on to the list of places to search.
+          stack << v
+        elsif key.is_a? Regexp
+          search_results[k] = v if key.match(k.to_s)
+        else
+          return v if (k == key)
+        end
+      end
+    end
+    if search_results.empty?
+      return nil
+    elsif search_results.size == 1
+      return search_results.values.first
+    else
+      return search_results
+    end
+  end
 end

data/lib/origen/core_ext/string.rb

@@ -10,10 +10,10 @@ end
 
 class String
   def to_dec
-    if self =~ /0x(.*)/
-      Regexp.last_match[1].to_i(16)
-    elsif self =~ /0b(.*)/
-      Regexp.last_match[1].to_i(2)
+    if self.is_verilog_number?
+      verilog_to_dec
+    elsif match(/^0[x,o,d,b]\S+/)
+      _to_dec(self)
     else
       to_i
     end
@@ -122,4 +122,116 @@ class String
       split(/ |\_|\-/).map(&:capitalize).join(' ')
     end
   end
+
+  def is_verilog_number?
+    case self
+    when /^[b,o,d,h]\S+$/, /^\d+\'[b,o,d,h]\S+$/, /^\d+\'s[b,o,d,h]\S+$/
+      true
+    else
+      false
+    end
+  end
+
+  private
+
+  # Convert a verilog number string to an integer
+  def verilog_to_dec
+    verilog_hash = parse_verilog_number
+    bit_str = verilog_to_bits
+    msb_size_bit = bit_str.size - verilog_hash[:size]
+    if verilog_hash[:signed] == true
+      if bit_str[msb_size_bit] == '1'
+        _to_dec("0b#{bit_str}") * -1
+      else
+        _to_dec("0b#{bit_str}")
+      end
+    else
+      _to_dec("0b#{bit_str}")
+    end
+  end
+
+  # Convert a verilog number string to a bit string
+  def verilog_to_bits
+    verilog_hash = parse_verilog_number
+    if [verilog_hash[:radix], verilog_hash[:value]].include?(nil)
+      Origen.log.error("The string '#{self}' does not appear to be valid Verilog number notation!")
+      fail
+    end
+    value_bit_string = create_bit_string_from_verilog(verilog_hash[:value], verilog_hash[:radix])
+    audit_verilog_value(value_bit_string, verilog_hash[:radix], verilog_hash[:size], verilog_hash[:signed])
+  end
+
+  def _to_dec(str)
+    if str =~ /^0x(.*)/i
+      Regexp.last_match[1].to_i(16)
+    elsif str =~ /0d(.*)/i
+      Regexp.last_match[1].to_i(10)
+    elsif str =~ /0o(.*)/i
+      Regexp.last_match[1].to_i(8)
+    elsif str =~ /0b(.*)/
+      Regexp.last_match[1].to_i(2)
+    end
+  end
+
+  def parse_verilog_number
+    str = nil
+    verilog_hash = {}.tap do |parse_hash|
+      [:size, :radix, :value].each do |attr|
+        parse_hash[attr] = nil
+      end
+    end
+    verilog_hash[:signed] = false
+    if match(/\_/)
+      str = delete('_')
+    else
+      str = self
+    end
+    str.downcase!
+    case str
+    when /^[0,1]+$/ # Just a value
+      verilog_hash[:size], verilog_hash[:radix], verilog_hash[:value] = 32, 'b', self
+    when /^[b,o,d,h]\S+$/ # A value and a radix
+      _m, verilog_hash[:radix], verilog_hash[:value] = /^([b,o,d,h])(\S+)$/.match(str).to_a
+      verilog_hash[:size] = calc_verilog_value_bit_size(verilog_hash[:value], verilog_hash[:radix])
+    when /^\d+\'[b,o,d,h]\S+$/ # A value, a radix, and a size
+      _m, verilog_hash[:size], verilog_hash[:radix], verilog_hash[:value] = /^(\d+)\'([b,o,d,h])(\S+)$/.match(str).to_a
+    when /^\d+\'s[b,o,d,h]\S+$/ # A signed value, a radix, and a size
+      _m, verilog_hash[:size], verilog_hash[:radix], verilog_hash[:value] = /^(\d+)\'s([b,o,d,h])(\S+)$/.match(str).to_a
+      verilog_hash[:signed] = true
+    else
+      Origen.log.error("The string '#{self}' does not appear to be valid Verilog number notation!")
+      fail
+    end
+    verilog_hash[:size] = verilog_hash[:size].to_i if verilog_hash[:size].is_a?(String)
+    verilog_hash
+  end
+
+  def calc_verilog_value_bit_size(val, radix)
+    create_bit_string_from_verilog(val, radix).size
+  end
+
+  def create_bit_string_from_verilog(val, radix)
+    bit_str = ''
+    case radix
+    when 'b'
+      return val
+    when 'o', 'd'
+      bit_str = "0#{radix}#{val}".to_dec.to_bin
+    when 'h'
+      bit_str = "0x#{val}".to_dec.to_bin
+    end
+    2.times { bit_str.slice!(0) }
+    bit_str
+  end
+
+  def audit_verilog_value(bit_str, radix, size, signed)
+    size_diff = bit_str.size - size
+    if size_diff > 0
+      Origen.log.warn("Truncating Verilog number '#{self}' by #{size_diff} MSBs!")
+      size_diff.times { bit_str.slice!(0) }
+    elsif size_diff < 0
+      bit_str = '0' * size_diff.abs + bit_str
+    end
+    bit_str
+  end
 end

data/lib/origen/fuses.rb

@@ -0,0 +1,31 @@
+require_relative 'fuses/fuse_field'
+module Origen
+  module Fuses
+    def fuses(expr = nil)
+      if expr.nil?
+        if @_fuses.nil?
+          @_fuses = {}
+        elsif @_fuses.is_a? Hash
+          if @_fuses.empty?
+            @_fuses
+          else
+            @_fuses.ids
+          end
+        else
+          @_fuses = {}
+        end
+      else
+        @_fuses.recursive_find_by_key(expr)
+      end
+    end
+
+    def fuse_field(name, start_addr, size, options = {})
+      @_fuses ||= {}
+      if fuses.respond_to? :name
+        Origen.log.error("Cannot create fuse field '#{name}', it already exists!")
+        fail
+      end
+      @_fuses[name] = FuseField.new(name, start_addr, size, self, options)
+    end
+  end
+end

data/lib/origen/fuses/fuse_field.rb

@@ -0,0 +1,45 @@
+module Origen
+  module Fuses
+    # Currently just a simple data container most suited for import from Excel/CSV/XML
+    # by stuffing all attributes into the options hash
+    class FuseField
+      attr_accessor :name, :size, :start_addr, :owner
+
+      def initialize(name, start_addr, size, owner, options = {})
+        options = {
+          default_value: 0
+        }.merge(options)
+        @name, @start_addr, @size, @owner = name, start_addr, size, owner
+        # Check if the start address is in Verilog format or includes the number base in it
+        if @start_addr.is_a? String
+          if @start_addr.is_verilog_number? || @start_addr.match(/^0[x,o,d,b]\S+/)
+            @start_addr = @start_addr.to_dec
+          end
+        end
+        unless @size.is_a?(Numeric) && @start_addr.size.is_a?(Numeric)
+          Origen.log.error("Fuse fields must have numeric attributes for 'size' and 'start_addr'!")
+          fail
+        end
+        # If the fuse field is owned by Top Level DUT then keep the start address as-is
+        # If not, then add the fuse field start address to the base address of the IP
+        unless owner.is_top_level?
+          @start_addr += owner.base_address if owner.respond_to?(:base_address)
+        end
+        options.each do |o, val|
+          instance_eval("def #{o};@#{o};end") # getter
+          instance_eval("def #{o}=(val);@#{o}=val;end") # setter
+          ivar_name = "@#{o}".to_sym
+          instance_variable_set(ivar_name, options[o])
+        end
+
+        def reprogrammeable?
+          self.respond_to?(:reprogrammeable) ? reprogrammeable : true
+        end
+
+        def customer_visible?
+          self.respond_to?(:customer_visible) ? customer_visible : false
+        end
+      end
+    end
+  end
+end

data/lib/origen/model.rb

@@ -25,6 +25,7 @@ module Origen
       include Origen::Netlist
       include Origen::Memory
       include Origen::Errata
+      include Origen::Fuses
     end
 
     module ClassMethods

data/lib/origen/site_config.rb

@@ -6,24 +6,34 @@ module Origen
     TRUE_VALUES = ['true', 'TRUE', '1', 1]
     FALSE_VALUES = ['false', 'FALSE', '0', 0]
 
+    # Define a couple of site configs variables that need a bit of processing
+
+    # Gets the gem_intall_dir. This is either site_config.home_dir/gems or the site configs gem_install_dir
+    def gem_install_dir
+      return "#{tool_repo_install_dir}/gems" if gems_use_tool_repo && tool_repo_install_dir && !user_install_enable
+      dir = find_val('user_gem_dir')
+      unless dir
+        dir = "#{find_val('home_dir')}/gems"
+      end
+      dir
+    end
+
+    # Gets the user_install_dir. Like gem_install_dir, this default to somewhere home_dir, unless overridden
+    def user_install_dir
+      dir = find_val('user_install_dir')
+      unless dir
+        dir = find_val('home_dir')
+      end
+      dir
+    end
+
     def method_missing(method, *args, &block)
       method = method.to_s
       if method =~ /(.*)!$/
         method = Regexp.last_match(1)
         must_be_present = true
       end
-      env = "ORIGEN_#{method.upcase}"
-      if ENV.key?(env)
-        val = ENV[env]
-        if TRUE_VALUES.include?(val)
-          val = true
-        elsif FALSE_VALUES.include?(val)
-          val = false
-        end
-      else
-        config = configs.find { |c| c.key?(method) }
-        val = config ? config[method] : nil
-      end
+      val = find_val(method)
       if must_be_present && val.nil?
         puts "No value assigned for site_config attribute '#{method}'"
         puts
@@ -37,6 +47,22 @@ module Origen
 
     private
 
+    def find_val(val, options = {})
+      env = "ORIGEN_#{val.upcase}"
+      if ENV.key?(env)
+        config = ENV[env]
+        if TRUE_VALUES.include?(val)
+          config = true
+        elsif FALSE_VALUES.include?(val)
+          config = false
+        end
+        config
+      else
+        config = configs.find { |c| c.key?(val) }
+        config ? config[val] : nil
+      end
+    end
+
     def configs
       @configs ||= begin
         # This global is set when Origen is first required, it generally means that what is considered
@@ -50,21 +76,31 @@ module Origen
         # directory area
         until path.root?
           file = File.join(path, 'config', 'origen_site_config.yml')
-          configs << YAML.load_file(file) if File.exist?(file)
+          configs << YAML.load_file(file) if File.exist?(file) && YAML.load_file(file)
           file = File.join(path, 'origen_site_config.yml')
-          configs << YAML.load_file(file) if File.exist?(file)
+          configs << YAML.load_file(file) if File.exist?(file) && YAML.load_file(file)
           path = path.parent
         end
         # Add and any site_configs from the directory hierarchy where Ruby is installed
         path = Pathname.new($LOAD_PATH.last)
         until path.root?
           file = File.join(path, 'origen_site_config.yml')
-          configs << YAML.load_file(file) if File.exist?(file)
+          configs << YAML.load_file(file) if File.exist?(file) && YAML.load_file(file)
           path = path.parent
         end
         # Add the one from the Origen core as the lowest priority, this one defines
         # the default values
         configs << YAML.load_file(File.expand_path('../../../origen_site_config.yml', __FILE__))
+        # Add the site_config from the user's home directory as highest priority, if it exists
+        # But, make sure we take the site installation's setup into account.
+        # That is, if user's home directories are somewhere else, make sure we use that directory to the find
+        # the user's overwrite file. The user can then override that if they want."
+        install_path = configs.find { |c| c.key?('home_dir') }
+        install_path = install_path ? install_path['home_dir'] : nil
+        install_path.nil? ? user_config = nil : user_config =  File.join(File.expand_path(install_path), 'origen_site_config.yml')
+        if user_config && File.exist?(user_config)
+          configs.unshift(YAML.load_file(user_config)) if YAML.load_file(user_config)
+        end
         configs
       end
     end

data/origen_site_config.yml

@@ -2,11 +2,39 @@
 
 # If your company has an internal gem server enter it here
 #gem_server: http://gems.company.net:9292
+
 # When true Origen will configure and run Bundler in a consistent way for every
 # user (recommended)
 gem_manage_bundler: true
-# Where user's local gems will be installed if gem_manage_bundler is set to true.
-gem_install_dir: ~/.origen/gems
+
+# Define where a typical user's home directory will be, with a hidden directory for Origen.
+home_dir: ~/.origen
+
+# Define where the gems should be installed
+# By default, this will be at <home_dir>/gems but can be overridden here.
+#gem_install_dir: ~/.origen/gems
+
+# ORIGEN STARTUP OPTIONS
+# These options define how and where Origen should boot.
+# See the guides at advanced/invocations for additional details.
+
+# By default, don't allow user install. This is more for power users to utilize for debug or those who want absolute 
+# control over their environment.
+user_install_enable: false
+
+# Default to the user's install dir being the .origen in their home directory but allow it to be overridden
+#user_install_dir: ~/.origen
+
+# Default 'tool_repo_install_dir' to nil, meaning no 'tool_repo_install_dir' is present. If neither this nor 
+# 'user_install_enable' is present, the universal install will be used.
+#tool_repo_install_dir: nil
+
+# If 'tool_repo_install_dir' is set, then, by default, Bundler will use and build the gems in the tool repo.
+# Purpose of this, is to allow a power user to setup and install these gems and for individuals to just use.
+# Added this parameter and set to true so that this will be the default behavior. Otherwise, gem_install_dir
+# would need to be overwritten and set with the 'tool_repo_install_dir'
+gems_use_tool_repo: true
+
 # Some gems can be difficult to install reliably across individual user environments.
 # Such gems can be installed to a communal system Ruby and then listed here, Origen
 # will then use the system version of the given gem instead of trying to install
@@ -16,6 +44,7 @@ gem_use_from_system:
   - [nokogiri, 1.6.4.1] # Only required for earlier versions of Origen
   - [nokogiri, 1.6.7.2] # Only required for earlier versions of Origen
   - [nokogiri, 1.7.2]
+
 # Additionally any build switches/options that are required to build specific gems
 # in your user environment can be defined here.
 #gem_build_switches:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.20.3
+  version: 0.21.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-02 00:00:00.000000000 Z
+date: 2017-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -459,6 +459,8 @@ files:
 - lib/origen/features.rb
 - lib/origen/features/feature.rb
 - lib/origen/file_handler.rb
+- lib/origen/fuses.rb
+- lib/origen/fuses/fuse_field.rb
 - lib/origen/generator.rb
 - lib/origen/generator/comparator.rb
 - lib/origen/generator/compiler.rb