origen 0.28.2 → 0.29.0

data/lib/origen/ports/port.rb

@@ -71,7 +71,7 @@ module Origen
       def drive(value = nil, options = {})
         value, options = nil, value if value.is_a?(Hash)
         if options[:index]
-          if options[:index].is_a?(Fixnum)
+          if options[:index].is_a?(Integer)
             drive_values[options[:index]] = value ? value[0] : nil
           else
             options[:index].to_a.each do |i|

data/lib/origen/registers.rb

@@ -516,7 +516,7 @@ module Origen
     # Can also be used to define a new register if a block is supplied in which case
     # it is equivalent to calling add_reg with a block.
     def reg(*args, &block)
-      if block_given? || (args[1].is_a?(Fixnum) && !try(:_initialized?))
+      if block_given? || (args[1].is_a?(Integer) && !try(:_initialized?))
         @reg_define_file = define_file(caller[0])
         add_reg(*args, &block)
       else

data/lib/origen/registers/reg.rb

@@ -1095,7 +1095,7 @@ module Origen
           args.flatten!
           args.sort!
           args.each do |arg_item|
-            if arg_item.is_a?(Fixnum)
+            if arg_item.is_a?(Integer)
               b = get_bits_with_constraint(arg_item, constraint)
               collection << b if b
             elsif arg_item.is_a?(Range)

data/lib/origen/remote_manager.rb

@@ -22,9 +22,9 @@ module Origen
           Origen.log.info 'The following remotes need to be updated, this will now happen automatically:'
           dirty_remotes.each do |name, remote|
             if remote[:path]
-              Origen.log.info "  #{name} - #{remote[:path]}".green
+              Origen.log.info "  #{name} - #{remote[:path]} (included by #{remote[:importer].name})".green
             else
-              Origen.log.info "  #{name} - #{remote[:version]}".green
+              Origen.log.info "  #{name} - #{remote[:version]} (included by #{remote[:importer].name})".green
             end
           end
           Origen.log.info ''
@@ -216,11 +216,13 @@ module Origen
       @remotes = {}
       top_level_remotes
       top_level_remotes.each do |remote|
+        remote[:importer] = Origen.app
         add_remote(remote)
       end
       # Add remotes from imports
       Origen.app.plugins.each do |plugin|
         plugin.config.remotes.each do |import_remote|
+          import_remote[:importer] = plugin
           add_remote(import_remote) unless import_remote[:development]
         end
       end
@@ -292,20 +294,28 @@ module Origen
           rc_url = remote[:rc_url] || remote[:vault]
           tag = Origen::VersionString.new(remote[:version])
           version_file = dir.to_s + '/.current_version'
-          if File.exist?("#{dir}/.initial_populate_successful")
-            FileUtils.rm_f(version_file) if File.exist?(version_file)
-            rc = RevisionControl.new remote: rc_url, local: dir
-            rc.checkout version: prefix_tag(tag), force: true
-            File.open(version_file, 'w') do |f|
-              f.write tag
-            end
-          else
-            rc = RevisionControl.new remote: rc_url, local: dir
-            rc.checkout version: prefix_tag(tag), force: true
-            FileUtils.touch "#{dir}/.initial_populate_successful"
-            File.open(version_file, 'w') do |f|
-              f.write tag
+          begin
+            if File.exist?("#{dir}/.initial_populate_successful")
+              FileUtils.rm_f(version_file) if File.exist?(version_file)
+              rc = RevisionControl.new remote: rc_url, local: dir
+              rc.checkout version: prefix_tag(tag), force: true
+              File.open(version_file, 'w') do |f|
+                f.write tag
+              end
+            else
+              rc = RevisionControl.new remote: rc_url, local: dir
+              rc.checkout version: prefix_tag(tag), force: true
+              FileUtils.touch "#{dir}/.initial_populate_successful"
+              File.open(version_file, 'w') do |f|
+                f.write tag
+              end
             end
+          rescue Origen::GitError, Origen::DesignSyncError => e
+            # If Git failed in the remote, its usually easy to see what the problem is, but now *where* it is.
+            # This will prepend the failing remote along with the error from the revision control system,
+            # then rethrow the error
+            e.message.prepend "When updating remotes for #{remote[:importer].name}: "
+            raise e
           end
         end
       end

data/lib/origen/site_config.rb

@@ -2,6 +2,7 @@ module Origen
   class SiteConfig
     require 'pathname'
     require 'yaml'
+    require 'etc'
 
     TRUE_VALUES = ['true', 'TRUE', '1', 1]
     FALSE_VALUES = ['false', 'FALSE', '0', 0]
@@ -10,13 +11,109 @@ module Origen
 
     # 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
-      find_val('user_gem_dir') || find_val('gem_install_dir') || "#{find_val('home_dir')}/gems"
+      if gems_use_tool_repo && tool_repo_install_dir && !user_install_enable
+        path = eval_path(tool_repo_install_dir)
+      else
+        path = eval_path(find_val('user_gem_dir') || find_val('gem_install_dir') || home_dir)
+      end
+
+      append = find_val('append_gems')
+      append = 'gems' if append == true || append.nil?
+
+      if append
+        unless path.end_with?(append)
+          path = File.join(path, append)
+        end
+      end
+      path
     end
+    alias_method :user_gem_dir, :gem_install_dir
 
     # Gets the user_install_dir. Like gem_install_dir, this default to somewhere home_dir, unless overridden
     def user_install_dir
-      find_val('user_install_dir') || find_val('home_dir')
+      eval_path(find_val('user_install_dir') || home_dir)
+    end
+
+    def home_dir
+      eval_path(find_val('home_dir') || '~/')
+    end
+
+    def eval_path(path, options = {})
+      # Expand the first path. This will take care of replacing any leading ~/ with the home directory.
+      if path.start_with?('\\')
+        path[0] = ''
+      else
+        path = File.expand_path(path)
+      end
+
+      # Gsub the remaining ~ that aren't escaped.
+      # If it was escaped, eat the escape character
+      path.gsub!(/(?<!\\|\A)~/, "#{Etc.getlogin}")
+      path.gsub!(/\\(?=~)/, '')
+
+      append = find_val('append_dot_origen')
+      append = '.origen' if append == true || append.nil?
+
+      if append
+        unless path.end_with?(append)
+          path = File.join(path, append)
+        end
+      end
+      path
+    end
+
+    # Dynamically remove the highest instance of :var
+    def remove_highest(var)
+      @configs.each do |c|
+        if c.key?(var)
+          return c.delete(var)
+        end
+      end
+
+      # return nil if we haven't returned a value yet
+      nil
+    end
+
+    # Dynamically remove all the instances of :var
+    def remove_all_instances(var)
+      # Iterate though all the site configs, removing every instance of :var
+      # Return an array containing the value of :var at each config,
+      # from lowest priority to highest.
+      # If [] is returned, it implies that there was no instancs of :var to be removed.
+      ret = []
+      @configs.each do |c|
+        if c.key?(var)
+          ret << c.delete(var)
+        end
+      end
+      ret
+    end
+    alias_method :purge, :remove_all_instances
+
+    # Dynamically add a new site variable at the highest priority.
+    def add_as_highest(var, value)
+      # Don't want to override anything, so just shift in a dummy site config instance at the highest level and
+      # set the value there.
+      configs.prepend(var.to_s => value)
+    end
+    alias_method :[]=, :add_as_highest
+
+    # Dynamically add a new site variable at the lowest priority.
+    # Essentially, this sets a new default value.
+    def add_as_lowest(var, value)
+      # Don't want to override anything, so just shift in a dummy site config at the lowest level and
+      # set the value there.
+      configs.append(var.to_s => value)
+    end
+
+    # Adds a new site config file as the highest priority
+    def add_site_config_as_highest(site_config_file)
+      configs.prepend YAML.load_file(File.expand_path('../../../origen_site_config.yml', __FILE__))
+    end
+
+    # Adds a new site config file as the highest priority
+    def add_site_config_as_lowest(site_config_file)
+      configs.append YAML.load_file(File.expand_path('../../../origen_site_config.yml', __FILE__))
     end
 
     def method_missing(method, *args, &block)
@@ -32,31 +129,61 @@ module Origen
         fail 'Missing site_config value!'
       end
       define_singleton_method(method) do
-        val
+        find_val(method)
       end
       val
     end
 
+    def get(val)
+      find_val(val)
+    end
+    alias_method :[], :get
+
+    def get_all(val)
+      ret = []
+      @configs.each do |c|
+        if c.key?(val)
+          ret << c[val]
+        end
+      end
+      ret
+    end
+
+    def clear
+      @configs.clear
+    end
+
+    def rebuild!
+      configs!
+    end
+
     private
 
     def find_val(val, options = {})
       env = "ORIGEN_#{val.upcase}"
       if ENV.key?(env)
-        val = ENV[env]
-        if TRUE_VALUES.include?(val)
-          return true
-        elsif FALSE_VALUES.include?(val)
-          return false
-        end
-        val
+        value = ENV[env]
+        value
       else
         config = configs.find { |c| c.key?(val) }
-        config ? config[val] : nil
+        value = config ? config[val] : nil
+      end
+
+      if TRUE_VALUES.include?(value)
+        return true
+      elsif FALSE_VALUES.include?(value)
+        return false
       end
+      value
     end
 
     def configs
-      @configs ||= begin
+      @configs ||= configs!
+    end
+
+    # Forces a reparse of the site configs.
+    def configs!
+      @configs = begin
         # This global is set when Origen is first required, it generally means that what is considered
         # to be the pwd for the purposes of looking for a site_config file is the place from where the
         # user invoked Origen. Otherwise if the running app switches the PWD it can lead to confusing

data/lib/origen/specs/checkers.rb

@@ -72,7 +72,7 @@ module Origen
       end
 
       def evaluate_limit(limit)
-        return limit if [Fixnum, Float, Numeric].include? limit.class
+        return limit if limit.is_a?(Numeric)
         return nil if limit.nil?
         limit = limit.to_s if [Nokogiri::XML::NodeSet, Nokogiri::XML::Text, Nokogiri::XML::Element].include? limit.class
         if limit.is_a? Symbol
@@ -132,7 +132,7 @@ module Origen
           begin
             result = eval(limit)
             return result.round(4) if result.is_a? Numeric
-            rescue SyntaxError, NameError, TypeError
+            rescue ::SyntaxError, ::NameError, ::TypeError
               Origen.log.debug "Limit '#{limit}' had to be rescued, storing it as a #{limit.class}"
               if limit.is_a? Symbol
                 return limit

data/lib/origen/sub_blocks.rb

@@ -314,9 +314,14 @@ module Origen
         @attributes = @attributes.merge(attrs)
       end
 
+      # Make this appear like a sub-block to any application code
+      def class
+        klass
+      end
+
       # Make this appear like a sub-block to any application code
       def is_a?(klass)
-        klass == self.klass || klass == self.class
+        klass == self.klass || klass == Placeholder
       end
 
       # Make it look like a sub-block in the console to avoid confusion

data/lib/origen/value.rb

@@ -0,0 +1,119 @@
+module Origen
+  # This class wraps various different class which handle number representation in
+  # various formats.
+  #
+  # The user should never instantiate those directly and should always instantiate an
+  # Origen::Value instance, thereby ensuring a common API regardless of the internal
+  # representation and handling of the value
+  class Value
+    autoload :HexStrVal, 'origen/value/hex_str_val'
+    autoload :BinStrVal, 'origen/value/bin_str_val'
+
+    # Represents a single bit value of 'X'
+    class X
+      def z?
+        false
+      end
+      alias_method :hi_z?, :z?
+
+      def x?
+        true
+      end
+      alias_method :undefined?, :x?
+
+      def x_or_z?
+        true
+      end
+      alias_method :z_or_x?, :x_or_z?
+    end
+
+    # Represents a single bit value of 'Y'
+    class Z
+      def z?
+        true
+      end
+      alias_method :hi_z?, :z?
+
+      def x?
+        false
+      end
+      alias_method :undefined?, :x?
+
+      def x_or_z?
+        true
+      end
+      alias_method :z_or_x?, :x_or_z?
+    end
+
+    def initialize(val, options = {})
+      if val.is_a?(Integer)
+        @val = val
+      else
+        val = val.to_s
+        case val[0].downcase
+        when 'b'
+          @val = BinStrVal.new(val, options)
+        when 'h'
+          @val = HexStrVal.new(val, options)
+        when 'd'
+          @val = val.to_s[1..-1].to_i
+        else
+          if  val =~ /^[0-9]+$/
+            @val = val.to_i
+          else
+            fail 'Unsupported value syntax'
+          end
+        end
+      end
+    end
+
+    # Returns true if all bits have a numeric value - i.e. no X or Z
+    def numeric?
+      val.numeric?
+    end
+
+    def value?
+      true
+    end
+
+    # Converts to an integer, returns nil if the value contains non-numeric bits
+    def to_i
+      val.to_i
+    end
+
+    # Converts to a string, the format of it depends on the underlying value type
+    def to_s
+      val.to_s
+    end
+
+    # Returns the size of the value in bits
+    def size
+      val.size
+    end
+    alias_method :bits, :size
+    alias_method :number_of_bits, :size
+
+    def hex_str_val?
+      val.is_a?(HexStrVal)
+    end
+    alias_method :hex_str_value?, :hex_str_val?
+
+    def bin_str_val?
+      val.is_a?(BinStrVal)
+    end
+    alias_method :bin_str_value?, :bin_str_val?
+
+    def [](index)
+      if index.is_a?(Range)
+        fail 'Currently, only single bit extraction from a Value object is supported'
+      end
+      val[index]
+    end
+
+    private
+
+    def val
+      @val
+    end
+  end
+end

data/lib/origen/value/bin_str_val.rb

@@ -0,0 +1,72 @@
+module Origen
+  class Value
+    # Handles a value represented by a string of bin character(s) [0, 1, x, z]
+    #
+    # Capital X/Z will be accepted when defining the value, but they will be converted
+    # to lower case
+    class BinStrVal
+      attr_reader :val, :size
+
+      def initialize(value, options)
+        @val = clean(value)
+        if options[:size]
+          @size = options[:size]
+          # Trim any bits that are out of range...
+          @val = val.split(//).last(size).join
+        else
+          @size = val.size
+        end
+      end
+
+      def numeric?
+        !!(val =~ /^[01]+$/)
+      end
+
+      def to_i
+        if numeric?
+          val.to_i(2) & size.bit_mask
+        end
+      end
+
+      def to_s
+        "b#{val}"
+      end
+
+      # Returns the value of the given bit.
+      # Return nil if out of range, otherwise 0, 1 or an X or Z object
+      def [](index)
+        unless index > (size - 1)
+          if numeric?
+            to_i[index]
+          else
+            char = val[val.size - 1 - index]
+            if char == 'x'
+              X.new
+            elsif char == 'z'
+              Z.new
+            else
+              char.to_i
+            end
+          end
+        end
+      end
+
+      private
+
+      def clean(val)
+        val = val.to_s.strip.to_s[1..-1]
+        if valid?(val)
+          val.gsub('_', '').downcase
+        end
+      end
+
+      def valid?(val)
+        if val =~ /^[01_xXzZ]+$/
+          true
+        else
+          fail Origen::SyntaxError, 'Binary string values can only contain: 0, 1, _, x, X, z, Z'
+        end
+      end
+    end
+  end
+end