nydp 0.5.0 → 0.6.0

data/lib/nydp/builtin.rb

@@ -1,55 +1,33 @@
 module Nydp::Builtin
   module Base
+    @@reraise_errors = []
     include Nydp::Helper
 
-    def builtin_invoke   vm, args       ; raise "#{self.class.name} : please implement #builtin_invoke" ; end
-    def builtin_invoke_1 vm             ; builtin_invoke vm, Nydp::NIL                    ; end
-    def builtin_invoke_2 vm, a          ; builtin_invoke vm, cons(a)                      ; end
-    def builtin_invoke_3 vm, a0, a1     ; builtin_invoke vm, cons(a0, cons(a1))           ; end
-    def builtin_invoke_4 vm, a0, a1, a2 ; builtin_invoke vm, cons(a0, cons(a1, cons(a2))) ; end
-
-    def invoke_1 vm
-      builtin_invoke_1 vm
-    rescue StandardError => e
-      handle_error e
-    end
-
-    def invoke_2 vm, arg
-      builtin_invoke_2 vm, arg
-    rescue StandardError => e
-      handle_error e, arg
+    def self.ignore_errors kla
+      @@reraise_errors << kla
     end
 
-    def invoke_3 vm, arg_0, arg_1
-      builtin_invoke_3 vm, arg_0, arg_1
-    rescue StandardError => e
-      handle_error e, arg_0, arg_1
-    end
-
-    def invoke_4 vm, arg_0, arg_1, arg_2
-      builtin_invoke_4 vm, arg_0, arg_1, arg_2
-    rescue StandardError => e
-      handle_error e, arg_0, arg_1, arg_2
-    end
-
-    # called from 'apply (among others)
-    def invoke vm, args
-      builtin_invoke vm, args
-    rescue StandardError => e
-      handle_error e, *(args.to_a)
-    end
+    ignore_errors Nydp::Error
 
     def handle_error e, *args
       case e
-      when Nydp::Error
+      when *@@reraise_errors
         raise e
       else
-        arg_msg = args.map { |a| "  #{a.inspect}"}.join("\n")
-        new_msg = "Called #{self.inspect}\nwith args\n#{arg_msg}"
+        arg_msg = args.map { |a| "#{a._nydp_inspect}"}.join("\n").split(/\n/).map { |s| "  #{s}"}.join("\n")
+        new_msg = "Called #{self._nydp_inspect}\nwith args\n#{arg_msg}"
         raise new_msg
       end
     end
 
+    def call *args
+      builtin_call *args
+    rescue => e
+      handle_error e, *args
+    end
+
+    alias _nydp_call call
+
     def name
       cname = self.class.name.split("::").last
       cname = cname.gsub(/([a-z])([A-Z])/) { |m| "#{m[0]}-#{m[1].downcase}" }

data/lib/nydp/compiler.rb

@@ -1,4 +1,5 @@
 require 'nydp/cond'
+require 'nydp/loop'
 require 'nydp/function_invocation'
 require 'nydp/interpreted_function'
 require 'nydp/literal'
@@ -7,48 +8,57 @@ module Nydp
   class Compiler
     extend Helper
 
-    def self.compile expression, bindings
-      compile_expr expression, bindings
+    def self.compile expression, bindings, ns
+      compile_expr expression, bindings, ns
     rescue StandardError => e
-      raise Nydp::Error.new "failed to compile expression:\n#{expression.inspect}"
+      raise Nydp::Error.new "failed to compile expression:\n#{expression._nydp_inspect}\n#{e.message}"
     end
 
-    def self.compile_expr expression, bindings
-      if expression.is_a? Nydp::Symbol
-        SymbolLookup.build expression, bindings
+    def self.compile_expr expression, bindings, ns
+      # if expression.is_a? Nydp::Symbol
+      if expression.is_a? ::Symbol
+        SymbolLookup.build expression, bindings, ns
       elsif literal? expression
-        Literal.build expression, bindings
+        Literal.build expression, bindings, ns
       elsif expression.is_a? Nydp::Pair
-        compile_pair expression, bindings
+        begin
+          compile_pair expression, bindings, ns
+        rescue => e
+          raise "failed to compile #{expression._nydp_inspect}"
+        end
+      else
+        raise Nydp::Error.new "failed to compile unrecognised expression:\n#{expression._nydp_inspect}\nwhich is a #{expression.class}"
       end
     end
 
     def self.maybe_cons a, b
-      Nydp::NIL.is?(a) ? b : cons(a, b)
+      (a == nil) ? b : cons(a, b)
     end
 
-    def self.compile_each expr, bindings
-      if Nydp::NIL.is?(expr)
+    def self.compile_each expr, bindings, ns
+      if expr == nil
         expr
       elsif pair?(expr)
-        maybe_cons compile(expr.car, bindings), compile_each(expr.cdr, bindings)
+        maybe_cons compile(expr.car, bindings, ns), compile_each(expr.cdr, bindings, ns)
       else
-        compile(expr, bindings)
+        compile(expr, bindings, ns)
       end
     end
 
-    def self.compile_pair expression, bindings
+    def self.compile_pair expression, bindings, ns
       key = expression.car
       if sym?(key, :cond)
-        Cond.build expression.cdr, bindings # todo: replace with function? (cond x (fn () iftrue) (fn () iffalse)) -->> performance issues, creating two closures for every cond invocation
+        Cond.build expression.cdr, bindings, ns # todo: replace with function? (cond x (fn () iftrue) (fn () iffalse)) -->> performance issues, creating two closures for every cond invocation
+      elsif sym?(key, :loop)
+        Loop.build expression.cdr, bindings, ns
       elsif sym?(key, :quote)
-        Literal.build expression.cadr, bindings
+        Literal.build expression.cadr, bindings, ns
       elsif sym?(key, :assign)
-        Assignment.build expression.cdr, bindings
+        Assignment.build expression.cdr, bindings, ns
       elsif sym?(key, :fn)
-        InterpretedFunction.build expression.cadr, expression.cddr, bindings
+        InterpretedFunction.build expression.cadr, expression.cddr, bindings, ns
       else
-        FunctionInvocation.build expression, bindings
+        FunctionInvocation.build expression, bindings, ns
       end
     end
   end

data/lib/nydp/cond.rb

@@ -1,73 +1,69 @@
 module Nydp
-  class ExecuteConditionalInstruction
-    extend Helper
-
-    def initialize when_true, when_false
-      @when_true, @when_false = when_true, when_false
-    end
-
-    def lexical_reach n
-      [@when_true.lexical_reach(n), @when_false.lexical_reach(n)].max
-    end
-
-    def execute vm
-      (Nydp::NIL.is?(vm.args.pop) ? @when_false : @when_true).execute vm
-    end
-
-    def inspect
-      "when_true:#{@when_true.inspect}:when_false:#{@when_false.inspect}"
-    end
-
-    def to_s
-      "#{@when_true.to_s} #{@when_false.to_s}"
-    end
-  end
-
   class Cond
     extend Helper
     include Helper
     attr_reader :condition, :conditional
 
     def initialize cond, when_true, when_false
-      @condition, @conditional = cond, cons(ExecuteConditionalInstruction.new(when_true, when_false))
+      @condition, @when_true, @when_false = cond, when_true, when_false
     end
 
     def lexical_reach n
-      [@condition.lexical_reach(n), @conditional.car.lexical_reach(n)].max
+      [@condition.lexical_reach(n), @when_true.lexical_reach(n), @when_false.lexical_reach(n)].max
     end
 
     def execute vm
-      vm.push_ctx_instructions conditional
-      condition.execute vm
+      if (@condition.execute(vm))
+        @when_true.execute(vm)
+      else
+        @when_false.execute(vm)
+      end
+    end
+
+    def compile_to_ruby indent, srcs, opts=nil
+      if (!@when_false) || (@when_false.is_a?(Nydp::Literal) && !@when_false.expression)
+        "#{indent}##> #{inspect.split(/\n/).join('\n')}
+#{indent}if (#{@condition.compile_to_ruby "", srcs})
+#{@when_true.compile_to_ruby(indent + "  ", srcs, cando: true)}
+#{indent}end"
+      else
+        "#{indent}##> #{inspect.split(/\n/).join('\n')}
+#{indent}if (#{@condition.compile_to_ruby "", srcs})
+#{@when_true.compile_to_ruby(indent + "  ", srcs, cando: true)}
+#{indent}else
+#{@when_false.compile_to_ruby(indent + "  ", srcs, cando: true)}
+#{indent}end"
+      end
     end
 
     def inspect
-      "cond:#{condition.inspect}:#{conditional.inspect}"
+      "(cond #{condition._nydp_inspect} #{@when_true._nydp_inspect} #{@when_false._nydp_inspect})"
     end
 
     def to_s
-      "(cond #{condition.to_s} #{conditional.to_s})"
+      "(cond #{condition.to_s} #{@when_true.to_s} #{@when_false.to_s})"
     end
 
-    def self.build expressions, bindings
+    def self.build expressions, bindings, ns
       if expressions.is_a? Nydp::Pair
-        cond       = Compiler.compile expressions.car, bindings
-        when_true  = Compiler.compile expressions.cdr.car, bindings
-        when_false = Compiler.compile expressions.cdr.cdr.car, bindings
+        cond       = Compiler.compile expressions.car, bindings, ns
+        when_true  = Compiler.compile expressions.cdr.car, bindings, ns
+        when_false = Compiler.compile expressions.cdr.cdr.car, bindings, ns
         csig       = sig(cond)
-        # puts cond_sig
-        # TODO : handle literal nil explicitly (if x y) -> #when_false is literal nil, we can hardcode that
-        # todo : handle "OR" explicitly -> (if x x y) -> when #cond equals #when_true, hardcode this case
-        case csig
-        when "LEX"
-          Cond_LEX.build(cond, when_true, when_false)
-        when "SYM"
-          Cond_SYM.new(cond, cons(when_true), cons(when_false))
-        else
-          new(cond, when_true, when_false)
-        end
+        xsig       = "#{sig(cond)}_#{sig(when_true)}_#{sig(when_false)}"
+
+        # case csig
+        # when "LEX"
+        #   Cond_LEX.build(cond, when_true, when_false)
+        # when "SYM"
+        #   Cond_SYM.new(cond, when_true, when_false)
+        # else
+        #   new(cond, when_true, when_false)
+        # end
+
+        new(cond, when_true, when_false)
       else
-        raise "can't compile Cond: #{expressions.inspect}"
+        raise "can't compile Cond: #{expressions._nydp_inspect}"
       end
     end
   end
@@ -84,20 +80,26 @@ module Nydp
       [@condition.lexical_reach(n), @when_true.lexical_reach(n), @when_false.lexical_reach(n)].max
     end
 
-    def inspect ; "cond:#{@condition.inspect}:#{@when_true.inspect}:#{@when_false.inspect}" ; end
+    def inspect ; "cond:#{@condition._nydp_inspect}:#{@when_true._nydp_inspect}:#{@when_false._nydp_inspect}" ; end
     def to_s    ; "(cond #{@condition.to_s} #{@when_true.to_s} #{@when_false.to_s})" ; end
+    # def compile_to_ruby indent
+    #   "((#{@condition.compile_to_ruby "", srcs}) ? (#{@when_true.compile_to_ruby "", srcs}) : (#{@when_false.compile_to_ruby "", srcs}))"
+    # end
   end
 
   class Cond_LEX < CondBase
     def execute vm
-      truth = !Nydp::NIL.is?(@condition.value vm.current_context)
-      vm.push_ctx_instructions (truth ? @when_true : @when_false)
+      if @condition.value vm.current_context
+        @when_true.execute(vm)
+      else
+        @when_false.execute(vm)
+      end
     end
 
     def lexical_reach n
       cr = @condition.lexical_reach(n)
-      ct = @when_true.car.lexical_reach(n)
-      cf = @when_false.car.lexical_reach(n)
+      ct = @when_true.lexical_reach(n)
+      cf = @when_false.lexical_reach(n)
 
       [cr, ct, cf].max
     end
@@ -107,23 +109,27 @@ module Nydp
       fsig       = sig(when_false)
       cond_sig = "#{tsig}_#{fsig}"
 
-      # if (cond == when_true)
-      #   OR_LEX.build cond, when_false
-
       if (cond == when_true) && (fsig == "LIT")
-        OR_LEX_LIT.new cond, nil, when_false
+        OR_LEX_LIT.new cond, nil, when_false.expression
       elsif (cond == when_true) && (fsig == "LEX")
         OR_LEX_LEX.new cond, nil, when_false
+      elsif (cond == when_true)
+        OR_LEX_XXX.new cond, nil, when_false
       else
         case cond_sig
         when "LIT_LIT"
+          # puts "building Cond_LEX_LIT_LIT #{[cond, when_true.expression, when_false.expression]}"
           Nydp::Cond_LEX_LIT_LIT.new(cond, when_true.expression, when_false.expression)
         when "LEX_LIT"
           Nydp::Cond_LEX_LEX_LIT.new(cond, when_true, when_false.expression)
         when "CND_LIT"
           Nydp::Cond_LEX_CND_LIT.new(cond, when_true, when_false.expression)
+        when "NVB_LEX"
+          Nydp::Cond_LEX_NVB_LEX.new(cond, when_true, when_false)
+        when "NVB_LIT"
+          Nydp::Cond_LEX_NVB_LIT.new(cond, when_true, when_false.expression)
         else
-          Nydp::Cond_LEX.new(cond, cons(when_true), cons(when_false))
+          new(cond, when_true, when_false)
         end
       end
     end
@@ -131,67 +137,68 @@ module Nydp
 
   class OR_LEX_LIT < CondBase
     def execute vm
-      value = @condition.value vm.current_context
-      vm.push_arg(!Nydp::NIL.is?(value) ? value : @when_false)
+      @condition.value(vm.current_context) || @when_false
     end
   end
 
   class OR_LEX_LEX < CondBase
     def execute vm
-      value = @condition.value vm.current_context
-      vm.push_arg(!Nydp::NIL.is?(value) ? value : (@when_false.value vm.current_context))
+      @condition.value(vm.current_context) || (@when_false.value vm.current_context)
     end
   end
 
-  # class OR_LEX < CondBase
-  #   def execute vm
-  #     value = @condition.value vm.current_context
-  #     if !Nydp::NIL.is?(value)
-  #       vm.push_arg value
-  #     else
-  #       @when_false.execute vm
-  #     end
-  #   end
-
-  #   def self.build cond, when_false
-  #     case sig(when_false)
-  #     when "LIT"
-  #       OR_LEX_LIT.new(cond, nil, when_false)
-  #     when "LEX"
-  #       OR_LEX_LEX.new(cond, nil, when_false)
-  #     else
-  #       OR_LEX.new(cond, nil, when_false)
-  #     end
-  #   end
-  # end
+  class OR_LEX_XXX < CondBase
+    def execute vm
+      @condition.value(vm.current_context) || (@when_false.execute vm)
+    end
+  end
 
   class Cond_LEX_LIT_LIT < CondBase # (def no (arg) (cond arg nil t))
     def execute vm
-      falsity = Nydp::NIL.is?(@condition.value vm.current_context)
-      vm.push_arg(falsity ? @when_false : @when_true)
+      (@condition.value vm.current_context) ? @when_true : @when_false
     end
   end
 
   class Cond_LEX_LEX_LIT < CondBase
     def execute vm
-      falsity = Nydp::NIL.is?(@condition.value vm.current_context)
-      vm.push_arg(falsity ? @when_false : (@when_true.value vm.current_context))
+      (@condition.value vm.current_context) ? (@when_true.value vm.current_context) : @when_false
     end
   end
 
   class Cond_LEX_CND_LIT < CondBase
     def execute vm
-      if Nydp::NIL.is?(@condition.value vm.current_context)
-        vm.push_arg @when_false
+      if (@condition.value vm.current_context)
+        @when_true.execute vm
+      else
+        @when_false
+      end
+    end
+  end
+
+  class Cond_LEX_NVB_LEX < CondBase
+    def execute vm
+      if (@condition.value vm.current_context)
+        @when_true.execute vm
       else
+        @when_false.value(vm.current_context)
+      end
+    end
+  end
+
+  class Cond_LEX_NVB_LIT < CondBase
+    def execute vm
+      if (@condition.value vm.current_context)
         @when_true.execute vm
+      else
+        @when_false
       end
     end
   end
 
   class Cond_SYM < CondBase
     def execute vm
-      vm.push_ctx_instructions (Nydp::NIL.is?(@condition.value) ? @when_false : @when_true)
+      # puts "Cond_SYM"
+      (@condition.value) ? @when_true.execute(vm) : @when_false.execute(vm)
     end
   end
 end

data/lib/nydp/context_symbol.rb

@@ -24,6 +24,7 @@ module Nydp
                     "set_index(#{binding_index}, value)"
                   end
 
+      line = __LINE__ + 2
       code = <<-KLASS
         def initialize name, lexical_depth
           @name, @lexical_depth = name, lexical_depth
@@ -33,10 +34,14 @@ module Nydp
           @lexical_depth + n
         end
 
+        def compile_to_ruby indent, srcs, opts=nil
+          "\#{indent}_arg_\#{@name.to_s._nydp_name_to_rb_name}"
+        end
+
         def value ctx
-          ctx#{getctx}.#{at_index} || Nydp::NIL
+          ctx#{getctx}.#{at_index} || nil
         rescue
-          raise "failed looking up \#{@name.inspect} (\#{@name.class.name})"
+          raise "failed looking up \#{@name._nydp_inspect} (\#{@name.class.name}) : lookup expression was ctx#{getctx}.#{at_index}"
         end
 
         def assign value, ctx
@@ -45,24 +50,21 @@ module Nydp
           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 depth   ; #{depth}                               ; end
         def inspect ; to_s                                   ; end
-        def to_s    ; "[#{depth}##{binding_index}#\#{@lexical_depth}]\#{@name}" ; end
+        # def to_s    ; "[#{depth}##{binding_index}#\#{@lexical_depth}]\#{@name}" ; end
+        def to_s    ; @name ; end
       KLASS
 
       const_set name, Class.new(Nydp::ContextSymbol) {
-        eval code, binding, name.to_s, 0
+        eval code, binding, "#{name.to_s} : #{__FILE__}", line
       }
     end
 
     def self.build effective_depth, name, binding_index, lexical_depth
       const_get(:"ContextSymbol_#{effective_depth}_#{binding_index}").new(name, lexical_depth)
     rescue
-      raise "building ContextSymbol #{[effective_depth, name, binding_index, lexical_depth].inspect}"
+      raise "building ContextSymbol #{[effective_depth, name, binding_index, lexical_depth]._nydp_inspect}"
     end
   end
 end