HDLRuby 3.1.0 → 3.3.0

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 built through +ruby_block+.
+        def program(lang, func, &ruby_block)
+            # Create the program.
+            prog = Program.new(lang, func, &ruby_block)
+            # 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)
@@ -2294,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}"
@@ -2441,7 +2446,6 @@ module HDLRuby::High
 
         # Gets the private namespace.
         def namespace
-            # self.systemT.scope.namespace
             self.systemT.namespace
         end
 
@@ -2492,6 +2496,68 @@ module HDLRuby::High
         end
     end
 
+
+
+
+    ##
+    # Describes a program.
+    class Program < HDLRuby::Low::Program
+
+        include Hmissing
+
+        attr_reader :namespace
+
+        # Create a program in language +lang+ with start function named +func+
+        # and built through +ruby_block+.
+        def initialize(lang, func, &ruby_block)
+            # Create the program.
+            super(lang,func)
+            # Create the namespace for the program.
+            @namespace = Namespace.new(self)
+            # Build the program object.
+            High.space_push(@namespace)
+            High.top_user.instance_eval(&ruby_block)
+            High.space_pop
+        end
+
+        # Converts the if to HDLRuby::Low.
+        def to_low
+            # Create the resulting program.
+            progL = HDLRuby::Low::Program.new(self.lang,self.function)
+            # Add the wakening events.
+            self.each_event  { |ev| progL.add_event(ev.to_low) }
+            # Add the code files.
+            self.each_code   { |ev| progL.add_code(code) }
+            # Add the input signals references.
+            self.each_input  { |ref| progL.add_input(ref.to_low) }
+            # Add the output signals references.
+            self.each_output { |ref| progL.add_output(ref.to_low) }
+            # Return the resulting program.
+            return progL
+        end
+
+        # Adds new activation ports.
+        def actport(*evs)
+            evs.each(&method(:add_actport))
+        end
+
+        # Adds new code files.
+        def code(*codes)
+            codes.each(&method(:add_code))
+        end
+
+        # Adds new input ports.
+        def inport(ports = {})
+          ports.each { |k,v| self.add_inport(k,v) }
+        end
+
+        # Adds new output ports.
+        def outport(ports = {})
+          ports.each { |k,v| self.add_outport(k,v) }
+        end
+    end
+
+
     ##
     # Decribes a set of non-HDLRuby code chunks.
     class Code < HDLRuby::Low::Code
@@ -3336,6 +3402,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
@@ -3436,15 +3520,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,
@@ -3972,11 +4063,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.
+            prog.parent = self
+            # Add the program.
+            @programs << prog
+            prog
+        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,113 @@ 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+.
+        def initialize(lang,func)
+            # Sets the language.
+            @language = lang.to_sym
+            # Sets the start function.
+            @function = func.to_s
+            # Initializes the contents.
+            @actports = [] # The activation ports.
+            @codes    = [] # The code files.
+            @inports  = {} # The input ports.
+            @outports = {} # The output ports.
+        end
+
+        # Add a new activation port.
+        def add_actport(ev)
+            unless ev.is_a?(Event) then
+                raise AnyError, "Invalid class for an event: #{ev.class}"
+            end
+            @actports << ev
+        end
+
+        # Add a new code file.
+        def add_code(code)
+            @codes << code.to_s
+        end
+
+        # Add a new input port.
+        def add_inport(name, sig)
+            # Ensure name is a symbol.
+            unless name.is_a?(Symbol) then
+                name = name.to_s.to_sym
+            end
+            # Ensure sig is a signal.
+            unless sig.is_a?(SignalI) then
+                raise AnyError, "Invalid class for a signal: #{sig.class}"
+            end
+            # Add the new port.
+            @inports[name] = sig
+        end
+
+        # Add a new output port.
+        def add_outport(name, sig)
+            # Ensure name is a symbol.
+            unless name.is_a?(Symbol) then
+                name = name.to_s.to_sym
+            end
+            # Ensure sig is a signal.
+            unless sig.is_a?(SignalI) then
+                raise AnyError, "Invalid class for a signal: #{sig.class}"
+            end
+            # Add the new port.
+            @outports[name] = sig
+        end
+
+
+        # Iterates over each activation event.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_actport(&ruby_block)
+            # No block? Return an enumerator.
+            return to_enum(:each_actport) unless ruby_block
+            # A block is given, apply it.
+            @actports.each(&ruby_block)
+        end
+
+        # Iterates over each code file.
+        #
+        # 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
+
+        # Iterate over each input port.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_inport(&ruby_block)
+            # No block? Return an enumerator.
+            return to_enum(:each_inport) unless ruby_block
+            # A block is given, apply it.
+            @inports.each(&ruby_block)
+        end
+
+        # Iterate over each output port.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_outport(&ruby_block)
+            # No block? Return an enumerator.
+            return to_enum(:each_outport) unless ruby_block
+            # A block is given, apply it.
+            @outports.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