HDLRuby 3.7.2 → 3.7.4

data/lib/HDLRuby/std/sequencer_sw.rb

@@ -15,6 +15,8 @@ module RubyHDL::High
   ########################################################################
 
 
+
+
   @@absoluteCounter = -1 # The absolute name counter.
 
   @@uniq_names = Set.new(Symbol.all_symbols.map {|sym| sym.to_s})
@@ -52,6 +54,42 @@ module RubyHDL::High
       nil
     end
 
+    # Generate input signals with type +type+ and names from +names+ list.
+    def make_inputs(type,*names)
+      # puts "make_inputs with names=#{names.join(",")}"
+      type = type.to_type
+      last_sig = nil
+      names.each do |name|
+        name = name.to_sym
+        # Create and add the signal.
+        sig = SignalI.new(name,type,:input)
+        @signals << sig
+        # Register it.
+        # self.register(name) { puts("sig=",sig.inspect); sig }
+        self.register(name) { sig }
+        last_sig = sig
+      end
+      return last_sig
+    end
+
+    # Generate output signals with type +type+ and names from +names+ list.
+    def make_outputs(type,*names)
+      # puts "make_outputs with names=#{names.join(",")}"
+      type = type.to_type
+      last_sig = nil
+      names.each do |name|
+        name = name.to_sym
+        # Create and add the signal.
+        sig = SignalI.new(name,type,:output)
+        @signals << sig
+        # Register it.
+        # self.register(name) { puts("sig=",sig.inspect); sig }
+        self.register(name) { sig }
+        last_sig = sig
+      end
+      return last_sig
+    end
+
     # Generate inner signals with type +type+ and names from +names+ list.
     def make_inners(type,*names)
       # puts "make_inners with names=#{names.join(",")}"
@@ -60,7 +98,7 @@ module RubyHDL::High
       names.each do |name|
         name = name.to_sym
         # Create and add the signal.
-        sig = SignalI.new(type,name)
+        sig = SignalI.new(name,type,:inner)
         @signals << sig
         # Register it.
         # self.register(name) { puts("sig=",sig.inspect); sig }
@@ -73,12 +111,12 @@ module RubyHDL::High
     # Register a new object named +name+ generated by +ruby_block+.
     def register(name,&ruby_block)
       # Add a way to call it from the stack of SW blocks.
-      ::Object.define_method(name) do
-        RubyHDL::High.call_sblock(name)
+      ::Object.define_method(name) do |*args|
+        RubyHDL::High.call_sblock(name,*args)
       end
       # Add a method for accessing the object.
       # self.define_singleton_method(name,&ruby_block)
-      res = ruby_block.call
+      # res = ruby_block.call
       @callables[name] = ruby_block
     end
 
@@ -183,12 +221,12 @@ module RubyHDL::High
     :"&" => "(%{l})&(%{r})", :"|" => "(%{l})|(%{r})", 
     :"^" => "(%{l})^(%{r})",
     :"<<" => "(%{l})<<(%{r})", :">>" => "(%{l})>>(%{r})",
-    :"==" => "(%{l}) & %{m}==(%{r}) & %{m}", 
-    :"!=" => "(%{l}) & %{m}!=(%{r}) %{m}",
-    :"<" => "(%{l}) & %{m}%{s} < (%{r}) & %{m}%{s}", 
-    :">" => "(%{l}) & %{m}%{s} > (%{r}) & %{m}%{s}", 
-    :"<=" => "(%{l}) & %{m}%{s} <=(%{r}) & %{m}%{s}",
-    :">=" => "(%{l}) & %{m}%{s} >=(%{r}) & %{m}%{s}"
+    :"==" => "((%{l}) & %{m}==(%{r}) & %{m}) ? 1:0", 
+    :"!=" => "((%{l}) & %{m}!=(%{r}) %{m}) ? 1:0",
+    :"<" => "((%{l}) & %{m}%{s} < (%{r}) & %{m}%{s}) ? 1:0", 
+    :">" => "((%{l}) & %{m}%{s} > (%{r}) & %{m}%{s}) ? 1:0", 
+    :"<=" => "((%{l}) & %{m}%{s} <=(%{r}) & %{m}%{s}) ? 1:0",
+    :">=" => "((%{l}) & %{m}%{s} >=(%{r}) & %{m}%{s}) ? 1:0"
   }
 
   # The translation of operators into C code.
@@ -618,7 +656,23 @@ module RubyHDL::High
       return TypeVector.new(:"",base,self[0])
     end
 
-    # Generate signals from +names+.
+    # Generate input signals from +names+.
+    def input(*names)
+      # Generate the type.
+      type = self.to_type
+      # Generate the resulting signals.
+      return type.input(*names)
+    end
+
+    # Generate output signals from +names+.
+    def output(*names)
+      # Generate the type.
+      type = self.to_type
+      # Generate the resulting signals.
+      return type.output(*names)
+    end
+
+    # Generate inner signals from +names+.
     def inner(*names)
       # Generate the type.
       type = self.to_type
@@ -639,6 +693,8 @@ module RubyHDL::High
     using RubyHDL::High
     include HDLRuby::Tprocess
 
+    attr_reader :name
+
     # Type creation.
 
     # Creates a new type named +name+.
@@ -707,13 +763,13 @@ module RubyHDL::High
     # Gets the type max value if any.
     # Default: not defined.
     def max
-      raise AnyError, "No max value for type #{self}"
+      raise "No max value for type #{self} (#{self.name})"
     end
 
     # Gets the type min value if any.
     # Default: not defined.
     def min
-      raise AnyError, "No min value for type #{self}"
+      raise "No min value for type #{self} (#{self.name})"
     end
 
     # Get the direction of the type, little or big endian.
@@ -729,7 +785,7 @@ module RubyHDL::High
 
     # Gets the range of the type, by default range is not defined.
     def range
-      raise AnyError, "No range for type #{self}"
+      raise "No range for type #{self} (#{self.name})"
     end
 
     # Tells if the type has a base.
@@ -739,7 +795,7 @@ module RubyHDL::High
 
     # Gets the base type, by default base type is not defined.
     def base
-      raise AnyError, "No base type for type #{self}"
+      raise "No base type for type #{self} (#{self.name})"
     end
 
     # Tells if the type has sub types.
@@ -802,12 +858,12 @@ module RubyHDL::High
     # NOTE: can only be done if the name is not already set.
     def name=(name)
       unless @name.empty? then
-        raise AnyError, "Name of type already set to: #{@name}."
+        raise "Name of type already set to: #{@name}."
       end
       # Checks and sets the name.
       name = name.to_sym
       if name.empty? then
-        raise AnyError, "Cannot set an empty name."
+        raise "Cannot set an empty name."
       end
       @name = name
       # Registers the name.
@@ -857,17 +913,17 @@ module RubyHDL::High
 
     # SignalI creation through the type.
 
-    # # Declares high-level input signals named +names+ of the current type.
-    # def input(*names)
-    #   High.top_sblock.make_inputs(self,*names)
-    # end
+    # Declares high-level input signals named +names+ of the current type.
+    def input(*names)
+      RubyHDL::High.top_sblock.make_inputs(self,*names)
+    end
 
-    # # Declares high-level untyped output signals named +names+ of the
-    # # current type.
-    # def output(*names)
-    #   # High.top_user.make_outputs(self.instantiate,*names)
-    #   High.top_sblock.make_outputs(self,*names)
-    # end
+    # Declares high-level untyped output signals named +names+ of the
+    # current type.
+    def output(*names)
+      # High.top_user.make_outputs(self.instantiate,*names)
+      RubyHDL::High.top_sblock.make_outputs(self,*names)
+    end
 
     # # Declares high-level untyped inout signals named +names+ of the
     # # current type.
@@ -1076,7 +1132,7 @@ module RubyHDL::High
       # Ensures a type has been produced.
       gtype = gtype.to_type if gtype.respond_to?(:to_type)
       unless gtype.is_a?(Type) then
-        raise AnyError, "Generic type #{self.name} did not produce a valid type: #{gtype.class}"
+        raise "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(':')}",
@@ -1121,8 +1177,7 @@ module RubyHDL::High
 
       # Check and set the base
       unless base.is_a?(Type)
-        raise AnyError,
-          "Invalid class for VectorType base: #{base.class}."
+        raise "Invalid class for VectorType base: #{base.class}."
       end
       @base = base
 
@@ -1335,13 +1390,13 @@ module RubyHDL::High
       # Set the direction.
       @direction = direction.to_sym
       unless [:little, :big].include?(@direction)
-        raise AnyError, "Invalid direction for a type: #{direction}"
+        raise "Invalid direction for a type: #{direction}"
       end
 
       # Check and set the content.
       content.each do |sub|
         unless sub.is_a?(Type) then
-          raise AnyError, "Invalid class for a type: #{sub.class}"
+          raise "Invalid class for a type: #{sub.class}"
         end
       end
       @types = content
@@ -1385,8 +1440,7 @@ module RubyHDL::High
     # Adds a sub +type+.
     def add_type(type)
       unless type.is_a?(Type) then
-        raise AnyError, 
-          "Invalid class for a type: #{type.class} (#{type})"
+        raise "Invalid class for a type: #{type.class} (#{type})"
       end
       @types << type
     end
@@ -1454,7 +1508,7 @@ module RubyHDL::High
         # Regular tuple, return its range as if it was an array.
         return 0..@types.size-1
       else
-        raise AnyError, "No range for type #{self}"
+        raise "No range for type #{self}"
       end
     end
 
@@ -1475,7 +1529,7 @@ module RubyHDL::High
         # Regular tuple, return the type of its first element.
         return @types[0]
       else
-        raise AnyError, "No base type for type #{self}"
+        raise "No base type for type #{self}"
       end
     end
 
@@ -1503,14 +1557,14 @@ module RubyHDL::High
       # Set the direction.
       @direction = dir.to_sym
       unless [:little, :big].include?(@direction)
-        raise AnyError, "Invalid direction for a type: #{dir}"
+        raise "Invalid direction for a type: #{dir}"
       end
 
       # Check and set the content.
       content = Hash[content]
       @types = content.map do |k,v|
         unless v.is_a?(Type) then
-          raise AnyError, "Invalid class for a type: #{v.class}"
+          raise "Invalid class for a type: #{v.class}"
         end
         [ k.to_sym, v ]
       end.to_h
@@ -1889,6 +1943,7 @@ module RubyHDL::High
       @right = right.to_expr
       # Compute the mask for fixing the bit width.
       @mask = (2 ** @type.width)-1
+      # puts "@type=#{@type} name=#{@type.name} @type.width=#{@type.width} @mask=#{@mask}"
       # Compute xor mask for handling the sign.
       # Make it as a string so that no addition computation is required
       # if no sign is required.
@@ -1923,7 +1978,7 @@ module RubyHDL::High
 
     # Convert to Ruby code.
     def to_ruby
-      return "case(#{@sel.to_}) ; " +
+      return "case(#{@sel.to_ruby}) ; " +
         @choices.map.with_index do |choice,i|
           "when #{i} ; #{choice.to_ruby} ; "
         end.join + "end"
@@ -2115,10 +2170,27 @@ module RubyHDL::High
     end
   end
 
-  
+ 
+  # Describes a SW implementation of a statement.
+  class Statement
+
+    # Iterate on the statements.
+    def each_statement(&ruby_block)
+      return to_enum(:each_statement) unless ruby_block
+      # By default nothing to do.
+    end
+
+    # Iterate deeply on the statements.
+    def each_statement_deep(&ruby_block)
+      return to_enum(:each_statement_deep) unless ruby_block
+      # Just apply ruby_block on self.
+      ruby_block.call(self)
+    end
+  end
+
 
   # Describes a SW implementation of a transmit statement.
-  class Transmit
+  class Transmit < Statement
     using RubyHDL::High
 
     attr_reader :left, :right
@@ -2185,12 +2257,11 @@ module RubyHDL::High
       else
         return "#{@left.to_c} = #{@right.to_c};"
       end
-    end
-    
+    end  
   end
 
   # Describes a SW implementation of a if statement.
-  class Sif
+  class Sif < Statement
     # Create a new if statement in sequencer +sequencer+ 
     # with +cond+ condition and +ruby_block+
     # for generating the block that is taken if the condition is met.
@@ -2212,9 +2283,33 @@ module RubyHDL::High
       @else_blk = Sblock.new(@sequencer,&ruby_block)
     end
 
+    # Iterate on the statements.
+    def each_statement(&ruby_block)
+      return to_enum(:each_statement) unless ruby_block
+      # Apply ruby_block on the yes block.
+      ruby_block.call(@yes_blk)
+      # On the elsifs.
+      @elsifs.each { |cond,statement| ruby_block.call(statement) }
+      # On the else if any.
+      ruby_block.call(@else_blk) if @else_blk
+    end
+
+    # Iterate deeply on the statements.
+    def each_statement_deep(&ruby_block)
+      return to_enum(:each_statement_deep) unless ruby_block
+      # Recurse on the yes block.
+      @yes_blk.each_statement_deep
+      # On the elsifs.
+      @elsifs.each { |cond,statement| statement.each_statement_deep }
+      # On the else if any.
+      @else_blk.each_statement_deep if @else_blk
+      # And apply ruby_block on self.
+      ruby_block.call(self)
+    end
+
     # Convert to Ruby code.
     def to_ruby
-      res = @sequencer.clk_up + "\nif(#{@condition.to_ruby})\n#{@yes_blk.to_ruby}\n"
+      res = @sequencer.clk_up + "\nif(#{@condition.to_ruby} != 0)\n#{@yes_blk.to_ruby}\n"
       @elsifs.each do |(cond,blk)|
         res << "elsif(#{cond.to_ruby})\n#{blk.to_ruby}\n"
       end
@@ -2238,7 +2333,7 @@ module RubyHDL::High
   end
 
   # Describes a SW implementation of a loop statement.
-  class Sloop
+  class Sloop < Statement
     # Create a new infinite loop statement in sequencer +sequencer+ 
     # with +ruby_block+ for generating the block that is taken.
     def initialize(sequencer, &ruby_block)
@@ -2246,6 +2341,22 @@ module RubyHDL::High
       @blk = Sblock.new(sequencer,&ruby_block)
     end
 
+    # Iterate on the statements.
+    def each_statement(&ruby_block)
+      return to_enum(:each_statement) unless ruby_block
+      # Apply ruby_block on the block.
+      ruby_block.call(@blk)
+    end
+
+    # Iterate deeply on the statements.
+    def each_statement_deep(&ruby_block)
+      return to_enum(:each_statement_deep) unless ruby_block
+      # Recurse on the block.
+      @blk.each_statement_deep
+      # And apply ruby_block on self.
+      ruby_block.call(self)
+    end
+
     # Convert to Ruby code.
     def to_ruby
       return "loop do\n#{@blk.to_ruby}\n#{@sequencer.clk_up}\nend"
@@ -2258,7 +2369,7 @@ module RubyHDL::High
   end
 
   # Describes a SW implementation of a while statement.
-  class Swhile
+  class Swhile < Statement
     # Create a new while statement in sequencer +sequencer+ 
     # with +cond+ condition and +ruby_block+
     # for generating the block that is taken while the condition is met.
@@ -2268,6 +2379,22 @@ module RubyHDL::High
       @yes_blk = Sblock.new(sequencer,&ruby_block)
     end
 
+    # Iterate on the statements.
+    def each_statement(&ruby_block)
+      return to_enum(:each_statement) unless ruby_block
+      # Apply ruby_block on the block.
+      ruby_block.call(@yes_blk)
+    end
+
+    # Iterate deeply on the statements.
+    def each_statement_deep(&ruby_block)
+      return to_enum(:each_statement_deep) unless ruby_block
+      # Recurse on the yes block.
+      @yes_blk.each_statement_deep
+      # And apply ruby_block on self.
+      ruby_block.call(self)
+    end
+
     # Convert to Ruby code.
     def to_ruby
       return @sequencer.clk_up + 
@@ -2281,7 +2408,7 @@ module RubyHDL::High
   end
 
   # Describes a SW implementation of a step statement.
-  class Step
+  class Step < Statement
     # Create a new step statement in sequencer +sequencer+.
     def initialize(sequencer)
       @sequencer = sequencer
@@ -2299,7 +2426,7 @@ module RubyHDL::High
   end
 
   # Describes a SW implementation of a break statement.
-  class Sbreak
+  class Sbreak < Statement
     # Create a new break statement in sequencer +sequencer+.
     def initialize(sequencer)
       @sequencer = sequencer
@@ -2317,7 +2444,7 @@ module RubyHDL::High
   end
 
   # Describes a SW implementation of a continue statement.
-  class Scontinue
+  class Scontinue < Statement
     # Create a new break statement in sequencer +sequencer+.
     def initialize
       @sequencer = sequencer
@@ -2334,10 +2461,32 @@ module RubyHDL::High
     end
   end
 
+  # Describes a SW implementation of a return statement.
+  class Sreturn < Statement
+    attr_reader :value
+
+    # Create a new break statement in sequencer +sequencer+ 
+    # returning value +val+.
+    def initialize(sequencer,val)
+      @sequencer = sequencer
+      @value = val
+    end
+
+    # Convert to Ruby code.
+    def to_ruby
+      return @sequencer.clk_up + "\nreturn #{@value.to_ruby}"
+    end
+
+    # Convert to Ruby code.
+    def to_c
+      return @sequencer.clk_up_c + "\nreturn #{val.to_c};"
+    end
+  end
+
   # Describes a SW implementation of a terminate statement.
-  class Sterminate
+  class Sterminate < Statement
     # Create a new break statement in sequencer +sequencer+.
-    def initialize
+    def initialize(sequencer)
       @sequencer = sequencer
     end
 
@@ -2355,13 +2504,25 @@ module RubyHDL::High
   end
 
   # Describes a SW synchronization of a signal.
-  class Sync
-    def initialize
+  class Sync < Statement
+    def initialize(sequencer)
+      @sequencer = sequencer
     end
 
     # Convert to Ruby code.
     def to_ruby
-      return "Fiber.yield"
+      # Update the inputs and outputs.
+      res = ""
+      RubyHDL::High.global_sblock.each_signal do |signal|
+        case signal.dir
+        when :input
+          res << signal.to_ruby + " = RubyHDL.#{signal.name}\n"
+        when :output
+          res << "RubyHDL.#{signal.name} = " + signal.to_ruby + "\n"
+        end
+      end
+      res << "Fiber.yield"
+      return res
     end
 
     # Convert to C code.
@@ -2397,6 +2558,19 @@ module RubyHDL::High
       return self
     end
 
+    # Iterate on the statements.
+    def each_statement(&ruby_block)
+      return to_enum(:each_statement) unless ruby_block
+      # By default nothing to do.
+    end
+
+    # Iterate deeply on the statements.
+    def each_statement_deep(&ruby_block)
+      return to_enum(:each_statement_deep) unless ruby_block
+      # Just apply ruby_block on self.
+      ruby_block.call(self)
+    end
+
     # Execute a ruby code block for +ruby_block+.
     def self.call(id)
       # puts "id=#{id}"
@@ -2421,27 +2595,39 @@ module RubyHDL::High
 
 
   # Describes a SW implementation of an call statement.
-  class Scall
+  class Scall < Expression
     using RubyHDL::High
 
-    # Create a new call statement in sequencer +sequencer+ for function
-    # named +name+ with arguments +args+.
-    def initialize(sequencer, name, *args)
+    # Create a new call to function named +func+ statement in 
+    # sequencer +sequencer+ with arguments +args+.
+    def initialize(func, sequencer, *args)
+      super(func.type)
       @sequencer = sequencer
-      @name = name.to_sym
+      @name = func.name
       @args = args
     end
 
+    # Iterate on the statements.
+    def each_statement(&ruby_block)
+      return to_enum(:each_statement) unless ruby_block
+      # By default nothing to do.
+    end
+
+    # Iterate deeply on the statements.
+    def each_statement_deep(&ruby_block)
+      return to_enum(:each_statement_deep) unless ruby_block
+      # Just apply ruby_block on self.
+      ruby_block.call(self)
+    end
+
     # Convert to Ruby code.
     def to_ruby
-      return @sequencer.clk_up + "\n#{name}(" + 
-        @args.map {|arg| arg.to_ruby}.join(",") + ")"
+      return "__#{@name}(" + @args.map {|arg| arg.to_ruby}.join(",") + ")"
     end
 
     # Convert to C code.
     def to_c
-      return @sequencer.clk_up + "\n#{name}(" + 
-        @args.map {|arg| arg.to_ruby}.join(",") + ");"
+      return "\n__#{name}(" + @args.map {|arg| arg.to_ruby}.join(",") + ");"
     end
 
     # Create an iterator for a given method +meth+.
@@ -2778,7 +2964,7 @@ module RubyHDL::High
 
 
   # Describes a SW implementation of an iterator statement.
-  class Siter
+  class Siter < Statement
     using RubyHDL::High
 
     # Create a new iteration statement in sequencer +sequencer+ 
@@ -2801,12 +2987,31 @@ module RubyHDL::High
     end
     alias_method :each, :each_command
 
+    # Iterate on the statements.
+    def each_statement(&ruby_block)
+      return to_enum(:each_statement) unless ruby_block
+      # Apply ruby_block on the block.
+      @blk.each_statement(&ruby_block)
+    end
+
+    # Iterate deeply on the statements.
+    def each_statement_deep(&ruby_block)
+      return to_enum(:each_statement_deep) unless ruby_block
+      # Recurse on the yes block.
+      @blk.each_statement_deep
+      # And apply ruby_block on self.
+      ruby_block.call(self)
+    end
+
     # Convert to Ruby code.
     def to_ruby
       # puts "to_ruby with blk=#{@blk} commands=#{@commands}"
       res = @sequencer.clk_up + "\n" + 
         @commands.map { |command| command.to_ruby }.join(".") 
-      return res + " do\n#{@blk.to_ruby}\n#{@sequencer.clk_up}\nend"
+      return res + " do" + 
+        (@blk.each_arg.any? ? 
+         "|#{@blk.each_arg.map(&:to_ruby).join(",")}|" : "") + 
+        "\n#{@blk.to_ruby}\n#{@sequencer.clk_up}\nend"
     end
 
     # Convert to C code.
@@ -3158,14 +3363,26 @@ module RubyHDL::High
   # Describes a SW implementation of a signal.
   class SignalI < Expression
     using RubyHDL::High
-    attr_reader :type, :name #, :content
+    attr_reader :name, :type, :dir
     # Create a new signal with type +type+ and name +name+.
-    def initialize(type,name)
-      @type = type.to_type
+    def initialize(name,type,dir)
       @name = name.to_sym
+      @type = type.to_type
+      @dir = dir.to_sym
       # Compute the mask for adjusting the value to the type.
       @mask = (2 ** @type.width)-1
       @sign = 2 ** (@type.width-1)
+      @global = "" # The global indicator: empty or '$'
+    end
+
+    # Tell if the signal is global or not.
+    def global?
+      return @global == "$"
+    end
+
+    # Set the signal to be a global.
+    def global!
+      @global = "$"
     end
 
     # Tell if the signal is an array.
@@ -3175,7 +3392,7 @@ module RubyHDL::High
 
     # Convert to Ruby code.
     def to_ruby
-      return "__" + self.name.to_s
+      return @global + "__" + self.name.to_s
     end
 
     # Convert to C code.
@@ -3183,7 +3400,11 @@ module RubyHDL::High
 
     # Check if a value is defined for the signal.
     def value?
-      return TOPLEVEL_BINDING.local_variable_defined?(self.to_ruby)
+      if global? then
+        return global_variables.include?(self.to_ruby)
+      else
+        return TOPLEVEL_BINDING.local_variable_defined?(self.to_ruby)
+      end
     end
 
     # Gets the value of the signal.
@@ -3236,7 +3457,6 @@ module RubyHDL::High
     end
   end
 
-
   # Describes a SW implementation of a block.
   class Sblock < SblockTop
     using RubyHDL::High
@@ -3254,9 +3474,11 @@ module RubyHDL::High
       # Push the new sblock on top of the stack.
       RubyHDL::High.push_sblock(self)
       # Make signals from the arguments of the ruby block.
+      # unsigned 32-bit integers by default.
       @args = []
       ruby_block.parameters.each do |typ,arg|
-        @args << SignalI.new(Void,arg)
+        # @args << SignalI.new(arg,Void,:inner)
+        @args << SignalI.new(arg,bit[32],:inner)
       end
       # Fill it.
       self.instance_exec(*@args,&ruby_block)
@@ -3277,6 +3499,21 @@ module RubyHDL::High
     end
     alias_method :<<, :add
 
+    # Iterate on the statements.
+    def each_statement(&ruby_block)
+      return to_enum(:each_statement) unless ruby_block
+      @statements.each { |statement| ruby_block(statement) }
+    end
+
+    # Iterate deeply on the statements.
+    def each_statement_deep(&ruby_block)
+      return to_enum(:each_statement_deep) unless ruby_block
+      @statements.each do |statement|
+        statement.each_statement_deep(&ruby_block)
+        ruby_block(statement)
+      end
+    end
+
     # Delete a statement.
     def delete(statement)
       @statements.delete(statement)
@@ -3292,14 +3529,20 @@ module RubyHDL::High
       return @statements[-1]
     end
 
+    # Iterate on the arguments if any.
+    def each_arg(&ruby_block)
+      return to_enum(:each_arg) unless ruby_block
+      @args.each(&ruby_block)
+    end
 
     # Convert to Ruby code.
     def to_ruby
       res = ""
-      # Generate the arguments if any.
-      if @args.any? then
-        res = "|#{@args.map(&:to_ruby).join(",")}|\n"
-      end
+      # The arguments are ignored, as they are handled in SfunctionT.
+      # # Generate the arguments if any.
+      # if @args.any? then
+      #   res = "|#{@args.map(&:to_ruby).join(",")}|\n"
+      # end
       # Generate the statements.
       res += @statements.map do |stmnt|
         stmnt.to_ruby + "\n"
@@ -3343,6 +3586,11 @@ module RubyHDL::High
       self << RubyHDL::High::Scontinue.new(@sequencer)
     end
 
+    # Create a return statement.
+    def sreturn(val)
+      self << RubyHDL::High::Sreturn.new(@sequencer,val)
+    end
+
     # Terminates the sequencer.
     def sterminate
       self << RubyHDL::High::Sterminate.new(@sequencer)
@@ -3390,13 +3638,26 @@ module RubyHDL::High
       self << expr.seach.with_index(&ruby_block)
     end
 
+    # Implements a multiplexer.
+    def mux(cond, *choices)
+      return Select.new(choices[0].type,:mux,cond,*choices)
+    end
+
+    # Displays a string for debugging purpose.
+    def hprint(*args)
+      args.each do |arg|
+        arg = arg.to_value if arg.is_a?(RubyHDL::High::Expression)
+        print arg
+      end
+    end
+
     # The SW-specific statements and expressions.
     
     # Mark a synchronisation.
     # For software only: stop the current sequencer for allowing
     # sharing of variables with other ones.
     def sync
-      self << RubyHDL::High::Sync.new
+      self << RubyHDL::High::Sync.new(@sequencer)
     end
 
     # Some arbirary Ruby code as a string +str+ or as a proc
@@ -3415,23 +3676,36 @@ module RubyHDL::High
   # Describes a SW implementation of a sequencer function.
   class SfunctionT
     using RubyHDL::High
-    attr_reader :name
+    attr_reader :name, :type
     # Create a new named +name+ with arguments +args+ and 
     # executing the content of block +sblock+
-    def initialize(type,name,sblock,*args)
+    def initialize(name,sblock,*args)
       @name = name.to_sym
       @args  = args
       @blk = sblock
+      @type = self.make_return_type(@blk)
+    end
+
+    # Compute the return type from current sblock +sblock+
+    def make_return_type(sblock)
+      # Locate a return statement.
+      sblock.each_statement_deep do |statement|
+        if statement.is_a?(RubyHDL::High::Sreturn) then
+          return statement.value.type
+        end
+      end
+      # No return, so void type.
+      return RubyHDL::High::Void
     end
 
     # Convert to Ruby code.
     def to_ruby
-      return "def #{name}(#{@args.map {|arg| arg.to_ruby}.join(",")}\n#{@blk.to_ruby}\nend\n"
+      return "def __#{name}(#{@args.map {|arg| "__" + arg.to_ruby}.join(",")})\n#{@blk.sequencer.clk_up}\n#{@blk.to_ruby}\nend\n"
     end
 
     # Convert to C code.
     def to_c
-      return "unsigned long long #{name}(#{@args.map {|arg| "unsigned long long " + arg.to_c}.join(",")} {\n#{@blk.to_c}\n}\n"
+      return "unsigned long long __#{name}(#{@args.map {|arg| "unsigned long long " + arg.to_c}.join(",")} {\n#{@blk.sequencer.clk_up_c}\n#{@blk.to_c}\n}\n"
     end
   end
 
@@ -3464,7 +3738,7 @@ module RubyHDL::High
       # Create a set of sfunction used in the sequencer.
       @sfunctions = {}
       # Create the main block.
-      @sblock = RubyHDL::High::Sblock.new(self,&ruby_block)
+      @blk = RubyHDL::High::Sblock.new(self,&ruby_block)
       # Build the Ruby code.
       @source = ""
       @code = nil
@@ -3491,11 +3765,20 @@ module RubyHDL::High
       this = self
       @source = <<-BUILD
 #{RubyHDL::High.global_sblock.each_signal.map do |signal|
-      signal.to_ruby + " ||= " + 
-        (signal.array? ? "[]" : signal.value? ? signal.value.inspect : "nil")
+      # puts "for signal=#{signal.name} with type=#{signal.type}"
+      case signal.dir
+      when :input
+        signal.to_ruby + " = RubyHDL.#{signal.name}"
+      else
+        signal.to_ruby + " ||= " + 
+        (signal.array? ? "[]" : signal.value? ? signal.value.inspect : "0")
+      end
 end.join("\n")}
+
+#{@sfunctions.map {|n,f| f.to_ruby }.join("\n\n")}
+
 Fiber.new do
-#{@sblock.to_ruby}
+#{@blk.to_ruby}
 end
 BUILD
       # puts "building code_txt=" + @source
@@ -3569,10 +3852,22 @@ BUILDC
   # Create a new sequencer block, with clock counter +clk+ and
   # run control +start+
   def sequencer(clk = nil, start = nil, &ruby_block)
+    # Ensure the clock is global.
+    clk.global! if clk
     return SequencerT.new(clk,start,&ruby_block)
   end
 
-  # Create a 1-bit signal.
+  # Create a 1-bit input signal.
+  def input(*names)
+    return [1].input(*names)
+  end
+
+  # Create a 1-bit output signal.
+  def output(*names)
+    return [1].output(*names)
+  end
+
+  # Create a 1-bit inner signal.
   def inner(*names)
     return [1].inner(*names)
   end
@@ -3581,31 +3876,36 @@ BUILDC
   def sdef(name,&ruby_block)
     name = name.to_sym
     # Get the arguments of the ruby_block.
-    args = ruby_block.parameters.map {|typ,name| name.to_s }
-    # Register the call to the function.
-    RubyHDL::High.register(name.to_sym) do |args|
-      cur_seq = Ruby::HDL::High.top_sblock.sequencer
-      unless cur_seq.sfunction?(name) then
-        # Need to create a new sfunction.
-        # Push a new empty sblock for building the function.
-        RubyHDL::High.push_sblock(SblockTop.new)
-        args.each do |arg|
-          RubyHDL::High.top_sblock.make_inners(Void,arg.to_sym)
-        end
+    block_args = ruby_block.parameters.map {|typ,name| name.to_s }
+    # Create function.
+    cur_sblock = RubyHDL::High.top_sblock
+    # Register the call.
+    cur_sblock.register(name.to_sym) do |*args|
+      # Create the function.
+      # Get the current sequencer.
+      cur_seq = RubyHDL::High.top_sblock.sequencer
+      # Get the function from the sequencer if any.
+      function = cur_seq.sfunction(name)
+      unless function then
+        # There were no function for the sequencer, create it.
         # Execute the ruby block in a sequencer environment for building
         # the sblock.
         sblock = Sblock.new(cur_seq,&ruby_block)
-        RubyHDL::High.pop_sblock
+        # Create the arguments.
+        block_args.each_with_index do |block_arg,i|
+          # puts "args[#{i}]=(#{args[i].name},#{args[i].type})"
+          sblock.make_inners(args[i].type,block_arg.to_sym)
+        end
         # Create the function.
-        function = SfunctionT.new(name,args,sblock)
-        # Add it to the sequencer.
-        cur_seq.add_sfunction(name)
+        function = SfunctionT.new(name,sblock,*block_args)
+        # Add it to the current sequencer.
+        cur_seq.add_sfunction(name,function)
       end
-      Scall.new(cur_seq,name,args)
+      # And create the call
+      Scall.new(function,cur_seq,*args)
     end
   end
 
-
 end