HDLRuby 2.0.18 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: afbd4b4db1a9b95b92f5289877bd4fcee7468ff1
-  data.tar.gz: f7c28abc847bb5061d0321e1de933d8c14f54997
+  metadata.gz: c150464dc8c76fe2fdcf37ee752a8662c8d6128b
+  data.tar.gz: 16facc5e58f5545cf85586f541c61638ecd78733
 SHA512:
-  metadata.gz: 90922bedcaa4374b28b91ef6b165870a680b4b13e530d13b37ff0b6416ac55a08e9adb0f5e9a799d5833932e050651376f5e22c87d1fedee1a040dcb586e4fed
-  data.tar.gz: f357a3be8525021f6be2a2b022ba283209f101405dbe1b9fbaeb8d8345e95f3b75e46c0fc44ff1617a9cecadf007a0fd98aaf5597c3f73e744fecc7b93d43eb2
+  metadata.gz: 8402087045e3f64a50e0553a69b36dcce5b752bb16c58a0f75ffa37bddeea9b3e366f65d94abdc5abae4f9ee0532d0e8e85e8b2a254e9f18484033b17e31fa47
+  data.tar.gz: 406803e4c457b43b52a71eec5d121d8fa09902c7943b7611c5ffd22cca5207bfb3647ee642bdbc869a7d4aff9d07d2d69d8f29878a1fdae06fbb6d650f3257bc

data/lib/HDLRuby/hdr_samples/with_channel.rb

@@ -71,7 +71,7 @@ system :producer8 do |channel|
     # Inputs of the producer: clock and reset.
     input :clk, :rst
     # Instantiate the channel ports
-    channel.writer_ports
+    channel.output :ch
     # Inner 8-bit counter for generating values.
     [8].inner :counter
 
@@ -79,7 +79,7 @@ system :producer8 do |channel|
     par(clk.posedge) do
         hif(rst) { counter <= 0 }
         helse do
-            channel.write(counter) { counter <= counter + 1 }
+            ch.write(counter) { counter <= counter + 1 }
         end
     end
 end
@@ -89,13 +89,13 @@ system :consummer8 do |channel|
     # Input of the consummer: a clock is enough.
     input :clk
     # Instantiate the channel ports
-    channel.reader_ports
+    channel.input :ch
     # Inner buffer for storing the cunsummed value.
     [8].inner :buf
 
     # The value consumption process
     par(clk.posedge) do
-        channel.read(buf)
+        ch.read(buf)
     end
 end
 
@@ -111,8 +111,8 @@ system :hs_test do
     hs.reset.at(rst.posedge)
 
     # Instantiate the producer.
-    producer8(hs).(:producerI).(clk,rst,*hs.writer_signals)
+    producer8(hs).(:producerI).(clk,rst)
 
     # Instantiate the consummer.
-    consummer8(hs).(:consummerI).(clk,*hs.reader_signals)
+    consummer8(hs).(:consummerI).(clk)
 end

data/lib/HDLRuby/high_samples/registers.rb

@@ -56,22 +56,31 @@ system :regn do |n|
 end
 
 # Instantiate it for checking.
-regn :regn8I,8
+# regn :regn8I,8
+regn(8).(:regn8I)
 
 
 # Describes a register of generic type.
+# NOTE: the input can be automatically connected from the generic argument.
 system :reg do |typ|
     input :clk, :rst
     typ.input :d
+    # Now ensure typ is a type.
+    typ = typ.type if typ.is_a?(HExpression)
     typ.output :q,:qb
 
+
     qb <= ~q
     (q <= d & [~rst]*typ.width).at(clk.posedge)
 end
 
 # Instantiate it for checking.
-reg :regbit8I, bit[7..0]
+# reg :regbit8I, bit[7..0]
+reg(bit[7..0]).(:regbit8I)
 
+# Instantiate it with infered type from connection.
+bit[8].inner :sig0
+reg(sig0).(:regSig0I)
 
 
 # Function generating the body of a register description.
@@ -104,8 +113,10 @@ end
 # Instantiate these systems for checking them.
 dff_body  :dff_bodyI
 reg8_body :reg8_bodyI
-regn_body :regn_bodyI, 8
-reg_body  :reg_bodyI, bit[7..0]
+# regn_body :regn_bodyI, 8
+regn_body(8).(:regn_bodyI)
+# reg_body  :reg_bodyI, bit[7..0]
+reg_body(bit[7..0]).(:reg_bodyI)
 
 
 # Function generating a register declaration.
@@ -123,7 +134,7 @@ end
 # Now let's generate the register declarations.
 make_reg(:dff_make) { bit }
 make_reg(:reg8_make){ bit[7..0] }
-make_reg(:regn_make){ |n| bit[n-1..0] }
+make_reg(:regn_make){ |n| bit[(n-1)..0] }
 make_reg(:reg_make) { |typ| typ }
 
 # Instantiate these systems for checking them.

data/lib/HDLRuby/hruby_high.rb

@@ -336,6 +336,9 @@ module HDLRuby::High
             # Create the public namespace.
             @public_namespace = Namespace.new(self.scope)
 
+            # Initialize the list of tasks to execute on the instance.
+            @on_instances = []
+
             # Check and set the mixins.
             mixins.each do |mixin|
                 unless mixin.is_a?(SystemT) then
@@ -543,6 +546,21 @@ module HDLRuby::High
             return self
         end
 
+
+        # Adds a task to apply on the instances of the system.
+        def on_instance(&ruby_block)
+            @on_instances << ruby_block
+        end
+
+        # Iterate over the task to apply on the instances of the system.
+        def each_on_instance(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_on_instance) unless ruby_block
+            # A block? Apply it on each overload if any.
+            @on_instances.each(&ruby_block)
+        end
+
+
         # Instantiate the system type to an instance named +i_name+ with
         # possible arguments +args+.
         def instantiate(i_name,*args)
@@ -560,6 +578,10 @@ module HDLRuby::High
             # puts "instance scope= #{instance.systemT.scope}"
             # Add the instance.
             High.top_user.send(:add_systemI,instance)
+            
+            # Execute the post instantiation tasks.
+            eigen.each_on_instance { |task| task.(instance) }
+
             # Return the resulting instance
             return instance
         end
@@ -884,8 +906,6 @@ module HDLRuby::High
             @namespace.concat_namespace(base.namespace)
             High.space_push(@namespace)
             # Execute the instantiation block
-            # instance_proc = base.parent.instance_proc if base.parent.respond_to?(:instance_proc)
-            # @return_value = High.top_user.instance_exec(*args,&instance_proc) if instance_proc
             base.parent.each_instance_proc do |instance_proc|
                 @return_value = High.top_user.instance_exec(*args,&instance_proc)
             end
@@ -1148,9 +1168,14 @@ module HDLRuby::High
                         export
                     end
                 end
+                # Adds the task to execute on the instance.
+                system.each_on_instance do |task|
+                    self.parent.on_instance(&task)
+                end
             end
             # Adds it the list of includeds
             @includes[include_name] = system
+            
         end
 
         # Casts as an included +system+.
@@ -1161,6 +1186,7 @@ module HDLRuby::High
             return @includes[system].namespace
         end
 
+
         include Hmux
 
         # Fills a low level scope with self's contents.
@@ -1523,7 +1549,34 @@ module HDLRuby::High
 
         include HbasicType
     end
-    
+
+    # # The infer type.
+    # # Unspecified, but automatically infered when connected.
+    # Infer = define_type(:infer)
+    # class << Infer
+    #     # The specified type.
+    #     attr_reader :type
+
+    #     # Sets the specifed type to typ.
+    #     def type=(typ)
+    #         # Ensure typ is a type.
+    #         typ = typ.to_type
+    #         unless @type
+    #             @type = typ
+    #         else
+    #             unless @type.eql(typ)
+    #                 raise AnyError.new("Invalid type for connection to auto type: expecting #{@type} but got #{typ}")
+    #             end
+    #         end
+    #         return self
+    #     end
+
+    #     # Converts the type to HDLRuby::low.
+    #     # Actually returns the HDLRuby::low version of the specified type.
+    #     def to_low
+    #         return type.to_low
+    #     end
+    # end
 
 
 
@@ -1839,7 +1892,8 @@ module HDLRuby::High
         # in the order of declaration.
         def call(*connects)
             # Checks if it is a connection through is a hash.
-            if connects.size == 1 and connects[0].respond_to?(:to_h) then
+            if connects.size == 1 and connects[0].respond_to?(:to_h) and
+                !connects[0].is_a?(HRef) then
                 # Yes, perform a connection by name
                 connects = connects[0].to_h
                 # Performs the connections.
@@ -2167,6 +2221,66 @@ module HDLRuby::High
         # The type of the expression if resolved.
         attr_reader :type
 
+        # Creates input port +name+ and connect it to the expression.
+        def input(name)
+            # Ensures the name is a symbol.
+            name = name.to_sym
+            # Get access to the current expression
+            obj = self
+            # Create the input.
+            port = nil
+            HDLRuby::High.cur_system.open do
+                port = obj.type.input(name)
+            end
+            # Make the connection when the instance is ready.
+            HDLRuby::High.cur_system.on_instance do |inst|
+                obj.scope.open do
+                    RefObject.new(inst,port.to_ref) <= obj
+                end
+            end
+            return port
+        end
+
+        # Creates output port +name+ and connect it to the expression.
+        def output(name)
+            # Ensures the name is a symbol.
+            name = name.to_sym
+            # Get access to the current expression
+            obj = self
+            # Create the output.
+            port = nil
+            HDLRuby::High.cur_system.open do
+                port = obj.type.output(name)
+            end
+            # Make the connection when the instance is ready.
+            HDLRuby::High.cur_system.on_instance do |inst|
+                obj.scope.open do
+                    obj <= RefObject.new(inst,port.to_ref)
+                end
+            end
+            return port
+        end
+
+        # Creates inout port +name+ and connect it to the expression.
+        def inout(name)
+            # Ensures the name is a symbol.
+            name = name.to_sym
+            # Get access to the current expression
+            obj = self
+            # Create the inout.
+            port = nil
+            HDLRuby::High.cur_system.open do
+                port = obj.type.inout(name)
+            end
+            # Make the connection when the instance is ready.
+            HDLRuby::High.cur_system.on_instance do |inst|
+                obj.scope.open do
+                    RefObject.new(inst,port.to_ref) <= obj
+                end
+            end
+            return port
+        end
+
         # Tell if the expression can be converted to a value.
         def to_value?
             return false
@@ -3495,6 +3609,22 @@ module HDLRuby::High
         top_user.is_a?(Block)
     end
 
+    # Gets the enclosing scope if any.
+    #
+    # NOTE: +level+ allows to get an upper scope of the currently enclosing
+    #       scope.
+    def self.cur_scope(level = 0)
+        if level < 0 then
+            raise AnyError, "Not within a scope: #{Namespaces[-1].user.class}"
+        end
+        if Namespaces[-1-level].user.is_a?(Scope) then
+            return Namespaces[-1-level].user
+        else
+            return cur_scope(level+1)
+        end
+    end
+
+
     # Gets the enclosing block if any.
     #
     # NOTE: +level+ allows to get an upper block of the currently enclosing

data/lib/HDLRuby/hruby_low.rb

@@ -52,6 +52,13 @@ module HDLRuby::Low
                 @parent = parent
             end
         end
+
+        # Get the parent scope.
+        def scope
+            cur = self.parent
+            cur = cur.parent until cur.is_a?(Scope)
+            return cur
+        end
     end
 
 

data/lib/HDLRuby/std/channel.rb

@@ -71,6 +71,9 @@ module HDLRuby::High::Std
         # The name of the channel instance.
         attr_reader :name
 
+        # The scope the channel has been created in.
+        attr_reader :scope
+
         # The namespace associated with the current execution when
         # building a channel, its reader or its writer.
         attr_reader :namespace
@@ -80,6 +83,10 @@ module HDLRuby::High::Std
             # Check and set the name
             @name = name.to_sym
 
+            # Sets the scope.
+            @scope = HDLRuby::High.cur_scope
+
+            # Keep access to self.
             obj = self
 
             # The reader input ports by name.
@@ -253,35 +260,116 @@ module HDLRuby::High::Std
 
         # Reader an writer side.
 
-        ## Declares the ports for the reader.
-        def reader_ports
+        # ## Declares the ports for the reader.
+        # def reader_ports
+        #     loc_inputs  = @reader_inputs
+        #     loc_outputs = @reader_outputs
+        #     loc_inouts  = @reader_inouts
+        #     HDLRuby::High.cur_system.open do
+        #         # The inputs
+        #         loc_inputs.each  { |name,sig| sig.type.input  name }
+        #         # The outputs
+        #         loc_outputs.each { |name,sig| sig.type.output name }
+        #         # The inouts
+        #         loc_inouts.each  { |name,sig| sig.type.inout  name }
+        #     end
+        # end
+
+        ## Declares the ports for the reader and assigned them to +name+.
+        def input(name)
+            # Ensure name is a symbol.
+            name = name.to_sym
+            # Access the ports
             loc_inputs  = @reader_inputs
             loc_outputs = @reader_outputs
             loc_inouts  = @reader_inouts
+            # The generated port with corresponding channel port pairs.
+            port_pairs = []
+            # Add them to the current system.
             HDLRuby::High.cur_system.open do
                 # The inputs
-                loc_inputs.each  { |name,sig| sig.type.input  name }
+                loc_inputs.each  do |name,sig|
+                    port_pairs << [sig, sig.type.input(name)]
+                end
                 # The outputs
-                loc_outputs.each { |name,sig| sig.type.output name }
+                loc_outputs.each do |name,sig| 
+                    port_pairs << [sig, sig.type.output(name)]
+                end
                 # The inouts
-                loc_inouts.each  { |name,sig| sig.type.inout  name }
+                loc_inouts.each  do |name,sig| 
+                    port_pairs << [sig, sig.type.inout(name)]
+                end
+            end
+            obj = self
+            # Make the connection of the instance.
+            HDLRuby::High.cur_system.on_instance do |inst|
+                obj.scope.open do
+                    port_pairs.each do |sig, port|
+                        RefObject.new(inst,port.to_ref) <= sig
+                    end
+                end
             end
+            # Give access to the ports through name.
+            # NOTE: for now, simply associate the channel to name.
+            this = self
+            HDLRuby::High.space_reg(name) { this }
         end
 
-        ## Declares the ports for the writer.
-        def writer_ports
+        # ## Declares the ports for the writer.
+        # def writer_ports
+        #     loc_inputs  = @writer_inputs
+        #     loc_outputs = @writer_outputs
+        #     loc_inouts  = @writer_inouts
+        #     HDLRuby::High.cur_system.open do
+        #         # The inputs
+        #         loc_inputs.each  { |name,sig| sig.type.input  name }
+        #         # The outputs
+        #         loc_outputs.each { |name,sig| sig.type.output name }
+        #         # The inouts
+        #         loc_inouts.each  { |name,sig| sig.type.inout  name }
+        #     end
+        # end
+
+        ## Declares the ports for the reader and assigned them to +name+.
+        def output(name)
+            # Ensure name is a symbol.
+            name = name.to_sym
+            # Access the ports
             loc_inputs  = @writer_inputs
             loc_outputs = @writer_outputs
             loc_inouts  = @writer_inouts
+            # The generated port with corresponding channel port pairs.
+            port_pairs = []
+            # Add them to the current system.
             HDLRuby::High.cur_system.open do
                 # The inputs
-                loc_inputs.each  { |name,sig| sig.type.input  name }
+                loc_inputs.each  do |name,sig|
+                    port_pairs << [sig, sig.type.input(name)]
+                end
                 # The outputs
-                loc_outputs.each { |name,sig| sig.type.output name }
+                loc_outputs.each do |name,sig| 
+                    port_pairs << [sig, sig.type.output(name)]
+                end
                 # The inouts
-                loc_inouts.each  { |name,sig| sig.type.inout  name }
+                loc_inouts.each  do |name,sig| 
+                    port_pairs << [sig, sig.type.inout(name)]
+                end
             end
+            obj = self
+            # Make the connection of the instance.
+            HDLRuby::High.cur_system.on_instance do |inst|
+                obj.scope.open do
+                    port_pairs.each do |sig, port|
+                        RefObject.new(inst,port.to_ref) <= sig
+                    end
+                end
+            end
+            # Give access to the ports through name.
+            # NOTE: for now, simply associate the channel to name.
+            this = self
+            HDLRuby::High.space_reg(name) { this }
         end
+
         
         ## Performs a read on the channel using +args+ and +ruby_block+
         #  as arguments.

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.0.18"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.0.18
+  version: 2.1.0
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-16 00:00:00.000000000 Z
+date: 2020-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler