HDLRuby 2.5.1 → 2.6.8

data/lib/HDLRuby/hdr_samples/with_to_array.rb

@@ -0,0 +1,29 @@
+
+def connect8(i0,i1,i2,i3,i4,i5,i6,i7,
+             o0,o1,o2,o3,o4,o5,o6,o7)
+    o0 <= i0
+    o1 <= i1
+    o2 <= i2
+    o3 <= i3
+    o4 <= i4
+    o5 <= i5
+    o6 <= i6
+    o7 <= i7
+end
+
+# A benchmark for testing the conversion to ruby array of expressions.
+system :with_to_bench do
+    [8].inner :val
+    inner :b0,:b1,:b2,:b3,:b4,:b5,:b6,:b7
+
+    connect8(*val,b0,b1,b2,b3,b4,b5,b6,b7)
+
+    timed do
+        val <= _01101010
+        !10.ns
+        val <= _01011010
+        !10.ns
+        val <= _00001111
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -5,7 +5,7 @@ require 'tempfile'
 require 'HDLRuby'
 require 'HDLRuby/hruby_check.rb'
 # require 'ripper'
-require 'HDLRuby/hruby_low2high'
+require 'HDLRuby/hruby_low2hdr'
 require 'HDLRuby/hruby_low2c'
 require 'HDLRuby/hruby_low2vhd'
 require 'HDLRuby/hruby_low_fix_types'
@@ -252,6 +252,20 @@ module HDLRuby
 
 end
 
+# Locate an executable from cmd.
+def which(cmd)
+    # Get the possible exetensions (for windows case).
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    # Look for the command within the executable paths.
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+    end
+    nil
+end
+
 
 
 if __FILE__ == $0 then
@@ -337,9 +351,12 @@ $optparse = OptionParser.new do |opts|
     opts.on("-D", "--debug","Set the HDLRuby debug mode") do |d|
         $options[:debug] = d
     end
-    opts.on("-T","--test","Compile the unit tests.") do |t|
+    opts.on("-T","--test t0,t1,t2","Compile the unit tests named t0,t1,...") do |t|
         $options[:test] = t
     end
+    opts.on("--testall","Compile all the available unit tests.") do |t|
+        $options[:testall] = t
+    end
     opts.on("-t", "--top system", "Specify the top system to process") do|t|
         $options[:top] = t
     end
@@ -350,6 +367,10 @@ $optparse = OptionParser.new do |opts|
         $options[:dump] = v
         $options[:multiple] = v
     end
+    opts.on("--version", "Shows the version of HDLRuby.") do |v|
+        puts VERSION
+        exit
+    end
     # opts.on_tail("-h", "--help", "Show this message") do
     opts.on("-h", "--help", "Show this message") do
         puts opts
@@ -400,14 +421,23 @@ if $input == nil then
     exit
 end
 
-if ($options[:test]) then
+if ($options[:test] || $options[:testall]) then
     $top = "__test__"
+    tests = $options[:test]
+    if tests then
+        tests = tests.to_s.split(",")
+        tests.map! {|test| ":\"#{test}\"" }
+        tests = ", #{tests.join(",")}"
+    else
+        tests = ""
+    end
     # Generate the unit test file.
     $test_file = Tempfile.new('tester.rb',Dir.getwd)
-    $test_file.write("require 'hruby_unit.rb'\nrequire_relative '#{$input}'\n\n" +
-                    "HDLRuby::Unit.test(\"#{$top}\")\n")
+    $test_file.write("require 'std/hruby_unit.rb'\nrequire_relative '#{$input}'\n\n" +
+                     "HDLRuby::Unit.test(:\"#{$top}\"#{tests})\n")
     # $test_file.rewind
     # puts $test_file.read
+    # exit
     $test_file.rewind
     # It is the new input file.
     $input = $test_file
@@ -425,7 +455,7 @@ if $output then
         $output = File.open($output,"w")
     end
 else
-    if $option[:multiple] then
+    if $options[:multiple] then
         raise "Need a target directory in multiple files generation mode."
     end
     $output = $stdout
@@ -463,6 +493,24 @@ end
 # Get the top systemT.
 $top_system = $top_instance.to_low.systemT
 
+
+# Apply the pre drivers if any.
+Hdecorator.each_with_property(:pre_driver) do |obj, value|
+    unless value.is_a?(Array) && value.size == 2 then
+        raise "pre_driver requires a driver file name command name."
+    end
+    # Load the driver.
+    require_relative(value[0].to_s)
+    # Ensure obj is the low version.
+    if obj.properties.key?(:high2low) then
+        # obj is high, get the corresponding low.
+        obj = obj.properties[:high2low][0]
+    end
+    # Execute it.
+    send(value[1].to_sym,obj,*value[2..-1])
+end
+
+
 # Gather the non-HDLRuby code.
 $non_hdlruby = []
 $top_system.each_systemT_deep do |systemT|
@@ -504,7 +552,7 @@ elsif $options[:hdr] then
     #     $output << systemT.to_high
     # end
     # $output << $top_instance.to_low.systemT.to_high
-    $output << $top_system.to_high
+    $output << $top_system.to_hdr
 elsif $options[:clang] then
     # top_system = $top_instance.to_low.systemT
     # top_system = $top_system
@@ -589,6 +637,7 @@ elsif $options[:clang] then
             name = $output + "/" +
                 HDLRuby::Low::Low2C.c_name(systemT.name) +
                 ".c"
+            # puts "for systemT=#{systemT.name} generating: #{name}"
             # Open the file for current systemT
             outfile = File.open(name,"w")
             # Generate the C code in to.
@@ -621,8 +670,19 @@ elsif $options[:clang] then
             end
         end
         Dir.chdir($output)
-        # Kernel.system("make -s")
-        Kernel.system("cc -o3 -o hruby_simulator *.c -lpthread")
+        # Find the compiler.
+        cc_cmd = which('cc')
+        unless cc_cmd then
+            cc_cmd = which('gcc')
+        end
+        unless cc_cmd then
+            raise "Could not find any compiler, please compile by hand as follows:\n" +
+                "   In folder #{$output} execute:\n" +
+                "     <my compiler> -o hruby_simulator *.c -lpthread\n" +
+                "   Then execute:\n   hruby_simulator"
+        end
+        # Use it.
+        Kernel.system("#{cc_cmd} -o3 -o hruby_simulator *.c -lpthread")
         Kernel.system("./hruby_simulator")
     end
 elsif $options[:verilog] then

data/lib/HDLRuby/hruby_decorator.rb

@@ -46,11 +46,13 @@ module HDLRuby
         # Iterate over all the id with their object.
         #
         # Returns an enumerator if no ruby block is given.
+        #
+        # NOTE: converts the hash to an array to allow on-the-fly modification.
         def self.each(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each) unless ruby_block
             # A ruby block? Apply it on each object.
-            @@id_map.each(&ruby_block)
+            @@id_map.to_a.each(&ruby_block)
         end
 
         # The decorator also need to add properties to the HDLRuby objects.

data/lib/HDLRuby/hruby_high.rb

@@ -609,7 +609,8 @@ module HDLRuby::High
         # possible arguments +args+.
         def instantiate(i_name,*args)
             # Create the eigen type.
-            eigen = self.expand(High.names_create(i_name.to_s + ":T"), *args)
+            # eigen = self.expand(High.names_create(i_name.to_s + ":T"), *args)
+            eigen = self.expand(HDLRuby.uniq_name(i_name.to_s + ":T"), *args)
 
             # Create the instance and sets its eigen system to +eigen+.
             instance = @instance_class.new(i_name,eigen)
@@ -620,8 +621,8 @@ module HDLRuby::High
             # Extend the instance.
             instance.eigen_extend(@singleton_instanceO)
             # puts "instance scope= #{instance.systemT.scope}"
-            # Add the instance.
-            High.top_user.send(:add_systemI,instance)
+            # Add the instance if instantiating within another system.
+            High.top_user.send(:add_systemI,instance) if High.top_user
             
             # Execute the post instantiation tasks.
             eigen.each_on_instance { |task| task.(instance) }
@@ -758,10 +759,13 @@ module HDLRuby::High
                       "Cannot convert a system without a name to HDLRuby::Low."
             end
             # Create the resulting low system type.
-            systemTL = HDLRuby::Low::SystemT.new(High.names_create(name),
+            # systemTL = HDLRuby::Low::SystemT.new(High.names_create(name),
+            systemTL = HDLRuby::Low::SystemT.new(HDLRuby.uniq_name(name),
                                                    self.scope.to_low)
+            # puts "New low from system #{self.name}: #{systemTL.name}"
             # For debugging: set the source high object 
             systemTL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = systemTL
 
             # Fills the interface of the new system 
             # from the included systems.
@@ -936,8 +940,19 @@ module HDLRuby::High
             # Set the namespace for buidling the scope.
             High.space_push(@namespace)
             # Build the scope.
-            @return_value = High.top_user.instance_eval(&ruby_block)
+            # @return_value = High.top_user.instance_eval(&ruby_block)
+            res = High.top_user.instance_eval(&ruby_block)
             High.space_pop
+            # Now gain access to the result within the sub scope.
+            if (res.is_a?(HRef)) then
+                @return_value = res.type.inner(HDLRuby.uniq_name)
+                High.space_push(@namespace)
+                @return_value <= res
+                High.space_pop
+            else
+                @return_value = res
+            end
+            # This will be the return value.
             @return_value
         end
 
@@ -1298,6 +1313,7 @@ module HDLRuby::High
             scopeL = HDLRuby::Low::Scope.new(self.name)
             # For debugging: set the source high object 
             scopeL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = scopeL
 
             # Push the private namespace for the low generation.
             High.space_push(@namespace)
@@ -1531,6 +1547,7 @@ module HDLRuby::High
             typeL = HDLRuby::Low::Type.new(name)
             # For debugging: set the source high object 
             typeL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeL
             return typeL
         end
     end
@@ -1616,6 +1633,18 @@ module HDLRuby::High
         include HbasicType
     end
 
+    # The string type
+    StringT = define_type(:string)
+    class << StringT
+        # Converts the type to HDLRuby::Low.
+        def to_low
+            return Low::StringT
+        end
+
+        include HbasicType
+    end
+
+
     # # The infer type.
     # # Unspecified, but automatically infered when connected.
     # Infer = define_type(:infer)
@@ -1672,6 +1701,7 @@ module HDLRuby::High
             typeDefL = HDLRuby::Low::TypeDef.new(name,self.def.to_low)
             # For debugging: set the source high object 
             typeDefL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeDefL
             return typeDefL
         end
     end
@@ -1724,6 +1754,7 @@ module HDLRuby::High
             typeDefL = HDLRuby::Low::TypeDef.new(name,self.def.to_low)
             # For debugging: set the source high object 
             typeDefL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeDefL
             return typeDefL
         end
     end
@@ -1741,6 +1772,7 @@ module HDLRuby::High
                                                 self.range.to_low)
             # For debugging: set the source high object 
             typeVectorL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeVectorL
             return typeVectorL
         end
     end
@@ -1820,6 +1852,7 @@ module HDLRuby::High
                                *@types.map { |type| type.to_low } )
             # For debugging: set the source high object 
             typeTupleL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeTupleL
             return typeTupleL
         end
     end
@@ -1840,6 +1873,7 @@ module HDLRuby::High
                                 @types.map { |name,type| [name,type.to_low] } )
             # For debugging: set the source high object 
             typeStructL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeStructL
             return typeStructL
         end
     end
@@ -2007,7 +2041,8 @@ module HDLRuby::High
             else
                 # No, perform a connection is order of declaration
                 connects.each.with_index do |csig,i|
-                    # puts "csig=#{csig.name} i=#{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)
@@ -2078,6 +2113,7 @@ module HDLRuby::High
                                              systemTL)
             # For debugging: set the source high object 
             systemIL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = systemIL
             # Adds the other systemTs.
             self.each_systemT do |systemT|
                 systemIL.add_systemT(systemT.to_low) unless systemT == self.systemT
@@ -2105,6 +2141,7 @@ module HDLRuby::High
             end)
             # For debugging: set the source high object 
             chunkL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = chunkL
             return chunkL
         end
     end
@@ -2118,6 +2155,7 @@ module HDLRuby::High
             codeL = HDLRuby::Low::Code.new
             # For debugging: set the source high object 
             codeL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = codeL
             # Add the low-level events.
             self.each_event { |event| codeL.add_event(event.to_low) }
             # Add the low-level code chunks.
@@ -2211,6 +2249,7 @@ module HDLRuby::High
             self.each_noif {|cond,block| ifL.add_noif(cond.to_low,block.to_low)}
             # For debugging: set the source high object 
             ifL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = ifL
             return ifL
         end
     end
@@ -2235,6 +2274,7 @@ module HDLRuby::High
                                           self.statement.to_low)
             # For debugging: set the source high object 
             whenL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = whenL
             return whenL
         end
     end
@@ -2282,6 +2322,7 @@ module HDLRuby::High
             caseL = HDLRuby::Low::Case.new(@value.to_low)
             # For debugging: set the source high object 
             caseL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = caseL
             # Add each when case.
             self.each_when do |w|
                 caseL.add_when(w.to_low)
@@ -2312,6 +2353,7 @@ module HDLRuby::High
             delayL = HDLRuby::Low::Delay.new(self.value, self.unit)
             # For debugging: set the source high object 
             delayL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = delayL
             return delayL
         end
     end
@@ -2327,6 +2369,7 @@ module HDLRuby::High
             timeWaitL = HDLRuby::Low::TimeWait.new(self.delay.to_low)
             # For debugging: set the source high object 
             timeWaitL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = timeWaitL
             return timeWaitL
         end
     end
@@ -2345,6 +2388,7 @@ module HDLRuby::High
                                                 self.delay.to_low)
             # For debugging: set the source high object 
             timeRepeatL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = timeRepeatL
             return timeRepeatL
         end
     end
@@ -2493,6 +2537,35 @@ 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.
+        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
+
         # Gets the origin method for operation +op+.
         def self.orig_operator(op)
             return (op.to_s + "_orig").to_sym
@@ -2585,7 +2658,6 @@ module HDLRuby::High
             end
         end
 
-
         # Converts to a select operator using current expression as
         # condition for one of the +choices+.
         #
@@ -2601,6 +2673,7 @@ module HDLRuby::High
         end
 
 
+
         # Methods for conversion for HDLRuby::Low: type processing, flattening
         # and so on
 
@@ -2641,14 +2714,19 @@ module HDLRuby::High
         #
         # NOTE: it is converted afterward to an expression if required.
         def <=(expr)
+            # Cast expr to self if required.
+            expr = expr.to_expr.match_type(self.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.to_expr))
+                    add_statement(Transmit.new(self.to_ref,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.to_expr))
+                    add_connection(Connection.new(self.to_ref,expr))
             end
         end
     end
@@ -2670,6 +2748,7 @@ module HDLRuby::High
             castL =HDLRuby::Low::Cast.new(self.type.to_low,self.child.to_low)
             # For debugging: set the source high object 
             castL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = castL
             return castL
         end
     end
@@ -2693,6 +2772,7 @@ module HDLRuby::High
                                            self.child.to_low)
             # For debugging: set the source high object 
             unaryL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = unaryL
             return unaryL
         end
     end
@@ -2717,6 +2797,7 @@ module HDLRuby::High
                                            self.left.to_low, self.right.to_low)
             # For debugging: set the source high object 
             binaryL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = binaryL
             return binaryL
         end
     end
@@ -2751,6 +2832,7 @@ module HDLRuby::High
             end)
             # For debugging: set the source high object 
             selectL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = selectL
             return selectL
         end
     end
@@ -2784,6 +2866,7 @@ module HDLRuby::High
             )
             # For debugging: set the source high object 
             concatL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = concatL
             return concatL
         end
     end
@@ -2827,6 +2910,7 @@ module HDLRuby::High
             valueL = HDLRuby::Low::Value.new(self.type.to_low,self.content)
             # For debugging: set the source high object 
             valueL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = valueL
             return valueL
         end
 
@@ -2929,12 +3013,12 @@ module HDLRuby::High
 
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
-            # return HDLRuby::Low::RefName.new(self.type.to_low,
-            #                                  @base.to_ref.to_low,@object.name)
+            # puts "to_low with base=#{@base} @object=#{@object}"
             refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                              @base.to_ref.to_low,@object.name)
             # For debugging: set the source high object 
             refNameL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refNameL
             return refNameL
         end
 
@@ -2974,6 +3058,7 @@ module HDLRuby::High
             )
             # For debugging: set the source high object 
             refConcatL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refConcatL
             return refConcatL
         end
     end
@@ -2997,6 +3082,7 @@ module HDLRuby::High
                                             self.ref.to_low,self.index.to_low)
             # For debugging: set the source high object 
             refIndexL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refIndexL
             return refIndexL
         end
     end
@@ -3020,6 +3106,7 @@ module HDLRuby::High
                 self.ref.to_low,self.range.to_low)
             # For debugging: set the source high object 
             refRangeL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refRangeL
             return refRangeL
         end
     end
@@ -3031,7 +3118,7 @@ module HDLRuby::High
 
         # Converts to a new reference.
         def to_ref
-            return RefName.new(self.ref.to_ref,self.name)
+            return RefName.new(self.type,self.ref.to_ref,self.name)
         end
 
         # Converts the name reference to HDLRuby::Low.
@@ -3042,6 +3129,7 @@ module HDLRuby::High
                                              self.ref.to_low,self.name)
             # For debugging: set the source high object 
             refNameL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refNameL
             return refNameL
         end
     end
@@ -3078,14 +3166,49 @@ module HDLRuby::High
             refThisL = HDLRuby::Low::RefThis.new
             # For debugging: set the source high object 
             refThisL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refThisL
             return refThisL
         end
     end
 
+    ##
+    # Describes a string.
+    #
+    # NOTE: This is not synthesizable!
+    class StringE < Low::StringE
+        include HExpression
+
+        # Converts to an expression.
+        def to_expr
+            return StringE.new(self.content,*self.each_arg.map(&:to_expr))
+        end
+
+        # Converts the connection to HDLRuby::Low.
+        def to_low
+            return HDLRuby::Low::StringE.new(self.content,
+                                             *self.each_arg.map(&:to_low))
+        end
+    end
+
+
+
+    
+    # Sets the current this to +obj+.
+    #
+    # NOTE: do not use a this= style to avoid confusion.
+    def set_this(obj = proc { RefThis.new })
+        if (obj.is_a?(Proc)) then
+            @@this = obj
+        else
+            @@this = proc { RefObject.new(RefThis.new,obj) }
+        end
+    end
+
 
     # Gives access to the *this* reference.
     def this
-        RefThis.new
+        # RefThis.new
+        @@this.call
     end
 
 
@@ -3116,6 +3239,7 @@ module HDLRuby::High
             eventL = HDLRuby::Low::Event.new(self.type,self.ref.to_low)
             # For debugging: set the source high object 
             eventL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = eventL
             return eventL
         end
     end
@@ -3158,10 +3282,33 @@ module HDLRuby::High
                                               self.right.to_low)
             # For debugging: set the source high object 
             transmitL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = transmitL
             return transmitL
         end
     end
 
+
+    ## 
+    # Describes a print statement: not synthesizable!
+    class Print < Low::Print
+        High = HDLRuby::High
+
+        include HStatement
+
+        # Creates a new statement for printing +args+.
+        def initialize(*args)
+            # Process the arguments.
+            super(*args.map(&:to_expr))
+        end
+
+        # Converts the connection to HDLRuby::Low.
+        def to_low
+            return HDLRuby::Low::Print.new(*self.each_arg.map(&:to_low))
+        end
+
+    end
+
+
     ## 
     # Describes a connection.
     class Connection < Low::Connection
@@ -3228,6 +3375,7 @@ module HDLRuby::High
                                                 self.right.to_low)
             # For debugging: set the source high object 
             connectionL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = connectionL
             return connectionL
         end
     end
@@ -3258,7 +3406,7 @@ module HDLRuby::High
         # NOTE: +dir+ can be :input, :output, :inout or :inner
         def initialize(name,type,dir,value =  nil)
             # Check the value.
-            value = value.to_expr if value
+            value = value.to_expr.match_type(type) if value
             # Initialize the type structure.
             super(name,type,value)
 
@@ -3341,6 +3489,7 @@ module HDLRuby::High
             signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low)
             # For debugging: set the source high object 
             signalIL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = signalIL
             return signalIL
         end
     end
@@ -3357,7 +3506,7 @@ module HDLRuby::High
         # and +value+.
         def initialize(name,type,value)
             # Check the value is a constant.
-            value = value.to_expr
+            value = value.to_expr.match_type(type)
             unless value.constant? then
                 raise AnyError,"Non-constant value assignment to constant."
             end
@@ -3406,6 +3555,7 @@ module HDLRuby::High
                                              self.value.to_low)
             # For debugging: set the source high object 
             signalCL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = signalCL
             return signalCL
         end
     end
@@ -3479,13 +3629,6 @@ module HDLRuby::High
             # Use its return value.
             return block.return_value
         end
-
-        # # Get the current mode of the block.
-        # #
-        # # NOTE: for name coherency purpose only. 
-        # def block
-        #     return self.mode
-        # end
         
         # Gets the current block.
         def cur_block
@@ -3583,6 +3726,12 @@ module HDLRuby::High
             end
             statement.hwhen(match, mode, &ruby_block)
         end
+
+
+        # Prints.
+        def hprint(*args)
+            self.add_statement(Print.new(*args))
+        end
     end
 
 
@@ -3619,6 +3768,7 @@ module HDLRuby::High
             blockL = HDLRuby::Low::Block.new(self.mode)
             # For debugging: set the source high object 
             blockL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = blockL
             # Push the namespace for the low generation.
             High.space_push(@namespace)
             # Pushes on the name stack for converting the internals of
@@ -3688,6 +3838,7 @@ module HDLRuby::High
             blockL = HDLRuby::Low::TimeBlock.new(self.mode)
             # For debugging: set the source high object 
             blockL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = blockL
             # Add the inner signals
             self.each_inner { |inner| blockL.add_inner(inner.to_low) }
             # Add the statements
@@ -3781,6 +3932,7 @@ module HDLRuby::High
             behaviorL = HDLRuby::Low::Behavior.new(blockL)
             # For debugging: set the source high object 
             behaviorL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = behaviorL
             eventLs.each(&behaviorL.method(:add_event))
             return behaviorL
         end
@@ -3810,6 +3962,7 @@ module HDLRuby::High
             timeBehaviorL = HDLRuby::Low::TimeBehavior.new(blockL)
             # For debugging: set the source high object 
             timeBehaviorL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = timeBehaviorL
             eventLs.each(&timeBehaviorL.method(:add_event))
             return timeBehaviorL
         end
@@ -4116,13 +4269,40 @@ module HDLRuby::High
 
     # Extends the String class for computing conversion to expression.
     class ::String
-        # Converts to a new high-level expression.
-        def to_expr
+        # # Converts to a new high-level expression.
+        # def to_expr
+        #     # 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)
+        # 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)
         end
+        
+        # Convert to a new high-level string expression
+        def to_expr
+            return StringE.new(self)
+        end
+
+        # For now deactivated, needs rethinking.
+        # # Rework format to generate HDLRuby string.
+        # alias_method :__format_old__, :%
+        # def %(args)
+        #     # Is there any HW argument?
+        #     if args.any? { |arg| arg.is_a?(HDLRuby::Low::Hparent) } then
+        #         # Yes generate a HDLRuby string.
+        #         return StringE.new(self,*args)
+        #     else
+        #         # No process the format normally.
+        #         self.__format_old__(args)
+        #     end
+        # end
     end
 
 
@@ -4216,11 +4396,14 @@ module HDLRuby::High
 
         # Converts to a new high-level expression.
         def to_expr
-            # expr = Concat.new
-            expr = Concat.new(TypeTuple.new(:"",:little,*self.map do |elem|
-                elem.to_expr.type
-            end))
-            self.each {|elem| expr.add_expression(elem.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) }
+            expr = Concat.new(typ)
+            elems.each {|elem| expr.add_expression(elem) }
             expr
         end
 
@@ -4291,6 +4474,11 @@ module HDLRuby::High
             end
         end
 
+        # Add support of the left arrow operator.
+        def <=(expr)
+            self.to_expr <= expr
+        end
+
         # Array construction shortcuts
 
         # Create an array whose number of elements is given by the content
@@ -4583,6 +4771,9 @@ def self.configure_high
         end
     end
 
+    # Initialize the this.
+    set_this
+
     # Generate the standard signals
     $clk = Universe.scope.inner :__universe__clk__
     $rst = Universe.scope.inner :__universe__rst__