sexpir 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 682317cfd3be1aa8cbdefa505279d36be704c833b4f9cfc1165dbfe6f17777c0
+  data.tar.gz: 739265b361bf8d05fa41c827d1db2b2a858306832343189eba1c5f368110000f
+SHA512:
+  metadata.gz: 60bff8d21a153e2c9f919b07d24647b55233f67170789ce247625f4f8e4024d5756dd85b200840a121df202441d1003505b9e31cda1003755d52e11fe6a03433
+  data.tar.gz: 0d501270fe47eaa5a1d46d71686ce1e0aba1dc19921fa579cedd6b029ea98faaf64102e2149bf6b8418c64abacfc6462eeedfa5eadbb16cc40ea294888dedd16

data/bin/sexpir

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/sexpir'
+
+Sexpir::Runner.run(*ARGV)

data/lib/sexpir/ast.rb

@@ -0,0 +1,98 @@
+module Sexpir
+  class Ast
+    attr_accessor :node
+    def accept(visitor, arg=nil)
+       name = self.class.name.split(/::/).last
+       visitor.send("visit#{name}".to_sym, self ,arg) # Metaprograming !
+    end
+  end
+
+  class Circuit < Ast
+    attr_accessor :name,:signals,:inputs,:outputs,:body
+    def initialize
+      @signals=[]
+      @inputs,@outputs=[],[]
+      @body=Body.new
+    end
+  end
+
+  class Signal < Ast
+    attr_accessor :name,:type
+  end
+
+  class Io < Signal
+  end
+
+  class Port < Io
+    attr_accessor :component_name,:name
+  end
+
+  class Input < Io
+  end
+
+  class Output < Io
+  end
+
+  # statements
+  class Body < Ast
+    attr_accessor :stmts
+    def initialize
+      @stmts=[]
+    end
+
+    def << e
+      @stmts << e
+    end
+  end
+
+  class Combinatorial < Ast
+    attr_accessor :label,:body
+  end
+
+  class Sequential < Ast
+    attr_accessor :label,:body
+  end
+
+  class Assign < Ast
+    attr_accessor :lhs,:rhs
+  end
+
+  class If < Ast
+    attr_accessor :cond,:then,:elsifs,:else
+    def initialize
+      @elsifs=[]
+    end
+  end
+  #===============================
+  class Component < Ast
+    attr_accessor :name,:type
+  end
+
+  class Connect < Ast
+    attr_accessor :source,:sink
+  end
+  #================================
+  class Expression < Ast
+  end
+
+  class Binary < Expression
+    attr_accessor :lhs,:op,:rhs
+  end
+
+  class Term < Expression
+  end
+
+  class Var < Term
+    attr_accessor :name
+    def initialize name
+      @name=name
+    end
+  end
+
+  class Const < Expression
+    attr_accessor :value
+    def initialize value
+      @value=value
+    end
+  end
+end

data/lib/sexpir/ast_sexp.rb

@@ -0,0 +1,144 @@
+require_relative 'code'
+
+class Symbol
+  def sexp
+    self
+  end
+end
+
+module Sexpir
+
+  class Circuit < Ast
+    def sexp
+      code=Code.new
+      code << "(circuit #{name}"
+      code.indent=2
+      signals.each{|sig| code << sig.sexp}
+      inputs.each{|input | code << input.sexp}
+      outputs.each{|output| code << output.sexp}
+      code.newline
+      code << body.sexp
+      code.indent=0
+      code << ")"
+      code.finalize
+    end
+  end
+
+  class Signal < Ast
+    def sexp
+      "(signal  #{name} #{type})"
+    end
+  end
+
+  class Port < Io
+    def sexp
+      "(port #{component_name} #{name})"
+    end
+  end
+
+  class Input < Io
+    def sexp
+      "(input  #{name} #{type})"
+    end
+  end
+
+  class Output < Io
+    def sexp
+      "(output #{name} #{type})"
+    end
+  end
+
+  class Body < Ast
+    def sexp
+      code=Code.new
+      stmts.each{|stmt| code << stmt.sexp}
+      code
+    end
+  end
+
+  class Combinatorial < Ast
+    def sexp
+      code=Code.new
+      label_s=label ? label : "nil"
+      code << "(combinatorial #{label_s}"
+      code.indent=2
+      code << body.sexp
+      code.indent=0
+      code << ")"
+      code
+    end
+  end
+
+  class Sequential < Ast
+    def sexp
+      code=Code.new
+      label_s=label ? label : "nil"
+      code << "(sequential #{label_s}"
+      code.indent=2
+      code << body.sexp
+      code.indent=0
+      code << ")"
+      code
+    end
+  end
+
+  class Assign < Ast
+    def sexp
+      "(assign #{lhs.sexp} #{rhs.sexp})"
+    end
+  end
+
+  class If < Ast
+    def sexp
+      code=Code.new
+      code << "(if #{cond.sexp}"
+      code.indent=2
+      code << "(then"
+      code.indent=4
+      code << self.then.sexp
+      code.indent=2
+      code << ")"
+      if self.else
+        code << "(else"
+        code.indent=4
+        code << self.else.sexp
+        code.indent=2
+        code << ")"
+      end
+      code.indent=0
+      code << ")"
+      code
+    end
+  end
+  #===============================
+  class Component < Ast
+    def sexp
+      "(component #{name} #{type})"
+    end
+  end
+
+  class Connect < Ast
+    def sexp
+      "(connect #{source.sexp} #{sink.sexp})"
+    end
+  end
+
+  #================================
+  class Binary < Expression
+    def sexp
+      "(#{op} #{lhs.sexp} #{rhs.sexp})"
+    end
+  end
+
+  class Var < Term
+    def sexp
+      name
+    end
+  end
+
+  class Const < Expression
+    def sexp
+      value
+    end
+  end
+end

data/lib/sexpir/checker.rb

@@ -0,0 +1,14 @@
+require_relative 'visitor'
+require_relative 'printer'
+
+module Sexpir
+
+  class Checker < Visitor
+    include Log
+    def check circuit
+      log"[+] checking circuit '#{circuit.name}'"
+    end
+
+    private
+  end
+end

data/lib/sexpir/code.rb

@@ -0,0 +1,46 @@
+class Code
+
+  attr_accessor :indent,:lines
+
+  def initialize str=nil
+    @lines=[]
+    (@lines << str) if str
+    @indent=0
+  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/sexpir/code_generator.rb

@@ -0,0 +1,8 @@
+require_relative 'code'
+module Sexpir
+  class CodeGenerator
+    def generate fsmd
+      puts "[+] code generation"
+    end
+  end
+end

data/lib/sexpir/compiler.rb

@@ -0,0 +1,39 @@
+require 'sxp'
+
+require_relative 'version'
+require_relative 'ast'
+require_relative 'parser'
+require_relative 'printer'
+require_relative 'checker'
+require_relative 'transformer'
+require_relative 'ruby_rtl_generator'
+
+module Sexpir
+
+  class Compiler
+
+    include Log
+    attr_accessor :options
+
+    def initialize
+    end
+
+    def header
+      log "Sexpir compiler - version #{VERSION}"
+      #log "author : jean-christophe.le_lann@ensta-bretagne.fr"
+    end
+
+    def compile sexpfile
+      header
+      circuit=Parser.new.parse(sexpfile)
+      Printer.new.print(circuit)
+      Checker.new.check(circuit)
+      RubyRTLGenerator.new.generate(circuit)
+    end
+
+    def close
+      log "[+] closing : log is #{$log.inspect}"
+    end
+
+  end
+end

data/lib/sexpir/graph.rb

@@ -0,0 +1,116 @@
+require_relative "code"
+
+module GRAPH
+
+  class Graph
+
+    attr_accessor :name,:nodes
+    def initialize name
+      @name=name
+      @nodes=[]
+    end
+
+    def << node
+      @nodes << node
+    end
+
+    def size
+      @nodes.size
+    end
+
+    def include? node
+      @nodes.include? node
+    end
+
+    def connect source,sink,infos={}
+      raise "source nil" unless source
+      raise "sink   nil" unless sink
+      @nodes << source unless @nodes.include? source
+      @nodes << sink   unless @nodes.include? sink
+      source.to(sink,infos)
+    end
+
+    def connected? source,sink
+      source.succ_edges.select{|edge| edge.sink==sink}.any?
+    end
+
+    def unconnect source,sink
+      source.succ_edges.delete_if{|edge| edge.sink==sink}
+      sink.pred_edges.delete_if{|edge| edge.source==source}
+    end
+
+    def delete node
+      node.preds.each{|pred| unconnect(pred,node)}
+      node.succs.each{|succ| unconnect(node,succ)}
+      @nodes.delete(node)
+    end
+
+    def each_node &block
+      @nodes.each(&block)
+    end
+
+    def each_edge &block
+      edges.each(&block)
+    end
+
+    def edges
+      @nodes.collect{|n| n.succ_edges}.flatten
+    end
+
+    def to_dot
+      dot_code=Code.new
+      dot_code << "digraph #{name} {"
+      dot_code.indent=2
+
+      each_node do |node|
+        dot_code << "#{node.object_id};"
+      end
+      each_edge do |edge|
+        label=edge.infos.to_s
+        dot_code << "#{edge.object_id} -> #{edge.object_id} [label=\"#{label}\"];"
+      end
+      dot_code.indent=0
+      dot_code << "}"
+      return dot_code
+    end
+
+    def save_as dotfilename
+      dot_code||=to_dot()
+      dot_code.save_as dotfilename
+    end
+  end
+
+  class Node
+    attr_accessor :infos
+    attr_accessor :succ_edges,:pred_edges
+
+    def initialize infos={}
+      @infos=infos
+      @succ_edges=[]
+      @pred_edges=[]
+    end
+
+    def to node,infos={}
+      e=Edge.new(self,node,infos)
+      @succ_edges << e
+      node.pred_edges << e
+    end
+
+    def succs
+      @succ_edges.collect{|edge| edge.sink}
+    end
+
+    def preds
+      @pred_edges.collect{|edge| edge.source}
+    end
+  end
+
+  class Edge
+    attr_accessor :name,:source,:sink,:infos
+    def initialize source,sink,infos={}
+      @infos=infos
+      @source=source
+      @sink=sink
+    end
+  end
+end

data/lib/sexpir/log.rb

@@ -0,0 +1,22 @@
+module Log
+
+  def indent v,str
+    @indent=v
+    puts " "*@indent+str.to_s
+  end
+
+  def log msg
+    puts msg
+    #log_dbg msg
+  end
+
+  def log_dbg msg
+    puts msg
+    #$log.puts msg
+  end
+
+  def step
+    log "press any key"
+    key=$stdin.gets
+  end
+end

data/lib/sexpir/parser.rb

@@ -0,0 +1,274 @@
+require 'sxp'
+require_relative 'ast'
+require_relative 'log'
+
+module Sexpir
+
+  class Parser
+
+    include Log
+
+    attr_accessor :options
+
+    def initialize
+      @type_table={}
+      @var_table ={}
+    end
+
+    def parse sexpfile
+      log "[+] parsing  '#{sexpfile}'"
+      sexp=SXP.read IO.read(sexpfile)
+      ast=objectify(sexp)
+    end
+
+    def objectify sexp
+      circ=Circuit.new
+      sexp.shift
+      circ.name=sexp.shift
+      while sexp.any?
+        s=sexp.shift
+        case s.first
+        when :signal
+          circ.signals << parse_signal(s)
+        when :input
+          circ.inputs << parse_input(s)
+        when :output
+          circ.outputs << parse_output(s)
+        when :assign
+          circ.body << parse_assign(s)
+        when :component
+          circ.body << parse_component(s)
+        when :connect
+          circ.body << parse_connect(s)
+        when :comb,:combinatorial
+          circ.body << parse_comb(s)
+        when :seq,:sync,:sequential
+          circ.body << parse_seq(s)
+        else
+          raise "unknown car #{s}"
+        end
+      end
+      circ
+    end
+
+    def expect sexp,klass,value=nil
+      unless (kind=sexp.shift).is_a? klass
+        log "ERROR : expecting a #{klass}. Got a #{kind}."
+        raise "Syntax error"
+      end
+      if value
+        unless value==kind
+          log "ERROR : expecting value '#{value}'. Got '#{kind}'"
+          raise "Syntax error"
+        end
+      end
+      return kind
+    end
+
+    #======== IO & Signals ===========
+    def parse_signal sexp
+      sig=Signal.new
+      sexp.shift
+      sig.name=sexp.shift
+      sig.type=sexp.shift
+      sig
+    end
+
+    def parse_input sexp
+      input=Input.new
+      sexp.shift
+      input.name=sexp.shift
+      input.type=sexp.shift
+      input
+    end
+
+    def parse_output sexp
+      output=Output.new
+      sexp.shift
+      output.name=sexp.shift
+      output.type=sexp.shift
+      output
+    end
+
+
+
+    # ===== components stuff =====
+    def parse_component sexp
+      comp=Component.new
+      sexp.shift
+      comp.name=sexp.shift
+      comp.type=sexp.shift
+      comp
+    end
+
+    def parse_connect sexp
+      con=Connect.new
+      sexp.shift
+      con.source=parse_port(sexp.shift)
+      con.sink  =parse_port(sexp.shift)
+      con
+    end
+
+    def parse_port sexp
+      case sexp
+      when Array
+        port=Port.new
+        sexp.shift
+        port.component_name=sexp.shift
+        port.name=sexp.shift
+        return port
+      else
+        return sexp
+      end
+    end
+
+    # statements
+    def parse_statement sexp
+      case sexp.first
+      when :if
+        parse_if(sexp)
+      when :assign
+        parse_assign(sexp)
+      else
+        raise "unknow statement starting with : #{sexp.first}"
+      end
+    end
+
+    def parse_comb sexp
+      comb=Combinatorial.new
+      sexp.shift
+      label=sexp.shift
+      comb.body=parse_body(sexp)
+      comb
+    end
+
+    def parse_body sexp
+      body=Body.new
+      while sexp.any?
+         body << parse_statement(sexp.shift)
+      end
+      body
+    end
+
+    def parse_if sexp
+      if_=If.new
+      sexp.shift
+      if_.cond = parse_expression(sexp.shift)
+      while sexp.any?
+        case sexp.first.first
+        when :then
+          if_.then = parse_then(sexp.shift)
+        when :elsif
+          if_.elsifs << parse_elsif(sexp.shift)
+        when :else
+          if_.else = parse_else(sexp.shift)
+        else
+          raise "error parsing 'if' : #{sexp.first.first}"
+        end
+      end
+      if_
+    end
+
+    def parse_then sexp
+      sexp.shift
+      body=parse_body(sexp)
+      body
+    end
+
+    def parse_elsif sexp
+      sexp.shift
+      body=parse_body(sexp)
+      body
+    end
+
+    def parse_else sexp
+      sexp.shift
+      body=parse_body(sexp)
+      body
+    end
+
+    def parse_assign sexp
+      assign=Assign.new
+      sexp.shift
+      assign.lhs=parse_expression(sexp.shift)
+      assign.rhs=parse_expression(sexp.shift)
+      assign
+    end
+
+    # expressions
+
+    def parse_expression sexp
+      case sexp
+      when Array
+        case sexp.size
+        when 1
+          case sexp
+          when Symbol
+            return Var.new(sexp)
+          when Integer
+            return Const.new(sexp)
+          else
+            raise "unknown expression '#{sexp}'"
+          end
+        when 2
+          ret=parse_unary(sexp)
+        when 3
+          ret=parse_binary(sexp)
+        else
+          raise "unknown expression '#{sexp}'(size = '#{sexp.size}')"
+        end
+      when Symbol
+        ret=Var.new(sexp)
+      when Integer
+        ret=Const.new(sexp)
+      else
+        raise "unknown expression '#{sexp}'"
+      end
+      ret
+    end
+
+    OP_TRANSLATE={
+      "gt" => ">",
+      "lt" => "<",
+      "eq" => "=",
+      "neq"=> "/=",
+      "gte"=> ">=",
+      "lte"=> "<=",
+    }
+
+    NORMALIZED_OP={
+      "*"  => "mul",
+      "+"  => "add",
+      "-"  => "sub",
+      "/"  => "div",
+      "="  => "eq",
+      ">=" => "gte",
+      "<=" => "lte",
+      "/=" => "neq"
+    }
+
+    def parse_binary sexp
+      case sexp.first
+      when :mread
+        ret=MRead.new
+        sexp.shift
+        ret.mem = Mem.new(sexp.shift) # memory name
+        ret.addr= parse_expression(sexp.shift)
+      else
+        ret=Binary.new
+        ret.op=sexp.shift
+        #ret.op=OP_TRANSLATE[ret.op.to_s]||ret.op.to_s
+        ret.op=NORMALIZED_OP[ret.op.to_s] || ret.op.to_s
+        ret.lhs=parse_expression(sexp.shift)
+        ret.rhs=parse_expression(sexp.shift)
+      end
+      ret
+    end
+
+    def parse_unary sexp
+      ret=Unary.new
+      ret.op=sexp.shift
+      ret
+    end
+  end
+end

data/lib/sexpir/printer.rb

@@ -0,0 +1,10 @@
+require_relative 'ast_sexp'
+
+module Sexpir
+  class Printer
+    def print circuit
+      puts "[+] pretty printing"
+      puts circuit.sexp
+    end
+  end
+end

data/lib/sexpir/ruby_rtl_generator.rb

@@ -0,0 +1,169 @@
+require_relative 'log'
+class Symbol
+  def accept visitor,args=nil
+    self
+  end
+end
+
+module Sexpir
+  class RubyRTLGenerator < Visitor
+    include Log
+    def generate circuit
+      log "[+] generating RubyRTL '#{circuit.name}'"
+      code=circuit.accept(self)
+      puts code.finalize
+    end
+
+    def visitCircuit circuit,args=nil
+      code=Code.new
+      code << "require 'ruby_rtl'"
+      code << "class #{circuit.name.capitalize} < Circuit"
+      code.indent=2
+      circuit.inputs.each{|input| code << input.accept(self)}
+      circuit.outputs.each{|output| code << output.accept(self)}
+      circuit.signals.each{|signal| code << signal.accept(self)}
+      code.newline
+      code << circuit.body.accept(self)
+      code.indent=0
+      code << "end"
+      code
+    end
+
+    def gen_type(type)
+      case num=type
+      when Integer
+        case num
+        when 1
+          return "bit"
+        else
+          return "bv#{num}"
+        end
+      else
+        return type
+      end
+    end
+
+    def visitSignal sig,args=nil
+      sig.name
+      type=gen_type(sig.type)
+      "wire :#{sig.name} => :#{type}"
+    end
+
+    def visitIo io,args=nil
+      io.name
+      io.type
+    end
+
+    def visitPort port,args=nil
+      comp=port.component_name
+      name=port.name
+      "#{comp}.#{name}"
+    end
+
+    def visitInput input,args=nil
+      input.name
+      input.type
+      "input :#{input.name} => :#{input.type}"
+    end
+
+    def visitOutput output,args=nil
+      output.name
+      output.type
+      "output :#{output.name} => :#{output.type}"
+    end
+
+    # === statements ===
+    def visitBody body,args=nil
+      code=Code.new
+      body.stmts.each{|stmt| code << stmt.accept(self)}
+      code
+    end
+
+    def visitCombinatorial comb,args=nil
+      code=Code.new
+      code << "combinatorial(#{comb.label}){"
+      code.indent=2
+      code << comb.body.accept(self)
+      code.indent=0
+      code << "}"
+      code
+    end
+    def visitSequential seq,args=nil
+      code=Code.new
+      code << "sequential(#{seq.label}){"
+      code.indent=2
+      code << seq.body.accept(self)
+      code.indent=0
+      code << "}"
+      code
+    end
+
+    def visitAssign assign,args=nil
+      lhs=assign.lhs.accept(self)
+      rhs=assign.rhs.accept(self)
+      "assign(#{lhs} <= #{rhs})"
+    end
+
+    def visitIf if_,args=nil
+      cond=if_.cond.accept(self)
+      code=Code.new
+      code << "if (#{cond}"
+      code.indent=2
+      code << if_.then.accept(self)
+      if if_.else
+        code.indent=0
+        code << "else"
+        code.indent=2
+        code << if_.else.accept(self)
+        code.indent=0
+      end
+      code.indent=0
+      code << "end"
+      code
+    end
+
+    # === component stuff ====
+    def visitComponent component,args=nil
+      name=component.name
+      type=component.type
+      "component :#{name} => #{type.capitalize}"
+    end
+
+    def visitConnect connect,args=nil
+      source=connect.source.accept(self)
+      sink=connect.sink.accept(self)
+      "connect #{source} => #{sink}"
+    end
+
+    #===========
+    def visitExpression expr,args=nil
+    end
+
+    SEXPIR_TO_RUBY_OP={
+      "and" => "&",
+      "or"  => "|",
+      "xor" => "^",
+      "not" => "!",
+    }
+    def visitBinary binary,args=nil
+      lhs=binary.lhs.accept(self)
+      rhs=binary.rhs.accept(self)
+      op=SEXPIR_TO_RUBY_OP[binary.op] || binary.op
+      "(#{lhs} #{op} #{rhs})"
+    end
+
+    def visitTerm term,args=nil
+      term
+    end
+
+    def visitVar var,args=nil
+      var.name
+    end
+
+    def visitConst const,args=nil
+      const.value
+    end
+
+
+  end
+end

data/lib/sexpir/runner.rb

@@ -0,0 +1,64 @@
+require "optparse"
+
+require_relative "compiler"
+
+module Sexpir
+
+  class Runner
+
+    def self.run *arguments
+      new.run(arguments)
+    end
+
+    def run arguments
+      compiler=Compiler.new
+      compiler.options = args = parse_options(arguments)
+      $options=compiler.options
+
+      if filename=args[:filename]
+        compiler.compile filename
+      else
+        puts "need an sexpir file : sexpir <file.sexp>"
+      end
+    end
+
+    private
+    def parse_options(arguments)
+
+      size=arguments.size
+
+      parser = OptionParser.new
+
+      options = {}
+
+      parser.on("-h", "--help", "Show help message") do
+        puts parser
+        exit(true)
+      end
+
+      parser.on("-v", "--version", "Show version number") do
+        puts VERSION
+        exit(true)
+      end
+
+      parser.on("--verbose", "verbose mode") do
+        options[:verbose]=true
+        $VERBOSE=true
+      end
+
+      parser.parse!(arguments)
+
+      options[:filename]=arguments.shift
+
+      if arguments.any?
+        puts "WARNING : superfluous arguments : #{arguments}"
+      end
+
+      if size==0
+        puts parser
+      end
+
+      options
+    end
+  end
+end

data/lib/sexpir/transformer.rb

@@ -0,0 +1,9 @@
+module Sexpir
+
+  class Transformer < Visitor
+
+    def visitCircuit circuit,args=nil
+  	end
+
+  end
+end

data/lib/sexpir/version.rb

@@ -0,0 +1,3 @@
+module Sexpir
+  VERSION="0.0.2"
+end

data/lib/sexpir/visitor.rb

@@ -0,0 +1,76 @@
+module Sexpir
+
+  class Visitor
+
+    def visitCircuit circuit,args=nil
+      circuit.name
+      circuit.inputs.each{|input| input.accept(self)}
+      circuit.outputs.each{|output| output.accept(self)}
+      circuit.signals.each{|signal| signal.accept(self)}
+      circuit.body.accept(self)
+    end
+
+    def visitSignal sig,args=nil
+      signal.name
+      signal.type
+    end
+
+    def visitIo io,args=nil
+      io.name
+      io.type
+    end
+
+    def visitPort port,args=nil
+      port.name
+      port.type
+    end
+
+    def visitInput input,args=nil
+      input.name
+      input.type
+    end
+
+    def visitOutput output,args=nil
+      output.name
+      output.type
+    end
+
+    def visitBody body,args=nil
+      body.stmts.each{|stmt| stmt.accept(self)}
+    end
+
+    def visitAssign assign,args=nil
+      assign.lhs.accept(self)
+      assign.rhs.accept(self)
+    end
+
+    def visitComponent component,args=nil
+      name=component.name
+      type=component.type
+      "component #{name} => #{type}"
+    end
+
+    def visitConnect connect,args=nil
+      connect.source
+      connect.sink
+    end
+
+    #===========
+    def visitExpression expr,args=nil
+    end
+
+    def visitBinary binary,args=nil
+      binary.lhs.accept(self)
+      binary.rhs.accept(self)
+    end
+
+    def visitTerm term,args=nil
+      term
+    end
+
+    def visitVar var,args=nil
+      var.name
+    end
+
+  end
+end

data/lib/sexpir.rb

@@ -0,0 +1,4 @@
+require_relative './sexpir/compiler'
+require_relative './sexpir/runner'
+module Sexpir
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: sexpir
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jean-Christophe Le Lann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: distribution
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: sexpir is a sexp-based interchange format for RTL design
+email: lelannje@ensta-bretagne.fr
+executables:
+- sexpir
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/sexpir
+- lib/sexpir.rb
+- lib/sexpir/ast.rb
+- lib/sexpir/ast_sexp.rb
+- lib/sexpir/checker.rb
+- lib/sexpir/code.rb
+- lib/sexpir/code_generator.rb
+- lib/sexpir/compiler.rb
+- lib/sexpir/graph.rb
+- lib/sexpir/log.rb
+- lib/sexpir/parser.rb
+- lib/sexpir/printer.rb
+- lib/sexpir/ruby_rtl_generator.rb
+- lib/sexpir/runner.rb
+- lib/sexpir/transformer.rb
+- lib/sexpir/version.rb
+- lib/sexpir/visitor.rb
+homepage: https://github.com/JC-LL/sexpir
+licenses:
+- MIT
+metadata: {}
+post_install_message: Thanks for installing ! Homepage :https://github.com/JC-LL/sexpir
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: interchange format for RTL designs
+test_files: []