HDLRuby 3.7.7 → 3.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15e4da96afaa32db3686dcbad0ea327db644719dadfdba4ed6dcef1464f1e391
-  data.tar.gz: 1d08ab446037ab8ae6b86e6394a209a03ef06e8bcf233d10d9af25d059873f47
+  metadata.gz: 343e43059315343f17e5999397af265b9d7c241ce527c57855b4b7d24d4c698a
+  data.tar.gz: d21dd89efe29eb843ad69c20ae802bad2c11d9d2ad5f6a2d96a904cdd72b9b33
 SHA512:
-  metadata.gz: 444499b3dc4f0577f113630a521bf7de67186f8dc2936c8626b91fd1dc556fac9b5f361f7265dbe81123c6a8391054eca2d57076e3067653b41c9566125d5b65
-  data.tar.gz: 9284989cce6b6006c3551e6d5f8e40a29a8c16726d168cab4347f27b596eac1962f045cd260c072ad0be31665e69f2f84ce6406e28b65d378262bc7586c39fbb
+  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

@@ -3032,14 +3032,16 @@ 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.

data/lib/HDLRuby/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 3.7.7
+  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: []