HDLRuby 3.7.6 → 3.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8331701e40f0efc7e0481fdacf241194aa5aba8a707ee257a75a73f295ba677
-  data.tar.gz: 9d41bbff0f3ad714e012c65a7ff2b920551cc1db607a7c20f281dfc5b6dbde1c
+  metadata.gz: 343e43059315343f17e5999397af265b9d7c241ce527c57855b4b7d24d4c698a
+  data.tar.gz: d21dd89efe29eb843ad69c20ae802bad2c11d9d2ad5f6a2d96a904cdd72b9b33
 SHA512:
-  metadata.gz: 83b7cf2d52d862a704166a50c6c9440bd1d3349a062a2e146cfbdf8c1314435b3237acc371a7f9377a7de70b2565f17f6829441a386fe369c975d8e67f7b45c7
-  data.tar.gz: c1ff187b98317042cc4ba243fa35d08e6771c73d2c8d77a66444bb13faa6c3fd2a37b7733087a2cbe2fe97dcb25928485a44af334b41751222040d41655d8d68
+  metadata.gz: 0ebc27526e8c259b80a40171e7eb65fa529c477621366296926acbb266f20dd44a55cff96a875cf77cf7c3d739d2d7f252281fec9671a06400829ae01f84883b
+  data.tar.gz: 36e07d94b685e170b815ca07f1e2c8e50b580b02c49602e8737aced082e606b3c269e1173c9ed92dee89d53418f1dc3a04491d0d9510992e4f04088062fca15e

data/README.md

@@ -17,6 +17,10 @@ hdrcc --get-tuto
 
 __What's new_
 
+For HDLRuby versions 3.7.7/3.7.8:
+
+* Various fixes regqrding the software sequencers.
+
 For HDLRuby version 3.7.6:
 
 * Added initial value to signals for the software sequencers.

data/ext/hruby_sim/hruby_sim_calc.c

@@ -690,13 +690,13 @@ static Value mul_value_defined_bitstring(Value src0, Value src1, Value dst) {
         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);
+        // printf("first src1->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);
+        // printf("now psrc1->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;
@@ -778,8 +778,8 @@ static Value mod_value_defined_bitstring(Value src0, Value src1, Value dst) {
 
 
 /** Computes the greater comparision of two defined bitstring values.
- *  @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 comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
 static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst) {
@@ -788,28 +788,13 @@ static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst)
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Converts the values to integers. */
-    // unsigned long long src0i = value2integer(src0);
-    // unsigned long long src1i = value2integer(src1);
-    // /* Perform the comparison. */
-    // if (src0->type->flags.sign) {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src0i > (signed long long)src1i;
-    //     else
-    //         dst->data_int = (signed long long)src0i >= 0 ? src0i > src1i : 0;
-    // } else {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src1i >= 0 ? src0i > src1i : 1;
-    //     else 
-    //         dst->data_int = src0i > src1i;
-    // }
     char* src0_data = src0->data_str;
     char* src1_data = src1->data_str;
     long long width0 = type_width(src0->type);
     long long width1 = type_width(src1->type);
     long long width = width0>width1 ? width0 : width1;
-    if (src0->type->flags.sign && src0_data[width0-1] == '1') {
-        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+    if (src0->type->flags.sign && (src0_data[width0-1] == '1')) {
+        if(src1->type->flags.sign && (src1_data[width1-1] == '1')) {
             /* Negative-negative comparison. */
             for(long long i=width-1; i >= 0; --i) {
                 char d0 = i >= width0 ? '1' : src0_data[i];
@@ -828,7 +813,7 @@ static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst)
             return dst;
         }
     } else {
-        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+        if(src1->type->flags.sign && (src1_data[width1-1] == '1')) {
             /* Positive-negative comparison, src0 is greater. */
             dst->data_int = 1;
             return dst;
@@ -852,9 +837,72 @@ static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst)
     return dst;
 }
 
+/** Computes the greater comparision of a numeric value and a
+ * defined bitstring values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+static Value greater_value_numeric_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("greater_value_numeric_defined_bitstring.\n");
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    unsigned long long src0_int = src0->data_int;
+    char* src1_data = src1->data_str;
+    long long width0 = type_width(src0->type);
+    long long width1 = type_width(src1->type);
+    long long width = width0>width1 ? width0 : width1;
+    if (src0->type->flags.sign && (src0_int & (1 << (width0-1)))) {
+        if(src1->type->flags.sign && (src1_data[width1-1] == '1')) {
+            /* Negative-negative comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '1' : 
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '1' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 0;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 1;
+                    return dst;
+                }
+            }
+        } else {
+            /* Negative positive comparison, src0 is smaller. */
+            dst->data_int = 0;
+            return dst;
+        }
+    } else {
+        if(src1->type->flags.sign && (src1_data[width1-1] == '1')) {
+            /* Positive-negative comparison, src0 is greater. */
+            dst->data_int = 1;
+            return dst;
+        } else {
+            /* Positive-positive comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '0' : 
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '0' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 0;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 1;
+                    return dst;
+                }
+            }
+        }
+    }
+    /* Equality. */
+    dst->data_int = 0;
+    return dst;
+}
+
 /** Computes the lesser comparision of two defined bitstring values.
- *  @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 comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
 static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
@@ -863,21 +911,6 @@ static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Converts the values to integers. */
-    // unsigned long long src0i = value2integer(src0);
-    // unsigned long long src1i = value2integer(src1);
-    // /* Perform the comparison. */
-    // if (src0->type->flags.sign) {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src0i < (signed long long)src1i;
-    //     else
-    //         dst->data_int = (signed long long)src0i >= 0 ? src0i < src1i : 1;
-    // } else {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src1i >= 0 ? src0i < src1i : 0;
-    //     else 
-    //         dst->data_int = src0i < src1i;
-    // }
     char* src0_data = src0->data_str;
     char* src1_data = src1->data_str;
     long long width0 = type_width(src0->type);
@@ -927,32 +960,80 @@ static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
     return dst;
 }
 
+/** Computes the lesser comparision of one numeric value and one
+ *  defined bitstring values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+static Value lesser_value_numeric_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("lesser_value_numeric_defined_bitstring.\n");
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    unsigned long long src0_int = src0->data_int;
+    char* src1_data = src1->data_str;
+    long long width0 = type_width(src0->type);
+    long long width1 = type_width(src1->type);
+    long long width = width0>width1 ? width0 : width1;
+    if (src0->type->flags.sign && (src0_int & (1 << (width0-1)))) {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Negative-negative comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '1' : 
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '1' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 1;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 0;
+                    return dst;
+                }
+            }
+        } else {
+            /* Negative positive comparison, src0 is smaller. */
+            dst->data_int = 1;
+            return dst;
+        }
+    } else {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Positive-negative comparison, src0 is greater. */
+            dst->data_int = 0;
+            return dst;
+        } else {
+            /* Positive-positive comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '0' :
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '0' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 1;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 0;
+                    return dst;
+                }
+            }
+        }
+    }
+    /* Equality. */
+    dst->data_int = 0;
+    return dst;
+}
+
 /** Computes the greater or equal comparision of two defined bitstring values.
- *  @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 comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
 static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("greater_equal_value_defined_bitstring.\n");
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* 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)
-    //         dst->data_int = (signed long long)src0i >= (signed long long)src1i;
-    //     else
-    //         dst->data_int = (signed long long)src0i >= 0 ? src0i >= src1i : 0;
-    // } else {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src1i >= 0 ? src0i >= src1i : 1;
-    //     else 
-    //         dst->data_int = src0i >= src1i;
-    // }
     char* src0_data = src0->data_str;
     char* src1_data = src1->data_str;
     long long width0 = type_width(src0->type);
@@ -1002,31 +1083,80 @@ static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value
     return dst;
 }
 
+/** Computes the greater or equal comparision of numeric and one
+ *  defined bitstring values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+static Value greater_equal_value_numeric_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("greater_equal_value_numeric_defined_bitstring.\n");
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    unsigned long long src0_int = src0->data_int;
+    char* src1_data = src1->data_str;
+    long long width0 = type_width(src0->type);
+    long long width1 = type_width(src1->type);
+    long long width = width0>width1 ? width0 : width1;
+    if (src0->type->flags.sign && (src0_int & (1 <<(width0-1)))) {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Negative-negative comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '1' :
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '1' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 0;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 1;
+                    return dst;
+                }
+            }
+        } else {
+            /* Negative positive comparison, src0 is smaller. */
+            dst->data_int = 0;
+            return dst;
+        }
+    } else {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Positive-negative comparison, src0 is greater. */
+            dst->data_int = 1;
+            return dst;
+        } else {
+            /* Positive-positive comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '0' : 
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '0' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 0;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 1;
+                    return dst;
+                }
+            }
+        }
+    }
+    /* Equality. */
+    dst->data_int = 1;
+    return dst;
+}
+
 /** Computes the lesser or equal comparision of two defined bitstring values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
  *  @param dst the destination value
  *  @return dst */
 static Value lesser_equal_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("lesser_equal_value_defined_bitstring.\n");
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Converts the values to integers. */
-    // unsigned long long src0i = value2integer(src0);
-    // unsigned long long src1i = value2integer(src1);
-    // /* Perform the comparison. */
-    // if (src0->type->flags.sign) {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src0i <= (signed long long)src1i;
-    //     else
-    //         dst->data_int = (signed long long)src0i >= 0 ? src0i <= src1i : 1;
-    // } else {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src1i >= 0 ? src0i <= src1i : 0;
-    //     else 
-    //         dst->data_int = src0i <= src1i;
-    // }
     char* src0_data = src0->data_str;
     char* src1_data = src1->data_str;
     long long width0 = type_width(src0->type);
@@ -1076,6 +1206,70 @@ static Value lesser_equal_value_defined_bitstring(Value src0, Value src1, Value
     return dst;
 }
 
+/** Computes the lesser or equal comparision of on numeric value and one
+ *  defined bitstring values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value lesser_equal_value_numeric_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("lesser_equal_value_numeric_defined_bitstring.\n");
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    unsigned long long src0_int = src0->data_int;
+    char* src1_data = src1->data_str;
+    long long width0 = type_width(src0->type);
+    long long width1 = type_width(src1->type);
+    long long width = width0>width1 ? width0 : width1;
+    if (src0->type->flags.sign && (src0_int & (1 << (width0-1)))) {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Negative-negative comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '1' :
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '1' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 1;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 0;
+                    return dst;
+                }
+            }
+        } else {
+            /* Negative positive comparison, src0 is smaller. */
+            dst->data_int = 1;
+            return dst;
+        }
+    } else {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Positive-negative comparison, src0 is greater. */
+            dst->data_int = 0;
+            return dst;
+        } else {
+            /* Positive-positive comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '0' :
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '0' : src1_data[i];
+                // printf("d0=%c d1=%c\n",d0,d1);
+                if (d0 < d1) {
+                    dst->data_int = 1;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 0;
+                    return dst;
+                }
+            }
+        }
+    }
+    /* Equality. */
+    dst->data_int = 1;
+    return dst;
+}
+
 
 /** Computes the NOT of a bitstring value.
  *  @param src the source value of the not
@@ -3111,6 +3305,10 @@ Value greater_value(Value src0, Value src1, Value dst) {
         /* Both sources are numeric. */
         return greater_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        if (src0->numeric)
+            return greater_value_numeric_defined_bitstring(src0,src1,dst);
+        if (src1->numeric)
+            return lesser_equal_value_numeric_defined_bitstring(src1,src0,dst);
         /* Both sources can be converted to numeric values. */
         return greater_value_defined_bitstring(src0,src1,dst);
     } else {
@@ -3139,6 +3337,10 @@ Value lesser_value(Value src0, Value src1, Value dst) {
         return lesser_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
         /* Both sources can be converted to numeric values. */
+        if (src0->numeric)
+            return lesser_value_numeric_defined_bitstring(src0,src1,dst);
+        if (src1->numeric)
+            return greater_equal_value_numeric_defined_bitstring(src1,src0,dst);
         return lesser_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */
@@ -3166,6 +3368,10 @@ Value greater_equal_value(Value src0, Value src1, Value dst) {
         return greater_equal_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
         /* Both sources can be converted to numeric values. */
+        if (src0->numeric)
+            return greater_equal_value_numeric_defined_bitstring(src0,src1,dst);
+        if (src1->numeric)
+            return lesser_value_numeric_defined_bitstring(src1,src0,dst);
         return greater_equal_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */
@@ -3192,6 +3398,10 @@ Value lesser_equal_value(Value src0, Value src1, Value dst) {
         return lesser_equal_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
         /* Both sources can be converted to numeric values. */
+        if (src0->numeric)
+            return lesser_equal_value_numeric_defined_bitstring(src0,src1,dst);
+        if (src1->numeric)
+            return greater_value_numeric_defined_bitstring(src1,src0,dst);
         return lesser_equal_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */

data/lib/HDLRuby/hdr_samples/comparison_bench.rb

@@ -42,6 +42,28 @@ system :comparison_bench do
         sgeL <= (uL >= vL)
     end
 
+    [8].inner :xND
+    [96].inner :yND
+    signed[8].inner :uND
+    signed[128].inner :vND
+    inner :ueND, :ultND, :uleND, :ugtND, :ugeND
+    inner :seND, :sltND, :sleND, :sgtND, :sgeND
+
+    par do
+        ueND  <= (xND == yND)
+        ultND <= (xND < yND)
+        uleND <= (xND <= yND)
+        ugtND <= (xND > yND)
+        ugeND <= (xND >= yND)
+
+        seND  <= (uND == vND)
+        sltND <= (uND < vND)
+        sleND <= (uND <= vND)
+        sgtND <= (uND > vND)
+        sgeND <= (uND >= vND)
+    end
+
+
     timed do
         x <= 0
         y <= 0
@@ -51,26 +73,38 @@ system :comparison_bench do
         yL <= 0
         uL <= 0
         vL <= 0
+        xND <= 0
+        yND <= 0
+        uND <= 0
+        vND <= 0
         !10.ns
         x <= 1
         u <= 1
         xL <= 2**80 - 1
         uL <= 2**80 - 1
+        xND <= 1
+        uND <= 1
         !10.ns
         y <= 2
         v <= 2
         yL <= 2**81 - 1
         vL <= 2**81 - 1
+        yND <= 2
+        vND <= 2
         !10.ns
         x <= 3
         u <= 3
         xL <= 2**81 + 2**80 - 1
         uL <= 2**81 + 2**80 - 1
+        xND <= 3
+        uND <= 3
         !10.ns
         x <= 2
         u <= -2
         xL <= 2**81 - 1
         uL <= -2**81 + 1
+        xND <= 2
+        uND <= -2
         !10.ns
     end
 end

data/lib/HDLRuby/std/sequencer_sw.rb

@@ -1325,10 +1325,10 @@ module RubyHDL::High
         return @base.to_c + "[#{self.size.to_i}]"
       else
         # Simple vector type case.
-        if float? then
+        if @base.float? then
           return @base.to_c
         else
-          return @base + " long long"
+          return @base.to_c + " long long"
         end
       end
     end
@@ -1338,7 +1338,7 @@ module RubyHDL::High
       if @base.is_a?(TypeVector) then
         # Array type case.
         base_init = @base.to_c_init
-        return "[" + ([base_init] * self.size.to_i).join(",") + "]"
+        return "{" + ([base_init] * self.size.to_i).join(",") + "}"
       else
         return "0"
       end
@@ -1919,7 +1919,13 @@ module RubyHDL::High
     end
 
     # Convert to C code.
-    alias_method :to_c, :to_ruby
+    def to_c
+      if @content.is_a?(::Array) then
+        return "{" + @content.to_s[1..-2] + "}"
+      else
+        return @content.to_s
+      end
+    end
   end
 
   
@@ -2000,10 +2006,11 @@ module RubyHDL::High
 
     # Convert to C code.
     def to_c
-      return "switch(#{@sel.to_c}) {\n" +
-        @choices.map.with_index do |choice,i|
-          "case #{i}:\n#{choice.to_c}\nbreak;"
-        end.join("\n") + "\n}"
+      # return "switch(#{@sel.to_c}) {\n" +
+      #   @choices.map.with_index do |choice,i|
+      #     "case #{i}:\n#{choice.to_c}\nbreak;"
+      #   end.join("\n") + "\n}"
+      return "#{@sel.to_c} ? #{@choices[1].to_c} : #{@choices[0].to_c}"
     end
   end
 
@@ -2112,6 +2119,7 @@ module RubyHDL::High
 
   # Describes a SW implementation of an range reference.
   class RefRange < Ref
+    using RubyHDL::High
     attr_reader :base
 
     # Create a new index reference with +type+ data type +base+ base
@@ -2178,7 +2186,11 @@ module RubyHDL::High
         smask = (1.to_value<<(@rng.first+1-@rng.last))-1
         cmask = ~(smask << @rng.last)
         # Get the final base.
-        base = @base.final_base.to_c
+        if @base.is_a?(Ref) then
+          base = @base.final_base.to_c
+        else
+          base = @base.to_c
+        end
         # Generate the ruby code.
         return "(#{base} & #{cmask.to_c}) >> (#{@rng.last.to_c})"
       end
@@ -2256,7 +2268,7 @@ module RubyHDL::High
     def to_c
       if (@left.is_a?(RefIndex) or @left.is_a?(RefRange)) then
         if @left.base.type.base.is_a?(TypeVector) then
-          return "#{@left.to_c} = #{@right.to_c}"
+          return "#{@left.to_c} = #{@right.to_c};"
         else
           # Get the access range.
           rng = @left.range
@@ -2275,7 +2287,7 @@ module RubyHDL::High
     end  
   end
 
-  # Describes a SW implementation of a if statement.
+  # Describes a SW implementation of a sif statement.
   class Sif < Statement
     # Create a new if statement in sequencer +sequencer+ 
     # with +cond+ condition and +ruby_block+
@@ -2336,7 +2348,7 @@ module RubyHDL::High
 
     # Convert to C code.
     def to_c
-      res = @sequencer.clk_up + "\nif(#{@condition.to_c}) {\n#{@yes_blk.to_c}\n}"
+      res = @sequencer.clk_up_c + "\nif(#{@condition.to_c}) {\n#{@yes_blk.to_c}\n}"
       @elsifs.each do |(cond,blk)|
         res << "\nelse if(#{cond.to_c}) {\n#{blk.to_c}\n}"
       end
@@ -2347,6 +2359,33 @@ module RubyHDL::High
     end
   end
 
+  # Describes a SW implementation of a hif statement.
+  class Hif < Sif
+    # Convert to Ruby code.
+    def to_ruby
+      res = "\nif((#{@condition.to_ruby}) != 0)\n#{@yes_blk.to_ruby}\n"
+      @elsifs.each do |(cond,blk)|
+        res << "elsif((#{cond.to_ruby}) != 0)\n#{blk.to_ruby}\n"
+      end
+      if @else_blk then
+        res << "else\n#{@else_blk.to_ruby}\n"
+      end
+      return res + "end\n"
+    end
+
+    # Convert to C code.
+    def to_c
+      res = "\nif(#{@condition.to_c}) {\n#{@yes_blk.to_c}\n}"
+      @elsifs.each do |(cond,blk)|
+        res << "\nelse if(#{cond.to_c}) {\n#{blk.to_c}\n}"
+      end
+      if @else_blk then
+        res << "\nelse {\n#{@else_blk.to_c}\n}"
+      end
+      return res
+    end
+  end
+
   # Describes a SW implementation of a loop statement.
   class Sloop < Statement
     # Create a new infinite loop statement in sequencer +sequencer+ 
@@ -2494,7 +2533,7 @@ module RubyHDL::High
 
     # Convert to Ruby code.
     def to_c
-      return @sequencer.clk_up_c + "\nreturn #{val.to_c};"
+      return @sequencer.clk_up_c + "\nreturn #{@value.to_c};"
     end
   end
 
@@ -2642,7 +2681,7 @@ module RubyHDL::High
 
     # Convert to C code.
     def to_c
-      return "\n__#{name}(" + @args.map {|arg| arg.to_ruby}.join(",") + ");"
+      return "\n__#{@name}(" + @args.map {|arg| arg.to_ruby}.join(",") + ");"
     end
 
     # Create an iterator for a given method +meth+.
@@ -2993,21 +3032,23 @@ module RubyHDL::High
       return "" if @arguments.empty?
       res = "print("
       @arguments.each do |arg|
-          if arg.is_a?(::String) then
-            res << "\"#{arg}\""
-          else
-            res << arg.to_ruby
-          end
+        if arg.is_a?(::String) then
+          res << "\"#{arg}\""
+        else
+          res << arg.to_ruby
         end
-        res << ")\n"
-        return res
+        res << ","
+      end
+      res[-1] = ")"
+      res << "\n"
+      return res
     end
 
     # Convert to C code.
     def to_c
       return "" if @arguments.empty?
       # Create the format.
-      format = @arguments.each do |arg|
+      format = @arguments.map do |arg|
         if arg.is_a?(Expression) then
           arg.type.signed? ? "%lld" : "%llu"
         else
@@ -3015,13 +3056,13 @@ module RubyHDL::High
         end
       end.join
       return "printf(\"#{format}\"," +
-        @arguments.each do |arg|
+        @arguments.map do |arg|
           if arg.is_a?(::String) then
-            "\"#{arg}\""
+            "\"#{arg.gsub(/\n/,"\\n")}\""
           else
             arg.to_c
           end
-        end.join(",")
+        end.join(",") + ");"
     end
   end
 
@@ -3459,7 +3500,9 @@ module RubyHDL::High
     end
 
     # Convert to C code.
-    alias_method :to_c, :to_ruby
+    def to_c
+      return "__" + self.name.to_s
+    end
 
     # Check if a value is defined for the signal.
     def value?
@@ -3616,14 +3659,14 @@ module RubyHDL::High
     # Convert to C code.
     def to_c
       res = ""
-      # Generate the arguments if any.
-      if @args.any? then
-        res = "(#{@args.map(&:to_c).join(",")})\n"
-      end
+      # # Generate the arguments if any.
+      # if @args.any? then
+      #   res = "(#{@args.map(&:to_c).join(",")})\n"
+      # end
       # Generate the statements.
-      res += "{" + @statements.map do |stmnt|
-        stmnt.to_ruby + "\n"
-      end.join + "}"
+      res += "{\n" + @statements.map do |stmnt|
+        stmnt.to_c + "\n"
+      end.join + "\n}"
       return res
     end
 
@@ -3663,7 +3706,11 @@ module RubyHDL::High
     def sif(cond, &ruby_block)
       self << RubyHDL::High::Sif.new(@sequencer,cond,&ruby_block)
     end
-    alias_method :hif, :sif
+
+    # Create a sequential if statement on +cond+.
+    def hif(cond, &ruby_block)
+      self << RubyHDL::High::Hif.new(@sequencer,cond,&ruby_block)
+    end
 
     # Create a sequential elsif statement on +cond+.
     def selsif(cond, &ruby_block)
@@ -3769,7 +3816,7 @@ module RubyHDL::High
 
     # Convert to C code.
     def to_c
-      return "unsigned long long __#{name}(#{@args.map {|arg| "unsigned long long " + arg.to_c}.join(",")} {\n#{@blk.sequencer.clk_up_c}\n#{@blk.to_c}\n}\n"
+      return "unsigned long long __#{name}(#{@args.map {|arg| "unsigned long long __" + arg.to_c}.join(",")}) {\n#{@blk.sequencer.clk_up_c}\n#{@blk.to_c}\n}\n"
     end
   end
 
@@ -3858,11 +3905,29 @@ BUILD
     def to_c
       typ = nil
       res = <<-BUILDC
+#include <stdio.h>
+
 #{RubyHDL::High.global_sblock.each_signal.map do |signal|
       typ = signal.type
-      typ.to_c + " " + signal.to_c + "=" + typ.to_c_init + ";"
+      if signal.value? then
+        if signal.array? then
+          typ.base.to_c + " " + signal.to_c + "[#{typ.size}]" " = {" + 
+            signal.value.inspect[1..-2] + "};"
+        else
+          typ.to_c + " " + signal.to_c + "=" + signal.value.inspect + ";"
+        end
+      else
+        if signal.array? then
+          typ.base.to_c + " " + signal.to_c + "[#{typ.size}]" + " =" + typ.to_c_init + ";"
+        else
+          typ.to_c + " " + signal.to_c + "=" + typ.to_c_init + ";"
+        end
+      end
 end.join("\n")}
-#{sblock.to_c}
+
+#{@sfunctions.map {|n,f| f.to_c }.join("\n\n")}
+
+void sequencer() #{@blk.to_c}
 BUILDC
       return res
     end

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "3.7.6"
+  VERSION = "3.7.8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 3.7.6
+  version: 3.7.8
 platform: ruby
 authors:
 - Lovic Gauthier
@@ -495,7 +495,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: HDLRuby is a library for describing and simulating digital electronic systems.
 test_files: []