HDLRuby 3.1.0 → 3.2.0

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

data/lib/HDLRuby/hruby_low_without_namespace.rb

@@ -122,10 +122,17 @@ module HDLRuby::Low
             # Extract the connections of the sub scopes.
             cnxs = self.each_scope.map(&:extract_connections!).flatten
             # Reinsert them to self.
-            cnxs.each { |beh| self.add_connection(beh) }
+            cnxs.each { |cnx| self.add_connection(cnx) }
+
+            # The fix the RefName using sub scopes since their target have
+            # been deplaced to current scope and renamed.
+            self_scopes = self.each_scope.to_a
+            self.each_behavior { |beh| beh.fix_scope_refnames!(self_scopes) }
+            self.each_connection { |cnx| cnx.fix_scope_refnames!(self_scopes) }
 
             # Now can delete the sub scopes since they are empty.
-            self.each_scope.to_a.each { |scope| self.delete_scope!(scope) }
+            # self.each_scope.to_a.each { |scope| self.delete_scope!(scope) }
+            self_scopes.each { |scope| self.delete_scope!(scope) }
         end
 
         # Extract the behaviors from the scope and returns them into an array.
@@ -219,9 +226,10 @@ module HDLRuby::Low
         # in the internals.
         def replace_names_subs!(former,nname)
             # puts "replace_names_subs! for #{self} with former=#{former} and nname=#{nname}"
-            self.each_type do |type|
-                type.replace_names!(former,nname)
-            end
+            # No need? 
+            # self.each_type do |type|
+            #     type.replace_names!(former,nname)
+            # end
             self.each_systemT do |systemT|
                 systemT.replace_names!(former,nname)
             end
@@ -460,6 +468,13 @@ module HDLRuby::Low
             # Recurse on the block.
             self.block.replace_names!(former,nname)
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+          self.block.fix_scope_refnames!(scopes)
+          return self
+        end
     end
 
 
@@ -498,6 +513,34 @@ module HDLRuby::Low
                 node.break_types!(types)
             end
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+          # By default, does nothing.
+          return self
+        end
+    end
+
+
+    class Transmit
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            self.set_left!(self.left.fix_scope_refnames!(scopes))
+            self.set_right!(self.right.fix_scope_refnames!(scopes))
+            return self
+        end
+    end
+
+    class Connection
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            self.set_left!(self.left.fix_scope_refnames!(scopes))
+            self.set_right!(self.right.fix_scope_refnames!(scopes))
+            return self
+        end
     end
 
 
@@ -527,6 +570,16 @@ module HDLRuby::Low
                 end
             end
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # By default: recurse.
+            self.map_nodes! do |node|
+                node.fix_scope_refnames!(scopes)
+            end
+            return self
+        end
     end
 
     
@@ -578,6 +631,24 @@ module HDLRuby::Low
             # Recurse on the no if any.
             self.no.replace_names!(former,nname) if self.no
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # Fix the condition.
+            self.set_condition!(self.condition.fix_scope_refnames!(scopes))
+            # Recurse on the yes.
+            self.yes.fix_scope_refnames!(scopes)
+            # Recurse on the alternate ifs.
+            self.map_noifs! do |cond,stmnt|
+                cond = cond.fix_scope_refnames!(scopes)
+                stmnt = stmnt.fix_scope_refnames!(scopes)
+                [cond,stmnt]
+            end
+            # Recruse on the no if any.
+            self.no.fix_scope_refnames!(scopes) if self.no
+            return self
+        end
     end
 
 
@@ -618,6 +689,16 @@ module HDLRuby::Low
                 end
             end
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # Fix the match.
+            self.set_match!(self.match.fix_scope_refnames!(scopes))
+            # Recurse on the statement.
+            self.statement.fix_scope_refnames!(scopes)
+            return self
+        end
     end
 
 
@@ -655,6 +736,18 @@ module HDLRuby::Low
             # Recurse on the default.
             self.default.replace_names!(former,nname) if self.default
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # Fix the value.
+            self.set_value!(self.value.fix_scope_refnames!(scopes))
+            # Recurse on the whens.
+            self.each_when {|w| w.fix_scope_refnames!(scopes) }
+            # Recurse on the default.
+            self.default.fix_scope_refnames!(scopes) if self.default
+            return self
+        end
     end
 
 
@@ -681,6 +774,14 @@ module HDLRuby::Low
             # Recurse on the statement.
             self.statement.replace_names!(former,nname)
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # Recurse on the statement.
+            self.statement.fix_scope_refnames!(scopes)
+            return self
+        end
     end
 
 
@@ -738,6 +839,33 @@ module HDLRuby::Low
             # Recurse on the sub scopes and behaviors.
             replace_names_subs!(former,nname)
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            self.each_statement {|stmnt| stmnt.fix_scope_refnames!(scopes) }
+            return self
+        end
+    end
+
+
+    class RefName
+        include ForceName
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            return self unless self.ref.is_a?(RefName)
+            # puts "fix_scope_refnames! with self.name=#{name} and self.ref=#{self.ref}"
+            # Recurse on the ref.
+            self.set_ref!(self.ref.fix_scope_refnames!(scopes))
+            # Rename and curt the subref if referening to one of the scopes.
+            if scopes.find {|scope| scope.name == self.ref.name } then
+                self.ref.extend_name!(self)
+                self.set_ref!(RefThis.new)
+            end
+            return self
+        end
     end
 
 end

data/lib/HDLRuby/hruby_low_without_subsignals.rb

@@ -243,7 +243,6 @@ module HDLRuby::Low
         # Flatten a reference to a list of reference to leaf signals
         # from signal +sig+ and add to result to +subrefs+
         def flatten_to(sig,subrefs)
-            # puts "flatten_to with sig name=#{sig.name}"
             # Shall we decompose 2d vectors, and is the current signal
             # for one of them?
             if SystemT.decompose_vec2d? and sig.type.is_a?(TypeVector) and
@@ -294,6 +293,7 @@ module HDLRuby::Low
         # Decompose the hierarchical signals in the statements.
         def signal2subs!
             # puts "signal2subs! for RefName: #{self.name}"
+            return self if self.type == void # Not a singal anyway.
             # Decompose it to a list of reference to each leaf sub signal.
             subrefs = []
             self.flatten_to(self.resolve,subrefs)

data/lib/HDLRuby/hruby_rcsim.rb

@@ -1000,7 +1000,30 @@ module HDLRuby::High
 
     class RefName
         ## Extends the RefName class for hybrid Ruby-C simulation.
-        # Should not be used with rcsim.
+        # Converted to RefRange.
+
+        # Generate the C description of the reference range (not ref name!).
+        def to_rcsim
+            # Convert the base to a bit vector.
+            type_base = Bit[self.ref.type.width]
+            # self.ref.parent = nil
+            # bit_base = Cast.new(type_base,self.ref)
+            bit_base = RCSim.rcsim_make_cast(type_base.to_rcsim,self.ref.to_rcsim)
+            # Compute range in bits of the field.
+            last = 0
+            self.ref.type.each.detect do |name,typ|
+                last += typ.width
+                name == self.name
+            end
+            first = last-self.type.width
+            last -= 1
+            # puts "name=#{self.name} first=#{first} last=#{last}"
+            type_int = Bit[type_base.width.width]
+            return RCSim.rcsim_make_refRange(self.type.to_rcsim,
+                                             Value.new(type_int,last).to_rcsim,
+                                             Value.new(type_int,first).to_rcsim,
+                                             bit_base)
+        end
     end
 
 

data/lib/HDLRuby/hruby_serializer.rb

@@ -23,7 +23,8 @@ module HDLRuby
                  Low::TypeSigned, Low::TypeUnsigned, Low::TypeFloat,
                  Low::TypeTuple, Low::TypeStruct,
                  Low::Behavior, Low::TimeBehavior, 
-                 Low::Event, Low::Block, Low::TimeBlock, Low::Code, 
+                 Low::Event, Low::Block, Low::TimeBlock, 
+                 Low::Program, Low::Code, 
                  Low::SignalI, Low::SignalC,
                  Low::SystemI, Low::Connection, 
                  Low::Transmit, Low::If, Low::Case, Low::When, Low::Cast,