nydp 0.4.3 → 0.4.5

data/lib/nydp/builtin.rb

@@ -32,13 +32,13 @@ module Nydp::Builtin
       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
 
-
     def handle_error e, *args
       case e
       when Nydp::Error

data/lib/nydp/builtin/abs.rb

@@ -0,0 +1,8 @@
+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
+end

data/lib/nydp/builtin/date.rb

@@ -1,6 +1,15 @@
 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
+    end
+  end
+
   def builtin_invoke_1 vm
     vm.push_arg(Nydp::Date.new Date.today)
   end

data/lib/nydp/builtin/error.rb

@@ -4,6 +4,6 @@ class Nydp::Builtin::Error
   # 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(&:inspect).join("\n"), vm.last_error)
+    raise Nydp::Error.new(args.to_a.map(&:to_s).join("\n"), vm.last_error)
   end
 end

data/lib/nydp/builtin/hash.rb

@@ -2,8 +2,18 @@ require "nydp/hash"
 
 class Nydp::Builtin::Hash
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
+
   def builtin_invoke vm, args
-    vm.push_arg(Nydp::Hash.new)
+    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
 end
 

data/lib/nydp/builtin/ruby_wrap.rb

@@ -0,0 +1,69 @@
+class Nydp::Builtin::RubyWrap
+  @@builtins           = { }
+
+  def self.builtins
+    @@builtins
+  end
+
+  class Coder < Struct.new(:name, :size, :code, :helpers)
+    def msize ; size + 1 ; end
+
+    def arg_mapper
+      case size
+      when 0 ; ""
+      when 1 ; ", a0"
+      when 2 ; ", a0, a1"
+      when 3 ; ", a0, a1, a2"
+      when 4 ; ", a0, a1, a2, a3"
+      else   ; raise "maximum 4 arguments!"
+      end
+    end
+
+    def to_ruby
+      generic_code = code.
+                       gsub(/a0/, "args.car").
+                       gsub(/a1/, "args.cdr.car").
+                       gsub(/a2/, "args.cdr.cdr.car").
+                       gsub(/a3/, "args.cdr.cdr.cdr.car")
+      <<CODE
+class #{name}
+  include Nydp::Builtin::Base, Singleton#{helpers}
+
+  def builtin_invoke_#{msize} vm#{ arg_mapper }
+    vm.push_arg(#{code})
+  end
+
+  def builtin_invoke vm, args
+    vm.push_arg(#{generic_code})
+  end
+end
+CODE
+    end
+  end
+
+  def self.const_missing const
+    coder = @@builtins[const]
+    coder ? class_eval(coder.to_ruby) : super
+    const_get const
+  end
+
+  class WrapperBuilder
+    def initialize default_helpers
+      @default_helpers = default_helpers.to_s.strip != "" ? ", #{default_helpers}" : ""
+    end
+
+    def build name, args, code, helpers=""
+      extra_helpers = helpers.to_s.strip != "" ? ", #{helpers}" : ""
+      Nydp::Builtin::RubyWrap.builtins[name.to_sym] = Coder.new(name.to_sym, args, code, "#{@default_helpers}#{extra_helpers}")
+    end
+  end
+
+  def self.builder includes
+    WrapperBuilder.new(includes)
+  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 })
+end

data/lib/nydp/builtin/string_pad_left.rb

@@ -0,0 +1,7 @@
+class Nydp::Builtin::StringPadLeft
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke_4 vm, str, len, padding
+    vm.push_arg Nydp::StringAtom.new str.to_s.rjust len, padding.to_s
+  end
+end

data/lib/nydp/builtin/string_pad_right.rb

@@ -0,0 +1,7 @@
+class Nydp::Builtin::StringPadRight
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke_4 vm, str, len, padding
+    vm.push_arg Nydp::StringAtom.new str.to_s.ljust len, padding.to_s
+  end
+end

data/lib/nydp/builtin/type_of.rb

@@ -1,18 +1,21 @@
 class Nydp::Builtin::TypeOf
   include Nydp::Builtin::Base, Singleton
 
-  def builtin_invoke vm, args
-    arg = args.car
-    typename = if arg.respond_to?(:nydp_type)
-                 arg.nydp_type.to_sym
-               elsif arg.is_a? Numeric
+  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/#{arg.class.name}".to_sym
+                 "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
+  end
 end

data/lib/nydp/closure.rb

@@ -4,9 +4,6 @@ module Nydp
 
     def initialize ifn, context
       @ifn, @context = ifn, context
-      # TODO don't create a closure where it's not needed (zero_arg functions), use parent context instead
-      # TODO see SymbolLookup for how to ensure variable references stay on track
-      # TODO see InterpretedFunction for where to not instantiate new LexicalContext
     end
 
     def invoke_1 vm

data/lib/nydp/cond.rb

@@ -6,6 +6,10 @@ module Nydp
       @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
@@ -13,6 +17,7 @@ module Nydp
     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
@@ -27,6 +32,10 @@ module Nydp
       @condition, @conditional = cond, cons(ExecuteConditionalInstruction.new(when_true, when_false))
     end
 
+    def lexical_reach n
+      [@condition.lexical_reach(n), @conditional.car.lexical_reach(n)].max
+    end
+
     def execute vm
       vm.push_ctx_instructions conditional
       condition.execute vm
@@ -35,6 +44,7 @@ module Nydp
     def inspect
       "cond:#{condition.inspect}:#{conditional.inspect}"
     end
+
     def to_s
       "(cond #{condition.to_s} #{conditional.to_s})"
     end
@@ -57,7 +67,7 @@ module Nydp
           new(cond, when_true, when_false)
         end
       else
-        raise "can't compile Cond: #{expr.inspect}"
+        raise "can't compile Cond: #{expressions.inspect}"
       end
     end
   end
@@ -70,6 +80,10 @@ module Nydp
       @condition, @when_true, @when_false = cond, when_true, when_false
     end
 
+    def lexical_reach n
+      [@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 to_s    ; "(cond #{@condition.to_s} #{@when_true.to_s} #{@when_false.to_s})" ; end
   end
@@ -80,6 +94,14 @@ module Nydp
       vm.push_ctx_instructions (truth ? @when_true : @when_false)
     end
 
+    def lexical_reach n
+      cr = @condition.lexical_reach(n)
+      ct = @when_true.car.lexical_reach(n)
+      cf = @when_false.car.lexical_reach(n)
+
+      [cr, ct, cf].max
+    end
+
     def self.build cond, when_true, when_false
       tsig       = sig(when_true)
       fsig       = sig(when_false)

data/lib/nydp/context_symbol.rb

@@ -25,12 +25,18 @@ module Nydp
                   end
 
       code = <<-KLASS
-        def initialize name
-          @name = name
+        def initialize name, lexical_depth
+          @name, @lexical_depth = name, lexical_depth
+        end
+
+        def lexical_reach n
+          @lexical_depth + n
         end
 
         def value ctx
           ctx#{getctx}.#{at_index} || Nydp::NIL
+        rescue
+          raise "failed looking up \#{@name.inspect} (\#{@name.class.name})"
         end
 
         def assign value, ctx
@@ -45,16 +51,18 @@ module Nydp
 
         def depth   ; #{depth}                               ; end
         def inspect ; to_s                                   ; end
-        def to_s    ; "[#{depth}##{binding_index}]\#{@name}" ; end
+        def to_s    ; "[#{depth}##{binding_index}#\#{@lexical_depth}]\#{@name}" ; end
       KLASS
 
       const_set name, Class.new(Nydp::ContextSymbol) {
-        eval code
+        eval code, binding, name.to_s, 0
       }
     end
 
-    def self.build depth, name, binding_index
-      const_get(:"ContextSymbol_#{depth}_#{binding_index}").new(name)
+    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}"
     end
   end
 end

data/lib/nydp/core.rb

@@ -25,9 +25,10 @@ module Nydp
     end
 
     def setup ns
-      Symbol.mk(:cons,  ns).assign(Nydp::Builtin::Cons.instance)
-      Symbol.mk(:car,   ns).assign(Nydp::Builtin::Car.instance)
-      Symbol.mk(:cdr,   ns).assign(Nydp::Builtin::Cdr.instance)
+      Symbol.mk(:cons         , ns).assign(Nydp::Builtin::RubyWrap::Cons.instance)
+      Symbol.mk(:car          , ns).assign(Nydp::Builtin::RubyWrap::Car.instance)
+      Symbol.mk(:cdr          , ns).assign(Nydp::Builtin::RubyWrap::Cdr.instance)
+
       Symbol.mk(:+,     ns).assign(Nydp::Builtin::Plus.instance)
       Symbol.mk(:-,     ns).assign(Nydp::Builtin::Minus.instance)
       Symbol.mk(:*,     ns).assign(Nydp::Builtin::Times.instance)
@@ -47,35 +48,38 @@ module Nydp
       Symbol.mk(:nil,   ns).assign Nydp::NIL
       Symbol.mk(:rand,  ns).assign Nydp::Builtin::Rand.instance
       Symbol.mk(:sort,  ns).assign Nydp::Builtin::Sort.instance
+      Symbol.mk(:abs,   ns).assign Nydp::Builtin::Abs.instance
       Symbol.mk(:sqrt,  ns).assign Nydp::Builtin::Sqrt.instance
       Symbol.mk(:t,     ns).assign Nydp::T
       Symbol.mk(:sym,   ns).assign Nydp::Builtin::Sym.instance
-      Symbol.mk(:ensuring,      ns).assign(Nydp::Builtin::Ensuring.instance)
-      Symbol.mk(:inspect,       ns).assign(Nydp::Builtin::Inspect.instance)
-      Symbol.mk(:comment,       ns).assign(Nydp::Builtin::Comment.instance)
-      Symbol.mk("handle-error"   , ns).assign(Nydp::Builtin::HandleError.instance)
-      Symbol.mk("parse-in-string", ns).assign(Nydp::Builtin::ParseInString.instance)
-      Symbol.mk("random-string"  , ns).assign(Nydp::Builtin::RandomString.instance)
-      Symbol.mk("to-string"      , ns).assign(Nydp::Builtin::ToString.instance)
-      Symbol.mk("string-length"  , ns).assign(Nydp::Builtin::StringLength.instance)
-      Symbol.mk("string-replace" , ns).assign(Nydp::Builtin::StringReplace.instance)
-      Symbol.mk("string-match"   , ns).assign(Nydp::Builtin::StringMatch.instance)
-      Symbol.mk("string-split"   , ns).assign(Nydp::Builtin::StringSplit.instance)
-      Symbol.mk("time"           , ns).assign(Nydp::Builtin::Time.instance)
-      Symbol.mk("thread-locals"  , ns).assign(Nydp::Builtin::ThreadLocals.instance)
-      Symbol.mk("type-of",      ns).assign(Nydp::Builtin::TypeOf.instance)
-      Symbol.mk(:"eq?",         ns).assign(Nydp::Builtin::IsEqual.instance)
-      Symbol.mk(:"cdr-set",     ns).assign(Nydp::Builtin::CdrSet.instance)
-      Symbol.mk(:"hash-get",    ns).assign(Nydp::Builtin::HashGet.instance)
-      Symbol.mk(:"hash-set",    ns).assign(Nydp::Builtin::HashSet.instance)
-      Symbol.mk(:"hash-keys",   ns).assign(Nydp::Builtin::HashKeys.instance)
-      Symbol.mk(:"hash-key?",   ns).assign(Nydp::Builtin::HashKeyPresent.instance)
-      Symbol.mk(:"hash-merge",  ns).assign(Nydp::Builtin::HashMerge.instance)
-      Symbol.mk(:"hash-slice",  ns).assign(Nydp::Builtin::HashSlice.instance)
-      Symbol.mk(:"vm-info",     ns).assign Nydp::Builtin::VmInfo.instance
-      Symbol.mk(:"pre-compile" , ns).assign Nydp::Builtin::PreCompile.instance
-      Symbol.mk(:"script-run"  , ns).assign Nydp::Builtin::ScriptRun.instance
-      Symbol.mk(:"**"          , ns).assign Nydp::Builtin::MathPower.instance
+      Symbol.mk(:ensuring          , ns).assign(Nydp::Builtin::Ensuring.instance)
+      Symbol.mk(:inspect           , ns).assign(Nydp::Builtin::Inspect.instance)
+      Symbol.mk(:comment           , ns).assign(Nydp::Builtin::Comment.instance)
+      Symbol.mk("handle-error"     , ns).assign(Nydp::Builtin::HandleError.instance)
+      Symbol.mk("parse-in-string"  , ns).assign(Nydp::Builtin::ParseInString.instance)
+      Symbol.mk("random-string"    , ns).assign(Nydp::Builtin::RandomString.instance)
+      Symbol.mk("to-string"        , ns).assign(Nydp::Builtin::ToString.instance)
+      Symbol.mk("string-length"    , ns).assign(Nydp::Builtin::StringLength.instance)
+      Symbol.mk("string-replace"   , ns).assign(Nydp::Builtin::StringReplace.instance)
+      Symbol.mk("string-match"     , ns).assign(Nydp::Builtin::StringMatch.instance)
+      Symbol.mk("string-split"     , ns).assign(Nydp::Builtin::StringSplit.instance)
+      Symbol.mk("string/pad-left"  , ns).assign(Nydp::Builtin::StringPadLeft.instance)
+      Symbol.mk("string/pad-right" , ns).assign(Nydp::Builtin::StringPadRight.instance)
+      Symbol.mk("time"             , ns).assign(Nydp::Builtin::Time.instance)
+      Symbol.mk("thread-locals"    , ns).assign(Nydp::Builtin::ThreadLocals.instance)
+      Symbol.mk("type-of"          , ns).assign(Nydp::Builtin::TypeOf.instance)
+      Symbol.mk(:"eq?"             , ns).assign(Nydp::Builtin::IsEqual.instance)
+      Symbol.mk(:"cdr-set"         , ns).assign(Nydp::Builtin::CdrSet.instance)
+      Symbol.mk(:"hash-get"        , ns).assign(Nydp::Builtin::HashGet.instance)
+      Symbol.mk(:"hash-set"        , ns).assign(Nydp::Builtin::HashSet.instance)
+      Symbol.mk(:"hash-keys"       , ns).assign(Nydp::Builtin::HashKeys.instance)
+      Symbol.mk(:"hash-key?"       , ns).assign(Nydp::Builtin::HashKeyPresent.instance)
+      Symbol.mk(:"hash-merge"      , ns).assign(Nydp::Builtin::HashMerge.instance)
+      Symbol.mk(:"hash-slice"      , ns).assign(Nydp::Builtin::HashSlice.instance)
+      Symbol.mk(:"vm-info"         , ns).assign Nydp::Builtin::VmInfo.instance
+      Symbol.mk(:"pre-compile"     , ns).assign Nydp::Builtin::PreCompile.instance
+      Symbol.mk(:"script-run"      , ns).assign Nydp::Builtin::ScriptRun.instance
+      Symbol.mk(:"**"              , ns).assign Nydp::Builtin::MathPower.instance
       Symbol.mk(:"⌊"               , ns).assign Nydp::Builtin::MathFloor.instance
       Symbol.mk(:"math-floor"      , ns).assign Nydp::Builtin::MathFloor.instance
       Symbol.mk(:"⌈"               , ns).assign Nydp::Builtin::MathCeiling.instance

data/lib/nydp/core_ext.rb

@@ -1,8 +1,9 @@
 class Object
-  def _nydp_get    a ; raise "_nydp_get : not gettable: #{a.inspect} on #{self.class.name}" ; end
-  def _nydp_set a, v ; raise "_nydp_get : not settable: #{a.inspect} on #{self.class.name}" ; end
-  def _nydp_keys     ; []   ; end
-  def _nydp_wrapper  ; self ; end
+  def _nydp_get     a ; raise "_nydp_get : not gettable: #{a.inspect} on #{self.class.name}" ; end
+  def _nydp_set  a, v ; raise "_nydp_get : not settable: #{a.inspect} on #{self.class.name}" ; end
+  def _nydp_keys      ; []   ; end
+  def _nydp_wrapper   ; self ; end
+  def lexical_reach n ; n    ; end
 end
 
 class NilClass

data/lib/nydp/date.rb

@@ -22,15 +22,15 @@ module Nydp
     def to_ruby   ; ruby_date                                        ; end
     def inspect   ; ruby_date.inspect                                ; end
     def nydp_type ; :date                                            ; end
-    def +     int ; r2n(ruby_date + int)                             ; end
     def >   other ; is_date?(other) && ruby_date > other.ruby_date   ; end
     def <   other ; is_date?(other) && ruby_date < other.ruby_date   ; end
     def ==  other ; is_date?(other) && ruby_date == other.ruby_date  ; end
     def <=> other ; is_date?(other) && ruby_date <=> other.ruby_date ; end
     def eql?    d ; self == d                                        ; end
     def hash      ; ruby_date.hash                                   ; end
-    def is_date? other ; other.is_a? Nydp::Date                                       ; end
-    def -        other ; r2n(ruby_date - (is_date?(other) ? other.ruby_date : other)) ; end
+    def is_date? other ; other.is_a? Nydp::Date                                               ; end
+    def -        other ; r2n(ruby_date - (is_date?(other) ? other.ruby_date : other))         ; end
+    def +          int ; int.is_a?(Fixnum) ? r2n(ruby_date + int) : r2n(change(*int.to_ruby)) ; end
 
     @@pass_through = %i{ monday? tuesday? wednesday? thursday? friday? saturday? sunday? }
     @@keys = Set.new %i{
@@ -46,15 +46,15 @@ module Nydp
     def day                y, m, d, w ; d ; end
     def week_day           y, m, d, w ; w ; end
 
-    def last_year          y, m, d, w ; build(y - 1, m, d)           ; end
+    def last_year          y, m, d, w ; ruby_date.prev_year          ; end
     def next_year          y, m, d, w ; ruby_date.next_year          ; end
     def beginning_of_year  y, m, d, w ; build(y, 1, 1)               ; end
     def end_of_year        y, m, d, w ; build(y, 12, 31)             ; end
 
-    def last_month         y, m, d, w ; build(y, m - 1, d)           ; end
+    def last_month         y, m, d, w ; ruby_date.prev_month         ; end
     def next_month         y, m, d, w ; ruby_date.next_month         ; end
     def beginning_of_month y, m, d, w ; build(y, m, 1)               ; end
-    def end_of_month       y, m, d, w ; build(y, m, 31)              ; end
+    def end_of_month       y, m, d, w ; beginning_of_month(*splat(ruby_date.next_month)) - 1 ; end
 
     def last_week          y, m, d, w ; ruby_date - 7                ; end
     def next_week          y, m, d, w ; ruby_date + 7                ; end
@@ -75,17 +75,17 @@ module Nydp
       class_eval "def #{n} * ; ruby_date.#{n} ; end"
     end
 
-    def _nydp_keys               ; @@keys.to_a                                            ; end
-    def dispatch key, y, m, d, w ; self.send(key, y, m, d, w) if _nydp_keys.include?(key) ; end
-
-    def _nydp_get key
-      key = key.to_s.gsub(/-/, '_').to_sym
-      y = ruby_date.year
-      m = ruby_date.month
-      d = ruby_date.day
-      w = ruby_date.wday
-
-      r2n(dispatch(key, y, m, d, w))
+    def _nydp_keys                ; @@keys.to_a                                                              ; end
+    def dispatch  key, y, m, d, w ; self.send(key, y, m, d, w) if _nydp_keys.include?(key)                   ; end
+    def splat                date ; [date.year, date.month, date.day, date.wday]                             ; end
+    def lookup          key, date ; r2n(dispatch(key.to_s.gsub(/-/, '_').to_sym, *splat(date)))              ; end
+    def _nydp_get             key ; lookup key, ruby_date                                                    ; end
+    def change       amount, attr
+      if    attr == :day   ; (ruby_date + amount)
+      elsif attr == :week  ; (ruby_date + (7 * amount))
+      elsif attr == :month ; (ruby_date >> amount)
+      elsif attr == :year  ; (ruby_date >> (12 * amount))
+      end
     end
   end
 end