nydp 0.5.0 → 0.6.0

data/lib/nydp/function_invocation.rb

@@ -3,32 +3,77 @@ module Nydp
   end
 
   module Invocation
-    @@sig_counts = Hash.new { |h,k| h[k] = 0}
-
-    # def self.sig name ; @@sig_counts[name] += 1 ; end
-
-    # def self.whazzup
-    #   puts @@sig_counts.to_a.sort_by { |c| c[1] }.map { |c| "#{c[1]}\t#{c[0]}"}
-    # end
-
     class Base
       include Helper
       def initialize expr, source, sig=nil
         @expr, @source, @sig = expr, source, sig
       end
 
+      def compile_to_ruby indent, srcs, opts={}
+        ruby = if opts[:cando]
+                 compile_do_expr_to_ruby indent, srcs
+               end
+
+        ruby ||= normal_compile_to_ruby indent, srcs
+      end
+
+      def compile_do_expr_to_ruby indent, srcs
+        if @expr.car.is_a?(InterpretedFunction) && !@expr.cdr && @expr.car.can_do?
+          @expr.car.compile_do_expr_to_ruby indent, srcs
+        end
+      end
+
+      def normal_compile_to_ruby indent, srcs
+        ra = @expr.map { |e| e.compile_to_ruby "#{indent}  ", srcs}.to_a
+        fn_expr = @expr.first.to_s.inspect.gsub("\'", "\\\\'")
+        fn = ra.shift
+
+        src_expr = @expr.inspect.split(/\n/).join('\n')
+
+        if ra.empty?
+          "#{indent}  ##> #{src_expr}
+#{indent}  (begin ; #{fn}.
+#{indent}    ##> #{src_expr}
+#{indent}    _nydp_call()
+#{indent}   rescue CantCallNil => e
+#{indent}    (raise 'can\\'t call nil : #{fn_expr}')
+#{indent}   end)"
+        else
+          "#{indent}  ##> #{src_expr}
+#{indent}  (begin ; #{fn}.
+#{indent}    ##> #{src_expr}
+#{indent}    _nydp_call(#{ra.join(",\n")})
+#{indent}   rescue CantCallNil => e
+#{indent}    (raise 'can\\'t call nil : #{fn_expr}')
+#{indent}   end)"
+        end
+      end
+
+#       def compile_to_ruby indent, srcs
+#         ra = @expr.map { |e| e.compile_to_ruby "#{indent}  ", srcs}
+#         fn = ra.shift
+
+#         if ra.empty?
+#           "#{indent}#{fn}._nydp_callable(#{@expr.first.to_s.inspect})._nydp_call()"
+#         else
+#           "#{indent}#{fn}._nydp_callable(#{@expr.first.to_s.inspect})._nydp_call(
+# #{ra.join(",\n")}
+# #{indent})"
+#         end
+#       end
+
       def handle e, f, invoker, *args
         case e
         when Nydp::Error, InvocationFailed
           raise
         else
           if e.is_a?(NoMethodError) && !f.respond_to?(invoker)
-            raise InvocationFailed.new("#{f.inspect} is not a function: args were #{args.inspect} in #{source.inspect}")
+            raise InvocationFailed.new("#{f._nydp_inspect} is not a function: args were #{args._nydp_inspect} in #{source._nydp_inspect}")
           else
-            msg  = args.map { |a| "  #{a.inspect}"}.join("\n")
-            msg  =  "failed to execute invocation #{f.inspect}\n#{msg}"
-            msg +=  "\nsource was #{source.inspect}"
-            msg +=  "\nfunction name was #{source.car.inspect}"
+            msg  = args.map { |a| "  #{a._nydp_inspect}"}.join("\n")
+            msg  =  "failed to execute invocation #{f._nydp_inspect}\n#{msg}"
+            msg +=  "\nsource was #{source._nydp_inspect}"
+            msg +=  "\nfunction name was #{source.car._nydp_inspect}"
             raise InvocationFailed.new msg
           end
         end
@@ -39,253 +84,10 @@ module Nydp
         @expr.map { |x| x.lexical_reach n}.max
       end
 
-      def inspect ; @expr.map { |x| x.inspect }.join(' ') ; end
+      def inspect ; "(" + @expr.map { |x| x._nydp_inspect }.join(' ') + ")" ; end
       def source  ; @source       ; end
       def to_s    ; source.to_s   ; end
     end
-
-    class Invocation_1 < Invocation::Base
-      def execute vm
-#        Invocation.sig @sig
-        f = vm.args.pop
-        f.invoke_1 vm
-      rescue StandardError => e
-        handle e, f, :invoke_1
-      end
-    end
-
-    class Invocation_2 < Invocation::Base
-      def execute vm
-#        Invocation.sig @sig
-        arg = vm.args.pop
-        f = vm.args.pop
-        f.invoke_2 vm, arg
-      rescue StandardError => e
-        handle e, f, :invoke_2, arg
-      end
-    end
-
-    class Invocation_3 < Invocation::Base
-      def execute vm
-#        Invocation.sig @sig
-        arg_1 = vm.args.pop
-        arg_0 = vm.args.pop
-        f   = vm.args.pop
-        f.invoke_3 vm, arg_0, arg_1
-      rescue StandardError => e
-        handle e, f, :invoke_3, arg_0, arg_1
-      end
-    end
-
-    class Invocation_4 < Invocation::Base
-      def execute vm
-        # Invocation.sig @sig
-        arg_2 = vm.args.pop
-        arg_1 = vm.args.pop
-        arg_0 = vm.args.pop
-        f   = vm.args.pop
-        f.invoke_4 vm, arg_0, arg_1, arg_2
-      rescue StandardError => e
-        handle e, f, :invoke_4, arg_0, arg_1, arg_2
-      end
-    end
-
-    class Invocation_N < Invocation::Base
-      def initialize arg_count, expr, source
-        super expr, source
-        @arg_count = arg_count
-      end
-
-      def execute vm
-#        Invocation.sig @sig
-        args = vm.pop_args @arg_count
-        args.car.invoke vm, args.cdr
-      rescue StandardError => e
-        handle e, args.car, :invoke, args.cdr
-      end
-    end
-
-    # TODO generate various Invocation_XXX classes on-demand instead of hand_coding them all up front
-    SIGS = Set.new
-
-    class Invocation_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        @sym.value(vm.current_context).invoke_1 vm
-      rescue StandardError => e
-        handle e, @sym.value(vm.current_context), :invoke_1
-      end
-    end
-
-    class Invocation_SYM < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        @sym.value.invoke_1 vm
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_1
-      end
-    end
-
-    class Invocation_LEX_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @lex0 = expr.car
-        @lex1 = expr.cdr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        fn = @lex0.value(vm.current_context)
-        a0 = @lex1.value(vm.current_context)
-        fn.invoke_2 vm, a0
-      rescue StandardError => e
-        handle e, fn, :invoke_2, a0
-      end
-    end
-
-    class Invocation_SYM_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-        @lex = expr.cdr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        a0 = @lex.value(vm.current_context)
-        @sym.value.invoke_2 vm, a0
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_2, a0
-      end
-    end
-
-    class Invocation_SYM_LIT < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-        @lit = expr.cdr.car.expression
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        @sym.value.invoke_2 vm, @lit
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_2, @lit
-      end
-    end
-
-    class Invocation_LEX_LEX_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @lex_0 = expr.car
-        @lex_1 = expr.cdr.car
-        @lex_2 = expr.cdr.cdr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        fn = @lex_0.value(vm.current_context)
-        a0 = @lex_1.value(vm.current_context)
-        a1 = @lex_2.value(vm.current_context)
-        fn.invoke_3 vm, a0, a1
-      rescue StandardError => e
-        handle e, fn, :invoke_3, a0, a1
-      end
-    end
-
-    class Invocation_SYM_LEX_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-        @lex_0 = expr.cdr.car
-        @lex_1 = expr.cdr.cdr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        a0 = @lex_0.value(vm.current_context)
-        a1 = @lex_1.value(vm.current_context)
-        @sym.value.invoke_3 vm, a0, a1
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_3, a0, a1
-      end
-    end
-
-    class Invocation_SYM_LEX_LEX_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-        @lex_0 = expr.cdr.car
-        @lex_1 = expr.cdr.cdr.car
-        @lex_2 = expr.cdr.cdr.cdr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        a0 = @lex_0.value(vm.current_context)
-        a1 = @lex_1.value(vm.current_context)
-        a2 = @lex_2.value(vm.current_context)
-        @sym.value.invoke_4 vm, a0, a1, a2
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_4, a0, a1, a2
-      end
-    end
-
-    class Invocation_SYM_LEX_LIT_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-        @lex_0 = expr.cdr.car
-        @lit_1 = expr.cdr.cdr.car.expression
-        @lex_2 = expr.cdr.cdr.cdr.car
-      end
-
-      def execute vm
-        # Invocation.sig self.class.name
-        a0 = @lex_0.value(vm.current_context)
-        a2 = @lex_2.value(vm.current_context)
-        @sym.value.invoke_4 vm, a0, @lit_1, a2
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_4, a0, @lit_1, a2
-      end
-    end
-
-    class Invocation_SYM_LIT_LEX < Invocation::Base
-      SIGS << self.name
-      def initialize expr, src
-        super expr, src
-        @sym = expr.car
-        @lit_0 = expr.cdr.car.expression
-        @lex_1 = expr.cdr.cdr.car
-      end
-
-      def execute vm
-#        Invocation.sig self.class.name
-        a1 = @lex_1.value(vm.current_context)
-        @sym.value.invoke_3 vm, @lit_0, a1
-      rescue StandardError => e
-        handle e, @sym.value, :invoke_3, @lit_0, a1
-      end
-    end
   end
 
   class FunctionInvocation
@@ -293,35 +95,26 @@ module Nydp
     attr_accessor :function_instruction, :argument_instructions
 
     def lexical_reach n
-      function_instruction.car.lexical_reach(n)
+      function_instruction.lexical_reach(n)
     end
 
-    def self.build expression, bindings
-      compiled   = Compiler.compile_each(expression, bindings)
-      invocation_sig = compiled.map { |x| sig x }.join("_")
-
-      cname  = "Invocation_#{invocation_sig}"
+    def compile_to_ruby indent, srcs, opts=nil
+      ra = argument_instructions.map { |e| e.compile_to_ruby "#{indent}  ", srcs, cando: true }.to_a
+      if ra.length == 1
+        "#{indent}#{ra.shift}._nydp_call()"
+      else
+        "#{indent}#{ra.shift}._nydp_call(
+#{ra.join(",\n")}
+#{indent})"
+      end
+    end
 
-      # puts expression.inspect if cname == "Invocation_SYM_LEX_LIT_LEX"
+    @@seen = { }
 
-      exists = Invocation::SIGS.include? "Nydp::Invocation::#{cname}"
-      if exists
-        return Nydp::Invocation.const_get(cname).new(compiled, expression)
-      end
+    def self.build expression, bindings, ns
+      compiled   = Compiler.compile_each(expression, bindings, ns)
 
-      invocation = cons case expression.size
-                        when 1
-                          Invocation::Invocation_1.new(compiled, expression)
-                        when 2
-                          Invocation::Invocation_2.new(compiled, expression)
-                        when 3
-                          Invocation::Invocation_3.new(compiled, expression)
-                        when 4
-                          Invocation::Invocation_4.new(compiled, expression)
-                        else
-                          Invocation::Invocation_N.new(expression.size, compiled, expression)
-                        end
-      new invocation, compiled, expression, cname
+      Invocation::Base.new(compiled, expression)
     end
 
     def initialize function_instruction, argument_instructions, source, sig=nil
@@ -329,13 +122,7 @@ module Nydp
       @sig = sig
     end
 
-    def execute vm
-##      Invocation.sig @sig
-      vm.push_ctx_instructions function_instruction
-      vm.push_ctx_instructions argument_instructions
-    end
-
-    def inspect ; @function_instruction.inspect ; end
-    def to_s    ; @source.to_s                  ; end
+    def inspect ; @function_instruction._nydp_inspect ; end
+    def to_s    ; @source.to_s                        ; end
   end
 end

data/lib/nydp/helper.rb

@@ -1,7 +1,7 @@
 module Nydp
   module AutoWrap
     # include this and be sure to either override #_nydp_ok? or #_nydp_whitelist
-    # #_nydp_whitelist should return a list of accessor (zero-arg) methods which are safe for nydp to invoke
+    # #_nydp_whitelist should return a list of accessor (zero-arg) methods which are safe for nydp to call
     # #_nydp_procify should return a list of methods that can be exposed to script code.
     #
     # class Blub
@@ -19,11 +19,9 @@ module Nydp
     #
     # blubme here, now
     #
-    def _nydp_wrapper                 ; self                                     ; end
     def _nydp_ok?              method ; _nydp_whitelist.include? method          ; end
     def _nydp_procify?         method ; _nydp_procs.include? method              ; end # override to allow returning Method instances for given method name
     def _nydp_get                 key ; _nydp_safe_send(key.to_s.as_method_name) ; end
-    def to_ruby                       ; self                                     ; end
     def _nydp_safe_send meth, *args
       return send meth, *args if _nydp_ok?(meth)
       return method(meth)     if _nydp_procify?(meth)
@@ -37,8 +35,16 @@ module Nydp
   end
 
   module Converter
-    def n2r         o ; o.respond_to?(:to_ruby) ? o.to_ruby : o ; end
-    def r2n o, ns=nil ; o._nydp_wrapper                         ; end
+    def n2r o ; o.respond_to?(:to_ruby) ? o.to_ruby : o ; end
+    def r2n o ; o._nydp_wrapper                         ; end
+
+    def rubify value
+      if value.is_a?(Array)           ; value.map { |v| rubify v }
+      elsif value.is_a?(::Nydp::Pair) ; rubify(value.to_a)
+      elsif value.is_a?(::Hash)       ; { }.tap { |h| value.each { |k, v| h[rubify k] = rubify(v) } }
+      else                            ; n2r value
+      end
+    end
   end
 
   extend Converter
@@ -62,14 +68,15 @@ module Nydp
     end
 
     def sym? expr, name
-      expr.is_a?(Nydp::Symbol) && (expr.is? name)
+      # expr.is_a?(Nydp::Symbol) && (expr.is? name)
+      expr.is_a?(::Symbol) && (expr == name.to_sym)
     end
 
     def pair? expr
       expr.is_a?(Nydp::Pair)
     end
 
-    def cons a, b=Nydp::NIL
+    def cons a=nil, b=nil
       Nydp::Pair.new a, b
     end
 
@@ -78,12 +85,14 @@ module Nydp
     end
 
     def sym name, ns
-      Nydp::Symbol.mk name, ns
+      name.to_s.to_sym
     end
 
     def literal? expr
       case expr
-      when String, Float, Integer, Integer, Nydp::Symbol, Nydp::Truth, Nydp::Nil
+      # when String, Float, Integer, Integer, Symbol, Nydp::Truth, Nydp::Nil
+      # when String, Float, Integer, Integer, Symbol, Nydp::Truth, NilClass
+      when String, Float, Integer, Integer, Symbol, TrueClass, FalseClass, NilClass
         true
       else
         false