HDLRuby 2.2.17 → 2.3.4

data/lib/HDLRuby/hdr_samples/with_memory.rb

@@ -108,16 +108,26 @@ system :mem_test do
     end
 
 
-    [8].inner :sum
+    [8].inner :sum0, :sum1
 
     # Declares a dual edge 8-bit data and address memory.
     mem_dual([8],256,clk,rst, raddr: :rst,waddr: :rst).(:memDI)
 
     # Instantiate the producer to access port waddr of the memory.
-    producer(memDI.branch(:waddr)).(:producerI).(clk,rst)
+    producer(memDI.branch(:waddr)).(:producerI0).(clk,rst)
 
     # Instantiate the producer to access port raddr of the memory.
-    consumer(memDI.branch(:raddr)).(:consumerI).(clk,rst,sum)
+    consumer(memDI.branch(:raddr)).(:consumerI0).(clk,rst,sum0)
+
+
+    # Declares a 4-bank 8-bit data and address memory.
+    mem_bank([8],4,256/4,clk,rst, raddr: :rst, waddr: :rst).(:memBI)
+
+    # Instantiate the producer to access port waddr of the memory.
+    producer(memBI.branch(:waddr)).(:producerI1).(clk,rst)
+
+    # Instantiate the producer to access port raddr of the memory.
+    consumer(memBI.branch(:raddr)).(:consumerI1).(clk,rst,sum1)
 
 
 end

data/lib/HDLRuby/hdrcc.rb

@@ -113,12 +113,9 @@ module HDLRuby
                 return
             end
             # Get its required files.
-            requires = @checks[-1].get_all_requires
+            requires = @checks[-1].get_all_requires +
+                       @checks[-1].get_all_require_relatives
             requires.each do |file|
-                # if file != "HDLRuby" &&
-                #         !@std_files.find { |std| std.include?(file) } then
-                #     read_all(file)
-                # end
                 read_all(file)
             end
             @requires += requires
@@ -244,7 +241,7 @@ include HDLRuby
 # Process the command line options
 $options = {}
 $optparse = OptionParser.new do |opts|
-    opts.banner = "Usage: hdrcc.rb [options] <input file> [<output file>]"
+    opts.banner = "Usage: hdrcc.rb [options] <input file> [<output directory or file>]"
 
     opts.separator ""
     opts.separator "Where:"
@@ -326,18 +323,17 @@ $optparse = OptionParser.new do |opts|
     opts.separator ""
     opts.separator "Notice:"
     opts.separator "* If no output option is given, simply checks the input file"
-    opts.separator "* If no output file is given, the result is given through the standard output."
     opts.separator "* If no top system is given, it will be automatically searched in the input file."
     opts.separator ""
     opts.separator "Examples:"
     opts.separator "* Compile system named `adder` from `adder.rb` input file and generate `adder.yaml` low-level YAML description:"
     opts.separator "   hdrcc.rb --yaml --top adder adder.rb adder.yaml"
-    opts.separator "* Compile `adder.rb` input file and generate `adder.vhd` low-level VHDL description:"
-    opts.separator "   hdrcc.rb --vhdl adder.rb adder.vhd"
+    opts.separator "* Compile `adder.rb` input file and generate low-level VHDL description files in `adder_vhd` directory:"
+    opts.separator "   hdrcc.rb --vhdl adder.rb adder_vhd"
     opts.separator "* Check the validity of `adder.rb` input file:"
     opts.separator "   hdrcc.rb adder.rb"
-    opts.separator "* Compile system `adder` whose bit width is generic from `adder_gen.rb` input file to a 16-bit circuit whose low-level Verilog HDL description is dumped to the standard output:"
-    opts.separator "   hdrcc -v -t adder --param 16 adder_gen.rb"
+    opts.separator "* Compile system `adder` whose bit width is generic from `adder_gen.rb` input file to a 16-bit circuit whose low-level Verilog HDL description files are put in `adder_gen_v` directory:"
+    opts.separator "   hdrcc -v -t adder --param 16 adder_gen.rb adder_gen_v"
     opts.separator "* Compile system `multer` with inputs and output bit width is generic from `multer_gen.rb` input file to a 16x16->32 bit cicruit whose low-level YAML description is saved to output file `multer_gen.yaml`"
     opts.separator "hdrcc -y -t multer -p 16,16,32 multer_gen.rb multer_gen.yaml"
 

data/lib/HDLRuby/hruby_check.rb

@@ -45,11 +45,20 @@ module HDLRuby
                    (code[1][1] == "require")
         end
 
+        # Tells if +code+ is require_relative description.
+        def is_require_relative?(code)
+            # return code[0] && (code[0][0] == :command) &&
+            #        (code[0][1][1] == "require_relative")
+            return code && (code[0] == :command) &&
+                   (code[1][1] == "require_relative")
+        end
+
         # Gets the required file from +code+.
         def get_require(code)
             # return (code[0][2][1][0][1][1][1])
             return (code[2][1][0][1][1][1])
         end
+        alias_method :get_require_relative, :get_require
 
         # Gets all the required files of  +code+.
         def get_all_requires(code = @code)
@@ -66,6 +75,21 @@ module HDLRuby
             end
         end
 
+        # Gets all the require_relative files of  +code+.
+        def get_all_require_relatives(code = @code)
+            if code.is_a?(Array) then
+                require_relatives = (code.select { |sub| is_require_relative?(sub) }).map! do |sub|
+                    get_require_relative(sub)
+                end
+                code.each do |sub|
+                    require_relatives += get_all_require_relatives(sub)
+                end
+                return require_relatives
+            else
+                return []
+            end
+        end
+
         # Tells if +code+ is a system description.
         def is_system?(code)
             return code.is_a?(Array) && (code[0] == :command) &&
@@ -77,7 +101,7 @@ module HDLRuby
             return code[2][1][0][1][1][1]
         end
 
-        # Gets all the required files of  +code+.
+        # Gets all the systems of  +code+.
         def get_all_systems(code = @code)
             return [] unless code.is_a?(Array)
             return code.reduce([]) {|ar,sub| ar + get_all_systems(sub) } +

data/lib/HDLRuby/hruby_high.rb

@@ -1308,6 +1308,12 @@ module HDLRuby::High
             return true
         end
 
+        # Converts to a type.
+        # Returns self since it is already a type.
+        def to_type
+            return self
+        end
+
         # Sets the +name+.
         #
         # NOTE: can only be done if the name is not already set.

data/lib/HDLRuby/hruby_low.rb

@@ -1123,6 +1123,10 @@ module HDLRuby::Low
             return self.parent.is_a?(SystemT) ? self : self.parent.top_scope
         end
 
+        # Gets the parent system, i.e., the parent of the top scope.
+        def parent_system
+            return self.top_scope.parent
+        end
 
     end
 
@@ -1385,7 +1389,8 @@ module HDLRuby::Low
     # NOTE: type definition are actually type with a name refering to another
     #       type (and equivalent to it).
     class TypeDef < Type
-        extend Forwardable
+        # Moved to constructor
+        # extend Forwardable
 
         # The definition of the type.
         attr_reader :def
@@ -1402,6 +1407,19 @@ module HDLRuby::Low
             end
             # Set the referened type.
             @def = type
+
+            # Sets the delegations
+            self.extend Forwardable
+            [ :signed?, :unsigned?, :fixed?, :float?, :leaf?,
+              :width, :range?, :range, :base?, :base, :types?,
+              :get_all_types, :get_type, :each, :each_type, 
+              :regular?,
+              :each_name,
+              :equivalent? ].each do |meth|
+                  if @def.respond_to?(meth)
+                      self.def_delegator :@def, meth
+                  end
+              end
         end
 
         # Comparison for hash: structural comparison.
@@ -1429,14 +1447,15 @@ module HDLRuby::Low
             @def.each_type_deep(&ruby_block)
         end
 
-        # Delegate the type methods to the ref.
-        def_delegators :@def,
-                       :signed?, :unsigned?, :fixed?, :float?, :leaf?,
-                       :width, :range?, :range, :base?, :base, :types?,
-                       :get_all_types, :get_type, :each, :each_type, 
-                       :regular?,
-                       :each_name,
-                       :equivalent?
+        # Moved to constructor
+        # # Delegate the type methods to the ref.
+        # def_delegators :@def,
+        #                :signed?, :unsigned?, :fixed?, :float?, :leaf?,
+        #                :width, :range?, :range, :base?, :base, :types?,
+        #                :get_all_types, :get_type, :each, :each_type, 
+        #                :regular?,
+        #                :each_name,
+        #                :equivalent?
     end
 
 
@@ -2117,6 +2136,11 @@ module HDLRuby::Low
         def top_scope
             return parent.top_scope
         end
+
+        # Gets the parent system, i.e., the parent of the top scope.
+        def parent_system
+            return self.top_scope.parent
+        end
     end
 
 
@@ -2604,6 +2628,11 @@ module HDLRuby::Low
         def top_scope
             return self.scope.top_scope
         end
+
+        # Gets the parent system, i.e., the parent of the top scope.
+        def parent_system
+            return self.top_scope.parent
+        end
     end
 
 
@@ -3702,6 +3731,11 @@ module HDLRuby::Low
         def top_scope
             return self.parent.is_a?(Scope) ? self.parent : self.parent.top_scope
         end
+
+        # Gets the parent system, i.e., the parent of the top scope.
+        def parent_system
+            return self.top_scope.parent
+        end
     end
 
 

data/lib/HDLRuby/hruby_low2c.rb

@@ -546,9 +546,10 @@ module HDLRuby::Low
         #
         # NOTE: type tuples are converted to bit vector of their contents.
         def to_c(level = 0)
-            return "get_type_tuple(#{self.each.join(",") do |type|
-               type.to_c(level+1)
-            end})"
+            # return "get_type_tuple(#{self.each.to_a.join(",") do |type|
+            #    type.to_c(level+1)
+            # end})"
+            return self.to_vector.to_c(level)
         end
     end
 
@@ -1872,7 +1873,8 @@ module HDLRuby::Low
             res << "idx = value2integer(#{self.index.to_c(level+2)});\n"
             # Make the access.
             res << (" " * ((level+1)*3))
-            res << "dst = read_range(ref,idx,idx,#{self.ref.type.base.to_c(level)},dst);\n"
+            # res << "dst = read_range(ref,idx,idx,#{self.ref.type.base.to_c(level)},dst);\n"
+            res << "dst = read_range(ref,idx,idx,#{self.type.to_c(level)},dst);\n"
             # Restore the state of the value pool.
             res << (" " * ((level+1)*3))
             res << "set_value_pos(pool_state);\n"
@@ -1930,7 +1932,9 @@ module HDLRuby::Low
             res << "last = value2integer(#{self.range.last.to_c(level+2)});\n"
             # Make the access.
             res << (" " * ((level+1)*3))
-            res << "dst = #{command}_range(ref,first,last,#{self.ref.type.base.to_c(level)},dst);\n"
+            # res << "dst = #{command}_range(ref,first,last,#{self.ref.type.base.to_c(level)},dst);\n"
+            # puts "will read_range for #{self.ref.name} with width=#{self.ref.type.width} with base width=#{self.ref.type.base.width} with range=#{self.ref.type.range} with range=#{self.range.first.content}..#{self.range.last.content}"
+            res << "dst = #{command}_range(ref,first,last,#{self.type.base.to_c(level)},dst);\n"
             # Restore the state of the value pool.
             res << (" " * ((level+1)*3))
             res << "set_value_pos(pool_state);\n"
@@ -1942,7 +1946,9 @@ module HDLRuby::Low
         # 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)
-            return to_c(level,true)
+            # return to_c(level,true)
+            return "make_ref_rangeS(#{self.ref.to_c_signal(level)}," +
+                "value2integer(#{self.range.first.to_c(level)}),value2integer(#{self.range.last.to_c(level)}))"
         end
     end
 

data/lib/HDLRuby/hruby_low_fix_types.rb

@@ -294,6 +294,8 @@ module HDLRuby::Low
             # Is there a type to match?
             if type then
                 # Yes, update the concat to the type.
+                # Get the real type in case of typedef.
+                type = type.def while type.is_a?(TypeDef)
                 # Is it an array type?
                 if type.is_a?(TypeVector) then
                     # Yes, update the concat without subcasting.
@@ -302,14 +304,16 @@ module HDLRuby::Low
                     end)
                 else
                     # No, it should be a tuple.
-                    return Concat.new(type,self.expressions.map.with_index do
+                    return Concat.new(type,
+                                      self.each_expression.map.with_index do
                         |expr,i|
                         expr.explicit_types(type.get_type(i))
                     end)
                 end
             else
                 # No, recurse on the sub expressions.
-                return Concat.new(self.type,self.expressions.map do |expr|
+                return Concat.new(self.type,
+                                  self.each_expression.map do |expr|
                     expr.explicit_types
                 end)
             end

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -91,7 +91,7 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            return self.ref.from_systemI
+            return self.ref.from_systemI?
         end
     end
 
@@ -103,7 +103,7 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            return self.ref.from_systemI
+            return self.ref.from_systemI?
         end
     end
 
@@ -119,11 +119,13 @@ module HDLRuby::Low
             if self.ref.is_a?(RefName) then
                 # Look in the parent hierachy for the sub reference name.
                 parent = self.parent
+                # puts "self.ref.name=#{self.ref.name}"
                 while parent
+                    # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
                         found = parent.get_by_name(self.ref.name)
                         # puts "found is a :#{found.class}"
-                        return found.is_a?(SystemI)
+                        return found.is_a?(SystemI) if found
                     end
                     parent = parent.parent
                 end

data/lib/HDLRuby/hruby_low_without_concat.rb

@@ -187,11 +187,13 @@ module HDLRuby::Low
                             # Generate the assignment.
                             block.add_statement(
                                 Transmit.new(ref.clone,
-                                RefIndex.new(aux.type.base, aux.clone, idx)))
+                                # RefIndex.new(aux.type.base, aux.clone, idx)))
+                                RefIndex.new(bit, aux.clone, idx)))
                         else
                             # Multi-bits.
                             # Compute the type of the right value.
-                            rtype = TypeVector.new(:"",aux.type.base,range)
+                            # rtype = TypeVector.new(:"",aux.type.base,range)
+                            rtype = TypeVector.new(:"",bit,range)
                             # Generate the range.
                             range = Value.new(Integer,range.first) ..
                                     Value.new(Integer,range.last)
@@ -272,11 +274,13 @@ module HDLRuby::Low
                             # Generate the assignment.
                             block.add_statement(
                                 Transmit.new(ref.clone,
-                                RefIndex.new(aux.type.base, aux.clone, idx)))
+                                # RefIndex.new(aux.type.base, aux.clone, idx)))
+                                RefIndex.new(bit, aux.clone, idx)))
                         else
                             # Multi-bits.
                             # Compute the type of the right value.
-                            rtype = TypeVector.new(:"",aux.type.base,range)
+                            # rtype = TypeVector.new(:"",aux.type.base,range)
+                            rtype = TypeVector.new(:"",bit,range)
                             # Generate the range.
                             range = Value.new(Integer,range.first) ..
                                     Value.new(Integer,range.last)

data/lib/HDLRuby/hruby_types.rb

@@ -76,19 +76,21 @@ module HDLRuby
 
         # Addition.
         def +(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range + 1
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max + 1
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range + 1
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max + 1
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Subtraction
@@ -96,36 +98,40 @@ module HDLRuby
 
         # Multiplication
         def *(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range * 2
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max * 2
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range * 2
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max * 2
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Division
         def /(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range 
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max 
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range 
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max 
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Modulo
@@ -151,26 +157,28 @@ module HDLRuby
 
         # And
         def &(type)
-            # puts "compute types with=#{self} and #{type}"
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            
-            # Logical operation on non-vector types are kept as is.
-            return resolved unless resolved.is_a?(TypeVector)
-
-            # Otherwise the range is computed.
-            # New type range: largest range 
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            # puts "bounds=#{bounds}"
-            res_lsb =  bounds.min
-            res_msb = bounds.max 
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # puts "compute types with=#{self} and #{type}"
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # 
+            # # Logical operation on non-vector types are kept as is.
+            # return resolved unless resolved.is_a?(TypeVector)
+
+            # # Otherwise the range is computed.
+            # # New type range: largest range 
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # # puts "bounds=#{bounds}"
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max 
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Or
@@ -211,19 +219,21 @@ module HDLRuby
 
         # Shift left
         def <<(type)
-            # The result type is the type of left.
-            resolved = self
-            # New type range: 2**(type width) times self range
-            bounds = [ self.range.first.to_i, self.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max +
-                (2 ** ((type.range.last-type.range.first).abs))
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # The result type is the type of left.
+            # resolved = self
+            # # New type range: 2**(type width) times self range
+            # bounds = [ self.range.first.to_i, self.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max +
+            #     (2 ** ((type.range.last-type.range.first).abs))
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         alias_method :ls, :<<