HDLRuby 2.4.29 → 2.6.4

data/lib/HDLRuby/hdr_samples/rom.rb

@@ -14,3 +14,19 @@ system :rom4_8 do
     data1 <= content1[addr]
     data2 <= content2[addr]
 end
+
+
+
+system :test_rom do
+    [2..0].inner :addr
+    [7..0].inner :data0,:data1,:data2
+
+    rom4_8(:my_rom).(addr,data0,data1,data2)
+
+    timed do
+        8.times do |i|
+            addr <= i
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_function_generator.rb

@@ -0,0 +1,25 @@
+require 'std/function_generator.rb'
+
+include HDLRuby::High::Std
+
+# System for testing the function generator standard library.
+system :with_function_generator do
+    # signed[8].inner :x
+    # signed[32].inner :y
+    bit[8].inner :x
+    signed[8].inner :y
+
+    # function_generator(Math.method(:sin).to_proc,
+    #                    signed[8],signed[32],4,-Math::PI..Math::PI,-2..2).
+    function_generator(Math.method(:sin).to_proc,
+                       bit[8],signed[8],4,-Math::PI..Math::PI,-2..2).
+    (:my_sin).(x,y)
+
+    timed do
+        # (-128..127).each do |i|
+        (0..255).each do |i|
+            x <= i
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -1,10 +1,11 @@
 #!/usr/bin/ruby
 
 require 'fileutils'
+require 'tempfile'
 require 'HDLRuby'
 require 'HDLRuby/hruby_check.rb'
 # require 'ripper'
-require 'HDLRuby/hruby_low2high'
+require 'HDLRuby/hruby_low2hdr'
 require 'HDLRuby/hruby_low2c'
 require 'HDLRuby/hruby_low2vhd'
 require 'HDLRuby/hruby_low_fix_types'
@@ -50,12 +51,21 @@ module HDLRuby
         # The required files.
         attr_reader :requires
 
-        # Creates a new loader for a +top_system+ system in file +top_file+
+        # Creates a new loader for a +top_system+ system in file +top_file_name+
         # from directory +dir+ with generic parameters +params+.
+        #
+        # NOTE: +top_file+ can either be a file or a file name.
         def initialize(top_system,top_file,dir,*params)
             # Sets the top and the looking directory.
             @top_system = top_system.to_s
-            @top_file = top_file.to_s
+            # @top_file can either be a file or a string giving the file name.
+            if top_file.respond_to?(:path) then
+                @top_file = top_file
+                @top_file_name = top_file.path
+            else
+                @top_file = nil
+                @top_file_name = top_file.to_s
+            end
             @dir = dir.to_s
             @params = params
 
@@ -82,31 +92,48 @@ module HDLRuby
         end
 
         # Loads a single +file+.
+        #
+        # NOTE: +file+ can either be a file or a file name.
         def read(file)
             # Resolve the file.
-            found = File.join(@dir,file)
-            unless File.exist?(found) then
-                founds = Dir.glob(@std_dirs.map {|path| File.join(path,file) })
-                if founds.empty? then
-                    # No standard file with this name, this is an error.
-                    raise "Unknown required file: #{file}."
-                else
-                    # A standard file is found, skip it since it does not
-                    # need to be read.
-                    # puts "Standard files: #{founds}"
-                    return false
+            if file.respond_to?(:read) then
+                found = file
+            else
+                found = File.join(@dir,file)
+                unless File.exist?(found) then
+                    founds = Dir.glob(@std_dirs.map do |path|
+                        File.join(path,file) 
+                    end)
+                    if founds.empty? then
+                        # No standard file with this name, this is an error.
+                        raise "Unknown required file: #{file}."
+                    else
+                        # A standard file is found, skip it since it does not
+                        # need to be read.
+                        # puts "Standard files: #{founds}"
+                        return false
+                    end
                 end
             end
             # Load the file.
-            # @texts << File.read(File.join(@dir,file) )
             @texts << File.read(found)
-            # @checks << Checker.new(@texts[-1],file)
-            @checks << Checker.new(@texts[-1],found)
+            if found.respond_to?(:path) then
+                @checks << Checker.new(@texts[-1],found.path)
+            else
+                @checks << Checker.new(@texts[-1])
+            end
             return true
         end
 
         # Loads all the files from +file+.
-        def read_all(file = @top_file)
+        def read_all(file = nil)
+            unless file then
+                if @top_file then
+                    file = @top_file
+                else
+                    file = @top_file_name
+                end
+            end
             # puts "read_all with file=#{file}"
             # Read the file
             # read(file)
@@ -174,7 +201,7 @@ module HDLRuby
                     # Maybe it is a parse error, look for it.
                     bind = TOPLEVEL_BINDING.clone
                     eval("require 'HDLRuby'\n\nconfigure_high\n\n",bind)
-                    eval(@texts[0],bind,@top_file,1)
+                    eval(@texts[0],bind,@top_file_name,1)
                     # No parse error found.
                     raise "Cannot find a top system." unless @top_system
                 end
@@ -183,7 +210,7 @@ module HDLRuby
             bind = TOPLEVEL_BINDING.clone
             eval("require 'HDLRuby'\n\nconfigure_high\n\n",bind)
             # Process it.
-            eval(@texts[0],bind,@top_file,1)
+            eval(@texts[0],bind,@top_file_name,1)
             # Get the resulting instance
             if @params.empty? then
                 # There is no generic parameter
@@ -225,6 +252,20 @@ module HDLRuby
 
 end
 
+# Locate an executable from cmd.
+def which(cmd)
+    # Get the possible exetensions (for windows case).
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    # Look for the command within the executable paths.
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+    end
+    nil
+end
+
 
 
 if __FILE__ == $0 then
@@ -310,14 +351,24 @@ $optparse = OptionParser.new do |opts|
     opts.on("-D", "--debug","Set the HDLRuby debug mode") do |d|
         $options[:debug] = d
     end
+    opts.on("-T","--test t0,t1,t2","Compile the unit tests named t0,t1,...") do |t|
+        $options[:test] = t
+    end
+    opts.on("--testall","Compile all the available unit tests.") do |t|
+        $options[:testall] = t
+    end
     opts.on("-t", "--top system", "Specify the top system to process") do|t|
         $options[:top] = t
     end
     opts.on("-p", "--param x,y,z", "Specify the generic parameters") do |p|
         $options[:param] = p
     end
-    opts.on("--version", "Print the version number, then exit") do
-        puts "hdrcc: HDLRuby #{HDLRuby::VERSION} compiler"
+    opts.on("--dump","Dump all the properties to yaml files") do |v|
+        $options[:dump] = v
+        $options[:multiple] = v
+    end
+    opts.on("--version", "Shows the version of HDLRuby.") do |v|
+        puts VERSION
         exit
     end
     # opts.on_tail("-h", "--help", "Show this message") do
@@ -370,6 +421,28 @@ if $input == nil then
     exit
 end
 
+if ($options[:test] || $options[:testall]) then
+    $top = "__test__"
+    tests = $options[:test]
+    if tests then
+        tests = tests.to_s.split(",")
+        tests.map! {|test| ":\"#{test}\"" }
+        tests = ", #{tests.join(",")}"
+    else
+        tests = ""
+    end
+    # Generate the unit test file.
+    $test_file = Tempfile.new('tester.rb',Dir.getwd)
+    $test_file.write("require 'std/hruby_unit.rb'\nrequire_relative '#{$input}'\n\n" +
+                     "HDLRuby::Unit.test(:\"#{$top}\"#{tests})\n")
+    # $test_file.rewind
+    # puts $test_file.read
+    # exit
+    $test_file.rewind
+    # It is the new input file.
+    $input = $test_file
+end
+
 # Open the output.
 if $output then
     if $options[:multiple] then
@@ -382,7 +455,7 @@ if $output then
         $output = File.open($output,"w")
     end
 else
-    if $option[:multiple] then
+    if $options[:multiple] then
         raise "Need a target directory in multiple files generation mode."
     end
     $output = $stdout
@@ -394,6 +467,12 @@ $loader = HDRLoad.new($top,$input,$options[:directory].to_s,*$params)
 $loader.read_all
 $loader.check_all
 
+# Remove the test file if any, it is not needed any longer.
+if $test_file then
+    $test_file.close
+    $test_file.unlink 
+end
+
 if $options[:syntax] then
     if $options[:multiple] then
         raise "Multiple files generation mode not supported for syntax tree output."
@@ -414,6 +493,24 @@ end
 # Get the top systemT.
 $top_system = $top_instance.to_low.systemT
 
+
+# Apply the pre drivers if any.
+Hdecorator.each_with_property(:pre_driver) do |obj, value|
+    unless value.is_a?(Array) && value.size == 2 then
+        raise "pre_driver requires a driver file name command name."
+    end
+    # Load the driver.
+    require_relative(value[0].to_s)
+    # Ensure obj is the low version.
+    if obj.properties.key?(:high2low) then
+        # obj is high, get the corresponding low.
+        obj = obj.properties[:high2low][0]
+    end
+    # Execute it.
+    send(value[1].to_sym,obj,*value[2..-1])
+end
+
+
 # Gather the non-HDLRuby code.
 $non_hdlruby = []
 $top_system.each_systemT_deep do |systemT|
@@ -455,7 +552,7 @@ elsif $options[:hdr] then
     #     $output << systemT.to_high
     # end
     # $output << $top_instance.to_low.systemT.to_high
-    $output << $top_system.to_high
+    $output << $top_system.to_hdr
 elsif $options[:clang] then
     # top_system = $top_instance.to_low.systemT
     # top_system = $top_system
@@ -572,8 +669,19 @@ elsif $options[:clang] then
             end
         end
         Dir.chdir($output)
-        # Kernel.system("make -s")
-        Kernel.system("cc -o3 -o hruby_simulator *.c -lpthread")
+        # Find the compiler.
+        cc_cmd = which('cc')
+        unless cc_cmd then
+            cc_cmd = which('gcc')
+        end
+        unless cc_cmd then
+            raise "Could not find any compiler, please compile by hand as follows:\n" +
+                "   In folder #{$output} execute:\n" +
+                "     <my compiler> -o hruby_simulator *.c -lpthread\n" +
+                "   Then execute:\n   hruby_simulator"
+        end
+        # Use it.
+        Kernel.system("#{cc_cmd} -o3 -o hruby_simulator *.c -lpthread")
         Kernel.system("./hruby_simulator")
     end
 elsif $options[:verilog] then
@@ -678,3 +786,31 @@ elsif $options[:vhdl] then
         end
     end
 end
+
+# Apply the post drivers if any.
+Hdecorator.each_with_property(:post_driver) do |obj, value|
+    # Load the driver.
+    require_relative(value[0].to_s)
+    # Execute it.
+    send(value[1].to_sym,obj,$output)
+end
+
+# Dump the properties
+if $options[:dump] then
+    # Decorate with the parent ids.
+    Hdecorator.decorate_parent_id
+    
+    # Generate the directory for the properties
+    property_dir = $output + "/properties"
+    unless File.directory?(property_dir)
+        FileUtils.mkdir_p(property_dir)
+    end
+
+    # Dump to one file per key
+    Properties.each_key do |key|
+        File.open(property_dir + "/#{key}.yaml", "w") do |f|
+            Hdecorator.dump(key,f)
+        end
+    end
+    
+end

data/lib/HDLRuby/hruby_decorator.rb

@@ -0,0 +1,250 @@
+require 'yaml'
+require 'set'
+
+module HDLRuby
+
+##
+# Library for describing a decorator used for adding properties to
+# HDLRuby objects that are persistent and can be used for back annotation
+########################################################################
+
+    ##
+    # Gives a decorator the HDLRuby object.
+    module Hdecorator
+        # The decorator requires that each HDLRuby object has a uniq
+        # persistent id
+
+        # The id
+        attr_reader :hdr_id
+
+        # The id to object table
+        @@id_map = {}
+
+        # Generate the ID
+        @@id_gen = 0
+
+        # Ensures the ID is generated when object is initialized
+        def self.included(base) # built-in Ruby hook for modules
+            base.class_eval do    
+                original_method = instance_method(:initialize)
+                define_method(:initialize) do |*args, &block|
+                    original_method.bind(self).call(*args, &block)
+                    # Generate the id.
+                    @hdr_id = @@id_gen
+                    @@id_gen += 1
+                    # Update the id to object table
+                    @@id_map[@hdr_id] = self
+                end
+            end
+        end
+
+        # Get an object by id.
+        def self.get(id)
+            return @@id_map[id]
+        end
+
+        # Iterate over all the id with their object.
+        #
+        # Returns an enumerator if no ruby block is given.
+        #
+        # NOTE: converts the hash to an array to allow on-the-fly modification.
+        def self.each(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each) unless ruby_block
+            # A ruby block? Apply it on each object.
+            @@id_map.to_a.each(&ruby_block)
+        end
+
+        # The decorator also need to add properties to the HDLRuby objects.
+
+        # Access the set of properties
+        def properties
+            # Create the properties if not present.
+            unless @properties then
+                @properties = Properties.new(self)
+            end
+            return @properties
+        end
+
+        # Iterate over all the objects from +top+ with +prop+ property.
+        #
+        # Returns an enumerator if no ruby block is given.
+        # NOTE: if +top+ is not given, iterate over all the objects.
+        def self.each_with_property(prop, top = nil, &ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_with_property) unless ruby_block
+            # A ruby block? Apply the ruby_block...
+            if (top) then
+                # A top... on each object from it.
+                top.each_deep do |obj|
+                    if (obj.properties.key?(prop)) then
+                        ruby_block.call(obj, *obj.properties[prop])
+                    end
+                end
+            else
+                # No top... on all the objects.
+                self.each do |id,obj|
+                    if (obj.properties.key?(prop)) then
+                        ruby_block.call(obj, *obj.properties[prop])
+                    end
+                end
+            end
+        end
+
+        # # Access the set of properties and the inherited properties from
+        # # the high objects.
+        # def all_properties
+        #     high_id = self.properties[:low2high]
+        #     if high_id && high_id >= 0 then
+        #         return properties.merge(Hdecorator.get(high_id))
+        #     else
+        #         return properties.clone
+        #     end
+        # end
+
+        # Saves properties +key+ of all the object associated with
+        # their id to +target+.
+        def self.dump(key, target = "")
+            # Build the table to dump
+            tbl = {}
+            self.each do |id,obj|
+                value = obj.properties[key]
+                if value.any? then
+                    tbl[id] = value
+                end
+            end
+            # Dump the table.
+            target << YAML.dump(tbl)
+            return target
+        end
+
+        # Loads properties to +key+ for all objects from +source+.
+        def self.load(source,key)
+            # Load the id to property table.
+            tbl = YAML.load(source)
+            # Adds the property of each object according to tbl
+            tbl.each do |id,value|
+                @@id_map[id].properties[key] = value
+            end
+        end
+
+        # Some predefined properties to set.
+
+        def self.decorate_parent_id
+            @@id_map.each do |id, obj|
+                parent = obj.parent
+                if parent then
+                    obj.properties[:parent_id] = obj.parent.hdr_id
+                else
+                    obj.properties[:parent_id] = -1
+                end
+            end
+        end
+
+    end
+
+
+    ## A HDLRuby set of properties
+    class Properties
+
+        # The set of all the property keys
+        @@property_keys = Set.new
+
+        # The HDLRuby object owning of the set of properties
+        attr_reader :owner
+
+        # Create a new set of properties and attach it to HDLRuby object
+        # +owner+.
+        def initialize(owner)
+            # Attach the owner.
+            @owner = owner
+            # Create the set.
+            @content = {}
+        end
+
+        # Clones the properties: also clone the contents.
+        def clone
+            result = Properties.new(owner)
+            @contents.each do |k,vals|
+                vals.each { |v| result[k] = v }
+            end
+            return result
+        end
+
+        # Create a new set of properties by merging with +prop+
+        def merge(prop)
+            result = self.clone
+            prop.each do |k,vals|
+                vals.each { |v| result[k] = v }
+            end
+            return result
+        end
+
+        # Tells if +key+ is present.
+        def key?(key)
+           @content.key?(key)
+        end
+
+        # Add a property
+        def []=(key,value)
+            @@property_keys << key
+            # Add an entry if not present.
+            @content[key] = [] unless @content.key?(key)
+            # Add the value to the entry.
+            @content[key] << value
+        end
+
+        # Get a property
+        def [](key)
+            return @content[key]
+        end
+
+        # Iterate over each value associated with +key+.
+        def each_with_key(key,&ruby_block)
+            return unless @content.key?(key)
+            @content[key].each(&ruby_block)
+        end
+
+        # Iterate over the properties of the current set.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each) unless ruby_block
+            # A ruby block? Apply it on each input signal instance.
+            @content.each(&ruby_block)
+        end
+
+        # Iterator over all the property keys
+        #
+        # Returns an enumerator if no ruby block is given.
+        def self.each_key(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_key) unless ruby_block
+            # A ruby block? Apply it on each input signal instance.
+            @@property_keys.each(&ruby_block)
+        end
+
+        # # Iterate over the property set of all the objects from current owner.
+        # #
+        # # Returns an enumerator if no ruby block is given.
+        # def each_properties(&ruby_block)
+        #     # No ruby block? Return an enumerator.
+        #     return to_enum(:each_properties) unless ruby_block
+        #     # A ruby block? Apply it.
+        #     # On current property set
+        #     ruby_block.call(self)
+        #     # And on the properties set of sub objects of the owner.
+        #     self.owner.instance_variables.each do |var|
+        #         obj = owner.instance_variable_get(var)
+        #         if (obj.is_a?(Hproperties)) then
+        #             # obj has properties, recurse on them.
+        #             obj.properties.each_properties(&ruby_block)
+        #         end
+        #     end
+        # end
+
+    end
+
+    
+end