HDLRuby 2.3.3 → 2.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6548ba8f8c1572f8aa254b168eab065bc5d0a06ac996d792b4082a9243a2dfc9
-  data.tar.gz: 97891dad52f2454d37755af82cf6d23b2665cccd39a44caff81701921f233931
+  metadata.gz: 164191b6cbfda40e60bc6b253c95a0ff511164007c83adf53c7f86383b404464
+  data.tar.gz: 5344dd9f624089cab1488d9e10b67e542cb83639db81e397c0d2241c67a43527
 SHA512:
-  metadata.gz: 6df258eebc8a3448824aca9bf39d24ad98c9302728c2584bb34880b8160b42a00f6b7e0fed68a4097403046e0621bf16c8048c43ce95090254f4e9e6e1ebc079
-  data.tar.gz: 73cc373d53e91a756922c8539f15283f793db0ce6e1b3e7c2ae566ae6e2c19691ee62d7dd3ac5ca1f1e19c61a809ab234aba3c790ae207327f8cd2609c76816f
+  metadata.gz: 5e9b00b3fad458789078bcaca6d8d45e7ac5877ff14a3971ce2ddac186ed15a1ad2aa440d3c5619c66f324e9f6dbeda5c8bcf2aa5de3389aa12d631abbd780a4
+  data.tar.gz: '08dc450e1e3807d85f8ffb22888c037b081bed44dab318fac5fb33611f706c58191a2b06379b0798b61bbf3578d0e058b144ee8995e4212250826366bd306e9e'

data/lib/HDLRuby/hdr_samples/with_fixpoint.rb

@@ -9,6 +9,8 @@ system :fix_test do
 
     # Declare three 4-bit integer part 4-bit fractional part
     bit[3..0,3..0].inner :x,:y,:z
+    # Declare three 8-bit integer part 8-bit fractional part
+    signed[3..0,3..0].inner :a,:b,:c,:d
 
     # Performs calculation between then
     timed do
@@ -22,5 +24,12 @@ system :fix_test do
         !10.ns
         z <= z / x
         !10.ns
+        a <= _00010000
+        b <= _00001111
+        !10.ns
+        c <= a * b
+        d <= 0
+        !10.ns
+        d <= d + c 
     end
 end

data/lib/HDLRuby/hdr_samples/with_linear.rb

@@ -22,9 +22,6 @@ system :testmat do
     mem_dual([8],256,clk,rst, rinc: :rst,winc: :rst).(:memL1)
     mem_dual([8],256,clk,rst, rinc: :rst,winc: :rst).(:memR)
     # Access ports.
-    # # memL0.branch(:rinc).inner :readL0
-    # # memL1.branch(:rinc).inner :readL1
-    # # memR.branch(:rinc).inner :readR
     # memL0.branch(:rinc).input :readL0
     # memL1.branch(:rinc).input :readL1
     # memR.branch(:rinc).input :readR
@@ -35,9 +32,9 @@ system :testmat do
 
     # Accumulators memory.
     mem_file([8],2,clk,rst,rinc: :rst).(:memAcc)
-    # # memAcc.branch(:anum).inner :accs
-    memAcc.branch(:anum).inout :accs
-    accs_out = [accs.wrap(0), accs.wrap(1)]
+    # memAcc.branch(:anum).inout :accs
+    # accs_out = [accs.wrap(0), accs.wrap(1)]
+    accs_out = [memAcc.branch(:anum).wrap(0), memAcc.branch(:anum).wrap(1)]
 
     # Layer 0 ack.
     inner :ack0
@@ -52,8 +49,6 @@ system :testmat do
     # Tarnslation result
     mem_file([8],2,clk,rst,rinc: :rst).(:memF)
     # Access ports.
-    # # memT.branch(:anum).inner :readT
-    # # memF.branch(:anum).inner :writeF
     memT.branch(:anum).input :readT
     memF.branch(:anum).output :writeF
     regRs = [ readT.wrap(0), readT.wrap(1) ]
@@ -72,8 +67,6 @@ system :testmat do
     # Input memories.
     mem_dual([8],2,clk,rst, rinc: :rst,winc: :rst).(:mem2L0)
     # Access ports.
-    # # mem2L0.branch(:rinc).inner :read2L0
-    # # memF.branch(:rinc).inner :readF
     # mem2L0.branch(:rinc).input :read2L0
     # memF.branch(:rinc).input :readF
 
@@ -93,11 +86,6 @@ system :testmat do
 
 
     # The memory initializer.
-    # # memL0.branch(:winc).inner :writeL0
-    # # memL1.branch(:winc).inner :writeL1
-    # # memR.branch(:winc).inner :writeR
-    # # memT.branch(:winc).inner :writeT
-    # # mem2L0.branch(:winc).inner :write2L0
     # memL0.branch(:winc).output :writeL0
     # memL1.branch(:winc).output :writeL1
     # memR.branch(:winc).output :writeR

data/lib/HDLRuby/hruby_high.rb

@@ -1263,7 +1263,8 @@ module HDLRuby::High
         # Converts the scope to HDLRuby::Low.
         def to_low()
             # Create the resulting low scope.
-            scopeLow = HDLRuby::Low::Scope.new()
+            # scopeLow = HDLRuby::Low::Scope.new()
+            scopeLow = HDLRuby::Low::Scope.new(self.name)
             # Push the private namespace for the low generation.
             High.space_push(@namespace)
             # Pushes on the name stack for converting the internals of
@@ -1858,7 +1859,8 @@ module HDLRuby::High
     def function(name, &ruby_block)
         if HDLRuby::High.in_system? then
             define_singleton_method(name.to_sym) do |*args,&other_block|
-                sub do
+                # sub do
+                sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
                     # ruby_block.call(*args)
@@ -1866,7 +1868,8 @@ module HDLRuby::High
             end
         else
             define_method(name.to_sym) do |*args,&other_block|
-                sub do
+                # sub do
+                sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
                 end

data/lib/HDLRuby/hruby_low.rb

@@ -2633,6 +2633,11 @@ module HDLRuby::Low
         def parent_system
             return self.top_scope.parent
         end
+
+        # Tell if the statement includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # By default, nothing to do.
+        end
     end
 
 
@@ -2747,6 +2752,11 @@ module HDLRuby::Low
             # A ruby block?
             # Nothing to do.
         end
+
+        # Tell if the statement includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            return @left.use_name?(*names) || @right.use_name?(*names)
+        end
     end
 
 
@@ -2925,6 +2935,12 @@ module HDLRuby::Low
             @no.each_block_deep(&ruby_block) if @no
         end
 
+        # Tell if the statement includes a signal whose name is one of +names+.
+        # NOTE: for the if check only the condition.
+        def use_name?(*names)
+            return @condition.use_name?(*name)
+        end
+
         # Clones the If (deeply)
         def clone
             # Duplicate the if.
@@ -3038,6 +3054,12 @@ module HDLRuby::Low
         def top_block
             return self.parent.is_a?(Behavior) ? self : self.parent.top_block
         end
+
+        # Tell if the statement includes a signal whose name is one of +names+.
+        # NOTE: for the when check only the match.
+        def use_name?(*names)
+            return @match.use_name?(*name)
+        end
     end
 
 
@@ -3186,6 +3208,12 @@ module HDLRuby::Low
             @default.each_statement_deep(&ruby_block) if @default
         end
 
+        # Tell if the statement includes a signal whose name is one of +names+.
+        # NOTE: for the case check only the value.
+        def use_name?(*names)
+            return @value.use_name?(*name)
+        end
+
         # Clones the Case (deeply)
         def clone
             # Clone the default if any.
@@ -3838,6 +3866,12 @@ module HDLRuby::Low
             end
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # By default nothing.
+            return false
+        end
+
         # Clones the expression (deeply)
         def clone
             raise AnyError,
@@ -3991,6 +4025,12 @@ module HDLRuby::Low
             @child.each_ref_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the child.
+            return @child.use_name?(*names)
+        end
+
         # Clones the value (deeply)
         def clone
             return Cast.new(@type,@child.clone)
@@ -4101,6 +4141,12 @@ module HDLRuby::Low
             @child.each_ref_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the child.
+            return @child.use_name?(*names)
+        end
+
         # Clones the unary operator (deeply)
         def clone
             return Unary.new(@type,self.operator,@child.clone)
@@ -4187,6 +4233,12 @@ module HDLRuby::Low
             @right.each_ref_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the left and the right.
+            return @left.use_name?(*names) || @right.use_name?(*names)
+        end
+
         # Clones the binary operator (deeply)
         def clone
             return Binary.new(@type, self.operator,
@@ -4311,6 +4363,14 @@ module HDLRuby::Low
             end
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the select.
+            return true if @select.use_name?(*names)
+            # Recurse on the choices.
+            return @choices.include? { |choice| choice.use_name?(*names) }
+        end
+
         # Clones the select (deeply)
         def clone
             return Select.new(@type, self.operator, @select.clone,
@@ -4390,6 +4450,12 @@ module HDLRuby::Low
             end
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the expressions.
+            return @expressions.include? { |expr| expr.use_name?(*names) }
+        end
+
         # Clones the concatenated expression (deeply)
         def clone
             return Concat.new(@type,
@@ -4532,6 +4598,12 @@ module HDLRuby::Low
             end
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the references.
+            return @refs.include? { |expr| expr.use_name?(*names) }
+        end
+
         # Clones the concatenated references (deeply)
         def clone
             return RefConcat.new(@type, @refs.map { |ref| ref.clone } )
@@ -4615,6 +4687,12 @@ module HDLRuby::Low
             @ref.each_node_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the index and the reference.
+            return @index.use_name?(names) || @ref.use_name?(*names)
+        end
+
         # Clones the indexed references (deeply)
         def clone
             return RefIndex.new(@type, @ref.clone, @index.clone)
@@ -4710,6 +4788,13 @@ module HDLRuby::Low
             @ref.each_node_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the range and the reference.
+            return @range.first.use_name?(names) ||
+                   @range.last.use_name?(names)  || @ref.use_name?(*names)
+        end
+
         # Clones the range references (deeply)
         def clone
             return RefRange.new(@type, @ref.clone,
@@ -4797,6 +4882,14 @@ module HDLRuby::Low
             @ref.each_node_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Is the named used here?
+            return true if names.include?(@name)
+            # No, recurse the reference.
+            return @ref.use_name?(*names)
+        end
+
         # Clones the name references (deeply)
         def clone
             return RefName.new(@type, @ref.clone, @name)

data/lib/HDLRuby/hruby_low2c.rb

@@ -1946,7 +1946,9 @@ module HDLRuby::Low
         # Generates the C text for reference as left value to a signal.
         # +level+ is the hierarchical level of the object.
         def to_c_signal(level = 0)
-            return to_c(level,true)
+            # return to_c(level,true)
+            return "make_ref_rangeS(#{self.ref.to_c_signal(level)}," +
+                "value2integer(#{self.range.first.to_c(level)}),value2integer(#{self.range.last.to_c(level)}))"
         end
     end
 

data/lib/HDLRuby/hruby_low_mutable.rb

@@ -156,7 +156,7 @@ module HDLRuby::Low
             end
         end
 
-        # Deletes an type.
+        # Deletes a type.
         def delete_type!(type)
             if @types.key?(type.name) then
                 # The type is present, delete it. 
@@ -167,7 +167,7 @@ module HDLRuby::Low
             type
         end
 
-        # Deletes an systemT.
+        # Deletes a systemT.
         def delete_systemT!(systemT)
             if @systemTs.key?(systemT.name) then
                 # The systemT is present, delete it. 
@@ -230,6 +230,33 @@ module HDLRuby::Low
                 behavior.parent = nil
             end
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Delete the sub scopes whose name are in names.
+            @scopes.delete_if { |scope| names.include?(scope.name) }
+            # Delete the inner signals whose name are in names.
+            @inners.delete_if { |sig| names.include?(sig.name) }
+            # Delete the connections that contain signals whose name are
+            # in names.
+            @connections.delete_if { |connection| connection.use_name?(*names) }
+            # Delete the behaviors whose block name or events' name are in
+            # names.
+            @behaviors.delete_if do |behavior|
+                names.include?(behavior.block.name) or
+                behavior.each_event.include? do |event|
+                    event.ref.use_name?(*names)
+                end
+            end
+            
+            # Recurse on the sub scopes.
+            @scopes.each { |scope| scope.delete_related!(names) }
+            # Recurse on the behaviors.
+            @behaviors.each { |behavior| behavior.block.delete_related!(names) }
+        end
     end
 
     
@@ -514,6 +541,14 @@ module HDLRuby::Low
             # By default: nothing to do.
             return {}
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Nothing to do by default.
+        end
     end
 
 
@@ -694,6 +729,21 @@ module HDLRuby::Low
 
             return res
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Delete the noifs if their condition uses one of names.
+            @noifs.delete_if { |noif| noif[0].use_names?(names) }
+            # Recurse on the yes.
+            @yes.delete_related!(*names)
+            # Recurse on the no.
+            @no.delete_related!(*names)
+            # Recruse one the no ifs statements.
+            @noifs.each { |noif| noif[1].delete_related!(*names) }
+        end
     end
 
     ##
@@ -758,6 +808,15 @@ module HDLRuby::Low
 
             return res
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Recurse on the statement.
+            @statement.delete_related!(*names)
+        end
     end
 
 
@@ -833,6 +892,18 @@ module HDLRuby::Low
 
             return res
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Delete the whens whose match contains a signal whoses name is
+            # in names.
+            @whens.delete_if { |w| w.match.use_name?(*names) }
+            # Recurse on the whens.
+            @whens.each { |w| w.delete_related!(*names) }
+        end
     end
 
 
@@ -1091,8 +1162,25 @@ module HDLRuby::Low
                 end
             end
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Delete the inner signals whose name are in names.
+            @inners.delete_if { |sig| names.include?(sig.name) }
+            # Recurse on the statements.
+            @statements.each do |statement|
+                statement.delete_related!(*names)
+            end
+            # Delete the statements that contain signals whose name are
+            # in names.
+            @statements.delete_if { |statement| statement.use_name?(*names) }
+        end
     end
 
+
     # Describes a timed block.
     #
     # NOTE: 

data/lib/HDLRuby/hruby_low_without_connection.rb

@@ -29,6 +29,7 @@ module HDLRuby::Low
                 if scope.each_connection.to_a.any? then
                     inputs_blk = Block.new(:par)
                     outputs_blk = Block.new(:par)
+                    timed_blk = TimeBlock.new(:seq)
                     scope.each_connection do |connection|
                         # Check the left and right of the connection
                         # for input or output port.
@@ -40,6 +41,15 @@ module HDLRuby::Low
                         right_r = right.resolve if right.respond_to?(:resolve)
                         # puts "right_r=#{right_r.name}" if right_r
                         # puts "right_r.parent=#{right_r.parent.name}" if right_r && right_r.parent
+                        if right.is_a?(Value) then
+                            # Right is value, the new transmit is to add
+                            # to the timed block.
+                            timed_blk.add_statement(
+                                Transmit.new(left.clone,right.clone))
+                            # No more process for this connection.
+                            next
+                        end
+
                         # Check if left is an input or an output.
                         left_is_i = left_is_o = false
                         if left_r && left_r.parent.is_a?(SystemT) then
@@ -118,6 +128,9 @@ module HDLRuby::Low
                     if outputs_blk.each_statement.any? then
                         scope.add_behavior(Behavior.new(outputs_blk))
                     end
+                    if timed_blk.each_statement.any? then
+                        scope.add_behavior(TimeBehavior.new(timed_blk))
+                    end
                 end
             end
         end

data/lib/HDLRuby/hruby_tools.rb

@@ -13,9 +13,9 @@ module HDLRuby
     @@absoluteCounter = -1 # The absolute name counter.
 
     # Generates an absolute uniq name.
-    def self.uniq_name
+    def self.uniq_name(base = "")
         @@absoluteCounter += 1
-        name = ":#{@@absoluteCounter}"
+        name = base.to_s + ":#{@@absoluteCounter}"
         if Symbol.all_symbols.find {|symbol| symbol.to_s == name } then
             # The symbol exists, try again.
             return self.uniq_name

data/lib/HDLRuby/sim/hruby_sim.h

@@ -612,14 +612,18 @@ extern Value read_range(Value value, long long first, long long last,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
-extern Value write_range(Value src, long long first, long long last, Value dst);
+extern Value write_range(Value src, long long first, long long last, 
+        Type base, Value dst);
 
 /** Writes to a range within a value but without overwrite with Z. 
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
-extern Value write_range_no_z(Value src, long long first, long long last, Value dst);
+extern Value write_range_no_z(Value src, long long first, long long last,
+        Type base, Value dst);

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -1354,10 +1354,11 @@ Value read_range_bitstring(Value src, long long first, long long last,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
 Value write_range_bitstring(Value src, long long first, long long last,
-        Value dst) {
+        Type base, Value dst) {
     unsigned long long i;
     /* Ensure first is the smaller. */
     if (first > last) {
@@ -1370,7 +1371,8 @@ Value write_range_bitstring(Value src, long long first, long long last,
     unsigned long long src_width = type_width(src->type);
     unsigned long long dst_width = type_width(dst->type);
     /* scale the range according to the base type. */
-    unsigned long long bw = dst->type->base;
+    // unsigned long long bw = dst->type->base;
+    unsigned long long bw = type_width(base);
     first *= bw;
     last *=  bw;
     last += bw-1;
@@ -1391,10 +1393,11 @@ Value write_range_bitstring(Value src, long long first, long long last,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
 Value write_range_bitstring_no_z(Value src, long long first, long long last,
-        Value dst) {
+        Type base, Value dst) {
     unsigned long long i;
     /* Ensure first is the smaller. */
     if (first > last) {
@@ -1406,7 +1409,8 @@ Value write_range_bitstring_no_z(Value src, long long first, long long last,
     unsigned long long src_width = type_width(src->type);
     unsigned long long dst_width = type_width(dst->type);
     /* scale the range according to the base type. */
-    unsigned long long bw = dst->type->base;
+    // unsigned long long bw = dst->type->base;
+    unsigned long long bw = type_width(base);
     first *= bw;
     last *=  bw;
     /* Access the source and destination bitstring data. */
@@ -1864,10 +1868,11 @@ Value read_range_numeric(Value value, long long first, long long last,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
 Value write_range_numeric(Value src, long long first, long long last,
-        Value dst) {
+        Type base, Value dst) {
     // printf("write_range_numeric\n");
     /* Ensure first is the smaller. */
     if (first > last) {
@@ -1879,7 +1884,8 @@ Value write_range_numeric(Value src, long long first, long long last,
     unsigned long long src_width = type_width(src->type);
     unsigned long long dst_width = type_width(dst->type);
     /* scale the range according to the base type of the destination. */
-    unsigned long long bw = dst->type->base;
+    // unsigned long long bw = dst->type->base;
+    unsigned long long bw = type_width(base);
     // printf("src_width=%llu dst_wdith=%llu bw=%llu\n",src_width,dst_width,bw);
     first *= bw;
     last *= bw;
@@ -2691,14 +2697,17 @@ Value read_range(Value value, long long first, long long last, Type base,
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
-Value write_range(Value src, long long first, long long last, Value dst) {
+Value write_range(Value src, long long first, long long last, Type base,
+        Value dst) {
     // printf("write_range\n");
     /* Is the value numeric? */
     if ((src->numeric) && (dst->numeric)) {
         /* Yes, do a numeric range read. */
-        return write_range_numeric(src,first,last,dst);
+        // return write_range_numeric(src,first,last,dst);
+        return write_range_numeric(src,first,last,base,dst);
     } else {
         /* No, do a bitstring range read. */
         if (dst->numeric) {
@@ -2708,7 +2717,8 @@ Value write_range(Value src, long long first, long long last, Value dst) {
             /* Need to convert the source to a bitstring. */
             src = set_bitstring_value(src,get_value());
         }
-        return write_range_bitstring(src,first,last,dst);
+        // return write_range_bitstring(src,first,last,dst);
+        return write_range_bitstring(src,first,last,base,dst);
     }
 }
 
@@ -2717,14 +2727,16 @@ Value write_range(Value src, long long first, long long last, Value dst) {
  *  @param src the source value
  *  @param first the first index of the range
  *  @param last the last index of the range
+ *  @param base the type of the elements
  *  @param dst the destination value
  *  @return dst */
-Value write_range_no_z(Value src, long long first, long long last, Value dst) {
+Value write_range_no_z(Value src, long long first, long long last, Type base,
+        Value dst) {
     // printf("write_range_no_z\n");
     /* Is the value numeric? */
     if ((src->numeric) && (dst->numeric)) {
         /* Yes, do a numeric range read. */
-        return write_range_numeric(src,first,last,dst);
+        return write_range_numeric(src,first,last,base,dst);
     } else {
         /* No, do a bitstring range read. */
         if (dst->numeric) {
@@ -2734,7 +2746,8 @@ Value write_range_no_z(Value src, long long first, long long last, Value dst) {
             /* Need to convert the source to a bitstring. */
             src = set_bitstring_value(src,get_value());
         }
-        return write_range_bitstring_no_z(src,first,last,dst);
+        // return write_range_bitstring_no_z(src,first,last,dst);
+        return write_range_bitstring_no_z(src,first,last,base,dst);
     }
 }
 

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -499,12 +499,18 @@ void transmit_to_signal_range(Value value, RefRangeS ref) {
     SignalI signal = ref.signal;
     unsigned long long first = ref.first;
     unsigned long long last = ref.last;
+    /* The base type is stored here to avoid allocating a new type each time.
+     * It have an arbitrary base size a single element. */
+    static TypeS baseT = { 1, 1 };
+    baseT.base = signal->f_value->type->base;
     // printf("Tansmit to signal range: %s(%p) [%lld:%lld]\n",signal->name,signal,first,last);
     /* Can transmit, copy the content. */
     if (signal->fading)
-        signal->f_value = write_range(value,first,last,signal->f_value);
+        signal->f_value = write_range(value,first,last,&baseT,
+                signal->f_value);
     else
-        signal->f_value = write_range_no_z(value,first,last,signal->f_value);
+        signal->f_value = write_range_no_z(value,first,last,&baseT,
+                signal->f_value);
     /* And touch the signal. */
     touch_signal(signal);
 }
@@ -553,9 +559,9 @@ void transmit_to_signal_range_seq(Value value, RefRangeS ref) {
     // printf("Tansmit to signal range: %s(%p)\n",signal->name,signal);
     /* Can transmit, copy the content. */
     if (signal->fading)
-        write_range(value,first,last,signal->f_value);
+        write_range(value,first,last,signal->f_value->type,signal->f_value);
     else
-        write_range_no_z(value,first,last,signal->f_value);
+        write_range_no_z(value,first,last,signal->f_value->type,signal->f_value);
     /* And touch the signal. */
     touch_signal_seq(signal);
 }

data/lib/HDLRuby/std/channel.rb

@@ -45,8 +45,10 @@ module HDLRuby::High::Std
             # Generates the channels.
             channelI = nil
             args.each do |nameI|
-                channelI = ChannelI.new(name,&@ruby_block)
-                HDLRuby::High.space_reg(nameI) { channelI }
+                # puts "nameI=#{nameI}"
+                channelI = ChannelI.new(nameI,&@ruby_block)
+                # Already registered!
+                # HDLRuby::High.space_reg(nameI) { channelI }
             end
             channelI
         end
@@ -323,6 +325,86 @@ module HDLRuby::High::Std
     end
 
 
+    ##
+    # Module giving the methods for accessing a channel instance.
+    module HchannelI
+        ## Performs a read on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        #  NOTE:
+        #  * Will generate a port if not present.
+        #  * Will generate an error if a read is tempted while the read
+        #    port has been declared within another system.
+        def read(*args,&ruby_block)
+            # Is there a port to read?
+            unless self.read_port then
+                # No, generate a new one.
+                # Is it possible to be inout?
+                if self.inout? then
+                    # Yes, create an inout port.
+                    self.inout(HDLRuby.uniq_name)
+                else
+                    # No, create an input port.
+                    self.input(HDLRuby.uniq_name)
+                end
+            end
+            # Ensure the read port is within current system.
+            unless self.read_port.scope.system != HDLRuby::High.cur_system then
+                raise "Cannot read from a port external of current system for channel " + self.name
+            end
+            # Performs the read.
+            self.read_port.read(*args,&ruby_block)
+        end
+        
+        ## Performs a write on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        #  NOTE:
+        #  * Will generate a port if not present.
+        #  * Will generate an error if a read is tempted while the read
+        #    port has been declared within another system.
+        def write(*args,&ruby_block)
+            # Is there a port to write?
+            unless self.write_port then
+                # No, generate a new one.
+                # Is it possible to be inout?
+                if self.inout? then
+                    # Yes, create an inout port.
+                    self.inout(HDLRuby.uniq_name)
+                else
+                    # No, create an output port.
+                    self.output(HDLRuby.uniq_name)
+                end
+            end
+            # Ensure the write port is within current system.
+            unless self.write_port.scope.system != HDLRuby::High.cur_system then
+                raise "Cannot write from a port external of current system for channel " + self.name
+            end
+            # Performs the write.
+            self.write_port.write(*args,&ruby_block)
+        end
+        
+
+        ## Performs a reset on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        def reset(*args,&ruby_block)
+            # Gain access to the writer as local variable.
+            reseter_proc = @inout_reseter_proc
+            # # The context is the one of the writer.
+            # Execute the code generating the writer in context.
+            HDLRuby::High.space_push(@namespace)
+            HDLRuby::High.cur_block.open do
+                instance_exec(ruby_block,*args,&reseter_proc)
+            end
+            HDLRuby::High.space_pop
+        end
+
+
+        # Wrap with +args+ arguments.
+        def wrap(*args)
+            return ChannelB.new(self,*args)
+        end
+    end
+
+
 
     ## 
     # Describes a high-level channel instance.
@@ -350,9 +432,11 @@ module HDLRuby::High::Std
         def initialize(name,&ruby_block)
             # Check and set the name of the channel.
             @name = name.to_sym
+            # puts "my name is #{self.name}"
             # Generate a name for the scope containing the signals of
             # the channel.
-            @scope_name = HDLRuby.uniq_name
+            # @scope_name = HDLRuby.uniq_name
+            @scope_name = HDLRuby.uniq_name(name)
 
             # # Sets the scope.
             # @scope = HDLRuby::High.cur_scope
@@ -635,6 +719,7 @@ module HDLRuby::High::Std
         # Alternatively, a ready channel instance can be passed as argument
         # as +channelI+.
         def brancher(name,channelI = nil,&ruby_block)
+            # puts "self.name=#{self.name} and name=#{name}"
             # Ensure name is a symbol.
             name = name.to_s unless name.respond_to?(:to_sym)
             name = name.to_sym
@@ -646,6 +731,7 @@ module HDLRuby::High::Std
             end
             # Now, create the branch.
             channelI = HDLRuby::High::Std.channel_instance(name, &ruby_block)
+            # channelI = HDLRuby::High::Std.channel_instance("#{self.name}::#{name}", &ruby_block)
             @branches[name] = channelI
             return self
         end
@@ -858,12 +944,12 @@ module HDLRuby::High::Std
             # Ensure the port is not already existing.
             if @read_port then
                 raise "Read port already declared for channel instance: " +
-                    self.name
+                    self.name.to_s
             end
 
             if @write_port then
                 raise "Write port already declared for channel instance: " +
-                    self.name
+                    self.name.to_s
             end
 
             # Access the ports
@@ -1000,76 +1086,238 @@ module HDLRuby::High::Std
         #     return chp
         # end
 
+        # Standard channel access is given is HchannelI module.
+        include HchannelI
 
         
-        ## Performs a read on the channel using +args+ and +ruby_block+
-        #  as arguments.
-        #  NOTE:
-        #  * Will generate a port if not present.
-        #  * Will generate an error if a read is tempted while the read
-        #    port has been declared within another system.
-        def read(*args,&ruby_block)
-            # Is there a port to read?
-            unless self.read_port then
-                # No, generate a new one.
-                # Is it possible to be inout?
-                if self.inout? then
-                    # Yes, create an inout port.
-                    self.inout(HDLRuby.uniq_name)
-                else
-                    # No, create an input port.
-                    self.input(HDLRuby.uniq_name)
-                end
+        # ## Performs a read on the channel using +args+ and +ruby_block+
+        # #  as arguments.
+        # #  NOTE:
+        # #  * Will generate a port if not present.
+        # #  * Will generate an error if a read is tempted while the read
+        # #    port has been declared within another system.
+        # def read(*args,&ruby_block)
+        #     # Is there a port to read?
+        #     unless self.read_port then
+        #         # No, generate a new one.
+        #         # Is it possible to be inout?
+        #         if self.inout? then
+        #             # Yes, create an inout port.
+        #             self.inout(HDLRuby.uniq_name)
+        #         else
+        #             # No, create an input port.
+        #             self.input(HDLRuby.uniq_name)
+        #         end
+        #     end
+        #     # Ensure the read port is within current system.
+        #     unless self.read_port.scope.system != HDLRuby::High.cur_system then
+        #         raise "Cannot read from a port external of current system for channel " + self.name
+        #     end
+        #     # Performs the read.
+        #     self.read_port.read(*args,&ruby_block)
+        # end
+        # 
+        # ## Performs a write on the channel using +args+ and +ruby_block+
+        # #  as arguments.
+        # #  NOTE:
+        # #  * Will generate a port if not present.
+        # #  * Will generate an error if a read is tempted while the read
+        # #    port has been declared within another system.
+        # def write(*args,&ruby_block)
+        #     # Is there a port to write?
+        #     unless self.write_port then
+        #         # No, generate a new one.
+        #         # Is it possible to be inout?
+        #         if self.inout? then
+        #             # Yes, create an inout port.
+        #             self.inout(HDLRuby.uniq_name)
+        #         else
+        #             # No, create an output port.
+        #             self.output(HDLRuby.uniq_name)
+        #         end
+        #     end
+        #     # Ensure the write port is within current system.
+        #     unless self.write_port.scope.system != HDLRuby::High.cur_system then
+        #         raise "Cannot write from a port external of current system for channel " + self.name
+        #     end
+        #     # Performs the write.
+        #     self.write_port.write(*args,&ruby_block)
+        # end
+        # 
+
+        # ## Performs a reset on the channel using +args+ and +ruby_block+
+        # #  as arguments.
+        # def reset(*args,&ruby_block)
+        #     # Gain access to the writer as local variable.
+        #     reseter_proc = @inout_reseter_proc
+        #     # # The context is the one of the writer.
+        #     # Execute the code generating the writer in context.
+        #     HDLRuby::High.space_push(@namespace)
+        #     HDLRuby::High.cur_block.open do
+        #         instance_exec(ruby_block,*args,&reseter_proc)
+        #     end
+        #     HDLRuby::High.space_pop
+        # end
+    end
+
+    # Describes channel instance wrapper (Box) for fixing arugments.
+    class ChannelB
+        include HDLRuby::High::Hmissing
+        include HchannelI
+
+        # Create a new channel box over +channelI+ channel instance using
+        # +args+ for fixing the arguments as follows:
+        # It can also be three lists for seperate read, write and access
+        # procedures using named arguments as:
+        # read: <read arguments>, write: <write arguments>,
+        # access: <access arguments>
+        def initialize(channelI,*args)
+            # Ensure port is a channel port.
+            unless channelI.is_a?(ChannelI) || channel.is_a?(ChannelB)
+                raise "Invalid class for a channel instance: #{ch.class}"
             end
-            # Ensure the read port is within current system.
-            unless self.read_port.scope.system != HDLRuby::High.cur_system then
-                raise "Cannot read from a port external of current system for channel " + self.name
+            @channelI = channelI
+            # Process the arguments.
+            if args.size == 1 && args[0].is_a?(Hash) then
+                # Read, write and access are separated.
+                @args_read = args[0][:read]
+                @args_write = args[0][:write]
+                @args_access = args[0][:access]
+            else
+                @args_read = args
+                @args_write = args.clone
+                @args_access = args.clone
             end
-            # Performs the read.
-            self.read_port.read(*args,&ruby_block)
         end
+
+        # Delegates to the boxed channel instance.
+
+        # The name of the channel instance.
+        def name
+            return @channelI.name
+        end
+
+        # The scope the channel has been created in.
+        def scope
+            return @channelI.scope
+        end
+
+        # The namespace associated with the current execution when
+        # building a channel.
+        def namespace
+            return @channelI.namespace
+        end
+
+        # The read port if any.
+        def read_port
+            return @read_port
+        end
+
+        # The write port if any.
+        def write_port
+            return @write_port
+        end
+
+        # Methods used on the channel outside its definition.
         
-        ## Performs a write on the channel using +args+ and +ruby_block+
-        #  as arguments.
-        #  NOTE:
-        #  * Will generate a port if not present.
-        #  * Will generate an error if a read is tempted while the read
-        #    port has been declared within another system.
-        def write(*args,&ruby_block)
-            # Is there a port to write?
-            unless self.write_port then
-                # No, generate a new one.
-                # Is it possible to be inout?
-                if self.inout? then
-                    # Yes, create an inout port.
-                    self.inout(HDLRuby.uniq_name)
-                else
-                    # No, create an output port.
-                    self.output(HDLRuby.uniq_name)
-                end
+        # Gets branch channel +name+.
+        # NOTE: 
+        #  * +name+ can be of any type on purpose.
+        #  * The wrapping arguments are not transmitted to the branch.
+        def branch(name,*args)
+            return @channelI.branch(name,*args)
+        end
+
+        ## Tells if the channel support inout port.
+        def inout?
+            return @channelI.inout?
+        end
+
+
+        # Reader, writer and accesser side.
+
+        ## Declares the reader port as and assigned them to +name+.
+        def input(name = nil)
+            # Ensure name is a symbol.
+            name = HDLRuby.uniq_name unless name
+            name = name.to_sym
+            # Ensure the port is not already existing.
+            if @read_port then
+                raise "Read port already declared for channel instance: " +
+                    self.name
             end
-            # Ensure the write port is within current system.
-            unless self.write_port.scope.system != HDLRuby::High.cur_system then
-                raise "Cannot write from a port external of current system for channel " + self.name
+
+            # Create a read port for the encaspulted channel.
+            real_port = @channelI.read_port
+            real_port = @channelI.input unless real_port
+
+            # Wrap it to a new port using.
+            chp = real_port.wrap(read: @args_read)
+
+            HDLRuby::High.space_reg(name) { chp }
+            # Save the port in the channe to avoid conflicting declaration.
+            @read_port = chp
+            return chp
+        end
+
+        ## Declares the ports for the writer and assigned them to +name+.
+        def output(name = nil)
+            # Ensure name is a symbol.
+            name = HDLRuby.uniq_name unless name
+            name = name.to_sym
+            # Ensure the port is not already existing.
+            if @write_port then
+                raise "Read port already declared for channel instance: " +
+                    self.name
             end
-            # Performs the write.
-            self.write_port.write(*args,&ruby_block)
+
+            # Create a write port for the encaspulted channel.
+            real_port = @channelI.write_port
+            real_port = @channelI.output unless real_port
+
+            # Wrap it to a new port using.
+            chp = real_port.wrap(write: @args_write)
+
+            HDLRuby::High.space_reg(name) { chp }
+            # Save the port in the channe to avoid conflicting declaration.
+            @write_port = chp
+            return chp
         end
-        
 
-        ## Performs a reset on the channel using +args+ and +ruby_block+
-        #  as arguments.
-        def reset(*args,&ruby_block)
-            # Gain access to the writer as local variable.
-            reseter_proc = @inout_reseter_proc
-            # # The context is the one of the writer.
-            # Execute the code generating the writer in context.
-            HDLRuby::High.space_push(@namespace)
-            HDLRuby::High.cur_block.open do
-                instance_exec(ruby_block,*args,&reseter_proc)
+
+        ## Declares the accesser port and assigned them to +name+.
+        def inout(name = nil)
+            # Ensure name is a symbol.
+            name = HDLRuby.uniq_name unless name
+            name = name.to_sym
+            # Ensure the port is not already existing.
+            if @read_port then
+                raise "Read port already declared for channel instance: " +
+                    self.name
             end
-            HDLRuby::High.space_pop
+            if @write_port then
+                raise "Write port already declared for channel instance: " +
+                    self.name
+            end
+
+            # Create a write port for the encaspulted channel.
+            if @channelI.read_port == @channelI.write_port then
+                real_port = @channelI.read_port
+                real_port = @channelI.inout unless real_port
+            else
+                raise "Inout port not supported for channel #{@channelI}"
+            end
+
+            # Wrap it to a new port using.
+            chp = real_port.wrap(read: @args_read, write: @args_write)
+
+            HDLRuby::High.space_reg(name) { chp }
+            # Save the port in the channe to avoid conflicting declaration.
+            @write_port = chp
+            @read_port = chp
+            return chp
         end
+
     end
 
 

data/lib/HDLRuby/std/linear.rb

@@ -214,6 +214,14 @@ module HDLRuby::High::Std
         par(ev) do
             ack <= 0
             run <= 0
+            hif(~run) do
+                rvok <= 0
+                lefts.each_with_index do |left,i|
+                    lvoks[i] <= 0
+                    # accs[i].write(0)
+                    avs[i] <= 0
+                end
+            end
             hif(req | run) do
                 run <= 1
                 # Computation request.
@@ -232,14 +240,14 @@ module HDLRuby::High::Std
                     end
                 end
             end
-            helse do
-                rvok <= 0
-                lefts.each_with_index do |left,i|
-                    lvoks[i] <= 0
-                    # accs[i].write(0)
-                    avs[i] <= 0
-                end
-            end
+            # helse do
+            #     rvok <= 0
+            #     lefts.each_with_index do |left,i|
+            #         lvoks[i] <= 0
+            #         # accs[i].write(0)
+            #         avs[i] <= 0
+            #     end
+            # end
         end
     end
 

data/lib/HDLRuby/std/memory.rb

@@ -568,7 +568,7 @@ HDLRuby::High::Std.channel(:mem_dual) do |typ,size,clk,rst,br_rsts = {}|
         # using +target+ as target of access result.
         writer do |blk,target|
             # On reset the read trigger is 0.
-            rst  = send(rst_name)
+            rst = send(rst_name)
             top_block.unshift do
                 # Initialize the address so that the next access is at address 0.
                 hif(rst == 1) { abus_w <= -1 }

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.3.3"
+  VERSION = "2.3.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 2.3.8
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-09 00:00:00.000000000 Z
+date: 2020-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler