HDLRuby 2.6.4 → 2.6.15

data/lib/HDLRuby/hruby_low.rb

@@ -1,6 +1,6 @@
 require "HDLRuby/hruby_bstr"
 require "HDLRuby/hruby_error"
-require "HDLRuby/hruby_decorator"
+# require "HDLRuby/hruby_decorator"
 require 'forwardable'
 
 
@@ -36,7 +36,7 @@ module HDLRuby::Low
     end
 
 
-    Hdecorator = HDLRuby::Hdecorator
+    # Hdecorator = HDLRuby::Hdecorator
 
     ##
     # Gives parent definition and access properties to an hardware object.
@@ -118,8 +118,8 @@ module HDLRuby::Low
             end
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
@@ -455,8 +455,8 @@ module HDLRuby::Low
             @behaviors = []
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
@@ -1221,8 +1221,8 @@ module HDLRuby::Low
             @name = name.to_sym
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
@@ -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
@@ -2093,8 +2124,8 @@ module HDLRuby::Low
             # @block = block
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Sets the block if not already set.
         def block=(block)
@@ -2317,8 +2348,8 @@ module HDLRuby::Low
             ref.parent = self
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
@@ -2401,8 +2432,8 @@ module HDLRuby::Low
             false
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Iterates over each object deeply.
         #
@@ -2486,8 +2517,8 @@ module HDLRuby::Low
             @systemTs = [ @systemT ]
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Iterates over each object deeply.
         #
@@ -2618,8 +2649,8 @@ module HDLRuby::Low
             lumps.each { |lump| self.add_lump(lump) }
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Adds a +lump+ of code, it is ment to become an expression or
         # some text.
@@ -2667,8 +2698,8 @@ module HDLRuby::Low
             @chunks = HashName.new
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Adds a +chunk+ to the sensitivity list.
         def add_chunk(chunk)
@@ -2779,7 +2810,7 @@ module HDLRuby::Low
     # NOTE: this is an abstract class which is not to be used directly.
     class Statement
         include Hparent
-        include Hdecorator
+        # include Hdecorator
         
         # Clones (deeply)
         def clone
@@ -3267,8 +3298,8 @@ module HDLRuby::Low
             match.parent = statement.parent = self
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Iterates over each object deeply.
         #
@@ -3592,8 +3623,8 @@ module HDLRuby::Low
             @unit = unit.to_sym
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Iterates over each object deeply.
         #
@@ -4302,8 +4333,8 @@ module HDLRuby::Low
             end
         end
 
-        # Add decorator capability (modifies intialize to put after).
-        include Hdecorator
+        # # Add decorator capability (modifies intialize to put after).
+        # include Hdecorator
 
         # Comparison for hash: structural comparison.
         def eql?(obj)

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_low_resolve.rb

@@ -165,6 +165,30 @@ module HDLRuby::Low
             return false
         end
 
+        ## Gets the systemI the reference comes from if any.
+        def get_systemI
+            # Look for the owner from the name hierarchy.
+            if self.ref.is_a?(RefName) then
+                # Look in the parent hierachy for the sub reference name.
+                parent = self.parent
+                # puts "self.ref.name=#{self.ref.name}"
+                while parent
+                    # puts "parent=#{parent}"
+                    if parent.respond_to?(:get_by_name) then
+                        found = parent.get_by_name(self.ref.name)
+                        # puts "found is a :#{found.class}"
+                        return found if found.is_a?(SystemI)
+                    end
+                    parent = parent.parent
+                end
+                # Not found, look further in the reference hierarchy.
+                return self.ref.get_systemI
+            end
+            # Not from a systemI.
+            # puts "Not from systemI for #{self.name}"
+            return nil
+        end
+
 
         ## Resolves the name of the reference and return the
         #  corresponding object.

data/lib/HDLRuby/hruby_verilog.rb

@@ -134,7 +134,7 @@ module HDLRuby::Low
             if self.name && !self.name.empty? then
                 vname = name_to_verilog(self.name)
                 code << " : #{vname}"
-                self.properties[:verilog_name] = vname
+                # self.properties[:verilog_name] = vname
             end
             code << "\n" if block.each_inner.any?
             # Declaration of "inner" part within "always".
@@ -1371,7 +1371,7 @@ module HDLRuby::Low
         # Converts the system to Verilog code using +renamer+ for producing Verilog-compatible names.
         def to_verilog
             vname = name_to_verilog(self.name)
-            self.properties[:verilog_name] = vname
+            # self.properties[:verilog_name] = vname
             return "#{vname}"
         end
 
@@ -1677,7 +1677,7 @@ module HDLRuby::Low
         def to_verilog
             # Convert unusable characters and return them.
             vname = name_to_verilog(self.name)
-            self.properties[:verilog_name] = vname
+            # self.properties[:verilog_name] = vname
             return "#{vname}"
         end
     end
@@ -1842,7 +1842,7 @@ module HDLRuby::Low
             code = "`timescale 1ps/1ps\n\n"
 
             vname = name_to_verilog(self.name)
-            self.properties[:verilog_name] = vname
+            # self.properties[:verilog_name] = vname
             # Output the module name.
             code << "module #{vname}("
 
@@ -2007,7 +2007,7 @@ module HDLRuby::Low
                 systemT = systemI.systemT
                 code << name_to_verilog(systemT.name) << " "
                 vname = name_to_verilog(systemI.name)
-                systemI.properties[:verilog_name] = vname
+                # systemI.properties[:verilog_name] = vname
                 code << vname << "("
                 # Its ports connections
                 # Inputs

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