HDLRuby 2.11.5 → 2.11.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 450d4465eb4fb71c70d61bdadf5bd0d944b5b8c7f7f9f3d02f847d670eb74f76
-  data.tar.gz: b3cf3b934d8a50f6d85ffc74f3a34b0cfd2f074d472d2f6a8b93b4324cc2e5bd
+  metadata.gz: 7b7d0296f617dc4b015e423c6f5b3e381fc3d91d9537a1bf4adf3fcc8e3a1f3c
+  data.tar.gz: 957f7763c2452bc1b96e1301fe2aebadd081a2b4ea6d282ae5907768b28b0e85
 SHA512:
-  metadata.gz: 667da8c2f678834407374f739ea4d0094803e82145b1485aa2b53bcef54f04b368668ad62996aaa67ae48b0e80fb9c9c9f731131e3eeb6c69c5c23363b2242e7
-  data.tar.gz: 39ae4cea2c84140063b601b5c3f171462db40a41b01739894daa95b90cec6dd8c87780cc86f65ff269a0d7fb4478412d06c114d4c3a921ade691c6c3d9868110
+  metadata.gz: 28529796983feba1bba6502a63a9ace24e42f08410ba4afe70fc48bba1b36ba17bac3cdde95ef245590e5e3028428a477e59ef311e5eb7c9eaee48b394f01217
+  data.tar.gz: 90e23aa3e7cbfa2ac5c397a58a8b06b2f4798a72ca491a6134b4d7c694eba6952e02e8fc0e91b10aca8790129977f893ca67c626c2aa28845596365ad65560f1

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -86,6 +86,7 @@ static VALUE RCSimPointer;
 
 /* My own realloc. */
 static void* my_realloc(void* pointer, size_t old_size, size_t new_size) {
+    // printf("my_realloc with old_size=%lu new_size=%lu\n",old_size,new_size);
     if(old_size >= new_size) { return pointer; }
     void* new_pointer = malloc(new_size);
     memcpy(new_pointer,pointer,old_size);
@@ -265,6 +266,8 @@ VALUE rcsim_make_behavior(VALUE mod, VALUE timed) {
     } else {
         /* The behavior is not timed. */
         behavior->timed = 0;
+        /* It must be initialized though. */
+        register_init_behavior(behavior);
     }
     behavior->active_time = 0;
     behavior->thread = NULL;
@@ -315,7 +318,7 @@ VALUE rcsim_make_signal(VALUE mod, VALUE name, VALUE type) {
     // 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));
+    // printf("&type=%p type=%p width=%llu\n",&(signal->type),signal->type,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;
@@ -378,6 +381,7 @@ VALUE rcsim_make_transmit(VALUE mod, VALUE left, VALUE right) {
     // printf("transmit=%p\n",transmit);
     /* Set it up. */
     transmit->kind = TRANSMIT;
+    transmit->owner = NULL;
     value_to_rcsim(ReferenceS,left,transmit->left);
     value_to_rcsim(ExpressionS,right,transmit->right);
     /* Returns the C transmit embedded into a ruby VALUE. */
@@ -395,6 +399,7 @@ VALUE rcsim_make_print(VALUE mod) {
     // printf("print=%p\n",print);
     /* Set it up. */
     print->kind = PRINT;
+    print->owner = NULL;
     print->num_args = 0;
     print->args = NULL;
     /* Returns the C print embedded into a ruby VALUE. */
@@ -412,6 +417,7 @@ VALUE rcsim_make_timeWait(VALUE mod, VALUE unitV, VALUE delayV) {
     // printf("timeWait=%p\n",timeWait);
     /* Set it up. */
     timeWait->kind = TIME_WAIT;
+    timeWait->owner = NULL;
     /* Compute the delay. */
     unsigned long long delay;
     delay = NUM2LL(delayV);
@@ -441,6 +447,7 @@ VALUE rcsim_make_timeRepeat(VALUE mod, VALUE numberV, VALUE statementV) {
     // printf("timeRepeat=%p\n",timeRepeat); fflush(stdout);
     /* Set it up. */
     timeRepeat->kind = TIME_REPEAT;
+    timeRepeat->owner = NULL;
     /* Get and set the number of repeatition. */
     long long number;
     number = NUM2LL(numberV);
@@ -463,6 +470,7 @@ VALUE rcsim_make_timeTerminate(VALUE mod) {
     // printf("timeTerminate=%p\n",timeTerminate);
     /* Set it up. */
     timeTerminate->kind = TIME_TERMINATE;
+    timeTerminate->owner = NULL;
     /* Returns the C time terminate embedded into a ruby VALUE. */
     VALUE res;
     rcsim_to_value(TimeTerminateS,timeTerminate,res);
@@ -478,6 +486,7 @@ VALUE rcsim_make_hif(VALUE mod, VALUE conditionV, VALUE yesV, VALUE noV) {
     // printf("hif=%p\n",hif);
     /* Set it up. */
     hif->kind = HIF;
+    hif->owner = NULL;
     value_to_rcsim(ExpressionS,conditionV,hif->condition);
     value_to_rcsim(StatementS,yesV,hif->yes);
     if (TYPE(noV) == T_NIL)
@@ -502,6 +511,7 @@ VALUE rcsim_make_hcase(VALUE mod, VALUE valueV, VALUE defoltV) {
     // printf("hcase=%p\n",hcase);
     /* Set it up. */
     hcase->kind = HCASE;
+    hcase->owner = NULL;
     value_to_rcsim(ExpressionS,valueV,hcase->value);
     hcase->num_whens = 0;
     hcase->matches = NULL;
@@ -553,6 +563,7 @@ VALUE rcsim_make_value_numeric(VALUE mod, VALUE typeV, VALUE contentV) {
     value->capacity = 0;
     value->data_str = NULL;
     value->data_int = NUM2LL(contentV);
+    // printf("value->data_int=%lld\n",value->data_int);
     /* Returns the C value embedded into a ruby VALUE. */
     VALUE res;
     rcsim_to_value(ValueS,value,res);
@@ -594,6 +605,7 @@ VALUE rcsim_make_cast(VALUE mod, VALUE type, VALUE child) {
     // printf("cast=%p\n",cast);
     /* Set it up. */
     cast->kind = CAST;
+    cast->owner = NULL;
     value_to_rcsim(TypeS,type,cast->type);
     value_to_rcsim(ExpressionS,child,cast->child);
     /* Returns the C cast embedded into a ruby VALUE. */
@@ -610,6 +622,7 @@ VALUE rcsim_make_unary(VALUE mod, VALUE type, VALUE operator, VALUE child) {
     // printf("unary=%p\n",unary);
     /* Set it up. */
     unary->kind = UNARY;
+    unary->owner = NULL;
     value_to_rcsim(TypeS,type,unary->type);
     switch(sym_to_char(operator)) {
         case (unsigned char)'~':         unary->oper = not_value; break;
@@ -631,6 +644,7 @@ VALUE rcsim_make_binary(VALUE mod, VALUE type, VALUE operator, VALUE left, VALUE
     // printf("binary=%p\n",binary);
     /* Set it up. */
     binary->kind = BINARY;
+    binary->owner = NULL;
     value_to_rcsim(TypeS,type,binary->type);
     switch(sym_to_char(operator)) {
         case (unsigned char)'+':         binary->oper = add_value; break;
@@ -667,6 +681,7 @@ VALUE rcsim_make_select(VALUE mod, VALUE type, VALUE sel) {
     // printf("select=%p\n",select);
     /* Set it up. */
     select->kind = SELECT;
+    select->owner = NULL;
     value_to_rcsim(TypeS,type,select->type);
     value_to_rcsim(ExpressionS,sel,select->select);
     select->num_choices = 0;
@@ -685,6 +700,7 @@ VALUE rcsim_make_concat(VALUE mod, VALUE type, VALUE dirV) {
     // printf("concat=%p\n",concat);
     /* Set it up. */
     concat->kind = CONCAT;
+    concat->owner = NULL;
     value_to_rcsim(TypeS,type,concat->type);
     concat->num_exprs = 0;
     concat->exprs = NULL;
@@ -703,6 +719,7 @@ VALUE rcsim_make_refConcat(VALUE mod, VALUE type, VALUE dirV) {
     // printf("refConcat=%p\n",refConcat);
     /* Set it up. */
     refConcat->kind = REF_CONCAT;
+    refConcat->owner = NULL;
     value_to_rcsim(TypeS,type,refConcat->type);
     refConcat->num_refs = 0;
     refConcat->refs = NULL;
@@ -721,6 +738,7 @@ VALUE rcsim_make_refIndex(VALUE mod, VALUE type, VALUE index, VALUE ref) {
     // printf("refIndex=%p\n",refIndex);
     /* Set it up. */
     refIndex->kind = REF_INDEX;
+    refIndex->owner = NULL;
     value_to_rcsim(TypeS,type,refIndex->type);
     value_to_rcsim(ExpressionS,index,refIndex->index);
     value_to_rcsim(ReferenceS,ref,refIndex->ref);
@@ -738,6 +756,7 @@ VALUE rcsim_make_refRange(VALUE mod, VALUE type, VALUE first, VALUE last, VALUE
     // printf("refRange=%p\n",refRange);
     /* Set it up. */
     refRange->kind = REF_RANGE;
+    refRange->owner = NULL;
     value_to_rcsim(TypeS,type,refRange->type);
     value_to_rcsim(ExpressionS,first,refRange->first);
     value_to_rcsim(ExpressionS,last,refRange->last);
@@ -757,6 +776,7 @@ VALUE rcsim_make_stringE(VALUE mod, VALUE strV) {
     // printf("stringE=%p\n",stringE);
     /* Set it up. */
     stringE->kind = STRINGE;
+    stringE->owner = NULL;
     stringE->str   = strdup(StringValueCStr(strV));
     /* Returns the C character string embedded into a ruby VALUE. */
     VALUE res;
@@ -780,8 +800,8 @@ VALUE rcsim_add_systemT_inputs(VALUE mod, VALUE systemTV, VALUE sigVs) {
     // 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]));
+    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. */
@@ -807,8 +827,8 @@ VALUE rcsim_add_systemT_outputs(VALUE mod, VALUE systemTV, VALUE sigVs) {
     // 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]));
+    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. */
@@ -834,8 +854,8 @@ VALUE rcsim_add_systemT_inouts(VALUE mod, VALUE systemTV, VALUE sigVs) {
     // 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]));
+    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. */
@@ -861,8 +881,8 @@ VALUE rcsim_add_scope_inners(VALUE mod, VALUE scopeV, VALUE sigVs) {
     // 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]));
+    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. */
@@ -891,8 +911,8 @@ VALUE rcsim_add_scope_behaviors(VALUE mod, VALUE scopeV, VALUE behVs) {
     // 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]));
+    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. */
@@ -918,8 +938,8 @@ VALUE rcsim_add_scope_systemIs(VALUE mod, VALUE scopeV, VALUE sysVs) {
     // 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]));
+    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. */
@@ -945,8 +965,8 @@ VALUE rcsim_add_scope_scopes(VALUE mod, VALUE scopeV, VALUE scpVs) {
     // 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]));
+    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. */
@@ -972,8 +992,8 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
     // 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]));
+    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. */
@@ -989,7 +1009,8 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
                 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]));
+                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);
@@ -1000,7 +1021,8 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
                 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]));
+                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);
@@ -1011,7 +1033,8 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
                 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]));
+                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);
@@ -1038,8 +1061,8 @@ VALUE rcsim_add_systemI_systemTs(VALUE mod, VALUE systemIV, VALUE sysVs) {
     // 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]));
+    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. */
@@ -1065,8 +1088,8 @@ VALUE rcsim_add_print_args(VALUE mod, VALUE printV, VALUE argVs) {
     // 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]));
+    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. */
@@ -1092,11 +1115,13 @@ VALUE rcsim_add_hif_noifs(VALUE mod, VALUE hifV, VALUE condVs, VALUE stmntVs) {
     // 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]));
+    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 = my_realloc(hif->nostmnts,sizeof(Statement[old_num]),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. */
@@ -1127,14 +1152,14 @@ VALUE rcsim_add_hcase_whens(VALUE mod, VALUE hcaseV, VALUE matchVs, VALUE stmntV
     // 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]));
+    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 = my_realloc(hcase->stmnts,sizeof(Statement[old_num]),
-                            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. */
@@ -1164,8 +1189,8 @@ VALUE rcsim_add_block_inners(VALUE mod, VALUE blockV, VALUE sigVs) {
     // 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]));
+    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. */
@@ -1191,8 +1216,8 @@ VALUE rcsim_add_block_statements(VALUE mod, VALUE blockV, VALUE stmntVs) {
     // 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]));
+    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. */
@@ -1218,8 +1243,8 @@ VALUE rcsim_add_select_choices(VALUE mod, VALUE selectV, VALUE choiceVs) {
     // 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]));
+    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. */
@@ -1246,8 +1271,8 @@ VALUE rcsim_add_concat_expressions(VALUE mod, VALUE concatV, VALUE exprVs) {
     // 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]));
+    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. */
@@ -1273,8 +1298,8 @@ VALUE rcsim_add_refConcat_refs(VALUE mod, VALUE refConcatV, VALUE refVs) {
     // 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]));
+    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. */
@@ -1283,6 +1308,7 @@ VALUE rcsim_add_refConcat_refs(VALUE mod, VALUE refConcatV, VALUE refVs) {
         // show_access(refConcat->refs,old_num+i);
         value_to_rcsim(ReferenceS,rb_ary_entry(refVs,i),ref);
         refConcat->refs[old_num + i] = ref;
+        // printf("ref=%p ref &type=%p type=%p width=%llu\n",ref,&(ref->type),ref->type,type_width(ref->type));
     }
     return refConcatV;
 }
@@ -1339,11 +1365,11 @@ VALUE rcsim_set_signal_value(VALUE mod, VALUE signalV, VALUE exprV) {
     Expression expr;
     value_to_rcsim(ExpressionS,exprV,expr);
     /* Compute the value from it. */
-    // Value value = calc_expression(expr);
     Value value = get_value();
     value = calc_expression(expr,value);
     /* Copies the value. */
     signal->f_value = copy_value(value,signal->f_value);
+    signal->c_value = copy_value(value,signal->c_value);
     free_value();
     return signalV;
 }
@@ -1352,8 +1378,11 @@ VALUE rcsim_set_signal_value(VALUE mod, VALUE signalV, VALUE exprV) {
 /** Starts the C-Ruby hybrid simulation.
  *  @param systemTV the top system type. 
  *  @param name the name of the simulation.
- *  @param vcd tells if the vcd generation is used or not. */
-VALUE rcsim_main(VALUE mod, VALUE systemTV, VALUE name, VALUE vcd) {
+ *  @param outmode tells which output mode is used:
+ *         0: standard
+ *         1: mute
+ *         2: vcd */
+VALUE rcsim_main(VALUE mod, VALUE systemTV, VALUE name, VALUE outmodeV) {
     /* Get the C system type from the Ruby value. */
     SystemT systemT;
     value_to_rcsim(SystemTS,systemTV,systemT);
@@ -1361,11 +1390,18 @@ VALUE rcsim_main(VALUE mod, VALUE systemTV, VALUE name, VALUE vcd) {
     top_system = systemT;
     /* Enable it. */
     set_enable_system(systemT,1);
+    /* Get the output mode. */
+    int outmode = NUM2INT(outmodeV);
     /* Starts the simulation. */
-    if (TYPE(vcd) == T_TRUE) 
-        hruby_sim_core(StringValueCStr(name),init_vcd_visualizer,-1);
-    else
-        hruby_sim_core(StringValueCStr(name),init_default_visualizer,-1);
+    switch(outmode) { 
+        case 0: hruby_sim_core(StringValueCStr(name),init_default_visualizer,-1);
+                break;
+        case 1: hruby_sim_core(StringValueCStr(name),init_mute_visualizer,-1);
+                break;
+        case 2: hruby_sim_core(StringValueCStr(name),init_vcd_visualizer,-1);
+                break;
+        default:hruby_sim_core(StringValueCStr(name),init_default_visualizer,-1);
+    }
     return systemTV;
 }
 
@@ -1409,7 +1445,7 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_make_binary",rcsim_make_binary,4);
     rb_define_singleton_method(mod,"rcsim_make_select",rcsim_make_select,2);
     rb_define_singleton_method(mod,"rcsim_make_concat",rcsim_make_concat,2);
-    rb_define_singleton_method(mod,"rcsim_make_refConcat",rcsim_make_refConcat,1);
+    rb_define_singleton_method(mod,"rcsim_make_refConcat",rcsim_make_refConcat,2);
     rb_define_singleton_method(mod,"rcsim_make_refIndex",rcsim_make_refIndex,3);
     rb_define_singleton_method(mod,"rcsim_make_refRange",rcsim_make_refRange,4);
     rb_define_singleton_method(mod,"rcsim_make_stringE",rcsim_make_stringE,1);