nydp 0.2.3 → 0.2.5

data/lib/nydp/context_symbol.rb

@@ -31,13 +31,16 @@ class #{cname} < Nydp::ContextSymbol
 
   def assign value, ctx
     ctx#{getctx}.#{set_index}
+  rescue StandardError => e
+    raise "problem in \#{self.class.name}#assign, name is \#{@name}, depth is \#{depth}, index is #{binding_index}"
   end
 
   def execute vm
     vm.push_arg value vm.current_context
   end
 
-  def inspect ; to_s                               ; end
+  def depth   ; #{depth}                               ; end
+  def inspect ; to_s                                   ; end
   def to_s    ; "[#{depth}##{binding_index}]\#{@name}" ; end
 end
 KLASS

data/lib/nydp/error.rb

@@ -4,5 +4,13 @@ module Nydp
   end
 
   class Error < StandardError
+    def initialize message, nydp_cause=nil
+      super(message)
+      @nydp_cause = nydp_cause
+    end
+
+    def cause
+      @nydp_cause || super
+    end
   end
 end

data/lib/nydp/function_invocation.rb

@@ -9,17 +9,20 @@ module Nydp
         @source_expression = source_expression
       end
 
-      def handle e, f, args
+      def handle e, f, invoker, *args
         case e
         when Nydp::Error, InvocationFailed
-          raise e
+          raise
         else
-          msg  =  "failed to execute invocation #{f.inspect} #{args.inspect}"
-          msg +=  "\nsource was #{source.inspect}"
-          msg +=  "\nfunction name was #{source.car.inspect}"
-          i_f = InvocationFailed.new "#{msg}\n#{e.message}"
-          i_f.set_backtrace e.backtrace
-          raise i_f
+          if e.is_a?(NoMethodError) && !f.respond_to?(invoker)
+            raise InvocationFailed.new("#{f} is not a function")
+          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}"
+            raise InvocationFailed.new msg
+          end
         end
       end
 
@@ -32,8 +35,8 @@ module Nydp
       def execute vm
         f = vm.args.pop
         f.invoke_1 vm
-      rescue Exception => e
-        handle e, f, Nydp::NIL
+      rescue StandardError => e
+        handle e, f, :invoke_1
       end
     end
 
@@ -41,10 +44,9 @@ module Nydp
       def execute vm
         arg = vm.args.pop
         f = vm.args.pop
-
         f.invoke_2 vm, arg
-      rescue Exception => e
-        handle e, f, cons(arg)
+      rescue StandardError => e
+        handle e, f, :invoke_2, arg
       end
     end
 
@@ -54,8 +56,8 @@ module Nydp
         arg_0 = vm.args.pop
         f   = vm.args.pop
         f.invoke_3 vm, arg_0, arg_1
-      rescue Exception => e
-        handle e, f, cons(arg_0, cons(arg_1))
+      rescue StandardError => e
+        handle e, f, :invoke_3, arg_0, arg_1
       end
     end
 
@@ -66,8 +68,8 @@ module Nydp
         arg_0 = vm.args.pop
         f   = vm.args.pop
         f.invoke_4 vm, arg_0, arg_1, arg_2
-      rescue Exception => e
-        handle e, f, cons(arg_0, cons(arg_1, cons(arg_2)))
+      rescue StandardError => e
+        handle e, f, :invoke_4, arg_0, arg_1, arg_2
       end
     end
 
@@ -80,13 +82,16 @@ module Nydp
       def execute vm
         args = vm.pop_args @arg_count
         args.car.invoke vm, args.cdr
-      rescue Exception => e
-        handle e, args.car, 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 src
         @sym = expr.car
@@ -94,12 +99,13 @@ module Nydp
 
       def execute vm
         @sym.value(vm.current_context).invoke_1 vm
-      rescue Exception => e
-        handle e, @sym.value(vm.current_context), Nydp::NIL
+      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 src
         @sym = expr.car
@@ -107,12 +113,13 @@ module Nydp
 
       def execute vm
         @sym.value.invoke_1 vm
-      rescue Exception => e
-        handle e, @sym.value, Nydp::NIL
+      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 src
         @lex0 = expr.car
@@ -123,12 +130,13 @@ module Nydp
         fn = @lex0.value(vm.current_context)
         a0 = @lex1.value(vm.current_context)
         fn.invoke_2 vm, a0
-      rescue Exception => e
-        handle e, fn, cons(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 src
         @sym = expr.car
@@ -139,12 +147,13 @@ module Nydp
         fn = @sym.value
         a0 = @lex.value(vm.current_context)
         fn.invoke_2 vm, a0
-      rescue Exception => e
-        handle e, fn, cons(a0)
+      rescue StandardError => e
+        handle e, fn, :invoke_2, a0
       end
     end
 
     class Invocation_LEX_LEX_LEX < Invocation::Base
+      SIGS << self.name
       def initialize expr, src
         super src
         @lex_0 = expr.car
@@ -157,12 +166,13 @@ module Nydp
         a0 = @lex_1.value(vm.current_context)
         a1 = @lex_2.value(vm.current_context)
         fn.invoke_3 vm, a0, a1
-      rescue Exception => e
-        handle e, fn, cons(a0, cons(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 src
         @sym = expr.car
@@ -175,8 +185,8 @@ module Nydp
         a0 = @lex_0.value(vm.current_context)
         a1 = @lex_1.value(vm.current_context)
         fn.invoke_3 vm, a0, a1
-      rescue Exception => e
-        handle e, fn, cons(a0, cons(a1))
+      rescue StandardError => e
+        handle e, fn, :invoke_3, a0, a1
       end
     end
   end
@@ -184,29 +194,17 @@ module Nydp
   class FunctionInvocation
     extend Helper
     attr_accessor :function_instruction, :argument_instructions
+    @@put = nil
 
-    def self.sig klass
-      case klass
-      when Nydp::Symbol              ; "SYM"
-      when Nydp::ContextSymbol       ; "LEX"
-      when Nydp::Literal             ; "LIT"
-      when Nydp::FunctionInvocation  ; "NVK"
-      when Nydp::Invocation::Base    ; "NVB"
-      when Nydp::InterpretedFunction ; "IFN"
-      when Nydp::Cond                ; "CND"
-      when Nydp::Assignment          ; "ASN"
-      else ; raise "no sig for #{klass.class.name}"
-      end
-    end
     def self.build expression, bindings
       compiled   = Compiler.compile_each(expression, bindings)
       invocation_sig = compiled.map { |x| sig x }.join("_")
 
       cname  = "Invocation_#{invocation_sig}"
-      iclass = Nydp::Invocation.const_get(cname) rescue nil
-      if iclass
-        # puts "found #{cname}"
-        return iclass.new(compiled, expression)
+
+      exists = Invocation::SIGS.include? "Nydp::Invocation::#{cname}"
+      if exists
+        return Nydp::Invocation.const_get(cname).new(compiled, expression)
       end
 
       invocation = cons case expression.size

data/lib/nydp/helper.rb

@@ -30,6 +30,21 @@ module Nydp
     def n2r obj     ; Nydp.n2r obj     ; end
     def r2n obj, ns ; Nydp.r2n obj, ns ; end
 
+    def sig klass
+      case klass
+      when Nydp::Symbol              ; "SYM"
+      when Nydp::ContextSymbol       ; "LEX"
+      when Nydp::Literal             ; "LIT"
+      when Nydp::FunctionInvocation  ; "NVK"
+      when Nydp::Invocation::Base    ; "NVB"
+      when Nydp::InterpretedFunction ; "IFN"
+      when Nydp::Cond                ; "CND"
+      when Nydp::CondBase            ; "CND"
+      when Nydp::Assignment          ; "ASN"
+      else ; raise "no sig for #{klass.class.name}"
+      end
+    end
+
     def sym? expr, name
       expr.is_a?(Nydp::Symbol) && (expr.is? name)
     end

data/lib/nydp/interpreted_function.rb

@@ -17,35 +17,27 @@ module Nydp
 
     def invoke_1 vm, parent_context
       vm.instructions.push self.body
-      vm.contexts.push LexicalContext.new(parent_context)
+      vm.contexts.push set_args_0 parent_context
     end
 
     def invoke_2 vm, parent_context, arg
-      lc = LexicalContext.new parent_context
-      set_args_1 lc, arg
       vm.instructions.push self.body
-      vm.contexts.push lc
+      vm.contexts.push set_args_1(parent_context, arg)
     end
 
     def invoke_3 vm, parent_context, arg_0, arg_1
-      lc = LexicalContext.new parent_context
-      set_args_2 lc, arg_0, arg_1
       vm.instructions.push self.body
-      vm.contexts.push lc
+      vm.contexts.push set_args_2(parent_context, arg_0, arg_1)
     end
 
     def invoke_4 vm, parent_context, arg_0, arg_1, arg_2
-      lc = LexicalContext.new parent_context
-      set_args_3 lc, arg_0, arg_1, arg_2
       vm.instructions.push self.body
-      vm.contexts.push lc
+      vm.contexts.push set_args_3(parent_context, arg_0, arg_1, arg_2)
     end
 
     def invoke vm, parent_context, arg_values
-      lc = LexicalContext.new parent_context
-      set_args lc, arg_values
       vm.instructions.push self.body
-      vm.contexts.push lc
+      vm.contexts.push set_args(parent_context, arg_values)
     end
 
     def setup_context context, names, values
@@ -63,7 +55,6 @@ module Nydp
       ifn = Nydp::InterpretedFunction.new
       ifn.arg_names = arg_list
       ifn.extend Nydp::LexicalContextBuilder.select arg_list
-      ifn.initialize_names arg_list
       ifn.body = compile_body body, cons(my_params, bindings), []
       ifn
     end
@@ -90,6 +81,11 @@ module Nydp
     end
 
     def execute vm
+      # TODO do not create a new Closure if this function does not refer to it
+      #      - including top-level function definitions
+      #      - and any other function that does not refer to any lexically-bound outer variable
+      #      - for example (fn (x) (* x x)) in (map λx(* x x) things) does not need a closure, because
+      #        the function does not refer to any lexical variable outside itself.
       vm.push_arg Closure.new(self, vm.current_context)
     end
 

data/lib/nydp/lexical_context.rb

@@ -38,14 +38,25 @@ module Nydp
     end
 
     def to_s_with_indent str
-      me = @values.map { |k, v|
+      me = (@values || { }).map { |k, v|
         [str, k, "=>", v].join ' '
       }.join "\n"
       me + (parent ? parent.to_s_with_indent("  #{str}") : '')
     end
 
-    def to_s
+    def pretty
       to_s_with_indent ''
     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})"
+    end
   end
 end

data/lib/nydp/lexical_context_builder.rb

@@ -1,12 +1,22 @@
 module Nydp::LexicalContextBuilder
   extend Nydp::Helper
 
+  def self.mklc nexpected
+    (nexpected > 0) ? "lc = Nydp::LexicalContext.new lc\n    " : ""
+  end
+
+  def self.build_arg_names ngiven
+    (["lc"] + (0...ngiven      ).map { |i| "arg_#{i}"}).join ", "
+  end
+
   def self.build_set_args_n_method ngiven, nexpected
     setter_count = [ngiven, nexpected].min
-    arg_names = (0...ngiven      ).map { |i| "arg_#{i}"}
     setters   = (0...setter_count).map { |i| "lc.at_#{i}= arg_#{i}"}
-"  def set_args_#{ngiven} lc, #{arg_names.join ", "}
-    #{setters.join "\n    "}
+"  def set_args_#{ngiven} #{build_arg_names ngiven}
+    #{mklc nexpected}#{setters.join "\n    "}
+    lc
+   rescue StandardError => e
+     raise \"error in \#{self.class.name}#set_args_#{ngiven}\"
   end
 "
   end
@@ -26,9 +36,12 @@ module Nydp::LexicalContextBuilder
     if ngiven > setter_count
       rest_setter = "lc.at_#{nexpected}= #{build_arg_conses arg_names[setter_count..-1], 0}"
     end
-"  def set_args_#{ngiven} lc, #{arg_names.join ", "}
-    #{setters.join "\n    "}
+"  def set_args_#{ngiven} #{build_arg_names ngiven}
+    #{mklc 1}#{setters.join "\n    "}
     #{rest_setter}
+    lc
+   rescue StandardError => e
+     raise \"error in \#{self.class.name}#set_args_#{ngiven}\"
   end
 "
   end
@@ -36,7 +49,10 @@ module Nydp::LexicalContextBuilder
   def self.build_set_args_method nexpected
     setters   = (0...nexpected).map { |i| "lc.at_#{i}= args#{ ([".cdr"] * i).join }.car"}
 "  def set_args lc, args
-    #{setters.join "\n    "}
+    #{mklc nexpected}#{setters.join "\n    "}
+    lc
+   rescue StandardError => e
+     raise \"error in \#{self.class.name}#set_args\"
   end
 "
   end
@@ -45,8 +61,11 @@ module Nydp::LexicalContextBuilder
     setters   = (0...nexpected).map { |i| "lc.at_#{i}= args#{ ([".cdr"] * i).join }.car"}
     rest_set  = "lc.at_#{nexpected}= args#{ ([".cdr"] *(nexpected)).join }"
 "  def set_args lc, args
-    #{setters.join "\n    "}
+    #{mklc 1}#{setters.join "\n    "}
     #{rest_set}
+    lc
+   rescue StandardError => e
+     raise \"error in \#{self.class.name}#set_args\"
   end
 "
   end
@@ -56,12 +75,10 @@ module Nydp::LexicalContextBuilder
     existing  = const_get(name) rescue nil
     return name if existing
 
-    n_methods = (1..3).map { |given| build_set_args_n_method given, expected_arg_count }
+    n_methods = (0..3).map { |given| build_set_args_n_method given, expected_arg_count }
     x_method  = build_set_args_method expected_arg_count
     klass     = <<KLASS
 module #{name}
-  def initialize_names names ; end
-
 #{n_methods.join "\n"}
 #{x_method}
 end
@@ -76,12 +93,10 @@ KLASS
     existing  = const_get(name) rescue nil
     return name if existing
 
-    n_methods = (1..3).map { |given| build_set_args_n_rest_method given, proper_arg_count }
+    n_methods = (0..3).map { |given| build_set_args_n_rest_method given, proper_arg_count }
     x_method  = build_set_args_rest_method proper_arg_count
     klass     = <<KLASS
 module #{name}
-  def initialize_names names ; end
-
 #{n_methods.join "\n"}
 #{x_method}
 end