nydp 0.5.1 → 0.6.0

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

@@ -18,4 +18,11 @@
 
  ("returns its year"      (&year  (date (time 1999 12 31 13 29 52)))     1999)
  ("returns its month"     (&month (date (time 1999 12 31 13 29 52)))       12)
- ("returns its day"       (&day   (date (time 1999 12 31 13 29 52)))       31))
+ ("returns its day"       (&day   (date (time 1999 12 31 13 29 52)))       31)
+
+ ("returns its year"      (&year  (time 1999 12 31 13 29 52))     1999)
+ ("returns its month"     (&month (time 1999 12 31 13 29 52))       12)
+ ("returns its day"       (&day   (time 1999 12 31 13 29 52))       31)
+ ("returns its hour"      (&hour  (time 1999 12 31 13 29 52))       13)
+ ("returns its minute"    (&min   (time 1999 12 31 13 29 52))       29)
+ ("returns its second"    (&sec   (time 1999 12 31 13 29 52))       52))

data/lib/lisp/tests/unparse-tests.nydp

@@ -1,8 +1,14 @@
 (examples-for to-string
-  ("unquote"           (to-string '(unquote a))          ",a"           )
-  ("quote"             (to-string '(quote a))            "'a"           )
-  ("quasiquote"        (to-string '(quasiquote a))       "`a"           )
-  ("unquote-splicing"  (to-string '(unquote-splicing a)) ",@a"          )
-  ("brace-list"        (to-string '(brace-list a))       "{ a }"        )
-  ("brace-list"        (to-string '(brace-list a b))     "{ a b }"      )
-  ("brace-list"        (to-string '(brace-list a b c d)) "{ a b c d }"  ))
+  ("unquote"           (to-string '(unquote a))           ",a"           )
+  ("quote"             (to-string '(quote a))             "'a"           )
+  ("quasiquote"        (to-string '(quasiquote a))        "`a"           )
+  ("unquote-splicing"  (to-string '(unquote-splicing a))  ",@a"          )
+  ("percent-syntax"    (to-string '(percent-syntax || a)) "%a"           )
+  ("colon-syntax"      (to-string '(colon-syntax a b c))  "a:b:c"        )
+  ("dot-syntax"        (to-string '(dot-syntax a b c))    "a.b.c"        )
+  ("brace-list"        (to-string '(brace-list a))        "{ a }"        )
+  ("brace-list"        (to-string '(brace-list a b))      "{ a b }"      )
+  ("brace-list"        (to-string '(brace-list a b c d))  "{ a b c d }"  )
+  ("prefix-list"
+   (to-string '((prefix-list "%a.item" (href path)) anchor))
+   "(%a.item(href path) anchor)"))

data/lib/nydp/assignment.rb

@@ -1,35 +1,16 @@
 module Nydp
-  class AssignmentInstruction
-    attr_accessor :name
-
-    def initialize name
-      @name = name
-    end
-
-    def execute vm
-      @name.assign vm.peek_arg, vm.current_context
-    rescue
-      raise "assigning #{@name.inspect}"
-    end
-
-    def to_s
-      "#assign #{@name}"
-    end
-  end
-
   class Assignment
     include Helper
 
-    def self.build args, bindings
-      name = Compiler.compile args.car, bindings
-      raise "can't assign to #{name.inspect} : expression was #{args}" unless name.respond_to?(:assign)
+    def self.build args, bindings, ns
+      name = Compiler.compile args.car, bindings, ns
+      raise "can't assign to #{name._nydp_inspect} : expression was #{args}" unless name.respond_to?(:assign)
       value_expr = args.cdr.car
-      Assignment.new name, Compiler.compile(value_expr, bindings), value_expr
+      Assignment.new name, Compiler.compile(value_expr, bindings, ns), args
     end
 
-    def initialize name, value, value_src
-      @name, @value, @value_src = name, value, value_src
-      @instructions = cons(value, cons(AssignmentInstruction.new(name)))
+    def initialize name, value, src
+      @name, @value, @src = name, value, src
     end
 
     def lexical_reach n
@@ -37,15 +18,21 @@ module Nydp
     end
 
     def to_s
-      "(assign #{@instructions.cdr.car.name} #{@value_src.inspect})"
+      "(assign #{@src.car} #{@src.cdr.car})"
+    end
+
+    def compile_to_ruby indent, srcs, opts=nil
+      "#{indent}##> #{to_s.split(/\n/).join('\n')}\n" +
+        "#{indent}(#{@name.compile_to_ruby "", srcs} =\n" +
+        "#{indent}#{@value.compile_to_ruby indent, srcs})"
     end
 
     def inspect; to_s ; end
 
     def execute vm
-      vm.push_ctx_instructions @instructions
+      @name.assign @value.execute(vm), vm.current_context
     rescue
-      raise "assigning #{@value.inspect} to #{@name.inspect}"
+      raise "assigning #{@value._nydp_inspect} to #{@name._nydp_inspect}"
     end
   end
 end

data/lib/nydp/builtin/abs.rb

@@ -1,8 +1,9 @@
 class Nydp::Builtin::Abs
   include Nydp::Builtin::Base, Singleton
 
-  def invoke_2         vm, a0 ; vm.push_arg(a0.abs)   ; end
-  def builtin_invoke vm, args ; invoke_2 vm, args.car ; end
-
   def name ; "mod" ; end
+
+  def builtin_call arg
+    arg.abs
+  end
 end

data/lib/nydp/builtin/apply.rb

@@ -1,16 +1,14 @@
 class Nydp::Builtin::Apply
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    args.car.invoke vm, apply_args(args.cdr)
-  end
-
-  private
+  def builtin_call arg, *args
+    # original_args = args.dup
+    cc            = args.pop
+    cc            = [] if cc == nil
+    dd            = cc.to_a
+    aa            = args.concat(dd)
 
-  def apply_args args
-    raise "Apply: expected a list : got #{args.inspect}" unless pair? args
-    raise "Apply: improper list : cdr is ruby nil" if args.cdr.nil?
-    return args.car if Nydp::NIL.is? args.cdr
-    cons args.car, apply_args(args.cdr)
+    arg.call(*aa)._nydp_wrapper
   end
+
 end

data/lib/nydp/builtin/cdr_set.rb

@@ -1,5 +1,5 @@
 class Nydp::Builtin::CdrSet
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args ; vm.push_arg(args.car.cdr = args.cdr.car) ; end
+  def builtin_call a, b ; a.cdr = b ; end
 end

data/lib/nydp/builtin/comment.rb

@@ -1,7 +1,5 @@
 class Nydp::Builtin::Comment
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg Nydp::NIL
-  end
+  def builtin_call *args ; nil ; end
 end

data/lib/nydp/builtin/date.rb

@@ -1,34 +1,17 @@
 class Nydp::Builtin::Date
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    case args.size
-    when 0 ; builtin_invoke_1 vm
-    when 1 ; builtin_invoke_2 vm, args.car
-    when 2 ; builtin_invoke_3 vm, args.car, args.cdr.car
-    when 3 ; builtin_invoke_4 vm, args.car, args.cdr.car, args.cdr.cdr.car
+  def builtin_call y=:unset, m=:unset, d=:unset
+    if y == :unset
+      Date.today
+    elsif m == :unset
+      if y.respond_to?(:to_date)
+        y.to_date
+      elsif y.is_a?(String)
+        ::Date.parse(y)
+      end
+    else
+      Date.new(y,m,d)
     end
   end
-
-  def builtin_invoke_1 vm
-    vm.push_arg(Nydp::Date.new Date.today)
-  end
-
-  # it's a Time object (or any object that responds to #to_date)
-  def builtin_invoke_2 vm, arg
-    arg = if arg.respond_to?(:to_date)
-            arg.to_date
-          elsif arg.is_a?(String)
-            ::Date.parse(arg)
-          end
-    vm.push_arg(Nydp::Date.new arg)
-  end
-
-  def builtin_invoke_3 vm, a0, a1
-    raise Nydp::Error.new "Date, got 2 args (#{a0} #{a1}), expected 0 or 1 or 3 args"
-  end
-
-  def builtin_invoke_4 vm, y, m, d
-    vm.push_arg(Nydp::Date.new Date.new(y,m,d))
-  end
 end

data/lib/nydp/builtin/divide.rb

@@ -1,17 +1,10 @@
 class Nydp::Builtin::Divide
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg divide(args.cdr, args.car)
-  end
+  def name ; "/" ; end
 
-  def divide args, accum
-    if Nydp::NIL.is? args
-      accum
-    else
-      divide(args.cdr, (accum / args.car))
-    end
+  def builtin_call *args
+    (args.reduce &:/)._nydp_wrapper
   end
 
-  def name ; "/" ; end
 end

data/lib/nydp/builtin/ensuring.rb

@@ -1,28 +1,13 @@
-require "nydp/vm"
+# require "nydp/vm"
 
 class Nydp::Builtin::Ensuring
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  class InvokeProtection
-    include Nydp::VM::Finally
-    attr_reader :protection
-
-    def initialize protection
-      @protection = protection
-    end
-
-    def execute vm
-      protection.invoke vm, Nydp::NIL
+  def builtin_call ensureme, tricky
+    begin
+      tricky.call
+    ensure
+      ensureme.call
     end
   end
-
-  def builtin_invoke vm, args
-    fn_ensure = args.car
-    fn_tricky = args.cdr.car
-
-    protection_instructions = Nydp::Pair.from_list [InvokeProtection.new(fn_ensure), Nydp::PopArg]
-    vm.push_ctx_instructions protection_instructions
-
-    fn_tricky.invoke vm, Nydp::NIL
-  end
 end

data/lib/nydp/builtin/error.rb

@@ -1,9 +1,7 @@
 class Nydp::Builtin::Error
   include Nydp::Builtin::Base, Singleton
 
-  # override #invoke on nydp/builtin/base because
-  # we don't want to inherit error handling
-  def builtin_invoke vm, args
-    raise Nydp::Error.new(args.to_a.map(&:to_s).join("\n"), vm.last_error)
+  def builtin_call *args
+    raise Nydp::Error.new(args.map(&:to_s).join("\n"))
   end
 end

data/lib/nydp/builtin/eval.rb

@@ -1,8 +1,13 @@
 class Nydp::Builtin::Eval
-  include Nydp::Builtin::Base, Singleton
+  include Nydp::Builtin::Base
 
-  def builtin_invoke vm, args
-    evaluator = Nydp::Evaluator.new Nydp::VM.new(vm.ns), vm.ns, "<eval>"
-    vm.push_arg evaluator.evaluate args.car
+  def initialize ns
+    @ns = ns
+    super()
+  end
+
+  def builtin_call *args
+    evaluator = Nydp::Evaluator.new @ns, "<eval>"
+    evaluator.evaluate args.first
   end
 end

data/lib/nydp/builtin/greater_than.rb

@@ -1,14 +1,13 @@
 class Nydp::Builtin::GreaterThan
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg(greater_than(args.car, args.cdr) || Nydp::NIL)
-  end
+  def name ; ">" ; end
 
-  def greater_than arg, args
-    return arg if Nydp::NIL.is? args
-    (arg > args.car) && greater_than(args.car, args.cdr)
+  def builtin_call arg, *args
+    while !args.empty?
+      return nil unless args.first && arg > args.first
+      arg = args.shift
+    end
+    return arg
   end
-
-  def name ; ">" ; end
 end

data/lib/nydp/builtin/handle_error.rb

@@ -1,46 +1,22 @@
-require "nydp/vm"
+# require "nydp/vm"
 
 class Nydp::Builtin::HandleError
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  class CatchError
-    include Nydp::Helper, Nydp::VM::HandleError
-
-    attr_reader :handler, :vm_arg_array_size
-
-    def initialize handler, vm_arg_array_size
-      @handler, @vm_arg_array_size = handler, vm_arg_array_size
-    end
-
-    def execute vm
-      e = vm.last_error = vm.unhandled_error
-      vm.unhandled_error = nil
-      return unless e
-
-      vm.args = vm.args[0...vm_arg_array_size]
-
+  def builtin_call handler, tricky
+    begin
+      res = tricky.call
+    rescue Exception => e
+      o = e
       msgs = []
+      traces = []
       while e
         msgs << e.message
+        traces << Nydp.enhance_backtrace(e.backtrace)
         e = e.cause
       end
-
-      handler.invoke_2 vm, r2n(msgs)
+      res = handler.call msgs._nydp_wrapper, traces._nydp_wrapper
     end
-
-    def to_s
-      "(on-err: #{handler})"
-    end
-  end
-
-
-  def builtin_invoke vm, args
-    fn_handle = args.car
-    fn_tricky = args.cdr.car
-
-    catcher_instructions = Nydp::Pair.from_list [CatchError.new(fn_handle, vm.args.size)]
-    vm.push_ctx_instructions catcher_instructions
-
-    fn_tricky.invoke vm, Nydp::NIL
+    res._nydp_wrapper
   end
 end

data/lib/nydp/builtin/hash.rb

@@ -1,81 +1,60 @@
-require "nydp/hash"
-
 class Nydp::Builtin::Hash
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg(build_hash Nydp::Hash.new, args)
-  end
-
-  def build_hash h, args
-    return h if Nydp::NIL.is? args
-    k = args.car
-    rest = args.cdr
-    v = rest.car
-    h[k] = v
-    build_hash h, rest.cdr
-  end
+  def builtin_call *args ; Hash[*args] ; end
 end
 
 class Nydp::Builtin::HashGet
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
-  def builtin_invoke vm, args
-    vm.push_arg(args.car._nydp_get(args.cdr.car)._nydp_wrapper || Nydp::NIL)
+  def builtin_call hsh=nil, k=nil, *args
+    hsh._nydp_get(k)._nydp_wrapper
   end
 end
 
 class Nydp::Builtin::HashSet
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
-  def builtin_invoke vm, args
-    value = args.cdr.cdr.car
-    args.car._nydp_set(args.cdr.car, value)
-    vm.push_arg value
+  def builtin_call hsh, k, v=nil
+    hsh._nydp_set(k, v)
+    v
   end
 end
 
 class Nydp::Builtin::HashKeys
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
-  def builtin_invoke vm, args
-    vm.push_arg args.car._nydp_keys._nydp_wrapper
+  def builtin_call h
+    h._nydp_keys._nydp_wrapper
   end
 end
 
 class Nydp::Builtin::HashKeyPresent
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
-  def builtin_invoke vm, args
-    hash = args.car
-    key  = args.cdr.car
-    truth = case hash
-            when Nydp::Hash
-              hash.key? key
-            else
-              hash.key? n2r key
-            end
-    vm.push_arg(truth ? Nydp::T : Nydp::NIL)
-  end
   def name ; "hash-key?" ; end
+
+  def builtin_call h, k
+    h.key?(k) || nil
+  end
 end
 
 class Nydp::Builtin::HashMerge
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    hash_0 = args.car
-    hash_1 = args.cdr.car
-
-    vm.push_arg hash_0.merge hash_1
+  def builtin_call a0, a1
+    (a0.merge a1)._nydp_wrapper
   end
 end
 
 class Nydp::Builtin::HashSlice
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    old   = args.car
-    h     = old.class.new
-    slice = args.cdr.car
-    slice = slice.map { |k| n2r k } unless old.is_a? Nydp::Hash
-    slice.each { |k| h[k] = old[k] if old.key?(k) }
-    vm.push_arg h
+  def builtin_call h, slice
+    h.slice(*slice.to_a)
+  end
+end
+
+class Nydp::Builtin::HashToArray
+  include Nydp::Helper, Nydp::Builtin::Base, Singleton
+
+  def builtin_call h
+    h.to_a._nydp_wrapper
   end
 end

data/lib/nydp/builtin/inspect.rb

@@ -1,7 +1,5 @@
 class Nydp::Builtin::Inspect
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg args.car.inspect
-  end
+  def builtin_call arg ; arg._nydp_inspect ; end
 end

data/lib/nydp/builtin/is_equal.rb

@@ -1,14 +1,11 @@
 class Nydp::Builtin::IsEqual
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke_1 vm      ; raise "#{name} : requires at least two args"                    ; end
-  def builtin_invoke_2 vm, arg ; raise "#{name} : requires at least two args, got one: (#{arg})" ; end
-
-  def builtin_invoke_3 vm, a0, a1     ; vm.push_arg ((a0 == a1)        ? Nydp::T : Nydp::NIL) ; end
-  def builtin_invoke_4 vm, a0, a1, a2 ; vm.push_arg (eq?([a0, a1, a2]) ? Nydp::T : Nydp::NIL) ; end
-  def builtin_invoke   vm, args       ; vm.push_arg (eq?(args.to_a)    ? Nydp::T : Nydp::NIL) ; end
-
   def _eq?  arg, args ; args.all? { |a| a == arg }   ; end
   def eq?        args ; _eq? args.first, args[1..-1] ; end
   def name            ; "eq?"                        ; end
+
+  def builtin_call *args
+    eq?(args) || nil
+  end
 end

data/lib/nydp/builtin/less_than.rb

@@ -1,13 +1,12 @@
 class Nydp::Builtin::LessThan
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg(less_than(args.car, args.cdr) || Nydp::NIL)
-  end
-
-  def less_than arg, args
-    return arg if Nydp::NIL.is? args
-    (arg < args.car) && less_than(args.car, args.cdr)
+  def builtin_call arg, *args
+    while !args.empty?
+      return nil unless args.first && (arg < args.first)
+      arg = args.shift
+    end
+    return arg
   end
 
   def name ; "<" ; end

data/lib/nydp/builtin/log.rb

@@ -0,0 +1,7 @@
+class Nydp::Builtin::Log
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_call *args
+    Nydp.logger.info(args.map(&:to_s).join(' '))
+  end
+end

data/lib/nydp/builtin/math_ceiling.rb

@@ -1,7 +1,5 @@
 class Nydp::Builtin::MathCeiling
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg(args.car.ceil)
-  end
+  def builtin_call arg ; arg.ceil ; end
 end

data/lib/nydp/builtin/math_floor.rb

@@ -1,7 +1,5 @@
 class Nydp::Builtin::MathFloor
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg(args.car.floor)
-  end
+  def builtin_call arg ; arg.floor ; end
 end

data/lib/nydp/builtin/math_power.rb

@@ -1,7 +1,5 @@
 class Nydp::Builtin::MathPower
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg(args.car ** args.cdr.car)
-  end
+  def builtin_call a0, a1 ; a0 ** a1 ; end
 end

data/lib/nydp/builtin/math_round.rb

@@ -1,7 +1,7 @@
 class Nydp::Builtin::MathRound
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg(args.car.round)
+  def builtin_call arg
+    arg.round
   end
 end

data/lib/nydp/builtin/minus.rb

@@ -1,22 +1,15 @@
 class Nydp::Builtin::Minus
   include Nydp::Builtin::Base, Singleton
 
-  def invoke_1 vm             ; vm.push_arg 0             ; end
-  def invoke_2 vm, a          ; vm.push_arg -a            ; end
-  def invoke_3 vm, a0, a1     ; vm.push_arg(a0 - a1)      ; end
-  def invoke_4 vm, a0, a1, a2 ; vm.push_arg(a0 - a1 - a2) ; end
-
-  def builtin_invoke vm, args
-    vm.push_arg diff(args.cdr, args.car)
-  end
+  def name ; "-" ; end
 
-  def diff args, accum
-    if Nydp::NIL.is? args
-      accum
+  def builtin_call *args
+    if args.length == 1
+      - args.first
+    elsif args.first
+      args.reduce(&:-)
     else
-      diff(args.cdr, (accum - args.car))
+      0
     end
   end
-
-  def name ; "-" ; end
 end

data/lib/nydp/builtin/parse.rb

@@ -1,14 +1,14 @@
 class Nydp::Builtin::Parse
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    parser = Nydp.new_parser(vm.ns)
-    tokens = Nydp.new_tokeniser Nydp::StringReader.new args.car.to_s
+  def builtin_call arg
+    parser = Nydp.new_parser
+    tokens = Nydp.new_tokeniser Nydp::StringReader.new "parse", arg.to_s
     exprs  = []
     while !tokens.finished
       expr = parser.expression(tokens)
-      exprs << expr unless expr == nil
+      exprs << expr unless expr == nil && tokens.finished
     end
-    vm.push_arg Nydp::Pair.from_list exprs
+    Nydp::Pair.from_list exprs
   end
 end

data/lib/nydp/builtin/parse_in_string.rb

@@ -1,14 +1,12 @@
 class Nydp::Builtin::ParseInString
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    parser = Nydp.new_parser(vm.ns)
-    parsable = args.car.to_s
-    tokens = Nydp.new_tokeniser Nydp::StringReader.new parsable
-    expr = parser.embedded(tokens)
-    vm.push_arg expr
+  def builtin_call arg
+    parser = Nydp.new_parser
+    tokens = Nydp.new_tokeniser Nydp::StringReader.new "parse-in-string", arg.to_s
+    parser.embedded(tokens)
   rescue StandardError => e
-    new_msg = "parse error: #{e.message.inspect} in\n#{Nydp.indent_text parsable}"
+    new_msg = "parse error: #{e.message._nydp_inspect} in\n#{Nydp.indent_text arg.to_s}"
     raise Nydp::Error.new new_msg
   end
 end