HDLRuby 2.2.16 → 2.3.3

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. */

data/lib/HDLRuby/std/channel.rb

@@ -81,20 +81,31 @@ module HDLRuby::High::Std
     end
 
 
-    ##
-    #  Module for wrapping channel ports.
-    module ChannelPortWrapping
+    # ##
+    # #  Module for wrapping channel ports.
+    # module ChannelPortWrapping
+    #     # Wrap with +args+ arguments.
+    #     def wrap(*args)
+    #         return ChannelPortB.new(self,*args)
+    #     end
+    # end
+
+    ## Describes a channel port.
+    class ChannelPort
         # Wrap with +args+ arguments.
         def wrap(*args)
             return ChannelPortB.new(self,*args)
         end
+
+        # The scope the port has been declared in.
+        attr_reader :scope
     end
 
 
     ##
     # Describes a read port to a channel.
-    class ChannelPortR
-        include ChannelPortWrapping
+    class ChannelPortR < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel reader running in +namespace+ and
         # reading using +reader_proc+ and reseting using +reseter_proc+.
@@ -105,6 +116,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+
@@ -137,8 +149,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes a writer port to a channel.
-    class ChannelPortW
-        include ChannelPortWrapping
+    class ChannelPortW < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel writer running in +namespace+ and
         # writing using +writer_proc+ and reseting using +reseter_proc+.
@@ -149,6 +161,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+
@@ -181,8 +194,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes an access port to a channel.
-    class ChannelPortA
-        include ChannelPortWrapping
+    class ChannelPortA < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel accesser running in +namespace+
         # and reading using +reader_proc+, writing using +writer_proc+,
@@ -198,6 +211,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+
@@ -243,8 +257,8 @@ module HDLRuby::High::Std
 
     ##
     # Describes port wrapper (Box) for fixing arugments.
-    class ChannelPortB
-        include ChannelPortWrapping
+    class ChannelPortB < ChannelPort
+        # include ChannelPortWrapping
 
         # Creates a new channel box over channel port +port+ fixing +args+
         # as arguments.
@@ -273,6 +287,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+
@@ -324,6 +340,12 @@ 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.
@@ -338,6 +360,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.
@@ -359,11 +385,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 = {}
 
@@ -419,6 +440,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
@@ -598,15 +624,30 @@ 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+.
-        def brancher(name,&ruby_block)
+        # Alternatively, a ready channel instance can be passed as argument
+        # as +channelI+.
+        def brancher(name,channelI = nil,&ruby_block)
             # Ensure name is a symbol.
             name = name.to_s unless name.respond_to?(:to_sym)
             name = name.to_sym
-            # Create the branch.
-            channelI = HDLRuby::High.channel_instance(name, &ruby_block)
+            # Is there a ready channel instance.
+            if channelI then
+                # Yes, use it directly.
+                @branches[name] = channelI
+                return self
+            end
+            # Now, create the branch.
+            channelI = HDLRuby::High::Std.channel_instance(name, &ruby_block)
             @branches[name] = channelI
+            return self
         end
 
 
@@ -619,60 +660,90 @@ module HDLRuby::High::Std
             name = name.to_s unless name.respond_to?(:to_sym)
             name = name.to_sym
             # Get the branch.
+            channelI = @branches[name]
             return @branches[name]
         end
 
 
         # 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
@@ -682,56 +753,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
@@ -741,73 +844,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
             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
-            end
-            @accesser_inouts.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
             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)
@@ -818,21 +876,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)
@@ -853,37 +941,121 @@ 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
+
+
         
         ## 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)
-            # 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)
+            # 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
-            HDLRuby::High.space_pop
+            # 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)
-            # 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)
+            # 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
-            HDLRuby::High.space_pop
+            # 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.
@@ -902,10 +1074,12 @@ module HDLRuby::High::Std
 
 
     # Wrapper to make an object run like a channel port.
-    class ChannelPortObject
+    class ChannelPortObject < ChannelPort
         # 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
@@ -946,9 +1120,13 @@ module HDLRuby::High::Std
 
 
     # Wrap object +obj+ to act like a channel port.
-    def channel_port(obj)
+    def self.channel_port(obj)
+        return obj if obj.is_a?(ChannelPort) # No need to wrap.
         return ChannelPortObject.new(obj)
     end
+    def channel_port(obj)
+        return HDLRuby::High::Std.channel_port(obj)
+    end
 end