HDLRuby 3.7.9 → 3.8.0

data/lib/HDLRuby/hruby_high.rb

@@ -232,6 +232,11 @@ module HDLRuby::High
         #         integer-constant choice. If only constant integer choices,
         #         use the largest type of them.
         def mux(select,*choices)
+            select = select ? 1 : 0 if [true,false,nil].include?(select)
+            if select.respond_to?(:to_i) then
+              # The mux can be evaluate straight away. Do metaprograming.
+              return choices[select.to_i]
+            end
             # Process the choices.
             choices = choices.flatten(1) if choices.size == 1
             choices.map! { |choice| choice.to_expr }
@@ -310,7 +315,8 @@ module HDLRuby::High
                 unless instance_methods.include?(:inner) then
                     # Declares high-level bit inner signals named +names+.
                     def inner(*names)
-                        self.make_inners(bit,*names)
+                        # self.make_inners(bit,*names)
+                        bit.inner(*names)
                     end
                 end
 
@@ -318,7 +324,8 @@ module HDLRuby::High
                     # Declares high-level untyped constant signals by name and
                     # value given by +hsh+ of the current type.
                     def constant(hsh)
-                        self.make_constants(bit,hsh)
+                        # self.make_constants(bit,hsh)
+                        bit.constant(hsh)
                     end
                 end
             end
@@ -901,6 +908,101 @@ module HDLRuby::High
     end
 
 
+    # Module adding metaprogramming capabilities to control statements.
+    module HmetaControl
+      # Adds meta programming capability to a if statement.
+      def metaif(condition, &ruby_block)
+        @metacond = nil
+        condition = condition ? 1 : 0 if [true,false,nil].include?(condition)
+        if condition.respond_to?(:to_i) then
+          # The hif can be evaluate straight away. Do metaprograming.
+          if condition.to_i != 0 then
+            HDLRuby::High.top_user.sub do
+              ruby_block.call
+            end
+            @metacond = :hif
+          else
+            @metacond = :helse
+          end
+          return true
+        end
+        return false
+      end
+
+      # Adds meta programming capability to a elsif statement.
+      def metaelsif(condition, &ruby_block)
+        @metacond ||= nil
+        if @metacond == :helse then
+          condition = condition ? 1 : 0 if [true,false,nil].include?(condition)
+          # Need to convert the elsif to a if since it is not
+          # compatible with metaprogramming.
+          return :toif unless condition.respond_to?(:to_i)
+          # The hif can be evaluate straight away. Do metaprograming.
+          if condition.to_i != 0 then
+            HDLRuby::High.top_user.sub do
+              ruby_block.call
+            end
+            @metacond = :hif
+          else
+            @metacond = :helse
+          end
+          return true
+        elsif @metacond == :hif
+          return true
+        end
+        return false
+      end
+
+      # Adds meta programming capability to a case statement.
+      def metacase(value, &ruby_block)
+        @metacond = nil
+        @metavalue = nil
+        value = value ? 1 : 0 if [true,false,nil].include?(value)
+        if value.respond_to?(:to_i) then
+          @metavalue = value.to_i
+          return true
+        end
+        return false
+      end
+
+      # Adds meta programming capability to a when statement.
+      def metawhen(match, &ruby_block)
+        @metacond ||= nil
+        @metavalue ||= nil
+        match = match ? 1 : 0 if [true,false,nil].include?(match)
+        if match.respond_to?(:to_i) then
+          # The hwen can be evaluate straight away. Do metaprograming.
+          if @metavalue == match.to_i then
+            HDLRuby::High.top_user.sub do
+              ruby_block.call
+            end
+            @metacond = :hwhen
+          else
+            @metacond = :helse
+          end
+          return true
+        end
+        return false
+      end
+
+      # Adds meta programming capability to a else statement.
+      def metaelse(&ruby_block)
+        @metacond ||= nil
+        if @metacond then
+          if @metacond == :helse then
+            if ruby_block then
+              HDLRuby::High.top_user.sub do
+                ruby_block.call
+              end
+            end
+            @metacond = nil
+          end
+          return true
+        end
+        return false
+      end
+    end
+
 
     ## 
     # Describes a scope for a system type
@@ -1220,7 +1322,8 @@ module HDLRuby::High
         end
 
         # Declares a sub scope with possible +name+ and built from +ruby_block+.
-        def sub(name = :"", &ruby_block)
+        # def sub(name = :"", &ruby_block)
+        def sub(name = HDLRuby.uniq_name, &ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # Creates the new scope.
@@ -1278,7 +1381,8 @@ module HDLRuby::High
             self.add_behavior(TimeBehavior.new(:seq,&ruby_block))
         end
 
-        # Statements automatically enclosed in a behavior.
+        # Handling metaprogramming
+        include HmetaControl
         
         # Creates a new if statement with a +condition+ that when met lead
         # to the execution of the block in +mode+ generated by the +ruby_block+.
@@ -1287,10 +1391,11 @@ module HDLRuby::High
         #  * the else part is defined through the helse method.
         #  * a behavior is created to enclose the hif.
         def hif(condition, mode = nil, &ruby_block)
+            return if self.metaif(condition,&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             self.par do
-                hif(condition,mode,&ruby_block)
+              hif(condition,mode,&ruby_block)
             end
         end
 
@@ -1301,6 +1406,7 @@ module HDLRuby::High
         #
         # NOTE: added to the hif of the last behavior.
         def helse(mode = nil, &ruby_block)
+            return if self.metaelse(&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # There is a ruby_block: the helse is assumed to be with
@@ -1317,6 +1423,13 @@ module HDLRuby::High
         # with a +condition+ that when met lead
         # to the execution of the block in +mode+ generated by the +ruby_block+.
         def helsif(condition, mode = nil, &ruby_block)
+            meta = self.metaelsif(condition,&ruby_block) 
+            if meta == :toif then
+              # Must be converted to hif.
+              return self.hif(condition,mode, &ruby_block)
+            elsif meta then
+              return
+            end
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # There is a ruby_block: the helse is assumed to be with
@@ -1336,6 +1449,7 @@ module HDLRuby::High
         #  * the when part is defined through the hwhen method.
         #  * a new behavior is created to enclose the hcase.
         def hcase(value)
+            return if self.metacase(value)
             self.par do
                 hcase(value)
             end
@@ -1346,6 +1460,7 @@ module HDLRuby::High
         #
         # Can only be used once.
         def hwhen(match, mode = nil, &ruby_block)
+            return if self.metawhen(match,&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # There is a ruby_block: the helse is assumed to be with
@@ -2270,6 +2385,10 @@ module HDLRuby::High
                     res = HDLRuby::High.top_user.instance_exec(*args,
                                             *other_block, &ruby_block)
                 end
+                unless res.respond_to?(:to_expr) then
+                  raise AnyError, 
+                    "The last statement of a function must be an expression: #{res}"
+                end
                 res
             end
         else
@@ -2279,6 +2398,10 @@ module HDLRuby::High
                     res = HDLRuby::High.top_user.instance_exec(*args,
                                             *other_block, &ruby_block)
                 end
+                unless res.respond_to?(:to_expr) then
+                  raise AnyError, 
+                    "The last statement of a function must be an expression: #{res}"
+                end
                 res
             end
         end
@@ -2647,6 +2770,11 @@ module HDLRuby::High
     ##
     # Module giving high-level statement properties
     module HStatement
+
+        # Handling metaprogramming
+        # Also adds the methods of HEnumerable.
+        define_method(:metaif,HmetaControl.instance_method(:metaif))
+
         # Creates a new if statement with a +condition+ enclosing the statement.
         #
         # NOTE: the else part is defined through the helse method.
@@ -2656,6 +2784,8 @@ module HDLRuby::High
             # Remove self from the current block.
             obj = self
             ::HDLRuby::High.cur_block.delete_statement!(obj)
+            # Handles the metaprogramming.
+            return obj if self.metaif(condition,proc { add_statement(obj) })
             # Creates the if statement.
             stmnt = If.new(condition) { add_statement(obj) }
             # Add it to the current block.
@@ -3206,11 +3336,18 @@ module HDLRuby::High
          # If +choices+ has only two entries
          # (and it is not a hash), +value+ will be converted to a boolean.
          def mux(*choices)
+             select = self
+             select = select ? 1 : 0 if [true,false,nil].include?(select)
+             if select.respond_to?(:to_i) then
+               # The mux can be evaluate straight away. 
+               # Do metaprograming.
+               return choices[select.to_i]
+             end
              # Process the choices.
              choices = choices.flatten(1) if choices.size == 1
              choices.map! { |choice| choice.to_expr }
              # Generate the select expression.
-             return Select.new(choices[0].type,"?",self.to_expr,*choices)
+             return Select.new(choices[0].type,"?",select.to_expr,*choices)
          end
 
 
@@ -3236,11 +3373,17 @@ module HDLRuby::High
         # If +choices+ has only two entries
         # (and it is not a hash), +value+ will be converted to a boolean.
         def mux(*choices)
+            select = self
+            select = select ? 1 : 0 if [true,false,nil].include?(select)
+            if select.respond_to?(:to_i) then
+              # The mux can be evaluate straight away. Do metaprograming.
+              return choices[select.to_i]
+            end
             # Process the choices.
             choices = choices.flatten(1) if choices.size == 1
             choices.map! { |choice| choice.to_expr }
             # Generate the select expression.
-            return Select.new(choices[0].type,"?",self.to_expr,*choices)
+            return Select.new(choices[0].type,"?",select.to_expr,*choices)
         end
 
     end
@@ -3461,6 +3604,21 @@ module HDLRuby::High
             return valueL
         end
 
+
+        # Iterate over the elements.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each) unless ruby_block
+            # A block? Apply it on each element.
+            self.type.range.heach do |i|
+              yield(self.content[i])
+            end
+        end
+
+        # Reference can be used like enumerator
+        include Enumerable
     end
 
 
@@ -3512,26 +3670,14 @@ module HDLRuby::High
             return Event.new(:anyedge,self.to_ref)
         end
 
-        # Iterate over the elements.
-        #
-        # Returns an enumerator if no ruby block is given.
-        def each(&ruby_block)
-            # No ruby block? Return an enumerator.
-            return to_enum(:each) unless ruby_block
-            # A block? Apply it on each element.
-            self.type.range.heach do |i|
-                yield(self[i])
-            end
-        end
-
         # Get the refered objects.
         def objects
             return [ self.object] if self.is_a?(RefObject)
             return self.each.map { |ref| ref.objects }.flatten
         end
 
-        # Reference can be used like enumerator
-        include Enumerable
+        # # Reference can be used like enumerator
+        # include Enumerable
     end
 
 
@@ -3977,12 +4123,22 @@ module HDLRuby::High
             High.top_user.delete_connection!(self)
         end
 
+        # Handling metaprogramming
+        # Also adds the methods of HEnumerable.
+        define_method(:metaif,HmetaControl.instance_method(:metaif))
+
         # Creates a new behavior with an if statement from +condition+
         # enclosing the connection converted to a transmission, and replace the
         # former by the new behavior.
         #
         # NOTE: the else part is defined through the helse method.
         def hif(condition)
+            # Handles the metaprogramming.
+            if self.metaif(condition,proc { left <= right }) then
+              High.top_user.delete_connection!(self)
+              return
+            end
+
             # Creates the behavior.
             left, right = self.left, self.right
             # Detached left and right from their connection since they will
@@ -4291,6 +4447,10 @@ module HDLRuby::High
         # built from +ruby_block+.
         def par(name = :"", &ruby_block)
             return :par unless ruby_block
+            unless name.is_a?(::Symbol) or name.is_a?(::String) then
+              raise AnyError,
+                "Events can only be used at top level seq blocks."
+            end
             self.add_block(:par,name,&ruby_block)
         end
 
@@ -4298,12 +4458,17 @@ module HDLRuby::High
         # built from +ruby_block+.
         def seq(name = :"", &ruby_block)
             return :seq unless ruby_block
+            unless name.is_a?(::Symbol) or name.is_a?(::String) then
+              raise AnyError,
+                "Events can only be used at top level seq blocks."
+            end
             self.add_block(:seq,name,&ruby_block)
         end
 
         # Creates a new block with the current mode with possible +name+ and
         # built from +ruby_block+.
-        def sub(name = :"", &ruby_block)
+        # def sub(name = :"", &ruby_block)
+        def sub(name = HDLRuby.uniq_name, &ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             self.add_block(self.mode,name,&ruby_block)
@@ -4351,6 +4516,11 @@ module HDLRuby::High
         # Need to be able to declare select operators
         include Hmux
 
+        # Also adds the methods of HEnumerable.
+        HmetaControl.instance_methods.each do |meth|
+          define_method(meth,HmetaControl.instance_method(meth))
+        end
+
         # Creates a new if statement with a +condition+ that when met lead
         # to the execution of the block in +mode+ generated by the
         # +ruby_block+.
@@ -4358,6 +4528,7 @@ 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)
+            return if self.metaif(condition,&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # Creates the if statement.
@@ -4369,6 +4540,7 @@ module HDLRuby::High
         #
         # Can only be used once.
         def helse(mode = nil, &ruby_block)
+            return if self.metaelse(&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # There is a ruby_block: the helse is assumed to be with
@@ -4385,6 +4557,13 @@ module HDLRuby::High
         # with a +condition+ that when met lead
         # to the execution of the block in +mode+ generated by the +ruby_block+.
         def helsif(condition, mode = nil, &ruby_block)
+            meta = self.metaelsif(condition,&ruby_block) 
+            if meta == :toif then
+              # Must be converted to hif.
+              return self.hif(condition,mode, &ruby_block)
+            elsif meta then
+              return
+            end
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # There is a ruby_block: the helse is assumed to be with
@@ -4405,6 +4584,7 @@ module HDLRuby::High
         #
         # NOTE: the when part is defined through the hwhen method.
         def hcase(value)
+            return if self.metacase(value)
             # Creates the case statement.
             self.add_statement(Case.new(value))
         end
@@ -4414,6 +4594,7 @@ module HDLRuby::High
         #
         # Can only be used once.
         def hwhen(match, mode = nil, &ruby_block)
+            return if self.metawhen(match,&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # There is a ruby_block: the helse is assumed to be with
@@ -5245,22 +5426,22 @@ module HDLRuby::High
         #     self.to_expr <= expr
         # end
 
-        # Array construction shortcuts
+        # # Array construction shortcuts
 
-        # Create an array whose number of elements is given by the content
-        # of the current array, filled by +obj+ objects.
-        # If +obj+ is nil, +ruby_block+ is used instead for filling the array.
-        def call(obj = nil, &ruby_block)
-            unless self.size == 1 then
-                raise AnyError, "Invalid array for call opertor."
-            end
-            number = self[0].to_i
-            if obj then
-                return Array.new(number,obj)
-            else
-                return Array.new(number,&ruby_block)
-            end
-        end
+        # # Create an array whose number of elements is given by the content
+        # # of the current array, filled by +obj+ objects.
+        # # If +obj+ is nil, +ruby_block+ is used instead for filling the array.
+        # def call(obj = nil, &ruby_block)
+        #     unless self.size == 1 then
+        #         raise AnyError, "Invalid array for call opertor."
+        #     end
+        #     number = self[0].to_i
+        #     if obj then
+        #         return Array.new(number,obj)
+        #     else
+        #         return Array.new(number,&ruby_block)
+        #     end
+        # end
 
         # Create an array of instances of system +name+, using +args+ as
         # arguments.

data/lib/HDLRuby/hruby_rcsim.rb

@@ -943,7 +943,7 @@ module HDLRuby::High
 
         # Generate the C description of the cast.
         def to_rcsim
-            # puts "Cast to width=#{self.type.width} and child=#{self.child}"
+          # puts "Cast to width=#{self.type.width} and child=#{self.child} and child.to_rcsim=#{child.to_rcsim}"
             # Shall we reverse when casting?
             if self.type.direction != self.child.type.direction then
                 # Yes, reverse the direction of the child.