HDLRuby 2.6.3 → 2.6.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de0bd759fdbbac53ed126dac38739ef63bdbea435e59f6ebfe9fe35d08475e13
-  data.tar.gz: 9ddbebe786fe3f3f3b6a2db76954f1d8c118cb1913d3487251b9419c1c68c997
+  metadata.gz: 219077a50d543c3ecdb964a7bd7571f5c0db02ece82a0efb7670e5531acf437d
+  data.tar.gz: 2bbff4911a6c7ff9ec3c33287b61d4a1b7efd5c7dc789975d89e53b3f42638c1
 SHA512:
-  metadata.gz: d22275446a0323c9a27ff0df24d7bb6f684dec195a53f2713176908da81dfc693502bf7649cde756e81726f01dbce910befdc33a623f6022e9e448c559f8bfef
-  data.tar.gz: 8dd6f59d5f0c6898e3e5b71b287900ab3bac0b21154b51acbf14a5959180632d3090fd3979478a5f50bdd418ec09104fb33e4d99059dee7812a16a9aba6f42af
+  metadata.gz: c95ef3fa229c2e9283cd78f86c9f6fa4ad4f80d0e3f6153ee444e2c75d754dc7098a5547ce623f8aa85b1860e24522f8404a6e654849d0250897acca26134f9a
+  data.tar.gz: '023502192d5189e2a85a4d69d3f63bb81d58d38496812be03b8c7c5c92791309412e21cbb4d68aa79f03372d296635cafe55264e5483d12d8eef56236b188aeb'

data/lib/HDLRuby/hdr_samples/comparison_bench.rb

@@ -0,0 +1,40 @@
+# Test the comparison operators.
+
+# A benchmark for the adder.
+system :adder_bench do
+    [8].inner :x, :y
+    signed[8].inner :u,:v
+    inner :ue, :ult, :ule, :ugt, :uge
+    inner :se, :slt, :sle, :sgt, :sge
+
+    par do
+        ue  <= (x == y)
+        ult <= (x < y)
+        ule <= (x <= y)
+        ugt <= (x > y)
+        uge <= (x >= y)
+
+        se  <= (u == v)
+        slt <= (u < v)
+        sle <= (u <= v)
+        sgt <= (u > v)
+        sge <= (u >= v)
+    end
+
+    timed do
+        x <= 0
+        y <= 0
+        u <= 0
+        v <= 0
+        !10.ns
+        x <= 1
+        u <= 1
+        !10.ns
+        y <= 2
+        v <= 2
+        !10.ns
+        x <= 2
+        u <= -2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/multi_timed_bench.rb

@@ -0,0 +1,54 @@
+# Test the execution of multiple timed behaviors
+system :multi_timed do
+    inner :clk1, :clk2, :rst, :button
+    [8].inner :counter1, :counter2 
+
+    # The process controlling counter1.
+    par(clk1.posedge) do
+        hif(rst) { counter1 <= 0 }
+        helsif(button) { counter1 <= counter1 + 1 }
+    end
+
+    # The process controlling counter2.
+    par(clk2.posedge) do
+        hif(rst) { counter2 <= 0 }
+        helsif(button) { counter2 <= counter2 + 1 }
+    end
+
+    # The process for clk1
+    timed do
+        50.times do
+            clk1 <= 0
+            !10.ns
+            clk1 <= 1
+            !10.ns
+        end
+    end
+
+    # The process for clk2
+    timed do
+        80.times do
+            clk2 <= 0
+            !3.ns
+            clk2 <= 1
+            !3.ns
+        end
+    end
+
+    # The control process
+    timed do
+        rst <= 0
+        button <= 0
+        !10.ns
+        rst <= 1
+        !20.ns
+        rst <= 0
+        !10.ns
+        10.times do
+            button <= 1
+            !20.ns
+            button <= 0
+            !20.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/neg_arith_bench.rb

@@ -2,6 +2,7 @@
 # A benchmark for testing the arithmetic with signed values.
 system :neg_arith_bench do
     signed[11..0].inner :x,:y,:z
+    inner :cmp
 
     timed do
         x <= 10
@@ -9,41 +10,51 @@ system :neg_arith_bench do
         z <= 0
         !10.ns
         z <= 10 * 10
+        cmp <= (10 < 10)
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= 10
         y <= -10
         !10.ns
         z <= 10 * (-10)
+        cmp <= (10 < -10)
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= -10
         y <= 10
         !10.ns
         z <= (-10) * 10
+        cmp <= (-10 < 10)
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= -10
         y <= -10
         !10.ns
         z <= (-10) * (-10)
+        cmp <= (-10 < -10)
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= _000000011010
         y <= _000011111010
         z <= 0
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= _000000011010
         y <= _111111111010
         z <= 0
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/type_minmax_bench.rb

@@ -0,0 +1,37 @@
+# Test the type method min and max
+
+# A benchmark for the adder.
+system :adder_bench do
+    [32].inner :x
+    signed[32].inner :y
+
+    timed do
+        x <= 0
+        y <= 0
+        !10.ns
+        x <= bit[8].max
+        y <= signed[8].max
+        !10.ns
+        x <= bit[8].min
+        y <= signed[8].min
+        !10.ns
+        x <= bit[10].max
+        y <= signed[10].max
+        !10.ns
+        x <= bit[10].min
+        y <= signed[10].min
+        !10.ns
+        x <= bit[16].max
+        y <= signed[16].max
+        !10.ns
+        x <= bit[16].min
+        y <= signed[16].min
+        !10.ns
+        x <= bit[32].max
+        y <= signed[32].max
+        !10.ns
+        x <= bit[32].min
+        y <= signed[32].min
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_to_array.rb

@@ -0,0 +1,29 @@
+
+def connect8(i0,i1,i2,i3,i4,i5,i6,i7,
+             o0,o1,o2,o3,o4,o5,o6,o7)
+    o0 <= i0
+    o1 <= i1
+    o2 <= i2
+    o3 <= i3
+    o4 <= i4
+    o5 <= i5
+    o6 <= i6
+    o7 <= i7
+end
+
+# A benchmark for testing the conversion to ruby array of expressions.
+system :with_to_bench do
+    [8].inner :val
+    inner :b0,:b1,:b2,:b3,:b4,:b5,:b6,:b7
+
+    connect8(*val,b0,b1,b2,b3,b4,b5,b6,b7)
+
+    timed do
+        val <= _01101010
+        !10.ns
+        val <= _01011010
+        !10.ns
+        val <= _00001111
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -637,6 +637,7 @@ elsif $options[:clang] then
             name = $output + "/" +
                 HDLRuby::Low::Low2C.c_name(systemT.name) +
                 ".c"
+            # puts "for systemT=#{systemT.name} generating: #{name}"
             # Open the file for current systemT
             outfile = File.open(name,"w")
             # Generate the C code in to.

data/lib/HDLRuby/hruby_high.rb

@@ -609,7 +609,8 @@ module HDLRuby::High
         # possible arguments +args+.
         def instantiate(i_name,*args)
             # Create the eigen type.
-            eigen = self.expand(High.names_create(i_name.to_s + ":T"), *args)
+            # eigen = self.expand(High.names_create(i_name.to_s + ":T"), *args)
+            eigen = self.expand(HDLRuby.uniq_name(i_name.to_s + ":T"), *args)
 
             # Create the instance and sets its eigen system to +eigen+.
             instance = @instance_class.new(i_name,eigen)
@@ -758,8 +759,10 @@ module HDLRuby::High
                       "Cannot convert a system without a name to HDLRuby::Low."
             end
             # Create the resulting low system type.
-            systemTL = HDLRuby::Low::SystemT.new(High.names_create(name),
+            # systemTL = HDLRuby::Low::SystemT.new(High.names_create(name),
+            systemTL = HDLRuby::Low::SystemT.new(HDLRuby.uniq_name(name),
                                                    self.scope.to_low)
+            # puts "New low from system #{self.name}: #{systemTL.name}"
             # For debugging: set the source high object 
             systemTL.properties[:low2high] = self.hdr_id
             self.properties[:high2low] = systemTL
@@ -2655,7 +2658,6 @@ module HDLRuby::High
             end
         end
 
-
         # Converts to a select operator using current expression as
         # condition for one of the +choices+.
         #
@@ -2671,6 +2673,7 @@ module HDLRuby::High
         end
 
 
+
         # Methods for conversion for HDLRuby::Low: type processing, flattening
         # and so on
 
@@ -4234,6 +4237,22 @@ module HDLRuby::High
     #     end
     # end
     
+    # Extends the TrueClass class for computing for conversion to expression.
+    class ::TrueClass
+        # Converts to a new high-level expression.
+        def to_expr
+            return Value.new(Integer,1)
+        end
+    end
+    
+    # Extends the FalseClass class for computing for conversion to expression.
+    class ::FalseClass
+        # Converts to a new high-level expression.
+        def to_expr
+            return Value.new(Integer,0)
+        end
+    end
+    
     # Extends the Integer class for computing for conversion to expression.
     class ::Integer
         # Converts to a new high-level expression.

data/lib/HDLRuby/hruby_low.rb

@@ -1276,6 +1276,18 @@ module HDLRuby::Low
             end
         end
 
+        # Gets the type max value if any.
+        # Default: not defined.
+        def max
+            raise AnyError, "No max value for type #{self}"
+        end
+
+        # Gets the type min value if any.
+        # Default: not defined.
+        def min
+            raise AnyError, "No min value for type #{self}"
+        end
+
         # Get the direction of the type, little or big endian.
         def direction
             # By default, little endian.
@@ -1617,6 +1629,25 @@ module HDLRuby::Low
             return @base.width * ((first-last).abs + 1)
         end
 
+        # Gets the type max value if any.
+        def max
+            if (self.signed?) then
+                return (2**(self.width-1))-1
+            else
+                return (2**(self.width))-1
+            end
+        end
+
+        # Gets the type min value if any.
+        # Default: not defined.
+        def min
+            if (self.signed?) then
+                return -(2**(self.width-1))
+            else
+                return 0
+            end
+        end
+
         # Get the direction of the type, little or big endian.
         def direction
             return @range.first < @range.last ? :big : :little

data/lib/HDLRuby/hruby_low2c.rb

@@ -1570,7 +1570,9 @@ module HDLRuby::Low
                 # puts "content=#{self.content} str=#{str}"
             end
             # Is it a fully defined number?
-            if str =~ /^[01]+$/ then
+            # NOTE: bignum values are not supported by the simulation engine
+            #       yet, therefore numeric values are limited to 64 max.
+            if str =~ /^[01]+$/ && str.length <= 64 then
                 # Yes, generate a numeral value.
                 res << " " * (level+1)*3
                 res << "static unsigned long long data[] = { "

data/lib/HDLRuby/hruby_verilog_name.rb

@@ -10,41 +10,59 @@ module HDLRuby::Verilog
 
   # Since it is possible to use $ and numbers other than the beginning of the character string, it is divided.
   def name_to_verilog(name)
-    ref = ""         # For storing the converted character.
-    name = name.to_s # Ensure name is a string
-    
-    if (name[0] =~ /[a-zA-Z]/) then
-      ref << name[0]
-      # _ To convert it to __.
-    elsif (name[0] == "_") then
-      ref << "__"
-    # If it does not satisfy the above, it is another character.
-    # In that case, convert it to UTF-8 and convert it to a usable character string.
-    else
-      l = name[0].bytes.map{|v| v.to_s(16)}.join # Conversion to UTF-8 hexadecimal number.
+    # ref = ""         # For storing the converted character.
+    # name = name.to_s # Ensure name is a string
+    # 
+    # if (name[0] =~ /[a-zA-Z]/) then
+    #   ref << name[0]
+    #   # _ To convert it to __.
+    # elsif (name[0] == "_") then
+    #   ref << "__"
+    # # If it does not satisfy the above, it is another character.
+    # # In that case, convert it to UTF-8 and convert it to a usable character string.
+    # else
+    #   l = name[0].bytes.map{|v| v.to_s(16)}.join # Conversion to UTF-8 hexadecimal number.
    
-      ref << "_" + l.rjust(6,"0")      # Add an underscore indicating conversion.
-                                       # The remainder of 6 digits is filled with 0.
-    end
+    #   ref << "_" + l.rjust(6,"0")      # Add an underscore indicating conversion.
+    #                                    # The remainder of 6 digits is filled with 0.
+    # end
+    # 
+    # name[1..-1].each_char do |c|
+    #   # Confirmation of characters in array.
+    #   # If it is a-zA-Z 0 - 9, it is added to ref as it is.
+    #   if (c =~ /[a-zA-Z0-9]|\$/) then
+    #     ref << c
+    #   # _ To convert it to __.
+    #   elsif (c == "_") then
+    #     ref << "__"
+    #   # If it does not satisfy the above, it is another character.
+    #   # In that case, convert it to UTF-8 and convert it to a usable character string.
+    #   else
+    #     l = c.bytes.map{|v| v.to_s(16)}.join # Conversion to UTF-8 hexadecimal number.
+    #  
+    #     ref << "_" + l.rjust(6,"0")      # Add an underscore indicating conversion.
+    #                                      # The remainder of 6 digits is filled with 0.
+    #   end
+    # end
+    # return ref
+
     
-    name[1..-1].each_char do |c|
-      # Confirmation of characters in array.
-      # If it is a-zA-Z 0 - 9, it is added to ref as it is.
-      if (c =~ /[a-zA-Z0-9]|\$/) then
-        ref << c
-      # _ To convert it to __.
-      elsif (c == "_") then
-        ref << "__"
-      # If it does not satisfy the above, it is another character.
-      # In that case, convert it to UTF-8 and convert it to a usable character string.
-      else
-        l = c.bytes.map{|v| v.to_s(16)}.join # Conversion to UTF-8 hexadecimal number.
-     
-        ref << "_" + l.rjust(6,"0")      # Add an underscore indicating conversion.
-                                         # The remainder of 6 digits is filled with 0.
+      name = name.to_s
+      # Convert special characters.
+      name = name.each_char.map do |c|
+          if c=~ /[a-z0-9]/ then
+              c
+          elsif c == "_" then
+              "__"
+          else
+              "_" + c.ord.to_s
+          end
+      end.join
+      # First character: only letter is possible.
+      unless name[0] =~ /[a-z_]/ then
+          name = "_" + name
       end
-    end
-    return ref
+      return name
   end
 
   #puts ref

data/lib/HDLRuby/sim/hruby_sim.h

@@ -219,6 +219,13 @@ Value shift_right_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value equal_value(Value src0, Value src1, Value dst);
 
+/** Computes the greater comparision of two 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 */
+extern Value greater_value(Value src0, Value src1, Value dst);
+
 /** Computes the lesser comparision of two values.
  *  @param src0 the first source value of the comparison
  *  @param src1 the second source value of the comparison
@@ -226,12 +233,19 @@ extern Value equal_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value lesser_value(Value src0, Value src1, Value dst);
 
-/** Computes the greater comparision of two values.
+/** Computes the greater or equal comparision of two 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 */
-extern Value greater_value(Value src0, Value src1, Value dst);
+extern Value greater_equal_value(Value src0, Value src1, Value dst);
+
+/** Computes the lesser or equal comparision of two 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 */
+extern Value lesser_equal_value(Value src0, Value src1, Value dst);
 
 /** Selects a value depending on a condition.
  *  @param cond   the condition to use for selecting a value

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -686,6 +686,41 @@ 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 dst the destination value
+ *  @return dst */
+static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the comparison. */
+    if (src0->type->flags.sign) {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((signed long long)value2integer(src0) > 
+                 (signed long long)value2integer(src1));
+        } else {
+            dst->data_int = 
+                ((signed long long)value2integer(src0) > 
+                 (unsigned long long)value2integer(src1));
+        }
+    } else {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((unsigned long long)value2integer(src0) > 
+                 (signed long long)value2integer(src1));
+        } else {
+            dst->data_int = 
+                ((unsigned long long)value2integer(src0) > 
+                 (unsigned long long)value2integer(src1));
+        }
+    }
+    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
@@ -697,23 +732,97 @@ static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the comparison. */
-    dst->data_int = (value2integer(src0) < value2integer(src1));
+    if (src0->type->flags.sign) {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((signed long long)value2integer(src0) < 
+                 (signed long long)value2integer(src1));
+        } else {
+            dst->data_int = 
+                ((signed long long)value2integer(src0) < 
+                 (unsigned long long)value2integer(src1));
+        }
+    } else {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((unsigned long long)value2integer(src0) < 
+                 (signed long long)value2integer(src1));
+        } else {
+            dst->data_int = 
+                ((unsigned long long)value2integer(src0) < 
+                 (unsigned long long)value2integer(src1));
+        }
+    }
     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 dst the destination value
+ *  @return dst */
+static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
 
-/** Computes the greater comparision of two defined bitstring values.
+    /* Perform the comparison. */
+    if (src0->type->flags.sign) {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((signed long long)value2integer(src0) >=
+                 (signed long long)value2integer(src1));
+        } else {
+            dst->data_int = 
+                ((signed long long)value2integer(src0) >=
+                 (unsigned long long)value2integer(src1));
+        }
+    } else {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((unsigned long long)value2integer(src0) >=
+                 (signed long long)value2integer(src1));
+        } else {
+            dst->data_int = 
+                ((unsigned long long)value2integer(src0) >=
+                 (unsigned long long)value2integer(src1));
+        }
+    }
+    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 greater_value_defined_bitstring(Value src0, Value src1, Value dst) {
+static Value lesser_equal_value_defined_bitstring(Value src0, Value src1, Value dst) {
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
     /* Perform the comparison. */
-    dst->data_int = (value2integer(src0) > value2integer(src1));
+    if (src0->type->flags.sign) {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((signed long long)value2integer(src0) <=
+                 (signed long long)value2integer(src1));
+        } else {
+            dst->data_int = 
+                ((signed long long)value2integer(src0) <=
+                 (unsigned long long)value2integer(src1));
+        }
+    } else {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((unsigned long long)value2integer(src0) <=
+                 (signed long long)value2integer(src1));
+        } else {
+            dst->data_int = 
+                ((unsigned long long)value2integer(src0) <=
+                 (unsigned long long)value2integer(src1));
+        }
+    }
     return dst;
 }
 
@@ -1762,13 +1871,49 @@ static Value equal_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the !XOR. */
-    // dst->data_int = (src0->data_int == src1->data_int);
-    dst->data_int = ~(src0->data_int ^ src1->data_int);
+    // /* Perform the !XOR. */
+    // dst->data_int = ~(src0->data_int ^ src1->data_int);
+    /* Perform the comparison. */
+    dst->data_int = (src0->data_int == src1->data_int) ? 1 : 0;
     return dst;
 }
 
 
+/** Computes the greater comparision of two numeric 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 the destination value */
+static Value greater_value_numeric(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the greater. */
+    if (src0->type->flags.sign) {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((signed long long)src0->data_int > 
+                 (signed long long)src1->data_int);
+        } else {
+            dst->data_int = 
+                ((signed long long)src0->data_int > 
+                 (unsigned long long)src1->data_int);
+        }
+    } else {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((unsigned long long)src0->data_int > 
+                 (signed long long)src1->data_int);
+        } else {
+            dst->data_int = 
+                ((unsigned long long)src0->data_int > 
+                 (unsigned long long)src1->data_int);
+        }
+    }
+    return dst;
+}
+
 /** Computes the lesser comparision of two numeric values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -1780,22 +1925,97 @@ static Value lesser_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the lesser. */
-    dst->data_int = (src0->data_int < src1->data_int);
+    if (src0->type->flags.sign) {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((signed long long)src0->data_int < 
+                 (signed long long)src1->data_int);
+        } else {
+            dst->data_int = 
+                ((signed long long)src0->data_int < 
+                 (unsigned long long)src1->data_int);
+        }
+    } else {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((unsigned long long)src0->data_int < 
+                 (signed long long)src1->data_int);
+        } else {
+            dst->data_int = 
+                ((unsigned long long)src0->data_int < 
+                 (unsigned long long)src1->data_int);
+        }
+    }
     return dst;
 }
 
-/** Computes the greater comparision of two numeric values.
+/** Computes the greater or equal comparision of two numeric 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 the destination value */
-static Value greater_value_numeric(Value src0, Value src1, Value dst) {
+static Value greater_equal_value_numeric(Value src0, Value src1, Value dst) {
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the lesser. */
-    dst->data_int = (src0->data_int > src1->data_int);
+    /* Perform the greater or equal. */
+    if (src0->type->flags.sign) {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((signed long long)src0->data_int >=
+                 (signed long long)src1->data_int);
+        } else {
+            dst->data_int = 
+                ((signed long long)src0->data_int >=
+                 (unsigned long long)src1->data_int);
+        }
+    } else {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((unsigned long long)src0->data_int >=
+                 (signed long long)src1->data_int);
+        } else {
+            dst->data_int = 
+                ((unsigned long long)src0->data_int >=
+                 (unsigned long long)src1->data_int);
+        }
+    }
+    return dst;
+}
+
+/** Computes the lesser or equal comparision of two numeric 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 the destination value */
+static Value lesser_equal_value_numeric(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the lesser or equal. */
+    if (src0->type->flags.sign) {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((signed long long)src0->data_int <=
+                 (signed long long)src1->data_int);
+        } else {
+            dst->data_int = 
+                ((signed long long)src0->data_int <=
+                 (unsigned long long)src1->data_int);
+        }
+    } else {
+        if (src1->type->flags.sign) {
+            dst->data_int = 
+                ((unsigned long long)src0->data_int <=
+                 (signed long long)src1->data_int);
+        } else {
+            dst->data_int = 
+                ((unsigned long long)src0->data_int <=
+                 (unsigned long long)src1->data_int);
+        }
+    }
     return dst;
 }
 
@@ -2434,6 +2654,34 @@ Value equal_value(Value src0, Value src1, Value dst) {
 }
 
 
+
+/** Computes the greater comparision of two general 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 */
+Value greater_value(Value src0, Value src1, Value dst) {
+    /* Might allocate a new value so save the current pool state. */
+    unsigned int pos = get_value_pos();
+    /* Do a numeric computation if possible, otherwise fallback to bitstring
+     * computation. */
+    if (src0->numeric && src1->numeric) {
+        /* Both sources are numeric. */
+        return greater_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return greater_value_defined_bitstring(src0,src1,dst);
+    } else {
+        /* Cannot compute (for now), simply undefines the destination. */
+        /* First ensure dst has the right shape. */
+        copy_value(src0,dst);
+        /* Then make it undefined. */
+        set_undefined_bitstring(dst);
+    }
+    return dst;
+}
+
+
 /** Computes the lesser comparision of two general values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -2461,22 +2709,22 @@ Value lesser_value(Value src0, Value src1, Value dst) {
 }
 
 
-/** Computes the greater comparision of two general values.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+/** Computes the greater or equal comparision of two 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 */
-Value greater_value(Value src0, Value src1, Value dst) {
+Value greater_equal_value(Value src0, Value src1, Value dst) {
     /* Might allocate a new value so save the current pool state. */
     unsigned int pos = get_value_pos();
     /* Do a numeric computation if possible, otherwise fallback to bitstring
      * computation. */
     if (src0->numeric && src1->numeric) {
         /* Both sources are numeric. */
-        return greater_value_numeric(src0,src1,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. */
-        return greater_value_defined_bitstring(src0,src1,dst);
+        return greater_equal_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */
         /* First ensure dst has the right shape. */
@@ -2487,6 +2735,33 @@ Value greater_value(Value src0, Value src1, Value dst) {
     return dst;
 }
 
+/** Computes the lesser or equal comparision of two 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 */
+Value lesser_equal_value(Value src0, Value src1, Value dst) {
+    /* Might allocate a new value so save the current pool state. */
+    unsigned int pos = get_value_pos();
+    /* Do a numeric computation if possible, otherwise fallback to bitstring
+     * computation. */
+    if (src0->numeric && src1->numeric) {
+        /* Both sources are numeric. */
+        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. */
+        return lesser_equal_value_defined_bitstring(src0,src1,dst);
+    } else {
+        /* Cannot compute (for now), simply undefines the destination. */
+        /* First ensure dst has the right shape. */
+        copy_value(src0,dst);
+        /* Then make it undefined. */
+        set_undefined_bitstring(dst);
+    }
+    return dst;
+}
+
+
 
 /** Selects a value depending on a general condition.
  *  @param cond   the condition to use for selecting a value

data/lib/HDLRuby/sim/hruby_sim_vcd.c

@@ -366,8 +366,8 @@ static void vcd_print_header() {
 extern void init_vcd_visualizer(char* name) {
     /* Open the resulting file with name: <name>.vcd */
     char filename[256];
-    strncpy(filename,name,256);
-    strncat(filename,".vcd",256);
+    strncpy(filename,name,255);
+    strncat(filename,".vcd",255);
     vcd_file = fopen(filename,"w");
 
     /* Initialize the vizualizer printer engine. */

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.6.3"
+  VERSION = "2.6.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.6.3
+  version: 2.6.10
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-09 00:00:00.000000000 Z
+date: 2021-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,6 +83,7 @@ files:
 - lib/HDLRuby/hdr_samples/alu.rb
 - lib/HDLRuby/hdr_samples/bstr_bench.rb
 - lib/HDLRuby/hdr_samples/calculator.rb
+- lib/HDLRuby/hdr_samples/comparison_bench.rb
 - lib/HDLRuby/hdr_samples/constant_in_function.rb
 - lib/HDLRuby/hdr_samples/counter_bench.rb
 - lib/HDLRuby/hdr_samples/dff.rb
@@ -102,6 +103,7 @@ files:
 - lib/HDLRuby/hdr_samples/memory_test.rb
 - lib/HDLRuby/hdr_samples/multer_gen.rb
 - lib/HDLRuby/hdr_samples/multer_seq.rb
+- lib/HDLRuby/hdr_samples/multi_timed_bench.rb
 - lib/HDLRuby/hdr_samples/music.rb
 - lib/HDLRuby/hdr_samples/named_sub.rb
 - lib/HDLRuby/hdr_samples/neg_arith_bench.rb
@@ -133,6 +135,7 @@ files:
 - lib/HDLRuby/hdr_samples/sw_encrypt_cpusim_bench.rb
 - lib/HDLRuby/hdr_samples/system_open.rb
 - lib/HDLRuby/hdr_samples/tuple.rb
+- lib/HDLRuby/hdr_samples/type_minmax_bench.rb
 - lib/HDLRuby/hdr_samples/with_channel.rb
 - lib/HDLRuby/hdr_samples/with_class.rb
 - lib/HDLRuby/hdr_samples/with_connector.rb
@@ -147,6 +150,7 @@ files:
 - lib/HDLRuby/hdr_samples/with_memory_rom.rb
 - lib/HDLRuby/hdr_samples/with_multi_channels.rb
 - lib/HDLRuby/hdr_samples/with_reconf.rb
+- lib/HDLRuby/hdr_samples/with_to_array.rb
 - lib/HDLRuby/hdrcc.rb
 - lib/HDLRuby/high_samples/_adder_fault.rb
 - lib/HDLRuby/high_samples/_generic_transmission2.rb