HDLRuby 2.11.4 → 2.11.7

data/ext/hruby_sim/hruby_sim.h

@@ -156,6 +156,7 @@ extern Type get_type_vector(Type base, unsigned long long number);
 typedef struct ValueS_ {
 #ifdef RCSIM
     Kind kind;                   /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
 #endif
     Type type;                   /* The type of the value. */
     int numeric;         /* Tell if the value is numeric or a bitstring. */
@@ -191,6 +192,12 @@ extern void set_value(Value value, int numeric, void* data);
  *  @param data the source data */
 extern Value make_set_value(Type type, int numeric, void* data);
 
+/** 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 size the size to match */
+extern void resize_value(Value value, unsigned long long size);
 
 /** Computes the neg of a value.
  *  @param src the source value of the neg
@@ -335,6 +342,7 @@ extern Value lesser_equal_value(Value src0, Value src1, Value dst);
  *  @param num    the number of values for the selection
  *  @return the selected value */
 extern Value select_value(Value cond, Value dst, unsigned int num, ...);
+extern Value select_valueP(Value cond, Value dst, unsigned int num, Value* values);
 
 /** Concat multiple values to a single one.
  *  @param num the number of values to concat
@@ -365,6 +373,7 @@ extern Value copy_value(Value src, Value dst);
  *  @return dst */
 extern Value copy_value_no_z(Value src, Value dst);
 
+
 /** Testing if a value is 0.
  *  @param value the value to check 
  *  @return 1 if 0 and 0 otherwize */
@@ -375,6 +384,11 @@ extern int zero_value(Value value);
  *  @return 1 if defined and 0 otherwize */
 extern int is_defined_value(Value value);
 
+/** Sets a value to undefined.
+ *  @param dst the destination value
+ *  @return the destination value */
+extern Value set_undefined_bitstring(Value dst);
+
 /** Testing if two values have the same content (the type is not checked).
  *  @param value0 the first value to compare
  *  @param value1 the second value to compare
@@ -510,9 +524,9 @@ typedef struct SystemTS_ {
 typedef struct SignalIS_ {
     Kind kind;          /* The kind of object. */
     Object owner;       /* The owner if any. */
+    Type  type;         /* The type of the signal. */
 
     char* name;         /* The name of the signal. */
-    Type  type;         /* The type of the signal. */
     Value c_value;      /* The current value of the signal. */
     Value f_value;      /* The future (next) value of the signal. */
 
@@ -524,6 +538,8 @@ typedef struct SignalIS_ {
     Object* pos;        /* The objects actvated on pos edge. */
     int num_neg;        /* The number of behavior activated on neg edge. */
     Object* neg;        /* The objects actvated on neg edge. */
+
+    size_t id;          /* The identity of the signal. */
 } SignalIS;
 
 
@@ -629,11 +645,14 @@ typedef struct EventS_ {
 /** The C model of a Statement. */
 typedef struct StatementS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
 } StatementS;
 
 /** The C model of a transmit statement. */
 typedef struct TransmitS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
+
     Reference left;     /* The left value. */
     Expression right;   /* The right value. */
 } TransmitS;
@@ -641,6 +660,8 @@ typedef struct TransmitS_ {
 /** The C model of a print statement. */
 typedef struct PrintS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
+
     int num_args;       /* The number of arguments of the print. */
     Expression* args;   /* The arguments of the print. */
 } PrintS;
@@ -648,6 +669,8 @@ typedef struct PrintS_ {
 /** The C model of a hardware if statement. */
 typedef struct HIfS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
+
     Expression condition; /* The condition. */
     Statement yes;      /* The statement executed if the condition is met. */
     int num_noifs;      /* The number of alternate conditions. */
@@ -659,6 +682,8 @@ typedef struct HIfS_ {
 /** The C model of a hardware case statement. */
 typedef struct HCaseS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
+
     Expression value;   /* The value to match. */
     int num_whens;      /* The number of possible cases. */
     Expression* matches;/* The cases matching values. */
@@ -669,6 +694,8 @@ typedef struct HCaseS_ {
 /** The C model of a time wait statement. */
 typedef struct TimeWaitS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
+
     // Expression delay;   /* The delay to wait in pico seconds. */
     unsigned long long delay; /* The delay to wait in pico seconds. */
 } TimeWaitS;
@@ -676,6 +703,8 @@ typedef struct TimeWaitS_ {
 /** The C model of a time repeat statement. */
 typedef struct TimeRepeatS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
+
     long long number;   /* The number of interations, negative means infinity. */
     Statement statement;/* The statement to execute in loop. */
 } TimeRepeatS;
@@ -683,19 +712,23 @@ typedef struct TimeRepeatS_ {
 /** The C model of a time terminate statement. */
 typedef struct TimeTerminateS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
 } TimeTerminateS;
 
 
 /** The C model of an expression. */
 typedef struct ExpressionS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the expression. */
 } ExpressionS;
 
 /** The C model of a unary expression. */
 typedef struct UnaryS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the expression. */
+
     Value (*oper)(Value,Value); /* The unary operator. */
     Expression child;   /* The child. */
 } UnaryS;
@@ -703,7 +736,9 @@ typedef struct UnaryS_ {
 /** The C model of a binary expression. */
 typedef struct BinaryS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the expression. */
+
     Value (*oper)(Value,Value,Value); /* The binary operator. */
     Expression left;    /* The left value. */
     Expression right;   /* The right value. */
@@ -712,7 +747,9 @@ typedef struct BinaryS_ {
 /** The C model of a select expression. */
 typedef struct SelectS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the expression. */
+
     Expression select;  /* The selection value. */
     int num_choices;    /* The number of choices. */
     Expression* choices;/* The choices. */
@@ -721,7 +758,9 @@ typedef struct SelectS_ {
 /** The C model of a concat expression. */
 typedef struct ConcatS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the expression. */
+
     int dir;            /* The direction of the concat. */
     int num_exprs;      /* The number of sub expressions. */
     Expression* exprs;  /* The sub expressions. */
@@ -730,7 +769,9 @@ typedef struct ConcatS_ {
 /** The C model of a cast expression. */
 typedef struct CastS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the expression. */
+
     Expression child;   /* The child expression. */
 } CastS;
 
@@ -738,20 +779,25 @@ typedef struct CastS_ {
 /** The C model of a reference. */
 typedef struct ReferenceS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the reference. */
 } ReferenceS;
 
 /** The C model of a reference to an object. */
 typedef struct RefObjectS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the reference. */
+
     Object object;      /* The refered object. */
 } RefObjectS;
 
 /** The C model of an index reference. */
 typedef struct RefIndexS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the reference. */
+
     Expression index;   /* The index. */
     Reference ref;      /* The reference to access. */
 } RefIndexS;
@@ -759,7 +805,9 @@ typedef struct RefIndexS_ {
 /** The C model of a range reference (expression version!). */
 typedef struct RefRangeES_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the reference. */
+
     Expression first;   /* The first of the range. */
     Expression last;    /* The last of the range. */
     Reference ref;      /* The reference to access. */
@@ -768,7 +816,9 @@ typedef struct RefRangeES_ {
 /** The C model of a concat reference. */
 typedef struct RefConcatS_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
     Type type;          /* The type of the reference. */
+
     int dir;            /* The direction of the concat. */
     int num_refs;       /* The number of sub references. */
     Reference* refs;    /* The sub references. */
@@ -777,6 +827,8 @@ typedef struct RefConcatS_ {
 /** The C model of a charcter string. */
 typedef struct StringES_ {
     Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
+
     char* str;          /* A pointer the to C character string. */
 } StringES;
 
@@ -795,6 +847,10 @@ extern SystemT top_system;
  *  @param behavior the timed behavior to register */
 extern void register_timed_behavior(Behavior behavior);
 
+/** Adds a behavior for initialization (not timed!).
+ *  @param beh the behavior to register. */
+extern void register_init_behavior(Behavior beh);
+
 /** Adds a signal for global processing. 
  *  @param signal the signal to register  */
 extern void register_signal(SignalI signal);
@@ -945,6 +1001,10 @@ extern void default_print_string(const char* str);
  *  @param name the name of the vizualization. */
 extern void init_default_visualizer(char* name);
 
+/** Sets up the mute vizualization engine.
+ *  @param name the name of the vizualization. */
+extern void init_mute_visualizer(char* name);
+
 /** Sets up the vcd vizualization engine.
  *  @param name the name of the vizualization. */
 extern void init_vcd_visualizer(char* name);
@@ -1047,6 +1107,12 @@ extern Value unary(Value (*oper)(Value,Value));
  **/
 extern Value binary(Value (*oper)(Value,Value,Value));
 
+/** Select calculation.
+ *  @param num the number of values to select from.
+ *  @return the destination.
+ **/
+extern Value select(unsigned int num);
+
 /** Cast calculation.
  *  @param typ the type to cast to.
  *  @return the destination.

data/ext/hruby_sim/hruby_sim_calc.c

@@ -315,7 +315,7 @@ Value copy_value(Value src, Value dst) {
         /* Numeric copy. */
         dst->data_int = fix_numeric_type(dst->type,src->data_int);
     } else {
-        // printf("copy_value with bit string: %s\n",src->data_str);
+        // printf("copy_value with bit string: %.*s\n",src->capacity,src->data_str);
         /* Resize the destination if required. */
         resize_value(dst,type_width(dst->type));
         /* Bitstring copy up to the end of dst or src. */
@@ -336,7 +336,7 @@ static Value set_numeric_value(Value src, Value dst);
  *  @param src the source value
  *  @param dst the destination value
  *  @return dst */
-extern Value copy_value_no_z(Value src, Value dst) {
+Value copy_value_no_z(Value src, Value dst) {
     /* set the status of the destination from the source. */
     // dst->type = src->type;
     /* Copy the data. */
@@ -432,7 +432,7 @@ static Value set_numeric_value(Value src, Value dst) {
 /** Sets a value to undefined.
  *  @param dst the destination value
  *  @return the destination value */
-static Value set_undefined_bitstring(Value dst) {
+Value set_undefined_bitstring(Value dst) {
     /* Compute the width of the result in bits. */
     unsigned long long width = type_width(dst->type);
 
@@ -481,13 +481,14 @@ static Value neg_value_bitstring(Value src, Value dst) {
         char d = src_data[count] - '0'; /* Get and convert to bit. */
         char res;
         if (d == (d&1)) { /* d is defined. */
+            d = 1-d;
             res = d ^ carry;
             carry = d & carry;
         } else {
             /* Undefined, end here. */
             break;
         }
-        dst_data[count] = res;
+        dst_data[count] = res + '0';
     }
     /* The remaining bits are undefined. */
     for(;count < width; ++count) {
@@ -508,6 +509,8 @@ static Value add_value_bitstring(Value src0, Value src1, Value dst) {
     unsigned long long width0 = type_width(src0->type);
     unsigned long long width1 = type_width(src1->type);
 
+    // printf("add_value_bitstring with width0=%llu width1=%llu\n",width0,width1);
+
     /* Update the destination capacity if required. */
     resize_value(dst,width0);
     /* Set the type and size of the destination from the type of the source.*/
@@ -645,13 +648,78 @@ static Value sub_value_bitstring(Value src0, Value src1, Value dst) {
  *  @return dst */
 static Value mul_value_defined_bitstring(Value src0, Value src1, Value dst) {
     // printf("mul_value_defined_bitstring with src0=%llx src1=%llx\n",value2integer(src0),value2integer(src1));
-    /* Sets state of the destination using the first source. */
-    dst->type = src0->type;
-    dst->numeric = 1;
+    /* Get the width of the sources. */
+    unsigned long long width0 = type_width(src0->type);
+    unsigned long long width1 = type_width(src1->type);
+    if (width0 <= 64 && width1 <= 64) {
+        /* Numeric computation is possible. */
+        /* Sets state of the destination using the first source. */
+        dst->type = src0->type;
+        dst->numeric = 1;
 
-    /* Perform the multiplication. */
-    dst->data_int = value2integer(src0) * value2integer(src1);
-    // printf("dst->data_int=%llx\n",dst->data_int);
+        /* Perform the multiplication. */
+        dst->data_int = value2integer(src0) * value2integer(src1);
+        // printf("dst->data_int=%llx\n",dst->data_int);
+    } else {
+        // printf("mul with width0=%llu width1=%llu\n",width0,width1);
+        // printf("src0->data_str=%s\n",src0->data_str);
+        // printf("src1->data_str=%s\n",src1->data_str);
+        /* Bit string computation. */
+        unsigned int pos = get_value_pos();
+        /* Process the sign. */
+        int sgn1 = (src1->type->flags.sign) && (src1->data_str[width1-1] == '1');
+        // printf("sgn0=%d sgn1=%d\n",(src0->type->flags.sign) && (src0->data_str[width0-1] == '1'),sgn1);
+        Value psrc1;
+        // printf("first scr1->data_str=%s\n",src1->data_str);fflush(stdout);
+        if (sgn1) {
+            psrc1 = neg_value_bitstring(src1,get_value());
+        } else {
+            psrc1 = src1;
+        }
+        // printf("now pscr1->data_str=%s\n",psrc1->data_str);fflush(stdout);
+        /* Perform the multiplying with sucessive shifts and additions. */
+        /* First the result is zero. */
+        const char* str = psrc1->data_str;
+        Value acc = get_value();
+        ValueS sh;
+        memcpy(&sh,src0,sizeof(ValueS));
+        // printf("sh width=%llu\n",type_width(sh.type));
+        // printf("sh.data_str=%s\n",sh.data_str); 
+        resize_value(acc,width0);
+        acc->numeric = 0;
+        acc->type = src0->type;
+        memset(acc->data_str,'0',width0);
+        // printf("first acc->data_str=%s\n",acc->data_str);fflush(stdout);
+        /* The multiply loop. */
+        unsigned long long i;
+        for(i=0; i<width1-1; ++i) {
+            unsigned long long j;
+            /* Add is bit is 1. */
+            if (str[i] == '1')
+                acc = add_value_bitstring(acc,&sh,get_value());
+            /* Shift. */
+            for(j=0; j<(width0-i-1); ++j) {
+                sh.data_str[width0-j-1] = sh.data_str[width0-j-2];
+            }
+            sh.data_str[width0-j-1] = '0';
+        }
+        /* Last addition. */
+        if (str[i] == '1')
+            acc = add_value_bitstring(acc,&sh,get_value());
+        /* Mange the sign of the result. */
+        // printf("before acc->data_str=%s\n",acc->data_str);fflush(stdout);
+        // printf("acc last bit=%d\n",acc->data_str[width0-1]);
+        if (sgn1) acc = neg_value_bitstring(acc,get_value());
+        // printf("finally acc->data_str=%s\n",acc->data_str);fflush(stdout);
+        // printf("acc last bit=%d\n",acc->data_str[width0-1]);
+        /* Save the result. */
+        dst = copy_value(acc,dst);
+        // printf("acc width=%llu acc->data_str=%p\n",type_width(acc->type),acc->data_str);
+        // printf("dst width=%llu dst->data_str=%p\n",type_width(dst->type),dst->data_str);
+        // printf("finally dst->data_str=%s\n",dst->data_str);fflush(stdout);
+        /* Restores the pool of values. */
+        set_value_pos(pos);
+    }
     return dst;
 }
 
@@ -1165,8 +1233,8 @@ static Value xor_value_bitstring(Value src0, Value src1, Value dst) {
 
 
 /** Computes the left shift of a bitstring value by a numeric value.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+ *  @param src0 the first source value of the shift
+ *  @param src1 the second source value of the shift
  *  @param dst the destination
  *  @return dst */
 static Value shift_left_value_bitstring_numeric(Value src0, Value src1, Value dst) {
@@ -1407,6 +1475,38 @@ static Value select_value_bitstring(Value cond, Value dst, unsigned int num,
     return dst;
 }
 
+/** Selects a value depending on a bitstring condition (pointer version).
+ *  @param cond   the condition to use for selecting a value
+ *  @param dst    the destination value (used only if new value is created).
+ *  @param num    the number of values for the selection
+ *  @param values the values to select from
+ *  @return the selected value */
+static Value select_value_bitstring_array(Value cond, Value dst,
+        unsigned int num, Value* values) 
+{
+    // printf("select_value_bitstring_array with cond=%s\n",cond->data_str);
+    /* Get the first alternative for sizing the result. */
+    Value src = values[0];
+    /* Compute the width of the result in bits. */
+    unsigned long long width = type_width(src->type);
+    // printf("select width=%llu\n",width);
+
+    /* Update the destination capacity if required. */
+    resize_value(dst,width);
+    /* Set the type and size of the destination from the type of the source.*/
+    dst->type = src->type;
+    dst->numeric = 0;
+    char *dst_data = dst->data_str;
+
+    /* Sets the destination as undefined. */
+    unsigned long long count;
+    for(count = 0; count < width; ++count) {
+        dst_data[count] = 'x';
+    }
+    /* Return the destination. */
+    return dst;
+}
+
 
 /** Concat multiple bitstring values to a single one.
  *  @param num the number of values to concat
@@ -1744,6 +1844,7 @@ static Value add_value_numeric(Value src0, Value src1, Value dst) {
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
+    // printf("add_value_numeric with width0=%llu width1=%llu\n",type_width(src0->type),type_width(src1->type));
 
     /* Perform the addition. */
     dst->data_int = fix_numeric_type(dst->type,src0->data_int + src1->data_int);
@@ -1773,7 +1874,7 @@ static Value sub_value_numeric(Value src0, Value src1, Value dst) {
  *  @param dst the destination value
  *  @return dst */
 static Value mul_value_numeric(Value src0, Value src1, Value dst) {
-    // printf("mul_value_numeric with src0->data_int=%llx src1->data_int=%llx\n",src0->data_int, src1->data_int);
+    printf("mul_value_numeric with src0->data_int=%llx src1->data_int=%llx\n",src0->data_int, src1->data_int);
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
@@ -1939,8 +2040,8 @@ static Value equal_value_numeric(Value src0, Value src1, Value dst) {
 
     /* Perform the comparison. */
     dst->data_int = (src0->data_int == src1->data_int) ? 1 : 0;
-    // printf("scr0->data_int=%lld\n",src0->data_int);
-    // printf("scr1->data_int=%lld\n",src1->data_int);
+    // printf("src0->data_int=%lld\n",src0->data_int);
+    // printf("src1->data_int=%lld\n",src1->data_int);
     // printf("dst->data_int=%lld\n",dst->data_int);
     return dst;
 }
@@ -2165,6 +2266,30 @@ static Value select_value_numeric(Value cond, Value dst, unsigned int num,
     return NULL;
 }
 
+/** Selects a value depending on a numeric condition (pointer version).
+ *  @param cond   the condition to use for selecting a value
+ *  @param dst    the destination value (used only if new value is created).
+ *  @param num    the number of values for the selection
+ *  @param values the values to select from.
+ *  @return the selected value */
+static Value select_value_numeric_array(Value cond, Value dst, unsigned int num,
+        Value* values) {
+    unsigned int i;
+    /* Select the value corresponding to the condition and copy it to
+     * the destination. */
+    for(i = 0; i<num;  ++i) {
+        Value value = values[i];
+        if (i == value2integer(cond)) {
+            /* The right value is reached, copy it. */
+            copy_value(value,dst);
+            return dst;
+        }
+    }
+    /* Should never be here. */
+    return NULL;
+}
+
+
 /** Concat multiple numeric values to a single one.
  *  @param num the number of values to concat
  *  @param dir the direction of the concatenation.
@@ -2228,6 +2353,28 @@ static int zero_value_numeric(Value value) {
     return value->data_int == 0;
 }
 
+/** Testing if a bitstring value is 0.
+ *  @param value the value to check.
+ *  @return 1 if 0 and 0 othewize. */
+static int zero_value_bitstring(Value value) {
+    unsigned long long width = type_width(value->type);
+    for(unsigned long long i=0;i<width; ++i) {
+        if (value->data_str[i] != '0') return 0;
+    }
+    return 1;
+}
+
+/** Testing if a numeric value is positive (or 0). */
+static int positive_value_numeric(Value value) {
+    return (value->type->flags.sign == 0) || ((long long)(value->data_int) >= 0);
+}
+
+/** Testing if a bitstring value is positive (or 0). */
+static int positive_value_bitstring(Value value) {
+    return (value->type->flags.sign == 0) || 
+        (value->data_str[type_width(value->type)-1] == '1');
+}
+
 
 
 /** Testing if two numeric values have the same content (the type is not checked).
@@ -2450,8 +2597,7 @@ Value sub_value(Value src0, Value src1, Value dst) {
  *  @param dst the destination value
  *  @return dst */
 Value mul_value(Value src0, Value src1, Value dst) {
-    // printf("mul_value with src0=%llx src1=%llx\n",value2integer(src0),value2integer(src1));
-    // printf("src0->numeric=%d src1->numeric=%d\n",src0->numeric,src1->numeric);
+    // printf("mul_value with src0->numeric=%d src1->numeric=%d\n",src0->numeric,src1->numeric);
     // printf("is_defined_value(src0)=%d is_defined_value(src1)=%d\n",is_defined_value(src0),is_defined_value(src1));
     /* Might allocate a new value so save the current pool state. */
     // unsigned int pos = get_value_pos();
@@ -2472,15 +2618,19 @@ Value mul_value(Value src0, Value src1, Value dst) {
             return mul_value_numeric(src0,src1,dst);
         }
     } else if (src1->numeric && is_defined_value(src0)) {
-        // /* src1 is numeric but src0 is a defined bitstring, convert src1 to
-        //  * bitstring. */
-        // src1 = set_bit_string_value(src1,get_value());
-        // /* And do a bitstring multiplying. */
-        // return mul_value_defined_bitstring(src0,src1,dst);
-            /* src0 is a defined bitstring, convert it to a numeric. */
+        if (type_width(src0->type) <= 64) {
+            /* src0 is aanot too big defined bitstring,
+             * convert it to a numeric. */
             src0 = set_numeric_value(src0,get_value());
             /* And do a numeri multiplying. */
             return mul_value_numeric(src0,src1,dst);
+        } else {
+            /* src1 is numeric but src0 is a defined bitstring, convert src1 to
+             * bitstring. */
+            src1 = set_bitstring_value(src1,get_value());
+            /* And do a bitstring multiplying. */
+            return mul_value_defined_bitstring(src0,src1,dst);
+        }
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
         /* Both sources are defined bitstrings. */
         return mul_value_defined_bitstring(src0,src1,dst);
@@ -2933,7 +3083,24 @@ Value select_value(Value cond, Value dst, unsigned int num, ...) {
     return dst;
 }
 
-/** Concat multiple general values to a single one.
+/** Selects a value depending on a general condition (pointer version).
+ *  @param cond   the condition to use for selecting a value
+ *  @param dst    the destination value (used only if new value is created).
+ *  @param num    the number of values for the selection
+ *  @param values the values to select from.
+ *  @return the selected value */
+Value select_valueP(Value cond, Value dst, unsigned int num, Value* values) {
+    if (is_defined_value(cond)) {
+        /* The condition can be made numeric. */
+        dst = select_value_numeric_array(cond,dst,num,values);
+    } else {
+        /* The sources cannot be numeric, compute bitsitrings. */
+        dst = select_value_bitstring_array(cond,dst,num,values);
+    }
+    return dst;
+}
+
+/** Concat multiple general values to a single one (pointer version).
  *  @param dir the direction of the concatenation.
  *  @param num the number of values to concat
  *  @param dst the destination value
@@ -3001,9 +3168,22 @@ Value concat_value(unsigned int num, int dir, Value dst, ...) {
  *  @param dst the destination value
  *  @return dst */
 Value cast_value(Value src, Type type, Value dst) {
+    // printf("cast value from width=%llu to width=%llu\n",type_width(src->type),type_width(type));
     if (src->numeric) {
         /* The source is numeric. */
-        return cast_value_numeric(src,type,dst);
+        /* Is the destination type small enough? */
+        if (type_width(type) <= 64) {
+            /* Yes, keep numeric. */
+            return cast_value_numeric(src,type,dst);
+        } else {
+            /* No, do it in bit string. */
+            Value res = set_bitstring_value(src,get_value());
+            // printf("res=%.*s\n",res->capacity,res->data_str);
+            dst = cast_value_bitstring(res,type,dst);
+            // printf("dst=%.*s\n",dst->capacity,dst->data_str);
+            free_value();
+            return dst;
+        }
     } else {
         /* The source cannot be numeric, compute bitsitrings. */
         return cast_value_bitstring(src,type,dst);
@@ -3019,8 +3199,7 @@ int zero_value(Value value) {
         /* The value is numeric. */
         return zero_value_numeric(value);
     } else {
-        /* The value cannot be reduced to numeric: cannot be 0. */
-        return 0;
+        return zero_value_bitstring(value);
     }
 }
 
@@ -3161,7 +3340,11 @@ unsigned long long value2integer(Value value) {
     unsigned long long width = type_width(value->type);
     /* If the value is numeric, just return its data as is. */
     if (value->numeric) {
-        return value->data_int & ~((unsigned long long)(-1LL) << width);
+        // printf("width=%llu\n",width);
+        if (width == 64)
+            return value->data_int;
+        else
+            return value->data_int & ~(0xFFFFFFFFFFFFFFFFULL << width);
     }
     /* Otherwise convert the bitstring to an integer if possible,
      * but return 0 in case of failure. */