nendo 0.3.2 → 0.3.3

data/lib/nendo.rb

@@ -34,1953 +34,2089 @@
 #  
 #  $Id: 
 #
-require 'stringio'
-require 'digest/sha1'
-#require 'profile'
 
-class Nil
-  include Enumerable
-  def each()               end
-  def to_arr()    []       end
-  def length()    0        end
-  def isNull()    true     end
-  def isDotted()  false    end
-  def lastAtom()  nil      end
-  def to_s()      ""       end
-  def car()
-    raise "Error: pair required, but got ()"
-  end
-  def cdr()
-    raise "Error: pair required, but got ()"
-  end
-end
-
-class LispString < String
-  def LispString.escape( str )
-    if str.is_a? String
-      str.gsub( /\\/, "\\\\\\\\" ).gsub( /["]/, "\\\"" ).gsub( /[\r]/, "\\r" ).gsub( /[\t]/, "\\t" )
-    else
-      raise TypeError
+module Nendo
+  require 'stringio'
+  require 'digest/sha1'
+  #require 'profile'
+  
+  class Nil
+    include Enumerable
+    def each()               end
+    def to_arr()    []       end
+    def length()    0        end
+    def isNull()    true     end
+    def isDotted()  false    end
+    def lastAtom()  false    end
+    def getLastAtom() 
+      raise RuntimeError, "Error: Nil#getLastAtom method:  this cell is not dotted list."
+    end
+    def to_s()      ""       end
+    def car()
+      raise "Error: Nil#car method:  pair required, but got ()"
+    end
+    def cdr()
+      raise "Error: Nil#cdr method:  pair required, but got ()"
     end
   end
-end
-
-class LispMacro < Proc
-end
-
-class Symbol
-  def setLispToken( token )
-    @token = token
-  end
-  def sourcefile
-    @token ? @token.sourcefile : ""
-  end
-  def lineno
-    @token ? @token.lineno : 1
+  
+  class LispString < String
+    def LispString.escape( str )
+      if str.is_a? String
+        str.gsub( /\\/, "\\\\\\\\" ).gsub( /["]/, "\\\"" ).gsub( /[\r]/, "\\r" ).gsub( /[\t]/, "\\t" )
+      else
+        raise TypeError
+      end
+    end
   end
-end
-
-class Cell
-  include Enumerable
-
-  def initialize( car = Nil.new, cdr = Nil.new )
-    @car = car
-    @cdr = cdr
+  
+  class LispMacro < Proc
   end
-  attr_accessor :car, :cdr
-
-  def each                    # Supporting iterator
-    if not isNull
-      it = self
-      while Nil != it.class
-        yield it
-        if it.cdr.is_a? Cell
-          it = it.cdr
-        else
-          it = Nil.new
+  
+  class Cell
+    include Enumerable
+  
+    def initialize( car = Nil.new, cdr = Nil.new )
+      @car = car
+      @cdr = cdr
+    end
+    attr_accessor :car, :cdr
+  
+    def each                    # Supporting iterator
+      h = {}
+      if not isNull
+        it = self
+        while Nil != it.class
+          h[ it.hash ] = true
+          # printf( "%s : %s\n", it.car, it.hash )
+          yield it
+          if it.cdr.is_a? Cell
+            it = it.cdr
+            if h.has_key?( it.hash )
+              # found circular-list.
+              it = Nil.new
+            end
+          else
+            it = Nil.new
+          end
         end
       end
     end
-  end
-
-  def length() self.to_arr.length  end
-  def size()   self.length         end # alias of length
-
-  def isDotted
-    ((Cell != @cdr.class) and (Nil != @cdr.class))
-  end
-
-  def isNull
-    ((Nil  == @car.class) and (Nil == @cdr.class))
-  end
-
-  def lastCell
-    lastOne = self
-    self.each { |x| lastOne = x }
-    lastOne
-  end
-
-  def lastAtom
-    lastOne = self.lastCell
-    if lastOne.isDotted
-      lastOne.cdr
-    else
-      nil
+  
+    def length() self.to_arr.length  end
+    def size()   self.length         end # alias of length
+  
+    def isDotted
+      ((Cell != @cdr.class) and (Nil != @cdr.class))
     end
-  end
-
-  def to_arr
-    if isNull
-      []
-    else
-      self.map {|x| x.car}
+  
+    def isNull
+      ((Nil  == @car.class) and (Nil == @cdr.class))
     end
-  end
-end
-
-class Array
-  def to_list( lastAtom = nil )
-    if 0 == self.length
-      Nil.new
-    else
-      cells = self.map { |x|
-        Cell.new( x )
-      }
-      ptr = cells.pop
-      ptr.cdr = lastAtom  if lastAtom
-      cells.reverse.each { |x|
-        x.cdr = ptr
-        ptr = x
-      }
-      return ptr
+  
+    def lastCell
+      lastOne = self
+      self.each { |x| lastOne = x }
+      lastOne
     end
-  end
-end
-
-class Hash
-  def to_list
-    arr = Array.new
-    self.each_pair { |key,val|
-      arr << Cell.new( key, val )
-    }
-    arr.to_list
-  end
-end
-
-class LispValues
-  def initialize( arr )
-    if 1 == arr.size
-      raise ArgumentError, "Error: LispValues object expects 0 or 2+ length of array"
-    else
-      @values = arr
+  
+    def lastAtom
+      lastOne = self.lastCell
+      lastOne.isDotted
+    end
+    
+    def getLastAtom
+      if self.lastAtom
+        self.lastCell.cdr
+      else
+        Nendo::Nil.new
+      end
     end
-  end
-  attr_reader :values
-end
-
-class LispKeyword
-  def initialize( str )
-    @key = str.intern
-  end
-
-  def ==(other)
-    if other.is_a? LispKeyword
-      self.key == other.key
-    else
-      false
+  
+    def to_arr
+      if isNull
+        []
+      else
+        self.map {|x| x.car}
+      end
     end
   end
-
-  def ===(other)
-    self.==(other)
-  end
-
-  def to_s
-    self.key.to_s
-  end
-
-  attr_reader :key
-end
-
-class Token
-  def initialize( kind, str, sourcefile, lineno = nil, column = nil )
-    @kind       = kind
-    @str        = str
-    @sourcefile = sourcefile
-    @lineno     = lineno
-    @column     = column
-  end
-  attr_accessor :kind, :str, :sourcefile, :lineno, :column
-end
-
-
-class CharReader
-  def initialize( inport, sourcefile )
-    @inport     = inport
-    @sourcefile = sourcefile
-    self.reset
-  end
-
-  def reset
-    @lineno = 1
-    @column = 1
-  end
-
-  def getc
-    @undo_lineno = @lineno
-    @undo_column = @column
-    ch = @inport.getc
-    if nil != ch
-      if ch.chr.match( /[\r\n]/ )
-        @lineno += 1
+  
+  class LispValues
+    def initialize( arr )
+      if 1 == arr.size
+        raise ArgumentError, "Error: LispValues object expects 0 or 2+ length of array"
+      else
+        @values = arr
       end
-      @column += 1
     end
-    ch
-  end
-
-  def ungetc( ch )
-    @lineno = @undo_lineno
-    @column = @undo_column
-    @inport.ungetc( ch )
-  end
-
-  def sourcefile
-    @sourcefile
+    attr_reader :values
   end
-
-  def lineno
-    @lineno
-  end
-
-  def column
-    @column
-  end
-end
-
-class Reader
-  ## tokens
-  T_EOF                 = :t_eof
-  T_LPAREN              = :t_lparen
-  T_RPAREN              = :t_rparen
-  T_LVECTOR             = :t_lvector
-  T_SYMBOL              = :t_symbol
-  T_KEYWORD             = :t_keyword
-  T_NUM                 = :t_num
-  T_STRING              = :t_string
-  T_QUOTE               = :t_quote
-  T_QUASIQUOTE          = :t_quasiquote
-  T_UNQUOTE             = :t_unquote
-  T_UNQUOTE_SPLICING    = :t_unquote_splicing
-  T_FEEDTO              = :t_feedto
-  T_DOT                 = :t_dot
-  T_LINEFEED            = :t_linefeed
-  T_COMMENT             = :t_comment
-  T_DEBUG_PRINT         = :t_debug_print
-
-  # inport is IO class
-  def initialize( inport, sourcefile, debug = false )
-    @chReader   = CharReader.new( inport, sourcefile )
-    @curtoken   = nil
-    @debug      = debug
-  end
-
-  def reset
-    @chReader.reset
+  
+  class LispKeyword
+    def initialize( str )
+      @key = str.intern
+    end
+  
+    def ==(other)
+      if other.is_a? LispKeyword
+        self.key == other.key
+      else
+        false
+      end
+    end
+  
+    def ===(other)
+      self.==(other)
+    end
+  
+    def to_s
+      self.key.to_s
+    end
+  
+    attr_reader :key
   end
-
-  def sourcefile
-    @chReader.sourcefile
+  
+  class DelayedCallPacket
+    def initialize( _origname, _pred, _args )
+      @origname = _origname
+      @pred     = _pred
+      @args     = _args
+    end
+    attr_reader :origname, :pred, :args
   end
 
-  def lineno
-    @chReader.lineno
+  class Token
+    def initialize( kind, str, sourcefile, lineno = nil, column = nil )
+      @kind       = kind
+      @str        = str
+      @sourcefile = sourcefile
+      @lineno     = lineno
+      @column     = column
+    end
+    attr_accessor :kind, :str, :sourcefile, :lineno, :column
   end
-
-  def skipspace
-    begin
-      ch = @chReader.getc
-      break if nil == ch # non eof?
-      #printf( "      skipspace: [%02x]\n", ch ) if @debug
-    end while ch.chr.match( /[ \t]/ )
-    @chReader.ungetc( ch ) if nil != ch 
+  
+  
+  class CharReader
+    def initialize( inport, sourcefile )
+      @inport     = inport
+      @sourcefile = sourcefile
+      self.reset
+    end
+  
+    def reset
+      @lineno = 1
+      @column = 1
+    end
+  
+    def getc
+      @undo_lineno = @lineno
+      @undo_column = @column
+      ch = @inport.getc
+      if nil != ch
+        if ch.chr.match( /[\r\n]/ )
+          @lineno += 1
+        end
+        @column += 1
+      end
+      ch
+    end
+  
+    def ungetc( ch )
+      @lineno = @undo_lineno
+      @column = @undo_column
+      @inport.ungetc( ch )
+    end
+  
+    def sourcefile
+      @sourcefile
+    end
+  
+    def lineno
+      @lineno
+    end
+  
+    def column
+      @column
+    end
   end
-
-  def readwhile( exp, oneshot = false )
-    ret = ""
-    while true
+  
+  class Reader
+    ## tokens
+    T_EOF                 = :t_eof
+    T_LPAREN              = :t_lparen
+    T_RPAREN              = :t_rparen
+    T_LVECTOR             = :t_lvector
+    T_SYMBOL              = :t_symbol
+    T_KEYWORD             = :t_keyword
+    T_NUM                 = :t_num
+    T_STRING              = :t_string
+    T_QUOTE               = :t_quote
+    T_QUASIQUOTE          = :t_quasiquote
+    T_UNQUOTE             = :t_unquote
+    T_UNQUOTE_SPLICING    = :t_unquote_splicing
+    T_FEEDTO              = :t_feedto
+    T_DOT                 = :t_dot
+    T_LINEFEED            = :t_linefeed
+    T_COMMENT             = :t_comment
+    T_DEBUG_PRINT         = :t_debug_print
+  
+    # inport is IO class
+    def initialize( inport, sourcefile, debug = false )
+      @inport     = inport
+      @sourcefile = sourcefile
+      @chReader   = nil
+      @curtoken   = nil
+      @debug      = debug
+    end
+  
+    def reset
+      @chReader.reset  if @chReader
+    end
+  
+    def sourcefile
+      @sourcefile
+    end
+  
+    def lineno
+      if @chReader
+        @chReader.lineno
+      else
+        1
+      end
+    end
+  
+    def skipspace
+      begin
+        ch = @chReader.getc
+        break if nil == ch # non eof?
+        #printf( "      skipspace: [%02x]\n", ch ) if @debug
+      end while ch.chr.match( /[ \t]/ )
+      @chReader.ungetc( ch ) if nil != ch 
+    end
+  
+    def readwhile( exp, oneshot = false )
+      ret = ""
+      while true
+        ch = @chReader.getc
+        #printf( "      readwhile: [%02x]\n", ch ) if @debug
+        if !ch # eof?
+          break
+        end
+        if ch.chr.match( exp )
+          ret += ch.chr
+        else
+          @chReader.ungetc( ch )
+          break
+        end
+        if oneshot then   break   end
+      end
+      ret
+    end
+  
+    def peekchar( exp )
       ch = @chReader.getc
-      #printf( "      readwhile: [%02x]\n", ch ) if @debug
+      #printf( "      peekchar: [%02x]\n", ch ) if @debug
       if !ch # eof?
-        break
+        return nil
       end
       if ch.chr.match( exp )
-        ret += ch.chr
+        ch.chr
       else
         @chReader.ungetc( ch )
-        break
+        nil
       end
-      if oneshot then   break   end
     end
-    ret
-  end
-
-  def peekchar( exp )
-    ch = @chReader.getc
-    #printf( "      peekchar: [%02x]\n", ch ) if @debug
-    if !ch # eof?
-      return nil
-    end
-    if ch.chr.match( exp )
-      ch.chr
-    else
-      @chReader.ungetc( ch )
-      nil
+    
+    def readstring()
+      ret = ""
+      while true
+        ch = @chReader.getc
+        #printf( "      readstring: [%s]\n", ch )
+        if !ch # eof?
+          break
+        end
+        if ch.chr == "\\"
+          ch2 = @chReader.getc
+          ret += case ch2.chr
+                 when '"'    #  \"  reduce to "
+                   '"'
+                 when '\\'   #  \\  reduce to \
+                   "\\"
+                 when 'n'
+                   "\n"
+                 when 'r'
+                   "\r"
+                 when 't'
+                   "\t"
+                 else
+                   ""
+                 end
+        elsif ch.chr != '"'
+          ret += ch.chr
+        else
+          @chReader.ungetc( ch )
+          break
+        end
+      end
+      ret
     end
-  end
   
-  def readstring()
-    ret = ""
-    while true
+    def tokenWithComment
+      skipspace
       ch = @chReader.getc
-      #printf( "      readstring: [%s]\n", ch )
-      if !ch # eof?
-        break
-      end
-      if ch.chr == "\\"
-        ch2 = @chReader.getc
-        ret += case ch2.chr
-               when '"'    #  \"  reduce to "
-                 '"'
-               when '\\'   #  \\  reduce to \
-                 "\\"
-               when 'n'
-                 "\n"
-               when 'r'
-                 "\r"
-               when 't'
-                 "\t"
-               else
-                 ""
-               end
-      elsif ch.chr != '"'
-        ret += ch.chr
+      if nil == ch # eof?
+        @curtoken = Token.new( T_EOF, "", @chReader.sourcefile, @chReader.lineno, @chReader.column )
       else
-        @chReader.ungetc( ch )
-        break
-      end
-    end
-    ret
-  end
-
-  def tokenWithComment
-    skipspace
-    ch = @chReader.getc
-    if nil == ch # eof?
-      @curtoken = Token.new( T_EOF, "", @chReader.sourcefile, @chReader.lineno, @chReader.column )
-    else
-      str = ch.chr
-      kind =
-        case str
-        when /[\']/
-          T_QUOTE
-        when /[\`]/
-          T_QUASIQUOTE
-        when /[,]/
-          str += readwhile( /[@]/, true )
-          if 1 == str.length
-            T_UNQUOTE
-          else
-            T_UNQUOTE_SPLICING
-          end
-        when '(', '['
-          T_LPAREN
-        when ')', ']'
-          T_RPAREN
-        when '.'
-          str += readwhile( /[_a-zA-Z0-9!?.]/ )
-          if 1 == str.length
-            T_DOT
-          else
-            T_SYMBOL
-          end
-        when /[\r\n]/
-          T_LINEFEED
-        when /;/
-          readwhile( /[^\r\n]/ )
-          str = ""
-          T_COMMENT
-        when /[#]/
-          nextch = peekchar( /[?!tfbodx(]/ )
-          case nextch
-          when "?"
-            if peekchar( /[=]/ )
-              str = ""
-              T_DEBUG_PRINT
+        str = ch.chr
+        kind =
+          case str
+          when /[\']/
+            T_QUOTE
+          when /[\`]/
+            T_QUASIQUOTE
+          when /[,]/
+            str += readwhile( /[@]/, true )
+            if 1 == str.length
+              T_UNQUOTE
             else
-              str += readwhile( /[^ \t\r\n]/ )
-              raise NameError, sprintf( "Error: unknown #xxxx syntax for Nendo %s", str )
-            end              
-          when "!"
+              T_UNQUOTE_SPLICING
+            end
+          when '(', '['
+            T_LPAREN
+          when ')', ']'
+            T_RPAREN
+          when '.'
+            str += readwhile( /[_a-zA-Z0-9!?.]/ )
+            if 1 == str.length
+              T_DOT
+            else
+              T_SYMBOL
+            end
+          when /[\r\n]/
+            T_LINEFEED
+          when /;/
             readwhile( /[^\r\n]/ )
             str = ""
             T_COMMENT
-          when "("
-            str = ""
-            T_LVECTOR
-          when "t"
-            str = "true"
-            T_SYMBOL
-          when "f"
-            str = "false"
-            T_SYMBOL
-          when "b","o","d","x"
-            str = readwhile( /[0-9a-zA-Z]/ )
+          when /[#]/
+            nextch = peekchar( /[?!tfbodx(]/ )
             case nextch
-            when "b"
-              if str.match( /^[0-1]+$/ )
-                str = "0b" + str
-              else
-                raise RuntimeError, sprintf( "Error: illegal #b number for Nendo #b%s", str )
-              end
-            when "o"
-              if str.match( /^[0-7]+$/ )
-                str = "0o" + str
-              else
-                raise RuntimeError, sprintf( "Error: illegal #o number for Nendo #o%s", str )
-              end
-            when "d"
-              if str.match( /^[0-9]+$/ )
-                str = "0d" + str
+            when "?"
+              if peekchar( /[=]/ )
+                str = ""
+                T_DEBUG_PRINT
               else
-                raise RuntimeError, sprintf( "Error: illegal #d number for Nendo #d%s", str )
-              end
-            when "x"
-              if str.match( /^[0-9a-fA-F]+$/ )
-                str = "0x" + str
-              else
-                raise RuntimeError, sprintf( "Error: illegal #x number for Nendo #x%s", str )
+                str += readwhile( /[^ \t\r\n]/ )
+                raise NameError, sprintf( "Error: unknown #xxxx syntax for Nendo %s", str )
+              end              
+            when "!"
+              readwhile( /[^\r\n]/ )
+              str = ""
+              T_COMMENT
+            when "("
+              str = ""
+              T_LVECTOR
+            when "t"
+              str = "true"
+              T_SYMBOL
+            when "f"
+              str = "false"
+              T_SYMBOL
+            when "b","o","d","x"
+              str = readwhile( /[0-9a-zA-Z]/ )
+              case nextch
+              when "b"
+                if str.match( /^[0-1]+$/ )
+                  str = "0b" + str
+                else
+                  raise RuntimeError, sprintf( "Error: illegal #b number for Nendo #b%s", str )
+                end
+              when "o"
+                if str.match( /^[0-7]+$/ )
+                  str = "0o" + str
+                else
+                  raise RuntimeError, sprintf( "Error: illegal #o number for Nendo #o%s", str )
+                end
+              when "d"
+                if str.match( /^[0-9]+$/ )
+                  str = "0d" + str
+                else
+                  raise RuntimeError, sprintf( "Error: illegal #d number for Nendo #d%s", str )
+                end
+              when "x"
+                if str.match( /^[0-9a-fA-F]+$/ )
+                  str = "0x" + str
+                else
+                  raise RuntimeError, sprintf( "Error: illegal #x number for Nendo #x%s", str )
+                end
               end
+              str = Integer( str ).to_s
+              T_NUM
+            else
+              str += readwhile( /[^ \t\r\n]/ )
+              raise NameError, sprintf( "Error: unknown #xxxx syntax for Nendo %s", str )
+            end
+          when /[_a-zA-Z!$%&*+\/:<=>?@^~-]/      # symbol
+            str += readwhile( /[0-9._a-zA-Z!$%&*+\/:<=>?@^~-]/ )
+            if str.match( /^[=][>]$/ )
+              T_FEEDTO
+            elsif str.match( /^[+-][0-9.]+$/ )
+              T_NUM
+            elsif str.match( /^[:]/ )
+              str = str[1..-1]
+              T_KEYWORD
+            else
+              T_SYMBOL
             end
-            str = Integer( str ).to_s
+          when /[0-9]/           # Numeric
+            str += readwhile( /[0-9.]/ )
             T_NUM
+          when /["]/             # String
+            str =  LispString.new( readstring() )
+            readwhile( /["]/ )
+            T_STRING
           else
             str += readwhile( /[^ \t\r\n]/ )
-            raise NameError, sprintf( "Error: unknown #xxxx syntax for Nendo %s", str )
+            raise NameError, sprintf( "Error: unknown token for Nendo [%s]", str )
           end
-        when /[_a-zA-Z!$%&*+\/:<=>?@^~-]/      # symbol
-          str += readwhile( /[0-9._a-zA-Z!$%&*+\/:<=>?@^~-]/ )
-          if str.match( /^[=][>]$/ )
-            T_FEEDTO
-          elsif str.match( /^[+-][0-9.]+$/ )
-            T_NUM
-          elsif str.match( /^[:]/ )
-            str = str[1..-1]
-            T_KEYWORD
+        printf( "    token: [%s] : %s   (%s:L%d:C%d)\n", str, kind.to_s, @chReader.sourcefile, @chReader.lineno, @chReader.column ) if @debug
+        @curtoken = Token.new( kind, str, @chReader.sourcefile, @chReader.lineno, @chReader.column )
+      end
+    end
+  
+    def token
+      begin
+        tokenWithComment
+      end while T_COMMENT == curtoken.kind
+      curtoken
+    end
+  
+    def curtoken
+      if !@curtoken
+        self.token
+      end
+      @curtoken
+    end
+  
+    def atom
+      cur = curtoken 
+      printf( "  NonT: [%s] : [%s]\n", "atom", cur.str ) if @debug
+      token
+      case cur.kind
+      when T_SYMBOL
+        sym = cur.str.intern
+        sym.setLispToken( cur )
+        case sym
+        when :true
+          true
+        when :false
+          false
+        when :nil
+          nil
+        else
+          sym
+        end
+      when T_NUM
+        if cur.str.match( /[.]/ ) # floating point
+          cur.str.to_f
+        else
+          cur.str.to_i
+        end
+      when T_STRING
+        cur.str
+      when T_QUOTE
+        :quote
+      when T_QUASIQUOTE
+        :quasiquote
+      when T_UNQUOTE
+        :unquote
+      when T_UNQUOTE_SPLICING
+        :"unquote-splicing"
+      when T_DOT
+        :"dot-operator"
+      when T_FEEDTO
+        :feedto
+      when T_DEBUG_PRINT
+        "debug-print".intern
+      when T_KEYWORD
+        LispKeyword.new( cur.str )
+      else
+        raise "Error: Unknown token in atom()"
+      end
+    end
+  
+    # vector := sexp 
+    #      | atom ... atom
+    def vector
+      printf( "  NonT: [%s]\n", "vector" ) if @debug
+      arr = []
+      while true
+        case curtoken.kind
+        when T_LINEFEED
+          token # skipEnter
+        when T_EOF
+          raise RuntimeError, "Error: unbalanced vector's paren(4)"
+        when T_LPAREN, T_LVECTOR
+          arr << sexp()
+        when T_RPAREN
+          break
+        when T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING, T_DEBUG_PRINT
+          arr << sexp()
+        when T_DOT
+          raise RuntimeError, "Error: illegal list."
+        else
+          arr << atom()
+        end
+      end
+      arr
+    end
+    
+    # list := sexp 
+    #      | atom ... atom
+    #      | atom ... . atom 
+    def list
+      printf( "  NonT: [%s]\n", "list" ) if @debug
+      dotted = false
+      cells = []
+      lastAtom = Nil.new
+      while true
+        case curtoken.kind
+        when T_LINEFEED
+          token # skipEnter
+        when T_EOF
+          raise RuntimeError, "Error: unbalanced paren(1)"
+        when T_LPAREN, T_LVECTOR
+          cells << Cell.new( sexp() )
+        when T_RPAREN
+          break
+        when T_DOT
+          if 0 == cells.length
+            # (. symbol1 symbol2 ... ) form
+            cells << Cell.new( atom() )
           else
-            T_SYMBOL
+            # ( symbol1 ... symbol2 . symbol3 ) form
+            token
+            lastAtom = sexp()
+            if lastAtom.is_a? Cell and lastAtom.isNull
+              lastAtom = Nil.new # the null list "()"  could not be a lastAtom.
+            end
           end
-        when /[0-9]/           # Numeric
-          str += readwhile( /[0-9.]/ )
-          T_NUM
-        when /["]/             # String
-          str =  LispString.new( readstring() )
-          readwhile( /["]/ )
-          T_STRING
+        when T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING, T_DEBUG_PRINT
+          cells << Cell.new( sexp() )
         else
-          str += readwhile( /[^ \t\r\n]/ )
-          raise NameError, sprintf( "Error: unknown token for Nendo [%s]", str )
+          if not lastAtom.is_a? Nil
+            raise "Error : illegal dotted pair syntax."
+          else
+            cells << Cell.new( atom() )
+          end
         end
-      printf( "    token: [%s] : %s   (%s:L%d:C%d)\n", str, kind.to_s, @chReader.sourcefile, @chReader.lineno, @chReader.column ) if @debug
-      @curtoken = Token.new( kind, str, @chReader.sourcefile, @chReader.lineno, @chReader.column )
-    end
-  end
-
-  def token
-    begin
-      tokenWithComment
-    end while T_COMMENT == curtoken.kind
-    curtoken
-  end
-
-  def curtoken
-    if !@curtoken
-      self.token
+      end
+      ## setup list
+      if 0 == cells.size
+        Cell.new() # null list
+      elsif 1 == cells.size
+        cells.first.cdr = lastAtom
+        cells.first
+      elsif 1 < cells.size
+        ptr = cells.pop
+        ptr.cdr = lastAtom
+        cells.reverse.each { |x|
+          x.cdr = ptr
+          ptr = x
+        }
+        cells.first
+      end
     end
-    @curtoken
-  end
-
-  def atom
-    cur = curtoken 
-    printf( "  NonT: [%s] : [%s]\n", "atom", cur.str ) if @debug
-    token
-    case cur.kind
-    when T_SYMBOL
-      sym = cur.str.intern
-      sym.setLispToken( cur )
-      case sym
-      when :true
-        true
-      when :false
-        false
-      when :nil
-        nil
-      else
-        sym
+  
+    def skipEnter
+      while T_LINEFEED == curtoken.kind
+        token
       end
-    when T_NUM
-      if cur.str.match( /[.]/ ) # floating point
-        cur.str.to_f
-      else
-        cur.str.to_i
-      end
-    when T_STRING
-      cur.str
-    when T_QUOTE
-      :quote
-    when T_QUASIQUOTE
-      :quasiquote
-    when T_UNQUOTE
-      :unquote
-    when T_UNQUOTE_SPLICING
-      :"unquote-splicing"
-    when T_DOT
-      :"dot-operator"
-    when T_FEEDTO
-      :feedto
-    when T_DEBUG_PRINT
-      "debug-print".intern
-    when T_KEYWORD
-      LispKeyword.new( cur.str )
-    else
-      raise "Error: Unknown token in atom()"
     end
-  end
-
-  # vector := sexp 
-  #      | atom ... atom
-  def vector
-    printf( "  NonT: [%s]\n", "vector" ) if @debug
-    arr = []
-    while true
+  
+    # sexp := ( list ) | | #( vector ) | 'sexp | `sexp | atom
+    def sexp
+      printf( "  NonT: [%s]\n", "sexp" ) if @debug
       case curtoken.kind
       when T_LINEFEED
-        token # skipEnter
+        token
+        sexp()
       when T_EOF
-        raise RuntimeError, "Error: unbalanced vector's paren(4)"
-      when T_LPAREN, T_LVECTOR
-        arr << sexp()
+        raise RuntimeError, "Error: unbalanced paren(2)"
+      when T_LPAREN
+        skipEnter
+        token # consume '('
+        ret = list()
+        skipEnter
+        token # consume ')'
+        ret
       when T_RPAREN
-        break
-      when T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING, T_DEBUG_PRINT
-        arr << sexp()
-      when T_DOT
-        raise RuntimeError, "Error: illegal list."
+        raise RuntimeError, "Error: unbalanced paren(3)"
+      when T_LVECTOR
+        skipEnter
+        token # consume '#('
+        ret = vector()
+        skipEnter
+        token # consume ')'
+        ret
+      when T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING
+        _atom = atom() ## "quote" symbol
+        Cell.new( _atom, Cell.new( sexp() ))
+      when T_DEBUG_PRINT
+        file   = curtoken.sourcefile
+        lineno = curtoken.lineno
+        _atom = atom() ## "debug-print" symbol
+        child = sexp() 
+        [_atom, child, LispString.new( file ), lineno, Cell.new( :quote, Cell.new( child )) ].to_list
       else
-        arr << atom()
+        atom()
       end
     end
-    arr
-  end
   
-  # list := sexp 
-  #      | atom ... atom
-  #      | atom ... . atom 
-  def list
-    printf( "  NonT: [%s]\n", "list" ) if @debug
-    dotted = false
-    cells = []
-    lastAtom = nil
-    while true
+    # return value is [ S-expression-tree, eof-flag, valid-sexp-flag ]
+    def _read
+      @chReader = CharReader.new( @inport, @sourcefile )  unless @chReader
       case curtoken.kind
-      when T_LINEFEED
-        token # skipEnter
       when T_EOF
-        raise RuntimeError, "Error: unbalanced paren(1)"
-      when T_LPAREN, T_LVECTOR
-        cells << Cell.new( sexp() )
-      when T_RPAREN
-        break
-      when T_DOT
-        if 0 == cells.length
-          # (. symbol1 symbol2 ... ) form
-          cells << Cell.new( atom() )
+        [ Nil.new, true,  false ]
+      when T_LINEFEED
+        token
+        [ Nil.new, false, false ]
+      else
+        [ sexp(),  false, true  ]
+      end
+    end
+  end
+  
+  
+  # built-in functions
+  module BuiltinFunctions
+    def __assertFlat( *args )
+      if 0 == args.length
+        raise ArgumentError, "Error: + - * / % operator got illegal argument. "
+      else
+        args.each { |x|
+          if Cell == x.class or Nil == x.class
+            raise ArgumentError, "Error: + - * / % operator got illegal argument. "
+          end
+        }
+      end
+    end
+    
+    def __assertList( funcname, arg )
+      if Cell != arg.class
+        raise ArgumentError, "Error: %s expects a list argument.\n"
+      end
+    end
+    
+    def _equal_QUMARK( a, b )
+      if a.class != b.class
+        false
+      elsif a.class == Cell
+        if a.isNull and b.isNull
+          true
         else
-          # ( symbol1 ... symbol2 . symbol3 ) form
-          token
-          lastAtom = sexp()
-          if lastAtom.is_a? Cell and lastAtom.isNull
-            lastAtom = Nil.new # the null list "()"  could not be a lastAtom.
+          _equal_QUMARK( a.car, b.car ) and _equal_QUMARK( a.cdr, b.cdr )
+        end
+      elsif a.class == Nil and b.class == Nil
+        true
+      else
+        (a === b)
+      end
+    end
+    
+    def __PLMARK( *args )
+      arr = args[0].to_arr
+      case args[0].length
+      when 0
+        0
+      else
+        __assertFlat( arr )
+        arr.each { |x| 
+          if not (_number_QUMARK(x) or _string_QUMARK(x))
+            raise TypeError
           end
+        }
+        case args[0].length
+        when 1
+          args[0].car
+        else
+          arr[1..-1].inject(arr[0]){|x,y| x+y}
         end
-      when T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING, T_DEBUG_PRINT
-        cells << Cell.new( sexp() )
+      end
+    end
+    
+    def __ASMARK( *args )
+      arr = args[0].to_arr
+      case args[0].length
+      when 0
+        1
       else
-        if lastAtom
-          raise "Error : illegal dotted pair syntax."
+        __assertFlat( arr )
+        arr.each { |x| 
+          if not _number_QUMARK(x)
+            raise TypeError
+          end
+        }
+        case args[0].length
+        when 1
+          args[0].car
         else
-          cells << Cell.new( atom() )
+          arr[1..-1].inject(arr[0]){|x,y| x*y}
         end
       end
     end
-    ## setup list
-    if 0 == cells.size
-      Cell.new() # null list
-    elsif 1 == cells.size
-      if lastAtom
-        cells.first.cdr = lastAtom
+  
+    def __MIMARK( first, *rest )
+      raise TypeError if not _number_QUMARK(first)
+      rest = rest[0].to_arr
+      __assertFlat( rest )
+      if 0 == rest.length 
+        - first
+      else
+        rest.inject(first){|x,y| x-y}
       end
-      cells.first
-    elsif 1 < cells.size
-      ptr = cells.pop
-      if lastAtom
-        ptr.cdr = lastAtom
+    end
+  
+    def __SLMARK( first, *rest )
+      raise TypeError if not _number_QUMARK(first)
+      rest = rest[0].to_arr
+      __assertFlat( rest )
+      if 0 == rest.length 
+        1 / first
+      else
+        rest.inject(first){|x,y| x/y}
       end
-      cells.reverse.each { |x|
-        x.cdr = ptr
-        ptr = x
-      }
-      cells.first
     end
-  end
-
-  def skipEnter
-    while T_LINEFEED == curtoken.kind
-      token
+    
+    def __PAMARK( first, *rest )
+      _modulo( first, *rest )
+    end
+    
+    def _quotient( first, second )
+      raise TypeError if not _number_QUMARK(first)
+      raise TypeError if not _number_QUMARK(second)
+      (first / second.to_f).to_i
+    end
+
+    def _remainder( first, second )
+      raise TypeError if not _number_QUMARK(first)
+      raise TypeError if not _number_QUMARK(second)
+      first - _quotient( first, second ) * second
+    end
+    
+    def _modulo( first, *rest )
+      raise TypeError if not _number_QUMARK(first)
+      rest = rest[0].to_arr
+      __assertFlat( rest )
+      if 0 == rest.length 
+        1 % first
+      else
+        rest.inject(first){|x,y| x%y}
+      end
     end
-  end
-
-  # sexp := ( list ) | | #( vector ) | 'sexp | `sexp | atom
-  def sexp
-    printf( "  NonT: [%s]\n", "sexp" ) if @debug
-    case curtoken.kind
-    when T_LINEFEED
-      token
-      sexp()
-    when T_EOF
-      raise RuntimeError, "Error: unbalanced paren(2)"
-    when T_LPAREN
-      skipEnter
-      token # consume '('
-      ret = list()
-      skipEnter
-      token # consume ')'
-      ret
-    when T_RPAREN
-      raise RuntimeError, "Error: unbalanced paren(3)"
-    when T_LVECTOR
-      skipEnter
-      token # consume '#('
-      ret = vector()
-      skipEnter
-      token # consume ')'
-      ret
-    when T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING
-      _atom = atom() ## "quote" symbol
-      Cell.new( _atom, Cell.new( sexp() ))
-    when T_DEBUG_PRINT
-      file   = curtoken.sourcefile
-      lineno = curtoken.lineno
-      _atom = atom() ## "debug-print" symbol
-      child = sexp() 
-      [_atom, child, LispString.new( file ), lineno, Cell.new( :quote, Cell.new( child )) ].to_list
-    else
-      atom()
+    
+    def _not( arg )
+      arg = false   if Nil == arg.class
+      not arg
+    end
+    
+    def _cons( first, second )
+      if first.is_a? Nil
+        first = Cell.new
+      end
+      if second.is_a? Cell
+        if second.isNull
+          Cell.new( first )
+        else
+          Cell.new( first, second )
+        end
+      else
+        Cell.new( first, second )
+      end
     end
-  end
 
-  # return value is [ S-expression-tree, eof-flag, valid-sexp-flag ]
-  def _read
-    case curtoken.kind
-    when T_EOF
-      [ Nil.new, true,  false ]
-    when T_LINEFEED
-      token
-      [ Nil.new, false, false ]
-    else
-      [ sexp(),  false, true  ]
+    def _set_MIMARKcar_EXMARK( cell, arg )
+      if cell.is_a? Cell
+        cell.car = arg
+        cell
+      else
+        raise TypeError
+      end
     end
-  end
-end
 
+    def _set_MIMARKcdr_EXMARK( cell, arg )
+      arg = if arg.is_a? Cell
+              _null_QUMARK( arg ) ? Nil.new : arg
+            else
+              arg
+            end
+      if cell.is_a? Cell
+        cell.cdr = arg
+        cell
+      else
+        raise TypeError
+      end
+    end
 
-# built-in functions
-module BuiltinFunctions
-  def __assertFlat( *args )
-    if 0 == args.length
-      raise ArgumentError, "Error: + - * / % operator got illegal argument. "
-    else
-      args.each { |x|
-        if Cell == x.class or Nil == x.class
-          raise ArgumentError, "Error: + - * / % operator got illegal argument. "
+    def _exit( *args )
+      if 0 == args[0].length
+        Kernel::exit(0)
+      else
+        arr = args[0].to_arr
+        Kernel::exit(arr[0])
+      end
+    end
+  
+    def _print( format, *rest )
+      print( format, *(rest[0].to_arr) )
+    end
+  
+    def _printf( format, *rest )
+      Kernel::printf( format, *(rest[0].to_arr) )
+    end
+  
+    def _sprintf( format, *rest )
+      Kernel::sprintf( format, *(rest[0].to_arr) )
+    end
+  
+    def _null_QUMARK( arg )
+      if Nil == arg.class
+        true
+      elsif Cell == arg.class
+        arg.isNull
+      else
+        false
+      end
+    end
+    def _length(   arg )
+      if _null_QUMARK( arg )
+        0
+      elsif arg.is_a? Cell
+        arg.length
+      else
+        raise TypeError
+      end
+    end
+    def _list(    *args)           args[0] end
+    def _sort(     arg )           arg.to_arr.sort.to_list end
+    def _reverse(  arg )           arg.to_arr.reverse.to_list end
+    def _uniq(     arg )           arg.to_arr.uniq.to_list end
+    def _range(    num, *args )
+      arr = args[0].to_arr
+      if 0 < arr.length
+        if arr[0].is_a? Fixnum
+          (0..num-1).to_a.map { |x| x + arr[0] }.to_list
+        else
+          raise TypeError, "Error range's start expects number."
+        end
+      else
+        (0..num-1).to_a.to_list
+      end
+    end
+    def __EQMARK(      a,b )        a ==  b end
+    def __GTMARK(      a,b )        a >   b end
+    def __GTMARK_EQMARK(      a,b ) a >=  b end
+    def __LTMARK(      a,b )        a <   b end
+    def __LTMARK_EQMARK(      a,b ) a <=  b end
+    def _eqv_QUMARK(     a,b )      a === b end
+    def _eq_QUMARK(      a,b )      a ==  b end
+    def _gt_QUMARK(      a,b )      a >   b end
+    def _ge_QUMARK(      a,b )      a >=  b end
+    def _lt_QUMARK(      a,b )      a <   b end
+    def _le_QUMARK(      a,b )      a <=  b end
+    def _eqv_QUMARK(     a,b )      a === b end
+    def _car(      cell )          cell.car end
+    def _cdr(      cell )          cell.cdr end
+    def _write(  arg  )            printer = Printer.new ; print printer._write( arg ) ; arg end
+    def _write_MIMARKto_MIMARKstring(  arg  )  printer = Printer.new ; printer._write( arg )             end
+    def _display(  arg  )          printer = Printer.new ; print printer._print( arg ) ; arg end
+    def _print(  arg  )            self._display( arg )  ; self._newline() ; arg             end
+    def _newline(       )          print "\n" end
+    def _procedure_QUMARK( arg )   ((Proc == arg.class) or (Method == arg.class)) end
+    def _macro_QUMARK( arg )       (LispMacro == arg.class) end
+    def _symbol_QUMARK(    arg )   (Symbol == arg.class) end
+    def _keyword_QUMARK(    arg )  (arg.is_a? LispKeyword) end
+    def _pair_QUMARK(      arg )   
+      if _null_QUMARK( arg )
+        false
+      else
+        (Cell == arg.class)
+      end
+    end
+    def _integer_QUMARK(   arg )   arg.is_a? Integer   end
+    def _number_QUMARK(   arg )    arg.is_a? Numeric   end
+    def _string_QUMARK(   arg )    String == arg.class end
+    def _macroexpand_MIMARK1( arg )
+      if _pair_QUMARK( arg )
+        macroexpandInit( 1 )
+        macroexpandEngine( arg )
+      else
+        arg
+      end
+    end
+    def _to_s( arg )                    _to_MIMARKs( arg ) end
+    def _to_MIMARKs( arg )              arg.to_s    end
+    def _to_i( arg )                    _to_MIMARKi( arg ) end
+    def _to_MIMARKi( arg )              arg.to_i    end
+    def _nil_QUMARK(   arg )            arg.nil?    end
+    def _to_list( arg )                 _to_MIMARKlist( arg ) end
+    def _to_MIMARKlist( arg )
+      case arg
+      when Array
+        arg.to_list
+      when Cell
+        arg
+      else
+        raise TypeError
+      end
+    end
+    def _to_arr( arg )                 _to_MIMARKarr( arg ) end
+    def _to_MIMARKarr( arg )
+      case arg
+      when Cell
+        arg.to_arr
+      when Array
+        arg
+      else
+        raise TypeError
+      end
+    end
+    def _intern( arg )                            arg.intern  end
+    def _string_MIMARK_GTMARKsymbol( arg )        arg.intern  end
+    def _symbol_MIMARK_GTMARKstring( arg )        arg.to_s    end
+    def _string_MIMARKjoin( lst, *args )
+      arr = args[0].to_arr
+      if 0 < arr.length
+        if not arr[0].is_a? String
+          raise TypeError, "Error string-join's expects delimitter as String."
+        else
+          lst.to_a.map{ |x| x.car }.join( arr[0] )
+        end
+      else
+        lst.to_a.map{ |x| x.car }.join
+      end
+    end
+    def _require( arg )
+      Kernel::require( arg )
+      false
+    end
+    def _read( *args )
+      lst = args[0].to_arr
+      io = if 0 == lst.length
+             STDIN
+           else
+             lst[0]
+           end
+      reader = Reader.new( io, "STDIN", false )
+      ret = nil
+      begin
+        s = reader._read
+        ret = s[0]
+        if s[1] # EOF?
+          ret = Cell.new
+          break
         end
-      }
+      end until s[2]
+      ret
     end
-  end
   
-  def __assertList( funcname, arg )
-    if Cell != arg.class
-      raise ArgumentError, "Error: %s expects a list argument.\n"
+    def _apply1( first, arg )
+      trampCall( callProcedure( "(apply1 genereate func)", first, arg ))
     end
-  end
   
-  def _equal_QUMARK( a, b )
-    if a.class != b.class
-      false
-    elsif a.class == Cell
-      if a.isNull and b.isNull
-        true
+    def _global_MIMARKvariables
+      self.instance_variables.select { |x|
+        x.match( /^[@]_[a-zA-Z]/ )
+      }.map{ |name| 
+        self.toLispSymbol( name[1..-1] ).intern
+      }.to_list
+    end
+  
+    def _make_MIMARKvalues( lst )
+      if _pair_QUMARK( lst )
+        LispValues.new( lst.to_arr )
+      elsif _null_QUMARK( lst )
+        LispValues.new( [] )
       else
-        _equal_QUMARK( a.car, b.car ) and _equal_QUMARK( a.cdr, b.cdr )
+        raise ArgumentError, "Error: make-values expects a list argument."
       end
-    elsif a.class == Nil and b.class == Nil
-      true
-    else
-      (a === b)
     end
-  end
   
-  def __PLMARK( *args )
-    arr = args[0].to_arr
-    case args[0].length
-    when 0
-      0
-    else
-      __assertFlat( arr )
-      arr.each { |x| 
-        if not (_number_QUMARK(x) or _string_QUMARK(x))
-          raise TypeError
-        end
-      }
-      case args[0].length
-      when 1
-        args[0].car
+    def _values_QUMARK( arg )     arg.is_a? LispValues   end
+  
+    def _values_MIMARKvalues( arg )
+      if _values_QUMARK( arg )
+        arg.values.to_list
       else
-        arr[1..-1].inject(arr[0]){|x,y| x+y}
+        raise TypeError, "Error: values-values expects only LispValues object."
       end
     end
-  end
   
-  def __ASMARK( *args )
-    arr = args[0].to_arr
-    case args[0].length
-    when 0
-      1
-    else
-      __assertFlat( arr )
-      arr.each { |x| 
-        if not _number_QUMARK(x)
-          raise TypeError
-        end
-      }
-      case args[0].length
-      when 1
-        args[0].car
+    def _make_MIMARKkeyword( arg )
+      if _symbol_QUMARK(    arg ) or _string_QUMARK(    arg )
+        LispKeyword.new( arg.to_s )
       else
-        arr[1..-1].inject(arr[0]){|x,y| x*y}
+        raise TypeError, "Error: make-keyword expects symbol or string object."
       end
     end
-  end
-
-  def __MIMARK( first, *rest )
-    raise TypeError if not _number_QUMARK(first)
-    rest = rest[0].to_arr
-    __assertFlat( rest )
-    if 0 == rest.length 
-      - first
-    else
-      rest.inject(first){|x,y| x-y}
-    end
-  end
-
-  def __SLMARK( first, *rest )
-    raise TypeError if not _number_QUMARK(first)
-    rest = rest[0].to_arr
-    __assertFlat( rest )
-    if 0 == rest.length 
-      1 / first
-    else
-      rest.inject(first){|x,y| x/y}
-    end
-  end
-
-  def __PAMARK( first, *rest )
-    raise TypeError if not _number_QUMARK(first)
-    rest = rest[0].to_arr
-    __assertFlat( rest )
-    if 0 == rest.length 
-      1 % first
-    else
-      rest.inject(first){|x,y| x%y}
-    end
-  end
-
-  def _not( arg )
-    arg = false   if Nil == arg.class
-    not arg
-  end
-
-  def _cons( first, second )
-    if second.is_a? Cell
-      if second.isNull
-        Cell.new( first )
+  
+    def _keyword_MIMARK_GTMARKstring( arg )
+      if _keyword_QUMARK(    arg )
+        arg.key.to_s
       else
-        Cell.new( first, second )
+        raise TypeError, "Error: keyword->string expects only keyword object."
       end
-    else
-      Cell.new( first, second )
-    end
-  end
-
-  def _exit( *args )
-    if 0 == args[0].length
-      Kernel::exit(0)
-    else
-      arr = args[0].to_arr
-      Kernel::exit(arr[0])
-    end
-  end
-
-  def _print( format, *rest )
-    print( format, *(rest[0].to_arr) )
-  end
-
-  def _printf( format, *rest )
-    Kernel::printf( format, *(rest[0].to_arr) )
-  end
-
-  def _sprintf( format, *rest )
-    Kernel::sprintf( format, *(rest[0].to_arr) )
-  end
-
-  def _null_QUMARK( arg )
-    if Nil == arg.class
-      true
-    elsif Cell == arg.class
-      arg.isNull
-    else
-      false
     end
-  end
-  def _length(   arg )
-    if _null_QUMARK( arg )
-      0
-    elsif arg.is_a? Cell
-      arg.length
-    else
-      raise TypeError
+  
+    def _get_MIMARKnendo_MIMARKhome
+      File.dirname(__FILE__) 
     end
-  end
-  def _list(    *args)           args[0] end
-  def _sort(     arg )           arg.to_arr.sort.to_list end
-  def _reverse(  arg )           arg.to_arr.reverse.to_list end
-  def _uniq(     arg )           arg.to_arr.uniq.to_list end
-  def _range(    num, *args )
-    arr = args[0].to_arr
-    if 0 < arr.length
-      if arr[0].is_a? Fixnum
-        (0..num-1).to_a.map { |x| x + arr[0] }.to_list
+  
+    def _hash_MIMARKtable_MIMARKget( h, key, *args )
+      if !((key.is_a? String) or ( key.is_a? Symbol))
+        raise TypeError, "Error: argument key requires String or Symbol.\n"
+      end
+      if h.has_key?( key )
+        h[key]
       else
-        raise TypeError, "Error range's start expects number."
+        arr = args[0].to_arr
+        if 0 < arr.length
+          arr[0]
+        else
+          raise RuntimeError, sprintf( "Error: in hash-table-get()  key [%s] was not exist.\n", key )
+        end
       end
-    else
-      (0..num-1).to_a.to_list
     end
-  end
-  def __EQMARK(      a,b )        a ==  b end
-  def __GTMARK(      a,b )        a >   b end
-  def __GTMARK_EQMARK(      a,b ) a >=  b end
-  def __LTMARK(      a,b )        a <   b end
-  def __LTMARK_EQMARK(      a,b ) a <=  b end
-  def _eqv_QUMARK(     a,b )      a === b end
-  def _eq_QUMARK(      a,b )      a ==  b end
-  def _gt_QUMARK(      a,b )      a >   b end
-  def _ge_QUMARK(      a,b )      a >=  b end
-  def _lt_QUMARK(      a,b )      a <   b end
-  def _le_QUMARK(      a,b )      a <=  b end
-  def _eqv_QUMARK(     a,b )      a === b end
-  def _car(      cell )          cell.car end
-  def _cdr(      cell )          cell.cdr end
-  def _write(  arg  )            printer = Printer.new ; print printer._write( arg ) ; arg end
-  def _write_MIMARKto_MIMARKstring(  arg  )  printer = Printer.new ; printer._write( arg )             end
-  def _display(  arg  )          printer = Printer.new ; print printer._print( arg ) ; arg end
-  def _print(  arg  )            self._display( arg )  ; self._newline() ; arg             end
-  def _newline(       )          print "\n" end
-  def _procedure_QUMARK( arg )   ((Proc == arg.class) or (Method == arg.class)) end
-  def _macro_QUMARK( arg )       (LispMacro == arg.class) end
-  def _symbol_QUMARK(    arg )   (Symbol == arg.class) end
-  def _keyword_QUMARK(    arg )  (arg.is_a? LispKeyword) end
-  def _pair_QUMARK(      arg )   
-    if _null_QUMARK( arg )
-      false
-    else
-      (Cell == arg.class)
+  
+    def _hash_MIMARKtable_MIMARKput_EXMARK( h, key, value )
+      if !((key.is_a? String) or ( key.is_a? Symbol))
+        raise TypeError, "Error: argument key requires String or Symbol.\n"
+      end
+      h[key] = value
     end
-  end
-  def _number_QUMARK(   arg )    arg.is_a? Numeric   end
-  def _string_QUMARK(   arg )    String == arg.class end
-  def _macroexpand_MIMARK1( arg )
-    if _pair_QUMARK( arg )
-      macroexpand_1( arg )
-    else
-      arg
+  
+    # backtrace expects this format "filename:lineno: place message ". e.g.  "init.nnd:10: in aaa macro.".
+    def _raise( exception, message, backtrace )
+      raise exception, message, [ backtrace ]
     end
-  end
-  def _to_s( arg )                    _to_MIMARKs( arg ) end
-  def _to_MIMARKs( arg )              arg.to_s    end
-  def _to_i( arg )                    _to_MIMARKi( arg ) end
-  def _to_MIMARKi( arg )              arg.to_i    end
-  def _nil_QUMARK(   arg )            arg.nil?    end
-  def _to_list( arg )                 _to_MIMARKlist( arg ) end
-  def _to_MIMARKlist( arg )
-    case arg
-    when Array
-      arg.to_list
-    when Cell
-      arg
-    else
-      raise TypeError
+  
+    def __ASMARKLINE_ASMARK()
+      @lastLineno
     end
-  end
-  def _to_arr( arg )                 _to_MIMARKarr( arg ) end
-  def _to_MIMARKarr( arg )
-    case arg
-    when Cell
-      arg.to_arr
-    when Array
-      arg
-    else
-      raise TypeError
+  
+    def __ASMARKFILE_ASMARK()
+      @lastSourcefile
     end
-  end
-  def _intern( arg )                            arg.intern  end
-  def _string_MIMARK_GTMARKsymbol( arg )        arg.intern  end
-  def _symbol_MIMARK_GTMARKstring( arg )        arg.to_s    end
-  def _string_MIMARKjoin( lst, *args )
-    arr = args[0].to_arr
-    if 0 < arr.length
-      if not arr[0].is_a? String
-        raise TypeError, "Error string-join's expects delimitter as String."
-      else
-        lst.to_a.map{ |x| x.car }.join( arr[0] )
+  
+    def _vector_MIMARKset_EXMARK( v, index, value )
+      if !(v.is_a? Array)
+        raise TypeError, "Error: vector-set! requires Array as argument v(Lisp's vector).\n"
       end
-    else
-      lst.to_a.map{ |x| x.car }.join
+      if (index < 0) or (v.size <= index)
+        raise ArgumentError, "Error: vector-set! requires index  between 0 and (size-1) number.\n"
+      end
+      v[index] = value
     end
   end
-  def _require( arg )
-    Kernel::require( arg )
-    false
-  end
-  def _read( *args )
-    lst = args[0].to_arr
-    io = if 0 == lst.length
-           STDIN
-         else
-           lst[0]
-         end
-    reader = Reader.new( io, "STDIN", false )
-    ret = nil
-    begin
-      s = reader._read
-      ret = s[0]
-      if s[1] # EOF?
-        ret = Cell.new
-        break
-      end
-    end until s[2]
-    ret
-  end
-
-  def _apply1( first, arg )
-    callProcedure( "(apply1 genereate func)", first, arg )
-  end
-
-  def _global_MIMARKvariables
-    self.instance_variables.select { |x|
-      x.match( /^[@]_[a-zA-Z]/ )
-    }.map{ |name| 
-      self.toLispSymbol( name[1..-1] ).intern
-    }.to_list
-  end
+  
+  
+  # Translate S expression to Ruby expression and Evaluation
+  class Evaluator
+    include BuiltinFunctions
+    EXEC_TYPE_NORMAL    = 1
+    EXEC_TYPE_ANONYMOUS = 2
+    EXEC_TYPE_TAILCALL  = 3
+
+    def initialize( debug = false )
+      @indent  = "  "
+      @binding = binding
+      @debug   = debug
+      @char_table_lisp_to_ruby = {
+        # list     (! $ % & * + - . / : < = > ? @ ^ _ ~)
+        '!' => '_EXMARK',
+        '$' => '_DOMARK',
+        '%' => '_PAMARK',
+        '&' => '_ANMARK',
+        '*' => '_ASMARK',
+        '+' => '_PLMARK',
+        '-' => '_MIMARK',
+        # '.'
+        '/' => '_SLMARK',
+        ':' => '_COMARK',
+        '<' => '_LTMARK',
+        '=' => '_EQMARK',
+        '>' => '_GTMARK',
+        '?' => '_QUMARK',
+        '@' => '_ATMARK',
+        '^' => '_NKMARK',
+        # '_'
+        '~' => '_CHMARK',
+      }
+      @char_table_ruby_to_lisp = @char_table_lisp_to_ruby.invert
+  
+      # toplevel binding
+      @global_lisp_binding = Hash.new
+  
+      # initialize buildin functions as Proc objects
+      rubyExp = self.methods.select { |x|
+        x.to_s.match( /^_/ )
+      }.map { |name|
+        [
+         defMethodStr( name ),
+         sprintf( "@%s                        = self.method( :%s        ).to_proc", name, name ),
+         sprintf( "@global_lisp_binding['%s'] = self.method( :%s_METHOD ).to_proc", name, name ),
+        ].join( " ; " )
+      }.join( " ; " )
+      eval( rubyExp, @binding )
+  
+      # reset gensym counter
+      @gensym_counter = 0
 
-  def _make_MIMARKvalues( lst )
-    if _pair_QUMARK( lst )
-      LispValues.new( lst.to_arr )
-    elsif _null_QUMARK( lst )
-      LispValues.new( [] )
-    else
-      raise ArgumentError, "Error: make-values expects a list argument."
+      # init optimize level
+      @optimize_level = 1
+  
+      # compiled ruby code
+      #  { 'filename1' => [ 'code1' 'code2' ... ], 
+      #    'filename2' => [ 'code1' 'code2' ... ], ... }
+      @compiled_code = Hash.new
+      
+      global_lisp_define( toRubySymbol( "%compile-phase-functions" ), Cell.new())
     end
-  end
-
-  def _values_QUMARK( arg )     arg.is_a? LispValues   end
-
-  def _values_MIMARKvalues( arg )
-    if _values_QUMARK( arg )
-      arg.values.to_list
-    else
-      raise TypeError, "Error: values-values expects only LispValues object."
+  
+    def global_lisp_define( rubySymbol, val )
+      @___tmp = val
+      eval( sprintf( "@%s = @___tmp;", rubySymbol ), @binding )
+      eval( sprintf( "@global_lisp_binding['%s'] = @___tmp;", rubySymbol ), @binding )
     end
-  end
-
-  def _make_MIMARKkeyword( arg )
-    if _symbol_QUMARK(    arg ) or _string_QUMARK(    arg )
-      LispKeyword.new( arg.to_s )
-    else
-      raise TypeError, "Error: make-keyword expects symbol or string object."
+  
+    def setArgv( argv )
+      self.global_lisp_define( toRubySymbol( "*argv*"), argv.to_list )
     end
-  end
 
-  def _keyword_MIMARK_GTMARKstring( arg )
-    if _keyword_QUMARK(    arg )
-      arg.key.to_s
-    else
-      raise TypeError, "Error: keyword->string expects only keyword object."
+    def setOptimizeLevel( level )
+      @optimize_level = level
     end
-  end
-
-  def _get_MIMARKnendo_MIMARKhome
-    File.dirname(__FILE__) 
-  end
 
-  def _hash_MIMARKtable_MIMARKget( h, key, *args )
-    if !((key.is_a? String) or ( key.is_a? Symbol))
-      raise TypeError, "Error: argument key requires String or Symbol.\n"
+    def getOptimizeLevel
+      @optimize_level
     end
-    if h.has_key?( key )
-      h[key]
-    else
-      arr = args[0].to_arr
-      if 0 < arr.length
-        arr[0]
-      else
-        raise RuntimeError, sprintf( "Error: in hash-table-get()  key [%s] was not exist.\n", key )
-      end
-    end
-  end
-
-  def _hash_MIMARKtable_MIMARKput_EXMARK( h, key, value )
-    if !((key.is_a? String) or ( key.is_a? Symbol))
-      raise TypeError, "Error: argument key requires String or Symbol.\n"
+  
+    def defMethodStr( name )
+      sprintf( "def self.%s_METHOD( origname, pred, args ) callProcedure( origname, pred, args ) end", name )
     end
-    h[key] = value
-  end
-
-  # backtrace expects this format "filename:lineno: place message ". e.g.  "init.nnd:10: in aaa macro.".
-  def _raise( exception, message, backtrace )
-    raise exception, message, [ backtrace ]
-  end
-
-  def __ASMARKLINE_ASMARK()
-    @lastLineno
-  end
-
-  def __ASMARKFILE_ASMARK()
-    @lastSourcefile
-  end
 
-  def _vector_MIMARKset_EXMARK( v, index, value )
-    if !(v.is_a? Array)
-      raise TypeError, "Error: vector-set! requires Array as argument v(Lisp's vector).\n"
+    def _gensym( )
+      @gensym_counter += 1
+      filename = if @lastSourcefile.is_a? String
+                   Digest::SHA1.hexdigest( @lastSourcefile )
+                 else
+                   ""
+                 end
+      sprintf( "__gensym__%s_%d", filename, @gensym_counter ).intern
     end
-    if (index < 0) or (v.size <= index)
-      raise ArgumentError, "Error: vector-set! requires index  between 0 and (size-1) number.\n"
+    
+    def forward_gensym_counter( )
+      @gensym_counter += 10000
     end
-    v[index] = value
-  end
-end
-
-
-# Translate S expression to Ruby expression and Evaluation
-class Evaluator
-  include BuiltinFunctions
-  def initialize( debug = false )
-    @indent  = "  "
-    @binding = binding
-    @debug   = debug
-    @char_table_lisp_to_ruby = {
-      # list     (! $ % & * + - . / : < = > ? @ ^ _ ~)
-      '!' => '_EXMARK',
-      '$' => '_DOMARK',
-      '%' => '_PAMARK',
-      '&' => '_ANMARK',
-      '*' => '_ASMARK',
-      '+' => '_PLMARK',
-      '-' => '_MIMARK',
-      # '.'
-      '/' => '_SLMARK',
-      ':' => '_COMARK',
-      '<' => '_LTMARK',
-      '=' => '_EQMARK',
-      '>' => '_GTMARK',
-      '?' => '_QUMARK',
-      '@' => '_ATMARK',
-      '^' => '_NKMARK',
-      # '_'
-      '~' => '_CHMARK',
-    }
-    @char_table_ruby_to_lisp = @char_table_lisp_to_ruby.invert
-
-    # toplevel binding
-    @global_lisp_binding = Hash.new
-
-    # built-in functions
-    self.methods.grep( /^_/ ) { |rubySymbol|
-      global_lisp_define( rubySymbol, self.method( rubySymbol ))
-    }
-
-    # initialize buildin functions as Proc objects
-    rubyExp = self.methods.select { |x|
-      x.to_s.match( /^_/ )
-    }.map { |name|
-      sprintf( "@%s = self.method( :%s ).to_proc", name, name )
-    }.join( " ; " )
-    eval( rubyExp, @binding )
-
-    # reset gensym counter
-    @gensym_counter = 0
-
-    # compiled ruby code
-    #  { 'filename1' => [ 'code1' 'code2' ... ], 
-    #    'filename2' => [ 'code1' 'code2' ... ], ... }
-    @compiled_code = Hash.new
-  end
-
-  def global_lisp_define( rubySymbol, val )
-    @___tmp = val
-    eval( sprintf( "@%s = @___tmp;", rubySymbol ), @binding )
-    eval( sprintf( "@global_lisp_binding['%s'] = true;", rubySymbol ), @binding )
-  end
-
-  def setArgv( argv )
-    self.global_lisp_define( toRubySymbol( "*argv*"), argv.to_list )
-  end
-
-  def _gensym( )
-    @gensym_counter += 1
-    filename = if @lastSourcefile.is_a? String
-                 Digest::SHA1.hexdigest( @lastSourcefile )
-               else
-                 ""
-               end
-    sprintf( "__gensym__%s_%d", filename, @gensym_counter ).intern
-  end
   
-  def forward_gensym_counter( )
-    @gensym_counter += 10000
-  end
-
-  def toRubyValue( val )
-    if NilClass == val.class
-      "nil"
-    elsif TrueClass == val.class
-      val.to_s
-    elsif FalseClass == val.class
-      val.to_s
-    else
-      val.to_s
-    end
-  end
-
-  def toRubySymbol( name )
-    name = name.to_s  if Symbol == name.class
-    if 0 == name.length
-      ""
-    else
-      arr = name.gsub( /["]/, '' ).split( /[.]/ )
-      tmp = arr[0]
-      tmp.gsub!( /[:][:]/, "  " ) # save '::'
-      @char_table_lisp_to_ruby.each_pair { |key,val|
-        tmp.gsub!( Regexp.new( Regexp.escape( key )), val )
-      }
-      arr[0] = tmp.gsub( /[ ][ ]/, "::" )
-      if arr[0].match( /^[A-Z]/ )
-        # nothing to do
-      elsif arr[0] == ""
-        arr[0] = 'Kernel'
+    def toRubyValue( val )
+      if NilClass == val.class
+        "nil"
+      elsif TrueClass == val.class
+        val.to_s
+      elsif FalseClass == val.class
+        val.to_s
       else
-        arr[0] = '_' + arr[0]
+        val.to_s
       end
-      arr.join( "." )
     end
-  end
-
-  def isRubyInterface( name )
-    name.to_s.match( /[.]/ )
-  end
-
-  def toLispSymbol( name )
-    name = name.to_s  if Symbol == name.class
-    raise ArgumentError, sprintf( "Error: `%s' is not a lisp symbol", name ) if not ('_' == name[0])
-    name = name[1..-1]
-    @char_table_ruby_to_lisp.each_pair { |key,val|
-      name = name.gsub( Regexp.new( key ), val )
-    }
-    name
-  end
-
-  def toRubyArgument( origname, pred, args )
-    argument_error_message = sprintf( "Error: wrong number of arguments for closure `%s'", origname )
-    num = pred.arity
-    if 0 == num
-      raise ArgumentError, argument_error_message if 0 != args.length
-      []
-    elsif 0 < num
-      if args.isNull
-        [ Nil.new ]
+  
+    def toRubySymbol( name )
+      name = name.to_s  if Symbol == name.class
+      if 0 == name.length
+        ""
       else
-        raise ArgumentError, argument_error_message if num != args.length
-        args.map { |x|  x.car }
-      end
-    else
-      num = num.abs( )-1
-      raise ArgumentError, argument_error_message if num > args.length
-      params = []
-      rest = []
-      args.each_with_index { |x,i|
-        if i < num
-          params << x.car
+        arr = name.gsub( /["]/, '' ).split( /[.]/ )
+        tmp = arr[0]
+        tmp.gsub!( /[:][:]/, "  " ) # save '::'
+        @char_table_lisp_to_ruby.each_pair { |key,val|
+          tmp.gsub!( Regexp.new( Regexp.escape( key )), val )
+        }
+        arr[0] = tmp.gsub( /[ ][ ]/, "::" )
+        if arr[0].match( /^[A-Z]/ )
+          # nothing to do
+        elsif arr[0] == ""
+          arr[0] = 'Kernel'
         else
-          rest   << x.car
+          arr[0] = '_' + arr[0]
         end
-      }
-      result = []
-      if 0 < params.length
-        result = params
+        arr.join( "." )
       end
-      if 0 == rest.length
-        result << Cell.new
-      else
-        result << rest.to_list
-      end
-      result
     end
-  end
-
-  def callProcedure( origname, pred, args )
-    rubyArgument = toRubyArgument( origname, pred, args )
-    pred.call( *rubyArgument )
-  end
-
-  # for code generation of Ruby's argument values
-  # in case:  str = ","
-  # [1,"2",3] => [ 
-  #                [ 1,  ","]
-  #                ["2", ","]
-  #                [ 3 ]
-  #              ]
-  def separateWith( arr, str )
-    seps = []
-    (arr.length-1).times {|n| seps << str }
-    arr.zip( seps ).map{ |x|
-      x.select { |elem| elem }
-    }
-  end
-
-  def execFunc( funcname, args, sourcefile, lineno, locals, lambda_flag )
-    case funcname
-    when :define, :set!   # `define' special form
-      ar = args.cdr.map { |x| x.car }
-      variable_sym = toRubySymbol( args.car.to_s.sub( /^:/, "" ))
-      global_cap = locals.flatten.include?( variable_sym.split( /[.]/ )[0] ) ? nil : "@"
-      [ "begin",
-        [
-         sprintf( "@global_lisp_binding['%s'] = true", variable_sym ),
-         sprintf( "%s%s = ", global_cap, variable_sym ),
-         ar ],
-        "end" ]
-    when :error
-      [
-       'begin raise RuntimeError, ',
-       args.car,
-       "rescue => __e ",
-       sprintf( "  __e.set_backtrace( [\"%s:%d\"] + __e.backtrace )", sourcefile, lineno ),
-       "  raise __e",
-       "end "]
-    else
-      if (not lambda_flag) and isRubyInterface( funcname )
-        # Ruby method
-        #   1) convert arguments
-        translatedArr  = args.map { |x| x.car }
-        #   2) generate caller code part
-        lispSymbolReference( toRubySymbol( funcname ), locals, translatedArr, sourcefile, lineno )
-      else
-        # Nendo function
-        if 0 == args.length
-          arr = [ "Cell.new(" ]
+  
+    def isRubyInterface( name )
+      name.to_s.match( /[.]/ )
+    end
+  
+    def toLispSymbol( name )
+      name = name.to_s  if Symbol == name.class
+      raise ArgumentError, sprintf( "Error: `%s' is not a lisp symbol", name ) if not ('_' == name[0])
+      name = name[1..-1]
+      @char_table_ruby_to_lisp.each_pair { |key,val|
+        name = name.gsub( Regexp.new( key ), val )
+      }
+      name
+    end
+  
+    def toRubyArgument( origname, pred, args )
+      argument_error_message = sprintf( "Error: wrong number of arguments for closure `%s'", origname )
+      num = pred.arity
+      if 0 == num
+        raise ArgumentError, argument_error_message if 0 != args.length
+        []
+      elsif 0 < num
+        if args.isNull
+          [ Nil.new ]
         else
-          arr = separateWith( args.map.with_index { |x,i| x.car }, ",Cell.new(" )
-          arr[0].unshift( "Cell.new(" )
+          raise ArgumentError, argument_error_message if num != args.length
+          args.map { |x|  x.car }
+        end
+      else
+        num = num.abs( )-1
+        raise ArgumentError, argument_error_message if num > args.length
+        params = []
+        rest = []
+        args.each_with_index { |x,i|
+          if i < num
+            params << x.car
+          else
+            rest   << x.car
+          end
+        }
+        result = []
+        if 0 < params.length
+          result = params
         end
-        if lambda_flag
-          [sprintf( "callProcedure( 'anonymouse', " ),
-           [ funcname ] + [ "," ],
-           arr,
-           sprintf( "             )" ) + arr.map { |n| ")" }.join]
+        if 0 == rest.length
+          result << Cell.new
         else
-          origname = funcname.to_s
-          funcname = funcname.to_s
-          sym      = toRubySymbol( funcname )
-          [sprintf( "callProcedure( '%s',", origname ),
-           [lispSymbolReference( sym, locals, nil, sourcefile, lineno )] + [","],
-           arr,
-           sprintf( "             )" ) + arr.map { |n| ")" }.join]
+          result << rest.to_list
         end
+        result
       end
     end
-  end
+  
+    def trampCall( result )
+      while result.is_a? DelayedCallPacket
+        method_name = toRubySymbol( result.origname ) + "_METHOD"
+        @tmp_origname = result.origname
+        @tmp_pred     = result.pred
+        @tmp_args     = result.args
+        result = eval( sprintf( "self.%s( @tmp_origname, @tmp_pred, @tmp_args )", method_name ), @binding )
+      end
+      result
+    end
 
-  def makeBegin( args, locals )
-    ar = args.map { |e|
-      translate( e.car, locals )
-    }
-    ["begin", ar, "end"]
-  end
+    def method_missing( name, *args )
+      sym = toRubySymbol( name );
+      if @global_lisp_binding[name].is_a? Proc
+        @global_lisp_binding[name].call( args[0], args[1], args[2] )
+      else
+        callProcedure( args[0], args[1], args[2] )
+      end
+    end
 
-  # returns [ argsyms[], string ]
-  def toRubyParameter( argform )
-    argsyms = []
-    locals = []
-    rest = nil
-    if Symbol == argform.class
-      rest       = argform
-    else
-      argsyms    = argform.map { |x|  toRubySymbol( x.car ) }
-      locals     = argsyms.clone
-      rest       = argform.lastAtom
-    end
-    if rest
-      rest       = toRubySymbol( rest ) 
-      locals     << rest
-      argsyms    << "*__rest__"
-      [ locals, sprintf( "|%s| %s = __rest__[0] ; ", argsyms.join( "," ), rest ) ]
-    else
-      [ locals, sprintf( "|%s|",                     argsyms.join( "," ))        ]
+    def delayCall( origname, pred, args )
+      case @optimize_level
+      when 0 # no optimize
+        callProcedure( origname, pred, args )
+      else # tail call optimization
+        DelayedCallPacket.new( origname, pred, args )
+      end
+    end
+    
+    def callProcedure( origname, pred, args )
+      pred.call( *toRubyArgument( origname, pred, args ))
+    end
+  
+    # for code generation of Ruby's argument values
+    # in case:  str = ","
+    # [1,"2",3] => [ 
+    #                [ 1,  ","]
+    #                ["2", ","]
+    #                [ 3 ]
+    #              ]
+    def separateWith( arr, str )
+      seps = []
+      (arr.length-1).times {|n| seps << str }
+      arr.zip( seps ).map{ |x|
+        x.select { |elem| elem }
+      }
     end
-  end
 
-  def makeClosure( sym, args, locals )
-    first = args.car
-    if args.car.car == :quote
-      first   = args.car.cdr.car
-    end
-    rest    = args.cdr
-    ( _locals, argStr ) = toRubyParameter( first )
-    str = case sym
-          when :macro
-            sprintf( "LispMacro.new { %s ", argStr )
-          when :lambda
-            sprintf( "Proc.new { %s ", argStr )
+    def execFunc( funcname, args, sourcefile, lineno, locals, execType )
+      case funcname
+      when :define, :set!   # `define' special form
+        ar = args.cdr.map { |x| x.car }
+        variable_sym = toRubySymbol( args.car.to_s.sub( /^:/, "" ))
+        global_cap = locals.flatten.include?( variable_sym.split( /[.]/ )[0] ) ? nil : "@"
+        [ "begin",
+          [
+           if global_cap
+             [
+              defMethodStr( variable_sym ),
+              sprintf( "@global_lisp_binding['%s'] = self.method( :%s_METHOD )", variable_sym, variable_sym )
+             ]
+           else
+             ""
+           end,
+           sprintf( "%s%s = ", global_cap, variable_sym ),
+           "trampCall(", [ ar ], ")"],
+          "end"
+        ]
+      when :error
+        [
+         'begin raise RuntimeError, ',
+         args.car,
+         "rescue => __e ",
+         sprintf( "  __e.set_backtrace( [\"%s:%d\"] + __e.backtrace )", sourcefile, lineno ),
+         "  raise __e",
+         "end "]
+      else
+        if (EXEC_TYPE_ANONYMOUS != execType) and isRubyInterface( funcname )
+          # Ruby method
+          #   1) convert arguments
+          translatedArr  = args.map { |x| x.car }
+          #   2) generate caller code part
+          lispSymbolReference( toRubySymbol( funcname ), locals, translatedArr, sourcefile, lineno )
+        else
+          # Nendo function
+          if 0 == args.length
+            arr = [ "Cell.new(" ]
           else
-            raise "Error: makeClosure: unknown symbol type " + sym
+            arr = separateWith( args.map.with_index { |x,i| x.car }, ",Cell.new(" )
+            arr[0].unshift( "Cell.new(" )
           end
-    ar = rest.map { |e|
-      translate( e.car, locals.clone + [_locals])
-    }
-    [ str, ar, "}" ]
-  end
-
-  def makeIf( args, locals )
-    _condition = translate( args.car,         locals )
-    _then      = translate( args.cdr.car,     locals )
-    _else      = nil
-    if 2 < args.length
-      _else    = translate( args.cdr.cdr.car, locals )
-    end
-    if _else
-      ["if ( ", _condition, " ) then", 
-       [ _then ],
-       "else",
-       [ _else ],
-       "end"]
-    else
-      ["if ( ", _condition, " ) then", 
-       [ _then ],
-       "end"]
+          if EXEC_TYPE_ANONYMOUS == execType
+            [sprintf( "trampCall( callProcedure( 'anonymouse', " ),
+             [ funcname ] + [ "," ],
+             arr,
+             sprintf( "             ))" ) + arr.map { |n| ")" }.join]
+          else
+            origname = funcname.to_s
+            funcname = funcname.to_s
+            sym      = toRubySymbol( funcname )
+            _call = case execType
+                    when EXEC_TYPE_NORMAL
+                      if locals.flatten.include?( sym )
+                        [ sprintf( "trampCall( callProcedure(  ", sym ), "))" ] # local function
+                      else
+                        [ sprintf( "trampCall( self.%s_METHOD( ", sym ), "))" ] # toplevel function
+                      end
+                    when EXEC_TYPE_TAILCALL
+                      [ "delayCall(",    ")"  ]
+                    end
+            [sprintf( "%s '%s',", _call[0], origname ), 
+             [lispSymbolReference( sym, locals, nil, sourcefile, lineno )] + [","], 
+             arr,
+             sprintf( "             %s", _call[1] ) + arr.map { |n| ")" }.join]
+          end
+        end
+      end
     end
-  end
-
-  def makeLet( args, locals )
-    _name = "___lambda"
-    argvals = []
-    rest = args.cdr
-    if args.car.is_a? Nil
-      # nothing to do
-      lambda_head = sprintf( "%s = lambda { || ", _name )
-    else
-      argsyms = args.car.map { |x|
-        toRubySymbol( x.car.car.cdr.car.to_s )
-      }
-      argvals = args.car.map.with_index { |x,i|
-        translate( x.car.cdr.car, locals )
-      }
-      lambda_head = sprintf( "%s = lambda { |%s| ", _name, argsyms.join( "," ))
-    end
-    ["begin",
-     [lambda_head,
-      rest.map { |e|  translate( e.car, locals.clone + [argsyms] ) },
-      sprintf( "} ; %s.call(", _name ),
-      separateWith( argvals, "," ),
-      sprintf( "           )")],
-     "end"]
-  end
-
-  def makeLetrec( args, locals )
-    _name = "___lambda"
-    argvals = []
-    argsyms = []
-    rest = args.cdr
-    if args.car.is_a? Nil
-      # nothing to do
-      lambda_head = sprintf( "%s = lambda { || ", _name )
-    else
-      argsyms = args.car.map { |x|
-        toRubySymbol( x.car.car.cdr.car.to_s )
-      }
-      argvals = args.car.map { |x|
-        translate( x.car.cdr.car, locals.clone + [argsyms] )
+  
+    def makeBegin( args, locals )
+      ar = args.map { |e|
+        translate( e.car, locals )
       }
-      lambda_head = sprintf( "%s = lambda { |%s| ", _name, argsyms.join( "," ))
-    end
-    ["begin",
-     [lambda_head,
-      argsyms.zip( argvals ).map { |x| [ x[0], " = ", x[1] ] },
-      rest.map { |e|  translate( e.car, locals.clone + [argsyms] ) },
-      sprintf( "} ; %s.call(", _name ),
-      argsyms.map { |x| "nil" }.join( "," ),
-      sprintf( "           )")],
-     "end"]
-  end
-
-  def apply( car, cdr, sourcefile, lineno, locals, lambda_flag = false )
-    cdr.each { |x| 
-      if Cell == x.class
-        x.car = translate( x.car, locals )
+      ["begin", ar, "end"]
+    end
+  
+    # returns [ argsyms[], string ]
+    def toRubyParameter( argform )
+      argsyms = []
+      locals = []
+      rest = false
+      if Symbol == argform.class
+        rest       = argform
+      else
+        argsyms    = argform.map { |x|  toRubySymbol( x.car ) }
+        locals     = argsyms.clone
+        if argform.lastAtom
+          rest = argform.getLastAtom
+        end
       end
-    }
-    execFunc( car, cdr, sourcefile, lineno, locals, lambda_flag )
-  end
-
-  def genQuote( sexp, str = "" )
-    origStr = str
-    case sexp
-    when Cell
-      if sexp.isNull
-        str += "Cell.new()"
+      if rest
+        rest       = toRubySymbol( rest ) 
+        locals     << rest
+        argsyms    << "*__rest__"
+        [ locals, sprintf( "|%s| %s = __rest__[0] ; ", argsyms.join( "," ), rest ) ]
       else
-        arr = sexp.map { |x| genQuote( x.car ) }
-        str += "Cell.new("
-        str += arr.join( ",Cell.new(" )
-        lastAtom = sexp.lastAtom
-        str += "," + genQuote( lastAtom )  if lastAtom
-        str += arr.map{ |e| ")" }.join
-      end
-    when Array
-      arr = sexp.map { |x| genQuote( x ) }
-      str += "[" +  arr.join(",") + "]"
-    when Symbol
-      str += sprintf( ":\"%s\"", sexp.to_s )
-    when String, LispString
-      str += sprintf( "\"%s\"", LispString.escape( sexp ))
-    when LispKeyword
-      str += sprintf( "LispKeyword.new( \"%s\" )", sexp.key.to_s )
-    when TrueClass, FalseClass, NilClass  # reserved symbols
-      str += toRubyValue( sexp )
-    else
-      str += sprintf( "%s", sexp )
+        [ locals, sprintf( "|%s|",                     argsyms.join( "," ))        ]
+      end
     end
-    str
-  end
-
-  def lispSymbolReference( sym, locals, translatedArr, sourcefile, lineno )
-    variable_sym = sym.split( /[.]/ )[0]
-    global_cap = if variable_sym.match( /^[A-Z]/ )
-                   nil
-                 else
-                   locals.flatten.include?( variable_sym ) ? nil : "@"
-                 end
-    expression = if translatedArr
-                   [sprintf( "%s%s(", global_cap, sym ),
-                    separateWith( translatedArr, "," ),
-                    sprintf( "  )" )]
-                 else
-                   [sprintf( "%s%s", global_cap, sym )]
-                 end
-    if global_cap
-      ["begin",
-       [sprintf( "if @global_lisp_binding.has_key?('%s') then", variable_sym ),
-        expression,
-        sprintf( 'else raise NameError.new( "Error: undefined variable %s", "%s" ) end', variable_sym, variable_sym ),
-        sprintf( 'rescue => __e ; __e.set_backtrace( ["%s:%d"] + __e.backtrace ) ; raise __e',  sourcefile, lineno  )],
-       "end"]
-    else
+  
+    def makeClosure( sym, args, locals )
+      first = args.car
+      if args.car.car == :quote
+        first   = args.car.cdr.car
+      end
+      rest    = args.cdr
+      ( _locals, argStr ) = toRubyParameter( first )
+      str = case sym
+            when :macro
+              sprintf( "LispMacro.new { %s ", argStr )
+            when :lambda
+              sprintf( "Proc.new { %s ", argStr )
+            else
+              raise "Error: makeClosure: unknown symbol type " + sym
+            end
+      ar = rest.map { |e|
+        translate( e.car, locals.clone + [_locals])
+      }
+      [ str, ar, "}" ]
+    end
+  
+    def makeIf( args, locals )
+      _condition = translate( args.car,         locals )
+      _then      = translate( args.cdr.car,     locals )
+      _else      = nil
+      if 2 < args.length
+        _else    = translate( args.cdr.cdr.car, locals )
+      end
+      if _else
+        ["if ( ", _condition, " ) then", 
+         [ _then ],
+         "else",
+         [ _else ],
+         "end"]
+      else
+        ["if ( ", _condition, " ) then", 
+         [ _then ],
+         "end"]
+      end
+    end
+  
+    def makeLet( args, locals )
+      _name = "___lambda"
+      argvals = []
+      rest = args.cdr
+      if args.car.is_a? Nil
+        # nothing to do
+        lambda_head = sprintf( "%s = lambda { || ", _name )
+      else
+        argsyms = args.car.map { |x|
+          toRubySymbol( x.car.car.cdr.car.to_s )
+        }
+        argvals = args.car.map.with_index { |x,i|
+          translate( x.car.cdr.car, locals )
+        }
+        lambda_head = sprintf( "%s = lambda { |%s| ", _name, argsyms.join( "," ))
+      end
       ["begin",
-       [expression,
-        sprintf( 'rescue => __e ; __e.set_backtrace( ["%s:%d"] + __e.backtrace ) ; raise __e', sourcefile, lineno )],
+       [lambda_head,
+        rest.map { |e|  translate( e.car, locals.clone + [argsyms] ) },
+        sprintf( "} ; %s.call(", _name ),
+        separateWith( argvals, "," ),
+        sprintf( "           )")],
        "end"]
     end
-  end
-
-  # Lisp->Ruby translater
-  #    - locals is array of closure's local variable list
-  #      when S-expression is 
-  #      (let ((a 1)
-  #            (b 2))
-  #        (let ((c 3))
-  #            (print (+ a b c))))
-  #         => locals must be  [["_a" "_b"]["_c"]] value.
-  def translate( sexp, locals )
-    case sexp
-    when Cell
-      if :quote == sexp.car
-        genQuote( sexp.cdr.car )
-      elsif sexp.isDotted
-        raise NameError, "Error: can't eval dotted pair."
-      elsif sexp.isNull
-        [ "Cell.new()" ]
-      elsif Cell == sexp.car.class
-        self.apply( translate( sexp.car, locals ), sexp.cdr, sexp.car.car.sourcefile, sexp.car.car.lineno, locals, true )
-      elsif :begin == sexp.car
-        self.makeBegin( sexp.cdr, locals )
-      elsif :lambda == sexp.car
-        self.makeClosure( :lambda, sexp.cdr, locals )
-      elsif :macro == sexp.car
-        self.makeClosure( :macro, sexp.cdr, locals )
-      elsif :if == sexp.car
-        self.makeIf( sexp.cdr,    locals )
-      elsif :let == sexp.car
-        self.makeLet( sexp.cdr,   locals )
-      elsif :letrec == sexp.car
-        self.makeLetrec( sexp.cdr,   locals )
+  
+    def makeLetrec( args, locals )
+      _name = "___lambda"
+      argvals = []
+      argsyms = []
+      rest = args.cdr
+      if args.car.is_a? Nil
+        # nothing to do
+        lambda_head = sprintf( "%s = lambda { || ", _name )
       else
-        self.apply( sexp.car, sexp.cdr, sexp.car.sourcefile, sexp.car.lineno, locals )
+        argsyms = args.car.map { |x|
+          toRubySymbol( x.car.car.cdr.car.to_s )
+        }
+        argvals = args.car.map { |x|
+          translate( x.car.cdr.car, locals.clone + [argsyms] )
+        }
+        lambda_head = sprintf( "%s = lambda { |%s| ", _name, argsyms.join( "," ))
       end
-    when Array
-      raise RuntimeError, "Error: can't eval unquoted vector."
-    else
+      ["begin",
+       [lambda_head,
+        argsyms.zip( argvals ).map { |x| [ x[0], " = ", x[1] ] },
+        rest.map { |e|  translate( e.car, locals.clone + [argsyms] ) },
+        sprintf( "} ; %s.call(", _name ),
+        argsyms.map { |x| "nil" }.join( "," ),
+        sprintf( "           )")],
+       "end"]
+    end
+  
+    def apply( car, cdr, sourcefile, lineno, locals, execType )
+      cdr.each { |x| 
+        if Cell == x.class
+          x.car = translate( x.car, locals )
+        end
+      }
+      execFunc( car, cdr, sourcefile, lineno, locals, execType )
+    end
+  
+    def genQuote( sexp, str = "" )
+      origStr = str
       case sexp
+      when Cell
+        if sexp.isNull
+          str += "Cell.new()"
+        else
+          arr = sexp.map { |x| genQuote( x.car ) }
+          str += "Cell.new("
+          str += arr.join( ",Cell.new(" )
+          str += "," + genQuote( sexp.getLastAtom )  if sexp.lastAtom
+          str += arr.map{ |e| ")" }.join
+        end
+      when Array
+        arr = sexp.map { |x| genQuote( x ) }
+        str += "[" +  arr.join(",") + "]"
       when Symbol
-        sym = sexp.to_s
-        sym = toRubySymbol( sym )
-        lispSymbolReference( sym, locals, nil, sexp.sourcefile, sexp.lineno )
-      when Fixnum
-        sexp.to_s
+        str += sprintf( ":\"%s\"", sexp.to_s )
       when String, LispString
-        sprintf( "\"%s\"", LispString.escape( sexp ))
+        str += sprintf( "\"%s\"", LispString.escape( sexp ))
       when LispKeyword
-        sprintf( "LispKeyword.new( \"%s\" )", sexp.key )
-      when Nil
-        "Nil.new"
+        str += sprintf( "LispKeyword.new( \"%s\" )", sexp.key.to_s )
       when TrueClass, FalseClass, NilClass  # reserved symbols
-        toRubyValue( sexp )
+        str += toRubyValue( sexp )
       else
-        sexp.to_s
+        str += sprintf( "%s", sexp )
+      end
+      str
+    end
+  
+    def trampCallCap( sym )
+      if isRubyInterface( sym )
+        arr = sym.split( /[.]/ )
+        arr[0] = sprintf( "trampCall(%s)", arr[0] )
+        arr.join( "." )
+      else
+        "trampCall(" + sym + ")"
       end
     end
-  end
-
-  # insert quote in let argument list
-  #  ((sym1 list1)
-  #   (sym2 list2)
-  #   (sym3 list3))
-  # will be transformed
-  #  (((quote sym1) list1)
-  #   ((quote sym2) list2)
-  #   ((quote sym3) list3))
-  def letArgumentList( sexp )
-    sexp.each { |arg|
-      arg.car.car = Cell.new( :quote, Cell.new( arg.car.car ))
-      arg.car.cdr = quoting( arg.car.cdr )
-    }
-    sexp
-  end
 
-  def quoting( sexp )
-    case sexp
-    when Cell
-      if :quote == sexp.car or :quasiquote == sexp.car 
-        sexp
-      elsif :define == sexp.car or :set! == sexp.car or :lambda == sexp.car or :macro == sexp.car
-        sexp.cdr.car = Cell.new( :quote, Cell.new( sexp.cdr.car ))
-        sexp.cdr.cdr = quoting( sexp.cdr.cdr )
-        sexp
-      elsif :let == sexp.car
-        if _null_QUMARK( sexp.cdr )
-          # do nothing
-          p "kiyoka1"
+    def lispSymbolReference( sym, locals, translatedArr, sourcefile, lineno )
+      variable_sym = sym.split( /[.]/ )[0]
+      global_cap = if variable_sym.match( /^[A-Z]/ )
+                     nil
+                   else
+                     locals.flatten.include?( variable_sym ) ? nil : "@"
+                   end
+      expression = if translatedArr
+                     [trampCallCap( sprintf( "%s%s(", global_cap, sym )),
+                      separateWith( translatedArr, "," ),
+                      sprintf( "  )" )]
+                   else
+                     [trampCallCap( sprintf( "%s%s", global_cap, sym ))]
+                   end
+      if global_cap
+        ["begin",
+         [sprintf( "if @global_lisp_binding.has_key?('%s') then", variable_sym ),
+          expression,
+          sprintf( 'else raise NameError.new( "Error: undefined variable %s", "%s" ) end', variable_sym, variable_sym ),
+          sprintf( 'rescue => __e ; __e.set_backtrace( ["%s:%d"] + __e.backtrace ) ; raise __e',  sourcefile, lineno  )],
+         "end"]
+      else
+        ["begin",
+         [expression,
+          sprintf( 'rescue => __e ; __e.set_backtrace( ["%s:%d"] + __e.backtrace ) ; raise __e', sourcefile, lineno )],
+         "end"]
+      end
+    end
+  
+    # Lisp->Ruby translater
+    #    - locals is array of closure's local variable list
+    #      when S-expression is 
+    #      (let ((a 1)
+    #            (b 2))
+    #        (let ((c 3))
+    #            (print (+ a b c))))
+    #         => locals must be  [["_a" "_b"]["_c"]] value.
+    def translate( sexp, locals )
+      case sexp
+      when Cell
+        if :quote == sexp.car
+          genQuote( sexp.cdr.car )
+        elsif sexp.isDotted
+          raise NameError, "Error: can't eval dotted pair."
+        elsif sexp.isNull
+          [ "Cell.new()" ]
+        elsif Cell == sexp.car.class
+          self.apply( translate( sexp.car, locals ), sexp.cdr, sexp.car.car.sourcefile, sexp.car.car.lineno, locals, EXEC_TYPE_ANONYMOUS )
+        elsif :begin == sexp.car
+          self.makeBegin( sexp.cdr, locals )
+        elsif :lambda == sexp.car
+          self.makeClosure( :lambda, sexp.cdr, locals )
+        elsif :macro == sexp.car
+          self.makeClosure( :macro, sexp.cdr, locals )
+        elsif :if == sexp.car
+          self.makeIf( sexp.cdr,    locals )
+        elsif :let == sexp.car
+          self.makeLet( sexp.cdr,   locals )
+        elsif :letrec == sexp.car
+          self.makeLetrec( sexp.cdr,   locals )
+        elsif :"%tailcall" == sexp.car
+          if sexp.cdr.car.is_a? Cell
+            sexp = sexp.cdr.car
+            self.apply( sexp.car, sexp.cdr, sexp.car.sourcefile, sexp.car.lineno, locals, EXEC_TYPE_TAILCALL )
+          else
+            raise RuntimeError, "Error: special form tailcall expects function call expression."
+          end
+        else
+          self.apply( sexp.car, sexp.cdr, sexp.car.sourcefile, sexp.car.lineno, locals, EXEC_TYPE_NORMAL )
+        end
+      when Array
+        raise RuntimeError, "Error: can't eval unquoted vector."
+      else
+        case sexp
+        when Symbol
+          sym = sexp.to_s
+          sym = toRubySymbol( sym )
+          lispSymbolReference( sym, locals, nil, sexp.sourcefile, sexp.lineno )
+        when Fixnum
+          sexp.to_s
+        when String, LispString
+          sprintf( "\"%s\"", LispString.escape( sexp ))
+        when LispKeyword
+          sprintf( "LispKeyword.new( \"%s\" )", sexp.key )
+        when Nil
+          "Nil.new"
+        when TrueClass, FalseClass, NilClass  # reserved symbols
+          toRubyValue( sexp )
         else
+          sexp.to_s
+        end
+      end
+    end
+  
+    # insert quote in let argument list
+    #  ((sym1 list1)
+    #   (sym2 list2)
+    #   (sym3 list3))
+    # will be transformed
+    #  (((quote sym1) list1)
+    #   ((quote sym2) list2)
+    #   ((quote sym3) list3))
+    def letArgumentList( sexp )
+      sexp.each { |arg|
+        arg.car.car = Cell.new( :quote, Cell.new( arg.car.car ))
+        arg.car.cdr = quotingPhase( arg.car.cdr )
+      }
+      sexp
+    end
+  
+    def quotingPhase( sexp )
+      case sexp
+      when Cell
+        if :quote == sexp.car or :quasiquote == sexp.car 
+          sexp
+        elsif :define == sexp.car or :set! == sexp.car or :lambda == sexp.car or :macro == sexp.car
+          sexp.cdr.car = Cell.new( :quote, Cell.new( sexp.cdr.car ))
+          sexp.cdr.cdr = quotingPhase( sexp.cdr.cdr )
+          sexp
+        elsif :let == sexp.car
+          if _null_QUMARK( sexp.cdr )
+            # do nothing
+          else
+            case sexp.cdr.car
+            when Cell        # let
+              sexp.cdr         = Cell.new( letArgumentList( sexp.cdr.car ),
+                                           quotingPhase( sexp.cdr.cdr ))
+            when Symbol      # named let
+              sexp.cdr.car     = Cell.new( :quote, Cell.new( sexp.cdr.car ))
+              sexp.cdr.cdr     = Cell.new( letArgumentList( sexp.cdr.cdr.car ),
+                                           quotingPhase( sexp.cdr.cdr.cdr ))
+            end
+          end
+          sexp
+        elsif :letrec == sexp.car
           case sexp.cdr.car
-          when Cell        # let
+          when Cell        # letrec
             sexp.cdr         = Cell.new( letArgumentList( sexp.cdr.car ),
-                                         quoting( sexp.cdr.cdr ))
-          when Symbol      # named let
-            sexp.cdr.car     = Cell.new( :quote, Cell.new( sexp.cdr.car ))
-            sexp.cdr.cdr     = Cell.new( letArgumentList( sexp.cdr.cdr.car ),
-                                         quoting( sexp.cdr.cdr.cdr ))
+                                         quotingPhase( sexp.cdr.cdr ))
+          when Symbol      # named letrec is illegal
+            raise RuntimeError, "Error: named letrec is not a illegal form"
           end
+          sexp
+        else
+          Cell.new( quotingPhase( sexp.car ), quotingPhase( sexp.cdr ))
         end
+      else
         sexp
-      elsif :letrec == sexp.car
-        case sexp.cdr.car
-        when Cell        # letrec
-          sexp.cdr         = Cell.new( letArgumentList( sexp.cdr.car ),
-                                       quoting( sexp.cdr.cdr ))
-        when Symbol      # named letrec is illegal
-          raise RuntimeError, "Error: named letrec is not a illegal form"
+      end
+    end
+  
+    def macroexpandInit( initVal )
+      @macroExpandCount = initVal
+    end
+
+    def macroexpandEngine( sexp )
+      case sexp
+      when Cell
+        if :quote == sexp.car
+          sexp
+        else
+          sym = sexp.car.to_s
+          sym = toRubySymbol( sym )
+          newSexp = sexp
+          if isRubyInterface( sym )
+            # do nothing
+            sexp
+          elsif sexp.car.class == Symbol and eval( sprintf( "(defined? @%s and LispMacro == @%s.class)", sym,sym ), @binding )
+            eval( sprintf( "@__macro = @%s", sym ), @binding )
+            newSexp = trampCall( callProcedure( sym, @__macro, sexp.cdr ))
+          end
+          if _equal_QUMARK( newSexp, sexp )
+            sexp.map { |x|
+              if x.car.is_a? Cell
+                if 0 <= @macroExpandCount
+                  macroexpandEngine( x.car )
+                else
+                  x.car
+                end
+              else
+                x.car
+              end
+            }.to_list( sexp.lastAtom, sexp.getLastAtom )
+          else
+            @macroExpandCount -= 1
+            newSexp
+          end
         end
-        sexp
       else
-        Cell.new( quoting( sexp.car ), quoting( sexp.cdr ))
+        sexp
       end
-    else
-      sexp
     end
-  end
-
-  def macroexpand_1_check( sexp )
-    if not @expand_flag
+  
+    def macroExpandPhase( sexp )
+      converge = true
+      begin
+        macroexpandInit( 100000 )
+        newSexp  = macroexpandEngine( sexp )
+        converge = _equal_QUMARK( newSexp, sexp )
+        sexp = newSexp
+      end until converge
       sexp
-    else
-      newSexp = macroexpand_1_sub( sexp )
-      if not _equal_QUMARK( newSexp, sexp )
-        @expand_flag = false
-      end
-      newSexp
     end
-  end
-
-  def macroexpand_1_sub( sexp )
-    case sexp
-    when Cell
-      if :quote == sexp.car
-        sexp
-      else
-        sym = sexp.car.to_s
-        sym = toRubySymbol( sym )
-        newSexp = sexp
-        if isRubyInterface( sym )
-          # do nothing
-        elsif sexp.car.class == Symbol and eval( sprintf( "(defined? @%s and LispMacro == @%s.class)", sym,sym ), @binding )
-          eval( sprintf( "@__macro = @%s", sym ), @binding )
-          newSexp = callProcedure( sym, @__macro, sexp.cdr )
-        end
-        if _equal_QUMARK( newSexp, sexp )
-          sexp.map { |x|
-            if x.car.is_a? Cell
-              macroexpand_1_check( x.car )
-            else
-              x.car
-            end
-          }.to_list( sexp.lastAtom )
+    
+    def ppRubyExp( level, exp )
+      indent = @indent * level
+      exp.map { |x|
+        if Array == x.class
+          ppRubyExp( level+1, x )
         else
-          newSexp
+          str = sprintf( "%s", x )
+          if str.match( /^[,]/ ) or str.match( /^ = / )
+            sprintf( "%s%s", indent, str )
+          else
+            sprintf( "\n%s%s", indent, str )
+          end
+        end
+      }
+    end
+  
+    def lispEval( sexp, sourcefile, lineno )
+      @lastSourcefile = sourcefile
+      @lastLineno     = lineno
+      sexp = macroExpandPhase( sexp )
+      sexp = quotingPhase( sexp )
+      if @debug
+        printf( "\n          quoting=<<< %s >>>\n", (Printer.new())._print(sexp))
+      end
+      # compiling phase written in Nendo
+      sym = toRubySymbol( "%compile-phase" )
+      if ( eval( sprintf( "(defined? @%s and Proc == @%s.class)", sym,sym ), @binding ))
+        eval( sprintf( "@___tmp = @%s", sym ), @binding )
+        sexp = trampCall( callProcedure( sym, @___tmp, Cell.new( sexp )))
+        if @debug
+          printf( "\n          compiled=<<< %s >>>\n", (Printer.new())._print(sexp))
         end
       end
-    else
-      sexp
+      
+      arr = [ "trampCall( ", translate( sexp, [] ), " )" ]
+      rubyExp = ppRubyExp( 0, arr ).flatten.join
+      if not @compiled_code.has_key?( sourcefile )
+        @compiled_code[ sourcefile ] = Array.new
+      end
+      @compiled_code[ sourcefile ] << rubyExp
+      printf( "          rubyExp=<<<\n%s\n>>>\n", rubyExp ) if @debug
+      eval( rubyExp, @binding, @lastSourcefile, @lastLineno )
+    end
+  
+    def _load( filename )
+      printer = Printer.new( @debug )
+      open( filename, "r:utf-8" ) {|f|
+        reader = Reader.new( f, filename, false )
+        while true
+          lineno = reader.lineno
+          s = reader._read
+          if s[1] # EOF?
+            break
+          elsif Nil != s[0].class
+            printf( "\n          readExp=<<< %s >>>\n", printer._print(s[0]) ) if @debug
+            self.lispEval( s[0], reader.sourcefile, lineno )
+          end
+        end
+      }
+      forward_gensym_counter()
+    end
+  
+    def _load_MIMARKcompiled_MIMARKcode_MIMARKfrom_MIMARKstring( rubyExp )
+      eval( rubyExp, @binding )
+      forward_gensym_counter()
+    end
+  
+    def _load_MIMARKcompiled_MIMARKcode( filename )
+      open( filename, "r:utf-8" ) { |f|
+        eval( f.read, @binding )
+      }
+      forward_gensym_counter()
     end
-  end
   
-  def macroexpand_1( sexp )
-    @expand_flag = true
-    macroexpand_1_check( sexp )
+    def _clean_MIMARKcompiled_MIMARKcode
+      @compiled_code = Hash.new
+    end
+    
+    def _get_MIMARKcompiled_MIMARKcode
+      @compiled_code
+      ret = Hash.new
+      @compiled_code.each_key { |key|
+        ret[key] = @compiled_code[key].to_list
+        ret[key]
+      }
+      ret.to_list
+    end
+  
+    def _eval( sexp )
+      self.lispEval( sexp, "dynamic S-expression ( no source )", 1 )
+    end
+  
+    def _enable_MIMARKidebug()
+      @debug = true
+    end
+    def _disable_MIMARKidebug()
+      @debug = false
+    end
+    def _set_MIMARKoptimize_MIMARKlevel(level)
+      self.setOptimizeLevel( level )
+    end
+    def _get_MIMARKoptimize_MIMARKlevel()
+      self.getOptimizeLevel
+    end
   end
-
-  def macroexpand( sexp )
-    case sexp
-    when Cell
-      if :quote == sexp.car
-        sexp
-      else
-        sym = sexp.car.to_s
-        sym = toRubySymbol( sym )
-        newSexp = sexp
-        if isRubyInterface( sym )
-          # do nothing
-        elsif sexp.car.class == Symbol and eval( sprintf( "(defined? @%s and LispMacro == @%s.class)", sym,sym ), @binding )
-          eval( sprintf( "@__macro = @%s", sym ), @binding )
-          newSexp = callProcedure( sym, @__macro, sexp.cdr )
+  
+  class Printer
+    def initialize( debug = false )
+      @debug    = debug
+    end
+  
+    def __write( sexp, readable )
+      getQuoteKeyword = lambda { |x|
+        case x
+        when :quote
+          "'"
+        when :quasiquote
+          "`"
+        when :unquote
+          ","
+        when :"unquote-splicing"
+          ",@"
+        when :"dot-operator"
+          "."
+        else
+          false
         end
-        if _equal_QUMARK( newSexp, sexp )
-          sexp.map { |x|
-            if x.car.is_a? Cell
-              macroexpand( x.car )
-            else
-              x.car
-            end
-          }.to_list( sexp.lastAtom )
+      }
+      case sexp
+      when Cell
+        arr = sexp.map { |x| __write( x.car, readable ) }
+        lastAtom = sexp.lastAtom
+        lastAtomStr = lastAtom ? __write( sexp.getLastAtom, readable ) : ""
+        keyword = getQuoteKeyword.call( sexp.car )
+        if keyword
+          keyword + arr[1..-1].join( " " ) + (lastAtom ? " . " + lastAtomStr : "")
+        else
+          "(" +  arr.join( " " ) + (lastAtom ? " . " + lastAtomStr : "") + ")"
+        end
+      when Array # is a vector in the Nendo world.
+        arr = sexp.map { |x| __write( x, readable ) }
+        "#(" + arr.join( " " ) + ")"
+      when true
+        "#t"
+      when false
+        "#f"
+      when Symbol
+        keyword = getQuoteKeyword.call( sexp )
+        if keyword
+          keyword
         else
-          newSexp
+          sprintf( "%s", sexp.to_s )
         end
+      when String, LispString
+        if readable
+          sprintf( "\"%s\"", LispString.escape( sexp.to_s ))
+        else
+          sexp.to_s
+        end
+      when LispKeyword
+        ":" + sexp.key.to_s
+      when Nil
+        "()"
+      when nil
+        "nil"
+      else
+        sprintf( "%s", sexp )
       end
-    else
-      sexp
     end
-  end
-
-  def lispCompile( sexp )
-    converge = true
-    begin
-      newSexp  = macroexpand( sexp )
-      converge = _equal_QUMARK( newSexp, sexp )
-      sexp = newSexp
-    end until converge
-    sexp
+  
+    def _print( sexp )
+      self.__write( sexp, false )
+    end
+    def _write( sexp )
+      self.__write( sexp, true  )
+    end
   end
   
-  def ppRubyExp( level, exp )
-    indent = @indent * level
-    exp.map { |x|
-      if Array == x.class
-        ppRubyExp( level+1, x )
-      else
-        str = sprintf( "%s", x )
-        if str.match( /^[,]/ ) or str.match( /^ = / )
-          sprintf( "%s%s", indent, str )
-        else
-          sprintf( "\n%s%s", indent, str )
+  
+  class Core
+    def initialize( debug_evaluator = false, debug_printer = false )
+      @debug_evaluator = debug_evaluator
+      @evaluator       = Evaluator.new( debug_evaluator )
+      @debug_printer   = debug_printer
+    end
+    
+    def loadInitFile( use_compiled = true )
+      done = false
+      if use_compiled 
+        compiled_file = File.dirname(__FILE__) + "/init.nndc"
+        if File.exist?( compiled_file )
+          @evaluator._load_MIMARKcompiled_MIMARKcode( compiled_file )
+          done = true
         end
       end
-    }
-  end
-
-  def lispEval( sexp, sourcefile, lineno )
-    @lastSourcefile = sourcefile
-    @lastLineno     = lineno
-    sexp = lispCompile( sexp )
-    sexp = quoting( sexp );
-    if @debug
-      printf( "\n          quoting=<<< %s >>>\n", (Printer.new())._print(sexp))
-    end
-    arr = [ translate( sexp, [] ) ]
-    rubyExp = ppRubyExp( 0, arr ).flatten.join
-    if not @compiled_code.has_key?( sourcefile )
-      @compiled_code[ sourcefile ] = Array.new
-    end
-    @compiled_code[ sourcefile ] << rubyExp
-    printf( "          rubyExp=<<<\n%s\n>>>\n", rubyExp ) if @debug
-    eval( rubyExp, @binding, @lastSourcefile, @lastLineno )
-  end
+      unless done
+        @evaluator._load( File.dirname(__FILE__) + "/init.nnd" )
+      end
+    end
+  
+    def load( path )
+      @evaluator._load( path )
+    end
+  
+    def load_compiled_code( path )
+      @evaluator._load_MIMARKcompiled_MIMARKcode( path )
+    end
+  
+    def load_compiled_code_from_string( rubyExp )
+      @evaluator._load_MIMARKcompiled_MIMARKcode_MIMARKfrom_MIMARKstring( rubyExp )
+    end
+  
+    def setArgv( argv )
+      @evaluator.setArgv( argv )
+    end
 
-  def _load( filename )
-    printer = Printer.new( @debug )
-    open( filename, "r:utf-8" ) {|f|
-      reader = Reader.new( f, filename, false )
+    def setOptimizeLevel( level )
+      @evaluator.setOptimizeLevel( level )
+    end
+  
+    def clean_compiled_code
+      @evaluator._clean_MIMARKcompiled_MIMARKcode()
+    end
+  
+    def prompt
+      STDERR.print "nendo> "
+    end
+  
+    def repl
+      printer = Printer.new( @debug_printer )
+      reader  = Reader.new( STDIN, "(stdin)", false )
+      self.prompt
+      while true
+        begin
+          lineno = reader.lineno
+          s = reader._read
+          if s[1] # EOF?
+            break
+          elsif not s[0].is_a? Nil
+            printf( "\n          readExp=<<< %s >>>\n", printer._write(s[0]) ) if @debug_evaluator
+            STDERR.print printer._write( @evaluator.lispEval( s[0], reader.sourcefile, lineno )) + "\n"
+            self.prompt
+          end
+        rescue => e
+          print e.message + "\n"
+          e.backtrace.each { |x| printf( "\tfrom %s\n", x ) }
+          print "\n"
+          self.prompt
+        end
+      end
+    end
+  
+    def replStr( str )
+      printer   = Printer.new( @debug_printer )
+      sio       = StringIO.open( str )
+      reader    = Reader.new( sio, "(string)", false )
+      result    = nil
       while true
         lineno = reader.lineno
         s = reader._read
         if s[1] # EOF?
           break
-        elsif Nil != s[0].class
-          printf( "\n          readExp=<<< %s >>>\n", printer._print(s[0]) ) if @debug
-          self.lispEval( s[0], reader.sourcefile, lineno )
+        elsif not s[0].is_a? Nil
+          printf( "\n          readExp=<<< %s >>>\n", printer._write(s[0]) ) if @debug_evaluator
+          result = printer._write( @evaluator.lispEval( s[0], reader.sourcefile, lineno )) 
         end
       end
-    }
-    forward_gensym_counter()
+      result
+    end
   end
+end
 
-  def _load_MIMARKcompiled_MIMARKcode_MIMARKfrom_MIMARKstring( rubyExp )
-    eval( rubyExp, @binding )
-    forward_gensym_counter()
-  end
 
-  def _load_MIMARKcompiled_MIMARKcode( filename )
-    open( filename, "r:utf-8" ) { |f|
-      eval( f.read, @binding )
-    }
-    forward_gensym_counter()
-  end
 
-  def _clean_MIMARKcompiled_MIMARKcode
-    @compiled_code = Hash.new
-  end
-  
-  def _get_MIMARKcompiled_MIMARKcode
-    @compiled_code
-    ret = Hash.new
-    @compiled_code.each_key { |key|
-      ret[key] = @compiled_code[key].to_list
-      ret[key]
-    }
-    ret.to_list
-  end
 
-  def _eval( sexp )
-    self.lispEval( sexp, "dynamic S-expression ( no source )", 1 )
+class Symbol
+  def setLispToken( token )
+    @token = token
   end
-
-  def _enable_MIMARKidebug()
-    @debug = true
+  def sourcefile
+    @token ? @token.sourcefile : ""
   end
-  def _disable_MIMARKidebug()
-    @debug = false
+  def lineno
+    @token ? @token.lineno : 1
   end
 end
 
-class Printer
-  def initialize( debug = false )
-    @debug    = debug
-  end
-
-  def __write( sexp, readable )
-    getQuoteKeyword = lambda { |x|
-      case x
-      when :quote
-        "'"
-      when :quasiquote
-        "`"
-      when :unquote
-        ","
-      when :"unquote-splicing"
-        ",@"
-      when :"dot-operator"
-        "."
-      else
-        false
-      end
-    }
-    case sexp
-    when Cell
-      arr = sexp.map { |x| __write( x.car, readable ) }
-      lastAtom = sexp.lastAtom
-      lastAtom = __write( lastAtom, readable )  if lastAtom
-      keyword = getQuoteKeyword.call( sexp.car )
-      if keyword
-        keyword + arr[1..-1].join( " " ) + (lastAtom ? " . " + lastAtom : "")
-      else
-        "(" +  arr.join( " " ) + (lastAtom ? " . " + lastAtom : "") + ")"
-      end
-    when Array # is a vector in the Nendo world.
-      arr = sexp.map { |x| __write( x, readable ) }
-      "#(" + arr.join( " " ) + ")"
-    when true
-      "#t"
-    when false
-      "#f"
-    when Symbol
-      keyword = getQuoteKeyword.call( sexp )
-      if keyword
-        keyword
-      else
-        sprintf( "%s", sexp.to_s )
-      end
-    when String, LispString
-      if readable
-        sprintf( "\"%s\"", LispString.escape( sexp.to_s ))
-      else
-        sexp.to_s
-      end
-    when LispKeyword
-      ":" + sexp.key.to_s
-    when Nil
-      "()"
-    when nil
-      "nil"
+class Array
+  def to_list( lastAtom = false, value = Nendo::Nil.new )
+    if 0 == self.length
+      Nendo::Nil.new
     else
-      sprintf( "%s", sexp )
+      cells = self.map { |x|
+        Nendo::Cell.new( x )
+      }
+      ptr = cells.pop
+      ptr.cdr = value  if lastAtom
+      cells.reverse.each { |x|
+        x.cdr = ptr
+        ptr = x
+      }
+      return ptr
     end
   end
-
-  def _print( sexp )
-    self.__write( sexp, false )
-  end
-  def _write( sexp )
-    self.__write( sexp, true  )
-  end
 end
 
-
-class Nendo
-  def initialize( debug_evaluator = false, debug_printer = false )
-    @debug_evaluator = debug_evaluator
-    @evaluator       = Evaluator.new( debug_evaluator )
-    @debug_printer   = debug_printer
-  end
-  
-  def loadInitFile( use_compiled = true )
-    done = false
-    if use_compiled 
-      compiled_file = File.dirname(__FILE__) + "/init.nndc"
-      if File.exist?( compiled_file )
-        @evaluator._load_MIMARKcompiled_MIMARKcode( compiled_file )
-        done = true
-      end
-    end
-    unless done
-      @evaluator._load( File.dirname(__FILE__) + "/init.nnd" )
-    end
-  end
-
-  def load( path )
-    @evaluator._load( path )
-  end
-
-  def load_compiled_code( path )
-    @evaluator._load_MIMARKcompiled_MIMARKcode( path )
-  end
-
-  def load_compiled_code_from_string( rubyExp )
-    @evaluator._load_MIMARKcompiled_MIMARKcode_MIMARKfrom_MIMARKstring( rubyExp )
-  end
-
-  def setArgv( argv )
-    @evaluator.setArgv( argv )
-  end
-
-  def clean_compiled_code
-    @evaluator._clean_MIMARKcompiled_MIMARKcode()
-  end
-
-  def repl
-    printer = Printer.new( @debug_printer )
-    reader = nil
-    print "nendo> "
-    begin
-      begin
-        reader = Reader.new( STDIN, "(stdin)", false )
-      rescue => e
-        print e.message + "\n"
-        e.backtrace.each { |x| printf( "\tfrom %s\n", x ) }
-        reader = nil
-        print "\n" + "nendo> "
-      end
-    end until reader
-    while true
-      lineno = reader.lineno
-      begin
-        s = reader._read
-        if s[1] # EOF?
-          break
-        elsif Nil != s[0].class
-          printf( "\n          readExp=<<< %s >>>\n", printer._write(s[0]) ) if @debug_evaluator
-          print printer._write( @evaluator.lispEval( s[0], reader.sourcefile, lineno ))
-          print "\n" + "nendo> "
-        end
-      rescue => e
-        print e.message + "\n"
-        e.backtrace.each { |x| printf( "\tfrom %s\n", x ) }
-        print "\n" + "nendo> "
-      end
-    end
-  end
-
-  def replStr( str )
-    printer   = Printer.new( @debug_printer )
-    sio       = StringIO.open( str )
-    reader    = Reader.new( sio, "(string)", false )
-    result    = nil
-    while true
-      lineno = reader.lineno
-      s = reader._read
-      if s[1] # EOF?
-        break
-      elsif Nil != s[0].class
-        printf( "\n          readExp=<<< %s >>>\n", printer._write(s[0]) ) if @debug_evaluator
-        result = printer._write( @evaluator.lispEval( s[0], reader.sourcefile, lineno )) 
-      end
-    end
-    result
+class Hash
+  def to_list
+    arr = Array.new
+    self.each_pair { |key,val|
+      arr << Nendo::Cell.new( key, val )
+    }
+    arr.to_list
   end
 end