HDLRuby 2.4.27 → 2.6.2

data/lib/HDLRuby/hruby_low2vhd.rb

@@ -50,6 +50,15 @@ module HDLRuby::Low
             @@alliance = mode ? true : false
         end
 
+
+        ## Converts string +str+ to a VHDL-compatible string.
+        def self.vhdl_string(str)
+            str = str.gsub(/\n/,"\\n")
+            str.gsub!(/\t/,"\\t")
+            return str
+        end
+
+
         ## Generates the pakage requirement for an entity.
         #  +spaces+ are the spaces to put before each line.
         def self.packages(spaces)
@@ -523,7 +532,8 @@ module HDLRuby::Low
                     if inner.value.is_a?(Concat) then
                         # Concat are to be given the expected type of the
                         # elements for casting them equally.
-                        res << " := " << inner.value.to_vhdl(inner.type.base,level)
+                        # res << " := " << inner.value.to_vhdl(inner.type.base,level)
+                        res << " := " << inner.value.to_vhdl(level,inner.type.base)
                     else
                         res << " := " << inner.value.to_vhdl(level)
                     end
@@ -901,6 +911,20 @@ module HDLRuby::Low
                    Low2VHDL.to_type(self.left.type,self.right) + ";\n"
         end
     end
+
+    ## Extends the Print class with generation of HDLRuby::High text.
+    class Print
+
+        # Generates the text of the equivalent HDLRuby::High code.
+        # +vars+ is the list of the variables and
+        # +level+ is the hierachical level of the object.
+        def to_vhdl(vars,level = 0)
+            # Generate a report statement.
+            return " " * (level*3) + "report " + self.each_arg.map do |arg|
+                arg.to_vhdl
+            end.join(" & ") + ";\n"
+        end
+    end
     
     ## Extends the If class with generation of HDLRuby::High text.
     class If
@@ -1347,7 +1371,8 @@ module HDLRuby::Low
         # Generates the text of the equivalent HDLRuby::High code.
         # +type+ is the expected type of the content.
         # +level+ is the hierachical level of the object.
-        def to_vhdl(type,level = 0)
+        # def to_vhdl(type,level = 0)
+        def to_vhdl(level = 0, type = self.type)
             raise "Invalid class for a type: #{type.class}" unless type.is_a?(Type) 
             # The resulting string.
             res = ""
@@ -1487,6 +1512,18 @@ module HDLRuby::Low
         # Nothing to generate.
     end
 
+    ## Extends the StringE class with generation of HDLRuby::High text.
+    class StringE
+
+        # Generates the text of the equivalent HDLRuby::High code.
+        # +level+ is the hierachical level of the object.
+        def to_vhdl(level = 0, std_logic = false)
+            # Generate a report statement.
+            return "\"#{Low2VHDL.vhdl_string(self.content)}\"" +
+                self.each_arg.map { |arg| arg.to_vhdl }.join(" & ")
+        end
+    end
+
     ## Extends the Numeric class with generation of HDLRuby::High text.
     class ::Numeric
 

data/lib/HDLRuby/hruby_low_bool2select.rb

@@ -61,6 +61,20 @@ module HDLRuby::Low
             return self
         end
     end
+
+
+    ## Extends the Print class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Print
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # Apply on the arguments.
+            self.map_args! { |arg| arg.boolean_in_assign2select }
+            return self
+        end
+    end
+
     
     ## Extends the If class with functionality for converting booleans
     #  in assignments to select operators.
@@ -315,4 +329,19 @@ module HDLRuby::Low
             return self.clone
         end
     end
+
+
+    ## Extends the StringE class with functionality for converting booleans
+    #  in assignments to select operators.
+    class StringE
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Apply on the content.
+            # Apply on the arguments.
+            return StringE.new(self.content.clone,*self.each_arg.map do |arg|
+                arg.boolean_in_assign2select
+            end)
+        end
+    end
 end

data/lib/HDLRuby/hruby_low_casts_without_expression.rb

@@ -62,6 +62,20 @@ module HDLRuby::Low
             return self
         end
     end
+
+
+    ## Extends the Print class with functionality for extracting 
+    #  expressions from cast.
+    class Print
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # Apply on the arguments.
+            self.map_args!(&:casts_without_expression)
+            return self
+        end
+    end
+
     
     ## Extends the If class with functionality for extracting 
     #  expressions from cast.
@@ -323,4 +337,17 @@ module HDLRuby::Low
             return self.clone
         end
     end
+
+
+    ## Extends the StringE class with functionality for extracting 
+    #  expressions from cast.
+    class StringE
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression
+            return StringE.new(self.content,
+                               *self.each_arg.map(&:cast_without_expression))
+            return self
+        end
+    end
 end

data/lib/HDLRuby/hruby_low_fix_types.rb

@@ -89,6 +89,20 @@ module HDLRuby::Low
 
     end
 
+
+    ## Extends the Print class with fixing of types and constants.
+    class Print
+        # Explicit the types conversions in the statement.
+        def explicit_types!
+            # Recurse on the arguments.
+            self.map_args!(&:explicit_types)
+            return self
+        end
+
+    end
+
+
+
     
     ## Extends the If class with fixing of types and constants.
     class If
@@ -438,4 +452,15 @@ module HDLRuby::Low
     end
 
 
+    ## Extends the stringE class with fixing of types and constants.
+    class StringE
+        # Explicit the types conversions in the concat where
+        # +type+ is the expected type of the condition if any.
+        def explicit_types(type = nil)
+            return StringE.new(self.content, 
+                               *self.each_arg.map(&:explicit_types))
+        end
+    end
+
+
 end

data/lib/HDLRuby/hruby_low_mutable.rb

@@ -626,6 +626,64 @@ module HDLRuby::Low
     end
 
 
+    ## 
+    # Decribes a print statement.
+    class Print
+
+        # 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
+
+        alias_method :map_nodes!, :map_args!
+
+        # Delete an arg.
+        def delete_arg!(arg)
+            if @args.include?(arg) then
+                # The arg is present, delete it.
+                @args.delete(arg)
+                # And remove its parent.
+                arg.parent = nil
+            end
+            arg
+        end
+
+        # Replaces sub arguments using +node2rep+ table indicating the
+        # node to replace and the corresponding replacement.
+        # Returns the actually replaced nodes and their corresponding
+        # replacement.
+        #
+        # NOTE: the replacement is duplicated.
+        def replace_args!(node2rep)
+            # First recurse on the children.
+            res = {}
+            self.each_node do |node|
+                res.merge!(node.replace_args!(node2rep))
+            end
+            # Is there a replacement of on a sub node?
+            self.map_nodes! do |sub|
+                rep = node2rep[sub]
+                if rep then
+                    # Yes, do it.
+                    rep = rep.clone
+                    node = sub
+                    # node.set_parent!(nil)
+                    # And register the replacement.
+                    res[node] = rep
+                    rep
+                else
+                    sub
+                end
+            end
+            return res
+        end
+    end
+
+
     ## 
     # Describes an if statement.
     class If
@@ -1093,6 +1151,18 @@ module HDLRuby::Low
             stmnt.parent = self
         end
 
+        # Replaces statement +org+ by statement +stmnt+.
+        # 
+        # NOTE: does nothing if +org+ is not present.
+        def replace_statement!(org,stmnt)
+            # Checks the statement.
+            unless stmnt.is_a?(Statement)
+                raise AnyError, "Invalid type for a statement: #{stmnt.class}"
+            end
+            idx = @statements.index(org)
+            @statements[idx] = stmnt if idx
+        end
+
         # Maps on the statements.
         def map_statements!(&ruby_block)
             @statements.map! do |stmnt|

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -84,6 +84,20 @@ module HDLRuby::Low
     end
 
 
+    ##
+    #  Extends RefIndex with the capability of finding the object it
+    #  refered to.
+    class Ref
+        ## Resolves the name of the reference (if any) and return the
+        #  corresponding object.
+        #  NOTE: return nil if could not resolve.
+        def resolve
+            # By default cannot resolve.
+            return nil
+        end
+    end
+
+
     ##
     #  Extends RefIndex with the capability of finding the object it
     #  refered to.
@@ -93,6 +107,13 @@ module HDLRuby::Low
         def from_systemI?
             return self.ref.from_systemI?
         end
+
+        ## Resolves the name of the reference (if any) and return the
+        #  corresponding object.
+        #  NOTE: return nil if could not resolve.
+        def resolve
+            return self.ref.resolve
+        end
     end
 
 
@@ -105,6 +126,13 @@ module HDLRuby::Low
         def from_systemI?
             return self.ref.from_systemI?
         end
+
+        ## Resolves the name of the reference (if any) and return the
+        #  corresponding object.
+        #  NOTE: return nil if could not resolve.
+        def resolve
+            return self.ref.resolve
+        end
     end
 
     

data/lib/HDLRuby/hruby_low_without_connection.rb

@@ -42,7 +42,8 @@ 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
+                        # if right.is_a?(Value) then
+                        if right.immutable? then
                             # Right is value, the new transmit is to add
                             # to the timed block.
                             timed_blk.add_statement(
@@ -108,13 +109,15 @@ module HDLRuby::Low
                             # end
                             # Both or neither input/output, make a behavior
                             # for each.
-                            if (left.is_a?(Ref)) then
+                            if (left.is_a?(Ref) && 
+                                    !(left_r && left_r.immutable?)) then
                                 blk = Block.new(:par)
                                 blk.add_statement(
                                     Transmit.new(left.clone,right.clone))
                                 scope.add_behavior(Behavior.new(blk))
                             end
-                            if (right.is_a?(Ref)) then
+                            if (right.is_a?(Ref) &&
+                                    !(right_r && right_r.immutable?)) then
                                 blk = Block.new(:par)
                                 blk.add_statement(
                                     Transmit.new(right.clone,left.clone))

data/lib/HDLRuby/hruby_low_without_namespace.rb

@@ -617,10 +617,13 @@ module HDLRuby::Low
         # 
         # NOTE: do not recurse into the sub scopes or behaviors!
         def extract_declares!
-            # Recurse on the whens.
-            return self.each_when.map(&:extract_declares!)
-            # Recurse on the default if any.
-            self.default.extract_declares! if self.default
+            # # Recurse on the whens.
+            # return self.each_when.map(&:extract_declares!)
+            # # Recurse on the default if any.
+            # self.default.extract_declares! if self.default
+            res = self.each_when.map(&:extract_declares!)
+            res += self.default.extract_declares! if self.default
+            return res
         end
 
         # Replaces recursively +former+ name by +nname+ until it is redeclared.

data/lib/HDLRuby/hruby_low_without_parinseq.rb

@@ -0,0 +1,151 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+
+
+module HDLRuby::Low
+
+
+##
+# Converts par blocks within seq blocks to seq blocks.
+# For matching the executing model of Verilog.
+#
+########################################################################
+    
+
+    ## Extends the SystemT class with functionality for converting par blocks
+    #  within seq blocks to seq blocks.
+    class SystemT
+
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            self.scope.par_in_seq2seq!
+        end
+    end
+
+    ## Extends the Scope class with functionality for breaking assingments
+    #  to concats.
+    class Scope
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            # Recruse on the sub scopes.
+            self.each_scope(&:par_in_seq2seq!)
+            # Recurse on the block.
+            self.each_behavior do |behavior|
+                behavior.block.par_in_seq2seq!
+            end
+        end
+    end
+
+
+    ## Extends the Statement class with functionality for breaking assingments
+    #  to concats.
+    class Statement
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            # By default nothing to do.
+            return self
+        end
+
+        # Convert the block to seq.
+        def to_seq!
+            # By default nothing to do.
+            return self
+        end
+    end
+
+
+    ## Extends the If class with functionality for breaking assingments
+    #  to concats.
+    class If
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            self.yes.par_in_seq2seq!
+            self.each_noif do |cond,blk|
+                blk.par_in_seq2seq!
+            end
+            self.no.par_in_seq2seq! if self.no
+        end
+
+        # Convert the block to seq.
+        def to_seq!
+            self.to_seq!
+            self.each_noif do |cond,blk|
+                blk.to_seq!
+            end
+            self.no.to_seq! if self.no
+        end
+    end
+
+
+    ## Extends the Case class with functionality for breaking assingments
+    #  to concats.
+    class Case
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            self.each_when do |w|
+                w.statement.par_in_seq2seq!
+            end
+            self.default.par_in_seq2seq! if self.default
+        end
+
+        # Convert the block to seq.
+        def to_seq!
+            self.each_when do |w|
+                w.statement.to_seq!
+            end
+            self.default.to_seq! if self.default
+        end
+    end
+
+
+    ## Extends the Block class with functionality for breaking assingments
+    #  to concats.
+    class Block
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            # Recurse on the sub blocks.
+            self.each_statement(&:par_in_seq2seq!)
+            # Is the current block a seq block?
+            if self.mode == :seq then
+                # Yes, convert its inner par blocks to seq blocks.
+                self.each_statement do |statement|
+                    if (statement.is_a?(Block)) then
+                        statement.to_seq! if statement.mode == :par
+                    end
+                end
+            end
+            return self
+        end
+
+        # Convert the block to seq.
+        def to_seq!
+            if self.mode == :par then
+                # Need to convert.
+                # First recurse on the sub blocks.
+                self.each_statement(&:to_seq!)
+                # Now replace each left value by a new signal for
+                # differed assingment in seq.
+                differeds = []
+                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)
+                        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))
+                end
+                # Change the mode.
+                self.set_mode!(:seq)
+            end
+            return self
+        end
+    end
+
+end