HDLRuby 2.10.5 → 2.11.2

data/{lib/HDLRuby/sim → ext/hruby_sim}/hruby_sim_core.c

@@ -67,6 +67,7 @@ static int sim_end_flag = 0;
 /** Adds a timed behavior for processing. 
  *  @param behavior the timed behavior to register */
 void register_timed_behavior(Behavior behavior) {
+    // printf("Registering timed behavior=%p\n",behavior);fflush(stdout);
     if (num_timed_behaviors == cap_timed_behaviors) {
         if (cap_timed_behaviors == 0) {
             /* Need to create the array containing the timed behaviors. */
@@ -75,7 +76,8 @@ void register_timed_behavior(Behavior behavior) {
         } else {
             /* Need to increase the capacity. */
             Behavior* behaviors = calloc(sizeof(Behavior),cap_timed_behaviors*2);
-            memcpy(timed_behaviors,behaviors,sizeof(Behavior)*cap_timed_behaviors);
+            memcpy(behaviors,timed_behaviors,sizeof(Behavior)*cap_timed_behaviors);
+            timed_behaviors = behaviors;
             cap_timed_behaviors *= 2;
         }
     }
@@ -100,7 +102,7 @@ void register_signal(SignalI signal) {
             all_signals=new_signals;
         }
     }
-    /* Add the behavior. */
+    /* Add the signal. */
     all_signals[num_all_signals++] = signal;
 }
 
@@ -108,15 +110,16 @@ void register_signal(SignalI signal) {
 /** Recursively update the signals until no (untimed) behavior are
  *  activated. */
 void hruby_sim_update_signals() {
-     // printf("hruby_sim_update_signals...\n");
+    // printf("hruby_sim_update_signals...\n");fflush(stdout);
     /* As long as the list of touched signals is not empty go on computing. */
     while(!empty_list(touched_signals) || !empty_list(touched_signals_seq)) {
-        // printf("## Checking touched signals.\n");
+        // printf("## Checking touched signals.\n");fflush(stdout);
         /* Sets the new signals values and mark the signals as activating. */
         /* For the case of the parallel execution model. */
         while(!empty_list(touched_signals)) {
             Elem e = remove_list(touched_signals);
             SignalI sig = e->data;
+            // printf("sig=%p kind=%d\n",sig,sig->kind);fflush(stdout);
             delete_element(e);
             /* Is there a change? */
             if (same_content_value(sig->c_value,sig->f_value)) continue;
@@ -124,7 +127,7 @@ void hruby_sim_update_signals() {
             printer.print_signal(sig);
             // printf("c_value="); printer.print_value(sig->c_value);
             // printf("\nf_value="); printer.print_value(sig->f_value); printf("\n");
-            // printf("Touched signal: %p (%s)\n",sig,sig->name);
+            // printf("Touched signal: %p (%s)\n",sig,sig->name);fflush(stdout);
             /* Update the current value of the signal. */
             copy_value(sig->f_value,sig->c_value);
             // /* Mark the signal as activated. */
@@ -148,11 +151,13 @@ void hruby_sim_update_signals() {
             }
             /* Positive edge activation. */
             if (!zero_value(sig->c_value)) {
+                // printf("PAR: posedge for sig=%s with num_pos=%i\n",sig->name,sig->num_pos);
                 for(i=0; i<sig->num_pos; ++i) {
                     Object obj = sig->pos[i];
                     if (obj->kind == BEHAVIOR) {
                         /* Behavior case. */
                         Behavior beh = (Behavior)obj;
+                        // printf("Activating beh=%p.\n",beh);
                         beh->activated = 1;
                         add_list(activate_codes,get_element(beh));
                     } else {
@@ -210,6 +215,7 @@ void hruby_sim_update_signals() {
             }
             /* Positive edge activation. */
             if (!zero_value(sig->c_value)) {
+                // printf("SEQ: posedge for sig=%s with num_pos=%i\n",sig->name,sig->num_pos);
                 for(i=0; i<sig->num_pos; ++i) {
                     Object obj = sig->pos[i];
                     if (obj->kind == BEHAVIOR) {
@@ -253,10 +259,17 @@ void hruby_sim_update_signals() {
             if (obj->kind == BEHAVIOR) {
                 /* Behavior case. */
                 Behavior beh = (Behavior)obj;
+                // printf("beh=%p\n",beh);
                 /* Is the code really enabled and activated? */
                 if (beh->enabled && beh->activated) {
                     /* Yes, execute it. */
+#ifdef RCSIM
+                    // printf("going to execute with beh=%p\n",beh);
+                    // printf("going to execute: %p with kind=%d\n",beh->block,beh->block->kind);
+                    execute_statement((Statement)(beh->block),0,beh);
+#else
                     beh->block->function();
+#endif
                     /* And deactivate it. */
                     beh->activated = 0;
                 }
@@ -284,9 +297,11 @@ void hruby_sim_advance_time() {
     int i;
     for(i=0; i<num_timed_behaviors; ++i) {
         unsigned long long beh_time = timed_behaviors[i]->active_time;
+        // printf("beh_time=%llu\n",beh_time);
         if (timed_behaviors[i]->timed == 1)
             if (beh_time < next_time) next_time = beh_time;
     }
+    // printf("hruby_sim_time=%llu next_time=%llu\n",hruby_sim_time,next_time);
     /* Sets the new activation time. */
     hruby_sim_time = next_time;
     // println_time(hruby_sim_time);
@@ -294,7 +309,7 @@ void hruby_sim_advance_time() {
 }
 
 
-/** Sets the enamble status of the behaviors of a scope.
+/** Sets the enable status of the behaviors of a scope.
  *  @param scope the scope to process.
  *  @param status the enable status. */
 static void set_enable_scope(Scope scope, int status) {
@@ -334,7 +349,6 @@ void activate_behavior(Behavior behavior) {
   * time. */
 void hruby_sim_activate_behaviors_on_time() {
     int i;
-    // printf("$1\n");
     pthread_mutex_lock(&hruby_sim_mutex); 
     /* Count the number of behaviors that will be activated. */
     for(i=0; i<num_timed_behaviors; ++i) {
@@ -349,7 +363,6 @@ void hruby_sim_activate_behaviors_on_time() {
     }
     /* Activate the behaviors .*/
     behaviors_can_run = 1;
-    // printf("$2\n");
     // pthread_cond_signal(&compute_cond); /* No behaviors. */
     // pthread_cond_signal(&hruby_beh_cond); 
     pthread_mutex_unlock(&hruby_sim_mutex);
@@ -361,14 +374,12 @@ void hruby_sim_activate_behaviors_on_time() {
 void hruby_sim_wait_behaviors() {
     pthread_mutex_lock(&hruby_sim_mutex);
     while(num_active_behaviors > 0) {
-        // printf("$3\n");
         // printf("num_active_behaviors = %d\n",num_active_behaviors);
         // pthread_cond_wait(&active_behaviors_cond, &hruby_sim_mutex);
         pthread_cond_wait(&hruby_sim_cond, &hruby_sim_mutex);
     }
     behaviors_can_run = 0;
     pthread_mutex_unlock(&hruby_sim_mutex);
-    // printf("$4\n");
 }
 
 
@@ -377,7 +388,6 @@ void hruby_sim_wait_behaviors() {
 void* behavior_run(void* arg) {
     Behavior behavior = (Behavior)arg;
     /* First lock the behavior until the simulation engine starts. */
-    // printf("#1\n");
     pthread_mutex_lock(&hruby_sim_mutex);
     num_active_behaviors -= 1;
     while(!behaviors_can_run) {
@@ -386,11 +396,16 @@ void* behavior_run(void* arg) {
         pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
     }
     pthread_mutex_unlock(&hruby_sim_mutex);
-    // printf("#2\n");
     /* Now can start the execution of the behavior. */
-    if (behavior->enabled)
+    if (behavior->enabled) {
+#ifdef RCSIM
+        // printf("going to execute with behavior=%p\n",behavior);
+        // printf("going to execute: %p with kind=%d\n",behavior->block,behavior->block->kind);
+        execute_statement((Statement)(behavior->block),0,behavior);
+#else
         behavior->block->function();
-    // printf("#3\n");
+#endif
+    }
     /* Now can start the execution of the behavior. */
     /* Stops the behavior. */
     pthread_mutex_lock(&hruby_sim_mutex);
@@ -410,6 +425,8 @@ void* behavior_run(void* arg) {
  *  @note create a thread per timed behavior. */
 void hruby_sim_start_timed_behaviors() {
     int i;
+    // printf("hruby_sim_start_timed_behaviors\n");fflush(stdout);
+    // printf("timed_behaviors=%p\n",timed_behaviors);fflush(stdout);
     pthread_mutex_lock(&hruby_sim_mutex);
     /* Sets the end flags to 0. */
     sim_end_flag = 0;
@@ -418,12 +435,11 @@ void hruby_sim_start_timed_behaviors() {
     /* Create and start the threads. */
     for(i=0; i<num_timed_behaviors; ++i) {
         num_run_behaviors += 1;
-        // ++num_active_behaviors;
-        // printf("0 num_run_behaviors = %d\n",num_run_behaviors);
         pthread_create(&timed_behaviors[i]->thread,NULL,
                        &behavior_run,timed_behaviors[i]);
     }
     pthread_mutex_unlock(&hruby_sim_mutex);
+    // exit(0);
 }
 
 /** Ends waiting all the threads properly terminates. */
@@ -474,6 +490,7 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
             /* Initially touch all the signals. */
             each_all_signal(&touch_signal);
         }
+        // printf("num_run_behavior=%d\n",num_run_behaviors);
         if (num_run_behaviors <= 0) break;
         /* Advance time to next timestep. */
         hruby_sim_advance_time();
@@ -499,7 +516,7 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
 
 
 /** Makes the behavior wait for a given time.
- *  @param delay the delay to wait in fs.
+ *  @param delay the delay to wait in ps.
  *  @param behavior the current behavior. */
 void hw_wait(unsigned long long delay, Behavior behavior) {
     /* Maybe the thread is to end immediatly. */
@@ -544,7 +561,6 @@ void touch_signal(SignalI signal) {
  *  @param value the value to transmit
  *  @param signal the signal to transmit the value to. */
 void transmit_to_signal(Value value, SignalI signal) {
-    // printf("Tansmit to signal: %s(%p) with fading=%d\n",signal->name,signal,signal->fading);
     /* Copy the content. */
     if (signal->fading)
         signal->f_value = copy_value(value,signal->f_value);
@@ -584,6 +600,7 @@ void transmit_to_signal_range(Value value, RefRangeS ref) {
  *  @param signal the signal to touch  */
 void touch_signal_seq(SignalI signal) {
     // printf("touching signal seq: %p\n",signal);
+    // printf("signal->c_value=%p\n",signal->c_value);
     /* Is there a difference between the present and future value? */ 
     if (same_content_value(signal->c_value,signal->f_value)) return;
     /* Yes, add the signal to the list of touched sequential ones and update
@@ -601,6 +618,7 @@ void touch_signal_seq(SignalI signal) {
  *  @param signal the signal to transmit the value to. */
 void transmit_to_signal_seq(Value value, SignalI signal) {
     // printf("Tansmit to signal seq: %s(%p)\n",signal->name,signal);
+    // printf("signal->f_value=%p\n",signal->f_value);
     /* Copy the content. */
     if (signal->fading)
         copy_value(value,signal->f_value);

data/{lib/HDLRuby/sim → ext/hruby_sim}/hruby_sim_stack_calc.c

@@ -1,3 +1,6 @@
+/* Not used for the C-Ruby hybrid simulator. */
+#ifndef RCSIM
+
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
@@ -5,7 +8,6 @@
 #include <limits.h>
 #include "hruby_sim.h"
 
-
 /**
  *  The HDLRuby simulation stack calculation engine, to be used with C code
  *  generated by hruby_low2c. 
@@ -248,3 +250,4 @@ void transmitR_seq(RefRangeS ref) {
     transmit_to_signal_range_seq(pop(),ref);
 }
 
+#endif

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -0,0 +1,375 @@
+/* Used by the C-Ruby hybrid simulator only. */
+#ifdef RCSIM
+
+#include "extconf.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include "hruby_sim.h"
+
+
+/**
+ *  The HDLRuby simulation tree-based calculation engine. 
+ **/
+
+
+
+/** Calculates a tree expression.
+ *  @param expr the expression to execute.
+ *  @param res the expression where to write the result. */
+Value calc_expression(Expression expr, Value res) {
+    // printf("calc_expression with kind=%d\n",expr->kind);
+    /* Depending on the kind of expression. */
+    switch(expr->kind) {
+        case VALUEE:
+            /* Assume it is a Value. */
+            // printf("value=%p type=%p\n",expr,((Value)expr)->type);
+            res = (Value)expr;
+            // res = copy_value((Value)expr,res);
+            break;
+        case UNARY:
+            {
+                Unary uexpr = (Unary)expr;
+                Value child = get_value();
+                child = calc_expression(uexpr->child,child);
+                res = uexpr->oper(child,res);
+                free_value();
+                break;
+            }
+        case BINARY:
+            {
+                Binary bexpr = (Binary)expr;
+                Value left = get_value();
+                Value right = get_value();
+                left = calc_expression(bexpr->left,left);
+                right = calc_expression(bexpr->right,right);
+                res = bexpr->oper(left,right,res);
+                free_value();
+                free_value();
+                break;
+            }
+        case CONCAT:
+            {
+                Concat cexpr = (Concat)expr;
+                /* Calculate the sub expressions. */
+                Value values[cexpr->num_exprs];
+                for(int i=0; i<cexpr->num_exprs; ++i) {
+                    values[i] = get_value();
+                    values[i] = calc_expression(cexpr->exprs[i],values[i]);
+                }
+                /* Use them for calculating the concat. */
+                res = concat_valueP(cexpr->num_exprs,cexpr->dir,res,values);
+                for(int i=0; i<cexpr->num_exprs; ++i) free_value();
+                break;
+            }
+        case CAST:
+            {
+                Cast cexpr = (Cast)expr;
+                Value child = get_value();
+                child = calc_expression(cexpr->child,child);
+                res = cast_value(child,cexpr->type,res);
+                free_value();
+                break;
+            }
+        case REF_OBJECT:
+            res = calc_expression((Expression)(((RefObject)expr)->object),res);
+            break;
+        case REF_INDEX:
+            {
+                RefIndex rexpr = (RefIndex)expr;
+                /* Compute the accessed value. */
+                Value value = get_value();
+                value = calc_expression((Expression)(rexpr->ref),value);
+                /* Compute the index. */
+                Value indexV = get_value();
+                indexV = calc_expression(rexpr->index,indexV);
+                /* Get its integer index. */
+                long long index = value2integer(indexV);
+                // printf("index=%llu\n",index);
+                free_value();
+                /* Performs the access. */
+                res = read_range(value,index,index,rexpr->type,res);
+                free_value();
+                break;
+            }
+        case REF_RANGE: 
+            {
+                RefRangeE rexpr = (RefRangeE)expr;
+                /* Compute the accessed value. */
+                Value value = get_value();
+                value = calc_expression((Expression)(rexpr->ref),value);
+                /* Compute the range. */
+                Value firstV = get_value();
+                firstV = calc_expression(rexpr->first,firstV);
+                Value lastV = get_value();
+                lastV = calc_expression(rexpr->last,lastV);
+                /* Get its integer range. */
+                long long first = value2integer(firstV);
+                long long last = value2integer(lastV);
+                free_value();
+                free_value();
+                // printf("first=%lli last=%lli\n",first,last);
+                /* Performs the access. */
+                TypeS base_type = { rexpr->type->base, 1, rexpr->type->flags };
+                res = read_range(value,first,last,&base_type,res);
+                free_value();
+                break;
+            }
+        case REF_CONCAT: 
+            {
+                RefConcat rexpr = (RefConcat)expr;
+                /* Process like a simple concat. */
+                /* Calculate the sub expressions. */
+                Value values[rexpr->num_refs];
+                for(int i=0; i<rexpr->num_refs; ++i) {
+                    values[i] = get_value();
+                    values[i] = calc_expression((Expression)(rexpr->refs[i]),values[i]);
+                }
+                /* Use them for calculating the concat. */
+                res = concat_valueP(rexpr->num_refs,rexpr->dir,res,values);
+                for(int i=0; i<rexpr->num_refs; ++i) free_value();
+                break;
+            }
+        case SIGNALI:
+            res = calc_expression((Expression)(((SignalI)expr)->c_value),res);
+            break;
+        default:
+            perror("Invalid expression kind.");
+            exit(1);
+            break;
+    }
+    return res;
+}
+
+
+
+/** Executes a statement.
+ *  @param stmnt the statement to execute.
+ *  @param mode blocking mode: 0: par, 1:seq
+ *  @param behavior the behavior in execution. */
+void execute_statement(Statement stmnt, int mode, Behavior behavior) {
+    /* Depending on the kind of statement. */
+    // printf("Executing statement=%p with kind=%d\n",stmnt,stmnt->kind);fflush(stdout);
+    switch(stmnt->kind) {
+        case TRANSMIT: 
+            {
+                Transmit trans = (Transmit)stmnt;
+                // printf("trans=%p trans->left=%p trans->left->kind=%d\n",trans,trans->left,trans->left->kind);
+                /* Compute the right value. */
+                // Value right = calc_expression(trans->right);
+                Value right = get_value();
+                right = calc_expression(trans->right,right);
+                /* Depending on the left value. */
+                switch (trans->left->kind) {
+                    case SIGNALI:
+                        // printf("left->name=%s\n",((SignalI)(trans->left))->name);
+                        fflush(stdout);
+                        /* Simple transmission. */
+                        if (mode)
+                            transmit_to_signal_seq(right,(SignalI)(trans->left));
+                        else 
+                            transmit_to_signal(right,(SignalI)(trans->left));
+                        break;
+                    case REF_INDEX:
+                        {
+                            /* Transmission to sub element. */
+                            RefIndex refi = (RefIndex)(trans->left);
+                            /* Compute the index. */
+                            // Value indexV = calc_expression(refi->index);
+                            Value indexV = get_value();
+                            indexV = calc_expression(refi->index,indexV);
+                            long long index = value2integer(indexV);
+                            free_value();
+                            /* Generate the reference inside the left value. */
+                            RefRangeS ref = 
+                                make_ref_rangeS((SignalI)(refi->ref),refi->type,
+                                    index,index);
+                            /* Perform the transmit. */
+                            if(mode)
+                                transmit_to_signal_range_seq(right,ref);
+                            else
+                                transmit_to_signal_range(right,ref);
+                            break;
+                        }
+                    case REF_RANGE: 
+                        {
+                            /* Transmission to range of sub elements. */
+                            RefRangeE refr = (RefRangeE)(trans->left);
+                            /* Compute the range. */
+                            // Value firstV = calc_expression(refr->first);
+                            Value firstV = get_value();
+                            firstV = calc_expression(refr->first,firstV);
+                            long long first = value2integer(firstV);
+                            free_value();
+                            // Value lastV = calc_expression(refr->last);
+                            Value lastV = get_value();
+                            lastV = calc_expression(refr->last,lastV);
+                            long long last = value2integer(lastV);
+                            free_value();
+                            /* Generate the reference inside the left value. */
+                            RefRangeS ref = 
+                                make_ref_rangeS((SignalI)(refr->ref),refr->type,
+                                    first,last);
+                            /* Perform the transmit. */
+                            if(mode)
+                                transmit_to_signal_range_seq(right,ref);
+                            else
+                                transmit_to_signal_range(right,ref);
+                            break;
+                        }
+                    case REF_CONCAT:
+                        {
+                            /* Transmit to each sub-reference. */
+                            RefConcat refc = (RefConcat)(trans->left);
+                            /* For that purpose use a temporary Transmit node. */
+                            TransmitS subtrans = { TRANSMIT, NULL, NULL };
+                            long long pos=0; /* The current position in the value
+                                                to assign */
+                            /* For each sub reference. */
+                            for(int i=0; i < refc->num_refs; ++i) {
+                                /* Set up the transmit. */
+                                subtrans.left = refc->refs[i];
+                                long long size = type_width(subtrans.left->type);
+                                subtrans.right = (Expression)get_value();
+                                subtrans.right = (Expression)read_range(
+                                        right,pos,pos+size-1,
+                                        get_type_bit(),(Value)(subtrans.right));
+                                /* Execute it. */
+                                execute_statement((Statement)&subtrans,
+                                        mode,behavior);
+                                /* Prepare the next step. */
+                                free_value();
+                                pos += size;
+                            }
+                        }
+                    default:
+                        perror("Invalid kind for a reference.");
+                }
+                break;
+            }
+        case PRINT:
+            {
+                Print prt = (Print)stmnt;
+                /* Prints each argument. */
+                for(int i=0; i<prt->num_args; ++i) {
+                    Expression arg=prt->args[i];
+                    switch(arg->kind) {
+                        case SYSTEMT:
+                        case SYSTEMI:
+                            printer.print_string_name((Object)arg);
+                            break;
+                        case STRINGE:
+                            printer.print_string(((StringE)arg)->str);
+                            break;
+                        default:
+                            {
+                                Value res = get_value();
+                                res = calc_expression(arg,res);
+                                printer.print_string_value(res);
+                                free_value();
+                            }
+                    }
+                }
+                break;
+            }
+        case HIF:
+            {
+                HIf hif = (HIf)stmnt;
+                /* Calculation the condition. */
+                // Value condition = calc_expression(hif->condition);
+                Value condition = get_value();
+                condition = calc_expression(hif->condition,condition);
+                /* Is it true? */
+                if (is_defined_value(condition) && value2integer(condition)) {
+                    /* Yes, execute the yes branch. */
+                    execute_statement(hif->yes,mode,behavior);
+                } else {
+                    /* No, maybe an alternate condition is met. */
+                    int met = 0;/* Tell if an alternate condition has been met.*/
+                    for(int i=0; i<hif->num_noifs; ++i) {
+                        // Value subcond = calc_expression(hif->noconds[i]);
+                        Value subcond = get_value();
+                        subcond = calc_expression(hif->noconds[i],subcond);
+                        if (is_defined_value(subcond) && value2integer(subcond)){
+                            /* The subcondition is met, execute the corresponding
+                             * substatement. */
+                            execute_statement(hif->nostmnts[i],mode,behavior);
+                            /* And remember it. */
+                            met = 1;
+                            free_value();
+                            break;
+                        }
+                        free_value();
+                    }
+                    /* Where there a sub condition met? */
+                    if (!met) {
+                        /* No, execute the no statement. */
+                        execute_statement(hif->no,mode,behavior);
+                    }
+                }
+                free_value();
+                break;
+            }
+        case HCASE:
+            {
+                HCase hcase = (HCase)stmnt;
+                /* Calculation the value to check. */
+                // Value value = calc_expression(hcase->value);
+                Value value = get_value();
+                value = calc_expression(hcase->value,value);
+                /* Tell if a case if matched. */
+                int met = 0;
+                /* Check each case. */
+                Value cmp = get_value();
+                for(int i=0; i<hcase->num_whens; ++i) {
+                    // cmp = equal_value_c(value,calc_expression(hcase->matches[i]),
+                    //         cmp);
+                    Value match = get_value();
+                    match = calc_expression(hcase->matches[i],match);
+                    cmp = equal_value_c(value,match,cmp);
+                    if (is_defined_value(cmp) && value2integer(cmp)) {
+                        /* Found the right case, execute the corresponding
+                         * statement. */
+                        execute_statement(hcase->stmnts[i],mode,behavior);
+                        /* And remeber it. */
+                        met = 1;
+                        free_value();
+                        break;
+                    }
+                    free_value();
+                }
+                free_value();
+                free_value();
+                /* Was no case found and is there a default statement? */
+                if (!met && hcase->defolt) {
+                    /* Yes, execute the default statement. */
+                    execute_statement(hcase->defolt,mode,behavior);
+                }
+                break;
+            }
+        case TIME_WAIT:
+            {
+                /* Get the value of the delay. */
+                long long delay = ((TimeWait)stmnt)->delay;
+                /* Wait the given delay. */
+                hw_wait(delay,behavior);
+                break;
+            }
+        case BLOCK:
+            {
+                Block block = (Block)stmnt;
+                /* Execute each statement of the block. */
+                for(int i=0; i<block->num_stmnts; ++i)
+                    execute_statement(block->stmnts[i],block->mode,behavior);
+                break;
+            }
+
+        default:
+            perror("Invalid kind for an expression."); 
+    }
+}
+
+#endif

data/{lib/HDLRuby/sim → ext/hruby_sim}/hruby_sim_vcd.c

@@ -22,7 +22,7 @@ static unsigned long long vcd_timeunit = 1;
 
 /** Prints to the vcd file.
  *  @param fmt the format for handling the variadic arguments. */
-static int vcd_print(char* fmt, ...) {
+static int vcd_print(const char* fmt, ...) {
     int ret;
 
     /* Declare a va_list type variable */
@@ -94,7 +94,7 @@ static void vcd_print_name(Object object) {
 }
 
 
-/** Prints the name of an object incluing its heirarchy.
+/** Prints the name of an object incluing its hierarchy.
  *  @param object the object to print the name. */
 static void vcd_print_full_name(Object object) {
     /* Recurse on the owner if any. */
@@ -119,8 +119,8 @@ static void vcd_print_value(Value value) {
         }
     } else {
         /* Display a bitstring value. */
-        int i;
-        int width = type_width(value->type);
+        unsigned long long i;
+        unsigned long long width = type_width(value->type);
         char* data = value->data_str;
         if (value->capacity == 0) {
             /* The value is empty, therefore undefined. */
@@ -289,7 +289,6 @@ static void vcd_print_systemT_content(SystemT system) {
 /** Prints the hierarchy of a system type.
  *  @param system the system to print. */
 static void vcd_print_systemT(SystemT system) {
-    int i;
     /* Declares the module. */
     vcd_print("$scope module ");
     vcd_print_name((Object)system);
@@ -346,6 +345,7 @@ static void vcd_print_header() {
 
     /* The declaration of the hierarchy and the variables
      * from the top system. */
+    // printf("top_system=%p\n",top_system);
     vcd_print_systemT(top_system);
     /* Ends the declarations. */
     vcd_print("$enddefinitions $end\n");