origen 0.31.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 437a40756e6194c3308c3044388d48c4c0b0c31c
-  data.tar.gz: d9341d81f27c7bbbf014fe26844d67f53bc1facf
+  metadata.gz: 4b636bd97c227eecf2344ccbdc17e29712953325
+  data.tar.gz: cd69d451f85313509d2a2c4a31887cbf81fb57c2
 SHA512:
-  metadata.gz: 8ce734ee2bd0f466c05c38c7a9205ac7bfbee4165780bfdca9c57f4eb3390b49819882a43e0c24f512f4b65c866a2edf5c057b6c6eb4015d7bea48c1cbbfa3a5
-  data.tar.gz: 967eafac1a53b990d7b8b5f689278f27527ece71e76cfd6db63faecd7d8b4dbce5a8c87c96c037c1451925267b52d5216179f1108d06183c9dd21ad65188f996
+  metadata.gz: 4e104a65bd531b7e52ec7f9f74d002b822d004fb0c46556e412392c3b874101a8be06c27fd83bb05e35acad5fa3b2c62251d9ba729a5de08dc472004ffd11b57
+  data.tar.gz: dc29b4f3a4567780af525fc9b023bae374af3d71ed96f241e294ae35aba9d241009f4496d4c7f25c112dca0a8d3978b3f6223b378488b8dc967bbabff6501af6

data/config/version.rb

@@ -1,6 +1,6 @@
 module Origen
   MAJOR = 0
-  MINOR = 31
+  MINOR = 32
   BUGFIX = 0
   DEV = nil
 

data/lib/origen/application/runner.rb

@@ -79,6 +79,7 @@ module Origen
               else
                 if options[:action] == :program
                   Origen.generator.generate_program(expand_lists_and_directories(options[:files], options), options)
+                  Origen.app.listeners_for(:program_generated).each(&:program_generated)
                 else
                   temporary_plugin_from_options = options[:current_plugin]
                   expand_lists_and_directories(options[:files], options).each do |file|

data/lib/origen/clocks/clock.rb

@@ -1,16 +1,18 @@
 module Origen
   module Clocks
     class Clock
-      attr_accessor :id, :owner, :users, :startup_freq, :nominal_freq, :frequency_range, :setpoint
+      attr_accessor :id, :owner, :users, :freq_target, :freq_range, :setpoint, :instantiate_users
 
       def initialize(id, owner, options = {}, &block)
         @id = id
         @owner = owner
         @id = @id.symbolize unless id.is_a? Symbol
+        @instantiate_users = true
         options.each { |k, v| instance_variable_set("@#{k}", v) }
         (block.arity < 1 ? (instance_eval(&block)) : block.call(self)) if block_given?
         @users = [@users] unless @users.is_a? Array
-        instantiate_users
+        add_users_sub_blocks if @instantiate_users
+        @setpoint = @freq_target
       end
 
       def name
@@ -21,29 +23,30 @@ module Origen
       def users
         @users
       end
-      alias_method :ips, :users
-      alias_method :sub_blocks, :users
 
       def setpoint=(val)
-        setpoint_ok?
-        @setpoint = val
+        if val == :gated || val == 'gated'
+          @setpoint = :gated
+        else
+          setpoint_ok?(val) # This just warns if the clock is set out of range
+          @setpoint = val
+        end
       end
 
       def setpoint_ok?(val = nil)
-        return nil if val.nil? && setpoint.nil?
-        if freq_range == :fixed
-          if val.nil? || val == nominal_frequency
+        val = @setpoint if val.nil?
+        if @freq_range == :fixed
+          if val == @freq_target
             return true
           else
-            Origen.log.warn("Clock '#{id}' is a fixed clock with a nominal frequency of #{nominal_frequency.as_Hz}, setting it to #{val.as_Hz}")
+            Origen.log.warn("Clock '#{id}' is a fixed clock with a target frequency of #{@freq_target.as_Hz}")
             return false
           end
         else
-          val = setpoint if val.nil?
-          if freq_range.include?(val)
+          if @freq_range.include?(val)
             return true
           else
-            Origen.log.warn("Setpoint (#{setpoint_string(val)}) for clock '#{id}' is not within the frequency range (#{freq_range_string}), setting it to #{val.as_Hz}")
+            Origen.log.warn("Setpoint (#{setpoint_string(val)}) for clock '#{id}' is not within the frequency range (#{freq_range_string})")
             return false
           end
         end
@@ -51,17 +54,10 @@ module Origen
       alias_method :value_ok?, :setpoint_ok?
       alias_method :val_ok?, :setpoint_ok?
 
-      # Set the clock to the nominal frequency
-      def setpoint_to_nominal
-        @setpoint = nominal_frequency
-      end
-
-      # Nominal frequency
-      def nominal_frequency
-        @nominal_frequency
+      # Set the clock to the target frequency
+      def setpoint_to_target
+        @setpoint = @freq_target
       end
-      alias_method :nominal, :nominal_frequency
-      alias_method :nom, :nominal_frequency
 
       # Current setpoint, defaults top nil on init
       def setpoint
@@ -71,11 +67,34 @@ module Origen
       alias_method :value, :setpoint
 
       # Acceptable frequency range
-      def frequency_range
-        @frequency_range
+      def freq_range
+        @freq_range
+      end
+      alias_method :range, :freq_range
+
+      # Acceptable frequency range
+      def freq_target
+        @freq_target
+      end
+      alias_method :target, :freq_target
+
+      # min method
+      def min
+        if @freq_range == :fixed
+          @freq_target
+        else
+          @freq_range.first
+        end
+      end
+
+      # max method
+      def max
+        if @freq_range == :fixed
+          @freq_target
+        else
+          @freq_range.last
+        end
       end
-      alias_method :freq_range, :frequency_range
-      alias_method :range, :frequency_range
 
       # Check if the clock users are defined anywhere in the DUT
       def users_defined?
@@ -108,12 +127,12 @@ module Origen
       private
 
       # Instantiate and IP/users that use/access the clock
-      def instantiate_users
-        users.each do |ip|
-          if owner.respond_to? ip
+      def add_users_sub_blocks
+        @users.each do |ip|
+          if @owner.respond_to? ip
             next
           else
-            owner.sub_block ip
+            @owner.sub_block ip
           end
         end
       end
@@ -130,20 +149,20 @@ module Origen
       end
 
       def frequencies_ok?
-        if nominal_frequency.nil?
+        if @freq_target.nil?
           false
-        elsif frequency_range.nil?
+        elsif @freq_range.nil?
           Origen.log.error("Missing frequency range for clock '#{name}'!")
           false
-        elsif frequency_range.is_a? Range
-          if frequency_range.include?(nominal_frequency)
+        elsif freq_range.is_a? Range
+          if freq_range.include?(@freq_target)
             true
           else
-            Origen.log.error("PPEKit: Nominal frequency #{nominal_frequency} is not inbetween the frequency range #{frequency_range} for clock '#{name}'!")
+            Origen.log.error("PPEKit: Frequency target #{@freq_target} is not inbetween the frequency range #{freq_range} for clock '#{name}'!")
             false
           end
         else
-          Origen.log.error("Clock attribute 'frequency_range' must be a Range!")
+          Origen.log.error("Clock attribute 'freq_range' must be a Range!")
           return_value = false
         end
       end
@@ -157,24 +176,24 @@ module Origen
       end
 
       def freq_range_string
-        start_freq = freq_range.first
-        end_freq = freq_range.last
+        start_freq = @freq_range.first
+        end_freq = @freq_range.last
         "#{start_freq.as_Hz}\.\.#{end_freq.as_Hz}"
       end
 
       def clock_freqs_ok?
-        if nominal_freq.nil?
+        if @freq_target.nil?
           false
-        elsif freq_range == :fixed
+        elsif @freq_range == :fixed
           true
         else
-          if freq_range.nil?
+          if @freq_range.nil?
             Origen.log.error("PPEKit: Missing frequency target or range for clock '#{id}'!")
             false
-          elsif freq_range.include?(nominal_freq)
+          elsif @freq_range.include?(@freq_target)
             true
           else
-            Origen.log.error("PPEKit: Frequency target #{nominal_freq} is not inbetween the freq range #{freq_range} for clock '#{id}'!")
+            Origen.log.error("PPEKit: Frequency target #{@freq_target} is not inbetween the freq range #{@freq_range} for clock '#{id}'!")
             false
           end
         end

data/lib/origen/commands/web.rb

@@ -92,7 +92,11 @@ The following options are available:
     server.close
     # Start the server
     puts ''
-    puts "Point your browser to this address:  http://#{host}#{domain.empty? ? '' : '.' + domain}:#{port}"
+    if host.include? domain
+      puts "Point your browser to this address:  http://#{host}:#{port}"
+    else
+      puts "Point your browser to this address:  http://#{host}#{domain.empty? ? '' : '.' + domain}:#{port}"
+    end
     puts ''
     puts 'To shut down the server use CTRL-C'
     puts ''

data/lib/origen/file_handler.rb

@@ -210,9 +210,10 @@ module Origen
       file = inject_import_path(file, type: :template)
       file = add_underscore_to(file)
       file = add_extension_to(file)
+      web_file = file =~ /\.(html|md)(\.|$)/
       begin
         # Allow relative references to templates/web when compiling a web template
-        if Origen.lsf.current_command == 'web'
+        if Origen.lsf.current_command == 'web' || web_file
           clean_path_to(file, load_paths: "#{Origen.root}/templates/web")
         else
           clean_path_to(file)
@@ -220,7 +221,7 @@ module Origen
       rescue
         # Try again without .erb
         file = file.gsub('.erb', '')
-        if Origen.lsf.current_command == 'web'
+        if Origen.lsf.current_command == 'web' || web_file
           clean_path_to(file, load_paths: "#{Origen.root}/templates/web")
         else
           clean_path_to(file)

data/lib/origen/generator/pattern.rb

@@ -349,10 +349,21 @@ module Origen
 
         unless options[:inhibit] || !Origen.tester.generate? || job.test?
           stats.collect_for_pattern(job.output_pattern) do
-            File.open(job.output_pattern, 'w') do |f|
-              [:header, :body, :footer].each do |section|
-                Origen.tester.format(stage.bank(section), section) do |line|
-                  f.puts line
+            # If the tester is going to deal with writing out the final pattern. The use case for this is when
+            # the pattern is comprised of multiple files instead of the more conventional case here which each
+            # pattern is one file.
+            if tester.respond_to?(:open_and_write_pattern)
+              tester.open_and_write_pattern(job.output_pattern) do
+                [:header, :body, :footer].each do |section|
+                  Origen.tester.format(stage.bank(section), section)
+                end
+              end
+            else
+              File.open(job.output_pattern, 'w') do |f|
+                [:header, :body, :footer].each do |section|
+                  Origen.tester.format(stage.bank(section), section) do |line|
+                    f.puts line
+                  end
                 end
               end
             end
@@ -362,7 +373,7 @@ module Origen
           log.info "Pattern vectors: #{stats.number_of_vectors_for(job.output_pattern).to_s.ljust(10)}"
           log.info 'Execution time'.ljust(15) + ': %.6f' % stats.execution_time_for(job.output_pattern)
           log.info '----------------------------------------------------------------------'
-          check_for_changes(job.output_pattern, job.reference_pattern)
+          check_for_changes(job.output_pattern, job.reference_pattern) unless tester.try(:disable_pattern_diffs)
           stats.record_pattern_completion(job.output_pattern)
         end
 

data/lib/origen/limits/limit.rb

@@ -0,0 +1,126 @@
+module Origen
+  module Limits
+    class Limit
+      attr_accessor :expr, :value, :owner, :type
+
+      def initialize(expr, type, owner, options = {})
+        @expr = expr
+        @owner = owner
+        @type = type
+        @value = evaluate_expr
+      end
+
+      # If the value is still a String then it could be
+      # due to referencing another LimitSet that is
+      # yet to be defined
+      def value
+        if @value.is_a?(String)
+          evaluate_expr
+        else
+          @value
+        end
+      end
+
+      # Backwards compatibility
+      def exp
+        @expr
+      end
+
+      private
+
+      def fetch_reference_value(ref)
+        ref = ref.to_sym unless ref.is_a?(Symbol)
+        # Check if the reference is to another limit set
+        if owner.limits.include? ref
+          return owner.limits(ref).send(type).value
+          # Check if the reference is to a power domain
+        end
+        if Origen.top_level.respond_to? :power_domains
+          if Origen.top_level.power_domains.include? ref
+            # Need to check the limit type and retrieve the appropriate value
+            case @type.to_s
+            when /target|typ/
+              return Origen.top_level.power_domains(ref).nominal_voltage
+            else
+              return Origen.top_level.power_domains(ref).send(@type)
+            end
+          end
+        end
+        # Check if the reference is to a clock
+        if Origen.top_level.respond_to? :clocks
+          if Origen.top_level.clocks.include? ref
+            # Need to check the limit type and retrieve the appropriate value
+            case @type.to_s
+            when /target|typ/
+              return Origen.top_level.clocks(ref).freq_target
+            else
+              return Origen.top_level.clocks(ref).send(@type)
+            end
+          end
+        end
+      end
+
+      def evaluate_expr
+        return @expr if @expr.is_a?(Numeric)
+        return nil if @expr.nil?
+        if @expr.is_a? Symbol
+          @expr = ':' + @expr.to_s
+        else
+          @expr.gsub!("\n", ' ')
+          @expr.scrub!
+        end
+        result = false
+        if @expr.match(/\:\S+/)
+          limit_items = @expr.split(/\:|\s+/).reject(&:empty?)
+          if limit_items.size == 1
+            return fetch_reference_value(limit_items.first)
+          else
+            references = @expr.split(/\:|\s+/).select { |var| var.match(/^[a-zA-Z]\S+$/) }
+            new_limit_items = [].tap do |limit_ary|
+              limit_items.each do |item|
+                if references.include? item
+                  limit_ary << fetch_reference_value(item)
+                  next
+                else
+                  limit_ary << item
+                end
+              end
+            end
+            new_limit = new_limit_items.join(' ')
+            new_limit_references = new_limit.split(/\:|\s+/).select { |var| var.match(/^[a-zA-Z]\S+$/) }
+            if new_limit_references.empty?
+              result = eval(new_limit).round(4)
+            else
+              return @expr
+            end
+          end
+        elsif !!(@expr.match(/^\d+\.\d+$/)) || !!(@expr.match(/^-\d+\.\d+$/))
+          result = Float(@expr).round(4) rescue false # rubocop:disable Style/RescueModifier
+        elsif !!(@expr.match(/\d+\.\d+\s+\d+\.\d+/))
+          Origen.log.debug "Found two numbers without an operator in the @expr string '#{@expr}', choosing the first..."
+          first_number = @expr.match(/(\d+\.\d+)\s+\d+\.\d+/).captures.first
+          result = Float(first_number).round(4) rescue false # rubocop:disable Style/RescueModifier
+        else
+          result = Integer(@expr) rescue false # rubocop:disable Style/RescueModifier
+        end
+        if result == false
+          # Attempt to eval the @expr because users could write a @expr like "3.3 + 50.mV"
+          # which would not work with the code above but should eval to a number 3.35
+          begin
+            result = eval(@expr)
+            return result.round(4) if result.is_a? Numeric
+            rescue ::SyntaxError, ::NameError, ::TypeError
+              Origen.log.debug "Limit '#{@expr}' had to be rescued, storing it as a #{@expr.class}"
+              if @expr.is_a? Symbol
+                return @expr
+              else
+                return "#{@expr}"
+              end
+          end
+        else
+          return result
+        end
+      end
+    end
+  end
+end

data/lib/origen/limits/limit_set.rb

@@ -0,0 +1,120 @@
+require_relative './limit'
+module Origen
+  module Limits
+    class LimitSet
+      attr_accessor :id, :min, :typ, :max, :target, :description, :static, :owner, :type
+
+      def initialize(id, owner, options)
+        @id = id
+        @description = options[:description]
+        @owner = owner
+        @min = Limit.new(options[:min], :min, @owner) unless options[:min].nil?
+        @typ = Limit.new(options[:typ], :typ, @owner) unless options[:typ].nil?
+        @max = Limit.new(options[:max], :max, @owner) unless options[:max].nil?
+        @target = Limit.new(options[:target], :target, @owner) unless options[:target].nil?
+        unless options[:static].nil?
+          unless [true, false].include? options[:static]
+            Origen.log.error("Static option must be set to 'true' or 'false'!")
+            fail
+          end
+        end
+        @static = options[:static].nil? ? false : options[:static]
+        fail unless limits_ok?
+      end
+
+      # Common alias
+      def name
+        @id
+      end
+
+      def frozen?
+        @static
+      end
+
+      def min=(val)
+        if frozen?
+          Origen.log.warn('Cannot change a frozen limit set!')
+        else
+          @min = Limit.new(val, :min, @owner)
+        end
+      end
+
+      def max=(val)
+        if frozen?
+          Origen.log.warn('Cannot change a frozen limit set!')
+        else
+          @max = Limit.new(val, :max, @owner)
+        end
+      end
+
+      def typ=(val)
+        if frozen?
+          Origen.log.warn('Cannot change a frozen limit set!')
+        else
+          @typ = Limit.new(val, :typ, @owner)
+        end
+      end
+
+      def target=(val)
+        if frozen?
+          Origen.log.warn('Cannot change a frozen limit set!')
+        else
+          @target = Limit.new(val, :target, @owner)
+        end
+      end
+
+      private
+
+      # Check that min, max are not mixed with typ.  If a user wants
+      # a baseline value for a spec use target as it will not be
+      # checked against pass/fail
+      def limits_ok?
+        status = true
+        # Must have at least one of the limit types defined
+        if @min.nil? && @max.nil? && @typ.nil? && @target.nil?
+          Origen.log.error("Limit set #{@id} does not have any limits defined!")
+          return false
+        end
+        if @min.nil? ^ @max.nil?
+          @type = :single_sided
+          unless @typ.nil?
+            status = false
+            Origen.log.error "Limit set #{@id} has a typical limit defined with either min or max.  They are mutually exclusive, use 'target' when using min or max"
+          end
+          # Check if the target is OK
+          unless @target.nil?
+            if @min.nil?
+              unless @target < @max
+                status = false
+                Origen.log.error("Limit set #{@id} has the target value #{@target} set greater than the max value #{@max}!")
+              end
+            else
+              unless @target > @min
+                status = false
+                Origen.log.error("Limit set #{@id} has the target value #{@target} set less than the min value #{@min}!")
+              end
+            end
+          end
+        elsif @min.expr && @max.expr
+          @type = :double_sided
+          # Both min and max must be numerical to compare them
+          if @min.value.is_a?(Numeric) && @max.value.is_a?(Numeric)
+            # Check that min and max make sense
+            if @max.value <= @min.value || @min.value >= @max.value
+              status = false
+              Origen.log.error "Limit set #{@id} has min (#{@min.value}) and max (#{@max.value}) reversed"
+            end
+            # Check that target is OK
+            unless @target.nil?
+              if @target.value <= @min.value || @target.value >= @max.value
+                status = false
+                Origen.log.error "Limit set #{@id} has a target (#{@target.value}) that is not within the min (#{@min.value}) and max #{@max.value}) values"
+              end
+            end
+          end
+        end
+        status
+      end
+    end
+  end
+end

data/lib/origen/limits.rb

@@ -0,0 +1,37 @@
+require_relative './limits/limit'
+require_relative './limits/limit_set'
+module Origen
+  module Limits
+    TYPES = [:min, :typ, :max, :target]
+
+    def add_limits(set, options)
+      @_limits ||= {}
+      options.ids.each do |limit_type|
+        unless TYPES.include? limit_type
+          Origen.log.error("Limit type '#{limit_type}' not supported, choose from #{TYPES}!")
+          fail
+        end
+      end
+      if @_limits.include? set
+        # Limit set already exists, modify it unless it is frozen
+        unless @_limits[set].frozen?
+          options.each do |limit_type, limit_expr|
+            @_limits[set].send("#{limit_type}=", limit_expr)
+          end
+        end
+      else
+        # Create a default limit set
+        @_limits[set] = LimitSet.new(set, self, options)
+      end
+    end
+
+    def limits(set = nil)
+      @_limits ||= {}
+      if set.nil?
+        @_limits
+      else
+        @_limits[set]
+      end
+    end
+  end
+end

data/lib/origen/model/exporter.rb

@@ -11,16 +11,13 @@ module Origen
         }.merge(options)
         # file_path is for internal use, don't pass it from the application, use the :dir option if you
         # want to change where the exported files are
-        if options[:file_path]
-          file = File.join(options[:file_path], "#{name}.rb")
-        else
-          file = export_path(name, options)
-        end
-        file = Pathname.new(file)
-        FileUtils.rm_rf(file.sub_ext('').to_s) if File.exist?(file.sub_ext('').to_s)
-        FileUtils.rm_rf(file.to_s) if File.exist?(file.to_s)
-        FileUtils.mkdir_p(file.dirname)
-        File.open(file, 'w') do |f|
+        file = options[:file_path] || export_path(name, options)
+        dir = options[:dir_path] || export_dir(options)
+        path_to_file = Pathname.new(File.join(dir, file))
+        FileUtils.rm_rf(path_to_file.sub_ext('').to_s) if File.exist?(path_to_file.sub_ext('').to_s)
+        FileUtils.rm_rf(path_to_file.to_s) if File.exist?(path_to_file.to_s)
+        FileUtils.mkdir_p(path_to_file.dirname)
+        File.open(path_to_file, 'w') do |f|
           export_wrap_with_namespaces(f, options) do |indent|
             f.puts((' ' * indent) + 'def self.extended(model)')
             indent += 2
@@ -51,12 +48,15 @@ module Origen
                 ground_pin_groups.each do |id, pins|
                   f.puts export_pin_group(id, pins, indent: indent, method: :add_ground_pin_group)
                 end
+                virtual_pins.each do |id, pin|
+                  f.puts export_pin(id, pin, indent: indent, method: :add_virtual_pin)
+                end
                 f.puts
               end
             end
             if options[:include_sub_blocks]
               sub_blocks.each do |name, block|
-                f.puts export_sub_block(name, block, options.merge(indent: indent, file_path: file))
+                f.puts export_sub_block(name, block, options.merge(indent: indent, file_path: file, dir_path: dir))
               end
               f.puts unless sub_blocks.empty?
             end
@@ -74,10 +74,18 @@ module Origen
       end
 
       def import(name, options = {})
-        path = export_path(name, options)
+        path = File.join(export_dir(options), export_path(name, options))
         if File.exist?(path)
           require path
-          extend "#{Origen.app.namespace.underscore.camelcase}::#{name.to_s.camelcase}".constantize
+          if options.key?(:namespace) && !options[:namespace]
+            extend name.to_s.gsub('.', '_').camelcase.constantize
+          else
+            if options[:namespace]
+              extend "#{options[:namespace].to_s.gsub('.', '_').camelcase}::#{name.to_s.gsub('.', '_').camelcase}".constantize
+            else
+              extend "#{Origen.app.namespace}::#{name.to_s.gsub('.', '_').camelcase}".constantize
+            end
+          end
           true
         else
           if options[:allow_missing]
@@ -143,16 +151,16 @@ module Origen
           if n == ''
             nil
           else
-            n.camelcase
+            n.to_s.gsub('.', '_').camelcase
           end
         end.compact
       end
 
       def export_path(name, options = {})
         if options.key?(:namespace) && !options[:namespace]
-          File.join(export_dir(options), "#{name.to_s.underscore}.rb")
+          "#{name.to_s.underscore}.rb"
         else
-          File.join(export_dir(options), (options[:namespace] || Origen.app.namespace).to_s.underscore, "#{name.to_s.underscore}.rb")
+          File.join((options[:namespace] || Origen.app.namespace).to_s.underscore, "#{name.to_s.underscore}.rb")
         end
       end
 
@@ -173,8 +181,11 @@ module Origen
         line << ", #{pkg_meta}" unless pkg_meta == ''
         Array(options[:attributes]).each do |attr|
           unless (v = pin.send(attr)).nil?
-            if v.is_a?(Numeric)
+            case v
+            when Numeric, Array, Hash
               line << ", #{attr}: #{v}"
+            when Symbol
+              line << ", #{attr}: :#{v}"
             else
               line << ", #{attr}: '#{v}'"
             end
@@ -183,8 +194,11 @@ module Origen
         unless pin.meta.empty?
           line << ', meta: { '
           line << pin.meta.map do |k, v|
-            if v.is_a?(Numeric)
+            case v
+            when Numeric, Array, Hash
               "#{k}: #{v}"
+            when Symbol
+              "#{k}: :#{v}"
             else
               "#{k}: '#{v}'"
             end
@@ -208,9 +222,9 @@ module Origen
 
       def export_sub_block(id, block, options = {})
         indent = ' ' * (options[:indent] || 0)
-        file = File.join(options[:file_path].sub_ext(''), "#{id}.rb")
-        local_file = file.to_s.sub("#{export_dir}/", '')
-        line = indent + "model.sub_block :#{id}, file: '#{local_file}', lazy: true"
+        file_path = File.join(Pathname.new(options[:file_path]).sub_ext(''), "#{id}.rb")
+        dir_path = options[:dir_path]
+        line = indent + "model.sub_block :#{id}, file: '#{file_path}', dir: '#{dir_path}', lazy: true"
         unless block.base_address == 0
           line << ", base_address: #{block.base_address.to_hex}"
         end
@@ -223,7 +237,7 @@ module Origen
             line << ", #{key}: #{value}"
           end
         end
-        block.export(id, options.merge(file_path: options[:file_path].sub_ext('').to_s))
+        block.export(id, options.merge(file_path: file_path, dir_path: dir_path))
         line
       end
 

data/lib/origen/model.rb

@@ -34,6 +34,7 @@ module Origen
       include Origen::Clocks
       include Origen::Model::Exporter
       include Origen::Component
+      include Origen::Limits
     end
 
     module ClassMethods
@@ -205,6 +206,7 @@ module Origen
         unless top_level?
           # Need to do this in case a class besides SubBlock includes Origen::Model
           obj_above_self = parent.nil? ? Origen.top_level : parent
+          return nil if obj_above_self.nil?
           if obj_above_self.current_mode
             _modes[obj_above_self.current_mode.id] if _modes.include? obj_above_self.current_mode.id
           end
@@ -216,6 +218,10 @@ module Origen
     # Set the current mode configuration of the current model
     def current_mode=(id)
       @current_mode = id.is_a?(ChipMode) ? id.id : id
+      Origen.app.listeners_for(:on_mode_changed).each do |listener|
+        listener.on_mode_changed(mode: @current_mode)
+      end
+      @current_mode
     end
     alias_method :mode=, :current_mode=
 

data/lib/origen/parameters.rb

@@ -69,6 +69,18 @@ module Origen
       _parameter_sets.empty? ? false : true
     end
 
+    # Return value of param if it exists, nil otherwise.
+    def param?(name)
+      _param = name.to_s =~ /^params./ ? name.to_s : 'params.' + name.to_s
+      begin
+        val = eval("self.#{_param}")
+      rescue
+        nil
+      else
+        val
+      end
+    end
+
     # @api private
     def _parameter_current
       if path = self.class.parameters_context

data/lib/origen/registers/bit_collection.rb

@@ -109,9 +109,22 @@ module Origen
             v = tester.capture do
               store!(sync: true)
             end
-            reverse_shift_out_with_index do |bit, i|
-              bit.instance_variable_set('@updated_post_reset', true)
-              bit.instance_variable_set('@data', v.first[i])
+            if v.first
+              # Serial shift
+              if v.size == 1
+                reverse_shift_out_with_index do |bit, i|
+                  bit.instance_variable_set('@updated_post_reset', true)
+                  bit.instance_variable_set('@data', v.first[i])
+                end
+              # Parallel shift
+              else
+                reverse_shift_out_with_index do |bit, i|
+                  bit.instance_variable_set('@updated_post_reset', true)
+                  bit.instance_variable_set('@data', v[i].to_i)
+                end
+              end
+            else
+              Origen.log.warning "No data was captured when attempting to sync register #{owner.name}, this is probably because the current read_register driver method does not implement store requests"
             end
           end
           if size

data/lib/origen/remote_manager.rb

@@ -119,8 +119,47 @@ module Origen
       end
     end
 
+    # Fetches any defined remotes, regardless of whether they are dirty or not
+    def resolve_remotes!
+      resolve_remotes
+      process_remotes
+    end
+
     private
 
+    # Process each remote
+    def process_remotes
+      remotes.each do |_name, remote|
+        dir = workspace_of(remote)
+        rc_url = remote[:rc_url] || remote[:vault]
+        tag = remote[:tag].nil? ? Origen::VersionString.new(remote[:version]) : Origen::VersionString.new(remote[:tag])
+        version_file = dir.to_s + '/.current_version'
+        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.send rc.remotes_method, 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.send rc.remotes_method, 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, Origen::PerforceError => 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
+
     # Returns the name of the given import (a lower cased symbol)
     def name_of(remote)
       dir_defined?(remote)
@@ -243,6 +282,11 @@ module Origen
     #   * If multiple versions of the same remote are found the most
     #     recent one wins.
     def add_remote(new)
+      # Cannot have both a tag and a version defined for a remote
+      if ([:tag, :version] - new.keys).empty?
+        Origen.log.error('Cannot define both a tag and a version for a remote!')
+        fail
+      end
       name = name_of(new)
       # If the current remote has been imported by one of it's dev dependencies
       # then always use the local workspace
@@ -289,28 +333,27 @@ module Origen
         end
         if remote[:path]
           create_symlink(remote[:path], dir)
-
         else
           rc_url = remote[:rc_url] || remote[:vault]
-          tag = Origen::VersionString.new(remote[:version])
+          tag = remote[:tag].nil? ? Origen::VersionString.new(remote[:version]) : Origen::VersionString.new(remote[:tag])
           version_file = dir.to_s + '/.current_version'
           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
+              rc.send rc.remotes_method, 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
+              rc.send rc.remotes_method, 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
+          rescue Origen::GitError, Origen::DesignSyncError, Origen::PerforceError  => 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

data/lib/origen/revision_control/base.rb

@@ -16,6 +16,8 @@ module Origen
       attr_reader :remote
       # Returns a pointer to the local location (a Pathname object)
       attr_reader :local
+      # Method to use by Origen::RemoteManager to handle fetching a remote file
+      attr_reader :remotes_method
 
       # rubocop:disable Lint/UnusedMethodArgument
 
@@ -27,6 +29,7 @@ module Origen
         end
         @remote = Pathname.new(options[:remote])
         @local = Pathname.new(options[:local]).expand_path
+        @remotes_method = :checkout
         initialize_local_dir(options)
       end
 
@@ -192,6 +195,12 @@ module Origen
         is_a?(Git) # :-)
       end
 
+      # Returns true if the revision controller object uses Perforce
+      def p4?
+        is_a?(Perforce)
+      end
+      alias_method :perforce?, :p4?
+
       # Returns true if the revision controller object uses Subversion
       def svn?
         is_a?(Subversion) # :-)

data/lib/origen/revision_control/perforce.rb

@@ -0,0 +1,110 @@
+require 'P4'
+module Origen
+  module RevisionControl
+    class Perforce < Base
+      # P4 session
+      attr_reader :p4
+
+      # e.g. myfile.txt
+      attr_accessor :remote_file
+
+      def initialize(options = {})
+        super
+        @remotes_method = :print
+        @p4 = P4.new
+        @p4.maxresults = 1
+        parse_remote
+        @p4.connect
+        unless @p4.connected?
+          Origen.log.error("Could not connect to port #{@p4.port} on client #{@p4.client}!")
+          fail
+        end
+        @p4.run_login
+      end
+
+      # Downloads a file to a local directory, no workspace/client is created.  Perfect
+      # for read-only access like an application remote
+      def print(options = {})
+        options = {
+          verbose: true,
+          version: 'Latest'
+        }.merge(options)
+        cmd = [__method__.to_s, '-o', "#{@local}/#{@remote_file.to_s.split('/')[-1]}", @remote_file.to_s]
+        run cmd
+      end
+
+      def checkout(path = nil, options = {})
+        not_yet_supported(__method__)
+      end
+
+      def root
+        not_yet_supported(__method__)
+      end
+
+      def current_branch
+        not_yet_supported(__method__)
+      end
+
+      def diff_cmd
+        not_yet_supported(__method__)
+      end
+
+      def unmanaged
+        not_yet_supported(__method__)
+      end
+
+      def local_modifications
+        not_yet_supported(__method__)
+      end
+
+      def changes
+        not_yet_supported(__method__)
+      end
+
+      def checkin
+        not_yet_supported(__method__)
+      end
+
+      def build
+        not_yet_supported(__method__)
+      end
+
+      private
+
+      # Needs to be in the form of an Array with command, as a Sting, as the first argument
+      # e.g. ["print", "-o", "pins/myfile.txt", "//depot/myprod/main/doc/pinout/myfile.txt"]
+      def run(cmd)
+        p4.run cmd
+      end
+
+      def not_yet_supported(m)
+        Origen.log.warn("The method #{m} is not currently supported by the Perforce API")
+        nil
+      end
+
+      def parse_remote
+        (@p4.port, @remote_file) = @remote.to_s.match(/^p4\:\/\/(\S+\:\d+)(.*)/).captures unless @remote.nil?
+      end
+
+      def configure_client(options)
+        unless options.include? :local
+          Origen.log.error('Need options[:local] to know how to configure the Perforce client!')
+          fail
+        end
+        client_name = "#{Origen.app.name}_#{User.current.id}_#{Time.now.to_i}"
+        begin
+          client_spec = @p4.fetch_client
+          client_spec['Root'] = options[:local].to_s
+          client_spec['Client'] = client_name
+          client_spec['View'] = ["#{@remote_file} //#{client_name}/#{@remote_file.split('/')[-1]}"]
+          client_spec['Host'] = nil
+          @p4.save_client(client_spec)
+          @p4.client = client_name
+        rescue P4Exception
+          @p4.errors.each { |e| Origen.log.error e }
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/origen/revision_control.rb

@@ -4,6 +4,7 @@ module Origen
     autoload :DesignSync, 'origen/revision_control/design_sync'
     autoload :Git,        'origen/revision_control/git'
     autoload :Subversion, 'origen/revision_control/subversion'
+    autoload :Perforce,   'origen/revision_control/perforce'
 
     IGNORE_DIRS =  %w(
       .ws .lsf log output web coverage .ref .yardoc .collection .bin
@@ -36,6 +37,8 @@ module Origen
         DesignSync.new(options)
       when options[:remote] =~ /git/
         Git.new(options)
+      when options[:remote] =~ /^p4/
+        Perforce.new(options)
       else
         fail "Could not work out the revision control system for: #{options[:remote]}"
       end

data/lib/origen/specs/checkers.rb

@@ -1,8 +1,6 @@
 module Origen
   module Specs
     module Checkers
-      require 'nokogiri'
-
       # rubocop:disable Style/RescueModifier:
       def name_audit(name)
         return name if name.nil?
@@ -74,7 +72,6 @@ module Origen
       def evaluate_limit(limit)
         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
           limit = ':' + limit.to_s
         else

data/lib/origen/sub_blocks.rb

@@ -364,11 +364,13 @@ module Origen
 
       def materialize
         file = attributes.delete(:file)
+        dir = attributes.delete(:dir) || owner.send(:export_dir)
         block = owner.send(:instantiate_sub_block, name, klass, attributes)
         if file
-          require File.join(owner.send(:export_dir), file)
+          require File.join(dir, file)
           block.extend owner.send(:export_module_names_from_path, file).join('::').constantize
         end
+        block.owner = owner
         block
       end
 

data/lib/origen/tests/test.rb

@@ -1,6 +1,9 @@
+require 'origen/limits'
 module Origen
   module Tests
     class Test
+      include Limits
+
       attr_accessor :id, :owner, :description, :conditions, :platforms
 
       def initialize(id, options = {}, &block)

data/lib/origen.rb

@@ -68,6 +68,7 @@ unless defined? RGen::ORIGENTRANSITION
     autoload :Clocks,            'origen/clocks'
     autoload :Value,             'origen/value'
     autoload :OrgFile,           'origen/org_file'
+    autoload :Limits,            'origen/limits'
 
     attr_reader :switch_user
 
@@ -79,6 +80,7 @@ unless defined? RGen::ORIGENTRANSITION
       end
     end
 
+    class PerforceError < OrigenError;  status_code(11); end
     class GitError < OrigenError; status_code(11); end
     class DesignSyncError < OrigenError; status_code(12); end
     class RevisionControlUninitializedError < OrigenError; status_code(13); end

data/templates/git/gitignore.erb

@@ -1,6 +1,7 @@
 # Misc
 .irb_history
 .byebug_history
+/config/waves/**/DVEfiles
 
 # Editor cruft
 *.swp
@@ -31,6 +32,8 @@
 /.bin
 /.session
 /tmp
+/waves
+/simulation
 
 # Cruft from other revision control systems
 .SYNC

data/vendor/lib/models/origen/export1/block1.rb

@@ -4,7 +4,7 @@ module Origen
   module Export1
     module Block1
       def self.extended(model)
-        model.sub_block :x, file: 'origen/export1/block1/x.rb', lazy: true, base_address: 0x40000000
+        model.sub_block :x, file: 'origen/export1/block1/x.rb', dir: '/home/stephen/Code/github/origen/vendor/lib/models', lazy: true, base_address: 0x40000000
 
       end
     end

data/vendor/lib/models/origen/export1.rb

@@ -66,8 +66,10 @@ module Origen
       model.add_ground_pin :gnd2
       model.add_ground_pin :gnd3
       model.add_ground_pin_group :gnd, :gnd1, :gnd2, :gnd3
+      model.add_virtual_pin :relay1
+      model.add_virtual_pin :relay2, packages: { bga: {} }
 
-      model.sub_block :block1, file: 'origen/export1/block1.rb', lazy: true
+      model.sub_block :block1, file: 'origen/export1/block1.rb', dir: '/home/stephen/Code/github/origen/vendor/lib/models', lazy: true
 
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.31.0
+  version: 0.32.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-12 00:00:00.000000000 Z
+date: 2018-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,20 +80,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.7.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.7.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -366,6 +352,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: p4ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2015.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2015.2.1313860
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2015.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2015.2.1313860
 description: 
 email:
 - stephen.f.mcginty@gmail.com
@@ -494,6 +500,9 @@ files:
 - lib/origen/generator/stage.rb
 - lib/origen/global_app.rb
 - lib/origen/global_methods.rb
+- lib/origen/limits.rb
+- lib/origen/limits/limit.rb
+- lib/origen/limits/limit_set.rb
 - lib/origen/location.rb
 - lib/origen/location/base.rb
 - lib/origen/location/map.rb
@@ -553,6 +562,7 @@ files:
 - lib/origen/revision_control/base.rb
 - lib/origen/revision_control/design_sync.rb
 - lib/origen/revision_control/git.rb
+- lib/origen/revision_control/perforce.rb
 - lib/origen/revision_control/subversion.rb
 - lib/origen/ruby_version_check.rb
 - lib/origen/site_config.rb
@@ -640,7 +650,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.7
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: The Semiconductor Developer's Kit