nendo 0.5.0 → 0.5.1

data/lib/nendo.rb

@@ -34,13 +34,11 @@
 #  
 #  $Id: 
 #
-
-require 'pp'
-
 module Nendo
   require 'stringio'
   require 'digest/sha1'
-  
+  require 'pp'
+
   class Nil
     include Enumerable
     def each()               end
@@ -83,10 +81,10 @@ module Nendo
     end
     attr_reader :syntaxName
   end
-  
+
   class Cell
     include Enumerable
-  
+
     def initialize( car = Nil.new, cdr = Nil.new )
       @car = car
       @cdr = cdr
@@ -151,6 +149,21 @@ module Nendo
         self.map {|x| x.car}
       end
     end
+
+    def first
+      self.car
+    end
+
+    def second
+      self.cdr.car
+    end
+
+    def third
+      self.cdr.cdr.car
+    end
+
+    alias :cdar  :second
+    alias :cddar :third
   end
   
   class LispValues
@@ -202,6 +215,34 @@ module Nendo
     attr_reader :key
   end
 
+  class SyntacticClosure
+    def initialize( originalSymbol, renamedSymbol )
+      @originalSymbol = originalSymbol
+      @renamedSymbol  = renamedSymbol
+    end
+
+    def to_s
+      @renamedSymbol.to_s
+    end
+
+    def intern
+      @renamedSymbol
+    end
+
+#    def ==(other_sc)
+#      if other_sc.is_a? SyntacticClosure
+#        @renamedSymbol == other_sc.renamedSymbol
+#      else
+#        false
+#      end
+#    end
+
+    def sourcefile()  "dynamic S-expression ( no source )"  end
+    def lineno()      1                                     end
+
+    attr_reader :originalSymbol, :renamedSymbol
+  end
+
   class SourceInfo
     def initialize
       @varname       = nil
@@ -330,6 +371,7 @@ module Nendo
     T_LINEFEED            = :t_linefeed
     T_COMMENT             = :t_comment
     T_DEBUG_PRINT         = :t_debug_print
+    T_MACRO_DEBUG_PRINT   = :t_macro_debug_print
     T_REGEXP              = :t_regexp
   
     # inport is IO class
@@ -498,10 +540,13 @@ module Nendo
               if peekchar( /[=]/ )
                 str = ""
                 T_DEBUG_PRINT
+              elsif peekchar( /[.]/ )
+                str = ""
+                T_MACRO_DEBUG_PRINT
               else
                 str += readwhile( /[^ \t\r\n]/ )
                 raise NameError, sprintf( "Error: unknown #xxxx syntax for Nendo %s", str )
-              end              
+              end
             when "!"
               readwhile( /[^\r\n]/ )
               str = ""
@@ -638,6 +683,8 @@ module Nendo
         :feedto
       when T_DEBUG_PRINT
         "debug-print".intern
+      when T_MACRO_DEBUG_PRINT
+        LispString.new( sprintf( "%s:%d", cur.sourcefile, cur.lineno ))
       when T_KEYWORD
         LispKeyword.new( cur.str )
       else
@@ -833,12 +880,14 @@ module Nendo
     def _equal_QUMARK( a, b )
       if a.is_a? String  and  b.is_a? String
         a === b
-      elsif _null_QUMARK( a ) and _null_QUMARK( b )
-        true
       elsif a.class != b.class
         false
-      elsif a.class == Cell
+      elsif a.is_a? Cell
         _equal_QUMARK( a.car, b.car ) and _equal_QUMARK( a.cdr, b.cdr )
+      elsif _null_QUMARK( a ) and _null_QUMARK( b )
+        true
+      elsif a.is_a? Proc
+        a == b
       else
         (a === b)
       end
@@ -1045,15 +1094,22 @@ module Nendo
     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 _cdr(      cell )
+      if cell.cdr.is_a? Nil
+        Cell.new
+      else
+        cell.cdr
+      end
+    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
+    alias write_to_string _write_MIMARKto_MIMARKstring
     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 _symbol_QUMARK(    arg )   (arg.is_a? Symbol or arg.is_a? SyntacticClosure) end
     def _keyword_QUMARK(    arg )  (arg.is_a? LispKeyword) end
     def _syntax_QUMARK( arg )      (arg.is_a? LispSyntax)  end
     def _core_MIMARKsyntax_QUMARK( arg )
@@ -1083,7 +1139,7 @@ module Nendo
     def _macroexpand_MIMARK1( arg )
       if _pair_QUMARK( arg )
         macroexpandInit( 1 )
-        macroexpandEngine( arg )
+        macroexpandEngine( arg, [], [] )
       else
         arg
       end
@@ -1273,6 +1329,8 @@ module Nendo
       @binding = binding
       @debug   = debug
       @trace_debug = false
+      @lexicalVars = []
+      @syntaxHash = {}
       @char_table_lisp_to_ruby = {
         # list     (! $ % & * + - . / : < = > ? @ ^ _ ~ ...)
         '!'   => '_EXMARK',
@@ -1297,7 +1355,7 @@ module Nendo
       }
       @char_table_ruby_to_lisp = @char_table_lisp_to_ruby.invert
 
-      @core_syntax_list = [ :quote, :"syntax-quote", :if , :begin , :lambda , :macro , :"&block" , :let , :letrec , :define, :set!, :error, :"%syntax", :"define-syntax" ]
+      @core_syntax_list = [ :quote, :"syntax-quote", :if , :begin , :lambda , :macro , :"&block" , :"%let" , :letrec , :define, :set!, :error, :"%syntax", :"define-syntax", :"let-syntax" ]
       @core_syntax_hash = Hash.new
       @core_syntax_list.each { |x|
         renamed = ("/nendo/core/" + x.to_s).intern
@@ -1419,29 +1477,33 @@ module Nendo
     end
   
     def toRubySymbol( name )
-      name = name.to_s  if Symbol == name.class
-      if 0 == name.length
-        ""
-      else
-        name.gsub!( Regexp.new( Regexp.escape( '...' )), @char_table_lisp_to_ruby[ '...' ] )
-        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'
+      if SyntacticClosure == name.class
+        "_" + name.to_s
+      else
+        name = name.to_s  if Symbol == name.class
+        if 0 == name.length
+          ""
         else
-          arr[0] = '_' + arr[0]
+          name.gsub!( Regexp.new( Regexp.escape( '...' )), @char_table_lisp_to_ruby[ '...' ] )
+          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
+            arr[0] = '_' + arr[0]
+          end
+          arr.join( "." )
         end
-        arr.join( "." )
       end
     end
-  
+
     def isRubyInterface( name )
       name.to_s.match( /[.]/ )
     end
@@ -1550,9 +1612,12 @@ module Nendo
       }
     end
 
+    def isDefines( sym )
+      [ :define, :set!, :"define-syntax", @core_syntax_hash[ :define ], @core_syntax_hash[ :set! ], @core_syntax_hash[ :"define-syntax" ] ].include?( sym )
+    end
+
     def execFunc( funcname, args, sourcefile, lineno, locals, sourceInfo, execType )
-      case funcname
-      when :define, :set!, :"define-syntax", @core_syntax_hash[ :define ], @core_syntax_hash[ :set! ], @core_syntax_hash[ :"define-syntax" ]   # `define' special form
+      if isDefines( funcname )
         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 : "@"
@@ -1573,7 +1638,7 @@ module Nendo
            "trampCall(", [ ar ], ")"],
           "end"
         ]
-      when :error, @core_syntax_hash[ :error ]
+      elsif :error == funcname or  @core_syntax_hash[ :error ] == funcname
         arr = if args.length < 2
                 args.car
               else
@@ -1626,20 +1691,29 @@ module Nendo
         end
       end
     end
-  
+
+    def makeSetVariable( car, cdr, locals, sourceInfo )
+      cdr.cdr.each { |x|
+        if Cell == x.class
+          x.car = translate( x.car, locals, sourceInfo )
+        end
+      }
+      execFunc( car, cdr, car.sourcefile, car.lineno, locals, sourceInfo, EXEC_TYPE_ANONYMOUS )
+    end
+
     def makeBegin( args, locals )
       ar = args.map { |e|
         translate( e.car, locals )
       }
       ["begin", ar, "end"]
     end
-  
+
     # returns [ argsyms[], string ]
     def toRubyParameter( argform )
       argsyms = []
       locals = []
       rest = false
-      if Symbol == argform.class
+      if _symbol_QUMARK( argform )
         rest       = argform
       else
         argsyms    = argform.map { |x|  toRubySymbol( x.car ) }
@@ -1649,7 +1723,7 @@ module Nendo
         end
       end
       if rest
-        rest       = toRubySymbol( rest ) 
+        rest       = toRubySymbol( rest )
         locals     << rest
         argsyms    << "*__rest__"
         [ locals, sprintf( "|%s| %s = __rest__[0] ; ", argsyms.join( "," ), rest ) ]
@@ -1657,13 +1731,10 @@ module Nendo
         [ locals, sprintf( "|%s|",                     argsyms.join( "," ))        ]
       end
     end
-  
+
     def makeClosure( sym, args, locals )
       first = args.car
-      if args.car.car == :quote
-        first   = args.car.cdr.car
-      end
-      rest    = args.cdr
+      rest  = args.cdr
       ( _locals, argStr ) = toRubyParameter( first )
       str = case sym
             when :macro
@@ -1707,12 +1778,12 @@ module Nendo
       _name = "___lambda"
       argvals = []
       rest = args.cdr
-      if args.car.is_a? Nil
+      if _null_QUMARK( args.car )
         # nothing to do
         lambda_head = sprintf( "%s = lambda { || ", _name )
       else
         argsyms = args.car.map { |x|
-          toRubySymbol( x.car.car.cdr.car.to_s )
+          toRubySymbol( x.car.car.to_s )
         }
         argvals = args.car.map.with_index { |x,i|
           translate( x.car.cdr.car, locals )
@@ -1733,12 +1804,12 @@ module Nendo
       argvals = []
       argsyms = []
       rest = args.cdr
-      if args.car.is_a? Nil
+      if _null_QUMARK( args.car )
         # nothing to do
         lambda_head = sprintf( "%s = lambda { || ", _name )
       else
         argsyms = args.car.map { |x|
-          toRubySymbol( x.car.car.cdr.car.to_s )
+          toRubySymbol( x.car.car.to_s )
         }
         argvals = args.car.map { |x|
           translate( x.car.cdr.car, locals.clone + [argsyms] )
@@ -1754,7 +1825,7 @@ module Nendo
         sprintf( "           )")],
        "end"]
     end
-  
+
     def apply( car, cdr, sourcefile, lineno, locals, sourceInfo, execType )
       cdr.each { |x| 
         if Cell == x.class
@@ -1763,7 +1834,7 @@ module Nendo
       }
       execFunc( car, cdr, sourcefile, lineno, locals, sourceInfo, execType )
     end
-  
+
     def genQuote( sexp, str = "" )
       origStr = str
       case sexp
@@ -1788,6 +1859,8 @@ module Nendo
         str += sprintf( "LispKeyword.new( \"%s\" )", sexp.key.to_s )
       when TrueClass, FalseClass, NilClass  # reserved symbols
         str += toRubyValue( sexp )
+      when SyntacticClosure
+        str += sprintf( ":\"%s\"", sexp.originalSymbol.to_s )
       when Nil
         str += "Cell.new()"
       else
@@ -1852,14 +1925,16 @@ module Nendo
               else
                 sexp.car
               end
-        if :quote == car or :"syntax-quote" == car
-          genQuote( sexp.cdr.car )
+        if :quote == car
+          genQuote( sexp.second )
+        elsif :"syntax-quote" == car
+          [ "Cell.new(:\"syntax-quote\", ", genQuote( sexp.cdr ), ")" ]
         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, sourceInfo ), sexp.cdr, sexp.car.car.sourcefile, sexp.car.car.lineno, locals, sourceInfo, EXEC_TYPE_ANONYMOUS )
+        elsif isDefines( car )
+          self.makeSetVariable( car, sexp.cdr, locals, sourceInfo )
         elsif :begin == car
           self.makeBegin( sexp.cdr, locals )
         elsif :lambda == car
@@ -1872,17 +1947,27 @@ module Nendo
           self.makeClosure( :"&block", sexp.cdr, locals )
         elsif :if == car
           self.makeIf( sexp.cdr,    locals )
-        elsif :let == car
+        elsif :"%let" == car
           self.makeLet( sexp.cdr,   locals )
         elsif :letrec == car
           self.makeLetrec( sexp.cdr,   locals )
         elsif :"%tailcall" == 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, sourceInfo, EXEC_TYPE_TAILCALL )
+            if isDefines( sexp.car )
+              translate( sexp, locals, sourceInfo )
+            else
+              if sexp.car.is_a? Cell
+                self.apply( translate( sexp.car, locals, sourceInfo ), sexp.cdr, sexp.car.car.sourcefile, sexp.car.car.lineno, locals, sourceInfo, EXEC_TYPE_ANONYMOUS )
+              else
+                self.apply( sexp.car, sexp.cdr, sexp.car.sourcefile, sexp.car.lineno, locals, sourceInfo, EXEC_TYPE_TAILCALL )
+              end
+            end
           else
             raise RuntimeError, "Error: special form tailcall expects function call expression."
           end
+        elsif Cell == sexp.car.class
+          self.apply( translate( sexp.car, locals, sourceInfo ), sexp.cdr, sexp.car.car.sourcefile, sexp.car.car.lineno, locals, sourceInfo, EXEC_TYPE_ANONYMOUS )
         else
           self.apply( sexp.car, sexp.cdr, sexp.car.sourcefile, sexp.car.lineno, locals, sourceInfo, EXEC_TYPE_NORMAL )
         end
@@ -1910,139 +1995,233 @@ module Nendo
           "Nil.new"
         when TrueClass, FalseClass, NilClass  # reserved symbols
           toRubyValue( sexp )
+        when SyntacticClosure
+          toRubySymbol( 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 )
+
+
+    # warp sexp by lexicalVars
+    def __wrapNestedLet( sexp, lexicalVars )
+      if 0 == lexicalVars.size
+        sexp
+      else
+        elem  = lexicalVars.shift
+        Cell.new( :"%let",
+             Cell.new(
+                  Cell.new(
+                       Cell.new( elem[0], elem[1] )),
+                  Cell.new( __wrapNestedLet( sexp, lexicalVars ) )))
+      end
+    end
+
+    def __removeSameLexicalScopeVariables( frame )
+      frame.select {|x|
+        # search same varname and different value
+        found = frame.any? {|y|
+          x[0] == y[0] and (not _equal_QUMARK( x[1], y[1] ))
+        }
+        if found
+          x
+        else
+          false
+        end
       }
+    end
+
+    def macroexpandInit( initVal )
+      @macroExpandCount = initVal
+    end
+
+    def macroexpandEngineLoop( sexp, syntaxArray, lexicalVars )
+      converge = true
+      begin
+        newSexp  = macroexpandEngine( sexp, syntaxArray, lexicalVars )
+        converge = _equal_QUMARK( newSexp, sexp )
+        sexp = newSexp
+      end until converge or (@macroExpandCount <= 0)
       sexp
     end
-  
-    def quotingPhase( sexp )
-      case sexp
-      when Cell
-        car = sexp.car
-        if :quote == car or :quasiquote == car or :"syntax-quote" == car or
-            @core_syntax_hash[ :quote ] == car or
-            @core_syntax_hash[ :quasiquote ] == car or
-            @core_syntax_hash[ :"syntax-quote" ] == car
-          sexp
-        elsif :define == car or :set! == car or :lambda == car or :macro == car or :"&block" == car or :"%syntax" == car or :"define-syntax" == car or
-            @core_syntax_hash[ :define ] == car or
-            @core_syntax_hash[ :set! ] == car or
-            @core_syntax_hash[ :lambda ] == car or
-            @core_syntax_hash[ :macro ] == car or
-            @core_syntax_hash[ :"&block" ] == car or
-            @core_syntax_hash[ :"%syntax" ] == car or 
-            @core_syntax_hash[ :"define-syntax" ] == car
-          if @debug
-            if 2 >= sexp.length
-              printf( "\n    quotingPhase-1      label=%s, sexp.length=%d \n", sexp.car, sexp.length )
-            else
-              printf( "\n    quotingPhase-1      label=%s, sexp.length=%d, sexp.cdr=%s sexp.cdr.car=%s sexp.cdr.cdr=%s\n", sexp.car, sexp.length, sexp.cdr, sexp.cdr.car, sexp.cdr.cdr )
-            end
-          end
-          if 1 == sexp.length
-            nil
-            # do nothing
-          elsif 3 <= sexp.length
-            # argument
-            sexp.cdr.car = Cell.new( :quote, Cell.new( sexp.cdr.car ))
-            # body
-            sexp.cdr.cdr = quotingPhase( sexp.cdr.cdr )
-          else
-            raise RuntimeError, sprintf( "Error: %s is not a illegal form got: %s", sexp.car, _write_MIMARKto_MIMARKstring( sexp ))
-          end
-          sexp
-        elsif :let == car or @core_syntax_hash[ :let ] == 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 == car or @core_syntax_hash[ :letrec ] == car
-          if _null_QUMARK( sexp.cdr )
-            # do nothing
+
+    def macroexpandEngine( sexp, syntaxArray, lexicalVars )
+      if @macroExpandCount <= 0
+        sexp
+      else
+        __macroexpandEngine( sexp, syntaxArray, lexicalVars )
+      end
+    end
+
+    #
+    # expand (syntax-rules ...) => (%syntax-rules ...)
+    #
+    def __expandSyntaxRules( rules, syntaxArray, lexicalVars )
+      if :"%syntax-rules" == rules.car
+        rules
+      else
+        ellipse = rules.second
+        pattern_body_list = rules.cdr.cdr
+
+        lst = []
+        lst << :"syntax-rules"
+        lst << ellipse
+        pattern_body_list.each {|xx|
+          pattern_body = xx.car
+          pattern = pattern_body.first
+          body = pattern_body.second
+          new_pattern_body = [ pattern, macroexpandEngine( body, syntaxArray, lexicalVars ) ].to_list
+          lst << new_pattern_body
+        }
+        lst.to_list
+      end
+    end
+
+    # eval (syntax-rules ...) sexp
+    #
+    # return:
+    #   (%syntax-rules
+    #    ((v1 <<@syntaxHash's key1>>)
+    #     (v2 <<@syntaxHash's key2>>)
+    #     body))
+    #
+    #   example:
+    #   (%syntax-rules
+    #    ((v1 "x = 10 // (+ x v1)")
+    #     (v2 "y = 20 // (+ y v2)"))
+    #    (+ v1 v2))
+    #
+    def __evalSyntaxRules( rules, lexicalVars )
+      if :"%syntax-rules" == rules.car
+        rules.second
+      else
+        lexvars = lexicalVars.select { |x|
+          if _symbol_MIMARKinclude_QUMARK( rules, x[0].intern )
+            x
+          elsif lexicalVars.find {|y| _symbol_MIMARKinclude_QUMARK( y[1], x[0].intern ) }
+            x
           else
-            case sexp.cdr.car
-            when Cell        # letrec
-              sexp.cdr         = Cell.new( letArgumentList( sexp.cdr.car ),
-                                           quotingPhase( sexp.cdr.cdr ))
-            when Symbol      # named letrec is illegal
-              raise RuntimeError, "Error: named letrec is not a illegal form"
-            end
+            false
           end
-          sexp
+        }
+
+        __setupLexicalScopeVariables( lexvars )
+        keyStr = lexvars.map {|z|
+          z[0].to_s + " / " +  write_to_string( z[1] )
+        }.join( " / " )
+        keyStr += " // " + write_to_string( rules )
+        if @syntaxHash.has_key?( keyStr )
+          true
         else
-          Cell.new( quotingPhase( sexp.car ), quotingPhase( sexp.cdr ))
+          @syntaxHash[ keyStr ] = [ lexvars,
+            self.lispEval( rules, "dynamic syntax-rules sexp (no source) ", 1 ) ]
         end
-      else
-        sexp
+        __setupLexicalScopeVariables( [] )
+        keyStr
       end
     end
-  
-    def macroexpandInit( initVal )
-      @macroExpandCount = initVal
-    end
 
-    def macroexpandEngine( sexp )
+    # args:
+    #
+    #   syntaxArray ... let-syntax's identifiers
+    #                   [
+    #                      [ identifier-name, key of @syntaxHash, sexp of (syntax-rules ...), frame_of_let-syntax ],
+    #                        .
+    #                        .
+    #                   ]
+    #   lexicalVars ... let's identifiers
+    #                   [
+    #                      [ identifier-name, macroexpandEngine( let's body ) ],
+    #                   ]
+    #
+    #
+    def __macroexpandEngine( sexp, syntaxArray, lexicalVars )
       case sexp
       when Cell
         car = sexp.car
         if :quote == car or :"syntax-quote" == car or @core_syntax_hash[ :quote ] == car or @core_syntax_hash[ :"syntax-quote" ] == car
           sexp
+        elsif :"%let" == car or :letrec == car or @core_syntax_hash[ :"%let" ] == car or @core_syntax_hash[ :letrec ] == car
+          # catch lexical identifiers of `let' and `letrec'.
+          arr = sexp.second.map { |x|
+            [ x.car.car, macroexpandEngine( x.car.cdr, syntaxArray, lexicalVars ) ]
+          }
+          lst = arr.map {|x| Cell.new( x[0], x[1] ) }.to_list
+          ret = Cell.new( car,
+                     Cell.new( lst,
+                          macroexpandEngine( sexp.cdr.cdr, syntaxArray, lexicalVars + arr )))
+          ret
+        elsif :"let-syntax" == car
+          sexp.second.each {|x|
+            if not x.car.second.is_a? Cell
+              raise SyntaxError, "Error: let-syntax get only '((name (syntax-rules ...)))' form but got: " + write_to_string( x )
+            elsif not ( x.car.second.first == :"syntax-rules" or x.car.second.first == :"%syntax-rules")
+              raise SyntaxError, "Error: let-syntax get only '((name (syntax-rules ...)))' form but got: " + write_to_string( x )
+            end
+          }
+          arr_tmp = sexp.second.map { |x|
+            [ x.car.first, __expandSyntaxRules( x.car.second, syntaxArray, lexicalVars ) ]
+          }
+          arr = arr_tmp.map {|x|
+            [ x[0], __evalSyntaxRules( x[1], lexicalVars ), x[1], lexicalVars ]
+          }
+
+          # trial (expand recursively)
+          arr_tmp = arr.map { |x|
+            [ x[0], __expandSyntaxRules( x[2], syntaxArray + arr, lexicalVars ) ]
+          }
+          arr = arr_tmp.map {|x|
+            [ x[0], __evalSyntaxRules( x[1], lexicalVars ), x[1], lexicalVars ]
+          }
+
+          # keywords = ((let-syntax-keyword ( let-syntax-body ))
+          #             (let-syntax-keyword ( let-syntax-body ))
+          #             ..)
+          newKeywords = arr.map { |e|
+            [ e[0], [ :"%syntax-rules", e[1]].to_list ].to_list
+          }.to_list
+
+          ret = Cell.new( :"let-syntax",
+                     Cell.new( newKeywords, macroexpandEngine( sexp.cdr.cdr, syntaxArray + arr, lexicalVars )))
+
+          ret
         else
-          sym = sexp.car.to_s
-          p 'macroexpandEngine' if @debug
-          p sexp.car.class if @debug
-          p sym            if @debug
-          sym = toRubySymbol( sym )
+          sym = toRubySymbol( car.to_s )
           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 )
+          elsif _symbol_QUMARK( car ) 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.to_arr ))
-          elsif sexp.car.class == Symbol and eval( sprintf( "(defined? @%s and LispSyntax == @%s.class)", sym,sym ), @binding )
+          elsif _symbol_QUMARK( car ) and eval( sprintf( "(defined? @%s and LispSyntax == @%s.class)", sym,sym ), @binding )
             # expected input is
             #   (syntaxName arg1 arg2 ...)
             # will be transformed
             #   (syntaxName (syntaxName arg1 arg2 ...) () (global-variables))
             eval( sprintf( "@__syntax = @%s", sym ), @binding )
             newSexp = trampCall( callProcedure( sym, @__syntax, [ sexp, Cell.new(), _global_MIMARKvariables( ) ] ))
+          elsif _symbol_QUMARK( car ) and syntaxArray.map {|arr| arr[0].intern}.include?( car.intern )
+            # lexical macro expandeding
+            symbol_and_syntaxObj = syntaxArray.reverse.find {|arr| car == arr[0]}
+            keys    = syntaxArray.reverse.map { |arr| arr[0] }
+            if not symbol_and_syntaxObj
+              raise "can't find valid syntaxObject"
+            end
+            vars       = symbol_and_syntaxObj[3].map { |arr| arr[0] }
+            lexvars    = @syntaxHash[ symbol_and_syntaxObj[1] ][0]
+            lispSyntax = @syntaxHash[ symbol_and_syntaxObj[1] ][1]
+            newSexp = trampCall( callProcedure( symbol_and_syntaxObj[0], lispSyntax, [
+                                                  sexp,
+                                                  Cell.new(),
+                                                  (_global_MIMARKvariables( ).to_arr + keys + vars).to_list ] ))
+            newSexp = __wrapNestedLet( newSexp, __removeSameLexicalScopeVariables( lexicalVars + lexvars ))
           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
+                macroexpandEngine( x.car, syntaxArray, lexicalVars )
               else
                 x.car
               end
@@ -2056,18 +2235,14 @@ module Nendo
         sexp
       end
     end
-  
-    def macroExpandPhase( sexp )
-      converge = true
-      begin
-        macroexpandInit( 100000 )
-        newSexp  = macroexpandEngine( sexp )
-        converge = _equal_QUMARK( newSexp, sexp )
-        sexp = newSexp
-      end until converge
-      sexp
+
+    def macroexpandPhase( sexp )
+      macroexpandInit( 100000 )
+      _strip_MIMARKlet_MIMARKsyntax_MIMARKkeyword(
+         _strip_MIMARKsyntax_MIMARKquote(
+            macroexpandEngineLoop( sexp, [], [] )))
     end
-    
+
     def ppRubyExp( level, exp )
       indent = @indent * level
       exp.map { |x|
@@ -2083,7 +2258,7 @@ module Nendo
         end
       }
     end
-  
+
     def displayTopOfCalls( exception )
       STDERR.puts( "\n  <<< Top of calls >>>" )
       strs = []
@@ -2096,29 +2271,31 @@ module Nendo
         STDERR.puts( str )
       }
     end
-      
+
     def lispEval( sexp, sourcefile, lineno )
       begin
         sourceInfo = SourceInfo.new
         @lastSourcefile = sourcefile
         @lastLineno     = lineno
         sourceInfo.setSource( sourcefile, lineno, sexp )
-        sexp = macroExpandPhase( sexp )
-        sexp = quotingPhase( sexp )
+
+        # macro expand phase
+        sexp = macroexpandPhase( sexp )
         if @debug
-          printf( "\n          quoting=<<< %s >>>\n", (Printer.new())._print(sexp))
+          printf( "\n          expaneded=<<< %s >>>\n", (Printer.new())._print(sexp))
         end
-        # compiling phase written in Nendo
+
+        # compiling phase written
         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, [ sexp ]))
           if @debug
-            printf( "\n          compiled=<<< %s >>>\n", (Printer.new())._print(sexp))
+            printf( "\n          compiled= <<< %s >>>\n", (Printer.new())._print(sexp))
           end
         end
         sourceInfo.setExpanded( sexp )
-        
+
         arr = [ "trampCall( ", translate( sexp, [], sourceInfo ), " )" ]
         rubyExp = ppRubyExp( 0, arr ).flatten.join
         sourceInfo.setCompiled( rubyExp )
@@ -2154,23 +2331,23 @@ module Nendo
       }
       forward_gensym_counter()
     end
-  
+
     def _load_MIMARKcompiled_MIMARKcode_MIMARKfrom_MIMARKstring( rubyExp )
       eval( rubyExp, @binding )
       forward_gensym_counter()
     end
-    
+
     def __PAMARKload_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
@@ -2180,11 +2357,11 @@ module Nendo
       }
       ret.to_list
     end
-  
+
     def _eval( sexp )
       self.lispEval( sexp, "dynamic S-expression ( no source )", 1 )
     end
-  
+
     def _enable_MIMARKidebug()
       @debug = true
     end
@@ -2246,21 +2423,116 @@ module Nendo
       true
     end
 
+    def __setupLexicalScopeVariables( lexicalVars )
+      @lexicalVars = lexicalVars.clone
+    end
+
     def _make_MIMARKsyntactic_MIMARKclosure( mac_env, use_env, identifier )
       if _pair_QUMARK( identifier )
-        raise RuntimeError, "Error: make-syntactic-closure requires symbol only..."
-      else
-        if mac_env.to_arr.include?( identifier )
+        if :"syntax-quote" == identifier.car
           identifier
         else
-          sym = toRubySymbol( identifier ) + _gensym( ).to_s
-          sym.intern
+          raise TypeError, "make-syntactic-closure requires symbol or (syntax-quote sexp) only. but got: " + write_to_string( identifier )
         end
+      elsif _symbol_QUMARK( identifier )
+        # pp [ "identifier: ", identifier, "include?=", mac_env.to_arr.include?( identifier.intern ) ]
+        # pp [ "mac_env: ",    mac_env.to_arr ]
+        if mac_env.to_arr.include?( identifier.intern )
+          found = @lexicalVars.find { |x| identifier == x[0] }
+          if found
+            lexvars = @lexicalVars.clone
+            __wrapNestedLet( identifier, lexvars )
+          else
+            identifier
+          end
+        else
+          SyntacticClosure.new( identifier, (toRubySymbol( identifier ) + _gensym( ).to_s).intern )
+        end
+      else
+        raise TypeError, "make-syntactic-closure requires symbol or (syntax-quote sexp) type."
+      end
+    end
+
+    def _strip_MIMARKsyntax_MIMARKquote( sexp )
+      case sexp
+      when Cell
+        if _null_QUMARK( sexp )
+          sexp
+        else
+          car = sexp.car
+          if :"syntax-quote" == car or @core_syntax_hash[ :"syntax-quote" ] == car
+            Cell.new( :quote, sexp.cdr )
+          else
+            Cell.new(
+                 _strip_MIMARKsyntax_MIMARKquote( sexp.car ),
+                 _strip_MIMARKsyntax_MIMARKquote( sexp.cdr ))
+          end
+        end
+      else
+        sexp
+      end
+    end
+
+    def _strip_MIMARKlet_MIMARKsyntax_MIMARKkeyword( sexp )
+      case sexp
+      when Cell
+        if _null_QUMARK( sexp )
+          sexp
+        else
+          car = sexp.car
+          if :"quote" == car or @core_syntax_hash[ :"quote" ] == car
+            sexp
+          elsif :"let-syntax" == car or @core_syntax_hash[ :"let-syntax" ] == car
+            Cell.new( :begin,
+                 _strip_MIMARKlet_MIMARKsyntax_MIMARKkeyword( sexp.cdr.cdr ))
+          else
+            Cell.new(
+                 _strip_MIMARKlet_MIMARKsyntax_MIMARKkeyword( sexp.car ),
+                 _strip_MIMARKlet_MIMARKsyntax_MIMARKkeyword( sexp.cdr ))
+          end
+        end
+      else
+        sexp
       end
     end
 
+    def _strip_MIMARKsyntactic_MIMARKclosures( sexp )
+      case sexp
+      when Cell
+        if _null_QUMARK( sexp )
+          sexp
+        else
+          Cell.new(
+                 _strip_MIMARKsyntactic_MIMARKclosures( sexp.car ),
+                 _strip_MIMARKsyntactic_MIMARKclosures( sexp.cdr ))
+        end
+      else
+        if sexp.is_a? SyntacticClosure
+          sexp.intern
+        else
+          sexp
+        end
+      end
+    end
+
+    def _symbol_MIMARKinclude_QUMARK( sexp, sym )
+      case sexp
+      when Cell
+        if _null_QUMARK( sexp )
+          false
+        else
+          _symbol_MIMARKinclude_QUMARK( sexp.car, sym ) or _symbol_MIMARKinclude_QUMARK( sexp.cdr, sym )
+        end
+      else
+        if _symbol_QUMARK( sexp )
+          sym.intern == sexp.intern
+        else
+          false
+        end
+      end
+    end
   end
-  
+
   class Printer
     def initialize( debug = false )
       @debug    = debug
@@ -2269,14 +2541,6 @@ module Nendo
     def __write( sexp, readable )
       getQuoteKeyword = lambda { |x|
         case x
-        when :quote
-          "'"
-        when :quasiquote
-          "`"
-        when :unquote
-          ","
-        when :"unquote-splicing"
-          ",@"
         when :"dot-operator"
           "."
         else
@@ -2314,6 +2578,8 @@ module Nendo
         else
           sexp.to_s
         end
+      when SyntacticClosure
+        sprintf( "#<SyntacticClosure[%s:%s]>", sexp.originalSymbol, sexp.renamedSymbol )
       when Regexp
         "#/" + sexp.source + "/" + (sexp.casefold? ? "i" : "")
       when LispKeyword
@@ -2344,9 +2610,11 @@ module Nendo
     end
 
     def self.version
-      "0.5.0"  ##NENDO-VERSION
+      "0.5.1"  ##NENDO-VERSION
     end
-    
+
+    attr_reader :evaluator
+
     def loadInitFile( use_compiled = true )
       done = false
       if use_compiled 
@@ -2477,3 +2745,4 @@ class Hash
     arr.to_list
   end
 end
+