HDLRuby 3.9.3 → 3.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b1202930bb068b286b20287846f5c89bbdc4b7a2361aad7719252fa23f72a9
-  data.tar.gz: 612ee6e9bfacfa5f670a138adf77c9924a182f1ea4ad7b48a1c5d25a49aabf89
+  metadata.gz: 00a784914e79391b0aa065086641989892907de384b64b3b43b221587076fcf4
+  data.tar.gz: b53f9aa4f668cd8a736f476b4c8b86572ec8572f00f09ba85bfd484e67ff3fc6
 SHA512:
-  metadata.gz: 53a81f6c68706a774377e4b2bb5de7b2c9e0432150c8b98803d26208b1ed195d164d1bbcbe0d9ba9824ed5624d82ccfc35e35b104f251da84300a7b38d255fd2
-  data.tar.gz: 16d7a500401513cd49550d58204497735f70540d09230701a9222fac24c515bb7a7bc10e30a118fc4bcf2a6b49f38578b4ce914abf3e0affdb7bfa6ea93e8e64
+  metadata.gz: 0e35ec948e04837424e7a2992a9f06aa15d580305c68688bdf22270b73b762f759bb7c76785f3866dd2abc25a1eaf6835005e622467458e2b9ad04134839ab62
+  data.tar.gz: 3a3a557df353dff6b0203dcbc28fc3231d76fd6a7b7b29853061ac5451dc9a375f272f46adbb8b9ad4a838992f27097c443f0817c19d565103c2ffb0a0d343bf

data/README.md

@@ -71,7 +71,14 @@ hdrcc --get-tuto
 
 __What's New__
 
-For HDKRuby version 3.9.2:
+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.
+
+* Fixed various bugs.
+
+
+For HDLRuby version 3.9.2:
 
 * Added the `hbreak` command for exiting parallel enumerator loops.
 
@@ -468,7 +475,7 @@ These include:
 
 * `hif` / `helsif` / `helse` for `if`-like conditionals
 
-* `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
 
@@ -1786,7 +1793,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
 
@@ -1813,6 +1820,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:

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) {
@@ -688,6 +710,7 @@ VALUE rcsim_make_value_numeric(VALUE mod, VALUE typeV, VALUE contentV) {
     /* Get the type. */
     Type type;
     value_to_rcsim(TypeS,typeV,type);
+    // printf("type=%llu\n",type_width(type));
     /* Create the value. */
     Value value = make_value(type,0);
     // printf("value=%p\n",value);
@@ -703,6 +726,28 @@ VALUE rcsim_make_value_numeric(VALUE mod, VALUE typeV, VALUE contentV) {
     return res;
 }
 
+/* Creating a numeric value C object forcing bit 63 to one. */
+VALUE rcsim_make_value_numeric_63one(VALUE mod, VALUE typeV, VALUE contentV) {
+    // printf("rcsim_make_value_numeric_63one\n");
+    /* Get the type. */
+    Type type;
+    value_to_rcsim(TypeS,typeV,type);
+    // printf("type=%llu\n",type_width(type));
+    /* Create the value. */
+    Value value = make_value(type,0);
+    // printf("value=%p\n",value);
+    /* Set it to numeric. */
+    value->numeric = 1;
+    value->capacity = 0;
+    value->data_str = NULL;
+    value->data_int = NUM2LL(contentV) | 0x8000000000000000ULL;
+    // printf("value->data_int=%lld\n",value->data_int);
+    /* Returns the C value embedded into a ruby VALUE. */
+    VALUE res;
+    rcsim_to_value(ValueS,value,res);
+    return res;
+}
+
 
 /* Creating a bitstring value C object. */
 VALUE rcsim_make_value_bitstring(VALUE mod, VALUE typeV, VALUE contentV) {
@@ -1904,8 +1949,10 @@ 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);
     rb_define_singleton_method(mod,"rcsim_make_value_bitstring",rcsim_make_value_bitstring,2);
     rb_define_singleton_method(mod,"rcsim_make_cast",rcsim_make_cast,2);
     rb_define_singleton_method(mod,"rcsim_make_unary",rcsim_make_unary,3);

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

@@ -327,6 +327,7 @@ Value copy_value(Value src, Value dst) {
     /* Copy the data. */
     if (src->numeric) {
         /* Numeric copy. */
+        // printf("copy_value with data_in: %llu\n", src->data_int);
         dst->data_int = fix_numeric_type(dst->type,src->data_int);
     } else {
         // printf("copy_value with bit string: %.*s\n",src->capacity,src->data_str);
@@ -1732,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)) {
@@ -1781,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;
 }
 
@@ -2166,7 +2243,6 @@ fix_numeric_type(Type type, unsigned long long val) {
     if (type->flags.sign) {
         /* Yes, perform sign extension. */
         int is_neg = (val >> (width-1)) & 1;
-        // printf("is_neg=%i\n",is_neg);
         if (is_neg) {
             /* Negative sign extension. */
             return val | mask;
@@ -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

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -471,6 +471,43 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                 }
                 break;
             }
+        case HCASEZ:
+            {
+                HCaseZ hcasez = (HCaseZ)stmnt;
+                /* Calculation the value to check. */
+                // Value value = calc_expression(hcasez->value);
+                Value value = get_value();
+                value = calc_expression(hcasez->value,value);
+                /* Tell if a casez if matched. */
+                int met = 0;
+                /* Check each case. */
+                Value cmp = get_value();
+                for(int i=0; i<hcasez->num_whens; ++i) {
+                    // cmp = equal_value_z_c(value,calc_expression(hcasez->matches[i]),
+                    //         cmp);
+                    Value match = get_value();
+                    match = calc_expression(hcasez->matches[i],match);
+                    cmp = equal_value_z_c(value,match,cmp);
+                    if (is_defined_value(cmp) && value2integer(cmp)) {
+                        /* Found the right case, execute the corresponding
+                         * statement. */
+                        execute_statement(hcasez->stmnts[i],mode,behavior);
+                        /* And remeber it. */
+                        met = 1;
+                        free_value();
+                        break;
+                    }
+                    free_value();
+                }
+                free_value();
+                free_value();
+                /* Was no case found and is there a default statement? */
+                if (!met && hcasez->defolt) {
+                    /* Yes, execute the default statement. */
+                    execute_statement(hcasez->defolt,mode,behavior);
+                }
+                break;
+            }
         case TIME_WAIT:
             {
                 /* Get the value of the delay. */

data/lib/HDLRuby/hdr_samples/case_bench.rb

@@ -1,4 +1,4 @@
-# Test the comparison operators.
+# Test the case.
 
 # A benchmark for the case statement.
 system :case_bench do

data/lib/HDLRuby/hdr_samples/constant_prop_bench.rb

@@ -16,8 +16,8 @@ system :dff_bench do
     [8].inner :count
     [8].constant inc: 5
 
-    # counter(:my_counter).(clk,rst,inc,count)
-    counter(:my_counter).(clk,rst,5,count)
+    counter(:my_counter).(clk,rst,inc,count)
+    # counter(:my_counter).(clk,rst,5,count)
 
     # par do
     #     my_counter.inc <= 5

data/lib/HDLRuby/hdr_samples/logic_bench.rb

@@ -2,25 +2,25 @@
 # A benchmark for the logic operations.
 system :logic_bench do
     [3].inner :x,:y
-    [3].inner :s_not, :s_and, :s_or, :s_xor, :s_nxor
+    [3].inner :s_not, :s_and, :s_or, :s_xor, :s_eq
     
     signed[16].inner :a,:b,:shl,:shr
 
     timed do
         8.times do |i|
             8.times do |j|
-                x      <= i
-                y      <= j
-                s_not  <= ~x
-                s_and  <= x & y
-                s_or   <= x | y
-                s_xor  <= x ^ y
-                s_nxor <= (x == y)
+                x     <= i
+                y     <= j
+                s_not <= ~x
+                s_and <= x & y
+                s_or  <= x | y
+                s_xor <= x ^ y
+                s_eq  <= (x == y)
                 !10.ns
-                a      <= i
-                b      <= j
-                shl    <= (a << b)
-                shr    <= (a >> b)
+                a     <= i
+                b     <= j
+                shl   <= (a << b)
+                shr   <= (a >> b)
             end
         end
     end

data/lib/HDLRuby/hdr_samples/with_assign_to_slice.rb

@@ -0,0 +1,19 @@
+system :assign_to_slice do
+  [8].inner :reg
+
+  timed do
+    !10.ns
+    reg[1..0] <= _b00
+    !10.ns
+    reg[3..2] <= _b01
+    !10.ns
+    reg[5..4] <= _b10
+    !10.ns
+    reg[7..6] <= _b11
+    !10.ns
+    reg[3..0] <= _ha
+    !10.ns
+    reg[7..4] <= _h5
+    !10.ns
+  end
+end

data/lib/HDLRuby/hdr_samples/with_casez.rb

@@ -0,0 +1,35 @@
+# Test the casez statement.
+
+# A benchmark for the case statement.
+system :case_bench do
+    [8].inner :x, :z
+
+    par do
+        hcasez(x)
+        hwhen(_b0000_0000)  { z <= 0 }
+        hwhen(_b000z_0001)  { z <= 1 }
+        hwhen(_b00z0_0010)  { z <= 4 }
+        hwhen(_b00zz_0011)  { z <= 9 }
+        hwhen(_b0z00_0100)  { z <= 16 }
+        hwhen(_b0z0z_0101)  { z <= 25 }
+        hwhen(_b0zz0_0110)  { z <= 36 }
+        hwhen(_b0zzz_0111)  { z <= 49 }
+        hwhen(_bz000_1000)  { z <= 64 }
+        hwhen(_bz00z_1001)  { z <= 81 }
+        hwhen(_bz0z0_1010) { z <= 100 }
+        hwhen(_bz0zz_1011) { z <= 121 }
+        hwhen(_bzz00_1100) { z <= 144 }
+        hwhen(_bzz0z_1101) { z <= 169 }
+        hwhen(_bzzz0_1110) { z <= 196 }
+        hwhen(_bzzzz_1111) { z <= 225 }
+        helse    { z <= _zzzzzzzz }
+    end
+
+    timed do
+        !10.ns
+        20.times do |i|
+            x <= i
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_henumerable.rb

@@ -344,7 +344,7 @@ system :henmerable_checks do
 
   par(clk.posedge) do
     # hprint("}0\n")
-    vals.hzip([_h12]*8).each_with_index { |(a,b),i| res62[i] <= a+b }
+    vals.hzip([_h12]*8).heach_with_index { |(a,b),i| res62[i] <= a+b }
   end
 
   # Test enumerators of values.