HDLRuby 3.9.1 → 3.9.3

data/README.md

@@ -71,7 +71,11 @@ hdrcc --get-tuto
 
 __What's New__
 
-For HDLRuby version 3.9.0:
+For HDKRuby version 3.9.2:
+
+* Added the `hbreak` command for exiting parallel enumerator loops.
+
+For HDLRuby version 3.9.0/3.9.1:
 
 * Added the parallel enumerators to the software sequencers.
 
@@ -3981,6 +3985,10 @@ Parallel enumerators provide several control methods:
 
 * `+`: Concatenates two enumerators.
 
+Additionaly, it is possible to exit an enumeration loop using the following command:
+
+* `hbreak`: Exits the current enumeration loop.
+
 __Hardware Implementations of Enumerable Methods__
 
 Using parallel enumerators, HDLRuby provides hardware implementations of many Ruby Enumerable methods. These are available for any enumerable object and can be used inside or outside processes.

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -760,6 +760,8 @@ VALUE rcsim_make_unary(VALUE mod, VALUE type, VALUE operator, VALUE child) {
     switch(sym_to_char(operator)) {
         case (unsigned char)'~':         unary->oper = not_value; break;
         case (unsigned char)('-'+'@'*2): unary->oper = neg_value; break;
+        case (unsigned char)'|':   unary->oper = reduce_or_value; break;
+        case (unsigned char)'&':  unary->oper = reduce_and_value; break;
         default: perror("Invalid operator for unary.");
     }
     value_to_rcsim(ExpressionS,child,unary->child);

data/ext/hruby_sim/hruby_sim.h

@@ -252,6 +252,12 @@ extern Value not_value(Value src, Value dst);
  *  @return dst */
 extern Value reduce_or_value(Value src, Value dst);
 
+/** Compute the and of the bits a a value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+extern Value reduce_and_value(Value src, Value dst);
+
 /** Computes the AND of two values.
  *  @param src0 the first source value of the and
  *  @param src1 the second source value of the and

data/ext/hruby_sim/hruby_sim_calc.c

@@ -1348,6 +1348,44 @@ Value reduce_or_value_bitstring(Value src, Value dst) {
     return dst;
 }
 
+/** Compute the and of the bits a bitstring value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_and_value_bitstring(Value src, Value dst) {
+    /* Compute the width of the result in bits. */
+    unsigned long long width = type_width(src->type);
+
+    /* Update the destination capacity if required. */
+    resize_value(dst,width);
+    /* Set the type and size of the destination from the type of the source.*/
+    dst->type = src->type;
+    dst->numeric = 0;
+
+    /* Get access to the source and destination data. */
+    char* src_data = src->data_str;
+    char* dst_data = dst->data_str;
+
+    /* Performs the reduce or. */
+    unsigned long long count;
+    char res = 0;
+    for(count = 0; count < width; ++count) {
+        /* Performs the reduce and. */
+        char d = src_data[count] - '0'; /* Get and convert to bit. */
+        if ((d == (d&1)) && (res != 'x'-'0')) { /* d is defined. */
+            res &= d;
+        } else {
+            /* res is undefined. */
+            res = 'x' - '0';
+        }
+        /* Apart for the first bit, there are only 0, still we are in
+         * the loop, set it. */
+        dst_data[count] = '0';
+    }
+    dst_data[0] = res + '0';
+    /* Return the destination. */
+    return dst;
+}
 
 /** Computes the and of two bitstring values.
  *  @param src0 the first source value of the and
@@ -2280,6 +2318,21 @@ Value reduce_or_value_numeric(Value src, Value dst) {
     return dst;
 }
 
+/** Compute the and of the bits a numeric value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_and_value_numeric(Value src, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src->type;
+    dst->numeric = 1;
+
+    /* Perform the reduce and. */
+    unsigned long long mask = ~(-1LL << type_width(src->type));
+    dst->data_int = fix_numeric_type(dst->type, (~src->data_int & mask) == 0);
+    return dst;
+}
+
 
 /** Computes the AND of two numeric values.
  *  @param src0 the first source value of the addition
@@ -3061,6 +3114,20 @@ Value reduce_or_value(Value src, Value dst) {
     }
 }
 
+/** Compute the and of the bits a value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_and_value(Value src, Value dst) {
+    if (src->numeric) {
+        /* The source is numeric. */
+        return reduce_and_value_numeric(src,dst);
+    } else {
+        /* The source cannot be numeric, compute bitsitrings. */
+        return reduce_and_value_bitstring(src,dst);
+    }
+}
+
 
 /** Computes the AND of two general values. 
  *  @param src0 the first source value of the addition