HDLRuby 2.7.5 → 2.9.0

data/lib/HDLRuby/hruby_low2c.rb

@@ -135,6 +135,8 @@ module HDLRuby::Low
             objs.each { |obj| res << "   " << Low2C.make_name(obj) << "();\n" }
             # Sets the top systemT.
             res << "   top_system = " << Low2C.obj_name(top) << ";\n"
+            # Enable it.
+            res << "   set_enable_system(top_system,1);\n"
             # Starts the simulation.
             res<< "   hruby_sim_core(\"#{name}\",#{init_visualizer},-1);\n"
             # Close the main.
@@ -170,6 +172,7 @@ module HDLRuby::Low
         # is the list of extra h files to include.
         # def to_c(level = 0, *hnames)
         def to_c(res, level = 0, *hnames)
+            # puts "SystemT.to_c with name=#{Low2C.obj_name(self)}#{@wrapper ? " and wrapper=#{Low2C.obj_name(@wrapper)}" : ""}"
             # The header
             # res = Low2C.includes(*hnames)
             res << Low2C.includes(*hnames)
@@ -179,7 +182,16 @@ module HDLRuby::Low
 
             # Generate the signals of the system.
             # self.each_signal { |signal| signal.to_c(level) }
-            self.each_signal { |signal| signal.to_c(res,level) }
+            if ((defined? @wrapper) && @wrapper) then
+                # It is a reconfiguring system, alias the signals.
+                wrap_signals = @wrapper.each_signal.to_a
+                self.each_signal.with_index do |signal,i|
+                    signal.to_c_alias(res,wrap_signals[i],level)
+                end
+            else
+                # It is a single system, default generation.
+                self.each_signal { |signal| signal.to_c(res,level) }
+            end
 
             # Generate the code for all the blocks included in the system.
             self.scope.each_scope_deep do |scope|
@@ -356,8 +368,13 @@ module HDLRuby::Low
             end
             self.scope.each_block_deep do |block|
                 block.each_inner do |signal|
-                    # res << signal.value.to_ch if signal.value
-                    signal.value.to_ch(res) if signal.value
+                    # signal.value.to_ch(res) if signal.value
+                    if signal.value then
+                        signal.value.each_node_deep do |node|
+                            # res << node.to_ch if node.is_a?(Value)
+                            node.to_ch(res) if node.is_a?(Value)
+                        end
+                    end
                 end
                 block.each_node_deep do |node|
                     # res << node.to_ch if node.is_a?(Value)
@@ -681,6 +698,10 @@ module HDLRuby::Low
                 res << "behavior->owner = NULL;\n"
             end
 
+            # Set the behavior as not enabled. */
+            res << " " * (level+1)*3
+            res << "behavior->enabled = 0;\n"
+
             # Set the behavior as inactive. */
             res << " " * (level+1)*3
             res << "behavior->activated = 0;\n"
@@ -702,6 +723,10 @@ module HDLRuby::Low
                 end.to_a
                 # Keep only one ref per signal.
                 refs.uniq! { |node| node.full_name }
+                # Remove the inner signals from the list.
+                self.block.each_inner do |inner|
+                    refs.delete_if {|r| r.name == inner.name }
+                end
                 # Generate the event.
                 events = refs.map {|ref| Event.new(:anyedge,ref.clone) }
                 # Add them to the behavior for further processing.
@@ -833,11 +858,8 @@ module HDLRuby::Low
         #  +level+ is the hierachical level of the object.
         # def to_c(level = 0)
         def to_c(res,level = 0)
-            # The resulting string.
-            # res = ""
-
+            # puts "Signal.to_c with name: #{Low2C.obj_name(self)}"
             # Declare the global variable holding the signal.
-            # res << "SignalI #{self.to_c_signal(level+1)};\n\n"
             res << "SignalI "
             self.to_c_signal(res,level+1)
             res << ";\n\n"
@@ -845,6 +867,7 @@ module HDLRuby::Low
             # The header of the signal generation.
             res << " " * level*3
             res << "SignalI " << Low2C.make_name(self) << "() {\n"
+
             # res << " " * level*3
             # res << "Value l,r,d;\n"
             # res << " " * (level+1)*3
@@ -857,7 +880,6 @@ module HDLRuby::Low
             # Sets the global variable of the signal.
             res << "\n"
             res << " " * (level+1)*3
-            # res << "#{self.to_c_signal(level+1)} = signalI;\n"
             self.to_c_signal(res,level+1)
             res << " = signalI;\n"
 
@@ -891,11 +913,12 @@ module HDLRuby::Low
             if self.value then
                 # There is an initial value.
                 res << " " * (level+1)*3
-                # res << "copy_value(#{self.value.to_c(level+2)}," +
-                #        "signalI->c_value);\n"
+                # res << "copy_value("
+                # self.value.to_c_expr(res,level+2)
+                # res << ",signalI->c_value);\n"
                 res << "copy_value("
                 self.value.to_c_expr(res,level+2)
-                res << ",signalI->c_value);\n"
+                res << ",signalI->f_value);\n"
             end
 
             # Initially the signal can be overwritten by anything.
@@ -948,6 +971,43 @@ module HDLRuby::Low
 
             return res;
         end
+
+        ## Generates the C text of the equivalent HDLRuby code in case
+        #  the signals is actually an alias to another signal.
+        #  +other+ is the target signal of the alias.
+        #  +level+ is the hierachical level of the object.
+        def to_c_alias(res,target,level = 0)
+            # puts "Signal.to_c_alias with name: #{Low2C.obj_name(self)}"
+            # The resulting string.
+            # res = ""
+
+            # Declare the global variable holding the signal.
+            res << "SignalI "
+            self.to_c_signal(res,level+1)
+            res << ";\n\n"
+
+            # The header of the signal generation.
+            res << " " * level*3
+            res << "SignalI " << Low2C.make_name(self) << "() {\n"
+
+            res << "SignalI signalI = #{Low2C.obj_name(target)};\n"
+
+            # Sets the global variable of the signal.
+            res << "\n"
+            res << " " * (level+1)*3
+            self.to_c_signal(res,level+1)
+            res << " = signalI;\n"
+
+            # Generate the return of the signal.
+            res << "\n"
+            res << " " * (level+1)*3
+            res << "return signalI;\n"
+
+            # Close the signal.
+            res << " " * level*3
+            res << "};\n\n"
+            return res
+        end
     end
 
 
@@ -989,9 +1049,22 @@ module HDLRuby::Low
             # Set the name
             res << " " * (level+1)*3
             res << "systemI->name = \"#{self.name}\";\n"
-            # Set the type.
+            # # Set the type.
+            # res << " " * (level+1)*3
+            # res << "systemI->system = " << Low2C.obj_name(self.systemT) << ";\n"
+            # Set the systems.
+            num_sys = self.each_systemT.to_a.size
             res << " " * (level+1)*3
-            res << "systemI->system = " << Low2C.obj_name(self.systemT) << ";\n"
+            res << "systemI->num_systems = #{num_sys};\n"
+            res << " " * (level+1)*3
+            res << "systemI->systems = calloc(sizeof(SystemT), #{num_sys});\n"
+            self.each_systemT.with_index do |sysT,i|
+                res << " " * (level+1)*3
+                res << "systemI->systems[#{i}] = #{Low2C.obj_name(sysT)};\n"
+            end
+
+            # Configure the instance to current systemT.
+            res << (" " * (level*3)) << "configure(systemI,0);\n"
 
             # Generate the return of the signal.
             res << "\n"
@@ -1090,6 +1163,10 @@ module HDLRuby::Low
                 res << "code->owner = NULL;\n"
             end
 
+            # Set the code as enabled (for now, may change in a near future). */
+            res << " " * (level+1)*3
+            res << "code->enabled = 1;\n"
+
             # Set the code as inactive. */
             res << " " * (level+1)*3
             res << "code->activated = 0;\n"
@@ -1382,6 +1459,28 @@ module HDLRuby::Low
         end
     end
 
+    ## Extends the TimeTerminate class with generation of C text.
+    class TimeTerminate
+
+        # Generates the C text of the equivalent HDLRuby code.
+        # +level+ is the hierachical level of the object.
+        def to_c(res,level = 0)
+            # Save the value pool state.
+            res << (" " * (level*3)) << "terminate();\n"
+        end
+    end
+
+    ## Extends the Configure class with generation of C text.
+    class Configure
+
+        # Generates the C text of the equivalent HDLRuby code.
+        # +level+ is the hierachical level of the object.
+        def to_c(res,level = 0)
+            # Save the value pool state.
+            res << (" " * (level*3)) << "configure(#{Low2C.obj_name(self.ref.resolve)},#{self.index});\n"
+        end
+    end
+
     
     ## Extends the If class with generation of C text.
     class If
@@ -1893,6 +1992,16 @@ module HDLRuby::Low
             # Should never be here.
             raise AnyError, "Internal error: to_c should be implemented in class :#{self.class}"
         end
+
+        ## Generates the C text for an expression access to the expression,
+        #  default case.
+        #  +level+ is the hierachical level of the object.
+        def to_c_expr(res,level = 0)
+            res << "({"
+            self.to_c(res,level+1)
+            res << (" " * ((level+1)*3))
+            res << "pop();})"
+        end
     end
 
 
@@ -2455,46 +2564,64 @@ module HDLRuby::Low
             return res
         end
 
-        # Generates the C text of expression for the equivalent HDLRuby code.
-        # +level+ is the hierachical level of the object.
-        def to_c_expr(res,level = 0)
-            # Gather the content to concat.
-            expressions = self.each_expression.to_a
-            # Create the resulting string.
-            res << "({\n"
-            # Overrides the upper src0, src1, ..., and dst...
-            # And allocates a new value for dst.
-            res << (" " * ((level+1)*3))
-            res << "Value "
-            res << expressions.size.times.map do |i| 
-                "src#{i}"
-            end.join(",")
-            res << ";\n"
-            res << (" " * ((level+1)*3))
-            res << "Value dst = get_value();\n"
-            # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
-            # Compute each sub expression.
-            expressions.each_with_index do |expr,i|
-                res << (" " * ((level+1)*3))
-                res << "src#{i} = "
-                expr.to_c_expr(res,level+2)
-                res << ";\n"
-            end
-            # Compute the direction.
-            # Compute the resulting concatenation.
-            res << (" " * ((level+1)*3))
-            res << "concat_value(#{expressions.size},"
-            res << "#{self.type.direction == :little ? 1 : 0},dst,"
-            res << expressions.size.times.map { |i| "src#{i}" }.join(",")
-            res << ");\n"
-            # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
-            # Close the computation.
-            res << (" " * (level*3))
-            res << "dst; })"
-            return res
-        end
+        # # # Generates the C text of expression for the equivalent HDLRuby code.
+        # # # +level+ is the hierachical level of the object.
+        # # def to_c_expr(res,level = 0)
+        # #     # Gather the content to concat.
+        # #     expressions = self.each_expression.to_a
+        # #     # Create the resulting string.
+        # #     res << "({\n"
+        # #     # Overrides the upper src0, src1, ..., and dst...
+        # #     # And allocates a new value for dst.
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "Value "
+        # #     res << expressions.size.times.map do |i| 
+        # #         "src#{i}"
+        # #     end.join(",")
+        # #     res << ";\n"
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "Value dst = get_value();\n"
+        # #     # Save the value pool state.
+        # #     res << (" " * (level*3)) << "SV;\n"
+        # #     # Compute each sub expression.
+        # #     expressions.each_with_index do |expr,i|
+        # #         res << (" " * ((level+1)*3))
+        # #         res << "src#{i} = "
+        # #         expr.to_c_expr(res,level+2)
+        # #         res << ";\n"
+        # #     end
+        # #     # Compute the direction.
+        # #     # Compute the resulting concatenation.
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "concat_value(#{expressions.size},"
+        # #     res << "#{self.type.direction == :little ? 1 : 0},dst,"
+        # #     res << expressions.size.times.map { |i| "src#{i}" }.join(",")
+        # #     res << ");\n"
+        # #     # Save the value pool state.
+        # #     res << (" " * (level*3)) << "SV;\n"
+        # #     # Close the computation.
+        # #     res << (" " * (level*3))
+        # #     res << "dst; })"
+        # #     return res
+        # # end
+        # def to_c_expr(res,level = 0)
+        #     # Save the value pool state.
+        #     res << "({ PV;"
+        #     # Gather the content to concat.
+        #     expressions = self.each_expression.to_a
+        #     # Compute each sub expression.
+        #     expressions.each_with_index do |expr,i|
+        #         expr.to_c(res,level+2)
+        #     end
+        #     # Compute the resulting concatenation.
+        #     res << (" " * ((level+1)*3))
+        #     res << "sconcat(#{expressions.size},"
+        #     res << (self.type.direction == :little ? "1" : "0")
+        #     res << ");\n"
+        #     # Restore the value pool state.
+        #     res << "RV; pop();})"
+        #     return res
+        # end
     end
 
 
@@ -2778,17 +2905,11 @@ module HDLRuby::Low
         # +left+ tells if it is a left value or not.
         # def to_c(level = 0, left = false)
         def to_c(res,level = 0, left = false)
-            # # puts "RefName to_c for #{self.name}"
-            # self.resolve.to_c_signal(res,level+1)
-            # res << "->" << (left ? "f_value" : "c_value")
-            # return res
             # puts "RefName to_c for #{self.name}"
             res << (" " * (level*3))
-            # res << "d="
             res << "push("
             self.resolve.to_c_signal(res,level+1)
             res << "->" << (left ? "f_value" : "c_value")
-            # res << ";\n"
             res << ");\n"
             return res
         end

data/lib/HDLRuby/hruby_low2vhd.rb

@@ -925,6 +925,18 @@ module HDLRuby::Low
             end.join(" & ") + ";\n"
         end
     end
+
+    ## Extends the TimeTerminate class with generation of HDLRuby::High text.
+    class TimeTerminate
+
+        # Generates the text of the equivalent HDLRuby::High code.
+        # +vars+ is the list of the variables and
+        # +level+ is the hierachical level of the object.
+        def to_vhdl(vars,level = 0)
+            # Generate a report statement.
+            return " " * (level*3) + "finish;\n"
+        end
+    end
     
     ## Extends the If class with generation of HDLRuby::High text.
     class If

data/lib/HDLRuby/hruby_low_bool2select.rb

@@ -75,6 +75,18 @@ module HDLRuby::Low
         end
     end
 
+
+    ## Extends the TimeTerminate class with functionality for converting booleans
+    #  in assignments to select operators.
+    class TimeTerminate
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # Nothing to do.
+            return self
+        end
+    end
+
     
     ## Extends the If class with functionality for converting booleans
     #  in assignments to select operators.

data/lib/HDLRuby/hruby_low_fix_types.rb

@@ -71,7 +71,7 @@ module HDLRuby::Low
     class Statement
         # Explicit the types conversions in the statement.
         def explicit_types!
-            raise "Should implement explicit_types for class #{self.class}."
+            raise "Should implement explicit_types! for class #{self.class}."
         end
     end
 
@@ -98,7 +98,26 @@ module HDLRuby::Low
             self.map_args!(&:explicit_types)
             return self
         end
+    end
+
+
+    ## Extends the Configure class with fixing of types and constants.
+    class Configure
+        # Explicit the types conversions in the statement.
+        def explicit_types!
+            # Nothing to do.
+            return self
+        end
+    end
 
+
+    ## Extends the TimeTerminate class with fixing of types and constants.
+    class TimeTerminate
+        # Explicit the types conversions in the statement.
+        def explicit_types!
+            # Nothing to do.
+            return self
+        end
     end
 
 

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -50,9 +50,25 @@ module HDLRuby::Low
             return found if found
             # Maybe it is a sub scope.
             return self.each_scope.find { |scope| scope.name == name }
+            # Maybe it in the behavior.
+            return self.behavior.get_by_name
         end
     end
 
+    ##
+    #  Extends Behavior with the capability of finding one of its inner object
+    #  by name.
+    class Behavior
+        
+        ## Find an inner object by +name+.
+        #  NOTE: return nil if not found.
+        def get_by_name(name)
+            if (self.block.name == name.to_sym) then
+                return self.block
+            end
+            return self.block.get_by_name(name)
+        end
+    end
 
     ##
     #  Extends SystemI with the capability of finding one of its inner object
@@ -79,7 +95,16 @@ module HDLRuby::Low
             # Ensure the name is a symbol.
             name = name.to_sym
             # Look in the signals.
-            return self.get_inner(name)
+            found = self.get_inner(name)
+            return found if found
+            # Check the sub blocks names.
+            self.each_block do |block|
+                # puts "block=#{block.name}"
+                if (block.name == name) then
+                    return block
+                end
+            end
+            return nil
         end
     end
 
@@ -199,6 +224,7 @@ module HDLRuby::Low
             if self.ref.is_a?(RefName) then
                 # puts "ref name=#{self.ref.name}"
                 obj = self.ref.resolve
+                # puts "obj=#{obj}"
                 # Look into the object for the name.
                 return obj.get_by_name(self.name)
             else
@@ -208,12 +234,15 @@ module HDLRuby::Low
                 while parent
                     # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
+                        # puts "get_by_name"
                         found = parent.get_by_name(self.name)
+                        # puts "found" if found
                         return found if found
                     end
                     parent = parent.parent
                 end
                 # Not found.
+                puts "Not found!"
                 return nil
             end
         end

data/lib/HDLRuby/hruby_low_without_select.rb

@@ -163,7 +163,7 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the String class with functionality for converting select
+    ## Extends the Print class with functionality for converting select
     #  expressions to case statements.
     class Print
         # Extract the Select expressions.
@@ -175,6 +175,16 @@ module HDLRuby::Low
             return selects
         end
     end
+
+    ## Extends the TimeTerminate class with functionality for converting select
+    #  expressions to case statements.
+    class TimeTerminate
+        # Extract the Select expressions.
+        def extract_selects!
+            # Nothing to extract.
+            return []
+        end
+    end
     
     ## Extends the If class with functionality for converting select
     #  expressions to case statements.

data/lib/HDLRuby/hruby_tools.rb

@@ -1,5 +1,6 @@
 require 'set'
 
+
 module HDLRuby
 
 ##

data/lib/HDLRuby/hruby_verilog.rb

@@ -171,7 +171,7 @@ module HDLRuby::Low
 
     # Enhance Print with generation of verilog code.
     class Print
-        # Converts the system to Verilog code.
+        # Converts the print to Verilog code.
         def to_verilog(spc = 3)
             code = "#{" " * spc}$write(#{self.each_arg.map do |arg|
             arg.to_verilog
@@ -180,6 +180,14 @@ module HDLRuby::Low
         end
     end
 
+    # Enhance TimeTerminate with generation of verilog code.
+    class TimeTerminate
+        # Converts the terminate to Verilog code.
+        def to_verilog(spc = 3)
+            return "#{" " * spc}$finish;"
+        end
+    end
+
     # To scheduling to the Block.
     # Enhance Block with generation of verilog code.
     class Block

data/lib/HDLRuby/sim/hruby_sim.h

@@ -467,7 +467,10 @@ typedef struct SystemIS_ {
     Object owner;       /* The owner if any. */
 
     char* name;         /* The name of the signal. */
-    SystemT system;     /* The instantiated system. */
+    SystemT system;     /* The currently instantiated system. */
+
+    int num_systems;    /* The number of systems possibly instantiated here. */
+    SystemT* systems;   /* The systems possibly instantiated here. */
 } SystemIS;
 
 
@@ -499,6 +502,8 @@ typedef struct BehaviorS_ {
     Event* events;      /* The events of the behavior. */
     Block block;        /* The block of the behavior. */
 
+    int enabled;        /* Tells if the behavior is enabled or not. */
+
     int activated;      /* Tells if the behavior is activated or not. */
 
     int timed;          /* Tell if the behavior is timed or not:
@@ -519,6 +524,8 @@ typedef struct CodeS_ {
     Event* events;      /* The events of the behavior. */
     void (*function)(); /* The function to execute for the code. */
 
+    int enabled;        /* Tells if the behavior is enabled or not. */
+
     int activated;      /* Tells if the code is activated or not. */
 } CodeS;
 
@@ -623,6 +630,16 @@ extern unsigned long long make_delay(int value, Unit unit);
  * @param func function to applie on each signal. */
 extern void each_all_signal(void (*func)(SignalI));
 
+
+/** Configure a system instance.
+ *  @param systemI the system instance to configure.
+ *  @param idx the index of the target system. */
+extern void configure(SystemI systemI, int idx);
+
+
+/** Terminates the simulation. */
+extern void terminate();
+
 /* Interface to the visualization engine. */
 
 typedef struct {
@@ -701,6 +718,11 @@ extern void init_vcd_visualizer(char* name);
 
 /* The interface to the simulator core. */
 
+/** Sets the enable status of the behaviors of a system type. 
+ *  @param systemT the system type to process.
+ *  @param status the enable status. */
+extern void set_enable_system(SystemT systemT, int status);
+
 /** The simulation core function.
  *  @param name the name of the simulation.
  *  @param init_vizualizer the vizualizer engine initializer.