HDLRuby 3.1.0 → 3.3.0

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -6,9 +6,16 @@
 #include <string.h>
 #include <limits.h>
 
+#if defined(_WIN32) || defined(_WIN64)
+#include <windows.h>
+#include <direct.h>
+#else
+#include <dlfcn.h>
+#endif
+
 #include <ruby.h>
-#include "extconf.h"
 
+#include "extconf.h"
 #include "hruby_sim.h"
 
 // #if defined(_WIN32) || defined(_WIN64)
@@ -72,7 +79,10 @@
 // rcsim_wrapper(RefIndex);
 // rcsim_wrapper(RefRange);
 
-static VALUE RCSimPointer;
+static VALUE RCSimPointer;      // The C pointer type for Ruby.
+static VALUE RCSimCinterface;   // The RCSim Ruby module for C.
+static VALUE RCSimCports;       // The RCSim table of C ports.
+// static VALUE RubyHDL;           // The interface for Ruby programs.
 
 #define rcsim_to_value(TYPE,POINTER,VALUE) \
     (VALUE) = Data_Wrap_Struct(RCSimPointer, 0, 0, (POINTER))
@@ -376,6 +386,123 @@ VALUE rcsim_make_systemI(VALUE mod, VALUE name, VALUE systemT) {
 }
 
 
+void ruby_function_wrap(Code);
+
+/* Creating a system code C object. 
+ * Note: HDLRuby Code object are actually refactored to Program object,
+ *       but the low-level simulation still use Code as data structure.
+ *       Hence, it may change in the future. */
+VALUE rcsim_make_code(VALUE mod, VALUE lang, VALUE funcname) {
+    // printf("rcsim_make_code\n");
+    /* Allocates the code. */
+    Code code = (Code)malloc(sizeof(CodeS));
+    // printf("code=%p\n",code);
+    /* Set it up. */
+    code->kind  = CODE;
+    code->owner = NULL;
+    code->name = strdup(StringValueCStr(funcname));
+    // printf("code->name=%p\n",code->name);
+    code->num_events = 0;
+    code->events = NULL;
+    code->function = NULL;
+    char* langStr = StringValueCStr(lang);
+    if(strncmp(langStr,"ruby",4) == 0) {
+        /* Ruby function. */
+        code->function = ruby_function_wrap;
+    } else if (strncmp(langStr,"c",1) == 0) {
+        /* C or C-compatible dynamically compiled code: it will be loaded
+         * afterward */
+        code->function = NULL;
+    } else {
+        /* Other language function. */
+        fprintf(stderr,"Unsupported language.");
+        exit(-1);
+    }
+    code->enabled = 0;
+    code->activated = 0;
+    /* Returns the C code embedded into a ruby VALUE. */
+    VALUE res;
+    rcsim_to_value(CodeS,code,res);
+    return res;
+}
+
+
+
+
+#if defined(_WIN32) || defined(_WIN64)
+/** Loads a C program dynamic library (called from HDLRuby) for a code. */
+VALUE rcsim_load_c(VALUE mod, VALUE codeV, VALUE libnameV, VALUE funcnameV) {
+    char* libname;
+    char* funcname;
+    Code code;
+    HINSTANCE handle;
+
+    libname  = StringValueCStr(libnameV);
+    funcname = StringValueCStr(funcnameV);
+
+    char path[1024];
+
+    if (getcwd(path, sizeof(path)) != NULL) {
+        printf("Current working directory: %s\n", path);
+    } else {
+        perror("getcwd error");
+        return 1;
+    }
+
+    if(strlen(path) + strlen(libname) >= 1023) {
+        fprintf(stderr,"Path too long for loading c program.\n");
+    }
+    strcat(path,"/");
+    strcat(path,libname);
+    // printf("Loading c program at: %s\n",path);
+   
+    /* Get the code. */ 
+    value_to_rcsim(CodeS,codeV,code);
+    /* Load the library. */
+    handle = LoadLibrary(TEXT(path));
+    if (handle == NULL) {
+        fprintf(stderr,"Unable to open program library at: %s\n",path);
+        DWORD dwError = GetLastError();
+        fprintf(stderr,"LoadLibrary failed with error code %ld\n", dwError);
+        exit(-1);
+    }
+    code->function = GetProcAddress(handle,funcname);
+    if (code->function == NULL) {
+        fprintf(stderr,"Unable to get function: %s\n",code->name);
+        exit(-1);
+    }
+    return codeV;
+}
+#else
+/** Loads a C program dynamic library (called from HDLRuby) for a code. */
+VALUE rcsim_load_c(VALUE mod, VALUE codeV, VALUE libnameV, VALUE funcnameV) {
+    char* libname;
+    char* funcname;
+    Code code;
+    void* handle;
+
+    libname  = StringValueCStr(libnameV);
+    funcname = StringValueCStr(funcnameV);
+   
+    /* Get the code. */ 
+    value_to_rcsim(CodeS,codeV,code);
+    /* Load the library. */
+    handle = dlopen(libname,RTLD_NOW | RTLD_GLOBAL);
+    if (handle == NULL) {
+        fprintf(stderr,"Unable to open program: %s\n",dlerror());
+        exit(-1);
+    }
+    code->function = dlsym(handle,funcname);
+    if (code->function == NULL) {
+        fprintf(stderr,"Unable to get function: %s\n",code->name);
+        exit(-1);
+    }
+    return codeV;
+}
+#endif
+
+
+
 /* Creating a transmit C object. */
 VALUE rcsim_make_transmit(VALUE mod, VALUE left, VALUE right) {
     // printf("rcsim_make_transmit\n");
@@ -955,6 +1082,30 @@ VALUE rcsim_add_scope_systemIs(VALUE mod, VALUE scopeV, VALUE sysVs) {
     return scopeV;
 }
 
+/* Adds codes to a C scope. */
+VALUE rcsim_add_scope_codes(VALUE mod, VALUE scopeV, VALUE codeVs) {
+    /* Get the C scope from the Ruby value. */
+    Scope scope;
+    value_to_rcsim(ScopeS,scopeV,scope);
+    // printf("rcsim_add_scope_codes with scope=%p\n",scope);
+    /* Prepare the size for the codes. */
+    long num = RARRAY_LEN(codeVs);
+    long old_num = scope->num_codes;
+    scope->num_codes += num;
+    // printf("first scope->codes=%p\n",scope->codes); fflush(stdout);
+    scope->codes = realloc(scope->codes,
+                            sizeof(Code[scope->num_codes]));
+    // printf("now scope->codes=%p\n",scope->codes); fflush(stdout);
+    // printf("access test: %p\n",scope->codes[0]); fflush(stdout);
+    /* Get and add the codes from the Ruby value. */
+    for(long i=0; i< num; ++i) {
+        Code code;
+        value_to_rcsim(CodeS,rb_ary_entry(codeVs,i),code);
+        scope->codes[old_num + i] = code;
+    }
+    return scopeV;
+}
+
 /* Adds sub scopes to a C scope. */
 VALUE rcsim_add_scope_scopes(VALUE mod, VALUE scopeV, VALUE scpVs) {
     /* Get the C scope from the Ruby value. */
@@ -1051,6 +1202,53 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
     return behaviorV;
 }
 
+
+/* Adds events to a C code. */
+VALUE rcsim_add_code_events(VALUE mod, VALUE codeV, VALUE eventVs) {
+    /* Get the C code from the Ruby value. */
+    Code code;
+    value_to_rcsim(CodeS,codeV,code);
+    // printf("rcsim_add_codee_events with code=%p\n",code);
+    /* Prepare the size for the events. */
+    long num = RARRAY_LEN(eventVs);
+    long old_num = code->num_events;
+    code->num_events += num;
+    // printf("first code->events=%p\n",code->events); fflush(stdout);
+    code->events = realloc(code->events,
+                               sizeof(Event[code->num_events]));
+    // printf("now code->events=%p\n",code->events); fflush(stdout);
+    // printf("access test: %p\n",code->events[0]); fflush(stdout);
+    /* Get and add the events from the Ruby value. */
+    for(long i=0; i< num; ++i) {
+        Event event;
+        value_to_rcsim(EventS,rb_ary_entry(eventVs,i),event);
+        code->events[old_num + i] = event;
+        /* Update the signal of the event to say it activates the code. */
+        SignalI sig = event->signal;
+        switch(event->edge) {
+            case ANYEDGE:
+                sig->num_any++;
+                sig->any = realloc(sig->any,sizeof(Object[sig->num_any]));
+                sig->any[sig->num_any-1] = (Object)code;
+                break;
+            case POSEDGE:
+                sig->num_pos++;
+                sig->pos = realloc(sig->pos,sizeof(Object[sig->num_pos]));
+                sig->pos[sig->num_pos-1] = (Object)code;
+                break;
+            case NEGEDGE:
+                sig->num_neg++;
+                sig->neg = realloc(sig->neg,sizeof(Object[sig->num_neg]));
+                sig->neg[sig->num_neg-1] = (Object)code;
+                break;
+            default:
+                perror("Invalid value for an edge.");
+        }
+    }
+    return codeV;
+}
+
+
 /* Adds alternate system types to a C system instance. */
 VALUE rcsim_add_systemI_systemTs(VALUE mod, VALUE systemIV, VALUE sysVs) {
     /* Get the C systemI from the Ruby value. */
@@ -1381,7 +1579,10 @@ VALUE rcsim_set_behavior_block(VALUE mod, VALUE behaviorV, VALUE blockV) {
     return behaviorV;
 }
 
-/** Sets the value for a C signal. */
+/** Sets the value for a C signal.
+ *  NOTE: for initialization only (the simulator events are not updated),
+ *  otherwise, please use rcsim_transmit_to_signal or
+ *  rc_sim_transmit_to_signal_seq. */
 VALUE rcsim_set_signal_value(VALUE mod, VALUE signalV, VALUE exprV) {
     /* Get the C signal from the Ruby value. */
     SignalI signal;
@@ -1400,6 +1601,127 @@ VALUE rcsim_set_signal_value(VALUE mod, VALUE signalV, VALUE exprV) {
     return signalV;
 }
 
+/** Gets the value of a C signal. */
+VALUE rcsim_get_signal_value(VALUE mod, VALUE signalV) {
+    VALUE res;
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    // printf("rc_sim_get_signal_value for signal=%s\n",signal->name);
+    /* Returns the current value. */
+    rcsim_to_value(ValueS,signal->c_value,res);
+    return res; 
+}
+
+/** Transmit a value to a signal in a non-blocking fashion.
+ * NOTE: the simulator events are updated. */
+VALUE rcsim_transmit_to_signal(VALUE mod, VALUE signalV, VALUE exprV) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    // printf("rc_sim_set_signal_value for signal=%s\n",signal->name);
+    /* Get the C expression from the Ruby value. */
+    Expression expr;
+    value_to_rcsim(ExpressionS,exprV,expr);
+    /* Compute the value from it. */
+    Value value = get_value();
+    value = calc_expression(expr,value);
+    /* Transmit it. */
+    transmit_to_signal(value, signal);
+    /* End, return the transmitted expression. */
+    return exprV;
+}
+
+/** Transmit a value to a signal in a blocking fashion.
+ * NOTE: the simulator events are updated. */
+VALUE rcsim_transmit_to_signal_seq(VALUE mod, VALUE signalV, VALUE exprV) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    // printf("rc_sim_set_signal_value for signal=%s\n",signal->name);
+    /* Get the C expression from the Ruby value. */
+    Expression expr;
+    value_to_rcsim(ExpressionS,exprV,expr);
+    /* Compute the value from it. */
+    Value value = get_value();
+    value = calc_expression(expr,value);
+    /* Transmit it. */
+    transmit_to_signal_seq(value, signal);
+    /* End, return the transmitted expression. */
+    return exprV;
+}
+
+
+
+
+/** Gets the value of a C signal as a Ruby fixnum.
+ *  Sets 0 if the value contains x or z bits. */
+VALUE rcsim_get_signal_fixnum(VALUE mod, VALUE signalV) {
+    Value value;
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    // printf("rc_sim_get_signal_fixnum for signal=%s\n",signal->name);
+    /* Get the value from the signal. */
+    value = signal->c_value;
+    // /* Is the value a numeric? */
+    // if(value->numeric == 1) {
+    //     /* Yes, return it as a Ruby fixnum. */
+    //     return LONG2FIX(value->data_int);
+    // } else {
+    //     /* No, return 0. */
+    //     return LONG2FIX(0);
+    // }
+    return LONG2FIX(value2integer(value));
+}
+
+/** Transmit a Ruby fixnum to a signal in a non-blocking fashion.
+ * NOTE: the simulator events are updated. */
+VALUE rcsim_transmit_fixnum_to_signal(VALUE mod, VALUE signalV, VALUE valR) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    /* Compute the simualtion value from valR. */
+    Value value = get_value();
+    value->type = signal->type;
+    value->numeric = 1;
+    value->data_int = FIX2LONG(valR);
+    /* Transmit it. */
+    transmit_to_signal(value, signal);
+    /* End, return the transmitted expression. */
+    return valR;
+}
+
+/** Transmit a Ruby fixnum to a signal in a non-blocking fashion.
+ * NOTE: the simulator events are updated. */
+VALUE rcsim_transmit_fixnum_to_signal_seq(VALUE mod, VALUE signalV, VALUE valR) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    /* Compute the simualtion value from valR. */
+    Value value = get_value();
+    value->type = signal->type;
+    value->numeric = 1;
+    value->data_int = FIX2LONG(valR);
+    /* Transmit it. */
+    transmit_to_signal_seq(value, signal);
+    /* End, return the transmitted expression. */
+    return valR;
+}
+
+
+// /** Execute a behavior. */
+// VALUE rcsim_execute_behavior(VALUE mod, VALUE behaviorV) {
+//     /* Get the behavior. */
+//     Behavior behavior;
+//     value_to_rcsim(BehaviorS,behaviorV,behavior);
+//     /* Execute the behavior. */
+//     execute_statement((Statement)(behavior->block),0,behavior);
+//     /* Returns the behavior. */
+//     return behaviorV;
+// }
+
+
 
 /** Starts the C-Ruby hybrid simulation.
  *  @param systemTV the top system type. 
@@ -1432,6 +1754,67 @@ VALUE rcsim_main(VALUE mod, VALUE systemTV, VALUE name, VALUE outmodeV) {
 }
 
 
+/** The wrapper for calling Ruby functions from the simulator. */
+void ruby_function_wrap(Code code) {
+    /* Convert the C code object to a Ruby VALUE. */
+    VALUE codeR;
+    rcsim_to_value(CodeS,code,codeR);
+    /* Call the ruby function launcher. */
+    rb_funcall(rb_cObject,rb_intern(code->name),0,Qnil);
+}
+
+
+/** The C interface. */
+
+#if defined(_WIN32) || defined(_WIN64)
+__declspec(dllexport) SignalI c_get_port(char* name);
+__declspec(dllexport) unsigned long long c_read_port(SignalI port);
+__declspec(dllexport) unsigned long long c_write_port(SignalI port, unsigned long long val);
+#endif
+
+
+/** The wrapper for getting an interface port for C software. */
+SignalI c_get_port(char* name) {
+    /* Get the C signal as a value. */
+    VALUE sigV = rb_hash_aref(RCSimCports,ID2SYM(rb_intern(name)));
+    /* Was there a signal? */
+    if (!NIL_P(sigV)) {
+        /* Yes, return it. */
+        SignalI sig;
+        value_to_rcsim(SignalIS,sigV,sig);
+        return sig;
+    } else {
+        /* No return NULL. */
+        return NULL;
+    }
+}
+
+/** The wrapper for getting a value from a port. */
+unsigned long long c_read_port(SignalI port) {
+    Value val = port->c_value;
+    if (val->numeric == 1) {
+        /* There is a defined value, return it. */
+        return val->data_int;
+    } else {
+        /* The value is undefined, return 0. */
+        return 0;
+    }
+}
+
+/** The wrapper for setting a value to a port. */
+unsigned long long c_write_port(SignalI port, unsigned long long val) {
+    /* Generate the value. */
+    Value value = get_value();
+    value->numeric = 1;
+    value->data_int = val;
+    /* Transmit it. */
+    transmit_to_signal_seq(value, port);
+    /* Returns the transmitted value. */
+    return val;
+}
+
+
+/* The simulator creation. */
 
 
 /** The initialization of the C-part of the C-Ruby hybrid HDLRuby simulator. */
@@ -1440,9 +1823,17 @@ void Init_hruby_sim() {
     make_sym_IDs();
     /* Create the module for C-Ruby interface. */
     VALUE mod = rb_define_module("RCSimCinterface");
+    RCSimCinterface = mod;
+
+    /* Create the table of C ports and add it to the C-Ruby interface. */
+    RCSimCports = rb_hash_new();
+    rb_define_const(mod,"CPorts",RCSimCports);
+
 
     /* Create the class that wraps C pointers. */
     RCSimPointer = rb_define_class("RCSimPointer",rb_cObject);
+    /* No allocator for C pointers. */
+    rb_undef_alloc_func(RCSimPointer);
 
     /* Add the interface methods. */
     /* Getting the C simulation type objects. */
@@ -1456,6 +1847,8 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_make_event",rcsim_make_event,2);
     rb_define_singleton_method(mod,"rcsim_make_signal",rcsim_make_signal,2);
     rb_define_singleton_method(mod,"rcsim_make_systemI",rcsim_make_systemI,2);
+    rb_define_singleton_method(mod,"rcsim_make_code",rcsim_make_code,2);
+    rb_define_singleton_method(mod,"rcsim_load_c",rcsim_load_c,3);
     rb_define_singleton_method(mod,"rcsim_make_transmit",rcsim_make_transmit,2);
     rb_define_singleton_method(mod,"rcsim_make_print",rcsim_make_print,0);
     rb_define_singleton_method(mod,"rcsim_make_timeWait",rcsim_make_timeWait,2);
@@ -1482,8 +1875,10 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_add_scope_inners",rcsim_add_scope_inners,2);
     rb_define_singleton_method(mod,"rcsim_add_scope_behaviors",rcsim_add_scope_behaviors,2);
     rb_define_singleton_method(mod,"rcsim_add_scope_systemIs",rcsim_add_scope_systemIs,2);
+    rb_define_singleton_method(mod,"rcsim_add_scope_codes",rcsim_add_scope_codes,2);
     rb_define_singleton_method(mod,"rcsim_add_scope_scopes",rcsim_add_scope_scopes,2);
     rb_define_singleton_method(mod,"rcsim_add_behavior_events",rcsim_add_behavior_events,2);
+    rb_define_singleton_method(mod,"rcsim_add_code_events",rcsim_add_code_events,2);
     rb_define_singleton_method(mod,"rcsim_add_systemI_systemTs",rcsim_add_systemI_systemTs,2);
     rb_define_singleton_method(mod,"rcsim_add_signal_signals",rcsim_add_signal_signals,2);
     rb_define_singleton_method(mod,"rcsim_add_print_args",rcsim_add_print_args,2);
@@ -1501,6 +1896,10 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_set_signal_value",rcsim_set_signal_value,2);
     /* Starting the simulation. */
     rb_define_singleton_method(mod,"rcsim_main",rcsim_main,3);
+    /* The Ruby software interface. */
+    rb_define_singleton_method(mod,"rcsim_get_signal_fixnum",rcsim_get_signal_fixnum,1);
+    rb_define_singleton_method(mod,"rcsim_transmit_fixnum_to_signal_seq",rcsim_transmit_fixnum_to_signal_seq,2);
+    // rb_define_singleton_method(mod,"rcsim_execute_behavior",rcsim_execute_behavior,1);
 
 }
 

data/ext/hruby_sim/hruby_sim.h

@@ -605,9 +605,10 @@ typedef struct CodeS_ {
     Kind kind;          /* The kind of object. */
     Object owner;       /* The owner if any. */
 
+    char* name;         /* The name of the called function. */
     int num_events;     /* The number of events. */
     Event* events;      /* The events of the behavior. */
-    void (*function)(); /* The function to execute for the code. */
+    void (*function)(Code); /* The function to execute for the code. */
 
     int enabled;        /* Tells if the behavior is enabled or not. */
 

data/ext/hruby_sim/hruby_sim_calc.c

@@ -50,6 +50,12 @@
 //     ({ __typeof__ (v) _v = (v); \
 //        _v->type->flags.sign ? (_v->data[_v->size-1] >> (INT_BIT-1)) ?  UINT_MAX : 0 : 0; })
 
+/** Fix the sign of a numeric value. */
+#define fix_numeric_sign(v) \
+    ({if ((v)->type->flags.sign && (type_width((v)->type) < 64) && ((v)->data_int & (1ULL << (type_width((v)->type)-1)))) {\
+        (v)->data_int |= (-1LL) << type_width((v)->type);\
+    }})
+
 /* The type engine: each type is simplified to a vector of X elements
  * of Y bits. */
 
@@ -231,7 +237,7 @@ Value make_value(Type type, int numeric) {
 /** Make the size of a value able to store size ints.
  *  @note The content of the value is lost!
  *  @note do not change the type of the value, only its capacity.
- *  @praam value the value to change
+ *  @param value the value to change
  *  @param size the size to match */
 void resize_value(Value value, unsigned long long size) {
     if (value->capacity < size) {
@@ -900,6 +906,7 @@ static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value
     /* Converts the values to integers. */
     unsigned long long src0i = value2integer(src0);
     unsigned long long src1i = value2integer(src1);
+    // printf("src0i=%lld src1i=%lld, src0i.sign=%d src0i.width=%d, src1i.sign=%d src1i.width=%d\n",src0i,src1i,src0->type->flags.sign,type_width(src0->type),src1->type->flags.sign,type_width(src1->type));
     /* Perform the comparison. */
     if (src0->type->flags.sign) {
         if (src1->type->flags.sign)
@@ -1275,7 +1282,7 @@ static Value shift_left_value_bitstring_numeric(Value src0, Value src1, Value ds
         char d0 = src0_data[count];
         /* Set it to the destination at the right place. */
         unsigned long long pos = count + sh;
-        if ((pos>0) && (pos<width0)) {
+        if ((pos>=0) && (pos<width0)) {
             dst_data[pos] = d0;
         }
     }
@@ -1290,6 +1297,7 @@ static Value shift_left_value_bitstring_numeric(Value src0, Value src1, Value ds
  *  @param dst the destination
  *  @return dst */
 static Value shift_right_value_bitstring_numeric(Value src0, Value src1, Value dst) {
+    // printf("shift_right_value_bitstring_numeric with src0=%s src1=%lld\n",src0->data_str,src1->data_int);
     unsigned long long count;
     /* Get the widths of the first source. */
     unsigned long long width0 = type_width(src0->type);
@@ -1319,10 +1327,11 @@ static Value shift_right_value_bitstring_numeric(Value src0, Value src1, Value d
         char d0 = src0_data[count];
         /* Set it to the destination at the right place. */
         unsigned long long pos = count + sh;
-        if ((pos>0) && (pos<width0)) {
+        if ((pos>=0) && (pos<width0)) {
             dst_data[pos] = d0;
         }
     }
+    // printf("result=%s\n",dst_data);
     /* Return the destination value. */
     return dst;
 }
@@ -1683,6 +1692,7 @@ Value read_range_bitstring(Value src,
         unsigned long long first, unsigned long long last,
         Type base, Value dst) {
     // printf("read_range_bitstring with first=%lld last=%lld src=%s\n",first,last,src->data_str);
+    // printf("read_range_bitstring with first=%lld last=%lld\n",first,last);
     /* Ensure first is the smaller. */
     if (first > last) {
         long long tmp = last;
@@ -1705,6 +1715,7 @@ Value read_range_bitstring(Value src,
 
     /* Performs the read. */
     memcpy(dst->data_str,src->data_str + first, length);
+    // printf("result: %s\n",dst->data_str);
 
     /* Return the destination. */
     return dst;
@@ -1888,9 +1899,15 @@ static Value mul_value_numeric(Value src0, Value src1, Value dst) {
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
+    /* Fix the numeric signs since multiply is sensitive to it. */
+    // printf("src0 type_width=%d src1 type_width=%d (%d)\n",type_width(src0->type),type_width(src1->type),src1->type->flags.sign);
+    fix_numeric_sign(src0);
+    fix_numeric_sign(src1);
+    // printf("Then src0->data_int=%llx src1->data_int=%llx\n",src0->data_int,src1->data_int);
 
     /* Perform the multiplication. */
     dst->data_int = fix_numeric_type(dst->type, src0->data_int * src1->data_int);
+    // printf("result=%llx\n",dst->data_int);
     return dst;
 }
 
@@ -1905,6 +1922,10 @@ static Value div_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
+    /* Fix the numeric signs since multiply is sensitive to it. */
+    fix_numeric_sign(src0);
+    fix_numeric_sign(src1);
+
     /* Perform the division. */
     dst->data_int = fix_numeric_type(dst->type, src0->data_int / src1->data_int);
     return dst;
@@ -3347,13 +3368,20 @@ RefRangeS make_ref_rangeS(SignalI signal, Type typ,
  *  @param value the value to convert
  *  @return the resulting int. */
 unsigned long long value2integer(Value value) {
+    // printf("value2integer\n");
     unsigned long long width = type_width(value->type);
-    /* If the value is numeric, just return its data as is. */
+    /* If the value is numeric, return it with its sign propoerly extended*/
     if (value->numeric) {
         // printf("width=%llu\n",width);
         if (width == 64)
+            /* Nothing to do. */
             return value->data_int;
+        else if (value->type->flags.sign &&
+                ((value->data_int >> (width-1))&1))
+            /* Sign extension. */
+            return value->data_int | (0xFFFFFFFFFFFFFFFFULL << width);
         else
+            /* Zero extension. */
             return value->data_int & ~(0xFFFFFFFFFFFFFFFFULL << width);
     }
     /* Otherwise convert the bitstring to an integer if possible,
@@ -3377,11 +3405,10 @@ unsigned long long value2integer(Value value) {
         res = (res << 1) | bit;
     }
     // printf("first res=%llx\n",res);
-    unsigned long long bit0 = (data_str[width-1]-'0') << i;
     /* Perform the sign extension if required. */
-    if (i>=width && value->type->flags.sign) {
+    if (value->type->flags.sign) {
+        unsigned long long bit0 = (data_str[width-1]-'0') << i;
         for(; i<LONG_LONG_BIT; ++i) {
-            // res = (res << 1) | bit;
             res |= bit0;
             bit0 <<= 1;
         }

data/ext/hruby_sim/hruby_sim_core.c

@@ -331,7 +331,8 @@ void hruby_sim_update_signals() {
                 /* Is the code really activated? */
                 if (cod->enabled && cod->activated) {
                     /* Yes, execute it. */
-                    cod->function();
+                    // cod->function();
+                    cod->function(cod); // NOTE: cod argument is required for identification.
                     /* And deactivate it. */
                     cod->activated = 0;
                 }
@@ -368,15 +369,24 @@ void hruby_sim_advance_time() {
  *  @param status the enable status. */
 static void set_enable_scope(Scope scope, int status) {
     int i;
-    int num_beh = scope->num_behaviors;
-    Behavior*  behs = scope->behaviors;
-    int num_scp = scope->num_scopes;
-    Scope* scps = scope->scopes;
+
+    int num_beh    = scope->num_behaviors;
+    Behavior* behs = scope->behaviors;
+
+    int num_cod    = scope->num_codes;
+    Code* cods     = scope->codes;
+    
+    int num_scp    = scope->num_scopes;
+    Scope* scps    = scope->scopes;
 
     /* Enable the behaviors. */
     for(i=0; i<num_beh; ++i) {
         behs[i]->enabled = status;
     }
+    /* Enable the codes. */
+    for(i=0; i<num_cod; ++i) {
+        cods[i]->enabled = status;
+    }
 
     /* Recurse on the sub scopes. */
     for(i=0; i<num_scp; ++i) {