Module: RubyHDL::High

Defined in:
lib/HDLRuby/std/sequencer_sw.rb

Defined Under Namespace

Modules: SEnumerable Classes: Binary, Expression, Ref, RefIndex, RefName, RefRange, Ruby, Sblock, SblockTop, Sbreak, Scall, Scontinue, Select, SequencerT, SfunctionT, Sif, SignalI, Siter, Sloop, Step, Sterminate, Swhile, Sync, Transmit, Type, TypeDef, TypeFloat, TypeGen, TypeSigned, TypeStruct, TypeTuple, TypeUnsigned, TypeVector, Unary, Value

Constant Summary collapse

SBLOCK_STACK =

The stack of SW blocks.

[ SblockTop.new ]
RUBY_OPERATOR =

The translation of operators into Ruby code.

{
  # Unary operators.
  :"-@" => "-(%{l})", :"+@" => "+(%{l})", :"~" => "~(%{l})",
  :abs => "(%{l}).abs",
  :boolean => "%{l}", :bit => "%{l}", 
  :signed => "%{l}", :unsigned => "(%{l}) & 0xFFFFFFFFFFFFFFFF",

  # Binary operators.
  :"+" => "(%{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}", 
  :"!=" => "(%{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}"
}
C_OPERATOR =

The translation of operators into C code.

{
  # 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)", :"**" => "pow((%s),(%s))",
  :"&" => "(%s)&(%s)", :"|" => "(%s)|(%s)",  :"^" => "(%s)^(%s)",
  :"<<" => "(%s)<<(%s)", :">>" => "(%s)>>(%s)",
  :"==" => "(%s)==(%s)", :"!=" => "(%s)!=(%s)",
  :"<" => "(%s)<(%s)", :">" => "(%s)>(%s)", 
  :"<=" => "(%s)<=(%s)",:">=" => "(%s)>=(%s)"
}
Void =

The void type

define_type(:void)
Bit =

The bit type.

define_type(:bit)
Signed =

The signed bit type.

define_type(:signed)
Unsigned =

The unsigned bit type.

define_type(:unsigned)
Float =

The float bit type

define_type(:float)
StringT =

The string type

define_type(:string)
@@absoluteCounter =

The absolute name counter.

-1 # The absolute name counter.
@@uniq_names = 
Set.new(Symbol.all_symbols.map {|sym| sym.to_s})

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.call_sblock(m, *args, &ruby_block) ⇒ Object

Calling a method from the stack.



123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 123

def self.call_sblock(m,*args,&ruby_block)
    SBLOCK_STACK.reverse_each do |sblock|
      if sblock.callable?(m) then
        # return sblock.callable(m,*args,&ruby_block)
        res = sblock.callable(m,*args,&ruby_block)
        return res
      end
    end
    # Method not found.
    method_missing(m,*args,&ruby_block)
end

.define_type(name) ⇒ Object

Defines a basic type +name+.



995
996
997
998
999
1000
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 995

def self.define_type(name)
  name = name.to_sym
  type = Type.new(name)
  self.send(:define_method,name) { type }
  return type
end

.global_sblock ⇒ Object 



106
107
108
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 106

def self.global_sblock
  SBLOCK_STACK[0]
end

.pop_sblock ⇒ Object 



118
119
120
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 118

def self.pop_sblock
  SBLOCK_STACK.pop
end

.push_sblock(sblock) ⇒ Object 



114
115
116
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 114

def self.push_sblock(sblock)
  SBLOCK_STACK << sblock
end

.top_sblock ⇒ Object 



110
111
112
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 110

def self.top_sblock
  SBLOCK_STACK[-1]
end

.uniq_name(base = "") ⇒ Object

Generates an absolute uniq name.



23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 23

def self.uniq_name(base = "")
  @@absoluteCounter += 1
  name = base.to_s + ":#{@@absoluteCounter}"
  if @@uniq_names.include?(name) then
    # The symbol exists, try again.
    return self.uniq_name
  else
    @@uniq_names.add(name)
    return name.to_sym
  end
end

Instance Method Details

#inner(*names) ⇒ Object

Create a 1-bit signal.



3576
3577
3578
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3576

def inner(*names)
  return [1].inner(*names)
end

#sdef(name, &ruby_block) ⇒ Object

Create a new function named +name+, built using block +ruby_block+.



3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3581

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
      # 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 function.
      function = SfunctionT.new(name,args,sblock)
      # Add it to the sequencer.
      cur_seq.add_sfunction(name)
    end
    Scall.new(cur_seq,name,args)
  end
end

#sequencer(clk = nil, start = nil, &ruby_block) ⇒ Object

Create a new sequencer block, with clock counter +clk+ and run control +start+



3571
3572
3573
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3571

def sequencer(clk = nil, start = nil, &ruby_block)
  return SequencerT.new(clk,start,&ruby_block)
end

#struct(content) ⇒ Object

Creates an unnamed structure type from a +content+.



1642
1643
1644
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1642

def struct(content)
  return TypeStruct.new(:"",:little,content)
end

#typedef(name, &ruby_block) ⇒ Object

Declares a high-level generic type named +name+, and using +ruby_block+ for construction.



1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1650

def typedef(name, &ruby_block)
  # Ensure there is a block.
  ruby_block = proc {} unless block_given?
  type = TypeGen.new(name,&ruby_block)
  define_singleton_method(name.to_sym) do |*args|
    if (args.size < ruby_block.arity) then
      # Not enough arguments get generic type as is.
      type
    else
      # There are arguments, specialize the type.
      gtype = type.generate(*args)
      # And add it as a local type of the system.
      RubyHDL::High.top_sblock.add_type(gtype)
      gtype
    end
  end
end