origen 0.5.7 → 0.5.8

data/lib/origen/registers.rb

@@ -311,6 +311,12 @@ module Origen
         @new_reg_attrs = { meta: bit_info }
         yield self
         bit_info = @new_reg_attrs
+      else
+        # If no block given then init with all writable bits unless bit_info has
+        # been supplied
+        unless bit_info.any? { |k, v| v.is_a?(Hash) && v[:pos] }
+          bit_info = { d: { pos: 0, bits: size }.merge(bit_info) }
+        end
       end
       if _registers[id] && Origen.config.strict_errors
         puts ''
@@ -472,7 +478,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?
+      if block_given? || (args[1].is_a?(Fixnum) && !try(:initialized?))
         @reg_define_file = define_file(caller[0])
         add_reg(*args, &block)
       else

data/lib/origen/registers/bit.rb

@@ -234,8 +234,12 @@ module Origen
       # This does not account for any overridding that may have been applied to
       # this bit specifically however, use the meta method to get that.
       def default_bit_metadata
-        Origen::Registers.default_bit_metadata.merge(
-          Origen::Registers.bit_metadata[owner.owner.class] || {})
+        if owner
+          Origen::Registers.default_bit_metadata.merge(
+            Origen::Registers.bit_metadata[owner.owner.class] || {})
+        else
+          Origen::Registers.default_bit_metadata
+        end
       end
 
       def inspect
@@ -440,7 +444,8 @@ module Origen
         self
       end
 
-      def respond_to?(sym) # :nodoc:
+      def respond_to?(*args) # :nodoc:
+        sym = args.first
         meta_data_method?(sym) || super(sym)
       end
 

data/lib/origen/registers/bit_collection.rb

@@ -10,6 +10,7 @@ module Origen
     # or a group of Bit objects, the same API can be used as described below.
     class BitCollection < Array
       include Origen::SubBlocks::Path
+      include Netlist::Connectable
 
       DONT_CARE_CHAR = 'X'
       OVERLAY_CHAR = 'V'
@@ -26,6 +27,10 @@ module Origen
         [data].flatten.each { |item| self << item }
       end
 
+      def terminal?
+        true
+      end
+
       def bind(live_parameter)
         parent.bind(name, live_parameter)
       end
@@ -201,7 +206,10 @@ module Origen
       #   reg(:control).data         #  => 0x55, assuming the reg has the required bits to store that
       def data
         data = 0
-        each_with_index { |bit, i| data |= bit.data << i }
+        each_with_index do |bit, i|
+          return undefined if bit.is_a?(Origen::UndefinedClass)
+          data |= bit.data << i
+        end
         data
       end
       alias_method :val, :data
@@ -540,7 +548,8 @@ module Origen
       end
 
       # Recognize that BitCollection responds to some Bit methods via method_missing
-      def respond_to?(sym) # :nodoc:
+      def respond_to?(*args) # :nodoc:
+        sym = args.first
         first.respond_to?(sym) || super(sym)
       end
 
@@ -728,6 +737,52 @@ module Origen
         make_hex_like(str, size / 4)
       end
 
+      # Shifts the data in the collection left by one place. The data held
+      # by the rightmost bit will be set to the given value (0 by default).
+      #
+      # @example
+      #   myreg.data          # => 0b1111
+      #   myreg.shift_left
+      #   myreg.data          # => 0b1110
+      #   myreg.shift_left
+      #   myreg.data          # => 0b1100
+      #   myreg.shift_left(1)
+      #   myreg.data          # => 0b1001
+      #   myreg.shift_left(1)
+      #   myreg.data          # => 0b0011
+      def shift_left(data = 0)
+        prev_bit = nil
+        reverse_each do |bit|
+          prev_bit.write(bit.data) if prev_bit
+          prev_bit = bit
+        end
+        prev_bit.write(data)
+        self
+      end
+
+      # Shifts the data in the collection right by one place. The data held
+      # by the leftmost bit will be set to the given value (0 by default).
+      #
+      # @example
+      #   myreg.data          # => 0b1111
+      #   myreg.shift_right
+      #   myreg.data          # => 0b0111
+      #   myreg.shift_right
+      #   myreg.data          # => 0b0011
+      #   myreg.shift_right(1)
+      #   myreg.data          # => 0b1001
+      #   myreg.shift_right(1)
+      #   myreg.data          # => 0b1100
+      def shift_right(data = 0)
+        prev_bit = nil
+        each do |bit|
+          prev_bit.write(bit.data) if prev_bit
+          prev_bit = bit
+        end
+        prev_bit.write(data)
+        self
+      end
+
       private
 
       # Converts a binary-like representation of a data value into a hex-like version.

data/lib/origen/registers/reg.rb

@@ -1122,8 +1122,8 @@ module Origen
 
       # Recognize that Reg responds to all BitCollection methods methods based on
       # application-specific meta data properties
-      def respond_to?(sym) # :nodoc:
-        sym = sym.to_sym
+      def respond_to?(*args) # :nodoc:
+        sym = args.first.to_sym
         meta_data_method?(sym) || has_bits?(sym) || super(sym) || BitCollection.instance_methods.include?(sym)
       end
 

data/lib/origen/revision_control/design_sync.rb

@@ -35,6 +35,43 @@ module Origen
         FileUtils.rm_rf(scratch)
       end
 
+      # Import a file to the local workspace from another vault, where the first
+      # argument must include the full path to the requested file in the vault. You can optionally
+      # supply a destination for where you want the file to end up via the :local option, if no destination
+      # is supplied the file will end up in the PWD.
+      #
+      # This is a DesignSync only API and can be used in cases where you would to fetch a file
+      # directly from a vault without setting up an association between a local directory and the
+      # vault. i.e. it will not create or modify an existing .SYNC in the local destination directory.
+      #
+      # ==== Example
+      #
+      #   # Import this file and save it in RGen.root
+      #   file = "sync://sync-15088:15088/Projects/common_tester_blocks/rgen/lib/sys/design_sync.rb"
+      #   version = "v0.1.0"   # Version can be any valid DS identifier, e.g. a version number or tag
+      #
+      #   import(file, version: version, local: RGen.root)
+      def self.import(path_to_file_in_vault, options = {})
+        options = {
+          verbose: true,
+          version: 'Latest'
+        }.merge(options)
+        if options[:verbose]
+          puts 'Importing from DesignSync...'
+          puts "#{path_to_file_in_vault} #{options[:version]}"
+        end
+        dir = path_to_file_in_vault.split('/')
+        file = dir.pop
+        dir = dir.join('/')
+        cmd = "import -version #{options[:version]} -force #{dir} #{file}"
+        dssc(cmd, verbose: false)
+        if Origen.os.windows?
+          system("move /Y #{file} #{options[:local]}/.") if options[:local]
+        else
+          system("mv -f #{file} #{options[:local]}/.") if options[:local]
+        end
+      end
+
       # Recursively remove all .SYNC directories from the given directory
       def self.remove_dot_syncs!(dir, options = {})
         dir = Pathname.new(dir)
@@ -261,17 +298,18 @@ module Origen
       end
 
       # Execute a dssc operation, the resultant output is returned in an array
-      def dssc(command, options = {})
+      def self.dssc(command, options = {})
         options = {
           check_errors: true,
-          verbose:      true
+          verbose:      true,
+          local:        Dir.pwd
         }.merge(options)
         output = []
         if options[:verbose]
           Origen.log.info "dssc #{command}"
           Origen.log.info ''
         end
-        Dir.chdir local do
+        Dir.chdir options[:local] do
           Open3.popen2e("dssc #{command}") do |_stdin, stdout_err, wait_thr|
             while line = stdout_err.gets
               Origen.log.info line.strip if options[:verbose]
@@ -293,6 +331,12 @@ module Origen
         end
         output
       end
+
+      # Execute a dssc operation, the resultant output is returned in an array
+      def dssc(command, options = {})
+        options[:local] ||= local
+        DesignSync.dssc(command, options)
+      end
     end
   end
 end

data/lib/origen/sub_blocks.rb

@@ -180,11 +180,20 @@ module Origen
             root = "#{p.path(options)}."
           end
         else
-          root = ''
+          # If a path variable has been set on a top-level object, then we will
+          # include that in path, otherwise by default the top-level object is not
+          # included in the path
+          if p || path_var
+            root = ''
+          else
+            return ''
+          end
         end
         local = (path_var || name || self.class.to_s.split('::').last).to_s
         if local == 'hidden'
           root.chop
+        elsif is_a?(Origen::Registers::BitCollection) && parent.path_var == :hidden
+          "#{root.chop}#{local}"
         else
           "#{root}#{local}"
         end
@@ -274,8 +283,7 @@ module Origen
           puts ''
           fail 'Sub block does not include Origen::Model!'
         end
-        block = klass.new(options.merge(parent: self))
-        block.name = name
+        block = klass.new(options.merge(parent: self, name: name))
         if sub_blocks[name]
           fail "You have already defined a sub-block named #{name} within class #{self.class}"
         else
@@ -312,6 +320,7 @@ module Origen
     # next time, this should be faster for repeated lookups of the same method, e.g. reg
     def method_missing(method, *args, &block)
       return regs(method) if self.has_reg?(method)
+      return ports(method) if self.has_port?(method)
       if method.to_s =~ /=$/
         define_singleton_method(method) do |val|
           instance_variable_set("@#{method.to_s.sub('=', '')}", val)

data/lib/origen/undefined.rb

@@ -0,0 +1,13 @@
+module Origen
+  class UndefinedClass
+    include Singleton
+
+    def inspect
+      'undefined'
+    end
+
+    def undefined?
+      true
+    end
+  end
+end

data/templates/nanoc/layouts/bootstrap.html.erb

@@ -114,5 +114,13 @@
     <script src="http://origen-sdk.org/js/lunr.min.js"></script>
     <script src="http://origen-sdk.org/js/highlight.js"></script>
     <script src="http://origen-sdk.org/js/custom.js"></script>
+    <% if @item[:gitter_chat] %>
+      <script>
+        ((window.gitter = {}).chat = {}).options = {
+          room: '<%= @item[:gitter_chat] %>'
+        };
+      </script>
+      <script src="https://sidecar.gitter.im/dist/sidecar.v1.js" async defer></script>
+    <% end %>
   </body>
 </html>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.8
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-02 00:00:00.000000000 Z
+date: 2015-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -344,14 +344,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.3
 - !ruby/object:Gem::Dependency
   name: origen_doc_helpers
   requirement: !ruby/object:Gem::Requirement
@@ -531,6 +531,12 @@ files:
 - lib/origen/mode.rb
 - lib/origen/model.rb
 - lib/origen/model_initializer.rb
+- lib/origen/models.rb
+- lib/origen/models/mux.rb
+- lib/origen/models/scan_register.rb
+- lib/origen/netlist.rb
+- lib/origen/netlist/connectable.rb
+- lib/origen/netlist/list.rb
 - lib/origen/operating_systems.rb
 - lib/origen/parameters.rb
 - lib/origen/parameters/live.rb
@@ -544,8 +550,12 @@ files:
 - lib/origen/pins/pin_clock.rb
 - lib/origen/pins/pin_collection.rb
 - lib/origen/pins/pin_common.rb
-- lib/origen/pins/port.rb
 - lib/origen/pins/power_pin.rb
+- lib/origen/ports.rb
+- lib/origen/ports/bit_collection.rb
+- lib/origen/ports/port.rb
+- lib/origen/ports/port_collection.rb
+- lib/origen/ports/section.rb
 - lib/origen/registers.rb
 - lib/origen/registers/bit.rb
 - lib/origen/registers/bit_collection.rb
@@ -575,6 +585,7 @@ files:
 - lib/origen/specs/version_history.rb
 - lib/origen/sub_blocks.rb
 - lib/origen/top_level.rb
+- lib/origen/undefined.rb
 - lib/origen/users.rb
 - lib/origen/users/ldap.rb
 - lib/origen/users/user.rb

data/lib/origen/pins/port.rb

@@ -1,268 +0,0 @@
-module Origen
-  module Pins
-    class Port
-      attr_accessor :name
-      attr_reader :id
-      attr_reader :owner
-      attr_reader :size
-      attr_accessor :order
-
-      include Pins
-
-      def initialize(id, owner, options = {})
-        options = {
-          name:     id.to_s,
-          endian:   :big,
-          add_pins: true
-        }.merge(options)
-        @endian = options.delete(:endian)
-        @size = options.delete(:size)
-        @name = options.delete(:name)
-        @order = options.delete(:order)
-        @id = id
-        @owner = owner
-        add_pins(options) if options[:add_pins]
-      end
-
-      def name
-        (Origen.app.pin_names[id] || @name).to_s
-      end
-
-      def inspect
-        "<#{self.class}:#{object_id}>"
-      end
-
-      def add_pins(options)
-        size.times do |i|
-          ix = @endian == :big ? @size - i - 1 : i
-          pin = add_pin(ix, options)
-          pin.port = self
-        end
-      end
-
-      def cycle # :nodoc:
-        Origen.tester.cycle
-      end
-
-      def drive_mem
-        pins.each { |_ix, pin| pin.drive_mem }
-      end
-
-      def drive_mem!
-        drive_mem
-        cycle
-      end
-
-      def expect_mem
-        pins.each { |_ix, pin| pin.expect_mem }
-      end
-
-      def expect_mem!
-        expect_mem
-        cycle
-      end
-
-      # Set the pin to drive a 1 on future cycles
-      def drive_hi
-        pins.each { |_ix, pin| pin.drive_hi }
-      end
-
-      def drive_hi!
-        drive_hi
-        cycle
-      end
-
-      # Set the pin to drive a high voltage on future cycles (if the tester supports it).
-      # For example on a J750 high-voltage channel the pin state would be set to "2"
-      def drive_very_hi
-        pins.each { |_ix, pin| pin.drive_very_hi }
-      end
-
-      def drive_very_hi!
-        drive_very_hi
-        cycle
-      end
-
-      # Set the pin to drive a 0 on future cycles
-      def drive_lo
-        pins.each { |_ix, pin| pin.drive_lo }
-      end
-
-      def drive_lo!
-        drive_lo
-        cycle
-      end
-
-      # Set the pin to expect a 1 on future cycles
-      def assert_hi(_options = {})
-        pins.each { |_ix, pin| pin.assert_hi }
-      end
-      alias_method :compare_hi, :assert_hi
-      alias_method :expect_hi, :assert_hi
-
-      def assert_hi!
-        assert_hi
-        cycle
-      end
-      alias_method :compare_hi!, :assert_hi!
-      alias_method :expect_hi!, :assert_hi!
-
-      # Set the pin to expect a 0 on future cycles
-      def assert_lo(_options = {})
-        pins.each { |_ix, pin| pin.assert_lo }
-      end
-      alias_method :compare_lo, :assert_lo
-      alias_method :expect_lo, :assert_lo
-
-      def assert_lo!
-        assert_lo
-        cycle
-      end
-      alias_method :compare_lo!, :assert_lo!
-      alias_method :expect_lo!, :assert_lo!
-
-      # Set the pin to X on future cycles
-      def dont_care
-        pins.each { |_ix, pin| pin.dont_care }
-      end
-
-      def dont_care!
-        dont_care
-        cycle
-      end
-
-      # Pass in 0 or 1 to have the pin drive_lo or drive_hi respectively.
-      # This is useful when programatically setting the pin state.
-      # ==== Example
-      #   [0,1,1,0].each do |level|
-      #       $pin(:d_in).drive(level)
-      #   end
-      def drive(value)
-        size.times do |i|
-          pins[i].drive(value[i])
-        end
-      end
-
-      def drive!(value)
-        drive(value)
-        cycle
-      end
-
-      # Pass in 0 or 1 to have the pin expect_lo or expect_hi respectively.
-      # This is useful when programatically setting the pin state.
-      # ==== Example
-      #   [0,1,1,0].each do |level|
-      #       $pin(:d_in).assert(level)
-      #   end
-      def assert(value, _options = {})
-        size.times do |i|
-          pins[i].expect(value[i])
-        end
-      end
-      alias_method :compare, :assert
-      alias_method :expect, :assert
-
-      def assert!(*args)
-        assert(*args)
-        cycle
-      end
-
-      def [](ix)
-        pins[ix]
-      end
-
-      # Returns the data value currently assigned to the port
-      def data
-        d = 0
-        size.times do |i|
-          d |= pins[i].data << i
-        end
-        d
-      end
-      alias_method :value, :data
-
-      # Returns the inverse of the data value currently assigned to the port
-      def data_b
-        # (& operation takes care of Bignum formatting issues)
-        ~data & ((1 << size) - 1)
-      end
-      alias_method :value_b, :data_b
-
-      # Set the data assigned to the port
-      def data=(val)
-        size.times do |i|
-          pins[i].data = val[i]
-        end
-      end
-
-      def toggle
-        self.data = data_b
-      end
-
-      def toggle!
-        toggle
-        cycle
-      end
-
-      def comparing?
-        pins.any? { |_ix, pin| pin.comparing? }
-      end
-
-      def comparing_mem?
-        pins.any? { |_ix, pin| pin.comparing_mem? }
-      end
-
-      def driving?
-        pins.any? { |_ix, pin| pin.driving? }
-      end
-
-      def driving_mem?
-        pins.any? { |_ix, pin| pin.driving_mem? }
-      end
-
-      def high_voltage?
-        pins.any? { |_ix, pin| pin.high_voltage? }
-      end
-
-      def repeat_previous=(bool)
-        pins.each { |_ix, pin| pin.repeat_previous = bool }
-      end
-
-      # Mark the (data) from the port to be captured
-      def capture
-        pins.each { |_ix, pin| pin.capture }
-      end
-      alias_method :store, :capture
-
-      # Mark the (data) from the port to be captured and trigger a cycle
-      def capture!
-        capture
-        cycle
-      end
-      alias_method :store!, :capture!
-
-      # Returns true if the (data) from the port is marked to be captured
-      def to_be_captured?
-        pins.any? { |_ix, pin| pin.to_be_captured? }
-      end
-      alias_method :to_be_stored?, :to_be_captured?
-      alias_method :is_to_be_stored?, :to_be_captured?
-      alias_method :is_to_be_captured?, :to_be_captured?
-
-      # Restores the state of the port at the end of the given block
-      # to the state it was in at the start of the block
-      #
-      #   port(:a).driving?  # => true
-      #   port(:a).restore_state do
-      #     port(:a).dont_care
-      #     port(:a).driving?  # => false
-      #   end
-      #   port(:a).driving?  # => true
-      def restore_state
-        pins.each { |_ix, pin| pin.save }
-        yield
-        pins.each { |_ix, pin| pin.restore }
-      end
-    end
-  end
-end