ruby_rtl 0.0.1

data/lib/ruby_rtl/ast_builder.rb

@@ -0,0 +1,183 @@
+module RubyRTL
+
+  class ASTBuilder
+
+    attr_accessor :ast
+
+    # no 'initialize' :
+    #  - @ast is not initialized here
+    #  - this allows to avoid calling "super" in every circuit.
+    #
+    #   - dont forget the parenthesis !
+
+    def input *arg
+      @ast||=Root.new
+      process_sig_decl(:input,*arg)
+    end
+
+    def output *arg
+      @ast||=Root.new
+      @last=@ast
+      process_sig_decl(:output,*arg)
+    end
+
+      # define a type
+    def typedef h
+      @ast||=Root.new
+      @last=@ast
+      name_sym,definition=h.first
+      @ast.decls << decl=TypeDecl.new(name_sym,definition)
+      @last=decl
+      $typedefs||={} # Global var !
+      $typedefs[name_sym]=definition
+      decl
+    end
+
+    def wire *arg
+      process_sig_decl(:sig,*arg)
+    end
+
+    alias :signal :wire
+
+    def comment str
+      (@last.comments||=[]) << Comment.new(str)
+    end
+
+    def component name_obj_or_class_h
+      comp_name,obj_or_klass=name_obj_or_class_h.first
+      comp_name=comp_name.to_sym if comp_name.is_a? String
+      case klass=comp=obj_or_klass
+      when Class
+        comp=klass.new # but no parameters :-(
+      end
+      cname="@#{comp_name}"
+      instance_variable_set(cname,comp)
+      self.class.__send__(:attr_accessor, comp_name)
+      @ast.body << CompDecl.new(comp_name,comp)
+      comp
+    end
+
+    # syntax : ASSIGN( y <= e), instead of ASSIGN(y,e)
+    def assign(var_expr_leq)
+      @ast||=Root.new
+      var,expr=var_expr_leq.lhs,var_expr_leq.rhs
+      @ast.body << Assign.new(var,expr)
+    end
+
+    def differential_ast &block
+      before=@ast.body.stmts.clone
+      instance_eval(&block)
+      after=@ast.body.stmts
+      diff=after-before
+      @ast.body.stmts=before
+      return diff
+    end
+
+    def If(cond,&block)
+      diff=differential_ast(&block)
+      @ast.body << If.new(cond,Body.new(diff))
+    end
+
+    def Elsif(cond,&block)
+      diff=differential_ast(&block)
+      @ast.body << Elsif.new(cond,Body.new(diff))
+    end
+
+    def Else(&block)
+      diff=differential_ast(&block)
+      @ast.body << Else.new(Body.new(diff))
+    end
+
+    # here, we need a trick to evaluate the block.
+    # we ask the current ast builder object to evaluate
+    # the block, in its current context.
+    # We then try to find the difference between ast before and after
+    # the evaluation.
+    def combinatorial(label=nil,&block)
+      diff=differential_ast(&block)
+      @ast.body << Combinatorial.new(name,Body.new(diff))
+    end
+
+    alias :comb :combinatorial
+
+    def sequential(label=nil,&block)
+      @has_sequential_statements=true
+      diff=differential_ast(&block)
+      @ast.body << Sequential.new(label,Body.new(diff))
+    end
+
+    alias :seq :sequential
+
+    def name
+      self.class.to_s
+    end
+    # === fsm stuff
+    def fsm name, &block
+      @has_sequential_statements=true
+      diff=differential_ast(&block)
+      @ast.body << Fsm.new(name,Body.new(diff))
+    end
+
+    def state name, &block
+      @has_sequential_statements=true
+      diff=differential_ast(&block)
+      @ast.body << State.new(name,Body.new(diff))
+    end
+
+    def next_state name
+      @ast.body << Next.new(name)
+    end
+
+    private
+    def process_sig_decl kind,*arg
+      case arg
+      when String
+        decl_sig(kind,vname=arg.to_sym,type=:bit)
+      when Symbol
+        decl_sig(kind,vname=arg,type=:bit)
+      when Array
+        # strange ! recursivity seems to fail
+        # output(element) # FAILS.
+        arg.each do |element|
+          case element
+          when String
+            decl_sig(kind,vname=element.to_sym,type=:bit)
+          when Symbol
+            decl_sig(kind,vname=element,type=:bit)
+          when Hash
+            element.each do |vname,type|
+              decl_sig(kind,vname,type)
+            end
+          else
+            "ERROR : wrong output declaration in list : '#{arg}'"
+          end
+        end
+      when Record
+        decl_sig(:input,vname=arg,type)
+      else
+        raise "ERROR : wrong input declaration '#{arg}'"
+      end
+    end
+
+    def decl_sig kind,vname_sym,type=:bit
+      @ast||=Root.new
+      klass=Object.const_get(kind.capitalize)
+      io=klass.new(vname_sym,type)
+      vname="@#{vname_sym}"
+      instance_variable_set(vname, io)
+      self.class.__send__(:attr_accessor, vname_sym)
+      @ast.decls << sig=SigDecl.new(vname_sym.to_s,io)
+      sig
+    end
+
+    def Case(arg,&block)
+      diff=differential_ast(&block)
+      @ast.body << Case.new(arg,Body.new(diff))
+    end
+
+    def When(arg,&block)
+      diff=differential_ast(&block)
+      @ast.body << When.new(arg,Body.new(diff))
+    end
+  end
+end

data/lib/ruby_rtl/ast_printer.rb

@@ -0,0 +1,85 @@
+module RubyRTL
+
+  class ASTPrinter
+
+    attr_accessor :code,:nodes_decl,:nodes_cnx
+
+    def run ast,suffix=nil
+      puts "[+] printing ast in dot file"
+      @verbose=false
+      @nodes_decl=Code.new
+      @nodes_cnx=Code.new
+      @printed_cnx={} #Cosmetic ! to keep track of already printed cnx source->sink
+      @code=Code.new
+      code << "digraph G {"
+      code.indent=2
+      code << "ordering=out;"
+      code << "ranksep=.4;"
+      code << "bgcolor=\"lightgrey\";"
+      code.newline
+      code << "node [shape=box, fixedsize=false, fontsize=12, fontname=\"Helvetica-bold\", fontcolor=\"blue\""
+      code << "       width=.25, height=.25, color=\"black\", fillcolor=\"white\", style=\"filled, solid, bold\"];"
+      code << "edge [arrowsize=.5, color=\"black\", style=\"bold\"]"
+      @visited=[]
+      process(ast)
+      code << @nodes_decl
+      code << @nodes_cnx
+      code.indent=0
+      code << "}"
+      clean(code)
+      dot_filename="#{ast.name}_ast#{suffix}.dot"
+      File.open(dot_filename,'w'){|f| f.puts code.finalize}
+    end
+
+    def process node,level=1
+      kname=node.class.name.split("::")[1] || "#{node.class}"
+      id=node.object_id
+      indent=" "*level
+
+      #puts indent+"processing #{node}"
+      (nodes_decl << "#{id} [label=\"#{kname}\"]")
+      unless @visited.include?(id)
+        node.instance_variables.each{|vname|
+          #puts indent+"-"+vname.to_s
+          ivar=node.instance_variable_get(vname)
+          vname=vname.to_s[1..-1]
+          if ivar
+            case ivar
+            when Array
+              ivar.each_with_index{|e,idx|
+                sink=process(e,level+1)
+                @printed_cnx[id]||=[]
+                nodes_cnx << "#{id} -> #{sink} [label=\"#{vname}[#{idx}]\"]" if not @printed_cnx[id].include? sink
+                @printed_cnx[id] << sink
+              }
+            when Symbol,Integer,String
+              val=ivar.to_s
+              sink="#{ivar.object_id}"
+              nodes_decl << "#{sink} [label=\"#{val}\",color=\"red\"]"
+              @printed_cnx[id]||=[]
+              nodes_cnx << "#{id} -> #{sink} [label=\"#{vname}\"]" if not @printed_cnx[id].include? sink
+              @printed_cnx[id] << sink
+            else
+              sink=process(ivar,level+1)
+              @printed_cnx[id]||=[]
+              nodes_cnx << "#{id} -> #{sink} [label=\"#{vname}\"]" if not @printed_cnx[id].include? sink
+              @printed_cnx[id] << sink
+            end
+          end
+        }
+      end
+      @visited << id
+      return id
+    end
+
+    # suppress syndrom : name=""not correct""
+    def clean code
+      #puts "=> cleaning dot code"
+      code.lines.each_with_index do |line,idx|
+        if line=~/\"\"(.*)\"\"/
+          code.lines[idx].gsub!(/\"\"(.*)\"\"/,"\"#{$1}\"")
+        end
+      end
+    end
+  end
+end

data/lib/ruby_rtl/code.rb

@@ -0,0 +1,50 @@
+class Code
+
+  attr_accessor :indent,:lines
+
+  def initialize str=nil
+    @lines=[]
+    (@lines << str) if str
+    @indent=0
+  end
+
+  def size
+    @lines.size
+  end
+
+  def <<(thing)
+    if (code=thing).is_a? Code
+      code.lines.each do |line|
+        @lines << " "*@indent+line.to_s
+      end
+    elsif thing.is_a? Array
+      thing.each do |kode|
+        @lines << kode
+      end
+    elsif thing.nil?
+    else
+      @lines << " "*@indent+thing.to_s
+    end
+  end
+
+  def finalize
+    return @lines.join("\n") if @lines.any?
+    ""
+  end
+
+  def newline
+    @lines << " "
+  end
+
+  def save_as filename,verbose=true,sep="\n"
+    str=self.finalize
+    File.open(filename,'w'){|f| f.puts(str)}
+    return filename
+  end
+
+  def size
+    @lines.size
+  end
+
+
+end

data/lib/ruby_rtl/compiler.rb

@@ -0,0 +1,61 @@
+require_relative 'ast_printer'
+require_relative 'dsl_printer'
+require_relative 'contextual_analyzer'
+require_relative 'type_checker'
+require_relative 'vhdl_generator'
+require_relative 'sexp_generator'
+
+module RubyRTL
+
+  class Compiler
+
+    def initialize
+      header
+      @printer=DSLPrinter.new
+      @dot_printer=ASTPrinter.new
+      @analyzer=ContextualAnalyzer.new
+      @checker=TypeChecker.new
+      @vgen=VhdlGenerator.new
+      @sexp_gen=SexpGenerator.new
+    end
+
+    def header
+      puts "RubyRTL compiler "
+    end
+
+    def compile circuit
+      print_ast(circuit)
+      analyze(circuit)
+      print_dsl(circuit)
+      type_check(circuit)
+      print_dsl(circuit)
+      generate(circuit)
+      generate_sexp(circuit)
+    end
+
+    def print_dsl circuit
+      @printer.print circuit
+    end
+
+    def print_ast circuit,file_suffix=""
+      @dot_printer.run(circuit,file_suffix)
+    end
+
+    def analyze circuit
+      @analyzer.analyze(circuit)
+    end
+
+    def type_check circuit
+      @checker.check circuit
+    end
+
+    def generate circuit
+      @vgen.generate(circuit)
+    end
+
+    def generate_sexp circuit
+      @sexp_gen.generate(circuit)
+    end
+
+  end
+end

data/lib/ruby_rtl/contextual_analyzer.rb

@@ -0,0 +1,88 @@
+require_relative 'code'
+require_relative 'visitor'
+
+module RubyRTL
+
+  class ContextualAnalyzer < Visitor
+
+    def analyze circuit
+      puts "[+] contextual analysis"
+      root=circuit.ast
+      if root
+        #root.ios.each{|io| io.accept(self)}
+        root.decls.each{|decl| decl.accept(self)}
+        root.body.accept(self)
+      end
+    end
+
+    def visitBody body,args=nil
+      #reconnect Else/Elsifs objects to their parent If
+      reconnectElseParts(body)
+      #attach comments to their adequate Ast nodes
+      attachComments(body)
+      body.stmts.each{|stmt| stmt.accept(self,args)}
+    end
+
+    def reconnectElseParts body
+      ifs=body.select{|stmt| stmt.is_a? If}
+      to_delete=[]
+      ifs.each do |if_|
+        index_if=body.stmts.index(if_)
+        do_iterate=true
+        index=index_if
+        while do_iterate
+          case elsei=body.stmts[index+1]
+          when Else
+            if_.else=elsei
+            to_delete << elsei
+            elsei.accept(self) # dont forget to visit it
+          when Elsif
+            if_.elsifs << elsei
+            to_delete << elsei
+            elsei.accept(self)
+          else
+            do_iterate=false
+          end
+          index+=1
+        end
+      end
+      to_delete.each{|stmt| body.stmts.delete(stmt)}
+    end
+
+    def attachComments body
+      #niy
+    end
+
+    def visitFsm fsm,args=nil
+      @fsm=fsm
+      @tmp_ary=[] #helper
+      puts " |-[+] visiting fsm '#{fsm.name}'"
+      # default assignements
+      fsm.default_assigns=fsm.body.select{|e| e.is_a? Assign}
+      # build a state hash : state_name => state
+      state_nodes=fsm.body.select{|e| e.is_a? State}
+      # fsm.states=states_nodes.inject({}){|hash,state| hash.merge!( state.name=> state)}
+      # build a state array
+      fsm.states=state_nodes
+      # don't forget to visit the states
+      @in_state=true
+      fsm.states.each{|state| state.accept(self)}
+      @in_state=false
+    end
+
+    def visitState state,args=nil
+      state.body.accept(self)
+    end
+
+    def visitAssign assign,args=nil
+      if @in_state
+        puts "pushing #{assign}"
+        unless @tmp_ary.include?(id=assign.lhs.object_id)
+          @tmp_ary << id
+          @fsm.assignments << assign
+        end
+      end
+    end
+
+  end
+end

data/lib/ruby_rtl/dsl.rb

@@ -0,0 +1,198 @@
+require_relative 'ast'
+require_relative 'ast_builder'
+
+module RubyRTL
+
+  def build_type arg
+    case arg
+    when Symbol
+      case sym=arg.to_s
+      when "bit"
+        sym="bit"
+        ret=BitType.new
+      when "byte"
+        ret=IntType.new(8)
+      when /\Abv(\d+)/
+        ret=BitVectorType.new($1.to_i)
+      when /\Auint(\d+)?/
+        nbits=($1 || 32).to_i
+        ret=UIntType.new(nbits)
+      when /\Aint(\d+)?/
+        nbits=($1 || 32).to_i
+        ret=IntType.new(nbits)
+      else
+        unless ret=$typedefs[arg] # global var !
+          raise "DSL syntax error : unknow type '#{sym}'"
+        end
+      end
+      $typedefs||={}
+      $typedefs[sym]||=ret
+    when Integer
+      val=arg
+      if val==1
+        name="bit"
+        ret=BitType.new if val==1
+      else
+        name="bv#{val}"
+        ret=BitVectorType.new(val)
+      end
+      $typedefs||={}
+      $typedefs[name]||=ret
+    when Hash
+      ret=arg
+    when IntType,UIntType,BitType,BitVectorType
+      ret=arg
+    else
+      raise "ERROR : DSL syntax error. build_type for #{arg} (#{arg.class})"
+    end
+    ret
+  end
+
+  class Sig < Ast
+    attr_accessor :name
+    attr_accessor :type
+    attr_accessor :subscript_of
+    attr_accessor :subsignals
+
+    def initialize name,type=:bit
+      @name=name
+      @type=build_type(type)
+    end
+
+    def treat_int(other)
+      case other
+      when Integer
+        if other >=0
+          #return UIntLit.new(other)
+          return RUIntLit.new(other)
+        else
+          #return IntLit.new(other)
+          return RIntLit.new(other)
+        end
+      else
+        return other
+      end
+    end
+
+    def |(other)
+      other=treat_int(other)
+      Binary.new(self,"|",other)
+    end
+
+    def &(other)
+      other=treat_int(other)
+      Binary.new(self,"&",other)
+    end
+
+    def ^(other)
+      other=treat_int(other)
+      Binary.new(self,"^",other)
+    end
+
+    # comparison
+    def <(other)
+      other=treat_int(other)
+      Binary.new(self,"<",other)
+    end
+
+    def <=(other)
+      other=treat_int(other)
+      Binary.new(self,"<=",other)
+    end
+
+    def >(other)
+      other=treat_int(other)
+      Binary.new(self,"<",other)
+    end
+
+    def >=(other)
+      other=treat_int(other)
+      Binary.new(self,"<=",other)
+    end
+
+    def ==(other)
+      other=treat_int(other)
+      Binary.new(self,"==",other)
+    end
+    # arith
+    def +(other)
+      other=treat_int(other)
+      Binary.new(self,"+",other)
+    end
+
+    def -(other)
+      other=treat_int(other)
+      Binary.new(self,"-",other)
+    end
+
+    def *(other)
+      other=treat_int(other)
+      Binary.new(self,"*",other)
+    end
+
+    def /(other)
+      other=treat_int(other)
+      Binary.new(self,"/",other)
+    end
+
+    def !=(other)
+      other=treat_int(other)
+      Binary.new(self,"!=",other)
+    end
+
+    # unary expressions
+    def !@
+      Unary.new("!",self)
+    end
+
+    def -@
+      Unary.new("-",self)
+    end
+
+    def [](index)
+      @indexed||={}
+      index=treat_int(index)
+      @indexed[index.to_s]||=Indexed.new(self,index,@type.type)
+    end
+
+    def coerce(other)
+      [IntLit.new(other), self]
+    end
+  end
+
+  class Indexed < Sig
+    attr_accessor :lhs,:rhs
+    def initialize lhs,rhs,type
+      super("foo",type)
+      @lhs,@rhs=lhs,rhs
+    end
+  end
+
+  def Memory size,type
+    p type=build_type(type)
+    MemoryType.new(size,type)
+  end
+
+  def Record hash
+    h={}
+    hash.each do |name,type|
+      type||=$typedefs[type]
+      type=build_type(type)
+      h[name]=type
+    end
+    RecordType.new(h)
+  end
+
+  def Struct hash
+    Record(hash) # call to method Record
+  end
+
+  def Enum *elems
+    EnumType.new(elems)
+  end
+
+  def Bit val
+    BitLit.new(val)
+  end
+
+end