HDLRuby 3.0.0 → 3.2.0

data/lib/HDLRuby/hdrcc.rb

@@ -84,6 +84,10 @@ require 'HDLRuby/backend/hruby_c_allocator'
 
 require 'HDLRuby/version.rb'
 
+# Global flags
+$sim = false     # Tells if hdrcc is in simulation mode
+$gen = false     # Tells if hdrcc is in hardware generation mode
+
 
 ##
 # HDLRuby compiler interface program
@@ -373,19 +377,23 @@ $optparse = OptionParser.new do |opts|
     opts.on("-S","--sim","Default simulator (hybrid C-Ruby)") do |v|
         $options[:rcsim] = v
         $options[:multiple] = v
+        $sim = true
     end
     opts.on("--csim","Standalone C-based simulator") do |v|
         $options[:clang] = v
         $options[:multiple] = v
         $options[:csim] = v
+        $sim = true
     end
     opts.on("--rsim","Ruby-based simulator") do |v|
         $options[:rsim] = v
         $options[:multiple] = v
+        $sim = true
     end
     opts.on("--rcsim","Hybrid C-Ruby-based simulator") do |v|
         $options[:rcsim] = v
         $options[:multiple] = v
+        $sim = true
     end
     opts.on("--mute", "The simulator will not generate any output") do |v|
         $options[:mute] = v
@@ -396,12 +404,14 @@ $optparse = OptionParser.new do |opts|
     opts.on("-v", "--verilog","Output in Verlog HDL format") do |v|
         $options[:verilog] = v
         $options[:multiple] = v
+        $gen = true
     end
     opts.on("-V", "--vhdl","Output in VHDL format") do |v|
         HDLRuby::Low::Low2VHDL.vhdl08 = false
         $options[:vhdl] = v
         $options[:multiple] = v
         $options[:vhdl08] = false
+        $gen = true
     end
     opts.on("-A", "--alliance","Output in Alliance-compatible VHDL format") do |v|
         HDLRuby::Low::Low2VHDL.vhdl08 = false
@@ -410,12 +420,14 @@ $optparse = OptionParser.new do |opts|
         $options[:alliance] = v
         $options[:multiple] = v
         $options[:vhdl08] = false
+        $gen = true
     end
     opts.on("-U", "--vhdl08","Output in VHDL'08 format") do |v|
         HDLRuby::Low::Low2VHDL.vhdl08 = true
         $options[:vhdl] = v
         $options[:multiple] = v
         $options[:vhdl08] = true
+        $gen = true
     end
     opts.on("-s", "--syntax","Output the Ruby syntax tree") do |s|
         $options[:syntax] = s
@@ -821,7 +833,7 @@ elsif $options[:verilog] then
     $top_system.each_systemT_deep do |systemT|
         HDLRuby.show? "signal2subs step..."
         # Ensure there is not implicit assign to sub signals.
-        systemT.signal2subs!
+        systemT.signal2subs!(true)
         # HDLRuby.show "casts_without_expression! step..."
         # systemT.casts_without_expression!
         # HDLRuby.show Time.now

data/lib/HDLRuby/hruby_high.rb

@@ -880,9 +880,11 @@ module HDLRuby::High
                       "Cannot convert a system without a name to HDLRuby::Low."
             end
             # Create the resulting low system type.
-            # systemTL = HDLRuby::Low::SystemT.new(High.names_create(name),
-            systemTL = HDLRuby::Low::SystemT.new(HDLRuby.uniq_name(name),
-                                                   self.scope.to_low)
+            # systemTL = HDLRuby::Low::SystemT.new(HDLRuby.uniq_name(name),
+            #                                        self.scope.to_low)
+            systemTLN = HDLRuby.uniq_name(name)
+            systemTL = HDLRuby::Low::SystemT.new(systemTLN,
+                                                   self.scope.to_low(systemTLN))
             # puts "New low from system #{self.name}: #{systemTL.name}"
             # # For debugging: set the source high object 
             # systemTL.properties[:low2high] = self.hdr_id
@@ -1168,6 +1170,17 @@ module HDLRuby::High
             self.parent.inout(*names)
         end
 
+        # Declares a program in language +lang+ with start function named +func+
+        # and accessed expressions an code given in +args+.
+        def program(lang, func, *args)
+            # Create the program.
+            prog = Program.new(lang, func, *args)
+            # Adds the resulting program to the current scope.
+            HDLRuby::High.top_user.add_program(prog)
+            # Return the resulting program
+            return prog
+        end
+
         # Declares a non-HDLRuby set of code chunks described by +content+ and
         # completed from +ruby_block+ execution result.
         # NOTE: content includes the events to activate the code on and
@@ -1512,6 +1525,8 @@ module HDLRuby::High
                     scopeL.add_systemT(systemI_low.systemT)
                 }
             end
+            # Adds the programs.
+            self.each_program { |prog| scopeL.add_program(prog.to_low) }
             # Adds the code chunks.
             self.each_code { |code| scopeL.add_code(code.to_low) }
             # Adds the connections.
@@ -1526,10 +1541,15 @@ module HDLRuby::High
         end
 
         # Converts the scope to HDLRuby::Low.
-        def to_low()
+        # +name+ is the name of the system containing the new low scope in case
+        # of top scope, should be used as name for it.
+        # NOTE: by convention, the name of the top scope is the name of the
+        # system.
+        def to_low(low_name = nil)
             # Create the resulting low scope.
             # scopeL = HDLRuby::Low::Scope.new()
-            scopeL = HDLRuby::Low::Scope.new(self.name)
+            low_name = self.name unless low_name
+            scopeL = HDLRuby::Low::Scope.new(low_name)
             # # For debugging: set the source high object 
             # scopeL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = scopeL
@@ -1974,7 +1994,7 @@ module HDLRuby::High
                 raise AnyError, "Generic type #{self.name} did not produce a valid type: #{gtype.class}"
             end
             # Create a new type definition from it.
-            gtype = TypeDef.new(self.name.to_s + "_#{args.join(":")}",
+            gtype = TypeDef.new(self.name.to_s + "_#{args.join(':')}",
                                    gtype)
             # Adds the possible overloaded operators.
             self.each_overload do |op,ruby_block|
@@ -2168,6 +2188,7 @@ module HDLRuby::High
 
     # Methods for declaring systems
 
+
     # Declares a high-level system type named +name+, with +includes+ mixins
     # system types and using +ruby_block+ for instantiating.
     def system(name = :"", *includes, &ruby_block)
@@ -2198,29 +2219,48 @@ module HDLRuby::High
     #
     # NOTE: a function is a short-cut for a method that creates a scope.
     def function(name, &ruby_block)
+        warn("Construct 'function' is deprecated, use 'hdef' instead.")
         # Ensure there is a block.
         ruby_block = proc {} unless block_given?
         if HDLRuby::High.in_system? then
             define_singleton_method(name.to_sym) do |*args,&other_block|
-                # sub do
                 sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
-                    # ruby_block.call(*args)
                 end
             end
         else
             define_method(name.to_sym) do |*args,&other_block|
-                # sub do
                 sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
-                    # ruby_block.call(*args,*other_block)
                 end
             end
         end
     end
 
+    # Declares a function named +name+ using +ruby_block+ as body.
+    #
+    # NOTE: a function is a short-cut for a method that creates a scope.
+    def hdef(name, &ruby_block)
+        # Ensure there is a block.
+        ruby_block = proc {} unless block_given?
+        if HDLRuby::High.in_system? then
+            define_singleton_method(name.to_sym) do |*args,&other_block|
+                sub(HDLRuby.uniq_name(name)) do
+                    HDLRuby::High.top_user.instance_exec(*args,*other_block,
+                                                         &ruby_block)
+                end
+            end
+        else
+            define_method(name.to_sym) do |*args,&other_block|
+                sub(HDLRuby.uniq_name(name)) do
+                    HDLRuby::High.top_user.instance_exec(*args,*other_block,
+                                                         &ruby_block)
+                end
+            end
+        end
+    end
 
 
 
@@ -2275,24 +2315,8 @@ module HDLRuby::High
                 # Performs the connections.
                 connects.each do |key,value|
                     # Gets the signal corresponding to connect.
-                    # signal = self.get_signal(key)
-                    # unless signal then
-                    #     # Look into the included systems.
-                    #     self.systemT.scope.each_included do |included|
-                    #         signal = included.get_signal(key)
-                    #         break if signal
-                    #     end
-                    # end
                     signal = self.systemT.get_signal_with_included(key)
                     # Check if it is an output.
-                    # isout = self.get_output(key)
-                    # unless isout then
-                    #     # Look into the inlucded systems.
-                    #     self.systemT.scope.each_included do |included|
-                    #         isout = included.get_output(key)
-                    #         break if isout
-                    #     end
-                    # end
                     isout = self.systemT.get_output_with_included(key)
                     # Convert it to a reference.
                     # puts "key=#{key} value=#{value} signal=#{signal}"
@@ -2422,7 +2446,6 @@ module HDLRuby::High
 
         # Gets the private namespace.
         def namespace
-            # self.systemT.scope.namespace
             self.systemT.namespace
         end
 
@@ -2473,6 +2496,25 @@ module HDLRuby::High
         end
     end
 
+
+
+
+    ##
+    # Describes a program.
+    class Program < HDLRuby::Low::Program
+        # Converts the if to HDLRuby::Low.
+        def to_low
+            # Create the resulting program.
+            progL = HDLRuby::Low::Program.new(self.lang,self.function,
+                                            *self.each_expression.map(&:to_low),
+                                            *self.each_event.map(&:to_low),
+                                            *self.each_code)
+            # Return the resulting program.
+            return progL
+        end
+    end
+
+
     ##
     # Decribes a set of non-HDLRuby code chunks.
     class Code < HDLRuby::Low::Code
@@ -3134,7 +3176,6 @@ module HDLRuby::High
 
         # Converts the unary expression to HDLRuby::Low.
         def to_low
-            # return HDLRuby::Low::Cast.new(self.type.to_low,self.child.to_low)
             castL =HDLRuby::Low::Cast.new(self.type.to_low,self.child.to_low)
             # # For debugging: set the source high object 
             # castL.properties[:low2high] = self.hdr_id
@@ -3318,6 +3359,24 @@ module HDLRuby::High
                 include HExpression
                 include HArrow
 
+                # Update the initialize to handle struct types accesses if
+                # it is not a RefObject, this latter being a proxy to a
+                # real component.
+                if klass != RefObject then
+                    original_initialize = instance_method(:initialize)
+                    define_method(:initialize) do |*args, &block|
+                        original_initialize.bind(self).call(*args,&block)
+                        # Now process it if it is a structured type.
+                        if self.type.struct? then
+                            self.type.each do |name,typ|
+                                self.define_singleton_method(name) do
+                                    RefName.new(typ,self,name)
+                                end
+                            end
+                        end
+                    end
+                end
+
                 # Converts to a new expression.
                 def to_expr
                     self.to_ref
@@ -3418,15 +3477,22 @@ module HDLRuby::High
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
             # puts "to_low with base=#{@base} @object=#{@object}"
-            # puts "@object.name=#{@object.name}"
+            # puts "@object.name=#{@object.name} @object.parent=#{@object.parent.name}"
             if @base.is_a?(RefThis) && 
                     (@object.parent != High.top_user) &&
                     (@object.parent != High.cur_system) &&
+                    (@object.parent != High.cur_system.scope) &&
                     (!@object.parent.name.empty?) then
                 # Need to have a hierachical access.
-                # puts "Indirect access for #{self.object.name}: #{self.object.parent.name}(#{self.object.parent.class}) != #{High.cur_system.name}(#{High.top_user.class})"
-                refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
+                if @object.respond_to?(:low_object) && @object.low_object then
+                    # There where already a low object, create the ref from it.
+                    # puts "absolute ref!"
+                    refNameL = @object.low_object.absolute_ref
+                else
+                    # No create the indirect reference.
+                    refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                                      @object.parent.to_ref.to_low,@object.name)
+                end
             else
                 # Direct access is enough.
                 refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
@@ -3954,11 +4020,19 @@ module HDLRuby::High
             return [obj,self.to_expr]
         end
 
+        # Get the low version off the object.
+        # NOTE: only useful for Signals and SystemIs since they can be accessed
+        # from outside the module they have been defined in.
+        def low_object
+            return @low_object
+        end
+
         # Converts the system to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
             # return HDLRuby::Low::SignalI.new(name,self.type.to_low)
             valueL = self.value ? self.value.to_low : nil
             signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low,valueL)
+            @low_object = signalIL
             # Recurse on the sub signals if any.
             self.each_signal do |sig|
                 signalIL.add_signal(sig.to_low)

data/lib/HDLRuby/hruby_low.rb

@@ -79,6 +79,24 @@ module HDLRuby::Low
             end
             return res
         end
+
+        # Get an absolute reference to the object.
+        def absolute_ref
+            # Get the full hierarchy up to the object.
+            path = self.hierarchy
+            # Create the reference.
+            # return path.reduce(RefThis.new) do |ref,node|
+            return path.reverse_each.reduce(RefThis.new) do |ref,node|
+                # puts "node=#{node}"
+                # puts "name=#{node.name}" if node.respond_to?(:name)
+                if node.respond_to?(:name) then
+                    typ = node.respond_to?(:type) ? node.type : void
+                    RefName.new(typ,ref,node.name)
+                else
+                    ref
+                end
+            end
+        end
     end
 
 
@@ -98,7 +116,8 @@ module HDLRuby::Low
         attr_reader :scope
 
         # Creates a new system type named +name+ with +scope+.
-        def initialize(name,scope)
+        # def initialize(name,scope)
+        def initialize(name,scope = nil)
             # Set the name as a symbol.
             @name = name.to_sym
 
@@ -109,6 +128,13 @@ module HDLRuby::Low
             @interface = []         # The interface signals in order of
                                     # declaration
 
+        #     self.set_scope(scope) if scope
+        # end
+
+        # # Set the scope of the systemT to +scope+.
+        # # Note: cannot override an existing scope.
+        # def set_scope(scope)
+        #     raise(AnyError,"Scope already present") if @scope
             # Check the scope
             unless scope.is_a?(Scope)
                 raise AnyError,
@@ -313,7 +339,7 @@ module HDLRuby::Low
         # Returns an enumerator if no ruby block is given.
         def each_signal_all(&ruby_block)
             # No ruby block? Return an enumerator.
-            return to_enum(:each_signal) unless ruby_block
+            return to_enum(:each_signal_all) unless ruby_block
             # A ruby block? Apply it on each signal instance.
             @inputs.each(&ruby_block)
             @outputs.each(&ruby_block)
@@ -526,6 +552,8 @@ module HDLRuby::Low
             @inners  = HashName.new
             # Initialize the system instances list.
             @systemIs = HashName.new
+            # Initialize the programs list.
+            @programs = []
             # Initialize the non-HDLRuby code chunks list.
             @codes = []
             # Initialize the connections list.
@@ -804,7 +832,40 @@ module HDLRuby::Low
         #     end
         #     systemI
         # end
+        
+
+        # Handling the programs.
+
+        # Adds program +prog+.
+        def add_program(prog)
+            # Check and add the program.
+            unless prog.is_a?(Program)
+                raise AnyError,
+                      "Invalid class for a program: #{prog.class}"
+            end
+            # Set the parent of the program.
+            program.parent = self
+            # Add the program.
+            @programs << program
+            program
+        end
+
+        # Iterates over the programs.
         #
+        # Returns an enumerator if no ruby block is given.
+        def each_program(&ruby_block)
+            # puts "each_program from scope=#{self}"
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_program) unless ruby_block
+            # A ruby block? Apply it on each program.
+            @programs.each(&ruby_block)
+        end
+
+        # Tells if there is any program.
+        def has_program?
+            return !@programs.empty?
+        end
+
         # Handling the non-HDLRuby code chunks.
 
         # Adds code chunk +code+.
@@ -832,7 +893,7 @@ module HDLRuby::Low
             # puts "each_code from scope=#{self}"
             # No ruby block? Return an enumerator.
             return to_enum(:each_code) unless ruby_block
-            # A ruby block? Apply it on each system instance.
+            # A ruby block? Apply it on each code.
             @codes.each(&ruby_block)
         end
 
@@ -2936,6 +2997,69 @@ module HDLRuby::Low
     end
 
 
+    ##
+    # Describes a program.
+    class Program
+
+        include Hparent
+
+        attr_reader :language, :function
+
+        # Creates a new program in language +lang+ with start function
+        # named +func+ accessed expressions, events and code files given in
+        # +args+.
+        def initialize(lang,func,*args)
+            # Sets the language.
+            @language = lang.to_sym
+            # Sets the start function.
+            @function = func.to_s
+            # Process the expressions and code files arguments.
+            @exprs = []
+            @events = []
+            @codes = []
+            args.each do |arg|
+                if arg.is_a?(String) then
+                    @codes << arg
+                elsif arg.is_a?(Event) then
+                    @events << arg
+                else
+                    @exprs << arg.to_expr
+                end
+            end
+        end
+
+        # Iterates over each accessed expression.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_expression(&ruby_block)
+            # No block? Return an enumerator.
+            return to_enum(:each_expression) unless ruby_block
+            # A block is given, apply it.
+            @exprs.each(&ruby_block)
+        end
+
+        # Iterates over each accessed event.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_event(&ruby_block)
+            # No block? Return an enumerator.
+            return to_enum(:each_event) unless ruby_block
+            # A block is given, apply it.
+            @events.each(&ruby_block)
+        end
+
+        # Iterates over each code files.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_code(&ruby_block)
+            # No block? Return an enumerator.
+            return to_enum(:each_code) unless ruby_block
+            # A block is given, apply it.
+            @codes.each(&ruby_block)
+        end
+    end
+
+
     ##
     # Decribes a set of non-HDLRuby code chunks.
     class Code

data/lib/HDLRuby/hruby_low2programs.rb

@@ -0,0 +1,47 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_low_with_bool'
+require 'HDLRuby/hruby_low_without_namespace'
+require 'HDLRuby/hruby_low_with_var'
+
+
+module HDLRuby::Low
+
+
+##
+# Converts a HDLRuby::Low description to descriptions of software programs.
+#
+########################################################################
+
+    ## Provides tools for extracting software from HDLRuby description.
+    module Low2Programs
+
+        class SystemT
+            ## Extends the SystemT class with extraction of software.
+
+            # Extract the information about the software in the system and put it
+            # into +target+ directory.
+            def extract_programs(target)
+                # Gather the programs descriptions.
+                programs = self.scope.each_scope_deep.map do |scope|
+                    scope.each_program.to_a
+                end
+                programs.flatten!
+                # Sort the programs by language.
+                lang2prog = Hash.new([])
+                programs.each { |prog| lang2prog[prog.language] << prog }
+                # Copy the programs in the corresponding subdirectories.
+                lang2prog.each do |lang,progs|
+                    dir = target + "/" + lang
+                    Dir.mkdir(dir)
+                    progs.each do |prog|
+                        prog.each_code  { |code| FileUtils.cp(code,dir) }
+                    end
+                end
+            end
+        end
+
+
+        class Scope
+        end
+
+    end

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -233,6 +233,7 @@ module HDLRuby::Low
             if self.ref.is_a?(RefName) then
                 obj = self.ref.resolve
                 # puts "obj=#{obj}"
+                return obj if obj.name == self.name
                 # Look into the object for the name.
                 return obj.get_by_name(self.name)
             else
@@ -242,9 +243,9 @@ module HDLRuby::Low
                 while parent
                     # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
-                        # puts "get_by_name"
+                        # puts "Going get_by_name with name=#{self.name}"
                         found = parent.get_by_name(self.name)
-                        # puts "found" if found
+                        # puts "found=#{found}" if found
                         return found if found
                     end
                     parent = parent.parent