HDLRuby 2.5.0 → 2.6.5

data/lib/HDLRuby/hruby_low.rb

@@ -1317,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
@@ -1359,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
     
     ##
@@ -1465,6 +1466,11 @@ module HDLRuby::Low
         # end
     end
 
+    ##
+    # The void type.
+    class << (StringT = Type.new(:string) )
+        include LLeaf
+    end
 
 
     ##
@@ -1473,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
 
@@ -1533,15 +1536,6 @@ module HDLRuby::Low
 
         alias_method :each_deep, :each_type_deep
 
-        # 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?
     end
 
 
@@ -2401,6 +2395,12 @@ 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
 
@@ -2445,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
 
     ## 
@@ -2802,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)
@@ -3114,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
@@ -3271,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.
@@ -3321,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+.
@@ -3425,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.
@@ -3571,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
@@ -3867,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
@@ -3958,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)
@@ -4180,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.
@@ -4235,29 +4400,34 @@ 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
-            @content = content 
+        end
+
+        # Tells if the expression is immutable (cannot be written.)
+        def immutable?
+            # Values are always immutable.
+            true
         end
 
         # Iterates over each object deeply.
@@ -4326,6 +4496,7 @@ module HDLRuby::Low
         end
     end
 
+
     ##
     # Describes a cast.
     class Cast < Expression
@@ -4345,6 +4516,12 @@ 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.
@@ -4475,6 +4652,12 @@ 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.
@@ -4577,6 +4760,12 @@ 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.
@@ -4688,6 +4877,15 @@ 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.
@@ -4822,6 +5020,14 @@ 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.
@@ -4985,6 +5191,14 @@ 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.
@@ -5102,6 +5316,12 @@ 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.
@@ -5215,6 +5435,12 @@ 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.
@@ -5444,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