HDLRuby 3.9.6 → 3.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00a784914e79391b0aa065086641989892907de384b64b3b43b221587076fcf4
-  data.tar.gz: b53f9aa4f668cd8a736f476b4c8b86572ec8572f00f09ba85bfd484e67ff3fc6
+  metadata.gz: d8c62653a5b0c4fa2e8a42e0c1198d3a0e714be890e4caf80058532150117b51
+  data.tar.gz: 6ec87f18f390bebb88d19bffce01a6ab7420d9f82777685d4ec330d0b5f2be34
 SHA512:
-  metadata.gz: 0e35ec948e04837424e7a2992a9f06aa15d580305c68688bdf22270b73b762f759bb7c76785f3866dd2abc25a1eaf6835005e622467458e2b9ad04134839ab62
-  data.tar.gz: 3a3a557df353dff6b0203dcbc28fc3231d76fd6a7b7b29853061ac5451dc9a375f272f46adbb8b9ad4a838992f27097c443f0817c19d565103c2ffb0a0d343bf
+  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,7 +491,7 @@ 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` / `hcasez` / `hwhen` / `helse` for `case`-like conditionals
 
@@ -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.
@@ -2001,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.
 
@@ -2030,6 +2108,7 @@ All the following immediate values represent the value `100`, using different ba
 ```ruby
 _bb01100100
 _b8b110_0100
+_8b1100100
 _u8d100
 _s8d100
 _uh64
@@ -2045,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`):
@@ -2137,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                   |
@@ -2174,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.
 
@@ -2213,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:
 
@@ -3759,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.
+
+### Procedural Decoder
 
-A decoder can be declared anywhere within a module definition using the `decoder` keyword, as shown below:
+A procedural decoder can be declared anywhere within a module definition using the `decoder` keyword, as shown below:
 
 ```ruby
 decoder(<signal>) <block>
@@ -3802,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
 
@@ -4018,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/lib/HDLRuby/hdr_samples/with_auto_connect.rb

@@ -0,0 +1,40 @@
+# A test of auto connection.
+
+
+system :adder8 do
+  [8].input :x, :y
+  [8].output :z
+
+  z <= x + y
+end
+
+system :adder do |n|
+  [n].input :x, :y
+  [n].output :s
+
+  s <= x + y
+end
+
+
+# A benchmark for testing the auto connection.
+system :auto_connect_bench do
+
+  [8].inner :x, :y, :z #, :s # For checking non-existant signal
+
+  adder8(:my_adder8).auto_connect
+  adder(8).(:my_adder).auto_connect
+
+  timed do
+    x <= 0
+    y <= 0
+    !10.ns
+    x <= x + 1
+    !10.ns
+    y <= y + 1
+    !10.ns
+    x <= x + 1
+    !10.ns
+    y <= y + 1
+    !10.ns
+  end
+end

data/lib/HDLRuby/hdr_samples/with_expr_decoder.rb

@@ -0,0 +1,38 @@
+# Test the expression decodor syntatic sugars.
+
+# A benchmark for the expression decoder.
+system :expr_decoder_bench do
+  [8].inner :x, :y, :z
+  inner :a,:b,:c, :u, :v, :w, :s
+
+  seq do
+    decoder(x,y,z).(u,[1,2,3]).(v,[1]).(w,[nil,nil,3])
+    [a,b,c] <= decoder(x,1,2,3)
+    decoder(x,y,z,:|).(s,[1,2,3])
+  end
+
+  timed do
+    !10.ns
+    x <= 0
+    y <= 1
+    z <= 2
+    !10.ns
+    x <= 0
+    y <= 1
+    z <= 3
+    !10.ns
+    x <= 1
+    y <= 2
+    z <= 0
+    !10.ns
+    x <= 1
+    y <= 2
+    z <= 3
+    !10.ns
+    x <= 2
+    !10.ns
+    x <= 3
+    !10.ns
+  end
+end
+

data/lib/HDLRuby/hdr_samples/with_expr_hif.rb

@@ -0,0 +1,34 @@
+# Test the expression if syntatic sugars.
+
+# A benchmark for the expression if.
+system :expr_if_bench do
+  [8].inner :x, :y, :z, :a, :b, :c, :d, :u, :v, :w, :s
+
+  seq do
+    u <= hif(x < y, a, b)
+    v <= hif(x < y, a).(b)
+    w <= hif(x < y, a).(x < z, b, c)
+    s <= hif(x < y, a).(x < z, b).(y < z, c, d)
+  end
+
+  timed do
+    !10.ns
+    a <= 1
+    b <= 2
+    c <= 3
+    d <= 4
+    x <= 0
+    y <= 1
+    z <= 2
+    !10.ns
+    x <= x + 1
+    !10.ns 
+    x <= x + 1
+    !10.ns
+    x <= x + 1
+    !10.ns
+    y <= x
+    !10.ns
+  end
+end
+

data/lib/HDLRuby/hdr_samples/with_hbreak.rb

@@ -0,0 +1,42 @@
+system :with_hbreak do
+
+    # The clock and reset
+    inner :clk, :rst
+
+    # A counter.
+    [8].inner :count
+
+    par(clk.posedge) do
+      hif(rst) do
+        count <= 0
+        hbreak
+      end
+      # helse { count <= count + 1 }
+      count <= count + 1
+    end
+
+
+    timed do
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        64.times do
+            clk <= 0
+            !10.ns
+            clk <= 1
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_values.rb

@@ -75,5 +75,8 @@ system :with_values do
         !10.ns
         v8 <= _CST
         !10.ns
+        v8 <= _8b1
+        v16 <= _16hx
+        !10.ns
     end
 end

data/lib/HDLRuby/hruby_high.rb

@@ -1431,7 +1431,15 @@ module HDLRuby::High
         # NOTE:
         #  * the else part is defined through the helse method.
         #  * a behavior is created to enclose the hif.
-        def hif(condition, mode = nil, &ruby_block)
+        def hif(condition, mode = nil, other = nil, &ruby_block)
+            if mode and !mode.is_a?(Symbol) then
+              if ruby_block then
+                raise AnyError, "Error: expression hif with a block."
+              end
+              # Expression hif case: 'mode' is interpreted as the 
+              # expression of the condition is true, 'other'if it is false.
+              return EIfMaker.new(condition,mode,other)
+            end
             return if self.metaif(condition,&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
@@ -2600,6 +2608,32 @@ module HDLRuby::High
                     end
                 end
             end
+            return self
+        end
+
+        # Auto connects signals of the system instance.
+        #
+        # NOTE: the connections are looked for automatically by name in 
+        # the system the instance is placed.
+        def auto_connect
+          # Gather the names of the signals to connect.
+          names = self.systemT.each_signal_with_included.map do |sig| 
+            sig.name
+          end
+          # Look for the right signals in the current context.
+          signals = []
+          High.top_user.instance_eval do
+            names.dup.each_with_index do |name,i| 
+              begin
+                signals << send(name)
+              rescue NotDefinedError => e
+                # Signal not found so no connection.
+                names.delete(name)
+              end
+            end
+          end
+          # Do the connection.
+          self.call(names.zip(signals).to_h) 
         end
 
         # Gets an exported element (signal or system instance) by +name+.
@@ -3093,6 +3127,66 @@ module HDLRuby::High
 
 
 
+    ##
+    # Class for building multiplexers from expression ifs.
+    #
+    # Note: expression if does not exist in HDLRuby, this is a syntactic
+    # sugar.
+    class EIfMaker
+      # Create a new multiplexer generator from if expression with
+      # +cond+ as boolean selection, +texpr+ the expression to use if 
+      # +cond+ is true +fexpr+ the expression to use if false.
+      # Note: +fexpr+ can be false, it it is the case, the call operator
+      # has to be used to give it.
+      def initialize(cond,texpr,fexpr = nil)
+        @cond = cond
+        @texpr = texpr
+        @fexpr = fexpr
+      end
+
+      # Replace the expression (fexpr) to use if the condition is false.
+      # If +epxr1+ is given, create an expression whose condition is expr0
+      # otherwise, use expression as fexpr.
+      def call(expr0,expr1 = nil,expr2 = nil)
+        if @fexpr then
+          if @fexpr.is_a?(EIfMaker) then
+            # Complete the fexpr.
+            @fexpr = @fexpr.call(expr0,expr1,expr2)
+          else
+            raise AnyError, "The expression to use if the condition is false is already set."
+          end
+        elsif expr1 then
+          @fexpr = EIfMaker.new(expr0,expr1,expr2)
+        else
+          @fexpr = expr0
+        end
+        return self
+      end
+
+      # Convert the expression if to an expression mux.
+      def to_expr
+        return HDLRuby::High.top_user.mux(@cond.to_expr == 0, @texpr.to_expr, @fexpr.to_expr)
+      end
+
+      [:"-@",:"+@",:"~", :abs,
+       :boolean, :bit, :signed, :unsigned].each do |operator|
+         define_method(operator) do
+           self.to_expr.send(operator)
+         end
+       end
+
+      [:"+",:"-",:"*",:"/",:"%",:"**",
+       :"&",:"|",:"^",
+       :"<<",:">>",# :ls,:rs,:lr,:rr, # ls, rs lr and rr are treated separately
+       :"==",:"!=",:"<",:">",:"<=",:">="].each do |operator|
+         define_method(operator) do |expr|
+           self.to_expr.send(operator,expr)
+         end
+       end
+
+    end
+
+
     ##
     # Module giving high-level expression properties
     module HExpression
@@ -4615,7 +4709,15 @@ module HDLRuby::High
         #
         # NOTE: the else part is defined through the helse method.
         # def hif(condition, mode = nil, &ruby_block)
-        def hif(condition, mode = self.mode, &ruby_block)
+        def hif(condition, mode = self.mode, other = nil, &ruby_block)
+            if mode and !mode.is_a?(Symbol) then
+              if ruby_block then
+                raise AnyError, "Error: expression hif with a block."
+              end
+              # Expression hif case: 'mode' is interpreted as the 
+              # expression of the condition is true, 'other'if it is false.
+              return EIfMaker.new(condition,mode,other)
+            end
             return if self.metaif(condition,&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
@@ -5308,6 +5410,13 @@ module HDLRuby::High
         end
     end
 
+    # Extends the NilClass to act as an empty statement.
+    class ::NilClass
+      # Does nothing.
+      def hif(*args)
+      end
+    end
+
     # Extends the String class for computing conversion to expression.
     class ::String
         # # Converts to a new high-level expression.
@@ -5632,7 +5741,8 @@ module HDLRuby::High
             # Get and check the type
             # type = str[0]
             type = str[1]
-            if ["0", "1", "z", "Z", "o", "d", "h"].include?(type) then
+            if ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
+                "z", "Z", "o", "d", "h"].include?(type) then
                 # Default binary
                 type = "b"
             else
@@ -5734,6 +5844,9 @@ module HDLRuby::High
                 # Unknown type
                 return nil
             end
+            # Extends by duplicating the upper bit if the width is too 
+            # large.
+            value = value.rjust(width,value[0])
             # puts "type.width=#{type.width}, value=#{value}"
             # Create and return the value.
             return Value.new(type,value)

data/lib/HDLRuby/std/decoder.rb

@@ -182,6 +182,76 @@ module HDLRuby::High::Std
     end
 
 
+    ##
+    # Class for building an expression decoder.
+    #
+    class EDecoderMaker
+      # Create a new decoder generator for input +sig+ that returns an
+      # array of bits for each value from +vals+ that matches given as
+      # subsequent arguments.
+      # Note: supports chaining using the call operator in wich case
+      # [sig,*value] is treated as a composite input signal and each set
+      # of values is given by the susequent call.
+      def initialize(sig,*values)
+        @sig = sig
+        @values = values
+        if @values.last.is_a?(::Symbol) then
+          @op = @values.pop
+        else
+          @op = :&
+        end
+        @targets = nil
+      end
+
+      # Add a decoder line in composite case.
+      # +target+ is the target bit and +set+ is the of values which sets
+      # the target
+      def call(target,set)
+        if @targets then
+          # Already composite, add the values.
+          @targets << target
+          @values << set
+        else
+          # Transform the decoder with composite values.
+          @sig = [ @sig, *@values ]
+          @targets = [ target ]
+          @values = [ set ]
+        end
+
+        # Generate the decode line.
+        target <= @sig.map.with_index do |sig,i|
+          set[i] ? (sig.to_expr == set[i]).as(HDLRuby::High.bit) : HDLRuby::High.top_user._b1
+        end.reduce(@op)
+
+        return self
+      end
+
+      # Convert the expression if to an expression mux.
+      def to_expr
+        raise "Not an expression decoder." if @targets
+        return @values.map do |set|
+          (@sig.to_expr == set).as(HDLRuby::High.bit)
+        end.to_expr
+      end
+
+      [:"-@",:"+@",:"~", :abs,
+       :boolean, :bit, :signed, :unsigned].each do |operator|
+         define_method(operator) do
+           self.to_expr.send(operator)
+         end
+       end
+
+      [:"+",:"-",:"*",:"/",:"%",:"**",
+       :"&",:"|",:"^",
+       :"<<",:">>",# :ls,:rs,:lr,:rr, # ls, rs lr and rr are treated separately
+       :"==",:"!=",:"<",:">",:"<=",:">="].each do |operator|
+         define_method(operator) do |expr|
+           self.to_expr.send(operator,expr)
+         end
+       end
+
+    end
+
 
 
     ## Declare a new decoder.
@@ -192,6 +262,11 @@ module HDLRuby::High::Std
     #
     #  If provided, +ruby_block+ the fsm is directly instantiated with it.
     def decoder(*args, &ruby_block)
+        # Is it an expression decoder?
+        unless ruby_block then
+          # Yes.
+          return EDecoderMaker.new(*args)
+        end
         # Sets the name if any
         unless args[0].respond_to?(:to_expr) then
             name = args.shift.to_sym

data/lib/HDLRuby/std/hruby_enum.rb

@@ -1261,4 +1261,107 @@ module HDLRuby::High::Std
     end
   end
 
+  module BlockHBreak
+    # Build the block by executing +ruby_block+.
+    def build(&ruby_block)
+      High.space_push(@namespace)
+      cur_hbreak = true
+      catch(:HDLRubyThrow) do
+        @return_value = High.top_user.instance_eval(&ruby_block)
+        cur_hbreak = false
+      end
+      @hbreak = true if cur_hbreak
+      High.space_pop
+      @return_value
+    end
+
+    # # Creates and adds a new block executed in +mode+, with possible
+    # # +name+ and built by executing +ruby_block+.
+    # def add_block(mode = nil, name = :"", &ruby_block)
+    #   # Creates the block.
+    #   block = High.make_block(mode,name,&ruby_block)
+    #   # Adds it as a statement.
+    #   self.add_statement(block)
+    #   # Handle the breaks if any.
+    #   @hbreak = block.hbreak
+    #   # Use its return value.
+    #   return block.return_value
+    # end
+
+    # Adds a +statement+.
+    #
+    # NOTE: TimeWait is not supported unless for TimeBlock objects.
+    def add_statement(statement)
+      res = super(statement)
+      hbrk = statement.instance_variable_get(:@hbreak)
+      @hbreak = hbrk if hbrk
+      return res
+    end
+  end
+
+  HDLRuby::High::Block.prepend(BlockHBreak)
+
+  module IfHBreak
+    # Creates a new if statement with a +condition+ that when met lead
+    # to the execution of the block in +mode+ generated by the execution of
+    # +ruby_block+.
+    def initialize(condition, mode = nil, &ruby_block)
+      super
+      hbrk = yes.instance_variable_get(:@hbreak)
+      @hbreak = hbrk if hbrk
+    end
+
+    # Sets the no block.
+    #
+    # No shoud only be set once, but this is not checked here for
+    # sake of flexibility.
+    def no=(no)
+      res = super(no)
+      hbrk = no.instance_variable_get(:@hbreak)
+      raise AnyError, "Invalid hbreak." if hbrk
+      return res
+    end
+
+    # Adds an alternative if statement (elsif) testing +next_cond+
+    # and executing +next_yes+ when the condition is met.
+    def add_noif(next_cond, next_yes)
+      res = super(next_cond,next_yes)
+      hbrk = next_yes.instance_variable_get(:@hbreak)
+      raise AnyError, "Invalid hbreak." if hbrk
+      return res
+    end
+  end
+
+  HDLRuby::High::If.prepend(IfHBreak)
+
+  module BehaviorHBreak
+    # Creates a new behavior executing +block+ activated on a list of
+    # +events+, possible name (of main block) +name+ and built by
+    # executing +ruby_block+.
+    # +mode+ can be either :seq or :par for respectively sequential or
+    # parallel.
+    def initialize(mode, *events, name: nil, &ruby_block)
+      super(mode,*events, name: name, &ruby_block)
+      if self.block.instance_variable_get(:@hbreak) then
+        stmnt0 = self.block.each_statement.first
+        unless stmnt0.is_a?(HDLRuby::High::If) then
+          raise AnyError, "Unsuported usage of hbreak."
+        end
+        if stmnt0.no || stmnt0.each_noif.any? then
+          raise AnyError, "Unsuported usage of hbreak."
+        end
+        # Extract the hif an put it as the single statement whose else
+        # part is the current block.
+        self.block.delete_statement!(stmnt0)
+        self.block.parent = nil
+        self.block.instance_variable_set(:@hbreak,false)
+        stmnt0.no = self.block
+        self.block = HDLRuby::High.make_block(self.block.mode) {}
+        self.block.add_statement(stmnt0)
+      end
+    end
+  end
+
+  HDLRuby::High::Behavior.prepend(BehaviorHBreak)
+
 end

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "3.9.6"
+  VERSION = "3.9.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 3.9.6
+  version: 3.9.7
 platform: ruby
 authors:
 - Lovic Gauthier
@@ -194,6 +194,7 @@ files:
 - lib/HDLRuby/hdr_samples/type_minmax_bench.rb
 - lib/HDLRuby/hdr_samples/verilog_parser_bench.rb
 - lib/HDLRuby/hdr_samples/with_assign_to_slice.rb
+- lib/HDLRuby/hdr_samples/with_auto_connect.rb
 - lib/HDLRuby/hdr_samples/with_board.rb
 - lib/HDLRuby/hdr_samples/with_board_sequencer.rb
 - lib/HDLRuby/hdr_samples/with_bram.rb
@@ -212,12 +213,15 @@ files:
 - lib/HDLRuby/hdr_samples/with_def.rb
 - lib/HDLRuby/hdr_samples/with_define_operator.rb
 - lib/HDLRuby/hdr_samples/with_delay.rb
+- lib/HDLRuby/hdr_samples/with_expr_decoder.rb
+- lib/HDLRuby/hdr_samples/with_expr_hif.rb
 - lib/HDLRuby/hdr_samples/with_fixpoint.rb
 - lib/HDLRuby/hdr_samples/with_fixpoint_adv.rb
 - lib/HDLRuby/hdr_samples/with_fsm.rb
 - lib/HDLRuby/hdr_samples/with_function_generator.rb
 - lib/HDLRuby/hdr_samples/with_generic_in_generic.rb
 - lib/HDLRuby/hdr_samples/with_handshake.rb
+- lib/HDLRuby/hdr_samples/with_hbreak.rb
 - lib/HDLRuby/hdr_samples/with_henumerable.rb
 - lib/HDLRuby/hdr_samples/with_init.rb
 - lib/HDLRuby/hdr_samples/with_instance.rb
@@ -504,7 +508,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.18
+rubygems_version: 4.0.20
 specification_version: 4
 summary: HDLRuby is a library for describing and simulating digital electronic systems.
 test_files: []