HDLRuby 3.9.5 → 3.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2158fa1453147b4f00983a8e182f592a7878a3314fdabb351e79da00c99eb875
-  data.tar.gz: db538f8d85886189c4d309acf9ed6e5e9239e0bbe7a7b380c22a768d20eca52f
+  metadata.gz: d8c62653a5b0c4fa2e8a42e0c1198d3a0e714be890e4caf80058532150117b51
+  data.tar.gz: 6ec87f18f390bebb88d19bffce01a6ab7420d9f82777685d4ec330d0b5f2be34
 SHA512:
-  metadata.gz: 210bf9b4b29db252d1c7364d70aea07473381e8eb5500cf936edae1f01cd67d37cff69e5cff9391b65b6265b3e8261f87ec8335b75cae577379fe70304f0ef78
-  data.tar.gz: 7c4e9e1ff74dcba76224505182b506363f772795a45e1608918d4b60648faed104b3776fdb459964e9900633448bbdb59af6c8259e309d9da329f6834c250f8b
+  metadata.gz: 4f88b4dea7c80c6fda808d63c718f64af2a1e2e8d6371b68ef50757347dc4d5b3232741151494e74f76251a451e03ed498fb2bb1ff85281f524a23ebf4494000
+  data.tar.gz: 49bb526022624a3654097d032ba6314b0725e7a6cbc9d4d82b71996058ba392196152c74e71d64c05a7ab5381866b95a9a357af21de3c447a3505526b6a95e4c

data/README.md

@@ -71,6 +71,24 @@ hdrcc --get-tuto
 
 __What's New__
 
+For HDLRuby version 3.9.6/3.9.7:
+
+* Added the bit-level decoder and the expression decoder.
+
+* Added `auto_connect` for letting HDLRuby looking for the signals to connect to the instances.
+
+* Now, `hbreak` allows end of process if present in the top hif.
+
+* Added bit extension in literals.
+
+* Added the expression hif.
+
+* Added the unary logic operators for bit reduction.
+
+* Removed 'nxor' and added 'eq' instead.
+
+* Various bug fixes.
+
 For HDLRuby version 3.9.3/3.9.4/3.9.5:
 
 * Improved the graphical representation of the RTL code in SVG format for faster generation and better rendering. The tool is still experimental though.
@@ -473,9 +491,9 @@ Conditional statements, common in RTL languages, are also supported in HDLRuby.
 
 These include:
 
-* `hif` / `helsif` / `helse` for `if`-like conditionals
+* `hif` / `helsif` / `helse` for `if`-like conditionals statements and expression.
 
-* `hcase` / `hwhen` / `helse` for `case`-like conditionals
+* `hcase` / `hcasez` / `hwhen` / `helse` for `case`-like conditionals
 
 * `mux`, an expression-level construct for multiplexers, which supports multiple inputs, unlike the ?: ternary operator in Verilog, which only handles two
 
@@ -501,6 +519,29 @@ The conditional logic above can also be written more compactly using the `mux` e
   [cout,z] <= x.as(bit[8..0]) + mux(addbsub, y, ~y + 1)
 ```
 
+Or alternatively, the expression `hif` can be used too:
+
+```ruby
+  [cout,z} <= x.as(bit[8..0] + hif(addbsub,~y + 1, y)
+```
+
+__Note__
+
+ * The `mux` expression orders its choices by selection value, whereas the `hif` expression puts the true case first, as expected for an if condition.
+
+ * The `hif` expressions can be cascades using the dot `.` operator.
+ For example the following code can be rewritten by a simple statement as given in the next code:
+
+```ruby
+hif(x<a)    { z <= 1 }
+helsif(x<b) { z <= 2 }
+helsif(x<c) { z <= 3 }
+helse       { z <= 0 }
+```
+
+```ruby
+z <= hif(x<a,1).(x<b,2).(x<c,3,0)
+```
 
 ---
 
@@ -532,6 +573,43 @@ In this example:
 
 It is also possible to connect only a subset of the ports at instantiation time, and to reconnect or override ports later in the code.
 
+Also, it is possible to let HDLRuby look for the signals to connect using `auto_connect` as shown in the following example:
+
+```ruby
+system :adder do
+  [8].input :x, :y
+  [8].output :z
+
+  z <= x + y
+end
+
+system :using_adder do
+
+  [8].inner :x, :y, :z
+
+  adder(:my_adder).auto_connect
+end
+```
+
+In the example above, HDLRuby will connect automatically the signals `x`, `y`, and `z` from `using_adder` to the adder `my_adder`.
+
+Alternatively, you can ask for auto connecting specific ports by giving the port name only. For example, the above auto connection can be described as follows for signal `x`, while connection of `y` and `z` are not automatic:
+
+```ruby
+system :using_adder do
+
+  [8].inner :x, :y0, :z0
+
+  adder(:my_adder).(x:, y: y0, z: z0)
+end
+```
+
+__Notes__: 
+
+ * Auto connection only works if the names of the signals match exactly those of the instance.
+
+ * Auto connection will ignore the signals whose connection is not found.
+
 ---
 
 To simulate a circuit, you must write a test bench using `timed` constructs, which describe how signals evolve over time.
@@ -1793,7 +1871,7 @@ The behavior of an assignment statement depends on the execution mode of the enc
 
 ### Control Statements
 
-There are two types of control statements in HDLRuby: the hardware if (`hif`) and the hardware case (`hcase`).
+There are two types of control statements in HDLRuby: the hardware if (`hif`) the hardware case (`hcase`), and the hardware case with wildcards (`hcasez`).
 
 #### hif
 
@@ -1820,6 +1898,30 @@ end
 ...
 ```
 
+#### hcasez
+
+The `hcasez` construct consists of an expression and a list of value-block pairs. A block is executed when its corresponding value matches the value of the `hcasez` expression. If the value contains wildcard digits represented by a `z` they match any corresponding digit. It is declared as follows:
+
+```ruby
+hcasez <expression>
+hwhen <value 0> do
+   <block contents 0>
+end
+hwhen <value 1> do
+   <block contents 1>
+end
+...
+```
+
+As an example of wildcard, the following statement will be executed if val is equal to 5 or 7:
+
+```ruby
+hcasez val
+hwhen _b01z1 do
+   <block contents 0>
+end
+```
+
 #### helse
 
 You can add a block that is executed when the condition of an `hif` is not met, or when no case in an hcase matches, using the `helse` keyword:
@@ -1977,7 +2079,7 @@ They include [immediate values](#immediate-values), [reference to signals](#refe
 
 ### Immediate values
 
-mmediate values in HDLRuby can represent vectors of type `bit`, `unsigned`, or `signed`, as well as `integer` or `float` numbers. They are prefixed with an underscore (`_`) and include a header indicating the vector type and the numeric base, followed by the actual number.
+Immediate values in HDLRuby can represent vectors of type `bit`, `unsigned`, or `signed`, as well as `integer` or `float` numbers. They are prefixed with an underscore (`_`) and include a header indicating the vector type and the numeric base, followed by the actual number.
 
 By default, the bit width is inferred from the length of the numeral, but it can also be explicitly specified in the header. Underscores (`_`) can be inserted anywhere within the number to improve readability—they are ignored by the parser.
 
@@ -2006,6 +2108,7 @@ All the following immediate values represent the value `100`, using different ba
 ```ruby
 _bb01100100
 _b8b110_0100
+_8b1100100
 _u8d100
 _s8d100
 _uh64
@@ -2021,6 +2124,10 @@ _o144
 
 __Notes__:
 
+* If the bit width given in the header is smaller than the bit width inferred from the numeral, the upper bits will be truncated. For example, the value of `_2b101` is truncated to `_b01`, i.e., one.
+
+* If the bit width given in the header is larger than the bit width inferred from the numeral, the numeral is extended by duplicating the most significant bit. For example, the value of `_4b1` is extended to `_b1111`, the value of `_8h1` is extended to `_b00000001` and the value of `_5ox` is extended to `_bxxxxx`.
+
 * The form `_01100100` was previously treated as equivalent to `_b01100100`, but due to compatibility issues with recent versions of Ruby, it is now deprecated.
 
 * You may also use Ruby-style immediate values. Their bit width will be automatically adjusted to match the data type of the expression in which they are used. Note, however, that this adjustment may change the value. For example, in the following code, sig is assigned the value `4` (not `100`):
@@ -2113,8 +2220,13 @@ __Logic and Shift Operators:__
 | :---          | :---                          |
 | `&`           | Bitwise/logical AND           |
 | `|`           | Bitwise/logical OR            |
+| `^`           | Bitwise/logical XOR           |
 | `~`           | Bitwise/logical NOT           |
+| `.&`          | Bitwise/logical AND reduction (postfix) |
+| `.|`          | Bitwise/logical OR reduction (postfix) |
+| `.^`          | Bitwise/logical XOR reduction (postfix) |
 | `mux`         | Multiplex                     |
+| `hif`         | Expression if                 |
 | `<<`/`ls`     | Left shift                    |
 | `>>`/`rs`     | Right shift                   |
 | `lr`          | Left rotate                   |
@@ -2150,7 +2262,7 @@ __Notes__:
 
 * Ruby does not allow overriding of the `&&`, `||`, or `?:` (ternary) operators, so they are not available in HDLRuby.
 
-  - Instead of the `?:` operator, HDLRuby provides the more general mux (multiplexer) operator.
+  - Instead of the `?:` operator, HDLRuby provides the more general mux (multiplexer) operator or expression hif operator.
 
   - HDLRuby does not provide replacements for `&&` and `||`; see the [Logic and Shift Operators](#logic-and-shift-operators) section for an explanation.
 
@@ -2189,7 +2301,11 @@ In HDLRuby, all logic operators are bitwise. To perform Boolean logic operations
 
 * Unary: `~`
 
-These behave the same way as their Ruby counterparts.
+* Unary Postfix: `.&`, `.|`, `.^`
+
+The binary and unary operators behave the same way as their Ruby counterparts.
+
+The unary postfix operators are specific to HDLRuby and perform the reduction of the bits of an expression using the indicated boolean operations. For example `_b101.|` results to `1` since `1 or 0 or 1=1`.
 
 __Note__: There are no Boolean (`&&`, `||`) operators in HDLRuby for two reasons:
 
@@ -3735,9 +3851,11 @@ The second construct is the `before` statement that activates a block until a gi
 
 ## Decoder
 
-The decoder library provides a new set of control statements for easily describing instruction decoders.
+The decoder library provides a new set of control statements for easily describing decoders circuits. There are three types of decoder descriptions: the procedural decoders, the bit-level decoders, and the expression decoders. They are detailed in the next sections.
 
-A decoder can be declared anywhere within a module definition using the `decoder` keyword, as shown below:
+### Procedural Decoder
+
+A procedural decoder can be declared anywhere within a module definition using the `decoder` keyword, as shown below:
 
 ```ruby
 decoder(<signal>) <block>
@@ -3778,6 +3896,38 @@ end
 
 Note that field bits do not need to be contiguous. For example, field `z` in the second entry spans non-adjacent bits.
 
+### Bit-level Decoder
+
+The bit-level decoder sets or resets individually a set of bit depending on the values of expressions. It takes as primary argument the list of expressions that are to be decoded, and then a cascade of arguments through the successive use of the `.()` operator as follows:
+
+```ruby
+sig <= decoder(<list of expression>).(out0, vals0).(out1, vals1).(..)
+```
+
+In the code above, `out0`, `out1`, and so, on are the signals whose value is to set or reset, and `vals0`, `vals1` are the corresponding sets of values that are compared to the primary arguments. If the values are equal, the corresponding signal is set, and it is reset otherwise. These values have to be given as an array of expressions, one per primary argument, but can be `nil` for indicating a don't care. For example, with the following code:
+
+```ruby
+decoder(a,b,c).(x,[_b010]).(y,[_b110,nil,_b11]).(z,[_b100,_b01,_b11])
+```
+
+`x` will be 1 if `a` is equal to `_b010`, and 0 otherwise; `y` will be 1 if `a` is equal to `_b110` and `c` is equal to `_b11`, and 0 otherwise; and `z` will be 1 if `a` is equal to `_b100`, `b` is equal to `_b01` and c is equal to `_b11`, and 0 otherwise.
+
+It is also possible to change how the comparisons results are reduced by specifying the operator to use through the last primary argument. For example, the decoder of the previous example can be converted to one which will set the signals if any of the corresponding equalities holds as follows:
+
+```ruby
+decoder(a,b,c,:|).(x,[_b010]).(y,[_b110,nil,_b11]).(z,[_b100,_b01,_b11])
+```
+
+### Expression Decoder
+
+The expression decoder is used as an expression and returns a bit-vector. It takes as argument a list of expressions whose first one is compared to each of the others. In case of equality, the corresponding bit of the result is set, otherwise it is reset. For example, with the following code:
+
+```ruby
+sig <= decoder(x,5,8,9)
+```
+
+`sig` will be `_b100` if `x` equals `5`, `_b010` if `x` equals `8`, `_b001` if `x` equals `9`, and `_b000` otherwise.
+
 
 ## FSM
 
@@ -3994,7 +4144,30 @@ Parallel enumerators provide several control methods:
 
 Additionaly, it is possible to exit an enumeration loop using the following command:
 
-* `hbreak`: Exits the current enumeration loop.
+* `hbreak`: Exits the current enumeration loop, or the current process if present in the top-level `hif` branch of a process when the condition is met. This second usage helps improve the readability of reset conditions, as shown in the following code:
+
+```ruby
+par(clk.posedge) do
+  hif(reset) do
+    <do some reset work>
+    hbreak
+  end
+  <normal execution>
+end
+```
+
+The code above is equivalent to the following one, but it clearly shows that the reset is an exception.
+
+```ruby
+par(clk.posdege) do
+  hif(reset) do
+    <do some reset work>
+  end
+  helse do
+    <normanl execution>
+  end
+end
+```
 
 __Hardware Implementations of Enumerable Methods__
 

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -659,6 +659,28 @@ VALUE rcsim_make_hcase(VALUE mod, VALUE valueV, VALUE defoltV) {
     return res;
 }
 
+/* Creating a hardware casez C object. */
+VALUE rcsim_make_hcasez(VALUE mod, VALUE valueV, VALUE defoltV) {
+    // printf("rcsim_make_hcasez\n");
+    /* Allocates the hardware case. */
+    HCaseZ hcasez = (HCaseZ)malloc(sizeof(HCaseZS));
+    // printf("hcasez=%p\n",hcasez);
+    /* Set it up. */
+    hcasez->kind = HCASEZ;
+    hcasez->owner = NULL;
+    value_to_rcsim(ExpressionS,valueV,hcasez->value);
+    hcasez->num_whens = 0;
+    hcasez->matches = NULL;
+    hcasez->stmnts = NULL;
+    if (TYPE(defoltV) == T_NIL)
+        hcasez->defolt = NULL;
+    else
+        value_to_rcsim(StatementS,defoltV,hcasez->defolt);
+    /* Returns the C hardware case embedded into a ruby VALUE. */
+    VALUE res;
+    rcsim_to_value(HCaseZS,hcasez,res);
+    return res;
+}
 
 /* Creating a block C object. */
 VALUE rcsim_make_block(VALUE mod, VALUE modeV) {
@@ -1927,6 +1949,7 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_make_timeTerminate",rcsim_make_timeTerminate,0);
     rb_define_singleton_method(mod,"rcsim_make_hif",rcsim_make_hif,3);
     rb_define_singleton_method(mod,"rcsim_make_hcase",rcsim_make_hcase,2);
+    rb_define_singleton_method(mod,"rcsim_make_hcasez",rcsim_make_hcasez,2);
     rb_define_singleton_method(mod,"rcsim_make_block",rcsim_make_block,1);
     rb_define_singleton_method(mod,"rcsim_make_value_numeric",rcsim_make_value_numeric,2);
     rb_define_singleton_method(mod,"rcsim_make_value_numeric_63one",rcsim_make_value_numeric_63one,2);

data/ext/hruby_sim/hruby_sim.h

@@ -27,6 +27,7 @@ typedef struct TransmitS_ TransmitS;
 typedef struct PrintS_ PrintS;
 typedef struct HIfS_ HIfS;
 typedef struct HCaseS_ HCaseS;
+typedef struct HCaseZS_ HCaseZS;
 typedef struct TimeWaitS_ TimeWaitS;
 typedef struct TimeRepeatS_ TimeRepeatS;
 typedef struct TimeTerminateS_ TimeTerminateS;
@@ -63,6 +64,7 @@ typedef struct TransmitS_* Transmit;
 typedef struct PrintS_* Print;
 typedef struct HIfS_* HIf;
 typedef struct HCaseS_* HCase;
+typedef struct HCaseZS_* HCaseZ;
 typedef struct TimeWaitS_* TimeWait;
 typedef struct TimeRepeatS_* TimeRepeat;
 typedef struct TimeTerminateS_* TimeTerminate;
@@ -91,7 +93,7 @@ typedef enum {
 #endif
     OBJECT, SYSTEMT, SIGNALI, SCOPE, BEHAVIOR, SYSTEMI, CODE, BLOCK, EVENT,
 #ifdef RCSIM
-    /* Statements */  TRANSMIT, PRINT, HIF, HCASE, 
+    /* Statements */  TRANSMIT, PRINT, HIF, HCASE, HCASEZ,
                       TIME_WAIT, TIME_REPEAT, TIME_TERMINATE,
     /* Expressions */ UNARY, BINARY, SELECT, CONCAT, CAST,
     /* References */  REF_OBJECT, REF_INDEX, REF_RANGE, REF_CONCAT,
@@ -300,6 +302,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 equal (NXOR) of two values treating Z as wildcards.
+ *  @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 equal_value_z(Value src0, Value src1, Value dst);
+
 /** Computes the C equal of two general values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -307,6 +316,13 @@ extern Value equal_value(Value src0, Value src1, Value dst);
  *  @return the destination value */
 extern Value equal_value_c(Value src0, Value src1, Value dst);
 
+/** Computes the C equal of two general values treating Z as wildcards.
+ *  @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 */
+extern Value equal_value_z_c(Value src0, Value src1, Value dst);
+
 /** Computes the C not equal of two general values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -701,6 +717,18 @@ typedef struct HCaseS_ {
     Statement defolt;   /* The default statement. */
 } HCaseS;
 
+/** The C model of a hardware casez statement. */
+typedef struct HCaseZS_ {
+    Kind kind;          /* The kind of object. */
+    Object owner;       /* The owner of the object if any. */
+
+    Expression value;   /* The value to match. */
+    int num_whens;      /* The number of possible cases. */
+    Expression* matches;/* The cases matching values. */
+    Statement* stmnts;  /* The corresponding statements. */
+    Statement defolt;   /* The default statement. */
+} HCaseZS;
+
 /** The C model of a time wait statement. */
 typedef struct TimeWaitS_ {
     Kind kind;          /* The kind of object. */

data/ext/hruby_sim/hruby_sim_calc.c

@@ -1733,44 +1733,44 @@ static Value shift_right_value_bitstring(Value src0, Value src1, Value dst) {
 }
 
 
-/** Computes the equal (!XOR) of two bitstring values.
+/** computes the equal (!xor) of two bitstring values.
  *  @param src0 the first source value of the and
  *  @param src1 the second source value of the and
  *  @param dst the destination value
  *  @return dst */
 static Value equal_value_bitstring(Value src0, Value src1, Value dst) {
     // printf("equal_value_bitstring.\n");
-    /* Compute the width of sources in bits. */
+    /* compute the width of sources in bits. */
     unsigned long long width0 = type_width(src0->type);
     unsigned long long width1 = type_width(src1->type);
 
-    /* Update the destination capacity if required. */
+    /* update the destination capacity if required. */
     resize_value(dst,width0);
-    /* Set the type and size of the destination from the type of the source.*/
+    /* set the type and size of the destination from the type of the source.*/
     dst->type = src0->type;
     dst->numeric = 0;
 
-    /* Get access to the data of the sources. */
+    /* get access to the data of the sources. */
     char *src0_data = src0->data_str;
     char *src1_data = src1->data_str;
-    /* Get access to the data of the destination. */
+    /* get access to the data of the destination. */
     char *dst_data = dst->data_str;
 
-    /* Get the sign extension character of source 1 and convert it to a bit.*/
+    /* get the sign extension character of source 1 and convert it to a bit.*/
     int ext = bitstring_ext(src1);
 
-    /* Perform the !xor. */
+    /* perform the !xor. */
     unsigned long long count;
-    /* Check if values are the same. */
+    /* check if values are the same. */
     char same = '1';
     for(count = 0; count < width0; ++count) {
-        char d0 = src0_data[count] - '0'; /* Get and convert to bit. */
+        char d0 = src0_data[count] - '0'; /* get and convert to bit. */
         char d1;
         if (count < width1) {
-            /* Still within source 1. */
-            d1 = src1_data[count] - '0';/* Get and convert to bit. */
+            /* still within source 1. */
+            d1 = src1_data[count] - '0';/* get and convert to bit. */
         } else {
-            /* Outside source 1, use the sign extension. */
+            /* outside source 1, use the sign extension. */
             d1 = ext;
         }
         if (d0 == (d0&1)) {
@@ -1782,22 +1782,98 @@ static Value equal_value_bitstring(Value src0, Value src1, Value dst) {
                     break;
                 }
             } else  {
-                /* Undefined. */
+                /* undefined. */
                 same = 'x';
                 break;
             }
         } else {
-            /* Undefined. */
+            /* undefined. */
             same = 'x';
             break;
         }
     }
-    /* Set the destination to 0 or 1 depending of different. */
+    /* set the destination to 0 or 1 depending of different. */
     dst_data[0] = same;
     for(count = 1; count < width0; ++count) {
         dst_data[count] = '0';
     }
-    /* Return the destination. */
+    /* return the destination. */
+    return dst;
+}
+
+/** computes the equal (!xor) of two bitstring values treating Z as wildcard.
+ *  @param src0 the first source value of the and
+ *  @param src1 the second source value of the and
+ *  @param dst the destination value
+ *  @return dst */
+static Value equal_value_z_bitstring(Value src0, Value src1, Value dst) {
+    // printf("equal_value_bitstring.\n");
+    /* compute the width of sources in bits. */
+    unsigned long long width0 = type_width(src0->type);
+    unsigned long long width1 = type_width(src1->type);
+
+    /* update the destination capacity if required. */
+    resize_value(dst,width0);
+    /* set the type and size of the destination from the type of the source.*/
+    dst->type = src0->type;
+    dst->numeric = 0;
+
+    /* get access to the data of the sources. */
+    char *src0_data = src0->data_str;
+    char *src1_data = src1->data_str;
+    /* get access to the data of the destination. */
+    char *dst_data = dst->data_str;
+
+    /* get the sign extension character of source 1 and convert it to a bit.*/
+    int ext = bitstring_ext(src1);
+
+    /* perform the !xor. */
+    unsigned long long count;
+    /* check if values are the same. */
+    char same = '1';
+    for(count = 0; count < width0; ++count) {
+        char d0 = src0_data[count] - '0'; /* get and convert to bit. */
+        char d1;
+        if (d0 == 'z' - '0' || d0 == 'Z' - '0') {
+            /* Z is wildcard, so same. */
+            continue;
+        }
+        if (count < width1) {
+            /* still within source 1. */
+            d1 = src1_data[count] - '0';/* get and convert to bit. */
+        } else {
+            /* outside source 1, use the sign extension. */
+            d1 = ext;
+        }
+        if (d1 == 'z' - '0' || d1 == 'Z' - '0') {
+            /* Z is wildcard, so same. */
+            continue;
+        }
+        if (d0 == (d0&1)) {
+            /* d0 is defined. */
+            if (d1 == (d1&1)) {
+                /* d1 is also defined. */
+                if (d0 != d1) {
+                    same = '0';
+                    break;
+                }
+            } else  {
+                /* undefined. */
+                same = 'x';
+                break;
+            }
+        } else {
+            /* undefined. */
+            same = 'x';
+            break;
+        }
+    }
+    /* set the destination to 0 or 1 depending of different. */
+    dst_data[0] = same;
+    for(count = 1; count < width0; ++count) {
+        dst_data[count] = '0';
+    }
+    /* return the destination. */
     return dst;
 }
 
@@ -3299,7 +3375,7 @@ Value shift_right_value(Value src0, Value src1, Value dst) {
 }
 
 
-/** Computes the equal (!XOR) of two general values.
+/** Computes the equal (NXOR) 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
@@ -3336,6 +3412,43 @@ Value equal_value(Value src0, Value src1, Value dst) {
     return dst;
 }
 
+/** Computes the equal (NXOR) 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 the destination value */
+Value equal_value_z(Value src0, Value src1, Value dst) {
+    // printf("equal_value.\n");
+    /* 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) {
+        if (src1->numeric) {
+            // printf("numeric numeric\n");
+            /* Both sources are numeric. */
+            return equal_value_numeric(src0,src1,dst);
+        } else {
+            // printf("numeric bitstring\n");
+            /* src1 is not numeric, convert src0 to bitstring. */
+            src0 = set_bitstring_value(src0,get_value());
+        }
+    } else {
+        /* src0 is not numeric, what about src1. */
+        if (src1->numeric) {
+            // printf("bitstring numeric\n");
+            /* src1 is numeric, convert it to bitstring. */
+            src1 = set_bitstring_value(src1,get_value());
+        }
+    }
+    /* The sources cannot be numeric, compute bitsitrings. */
+    dst = equal_value_z_bitstring(src0,src1,dst);
+    /* Restores the pool of values. */
+    set_value_pos(pos);
+    /* Return the destination. */
+    return dst;
+}
+
 
 /** Computes the C equal of two general values.
  *  @param src0 the first source value of the addition
@@ -3347,6 +3460,16 @@ Value equal_value_c(Value src0, Value src1, Value dst) {
     return reduce_or_value(dst,dst);
 }
 
+/** Computes the C equal of two general values treating Z as wildcards.
+ *  @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 */
+Value equal_value_z_c(Value src0, Value src1, Value dst) {
+    dst = equal_value_z(src0,src1,dst);
+    return reduce_or_value(dst,dst);
+}
+
 
 /** Computes the C not equal of two general values.
  *  @param src0 the first source value of the addition