nendo 0.5.1 → 0.5.2

data/lib/nendo.rb

@@ -229,14 +229,6 @@ module Nendo
       @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
 
@@ -287,13 +279,13 @@ module Nendo
   end
   
   class DelayedCallPacket
-    def initialize( _origname, _rubysym, _pred, _args )
-      @origname = _origname
+    def initialize( _rubysym, _origname, _pred, _args )
       @rubysym  = _rubysym
+      @origname = _origname
       @pred     = _pred
       @args     = _args
     end
-    attr_reader :origname, :rubysym, :pred, :args
+    attr_reader :rubysym, :origname, :pred, :args
   end
 
   class Token
@@ -892,7 +884,12 @@ module Nendo
         (a === b)
       end
     end
-    
+
+    def __PLMARK_ARGS0( )            0           end
+    def __PLMARK_ARGS1( a )          a           end
+    def __PLMARK_ARGS2( a, b )       a + b       end
+    def __PLMARK_ARGS3( a, b, c )    a + b + c   end
+
     def __PLMARK( *args )
       arr = args[0].to_arr
       case args[0].length
@@ -900,7 +897,7 @@ module Nendo
         0
       else
         __assertFlat( arr )
-        arr.each { |x| 
+        arr.each { |x|
           if not (_number_QUMARK(x) or _string_QUMARK(x))
             ##arr.each { |v| STDERR.printf( "__PLMARK: %s\n", v ) }
             raise TypeError, sprintf( "Error: arg %s is [%s] type",x ,x.class )
@@ -914,7 +911,12 @@ module Nendo
         end
       end
     end
-    
+
+    def __ASMARK_ARGS0( )            1           end
+    def __ASMARK_ARGS1( a )          a           end
+    def __ASMARK_ARGS2( a, b )       a * b       end
+    def __ASMARK_ARGS3( a, b, c )    a * b * c   end
+
     def __ASMARK( *args )
       arr = args[0].to_arr
       case args[0].length
@@ -935,7 +937,12 @@ module Nendo
         end
       end
     end
-  
+
+    def __MIMARK_ARGS0( )            0           end
+    def __MIMARK_ARGS1( a )          -a          end
+    def __MIMARK_ARGS2( a, b )       a - b       end
+    def __MIMARK_ARGS3( a, b, c )    a - b - c   end
+
     def __MIMARK( first, *rest )
       raise TypeError if not _number_QUMARK(first)
       rest = rest[0].to_arr
@@ -946,22 +953,22 @@ module Nendo
         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 
+      if 0 == rest.length
         1 / first
       else
         rest.inject(first){|x,y| x/y}
       end
     end
-    
+
     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)
@@ -973,23 +980,23 @@ module Nendo
       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 
+      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 first.is_a? Nil
         first = Cell.new
@@ -1036,19 +1043,19 @@ module Nendo
         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
@@ -1119,14 +1126,14 @@ module Nendo
         nil
       end
     end
-    def _pair_QUMARK(      arg )   
+    def _pair_QUMARK(      arg )
       if _null_QUMARK( arg )
         false
       else
         (Cell == arg.class)
       end
     end
-    def __PAMARKlist_QUMARK(      arg )   
+    def __PAMARKlist_QUMARK(      arg )
       if _pair_QUMARK( arg )
         (not arg.lastAtom) and (1 <= arg.to_arr.size) # it means proper list?
       else
@@ -1219,19 +1226,19 @@ module Nendo
       end until s[2]
       ret
     end
-  
+
     def _apply1( first, arg )
-      trampCall( callProcedure( "(apply1 genereate func)", first, arg.to_arr ))
+      trampCall( callProcedure( nil, "(apply1 genereate func)", first, arg.to_arr ))
     end
-  
+
     def _global_MIMARKvariables
       self.instance_variables.select { |x|
         x.match( /^[@]_[_a-zA-Z]/ )
-      }.map{ |name| 
+      }.map{ |name|
         self.toLispSymbol( name[1..-1] ).intern
       }.to_list
     end
-  
+
     def _make_MIMARKvalues( lst )
       if _pair_QUMARK( lst )
         LispValues.new( lst.to_arr )
@@ -1241,9 +1248,9 @@ module Nendo
         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
@@ -1251,7 +1258,7 @@ module Nendo
         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 )
@@ -1259,7 +1266,7 @@ module Nendo
         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
@@ -1267,7 +1274,7 @@ module Nendo
         raise TypeError, "Error: keyword->string expects only keyword object."
       end
     end
-  
+
     def _hash_MIMARKtable_MIMARKget( h, key, *args )
       if h.has_key?(key)
         h[key]
@@ -1280,7 +1287,7 @@ module Nendo
         end
       end
     end
-  
+
     def _hash_MIMARKtable_MIMARKput_EXMARK( h, key, value )
       h[key] = value
     end
@@ -1289,20 +1296,20 @@ module Nendo
       # don't use h.has_key(k), because has_key method undefined on some database bindings. (e.g. KyotoCabinet)
       h[key] ? true : false
     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"
@@ -1314,8 +1321,8 @@ module Nendo
     end
 
   end
-  
-  
+
+
   # Translate S expression to Ruby expression and Evaluation
   class Evaluator
     include BuiltinFunctions
@@ -1331,6 +1338,7 @@ module Nendo
       @trace_debug = false
       @lexicalVars = []
       @syntaxHash = {}
+      @optimize_level = 2
       @char_table_lisp_to_ruby = {
         # list     (! $ % & * + - . / : < = > ? @ ^ _ ~ ...)
         '!'   => '_EXMARK',
@@ -1395,9 +1403,6 @@ module Nendo
       @call_depth     = 0
       @call_counters  = Hash.new
 
-      # init optimize level
-      @optimize_level = 1
-  
       # compiled ruby code
       #  { 'filename1' => [ 'code1' 'code2' ... ], 
       #    'filename2' => [ 'code1' 'code2' ... ], ... }
@@ -1444,7 +1449,7 @@ module Nendo
     def defMethodStr( name, _log )
       [ "def self." + name.to_s + "_METHOD( origname, pred, args ) ",
         "  lispMethodEntry( origname, " + _log.to_s + " ) ; ",
-        "  ret = callProcedure( origname, pred, args ) ;",
+        "  ret = callProcedure( '" + name.to_s + "', origname, pred, args ) ;",
         "  lispMethodExit( origname,  " + _log.to_s + " ) ; ",
         "  return ret ",
         "end " ].join
@@ -1517,23 +1522,27 @@ module Nendo
       }
       name
     end
-  
+
+    def errorMessageOf_toRubyArgument( origname, no, req, got )
+      sprintf( "Error: [%s] wrong number of arguments for closure `%s' (requires %d, but got %d)", no, origname, req, got )
+    end
+
     def toRubyArgument( origname, pred, args )
-      argument_error_message = sprintf( "Error: wrong number of arguments for closure `%s'", origname )
+      len = args.length
       num = pred.arity
       if 0 == num
-        raise ArgumentError, argument_error_message if 0 != args.length
+        raise ArgumentError, errorMessageOf_toRubyArgument( origname, 1, num, len ) if 0 != len
         []
       elsif 0 < num
-        if 0 == args.length
+        if 0 == len
           [ Nil.new ]
         else
-          raise ArgumentError, argument_error_message if num != args.length
+          raise ArgumentError, errorMessageOf_toRubyArgument( origname, 2, num, len ) if num != len
           args
         end
       else
         num = num.abs( )-1
-        raise ArgumentError, argument_error_message if num > args.length
+        raise ArgumentError, errorMessageOf_toRubyArgument( origname, 3, num, len ) if num > len
         params = []
         rest = []
         args.each_with_index { |x,i|
@@ -1555,13 +1564,10 @@ module Nendo
         result
       end
     end
-  
+
     def trampCall( result )
-      while result.is_a? DelayedCallPacket
-        @tmp_origname = result.origname
-        @tmp_pred     = result.pred
-        @tmp_args     = result.args
-        result = eval( sprintf( "self.%s( @tmp_origname, @tmp_pred, @tmp_args )", result.rubysym + "_METHOD" ), @binding )
+      while result.class == DelayedCallPacket
+        result = __send__( result.rubysym + "_METHOD", result.origname, result.pred, result.args )
       end
       result
     end
@@ -1570,36 +1576,35 @@ module Nendo
       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] )
+        callProcedure( name, args[0], args[1], args[2] )
       end
     end
     
     def delayCall( rubysym, origname, pred, args )
       case @optimize_level
       when 0 # no optimize
-        callProcedure( origname, pred, args )
+        callProcedure( rubysym, origname, pred, args )
       else # tail call optimization
-        DelayedCallPacket.new( origname, rubysym, pred, args )
+        DelayedCallPacket.new( rubysym, origname, pred, args )
       end
     end
-    
-    def callProcedure( origname, pred, args )
+
+    def callProcedure( rubysym, origname, pred, args )
       if @call_counters.has_key?( origname )
         @call_counters[ origname ] += 1
       else
         @call_counters[ origname ]  = 1
       end
-
       result = pred.call( *toRubyArgument( origname, pred, args ))
 
       @call_counters[ origname ]   -= 1
 
       result
     end
-  
+
     # for code generation of Ruby's argument values
     # in case:  str = ","
-    # [1,"2",3] => [ 
+    # [1,"2",3] => [
     #                [ 1,  ","]
     #                ["2", ","]
     #                [ 3 ]
@@ -1616,6 +1621,37 @@ module Nendo
       [ :define, :set!, :"define-syntax", @core_syntax_hash[ :define ], @core_syntax_hash[ :set! ], @core_syntax_hash[ :"define-syntax" ] ].include?( sym )
     end
 
+    def optimizedFunc( origname, rubysym, args )
+      case origname
+      when '+', '-', '*'
+        case args.length
+        when 0
+          [ "#{rubysym}_ARGS0(",                                       ")" ]
+        when 1
+          [ "#{rubysym}_ARGS1(",           args[0],                     ")" ]
+        when 2
+          [ "#{rubysym}_ARGS2(",           args[0], args[1],             ")" ]
+        when 3
+          [ "#{rubysym}_ARGS3(",           args[0], args[1], args[2],     ")" ]
+        else
+          false
+        end
+      when 'car', 'cdr', 'not', 'length', 'null?', 'reverse', 'uniq',
+        'write', 'write-to-string', 'display', 'print',
+        'procedure?', 'macro?', 'symbol?', 'keyword?', 'syntax?', 'core-syntax?',
+        'pair?', '%list?', 'integer?', 'number?', 'string?', 'macroexpand-1',
+        'to-s', 'to-i', 'nil?', 'to-list', 'to-arr',
+        'intern', 'string->symbol', 'symbol->string', 'read-from-string'
+        raise ArgumentError, "Error: #{origname} requires 1 argument. "  unless 1 == args.length
+        [ "#{rubysym}(",              args[0],         ")" ]
+      when 'cons', '=', ">", ">=", "<", "<=", "eq?", "equal?", 'set-car!', 'set-cdr!'
+        raise ArgumentError, "Error: #{origname} requires 2 arguments. " unless 2 == args.length
+        [ "#{rubysym}(",            args[0], args[1], ")" ]
+      else
+        false
+      end
+    end
+
     def execFunc( funcname, args, sourcefile, lineno, locals, sourceInfo, execType )
       if isDefines( funcname )
         ar = args.cdr.map { |x| x.car }
@@ -1664,29 +1700,39 @@ module Nendo
         else
           # Nendo function
           arr = separateWith( args.map { |x| x.car }, "," )
+          origname = funcname.to_s
+          sym   = toRubySymbol( origname )
           if EXEC_TYPE_ANONYMOUS == execType
-            [sprintf( "trampCall( callProcedure( 'anonymouse', " ),
-             [ funcname ] + [ "," ],
-             "[", arr, "]",
-             "          ))"]
+            [sprintf( "trampCall( callProcedure( nil, 'anonymouse', " ),
+              [ funcname ] + [ "," ],
+              "[", arr, "]",
+              "          ))"]
           else
-            origname = funcname.to_s
-            funcname = funcname.to_s
-            sym      = toRubySymbol( funcname )
-            _call = case execType
-                    when EXEC_TYPE_NORMAL
-                      if locals.flatten.include?( sym )
-                        [          "trampCall( callProcedure(  ",        "))" ] # local function
-                      else
-                        [ sprintf( "trampCall( self.%s_METHOD( ", sym ), "))" ] # toplevel function
+            result = false
+            if (execType == EXEC_TYPE_NORMAL) and (not locals.flatten.include?( sym ))
+              if 1 < @optimize_level
+                result = optimizedFunc( origname, sym, arr )
+              end
+            end
+            if result
+              result
+            else
+              _call = case execType
+                      when EXEC_TYPE_NORMAL
+                        if locals.flatten.include?( sym )
+                          [          "trampCall( callProcedure(  '" + sym + "', ", "))" ] # local function
+                        else
+                          [ sprintf( "trampCall( self.%s_METHOD( ", sym ), "))" ]         # toplevel function
+                        end
+                      when EXEC_TYPE_TAILCALL
+                        [ sprintf( "delayCall( '%s', ", sym ),  ")"  ]
                       end
-                    when EXEC_TYPE_TAILCALL
-                      [ sprintf( "delayCall( '%s', ", sym ),    ")"  ]
-                    end
-            [sprintf( "%s '%s',", _call[0], origname ), 
-             [lispSymbolReference( sym, locals, nil, sourcefile, lineno )] + [","], 
-             "[", arr, "]",
-             sprintf( "             %s", _call[1] )]
+
+              [sprintf( "%s '%s',", _call[0], origname ),
+                [lispSymbolReference( sym, locals, nil, sourcefile, lineno )] + [","],
+                "[", arr, "]",
+                sprintf( "             %s", _call[1] )]
+            end
           end
         end
       end
@@ -2194,14 +2240,14 @@ module Nendo
             sexp
           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 ))
+            newSexp = trampCall( callProcedure( nil, sym, @__macro, sexp.cdr.to_arr ))
           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( ) ] ))
+            newSexp = trampCall( callProcedure( nil, 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]}
@@ -2212,7 +2258,7 @@ module Nendo
             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, [
+            newSexp = trampCall( callProcedure( nil, symbol_and_syntaxObj[0], lispSyntax, [
                                                   sexp,
                                                   Cell.new(),
                                                   (_global_MIMARKvariables( ).to_arr + keys + vars).to_list ] ))
@@ -2286,10 +2332,11 @@ module Nendo
         end
 
         # compiling phase written
-        sym = toRubySymbol( "%compile-phase" )
+        origsym = "%compile-phase"
+        sym = toRubySymbol( origsym )
         if ( eval( sprintf( "(defined? @%s and Proc == @%s.class)", sym,sym ), @binding ))
           eval( sprintf( "@___tmp = @%s", sym ), @binding )
-          sexp = trampCall( callProcedure( sym, @___tmp, [ sexp ]))
+          sexp = trampCall( callProcedure( nil, origsym, @___tmp, [ sexp ]))
           if @debug
             printf( "\n          compiled= <<< %s >>>\n", (Printer.new())._print(sexp))
           end
@@ -2412,7 +2459,7 @@ module Nendo
 
       argsStr = (1..(pred.arity)).map { |n| "arg" + n.to_s }.join( "," )
       str = [ "def self." + origname + "(" + argsStr + ")",
-              sprintf( "  trampCall( callProcedure( '%s', @_%s, [ " + argsStr + " ] )) ",
+              sprintf( "  trampCall( callProcedure( nil, '%s', @_%s, [ " + argsStr + " ] )) ",
                        origname, origname ),
               "end ;",
               "def @core." + origname + "(" + argsStr + ")",
@@ -2610,7 +2657,7 @@ module Nendo
     end
 
     def self.version
-      "0.5.1"  ##NENDO-VERSION
+      "0.5.2"  ##NENDO-VERSION
     end
 
     attr_reader :evaluator