HDLRuby 2.3.4 → 2.4.1

data/lib/HDLRuby/sim/hruby_sim_vizualize.c

@@ -7,26 +7,51 @@
  *  generated by hruby_low2c. 
  **/
 
+/* The print function pointers. */
+
+PrinterS printer;
+
+
+/** Initializes the visualization printer engine.
+ *  @param print_time the time printer
+ *  @param print_name the name printer
+ *  @param print_value the value printer
+ *  @param print_signal the signal state printer. */
+void init_visualizer(void (*print_time)(unsigned long long), 
+                     void (*print_name)(Object),
+                     void (*print_value)(Value),
+                     void (*print_signal)(SignalI)) {
+    printer.print_time = print_time; 
+    printer.print_name = print_name; 
+    printer.print_value = print_value; 
+    printer.print_signal = print_signal; 
+}
+
+                    
+
+
+/* The default printing functions. */
+
 /** Prints the time.
  *  @param time the time to show. */
-void print_time(unsigned long long time) {
+static void default_print_time(unsigned long long time) {
     printf("# %llups",time);
 }
 
 /** Prints the time and goes to the next line.
- *  @param time the time to show. */
-void println_time(unsigned long long time) {
-    print_time(time);
+ *  @par1am time the time to show. */
+static void default_println_time(unsigned long long time) {
+    default_print_time(time);
     printf("\n");
 }
 
 /** Prints the name of an object.
  *  @param object the object to print the name. */
-void print_name(Object object) {
+static void default_print_name(Object object) {
     /* Recurse on the owner if any. */
     // printf("owner=%p\n",object->owner);
     if (object->owner != NULL) {
-        print_name(object->owner);
+        default_print_name(object->owner);
         printf("::");
     }
     /* Depending on the kind of object. */
@@ -48,7 +73,7 @@ void print_name(Object object) {
 
 /** Prints a value.
  *  @param value the value to print */
-void print_value(Value value) {
+static void default_print_value(Value value) {
     if (value->numeric) {
         unsigned long long width = type_width(value->type);
         unsigned long long mask = 1ULL << (width-1);
@@ -77,15 +102,29 @@ void print_value(Value value) {
 
 /** Prints a signal.
  *  @param signal the signal to show */
-void print_signal(SignalI signal) {
-    print_name((Object)signal);
+static void default_print_signal(SignalI signal) {
+    default_print_name((Object)signal);
     printf(": ");
-    print_value(signal->f_value);
+    default_print_value(signal->f_value);
 }
 
 /** Prints a signal and goes to the next line.
  *  @param signal the signal to show */
-void println_signal(SignalI signal) {
-    print_signal(signal);
+static void default_println_signal(SignalI signal) {
+    default_print_signal(signal);
     printf("\n");
 }
+
+
+
+/* Set up the visualizer. */
+
+/** Set up the default vizualization engine.
+ *  @param name the name of the vizualization. */
+void init_default_visualizer(char* name) {
+    /* Initialize the vizualizer printer engine. */
+    init_visualizer(&default_println_time,
+                    &default_print_name,
+                    &default_print_value,
+                    &default_println_signal);
+}

data/lib/HDLRuby/std/channel.rb

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