HDLRuby 2.1.2 → 2.1.5

data/lib/HDLRuby/high_samples/with_top_unshift.rb

@@ -0,0 +1,29 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A example of behavior with some unshifted statements in the top block
+# of a behavior.
+system :with_top_unshift do
+    [15..0].input :x,:y, :clk
+    [16..0].inner :w0,:w1
+    [16..0].output :o
+
+    seq(clk.posedge) do
+        w0 <= x + y
+        par do
+            w1 <= w0 * x
+            top_block.unshift { o <= w1 + y }
+        end
+    end
+end
+
+# Instantiate it for checking.
+with_top_unshift :with_top_unshiftI
+
+# Generate the low level representation.
+low = with_top_unshiftI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/with_unshift.rb

@@ -0,0 +1,25 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A example of behavior with some unshifted statements in a block.
+system :with_unshift do
+    [15..0].input :x,:y, :clk
+    [16..0].inner :w
+    [16..0].output :o
+
+    seq(clk.posedge) do
+        w <= x + y
+        unshift { o <= w + y }
+    end
+end
+
+# Instantiate it for checking.
+with_unshift :with_unshiftI
+
+# Generate the low level representation.
+low = with_unshiftI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/hruby_high.rb

@@ -1187,6 +1187,11 @@ module HDLRuby::High
         end
 
 
+        # Gets the current system.
+        def cur_system
+            return HDLRuby::High.cur_system
+        end
+
         include Hmux
 
         # Fills a low level scope with self's contents.
@@ -2321,6 +2326,41 @@ module HDLRuby::High
             return Cast.new(type.to_type,self.to_expr)
         end
 
+        # Casts to a bit vector type.
+        def to_bit
+            return self.as(bit[self.width])
+        end
+
+        # Casts to an unsigned bit vector type.
+        def to_unsigned
+            return self.as(unsigned[self.width])
+        end
+
+        # Casts to a signed bit vector type.
+        def to_unsigned
+            return self.as(signed[self.width])
+        end
+
+        # Extends on the left to +n+ bits filling with +v+ bit values.
+        def ljust(n,v)
+            return [(v.to_s * (n-self.width)).to_expr, self]
+        end
+
+        # Extends on the right to +n+ bits filling with +v+ bit values.
+        def rjust(n,v)
+            return [self, (v.to_s * (n-self.width)).to_expr]
+        end
+
+        # Extends on the left to +n+ bits filling with 0.
+        def zext(n)
+            return self.ljust(n,0)
+        end
+
+        # Extends on the left to +n+ bits preserving the signe.
+        def sext(n)
+            return self.ljust(self[-1])
+        end
+
         # Gets the origin method for operation +op+.
         def self.orig_operator(op)
             return (op.to_s + "_orig").to_sym
@@ -2342,6 +2382,26 @@ module HDLRuby::High
             define_method(orig_operator(operator),&meth)
         end
 
+        # Left shift of +n+ bits.
+        def ls(n)
+            return self << n
+        end
+
+        # Right shift of +n+ bits.
+        def rs(n)
+            return self >> n
+        end
+
+        # Left rotate of +n+ bits.
+        def lr(n)
+            return [self[-(n+1)..0], self[-1..-(n)]]
+        end
+
+        # Right rotate of +n+ bits.
+        def rr(n)
+            return [self[(n-1)..0], self[-1..n]]
+        end
+
         # Coerce by forcing convertion of obj to expression.
         def coerce(obj)
             if obj.is_a?(HDLRuby::Low::Expression) then
@@ -2806,10 +2866,10 @@ module HDLRuby::High
             return High.cur_behavior
         end
 
-        # Gets the enclosing block if any.
-        def block
-            return High.cur_block
-        end
+        # # Gets the enclosing block if any.
+        # def block
+        #     return High.cur_block
+        # end
 
         # Converts the this reference to HDLRuby::Low.
         def to_low
@@ -3182,13 +3242,50 @@ module HDLRuby::High
             self.add_block(self.mode,name,&ruby_block)
         end
 
-        # Get the current mode of the block.
-        #
-        # NOTE: for name coherency purpose only. 
-        def block
-            return self.mode
+        # Adds statements at the top of the block.
+        def unshift(&ruby_block)
+            # Create a sub block for the statements.
+            block = High.make_block(self.mode,:"",&ruby_block)
+            # Unshifts it.
+            self.unshift_statement(block)
+            # Use its return value.
+            return block.return_value
         end
 
+        # # Get the current mode of the block.
+        # #
+        # # NOTE: for name coherency purpose only. 
+        # def block
+        #     return self.mode
+        # end
+        
+        # Gets the current block.
+        def cur_block
+            return HDLRuby::High.cur_block
+        end
+
+        # Gets the top block of the current behavior.
+        def top_block
+            return HDLRuby::High.top_block
+        end
+
+        # Gets the current behavior.
+        def cur_behavior
+            return HDLRuby::High.cur_behavior
+        end
+
+        # Gets the current scope.
+        def cur_scope
+            return HDLRuby::High.cur_scope
+        end
+
+        # Gets the current system.
+        def cur_system
+            return HDLRuby::High.cur_system
+        end
+
+
+
         # Need to be able to declare select operators
         include Hmux
 
@@ -3624,7 +3721,6 @@ module HDLRuby::High
         end
     end
 
-
     # Gets the enclosing block if any.
     #
     # NOTE: +level+ allows to get an upper block of the currently enclosing
@@ -3640,6 +3736,20 @@ module HDLRuby::High
         end
     end
 
+    # Gets the top enclosing block if any.
+    def self.top_block(level = 0)
+        blk = cur_block(level)
+        unless blk.is_a?(Block)
+            raise AnyError,
+                "Not within a block: #{blk.user.class}"
+        end
+        if Namespaces[-1-level-1].user.is_a?(Scope) then
+            return blk
+        else
+            return top_block(level+1)
+        end
+    end
+
     # Registers hardware referencing method +name+ to the current namespace.
     def self.space_reg(name,&ruby_block)
         # print "registering #{name} in #{Namespaces[-1]}\n"

data/lib/HDLRuby/hruby_low.rb

@@ -3495,6 +3495,24 @@ module HDLRuby::Low
             statement
         end
 
+        # Adds a +statement+ and the begining of the block
+        #
+        # NOTE: TimeWait is not supported unless for TimeBlock objects.
+        def unshift_statement(statement)
+            unless statement.is_a?(Statement) then
+                raise AnyError,
+                      "Invalid class for a statement: #{statement.class}"
+            end
+            if statement.is_a?(TimeWait) then
+                raise AnyError,
+                      "Timed statements are not supported in common blocks."
+            end
+            @statements.unshift(statement)
+            # And set its parent.
+            statement.parent = self
+            statement
+        end
+
         # Gets the number of statements.
         def num_statements
             return @statements.size
@@ -3620,6 +3638,20 @@ module HDLRuby::Low
             statement
         end
 
+        # Adds a +statement+ and the begining of the block
+        #
+        # NOTE: TimeWait is not supported unless for TimeBlock objects.
+        def unshift_statement(statement)
+            unless statement.is_a?(Statement) then
+                raise AnyError,
+                      "Invalid class for a statement: #{statement.class}"
+            end
+            @statements.unshift(statement)
+            # And set its parent.
+            statement.parent = self
+            statement
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(TimeBlock)

data/lib/HDLRuby/hruby_low2vhd.rb

@@ -1100,7 +1100,11 @@ module HDLRuby::Low
             # when Numeric
             #     return self.content.to_s
             when HDLRuby::BitString
-                sign = self.type.signed? ? self.content.to_s[-1] : "0"
+                # Compute the extension: in case of signed type, the extension
+                # is the last bit. Otherwise it is 0 unless the last bit
+                # is not defined (Z or X).
+                sign = self.type.signed? ? self.content.to_s[-1] : 
+                    /[01]/ =~ self.content[-1] ? "0" : self.content[-1]
                 return '"' + self.content.to_s.rjust(width,sign).upcase + '"'
             else
                 sign = self.type.signed? ? (self.content>=0 ? "0" : "1") : "0"

data/lib/HDLRuby/hruby_verilog.rb

@@ -1796,7 +1796,7 @@ class SystemT
                 ref = self.extract_port_assign!(systemI,inout)
                 if ref then
                     code << "." << name_to_verilog(inout.name) << "(" 
-                    code << ref.to_vhdl(level) 
+                    code << ref.to_verilog
                     code << "),"
                 end
             end

data/lib/HDLRuby/std/channel.rb

@@ -18,7 +18,8 @@ module HDLRuby::High::Std
             @name = name.to_sym
             # Sets the block for instantiating a channel.
             @ruby_block = ruby_block
-            # Sets the instantiation procedure.
+            # Sets the instantiation procedure if named.
+            return if @name.empty?
             obj = self
             HDLRuby::High.space_reg(@name) do |*args|
                 obj.instantiate(*args)
@@ -42,11 +43,12 @@ module HDLRuby::High::Std
                 end
             end
             # Generates the channels.
+            channelI = nil
             args.each do |nameI|
                 channelI = ChannelI.new(name,&@ruby_block)
                 HDLRuby::High.space_reg(nameI) { channelI }
-                channelI
             end
+            channelI
         end
 
         alias_method :call, :instantiate
@@ -55,11 +57,172 @@ module HDLRuby::High::Std
 
     ## Creates a new channel type named +name+ whose instances are
     #  creating executing +ruby_block+.
-    def channel(name,&ruby_block)
+    def self.channel(name,&ruby_block)
         return ChannelT.new(name,&ruby_block)
     end
 
+    ## Creates a new channel type named +name+ whose instances are
+    #  creating executing +ruby_block+.
+    def channel(name,&ruby_block)
+        HDLRuby::High::Std.channel(name,&ruby_block)
+    end
+
+    ## Creates directly an instance of channel named +name+ using
+    #  +ruby_block+ built with +args+.
+    def self.channel_instance(name,*args,&ruby_block)
+        return ChannelT.new(:"",&ruby_block).instantiate(name,*args)
+    end
+
+    ## Creates directly an instance of channel named +name+ using
+    #  +ruby_block+ built with +args+.
+    def channel_instance(name,*args,&ruby_block)
+        HDLRuby::High::Std.channel_instance(name,*args,&ruby_block)
+    end
+
+
+    ##
+    # Describes a read port to a channel.
+    class ChannelPortR
+
+        # Creates a new channel reader running in +namespace+ and
+        # reading using +reader_proc+ and reseting using +reseter_proc+.
+        def initialize(namespace,reader_proc,reseter_proc)
+            unless namespace.is_a?(Namespace)
+                raise "Invalid class for a namespace: #{namespace.class}"
+            end
+            @namespace = namespace
+            @reader_proc = reader_proc.to_proc
+            @rester_proc = reseter_proc.to_proc
+        end
+
+        ## 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
+            # Execute the code generating the accesser in context.
+            HDLRuby::High.space_push(@namespace)
+            HDLRuby::High.cur_block.open do
+                instance_exec(ruby_block,*args,&reader_proc)
+            end
+            HDLRuby::High.space_pop
+        end
+
+        ## Performs a reset on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        def reset(*args,&ruby_block)
+            # Gain access to the accesser as local variable.
+            reseter_proc = @reseter_proc
+            # Execute the code generating the accesser 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 a writer port to a channel.
+    class ChannelPortW
+
+        # Creates a new channel writer running in +namespace+ and
+        # writing using +writer_proc+ and reseting using +reseter_proc+.
+        def initialize(namespace,writer_proc,reseter_proc)
+            unless namespace.is_a?(Namespace)
+                raise "Invalid class for a namespace: #{namespace.class}"
+            end
+            @namespace = namespace
+            @writer_proc = writer_proc.to_proc
+            @reseter_proc = reseter_proc.to_proc
+        end
+
+        ## 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
+            # Execute the code generating the accesser in context.
+            HDLRuby::High.space_push(@namespace)
+            HDLRuby::High.cur_block.open do
+                instance_exec(ruby_block,*args,&writer_proc)
+            end
+            HDLRuby::High.space_pop
+        end
+
+        ## Performs a reset on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        def reset(*args,&ruby_block)
+            # Gain access to the accesser as local variable.
+            reseter_proc = @reseter_proc
+            # Execute the code generating the accesser 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 an access port to a channel.
+    class ChannelPortA
+
+        # Creates a new channel accesser running in +namespace+
+        # and reading using +reader_proc+, writing using +writer_proc+,
+        # and reseting using +reseter_proc+.
+        def initialize(namespace,reader_proc,writer_proc,reseter_proc)
+            unless namespace.is_a?(Namespace)
+                raise "Invalid class for a namespace: #{namespace.class}"
+            end
+            @namespace = namespace
+            @reader_proc  = reader_proc.to_proc
+            @writer_proc  = writer_proc.to_proc
+            @reseter_proc = reseter_proc.to_proc
+        end
+
+        ## Performs a read on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        def read(*args,&ruby_block)
+            # Gain access to the accesser as local variable.
+            reader_proc = @reader_proc
+            # Execute the code generating the accesser in context.
+            HDLRuby::High.space_push(@namespace)
+            HDLRuby::High.cur_block.open do
+                instance_exec(ruby_block,*args,&reader_proc)
+            end
+            HDLRuby::High.space_pop
+        end
+
+        ## Performs a write on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        def write(*args,&ruby_block)
+            # Gain access to the accesser as local variable.
+            writer_proc = @writer_proc
+            # Execute the code generating the accesser in context.
+            HDLRuby::High.space_push(@namespace)
+            HDLRuby::High.cur_block.open do
+                instance_exec(ruby_block,*args,&writer_proc)
+            end
+            HDLRuby::High.space_pop
+        end
+
+        ## Performs a reset on the channel using +args+ and +ruby_block+
+        #  as arguments.
+        def reset(*args,&ruby_block)
+            # Gain access to the accesser as local variable.
+            reseter_proc = @reseter_proc
+            # Execute the code generating the accesser 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
 
 
     ## 
@@ -75,16 +238,19 @@ module HDLRuby::High::Std
         attr_reader :scope
 
         # The namespace associated with the current execution when
-        # building a channel, its reader or its writer.
+        # building a channel.
         attr_reader :namespace
 
         ## Creates a new channel instance with +name+ built from +ruby_block+.
         def initialize(name,&ruby_block)
-            # Check and set the name
+            # Check and set the name of the channel.
             @name = name.to_sym
+            # Generate a name for the scope containing the signals of
+            # the channel.
+            @scope_name = HDLRuby.uniq_name
 
-            # Sets the scope.
-            @scope = HDLRuby::High.cur_scope
+            # # Sets the scope.
+            # @scope = HDLRuby::High.cur_scope
 
             # Keep access to self.
             obj = self
@@ -103,58 +269,93 @@ module HDLRuby::High::Std
             # The writer inout ports by name.
             @writer_inouts = {}
 
+            # The accesser input ports by name.
+            @accesser_inputs = {}
+            # The accesser output ports by name.
+            @accesser_outputs = {}
+            # 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 = {}
+
             # Create the namespaces for building the channel, its readers
-            # and its writers.
+            # its writers and its accessers.
 
             # Creates the namespace of the channel.
-            @channel_namespace = Namespace.new(self)
+            @namespace = Namespace.new(self)
             # Make it give access to the internal of the class.
-            @channel_namespace.add_method(:reader_input, &method(:reader_input))
-            @channel_namespace.add_method(:reader_output,&method(:reader_output))
-            @channel_namespace.add_method(:reader_inout, &method(:reader_inout))
-            @channel_namespace.add_method(:writer_input, &method(:writer_input))
-            @channel_namespace.add_method(:writer_output,&method(:writer_output))
-            @channel_namespace.add_method(:writer_inout, &method(:writer_inout))
-            @channel_namespace.add_method(:reader,       &method(:reader))
-            @channel_namespace.add_method(:writer,       &method(:writer))
+            @namespace.add_method(:reader_input,   &method(:reader_input))
+            @namespace.add_method(:reader_output,  &method(:reader_output))
+            @namespace.add_method(:reader_inout,   &method(:reader_inout))
+            @namespace.add_method(:writer_input,   &method(:writer_input))
+            @namespace.add_method(:writer_output,  &method(:writer_output))
+            @namespace.add_method(:writer_inout,   &method(:writer_inout))
+            @namespace.add_method(:accesser_input, &method(:accesser_input))
+            @namespace.add_method(:accesser_output,&method(:accesser_output))
+            @namespace.add_method(:accesser_inout, &method(:accesser_inout))
+            @namespace.add_method(:reader,         &method(:reader))
+            @namespace.add_method(:writer,         &method(:writer))
+            @namespace.add_method(:brancher,         &method(:brancher))
 
             # Creates the namespace of the reader.
             @reader_namespace = Namespace.new(self)
             # Creates the namespace of the writer.
             @writer_namespace = Namespace.new(self)
+            # Creates the namespace of the accesser.
+            @accesser_namespace = Namespace.new(self)
 
-            # By default the namespace is the one of the namespace
-            @namespace = @channel_namespace
-
-            # Builds the channel.
+            # Builds the channel within a new scope.
             HDLRuby::High.space_push(@namespace)
             # puts "top_user=#{HDLRuby::High.top_user}"
-            HDLRuby::High.top_user.instance_eval(&ruby_block)
+            scope_name = @scope_name
+            scope = nil
+            HDLRuby::High.top_user.instance_eval do 
+                sub(scope_name) do
+                    # Generate the channel code.
+                    ruby_block.call
+                end
+            end
             HDLRuby::High.space_pop
 
+            # Keep access to the scope containing the code of the channel.
+            @scope = @namespace.send(scope_name)
+            # puts "@scope=#{@scope}"
+            # Adds the name space of the scope to the namespace of the
+            # channel
+            @namespace.concat_namespace(@scope.namespace)
+
             # Gives access to the channel by registering its name.
             obj = self
-            HDLRuby::High.space_reg(@name) { self }
+            # HDLRuby::High.space_reg(@name) { self }
+            HDLRuby::High.space_reg(@name) { obj }
         end
 
         # The methods for defining the channel
         
         # For the channel itself
         
-        ## Defines new command +name+ to execute +ruby_block+ for the
-        #  channel.
-        def command(name,&ruby_block)
-            # Ensures name is a symbol.
-            name = name.to_sym
-            # Sets the new command.
-            self.define_singleton_method(name) do
-                # Executes the command in the right environment.
-                HDLRuby::High.space_push(@namespace)
-                res = HDLRuby::High.top_user.instance_exec(&ruby_block)
-                HDLRuby::High.space_pop
-                res
-            end
-        end
+        # ## Defines new command +name+ to execute +ruby_block+ for the
+        # #  channel.
+        # def command(name,&ruby_block)
+        #     # Ensures name is a symbol.
+        #     name = name.to_sym
+        #     res = nil
+        #     # Sets the new command.
+        #     self.define_singleton_method(name) do |*args|
+        #         HDLRuby::High.space_push(@namespace)
+        #         HDLRuby::High.cur_block.open do
+        #             res = instance_exec(*args,&ruby_block)
+        #         end
+        #         HDLRuby::High.space_pop
+        #         res
+        #     end
+        # end
         
         # For the reader and the writer
 
@@ -230,18 +431,74 @@ module HDLRuby::High::Std
             end
         end
 
+        ## Sets the signals accessible through +key+ to be accesser input port.
+        def accesser_input(*keys)
+            # Registers each signal as accesser port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @accesser_inputs[name] = send(key)
+            end
+        end
+
+        ## Sets the signals accessible through +key+ to be accesser output port.
+        def accesser_output(*keys)
+            # Registers each signal as accesser port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @accesser_outputs[name] = send(key)
+            end
+        end
+
+        ## Sets the signals accessible through +key+ to be accesser inout port.
+        def accesser_inout(*keys)
+            # Registers each signal as accesser port
+            keys.each do |key|
+                # Ensure the key is a symbol.
+                key = key.to_sym
+                # Register it with the corresponding signal.
+                name = HDLRuby.uniq_name # The name of the signal is uniq.
+                @accesser_inouts[name] = send(key)
+            end
+        end
+
+
         ## Sets the read procedure to be +ruby_block+.
         def reader(&ruby_block)
             @reader_proc = ruby_block
         end
 
-        ## Sets the writter procedure to be +ruby_block+.
+        ## Sets the writer procedure to be +ruby_block+.
         def writer(&ruby_block)
             @writer_proc = ruby_block
         end
 
-        # The methods for accessing the channel
+        # ## Sets the accesser procedure to be +ruby_block+.
+        # def accesser(&ruby_block)
+        #     @accesser_proc = ruby_block
+        # end
+
+        ## Sets the input port reset to be +ruby_block+.
+        def input_reseter(&ruby_block)
+            @input_reseter_proc = ruby_block
+        end
+
+        ## Sets the output port reset to be +ruby_block+.
+        def output_reseter(&ruby_block)
+            @output_reseter_proc = ruby_block
+        end
+
+        ## Sets the inout port reset to be +ruby_block+.
+        def inout_reseter(&ruby_block)
+            @inout_reseter_proc = ruby_block
+        end
         
+        # The methods for accessing the channel
         # Channel side.
 
         ## Gets the list of the signals of the channel to be connected
@@ -258,22 +515,32 @@ module HDLRuby::High::Std
                    @writer_inouts.values
         end
 
-        # Reader an writer side.
-
-        # ## Declares the ports for the reader.
-        # def reader_ports
-        #     loc_inputs  = @reader_inputs
-        #     loc_outputs = @reader_outputs
-        #     loc_inouts  = @reader_inouts
-        #     HDLRuby::High.cur_system.open do
-        #         # The inputs
-        #         loc_inputs.each  { |name,sig| sig.type.input  name }
-        #         # The outputs
-        #         loc_outputs.each { |name,sig| sig.type.output name }
-        #         # The inouts
-        #         loc_inouts.each  { |name,sig| sig.type.inout  name }
-        #     end
-        # end
+        # Defines a branch in the channel named +name+ built executing
+        # +ruby_block+.
+        def brancher(name,*args,&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,*args,&ruby_block)
+            @branches[name] = channelI
+        end
+
+
+        # Methods used on the channel outside its definition.
+        
+        # Gets branch channel +name+.
+        # NOTE: +name+ can be of any type on purpose.
+        def branch(name)
+            # Ensure name is a symbol.
+            name = name.to_s unless name.respond_to?(:to_sym)
+            name = name.to_sym
+            # Get the branch.
+            return @branches[name]
+        end
+
+
+        # Reader, writer and accesser side.
 
         ## Declares the ports for the reader and assigned them to +name+.
         def input(name)
@@ -289,6 +556,7 @@ module HDLRuby::High::Std
             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
@@ -309,28 +577,32 @@ module HDLRuby::High::Std
                     end
                 end
             end
+
+            # Fill the reader namespace with the access to the reader signals.
+            @reader_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|
+                @reader_namespace.add_method(sig.name) do
+                    HDLRuby::High.top_user.send(name)
+                end
+            end
+            @reader_inouts.each do |name,sig|
+                @reader_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.
-            this = self
-            HDLRuby::High.space_reg(name) { this }
-        end
-
-        # ## Declares the ports for the writer.
-        # def writer_ports
-        #     loc_inputs  = @writer_inputs
-        #     loc_outputs = @writer_outputs
-        #     loc_inouts  = @writer_inouts
-        #     HDLRuby::High.cur_system.open do
-        #         # The inputs
-        #         loc_inputs.each  { |name,sig| sig.type.input  name }
-        #         # The outputs
-        #         loc_outputs.each { |name,sig| sig.type.output name }
-        #         # The inouts
-        #         loc_inouts.each  { |name,sig| sig.type.inout  name }
-        #     end
-        # end
+            chp = ChannelPortR.new(@reader_namespace,@reader_proc,@input_reseter_proc)
+            HDLRuby::High.space_reg(name) { chp }
+            return chp
+        end
 
-        ## Declares the ports for the reader and assigned them to +name+.
+        ## Declares the ports for the writer and assigned them to +name+.
         def output(name)
             # Ensure name is a symbol.
             name = name.to_sym
@@ -364,77 +636,182 @@ module HDLRuby::High::Std
                     end
                 end
             end
+
+            # Fill the writer namespace with the access to the writer signals.
+            @writer_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|
+                @writer_namespace.add_method(sig.name) do
+                    HDLRuby::High.top_user.send(name)
+                end
+            end
+            @writer_inouts.each do |name,sig|
+                @writer_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.
-            this = self
-            HDLRuby::High.space_reg(name) { this }
+            chp = ChannelPortW.new(@writer_namespace,@writer_proc,@output_reseter_proc)
+            HDLRuby::High.space_reg(name) { chp }
+            return chp
         end
 
-        
-        ## Performs a read on the channel using +args+ and +ruby_block+
-        #  as arguments.
-        def read(*args,&ruby_block)
-            # Fill the reader namespace with the access to the reader signals.
-            @reader_inputs.each do |name,sig|
-                @reader_namespace.add_method(sig.name) do
+        ## Declares the ports for the accesser and assigned them to +name+.
+        def inout(name)
+            # Ensure name is a symbol.
+            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
+            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
-            @reader_outputs.each do |name,sig|
-                @reader_namespace.add_method(sig.name) do
+            @accesser_outputs.each do |name,sig|
+                @accesser_namespace.add_method(sig.name) do
                     HDLRuby::High.top_user.send(name)
                 end
             end
-            @reader_inouts.each do |name,sig|
-                @reader_namespace.add_method(sig.name) do
+            @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)
+            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|
+                port.to_ref <= sig
+            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
+            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.
+        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.
-            @namespace = @reader_namespace
+            # # 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)
             end
             HDLRuby::High.space_pop
-            # Restores the default context.
-            @namespace = @channel_namespace
         end
         
         ## Performs a write on the channel using +args+ and +ruby_block+
         #  as arguments.
         def write(*args,&ruby_block)
-            # Fill the writer namespace with the access to the writer signals.
-            @writer_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|
-                @writer_namespace.add_method(sig.name) do
-                    HDLRuby::High.top_user.send(name)
-                end
-            end
-            @writer_inouts.each do |name,sig|
-                @writer_namespace.add_method(sig.name) do
-                    HDLRuby::High.top_user.send(name)
-                end
-            end
             # Gain access to the writer as local variable.
             writer_proc = @writer_proc
-            # The context is the one of the writer.
-            @namespace = @writer_namespace
+            # # 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)
             end
             HDLRuby::High.space_pop
-            # Restores the default context.
-            @namespace = @channel_namespace
+        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