HDLRuby 2.6.4 → 2.6.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af0232d02d732388bb78569f40cf262167aeb9a5dc51b3b7ea98cf58a39da918
-  data.tar.gz: 5f46a159e7c3e0bf4414de3cda6bc78e5ac57060d958f0760a52012e18bc551e
+  metadata.gz: 639411f380dad2eb07b933ae8d23f558dc32e488ceadf1af897026b353a4164b
+  data.tar.gz: 8fb94917c40db1b73a63d323efdc04bbb1e5ebcb65460ebe42c0c468a75ac221
 SHA512:
-  metadata.gz: 69176b251e8c1a226e08ad1c45d3d57176c58424e849094ee07cbb3591a5743daf146a332076691ebbab9e100adb7d6a7a23104a1657bb684b79598f6df3ee03
-  data.tar.gz: 7f99f1f0551682713ecb20b9a0e93c85b6f7244c6ad6b0c3aa7e587b915be400ce914cedbb2f17a890a1e813db79c5d50b7117746c0d405386788d78d09c22db
+  metadata.gz: 0d00decbd699cc46f450c913b98e5d881fc10e3a9d171126bc3744ad8d05408536b38bc90d1d15227da67302570a425eb2ceccef7d65959e19f591a35aa1f00c
+  data.tar.gz: 9a2f9568732a851786fdfcd794ab146efa4ea36458163a11fe6c992c59bd53f643cd4691804f68e3438f8ce233996af7dd0d8ba205834596bf2b8c7d442ca69d

data/lib/HDLRuby/hdr_samples/comparison_bench.rb

@@ -0,0 +1,40 @@
+# Test the comparison operators.
+
+# A benchmark for the adder.
+system :adder_bench do
+    [8].inner :x, :y
+    signed[8].inner :u,:v
+    inner :ue, :ult, :ule, :ugt, :uge
+    inner :se, :slt, :sle, :sgt, :sge
+
+    par do
+        ue  <= (x == y)
+        ult <= (x < y)
+        ule <= (x <= y)
+        ugt <= (x > y)
+        uge <= (x >= y)
+
+        se  <= (u == v)
+        slt <= (u < v)
+        sle <= (u <= v)
+        sgt <= (u > v)
+        sge <= (u >= v)
+    end
+
+    timed do
+        x <= 0
+        y <= 0
+        u <= 0
+        v <= 0
+        !10.ns
+        x <= 1
+        u <= 1
+        !10.ns
+        y <= 2
+        v <= 2
+        !10.ns
+        x <= 2
+        u <= -2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/neg_arith_bench.rb

@@ -2,6 +2,7 @@
 # A benchmark for testing the arithmetic with signed values.
 system :neg_arith_bench do
     signed[11..0].inner :x,:y,:z
+    inner :cmp
 
     timed do
         x <= 10
@@ -9,41 +10,51 @@ system :neg_arith_bench do
         z <= 0
         !10.ns
         z <= 10 * 10
+        cmp <= (10 < 10)
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= 10
         y <= -10
         !10.ns
         z <= 10 * (-10)
+        cmp <= (10 < -10)
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= -10
         y <= 10
         !10.ns
         z <= (-10) * 10
+        cmp <= (-10 < 10)
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= -10
         y <= -10
         !10.ns
         z <= (-10) * (-10)
+        cmp <= (-10 < -10)
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= _000000011010
         y <= _000011111010
         z <= 0
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
         x <= _000000011010
         y <= _111111111010
         z <= 0
         !10.ns
         z <= x * y
+        cmp <= (x < y)
         !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/type_minmax_bench.rb

@@ -0,0 +1,37 @@
+# Test the type method min and max
+
+# A benchmark for the adder.
+system :adder_bench do
+    [32].inner :x
+    signed[32].inner :y
+
+    timed do
+        x <= 0
+        y <= 0
+        !10.ns
+        x <= bit[8].max
+        y <= signed[8].max
+        !10.ns
+        x <= bit[8].min
+        y <= signed[8].min
+        !10.ns
+        x <= bit[10].max
+        y <= signed[10].max
+        !10.ns
+        x <= bit[10].min
+        y <= signed[10].min
+        !10.ns
+        x <= bit[16].max
+        y <= signed[16].max
+        !10.ns
+        x <= bit[16].min
+        y <= signed[16].min
+        !10.ns
+        x <= bit[32].max
+        y <= signed[32].max
+        !10.ns
+        x <= bit[32].min
+        y <= signed[32].min
+        !10.ns
+    end
+end

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

@@ -491,24 +491,28 @@ end
 
 # Generate the result.
 # Get the top systemT.
+puts Time.now
 $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
+$top_intance = nil # Free as much memory as possible.
+puts "##### Top system built #####"
+puts Time.now
+
+
+# # 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.
@@ -558,15 +562,23 @@ elsif $options[:clang] then
     # top_system = $top_system
     # Preprocess the HW description for valid C generation.
     $top_system.each_systemT_deep do |systemT|
+        puts "seq2seq step..."
         # Coverts the par blocks in seq blocks to seq blocks to match
         # the simulation engine.
         systemT.par_in_seq2seq!
+        puts Time.now
+        puts "connections_to_behaviors step..."
         # Converts the connections to behaviors.
         systemT.connections_to_behaviors!
+        puts Time.now
         # Break the RefConcat.
+        puts "concat_assigns step..."
         systemT.break_concat_assigns! 
+        puts Time.now
         # Explicits the types.
+        puts "explicit_types step..."
         systemT.explicit_types!
+        puts Time.now
     end
     # Generate the C.
     if $options[:multiple] then
@@ -637,6 +649,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.
@@ -690,14 +703,26 @@ elsif $options[:verilog] then
     # top_system = $top_system
     # Make description compatible with verilog generation.
     $top_system.each_systemT_deep do |systemT|
+        puts "casts_without_expression! step..."
         systemT.casts_without_expression!
+        puts Time.now
+        puts "to_upper_space! step..."
         systemT.to_upper_space!
+        puts Time.now
+        puts "to_global_space! step..."
         systemT.to_global_systemTs!
+        puts Time.now
         # systemT.break_types!
         # systemT.expand_types!
+        puts "par_in_seq2seq! step..."
         systemT.par_in_seq2seq!
+        puts Time.now
+        puts "initial_concat_to_timed! step..."
         systemT.initial_concat_to_timed!
+        puts Time.now
+        puts "with_port! step..."
         systemT.with_port!
+        puts Time.now
     end
     # # Verilog generation
     # $output << top_system.to_verilog
@@ -787,13 +812,13 @@ elsif $options[:vhdl] then
     end
 end
 
-# Apply the post drivers if any.
-Hdecorator.each_with_property(:post_driver) do |obj, value|
-    # Load the driver.
-    require_relative(value[0].to_s)
-    # Execute it.
-    send(value[1].to_sym,obj,$output)
-end
+# # Apply the post drivers if any.
+# Hdecorator.each_with_property(:post_driver) do |obj, value|
+#     # Load the driver.
+#     require_relative(value[0].to_s)
+#     # Execute it.
+#     send(value[1].to_sym,obj,$output)
+# end
 
 # Dump the properties
 if $options[:dump] then

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)
@@ -758,11 +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)
-            # For debugging: set the source high object 
-            systemTL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = systemTL
+            # 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.
@@ -1308,9 +1311,9 @@ module HDLRuby::High
             # Create the resulting low scope.
             # scopeL = HDLRuby::Low::Scope.new()
             scopeL = HDLRuby::Low::Scope.new(self.name)
-            # For debugging: set the source high object 
-            scopeL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = scopeL
+            # # 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)
@@ -1542,9 +1545,9 @@ module HDLRuby::High
         def to_low(name = self.name)
             # return HDLRuby::Low::Type.new(name)
             typeL = HDLRuby::Low::Type.new(name)
-            # For debugging: set the source high object 
-            typeL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = typeL
+            # # For debugging: set the source high object 
+            # typeL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = typeL
             return typeL
         end
     end
@@ -1696,9 +1699,9 @@ module HDLRuby::High
         def to_low(name = self.name)
             # return HDLRuby::Low::TypeDef.new(name,self.def.to_low)
             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
+            # # For debugging: set the source high object 
+            # typeDefL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = typeDefL
             return typeDefL
         end
     end
@@ -1749,9 +1752,9 @@ module HDLRuby::High
         def to_low(name = self.name)
             # return HDLRuby::Low::TypeDef.new(name,self.def.to_low)
             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
+            # # For debugging: set the source high object 
+            # typeDefL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = typeDefL
             return typeDefL
         end
     end
@@ -1767,9 +1770,9 @@ module HDLRuby::High
             #                                     self.range.to_low)
             typeVectorL = HDLRuby::Low::TypeVector.new(name,self.base.to_low,
                                                 self.range.to_low)
-            # For debugging: set the source high object 
-            typeVectorL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = typeVectorL
+            # # For debugging: set the source high object 
+            # typeVectorL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = typeVectorL
             return typeVectorL
         end
     end
@@ -1847,9 +1850,9 @@ module HDLRuby::High
             #                    *@types.map { |type| type.to_low } )
             typeTupleL = HDLRuby::Low::TypeTuple.new(name,self.direction,
                                *@types.map { |type| type.to_low } )
-            # For debugging: set the source high object 
-            typeTupleL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = typeTupleL
+            # # For debugging: set the source high object 
+            # typeTupleL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = typeTupleL
             return typeTupleL
         end
     end
@@ -1868,9 +1871,9 @@ module HDLRuby::High
             #                     @types.map { |name,type| [name,type.to_low] } )
             typeStructL = HDLRuby::Low::TypeStruct.new(name,self.direction,
                                 @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
+            # # For debugging: set the source high object 
+            # typeStructL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = typeStructL
             return typeStructL
         end
     end
@@ -2108,9 +2111,9 @@ module HDLRuby::High
             # Creates the resulting HDLRuby::Low instance
             systemIL = HDLRuby::Low::SystemI.new(High.names_create(name),
                                              systemTL)
-            # For debugging: set the source high object 
-            systemIL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = systemIL
+            # # 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
@@ -2136,9 +2139,9 @@ module HDLRuby::High
                 lump = lump.respond_to?(:to_low) ? lump.to_low : lump.to_s
                 lump
             end)
-            # For debugging: set the source high object 
-            chunkL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = chunkL
+            # # For debugging: set the source high object 
+            # chunkL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = chunkL
             return chunkL
         end
     end
@@ -2150,9 +2153,9 @@ module HDLRuby::High
         def to_low
             # Create the resulting code.
             codeL = HDLRuby::Low::Code.new
-            # For debugging: set the source high object 
-            codeL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = codeL
+            # # 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.
@@ -2244,9 +2247,9 @@ module HDLRuby::High
             ifL = HDLRuby::Low::If.new(self.condition.to_low,
                                        self.yes.to_low,noL)
             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
+            # # For debugging: set the source high object 
+            # ifL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = ifL
             return ifL
         end
     end
@@ -2269,9 +2272,9 @@ module HDLRuby::High
             #                               self.statement.to_low)
             whenL = HDLRuby::Low::When.new(self.match.to_low,
                                           self.statement.to_low)
-            # For debugging: set the source high object 
-            whenL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = whenL
+            # # For debugging: set the source high object 
+            # whenL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = whenL
             return whenL
         end
     end
@@ -2317,9 +2320,9 @@ module HDLRuby::High
         def to_low
             # Create the low level case.
             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
+            # # 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)
@@ -2348,9 +2351,9 @@ module HDLRuby::High
         def to_low
             # return HDLRuby::Low::Delay.new(self.value, self.unit)
             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
+            # # For debugging: set the source high object 
+            # delayL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = delayL
             return delayL
         end
     end
@@ -2364,9 +2367,9 @@ module HDLRuby::High
         def to_low
             # return HDLRuby::Low::TimeWait.new(self.delay.to_low)
             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
+            # # For debugging: set the source high object 
+            # timeWaitL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = timeWaitL
             return timeWaitL
         end
     end
@@ -2383,9 +2386,9 @@ module HDLRuby::High
             #                                     self.delay.to_low)
             timeRepeatL = HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
                                                 self.delay.to_low)
-            # For debugging: set the source high object 
-            timeRepeatL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = timeRepeatL
+            # # For debugging: set the source high object 
+            # timeRepeatL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = timeRepeatL
             return timeRepeatL
         end
     end
@@ -2655,7 +2658,6 @@ module HDLRuby::High
             end
         end
 
-
         # Converts to a select operator using current expression as
         # condition for one of the +choices+.
         #
@@ -2671,6 +2673,7 @@ module HDLRuby::High
         end
 
 
+
         # Methods for conversion for HDLRuby::Low: type processing, flattening
         # and so on
 
@@ -2743,9 +2746,9 @@ module HDLRuby::High
         def to_low
             # return HDLRuby::Low::Cast.new(self.type.to_low,self.child.to_low)
             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
+            # # For debugging: set the source high object 
+            # castL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = castL
             return castL
         end
     end
@@ -2767,9 +2770,9 @@ module HDLRuby::High
             #                                self.child.to_low)
             unaryL = HDLRuby::Low::Unary.new(self.type.to_low, self.operator,
                                            self.child.to_low)
-            # For debugging: set the source high object 
-            unaryL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = unaryL
+            # # For debugging: set the source high object 
+            # unaryL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = unaryL
             return unaryL
         end
     end
@@ -2792,9 +2795,9 @@ module HDLRuby::High
             #                                self.left.to_low, self.right.to_low)
             binaryL = HDLRuby::Low::Binary.new(self.type.to_low, self.operator,
                                            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
+            # # For debugging: set the source high object 
+            # binaryL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = binaryL
             return binaryL
         end
     end
@@ -2827,9 +2830,9 @@ module HDLRuby::High
             *self.each_choice.map do |choice|
                 choice.to_low
             end)
-            # For debugging: set the source high object 
-            selectL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = selectL
+            # # For debugging: set the source high object 
+            # selectL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = selectL
             return selectL
         end
     end
@@ -2861,9 +2864,9 @@ module HDLRuby::High
                     expr.to_low
                 end
             )
-            # For debugging: set the source high object 
-            concatL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = concatL
+            # # For debugging: set the source high object 
+            # concatL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = concatL
             return concatL
         end
     end
@@ -2905,9 +2908,9 @@ module HDLRuby::High
             # Create and return the resulting low-level value
             # return HDLRuby::Low::Value.new(self.type.to_low,self.content)
             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
+            # # For debugging: set the source high object 
+            # valueL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = valueL
             return valueL
         end
 
@@ -3013,9 +3016,9 @@ module HDLRuby::High
             # 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
+            # # For debugging: set the source high object 
+            # refNameL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = refNameL
             return refNameL
         end
 
@@ -3053,9 +3056,9 @@ module HDLRuby::High
                     ref.to_low
                 end
             )
-            # For debugging: set the source high object 
-            refConcatL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = refConcatL
+            # # For debugging: set the source high object 
+            # refConcatL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = refConcatL
             return refConcatL
         end
     end
@@ -3077,9 +3080,9 @@ module HDLRuby::High
             #                                 self.ref.to_low,self.index.to_low)
             refIndexL = HDLRuby::Low::RefIndex.new(self.type.to_low,
                                             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
+            # # For debugging: set the source high object 
+            # refIndexL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = refIndexL
             return refIndexL
         end
     end
@@ -3101,9 +3104,9 @@ module HDLRuby::High
             #     self.ref.to_low,self.range.to_low)
             refRangeL = HDLRuby::Low::RefRange.new(self.type.to_low,
                 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
+            # # For debugging: set the source high object 
+            # refRangeL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = refRangeL
             return refRangeL
         end
     end
@@ -3124,9 +3127,9 @@ module HDLRuby::High
             #                                  self.ref.to_low,self.name)
             refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                              self.ref.to_low,self.name)
-            # For debugging: set the source high object 
-            refNameL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = refNameL
+            # # For debugging: set the source high object 
+            # refNameL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = refNameL
             return refNameL
         end
     end
@@ -3161,9 +3164,9 @@ module HDLRuby::High
         def to_low
             # return HDLRuby::Low::RefThis.new
             refThisL = HDLRuby::Low::RefThis.new
-            # For debugging: set the source high object 
-            refThisL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = refThisL
+            # # For debugging: set the source high object 
+            # refThisL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = refThisL
             return refThisL
         end
     end
@@ -3234,9 +3237,9 @@ module HDLRuby::High
         def to_low
             # return HDLRuby::Low::Event.new(self.type,self.ref.to_low)
             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
+            # # For debugging: set the source high object 
+            # eventL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = eventL
             return eventL
         end
     end
@@ -3277,9 +3280,9 @@ module HDLRuby::High
             #                                   self.right.to_low)
             transmitL = HDLRuby::Low::Transmit.new(self.left.to_low,
                                               self.right.to_low)
-            # For debugging: set the source high object 
-            transmitL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = transmitL
+            # # For debugging: set the source high object 
+            # transmitL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = transmitL
             return transmitL
         end
     end
@@ -3370,9 +3373,9 @@ module HDLRuby::High
             #                                     self.right.to_low)
             connectionL = HDLRuby::Low::Connection.new(self.left.to_low,
                                                 self.right.to_low)
-            # For debugging: set the source high object 
-            connectionL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = connectionL
+            # # For debugging: set the source high object 
+            # connectionL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = connectionL
             return connectionL
         end
     end
@@ -3484,9 +3487,9 @@ module HDLRuby::High
         def to_low(name = self.name)
             # return HDLRuby::Low::SignalI.new(name,self.type.to_low)
             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
+            # # For debugging: set the source high object 
+            # signalIL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = signalIL
             return signalIL
         end
     end
@@ -3550,9 +3553,9 @@ module HDLRuby::High
             #                                  self.value.to_low)
             signalCL = HDLRuby::Low::SignalC.new(name,self.type.to_low,
                                              self.value.to_low)
-            # For debugging: set the source high object 
-            signalCL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = signalCL
+            # # For debugging: set the source high object 
+            # signalCL.properties[:low2high] = self.hdr_id
+            # self.properties[:high2low] = signalCL
             return signalCL
         end
     end
@@ -3763,9 +3766,9 @@ module HDLRuby::High
         def to_low
             # Create the resulting block
             blockL = HDLRuby::Low::Block.new(self.mode)
-            # For debugging: set the source high object 
-            blockL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = blockL
+            # # 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
@@ -3833,9 +3836,9 @@ module HDLRuby::High
         def to_low
             # Create the resulting block
             blockL = HDLRuby::Low::TimeBlock.new(self.mode)
-            # For debugging: set the source high object 
-            blockL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = blockL
+            # # 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
@@ -3927,9 +3930,9 @@ module HDLRuby::High
             eventLs = self.each_event.map { |event| event.to_low }
             # Create and return the resulting low level behavior.
             behaviorL = HDLRuby::Low::Behavior.new(blockL)
-            # For debugging: set the source high object 
-            behaviorL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = behaviorL
+            # # 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
@@ -3957,9 +3960,9 @@ module HDLRuby::High
             eventLs = self.each_event.map { |event| event.to_low }
             # Create and return the resulting low level behavior.
             timeBehaviorL = HDLRuby::Low::TimeBehavior.new(blockL)
-            # For debugging: set the source high object 
-            timeBehaviorL.properties[:low2high] = self.hdr_id
-            self.properties[:high2low] = timeBehaviorL
+            # # 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
@@ -4234,6 +4237,22 @@ module HDLRuby::High
     #     end
     # end
     
+    # Extends the TrueClass class for computing for conversion to expression.
+    class ::TrueClass
+        # Converts to a new high-level expression.
+        def to_expr
+            return Value.new(Integer,1)
+        end
+    end
+    
+    # Extends the FalseClass class for computing for conversion to expression.
+    class ::FalseClass
+        # Converts to a new high-level expression.
+        def to_expr
+            return Value.new(Integer,0)
+        end
+    end
+    
     # Extends the Integer class for computing for conversion to expression.
     class ::Integer
         # Converts to a new high-level expression.