nydp 0.5.1 → 0.6.0

data/lib/nydp/builtin/plus.rb

@@ -1,37 +1,20 @@
 class Nydp::Builtin::Plus
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke_1 vm             ; vm.push_arg 0             ; end
-  def builtin_invoke_2 vm, a          ; vm.push_arg a             ; end
-  def builtin_invoke_3 vm, a0, a1     ; vm.push_arg(a0 + a1)      ; end
-  def builtin_invoke_4 vm, a0, a1, a2 ; vm.push_arg(a0 + a1 + a2) ; end
-
-  def builtin_invoke vm, args
-    vm.push_arg case args.car
-                when Nydp::Pair
-                  sum(args, Nydp::NIL)
-                when String
-                  string_concat("", args)
-                else
-                  sum(args.cdr, args.car)
-                end
-  end
-
-  def string_concat init, others
-    while others && !Nydp::NIL.is?(others)
-      init << others.car.to_s
-      others = others.cdr
-    end
-    init
-  end
+  def name ; "+" ; end
 
-  def sum args, accum
-    while args && !Nydp::NIL.is?(args)
-      accum += args.car
-      args = args.cdr
-    end
-    accum
+  def builtin_call *args
+    if args.empty?
+      0
+    else
+      case args.first
+      when String
+        args.each_with_object("") { |str, res| res << str.to_s }
+      when Date
+        (args.shift._nydp_date + builtin_call(*args)).to_ruby
+      else
+        args.reduce &:+
+      end
+    end._nydp_wrapper
   end
-
-  def name ; "+" ; end
 end

data/lib/nydp/builtin/pre_compile.rb

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

data/lib/nydp/builtin/puts.rb

@@ -1,14 +1,10 @@
 class Nydp::Builtin::Puts
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    if Nydp::NIL.is? args
-      puts
-    else
-      s = args.map { |a| a.to_s }
-      puts s.join ' '
-    end
-    vm.push_arg args.car
+  def builtin_call *args
+    s = args.map { |a| a.to_s }
+    puts s.join ' '
+    args.first
   end
 
   def name ; "p" ; end

data/lib/nydp/builtin/quit.rb

@@ -1,7 +1,7 @@
 class Nydp::Builtin::Quit
   include Nydp::Builtin::Base
 
-  def builtin_invoke vm, args
+  def builtin_call *args
     exit
   end
 end

data/lib/nydp/builtin/rand.rb

@@ -1,18 +1,13 @@
 class Nydp::Builtin::Rand
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke_1 vm             ; vm.push_arg rand                ; end
-  def builtin_invoke_2 vm, a          ; vm.push_arg rand(a)             ; end
-  def builtin_invoke_3 vm, a0, a1     ; vm.push_arg(a0 + rand(a1 - a0)) ; end
-  def builtin_invoke   vm, args       ;
-    if Nydp::NIL.is? args
-      builtin_invoke_1 vm
+  def builtin_call a0=nil, a1=nil
+    if a0 == nil
+      rand
+    elsif a1 == nil
+      rand(a0)
     else
-      case args.size
-      when 1 ; builtin_invoke_2 vm, args.car
-      when 2 ; builtin_invoke_3 vm, args.car, args.cadr
-      else   ; raise "rand: 0, 1 or 2 args expected, got #{args.length}"
-      end
+      (a0 + rand(a1 - a0))
     end
   end
 end

data/lib/nydp/builtin/random_string.rb

@@ -3,9 +3,7 @@ class Nydp::Builtin::RandomString
 
   RANDOM_CHARS = ["A","B","C","D","E","F","G","H","J","K","L","M","N","P","Q","R","S","T","U","V","W","X","Y","Z","2","3","4","5","6","7","8","9"]
 
-  def builtin_invoke vm, args
-    length = args.car unless Nydp::NIL.is?(args)
-    s = (0...(length || 10)).inject("") {|a,i| a << RANDOM_CHARS[rand(RANDOM_CHARS.size)] }
-    vm.push_arg s
+  def builtin_call length=nil
+    (0...(length || 10)).inject("") {|a,i| a << RANDOM_CHARS[rand(RANDOM_CHARS.size)] }
   end
 end

data/lib/nydp/builtin/rng.rb

@@ -0,0 +1,25 @@
+class Nydp::Builtin::RNG
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_call a0=nil
+    if a0 == nil
+      Random.new
+    else
+      Random.new(a0)
+    end
+  end
+end
+
+class ::Random
+  include Nydp::Builtin::Base
+
+  def builtin_call a0=nil, a1=nil
+    if a0 == nil
+      self.rand
+    elsif a1 == nil
+      self.rand(a0)
+    else
+      (a0 + self.rand(a1 - a0))
+    end
+  end
+end

data/lib/nydp/builtin/ruby_wrap.rb

@@ -8,14 +8,14 @@ class Nydp::Builtin::RubyWrap
   class Coder < Struct.new(:name, :size, :code, :helpers)
     def msize ; size + 1 ; end
 
-    def arg_mapper
+    def arg_mapper_novm
       case size
       when 0 ; ""
-      when 1 ; ", a0"
-      when 2 ; ", a0, a1"
-      when 3 ; ", a0, a1, a2"
-      when 4 ; ", a0, a1, a2, a3"
-      when 5 ; ", a0, a1, a2, a3, a4"
+      when 1 ; "a0=nil"
+      when 2 ; "a0=nil, a1=nil"
+      when 3 ; "a0=nil, a1=nil, a2=nil"
+      when 4 ; "a0=nil, a1=nil, a2=nil, a3=nil"
+      when 5 ; "a0=nil, a1=nil, a2=nil, a3=nil, a4=nil"
       else   ; raise "maximum 5 arguments!"
       end
     end
@@ -31,12 +31,18 @@ class Nydp::Builtin::RubyWrap
 class #{name}
   include Nydp::Builtin::Base, Singleton#{helpers}
 
-  def builtin_invoke_#{msize} vm#{ arg_mapper }
-    vm.push_arg(#{code})
+  def builtin_call #{ arg_mapper_novm }
+    (#{code})
   end
 
-  def builtin_invoke vm, args
-    vm.push_arg(#{generic_code})
+  # return the ruby equivalent of this code if it was inlined inside another builtin
+  def inline_code arg_expressions
+    #{code.inspect}.
+      gsub(/a0/, arg_expressions[0]).
+      gsub(/a1/, arg_expressions[1]).
+      gsub(/a2/, arg_expressions[2]).
+      gsub(/a3/, arg_expressions[3]).
+      gsub(/a4/, arg_expressions[4])
   end
 end
 CODE
@@ -65,8 +71,15 @@ CODE
   end
 
   core_builder = builder ""
-  core_builder.build(:Cons, 2, %{ Nydp::Pair.new(a0, a1) }        )
-  core_builder.build(:Car , 1, %{ a0.car }                        )
-  core_builder.build(:Cdr , 1, %{ a0.cdr }                        )
-  core_builder.build(:Log , 1, %{ r2n Nydp.logger.info(a0.to_s) } )
+  core_builder.build(:Cons          , 2, %{ Nydp::Pair.new(a0, a1) }        )
+  core_builder.build(:Car           , 1, %{ a0.car }                        )
+  core_builder.build(:Cdr           , 1, %{ a0.cdr }                        )
+  core_builder.build(:Ln            , 1, %{ Math.log(a0) }                  )
+  core_builder.build(:Modulo        , 2, %{ a0 % a1 }                       )
+  core_builder.build(:Sqrt          , 1, %{ Math.sqrt a0 }                  )
+  core_builder.build(:Regexp        , 1, %{ ::Regexp.compile(a0) }          )
+  core_builder.build(:StringPadLeft , 3, %{ a0.to_s.rjust(a1, a2.to_s) }    )
+  core_builder.build(:StringPadRight, 3, %{ a0.to_s.ljust(a1, a2.to_s) }    )
+  core_builder.build(:ToList        , 1, %{ a0.to_a._nydp_wrapper }         )
+  core_builder.build(:StringForceEncoding, 2, %{ a0.to_s.force_encoding(a1)._nydp_wrapper } )
 end

data/lib/nydp/builtin/script_run.rb

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

data/lib/nydp/builtin/set_intersection.rb

@@ -1,8 +1,7 @@
 class Nydp::Builtin::SetIntersection
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke_2       vm, a ; vm.push_arg a               ; end
-  def builtin_invoke_3    vm, a, b ; vm.push_arg(a & b)          ; end
-  def builtin_invoke_4 vm, a, b, c ; vm.push_arg(a & b & c)      ; end
-  def builtin_invoke      vm, args ; vm.push_arg args.reduce &:& ; end
+  def builtin_call *args
+    args.reduce(&:&)._nydp_wrapper
+  end
 end

data/lib/nydp/builtin/set_union.rb

@@ -1,8 +1,7 @@
 class Nydp::Builtin::SetUnion
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke_2       vm, a ; vm.push_arg a               ; end
-  def builtin_invoke_3    vm, a, b ; vm.push_arg(a | b)          ; end
-  def builtin_invoke_4 vm, a, b, c ; vm.push_arg(a | b | c)      ; end
-  def builtin_invoke      vm, args ; vm.push_arg args.reduce &:| ; end
+  def builtin_call *args
+    args.reduce(&:|)._nydp_wrapper
+  end
 end

data/lib/nydp/builtin/sort.rb

@@ -2,14 +2,9 @@ module Nydp
   class Builtin::Sort
     include Builtin::Base, Singleton
 
-    def builtin_invoke vm, args
-      vm.push_arg Pair.from_list to_array(args.car, []).sort
+    def builtin_call arg
+      arg.to_a.sort._nydp_wrapper
     end
 
-    private
-
-    def to_array pair, list
-      pair.is_a?(Pair) ? to_array(pair.cdr, (list << pair.car)) : list
-    end
   end
 end

data/lib/nydp/builtin/string_match.rb

@@ -1,21 +1,13 @@
 class Nydp::Builtin::StringMatch
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    kmatch            = Nydp::Symbol.mk :match   , vm.ns
-    kcaptures         = Nydp::Symbol.mk :captures, vm.ns
-    target            = args.car.to_s
-    pattern           = Regexp.new(args.cdr.car.to_s)
-    match             = pattern.match target
+  def builtin_call target, pattern
+    target  = target.to_s
+    pattern = Regexp.new(pattern.to_s) unless pattern.is_a? Regexp
+    match   = pattern.match target
 
     if match
-      result             = Nydp::Hash.new
-      result[kmatch]     = match.to_s
-      result[kcaptures]  = Nydp::Pair.from_list match.captures.map { |cap| cap.to_s }
-    else
-      result             = Nydp::NIL
+      { match: match.to_s, captures: (match.captures.map(&:to_s)._nydp_wrapper) }
     end
-
-    vm.push_arg result
   end
 end

data/lib/nydp/builtin/string_replace.rb

@@ -1,12 +1,7 @@
 class Nydp::Builtin::StringReplace
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    to_remove = Regexp.new args.car.to_ruby
-    to_insert = args.cdr.car.to_ruby
-    target    = args.cdr.cdr.car.to_s
-    result    = target.to_s.gsub to_remove, to_insert
-
-    vm.push_arg result
+  def builtin_call remove, insert, str
+    str.to_s.to_s.gsub Regexp.new(remove.to_ruby), insert.to_ruby
   end
 end

data/lib/nydp/builtin/string_split.rb

@@ -1,13 +1,8 @@
 class Nydp::Builtin::StringSplit
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    target    = args.car.to_s
-    separator = args.cdr.car
-    separator = separator.to_s unless separator.is_a? Regexp
-
-    result    = target.split separator, -1
-
-    vm.push_arg Nydp::Pair.from_list result
+  def builtin_call str, sep=nil
+    sep = sep.to_s unless sep.is_a? Regexp
+    Nydp::Pair.from_list str.to_s.split(sep, -1)
   end
 end

data/lib/nydp/builtin/sym.rb

@@ -1,14 +1,7 @@
 class Nydp::Builtin::Sym
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    arg = args.car
-    val = case arg.class
-          when Nydp::Symbol
-            arg
-          else
-            Nydp::Symbol.mk arg.to_s.to_sym, vm.ns
-          end
-    vm.push_arg val
+  def builtin_call s
+    s.to_s.to_sym
   end
 end

data/lib/nydp/builtin/thread_locals.rb

@@ -1,7 +1,7 @@
 class Nydp::Builtin::ThreadLocals
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    vm.push_arg vm.locals
+  def builtin_call *args
+    Thread.current[:_nydp_thread_locals] ||= { }
   end
 end

data/lib/nydp/builtin/time.rb

@@ -2,51 +2,45 @@
 class Nydp::Builtin::Time
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke_1 vm
-    vm.push_arg ::Time.now
-  end
-
-  # either an offset in seconds from now, or a Date to convert to a time, or a Time to subtract and return offset in seconds from now
-  # when Numeric : return now + offset in seconds from now
-  # when Nydp::Date : convert date to time
-  # when Time : calculate and return now - Time offset in seconds
-  def builtin_invoke_2 vm, arg
-    case arg
-    when Numeric # relative time in seconds
-      vm.push_arg(Time.now + arg)
-    when Nydp::Date
-      vm.push_arg arg.to_ruby.to_time
-    when ::Time
-      vm.push_arg ::Time.now - arg
+  # when 0 arguments:
+  #  return Time.now
+  # when 1 argument:
+  #  either an offset in seconds from now, or a Date to convert to a time, or a Time to subtract and return offset in seconds from now
+  #  when Numeric : return now + offset in seconds from now
+  #  when Nydp::Date : convert date to time
+  #  when Time : calculate and return now - Time offset in seconds
+  # when 2 arguments:
+  #  first arg is a Time
+  #  if second arg is numeric, add to first arg
+  #  if second arg is a Time, subtract from first arg
+  def builtin_call y=:unset, mo=:unset, d=:unset, h=nil, mi=nil, s=nil, ms=nil
+    if y == :unset
+      ::Time.now
+    elsif mo == :unset
+      case y
+      when Numeric # relative time in seconds
+        (Time.now + y)
+      when ::Date
+        y.to_time
+      when ::Time
+        ::Time.now - y
+      else
+        puts
+        puts y.class
+        raise Nydp::Error.new "time : expected a number or a date or a time, got #{y._nydp_inspect}"
+      end
+    elsif d == :unset
+      # y is a date or time, mo is a number or time
+      case mo
+      when Numeric # relative time in seconds
+        (y + mo)
+      when ::Time
+        y - mo
+      else
+        raise Nydp::Error.new "time : expected a number or a date, got #{mo._nydp_inspect}"
+      end
     else
-      raise Nydp::Error.new "time : expected a number or a date or a time, got #{arg.inspect}"
+      Time.new(y,mo,d,h,mi,s,ms)
     end
   end
-
-  # first arg is a Time
-  # if second arg is numeric, add to first arg
-  # if second arg is a Time, subtract from first arg
-  def builtin_invoke_3 vm, a0, a1
-    case a1
-    when Numeric # relative time in seconds
-      vm.push_arg(a0 + a1)
-    when ::Time
-      vm.push_arg a0 - a1
-    else
-      raise Nydp::Error.new "time : expected a number or a date, got #{a1.inspect}"
-    end
-  end
-
-  def builtin_invoke vm, args
-    # assume ruby Time constructor args y mo d h mi s ms
-    y  = args.car
-    mo = args.cdr.car
-    d  = args.cdr.cdr.car
-    h  = args.cdr.cdr.cdr.car             if args.size > 3
-    mi = args.cdr.cdr.cdr.cdr.car         if args.size > 4
-    s  = args.cdr.cdr.cdr.cdr.cdr.car     if args.size > 5
-    ms = args.cdr.cdr.cdr.cdr.cdr.cdr.car if args.size > 6
-
-    vm.push_arg(Time.new(y,mo,d,h,mi,s,ms))
-  end
 end

data/lib/nydp/builtin/times.rb

@@ -1,22 +1,13 @@
 class Nydp::Builtin::Times
   include Nydp::Builtin::Base, Singleton
 
-  def invoke_1 vm             ; vm.push_arg 1             ; 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 multiply(args, 1)
-  end
+  def name ; "*" ; end
 
-  def multiply args, accum
-    if Nydp::NIL.is? args
-      accum
+  def builtin_call *args
+    if args.empty?
+      1
     else
-      multiply(args.cdr, (accum * args.car))
-    end
+      args.reduce(&:*)
+    end._nydp_wrapper
   end
-
-  def name ; "*" ; end
 end

data/lib/nydp/builtin/to_integer.rb

@@ -2,22 +2,16 @@ module Nydp::Builtin
   class ToInteger
     include Nydp::Builtin::Base, Singleton
 
-    def builtin_invoke_2 vm, arg
+    def builtin_call arg
       arg = n2r arg
 
-      i = if arg.respond_to? :to_i
-            arg.to_i
-          elsif arg.respond_to? :to_time
-            arg.to_time.to_i
-          else
-            arg.to_s.to_i
-          end
-
-      vm.push_arg r2n i
-    end
-
-    def builtin_invoke vm, args
-      builtin_invoke_2 vm, args.car
+      if arg.respond_to? :to_i
+        arg.to_i
+      elsif arg.respond_to? :to_time
+        arg.to_time.to_i
+      else
+        arg.to_s.to_i
+      end
     end
   end
 end

data/lib/nydp/builtin/to_string.rb

@@ -2,23 +2,12 @@ module Nydp::Builtin
   class ToString
     include Nydp::Builtin::Base, Singleton
 
-    def builtin_invoke vm, args
-      vm.push_arg args.car.to_s
-    end
+    def builtin_call arg=nil ; arg._nydp_to_s ; end
   end
 
   class StringLength
     include Nydp::Builtin::Base, Singleton
 
-    def builtin_invoke vm, args
-      arg = args.car
-      val = case arg
-            when String
-              arg.length
-            else
-              0
-            end
-      vm.push_arg val
-    end
+    def builtin_call arg ; arg._nydp_to_s.length ; end
   end
 end

data/lib/nydp/builtin/type_of.rb

@@ -1,21 +1,15 @@
 class Nydp::Builtin::TypeOf
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke_1 vm, a0
-    typename = if a0.respond_to?(:nydp_type)
-                 a0.nydp_type.to_sym
-               elsif a0.is_a? Numeric
-                 :number
-               else
-                 "ruby/#{a0.class.name}".to_sym
-               end
-
-    type = Nydp::Symbol.mk(typename, vm.ns)
-
-    vm.push_arg(type || Nydp::NIL)
-  end
-
-  def builtin_invoke vm, args
-    builtin_invoke_1 vm, args.car
+  def builtin_call arg
+    if arg == nil
+      nil
+    elsif arg.respond_to?(:nydp_type)
+      arg.nydp_type.to_sym
+    elsif arg.is_a? Numeric
+      :number
+    else
+      "ruby/#{arg.class.name}".to_sym
+    end
   end
 end

data/lib/nydp/builtin/vm_info.rb

@@ -1,15 +1,7 @@
 class Nydp::Builtin::VmInfo
   include Nydp::Builtin::Base, Singleton
 
-  VMINFO_NS    = { }
-  CONTEXTS     = Nydp::Symbol.mk :contexts,     VMINFO_NS
-  INSTRUCTIONS = Nydp::Symbol.mk :instructions, VMINFO_NS
-  ARGS         = Nydp::Symbol.mk :args,         VMINFO_NS
-
-  def builtin_invoke vm, args
-    context_count     = Nydp::Pair.new CONTEXTS,     vm.contexts.size
-    instruction_count = Nydp::Pair.new INSTRUCTIONS, vm.instructions.size
-    arg_count         = Nydp::Pair.new ARGS,         vm.args.size
-    vm.push_arg Nydp::Pair.from_list [context_count, instruction_count, arg_count]
+  def builtin_call *args
+    nil
   end
 end

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}" }