HDLRuby 2.11.5 → 2.11.8

data/lib/HDLRuby/hruby_low.rb

@@ -4615,8 +4615,8 @@ module HDLRuby::Low
                 # Yes so it is also a left value if it is a sub ref.
                 if parent.respond_to?(:ref) then
                     # It might nor be a sub ref.
-                    # return parent.ref == self
-                    return parent.ref.eql?(self)
+                    # return parent.ref.eql?(self)
+                    return parent.ref.equal?(self)
                 else
                     # It is necessarily a sub ref (case of RefConcat for now).
                     return true
@@ -4624,8 +4624,8 @@ module HDLRuby::Low
             end
             # No, therefore maybe it is directly a left value.
             return (parent.is_a?(Transmit) || parent.is_a?(Connection)) &&
-                    # parent.left == self
-                parent.left.eql?(self)
+                # parent.left.eql?(self)
+                parent.left.equal?(self)
         end
 
         # Tells if the expression is a right value.
@@ -4715,9 +4715,18 @@ module HDLRuby::Low
                 # converted to BitString.
                 unless content.is_a?(Numeric) or
                         content.is_a?(HDLRuby::BitString)
-                    content = HDLRuby::BitString.new(content.to_s)
+                    # content = HDLRuby::BitString.new(content.to_s)
+                    content = content.to_s
+                    if self.type.unsigned? && content[0] != 0 then
+                        content = "0" + content.rjust(self.type.width,content[0])
+                    end
+                    content = HDLRuby::BitString.new(content)
                 end
                 @content = content 
+                if (@content.is_a?(Numeric) && self.type.unsigned?) then
+                    # Adjust the bits for unsigned.
+                    @content = @content & (2**self.type.width-1)
+                end
             end
         end
 

data/lib/HDLRuby/hruby_low2c.rb

@@ -20,6 +20,7 @@ module HDLRuby::Low
         #  h files.
         def self.includes(*names)
             res =  '#include <stdlib.h>' + "\n" + 
+                   '#include <string.h>' + "\n" +
                    '#include "hruby_sim.h"' + "\n"
             names.each { |name| res << "#include \"#{name}\"\n" }
             res << "\n"
@@ -687,6 +688,10 @@ module HDLRuby::Low
             if time then
                 res << " " * (level+1)*3
                 res << "register_timed_behavior(behavior);\n"
+            else
+                # Otherwise register it as a behavior to initialize. */
+                res << " " * (level+1)*3
+                res << "register_init_behavior(behavior);\n"
             end
 
             # Set the owner if any.
@@ -724,12 +729,39 @@ module HDLRuby::Low
                 refs = self.block.each_node_deep.select do |node|
                     node.is_a?(RefName) && !node.leftvalue? && 
                         !node.parent.is_a?(RefName) 
+                    # node.is_a?(RefName) && !node.parent.is_a?(RefName) 
                 end.to_a
                 # Keep only one ref per signal.
-                refs.uniq! { |node| node.full_name }
+                refs.uniq! { |ref| ref.full_name }
+                # # Remove the intermediate left values if sequential.
+                # self.each_block_deep do |blk|
+                #     if blk.mode == :seq && !blk.parent.is_a?(Behavior) then
+                #         blk.each_node_deep do |node|
+                #             if node.is_a?(RefName) && node.leftvalue? &&
+                #                 !node.parent.is_a?(RefName) then
+                #                 puts "removing ref=#{node.full_name}"
+                #                 refs.delete_if {|ref| ref.full_name == node.full_name }
+                #             end
+                #         end
+                #     end
+                # end
+                # # Remove left values.
+                # lefts = refs.select {|ref| ref.leftvalue? }.map do |ref|
+                #     ref.full_name
+                # end
+                # puts "lefts=#{lefts}"
+                # puts "first refs.size=#{refs.size}"
+                # refs.delete_if { |ref| lefts.include?(ref.full_name) }
+                # puts "now refs.size=#{refs.size}"
+                # puts "refs=#{refs.map {|r| r.full_name}}"
                 # Remove the inner signals from the list.
-                self.block.each_inner do |inner|
-                    refs.delete_if {|r| r.name == inner.name }
+                # self.block.each_inner do |inner|
+                #     refs.delete_if {|r| r.name == inner.name }
+                # end
+                self.each_block_deep do |blk|
+                    blk.each_inner do |inner|
+                        refs.delete_if {|r| r.name == inner.name }
+                    end
                 end
                 # Generate the event.
                 events = refs.map {|ref| Event.new(:anyedge,ref.clone) }
@@ -923,9 +955,9 @@ module HDLRuby::Low
             if self.value then
                 # There is an initial value.
                 res << " " * (level+1)*3
-                # res << "copy_value("
-                # self.value.to_c_expr(res,level+2)
-                # res << ",signalI->c_value);\n"
+                res << "copy_value("
+                self.value.to_c_expr(res,level+2)
+                res << ",signalI->c_value);\n"
                 res << "copy_value("
                 self.value.to_c_expr(res,level+2)
                 res << ",signalI->f_value);\n"
@@ -1725,26 +1757,49 @@ module HDLRuby::Low
             res << "if (is_defined()) {\n"
             # The condition is testable.
             # Generate the case as a succession of if statements.
-            self.each_when do |w|
+            # self.each_when do |w|
+            #     res << " " * ((level+2)*3)
+            #     res << "dup();\n"
+            #     res << " " * ((level+2)*3)
+            #     w.match.to_c(res,level+2)
+            #     res << "if (to_integer() == to_integer()) { \n"
+            #     w.statement.to_c(res,level+3)
+            #     res << " " * (level+2)*3
+            #     res << "}\n"
+            # end
+            # if self.default then
+            #     res << " " * (level+2)*3
+            #     res << "else {\n"
+            #     self.default.to_c(res,level+3)
+            #     res << " " * (level+2)*3
+            #     res << "}\n"
+            # end
+            res << " " * ((level+2)*3)
+            res << "int val=to_integer(), done=0;\n"
+            self.each_when.with_index do |w,i|
                 res << " " * ((level+2)*3)
-                res << "dup();\n"
+                res << "if (!done) {\n" unless i == 0
                 res << " " * ((level+2)*3)
                 w.match.to_c(res,level+2)
-                res << "if (to_integer() == to_integer()) {\n"
+                res << "if (val == to_integer()) {\n"
                 w.statement.to_c(res,level+3)
+                res << " " * (level+3)*3
+                res << "done = 1;\n"
                 res << " " * (level+2)*3
+                res << "}" unless i == 0
                 res << "}\n"
             end
             if self.default then
                 res << " " * (level+2)*3
-                res << "else {\n"
+                res << "if(!done) {\n"
                 self.default.to_c(res,level+3)
                 res << " " * (level+2)*3
                 res << "}\n"
             end
+
             # Close the case.
             res << " " * (level+1)*3
-            res << "pop();\n" # Remove the testing value.
+            # res << "pop();\n" # Remove the testing value.
             res << " " * (level+1)*3
             res << "}\n"
             res << " " * (level)*3
@@ -1832,7 +1887,7 @@ module HDLRuby::Low
         def to_c(res,level = 0)
             # The resulting string.
             res << " " * level*3
-            if (number < 0) then
+            if (self.number < 0) then
                 # Generate an infinite loop executing the block and waiting.
                 res << "for(;;) {\n"
             else
@@ -2058,8 +2113,6 @@ module HDLRuby::Low
         ## Generates the content of the h file.
         # def to_ch
         def to_ch(res)
-            # res = ""
-            # return "extern Value #{Low2C.make_name(self)}();"
             res << "extern Value " << Low2C.make_name(self) << "();"
             return res
         end
@@ -2072,74 +2125,131 @@ module HDLRuby::Low
         def to_c_make(res,level = 0)
             # Check is the value maker is already present.
             maker = Low2C.make_name(self);
-            # return "" if @@made_values.include?(maker)
             return res if @@made_values.include?(maker)
             @@made_values.add(maker)
 
-            # The resulting string.
-            # res = ""
-
             # The header of the value generation.
             res << " " * level*3
-            # res << "Value " << Low2C.make_name(self) << "() {\n"
             res << "Value " << maker << "() {\n"
 
+            # # Declares the data.
+            # # Create the bit string.
+            # # str = self.content.is_a?(BitString) ?
+            # #     self.content.to_s : self.content.to_s(2).rjust(32,"0")
+            # if self.content.is_a?(BitString) then
+            #     str = self.content.is_a?(BitString) ?
+            #         self.content.to_s : self.content.to_s(2).rjust(32,"0")
+            # else
+            #     # sign = self.content>=0 ? "0" : "1"
+            #     # str = self.content.abs.to_s(2).rjust(width,sign).upcase
+            #     if self.content >= 0 then
+            #         str = self.content.to_s(2).rjust(width,"0").upcase
+            #     else
+            #         # Compute the extension to the next multiple
+            #         # of int_width
+            #         ext_width = (((width-1) / Low2C.int_width)+1)*Low2C.int_width
+            #         # Convert the string.
+            #         str = (2**ext_width+self.content).to_s(2).upcase
+            #     end
+            #     # puts "content=#{self.content} str=#{str}"
+            # end
+            # # Is it a fully defined number?
+            # # NOTE: bignum values are not supported by the simulation engine
+            # #       yet, therefore numeric values are limited to 64 max.
+            # if str =~ /^[01]+$/ && str.length <= 64 then
+            #     # Yes, generate a numeral value.
+            #     res << " " * (level+1)*3
+            #     res << "static unsigned int data[] = { "
+            #     res << str.scan(/.{1,#{Low2C.int_width}}/m).reverse.map do |sub|
+            #         sub.to_i(2).to_s # + "ULL"
+            #     end.join(",")
+            #     res << ", 0" if (str.length <= 32)
+            #     res << " };\n"
+            #     # Create the value.
+            #     res << " " * (level+1)*3
+            #     # puts "str=#{str} type width=#{self.type.width} signed? #{type.signed?}"
+            #     # res << "return make_set_value(#{self.type.to_c(level+1)},1," +
+            #     #        "data);\n" 
+            #     res << "return make_set_value("
+            #     self.type.to_c(res,level+1)
+            #     res << ",1,data);\n" 
+            # else
+            #     # No, generate a bit string value.
+            #     res << " " * (level+1)*3
+            #     # res << "static unsigned char data[] = \"#{str}\";\n"
+            #     res << "static unsigned char data[] = \"#{str.reverse}\";\n"
+            #     # Create the value.
+            #     res << " " * (level+1)*3
+            #     # res << "return make_set_value(#{self.type.to_c(level+1)},0," +
+            #     #        "data);\n" 
+            #     res << "return make_set_value("
+            #     self.type.to_c(res,level+1)
+            #     res << ",0,data);\n" 
+            # end
+
             # Declares the data.
-            # Create the bit string.
-            # str = self.content.is_a?(BitString) ?
-            #     self.content.to_s : self.content.to_s(2).rjust(32,"0")
-            if self.content.is_a?(BitString) then
-                str = self.content.is_a?(BitString) ?
-                    self.content.to_s : self.content.to_s(2).rjust(32,"0")
-            else
-                # sign = self.content>=0 ? "0" : "1"
-                # str = self.content.abs.to_s(2).rjust(width,sign).upcase
-                if self.content >= 0 then
-                    str = self.content.to_s(2).rjust(width,"0").upcase
+            if self.content.is_a?(::Integer) then
+                if self.type.width <= 64 then
+                    res << " " * (level+1)*3
+                    res << "Value value = make_value("
+                    self.type.to_c(res,level+1)
+                    res << ",1);\n"
+                    # res << " " * (level+1)*3
+                    # res << "value->numeric = 1;\n"
+                    res << " " * (level+1)*3
+                    res << "value->capacity = 0;\n"
+                    res << " " * (level+1)*3
+                    res << "value->data_str = NULL;\n"
+                    res << " " * (level+1)*3
+                    if self.content.bit_length <= 63 then
+                        res << "value->data_int = #{self.content}LLU;\n"
+                    else
+                        res << "value->data_int = "
+                        res << "#{self.content & 0xFFFFFFFFFFFF}LLU;\n"
+                    end
+                    # Close the value.
+                    res << " " * (level+1)*3
+                    res << "return value;\n"
+                    res << " " * level*3
+                    res << "}\n\n"
+                    # Return the result.
+                    return res
                 else
-                    # Compute the extension to the next multiple
-                    # of int_width
-                    ext_width = (((width-1) / Low2C.int_width)+1)*Low2C.int_width
-                    # Convert the string.
-                    str = (2**ext_width+self.content).to_s(2).upcase
+                    str = self.content.to_s(2)
+                    # if str[-1] == "-" then
+                    #     str[-1] = "1"
+                    # elsif str[-1] == "1" then
+                    #     str = "0" + str
+                    # end
+                    if self.content < 0 then
+                        str = (2**self.type.width + self.content).to_s(2)
+                        str = "1" * (self.type.width-str.length) + str
+                    else
+                        str = self.content.to_s(2)
+                        str = "0" * (self.type.width-str.length) + str
+                    end
+                    str.reverse!
                 end
-                # puts "content=#{self.content} str=#{str}"
-            end
-            # Is it a fully defined number?
-            # NOTE: bignum values are not supported by the simulation engine
-            #       yet, therefore numeric values are limited to 64 max.
-            if str =~ /^[01]+$/ && str.length <= 64 then
-                # Yes, generate a numeral value.
-                res << " " * (level+1)*3
-                res << "static unsigned int data[] = { "
-                res << str.scan(/.{1,#{Low2C.int_width}}/m).reverse.map do |sub|
-                    sub.to_i(2).to_s # + "ULL"
-                end.join(",")
-                res << ", 0" if (str.length <= 32)
-                res << " };\n"
-                # Create the value.
-                res << " " * (level+1)*3
-                # puts "str=#{str} type width=#{self.type.width} signed? #{type.signed?}"
-                # res << "return make_set_value(#{self.type.to_c(level+1)},1," +
-                #        "data);\n" 
-                res << "return make_set_value("
-                self.type.to_c(res,level+1)
-                res << ",1,data);\n" 
             else
-                # No, generate a bit string value.
-                res << " " * (level+1)*3
-                # res << "static unsigned char data[] = \"#{str}\";\n"
-                res << "static unsigned char data[] = \"#{str.reverse}\";\n"
-                # Create the value.
-                res << " " * (level+1)*3
-                # res << "return make_set_value(#{self.type.to_c(level+1)},0," +
-                #        "data);\n" 
-                res << "return make_set_value("
-                self.type.to_c(res,level+1)
-                res << ",0,data);\n" 
+                str = content.to_s.reverse
             end
+            str = str.ljust(self.type.width,str[-1])
+            res << " " * (level+1)*3
+            res << "Value value = make_value("
+            self.type.to_c(res,level+1)
+            res << ",1);\n"
+            res << " " * (level+1)*3
+            res << "value->numeric = 0;\n"
+            res << " " * (level+1)*3
+            res << "value->capacity = #{str.length+1};"
+            res << " " * (level+1)*3
+            res << "value->data_str = calloc(value->capacity,sizeof(char));\n"
+            res << " " * (level+1)*3
+            res << "strcpy(value->data_str,\"#{str}\");\n"
 
             # Close the value.
+            res << " " * (level+1)*3
+            res << "return value;\n"
             res << " " * level*3
             res << "}\n\n"
             # Return the result.
@@ -2147,6 +2257,7 @@ module HDLRuby::Low
         end
     end
 
+
     ## Extends the Cast class with generation of C text.
     class Cast
 
@@ -2519,7 +2630,7 @@ module HDLRuby::Low
             end
             # Compute the resulting selection.
             res << (" " * (level*3))
-            res << "select(#{expressions.size});\n"
+            res << "hselect(#{expressions.size});\n"
             # Restore the value pool state.
             res << (" " * (level*3)) << "RV;\n"
             return res

data/lib/HDLRuby/hruby_low_without_connection.rb

@@ -29,7 +29,9 @@ module HDLRuby::Low
                 if scope.each_connection.to_a.any? then
                     inputs_blk = Block.new(:par)
                     outputs_blk = Block.new(:par)
-                    timed_blk = TimeBlock.new(:seq)
+                    # Timed block is not necessary anymore for initialization.
+                    # timed_blk = TimeBlock.new(:seq)
+                    timed_blk = Block.new(:seq)
                     scope.each_connection do |connection|
                         # puts "For connection: #{connection}"
                         # Check the left and right of the connection
@@ -134,7 +136,9 @@ module HDLRuby::Low
                         scope.add_behavior(Behavior.new(outputs_blk))
                     end
                     if timed_blk.each_statement.any? then
-                        scope.add_behavior(TimeBehavior.new(timed_blk))
+                        # No more required to be timed.
+                        # scope.add_behavior(TimeBehavior.new(timed_blk))
+                        scope.add_behavior(Behavior.new(timed_blk))
                     end
                 end
             end

data/lib/HDLRuby/hruby_rcsim.rb

@@ -78,11 +78,13 @@ module HDLRuby::High
 
     
     ## Starts the simulation for top system +top+.
-    #  NOTE: +name+ is the name of the simulation and +vcd+ tells if
-    #        the vcd generation is used and +outpath+ is the path where
-    #        the faile is to save.
-    def self.rcsim(top,name,outpath,vcd)
-        RCSim.rcsim_main(top.rcsystemT,outpath +"/" + name,vcd)
+    #  NOTE: +name+ is the name of the simulation, +outpath+ is the path where
+    #        the output is to save, and +outmode+ is the output mode as follows:
+    #        0: standard
+    #        1: mute
+    #        2: vcd
+    def self.rcsim(top,name,outpath,outmode)
+        RCSim.rcsim_main(top.rcsystemT,outpath +"/" + name,outmode)
     end
 
 
@@ -741,7 +743,7 @@ module HDLRuby::High
             # Create and add the events.
             rcevs = []
             self.right.each_node_deep do |node|
-                if node.is_a?(RefObject) then
+                if node.is_a?(RefObject) && !node.parent.is_a?(RefObject) then
                     ev = RCSim.rcsim_make_event(:anyedge,node.to_rcsim)
                     RCSim.rcsim_set_owner(ev,@rcbehavior)
                     rcevs << ev
@@ -786,16 +788,24 @@ module HDLRuby::High
         def to_rcsim
             # Create the value C object.
             if self.content.is_a?(::Integer) then
-                if self.content.bit_length <= 63 then
-                    return RCSim.rcsim_make_value_numeric(self.type.to_rcsim,
-                                                    self.content)
+                # puts "self.type.width=#{self.type.width} and content=#{self.content}" ; $stdout.flush
+                if self.type.width <= 64 then
+                    if self.content.bit_length <= 63 then
+                        return RCSim.rcsim_make_value_numeric(self.type.to_rcsim,
+                                                              self.content)
+                    else
+                        return RCSim.rcsim_make_value_numeric(self.type.to_rcsim,
+                                                              self.content & 0xFFFFFFFFFFFF)
+                    end
                 else
-                    str = self.content.to_s(2)
-                    if str[-1] == "-" then
-                        str[-1] = "1"
-                    elsif str[-1] == "1" then
-                        str = "0" + str
+                    if self.content < 0 then
+                        str = (2**self.type.width + self.content).to_s(2)
+                        str = "1" * (self.type.width-str.length) + str
+                    else
+                        str = self.content.to_s(2)
+                        str = "0" * (self.type.width-str.length) + str
                     end
+                    # puts "now str=#{str} (#{str.length})" ; $stdout.flush
                     return RCSim.rcsim_make_value_bitstring(self.type.to_rcsim,
                                                             str.reverse)
                 end
@@ -945,7 +955,7 @@ module HDLRuby::High
             #     RCSim.rcsim_add_refConcat_ref(rcref,ref.to_rcsim)
             # end
             if self.each_ref.any? then
-                RCSim.rcsim_add_refConcat_refs(rcref,self.each_ref(&:to_rcsim))
+                RCSim.rcsim_add_refConcat_refs(rcref,self.each_ref.map(&:to_rcsim))
             end
             
             return rcref

data/lib/HDLRuby/hruby_rsim.rb

@@ -19,6 +19,11 @@ module HDLRuby::High
         # Tell if the simulation is in multithread mode or not.
         attr_reader :multithread
 
+        ## Add untimed objet +obj+
+        def add_untimed(obj)
+            @untimeds << obj
+        end
+
         ## Add timed behavior +beh+.
         #  Returns the id of the timed behavior.
         def add_timed_behavior(beh)
@@ -41,21 +46,32 @@ module HDLRuby::High
 
         ## Advance the global simulator.
         def advance
-            # Display the time
-            self.show_time
+            # # Display the time
+            # self.show_time
             shown_values = {}
             # Get the behaviors waiting on activated signals.
             until @sig_active.empty? do
-                # # Update the signals.
-                # @sig_active.each { |sig| sig.c_value = sig.f_value }
                 # puts "sig_active.size=#{@sig_active.size}"
+                # puts "sig_active=#{@sig_active.map {|sig| sig.fullname}}"
                 # Look for the behavior sensitive to the signals.
+                # @sig_active.each do |sig|
+                #     sig.each_anyedge { |beh| @sig_exec << beh }
+                #     if (sig.c_value.zero? && !sig.f_value.zero?) then
+                #         # puts "sig.c_value=#{sig.c_value.content}"
+                #         sig.each_posedge { |beh| @sig_exec << beh }
+                #     elsif (!sig.c_value.zero? && sig.f_value.zero?) then
+                #         sig.each_negedge { |beh| @sig_exec << beh }
+                #     end
+                # end
                 @sig_active.each do |sig|
+                    next if (sig.c_value.eql?(sig.f_value))
+                    # next if (sig.c_value.to_vstr == sig.f_value.to_vstr)
+                    # puts "sig.c_value: #{sig.c_value.to_vstr}, sig.f_value=#{sig.f_value.to_vstr}"
                     sig.each_anyedge { |beh| @sig_exec << beh }
-                    if (sig.c_value.zero? && !sig.f_value.zero?) then
+                    if (sig.c_value.zero?) then
                         # puts "sig.c_value=#{sig.c_value.content}"
                         sig.each_posedge { |beh| @sig_exec << beh }
-                    elsif (!sig.c_value.zero? && sig.f_value.zero?) then
+                    elsif (!sig.c_value.zero?) then
                         sig.each_negedge { |beh| @sig_exec << beh }
                     end
                 end
@@ -81,6 +97,8 @@ module HDLRuby::High
                 # Advance time.
                 @time = (@timed_behaviors.min {|b0,b1|  b0.time <=> b1.time }).time
             end
+            # Display the time
+            self.show_time
         end
 
         ## Run the simulation from the current systemT and outputs the resuts
@@ -95,6 +113,8 @@ module HDLRuby::High
             # Initializes the time and signals execution buffers.
             @tim_exec = []
             @sig_exec = []
+            # Initilize the list of untimed objects.
+            @untimeds = []
             # Initialize the list of currently exisiting timed behavior.
             @timed_behaviors = []
             # Initialize the list of activated signals.
@@ -107,6 +127,10 @@ module HDLRuby::High
             # Initialize the displayer.
             self.show_init(simout)
 
+            # Initialize the untimed objects.
+            self.init_untimeds
+            # puts "End of init_untimed."
+
             # Is there more than one timed behavior.
             if @total_timed_behaviors <= 1 then
                 # No, no need of multithreading.
@@ -205,6 +229,17 @@ module HDLRuby::High
             # Recure on the scope.
             self.scope.init_sim(systemT)
         end
+
+        ## Initialize the untimed objects.
+        def init_untimeds
+            @untimeds.each do |obj|
+                if obj.is_a?(Behavior) then
+                    obj.block.execute(:seq)
+                else
+                    obj.execute(:seq)
+                end
+            end
+        end
         
         ## Initialize run for executing +ruby_block+
         def run_init(&ruby_block)
@@ -337,6 +372,8 @@ module HDLRuby::High
 
         ## Initialize the simulation for system +systemT+.
         def init_sim(systemT)
+            # Add the behavior to the list of untimed objects.
+            systemT.add_untimed(self)
             # Process the sensitivity list.
             # Is it a clocked behavior?
             events = self.each_event.to_a
@@ -351,6 +388,7 @@ module HDLRuby::High
                 end.to_a
                 # Keep only one ref per signal.
                 refs.uniq! { |node| node.fullname }
+                # puts "refs=#{refs.map {|node| node.fullname}}"
                 # Remove the inner signals from the list.
                 self.block.each_inner do |inner|
                     refs.delete_if {|r| r.name == inner.name }
@@ -516,8 +554,8 @@ module HDLRuby::High
             @f_value = value
             # Set the mode.
             @mode = mode
-            # puts "assign #{value.content} (#{value.content.class}) with self.type.width=#{self.type.width} while value.type.width=#{value.type.width}" if self.name.to_s.include?("idx")
-            # @f_value = value.cast(self.type) # Cast inserted by HDLRuby normally
+            # puts "assign #{value.content} (#{value.content.class}) with self.type.width=#{self.type.width} while value.type.width=#{value.type.width}" if self.name.to_s.include?("xnor")
+            @f_value = value.cast(self.type) # Cast not always inserted by HDLRuby normally
         end
 
         ## Assigns +value+ at +index+ (integer or range).
@@ -667,7 +705,7 @@ module HDLRuby::High
         ## Initialize the simulation for system +systemT+.
         def init_sim(systemT)
             self.each_when { |wh| wh.init_sim(systemT) }
-            self.default.init_sim(systemT)
+            self.default.init_sim(systemT) if self.default
         end
 
         ## Executes the statement.
@@ -678,7 +716,7 @@ module HDLRuby::High
                     return
                 end
             end
-                self.default.execute(mode)
+            self.default.execute(mode) if self.default
             end
         end
     end
@@ -849,6 +887,8 @@ module HDLRuby::High
 
         ## Initialize the simulation for system +systemT+.
         def init_sim(systemT)
+            # Add the connection to the list of untimed objets.
+            systemT.add_untimed(self)
             # Recurse on the left.
             self.left.init_sim(systemT)
             # Process the sensitivity list.
@@ -861,6 +901,8 @@ module HDLRuby::High
             end.to_a
             # Keep only one ref per signal.
             refs.uniq! { |node| node.fullname }
+            # puts "connection input: #{self.left.fullname}"
+            # puts "connection refs=#{refs.map {|node| node.fullname}}"
             # # Generate the event.
             # events = refs.map {|ref| Event.new(:anyedge,ref) }
             # # Add them to the behavior for further processing.
@@ -872,7 +914,7 @@ module HDLRuby::High
 
         ## Executes the statement.
         def execute(mode)
-            # puts "connection = #{self}"
+            # puts "connection = #{self}" if self.left.is_a?(RefObject) && self.left.object.name.to_s.include?("xnor")
             self.left.assign(mode,self.right.execute(mode))
         end
     end
@@ -972,10 +1014,18 @@ module HDLRuby::High
     class Select
         ## Execute the expression.
         def execute(mode)
+            unless @mask then
+                # Need to initialize the execution of the select.
+                width = (@choices.size-1).width
+                width = 1 if width == 0
+                @mask = 2**width - 1
+                @choices.concat([@choices[-1]] * (2**width-@choices.size))
+            end
             # Recurse on the select.
-            tmps = self.select.execute(mode)
+            tmps = self.select.execute(mode).to_i & @mask
+            # puts "select tmps=#{tmps}, @choices.size=#{@choices.size}"
             # Recurse on the selection result.
-            return @choices[tmps.to_i].execute(mode)
+            return @choices[tmps].execute(mode)
         end
     end