HDLRuby 2.4.27 → 2.6.2

data/lib/HDLRuby/hruby_low.rb

@@ -1,5 +1,6 @@
 require "HDLRuby/hruby_bstr"
 require "HDLRuby/hruby_error"
+require "HDLRuby/hruby_decorator"
 require 'forwardable'
 
 
@@ -34,6 +35,9 @@ module HDLRuby::Low
         alias_method :each, :each_value
     end
 
+
+    Hdecorator = HDLRuby::Hdecorator
+
     ##
     # Gives parent definition and access properties to an hardware object.
     module Hparent
@@ -62,6 +66,7 @@ module HDLRuby::Low
     end
 
 
+
     ##
     # Describes a system type.
     #
@@ -113,6 +118,9 @@ module HDLRuby::Low
             end
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(SystemT)
@@ -376,8 +384,28 @@ module HDLRuby::Low
         #     end
         #     signal
         # end
+    
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on each signal.
+            self.each_signal do |signal|
+                signal.each_deep(&ruby_block)
+            end
+            # Then apply on each scope.
+            self.each_scope do |scope|
+                scope.each_deep(&ruby_block)
+            end
+        end
 
         # Iterates over the systemT deeply if any.
+        #
+        # Returns an enumerator if no ruby block is given.
         def each_systemT_deep(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each_systemT_deep) unless ruby_block
@@ -427,6 +455,9 @@ module HDLRuby::Low
             @behaviors = []
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Scope)
@@ -1117,6 +1148,50 @@ module HDLRuby::Low
         #         systemI.each_sensitive_deep(&ruby_block)
         #     end
         # end
+        
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # The apply on each type.
+            self.each_type do |type|
+                type.each_deep(&ruby_block)
+            end
+            # Then apply on each systemT.
+            self.each_systemT do |systemT|
+                systemT.each_deep(&ruby_block)
+            end
+            # Then apply on each scope.
+            self.each_scope do |scope|
+                scope.each_deep(&ruby_block)
+            end
+            # Then apply on each inner signal.
+            self.each_inner do |inner|
+                inner.each_deep(&ruby_block)
+            end
+            # Then apply on each systemI.
+            self.each_systemI do |systemI|
+                systemI.each_deep(&ruby_block)
+            end
+            # Then apply on each code.
+            self.each_code do |code|
+                code.each_deep(&ruby_block)
+            end
+            # Then apply on each connection.
+            self.each_connection do |connection|
+                connection.each_deep(&ruby_block)
+            end
+            # Then apply on each behavior.
+            self.each_behavior do |behavior|
+                behavior.each_deep(&ruby_block)
+            end
+        end
+        
+
 
         # Gets the top scope, i.e. the first scope of the current system.
         def top_scope
@@ -1146,6 +1221,9 @@ module HDLRuby::Low
             @name = name.to_sym
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Type)
@@ -1239,6 +1317,11 @@ module HDLRuby::Low
             return false
         end
 
+        # Tells if the type is hierarchical.
+        def hierarchical?
+            return self.base? || self.types?
+        end
+
         # Tell if +type+ is equivalent to current type.
         #
         # NOTE: type can be compatible while not being equivalent, please
@@ -1256,6 +1339,7 @@ module HDLRuby::Low
             ruby_block.call(self)
             # And that's all by default.
         end
+        alias_method :each_deep, :each_type_deep
 
         # Converts to a bit vector.
         def to_vector
@@ -1280,10 +1364,6 @@ module HDLRuby::Low
     # The void type.
     class << (Void = Type.new(:void) )
         include LLeaf
-        # # Get the base type, actually self for leaf types.
-        # def base
-        #     self
-        # end
     end
     
     ##
@@ -1386,6 +1466,11 @@ module HDLRuby::Low
         # end
     end
 
+    ##
+    # The void type.
+    class << (StringT = Type.new(:string) )
+        include LLeaf
+    end
 
 
     ##
@@ -1394,9 +1479,6 @@ module HDLRuby::Low
     # NOTE: type definition are actually type with a name refering to another
     #       type (and equivalent to it).
     class TypeDef < Type
-        # Moved to constructor
-        # extend Forwardable
-
         # The definition of the type.
         attr_reader :def
 
@@ -1452,15 +1534,8 @@ module HDLRuby::Low
             @def.each_type_deep(&ruby_block)
         end
 
-        # Moved to constructor
-        # # Delegate the type methods to the ref.
-        # def_delegators :@def,
-        #                :signed?, :unsigned?, :fixed?, :float?, :leaf?,
-        #                :width, :range?, :range, :base?, :base, :types?,
-        #                :get_all_types, :get_type, :each, :each_type, 
-        #                :regular?,
-        #                :each_name,
-        #                :equivalent?
+        alias_method :each_deep, :each_type_deep
+
     end
 
 
@@ -1601,6 +1676,8 @@ module HDLRuby::Low
             # And recurse on the base.
             @base.each_type_deep(&ruby_block)
         end
+
+        alias_method :each_deep, :each_type_deep
     end
 
 
@@ -1756,6 +1833,8 @@ module HDLRuby::Low
             @types.each { |type| type.each_type_deep(&ruby_block) }
         end
 
+        alias_method :each_deep, :each_type_deep
+
         # Tell if the tuple is regular, i.e., all its sub types are equivalent.
         #
         # NOTE: empty tuples are assumed not to be regular.
@@ -1927,6 +2006,8 @@ module HDLRuby::Low
             @types.each_value { |type| type.each_type_deep(&ruby_block) }
         end
 
+        alias_method :each_deep, :each_type_deep
+
         # Gets the bitwidth of the type, nil for undefined.
         #
         # NOTE: must be redefined for specific types.
@@ -2012,6 +2093,9 @@ module HDLRuby::Low
             # @block = block
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
         # Sets the block if not already set.
         def block=(block)
             # Check the block.
@@ -2134,6 +2218,22 @@ module HDLRuby::Low
             @block.reverse_each_statement(&ruby_block)
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on each event.
+            self.each_event do |event|
+                event.each_deep(&ruby_block)
+            end
+            # Then apply on the block.
+            self.block.each_deep(&ruby_block)
+        end
+
         # Returns the last statement.
         def last_statement
             @block.last_statement
@@ -2217,6 +2317,9 @@ module HDLRuby::Low
             ref.parent = self
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Event)
@@ -2236,6 +2339,20 @@ module HDLRuby::Low
         def on_edge?
             return (@type == :posedge or @type == :negedge)
         end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the reference.
+            self.ref.each_deep(&ruby_block)
+        end
     end
 
 
@@ -2278,6 +2395,29 @@ module HDLRuby::Low
             end
         end
 
+        # Tells if the signal is immutable (cannot be written.)
+        def immutable?
+            # By default, signals are not immutable.
+            false
+        end
+
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the value.
+            self.value.each_deep(&ruby_block) if self.value
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(SignalI)
@@ -2305,6 +2445,11 @@ module HDLRuby::Low
     ##
     # Describes a constant signal.
     class SignalC < SignalI
+        # Tells if the signal is immutable (cannot be written.)
+        def immutable?
+            # Constant signals are immutable.
+            true
+        end
     end
 
     ## 
@@ -2341,6 +2486,22 @@ module HDLRuby::Low
             @systemTs = [ @systemT ]
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            
+            # Do not recurse on the systemTs since necesarily processed
+            # before!
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(SystemI)
@@ -2457,6 +2618,9 @@ module HDLRuby::Low
             lumps.each { |lump| self.add_lump(lump) }
         end
 
+        # 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.
         def add_lump(lump)
@@ -2476,6 +2640,16 @@ module HDLRuby::Low
             # A ruby block? Apply it on each lump.
             @lumps.each(&ruby_block)
         end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+        end
     end
 
 
@@ -2493,6 +2667,9 @@ module HDLRuby::Low
             @chunks = HashName.new
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
         # Adds a +chunk+ to the sensitivity list.
         def add_chunk(chunk)
             # Check and add the chunk.
@@ -2555,6 +2732,24 @@ module HDLRuby::Low
             return false
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on each chunk.
+            self.each_chunk do |chunk|
+                chunk.each_deep(&ruby_block)
+            end
+            # Then apply on each event.
+            self.each_event do |event|
+                event.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Code)
@@ -2584,6 +2779,7 @@ module HDLRuby::Low
     # NOTE: this is an abstract class which is not to be used directly.
     class Statement
         include Hparent
+        include Hdecorator
         
         # Clones (deeply)
         def clone
@@ -2591,6 +2787,14 @@ module HDLRuby::Low
                   "Internal error: clone is not defined for class: #{self.class}"
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            raise AnyError,
+                "Internal error: each_deep is not defined for class: #{self.class}"
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             raise AnyError,
@@ -2603,6 +2807,15 @@ module HDLRuby::Low
                 "Internal error: hash is not defined for class: #{self.class}"
         end
 
+        # Iterates over each sub statement if any.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_statement(&ruby_block)
+            # No ruby statement? Return an enumerator.
+            return to_enum(:each_statement) unless ruby_block
+            # By default: nothing to do.
+        end
+
         # Get the block of the statement.
         def block
             if self.is_a?(Block)
@@ -2692,6 +2905,7 @@ module HDLRuby::Low
                 raise AnyError,
                      "Invalid class for a reference (left value): #{left.class}"
             end
+            super()
             @left = left
             # and set its parent.
             left.parent = self
@@ -2704,6 +2918,20 @@ module HDLRuby::Low
             right.parent = self
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the left.
+            self.left.each_deep(&ruby_block)
+            # Then apply on the right.
+            self.right.each_deep(&ruby_block)
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Transmit)
@@ -2793,6 +3021,7 @@ module HDLRuby::Low
                 raise AnyError,
                       "Invalid class for a condition: #{condition.class}"
             end
+            super()
             @condition = condition
             # And set its parent.
             condition.parent = self
@@ -2815,6 +3044,27 @@ module HDLRuby::Low
             @noifs = []
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the condition.
+            self.condition.each_deep(&ruby_block)
+            # Then apply on the yes.
+            self.yes.each_deep(&ruby_block)
+            # The apply on the no.
+            self.no.each_deep(&ruby_block)
+            # Then apply on the alternate ifs.
+            self.each_noif do |cond,stmnt|
+                cond.each_deep(&ruby_block)
+                stmnt.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(If)
@@ -2878,7 +3128,24 @@ module HDLRuby::Low
             end
         end
 
+        # Iterates over each sub statement if any.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_statement(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement) unless ruby_block
+            # A ruby block?
+            # Appy it on the statement children.
+            ruby_block.call(@yes)
+            self.each_noif do |next_cond,next_yes|
+                ruby_block.call(next_yes)
+            end
+            ruby_block.call(@no) if @no
+        end
+
         # Iterates over the children (including the condition).
+        #
+        # Returns an enumerator if no ruby block is given.
         def each_node(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each_node) unless ruby_block
@@ -3000,6 +3267,23 @@ module HDLRuby::Low
             match.parent = statement.parent = self
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the match.
+            self.match.each_deep(&ruby_block)
+            # Then apply on the statement.
+            self.statement.each_deep(&ruby_block)
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(When)
@@ -3018,6 +3302,17 @@ module HDLRuby::Low
             return When.new(@match.clone,@statement.clone)
         end
 
+        # Iterates over each sub statement if any.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_statement(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement) unless ruby_block
+            # A ruby block?
+            # Appy it on the statement child.
+            ruby_block.call(@statement)
+        end
+
         # Iterates over the sub blocks.
         def each_block(&ruby_block)
             # No ruby block? Return an enumerator.
@@ -3068,7 +3363,8 @@ module HDLRuby::Low
 
         # Gets the top block, i.e. the first block of the current behavior.
         def top_block
-            return self.parent.is_a?(Behavior) ? self : self.parent.top_block
+            # return self.parent.is_a?(Behavior) ? self : self.parent.top_block
+            return self.parent.top_block
         end
 
         # Tell if the statement includes a signal whose name is one of +names+.
@@ -3096,6 +3392,7 @@ module HDLRuby::Low
             unless value.is_a?(Expression)
                 raise AnyError, "Invalid class for a value: #{value.class}"
             end
+            super()
             @value = value
             # And set its parent.
             value.parent = self
@@ -3106,6 +3403,22 @@ module HDLRuby::Low
             whens.each { |w| self.add_when(w) }
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the value.
+            self.value.each_deep(&ruby_block)
+            # Then apply on the whens.
+            self.each_when do |w|
+                w.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Case)
@@ -3155,6 +3468,19 @@ module HDLRuby::Low
             @default
         end
 
+        # Iterates over each sub statement if any.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_statement(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement) unless ruby_block
+            # A ruby block?
+            # Apply on each when.
+            @whens.each { |w| w.each_statement(&ruby_block) }
+            # And on the default if any.
+            ruby_block.call(@default) if @default
+        end
+
         # Iterates over the match cases.
         #
         # Returns an enumerator if no ruby block is given.
@@ -3266,6 +3592,21 @@ module HDLRuby::Low
             @unit = unit.to_sym
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the value.
+            self.value.each_deep(&ruby_block)
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Delay)
@@ -3286,6 +3627,122 @@ module HDLRuby::Low
     end
 
 
+    ## 
+    # Describes a print statement: not synthesizable!
+    class Print < Statement
+
+        # Creates a new statement for printing +args+.
+        def initialize(*args)
+            super()
+            # Process the arguments.
+            @args = args.map do |arg|
+                arg.parent = self 
+                arg
+            end
+        end
+
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(Print)
+            return false if @args.each.zip(obj.each_arg).any? do |a0,a1|
+                !a0.eql?(a1)
+            end
+            return true
+        end
+
+        # Iterates over each argument.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_arg(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_arg) unless ruby_block
+            # A ruby block? First apply it to each argument.
+            @args.each(&ruby_block)
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the arguments.
+            self.each_arg(&ruby_block)
+        end
+
+        # Hash function.
+        def hash
+            return @args.hash
+        end
+
+        # Clones the TimeWait (deeply)
+        def clone
+            return Print.new(*@args.map { |arg| arg.clone })
+        end
+
+        # Iterates over the expression children if any.
+        def each_node(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node) unless ruby_block
+            # A ruby block?
+            # Apply it on each argument.
+            @args.each(&ruby_block)
+        end
+
+        # Iterates over the nodes deeply if any.
+        def each_node_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # And apply it on each argument.
+            @args.each(&ruby_block)
+        end
+
+        # Iterates over the sub blocks.
+        def each_block(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_block) unless ruby_block
+            # A ruby block?
+            # Recurse on each argument.
+            @args.each do |arg|
+                arg.each_block(&ruby_block) if arg.respond_to?(:each_block)
+            end
+        end
+
+        # Iterates over all the blocks contained in the current block.
+        def each_block_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_block_deep) unless ruby_block
+            # A ruby block?
+            # Recurse on each argument.
+            @args.each do |arg|
+                if arg.respond_to?(:each_block_deep) then
+                    arg.each_block_deep(&ruby_block)
+                end
+            end
+        end
+
+        # Iterates over all the statements contained in the current block.
+        def each_statement_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement_deep) unless ruby_block
+            # A ruby block?
+            # Apply it on self.
+            ruby_block.call(self)
+            # Recurse on each argument.
+            @args.each do |arg|
+                if arg.respond_to?(:each_statement_deep) then
+                    arg.each_statement_deep(&ruby_block)
+                end
+            end
+        end
+
+    end
+
+
     ## 
     # Describes a wait statement: not synthesizable!
     class TimeWait < Statement
@@ -3298,6 +3755,7 @@ module HDLRuby::Low
             unless delay.is_a?(Delay)
                 raise AnyError, "Invalid class for a delay: #{delay.class}."
             end
+            super()
             @delay = delay
             # And set its parent.
             delay.parent = self
@@ -3310,6 +3768,18 @@ module HDLRuby::Low
             return true
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the delay.
+            self.delay.each_deep(&ruby_block)
+        end
+
         # Hash function.
         def hash
             return [@delay].hash
@@ -3381,6 +3851,7 @@ module HDLRuby::Low
                 raise AnyError,
                       "Invalid class for a statement: #{statement.class}."
             end
+            super()
             @statement = statement
             # And set its parent.
             statement.parent = self
@@ -3394,6 +3865,20 @@ module HDLRuby::Low
             delay.parent = self
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the statement.
+            self.statement.each_deep(&ruby_block)
+            # Then apply on the delay.
+            self.delay.each_deep(&ruby_block)
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(TimeRepeat)
@@ -3473,6 +3958,7 @@ module HDLRuby::Low
 
         # Creates a new +mode+ sort of block with possible +name+.
         def initialize(mode, name = :"")
+            super()
             # puts "new block with mode=#{mode} and name=#{name}"
             # Check and set the type.
             @mode = mode.to_sym
@@ -3485,6 +3971,24 @@ module HDLRuby::Low
             @statements = []
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the inners.
+            self.each_inner do |inner|
+                inner.each_deep(&ruby_block)
+            end
+            # Then apply on the statements.
+            self.each_statement do |stmnt|
+                stmnt.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Block)
@@ -3535,7 +4039,6 @@ module HDLRuby::Low
             # No ruby block? Return an enumerator.
             return to_enum(:each_inner) unless ruby_block
             # A ruby block? Apply it on each inner signal instance.
-            # @inners.each_value(&ruby_block)
             @inners.each(&ruby_block)
         end
         alias_method :each_signal, :each_inner
@@ -3626,17 +4129,6 @@ module HDLRuby::Low
         def last_statement
             return @statements[-1]
         end
-
-        # # Deletes +statement+.
-        # def delete_statement(statement)
-        #     if @statements.include?(statement) then
-        #         # Statement is present, delete it.
-        #         @statements.delete(statement)
-        #         # And remove its parent.
-        #         statement.parent = nil
-        #     end
-        #     statement
-        # end
         
         # Iterates over the sub blocks.
         def each_block(&ruby_block)
@@ -3810,6 +4302,9 @@ module HDLRuby::Low
             end
         end
 
+        # Add decorator capability (modifies intialize to put after).
+        include Hdecorator
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Expression)
@@ -3845,6 +4340,11 @@ module HDLRuby::Low
             return !self.leftvalue?
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            false
+        end
+
         # Iterates over the expression children if any.
         def each_node(&ruby_block)
             # By default: no child.
@@ -3900,29 +4400,50 @@ module HDLRuby::Low
     # Describes a value.
     class Value < Expression
 
-        # Moved to Expression
-        # # The type of value.
-        # attr_reader :type
-
         # The content of the value.
         attr_reader :content
 
         # Creates a new value typed +type+ and containing +content+.
         def initialize(type,content)
-            # Moved to Expression.
-            # # Check and set the type.
-            # if type.is_a?(Type) then
-            #     @type = type
-            # else
-            #     raise AnyError, "Invalid class for a type: #{type.class}."
-            # end
             super(type)
-            # Checks and set the content: Ruby Numeric and HDLRuby BitString 
-            # are supported. Strings or equivalent are converted to BitString.
-            unless content.is_a?(Numeric) or content.is_a?(HDLRuby::BitString)
-                content = HDLRuby::BitString.new(content.to_s)
+            unless content then
+                # Handle the nil content case.
+                unless type.eql?(Void) then
+                    raise AnyError, "A value with nil content must have the Void type."
+                end
+                @content = content
+            else
+                # Checks and set the content: Ruby Numeric and HDLRuby
+                # BitString are supported. Strings or equivalent are
+                # converted to BitString.
+                unless content.is_a?(Numeric) or
+                        content.is_a?(HDLRuby::BitString)
+                    content = HDLRuby::BitString.new(content.to_s)
+                end
+                @content = content 
+            end
+        end
+
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Values are always immutable.
+            true
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the content if possible.
+            if self.content.respond_to?(:each_deep) then
+                self.content.each_deep(&ruby_block)
             end
-            @content = content 
         end
 
         # Comparison for hash: structural comparison.
@@ -3975,6 +4496,7 @@ module HDLRuby::Low
         end
     end
 
+
     ##
     # Describes a cast.
     class Cast < Expression
@@ -3994,6 +4516,26 @@ module HDLRuby::Low
             child.parent = self
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Immutable if the child is immutable.
+            return child.immutable?
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the child.
+            self.child.each_deep(&ruby_block)
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             # General comparison.
@@ -4110,6 +4652,26 @@ module HDLRuby::Low
             child.parent = self
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Immutable if the child is immutable.
+            return child.immutable?
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the child.
+            self.child.each_deep(&ruby_block)
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             # General comparison.
@@ -4198,6 +4760,28 @@ module HDLRuby::Low
             left.parent = right.parent = self
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Immutable if both children are immutable.
+            return left.immutable? && right.immutable?
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the left.
+            self.left.each_deep(&ruby_block)
+            # Then apply on the right.
+            self.right.each_deep(&ruby_block)
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             # General comparison.
@@ -4293,6 +4877,33 @@ module HDLRuby::Low
             end
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Immutable if children are all immutable.
+            return self.select.constant &&
+              self.each_choice.reduce(true) do |r,c|
+                r && c.immutable?
+            end
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the select.
+            self.select.each_deep(&ruby_block)
+            # Then apply on the choices.
+            self.each_choice do |choice|
+                choice.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             # General comparison.
@@ -4409,6 +5020,30 @@ module HDLRuby::Low
             expressions.each { |expression| self.add_expression(expression) }
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Immutable if children are all immutable.
+            return self.each_expression.reduce(true) do |r,c|
+                r && c.immutable?
+            end
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the expressions.
+            self.each_expression do |expr|
+                expr.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             # General comparison.
@@ -4556,6 +5191,30 @@ module HDLRuby::Low
             refs.each { |ref| ref.parent = self }
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Immutable if children are all immutable.
+            return self.each_ref.reduce(true) do |r,c|
+                r && c.immutable?
+            end
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the sub references.
+            self.each_ref do |ref|
+                ref.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             # General comparison.
@@ -4657,6 +5316,30 @@ module HDLRuby::Low
             index.parent = self
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Immutable if the ref is immutable.
+            return self.ref.immutable?
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the reference.
+            self.ref.each_deep(&ruby_block)
+            # Then apply on the index if possible.
+            if self.index.respond_to?(:each_deep) then
+                self.index.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         def eql?(obj)
             # General comparison.
@@ -4752,6 +5435,33 @@ module HDLRuby::Low
             first.parent = last.parent = self
         end
 
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Immutable if the ref is immutable.
+            return self.ref.immutable?
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the reference.
+            self.ref.each_deep(&ruby_block)
+            # Then apply on the range if possible.
+            if self.range.first.respond_to?(:each_deep) then
+                self.range.first.each_deep(&ruby_block)
+            end
+            if self.range.last.respond_to?(:each_deep) then
+                self.range.last.each_deep(&ruby_block)
+            end
+        end
+
         # Comparison for hash: structural comparison.
         #
         # NOTE: ranges are assumed to be flattened (a range of range is
@@ -4843,6 +5553,20 @@ module HDLRuby::Low
             @name = name.to_sym
         end
 
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+            # Then apply on the reference.
+            self.ref.each_deep(&ruby_block)
+        end
+
         # Get the full name of the reference, i.e. including the sub ref
         # names if any.
         def full_name
@@ -4918,6 +5642,19 @@ module HDLRuby::Low
     #
     # This is the current system.
     class RefThis < Ref 
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the type.
+            self.type.each_deep(&ruby_block)
+        end
+
         # Clones this.
         def clone
             return RefThis.new
@@ -4933,4 +5670,135 @@ module HDLRuby::Low
             return super
         end
     end
+
+
+
+    ##
+    # Describes a string.
+    #
+    # NOTE: This is not synthesizable!
+    class StringE < Expression
+
+        attr_reader :content
+
+        # Creates a new string whose content is +str+ and is modified using
+        # the objects of +args+.
+        def initialize(content,*args)
+            super(StringT)
+            # Checks and set the content.
+            @content = content.to_s
+            # Process the arguments.
+            @args = args.map do |arg|
+                arg.parent = self 
+                arg
+            end
+        end
+
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # String objects are always immutable.
+            true
+        end
+
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(StringE)
+            return false unless @content.eql?(obj.content)
+            return false if @args.each.zip(obj.each_arg).any? do |a0,a1|
+                !a0.eql?(a1)
+            end
+            return true
+        end
+
+        # Iterates over each argument.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_arg(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_arg) unless ruby_block
+            # A ruby block? First apply it to each argument.
+            @args.each(&ruby_block)
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the arguments.
+            self.each_arg(&ruby_block)
+        end
+
+        # Hash function.
+        def hash
+            return @args.hash
+        end
+
+        # Clones the string.
+        def clone
+            return StringE.new(@content.clone,*@args.map {|arg| arg.clone})
+        end
+
+        # Iterates over the expression children if any.
+        def each_node(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node) unless ruby_block
+            # A ruby block?
+            # Apply it on each argument.
+            @args.each(&ruby_block)
+        end
+
+        # Iterates over the nodes deeply if any.
+        def each_node_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # And apply it on each argument.
+            @args.each(&ruby_block)
+        end
+
+        # Iterates over the sub blocks.
+        def each_block(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_block) unless ruby_block
+            # A ruby block?
+            # Recurse on each argument.
+            @args.each do |arg|
+                arg.each_block(&ruby_block) if arg.respond_to?(:each_block)
+            end
+        end
+
+        # Iterates over all the blocks contained in the current block.
+        def each_block_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_block_deep) unless ruby_block
+            # A ruby block?
+            # Recurse on each argument.
+            @args.each do |arg|
+                if arg.respond_to?(:each_block_deep) then
+                    arg.each_block_deep(&ruby_block)
+                end
+            end
+        end
+
+        # Iterates over all the statements contained in the current block.
+        def each_statement_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement_deep) unless ruby_block
+            # A ruby block?
+            # Apply it on self.
+            ruby_block.call(self)
+            # Recurse on each argument.
+            @args.each do |arg|
+                if arg.respond_to?(:each_statement_deep) then
+                    arg.each_statement_deep(&ruby_block)
+                end
+            end
+        end
+
+    end
 end