HDLRuby 2.11.10 → 2.11.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1abbd8fa7d81751f96e4728d9de4feca367a2fd279f53ba819403de04ed32a7
-  data.tar.gz: b820d83dffce7d785de1ec0ebffdab501fbd555808b694c5df70c96f4f599fbd
+  metadata.gz: 41a83b15623015119b3b9413b535614c9e99b92500e49d52ad6b14cd44fcc158
+  data.tar.gz: 38b0fea433d9d418998d72b03639fb02cc84c7345dd7f3a7c40c802166af0a41
 SHA512:
-  metadata.gz: 03d6925eef2143a0eead9c30147abe8617597dddddb2911a7b4cee3998a01df9d55a310eab0464676e6f1e58d7f300a377ed6da9cfda96fa66c8d8fa01dadd3e
-  data.tar.gz: fe6e7c90d8f4913d5cf680c3a65993624f90585d52387d2c04a94d454a6c2d295e22c0d152f4248fd678c13183c6d7c33e58824063a32dc76b58eb0651c341fd
+  metadata.gz: ac1c2e087bc1f3c55c7520d9f88230279a12e6500c7321683cd440d122436126e3335199bd1824d3f3018b2af82683a49c4c6982a41dfe5227a64e51519ff29c
+  data.tar.gz: 51de0a48243b54f5c5ffc9716609b2aba2604a7604c15938888c50139846f97e69267ace1044e2c3e111cc00bd70e77d4af378980214a6ee3ff1062c8181faba

data/README.md

@@ -437,7 +437,7 @@ system :sumprod do |typ,coefs|
    typ[coefs.size].input :ins
    typ.output :o
    
-   o <= coefs.each_with_index.reduce(_0) do |sum,(coef,i)|
+   o <= coefs.each_with_index.reduce(_b0) do |sum,(coef,i)|
       sum + ins[i]*coef
    end
 end
@@ -446,7 +446,7 @@ end
 In the code above, there are two generic parameters,
 `typ`, which indicates the data type of the circuit, and `coefs`, which is assumed to be an array of coefficients. Since the number of inputs depends on the number of provided coefficients, it is declared as an array of `width` bit signed whose size is equal to the number of coefficients.
 
-The description of the sum of products may be more difficult to understand for people not familiar with the Ruby language. The `each_with_index` method iterates over the coefficients adding their index as iteration variable, the resulting operation (i.e., the iteration loop) is then modified by the `reduce` method that accumulates the code passed as arguments. This code, starting by `|sum,coef,i|` simply performs the addition of the current accumulation result (`sum`) with the product of the current coefficient (`coef`) and input (`ins[i]`, where `i` is the index) in the iteration. The argument `_0` initializes the sum to `0`.
+The description of the sum of products may be more difficult to understand for people not familiar with the Ruby language. The `each_with_index` method iterates over the coefficients adding their index as iteration variable, the resulting operation (i.e., the iteration loop) is then modified by the `reduce` method that accumulates the code passed as arguments. This code, starting by `|sum,coef,i|` simply performs the addition of the current accumulation result (`sum`) with the product of the current coefficient (`coef`) and input (`ins[i]`, where `i` is the index) in the iteration. The argument `_b0` initializes the sum to `0`.
 
 While slightly longer than the previous description, this description allows declaring a circuit implementing a sum of products with any bit width and any number of coefficients. For instance, the following code describes a signed 32-bit sum of products with  16 coefficients (just random numbers here).
 
@@ -463,7 +463,7 @@ system :sumprod_func do |typ,coefs|
    typ[coefs.size].input ins
    typ.output :o
    
-   o <= coefs.each_with_index.reduce(_0) do 
+   o <= coefs.each_with_index.reduce(_b0) do 
    |sum,(coef,i)|
       add(sum, mult(ins[i]*coef))
    end
@@ -509,7 +509,7 @@ system :sumprod_proc do |add,mult,typ,coefs|
    typ[coefs.size].input ins
    typ.output :o
    
-   o <= coefs.each_with_index.reduce(_0) do 
+   o <= coefs.each_with_index.reduce(_b0) do 
    |sum,(coef,i)|
       add.(sum, mult.(ins[i]*coef))
    end
@@ -539,10 +539,8 @@ A second possible approach provided by HDLRuby is to declare a new data type wit
 signed[16].typedef(:sat16_1000)
 
 sat16_1000.define_operator(:+) do |x,y|
-   [16].inner :res
-   seq do
-      res <= x + y
-      ( res <= 1000 ).hif(res > 1000)
+      tmp = x + y
+      mux(tmp > 1000,tmp,1000)
    end
 end
 ```
@@ -565,10 +563,8 @@ end
 
 
 sat.define_operator(:+) do |width,max, x,y|
-   [width].inner :res
-   seq do
-      res <= x + y
-      ( res <= max ).hif(res > max)
+      tmp = x + y
+      mux(tmp > max, tmp, max)
    end
 end
 ```
@@ -1426,7 +1422,7 @@ They include [immediate values](#values), [reference to signals](#references) an
 ### Immediate values
 <a name="values"></a>
 
-The immediate values of HDLRuby can represent vectors of `bit`, `unsigned`, and `signed`, and integer or floating-point numbers. They are prefixed by a `_` character and include a header that indicates the vector type and the base used for representing the value, followed by a numeral representing the value.  The bit width of a value is obtained by default from the width of the numeral, but it is also possible to enforce it in the header.
+The immediate values of HDLRuby can represent vectors of `bit`, `unsigned`, and `signed`, and integer or floating-point numbers. They are prefixed by a `_` character and include a header that indicates the vector type and the base used for representing the value, followed by a numeral representing the value. The bit width of a value is obtained by default from the width of the numeral, but it is also possible to specify it in the header. In addition, the character `_` can be put anywhere in the number for increasing the readability, it will be ignored.
 
 The vector type specifiers are the followings:
  
@@ -1438,7 +1434,7 @@ The vector type specifiers are the followings:
 
 The base specifiers are the followings:
 
- - `b`: binary, can be omitted,
+ - `b`: binary,
 
  - `o`: octal,
  
@@ -1446,21 +1442,30 @@ The base specifiers are the followings:
 
  - `h`: hexadecimal.
 
-For example, all the following immediate values represent an 8-bit `100` (either in unsigned or signed representation):
+For example, all the following immediate values represent an 8-bit `hundred` (either in unsigned or signed representation):
 
 ```ruby
 _bb01100100
-_b8b1100100
+_b8b110_0100
 _b01100100
-_01100100
 _u8d100
 _s8d100
 _uh64
 _s8o144
 ```
 
+Finally, it is possible to omit either the type specifier, the default being unsigned bit, or the base specifier, the default being binary. For example, all the following immediate values represent an 8-bit unsigned `hundred`:
+
+```ruby
+_b01100100
+_h64
+_o144
+```
+
 __Notes__:
 
+ - `_01100100` used to be considered as equivalent to `_b01100100`, however due to compatibility troubles with recent version of Ruby it is considered deprecated.
+
  - Ruby immediate values can also be used, their bit width is automatically adjusted to match the data type of the expression they are used in. Please notice this adjusting may change the value of the immediate, for example, the following code will set `sig` to 4 instead of 100:
 
    ```ruby
@@ -2309,7 +2314,7 @@ Where:
  * `type` is the type from which the operation is overloaded.
  * `op` is the operator that is overloaded (e.g., `+`)
  * `args` are the arguments of the operation.
- * `operation description` is an HDLRuby description of the new operation.
+ * `operation description` is an HDLRuby expression of the new operation.
 
 For example, for `fix32` a 32-bit (decimal point at 16-bit) fixed-point type defined as follows:
 
@@ -2813,6 +2818,38 @@ fsm(clk.posedge,rst,:sync) do
 end
 ```
 
+__Note__: the goto statements acts globally, i.e., they are independant of the place where they are declared within the state. For example for both following statements, the next state will always be `st_a` whatever `cond` maybe:
+
+```ruby
+   state(:st_0) do
+      goto(:st_a)
+   end
+   state(:st_1) do
+      hif(cond) { goto(:st_a) }
+   end
+```
+
+That is to say, for a conditional `goto` for `st_1` the code should have been written as follows:
+
+```ruby
+   state(:st_1) do
+      goto(cond,:st_a)
+   end
+```
+
+The use of `goto` makes the design of FSM shorter for a majority of the cases, be sometimes, a finer control is required. For that purpose it is also possible to configure the FSM is `static` mode where the `next_state` statement that indicates implicitly the next state. Putting is static mode is done by passing `:static` as argument when declaring the FSM. For example the following FSM uses `next_state` to specify explicitly the next states depending on some condition signals `cond0` and `cond1`:
+
+```ruby
+fsm(clk.posedge,rst,:static)
+   state(:st_0) do
+      next_state(:st_1)
+   state(:st_1) do
+      hif(cond) { next_state(:st_1) }
+      helse { next_state(:st_0) }
+   end
+end
+```
+
 
 ## Fixed-point (fixpoint)
 <a name="fixpoint"></a>

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -319,6 +319,9 @@ VALUE rcsim_make_signal(VALUE mod, VALUE name, VALUE type) {
     // printf("Creating signal named=%s\n",signal->name);
     value_to_rcsim(TypeS,type,signal->type);
     // printf("&type=%p type=%p width=%llu\n",&(signal->type),signal->type,type_width(signal->type));
+    signal->num_signals= 0;
+    signal->signals = NULL;
+
     signal->c_value = make_value(signal->type,0);
     // printf("signal->c_value=%p\n",signal->c_value);
     signal->c_value->signal = signal;
@@ -798,10 +801,10 @@ VALUE rcsim_add_systemT_inputs(VALUE mod, VALUE systemTV, VALUE sigVs) {
     long old_num = systemT->num_inputs;
     systemT->num_inputs += num;
     // printf("first systemT->inputs=%p\n",systemT->inputs); fflush(stdout);
-    // systemT->inputs=realloc(systemT->inputs,
-    //         sizeof(SignalI[systemT->num_inputs]));
-    systemT->inputs=(SignalI*)my_realloc(systemT->inputs,
-            sizeof(SignalI[old_num]), sizeof(SignalI[systemT->num_inputs]));
+    systemT->inputs=realloc(systemT->inputs,
+            sizeof(SignalI[systemT->num_inputs]));
+    // systemT->inputs=(SignalI*)my_realloc(systemT->inputs,
+    //         sizeof(SignalI[old_num]), sizeof(SignalI[systemT->num_inputs]));
     // printf("now systemT->inputs=%p\n",systemT->inputs); fflush(stdout);
     // printf("access test: %p\n",systemT->inputs[0]); fflush(stdout);
     /* Get and add the signals from the Ruby value. */
@@ -825,10 +828,10 @@ VALUE rcsim_add_systemT_outputs(VALUE mod, VALUE systemTV, VALUE sigVs) {
     long old_num = systemT->num_outputs;
     systemT->num_outputs += num;
     // printf("first systemT->outputs=%p\n",systemT->outputs); fflush(stdout);
-    // systemT->outputs =realloc(systemT->outputs,
-    //         sizeof(SignalI[systemT->num_outputs]));
-    systemT->outputs =(SignalI*)my_realloc(systemT->outputs,
-            sizeof(SignalI[old_num]), sizeof(SignalI[systemT->num_outputs]));
+    systemT->outputs =realloc(systemT->outputs,
+            sizeof(SignalI[systemT->num_outputs]));
+    // systemT->outputs =(SignalI*)my_realloc(systemT->outputs,
+    //         sizeof(SignalI[old_num]), sizeof(SignalI[systemT->num_outputs]));
     // printf("now systemT->outputs=%p\n",systemT->outputs); fflush(stdout);
     // printf("access test: %p\n",systemT->outputs[0]); fflush(stdout);
     /* Get and add the signals from the Ruby value. */
@@ -852,10 +855,10 @@ VALUE rcsim_add_systemT_inouts(VALUE mod, VALUE systemTV, VALUE sigVs) {
     long old_num = systemT->num_inouts;
     systemT->num_inouts += num;
     // printf("first systemT->inouts=%p\n",systemT->inouts); fflush(stdout);
-    // systemT->inouts =realloc(systemT->inouts,
-    //         sizeof(SignalI[systemT->num_inouts]));
-    systemT->inouts =(SignalI*)my_realloc(systemT->inouts,
-            sizeof(SignalI[old_num]), sizeof(SignalI[systemT->num_inouts]));
+    systemT->inouts =realloc(systemT->inouts,
+            sizeof(SignalI[systemT->num_inouts]));
+    // systemT->inouts =(SignalI*)my_realloc(systemT->inouts,
+    //         sizeof(SignalI[old_num]), sizeof(SignalI[systemT->num_inouts]));
     // printf("now systemT->inouts=%p\n",systemT->inouts); fflush(stdout);
     // printf("access test: %p\n",systemT->inouts[0]); fflush(stdout);
     /* Get and add the signals from the Ruby value. */
@@ -879,10 +882,10 @@ VALUE rcsim_add_scope_inners(VALUE mod, VALUE scopeV, VALUE sigVs) {
     long old_num = scope->num_inners;
     scope->num_inners += num;
     // printf("first scope->inners=%p\n",scope->inners); fflush(stdout);
-    // scope->inners = realloc(scope->inners,
-    //         sizeof(SignalI[scope->num_inners]));
-    scope->inners = (SignalI*)my_realloc(scope->inners,
-            sizeof(SignalI[old_num]), sizeof(SignalI[scope->num_inners]));
+    scope->inners = realloc(scope->inners,
+            sizeof(SignalI[scope->num_inners]));
+    // scope->inners = (SignalI*)my_realloc(scope->inners,
+    //         sizeof(SignalI[old_num]), sizeof(SignalI[scope->num_inners]));
     // printf("now scope->inners=%p\n",scope->inners); fflush(stdout);
     // printf("access test: %p\n",scope->inners[0]); fflush(stdout);
     /* Get and add the signals from the Ruby value. */
@@ -909,10 +912,10 @@ VALUE rcsim_add_scope_behaviors(VALUE mod, VALUE scopeV, VALUE behVs) {
     // printf("scope->behaviors=%p\n",scope->behaviors);
     scope->num_behaviors += num;
     // printf("first scope->behaviors=%p\n",scope->behaviors); fflush(stdout);
-    // scope->behaviors = realloc(scope->behaviors,
-    //                            sizeof(Behavior[scope->num_behaviors]));
-    scope->behaviors = (Behavior*)my_realloc(scope->behaviors,
-            sizeof(Behavior[old_num]), sizeof(Behavior[scope->num_behaviors]));
+    scope->behaviors = realloc(scope->behaviors,
+                               sizeof(Behavior[scope->num_behaviors]));
+    // scope->behaviors = (Behavior*)my_realloc(scope->behaviors,
+    //         sizeof(Behavior[old_num]), sizeof(Behavior[scope->num_behaviors]));
     // printf("now scope->behaviors=%p\n",scope->behaviors); fflush(stdout);
     // printf("access test: %p\n",scope->behaviors[0]); fflush(stdout);
     /* Get and add the behaviors from the Ruby value. */
@@ -936,10 +939,10 @@ VALUE rcsim_add_scope_systemIs(VALUE mod, VALUE scopeV, VALUE sysVs) {
     long old_num = scope->num_systemIs;
     scope->num_systemIs += num;
     // printf("first scope->systemIs=%p\n",scope->systemIs); fflush(stdout);
-    // scope->systemIs = realloc(scope->systemIs,
-    //                            sizeof(SystemI[scope->num_systemIs]));
-    scope->systemIs = (SystemI*)my_realloc(scope->systemIs,
-            sizeof(SystemI[old_num]), sizeof(SystemI[scope->num_systemIs]));
+    scope->systemIs = realloc(scope->systemIs,
+                               sizeof(SystemI[scope->num_systemIs]));
+    // scope->systemIs = (SystemI*)my_realloc(scope->systemIs,
+    //         sizeof(SystemI[old_num]), sizeof(SystemI[scope->num_systemIs]));
     // printf("now scope->systemIs=%p\n",scope->systemIs); fflush(stdout);
     // printf("access test: %p\n",scope->systemIs[0]); fflush(stdout);
     /* Get and add the system instances from the Ruby value. */
@@ -963,10 +966,10 @@ VALUE rcsim_add_scope_scopes(VALUE mod, VALUE scopeV, VALUE scpVs) {
     long old_num = scope->num_scopes;
     scope->num_scopes += num;
     // printf("first scope->scopes=%p\n",scope->scopes); fflush(stdout);
-    // scope->scopes = realloc(scope->scopes,
-    //                         sizeof(Scope[scope->num_scopes]));
-    scope->scopes = (Scope*)my_realloc(scope->scopes,
-            sizeof(Scope[old_num]), sizeof(Scope[scope->num_scopes]));
+    scope->scopes = realloc(scope->scopes,
+                            sizeof(Scope[scope->num_scopes]));
+    // scope->scopes = (Scope*)my_realloc(scope->scopes,
+    //         sizeof(Scope[old_num]), sizeof(Scope[scope->num_scopes]));
     // printf("now scope->scopes=%p\n",scope->scopes); fflush(stdout);
     // printf("access test: %p\n",scope->scopes[0]); fflush(stdout);
     /* Get and add the sub scopes from the Ruby value. */
@@ -990,10 +993,10 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
     long old_num = behavior->num_events;
     behavior->num_events += num;
     // printf("first behavior->events=%p\n",behavior->events); fflush(stdout);
-    // behavior->events = realloc(behavior->events,
-    //                            sizeof(Event[behavior->num_events]));
-    behavior->events = (Event*)my_realloc(behavior->events,
-            sizeof(Event[old_num]), sizeof(Event[behavior->num_events]));
+    behavior->events = realloc(behavior->events,
+                               sizeof(Event[behavior->num_events]));
+    // behavior->events = (Event*)my_realloc(behavior->events,
+    //         sizeof(Event[old_num]), sizeof(Event[behavior->num_events]));
     // printf("now behavior->events=%p\n",behavior->events); fflush(stdout);
     // printf("access test: %p\n",behavior->events[0]); fflush(stdout);
     /* Get and add the events from the Ruby value. */
@@ -1008,9 +1011,9 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
             case ANYEDGE:
                 sig->num_any++;
     // printf("first sig->any=%p\n",sig->any); fflush(stdout);
-                // sig->any = realloc(sig->any,sizeof(Object[sig->num_any]));
-                sig->any = (Object*)my_realloc(sig->any,
-                    sizeof(Object[sig->num_any-1]),sizeof(Object[sig->num_any]));
+                sig->any = realloc(sig->any,sizeof(Object[sig->num_any]));
+                // sig->any = (Object*)my_realloc(sig->any,
+                //     sizeof(Object[sig->num_any-1]),sizeof(Object[sig->num_any]));
     // printf("now sig->any=%p\n",sig->any); fflush(stdout);
     // printf("access test: %p\n",sig->any[0]); fflush(stdout);
         // show_access(sig->any,sig->num_any-1);
@@ -1020,9 +1023,9 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
             case POSEDGE:
                 sig->num_pos++;
     // printf("first sig->pos=%p\n",sig->pos); fflush(stdout);
-                // sig->pos = realloc(sig->pos,sizeof(Object[sig->num_pos]));
-                sig->pos = (Object*)my_realloc(sig->pos,
-                    sizeof(Object[sig->num_pos-1]),sizeof(Object[sig->num_pos]));
+                sig->pos = realloc(sig->pos,sizeof(Object[sig->num_pos]));
+                // sig->pos = (Object*)my_realloc(sig->pos,
+                //     sizeof(Object[sig->num_pos-1]),sizeof(Object[sig->num_pos]));
     // printf("now sig->pos=%p\n",sig->pos); fflush(stdout);
     // printf("access test: %p\n",sig->pos[0]); fflush(stdout);
         // show_access(sig->pos,sig->num_pos-1);
@@ -1032,9 +1035,9 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
             case NEGEDGE:
                 sig->num_neg++;
     // printf("first sig->neg=%p\n",sig->neg); fflush(stdout);
-                // sig->neg = realloc(sig->neg,sizeof(Object[sig->num_neg]));
-                sig->neg = (Object*)my_realloc(sig->neg,
-                    sizeof(Object[sig->num_neg-1]),sizeof(Object[sig->num_neg]));
+                sig->neg = realloc(sig->neg,sizeof(Object[sig->num_neg]));
+                // sig->neg = (Object*)my_realloc(sig->neg,
+                //     sizeof(Object[sig->num_neg-1]),sizeof(Object[sig->num_neg]));
     // printf("now sig->neg=%p\n",sig->neg); fflush(stdout);
     // printf("access test: %p\n",sig->neg[0]); fflush(stdout);
         // show_access(sig->neg,sig->num_neg-1);
@@ -1059,10 +1062,10 @@ VALUE rcsim_add_systemI_systemTs(VALUE mod, VALUE systemIV, VALUE sysVs) {
     long old_num = systemI->num_systems;
     systemI->num_systems += num;
     // printf("first systemI->systems=%p\n",systemI->systems); fflush(stdout);
-    // systemI->systems=realloc(systemI->systems,
-    //         sizeof(SystemT[systemI->num_systems]));
-    systemI->systems = (SystemT*)my_realloc(systemI->systems,
-            sizeof(SystemT[old_num]), sizeof(SystemT[systemI->num_systems]));
+    systemI->systems=realloc(systemI->systems,
+            sizeof(SystemT[systemI->num_systems]));
+    // systemI->systems = (SystemT*)my_realloc(systemI->systems,
+    //         sizeof(SystemT[old_num]), sizeof(SystemT[systemI->num_systems]));
     // printf("now systemI->systems=%p\n",systemI->systems); fflush(stdout);
     // printf("access test: %p\n",systemI->systems[0]); fflush(stdout);
     /* Get and add the alternate system types from the Ruby value. */
@@ -1075,6 +1078,29 @@ VALUE rcsim_add_systemI_systemTs(VALUE mod, VALUE systemIV, VALUE sysVs) {
     return systemIV;
 }
 
+/* Adds sub signals a C signal. */
+VALUE rcsim_add_signal_signals(VALUE mod, VALUE signalIV, VALUE sigVs) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signalI;
+    value_to_rcsim(SignalIS,signalIV,signalI);
+    // printf("rcsim_add_signal_signals with signalI=%p\n",signalI);
+    /* Prepare the size for the alternate system types. */
+    long num = RARRAY_LEN(sigVs);
+    long old_num = signalI->num_signals;
+    signalI->num_signals += num;
+    signalI->signals=realloc(signalI->signals,
+            sizeof(SignalI[signalI->num_signals]));
+    // signalI->signals = (SignalI*)my_realloc(signalI->signals,
+    //         sizeof(SignalI[old_num]), sizeof(SignalI[signalI->num_signals]));
+    /* Get and add the alternate system types from the Ruby value. */
+    for(long i=0; i< num; ++i) {
+        SignalI sig;
+        value_to_rcsim(SignalIS,rb_ary_entry(sigVs,i),sig);
+        signalI->signals[old_num + i] = sig;
+    }
+    return signalIV;
+}
+
 /* Adds arguments to a C print. */
 VALUE rcsim_add_print_args(VALUE mod, VALUE printV, VALUE argVs) {
     /* Get the C print from the Ruby value. */
@@ -1086,10 +1112,10 @@ VALUE rcsim_add_print_args(VALUE mod, VALUE printV, VALUE argVs) {
     long old_num = print->num_args;
     print->num_args += num;
     // printf("first print->args=%p\n",print->args); fflush(stdout);
-    // print->args = realloc(print->args,
-    //                       sizeof(Expression[print->num_args]));
-    print->args = (Expression*)my_realloc(print->args,
-            sizeof(Expression[old_num]), sizeof(Expression[print->num_args]));
+    print->args = realloc(print->args,
+                          sizeof(Expression[print->num_args]));
+    // print->args = (Expression*)my_realloc(print->args,
+    //         sizeof(Expression[old_num]), sizeof(Expression[print->num_args]));
     // printf("now print->args=%p\n",print->args); fflush(stdout);
     // printf("access test: %p\n",print->args[0]); fflush(stdout);
     /* Get and add the arguments from the Ruby value. */
@@ -1114,14 +1140,14 @@ VALUE rcsim_add_hif_noifs(VALUE mod, VALUE hifV, VALUE condVs, VALUE stmntVs) {
     hif->num_noifs += num;
     // printf("first hif->noconds=%p\n",hif->noconds); fflush(stdout);
     // printf("first hif->nostmnts=%p\n",hif->nostmnts); fflush(stdout);
-    // hif->noconds = realloc(hif->noconds,sizeof(Expression[hif->num_noifs]));
-    hif->noconds = (Expression*)my_realloc(hif->noconds,
-            sizeof(Expression[old_num]),sizeof(Expression[hif->num_noifs]));
+    hif->noconds = realloc(hif->noconds,sizeof(Expression[hif->num_noifs]));
+    // hif->noconds = (Expression*)my_realloc(hif->noconds,
+    //         sizeof(Expression[old_num]),sizeof(Expression[hif->num_noifs]));
     // printf("now hif->noconds=%p\n",hif->noconds); fflush(stdout);
     // printf("access test: %p\n",hif->noconds[0]); fflush(stdout);
-    // hif->nostmnts = realloc(hif->nostmnts,sizeof(Statement[hif->num_noifs]));
-    hif->nostmnts = (Statement*)my_realloc(hif->nostmnts,
-            sizeof(Statement[old_num]),sizeof(Statement[hif->num_noifs]));
+    hif->nostmnts = realloc(hif->nostmnts,sizeof(Statement[hif->num_noifs]));
+    // hif->nostmnts = (Statement*)my_realloc(hif->nostmnts,
+    //         sizeof(Statement[old_num]),sizeof(Statement[hif->num_noifs]));
     // printf("now hif->nostmnts=%p\n",hif->nostmnts); fflush(stdout);
     // printf("access test: %p\n",hif->nostmnts[0]); fflush(stdout);
     /* Get and add the noifs from the Ruby value. */
@@ -1150,16 +1176,16 @@ VALUE rcsim_add_hcase_whens(VALUE mod, VALUE hcaseV, VALUE matchVs, VALUE stmntV
     hcase->num_whens += num;
     // printf("first hcase->matches=%p\n",hcase->matches); fflush(stdout);
     // printf("first hcase->stmnts=%p\n",hcase->stmnts); fflush(stdout);
-    // hcase->matches = realloc(hcase->matches,
-    //                          sizeof(Expression[hcase->num_whens]));
-    hcase->matches = (Expression*)my_realloc(hcase->matches,
-            sizeof(Expression[old_num]), sizeof(Expression[hcase->num_whens]));
+    hcase->matches = realloc(hcase->matches,
+                             sizeof(Expression[hcase->num_whens]));
+    // hcase->matches = (Expression*)my_realloc(hcase->matches,
+    //         sizeof(Expression[old_num]), sizeof(Expression[hcase->num_whens]));
     // printf("now hcase->matches=%p\n",hcase->matches); fflush(stdout);
     // printf("access test: %p\n",hcase->matches[0]); fflush(stdout);
-    // hcase->stmnts = realloc(hcase->stmnts,
-    //                         sizeof(Statement[hcase->num_whens]));
-    hcase->stmnts = (Statement*)my_realloc(hcase->stmnts,
-            sizeof(Statement[old_num]), sizeof(Statement[hcase->num_whens]));
+    hcase->stmnts = realloc(hcase->stmnts,
+                            sizeof(Statement[hcase->num_whens]));
+    // hcase->stmnts = (Statement*)my_realloc(hcase->stmnts,
+    //         sizeof(Statement[old_num]), sizeof(Statement[hcase->num_whens]));
     // printf("now hcase->stmnts=%p\n",hcase->stmnts); fflush(stdout);
     // printf("access test: %p\n",hcase->stmnts[0]); fflush(stdout);
     /* Get and add the whens from the Ruby value. */
@@ -1187,10 +1213,10 @@ VALUE rcsim_add_block_inners(VALUE mod, VALUE blockV, VALUE sigVs) {
     long old_num = block->num_inners;
     block->num_inners += num;
     // printf("first block->inners=%p\n",block->inners); fflush(stdout);
-    // block->inners = realloc(block->inners,
-    //         sizeof(SignalI[block->num_inners]));
-    block->inners = (SignalI*)my_realloc(block->inners,
-            sizeof(SignalI[old_num]), sizeof(SignalI[block->num_inners]));
+    block->inners = realloc(block->inners,
+            sizeof(SignalI[block->num_inners]));
+    // block->inners = (SignalI*)my_realloc(block->inners,
+    //         sizeof(SignalI[old_num]), sizeof(SignalI[block->num_inners]));
     // printf("now block->inners=%p\n",block->inners); fflush(stdout);
     // printf("access test: %p\n",block->inners[0]); fflush(stdout);
     /* Get and add the signals from the Ruby value. */
@@ -1214,10 +1240,10 @@ VALUE rcsim_add_block_statements(VALUE mod, VALUE blockV, VALUE stmntVs) {
     long old_num = block->num_stmnts;
     block->num_stmnts += num;
     // printf("first block->stmnts=%p\n",block->stmnts); fflush(stdout);
-    // block->stmnts = realloc(block->stmnts,
-    //         sizeof(Statement[block->num_stmnts]));
-    block->stmnts = (Statement*)my_realloc(block->stmnts,
-            sizeof(Statement[old_num]), sizeof(Statement[block->num_stmnts]));
+    block->stmnts = realloc(block->stmnts,
+            sizeof(Statement[block->num_stmnts]));
+    // block->stmnts = (Statement*)my_realloc(block->stmnts,
+    //         sizeof(Statement[old_num]), sizeof(Statement[block->num_stmnts]));
     // printf("now block->stmnts=%p\n",block->stmnts); fflush(stdout);
     // printf("access test: %p\n",block->stmnts[0]); fflush(stdout);
     /* Get and add the statements from the Ruby value. */
@@ -1241,10 +1267,10 @@ VALUE rcsim_add_select_choices(VALUE mod, VALUE selectV, VALUE choiceVs) {
     long old_num = select->num_choices;
     select->num_choices += num;
     // printf("first select->choices=%p\n",select->choices); fflush(stdout);
-    // select->choices = realloc(select->choices,
-    //         sizeof(Expression[select->num_choices]));
-    select->choices = (Expression*)my_realloc(select->choices,
-            sizeof(Expression[old_num]),sizeof(Expression[select->num_choices]));
+    select->choices = realloc(select->choices,
+            sizeof(Expression[select->num_choices]));
+    // Select->choices = (Expression*)my_realloc(select->choices,
+    //         sizeof(Expression[old_num]),sizeof(Expression[select->num_choices]));
     // printf("now select->choices=%p\n",select->choices); fflush(stdout);
     // printf("access test: %p\n",select->choices[0]); fflush(stdout);
     /* Get and add the choices from the Ruby value. */
@@ -1269,10 +1295,10 @@ VALUE rcsim_add_concat_expressions(VALUE mod, VALUE concatV, VALUE exprVs) {
     // printf("add_concat_expressions with num=%li old_num=%li\n",num,old_num);
     concat->num_exprs += num;
     // printf("first concat->exprs=%p\n",concat->exprs); fflush(stdout);
-    // concat->exprs = realloc(concat->exprs,
-    //         sizeof(Expression[concat->num_exprs]));
-    concat->exprs = (Expression*)my_realloc(concat->exprs,
-            sizeof(Expression[old_num]), sizeof(Expression[concat->num_exprs]));
+    concat->exprs = realloc(concat->exprs,
+            sizeof(Expression[concat->num_exprs]));
+    // concat->exprs = (Expression*)my_realloc(concat->exprs,
+    //         sizeof(Expression[old_num]), sizeof(Expression[concat->num_exprs]));
     // printf("now concat->exprs=%p\n",concat->exprs); fflush(stdout);
     // printf("access test: %p\n",concat->exprs[0]); fflush(stdout);
     /* Get and add the expressions from the Ruby value. */
@@ -1296,10 +1322,10 @@ VALUE rcsim_add_refConcat_refs(VALUE mod, VALUE refConcatV, VALUE refVs) {
     long old_num = refConcat->num_refs;
     refConcat->num_refs += num;
     // printf("first refConcat->refs=%p\n",refConcat->refs); fflush(stdout);
-    // refConcat->refs = realloc(refConcat->refs,
-    //         sizeof(Reference[refConcat->num_refs]));
-    refConcat->refs = (Reference*)my_realloc(refConcat->refs,
-            sizeof(Reference[old_num]), sizeof(Reference[refConcat->num_refs]));
+    refConcat->refs = realloc(refConcat->refs,
+            sizeof(Reference[refConcat->num_refs]));
+    // refConcat->refs = (Reference*)my_realloc(refConcat->refs,
+    //         sizeof(Reference[old_num]), sizeof(Reference[refConcat->num_refs]));
     // printf("now refConcat->refs=%p\n",refConcat->refs); fflush(stdout);
     // printf("access test: %p\n",refConcat->refs[0]); fflush(stdout);
     /* Get and add the references from the Ruby value. */
@@ -1459,6 +1485,7 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_add_scope_scopes",rcsim_add_scope_scopes,2);
     rb_define_singleton_method(mod,"rcsim_add_behavior_events",rcsim_add_behavior_events,2);
     rb_define_singleton_method(mod,"rcsim_add_systemI_systemTs",rcsim_add_systemI_systemTs,2);
+    rb_define_singleton_method(mod,"rcsim_add_signal_signals",rcsim_add_signal_signals,2);
     rb_define_singleton_method(mod,"rcsim_add_print_args",rcsim_add_print_args,2);
     rb_define_singleton_method(mod,"rcsim_add_hif_noifs",rcsim_add_hif_noifs,3);
     rb_define_singleton_method(mod,"rcsim_add_hcase_whens",rcsim_add_hcase_whens,3);

data/ext/hruby_sim/hruby_sim.h

@@ -530,6 +530,9 @@ typedef struct SignalIS_ {
     Value c_value;      /* The current value of the signal. */
     Value f_value;      /* The future (next) value of the signal. */
 
+    int num_signals;    /* The number of sub signals. */
+    SignalI* signals;   /* The sub signals. */
+
     int fading;         /* Tell if the signal can be overwritten by Z. */
 
     int num_any;        /* The number of behavior activated on any edge. */

data/ext/hruby_sim/hruby_sim_calc.c

@@ -83,7 +83,7 @@ static void add_hash_type(Type type) {
     List entry = hash_type[hvalue];
     if (!entry) {
         /* No entry, create a new one. */
-        entry = malloc(sizeof(List));
+        entry = (List)malloc(sizeof(ListS));
         entry = build_list(entry);
     }
     /* Adds the type to the entry. */
@@ -201,16 +201,24 @@ Value make_value(Type type, int numeric) {
     /* Compute the size in words of the data contained in the value. */
     unsigned long long width = type_width(type);
     /* Allocate the value. */
-    Value res = calloc(1,sizeof(ValueS));
+    // Value res = calloc(1,sizeof(ValueS));
+    Value res = malloc(sizeof(ValueS));
+#ifdef RCSIM
+    res->kind = VALUEE;
+    res->owner = 0;
+#endif
     /* Allocates the data of the value. */
     if (!numeric) {
         /* Allocate the bit string and fill it with u (undefined) by default. */
-        res->data_str = malloc(sizeof(char)*width);
+        // res->data_str = malloc(sizeof(char)*width);
+        res->data_str = malloc(sizeof(char)*width+1);
         memset(res->data_str,'x',width);
+        res->data_str[width] = 0;
         /* And set its capacity to the type width. */
-        res->capacity = width;
+        res->capacity = width+1;
     } else {
         res->capacity = 0;
+        res->data_str = 0;
     }
 
     /* Initialize it. */
@@ -229,8 +237,8 @@ void resize_value(Value value, unsigned long long size) {
     if (value->capacity < size) {
         /* Resizing required, to limit frequent resize, double the
          * required new capacity. */
-        /* Free the former data. */
-        free(value->data_str);
+        /* Free the former data if required. */
+        if (value->capacity > 0) free(value->data_str);
         /* Reallocate it. */
         value->data_str = calloc(size*2,sizeof(char));
         /* Update the size. */

data/ext/hruby_sim/hruby_sim_core.c

@@ -86,8 +86,8 @@ void register_timed_behavior(Behavior behavior) {
         } else {
             /* Need to increase the capacity. */
             Behavior* behaviors = calloc(cap_timed_behaviors*2,sizeof(Behavior));
-            // memcpy(behaviors,timed_behaviors,sizeof(Behavior)*cap_timed_behaviors);
             memcpy(behaviors,timed_behaviors,sizeof(Behavior[cap_timed_behaviors]));
+            free(timed_behaviors);
             timed_behaviors = behaviors;
             cap_timed_behaviors *= 2;
         }
@@ -110,6 +110,7 @@ void register_init_behavior(Behavior beh) {
             Behavior* new_behs = calloc(cap_init_behaviors*2,sizeof(Behavior));
             memcpy(new_behs,init_behaviors,sizeof(Behavior[cap_init_behaviors]));
             cap_init_behaviors *= 2;
+            free(init_behaviors);
             init_behaviors=new_behs;
         }
     }
@@ -129,9 +130,9 @@ void register_signal(SignalI signal) {
         } else {
             /* Need to increase the capacity. */
             SignalI* new_signals = calloc(cap_all_signals*2,sizeof(SignalI));
-            // memcpy(new_signals,all_signals,sizeof(SignalI)*cap_all_signals);
             memcpy(new_signals,all_signals,sizeof(SignalI[cap_all_signals]));
             cap_all_signals *= 2;
+            free(all_signals);
             all_signals=new_signals;
         }
     }
@@ -728,14 +729,26 @@ void transmit_to_signal_range_seq(Value value, RefRangeS ref) {
     SignalI signal = ref.signal;
     unsigned long long first = ref.first;
     unsigned long long last = ref.last;
-    // printf("Tansmit to signal range: %s(%p) [%llu,%llu]\n",signal->name,signal,first,last);
+    // printf("Tansmit to signal range seq: %s(%p) [%llu,%llu]\n",signal->name,signal,first,last);
+    // /* Can transmit, copy the content. */
+    // if (signal->fading)
+    //     // write_range(value,first,last,signal->f_value->type,signal->f_value);
+    //     write_range(value,first,last,ref.type,signal->f_value);
+    // else
+    //     // write_range_no_z(value,first,last,signal->f_value->type,signal->f_value);
+    //     write_range_no_z(value,first,last,ref.type,signal->f_value);
+    /* The base type is stored here to avoid allocating a new type each time.
+     * It have an arbitrary base size a single element. */
+    static TypeS baseT = { 1, 1 };
+    baseT.base = signal->f_value->type->base;
+    // printf("Tansmit to signal range: %s(%p) [%lld:%lld]\n",signal->name,signal,first,last);
     /* Can transmit, copy the content. */
     if (signal->fading)
-        // write_range(value,first,last,signal->f_value->type,signal->f_value);
-        write_range(value,first,last,ref.type,signal->f_value);
+        signal->f_value = write_range(value,first,last,&baseT,
+                signal->f_value);
     else
-        // write_range_no_z(value,first,last,signal->f_value->type,signal->f_value);
-        write_range_no_z(value,first,last,ref.type,signal->f_value);
+        signal->f_value = write_range_no_z(value,first,last,&baseT,
+                signal->f_value);
     /* And touch the signal. */
     touch_signal_seq(signal);
 }