nendo 0.1.0 → 0.2.0

data/lib/nendo.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # -*- encoding: utf-8 -*-
 #
-# Nendo:   "Principle of Least Surprise (for Rubyist)"
+# Nendo:   "Nendo is a diarect of Lisp."
 #  
 #
 #
@@ -26,6 +26,13 @@ class Nil
 end
 
 class LispString < String
+  def LispString.escape( str )
+    if str.is_a? String
+      str.gsub( /["]/, "\\\"" )
+    else
+      raise TypeError
+    end
+  end
 end
 
 class LispMacro < Proc
@@ -192,6 +199,7 @@ class Reader
   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 )
@@ -239,6 +247,32 @@ class Reader
     ret
   end
 
+  def readstring()
+    ret = ""
+    while true
+      ch = @chReader.getc
+      #printf( "      readstring: [%s]\n", ch )
+      if !ch # eof?
+        break
+      end
+      if ch.chr.match( /[\\]/ )
+        ch2 = @chReader.getc
+        if ch2.chr == "\""    #  \"  reduce to "  
+          ret += "\""
+        else
+          ret += ch.chr
+          ret += ch2.chr
+        end
+      elsif ch.chr.match( /[^"]/ )
+        ret += ch.chr
+      else
+        @chReader.ungetc( ch )
+        break
+      end
+    end
+    ret
+  end
+
   def tokenWithComment
     skipspace
     ch = @chReader.getc
@@ -276,12 +310,28 @@ class Reader
           readwhile( /[^\r\n]/ )
           str = ""
           T_COMMENT
-        when /[#!]/
-          readwhile( /[^\r\n]/ )
-          str = ""
-          T_COMMENT
+        when /[#]/
+          keyword = readwhile( /[?=!tf]/ )
+          case keyword
+          when /[?=]/
+            str = ""
+            T_DEBUG_PRINT
+          when /[!]/
+            readwhile( /[^\r\n]/ )
+            str = ""
+            T_COMMENT
+          when "t"
+            str = "true"
+            T_SYMBOL
+          when "f"
+            str = "false"
+            T_SYMBOL
+          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( /[_a-zA-Z0-9!?*.-]/ ).gsub( /[-]/, '_' )
+          str += readwhile( /[_a-zA-Z0-9!?*.:-]/ ).gsub( /[-]/, '_' )
           T_SYMBOL
         when /[*\/=!<>&|%]/   # symbol
           str += readwhile( /[+*\/=!<>&|?%-]/ )
@@ -301,11 +351,12 @@ class Reader
           str += readwhile( /[0-9.]/ )
           T_NUM
         when /["]/             # String
-          str = LispString.new( readwhile( /[^"]/ )) ; readwhile( /["]/ )
+          str =  LispString.new( readstring() )
+          readwhile( /["]/ )
           T_STRING
         else
           str += readwhile( /[^ \t\r\n]/ )
-          raise NameError, sprintf( "unknown token for Nendo [%s]", str )
+          raise NameError, sprintf( "Error: unknown token for Nendo [%s]", str )
         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 )
@@ -364,6 +415,8 @@ class Reader
       :dot_operator
     when T_FEEDTO
       :feedto
+    when T_DEBUG_PRINT
+      "debug-print".intern
     else
       raise "Error: Unknown token in atom()"
     end
@@ -396,7 +449,7 @@ class Reader
           token
           lastAtom = sexp()
         end
-      when T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING
+      when T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING, T_DEBUG_PRINT
         cells << Cell.new( sexp() )
       else
         if lastAtom
@@ -454,6 +507,12 @@ class Reader
     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()
     end
@@ -651,6 +710,8 @@ module BuiltinFunctions
     end
   end
   def _to_s( arg )              arg.to_s    end
+  def _to_i( arg )              arg.to_i    end
+  def _nil_QMARK(   arg )       arg.nil?    end
   def _to_list( arg )
     case arg
     when Array
@@ -665,7 +726,10 @@ module BuiltinFunctions
   def _string_join( lst, delim )
     lst.to_a.map{ |x| x.car }.join( delim )
   end
-  def _require( arg )           Kernel::require( arg ) end
+  def _require( arg )
+    Kernel::require( arg )
+    false
+  end
   def _read( *args )
     lst = args[0].to_arr
     io = if 0 == lst.length
@@ -685,6 +749,18 @@ module BuiltinFunctions
     end until s[2]
     ret
   end
+
+  def _apply1( first, arg )
+    callProcedure( "(apply1 genereate func)", first, arg )
+  end
+
+  def _global_variables
+    self.instance_variables.select { |x|
+      x.match( /^[@]_[a-zA-Z]/ )
+    }.map{ |name| 
+      self.toLispSymbol( name[1..-1] ).intern
+    }.to_list
+  end
 end
 
 
@@ -692,6 +768,7 @@ end
 class Evaluator
   include BuiltinFunctions
   def initialize( debug = false )
+    @indent  = "  "
     @binding = binding
     @debug   = debug
     @alias   = {'+'        => 'plus',
@@ -715,7 +792,7 @@ class Evaluator
 
     # initialize global symbols
     rubyExp = @sym.keys.map { |name|
-      sprintf( "%s = @sym[ '%s' ] ", name, name )
+      sprintf( "@%s = @sym[ '%s' ] ", name, name )
     }.join( " ; " )
     eval( rubyExp, @binding )
 
@@ -723,12 +800,15 @@ class Evaluator
     rubyExp = self.methods.select { |x|
       x.to_s.match( /^_/ )
     }.map { |name|
-      sprintf( "%s = self.method( :%s ).to_proc", name, name )
+      sprintf( "@%s = self.method( :%s ).to_proc", name, name )
     }.join( " ; " )
     eval( rubyExp, @binding )
 
     # reset gensym counter
     @gensym_counter = 0
+
+    # compiled ruby code
+    @compiled_code = []
   end
 
   def _gensym( )
@@ -753,8 +833,8 @@ class Evaluator
     if 0 == name.length
       ""
     else
-      arr = name.split( /[.]/ )
-      arr[0] = arr[0].gsub( /[*]/, '_AMARK' ).gsub( /[?]/, '_QMARK' ).gsub( /[!]/, '_EMARK' ).gsub( /[-]/, '_' ).gsub( /["]/, '' )
+      arr = name.gsub( /["]/, '' ).split( /[.]/ )
+      arr[0] = arr[0].gsub( /[*]/, '_AMARK' ).gsub( /[?]/, '_QMARK' ).gsub( /[!]/, '_EMARK' ).gsub( /[-]/, '_' )
       if arr[0].match( /^[A-Z]/ )
         # nothing to do
       elsif arr[0] == ""
@@ -772,26 +852,27 @@ class Evaluator
 
   def toLispSymbol( name )
     name = name.to_s  if Symbol == name.class
-    raise ArgumentError if not ('_' == name[0])
+    raise ArgumentError, sprintf( "Error: `%s' is not a lisp symbol", name ) if not ('_' == name[0])
     name = name[1..-1]
     name.gsub( /_AMARK/, '*' ).gsub( /_QMARK/, '?' ).gsub( /_EMARK/, '!' )
   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, sprintf( "at function `%s'", origname )  if 0 != args.length
+      raise ArgumentError, argument_error_message if 0 != args.length
       []
     elsif 0 < num
       if args.isNull
         [ Nil.new ]
       else
-        raise ArgumentError, sprintf( "at function `%s'", origname ) if num != args.length
+        raise ArgumentError, argument_error_message if num != args.length
         args.map { |x|  x.car }
       end
     else
       num = num.abs( )-1
-      raise ArgumentError, sprintf( "at function `%s'", origname )  if num > args.length
+      raise ArgumentError, argument_error_message if num > args.length
       params = []
       rest = []
       args.each_with_index { |x,i|
@@ -819,130 +900,193 @@ class Evaluator
     pred.call( *rubyArgument )
   end
 
-  def execFunc( funcname, args, sourcefile, lineno, lambda_flag )
+  # 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 :set!   # `set!' special form
-      sprintf( "%s = %s", toRubySymbol( args.car.to_s.sub( /^:/, "" )), toRubyValue( args.cdr.car ))
+    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 ) ? nil : "@"
+      [ sprintf( "%s%s = ", global_cap, variable_sym ), ar ]
     when :error
       sprintf( 'begin raise RuntimeError, %s ; rescue => __e ;  __e.set_backtrace( ["%s:%d"] + __e.backtrace ) ; raise __e ; end ', toRubyValue( args.car ), sourcefile, lineno )
     else
       if (not lambda_flag) and isRubyInterface( funcname )
         # Ruby method
         #   1) convert arguments
-        argStr  = args.map { |x| toRubyValue( x.car ) }.join( "," )
+        translatedArr  = args.map { |x| x.car }
         #   2) generate caller code part
-        sprintf( "%s( %s )", toRubySymbol( funcname ), argStr )
+        lispSymbolReference( toRubySymbol( funcname ), locals, translatedArr, sourcefile, lineno )
       else
         # Nendo function
-        argStr  = args.map { |x| toRubyValue( x.car ) }.join( " ,Cell.new(" )
-        argStr += args.map { |x| "" }.join( ")" )
+        if 0 == args.length
+          arr = [ "Cell.new(" ]
+        else
+          arr = separateWith( args.map.with_index { |x,i| x.car }, ",Cell.new(" )
+          arr[0].unshift( "Cell.new(" )
+        end
         if lambda_flag
-          "anonymouse"
-          sprintf( "callProcedure( 'anonymouse', %s, Cell.new( %s ))", funcname, argStr )
+          [sprintf( "callProcedure( 'anonymouse', " ),
+           [ funcname ] + [ "," ],
+           arr,
+           sprintf( "             )" ) + arr.map { |n| ")" }.join]
         else
           origname = funcname.to_s
           funcname = funcname.to_s
           funcname = @alias[ funcname ] if @alias[ funcname ] 
-          sprintf( "callProcedure( '%s', %s, Cell.new( %s ))", origname, toRubySymbol( funcname ), argStr )
+          sym      = toRubySymbol( funcname )
+          [sprintf( "callProcedure( '%s',", origname ),
+           [lispSymbolReference( sym, locals, nil, sourcefile, lineno )] + [","],
+           arr,
+           sprintf( "             )" ) + arr.map { |n| ")" }.join]
         end
       end
     end
   end
 
-  def makeBegin( args )
+  def makeBegin( args, locals )
     ar = args.map { |e|
-      translate( e.car )
+      translate( e.car, locals )
     }
-    "begin " + ar.join( ";" ) + " end"
+    ["begin", ar, "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__"
-      sprintf( "|%s| %s = __rest__[0] ; ", argsyms.join( "," ), rest )
+      [ locals, sprintf( "|%s| %s = __rest__[0] ; ", argsyms.join( "," ), rest ) ]
     else
-      sprintf( "|%s|",                     argsyms.join( "," ))
+      [ locals, sprintf( "|%s|",                     argsyms.join( "," ))        ]
     end
   end
 
-  def makeClosure( sym, args )
+  def makeClosure( sym, args, locals )
     first = args.car
     if args.car.car == :quote
       first   = args.car.cdr.car
     end
     rest    = args.cdr
-    argStr  = toRubyParameter( first )
+    ( _locals, argStr ) = toRubyParameter( first )
     str = case sym
           when :macro
             sprintf( "LispMacro.new { %s ", argStr )
           when :lambda
-            sprintf( "     Proc.new { %s ", argStr )
+            sprintf( "Proc.new { %s ", argStr )
           else
             raise "Error: makeClosure: unknown symbol type " + sym
           end
     ar = rest.map { |e|
-      translate( e.car )
+      translate( e.car, locals.clone + [_locals])
     }
-    str += ar.join( ";" ) + "}"
+    [ str, ar, "}" ]
   end
 
-  def makeIf( args )
-    _condition = translate( args.car )
-    _then      = translate( args.cdr.car )
+  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 )
+      _else    = translate( args.cdr.cdr.car, locals )
     end
     if _else
-      str = sprintf( "if ( %s ) then %s else %s end ", _condition, _then, _else )
+      ["if ( ", _condition, " ) then", 
+       [ _then ],
+       "else",
+       [ _else ],
+       "end"]
     else
-      str = sprintf( "if ( %s ) then %s end ", _condition, _then )
+      ["if ( ", _condition, " ) then", 
+       [ _then ],
+       "end"]
     end
   end
 
-  def makeLet( args )
+  def makeLet( args, locals )
     _name = "___lambda"
-    str = ""
     argvals = []
+    rest = args.cdr
     if args.car.is_a? Nil
       # nothing to do
-      str = sprintf( "begin %s = lambda { || ", _name )
-      rest = args.cdr
+      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
-      if :quote == args.car.car
-        _name = args.car.cdr.car.to_s
-        args = args.cdr
-      end
-      rest = args.cdr
       argsyms = args.car.map { |x|
         toRubySymbol( x.car.car.cdr.car.to_s )
       }
       argvals = args.car.map { |x|
-        translate( x.car.cdr.car )
+        translate( x.car.cdr.car, locals.clone + [argsyms] )
       }
-      str = sprintf( "begin %s = lambda { |%s| ", _name, argsyms.join( "," ))
+      lambda_head = sprintf( "%s = lambda { |%s| ", _name, argsyms.join( "," ))
     end
-    ar = rest.map { |e|  translate( e.car ) }
-    str += ar.join( ";" ) + "} ; "
-    str += sprintf( "%s.call( %s ) end ", _name, argvals.join( "," ))
+    ["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, lambda_flag = false )
+  def apply( car, cdr, sourcefile, lineno, locals, lambda_flag = false )
     cdr.each { |x| 
       if Cell == x.class
-        x.car = translate( x.car )
+        x.car = translate( x.car, locals )
       end
     }
-    execFunc( car, cdr, sourcefile, lineno, lambda_flag )
+    execFunc( car, cdr, sourcefile, lineno, locals, lambda_flag )
   end
 
   def genQuote( sexp, str = "" )
@@ -954,7 +1098,7 @@ class Evaluator
       else
         arr = sexp.map { |x| genQuote( x.car ) }
         str += "Cell.new("
-        str += arr.join( " ,Cell.new(" )
+        str += arr.join( ",Cell.new(" )
         lastAtom = sexp.lastAtom
         str += "," + genQuote( lastAtom )  if lastAtom
         str += arr.map{ |e| ")" }.join
@@ -962,7 +1106,7 @@ class Evaluator
     when Symbol
       str += sprintf( ":\"%s\"", sexp.to_s )
     when String
-      str += sprintf( "\"%s\"", sexp )
+      str += sprintf( "\"%s\"", LispString.escape( sexp ))
     when TrueClass, FalseClass, NilClass  # reserved symbols
       str += toRubyValue( sexp )
     else
@@ -971,35 +1115,72 @@ class Evaluator
     str
   end
 
-  def translate( sexp )
-    str = ""
+  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 (self.instance_variables.include?(:@%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
-        print "Error: can't eval dotted pair"
-        raise NameError
+        raise NameError, "Error: can't eval dotted pair."
       elsif sexp.isNull
-        str += "Cell.new()"
+        [ "Cell.new()" ]
       elsif Cell == sexp.car.class
         if :lambda == sexp.car.car
-          str += self.apply( translate( sexp.car ), sexp.cdr, sexp.car.car.sourcefile, sexp.car.car.lineno, true )
+          self.apply( translate( sexp.car, locals ), sexp.cdr, sexp.car.car.sourcefile, sexp.car.car.lineno, locals, true )
         else
-          str += translate( sexp.car )
+          translate( sexp.car, locals )
         end
       elsif :begin == sexp.car
-        str += self.makeBegin( sexp.cdr )
+        self.makeBegin( sexp.cdr, locals )
       elsif :lambda == sexp.car
-        str += self.makeClosure( :lambda, sexp.cdr )
+        self.makeClosure( :lambda, sexp.cdr, locals )
       elsif :macro == sexp.car
-        str += self.makeClosure( :macro, sexp.cdr )
+        self.makeClosure( :macro, sexp.cdr, locals )
       elsif :if == sexp.car
-        str += self.makeIf( sexp.cdr )
+        self.makeIf( sexp.cdr,    locals )
       elsif :let == sexp.car
-        str += self.makeLet( sexp.cdr )
+        self.makeLet( sexp.cdr,   locals )
+      elsif :letrec == sexp.car
+        self.makeLetrec( sexp.cdr,   locals )
       else
-        str += self.apply( sexp.car, sexp.cdr, sexp.car.sourcefile, sexp.car.lineno )
+        self.apply( sexp.car, sexp.cdr, sexp.car.sourcefile, sexp.car.lineno, locals )
       end
     else
       case sexp
@@ -1007,17 +1188,17 @@ class Evaluator
         sym = sexp.to_s
         sym = @alias[ sym ]  if @alias[ sym ]
         sym = toRubySymbol( sym )
-        str += sprintf( 'begin %s ; rescue NameError => __e ; __e.set_backtrace( ["%s:%d"] + __e.backtrace ) ; raise __e ; end', sym, sexp.sourcefile, sexp.lineno )
+        lispSymbolReference( sym, locals, nil, sexp.sourcefile, sexp.lineno )
       when Fixnum
-        str += sexp.to_s
-      when LispString
-        str += sprintf( "\"%s\"", sexp )
+        sexp.to_s
+      when String
+        sprintf( "\"%s\"", LispString.escape( sexp ))
       when Nil
-        str += "Nil.new"
+        "Nil.new"
       when TrueClass, FalseClass, NilClass  # reserved symbols
-        str += toRubyValue( sexp )
+        toRubyValue( sexp )
       else
-        str += sexp.to_s
+        sexp.to_s
       end
     end
   end
@@ -1043,19 +1224,33 @@ class Evaluator
     when Cell
       if :quote == sexp.car or :quasiquote == sexp.car 
         sexp
-      elsif :set! == sexp.car or :lambda == sexp.car or :macro == sexp.car
+      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_QMARK( sexp.cdr )
+          # do nothing
+          p "kiyoka1"
+        else
+          case sexp.cdr.car
+          when Cell        # let
+            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 ))
+          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 ))
+                                       quoting( sexp.cdr.cdr ))
+        when Symbol      # named letrec is illegal
+          raise SyntaxError, "Error: named letrec is not a illegal form"
         end
         sexp
       else
@@ -1066,7 +1261,19 @@ class Evaluator
     end
   end
 
-  def macroexpand_1( sexp )
+  def macroexpand_1_check( sexp )
+    if not @expand_flag
+      sexp
+    else
+      newSexp = macroexpand_1_sub( sexp )
+      if not _equal_QMARK( newSexp, sexp )
+        @expand_flag = false
+      end
+      newSexp
+    end
+  end
+
+  def macroexpand_1_sub( sexp )
     case sexp
     when Cell
       if :quote == sexp.car
@@ -1075,22 +1282,35 @@ class Evaluator
         sym = sexp.car.to_s
         sym = @alias[ sym ]  if @alias[ sym ]
         sym = toRubySymbol( sym )
-        if isRubyInterface( sym ) 
-          arr = sexp.map { |x| macroexpand_1( x.car ) }
-          arr.to_list( sexp.lastAtom )
-        elsif sexp.car.class == Symbol and eval( sprintf( "(defined? %s and LispMacro == %s.class)", sym,sym ), @binding )
-          eval( sprintf( "@_macro = %s", sym ), @binding )
-          callProcedure( sym, @_macro, sexp.cdr )
+        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_QMARK( newSexp, sexp )
+          sexp.map { |x|
+            if x.car.is_a? Cell
+              macroexpand_1_check( x.car )
+            else
+              x.car
+            end
+          }.to_list( sexp.lastAtom )
         else
-          arr = sexp.map { |x| macroexpand_1( x.car ) }
-          arr.to_list( sexp.lastAtom )
+          newSexp
         end
       end
     else
       sexp
     end
   end
-
+  
+  def macroexpand_1( sexp )
+    @expand_flag = true
+    macroexpand_1_check( sexp )
+  end
+  
   def lispCompile( sexp )
     converge = true
     begin
@@ -1100,6 +1320,22 @@ class Evaluator
     end until converge
     sexp
   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 )
+        end
+      end
+    }
+  end
 
   def lispEval( sexp, sourcefile, lineno )
     sexp = lispCompile( sexp )
@@ -1107,8 +1343,10 @@ class Evaluator
     if @debug
       printf( "\n          quoting=<<< %s >>>\n", (Printer.new())._print(sexp))
     end
-    rubyExp = translate( sexp );
-    printf( "          rubyExp=<<< %s >>>\n", rubyExp ) if @debug
+    arr = [ translate( sexp, [] ) ]
+    rubyExp = ppRubyExp( 0, arr ).flatten.join
+    @compiled_code << rubyExp
+    printf( "          rubyExp=<<<\n%s\n>>>\n", rubyExp ) if @debug
     eval( rubyExp, @binding, sourcefile, lineno );
   end
 
@@ -1129,13 +1367,27 @@ class Evaluator
     }
   end
 
+  def _loadCompiledCode( filename )
+    open( filename ) { |f|
+      rubyExp = f.read
+      eval( rubyExp, @binding )
+    }
+  end
+
+  def _get_compiled_code()
+    @compiled_code.to_list
+  end
+
   def _eval( sexp )
     self.lispEval( sexp, "dynamic S-expression ( no source )", 1 )
   end
 
-  def _enable_debug()
+  def _enable_idebug()
     @debug = true
   end
+  def _disable_idebug()
+    @debug = false
+  end
 end
 
 class Printer
@@ -1180,7 +1432,7 @@ class Printer
       end
     when String
       if readable
-        sprintf( "\"%s\"", sexp.to_s )
+        sprintf( "\"%s\"", LispString.escape( sexp.to_s ))
       else
         sexp.to_s
       end
@@ -1209,8 +1461,18 @@ class Nendo
     @debug_printer   = debug_printer
   end
   
-  def loadInitFile
-    @evaluator._load( File.dirname(__FILE__) + "/init.nnd" )
+  def loadInitFile( use_compiled = true )
+    done = false
+    if use_compiled 
+      compiled_file = File.dirname(__FILE__) + "/init.nndc"
+      if File.exist?( compiled_file )
+        @evaluator._loadCompiledCode( compiled_file )
+        done = true
+      end
+    end
+    unless done
+      @evaluator._load( File.dirname(__FILE__) + "/init.nnd" )
+    end
   end
 
   def load( path )
@@ -1238,8 +1500,8 @@ class Nendo
         if s[1] # EOF?
           break
         elsif Nil != s[0].class
-          printf( "\n          readExp=<<< %s >>>\n", printer._print(s[0]) ) if @debug_evaluator
-          print printer._print( @evaluator.lispEval( s[0], reader.sourcefile, lineno ))
+          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
@@ -1261,8 +1523,8 @@ class Nendo
       if s[1] # EOF?
         break
       elsif Nil != s[0].class
-        printf( "\n          readExp=<<< %s >>>\n", printer._print(s[0]) ) if @debug_evaluator
-        result = printer._print( @evaluator.lispEval( s[0], reader.sourcefile, lineno )) 
+        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