HDLRuby 3.7.1 → 3.7.3

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,15 +54,51 @@ 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(",")}"
+      # puts "make_inners 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(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
 
@@ -151,22 +189,44 @@ module RubyHDL::High
   # end
 
 
+  # RUBY_OPERATOR = {
+  #   # Unary operators.
+  #   :"-@" => "-(%s)", :"+@" => "+(%s)", :"~" => "~(%s)",
+  #   :abs => "(%s).abs",
+  #   :boolean => "%s", :bit => "%s", 
+  #   :signed => "%s", :unsigned => "(%s) & 0xFFFFFFFFFFFFFFFF",
+
+  #   # Binary operators.
+  #   :"+" => "(%s)+(%s)", :"-" => "(%s)-(%s)",  :"*" => "(%s)*(%s)",
+  #   :"/" => "(%s)/(%s)", :"%" => "(%s)%%(%s)", :"**" => "(%s)**(%s)",
+  #   :"&" => "(%s)&(%s)", :"|" => "(%s)|(%s)",  :"^" => "(%s)^(%s)",
+  #   :"<<" => "(%s)<<(%s)", :">>" => "(%s)>>(%s)",
+  #   :"==" => "(%s)==(%s)", :"!=" => "(%s)!=(%s)",
+  #   :"<" => "(%s)<(%s)", :">" => "(%s)>(%s)", 
+  #   :"<=" => "(%s)<=(%s)",:">=" => "(%s)>=(%s)"
+  # }
+
   # The translation of operators into Ruby code.
   RUBY_OPERATOR = {
     # Unary operators.
-    :"-@" => "-(%s)", :"+@" => "+(%s)", :"~" => "~(%s)",
-    :abs => "(%s).abs",
-    :boolean => "%s", :bit => "%s", 
-    :signed => "%s", :unsigned => "(%s) & 0xFFFFFFFFFFFFFFFF",
+    :"-@" => "-(%{l})", :"+@" => "+(%{l})", :"~" => "~(%{l})",
+    :abs => "(%{l}).abs",
+    :boolean => "%{l}", :bit => "%{l}", 
+    :signed => "%{l}", :unsigned => "(%{l}) & 0xFFFFFFFFFFFFFFFF",
 
     # Binary operators.
-    :"+" => "(%s)+(%s)", :"-" => "(%s)-(%s)",  :"*" => "(%s)*(%s)",
-    :"/" => "(%s)/(%s)", :"%" => "(%s)%%(%s)", :"**" => "(%s)**(%s)",
-    :"&" => "(%s)&(%s)", :"|" => "(%s)|(%s)",  :"^" => "(%s)^(%s)",
-    :"<<" => "(%s)<<(%s)", :">>" => "(%s)>>(%s)",
-    :"==" => "(%s)==(%s)", :"!=" => "(%s)!=(%s)",
-    :"<" => "(%s)<(%s)", :">" => "(%s)>(%s)", 
-    :"<=" => "(%s)<=(%s)",:">=" => "(%s)>=(%s)"
+    :"+" => "(%{l})+(%{r})", :"-" => "(%{l})-(%{r})", 
+    :"*" => "(%{l})*(%{r})", :"/" => "(%{l})/(%{r})", 
+    :"%" => "(%{l})%%(%{r})", :"**" => "(%{l})**(%{r})",
+    :"&" => "(%{l})&(%{r})", :"|" => "(%{l})|(%{r})", 
+    :"^" => "(%{l})^(%{r})",
+    :"<<" => "(%{l})<<(%{r})", :">>" => "(%{l})>>(%{r})",
+    :"==" => "((%{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.
@@ -596,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
@@ -617,6 +693,8 @@ module RubyHDL::High
     using RubyHDL::High
     include HDLRuby::Tprocess
 
+    attr_reader :name
+
     # Type creation.
 
     # Creates a new type named +name+.
@@ -685,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.
@@ -707,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.
@@ -717,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.
@@ -780,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.
@@ -835,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.
@@ -985,12 +1063,30 @@ module RubyHDL::High
 
   # The signed bit type.
   Signed = define_type(:signed)
+  class << Signed
+    # Tells if the type signed.
+    def signed?
+      return true
+    end
+  end
 
   # The unsigned bit type.
   Unsigned = define_type(:unsigned)
+  class << Unsigned
+    # Tells if the type unsigned.
+    def unsigned?
+      return true
+    end
+  end
 
   # The float bit type
   Float = define_type(:float)
+  class << Float
+    # Tells if the type signed.
+    def signed?
+      return true
+    end
+  end
 
   # The string type
   StringT = define_type(:string)
@@ -1036,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(':')}",
@@ -1081,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
 
@@ -1295,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
@@ -1345,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
@@ -1414,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
 
@@ -1435,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
 
@@ -1463,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
@@ -1823,11 +1917,13 @@ module RubyHDL::High
       super(type)
       @operator = operator.to_sym
       @child = child.to_expr
+      @mask = (2 ** @type.width)-1
     end
 
     # Convert to Ruby code.
     def to_ruby
-      return RUBY_OPERATOR[@operator] % @child.to_ruby
+      # return RUBY_OPERATOR[@operator] % @child.to_ruby
+      return RUBY_OPERATOR[@operator] % { l: @child.to_ruby }
     end
 
     # Convert to C code.
@@ -1845,11 +1941,23 @@ module RubyHDL::High
       @operator = operator.to_sym
       @left = left.to_expr
       @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.
+      @sign_fix = ""
+      if type.signed? then
+        @sign_fix = " ^ #{2**(@type.width-1)}"
+      end
     end
 
     # Convert to Ruby code.
     def to_ruby
-      return RUBY_OPERATOR[@operator] % [ @left.to_ruby, @right.to_ruby ]
+      # return RUBY_OPERATOR[@operator] % [ @left.to_ruby, @right.to_ruby ]
+      return RUBY_OPERATOR[@operator] % 
+        { l: @left.to_ruby, r: @right.to_ruby, m: @mask, s: @sign_fix }
     end
 
     # Convert to C code.
@@ -2062,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
@@ -2132,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.
@@ -2159,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
@@ -2185,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)
@@ -2193,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"
@@ -2205,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.
@@ -2215,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 + 
@@ -2228,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
@@ -2246,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
@@ -2264,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
@@ -2281,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
 
@@ -2302,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.
@@ -2344,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}"
@@ -2368,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+.
@@ -2725,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+ 
@@ -2748,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.
@@ -3105,11 +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.
@@ -3119,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.
@@ -3127,12 +3400,40 @@ 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.
     def value
-      return TOPLEVEL_BINDING.eval(self.to_ruby)
+      # return TOPLEVEL_BINDING.eval(self.to_ruby)
+      res = TOPLEVEL_BINDING.eval(self.to_ruby)
+      if res.is_a?(Integer) then
+        res = res & @mask
+        if @type.signed? then
+          if res & @sign != 0 then
+            return res - (@mask+1)
+          end
+        end
+      end
+      return res
+    end
+
+    # Generate a Ruby/C string code for accessing the value of the 
+    # signal with proper bit width and sign.
+    def value_text
+      unless self.array? then
+        if @type.signed? then
+          return "(#{self.to_ruby} & #{@sign} != 0 ? #{self.to_ruby} & #{@mask} - #{@mask+1} : #{self.to_ruby} & #{@mask})"
+        else
+          return "(#{self.to_ruby} & #{@mask})"
+        end
+      else
+        return self.to_ruby
+      end
     end
 
     # Sets the value of the signal.
@@ -3156,7 +3457,6 @@ module RubyHDL::High
     end
   end
 
-
   # Describes a SW implementation of a block.
   class Sblock < SblockTop
     using RubyHDL::High
@@ -3174,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)
@@ -3197,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)
@@ -3212,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"
@@ -3263,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)
@@ -3272,16 +3600,19 @@ module RubyHDL::High
     def sif(cond, &ruby_block)
       self << RubyHDL::High::Sif.new(@sequencer,cond,&ruby_block)
     end
+    alias_method :hif, :sif
 
     # Create a sequential elsif statement on +cond+.
     def selsif(cond, &ruby_block)
       self.last_statement.selsif(&ruby_block)
     end
+    alias_method :helsif, :selsif
 
     # Create a sequential else statement.
     def selse(&ruby_block)
       self.last_statement.selse(&ruby_block)
     end
+    alias_method :helse, :selse
 
     # Wait a given condition.
     def swait(cond)
@@ -3313,7 +3644,7 @@ module RubyHDL::High
     # 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
@@ -3321,29 +3652,47 @@ module RubyHDL::High
     def ruby(str = nil, &ruby_block)
       self << RubyHDL::High::Ruby.new(str,&ruby_block)
     end
+
+    # Some arbitrary code whose text is to add direction.
+    def text(str)
+      self << str.to_s
+    end
   end
 
 
   # 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
 
@@ -3376,7 +3725,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
@@ -3403,15 +3752,24 @@ 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
-      @code = TOPLEVEL_BINDING.eval(@source)
+      self.reset!
     end
 
     # Get the Ruby code.
@@ -3462,6 +3820,11 @@ BUILDC
     end
     alias_method :call, :resume
 
+    # Resets the sequencer.
+    def reset!
+      @code = TOPLEVEL_BINDING.eval(@source)
+    end
+
     # Check is the sequencer can still be resumed.
     def alive?
       @code.alive?
@@ -3476,38 +3839,60 @@ 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 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
+
   # Create a new function named +name+, built using block +ruby_block+.
   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