HDLRuby 2.11.11 → 2.11.12

data/lib/HDLRuby/hruby_low2c.rb

@@ -641,12 +641,10 @@ module HDLRuby::Low
         # +level+ is the hierachical level of the object.
         # def to_c(level = 0)
         def to_c(res,level = 0)
-            # return "get_type_struct(#{self.each.join(",") do |key,type|
-            #     "\"#{key.to_s}\",#{type.to_c(level+1)}"
-            # end})"
-            res << "get_type_struct(#{self.each.join(",") do |key,type|
-                "\"#{key.to_s}\",#{type.to_c("",level+1)}"
-            end})"
+            # res << "get_type_struct(#{self.each.map do |key,type|
+            #     "\"#{key.to_s}\",#{type.to_c("",level+1)}"
+            # end.join(",")})"
+            self.to_vector.to_c(res,level)
             return res
         end
     end
@@ -897,8 +895,17 @@ module HDLRuby::Low
         #  +level+ is the hierachical level of the object.
         # def to_c(level = 0)
         def to_c(res,level = 0)
+            # First generate the sub signals if any.
+            if self.each_signal.any? then
+                self.each_signal do |signal|
+                    signal.to_c(res,level)
+                end
+                # return res
+            end
 
-            # puts "Signal.to_c with name: #{Low2C.obj_name(self)}"
+            # No sub signals, generate for the current one.
+
+            # puts "Signal.to_c with signal #{self.name} and c_name: #{Low2C.obj_name(self)}"
             # Declare the global variable holding the signal.
             res << "SignalI "
             self.to_c_signal(res,level+1)
@@ -943,6 +950,22 @@ module HDLRuby::Low
             res << "signalI->type = "
             self.type.to_c(res,level+2)
             res << ";\n"
+
+            # Generate and set the sub signals if any.
+            res << " " * (level+1)*3
+            num_sig = self.each_signal.to_a.size
+            res << "signalI->num_signals = #{num_sig};\n"
+            if num_sig > 0 then
+                res << " " * (level+1)*3
+                res << "signalI->signals = calloc(sizeof(SignalI),#{num_sig});\n"
+                self.each_signal.with_index do |sig,i|
+                    res << " " * (level+1)*3
+                    res << "#{Low2C.obj_name(sig)} = #{Low2C.make_name(sig)}();\n"
+                    res << " " * (level+1)*3
+                    res << "signalI->signals[#{i}] = #{Low2C.obj_name(sig)};\n"
+                end
+            end
+
             # Set the current and the next value.
             res << " " * (level+1)*3
             res << "signalI->c_value = make_value(signalI->type,0);\n"
@@ -1000,6 +1023,15 @@ module HDLRuby::Low
         ## Generates the content of the h file.
         # def to_ch
         def to_ch(res)
+            # First generate the sub signals if any.
+            if self.each_signal.any? then
+                self.each_signal do |signal|
+                    signal.to_ch(res)
+                end
+                # return res
+            end
+
+            # No sub sub signal, generate for the current signal.
             # res = ""
             # puts "to_ch for SignalI: #{self.to_c_signal()}"
             # Declare the global variable holding the signal.
@@ -2205,7 +2237,7 @@ module HDLRuby::Low
                         res << "value->data_int = #{self.content}LLU;\n"
                     else
                         res << "value->data_int = "
-                        res << "#{self.content & 0xFFFFFFFFFFFF}LLU;\n"
+                        res << "#{self.content & 0xFFFF_FFFF_FFFF_FFFF}LLU;\n"
                     end
                     # Close the value.
                     res << " " * (level+1)*3
@@ -2697,7 +2729,7 @@ module HDLRuby::Low
             end
             # Compute the resulting concatenation.
             res << (" " * ((level+1)*3))
-            # puts "self.type.direction=#{self.type.direction}\n"
+            # puts "self.type=#{self.type} self.type.direction=#{self.type.direction}\n"
             res << "sconcat(#{expressions.size},"
             res << (self.type.direction == :little ? "1" : "0")
             res << ");\n"
@@ -3054,14 +3086,42 @@ module HDLRuby::Low
             res << "->" << (left ? "f_value" : "c_value")
             res << ");\n"
             return res
+            # sig = self.resolve
+            # if sig.each_signal.any? then
+            #     # Save the value pool state.
+            #     res << (" " * (level*3)) << "PV;\n"
+            #     # There are sub signals, get and concat their values.
+            #     subs = sig.each_signal.to_a
+            #     subs.each do |sub|
+            #         res << (" " * (level*3))
+            #         res << "push("
+            #         sub.to_c_signal(res,level+1)
+            #         res << "->" << (left ? "f_value" : "c_value")
+            #         res << ");\n"
+            #     end
+            #     # Compute the resulting concatenation.
+            #     res << (" " * ((level+1)*3))
+            #     res << "sconcat(#{subs.size},"
+            #     res << (sig.type.direction == :little ? "1" : "0")
+            #     res << ");\n"
+            #     # Restore the value pool state.
+            #     res << (" " * (level*3)) << "RV;\n"
+            # else
+            #     # There is no sub signals, get the signal value.
+            #     res << (" " * (level*3))
+            #     res << "push("
+            #     sig.to_c_signal(res,level+1)
+            #     res << "->" << (left ? "f_value" : "c_value")
+            #     res << ");\n"
+            # end
+            # return res
         end
 
         # Generates the C text for reference as left value to a signal.
         # +level+ is the hierarchical level of the object.
         # def to_c_signal(level = 0)
         def to_c_signal(res,level = 0)
-            # puts "to_c_signal with self=#{self.name}, resolve=#{self.resolve}"
-            # return "#{self.resolve.to_c_signal(level+1)}"
+            # puts "to_c_signal with self=#{self.name}"
             self.resolve.to_c_signal(res,level+1)
             return res
         end

data/lib/HDLRuby/hruby_low2vhd.rb

@@ -807,7 +807,8 @@ module HDLRuby::Low
             res << " " * (level*3)
             res << "begin\n"
             # Generate the edges if any.
-            if self.each_event.find {|event| event.type != :change} then
+            # if self.each_event.find {|event| event.type != :change} then
+            if self.each_event.find {|event| event.type != :anyedge} then
                 # Generate the edge test.
                 level = level + 1
                 res << " " * (level*3)

data/lib/HDLRuby/hruby_low_fix_types.rb

@@ -389,6 +389,7 @@ module HDLRuby::Low
                 # No, recurse on the sub expressions.
                 return RefConcat.new(self.type,self.each_ref.map.with_index do
                     |ref,i| 
+                    puts "self.type=#{self.type}"
                     ref.explicit_types(self.type.get_type(i))
                 end)
             end

data/lib/HDLRuby/hruby_low_mutable.rb

@@ -600,6 +600,9 @@ module HDLRuby::Low
             right.parent = self unless right.parent
         end
 
+        alias_method :map_expressions!, :map_nodes!
+
+
         # Replaces sub expressions using +node2rep+ table indicating the
         # node to replace and the corresponding replacement.
         # Returns the actually replaced nodes and their corresponding
@@ -908,6 +911,10 @@ module HDLRuby::Low
         # Sets the default.
         def set_default!(default)
             # Checks and set the default case if any.
+            if self.default then
+                # There is a default first detach it.
+                @default = nil
+            end
             self.default = default
         end
 
@@ -1172,7 +1179,11 @@ module HDLRuby::Low
                 raise AnyError, "Invalid type for a statement: #{stmnt.class}"
             end
             idx = @statements.index(org)
-            @statements[idx] = stmnt if idx
+            # @statements[idx] = stmnt if idx
+            if idx then
+                @statements[idx] = stmnt
+                stmnt.parent = self unless stmnt.parent
+            end
         end
 
         # Maps on the statements.
@@ -1403,6 +1414,8 @@ module HDLRuby::Low
             @child.parent = self unless @child.parent
         end
 
+        alias_method :map_expressions!, :map_nodes!
+
         # Replaces sub expressions using +node2rep+ table indicating the
         # node to replace and the corresponding replacement.
         # Returns the actually replaced nodes and their corresponding
@@ -1507,6 +1520,8 @@ module HDLRuby::Low
             @right.parent = self unless @right.parent
         end
 
+        alias_method :map_expressions!, :map_nodes!
+
         # Replaces sub expressions using +node2rep+ table indicating the
         # node to replace and the corresponding replacement.
         # Returns the actually replaced nodes and their corresponding
@@ -1590,6 +1605,8 @@ module HDLRuby::Low
             map_choices!(&ruby_block)
         end
 
+        alias_method :map_expressions!, :map_nodes!
+
         # Replaces sub expressions using +node2rep+ table indicating the
         # node to replace and the corresponding replacement.
         # Returns the actually replaced nodes and their corresponding
@@ -1707,6 +1724,8 @@ module HDLRuby::Low
         def map_nodes!(&ruby_block)
             # Nothing to do.
         end
+
+        alias_method :map_expressions!, :map_nodes!
     end
 
 
@@ -1775,6 +1794,8 @@ module HDLRuby::Low
             @ref.parent = self unless @ref.parent
         end
 
+        alias_method :map_expressions!, :map_nodes!
+
         # Replaces sub expressions using +node2rep+ table indicating the
         # node to replace and the corresponding replacement.
         # Returns the actually replaced nodes and their corresponding
@@ -1856,6 +1877,8 @@ module HDLRuby::Low
             @ref.parent = self unless @ref.parent
         end
 
+        alias_method :map_expressions!, :map_nodes!
+
         # Replaces sub expressions using +node2rep+ table indicating the
         # node to replace and the corresponding replacement.
         # Returns the actually replaced nodes and their corresponding
@@ -1934,6 +1957,8 @@ module HDLRuby::Low
             @ref.parent = self unless @ref.parent
         end
 
+        alias_method :map_expressions!, :map_nodes!
+
         # Replaces sub expressions using +node2rep+ table indicating the
         # node to replace and the corresponding replacement.
         # Returns the actually replaced nodes and their corresponding
@@ -1970,6 +1995,8 @@ module HDLRuby::Low
         def map_nodes!(&ruby_block)
             # Nothing to do.
         end
+
+        alias_method :map_expressions!, :map_nodes!
     end
 
     ##
@@ -1991,5 +2018,7 @@ module HDLRuby::Low
         def map_nodes!(&ruby_block)
             self.map_args!(&ruby_block)
         end
+
+        alias_method :map_expressions!, :map_nodes!
     end
 end

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -109,6 +109,20 @@ module HDLRuby::Low
     end
 
 
+    ##
+    #  Extends SignalI with the capability of finding one of its inner object
+    #  by name.
+    class SignalI
+        
+        ## Find an inner object by +name+.
+        #  NOTE: return nil if not found.
+        def get_by_name(name)
+            return self.get_signal(name)
+        end
+    end
+
+
+
     ##
     #  Extends RefIndex with the capability of finding the object it
     #  refered to.
@@ -219,10 +233,9 @@ module HDLRuby::Low
         #  corresponding object.
         #  NOTE: return nil if could not resolve.
         def resolve
-            # puts "Resolve with #{self} and name=#{self.name}"
+            # puts "Resolve with #{self} and name=#{self.name} and ref=#{self.ref.class}"
             # First resolve the sub reference if possible.
             if self.ref.is_a?(RefName) then
-                # puts "ref name=#{self.ref.name}"
                 obj = self.ref.resolve
                 # puts "obj=#{obj}"
                 # Look into the object for the name.

data/lib/HDLRuby/hruby_low_without_concat.rb

@@ -33,6 +33,7 @@ module HDLRuby::Low
 
     end
 
+
     ## Extends the Scope class with functionality for breaking assingments
     #  to concats.
     class Scope
@@ -42,7 +43,8 @@ module HDLRuby::Low
             self.each_scope(&:break_concat_assigns!)
             # Recurse on the statements.
             self.each_behavior do |behavior|
-                behavior.block.each_block_deep(&:break_concat_assigns!)
+                # behavior.block.each_block_deep(&:break_concat_assigns!)
+                behavior.break_concat_assigns!
             end
             # Work on the connections.
             self.each_connection.to_a.each do |connection|
@@ -100,6 +102,18 @@ module HDLRuby::Low
         end
     end
 
+    ## Extends the Behavior class with functionality for breaking assingments
+    #  to concats.
+    class Behavior
+        # Breaks the assignments to concats.
+        def break_concat_assigns!
+            # Recruse on the block.
+            self.block.each_block_deep(&:break_concat_assigns!)
+        end
+    end
+
+
+
     ## Extends the Block class with functionality for breaking assingments
     #  to concats.
     class Block
@@ -107,18 +121,23 @@ module HDLRuby::Low
         #
         # NOTE: work on the direct sub statement only, not deeply.
         def break_concat_assigns!
+            # puts "breack_concat_assigns! with block=#{self} with #{self.each_statement.count} statements"
             # Check each transmit.
-            self.each_statement.each.with_index do |stmnt,i|
+            self.each_statement.to_a.each_with_index do |stmnt|
+                # puts "stmnt=#{stmnt}"
                 if stmnt.is_a?(Transmit) then
                     # Transmit, breaking may be necessary.
                     nstmnt = stmnt.break_concat_assigns
                     if nstmnt.is_a?(Block) then
                         # The transmit has been broken, remove the former
                         # version and add the generated block as a behavior.
-                        self.set_statement!(i,nstmnt)
+                        # self.set_statement!(i,nstmnt)
+                        self.replace_statement!(stmnt,nstmnt)
+                        # puts "nstmnt.parent=#{nstmnt.parent}"
                     end
                 end
             end
+            return self
         end
     end
 
@@ -144,11 +163,12 @@ module HDLRuby::Low
                     top_scope = top_block.top_scope
                     aux = top_scope.add_inner(
                         SignalI.new(HDLRuby.uniq_name,self.right.type) )
-                    # puts "new signal: #{aux.name}"
                     aux = RefName.new(aux.type,RefThis.new,aux.name)
                     # Is a default value required to avoid latch generation?
-                    unless top_block.parent.each_event.
-                            find {|ev| ev.type!=:change} then
+                    unless top_block.is_a?(TimeBlock) ||
+                           top_block.parent.each_event.
+                            # find {|ev| ev.type!=:change} then
+                            find {|ev| ev.type!=:anyedge} then
                         # Yes, generate it.
                         top_block.insert_statement!(0,
                             Transmit.new(aux.clone,Value.new(aux.type,0)))
@@ -204,8 +224,8 @@ module HDLRuby::Low
                         end
                         pos += ref.type.width
                     end
-                    # puts "Resulting block=#{block.to_vhdl}"
                     # Return the resulting block
+                    # puts "new block=#{block}"
                     return block
                 end
             end
@@ -229,7 +249,7 @@ module HDLRuby::Low
                 if node.is_a?(RefConcat) then
                     # Yes, must break. Create the resulting sequential
                     # block that will contain the new assignements.
-                    block = Block.new(:seq)
+                    block = Block.new(:par)
                     # Create an intermediate signal for storing the
                     # right value. Put it in the top scope.
                     top_scope = self.top_scope

data/lib/HDLRuby/hruby_low_without_parinseq.rb

@@ -122,6 +122,9 @@ module HDLRuby::Low
         def to_seq!
             if self.mode == :par then
                 # Need to convert.
+                # Get which module is it.
+                modul = self.is_a?(HDLRuby::High::Block) ? HDLRuby::High :
+                    HDLRuby::Low
                 # First recurse on the sub blocks.
                 self.each_statement(&:to_seq!)
                 # Now replace each left value by a new signal for
@@ -130,16 +133,23 @@ module HDLRuby::Low
                 self.each_statement do |statement|
                     left = statement.left
                     if statement.is_a?(Transmit) then
-                        sig = SignalI.new(HDLRuby.uniq_name,left.type)
-                        self.add_inner(sig)
-                        diff = RefName.new(left.type,RefThis.new,sig.name)
+                        if modul == HDLRuby::High then
+                            sig = modul::SignalI.new(HDLRuby.uniq_name,left.type,:inner)
+                            self.add_inner(sig)
+                            puts "sig.parent=#{sig.parent}"
+                            diff = modul::RefObject.new(modul::RefThis.new,sig)
+                        else
+                            sig = modul::SignalI.new(HDLRuby.uniq_name,left.type)
+                            self.add_inner(sig)
+                            diff = modul::RefName.new(left.type,modul::RefThis.new,sig.name)
+                        end
                         differeds << [left,diff]
                         statement.set_left!(diff)
                     end
                 end
                 # Adds the differed assignments.
                 differeds.each do |left,diff|
-                    self.add_statement(Transmit.new(left.clone,diff.clone))
+                    self.add_statement(modul::Transmit.new(left.clone,diff.clone))
                 end
                 # Change the mode.
                 self.set_mode!(:seq)

data/lib/HDLRuby/hruby_low_without_select.rb

@@ -82,7 +82,7 @@ module HDLRuby::Low
                 selects = connection.extract_selects!
                 if selects.any? then
                     # Selects have been extract, replace the connection
-                    # be y behavior.
+                    # by a behavior.
                     # Generate the block with cases.
                     blk = LowWithoutSelect.selects2block(selects)
                     # Add a transmit replacing the connection.
@@ -214,7 +214,7 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the If class with functionality for converting select
+    ## Extends the Case class with functionality for converting select
     #  expressions to case statements.
     class Case