HDLRuby 2.11.2 → 2.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 284593b60cc81aa5e8f0f80a4370ffa33452763e22cf8928d3af1d773c69e8d4
-  data.tar.gz: 1f2f0a10ec13a7050740b621a436cf61b80895f0205033768bba101a358b911f
+  metadata.gz: 71e8ee2662101e18157249150f4766654b0c049e08c87190fa6e06e2805d087b
+  data.tar.gz: cfc13c02e2fae3ad7d2a3831be9728cc35dffa3096016c2790d9649d19348f18
 SHA512:
-  metadata.gz: 14458d5c7ae19883a43231859bce22f2e29efdbdaeb8b721af8178eab50626bbe49393c9b009eeb33b1301aeba0dec136cec804faf8c9e63a33c85ecd7595bc8
-  data.tar.gz: 542354d84103276c6875dab37528d4a7a7218d71d11a8dc70b6d49aa43a9c72c8967d729282126a24b84e763eb94297ffffae50dc9c785deb2d811cf29125c4b
+  metadata.gz: cae45da4c41f556fc550a53272861e3def26bc15107a7bcb2cce1b3f8e99491d4b9cb8d2d4f4f621f422ef99c64ed704ac2e05a5f7c2b6d906133f420994aaf1
+  data.tar.gz: d29fb9b5ba800bcc4dff27c78e8a5762b9e7be1550ec1cb916a3cda543fabce878cc317c11e208e7a299896a7fc308cb307db0667dc6b3f416920b3d1c5fa2b0

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -11,6 +11,20 @@
 
 #include "hruby_sim.h"
 
+// #if defined(_WIN32) || defined(_WIN64)
+// #define show_access(POINTER,IDX) \
+//     printf("In %s accessing range [%p,%p](%i) at=%p with size=%i\n",__func__,(POINTER),(unsigned long long)(POINTER)+_msize((POINTER)),_msize((POINTER)),&((POINTER)[(IDX)]),sizeof((POINTER[(IDX)]))); fflush(stdout)
+// #elif defined(__APPLE__)
+// #define show_access(POINTER,IDX) \
+//     printf("In %s accessing range [%p,%p](%i) at=%p with size=%i\n",__func__,(POINTER),(unsigned long long)(POINTER)+malloc_size((POINTER)),malloc_size((POINTER)),&((POINTER)[(IDX)]),sizeof((POINTER[(IDX)]))); fflush(stdout)
+// #else
+// #define show_access(POINTER,IDX) \
+//     printf("In %s accessing range [%p,%p](%i) at=%p with size=%i\n",__func__,(POINTER),(unsigned long long)(POINTER)+malloc_usable_size((POINTER)),malloc_usable_size((POINTER)),&((POINTER)[(IDX)]),sizeof((POINTER[(IDX)]))); fflush(stdout)
+// #endif
+
+// #define show_access(POINTER,IDX) 
+
+
 /**
  *  The C-Ruby hybrid HDLRuby simulation builder.
  **/
@@ -62,13 +76,23 @@ static VALUE RCSimPointer;
 
 #define rcsim_to_value(TYPE,POINTER,VALUE) \
     (VALUE) = Data_Wrap_Struct(RCSimPointer, 0, 0, (POINTER))
-    // (VALUE) = Data_Wrap_Struct(RCSimPointer, 0, free, (POINTER))
     // (VALUE) = ULL2NUM((unsigned long long)(POINTER))
+    // (VALUE) = Data_Wrap_Struct(RCSimPointer, 0, free, (POINTER))
 
 #define value_to_rcsim(TYPE,VALUE,POINTER) \
     Data_Get_Struct((VALUE),TYPE,(POINTER))
     // (POINTER) = (TYPE*)NUM2ULL((VALUE))
 
+
+/* My own realloc. */
+static void* my_realloc(void* pointer, size_t old_size, size_t new_size) {
+    if(old_size >= new_size) { return pointer; }
+    void* new_pointer = malloc(new_size);
+    memcpy(new_pointer,pointer,old_size);
+    free(pointer);
+    return new_pointer;
+}
+
 /*#### Generates the list of ID coressponding to the HDLRuby symbols. ####*/
 
 static ID id_ANYEDGE;
@@ -168,12 +192,15 @@ VALUE rcsim_get_type_vector(VALUE mod, VALUE baseV, VALUE numV) {
 
 /* Creating a systemT C object. */
 VALUE rcsim_make_systemT(VALUE mod, VALUE name) {
+    // printf("rcsim_make_systemT\n");
     /* Allocates the systemT. */
     SystemT systemT = (SystemT)malloc(sizeof(SystemTS));
+    // printf("systemT=%p\n",systemT);
     /* Set it up. */
     systemT->kind = SYSTEMT;
     systemT->owner = NULL;
     systemT->name = strdup(StringValueCStr(name));
+    // printf("systemT->name=%p\n",systemT->name);
     systemT->num_inputs = 0;
     systemT->inputs = NULL;
     systemT->num_outputs = 0;
@@ -191,12 +218,15 @@ VALUE rcsim_make_systemT(VALUE mod, VALUE name) {
 
 /* Creating a scope C object. */
 VALUE rcsim_make_scope(VALUE mod, VALUE name) {
+    // printf("rcsim_make_scope\n");
     /* Allocates the scope. */
     Scope scope = (Scope)malloc(sizeof(ScopeS));
+    // printf("scope=%p\n",scope);
     /* Set it up. */
     scope->kind = SCOPE;
     scope->owner = NULL;
     scope->name = strdup(StringValueCStr(name));
+    // printf("scope->name=%p\n",scope->name);
     scope->num_systemIs = 0;
     scope->systemIs = NULL;
     scope->num_inners = 0;
@@ -216,9 +246,10 @@ VALUE rcsim_make_scope(VALUE mod, VALUE name) {
 
 /* Creating a behavior C object. */
 VALUE rcsim_make_behavior(VALUE mod, VALUE timed) {
+    // printf("rcsim_make_behavior\n");
     /* Allocates the behavior. */
     Behavior behavior = (Behavior)malloc(sizeof(BehaviorS));
-    // printf("new behavior=%p\n",behavior);
+    // printf("behavior=%p\n",behavior);
     /* Set it up. */
     behavior->kind = BEHAVIOR;
     behavior->owner = NULL;
@@ -246,8 +277,10 @@ VALUE rcsim_make_behavior(VALUE mod, VALUE timed) {
 
 /* Creating an event C object. */
 VALUE rcsim_make_event(VALUE mod, VALUE typeV, VALUE sigV) {
+    // printf("rcsim_make_event\n");
     /* Allocates the event. */
     Event event = (Event)malloc(sizeof(EventS));
+    // printf("event=%p\n",event);
     /* Set it up. */
     event->kind = EVENT;
     event->owner = NULL;
@@ -268,28 +301,36 @@ VALUE rcsim_make_event(VALUE mod, VALUE typeV, VALUE sigV) {
 
 /* Creating a signal C object. */
 VALUE rcsim_make_signal(VALUE mod, VALUE name, VALUE type) {
+    // printf("rcsim_make_signal\n");
     /* Allocates the signal. */
     SignalI signal = (SignalI)malloc(sizeof(SignalIS));
+    // printf("signal=%p\n",signal);
     /* Set it up. */
     signal->kind = SIGNALI;
     signal->owner = NULL;
     signal->name = strdup(StringValueCStr(name));
+    // printf("signal->name=%p\n",signal->name);
     // printf("Creating signal named=%s\n",signal->name);
     value_to_rcsim(TypeS,type,signal->type);
     // printf("type width=%llu\n",type_width(signal->type));
     signal->c_value = make_value(signal->type,0);
+    // printf("signal->c_value=%p\n",signal->c_value);
     signal->c_value->signal = signal;
     // printf("c_value=%p type=%p\n",signal->c_value,signal->c_value->type);
     // printf("c_value type width=%llu\n",type_width(signal->c_value->type));
     signal->f_value = make_value(signal->type,0);
+    // printf("signal->f_value=%p\n",signal->f_value);
     signal->f_value->signal = signal;
     signal->fading = 1; /* Initially the signal can be overwritten by anything.*/
     signal->num_any = 0;
     signal->any = NULL;
+    // signal->any = (SignalI*)calloc(32,sizeof(SignalI));
     signal->num_pos = 0;
     signal->pos = NULL;
+    // signal->pos = (SignalI*)calloc(32,sizeof(SignalI));
     signal->num_neg = 0;
     signal->neg = NULL;
+    // signal->neg = (SignalI*)calloc(32,sizeof(SignalI));
     /* Register the signal. */
     register_signal(signal);
     /* Returns the C signal embedded into a ruby VALUE. */
@@ -301,17 +342,21 @@ VALUE rcsim_make_signal(VALUE mod, VALUE name, VALUE type) {
 
 /* Creating a system instance C object. */
 VALUE rcsim_make_systemI(VALUE mod, VALUE name, VALUE systemT) {
+    // printf("rcsim_make_systemI\n");
     /* Allocates the system instance. */
     SystemI systemI = (SystemI)malloc(sizeof(SystemIS));
+    // printf("systemI=%p\n",systemI);
     /* Set it up. */
     systemI->kind = SYSTEMI;
     systemI->owner = NULL;
     systemI->name = strdup(StringValueCStr(name));
+    // printf("systemI->name=%p\n",systemI->name);
     // /* Name is made empty since redundant with Eigen system. */
     // systemI->name = "";
     value_to_rcsim(SystemTS,systemT,systemI->system);
     systemI->num_systems = 1;
-    systemI->systems = (SystemT*)malloc(sizeof(SystemT));
+    systemI->systems = (SystemT*)malloc(sizeof(SystemT[1]));
+    // printf("systemI->systems=%p\n",systemI->systems); fflush(stdout);
     systemI->systems[0] = systemI->system;
     /* Configure the systemI to execute the default systemT. */
     configure(systemI,0);
@@ -324,8 +369,10 @@ VALUE rcsim_make_systemI(VALUE mod, VALUE name, VALUE systemT) {
 
 /* Creating a transmit C object. */
 VALUE rcsim_make_transmit(VALUE mod, VALUE left, VALUE right) {
+    // printf("rcsim_make_transmit\n");
     /* Allocates the transmit. */
     Transmit transmit = (Transmit)malloc(sizeof(TransmitS));
+    // printf("transmit=%p\n",transmit);
     /* Set it up. */
     transmit->kind = TRANSMIT;
     value_to_rcsim(ReferenceS,left,transmit->left);
@@ -339,8 +386,10 @@ VALUE rcsim_make_transmit(VALUE mod, VALUE left, VALUE right) {
 
 /* Creating a print C object. */
 VALUE rcsim_make_print(VALUE mod) {
+    // printf("rcsim_make_print\n");
     /* Allocates the print. */
     Print print = (Print)malloc(sizeof(PrintS));
+    // printf("print=%p\n",print);
     /* Set it up. */
     print->kind = PRINT;
     print->num_args = 0;
@@ -354,8 +403,10 @@ VALUE rcsim_make_print(VALUE mod) {
 
 /* Creating a time wait C object. */
 VALUE rcsim_make_timeWait(VALUE mod, VALUE unitV, VALUE delayV) {
+    // printf("rcsim_make_timeWait\n");
     /* Allocates the time wait. */
     TimeWait timeWait = (TimeWait)malloc(sizeof(TimeWaitS));
+    // printf("timeWait=%p\n",timeWait);
     /* Set it up. */
     timeWait->kind = TIME_WAIT;
     /* Compute the delay. */
@@ -382,8 +433,10 @@ VALUE rcsim_make_timeWait(VALUE mod, VALUE unitV, VALUE delayV) {
 
 /* Creating a time terminate C object. */
 VALUE rcsim_make_timeTerminate(VALUE mod) {
+    // printf("rcsim_make_timeTerminate\n");
     /* Allocates the time terminate. */
     TimeTerminate timeTerminate = (TimeTerminate)malloc(sizeof(TimeTerminateS));
+    // printf("timeTerminate=%p\n",timeTerminate);
     /* Set it up. */
     timeTerminate->kind = TIME_TERMINATE;
     /* Returns the C time terminate embedded into a ruby VALUE. */
@@ -395,8 +448,10 @@ VALUE rcsim_make_timeTerminate(VALUE mod) {
 
 /* Creating a hardware if C object. */
 VALUE rcsim_make_hif(VALUE mod, VALUE condition, VALUE yes, VALUE no) {
+    // printf("rcsim_make_hif\n");
     /* Allocates the hardware if. */
     HIf hif = (HIf)malloc(sizeof(HIfS));
+    // printf("hif=%p\n",hif);
     /* Set it up. */
     hif->kind = HIF;
     value_to_rcsim(ExpressionS,condition,hif->condition);
@@ -417,8 +472,10 @@ VALUE rcsim_make_hif(VALUE mod, VALUE condition, VALUE yes, VALUE no) {
 
 /* Creating a hardware case C object. */
 VALUE rcsim_make_hcase(VALUE mod, VALUE value, VALUE defolt) {
+    // printf("rcsim_make_hcase\n");
     /* Allocates the hardware case. */
     HCase hcase = (HCase)malloc(sizeof(HCaseS));
+    // printf("hcase=%p\n",hcase);
     /* Set it up. */
     hcase->kind = HCASE;
     value_to_rcsim(ExpressionS,value,hcase->value);
@@ -438,8 +495,10 @@ VALUE rcsim_make_hcase(VALUE mod, VALUE value, VALUE defolt) {
 
 /* Creating a block C object. */
 VALUE rcsim_make_block(VALUE mod, VALUE mode) {
+    // printf("rcsim_make_block\n");
     /* Allocates the block. */
     Block block = (Block)malloc(sizeof(BlockS));
+    // printf("block=%p\n",block);
     /* Set it up. */
     block->kind = BLOCK;
     block->owner = NULL;
@@ -458,15 +517,13 @@ VALUE rcsim_make_block(VALUE mod, VALUE mode) {
 
 /* Creating a numeric value C object. */
 VALUE rcsim_make_value_numeric(VALUE mod, VALUE typeV, VALUE contentV) {
-    // /* Allocates the value. */
-    // Value value = get_value();
-    // /* Sets its type. */
-    // value_to_rcsim(TypeS,typeV,value->type);
+    // printf("rcsim_make_value_numeric\n");
     /* Get the type. */
     Type type;
     value_to_rcsim(TypeS,typeV,type);
     /* Create the value. */
     Value value = make_value(type,0);
+    // printf("value=%p\n",value);
     /* Set it to numeric. */
     value->numeric = 1;
     value->capacity = 0;
@@ -481,15 +538,13 @@ VALUE rcsim_make_value_numeric(VALUE mod, VALUE typeV, VALUE contentV) {
 
 /* Creating a bitstring value C object. */
 VALUE rcsim_make_value_bitstring(VALUE mod, VALUE typeV, VALUE contentV) {
-    // /* Allocates the value. */
-    // Value value = get_value();
-    // /* Sets its type. */
-    // value_to_rcsim(TypeS,type,value->type);
+    // printf("rcsim_make_value_bitstring\n");
     /* Get the type. */
     Type type;
     value_to_rcsim(TypeS,typeV,type);
     /* Create the value. */
     Value value = make_value(type,0);
+    // printf("value=%p\n",value);
     // printf("Created from bitstring value=%p with type=%p\n",value,value->type);
     // printf("and width=%llu\n",type_width(value->type));
     /* Set it to bitstring. */
@@ -497,7 +552,8 @@ VALUE rcsim_make_value_bitstring(VALUE mod, VALUE typeV, VALUE contentV) {
     /* Generate the string of the content. */
     char* str = StringValueCStr(contentV);
     value->capacity = strlen(str)+1;
-    value->data_str = calloc(sizeof(char),value->capacity);
+    value->data_str = calloc(value->capacity,sizeof(char));
+    // printf("value->data_str=%p\n",value->data_str);
     strcpy(value->data_str,str);
     /* Returns the C value embedded into a ruby VALUE. */
     VALUE res;
@@ -508,8 +564,10 @@ VALUE rcsim_make_value_bitstring(VALUE mod, VALUE typeV, VALUE contentV) {
 
 /* Creating a cast C object. */
 VALUE rcsim_make_cast(VALUE mod, VALUE type, VALUE child) {
+    // printf("rcsim_make_cast\n");
     /* Allocates the cast. */
     Cast cast = (Cast)malloc(sizeof(CastS));
+    // printf("cast=%p\n",cast);
     /* Set it up. */
     cast->kind = CAST;
     value_to_rcsim(TypeS,type,cast->type);
@@ -522,8 +580,10 @@ VALUE rcsim_make_cast(VALUE mod, VALUE type, VALUE child) {
 
 /* Creating a unary value C object. */
 VALUE rcsim_make_unary(VALUE mod, VALUE type, VALUE operator, VALUE child) {
+    // printf("rcsim_make_unary\n");
     /* Allocates the unary. */
     Unary unary= (Unary)malloc(sizeof(UnaryS));
+    // printf("unary=%p\n",unary);
     /* Set it up. */
     unary->kind = UNARY;
     value_to_rcsim(TypeS,type,unary->type);
@@ -541,8 +601,10 @@ VALUE rcsim_make_unary(VALUE mod, VALUE type, VALUE operator, VALUE child) {
 
 /* Creating a binary value C object. */
 VALUE rcsim_make_binary(VALUE mod, VALUE type, VALUE operator, VALUE left, VALUE right) {
+    // printf("rcsim_make_binary\n");
     /* Allocates the binary. */
     Binary binary = (Binary)malloc(sizeof(BinaryS));
+    // printf("binary=%p\n",binary);
     /* Set it up. */
     binary->kind = BINARY;
     value_to_rcsim(TypeS,type,binary->type);
@@ -575,8 +637,10 @@ VALUE rcsim_make_binary(VALUE mod, VALUE type, VALUE operator, VALUE left, VALUE
 
 /* Creating a select C object. */
 VALUE rcsim_make_select(VALUE mod, VALUE type, VALUE sel) {
+    // printf("rcsim_make_select\n");
     /* Allocates the select. */
     Select select = (Select)malloc(sizeof(SelectS));
+    // printf("select=%p\n",select);
     /* Set it up. */
     select->kind = SELECT;
     value_to_rcsim(TypeS,type,select->type);
@@ -591,8 +655,10 @@ VALUE rcsim_make_select(VALUE mod, VALUE type, VALUE sel) {
 
 /* Creating a concat C object. */
 VALUE rcsim_make_concat(VALUE mod, VALUE type, VALUE dirV) {
+    // printf("rcsim_make_concat\n");
     /* Allocates the concat. */
     Concat concat = (Concat)malloc(sizeof(ConcatS));
+    // printf("concat=%p\n",concat);
     /* Set it up. */
     concat->kind = CONCAT;
     value_to_rcsim(TypeS,type,concat->type);
@@ -607,8 +673,10 @@ VALUE rcsim_make_concat(VALUE mod, VALUE type, VALUE dirV) {
 
 /* Creating a ref concat C object. */
 VALUE rcsim_make_refConcat(VALUE mod, VALUE type, VALUE dirV) {
+    // printf("rcsim_make_refConcat\n");
     /* Allocates the ref concat. */
     RefConcat refConcat = (RefConcat)malloc(sizeof(RefConcatS));
+    // printf("refConcat=%p\n",refConcat);
     /* Set it up. */
     refConcat->kind = REF_CONCAT;
     value_to_rcsim(TypeS,type,refConcat->type);
@@ -623,8 +691,10 @@ VALUE rcsim_make_refConcat(VALUE mod, VALUE type, VALUE dirV) {
 
 /* Creating a ref index C object. */
 VALUE rcsim_make_refIndex(VALUE mod, VALUE type, VALUE index, VALUE ref) {
+    // printf("rcsim_make_refIndex\n");
     /* Allocates the ref index. */
     RefIndex refIndex = (RefIndex)malloc(sizeof(RefIndexS));
+    // printf("refIndex=%p\n",refIndex);
     /* Set it up. */
     refIndex->kind = REF_INDEX;
     value_to_rcsim(TypeS,type,refIndex->type);
@@ -638,8 +708,10 @@ VALUE rcsim_make_refIndex(VALUE mod, VALUE type, VALUE index, VALUE ref) {
 
 /* Creating a ref range C object. */
 VALUE rcsim_make_refRange(VALUE mod, VALUE type, VALUE first, VALUE last, VALUE ref) {
+    // printf("rcsim_make_refRange\n");
     /* Allocates the ref range. */
     RefRangeE refRange = (RefRangeE)malloc(sizeof(RefRangeES));
+    // printf("refRange=%p\n",refRange);
     /* Set it up. */
     refRange->kind = REF_RANGE;
     value_to_rcsim(TypeS,type,refRange->type);
@@ -655,8 +727,10 @@ VALUE rcsim_make_refRange(VALUE mod, VALUE type, VALUE first, VALUE last, VALUE
 
 /* Creating a character string C object. */
 VALUE rcsim_make_stringE(VALUE mod, VALUE strV) {
+    // printf("rcsim_make_stringE\n");
     /* Allocates the string. */
     StringE stringE = (StringE)malloc(sizeof(StringES));
+    // printf("stringE=%p\n",stringE);
     /* Set it up. */
     stringE->kind = STRINGE;
     stringE->str   = strdup(StringValueCStr(strV));
@@ -673,19 +747,24 @@ VALUE rcsim_add_systemT_inputs(VALUE mod, VALUE systemTV, VALUE sigVs) {
     /* Get the C systemT from the Ruby value. */
     SystemT systemT;
     value_to_rcsim(SystemTS,systemTV,systemT);
+    // printf("rcsim_add_systemT_inputs with systemT=%p\n",systemT);
     // printf("Adding to systemT with kind=%d and name=%s\n",systemT->kind, systemT->name);
     /* Prepare the size for the inputs. */
     long num = RARRAY_LEN(sigVs);
     long old_num = systemT->num_inputs;
     systemT->num_inputs += num;
-    systemT->inputs=realloc(systemT->inputs,sizeof(SignalI)*systemT->num_inputs);
-    // printf("size=%d num=%i\n",malloc_size(systemT->inputs),systemT->num_inputs);
-    // printf("required size=%lu\n",sizeof(SignalI)*systemT->num_inputs);
+    // printf("first systemT->inputs=%p\n",systemT->inputs); fflush(stdout);
+    // systemT->inputs=realloc(systemT->inputs,
+    //         sizeof(SignalI[systemT->num_inputs]));
+    systemT->inputs=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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         SignalI sig;
+        // show_access(systemT->inputs,old_num+i);
         value_to_rcsim(SignalIS,rb_ary_entry(sigVs,i),sig);
-        // printf("old_num+i=%ld\n",old_num+i);
         systemT->inputs[old_num + i] = sig;
     }
     return systemTV;
@@ -696,14 +775,22 @@ VALUE rcsim_add_systemT_outputs(VALUE mod, VALUE systemTV, VALUE sigVs) {
     /* Get the C systemT from the Ruby value. */
     SystemT systemT;
     value_to_rcsim(SystemTS,systemTV,systemT);
+    // printf("rcsim_add_systemT_inputs with systemT=%p\n",systemT);
     /* Prepare the size for the outputs. */
     long num = RARRAY_LEN(sigVs);
     long old_num = systemT->num_outputs;
     systemT->num_outputs += num;
-    systemT->outputs =realloc(systemT->outputs,sizeof(SignalI)*systemT->num_outputs);
+    // printf("first systemT->outputs=%p\n",systemT->outputs); fflush(stdout);
+    // systemT->outputs =realloc(systemT->outputs,
+    //         sizeof(SignalI[systemT->num_outputs]));
+    systemT->outputs =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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         SignalI sig;
+        // show_access(systemT->outputs,old_num+i);
         value_to_rcsim(SignalIS,rb_ary_entry(sigVs,i),sig);
         systemT->outputs[old_num + i] = sig;
     }
@@ -715,14 +802,22 @@ VALUE rcsim_add_systemT_inouts(VALUE mod, VALUE systemTV, VALUE sigVs) {
     /* Get the C systemT from the Ruby value. */
     SystemT systemT;
     value_to_rcsim(SystemTS,systemTV,systemT);
+    // printf("rcsim_add_systemT_inputs with systemT=%p\n",systemT);
     /* Prepare the size for the inouts. */
     long num = RARRAY_LEN(sigVs);
     long old_num = systemT->num_inouts;
     systemT->num_inouts += num;
-    systemT->inouts =realloc(systemT->inouts,sizeof(SignalI)*systemT->num_inouts);
+    // printf("first systemT->inouts=%p\n",systemT->inouts); fflush(stdout);
+    // systemT->inouts =realloc(systemT->inouts,
+    //         sizeof(SignalI[systemT->num_inouts]));
+    systemT->inouts =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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         SignalI sig;
+        // show_access(systemT->inouts,old_num+i);
         value_to_rcsim(SignalIS,rb_ary_entry(sigVs,i),sig);
         systemT->inouts[old_num + i] = sig;
     }
@@ -734,14 +829,22 @@ VALUE rcsim_add_scope_inners(VALUE mod, VALUE scopeV, VALUE sigVs) {
     /* Get the C scope from the Ruby value. */
     Scope scope;
     value_to_rcsim(ScopeS,scopeV,scope);
+    // printf("rcsim_add_scope_inners with scope=%p\n",scope);
     /* Prepare the size for the inners. */
     long num = RARRAY_LEN(sigVs);
     long old_num = scope->num_inners;
     scope->num_inners += num;
-    scope->inners = realloc(scope->inners,sizeof(SignalI)*scope->num_inners);
+    // printf("first scope->inners=%p\n",scope->inners); fflush(stdout);
+    // scope->inners = realloc(scope->inners,
+    //         sizeof(SignalI[scope->num_inners]));
+    scope->inners = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         SignalI sig;
+        // show_access(scope->inners,old_num+i);
         value_to_rcsim(SignalIS,rb_ary_entry(sigVs,i),sig);
         scope->inners[old_num + i] = sig;
     }
@@ -750,18 +853,28 @@ VALUE rcsim_add_scope_inners(VALUE mod, VALUE scopeV, VALUE sigVs) {
 
 /* Adds behaviors to a C scope. */
 VALUE rcsim_add_scope_behaviors(VALUE mod, VALUE scopeV, VALUE behVs) {
+    // printf("rcsim_add_scope_behaviors\n");
     /* Get the C scope from the Ruby value. */
     Scope scope;
     value_to_rcsim(ScopeS,scopeV,scope);
+    // printf("rcsim_add_scope_behaviors with scope=%p\n",scope);
     /* Prepare the size for the behaviors. */
     long num = RARRAY_LEN(behVs);
     long old_num = scope->num_behaviors;
+    // printf("num=%lu old_num=%lu\n",num,old_num);
+    // printf("scope->behaviors=%p\n",scope->behaviors);
     scope->num_behaviors += num;
-    scope->behaviors = realloc(scope->behaviors,
-                               sizeof(Behavior)*scope->num_behaviors);
+    // printf("first scope->behaviors=%p\n",scope->behaviors); fflush(stdout);
+    // scope->behaviors = realloc(scope->behaviors,
+    //                            sizeof(Behavior[scope->num_behaviors]));
+    scope->behaviors = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Behavior beh;
+        // show_access(scope->behaviors,old_num+i);
         value_to_rcsim(BehaviorS,rb_ary_entry(behVs,i),beh);
         scope->behaviors[old_num + i] = beh;
     }
@@ -773,15 +886,22 @@ VALUE rcsim_add_scope_systemIs(VALUE mod, VALUE scopeV, VALUE sysVs) {
     /* Get the C scope from the Ruby value. */
     Scope scope;
     value_to_rcsim(ScopeS,scopeV,scope);
+    // printf("rcsim_add_scope_systemIs with scope=%p\n",scope);
     /* Prepare the size for the system instances. */
     long num = RARRAY_LEN(sysVs);
     long old_num = scope->num_systemIs;
     scope->num_systemIs += num;
-    scope->systemIs = realloc(scope->systemIs,
-                               sizeof(SystemI)*scope->num_systemIs);
+    // printf("first scope->systemIs=%p\n",scope->systemIs); fflush(stdout);
+    // scope->systemIs = realloc(scope->systemIs,
+    //                            sizeof(SystemI[scope->num_systemIs]));
+    scope->systemIs = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         SystemI sys;
+        // show_access(scope->systemIs,old_num+i);
         value_to_rcsim(SystemIS,rb_ary_entry(sysVs,i),sys);
         scope->systemIs[old_num + i] = sys;
     }
@@ -793,15 +913,22 @@ VALUE rcsim_add_scope_scopes(VALUE mod, VALUE scopeV, VALUE scpVs) {
     /* Get the C scope from the Ruby value. */
     Scope scope;
     value_to_rcsim(ScopeS,scopeV,scope);
+    // printf("rcsim_add_scope_scopes with scope=%p\n",scope);
     /* Prepare the size for the sub scopes. */
     long num = RARRAY_LEN(scpVs);
     long old_num = scope->num_scopes;
     scope->num_scopes += num;
-    scope->scopes = realloc(scope->scopes,
-                            sizeof(Scope)*scope->num_scopes);
+    // printf("first scope->scopes=%p\n",scope->scopes); fflush(stdout);
+    // scope->scopes = realloc(scope->scopes,
+    //                         sizeof(Scope[scope->num_scopes]));
+    scope->scopes = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Scope scp;
+        // show_access(scope->scopes,old_num+i);
         value_to_rcsim(ScopeS,rb_ary_entry(scpVs,i),scp);
         scope->scopes[old_num + i] = scp;
     }
@@ -813,15 +940,22 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
     /* Get the C behavior from the Ruby value. */
     Behavior behavior;
     value_to_rcsim(BehaviorS,behaviorV,behavior);
+    // printf("rcsim_add_behavior_events with behavior=%p\n",behavior);
     /* Prepare the size for the events. */
     long num = RARRAY_LEN(eventVs);
     long old_num = behavior->num_events;
     behavior->num_events += num;
-    behavior->events = realloc(behavior->events,
-                               sizeof(Event)*behavior->num_events);
+    // printf("first behavior->events=%p\n",behavior->events); fflush(stdout);
+    // behavior->events = realloc(behavior->events,
+    //                            sizeof(Event[behavior->num_events]));
+    behavior->events = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Event event;
+        // show_access(behavior->events,old_num+i);
         value_to_rcsim(EventS,rb_ary_entry(eventVs,i),event);
         behavior->events[old_num + i] = event;
         /* Update the signal of the event to say it activates the behavior. */
@@ -829,17 +963,35 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
         switch(event->edge) {
             case ANYEDGE:
                 sig->num_any++;
-                sig->any = realloc(sig->any,sizeof(Object)*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 = 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);
+                // printf("sig->any=%p\n",sig->any);
                 sig->any[sig->num_any-1] = (Object)behavior;
                 break;
             case POSEDGE:
                 sig->num_pos++;
-                sig->pos = realloc(sig->pos,sizeof(Object)*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 = 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);
+                // printf("sig->pos=%p\n",sig->pos);
                 sig->pos[sig->num_pos-1] = (Object)behavior;
                 break;
             case NEGEDGE:
                 sig->num_neg++;
-                sig->neg = realloc(sig->neg,sizeof(Object)*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 = 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);
+                // printf("sig->neg=%p\n",sig->neg);
                 sig->neg[sig->num_neg-1] = (Object)behavior;
                 break;
             default:
@@ -854,14 +1006,22 @@ VALUE rcsim_add_systemI_systemTs(VALUE mod, VALUE systemIV, VALUE sysVs) {
     /* Get the C systemI from the Ruby value. */
     SystemI systemI;
     value_to_rcsim(SystemIS,systemIV,systemI);
+    // printf("rcsim_add_systemI_systemTs with systemI=%p\n",systemI);
     /* Prepare the size for the alternate system types. */
     long num = RARRAY_LEN(sysVs);
     long old_num = systemI->num_systems;
     systemI->num_systems += num;
-    systemI->systems=realloc(systemI->systems,sizeof(SystemT)*systemI->num_systems);
+    // printf("first systemI->systems=%p\n",systemI->systems); fflush(stdout);
+    // systemI->systems=realloc(systemI->systems,
+    //         sizeof(SystemT[systemI->num_systems]));
+    systemI->systems=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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         SystemT sys;
+        // show_access(systemI->systems,old_num+i);
         value_to_rcsim(SystemTS,rb_ary_entry(sysVs,i),sys);
         systemI->systems[old_num + i] = sys;
     }
@@ -873,15 +1033,22 @@ VALUE rcsim_add_print_args(VALUE mod, VALUE printV, VALUE argVs) {
     /* Get the C print from the Ruby value. */
     Print print;
     value_to_rcsim(PrintS,printV,print);
+    // printf("rcsim_add_print_args with print=%p\n",print);
     /* Prepare the size for the arguments. */
     long num = RARRAY_LEN(argVs);
     long old_num = print->num_args;
     print->num_args += num;
-    print->args = realloc(print->args,
-                               sizeof(Expression)*print->num_args);
+    // printf("first print->args=%p\n",print->args); fflush(stdout);
+    // print->args = realloc(print->args,
+    //                       sizeof(Expression[print->num_args]));
+    print->args = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Expression arg;
+        // show_access(print->args,old_num+i);
         value_to_rcsim(ExpressionS,rb_ary_entry(argVs,i),arg);
         print->args[old_num + i] = arg;
     }
@@ -893,16 +1060,27 @@ VALUE rcsim_add_hif_noifs(VALUE mod, VALUE hifV, VALUE condVs, VALUE stmntVs) {
     /* Get the C hardware if from the Ruby value. */
     HIf hif;
     value_to_rcsim(HIfS,hifV,hif);
+    // printf("rcsim_add_hif_noifs with hif=%p\n",hif);
     /* Prepare the size for the noifs. */
     long num = RARRAY_LEN(condVs);
     long old_num = hif->num_noifs;
     hif->num_noifs += num;
-    hif->noconds = realloc(hif->noconds, sizeof(Expression)*hif->num_noifs);
-    hif->nostmnts = realloc(hif->nostmnts, sizeof(Statement)*hif->num_noifs);
+    // 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 = 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 = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Expression cond;
         Statement stmnt;
+        // show_access(hif->noconds,old_num+i);
+        // show_access(hif->nostmnts,old_num+i);
         value_to_rcsim(ExpressionS,rb_ary_entry(condVs,i),cond);
         hif->noconds[old_num + i] = cond;
         value_to_rcsim(StatementS,rb_ary_entry(stmntVs,i),stmnt);
@@ -916,18 +1094,31 @@ VALUE rcsim_add_hcase_whens(VALUE mod, VALUE hcaseV, VALUE matchVs, VALUE stmntV
     /* Get the C hardware case from the Ruby value. */
     HCase hcase;
     value_to_rcsim(HCaseS,hcaseV,hcase);
+    // printf("rcsim_add_hcase_whens with hcase=%p\n",hcase);
     /* Prepare the size for the noifs. */
     long num = RARRAY_LEN(matchVs);
     long old_num = hcase->num_whens;
     hcase->num_whens += num;
-    hcase->matches = realloc(hcase->matches,
-                             sizeof(Expression)*hcase->num_whens);
-    hcase->stmnts = realloc(hcase->stmnts,
-                             sizeof(Statement)*hcase->num_whens);
+    // 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 = 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 = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Expression match;
         Statement stmnt;
+        // show_access(hcase->matches,old_num+i);
+        // show_access(hcase->stmnts,old_num+i);
         value_to_rcsim(ExpressionS,rb_ary_entry(matchVs,i),match);
         hcase->matches[old_num + i] = match;
         value_to_rcsim(StatementS,rb_ary_entry(stmntVs,i),stmnt);
@@ -941,14 +1132,22 @@ VALUE rcsim_add_block_inners(VALUE mod, VALUE blockV, VALUE sigVs) {
     /* Get the C block from the Ruby value. */
     Block block;
     value_to_rcsim(BlockS,blockV,block);
+    // printf("rcsim_add_block_inners with block=%p\n",block);
     /* Prepare the size for the inners. */
     long num = RARRAY_LEN(sigVs);
     long old_num = block->num_inners;
     block->num_inners += num;
-    block->inners = realloc(block->inners,sizeof(SignalI)*block->num_inners);
+    // printf("first block->inners=%p\n",block->inners); fflush(stdout);
+    // block->inners = realloc(block->inners,
+    //         sizeof(SignalI[block->num_inners]));
+    block->inners = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         SignalI sig;
+        // show_access(block->inners,old_num+i);
         value_to_rcsim(SignalIS,rb_ary_entry(sigVs,i),sig);
         block->inners[old_num + i] = sig;
     }
@@ -960,14 +1159,22 @@ VALUE rcsim_add_block_statements(VALUE mod, VALUE blockV, VALUE stmntVs) {
     /* Get the C block from the Ruby value. */
     Block block;
     value_to_rcsim(BlockS,blockV,block);
+    // printf("rcsim_add_block_statements with block=%p\n",block);
     /* Prepare the size for the statements. */
     long num = RARRAY_LEN(stmntVs);
     long old_num = block->num_stmnts;
     block->num_stmnts += num;
-    block->stmnts = realloc(block->stmnts,sizeof(Statement)*block->num_stmnts);
+    // printf("first block->stmnts=%p\n",block->stmnts); fflush(stdout);
+    // block->stmnts = realloc(block->stmnts,
+    //         sizeof(Statement[block->num_stmnts]));
+    block->stmnts = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Statement stmnt;
+        // show_access(block->stmnts,old_num+i);
         value_to_rcsim(StatementS,rb_ary_entry(stmntVs,i),stmnt);
         block->stmnts[old_num + i] = stmnt;
     }
@@ -979,14 +1186,22 @@ VALUE rcsim_add_select_choices(VALUE mod, VALUE selectV, VALUE choiceVs) {
     /* Get the C select from the Ruby value. */
     Select select;
     value_to_rcsim(SelectS,selectV,select);
+    // printf("rcsim_add_select_choices with select=%p\n",select);
     /* Prepare the size for the choices. */
     long num = RARRAY_LEN(choiceVs);
     long old_num = select->num_choices;
     select->num_choices += num;
-    select->choices = realloc(select->choices,sizeof(Expression)*select->num_choices);
+    // printf("first select->choices=%p\n",select->choices); fflush(stdout);
+    // select->choices = realloc(select->choices,
+    //         sizeof(Expression[select->num_choices]));
+    select->choices = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Expression choice;
+        // show_access(select->choices,old_num+i);
         value_to_rcsim(ExpressionS,rb_ary_entry(choiceVs,i),choice);
         select->choices[old_num + i] = choice;
     }
@@ -998,17 +1213,24 @@ VALUE rcsim_add_concat_expressions(VALUE mod, VALUE concatV, VALUE exprVs) {
     /* Get the C concat from the Ruby value. */
     Concat concat;
     value_to_rcsim(ConcatS,concatV,concat);
+    // printf("rcsim_add_concat_expressions with concat=%p\n",concat);
     /* Prepare the size for the expressions. */
     long num = RARRAY_LEN(exprVs);
     long old_num = concat->num_exprs;
     // printf("add_concat_expressions with num=%li old_num=%li\n",num,old_num);
     concat->num_exprs += num;
-    concat->exprs = realloc(concat->exprs,sizeof(Expression)*concat->num_exprs);
+    // printf("first concat->exprs=%p\n",concat->exprs); fflush(stdout);
+    // concat->exprs = realloc(concat->exprs,
+    //         sizeof(Expression[concat->num_exprs]));
+    concat->exprs = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Expression expr;
+        // show_access(concat->exprs,old_num+i);
         value_to_rcsim(ExpressionS,rb_ary_entry(exprVs,i),expr);
-        // printf("Adding expression with type width=%llu\n",type_width(expr->type));
         concat->exprs[old_num + i] = expr;
     }
     return concatV;
@@ -1019,14 +1241,22 @@ VALUE rcsim_add_refConcat_refs(VALUE mod, VALUE refConcatV, VALUE refVs) {
     /* Get the C refConcat from the Ruby value. */
     RefConcat refConcat;
     value_to_rcsim(RefConcatS,refConcatV,refConcat);
+    // printf("rcsim_add_refConcat_refs with refConcat=%p\n",refConcat);
     /* Prepare the size for the references. */
     long num = RARRAY_LEN(refVs);
     long old_num = refConcat->num_refs;
     refConcat->num_refs += num;
-    refConcat->refs = realloc(refConcat->refs,sizeof(Reference)*refConcat->num_refs);
+    // printf("first refConcat->refs=%p\n",refConcat->refs); fflush(stdout);
+    // refConcat->refs = realloc(refConcat->refs,
+    //         sizeof(Reference[refConcat->num_refs]));
+    refConcat->refs = 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. */
-    for(int i=0; i< num; ++i) {
+    for(long i=0; i< num; ++i) {
         Reference ref;
+        // show_access(refConcat->refs,old_num+i);
         value_to_rcsim(ReferenceS,rb_ary_entry(refVs,i),ref);
         refConcat->refs[old_num + i] = ref;
     }

data/ext/hruby_sim/hruby_sim_calc.c

@@ -5,9 +5,9 @@
 #include <limits.h>
 #include "hruby_sim.h"
 
-#ifndef alloca
-#define alloca(x)  __builtin_alloca(x)
-#endif
+// #ifndef alloca
+// #define alloca(x)  __builtin_alloca(x)
+// #endif
 
 
 /**
@@ -147,7 +147,7 @@ Type get_type_signed() {
  *  @number the number of elements */
 Type make_type_vector(Type base, unsigned long long number) {
     /* Create the type. */
-    Type type = calloc(sizeof(TypeS),1);
+    Type type = calloc(1,sizeof(TypeS));
     type->base = type_width(base);
     type->number = number;
     type->flags = base->flags;
@@ -201,7 +201,7 @@ 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(sizeof(ValueS),1);
+    Value res = calloc(1,sizeof(ValueS));
     /* Allocates the data of the value. */
     if (!numeric) {
         /* Allocate the bit string and fill it with u (undefined) by default. */
@@ -232,7 +232,7 @@ void resize_value(Value value, unsigned long long size) {
         /* Free the former data. */
         free(value->data_str);
         /* Reallocate it. */
-        value->data_str = calloc(sizeof(char),size*2);
+        value->data_str = calloc(size*2,sizeof(char));
         /* Update the size. */
         value->capacity = size*2;
     }
@@ -2977,12 +2977,15 @@ Value concat_valueP(unsigned int num, int dir, Value dst, Value* values) {
 }
 Value concat_valueV(unsigned int num, int dir, Value dst, va_list args) {
     unsigned int i;
-    Value* values = alloca(num*sizeof(Value)); /* The values to concatenate. */
+    // Value* values = alloca(num*sizeof(Value)); /* The values to concatenate. */
+    Value* values = calloc(num,sizeof(Value)); /* The values to concatenate. */
     /* Copy the arguments to values for easier processing. */
     for(i=0; i<num; ++i) {
         values[i] = va_arg(args,Value);
     }
-    return concat_valueP(num,dir,dst,values);
+    Value res = concat_valueP(num,dir,dst,values);
+    free(values);
+    return res;
 }
 Value concat_value(unsigned int num, int dir, Value dst, ...) {
     va_list args;

data/ext/hruby_sim/hruby_sim_core.c

@@ -72,11 +72,12 @@ void register_timed_behavior(Behavior behavior) {
         if (cap_timed_behaviors == 0) {
             /* Need to create the array containing the timed behaviors. */
             cap_timed_behaviors = 5;
-            timed_behaviors = calloc(sizeof(Behavior),cap_timed_behaviors);
+            timed_behaviors = calloc(cap_timed_behaviors,sizeof(Behavior));
         } else {
             /* Need to increase the capacity. */
-            Behavior* behaviors = calloc(sizeof(Behavior),cap_timed_behaviors*2);
-            memcpy(behaviors,timed_behaviors,sizeof(Behavior)*cap_timed_behaviors);
+            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]));
             timed_behaviors = behaviors;
             cap_timed_behaviors *= 2;
         }
@@ -93,11 +94,12 @@ void register_signal(SignalI signal) {
         if (cap_all_signals == 0) {
             /* Need to create the array containing the timed behaviors. */
             cap_all_signals = 100;
-            all_signals = calloc(sizeof(SignalI),cap_all_signals);
+            all_signals = calloc(cap_all_signals,sizeof(SignalI));
         } else {
             /* Need to increase the capacity. */
-            SignalI* new_signals = calloc(sizeof(SignalI),cap_all_signals*2);
-            memcpy(new_signals,all_signals,sizeof(SignalI)*cap_all_signals);
+            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;
             all_signals=new_signals;
         }

data/ext/hruby_sim/hruby_value_pool.c

@@ -20,9 +20,10 @@ Value get_value() {
     if (pool_cap == 0) {
         /* First allocation. */
         pool_cap = 16;
-        pool_values = (Value*)malloc(pool_cap*sizeof(Value));
+        // pool_values = (Value*)malloc(pool_cap*sizeof(Value));
+        pool_values = (Value*)calloc(pool_cap,sizeof(Value));
         /* Allocate the new values. */
-        ValueS* new_values = (ValueS*)calloc(sizeof(ValueS),pool_cap);
+        ValueS* new_values = (ValueS*)calloc(pool_cap,sizeof(ValueS));
         /* Assign them to the pool. */
         unsigned int i;
         for(i=0; i<pool_cap; ++i) {
@@ -32,7 +33,8 @@ Value get_value() {
     else if (pool_pos == pool_cap) {
         /* Need to increase the pool capacity. */
         pool_cap = pool_cap * 2;
-        pool_values = (Value*)realloc(pool_values,pool_cap*sizeof(Value));
+        // pool_values = (Value*)realloc(pool_values,pool_cap*sizeof(Value));
+        pool_values = (Value*)realloc(pool_values,sizeof(Value[pool_cap]));
         if (pool_values == NULL) {
             perror("Internal error with the pool of values.");
             exit(1);
@@ -40,7 +42,7 @@ Value get_value() {
         /* Allocate the new values. */
         /* Note: now pool_pos is the old pool_cap and is also the number
          * of new values to allocate. */
-        ValueS* new_values = (ValueS*)calloc(sizeof(ValueS),pool_pos);
+        ValueS* new_values = (ValueS*)calloc(pool_pos,sizeof(ValueS));
         /* Assign them to the pool. */
         unsigned int i;
         for(i=0; i<pool_pos; ++i) {

data/lib/HDLRuby/hruby_rcsim.rb

@@ -107,26 +107,32 @@ module HDLRuby::High
             #     rcsig = sig.to_rcsim(@rcsystemT)
             #     RCSim.rcsim_add_systemT_input(@rcsystemT,rcsig)
             # end
-            RCSim.rcsim_add_systemT_inputs(@rcsystemT,
-                                           self.each_input.map do |sig|
-                sig.to_rcsim(@rcsystemT)
-            end)
+            if self.each_input.any? then
+                RCSim.rcsim_add_systemT_inputs(@rcsystemT,
+                                               self.each_input.map do |sig|
+                    sig.to_rcsim(@rcsystemT)
+                end)
+            end
             # self.each_output do |sig|
             #     rcsig = sig.to_rcsim(@rcsystemT)
             #     RCSim.rcsim_add_systemT_output(@rcsystemT,rcsig)
             # end
-            RCSim.rcsim_add_systemT_outputs(@rcsystemT,
-                                            self.each_output.map do |sig|
-                sig.to_rcsim(@rcsystemT)
-            end)
+            if self.each_output.any? then
+                RCSim.rcsim_add_systemT_outputs(@rcsystemT,
+                                                self.each_output.map do |sig|
+                    sig.to_rcsim(@rcsystemT)
+                end)
+            end
             # self.each_inout do |sig|
             #     rcsig = sig.to_rcsim(@rcsystemT)
             #     RCSim.rcsim_add_systemT_inout(@rcsystemT,rcsig)
             # end
-            RCSim.rcsim_add_systemT_inouts(@rcsystemT,
-                                           self.each_inout.map do |sig|
-                sig.to_rcsim(@rcsystemT)
-            end)
+            if self.each_inout.any? then
+                RCSim.rcsim_add_systemT_inouts(@rcsystemT,
+                                               self.each_inout.map do |sig|
+                    sig.to_rcsim(@rcsystemT)
+                end)
+            end
             # Create and add the scope.
             RCSim.rcsim_set_systemT_scope(@rcsystemT,
                                           self.scope.to_rcsim(@rcsystemT))
@@ -170,44 +176,43 @@ module HDLRuby::High
             #     rcsig = sig.to_rcsim(@rcscope)
             #     RCSim.rcsim_add_scope_inner(@rcscope,rcsig)
             # end
-            RCSim.rcsim_add_scope_inners(@rcscope,self.each_inner.map do |sig|
-                # sig.to_rcsim(@rcscope)
-                sig.to_rcsim(subowner)
-            end)
+            if self.each_inner.any? then
+                RCSim.rcsim_add_scope_inners(@rcscope,self.each_inner.map do|sig|
+                    # sig.to_rcsim(@rcscope)
+                    sig.to_rcsim(subowner)
+                end)
+            end
             
             # Create and add the system instances.
             # self.each_systemI do |sys|
             #     rcsys = sys.to_rcsim(@rcscope)
             #     RCSim.rcsim_add_scope_systemI(@rcscope,rcsys)
             # end
-            RCSim.rcsim_add_scope_systemIs(@rcscope,
-                                           self.each_systemI.map do |sys|
-                # sys.to_rcsim(@rcscope)
-                sys.to_rcsim(subowner)
-            end)
+            if self.each_systemI.any? then
+                RCSim.rcsim_add_scope_systemIs(@rcscope,
+                                               self.each_systemI.map do |sys|
+                    # sys.to_rcsim(@rcscope)
+                    sys.to_rcsim(subowner)
+                end)
+            end
 
             # Create and add the behaviors.
-            # self.each_behavior do |beh|
-            #     rcbeh = beh.to_rcsim(@rcscope)
-            #     RCSim.rcsim_add_scope_behavior(@rcscope,rcbeh)
-            # end
-            RCSim.rcsim_add_scope_behaviors(@rcscope,
-                                            self.each_behavior.map do |beh|
-                # beh.to_rcsim(@rcscope)
-                beh.to_rcsim(subowner)
-            end)
+            if self.each_behavior.any? then
+                RCSim.rcsim_add_scope_behaviors(@rcscope,
+                                                self.each_behavior.map do |beh|
+                    # beh.to_rcsim(@rcscope)
+                    beh.to_rcsim(subowner)
+                end)
+            end
 
             # Create and add the connections.
-            # self.each_connection do |cnx|
-            #     rccnx = cnx.to_rcsim(@rcscope)
-            #     # Connections are actually converted to behaviors.
-            #     RCSim.rcsim_add_scope_behavior(@rcscope,rccnx)
-            # end
-            RCSim.rcsim_add_scope_behaviors(@rcscope, 
-                                            self.each_connection.map do |cxt|
-                # cxt.to_rcsim(@rcscope)
-                cxt.to_rcsim(subowner)
-            end)
+            if self.each_connection.any? then
+                RCSim.rcsim_add_scope_behaviors(@rcscope, 
+                                                self.each_connection.map do |cxt|
+                    # cxt.to_rcsim(@rcscope)
+                    cxt.to_rcsim(subowner)
+                end)
+            end
 
             # Create and add the codes.
             # TODO!!
@@ -217,10 +222,12 @@ module HDLRuby::High
             #     rcsub = sub.to_rcsim(@rcscope)
             #     RCSim.rcsim_add_scope_scope(@rcscope,rcsub)
             # end
-            RCSim.rcsim_add_scope_scopes(@rcscope,self.each_scope.map do |sub|
-                # sub.to_rcsim(@rcscope)
-                sub.to_rcsim(subowner)
-            end)
+            if self.each_scope.any? then
+                RCSim.rcsim_add_scope_scopes(@rcscope,self.each_scope.map do|sub|
+                    # sub.to_rcsim(@rcscope)
+                    sub.to_rcsim(subowner)
+                end)
+            end
 
             return @rcscope
         end
@@ -349,11 +356,13 @@ module HDLRuby::High
             # self.each_event do |ev|
             #     RCSim.rcsim_add_behavior_event(@rcbehavior,ev.to_rcsim)
             # end
-            RCSim.rcsim_add_behavior_events(@rcbehavior,
-                                            self.each_event.map do |ev|
-                # puts "adding event: #{ev.ref.object.name}(#{ev.type})"
-                ev.to_rcsim(@rcbehavior)
-            end)
+            if self.each_event.any? then
+                RCSim.rcsim_add_behavior_events(@rcbehavior,
+                                                self.each_event.map do |ev|
+                    # puts "adding event: #{ev.ref.object.name}(#{ev.type})"
+                    ev.to_rcsim(@rcbehavior)
+                end)
+            end
 
             # Create and add the block.
             RCSim.rcsim_set_behavior_block(@rcbehavior,self.block.to_rcsim)
@@ -468,12 +477,15 @@ module HDLRuby::High
             #     rcsys = systemT.to_rcsim(@rcsystemI)
             #     RCSim.rcsim_add_systemI_systemT(@rcsystemI,rcsys)
             # end
-            RCSim.rcsim_add_systemI_systemTs(@rcsystemI,
-                                             self.each_systemT.select do |sys|
-                sys != self.systemT
-            end.map do |sys|
-                sys.to_rcsim(@rcsystemI)
-            end)
+            if self.each_systemI.any? then
+                RCSim.rcsim_add_systemI_systemTs(@rcsystemI,
+                                                 self.each_systemT.select do|sys|
+                    sys != self.systemT
+                end.map do |sys|
+                    # sys.to_rcsim(@rcsystemI)
+                    sys.to_rcsim(rcowner)
+                end)
+            end
 
             return @rcsystemI
         end
@@ -531,8 +543,10 @@ module HDLRuby::High
             # self.each_arg do |arg|
             #     RCSim.rcsim_add_print_arg(@rcstatement,arg.to_rcsim)
             # end
-            RCSim.rcsim_add_print_args(@rcstatement,
-                                       self.each_arg.map(&:to_rcsim))
+            if self.each_arg.any? then
+                RCSim.rcsim_add_print_args(@rcstatement,
+                                           self.each_arg.map(&:to_rcsim))
+            end
 
             return @rcstatement
         end
@@ -576,7 +590,9 @@ module HDLRuby::High
             # end
             rcsim_conds = self.each_noif.map {|cond,stmnt| cond.to_rcsim }
             rcsim_stmnts = self.each_noif.map {|cond,stmnt| stmnt.to_rcsim }
-            RCSim.rcsim_add_hif_noifs(@rcstatement,rcsim_conds,rcsim_stmnts)
+            if rcsim_conds.any? then
+                RCSim.rcsim_add_hif_noifs(@rcstatement,rcsim_conds,rcsim_stmnts)
+            end
 
             return @rcstatement
         end
@@ -605,7 +621,10 @@ module HDLRuby::High
             # end
             rcsim_matches = self.each_when.map {|wh| wh.match.to_rcsim }
             rcsim_stmnts = self.each_when.map {|wh| wh.statement.to_rcsim }
-            RCSim.rcsim_add_hcase_whens(@rcstatement,rcsim_matches,rcsim_stmnts)
+            if rcsim_matches.any? then
+                RCSim.rcsim_add_hcase_whens(@rcstatement,rcsim_matches,
+                                            rcsim_stmnts)
+            end
 
             return @rcstatement
         end
@@ -658,19 +677,23 @@ module HDLRuby::High
             # self.each_inner do |inner|
             #     RCSim.rcsim_add_block_inner(@rcstatement,inner.to_rcsim(@rcstatement))
             # end
-            RCSim.rcsim_add_block_inners(@rcstatement,
-                                         self.each_inner.map do |sig|
-                sig.to_rcsim(@rcstatement)
-            end)
+            if self.each_inner.any? then
+                RCSim.rcsim_add_block_inners(@rcstatement,
+                                             self.each_inner.map do |sig|
+                    sig.to_rcsim(@rcstatement)
+                end)
+            end
 
             # Add the statements.
             # self.each_statement do |stmnt|
             #     RCSim.rcsim_add_block_statement(@rcstatement,stmnt.to_rcsim)
             # end
-            RCSim.rcsim_add_block_statements(@rcstatement,
-                                       self.each_statement.map do |stmnt|
-                stmnt.to_rcsim
-            end)
+            if self.each_statement.any? then
+                RCSim.rcsim_add_block_statements(@rcstatement,
+                                            self.each_statement.map do |stmnt|
+                    stmnt.to_rcsim
+                end)
+            end
 
             return @rcstatement
         end
@@ -710,7 +733,9 @@ module HDLRuby::High
                     rcevs << ev
                 end
             end
-            RCSim.rcsim_add_behavior_events(@rcbehavior,rcevs)
+            if rcevs.any? then
+                RCSim.rcsim_add_behavior_events(@rcbehavior,rcevs)
+            end
 
             # Create and set the block.
             rcblock = RCSim.rcsim_make_block(:par)
@@ -843,8 +868,10 @@ module HDLRuby::High
             # self.each_choice do |choice|
             #     rcsim_add_select_choice(rcexpression,choice.to_rcsim)
             # end
-            RCSim.rcsim_add_select_choices(rcexpression,
-                                     self.each_choice.map(&:to_rcsim))
+            if self.each_choice.any? then
+                RCSim.rcsim_add_select_choices(rcexpression,
+                                               self.each_choice.map(&:to_rcsim))
+            end
             
             return rcexpression
         end
@@ -865,8 +892,10 @@ module HDLRuby::High
             # self.each_expression do |expr|
             #     RCSim.rcsim_add_concat_expression(rcexpression,expr.to_rcsim)
             # end
-            RCSim.rcsim_add_concat_expressions(rcexpression,
+            if self.each_expression.any? then
+                RCSim.rcsim_add_concat_expressions(rcexpression,
                                          self.each_expression.map(&:to_rcsim))
+            end
             
             return rcexpression
         end
@@ -901,7 +930,9 @@ module HDLRuby::High
             # self.each_ref do |ref|
             #     RCSim.rcsim_add_refConcat_ref(rcref,ref.to_rcsim)
             # end
-            RCSim.rcsim_add_refConcat_refs(rcref,self.each_ref(&:to_rcsim))
+            if self.each_ref.any? then
+                RCSim.rcsim_add_refConcat_refs(rcref,self.each_ref(&:to_rcsim))
+            end
             
             return rcref
         end

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.11.2"
+  VERSION = "2.11.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.11.2
+  version: 2.11.3
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-01 00:00:00.000000000 Z
+date: 2022-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler