nendo 0.2.0 → 0.3.0

data/lib/nendo.rb

@@ -6,7 +6,6 @@
 #
 #
 require 'stringio'
-require 'pp'
 
 class Nil
   include Enumerable
@@ -127,6 +126,51 @@ class Array
   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
+    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
+    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
@@ -189,6 +233,7 @@ class Reader
   T_LPAREN              = :t_lparen
   T_RPAREN              = :t_rparen
   T_SYMBOL              = :t_symbol
+  T_KEYWORD             = :t_keyword
   T_NUM                 = :t_num
   T_STRING              = :t_string
   T_QUOTE               = :t_quote
@@ -293,12 +338,12 @@ class Reader
           else
             T_UNQUOTE_SPLICING
           end
-        when '('
+        when '(', '['
           T_LPAREN
-        when ')'
+        when ')', ']'
           T_RPAREN
         when '.'
-          str += readwhile( /[_a-zA-Z0-9!?.-]/ ).gsub( /[-]/, '_' )
+          str += readwhile( /[_a-zA-Z0-9!?.]/ )
           if 1 == str.length
             T_DOT
           else
@@ -311,7 +356,7 @@ class Reader
           str = ""
           T_COMMENT
         when /[#]/
-          keyword = readwhile( /[?=!tf]/ )
+          keyword = readwhile( /[?=!]/ )
           case keyword
           when /[?=]/
             str = ""
@@ -320,30 +365,29 @@ class Reader
             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 )
+            keyword = readwhile( /[a-z]/ )
+            case keyword
+            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
           end
-        when /[_a-zA-Z]/      # symbol
-          str += readwhile( /[_a-zA-Z0-9!?*.:-]/ ).gsub( /[-]/, '_' )
-          T_SYMBOL
-        when /[*\/=!<>&|%]/   # symbol
-          str += readwhile( /[+*\/=!<>&|?%-]/ )
+        when /[_a-zA-Z!$%&*+\/:<=>?@^~-]/      # symbol
+          str += readwhile( /[0-9._a-zA-Z!$%&*+\/:<=>?@^~-]/ )
           if str.match( /^[=][>]$/ )
             T_FEEDTO
-          else
-            T_SYMBOL
-          end
-        when /[+-]/           # number
-          str += readwhile( /[0-9.]/ )
-          if 1 < str.length
+          elsif str.match( /^[+-][0-9.]+$/ )
             T_NUM
+          elsif str.match( /^[:]/ )
+            str = str[1..-1]
+            T_KEYWORD
           else
             T_SYMBOL
           end
@@ -410,13 +454,15 @@ class Reader
     when T_UNQUOTE
       :unquote
     when T_UNQUOTE_SPLICING
-      :unquote_splicing
+      :"unquote-splicing"
     when T_DOT
-      :dot_operator
+      :"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
@@ -445,9 +491,12 @@ class Reader
           # (. symbol1 symbol2 ... ) form
           cells << Cell.new( atom() )
         else
-          # ( symbol1 . symbol2 ... ) form
+          # ( 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 T_QUOTE , T_QUASIQUOTE , T_UNQUOTE , T_UNQUOTE_SPLICING, T_DEBUG_PRINT
         cells << Cell.new( sexp() )
@@ -553,14 +602,14 @@ module BuiltinFunctions
     end
   end
   
-  def _equal_QMARK( a, b )
+  def _equal_QUMARK( a, b )
     if a.class != b.class
       false
     elsif a.class == Cell
       if a.isNull and b.isNull
         true
       else
-        _equal_QMARK( a.car, b.car ) and _equal_QMARK( a.cdr, b.cdr )
+        _equal_QUMARK( a.car, b.car ) and _equal_QUMARK( a.cdr, b.cdr )
       end
     elsif a.class == Nil and b.class == Nil
       true
@@ -569,41 +618,61 @@ module BuiltinFunctions
     end
   end
   
-  def _plus( first, *rest )
-    raise TypeError if not (_number_QMARK(first) or _string_QMARK(first))
-    rest = rest[0].to_arr
-    __assertFlat( rest )
-    if 0 == rest.length 
-      first
+  def __PLMARK( *args )
+    arr = args[0].to_arr
+    case args[0].length
+    when 0
+      0
     else
-      rest.inject(first){|x,y| x+y}
+      __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
     end
   end
   
-  def _minus( first, *rest )
-    raise TypeError if not (_number_QMARK(first) or _string_QMARK(first))
-    rest = rest[0].to_arr
-    __assertFlat( rest )
-    if 0 == rest.length 
-      - first
+  def __ASMARK( *args )
+    arr = args[0].to_arr
+    case args[0].length
+    when 0
+      1
     else
-      rest.inject(first){|x,y| x-y}
+      __assertFlat( arr )
+      arr.each { |x| 
+        if not _number_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
     end
   end
 
-  def _multi( first, *rest )
-    raise TypeError if not _number_QMARK(first)
+  def __MIMARK( first, *rest )
+    raise TypeError if not _number_QUMARK(first)
     rest = rest[0].to_arr
     __assertFlat( rest )
     if 0 == rest.length 
-      first
+      - first
     else
-      rest.inject(first){|x,y| x*y}
+      rest.inject(first){|x,y| x-y}
     end
   end
 
-  def _div( first, *rest )
-    raise TypeError if not _number_QMARK(first)
+  def __SLMARK( first, *rest )
+    raise TypeError if not _number_QUMARK(first)
     rest = rest[0].to_arr
     __assertFlat( rest )
     if 0 == rest.length 
@@ -613,8 +682,8 @@ module BuiltinFunctions
     end
   end
 
-  def _mod( first, *rest )
-    raise TypeError if not _number_QMARK(first)
+  def __PAMARK( first, *rest )
+    raise TypeError if not _number_QUMARK(first)
     rest = rest[0].to_arr
     __assertFlat( rest )
     if 0 == rest.length 
@@ -630,7 +699,15 @@ module BuiltinFunctions
   end
 
   def _cons( first, second )
-    Cell.new( first, second )
+    if second.is_a? Cell
+      if second.isNull
+        Cell.new( first )
+      else
+        Cell.new( first, second )
+      end
+    else
+      Cell.new( first, second )
+    end
   end
 
   def _exit( *args )
@@ -654,7 +731,7 @@ module BuiltinFunctions
     Kernel::sprintf( format, *(rest[0].to_arr) )
   end
 
-  def _null_QMARK( arg )
+  def _null_QUMARK( arg )
     if Nil == arg.class
       true
     elsif Cell == arg.class
@@ -664,7 +741,7 @@ module BuiltinFunctions
     end
   end
   def _length(   arg )
-    if _null_QMARK( arg )
+    if _null_QUMARK( arg )
       0
     elsif arg.is_a? Cell
       arg.length
@@ -676,43 +753,64 @@ module BuiltinFunctions
   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 )           (0..num-1).to_a.to_list end
-  def _eq_QMARK(      a,b )      a ==  b end
-  def _gt_QMARK(      a,b )      a >   b end
-  def _ge_QMARK(      a,b )      a >=  b end
-  def _lt_QMARK(      a,b )      a <   b end
-  def _le_QMARK(      a,b )      a <=  b end
-  def _eqv_QMARK(     a,b )      a === b 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_to_string(  arg  )  printer = Printer.new ; printer._write( 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_QMARK( arg )   ((Proc == arg.class) or (Method == arg.class)) end
-  def _macro_QMARK( arg )       (LispMacro == arg.class) end
-  def _symbol_QMARK(    arg )   (Symbol == arg.class) end
-  def _pair_QMARK(      arg )   
-    if _null_QMARK( arg )
+  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 _number_QMARK(   arg )    ((Fixnum == arg.class) or (Float == arg.class)) end
-  def _string_QMARK(   arg )    String == arg.class end
-  def _macroexpand_1( arg )
-    if _pair_QMARK( arg )
+  def _number_QUMARK(   arg )    ((Fixnum == arg.class) or (Float == arg.class)) end
+  def _string_QUMARK(   arg )    String == arg.class end
+  def _macroexpand_MIMARK1( arg )
+    if _pair_QUMARK( arg )
       macroexpand_1( arg )
     else
       arg
     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 )
+  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
@@ -722,8 +820,10 @@ module BuiltinFunctions
       raise TypeError
     end
   end
-  def _intern( arg )            arg.intern  end
-  def _string_join( lst, delim )
+  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, delim )
     lst.to_a.map{ |x| x.car }.join( delim )
   end
   def _require( arg )
@@ -754,16 +854,78 @@ module BuiltinFunctions
     callProcedure( "(apply1 genereate func)", first, arg )
   end
 
-  def _global_variables
+  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
+      raise ArgumentError, "Error: make-values expects a list argument."
+    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."
+    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."
+    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."
+    end
+  end
+
+  def _get_MIMARKnendo_MIMARKhome
+    File.dirname(__FILE__) 
+  end
+
+  def _hash_MIMARKtable_MIMARKget( h, key, *args )
+    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 )
+    h[key] = value
+  end
+
+  def _raise( exception, message )
+    raise exception, message
+  end
 end
 
 
+
 # Translate S expression to Ruby expression and Evaluation
 class Evaluator
   include BuiltinFunctions
@@ -771,31 +933,35 @@ class Evaluator
     @indent  = "  "
     @binding = binding
     @debug   = debug
-    @alias   = {'+'        => 'plus',
-                '-'        => 'minus',
-                '*'        => 'multi',
-                '/'        => 'div',
-                '%'        => 'mod',
-                '='        => 'eq?',
-                '=='       => 'eq?',
-                '>'        => 'gt?',
-                '>='       => 'ge?',
-                '<'        => 'lt?',
-                '<='       => 'le?',
-                '==='      => 'eqv?',
+    @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
+
     # built-in functions
-    @sym = Hash.new
     self.methods.grep( /^_/ ) { |rubySymbol|
-      @sym[ rubySymbol ] = self.method( rubySymbol )
+      @___tmp = self.method( rubySymbol )
+      eval( sprintf( "@%s = @___tmp", rubySymbol ), @binding )
     }
 
-    # initialize global symbols
-    rubyExp = @sym.keys.map { |name|
-      sprintf( "@%s = @sym[ '%s' ] ", name, name )
-    }.join( " ; " )
-    eval( rubyExp, @binding )
-
     # initialize buildin functions as Proc objects
     rubyExp = self.methods.select { |x|
       x.to_s.match( /^_/ )
@@ -808,13 +974,19 @@ class Evaluator
     @gensym_counter = 0
 
     # compiled ruby code
-    @compiled_code = []
+    #  { 'filename1' => [ 'code1' 'code2' ... ], 
+    #    'filename2' => [ 'code1' 'code2' ... ], ... }
+    @compiled_code = Hash.new
   end
 
   def _gensym( )
     @gensym_counter += 1
     sprintf( "__gensym__%d", @gensym_counter ).intern
   end
+  
+  def forward_gensym_counter( )
+    @gensym_counter += 10000
+  end
 
   def toRubyValue( val )
     if NilClass == val.class
@@ -834,7 +1006,12 @@ class Evaluator
       ""
     else
       arr = name.gsub( /["]/, '' ).split( /[.]/ )
-      arr[0] = arr[0].gsub( /[*]/, '_AMARK' ).gsub( /[?]/, '_QMARK' ).gsub( /[!]/, '_EMARK' ).gsub( /[-]/, '_' )
+      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] == ""
@@ -854,7 +1031,10 @@ class Evaluator
     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]
-    name.gsub( /_AMARK/, '*' ).gsub( /_QMARK/, '?' ).gsub( /_EMARK/, '!' )
+    @char_table_ruby_to_lisp.each_pair { |key,val|
+      name = name.gsub( Regexp.new( key ), val )
+    }
+    name
   end
 
   def toRubyArgument( origname, pred, args )
@@ -920,10 +1100,16 @@ class Evaluator
     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 : "@"
+      global_cap = locals.flatten.include?( variable_sym.split( /[.]/ )[0] ) ? 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 )
+      [
+       '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
@@ -947,7 +1133,6 @@ class Evaluator
         else
           origname = funcname.to_s
           funcname = funcname.to_s
-          funcname = @alias[ funcname ] if @alias[ funcname ] 
           sym      = toRubySymbol( funcname )
           [sprintf( "callProcedure( '%s',", origname ),
            [lispSymbolReference( sym, locals, nil, sourcefile, lineno )] + [","],
@@ -1094,7 +1279,7 @@ class Evaluator
     case sexp
     when Cell
       if sexp.isNull
-        str += "Nil.new"
+        str += "Cell.new()"
       else
         arr = sexp.map { |x| genQuote( x.car ) }
         str += "Cell.new("
@@ -1107,6 +1292,8 @@ class Evaluator
       str += sprintf( ":\"%s\"", sexp.to_s )
     when String
       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
@@ -1162,11 +1349,7 @@ class Evaluator
       elsif sexp.isNull
         [ "Cell.new()" ]
       elsif Cell == sexp.car.class
-        if :lambda == sexp.car.car
-          self.apply( translate( sexp.car, locals ), sexp.cdr, sexp.car.car.sourcefile, sexp.car.car.lineno, locals, true )
-        else
-          translate( sexp.car, locals )
-        end
+        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
@@ -1186,13 +1369,14 @@ class Evaluator
       case sexp
       when Symbol
         sym = sexp.to_s
-        sym = @alias[ sym ]  if @alias[ sym ]
         sym = toRubySymbol( sym )
         lispSymbolReference( sym, locals, nil, sexp.sourcefile, sexp.lineno )
       when Fixnum
         sexp.to_s
       when String
         sprintf( "\"%s\"", LispString.escape( sexp ))
+      when LispKeyword
+        sprintf( "LispKeyword.new( \"%s\" )", sexp.key )
       when Nil
         "Nil.new"
       when TrueClass, FalseClass, NilClass  # reserved symbols
@@ -1229,7 +1413,7 @@ class Evaluator
         sexp.cdr.cdr = quoting( sexp.cdr.cdr )
         sexp
       elsif :let == sexp.car
-        if _null_QMARK( sexp.cdr )
+        if _null_QUMARK( sexp.cdr )
           # do nothing
           p "kiyoka1"
         else
@@ -1266,7 +1450,7 @@ class Evaluator
       sexp
     else
       newSexp = macroexpand_1_sub( sexp )
-      if not _equal_QMARK( newSexp, sexp )
+      if not _equal_QUMARK( newSexp, sexp )
         @expand_flag = false
       end
       newSexp
@@ -1280,7 +1464,6 @@ class Evaluator
         sexp
       else
         sym = sexp.car.to_s
-        sym = @alias[ sym ]  if @alias[ sym ]
         sym = toRubySymbol( sym )
         newSexp = sexp
         if isRubyInterface( sym )
@@ -1289,7 +1472,7 @@ class Evaluator
           eval( sprintf( "@__macro = @%s", sym ), @binding )
           newSexp = callProcedure( sym, @__macro, sexp.cdr )
         end
-        if _equal_QMARK( newSexp, sexp )
+        if _equal_QUMARK( newSexp, sexp )
           sexp.map { |x|
             if x.car.is_a? Cell
               macroexpand_1_check( x.car )
@@ -1315,7 +1498,7 @@ class Evaluator
     converge = true
     begin
       newSexp  = macroexpand_1( sexp )
-      converge = _equal_QMARK( newSexp, sexp )
+      converge = _equal_QUMARK( newSexp, sexp )
       sexp = newSexp
     end until converge
     sexp
@@ -1345,14 +1528,17 @@ class Evaluator
     end
     arr = [ translate( sexp, [] ) ]
     rubyExp = ppRubyExp( 0, arr ).flatten.join
-    @compiled_code << rubyExp
+    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, sourcefile, lineno );
   end
 
   def _load( filename )
     printer = Printer.new( @debug )
-    open( filename ) {|f|
+    open( filename, "r:utf-8" ) {|f|
       reader = Reader.new( f, filename, false )
       while true
         lineno = reader.lineno
@@ -1367,25 +1553,32 @@ class Evaluator
     }
   end
 
-  def _loadCompiledCode( filename )
-    open( filename ) { |f|
+  def _load_MIMARKcompiled_MIMARKcode( filename )
+    open( filename, "r:utf-8" ) { |f|
       rubyExp = f.read
       eval( rubyExp, @binding )
     }
+    forward_gensym_counter()
   end
 
-  def _get_compiled_code()
-    @compiled_code.to_list
+  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_idebug()
+  def _enable_MIMARKidebug()
     @debug = true
   end
-  def _disable_idebug()
+  def _disable_MIMARKidebug()
     @debug = false
   end
 end
@@ -1404,9 +1597,9 @@ class Printer
         "`"
       when :unquote
         ","
-      when :unquote_splicing
+      when :"unquote-splicing"
         ",@"
-      when :dot_operator
+      when :"dot-operator"
         "."
       else
         false
@@ -1436,6 +1629,8 @@ class Printer
       else
         sexp.to_s
       end
+    when LispKeyword
+      ":" + sexp.key.to_s
     when Nil
       "()"
     when nil
@@ -1466,7 +1661,7 @@ class Nendo
     if use_compiled 
       compiled_file = File.dirname(__FILE__) + "/init.nndc"
       if File.exist?( compiled_file )
-        @evaluator._loadCompiledCode( compiled_file )
+        @evaluator._load_MIMARKcompiled_MIMARKcode( compiled_file )
         done = true
       end
     end