nydp 0.5.1 → 0.6.0

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

data/lib/nydp/interpreted_function.rb

@@ -3,14 +3,37 @@ require 'nydp/lexical_context_builder'
 require 'nydp/closure'
 
 module Nydp
-  class PopArg
-    def self.execute vm ; vm.args.pop ; end
-    def self.to_s       ; ""          ; end
-    def self.inspect    ; "#pop_arg"  ; end
+  class Fn < Proc
+    attr_accessor :src
+    def initialize &b
+      super &b
+    end
+    def to_s
+      Nydp.nydp_from_backtrace(source_location.join(":"))
+    end
+    def container_class_name
+      file, line = source_location
+      [file.split(/\//).last, line].join(":")
+    end
+    def inspect
+      [@name, Nydp.nydp_from_backtrace(source_location.join(":"))].compact.join(" : ")
+    end
+    def src
+      Nydp.nydp_from_backtrace(source_location.join(":"))
+    end
+    def nydp_type
+      :fn
+    end
+
+    def is_named name
+      @name = name
+    end
+
+    alias _nydp_call call
   end
 
   class InterpretedFunction
-    NIL = Nydp::NIL
+    NIL = nil
     include Helper
     extend Helper
 
@@ -20,10 +43,63 @@ module Nydp
       body.map { |b| b.lexical_reach(n - 1)  }.max
     end
 
-    def self.build arg_list, body, bindings
+    def can_do?
+      arg_names == nil
+    end
+
+    def compile_do_expr_to_ruby indent, srcs
+      body.
+        map { |expr| expr.compile_to_ruby("  ", srcs, cando: true) }.
+        to_a.
+        join("\n").
+        split(/\n/). # need join-split to separate out embedded newlines (TODO worry about newlines within literal strings?)
+        map { |e| "#{indent}  #{e}" }.
+        join("\n")
+    end
+
+    def compile_to_ruby indent, srcs, opts={}
+      an        = arg_names
+      rubyargs  = []
+      src_index = srcs.length
+
+      srcs << to_s
+
+      while (pair? an)
+        rubyargs << "_arg_#{an.car.to_s._nydp_name_to_rb_name}=nil"
+        an = an.cdr
+      end
+
+      if an
+        rest_arg = "_arg_#{an.to_s._nydp_name_to_rb_name}"
+        rubyargs << "*#{rest_arg}"
+      end
+
+      if rubyargs == []
+        rubyargs = ""
+      else
+        rubyargs = "|#{rubyargs.join ","}|"
+        # rubyargs = "(#{rubyargs.join ","})"
+      end
+
+      # code = "#{indent}(Nydp::Fn.new(@@src_#{src_index}) {#{rubyargs}\n"
+      code = "#{indent}##> (fn #{arg_names._nydp_inspect} #{body.to_a.map(&:_nydp_inspect).join(" ").gsub(/\n/, '\n')})\n"
+      code << "#{indent}(Nydp::Fn.new {#{rubyargs}\n"
+      # code << "#{indent}(Proc.new {#{rubyargs}\n"
+      # code = "(->#{rubyargs} {\n"
+      if rest_arg
+        code << "#{indent}  #{rest_arg} = #{rest_arg}._nydp_wrapper\n"
+      end
+      bodycode = body.map { |expr| expr.compile_to_ruby("  ", srcs, cando: true) }.to_a
+
+      bodycode.push "#{bodycode.pop}._nydp_wrapper"
+      code << bodycode.join("\n").split(/\n/).map { |e| "#{indent}  #{e}" }.join("\n")
+      code << "\n#{indent}})"
+    end
+
+    def self.build arg_list, body, bindings, ns
       my_params = { }
       index_parameters arg_list, my_params
-      body = compile_body body, cons(my_params, bindings), []
+      body = compile_body body, cons(my_params, bindings), [], ns
       reach = body.map { |b| b.lexical_reach(-1)  }.max
 
       ifn_klass     = reach >= 0 ? InterpretedFunctionWithClosure : InterpretedFunctionWithoutClosure
@@ -35,11 +111,11 @@ module Nydp
       ifn
     end
 
-    def self.compile_body body_forms, bindings, instructions
-      instructions << Nydp::Compiler.compile(body_forms.car, bindings)
+    def self.compile_body body_forms, bindings, instructions, ns
+      instructions << Nydp::Compiler.compile(body_forms.car, bindings, ns)
 
       rest = body_forms.cdr
-      if Nydp::NIL.is? rest
+      if !rest
         return Pair.from_list(instructions)
       else
         # PopArg is necessary because each expression pushes an arg onto the arg stack.
@@ -47,8 +123,8 @@ module Nydp
         # so we need the following line in order to remove unwanted args from the stack.
         # Each expression at some executes vm.push_arg(thing)
         # TODO find a more intelligent way to do this, eg change the meaning of vm or of push_arg in the expression vm.push_arg(thing)
-        instructions << PopArg
-        compile_body rest, bindings, instructions
+        # instructions << PopArg
+        compile_body rest, bindings, instructions, ns
       end
     end
 
@@ -64,59 +140,117 @@ module Nydp
     def nydp_type ; "fn" ; end
     def inspect   ; to_s ; end
     def to_s
-      "(fn #{arg_names.inspect} #{body.map { |b| b.inspect}.join(' ')})"
+      "(fn #{arg_names._nydp_inspect} #{body.map { |b| b._nydp_inspect}.join('\n')})"
+    end
+
+    def run_body vm
+      res = nil
+      self.body.each { |x| res = x.execute(vm) }
+      res
     end
   end
 
   class InterpretedFunctionWithClosure < InterpretedFunction
     def invoke_1 vm, ctx
-      vm.push_instructions self.body, set_args_0(ctx)
+      cc                 = vm.current_context
+      vm.current_context = set_args_0(ctx)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args_0(ctx)
     end
 
     def invoke_2 vm, ctx, arg
-      vm.push_instructions self.body, set_args_1(ctx, arg)
+      cc                 = vm.current_context
+      vm.current_context = set_args_1(ctx, arg)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args_1(ctx, arg)
     end
 
     def invoke_3 vm, ctx, arg_0, arg_1
-      vm.push_instructions self.body, set_args_2(ctx, arg_0, arg_1)
+      cc                 = vm.current_context
+      vm.current_context = set_args_2(ctx, arg_0, arg_1)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args_2(ctx, arg_0, arg_1)
     end
 
     def invoke_4 vm, ctx, arg_0, arg_1, arg_2
-      vm.push_instructions self.body, set_args_3(ctx, arg_0, arg_1, arg_2)
+      cc                 = vm.current_context
+      vm.current_context = set_args_3(ctx, arg_0, arg_1, arg_2)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args_3(ctx, arg_0, arg_1, arg_2)
     end
 
     def invoke vm, ctx, arg_values
-      vm.push_instructions self.body, set_args(ctx, arg_values)
+      cc                 = vm.current_context
+      vm.current_context = set_args(ctx, arg_values)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args(ctx, arg_values)
     end
 
     def execute vm
-      vm.push_arg Closure.new(self, vm.current_context)
+      Closure.new(self, vm.current_context)
+      # vm.push_arg Closure.new(self, vm.current_context)
     end
   end
 
   class InterpretedFunctionWithoutClosure < InterpretedFunction
     def invoke_1 vm
-      vm.push_instructions self.body, set_args_0(vm.current_context)
+      cc                 = vm.current_context
+      vm.current_context = set_args_0(vm.current_context)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args_0(vm.current_context)
     end
 
     def invoke_2 vm, arg
-      vm.push_instructions self.body, set_args_1(vm.current_context, arg)
+      cc                 = vm.current_context
+      vm.current_context = set_args_1(vm.current_context, arg)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args_1(vm.current_context, arg)
     end
 
     def invoke_3 vm, arg_0, arg_1
-      vm.push_instructions self.body, set_args_2(vm.current_context, arg_0, arg_1)
+      cc                 = vm.current_context
+      vm.current_context = set_args_2(vm.current_context, arg_0, arg_1)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args_2(vm.current_context, arg_0, arg_1)
     end
 
     def invoke_4 vm, arg_0, arg_1, arg_2
-      vm.push_instructions self.body, set_args_3(vm.current_context, arg_0, arg_1, arg_2)
+      cc                 = vm.current_context
+      vm.current_context = set_args_3(vm.current_context, arg_0, arg_1, arg_2)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args_3(vm.current_context, arg_0, arg_1, arg_2)
     end
 
     def invoke vm, arg_values
-      vm.push_instructions self.body, set_args(vm.current_context, arg_values)
+      cc                 = vm.current_context
+      vm.current_context = set_args(vm.current_context, arg_values)
+      res                = run_body(vm)
+      vm.current_context = cc
+      res
+      # vm.push_instructions self.body, set_args(vm.current_context, arg_values)
     end
 
     def execute vm
-      vm.push_arg self
+      # vm.push_arg self
+      self
     end
   end
 end

data/lib/nydp/lexical_context.rb

@@ -49,14 +49,15 @@ module Nydp
     end
 
     def to_s
-      values = []
-      n = 0
-      while at_index n
-        values << at_index(n).inspect
-        n += 1
-      end
-      parent_s = parent ? " parent #{parent.to_s}" : ""
-      "(context (#{values.join ' '})#{parent_s})"
+      # values = []
+      # n = 0
+      # while at_index n
+      #   values << at_index(n)._nydp_inspect
+      #   n += 1
+      # end
+      # parent_s = parent ? " parent #{parent.to_s}" : ""
+      # "(context (#{values.join ' '})#{parent_s})"
+      "(NEW context)"
     end
   end
 end

data/lib/nydp/lexical_context_builder.rb

@@ -103,7 +103,7 @@ module Nydp::LexicalContextBuilder
       proper = arg_names.proper?
     else
       size   = 0
-      proper = Nydp::NIL.is? arg_names
+      proper = (!arg_names)
     end
     const_get(proper ? :"B_#{size}" : :"B_#{size}_Rest")
   end

data/lib/nydp/literal.rb

@@ -7,12 +7,12 @@ module Nydp
       @expression = expression
     end
 
-    def self.build expression, bindings
+    def self.build expression, bindings, ns
       new expression
     end
 
-    def execute vm
-      vm.push_arg expression
+    def compile_to_ruby indent, srcs, opts=nil
+      "#{indent}#{expression.compile_to_ruby "", srcs}"
     end
 
     def nydp_type ; :literal            ; end
@@ -20,10 +20,6 @@ module Nydp
     def to_s      ; @expression.to_s    ; end
     def to_ruby   ; n2r @expression     ; end
 
-    def coerce _
-      [_, expression]
-    end
-
     def > other
       other < expression
     end

data/lib/nydp/loop.rb

@@ -0,0 +1,72 @@
+module Nydp
+  # class LoopBodyInstruction
+  #   extend Helper
+  #   include Helper
+
+  #   def initialize loop_body, condition
+  #     @loop_body, @condition = loop_body, cons(Nydp::PopArg, cons(condition))
+  #     # @loop_body, @condition = loop_body, cons(condition)
+  #   end
+
+  #   def lexical_reach n
+  #     @loop_body.lexical_reach(n)
+  #   end
+
+  #   def execute vm
+  #     if vm.args.pop
+  #       vm.push_ctx_instructions @condition
+  #       @loop_body.execute vm
+  #     else
+  #       vm.push_arg nil
+  #     end
+  #   end
+
+  #   def inspect
+  #     "loop_body:#{@loop_body._nydp_inspect}"
+  #   end
+
+  #   def to_s
+  #     "#{@loop_body.to_s}"
+  #   end
+  # end
+
+  class Loop
+    extend Helper
+    include Helper
+    attr_reader :condition, :loop_body
+
+    def initialize cond, loop_body
+      @condition, @loop_body = cond, loop_body
+    end
+
+    def lexical_reach n
+      [condition.lexical_reach(n), loop_body.lexical_reach(n)].max
+    end
+
+    def inspect
+      "loop:#{condition._nydp_inspect}:#{loop_body._nydp_inspect}"
+    end
+
+    def to_s
+      "(loop #{condition.to_s} #{loop_body.to_s})"
+    end
+
+    def self.build expressions, bindings, ns
+      if expressions.is_a? Nydp::Pair
+        cond       = Compiler.compile expressions.car, bindings, ns
+        loop_body  = Compiler.compile expressions.cdr.car, bindings, ns
+        csig       = sig(cond)
+        new(cond, loop_body)
+      else
+        raise "can't compile Loop: #{expressions._nydp_inspect}"
+      end
+    end
+
+    def compile_to_ruby indent, srcs, opts=nil
+      "#{indent}##> #{to_s.split(/\n/).join('\n')}\n" +
+      "#{indent}while (#{condition.compile_to_ruby "", srcs})
+#{loop_body.compile_to_ruby(indent + "  ", srcs, cando: true)}
+#{indent}end"
+    end
+  end
+end

data/lib/nydp/namespace.rb

@@ -0,0 +1,52 @@
+module Nydp
+  class Namespace
+    include Nydp::Helper
+
+    def method_missing name, *args
+      if name.to_s =~ /^ns_/
+        attr = name.to_s.gsub(/=$/, '').to_sym
+        singleton_class.instance_eval do
+          attr_accessor attr
+        end
+        send name, *args
+      else
+        super
+      end
+    end
+
+    def names
+      mm = methods.select { |m| m.to_s =~ /^ns_.*[^=]$/ }.map { |m| nydp_name(m).to_sym }
+    end
+
+    def nydp_name n
+      n.to_s.gsub(/^ns_/, '').gsub(/_../) { |ch| ch[1,2].to_i(16).chr }
+    end
+
+    def ruby_name n
+      n.to_s._nydp_name_to_rb_name
+    end
+
+    def assign name, value
+      send "ns_#{ruby_name name}=", value
+    end
+
+    def fetch name
+      send "ns_#{ruby_name name}"
+    end
+
+    def apply name, *args
+      fn = if name.is_a?(String) || name.is_a?(::Symbol)
+             fetch name
+           elsif name.respond_to? :call
+             name
+           end
+
+      raise "can't apply #{name.inspect} : not a function" unless fn && fn.respond_to?(:call)
+
+      fn.call *(args.map { |a| r2n a })
+
+    rescue StandardError => e
+      raise Nydp::Error.new("Invoking #{name}\nwith args (#{args.map(&:_nydp_compact_inspect).join(' ')})")
+    end
+  end
+end