astrapi 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 10ee1c3dea18bdd7755a762060ccc1a1aa0692ca
+  data.tar.gz: cb41eab2377dafbac4d3b79c90e88873ec83973e
+SHA512:
+  metadata.gz: d327cb9aa4133ef33a4c47b191fbea985b2adc7e746d952077b1ec5caee7820fcfc9382b980a5e4966fd1b21490cecca79beeb5f7cb436eaf0321a1af08fcd70
+  data.tar.gz: 342378734808d44a6dd3993d593d6036669f7e3dd6be18aed39b966798d7416a309b2a8337d8850c9590591af093f4d0dbb80985229af075cb87929811267857

data/bin/astrapi

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require_relative "../lib/compiler"
+
+t1 = Time.now
+compiler=Astrapi::Compiler.new
+filename=compiler.analyze_options(ARGV)
+compiler.compile(filename)
+t2 = Time.now
+puts "compiled in     : #{t2-t1} s" if $options[:verbosity]>=2

data/doc/astrapi.html

@@ -0,0 +1,149 @@
+<h1 id="astrapi-meta-compiler">Astrapi meta-compiler</h1>
+
+<h2 id="what-is-astrapi-">What is Astrapi ?</h2>
+
+<p>Astrapi is meta-compiler for Sexp-based Domain Specific Languages : once you have described your DSL concepts (abstract syntax) thanks to Astrapi language, the compiler generates several files for you:</p>
+
+<ul>
+  <li>the corresponding classes</li>
+  <li>lexer and parser</li>
+  <li>generic visitor</li>
+  <li>pretty printer</li>
+  <li>graphical AST viewer</li>
+</ul>
+
+<p>Finally a driver for you own DSL compiler is also generated. Version 0.0.2 provides Ruby generation, but Python, Java and C++ will be available soon.</p>
+
+<p>Astrapi-generated DSL parser will assume your DSL models are written in plain <strong>s-expressions</strong>.</p>
+
+<h2 id="what-are-s-expressions-">What are s-expressions ?</h2>
+<p>S-expressions, abreviated as "sexps", actually mean "symbolic expressions". They originated from the famous LISP language. Compiler designers resort to  <em>sexp</em> as the most direct mean to capture Abstract Syntax Trees (AST) in a textual format.</p>
+
+<p>Sexps are convenient to serialize both data <em>and</em> code, which offers a superiority over other serialization formats like XML, YAML or JSON.</p>
+
+<p>It may be noticed that several S-expressions parsers exist around. In the Ruby ecosystems, SXP and Sexpistols can be recommanded. However, these parsers will just turn the parenthesized expressions into a Ruby native data structure : namely arrays of arrays, etc. If your intent is to consider each s-expression as an instance of a <em>custom</em> class, then Astrapi is for you !</p>
+
+<h2 id="how-to-install-">How to install ?</h2>
+<p>In your terminal, simply type : <strong>gem install astrapi</strong></p>
+
+<h2 id="quick-start">Quick start</h2>
+<p>In this example, we invent a toy language (DSL) that aims at describing simple geometry. Let us begin with examples programs written in our expected syntax :</p>
+
+<!-- HTML generated using hilite.me -->
+<div style="background: #ffffff; overflow:auto;width:auto;border:solid gray;border-width:.1em .1em .1em .8em;padding:.2em .6em;"><pre style="margin: 0; line-height: 125%">(<span style="color: #0066BB; font-weight: bold">scene</span> <span style="color: #996633">test</span>
+  (<span style="color: #0066BB; font-weight: bold">square</span> <span style="color: #996633">s1</span>
+     (<span style="color: #0066BB; font-weight: bold">position</span> <span style="color: #0000DD; font-weight: bold">123</span> <span style="color: #0000DD; font-weight: bold">345</span>)
+     (<span style="color: #0066BB; font-weight: bold">size</span> <span style="color: #0000DD; font-weight: bold">12</span>)
+  )
+  (<span style="color: #0066BB; font-weight: bold">circle</span> <span style="color: #996633">c1</span>
+     (<span style="color: #0066BB; font-weight: bold">position</span> <span style="color: #0000DD; font-weight: bold">123</span> <span style="color: #0000DD; font-weight: bold">345</span>)
+     (<span style="color: #0066BB; font-weight: bold">size</span> <span style="color: #0000DD; font-weight: bold">12</span> <span style="color: #0000DD; font-weight: bold">23</span>)
+  )
+  (<span style="color: #0066BB; font-weight: bold">rectangle</span> <span style="color: #996633">s2</span>
+     (<span style="color: #0066BB; font-weight: bold">position</span> <span style="color: #0000DD; font-weight: bold">323</span> <span style="color: #0000DD; font-weight: bold">445</span>)
+     (<span style="color: #0066BB; font-weight: bold">size</span> <span style="color: #0000DD; font-weight: bold">12</span> <span style="color: #0000DD; font-weight: bold">34</span>)
+  )
+)
+</pre></div>
+
+<p>Now let's express the concepts of this model : let's name this a <em>metamodel</em>. I suffix this file with '.mm'. It ressembles <em>Ruby modules and class</em>, but it is not.</p>
+
+<!-- HTML generated using hilite.me -->
+<div style="background: #f0f3f3; overflow:auto;width:auto;border:solid gray;border-width:.1em .1em .1em .8em;padding:.2em .6em;"><pre style="margin: 0; line-height: 125%"><span style="color: #006699; font-weight: bold">module</span> <span style="color: #00CCFF; font-weight: bold">Geometry</span>
+
+  <span style="color: #006699; font-weight: bold">class</span> <span style="color: #00AA88; font-weight: bold">Scene</span>
+    <span style="color: #006699">attr</span> elements <span style="color: #555555">=&gt;</span> <span style="color: #336600">Shape</span><span style="color: #555555">[]</span>
+  <span style="color: #006699; font-weight: bold">end</span>
+
+  <span style="color: #006699; font-weight: bold">class</span> <span style="color: #00AA88; font-weight: bold">Shape</span>
+    <span style="color: #006699">attr</span> <span style="color: #336666">id</span> <span style="color: #555555">=&gt;</span> <span style="color: #336600">IDENT</span>
+    <span style="color: #006699">attr</span> position <span style="color: #555555">=&gt;</span> <span style="color: #336600">Position</span>
+  <span style="color: #006699; font-weight: bold">end</span>
+
+  <span style="color: #006699; font-weight: bold">class</span> <span style="color: #00AA88; font-weight: bold">Square</span> <span style="color: #555555">&lt;</span> <span style="color: #336600">Shape</span>
+    <span style="color: #006699">attr</span> size <span style="color: #555555">=&gt;</span> <span style="color: #336600">INTEGER</span>
+  <span style="color: #006699; font-weight: bold">end</span>
+
+  <span style="color: #006699; font-weight: bold">class</span> <span style="color: #00AA88; font-weight: bold">Circle</span> <span style="color: #555555">&lt;</span> <span style="color: #336600">Shape</span>
+    <span style="color: #006699">attr</span> radius <span style="color: #555555">=&gt;</span> <span style="color: #336600">INTEGER</span>
+  <span style="color: #006699; font-weight: bold">end</span>
+
+  <span style="color: #006699; font-weight: bold">class</span> <span style="color: #00AA88; font-weight: bold">Rectangle</span> <span style="color: #555555">&lt;</span> <span style="color: #336600">Shape</span>
+    <span style="color: #006699">attr</span> size <span style="color: #555555">=&gt;</span> <span style="color: #336600">Size</span>
+  <span style="color: #006699; font-weight: bold">end</span>
+
+  <span style="color: #006699; font-weight: bold">class</span> <span style="color: #00AA88; font-weight: bold">Size</span>
+    <span style="color: #006699">attr</span> dims <span style="color: #555555">=&gt;</span> <span style="color: #336600">INTEGER</span><span style="color: #555555">[]</span>
+  <span style="color: #006699; font-weight: bold">end</span>
+
+  <span style="color: #006699; font-weight: bold">class</span> <span style="color: #00AA88; font-weight: bold">Position</span>
+     <span style="color: #006699">attr</span> coord <span style="color: #555555">=&gt;</span> <span style="color: #336600">INTEGER</span><span style="color: #555555">[]</span>
+  <span style="color: #006699; font-weight: bold">end</span>
+<span style="color: #006699; font-weight: bold">end</span>
+</pre></div>
+
+<p>Then compile this metamodel using Astrapi :</p>
+
+<!-- HTML generated using hilite.me -->
+<div style="background: #f0f3f3; overflow:auto;width:auto;border:solid gray;border-width:.1em .1em .1em .8em;padding:.2em .6em;"><pre style="margin: 0; line-height: 125%">
+jcll$ &gt; astrapi geometry.mm
+ASTRAPI meta-compiler for Sexp-based DSLs (c) J-C Le Lann 2016
+==&gt; parsing metamodel.................... geometry.mm
+==&gt; pretty print metamodel............... geometry_pp.mm
+==&gt; generate dot for metamodel........... geometry_ast.dot
+==&gt; checking metamodel
+==&gt; generating class diagram............. geometry_class_diagram.dot
+==&gt; generate software stack for DSL &#39;Geometry&#39;. Ruby version
+----&gt; generating Geometry DSL AST classes
+----&gt; generating Geometry DSL AST printer
+----&gt; generating Geometry DSL lexer
+----&gt; generating Geometry DSL parser
+----&gt; generating Geometry DSL pretty printer
+----&gt; generating Geometry DSL compiler
+</pre></div>
+
+<p>Now we can play with our brand new Geometry compiler !</p>
+
+<!-- HTML generated using hilite.me -->
+<div style="background: #f8f8f8; overflow:auto;width:auto;border:solid gray;border-width:.1em .1em .1em .8em;padding:.2em .6em;"><pre style="margin: 0; line-height: 125%">$&gt; ruby geometry_compiler.rb ex1.geo
+Geometry compiler
+==&gt; parsing ex1.geo
+==&gt; pretty print to ........ ex1.geo_pp.geometry
+==&gt; generate dot for AST in ex1.geo.dot
+compiled in     : 0.001463371 s
+</pre></div>
+
+<p>In particular, we can have a look at the graphical AST (plain graphiz dot format). If you have xdot installed, simply type <strong>xdot ex1.geo.dot</strong> and the AST of our example will show up like this.</p>
+
+<p><img src="./img/ex1.geo.png" alt="Image of AST model" /></p>
+
+<h2 id="about-the-metamodel">About the Metamodel</h2>
+
+<h3 id="basic-syntax">Basic syntax</h3>
+<p>Astrapi metamodel syntax remains very basic. A concept is captured as a <strong>class</strong>, followed by the list of its attributes <strong>attr</strong>. The type of the attributes appears after <strong>=&gt;</strong>. Attributes can be simple or multiple. The order of declaration of classes has no importance, but the <strong>order of <em>attr</em> declarations is fundamental</strong>, as it drives the generated DSL parser. This may be enhanced in a future version.</p>
+
+<h3 id="basic-data-types">Basic data types</h3>
+<p>There also exist some basic types understood by Astrapi and parsed as <em>terminals</em> :</p>
+
+<ul>
+  <li><strong>IDENT</strong> will make the lexer recognize tokens matching the regexp /[a-zA-Z]+[a-zA-Z_0-9]*/i.</li>
+  <li><strong>INTEGER</strong> : regexp is /[0-9]+/</li>
+  <li><strong>FLOAT</strong> : regexp is /[0-9]+.[0-9]+/</li>
+  <li><strong>RANGE</strong> : regexp is /[0-9]+..[0-9+/</li>
+  <li><strong>STRING</strong> : regexp is /"(.*)"/</li>
+  <li><strong>NIL</strong> : regexp is /nil/</li>
+</ul>
+
+<p>Note that you can use <strong>nil</strong> in your DSL model, either for expected concepts or terminals.</p>
+
+<h3 id="graphical-view-of-the-metamodel">Graphical view of the Metamodel</h3>
+<p>A graphical view of the metamodel structure is also generated by Astrapi. This is a basic <em>class-diagram</em> of the AST classes. The name of the dot file appears during the metamodel compilation. It is suffix a ** xxx_ast.dot <strong>.
+To view it, type **xdot xxx_ast.dot</strong>. For our Geometry example :</p>
+
+<p><img src="./img/geometry_class_diagram.png" alt="Image of the metamodel" /></p>
+
+<h2 id="comments-in-astrapi-s-expressions">Comments in Astrapi s-expressions</h2>
+<p>Comments are accepted in Astrapi s-expressions. Comments starts with <strong>#</strong> symbol and ends at the end of line. A comment will be attached (attribute <strong>.comments_</strong>) to the AST node following this comment. As such, comments can be reused (code generation etc).</p>
+
+<h2 id="credits">Credits</h2>
+<p>Please <a href="mailto:lelannje@ensta-bretagne.fr">drop me an email</a> if you use Astrapi, or want some additional features or bug fixes.</p>

data/lib/ast.rb

@@ -0,0 +1,68 @@
+module Astrapi
+
+  class Ast
+    def accept(visitor, arg=nil)
+      name = self.class.name.split(/::/)[1]
+      visitor.send("visit#{name}".to_sym, self ,arg) # Metaprograming !
+    end
+  end
+
+  class Module < Ast
+    attr_accessor :name,:classes
+    def initialize name,classes=[]
+      @name,@classes=name,classes
+    end
+  end
+
+  class Klass < Ast
+    attr_accessor :name,:inheritance,:attrs
+    def initialize name,inheritance=nil,attrs=[]
+      @name,@inheritance,@attrs=name,inheritance,attrs
+    end
+  end
+
+  class Attr < Ast
+    attr_accessor :name,:type
+    def initialize name,type
+      @name,@type=name,type
+    end
+  end
+
+  class Type < Ast
+    attr_accessor :name
+    def initialize name
+      @name=name
+    end
+
+    def ==(other)
+      name==other.name
+    end
+  end
+
+  class ArrayOf < Type
+    attr_accessor :type
+    def initialize type
+      @type=type
+    end
+  end
+
+  #..............................
+  class Identifier < Ast
+    def initialize tok
+      @tok=tok
+    end
+
+    def str
+      @tok.val.to_s
+    end
+
+    def to_s
+      str
+    end
+
+    def ==(other)
+      str==other.str
+    end
+  end
+
+end

data/lib/checker.rb

@@ -0,0 +1,61 @@
+require_relative 'ast'
+require_relative 'visitor'
+require_relative 'code'
+
+module Astrapi
+
+  class Checker < Visitor
+
+    # the checker checks  :
+    # - that classes are uniquely defined
+    # - that attrs are uniquely defined withing a given class
+    # - that attrs types are defined in the metamodel
+    attr_accessor :mm
+
+    def check ast
+      @verbose=false
+      @mm=ast
+      ast.accept(self)
+    end
+
+    def visitModule modul,args=nil
+      indent "visitModule"
+      name=modul.name.accept(self)
+      modul.classes.each{|k| k.accept(self)}
+      dedent
+    end
+
+    def visitKlass klass,args=nil
+      indent "visitKlass #{klass.name}"
+      if klass.inheritance
+
+      end
+      klass.attrs.each{|attr| attr.accept(self)}
+      dedent
+    end
+
+    def visitAttr attr,args=nil
+      indent "visitAttr"
+      attr.name.accept(self)
+      attr.type.accept(self)
+      dedent
+    end
+
+    def visitType type,args=nil
+      indent "visitType"
+      dedent
+    end
+
+    def visitArrayOf arrayOf,args=nil
+      indent "visitArrayOf"
+      arrayOf.type.accept(self)
+      dedent
+    end
+
+    def visitIdentifier id,args=nil
+      indent "visitIdentifier"
+      say " - #{id}"
+      dedent
+    end
+  end
+end

data/lib/class_diagram_printer.rb

@@ -0,0 +1,83 @@
+require_relative 'ast'
+require_relative 'indent'
+require_relative 'code'
+
+module Astrapi
+
+  class ClassDiagramPrinter
+
+    include Indent
+
+    DECL_FOR_INSTRINSICS={
+      :IDENT   => "IDENT[label=\"{IDENT|+kind\n+val\n+pos\n\}\"]",
+      :FLOAT   => "FLOAT[label=\"{FLOAT|+kind\n+val\n+pos\n\}\"]",
+      :INTEGER => "INTEGER[label=\"{INTEGER|+kind\n+val\n+pos\n\}\"]",
+      :STRING  => "STRING[label=\"{STRING|+kind\n+val\n+pos\n\}\"]",
+      :FRAC    => "FRAC[label=\"{FRAC|+kind\n+val\n+pos\n\}\"]",
+      :NIL     => "NIL[label=\"{NIL|+kind\n+val\n+pos\n\}\"]"
+    }
+
+    def print ast
+      ast.accept(self)
+    end
+
+    def visitModule modul,args=nil
+      indent "visitModule"
+
+      decl=Code.new # declarations of nodes
+      modul.classes.collect do |k|
+        attrs_str=k.attrs.collect{|attr| "+ #{attr.name}\\n"}
+        decl << "#{k.name}[label = \"{#{k.name}|#{attrs_str.join()}|...}\"]"
+      end
+      cnx=Code.new  #connexions
+      modul.classes.each{|k| cnx << k.accept(self)}
+      #................................................................
+      code=Code.new
+      code << "digraph hierarchy {"
+      code << " size=\"5,5\""
+      #code << " splines=ortho"
+      code << " node[shape=record,style=filled,fillcolor=gray95]"
+      code << " edge[dir=back, arrowtail=empty]"
+      code.newline
+      code.indent=2
+      code << decl
+      code << cnx
+      code.indent=0
+      code << "}"
+      dedent
+      return code
+    end
+
+    def visitKlass klass,args=nil
+      indent "visitKlass"
+      code = Code.new
+      klass.attrs.each do |attr|
+        case type=attr.type
+        when ArrayOf
+          sink=type.type.name.to_s
+          head="label=\"*\""
+        when Type
+          sink=type.name.to_s
+          head="label=1"
+          code << DECL_FOR_INSTRINSICS[sink.to_sym] if is_instrinsic(type)
+        end
+        code << "#{klass.name} -> #{sink}[#{head},arrowtail=diamond]"
+      end
+      if klass.inheritance
+        code << "#{klass.inheritance} -> #{klass.name}"
+      end
+      dedent
+      code
+    end
+
+    def is_instrinsic type
+      if type.respond_to? :type
+        str=type.type.name.to_s
+        return str==str.upcase
+      else
+        str=type.name.to_s
+        return str==str.upcase
+      end
+    end
+  end
+end

data/lib/code.rb

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

data/lib/compiler.rb

@@ -0,0 +1,149 @@
+require 'pp'
+require 'optparse'
+
+require_relative 'dbg'
+require_relative 'version'
+require_relative 'parser'
+require_relative 'checker'
+require_relative 'pretty_printer'
+require_relative 'dot_printer'
+require_relative 'class_diagram_printer'
+require_relative 'ruby_generator'
+
+module Astrapi
+
+  $options={
+    :verbosity => 0
+  }
+
+  class Compiler
+
+    include Dbg
+
+    attr_accessor :mm
+
+    def initialize
+      puts "ASTRAPI meta-compiler for Sexp-based DSLs [version #{VERSION}] (c) J-C Le Lann 2016"
+    end
+
+    def analyze_options args
+      args << "-h" if args.empty?
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: astrapi <file.mm> [options]"
+
+        opts.on("-p", "--parse", "[P]arsing  only. AST generated internally") do |n|
+          $options[:parse_only]=true
+          $options[:verbosity]=2
+        end
+
+        opts.on("-c", "--check", "[C]hecking only. Semantic/contextual analysis ") do |n|
+          $options[:check_only]=true
+        end
+
+        opts.on("--pp", "Pretty-print back the Astrapi code") do |n|
+          $options[:pp_only]=true
+        end
+
+        opts.on("--version", "Prints version") do |n|
+          puts VERSION
+          abort
+        end
+
+        targets=[:ruby,:java,:python,:cpp]
+        opts.on("--lang TARGET", "Target LANGUAGE (ruby by default,java,python,cpp)",targets) do |lang|
+          case lang
+          when :ruby
+            $options[:target_language]=lang
+          when :java,:python,:cpp
+            raise "#{lang} version not implemented yet. Sorry"
+            $options[:target_language]=lang
+          else
+            raise "illegal target language #{lang}"
+          end
+        end
+
+        opts.on("-v LEVEL", "--verbose level", "allow verbose levels (0,1)") do |level|
+          $options[:verbosity]=level.to_i
+        end
+
+        opts.on("-h", "--help", "Prints this help") do
+          puts opts
+          exit
+        end
+      end
+
+      begin
+        opt_parser.parse!(args)
+      rescue Exception => e
+        puts e
+        dbg 0,e.backtrace if $options[:verbosity]>2
+        exit
+      end
+      # remaining ARGV (remind that parse! has removed everything else)
+      filename = ARGV.pop
+      unless filename
+        dbg 0,"Need to specify a filename to process"
+        exit
+      end
+      return filename
+    end
+
+    def compile mm_filename
+      @mm=parse(mm_filename)
+      pretty_print
+      dot_print
+      check
+      generate_class_diagram
+      generate_ruby
+    end
+
+    def parse mm_filename
+      puts "==> parsing metamodel.................... #{mm_filename}"
+      ast=Astrapi::Parser.new.parse(mm_filename)
+      exit if $options[:parse_only]
+      ast
+    end
+
+    def pretty_print
+      target="#{mm.name.to_s.downcase}_pp.mm"
+      puts "==> pretty print metamodel............... #{target}"
+      code=PrettyPrinter.new.print(mm)
+      code.save_as(target,verbose=false)
+      exit if $options[:pp_only]
+    end
+
+    def check
+      puts "==> checking metamodel"
+      Checker.new.check(mm)
+    end
+
+    def generate_class_diagram
+      target="#{mm.name.to_s.downcase}_class_diagram.dot"
+      puts "==> generating class diagram............. #{target}"
+      code=ClassDiagramPrinter.new.print(mm)
+      code.save_as(target,verbose=false)
+    end
+
+    def dot_print
+      target="#{mm.name.to_s.downcase}_ast.dot"
+      puts "==> generate dot for metamodel........... #{target}"
+      code=DotPrinter.new.print(mm)
+      code.save_as(target,verbose=false)
+    end
+
+    def generate_ruby
+      puts "==> generate software stack for DSL '#{@mm.name}'. Ruby version"
+      RubyGenerator.new.generate(mm)
+    end
+
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  filename=ARGV[0]
+  raise "need a file !" if filename.nil?
+  t1 = Time.now
+  Astrapi::Compiler.new.compile(filename)
+  t2 = Time.now
+  puts "compiled in     : #{t2-t1} s"
+end

data/lib/dbg.rb

@@ -0,0 +1,7 @@
+module Astrapi
+  module Dbg
+  	def dbg level,str
+  		puts str if $options[:verbosity]>=level
+  	end
+  end
+end

data/lib/dot_printer.rb

@@ -0,0 +1,72 @@
+require_relative 'ast'
+require_relative 'indent'
+require_relative 'code'
+
+module Astrapi
+
+  class DotPrinter
+
+    include Indent
+
+    attr_accessor :code,:nodes_decl,:nodes_cnx
+
+    def print ast #entry method
+      @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\"]"
+      process(ast)
+      code << @nodes_decl
+      code << @nodes_cnx
+      code.indent=0
+      code << "}"
+      return code
+    end
+
+    def process node,level=0
+
+      kname=node.class.name.split("::")[1]
+      id=node.object_id
+      nodes_decl << "#{id} [label=\"#{kname}\"]"
+
+      node.instance_variables.each{|vname|
+        ivar=node.instance_variable_get(vname)
+        vname=vname.to_s[1..-1]
+        case ivar
+        when Array
+          ivar.each_with_index{|e,idx|
+            sink=process(e,level+2)
+            @printed_cnx[id]||=[]
+            nodes_cnx << "#{id} -> #{sink} [label=\"#{vname}[#{idx}]\"]" if not @printed_cnx[id].include? sink
+            @printed_cnx[id] << sink
+          }
+        when Token
+          val=ivar.val
+          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+2)
+          @printed_cnx[id]||=[]
+          nodes_cnx << "#{id} -> #{sink} [label=\"#{vname}\"]" if not @printed_cnx[id].include? sink
+          @printed_cnx[id] << sink
+        end
+
+      }
+      return id
+    end
+
+  end #class
+end #module

data/lib/indent.rb

@@ -0,0 +1,19 @@
+module Indent
+
+  INDENT=2
+
+  def indent str
+    @indentation||=-INDENT
+    @indentation+=INDENT
+    say(str)
+  end
+
+  def dedent
+    @indentation-=INDENT
+  end
+
+  def say str
+    puts " "*@indentation+str if @verbose
+  end
+  
+end