HDLRuby 2.6.22 → 2.7.1

data/lib/HDLRuby/hruby_low_casts_without_expression.rb

@@ -56,9 +56,9 @@ module HDLRuby::Low
         # Extracts the expressions from the casts.
         def casts_without_expression!
             # Apply on the left value.
-            self.set_left!(self.left.casts_without_expression)
+            self.set_left!(self.left.casts_without_expression!)
             # Apply on the right value.
-            self.set_right!(self.right.casts_without_expression)
+            self.set_right!(self.right.casts_without_expression!)
             return self
         end
     end
@@ -71,7 +71,7 @@ module HDLRuby::Low
         # Extracts the expressions from the casts.
         def casts_without_expression!
             # Apply on the arguments.
-            self.map_args!(&:casts_without_expression)
+            self.map_args!(&:casts_without_expression!)
             return self
         end
     end
@@ -84,12 +84,12 @@ module HDLRuby::Low
         # Extracts the expressions from the casts.
         def casts_without_expression!
             # Apply on the condition.
-            self.set_condition!(self.condition.casts_without_expression)
+            self.set_condition!(self.condition.casts_without_expression!)
             # Apply on the yes.
             self.yes.casts_without_expression!
             # Apply on the noifs.
             @noifs.map! do |cond,stmnt|
-                [cond.casts_without_expression,stmnt.casts_without_expression!]
+                [cond.casts_without_expression!,stmnt.casts_without_expression!]
             end
             # Apply on the no if any.
             self.no.casts_without_expression! if self.no
@@ -104,7 +104,7 @@ module HDLRuby::Low
         # Extracts the expressions from the casts.
         def casts_without_expression!
             # Apply on the match.
-            self.set_match!(self.match.casts_without_expression)
+            self.set_match!(self.match.casts_without_expression!)
             # Apply on the statement.
             self.statement.casts_without_expression!
             return self
@@ -120,7 +120,7 @@ module HDLRuby::Low
         def casts_without_expression!
             # No need to apply on the value!
             # Apply on the value.
-            self.set_value!(self.value.casts_without_expression)
+            self.set_value!(self.value.casts_without_expression!)
             # Apply on the whens.
             self.each_when(&:casts_without_expression!)
             # Apply on the default if any.
@@ -169,9 +169,10 @@ module HDLRuby::Low
     #  expressions from cast.
     class Value
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Simple clones.
-            return self.clone
+        def casts_without_expression!
+            # # Simple clones.
+            # return self.clone
+            return self
         end
     end
 
@@ -180,9 +181,10 @@ module HDLRuby::Low
     #  expressions from cast.
     class Cast
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the child.
-            nchild = self.child.casts_without_expression
+            nchild = self.child.casts_without_expression!
+            nchild.parent = nil
             # Process the cast.
             unless (nchild.is_a?(Ref)) then
                 # Need to extract the child.
@@ -221,10 +223,11 @@ module HDLRuby::Low
     class Unary
 
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Recurse on the sub node.
-            return Unary.new(self.type,self.operator,
-                             self.child.casts_without_expression)
+        def casts_without_expression!
+            # # Recurse on the sub node.
+            # return Unary.new(self.type,self.operator,
+            #                  self.child.casts_without_expression)
+            self.set_child!(self.child.casts_without_expression!)
             return self
         end
     end
@@ -235,11 +238,14 @@ module HDLRuby::Low
     class Binary
 
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Recurse on the sub nodes.
-            return Binary.new(self.type,self.operator,
-                              self.left.casts_without_expression,
-                              self.right.casts_without_expression)
+        def casts_without_expression!
+            # # Recurse on the sub nodes.
+            # return Binary.new(self.type,self.operator,
+            #                   self.left.casts_without_expression,
+            #                   self.right.casts_without_expression)
+            self.set_left!(self.left.casts_without_expression!)
+            self.set_right!(self.right.casts_without_expression!)
+            return self
         end
     end
 
@@ -250,13 +256,15 @@ module HDLRuby::Low
     class Select
 
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub node.
-            return Select.new(self.type,"?", 
-                              self.select.casts_without_expression,
-                              *self.each_choice.map do |choice|
-                                  choice.casts_without_expression
-                              end )
+            # return Select.new(self.type,"?", 
+            #                   self.select.casts_without_expression,
+            #                   *self.each_choice.map do |choice|
+            #                       choice.casts_without_expression
+            #                   end )
+            self.set_select!(self.select.casts_without_expression!)
+            self.map_choices! { |choice| choice.casts_without_expression! }
             return self
         end
     end
@@ -266,11 +274,13 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class Concat
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub expressions.
-            return Concat.new(self.type,self.each_expression.map do |expr|
-                expr.casts_without_expression
-            end )
+            # return Concat.new(self.type,self.each_expression.map do |expr|
+            #     expr.casts_without_expression
+            # end )
+            self.map_expressions! {|expr| expr.casts_without_expression! }
+            return self
         end
     end
 
@@ -279,11 +289,13 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefConcat
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Recurse on the sub references.
-            return RefConcat.new(self.type,self.each_expression.map do |expr|
-                expr.casts_without_expression
-            end )
+        def casts_without_expression!
+            # # Recurse on the sub references.
+            # return RefConcat.new(self.type,self.each_expression.map do |expr|
+            #     expr.casts_without_expression
+            # end )
+            self.map_expressions! {|expr| expr.casts_without_expression! }
+            return self
         end
     end
 
@@ -292,11 +304,14 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefIndex
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub references.
-            return RefIndex.new(self.type,
-                                self.ref.casts_without_expression,
-                                self.index.casts_without_expression)
+            # return RefIndex.new(self.type,
+            #                     self.ref.casts_without_expression,
+            #                     self.index.casts_without_expression)
+            self.set_ref!(self.ref.casts_without_expression!)
+            self.set_index!(self.index.casts_without_expression!)
+            return self
         end
     end
 
@@ -305,12 +320,16 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefRange
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub references.
-            return RefRange.new(self.type,
-                                self.ref.casts_without_expression,
-                                self.range.first.casts_without_expression ..
-                                self.range.last.casts_without_expression)
+            # return RefRange.new(self.type,
+            #                     self.ref.casts_without_expression,
+            #                     self.range.first.casts_without_expression ..
+            #                     self.range.last.casts_without_expression)
+            self.set_ref!(self.ref.casts_without_expression!)
+            self.set_range!(self.range.first.casts_without_expression! ..
+                            self.range.last.casts_without_expression!)
+            return self
         end
     end
 
@@ -319,11 +338,13 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefName
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub references.
-            return RefName.new(self.type,
-                               self.ref.casts_without_expression,
-                               self.name)
+            # return RefName.new(self.type,
+            #                    self.ref.casts_without_expression,
+            #                    self.name)
+            self.set_ref!(self.ref.casts_without_expression!)
+            return self
         end
     end
 
@@ -332,9 +353,10 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefThis 
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Simply clone.
-            return self.clone
+        def casts_without_expression!
+            # # Simply clone.
+            # return self.clone
+            return self
         end
     end
 
@@ -344,9 +366,10 @@ module HDLRuby::Low
     class StringE
 
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            return StringE.new(self.content,
-                               *self.each_arg.map(&:cast_without_expression))
+        def casts_without_expression!
+            # return StringE.new(self.content,
+            #                    *self.each_arg.map(&:casts_without_expression))
+            self.map_args! {|arg| arg.casts_without_expression! }
             return self
         end
     end

data/lib/HDLRuby/hruby_low_mutable.rb

@@ -221,6 +221,12 @@ module HDLRuby::Low
             connection
         end
 
+        # Deletes all the connections.
+        def delete_all_conncetions!
+            @connections.each { |cnx| cnx.parent = nil }
+            @connections = []
+        end
+
         # Deletes a behavior.
         def delete_behavior!(behavior)
             if @behaviors.include?(behavior) then
@@ -231,6 +237,12 @@ module HDLRuby::Low
             end
         end
 
+        # Deletes all the behaviors.
+        def delete_all_behaviors!
+            @behaviors.each { |beh| beh.parent = nil }
+            @behaviors = []
+        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
@@ -1959,4 +1971,25 @@ module HDLRuby::Low
             # Nothing to do.
         end
     end
+
+    ##
+    # Describes a string.
+    #
+    # NOTE: This is not synthesizable!
+    class StringE
+        
+        # Maps on the arguments.
+        def map_args!(&ruby_block)
+            @args.map! do |arg|
+                arg = ruby_block.call(arg)
+                arg.parent = self unless arg.parent
+                arg
+            end
+        end
+
+        # Maps on the children.
+        def map_nodes!(&ruby_block)
+            self.map_args!(&ruby_block)
+        end
+    end
 end

data/lib/HDLRuby/hruby_low_with_port.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 require "HDLRuby/hruby_error"
 require "HDLRuby/hruby_low_mutable"
 require "HDLRuby/hruby_low2sym"
@@ -88,14 +90,19 @@ module HDLRuby::Low
             # self.each_scope(&:with_port!)
             # Gather the references to instance ports.
             # Also remember if the references were left values or not.
+            # And remember where the node was.
             refs = []
             ref_sym2leftvalue = {}
+            # ref_parents = Set.new
+            ref_parents = []
             self.each_block_deep do |block|
                 block.each_node_deep do |node|
                     if instance_port?(node) then
                         # puts "port for node: #{node.ref.name}.#{node.name}"
                         refs << node 
                         ref_sym2leftvalue[node.to_sym] = node.leftvalue?
+                        ref_parents << node.parent
+                        # ref_parents[node.parent] = node
                     end
                 end
             end
@@ -106,6 +113,8 @@ module HDLRuby::Low
                         # puts "leftvalue? #{node.leftvalue?}"
                         refs << node 
                         ref_sym2leftvalue[node.to_sym] = node.leftvalue?
+                        ref_parents << node.parent
+                        # ref_parents[node.parent] = node
                     end
                 end
             end
@@ -117,17 +126,23 @@ module HDLRuby::Low
             # Replace the references by their corresponding port wires.
             self.each_block_deep do |block|
                 block.each_node_deep do |node|
-                    node.map_nodes! do |expr|
-                        portw = ref_sym2portw[expr.to_sym]
-                        portw ? portw2ref(portw) : expr
+                    if ref_parents.include?(node) then
+                        node.map_nodes! do |expr|
+                            next expr unless instance_port?(expr)
+                            portw = ref_sym2portw[expr.to_sym]
+                            portw ? portw2ref(portw) : expr
+                        end
                     end
                 end
             end
             self.each_connection do |connection|
                 connection.each_node_deep do |node|
-                    node.map_nodes! do |expr|
-                        portw = ref_sym2portw[expr.to_sym]
-                        portw ? portw2ref(portw) : expr
+                    if ref_parents.include?(node) then
+                        node.map_nodes! do |expr|
+                            next expr unless instance_port?(expr)
+                            portw = ref_sym2portw[expr.to_sym]
+                            portw ? portw2ref(portw) : expr
+                        end
                     end
                 end
             end

data/lib/HDLRuby/hruby_low_without_namespace.rb

@@ -133,7 +133,8 @@ module HDLRuby::Low
             # Get the behaviors.
             behs = self.each_behavior.to_a
             # Remove them from the scope.
-            behs.each { |beh| self.delete_behavior!(beh) }
+            # behs.each { |beh| self.delete_behavior!(beh) }
+            self.delete_all_behaviors!
             # Return the behaviors.
             return behs
         end
@@ -145,7 +146,8 @@ module HDLRuby::Low
             # Get the connections.
             cnxs = self.each_connection.to_a
             # Remove them from the scope.
-            cnxs.each { |beh| self.delete_connection!(beh) }
+            # cnxs.each { |cnx| self.delete_connection!(cnx) }
+            cnxs.delete_all_connections!
             # Return the connections.
             return cnxs
         end

data/lib/HDLRuby/hruby_tools.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module HDLRuby
 
 ##
@@ -11,16 +13,21 @@ module HDLRuby
 
     @@absoluteCounter = -1 # The absolute name counter.
 
+    @@uniq_names = Set.new(Symbol.all_symbols.map {|sym| sym.to_s})
+
     # Generates an absolute uniq name.
     def self.uniq_name(base = "")
         @@absoluteCounter += 1
         name = base.to_s + ":#{@@absoluteCounter}"
-        if Symbol.all_symbols.find {|symbol| symbol.to_s == name } then
+        # if Symbol.all_symbols.find {|symbol| symbol.to_s == name } then
+        if @@uniq_names.include?(name) then
             # The symbol exists, try again.
             return self.uniq_name
         else
+            @@uniq_names.add(name)
             return name.to_sym
         end
+        # return base.to_s + ":#{@@absoluteCounter}"
     end