HDLRuby 2.3.7 → 2.4.9

data/lib/HDLRuby/hruby_bstr.rb

@@ -32,13 +32,17 @@ module HDLRuby
         #   and negative when "1".
         # * when not present it is assumed to be within str.
         def initialize(str,sign = nil)
+            # puts "str=#{str}"
             # Maybe str is an numeric.
             if str.is_a?(Numeric) then
                 # Yes, convert it to a binary string.
-                str = str.to_s(2)
+                num = str
+                str = num.to_s(2)
                 # And fix the sign.
                 if str[0] == "-" then
-                    str = str[1..-1]
+                    # str = str[1..-1]
+                    str = (2**str.size+num).to_s(2)
+                    puts "str=#{str}"
                     sign = "-"
                 else
                     sign = "+"
@@ -71,6 +75,7 @@ module HDLRuby
                 end.reverse.join
             end
             @str += str.to_s.downcase
+            # puts "@str=#{@str}"
             unless @str.match(/^[0-1zx]+$/) then
                 raise "Invalid value for creating a bit string: #{str}"
             end

data/lib/HDLRuby/hruby_high.rb

@@ -2791,6 +2791,14 @@ module HDLRuby::High
             return RefObject.new(@base,@object)
         end
 
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(RefObject)
+            return false unless @base.eql?(obj.base)
+            return false unless @object.eql?(obj.object)
+            return true
+        end
+
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
             # return HDLRuby::Low::RefName.new(@base.to_ref.to_low,@object.name)

data/lib/HDLRuby/hruby_low.rb

@@ -1978,14 +1978,6 @@ module HDLRuby::Low
 
         include Hparent
 
-        # # Creates a new behavior.
-        # def initialize
-        #     # Initialize the sensitivity list.
-        #     @events = []
-        #     # Initialize the block list.
-        #     @blocks = []
-        # end
-
         # The block executed by the behavior.
         attr_reader :block
 
@@ -2074,6 +2066,11 @@ module HDLRuby::Low
             return !@events.empty?
         end
 
+        # Tells if it is activated on one of +events+.
+        def on_event?(*events)
+            @events.any? { |ev0| events.any? { |ev1| ev0.eql?(ev1) } }
+        end
+
         # Tells if there is a positive or negative edge event.
         def on_edge?
             @events.each do |event|
@@ -2619,6 +2616,15 @@ module HDLRuby::Low
             end
         end
 
+        # Gets the behavior the statement is in.
+        def behavior
+            if self.parent.is_a?(Behavior) then
+                return self.parent
+            else
+                return self.parent.behavior
+            end
+        end
+
         # Gets the top block, i.e. the first block of the current behavior.
         def top_block
             return self.parent.is_a?(Behavior) ? self : self.parent.top_block
@@ -2633,6 +2639,11 @@ module HDLRuby::Low
         def parent_system
             return self.top_scope.parent
         end
+
+        # Tell if the statement includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # By default, nothing to do.
+        end
     end
 
 
@@ -2747,6 +2758,11 @@ module HDLRuby::Low
             # A ruby block?
             # Nothing to do.
         end
+
+        # Tell if the statement includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            return @left.use_name?(*names) || @right.use_name?(*names)
+        end
     end
 
 
@@ -2925,6 +2941,12 @@ module HDLRuby::Low
             @no.each_block_deep(&ruby_block) if @no
         end
 
+        # Tell if the statement includes a signal whose name is one of +names+.
+        # NOTE: for the if check only the condition.
+        def use_name?(*names)
+            return @condition.use_name?(*name)
+        end
+
         # Clones the If (deeply)
         def clone
             # Duplicate the if.
@@ -3038,6 +3060,12 @@ module HDLRuby::Low
         def top_block
             return self.parent.is_a?(Behavior) ? self : self.parent.top_block
         end
+
+        # Tell if the statement includes a signal whose name is one of +names+.
+        # NOTE: for the when check only the match.
+        def use_name?(*names)
+            return @match.use_name?(*name)
+        end
     end
 
 
@@ -3186,6 +3214,12 @@ module HDLRuby::Low
             @default.each_statement_deep(&ruby_block) if @default
         end
 
+        # Tell if the statement includes a signal whose name is one of +names+.
+        # NOTE: for the case check only the value.
+        def use_name?(*names)
+            return @value.use_name?(*name)
+        end
+
         # Clones the Case (deeply)
         def clone
             # Clone the default if any.
@@ -3838,6 +3872,12 @@ module HDLRuby::Low
             end
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # By default nothing.
+            return false
+        end
+
         # Clones the expression (deeply)
         def clone
             raise AnyError,
@@ -3991,6 +4031,12 @@ module HDLRuby::Low
             @child.each_ref_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the child.
+            return @child.use_name?(*names)
+        end
+
         # Clones the value (deeply)
         def clone
             return Cast.new(@type,@child.clone)
@@ -4101,6 +4147,12 @@ module HDLRuby::Low
             @child.each_ref_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the child.
+            return @child.use_name?(*names)
+        end
+
         # Clones the unary operator (deeply)
         def clone
             return Unary.new(@type,self.operator,@child.clone)
@@ -4187,6 +4239,12 @@ module HDLRuby::Low
             @right.each_ref_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the left and the right.
+            return @left.use_name?(*names) || @right.use_name?(*names)
+        end
+
         # Clones the binary operator (deeply)
         def clone
             return Binary.new(@type, self.operator,
@@ -4311,6 +4369,14 @@ module HDLRuby::Low
             end
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the select.
+            return true if @select.use_name?(*names)
+            # Recurse on the choices.
+            return @choices.any? { |choice| choice.use_name?(*names) }
+        end
+
         # Clones the select (deeply)
         def clone
             return Select.new(@type, self.operator, @select.clone,
@@ -4390,6 +4456,12 @@ module HDLRuby::Low
             end
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the expressions.
+            return @expressions.any? { |expr| expr.use_name?(*names) }
+        end
+
         # Clones the concatenated expression (deeply)
         def clone
             return Concat.new(@type,
@@ -4532,6 +4604,12 @@ module HDLRuby::Low
             end
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the references.
+            return @refs.any? { |expr| expr.use_name?(*names) }
+        end
+
         # Clones the concatenated references (deeply)
         def clone
             return RefConcat.new(@type, @refs.map { |ref| ref.clone } )
@@ -4615,6 +4693,12 @@ module HDLRuby::Low
             @ref.each_node_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the index and the reference.
+            return @index.use_name?(names) || @ref.use_name?(*names)
+        end
+
         # Clones the indexed references (deeply)
         def clone
             return RefIndex.new(@type, @ref.clone, @index.clone)
@@ -4710,6 +4794,13 @@ module HDLRuby::Low
             @ref.each_node_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Recurse on the range and the reference.
+            return @range.first.use_name?(names) ||
+                   @range.last.use_name?(names)  || @ref.use_name?(*names)
+        end
+
         # Clones the range references (deeply)
         def clone
             return RefRange.new(@type, @ref.clone,
@@ -4797,6 +4888,14 @@ module HDLRuby::Low
             @ref.each_node_deep(&ruby_block)
         end
 
+        # Tell if the expression includes a signal whose name is one of +names+.
+        def use_name?(*names)
+            # Is the named used here?
+            return true if names.include?(@name)
+            # No, recurse the reference.
+            return @ref.use_name?(*names)
+        end
+
         # Clones the name references (deeply)
         def clone
             return RefName.new(@type, @ref.clone, @name)

data/lib/HDLRuby/hruby_low2c.rb

@@ -106,13 +106,15 @@ module HDLRuby::Low
 
         ## Generates the main for making the objects of +objs+ and
         #  for starting the simulation and including the files from +hnames+
-        def self.main(top,objs,hnames)
+        def self.main(name,init_visualizer,top,objs,hnames)
             res = Low2C.includes(*hnames)
             res << "int main(int argc, char* argv[]) {\n"
             # Build the objects.
             objs.each { |obj| res << "   #{Low2C.make_name(obj)}();\n" }
+            # Sets the top systemT.
+            res << "   top_system = #{Low2C.obj_name(top)};\n"
             # Starts the simulation.
-            res << "   hruby_sim_core(-1);\n"
+            res<< "   hruby_sim_core(\"#{name}\",#{init_visualizer},-1);\n"
             # Close the main.
             res << "}\n"
             return res
@@ -1329,6 +1331,10 @@ module HDLRuby::Low
                 res << "block->owner = NULL;\n"
             end
 
+            # The name
+            res << " " * (level+1)*3
+            res << "block->name = \"#{self.name}\";\n"
+
             # Add the inner signals declaration.
             res << " " * (level+1)*3
             res << "block->num_inners = #{self.each_inner.to_a.size};\n"
@@ -1439,8 +1445,18 @@ module HDLRuby::Low
                 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
+                # 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?
             if str =~ /^[01]+$/ then
@@ -1453,13 +1469,14 @@ module HDLRuby::Low
                 res << " };\n"
                 # Create the value.
                 res << " " * (level+1)*3
-                # puts "str=#{str} type width=#{self.type.width}"
+                # 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" 
             else
                 # No, generate a bit string value.
                 res << " " * (level+1)*3
-                res << "static unsigned char data[] = \"#{str}\";\n"
+                # 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," +
@@ -1612,7 +1629,9 @@ module HDLRuby::Low
         #         return "equal_value(#{self.left.to_c(level)}," +
         #                "#{self.right.to_c(level)})"
         #     when :!= then
-        #         return "not_equal_value(#{self.left.to_c(level)}," +
+        #         # return "not_equal_value(#{self.left.to_c(level)}," +
+        #         #        "#{self.right.to_c(level)})"
+        #         return "xor_value(#{self.left.to_c(level)}," +
         #                "#{self.right.to_c(level)})"
         #     when :> then
         #         return "greater_value(#{self.left.to_c(level)}," +
@@ -1681,9 +1700,12 @@ module HDLRuby::Low
             when :rr then
                 res += "dst = rotate_right_value(src0,src1,dst);\n"
             when :== then
-                res += "dst = equal_value(src0,src1,dst);\n"
+                res += "dst = equal_value(src0,src1,dst);\n" +
+                       "dst = reduce_or_value(dst,dst);"
             when :!= then
-                res += "dst = not_equal_value(src0,src1,dst);\n"
+                # res += "dst = not_equal_value(src0,src1,dst);\n"
+                res += "dst = xor_value(src0,src1,dst);\n" +
+                       "dst = reduce_or_value(dst,dst);"
             when :> then
                 res += "dst = greater_value(src0,src1,dst);\n"
             when :< then

data/lib/HDLRuby/hruby_low_mutable.rb

@@ -156,7 +156,7 @@ module HDLRuby::Low
             end
         end
 
-        # Deletes an type.
+        # Deletes a type.
         def delete_type!(type)
             if @types.key?(type.name) then
                 # The type is present, delete it. 
@@ -167,7 +167,7 @@ module HDLRuby::Low
             type
         end
 
-        # Deletes an systemT.
+        # Deletes a systemT.
         def delete_systemT!(systemT)
             if @systemTs.key?(systemT.name) then
                 # The systemT is present, delete it. 
@@ -230,6 +230,33 @@ module HDLRuby::Low
                 behavior.parent = nil
             end
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Delete the sub scopes whose name are in names.
+            @scopes.delete_if { |scope| names.include?(scope.name) }
+            # Delete the inner signals whose name are in names.
+            @inners.delete_if { |sig| names.include?(sig.name) }
+            # Delete the connections that contain signals whose name are
+            # in names.
+            @connections.delete_if { |connection| connection.use_name?(*names) }
+            # Delete the behaviors whose block name or events' name are in
+            # names.
+            @behaviors.delete_if do |behavior|
+                names.include?(behavior.block.name) or
+                behavior.each_event.include? do |event|
+                    event.ref.use_name?(*names)
+                end
+            end
+            
+            # Recurse on the sub scopes.
+            @scopes.each { |scope| scope.delete_related!(names) }
+            # Recurse on the behaviors.
+            @behaviors.each { |behavior| behavior.block.delete_related!(names) }
+        end
     end
 
     
@@ -514,6 +541,14 @@ module HDLRuby::Low
             # By default: nothing to do.
             return {}
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Nothing to do by default.
+        end
     end
 
 
@@ -694,6 +729,21 @@ module HDLRuby::Low
 
             return res
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Delete the noifs if their condition uses one of names.
+            @noifs.delete_if { |noif| noif[0].use_names?(names) }
+            # Recurse on the yes.
+            @yes.delete_related!(*names)
+            # Recurse on the no.
+            @no.delete_related!(*names)
+            # Recruse one the no ifs statements.
+            @noifs.each { |noif| noif[1].delete_related!(*names) }
+        end
     end
 
     ##
@@ -758,6 +808,15 @@ module HDLRuby::Low
 
             return res
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Recurse on the statement.
+            @statement.delete_related!(*names)
+        end
     end
 
 
@@ -833,6 +892,18 @@ module HDLRuby::Low
 
             return res
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Delete the whens whose match contains a signal whoses name is
+            # in names.
+            @whens.delete_if { |w| w.match.use_name?(*names) }
+            # Recurse on the whens.
+            @whens.each { |w| w.delete_related!(*names) }
+        end
     end
 
 
@@ -1091,8 +1162,25 @@ module HDLRuby::Low
                 end
             end
         end
+
+        # Deletes the elements related to one of +names+: either they have
+        # one of the names or they use an element with these names.
+        # NOTE: only delete actual instantiated elements, types or
+        # systemTs are left as is.
+        def delete_related!(*names)
+            # Delete the inner signals whose name are in names.
+            @inners.delete_if { |sig| names.include?(sig.name) }
+            # Recurse on the statements.
+            @statements.each do |statement|
+                statement.delete_related!(*names)
+            end
+            # Delete the statements that contain signals whose name are
+            # in names.
+            @statements.delete_if { |statement| statement.use_name?(*names) }
+        end
     end
 
+
     # Describes a timed block.
     #
     # NOTE: