HDLRuby 2.10.3 → 2.11.0

data/lib/HDLRuby/hruby_high.rb

@@ -38,7 +38,7 @@ module HDLRuby::High
             # puts "eigen_extend for #{self} class=#{self.class}"
             obj.singleton_methods.each do |name|
                 next if name == :yaml_tag # Do not know why we need to skip
-                # puts "name=#{name}"
+                puts "name=#{name}"
                 self.define_singleton_method(name, &obj.singleton_method(name))
             end
         end
@@ -87,10 +87,11 @@ module HDLRuby::High
                     raise AnyError, 
                           "Resevered name #{name} cannot be overridden."
                 end
-                if self.respond_to?(name) then
-                    raise AnyError,
-                          "Symbol #{name} is already defined."
-                end
+                # Deactivated: overriding is now accepted.
+                # if self.respond_to?(name) then
+                #     raise AnyError,
+                #           "Symbol #{name} is already defined."
+                # end
                 define_singleton_method(name,&ruby_block) 
             end
         end
@@ -669,7 +670,6 @@ module HDLRuby::High
             # Fill the public namespace
             space = self.public_namespace
             # Interface signals
-            # puts "i_name=#{i_name} @to_includes=#{@to_includes.size}"
             self.each_signal do |signal|
                 # puts "signal=#{signal.name}"
                 space.send(:define_singleton_method,signal.name) do
@@ -825,8 +825,20 @@ module HDLRuby::High
 
         include Hmux
 
+
+        # Merge the included systems interface in current system.
+        # NOTE: incompatible with further to_low transformation.
+        def merge_included!
+            # puts "merge_included! for system=#{self.name}"
+            # Recurse on the system instances.
+            self.scope.merge_included!
+            # Merge for current system.
+            self.scope.merge_included(self)
+        end
+
+
         # Fills the interface of a low level system.
-        def fill_interface(systemTlow)
+        def fill_interface_low(systemTlow)
             # Adds its input signals.
             self.each_input { |input|  systemTlow.add_input(input.to_low) }
             # Adds its output signals.
@@ -835,7 +847,7 @@ module HDLRuby::High
             self.each_inout { |inout|  systemTlow.add_inout(inout.to_low) }
             # Adds the interface of its included systems.
             self.scope.each_included do |included|
-                included.fill_interface(systemTlow)
+                included.fill_interface_low(systemTlow)
             end
         end
 
@@ -844,7 +856,7 @@ module HDLRuby::High
         # NOTE: name conflicts are treated in the current NameStack state.
         def fill_low(systemTlow)
             # Fills the interface
-            self.fill_interface(systemTlow)
+            self.fill_interface_low(systemTlow)
         end
 
         # Converts the system to HDLRuby::Low and set its +name+.
@@ -1181,6 +1193,8 @@ module HDLRuby::High
 
         # Declares a sub scope with possible +name+ and built from +ruby_block+.
         def sub(name = :"", &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Creates the new scope.
             # scope = Scope.new(name,&ruby_block)
             scope = Scope.new(name)
@@ -1197,6 +1211,8 @@ module HDLRuby::High
         # Declares a high-level sequential behavior activated on a list of
         # +events+, and built by executing +ruby_block+.
         def seq(*events, &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Preprocess the events.
             events.map! do |event|
                 event.respond_to?(:to_event) ? event.to_event : event
@@ -1208,6 +1224,8 @@ module HDLRuby::High
         # Declares a high-level parallel behavior activated on a list of
         # +events+, and built by executing +ruby_block+.
         def par(*events, &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Preprocess the events.
             events.map! do |event|
                 event.respond_to?(:to_event) ? event.to_event : event
@@ -1219,6 +1237,8 @@ module HDLRuby::High
         # Declares a high-level timed behavior built by executing +ruby_block+.
         # By default, timed behavior are sequential.
         def timed(&ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Create and add the resulting behavior.
             self.add_behavior(TimeBehavior.new(:seq,&ruby_block))
         end
@@ -1232,6 +1252,8 @@ 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)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             self.par do
                 hif(condition,mode,&ruby_block)
             end
@@ -1244,6 +1266,8 @@ module HDLRuby::High
         #
         # NOTE: added to the hif of the last behavior.
         def helse(mode = nil, &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
             # the last statement of the last behavior.
             statement = self.last_behavior.last_statement
@@ -1258,6 +1282,8 @@ 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)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # There is a ruby_block: the helse is assumed to be with
             # the last statement of the last behavior.
             statement = self.last_behavior.last_statement
@@ -1285,6 +1311,8 @@ module HDLRuby::High
         #
         # Can only be used once.
         def hwhen(match, mode = nil, &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
             # the last statement of the last behavior.
             statement = @behaviors.last.last_statement
@@ -1364,6 +1392,72 @@ module HDLRuby::High
 
         include Hmux
 
+
+
+        # Merge the included systems interface in +systemT+
+        # NOTE: incompatible with further to_low transformation.
+        def merge_included(systemT)
+            # Recurse on the sub.
+            self.each_scope {|scope| scope.merge_included(systemT) }
+            # Include for current scope.
+            self.each_included do |included|
+                included.merge_included!
+                # Adds its interface signals.
+                included.each_input do |input|
+                    input.no_parent!
+                    systemT.add_input(input)
+                end
+                included.each_output do |output|  
+                    output.no_parent!
+                    systemT.add_output(output)
+                end
+                included.each_inout do |inout|  
+                    inout.no_parent!
+                    systemT.add_inout(inout)
+                end
+                # Adds its behaviors.
+                included.scope.each_behavior do |beh|
+                    beh.no_parent!
+                    systemT.scope.add_behavior(beh)
+                end
+                # Adds its connections.
+                included.scope.each_connection do |cx|
+                    cx.no_parent!
+                    systemT.scope.add_connection(cx)
+                end
+                # Adds its sytem instances.
+                included.scope.each_systemI do |sys|
+                    sys.no_parent!
+                    systemT.scope.add_systemI(sys)
+                end
+                # Adds its code.
+                included.scope.each_code do |code|
+                    code.no_parent!
+                    systemT.scope.add_code(code)
+                end
+                # Adds its subscopes.
+                included.scope.each_scope do |scope|
+                    scope.no_parent!
+                    systemT.scope.add_scope(scope)
+                end
+                # Add its inner signals.
+                included.scope.each_inner do |inner|
+                    inner.no_parent!
+                    systemT.scope.add_inner(inner)
+                end
+            end
+        end
+
+        # Merge the included systems interface in system instances.
+        # NOTE: incompatible with further to_low transformation.
+        def merge_included!
+            # Recurse on the sub.
+            self.each_scope {|scope| scope.merge_included! }
+            # Merge in the system instances.
+            self.each_systemI {|systemI| systemI.systemT.merge_included! }
+        end
+
+
         # Fills a low level scope with self's contents.
         #
         # NOTE: name conflicts are treated in the current NameStack state.
@@ -1607,6 +1701,8 @@ module HDLRuby::High
 
         # Redefinition of +operator+.
         def define_operator(operator,&ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Register the operator as overloaded.
             @overloads ||= {}
             @overloads[operator] = ruby_block
@@ -2003,6 +2099,8 @@ module HDLRuby::High
     # Declares a high-level generic type named +name+, and using +ruby_block+
     # for construction.
     def typedef(name, &ruby_block)
+        # Ensure there is a block.
+        ruby_block = proc {} unless block_given?
         type = TypeGen.new(name,&ruby_block)
         if HDLRuby::High.in_system? then
             # Must be inside a scope.
@@ -2038,6 +2136,8 @@ module HDLRuby::High
     # Declares a high-level system type named +name+, with +includes+ mixins
     # system types and using +ruby_block+ for instantiating.
     def system(name = :"", *includes, &ruby_block)
+        # Ensure there is a block.
+        ruby_block = proc {} unless block_given?
         # print "system ruby_block=#{ruby_block}\n"
         # Creates the resulting system.
         return SystemT.new(name,*includes,&ruby_block)
@@ -2049,6 +2149,8 @@ module HDLRuby::High
     # NOTE: this is for generating directly an instance without declaring
     #       it system type.
     def instance(name, *includes, &ruby_block)
+        # Ensure there is a block.
+        ruby_block = proc {} unless block_given?
         # Creates the system type.
         systemT = system(:"",*includes,&ruby_block)
         # Instantiate it with +name+.
@@ -2061,6 +2163,8 @@ module HDLRuby::High
     #
     # NOTE: a function is a short-cut for a method that creates a scope.
     def function(name, &ruby_block)
+        # Ensure there is a block.
+        ruby_block = proc {} unless block_given?
         if HDLRuby::High.in_system? then
             define_singleton_method(name.to_sym) do |*args,&other_block|
                 # sub do
@@ -2168,8 +2272,6 @@ module HDLRuby::High
             else
                 # No, perform a connection is order of declaration
                 connects.each.with_index do |csig,i|
-                    csig = csig.to_expr
-                    # puts "csig=#{csig} i=#{i}"
                     # puts "systemT inputs=#{systemT.each_input.to_a.size}"
                     # Gets i-est signal to connect
                     ssig = self.systemT.get_interface_with_included(i)
@@ -2181,8 +2283,10 @@ module HDLRuby::High
                     # Make the connection.
                     if isout then
                         csig <= ssig
+                        # csig.to_ref <= ssig
                     else
                         ssig <= csig
+                        # ssig <= csig.to_expr
                     end
                 end
             end
@@ -2199,6 +2303,8 @@ module HDLRuby::High
         # NOTE: actually executes +ruby_block+ in the context of the
         #       systemT.
         def open(&ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Extend the eigen system.
             @systemT.run(&ruby_block)
             # Update the methods.
@@ -2260,7 +2366,15 @@ module HDLRuby::High
         # system type.
         def method_missing(m, *args, &ruby_block)
             # print "method_missing in class=#{self.class} with m=#{m}\n"
-            self.public_namespace.send(m,*args,&ruby_block)
+            # Maybe its a signal reference.
+            signal = self.systemT.get_signal_with_included(m)
+            if signal then
+                # Yes, create the reference.
+                return RefObject.new(self.to_ref,signal)
+            else
+                # No try elsewhere
+                self.public_namespace.send(m,*args,&ruby_block)
+            end
         end
 
 
@@ -2395,6 +2509,8 @@ module HDLRuby::High
         #
         # Can only be used once.
         def helse(mode = nil, &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # If there is a no block, it is an error.
             raise AnyError, "Cannot have two helse for a single if statement." if self.no
             # Create the no block if required
@@ -2409,6 +2525,8 @@ module HDLRuby::High
         #
         # Can only be used if the no-block is not set yet.
         def helsif(next_cond, mode = nil, &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # If there is a no block, it is an error.
             raise AnyError, "Cannot have an helsif after an helse." if self.no
             # Create the noif block if required
@@ -2477,6 +2595,8 @@ module HDLRuby::High
         #
         # Can only be used once for the given +match+.
         def hwhen(match, mode = nil, &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Create the nu block if required
             when_block = High.make_block(mode,&ruby_block)
             # Adds the case.
@@ -2488,6 +2608,8 @@ module HDLRuby::High
         #
         # Can only be used once.
         def helse(mode = nil, &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Create the nu block if required
             default_block = High.make_block(mode,&ruby_block)
             # Sets the default block.
@@ -2731,30 +2853,39 @@ module HDLRuby::High
             return self.ljust(self[-1])
         end
 
-        # Match the type with +typ+:
-        # - Recurse on the sub expr if hierachical type, raising an arror
-        #   if the expression is not hierarchical.
-        # - Directly cast otherwise.
+        # # Match the type with +typ+:
+        # # - Recurse on the sub expr if hierachical type, raising an error
+        # #   if the expression is not hierarchical.
+        # # - Directly cast otherwise.
+        # def match_type(typ)
+        #     # Has the type sub types?
+        #     if typ.types? then
+        #         unless self.is_a?(Concat) then
+        #             raise AnyError,
+        #                 "Invalid class for assignment to hierarchical: #{self.class}."
+        #         end
+        #         return Concat.new(typ,
+        #           self.each_expression.zip(typ.each_type).map do |e,t|
+        #             e.match_type(t)
+        #         end)
+        #     elsif typ.vector? && typ.base.hierarchical? then
+        #         unless self.is_a?(Concat) then
+        #             raise AnyError,
+        #                 "Invalid class for assignment to hierarchical: #{self.class}."
+        #         end
+        #         return Concat.new(typ,
+        #           self.each_expression.map do |e|
+        #             e.match_type(typ.base)
+        #         end)
+        #     else
+        #         return self.as(typ)
+        #     end
+        # end
+
+        # Match the type with +typ+: cast if different type.
         def match_type(typ)
-            # Has the type sub types?
-            if typ.types? then
-                unless self.is_a?(Concat) then
-                    raise AnyError,
-                        "Invalid class for assignment to hierarchical: #{self.class}."
-                end
-                return Concat.new(typ,
-                  self.each_expression.zip(typ.each_type).map do |e,t|
-                    e.match_type(t)
-                end)
-            elsif typ.vector? && typ.base.hierarchical? then
-                unless self.is_a?(Concat) then
-                    raise AnyError,
-                        "Invalid class for assignment to hierarchical: #{self.class}."
-                end
-                return Concat.new(typ,
-                  self.each_expression.map do |e|
-                    e.match_type(typ.base)
-                end)
+            if self.type.eql?(typ) then
+                return self
             else
                 return self.as(typ)
             end
@@ -2831,54 +2962,58 @@ module HDLRuby::High
              define_method(orig_operator(operator),&meth)
          end
 
-        # Creates an access to elements of range +rng+ of the signal.
-        #
-        # NOTE: +rng+ can be a single expression in which case it is an index.
-        def [](rng)
-            if rng.is_a?(::Range) then
-                first = rng.first
-                if (first.is_a?(::Integer)) then
-                    first = self.type.size+first if first < 0
-                end
-                last = rng.last
-                if (last.is_a?(::Integer)) then
-                    last = self.type.size+last if last < 0
-                end
-                rng = first..last
-            end
-            if rng.is_a?(::Integer) && rng < 0 then
-                rng = self.type.size+rng
-            end
-            if rng.respond_to?(:to_expr) then
-                # Number range: convert it to an expression.
-                rng = rng.to_expr
-            end 
-            if rng.is_a?(HDLRuby::Low::Expression) then
-                # Index case
-                return RefIndex.new(self.type.base,self.to_expr,rng)
-            else
-                # Range case, ensure it is made among expression.
-                first = rng.first.to_expr
-                last = rng.last.to_expr
-                # Abd create the reference.
-                return RefRange.new(self.type.slice(first..last),
-                                    self.to_expr,first..last)
-            end
-        end
 
-        # Converts to a select operator using current expression as
-        # condition for one of the +choices+.
-        #
-        # NOTE: +choices+ can either be a list of arguments or an array.
-        # If +choices+ has only two entries
-        # (and it is not a hash), +value+ will be converted to a boolean.
-        def mux(*choices)
-            # 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)
-        end
+         # Creates an access to elements of range +rng+ of the signal.
+         #
+         # NOTE: +rng+ can be a single expression in which case it is an index.
+         def [](rng)
+             if rng.is_a?(::Range) then
+                 first = rng.first
+                 if (first.is_a?(::Integer)) then
+                     first = self.type.size+first if first < 0
+                 end
+                 last = rng.last
+                 if (last.is_a?(::Integer)) then
+                     last = self.type.size+last if last < 0
+                 end
+                 rng = first..last
+             end
+             if rng.is_a?(::Integer) && rng < 0 then
+                 rng = self.type.size+rng
+             end
+             if rng.respond_to?(:to_expr) then
+                 # Number range: convert it to an expression.
+                 rng = rng.to_expr
+             end 
+             if rng.is_a?(HDLRuby::Low::Expression) then
+                 # Index case
+                 return RefIndex.new(self.type.base,self.to_expr,rng)
+             else
+                 # Range case, ensure it is made among expression.
+                 first = rng.first.to_expr
+                 last = rng.last.to_expr
+                 # Abd create the reference.
+                 return RefRange.new(self.type.slice(first..last),
+                                     self.to_expr,first..last)
+             end
+         end
+
+         # And save it so that it can still be accessed if overidden.
+         alias_method orig_operator(:[]), :[]
+
+         # Converts to a select operator using current expression as
+         # condition for one of the +choices+.
+         #
+         # NOTE: +choices+ can either be a list of arguments or an array.
+         # If +choices+ has only two entries
+         # (and it is not a hash), +value+ will be converted to a boolean.
+         def mux(*choices)
+             # 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)
+         end
 
 
 
@@ -2922,19 +3057,25 @@ module HDLRuby::High
         #
         # NOTE: it is converted afterward to an expression if required.
         def <=(expr)
+            # Generate a ref from self for the left of the transmit.
+            left = self.to_ref
             # Cast expr to self if required.
-            expr = expr.to_expr.match_type(self.type)
+            expr = expr.to_expr.match_type(left.type)
+            # Ensure expr is an expression.
+            expr = expr.to_expr
+            # Cast it to left if necessary.
+            expr = expr.as(left.type) unless expr.type.eql?(left.type)
             # Generate the transmit.
             if High.top_user.is_a?(HDLRuby::Low::Block) then
                 # We are in a block, so generate and add a Transmit.
                 High.top_user.
-                    # add_statement(Transmit.new(self.to_ref,expr.to_expr))
-                    add_statement(Transmit.new(self.to_ref,expr))
+                    # add_statement(Transmit.new(self.to_ref,expr))
+                    add_statement(Transmit.new(left,expr))
             else
                 # We are in a system type, so generate and add a Connection.
                 High.top_user.
-                    # add_connection(Connection.new(self.to_ref,expr.to_expr))
-                    add_connection(Connection.new(self.to_ref,expr))
+                    # add_connection(Connection.new(self.to_ref,expr))
+                    add_connection(Connection.new(left,expr))
             end
         end
     end
@@ -3185,7 +3326,7 @@ module HDLRuby::High
 
         # Creates a new reference from a +base+ reference and named +object+.
         def initialize(base,object)
-            # puts "New RefObjet with base=#{base}, object=#{object.name}"
+            # puts "New RefObjet with base=#{base}, object=#{object}"
             if object.respond_to?(:type) then
                 # Typed object, so typed reference.
                 super(object.type)
@@ -3202,6 +3343,11 @@ module HDLRuby::High
             @object = object
         end
 
+        # Clones.
+        def clone
+            return RefObject.new(self.base.clone,self.object)
+        end
+
         # Tell if the expression is constant.
         def constant?
             return self.base.constant?
@@ -3351,6 +3497,11 @@ module HDLRuby::High
         High = HDLRuby::High
         include HRef
 
+        # Clones.
+        def clone
+            return RefThis.new
+        end
+
         # Converts to a new reference.
         def to_ref
             return RefThis.new
@@ -3859,11 +4010,15 @@ module HDLRuby::High
         # Creates a new block with the current mode with possible +name+ and
         # built from +ruby_block+.
         def sub(name = :"", &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             self.add_block(self.mode,name,&ruby_block)
         end
 
         # Adds statements at the top of the block.
         def unshift(&ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Create a sub block for the statements.
             block = High.make_block(self.mode,:"",&ruby_block)
             # Unshifts it.
@@ -3908,6 +4063,8 @@ module HDLRuby::High
         #
         # NOTE: the else part is defined through the helse method.
         def hif(condition, mode = nil, &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Creates the if statement.
             self.add_statement(If.new(condition,mode,&ruby_block))
         end
@@ -3917,6 +4074,8 @@ module HDLRuby::High
         #
         # Can only be used once.
         def helse(mode = nil, &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
             # the hif in the same block.
             # Completes the hif or the hcase statement.
@@ -3931,6 +4090,8 @@ 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)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # There is a ruby_block: the helse is assumed to be with
             # the hif in the same block.
             # Completes the hif statement.
@@ -3958,6 +4119,8 @@ module HDLRuby::High
         #
         # Can only be used once.
         def hwhen(match, mode = nil, &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
             # the hif in the same block.
             # Completes the hcase statement.
@@ -4073,6 +4236,8 @@ module HDLRuby::High
         # Adds a loop until +delay+ statement in the block in +mode+ whose
         # loop content is built using +ruby_block+.
         def repeat(delay, mode = nil, &ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             # Build the content block.
             content = High.make_block(mode,&ruby_block)
             # Create and add the statement.
@@ -4539,13 +4704,19 @@ module HDLRuby::High
         #     # Use it to create the new value.
         #     return Value.new(Bit[bstr.width],self)
         # end
+        
+        # Tell if the expression can be converted to a value.
+        def to_value?
+            return true
+        end
 
         # Converts to a new high-level value.
         def to_value
             # Convert the string to a bit string.
             bstr = BitString.new(self)
             # Use it to create the new value.
-            return Value.new(Bit[bstr.width],self)
+            # return Value.new(Bit[bstr.width],bstr)
+            return Value.new(Bit[self.length],bstr)
         end
         
         # Convert to a new high-level string expression
@@ -4659,9 +4830,6 @@ module HDLRuby::High
 
         # Converts to a new high-level expression.
         def to_expr
-            # expr = Concat.new(TypeTuple.new(:"",:little,*self.map do |elem|
-            #     elem.to_expr.type
-            # end))
             elems = self.map {|elem| elem.to_expr }
             typ= TypeTuple.new(:"",:little)
             elems.each {|elem| typ.add_type(elem.type) }
@@ -4672,7 +4840,6 @@ module HDLRuby::High
 
         # Converts to a new high-level reference.
         def to_ref
-            # expr = RefConcat.new
             expr = RefConcat.new(TypeTuple.new(:"",:little,*self.map do |elem|
                 elem.to_ref.type
             end))
@@ -4731,16 +4898,19 @@ module HDLRuby::High
         # Creates a hcase statement executing +ruby_block+ on the element of
         # the array selected by +value+
         def hcase(value,&ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
             High.cur_block.hcase(value)
             self.each.with_index do |elem,i|
                 High.cur_block.hwhen(i) { ruby_block.call(elem) }
             end
         end
 
-        # Add support of the left arrow operator.
-        def <=(expr)
-            self.to_expr <= expr
-        end
+        # Moved to HArrow.
+        # # Add support of the left arrow operator.
+        # def <=(expr)
+        #     self.to_expr <= expr
+        # end
 
         # Array construction shortcuts