HDLRuby 2.3.2 → 2.3.7

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

@@ -365,6 +365,7 @@ void* behavior_run(void* arg) {
  *  @note create a thread per timed behavior. */
 void hruby_sim_start_timed_behaviors() {
     int i;
+    pthread_mutex_lock(&hruby_sim_mutex);
     /* Sets the end flags to 0. */
     sim_end_flag = 0;
     /* Create and start the threads. */
@@ -375,6 +376,7 @@ void hruby_sim_start_timed_behaviors() {
         pthread_create(&timed_behaviors[i]->thread,NULL,
                        &behavior_run,timed_behaviors[i]);
     }
+    pthread_mutex_unlock(&hruby_sim_mutex);
 }
 
 /** Ends waiting all the threads properly terminates. */
@@ -497,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);
 }
@@ -551,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
@@ -96,6 +98,9 @@ module HDLRuby::High::Std
         def wrap(*args)
             return ChannelPortB.new(self,*args)
         end
+
+        # The scope the port has been declared in.
+        attr_reader :scope
     end
 
 
@@ -113,6 +118,7 @@ module HDLRuby::High::Std
             @namespace = namespace
             @reader_proc = reader_proc.to_proc
             @rester_proc = reseter_proc ? reseter_proc.to_proc : proc {}
+            @scope = HDLRuby::High.cur_scope
         end
 
         ## Performs a read on the channel using +args+ and +ruby_block+
@@ -157,6 +163,7 @@ module HDLRuby::High::Std
             @namespace = namespace
             @writer_proc = writer_proc.to_proc
             @reseter_proc = reseter_proc ? reseter_proc.to_proc : proc {}
+            @scope = HDLRuby::High.cur_scope
         end
 
         ## Performs a write on the channel using +args+ and +ruby_block+
@@ -206,6 +213,7 @@ module HDLRuby::High::Std
             @reader_proc  = reader_proc ? reader_proc.to_proc : proc { }
             @writer_proc  = writer_proc ? writer_proc.to_proc : proc { }
             @reseter_proc = reseter_proc ? reseter_proc.to_proc : proc {}
+            @scope = HDLRuby::High.cur_scope
         end
 
         ## Performs a read on the channel using +args+ and +ruby_block+
@@ -281,6 +289,8 @@ module HDLRuby::High::Std
                 @args_write = args.clone
                 @args_access = args.clone
             end
+
+            @scope = @port.scope
         end
 
         ## Performs a read on the channel using +args+ and +ruby_block+
@@ -315,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.
@@ -332,13 +422,21 @@ module HDLRuby::High::Std
         # building a channel.
         attr_reader :namespace
 
+        # The read port if any.
+        attr_reader :read_port
+
+        # The write port if any.
+        attr_reader :write_port
+
         ## Creates a new channel instance with +name+ built from +ruby_block+.
         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
@@ -346,6 +444,10 @@ module HDLRuby::High::Std
             # Keep access to self.
             obj = self
 
+            # At first there no read nor write port.
+            @read_port = nil
+            @write_port = nil
+
             # The reader input ports by name.
             @reader_inputs = {}
             # The reader output ports by name.
@@ -367,11 +469,6 @@ module HDLRuby::High::Std
             # The accesser inout ports by name.
             @accesser_inouts = {}
 
-            # # The default reset procedures (reseters), by default do nothing.
-            # @input_reseter_proc  = proc {}
-            # @output_reseter_proc = proc {}
-            # @inout_reseter_proc  = proc {}
-
             # The branch channels
             @branches = {}
 
@@ -427,6 +524,11 @@ module HDLRuby::High::Std
             HDLRuby::High.space_reg(@name) { obj }
         end
 
+        # Get the parent system.
+        def parent_system
+            return self.scope.parent_system
+        end
+
         # The methods for defining the channel
         
         # For the channel itself
@@ -606,11 +708,18 @@ module HDLRuby::High::Std
                    @writer_inouts.values
         end
 
+        ## Tells if the channel support inout port.
+        def inout?
+            return @accesser_inputs.any? || @accesser_outputs.any? ||
+                   @accesser_inouts.any?
+        end
+
         # Defines a branch in the channel named +name+ built executing
         # +ruby_block+.
         # 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
@@ -620,9 +729,9 @@ module HDLRuby::High::Std
                 @branches[name] = channelI
                 return self
             end
-            # No, create the branch.
-            # channelI = HDLRuby::High.channel_instance(name, &ruby_block)
+            # 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
@@ -644,54 +753,83 @@ module HDLRuby::High::Std
 
         # Reader, writer and accesser side.
 
-        ## Declares the ports for the reader and assigned them to +name+.
-        def input(name)
+        ## 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
+
             # Access the ports
-            loc_inputs  = @reader_inputs
-            loc_outputs = @reader_outputs
-            loc_inouts  = @reader_inouts
+            # loc_inputs  = @reader_inputs
+            # loc_outputs = @reader_outputs
+            # loc_inouts  = @reader_inouts
+            loc_inputs  = @reader_inputs.merge(@accesser_inputs)
+            loc_outputs = @reader_outputs.merge(@accesser_outputs)
+            loc_inouts  = @reader_inouts.merge(@accesser_inouts)
+            locs = loc_inputs.merge(loc_outputs).merge(loc_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  do |name,sig|
-                    # puts "name=#{name} sig.name=#{sig.name}"
-                    port_pairs << [sig, sig.type.input(name)]
+            if HDLRuby::High.cur_system == self.parent_system then
+                # Port in same system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    locs.each  do |name,sig|
+                        port_pairs << [sig, sig.type.inner(name)]
+                    end
                 end
-                # The outputs
-                loc_outputs.each do |name,sig| 
-                    port_pairs << [sig, sig.type.output(name)]
+                obj = self
+                # Make the inner connection
+                port_pairs.each do |sig, port|
+                    sig.parent.open do
+                        port.to_ref <= sig
+                    end
                 end
-                # The inouts
-                loc_inouts.each  do |name,sig| 
-                    port_pairs << [sig, sig.type.inout(name)]
+            else
+                # Port in different system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    # The inputs
+                    loc_inputs.each  do |name,sig|
+                        # puts "name=#{name} sig.name=#{sig.name}"
+                        port_pairs << [sig, sig.type.input(name)]
+                    end
+                    # The outputs
+                    loc_outputs.each do |name,sig| 
+                        port_pairs << [sig, sig.type.output(name)]
+                    end
+                    # The inouts
+                    loc_inouts.each  do |name,sig| 
+                        port_pairs << [sig, sig.type.inout(name)]
+                    end
                 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
+                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
             end
 
             # Fill the reader namespace with the access to the reader signals.
-            @reader_inputs.each do |name,sig|
+            loc_inputs.each do |name,sig|
                 @reader_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
             end
-            @reader_outputs.each do |name,sig|
+            loc_outputs.each do |name,sig|
                 @reader_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
             end
-            @reader_inouts.each do |name,sig|
+            loc_inouts.each do |name,sig|
                 @reader_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
@@ -701,56 +839,88 @@ module HDLRuby::High::Std
             # NOTE: for now, simply associate the channel to name.
             chp = ChannelPortR.new(@reader_namespace,@reader_proc,@input_reseter_proc)
             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)
+        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 "Write port already declared for channel instance: " +
+                    self.name
+            end
             # Access the ports
-            loc_inputs  = @writer_inputs
-            loc_outputs = @writer_outputs
-            loc_inouts  = @writer_inouts
+            # loc_inputs  = @writer_inputs
+            # loc_outputs = @writer_outputs
+            # loc_inouts  = @writer_inouts
+            loc_inputs  = @writer_inputs.merge(@accesser_inputs)
+            loc_outputs = @writer_outputs.merge(@accesser_outputs)
+            loc_inouts  = @writer_inouts.merge(@accesser_inouts)
+            locs = loc_inputs.merge(loc_outputs).merge(loc_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  do |name,sig|
-                    port_pairs << [sig, sig.type.input(name)]
+            # puts "cur_system=#{HDLRuby::High.cur_system} self.parent_system=#{self.parent_system}"
+            if HDLRuby::High.cur_system == self.parent_system then
+                # puts "Inner found!"
+                # Port in same system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    locs.each  do |name,sig|
+                        port_pairs << [sig, sig.type.inner(name)]
+                    end
                 end
-                # The outputs
-                loc_outputs.each do |name,sig| 
-                    port_pairs << [sig, sig.type.output(name)]
+                obj = self
+                # Make the inner connection
+                port_pairs.each do |sig, port|
+                    sig.parent.open do
+                        port.to_ref <= sig
+                    end
                 end
-                # The inouts
-                loc_inouts.each  do |name,sig| 
-                    port_pairs << [sig, sig.type.inout(name)]
+            else
+                # Portds in different system as the channel's case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    # The inputs
+                    loc_inputs.each  do |name,sig|
+                        port_pairs << [sig, sig.type.input(name)]
+                    end
+                    # The outputs
+                    loc_outputs.each do |name,sig| 
+                        port_pairs << [sig, sig.type.output(name)]
+                    end
+                    # The inouts
+                    loc_inouts.each  do |name,sig| 
+                        port_pairs << [sig, sig.type.inout(name)]
+                    end
                 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
+                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
             end
 
             # Fill the writer namespace with the access to the writer signals.
-            @writer_inputs.each do |name,sig|
+            loc_inputs.each do |name,sig|
                 @writer_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
             end
-            @writer_outputs.each do |name,sig|
+            loc_outputs.each do |name,sig|
                 @writer_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
             end
-            @writer_inouts.each do |name,sig|
+            loc_inouts.each do |name,sig|
                 @writer_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
@@ -760,73 +930,28 @@ module HDLRuby::High::Std
             # NOTE: for now, simply associate the channel to name.
             chp = ChannelPortW.new(@writer_namespace,@writer_proc,@output_reseter_proc)
             HDLRuby::High.space_reg(name) { chp }
+            # Save the port in the channe to avoid conflicting declaration.
+            @write_port = chp
             return chp
         end
 
-        ## Declares the ports for the accesser and assigned them to +name+.
-        def inout(name)
+
+        ## 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
-            # Access the ports
-            loc_inputs  = @accesser_inputs
-            loc_outputs = @accesser_outputs
-            loc_inouts  = @accesser_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  do |name,sig|
-                    port_pairs << [sig, sig.type.input(name)]
-                end
-                # The outputs
-                loc_outputs.each do |name,sig| 
-                    port_pairs << [sig, sig.type.output(name)]
-                end
-                # The inouts
-                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
+            # Ensure the port is not already existing.
+            if @read_port then
+                raise "Read port already declared for channel instance: " +
+                    self.name.to_s
             end
 
-            # Set ups the accesser's namespace
-            @accesser_inputs.each do |name,sig|
-                @accesser_namespace.add_method(sig.name) do
-                    HDLRuby::High.top_user.send(name)
-                end
-            end
-            @accesser_outputs.each do |name,sig|
-                @accesser_namespace.add_method(sig.name) do
-                    HDLRuby::High.top_user.send(name)
-                end
+            if @write_port then
+                raise "Write port already declared for channel instance: " +
+                    self.name.to_s
             end
-            @accesser_inouts.each do |name,sig|
-                @accesser_namespace.add_method(sig.name) do
-                    HDLRuby::High.top_user.send(name)
-                end
-            end
-
-            # Give access to the ports through name.
-            # NOTE: for now, simply associate the channel to name.
-            chp = ChannelPortA.new(@accesser_namespace,@reader_proc,@writer_proc,@inout_reseter_proc)
-            HDLRuby::High.space_reg(name) { chp }
-            return chp
-        end
 
-        ## Declares the ports for accessing the channel as an inner component
-        #  and assigned them to +name+.
-        def inner(name)
-            # Ensure name is a symbol.
-            name = name.to_sym
             # Access the ports
             loc_inputs  = @accesser_inputs.merge(@reader_inputs).
                 merge(@writer_inputs)
@@ -837,21 +962,51 @@ module HDLRuby::High::Std
             locs = loc_inputs.merge(loc_outputs).merge(loc_inouts)
             # The generated port with corresponding channel port pairs.
             port_pairs = []
-            # Add them to the current system.
-            HDLRuby::High.cur_system.open do
-                locs.each  do |name,sig|
-                    port_pairs << [sig, sig.type.inner(name)]
+            if HDLRuby::High.cur_system == self.parent_system then
+                # Port in same system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    locs.each  do |name,sig|
+                        port_pairs << [sig, sig.type.inner(name)]
+                    end
                 end
-            end
-            obj = self
-            # Make the inner connection
-            port_pairs.each do |sig, port|
-                sig.parent.open do
-                    port.to_ref <= sig
+                obj = self
+                # Make the inner connection
+                port_pairs.each do |sig, port|
+                    sig.parent.open do
+                        port.to_ref <= sig
+                    end
+                end
+            else
+                # Port in different system as the channel case.
+                # Add them to the current system.
+                HDLRuby::High.cur_system.open do
+                    # The inputs
+                    loc_inputs.each  do |name,sig|
+                        # puts "name=#{name} sig.name=#{sig.name}"
+                        port_pairs << [sig, sig.type.input(name)]
+                    end
+                    # The outputs
+                    loc_outputs.each do |name,sig| 
+                        port_pairs << [sig, sig.type.output(name)]
+                    end
+                    # The inouts
+                    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
             end
 
-            # Set ups the accesser's namespace
+            # Fill the reader namespace with the access to the reader signals.
             loc_inputs.each do |name,sig|
                 @accesser_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
@@ -872,51 +1027,297 @@ module HDLRuby::High::Std
             # NOTE: for now, simply associate the channel to name.
             chp = ChannelPortA.new(@accesser_namespace,@reader_proc,@writer_proc,@inout_reseter_proc)
             HDLRuby::High.space_reg(name) { chp }
+            # Save the port in the channe to avoid conflicting declaration.
+            @read_port = chp
+            @write_port = chp
             return chp
         end
 
+        # ## Declares the ports for accessing the channel as an inner component
+        # #  and assigned them to +name+.
+        # def inner(name)
+        #     # Ensure name is a symbol.
+        #     name = name.to_sym
+        #     # Access the ports
+        #     loc_inputs  = @accesser_inputs.merge(@reader_inputs).
+        #         merge(@writer_inputs)
+        #     loc_outputs = @accesser_outputs.merge(@reader_outputs).
+        #         merge(@writer_outputs)
+        #     loc_inouts  = @accesser_inouts.merge(@reader_inouts).
+        #         merge(@writer_inouts)
+        #     locs = loc_inputs.merge(loc_outputs).merge(loc_inouts)
+        #     # The generated port with corresponding channel port pairs.
+        #     port_pairs = []
+        #     # Add them to the current system.
+        #     HDLRuby::High.cur_system.open do
+        #         locs.each  do |name,sig|
+        #             port_pairs << [sig, sig.type.inner(name)]
+        #         end
+        #     end
+        #     obj = self
+        #     # Make the inner connection
+        #     port_pairs.each do |sig, port|
+        #         sig.parent.open do
+        #             port.to_ref <= sig
+        #         end
+        #     end
+
+        #     # Set ups the accesser's namespace
+        #     loc_inputs.each do |name,sig|
+        #         @accesser_namespace.add_method(sig.name) do
+        #             HDLRuby::High.top_user.send(name)
+        #         end
+        #     end
+        #     loc_outputs.each do |name,sig|
+        #         @accesser_namespace.add_method(sig.name) do
+        #             HDLRuby::High.top_user.send(name)
+        #         end
+        #     end
+        #     loc_inouts.each do |name,sig|
+        #         @accesser_namespace.add_method(sig.name) do
+        #             HDLRuby::High.top_user.send(name)
+        #         end
+        #     end
+
+        #     # Give access to the ports through name.
+        #     # NOTE: for now, simply associate the channel to name.
+        #     chp = ChannelPortA.new(@accesser_namespace,@reader_proc,@writer_proc,@inout_reseter_proc)
+        #     HDLRuby::High.space_reg(name) { chp }
+        #     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.
-        def read(*args,&ruby_block)
-            # Gain access to the reader as local variable.
-            reader_proc = @reader_proc
-            # # The context is the one of the reader.
-            # Execute the code generating the reader in context.
-            HDLRuby::High.space_push(@namespace)
-            HDLRuby::High.cur_block.open do
-                instance_exec(ruby_block,*args,&reader_proc)
+        # ## 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
+            @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
-            HDLRuby::High.space_pop
         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.
-        def write(*args,&ruby_block)
-            # Gain access to the writer as local variable.
-            writer_proc = @writer_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,&writer_proc)
+        # 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
-            HDLRuby::High.space_pop
+
+            # 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
 
-        ## 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 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
-            HDLRuby::High.space_pop
+
+            # 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
+
+
+        ## 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
+            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
 
 
@@ -925,6 +1326,8 @@ module HDLRuby::High::Std
         # Create a new object wrapper for +obj+.
         def initialize(obj)
             @obj = obj
+
+            @scope = HDLRuby::High.cur_scope
         end
 
         # Port read with arguments +args+ executing +ruby_block+ in