nydp 0.2.1 → 0.2.2

data/lib/lisp/tests/sort-examples.nydp

@@ -15,7 +15,9 @@
   ("sorts a list of hashes by a specified key"
    (let hh (list { a 1 b 2 } { a 7 b 9 } { a 3 b 1 } { a 2 b 8 })
      (pp (sort-by &a hh)))
-   "({ a 1 b 2 } { a 2 b 8 } { a 3 b 1 } { a 7 b 9 })")
+   "({ a 1 b 2 } { a 2 b 8 }
+              { a 3 b 1 }
+              { a 7 b 9 })")
 
   ("sorts a list of strings according to their length"
    (sort-by len

data/lib/nydp/compiler.rb

@@ -10,7 +10,8 @@ module Nydp
     def self.compile expression, bindings
       compile_expr expression, bindings
     rescue Exception => e
-      raise "failed to compile expression #{expression.inspect},\nerror was #{e.message}"
+      new_msg = "failed to compile expression #{expression.inspect},\nerror was #{e.message}"
+      raise $!, new_msg, $!.backtrace
     end
 
     def self.compile_expr expression, bindings

data/lib/nydp/context_symbol.rb

@@ -1,54 +1,49 @@
 module Nydp
-  class ContextLookup0 ; def self.get_context ctx; ctx; end; end
-  class ContextLookup1 ; def self.get_context ctx; ctx.parent; end; end
-  class ContextLookup2 ; def self.get_context ctx; ctx.parent.parent; end; end
-  class ContextLookup3 ; def self.get_context ctx; ctx.parent.parent.parent; end; end
-  class ContextLookup4 ; def self.get_context ctx; ctx.parent.parent.parent.parent; end; end
-  class ContextLookup5 ; def self.get_context ctx; ctx.parent.parent.parent.parent.parent; end; end
-  class ContextLookup6 ; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup7 ; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup8 ; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup9 ; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup10; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup11; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup12; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup13; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup14; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup15; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup16; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup17; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookup18; def self.get_context ctx; ctx.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent.parent; end; end
-  class ContextLookupN
-    def initialize depth ; @depth = depth  ; end
-    def get_context  ctx ; ctx.nth(@depth) ; end
-  end
-
   class ContextSymbol
-    attr_accessor :depth, :name, :binding_index
+    def self.build depth, name, binding_index
+      cname = "ContextSymbol_#{depth}_#{binding_index}"
 
-    def initialize depth, name, binding_index
-      @ctx_lookup = build_lookup depth
-      @depth, @name, @binding_index = depth, name, binding_index
-    end
+      existing = const_get(cname) rescue nil
+      return existing.new(name) if existing
 
-    def get_context(context); @ctx_lookup.get_context context; end
+      getctx = ([".parent"] * depth).join
+      at_index = if binding_index < 10
+                   "at_#{binding_index}"
+                 else
+                   "at_index(#{binding_index})"
+                 end
 
-    def value context
-      get_context(context).at_index(binding_index)
-    end
+      set_index = if binding_index < 10
+                    "at_#{binding_index}= value"
+                  else
+                    "set_index(#{binding_index}, value)"
+                  end
 
-    def assign value, context
-      get_context(context).set_index(binding_index, value)
-    end
+      klass = <<KLASS
+class #{cname} < Nydp::ContextSymbol
+  def initialize name
+    @name = name
+  end
 
-    def inspect; to_s; end
-    def to_s
-      "[#{depth}##{binding_index}]#{name}"
-    end
+  def value ctx
+    ctx#{getctx}.#{at_index} || Nydp::NIL
+  end
+
+  def assign value, ctx
+    ctx#{getctx}.#{set_index}
+  end
+
+  def execute vm
+    vm.push_arg value vm.current_context
+  end
+
+  def inspect ; to_s                               ; end
+  def to_s    ; "[#{depth}##{binding_index}]\#{@name}" ; end
+end
+KLASS
 
-    def build_lookup depth
-      fast = Nydp.const_get "ContextLookup#{depth}" rescue nil
-      return fast || ContextLookupN.new(depth)
+      eval klass
+      const_get(cname).new(name)
     end
   end
 end

data/lib/nydp/function_invocation.rb

@@ -84,14 +84,84 @@ module Nydp
         handle e, args.car, args.cdr
       end
     end
+
+    # TODO generate various Invocation_XXX classes on-demand instead of hand_coding them all up front
+    class Invocation_SYM < Invocation::Base
+      def initialize expr, src
+        super src
+        @sym = expr.car
+      end
+
+      def execute vm
+        @sym.value.invoke_1 vm
+      rescue Exception => e
+        handle e, @sym.value, Nydp::NIL
+      end
+    end
+
+    class Invocation_SYM_LEX < Invocation::Base
+      def initialize expr, src
+        super src
+        @sym = expr.car
+        @lex = expr.cdr.car
+      end
+
+      def execute vm
+        fn = @sym.value
+        a0 = @lex.value(vm.current_context)
+        fn.invoke_2 vm, a0
+      rescue Exception => e
+        handle e, fn, cons(a0)
+      end
+    end
+
+    class Invocation_SYM_LEX_LEX < Invocation::Base
+      def initialize expr, src
+        super src
+        @sym = expr.car
+        @lex_0 = expr.cdr.car
+        @lex_1 = expr.cdr.cdr.car
+      end
+
+      def execute vm
+        fn = @sym.value
+        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))
+      end
+    end
   end
 
   class FunctionInvocation
     extend Helper
     attr_accessor :function_instruction, :argument_instructions
 
+    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)
+      end
+
       invocation = cons case expression.size
                         when 1
                           Invocation::Invocation_1.new(expression)

data/lib/nydp/lexical_context.rb

@@ -1,71 +1,51 @@
-class Nydp::LexicalContext
-  include Nydp::Helper
-  attr_reader :names, :values, :parent
-
-  def initialize parent
-    @parent = parent
-    @names  = []
-    @values = []
-  end
-
-  def nth n
-    case n
-    when 0
-      self
-    when -1
-      raise "wrong nesting level"
-    else
-      parent.nth(n - 1)
+module Nydp
+  class LexicalContext
+    include Nydp::Helper
+    attr_reader :parent
+    attr_accessor :at_0, :at_1, :at_2, :at_3, :at_4, :at_5, :at_6, :at_7, :at_8, :at_9
+
+    def initialize parent
+      @parent = parent
     end
-  end
-
-  def at_index index
-    values[index] || Nydp::NIL
-  end
-
-  def set name, value
-    names  << name
-    values << value
-  end
 
-  def set_args_1 names, arg
-    if pair? names
-      set names.car, arg
-    elsif Nydp::NIL.isnt? names
-      set names, cons(arg)
+    def nth n
+      case n
+      when 0
+        self
+      when -1
+        raise "wrong nesting level"
+      else
+        parent.nth(n - 1)
+      end
     end
-  end
 
-  def set_args_2 names, arg_0, arg_1
-    if pair? names
-      set names.car, arg_0
-      set_args_1 names.cdr, arg_1
-    elsif Nydp::NIL.isnt? names
-      set names, cons(arg_0, cons(arg_1))
+    def at_index index
+      instance_variable_get :"@at_#{index}"
     end
-  end
 
-  def set_args_3 names, arg_0, arg_1, arg_2
-    if pair? names
-      set names.car, arg_0
-      set_args_2 names.cdr, arg_1, arg_2
-    elsif Nydp::NIL.isnt? names
-      set names, cons(arg_0, cons(arg_1, cons(arg_2)))
+    def set_index index, value
+      instance_variable_set :"@at_#{index}", value
     end
-  end
 
-  def set_index index, value
-    values[index] = value
-  end
+    def method_missing mname, *args
+      if mname.to_s =~ /at_\d+=/
+        instance_variable_set :"@#{mname.to_s.sub(/=/, '')}", args[0]
+      elsif mname.to_s =~ /at_\d+/
+        instance_variable_get :"@#{mname}"
+      else
+        super
+      end
+    end
 
-  def to_s_with_indent str
-    me = @values.map { |k, v|
-      [str, k, "=>", v].join ' '
-    }.join "\n"
-    me + (parent ? parent.to_s_with_indent("  #{str}") : '')
-  end
+    def to_s_with_indent str
+      me = @values.map { |k, v|
+        [str, k, "=>", v].join ' '
+      }.join "\n"
+      me + (parent ? parent.to_s_with_indent("  #{str}") : '')
+    end
 
-  def to_s
-    to_s_with_indent ''
+    def to_s
+      to_s_with_indent ''
+    end
   end
 end

data/lib/nydp/lexical_context_builder.rb

@@ -1,203 +1,111 @@
 module Nydp::LexicalContextBuilder
   extend Nydp::Helper
 
-  module B_0
-    def initialize_names _           ; end
-    def set_args_1 lc, a             ; end
-    def set_args_2 lc, a_0, a_1      ; end
-    def set_args_3 lc, a_0, a_1, a_2 ; end
-    def set_args   lc, args          ; 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    "}
   end
-
-  module B_1
-    def initialize_names names             ; @param_name = names.car      ; end
-    def set_args_1 lc, arg                 ; lc.set @param_name, arg      ; end
-    def set_args_2 lc, arg_0, arg_1        ; lc.set @param_name, arg_0    ; end
-    def set_args_3 lc, arg_0, arg_1, arg_2 ; lc.set @param_name, arg_0    ; end
-    def set_args   lc, args                ; lc.set @param_name, args.car ; end
+"
   end
 
-  module B_2
-    def initialize_names names
-      @param_name_0 = names.car
-      @param_name_1 = names.cdr.car
-    end
-    def set_args_1 lc, arg
-      lc.set @param_name_0, arg
-    end
-    def set_args_2 lc, arg_0, arg_1
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, arg_1
-    end
-    def set_args_3 lc, arg_0, arg_1, arg_2
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, arg_1
-    end
-    def set_args lc, args
-      lc.set @param_name_0, args.car
-      lc.set @param_name_1, args.cdr.car
+  def self.build_arg_conses arg_names, n
+    if n == arg_names.size - 1
+      "cons(#{arg_names[n]})"
+    else
+      "cons(#{arg_names[n]}, #{build_arg_conses(arg_names, n+1)})"
     end
   end
 
-  module B_3
-    def initialize_names names
-      @param_name_0 = names.car
-      @param_name_1 = names.cdr.car
-      @param_name_2 = names.cdr.cdr.car
-    end
-    def set_args_1 lc, arg
-      lc.set @param_name_0, arg
-    end
-    def set_args_2 lc, arg_0, arg_1
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, arg_1
-    end
-    def set_args_3 lc, arg_0, arg_1, arg_2
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, arg_1
-      lc.set @param_name_2, arg_2
-    end
-    def set_args lc, args
-      lc.set @param_name_0, args.car
-      lc.set @param_name_1, args.cdr.car
-      lc.set @param_name_2, args.cdr.cdr.car
-    end
+  def self.build_set_args_n_rest_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}"}
+    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    "}
+    #{rest_setter}
   end
-
-  module B_0_Rest
-    include Nydp::Helper
-    def initialize_names names             ; @param_name = names                                       ; end
-    def set_args_1 lc, arg                 ; lc.set @param_name, cons(arg)                             ; end
-    def set_args_2 lc, arg_0, arg_1        ; lc.set @param_name, cons(arg_0, cons(arg_1))              ; end
-    def set_args_3 lc, arg_0, arg_1, arg_2 ; lc.set @param_name, cons(arg_0, cons(arg_1, cons(arg_2))) ; end
-    def set_args   lc, args                ; lc.set @param_name, args                                  ; end
+"
   end
 
-  module B_1_Rest
-    include Nydp::Helper
-    def initialize_names names
-      @param_name_0 = names.car
-      @param_name_1 = names.cdr
-    end
-    def set_args_1 lc, arg
-      lc.set @param_name_0, arg
-    end
-    def set_args_2 lc, arg_0, arg_1
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, cons(arg_1)
-    end
-    def set_args_3 lc, arg_0, arg_1, arg_2
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, cons(arg_1, cons(arg_2))
-    end
-    def set_args lc, args
-      lc.set @param_name_0, args.car
-      lc.set @param_name_1, args.cdr
-    end
+  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    "}
   end
-
-  module B_2_Rest
-    def initialize_names names
-      @param_name_0 = names.car
-      @param_name_1 = names.cdr.car
-      @param_name_2 = names.cdr.cdr
-    end
-    def set_args_1 lc, arg
-      lc.set @param_name_0, arg
-    end
-    def set_args_2 lc, arg_0, arg_1
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, arg_1
-    end
-    def set_args_3 lc, arg_0, arg_1, arg_2
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, arg_1
-      lc.set @param_name_2, cons(arg_2)
-    end
-    def set_args lc, args
-      lc.set @param_name_0, args.car
-      lc.set @param_name_1, args.cdr.car
-      lc.set @param_name_2, args.cdr.cdr
-    end
+"
   end
 
-  module B_3_Rest
-    def initialize_names names
-      @param_name_0 = names.car
-      @param_name_1 = names.cdr.car
-      @param_name_2 = names.cdr.cdr
-    end
-    def set_args_1 lc, arg
-      lc.set @param_name_0, arg
-    end
-    def set_args_2 lc, arg_0, arg_1
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, arg_1
-    end
-    def set_args_3 lc, arg_0, arg_1, arg_2
-      lc.set @param_name_0, arg_0
-      lc.set @param_name_1, arg_1
-      lc.set @param_name_2, arg_2
-    end
-    def set_args lc, args
-      lc.set @param_name_0, args.car
-      lc.set @param_name_1, args.cdr.car
-      lc.set @param_name_2, args.cdr.cdr.car
-      lc.set @param_name_3, args.cdr.cdr.cdr
-    end
+  def self.build_set_args_rest_method nexpected
+    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    "}
+    #{rest_set}
+  end
+"
   end
 
-  module B_X
-    def initialize_names names
-      @param_names = names
-    end
-    def set_args_1 lc, arg
-      lc.set @param_names.car, arg
-    end
-    def set_args_2 lc, arg_0, arg_1
-      lc.set @param_names.car,     arg_0
-      lc.set @param_names.cdr.car, arg_1
-    end
-    def set_args_3 lc, arg_0, arg_1, arg_2
-      lc.set @param_names.car,         arg_0
-      lc.set @param_names.cdr.car,     arg_1
-      lc.set @param_names.cdr.cdr.car, arg_2
-    end
-    def set_args lc, args
-      _set_args lc, @param_names, args
-    end
-    def _set_args lc, names, args
-      unless Nydp::NIL.is? names
-        lc.set names.car, args.car
-        _set_args lc, names.cdr, args.cdr
-      end
-    end
+  def self.get_builder_class expected_arg_count
+    name      = "B_#{expected_arg_count}"
+    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 }
+    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
+KLASS
+
+    eval klass
+    name
   end
 
-  module B_X_Rest
-    include Nydp::Helper
-    def initialize_names names             ; @param_names = names                               ; end
-    def set_args_1 lc, arg                 ; set_args lc, cons(arg)                             ; end
-    def set_args_2 lc, arg_0, arg_1        ; set_args lc, cons(arg_0, cons(arg_1))              ; end
-    def set_args_3 lc, arg_0, arg_1, arg_2 ; set_args lc, cons(arg_0, cons(arg_1, cons(arg_2))) ; end
-    def set_args lc, args                  ; _set_args lc, @param_names, args                   ; end
-    def _set_args lc, names, args
-      if pair? names
-        lc.set names.car, args.car
-        _set_args lc, names.cdr, args.cdr
-      elsif Nydp::NIL.isnt? names
-        lc.set names, args
-      end
-    end
+  def self.get_builder_rest_class proper_arg_count
+    name      = "B_#{proper_arg_count}_Rest"
+    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 }
+    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
+KLASS
+
+    eval klass
+    name
   end
 
   def self.select arg_names
-    if pair? arg_names
-      size = pair?(arg_names) ? arg_names.size : 0
-      class_name = "B_#{size > 3 ? "X" : size}#{arg_names.proper? ? "" : "_Rest"}"
+    if pair?(arg_names)
+      size   = arg_names.size
+      proper = arg_names.proper?
+    else
+      size   = 0
+      proper = Nydp::NIL.is? arg_names
+    end
+
+    if proper
+      class_name = get_builder_class size
     else
-      class_name = "B_0_Rest"
+      class_name = get_builder_rest_class size
     end
+
     self.const_get(class_name.to_sym)
   end
 end