HDLRuby 2.3.4 → 2.4.1

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,13 @@ 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" }
             # 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
@@ -1612,7 +1612,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 +1683,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: 

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -145,6 +145,7 @@ module HDLRuby::Low
             # puts "Resolve with #{self} and name=#{self.name}"
             # First resolve the sub reference if possible.
             if self.ref.is_a?(RefName) then
+                # puts "ref name=#{self.ref.name}"
                 obj = self.ref.resolve
                 # Look into the object for the name.
                 return obj.get_by_name(self.name)

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)
                     scope.each_connection do |connection|
+                        # puts "For connection: #{connection}"
                         # Check the left and right of the connection
                         # for input or output port.
                         left = connection.left
@@ -40,6 +42,15 @@ module HDLRuby::Low
                         right_r = right.resolve if right.respond_to?(:resolve)
                         # puts "right_r=#{right_r.name}" if right_r
                         # puts "right_r.parent=#{right_r.parent.name}" if right_r && right_r.parent
+                        if right.is_a?(Value) then
+                            # Right is value, the new transmit is to add
+                            # to the timed block.
+                            timed_blk.add_statement(
+                                Transmit.new(left.clone,right.clone))
+                            # No more process for this connection.
+                            next
+                        end
+
                         # Check if left is an input or an output.
                         left_is_i = left_is_o = false
                         if left_r && left_r.parent.is_a?(SystemT) then
@@ -118,6 +129,9 @@ module HDLRuby::Low
                     if outputs_blk.each_statement.any? then
                         scope.add_behavior(Behavior.new(outputs_blk))
                     end
+                    if timed_blk.each_statement.any? then
+                        scope.add_behavior(TimeBehavior.new(timed_blk))
+                    end
                 end
             end
         end