nydp 0.4.1 → 0.5.0

data/lib/nydp/builtin/inspect.rb

@@ -2,6 +2,6 @@ class Nydp::Builtin::Inspect
   include Nydp::Builtin::Base, Singleton
 
   def builtin_invoke vm, args
-    vm.push_arg Nydp::StringAtom.new(args.car.inspect)
+    vm.push_arg args.car.inspect
   end
 end

data/lib/nydp/builtin/plus.rb

@@ -10,13 +10,21 @@ class Nydp::Builtin::Plus
     vm.push_arg case args.car
                 when Nydp::Pair
                   sum(args, Nydp::NIL)
-                when String, Nydp::StringAtom
-                  sum(args, Nydp::StringAtom.new(""))
+                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 sum args, accum
     while args && !Nydp::NIL.is?(args)
       accum += args.car

data/lib/nydp/builtin/random_string.rb

@@ -5,7 +5,7 @@ class Nydp::Builtin::RandomString
 
   def builtin_invoke vm, args
     length = args.car unless Nydp::NIL.is?(args)
-    s = (0...(length || 10)).map { RANDOM_CHARS[rand(RANDOM_CHARS.size)] }.join
-    vm.push_arg Nydp::StringAtom.new s
+    s = (0...(length || 10)).inject("") {|a,i| a << RANDOM_CHARS[rand(RANDOM_CHARS.size)] }
+    vm.push_arg s
   end
 end

data/lib/nydp/builtin/{car.rb → regexp.rb}

@@ -1,7 +1,7 @@
-class Nydp::Builtin::Car
+class Nydp::Builtin::Regexp
   include Nydp::Builtin::Base, Singleton
 
   def builtin_invoke vm, args
-    vm.push_arg args.car.car
+    vm.push_arg Regexp.compile(args.car.to_s)
   end
 end

data/lib/nydp/builtin/ruby_wrap.rb

@@ -0,0 +1,72 @@
+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"
+      when 5 ; ", a0, a1, a2, a3, a4"
+      else   ; raise "maximum 5 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").
+                       gsub(/a4/, "args.cdr.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 }                        )
+  core_builder.build(:Log , 1, %{ r2n Nydp.logger.info(a0.to_s) } )
+end

data/lib/nydp/builtin/string_match.rb

@@ -10,8 +10,8 @@ class Nydp::Builtin::StringMatch
 
     if match
       result             = Nydp::Hash.new
-      result[kmatch]     = Nydp::StringAtom.new match.to_s
-      result[kcaptures]  = Nydp::Pair.from_list match.captures.map { |cap| Nydp::StringAtom.new cap.to_s }
+      result[kmatch]     = match.to_s
+      result[kcaptures]  = Nydp::Pair.from_list match.captures.map { |cap| cap.to_s }
     else
       result             = Nydp::NIL
     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 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 str.to_s.ljust(len, padding.to_s)
+  end
+end

data/lib/nydp/builtin/string_replace.rb

@@ -7,6 +7,6 @@ class Nydp::Builtin::StringReplace
     target    = args.cdr.cdr.car.to_s
     result    = target.to_s.gsub to_remove, to_insert
 
-    vm.push_arg Nydp::StringAtom.new result
+    vm.push_arg result
   end
 end

data/lib/nydp/builtin/string_split.rb

@@ -3,10 +3,11 @@ class Nydp::Builtin::StringSplit
 
   def builtin_invoke vm, args
     target    = args.car.to_s
-    separator = args.cdr.car.to_s
+    separator = args.cdr.car
+    separator = separator.to_s unless separator.is_a? Regexp
+
     result    = target.split separator, -1
-    list      = result.map { |s| Nydp::StringAtom.new s }
 
-    vm.push_arg Nydp::Pair.from_list list
+    vm.push_arg Nydp::Pair.from_list result
   end
 end

data/lib/nydp/builtin/to_integer.rb

@@ -0,0 +1,23 @@
+module Nydp::Builtin
+  class ToInteger
+    include Nydp::Builtin::Base, Singleton
+
+    def builtin_invoke_2 vm, 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
+    end
+  end
+end

data/lib/nydp/builtin/to_string.rb

@@ -3,14 +3,7 @@ module Nydp::Builtin
     include Nydp::Builtin::Base, Singleton
 
     def builtin_invoke vm, args
-      arg = args.car
-      val = case arg.class
-            when Nydp::StringAtom
-              arg
-            else
-              Nydp::StringAtom.new arg.to_s
-            end
-      vm.push_arg val
+      vm.push_arg args.car.to_s
     end
   end
 
@@ -20,7 +13,7 @@ module Nydp::Builtin
     def builtin_invoke vm, args
       arg = args.car
       val = case arg
-            when Nydp::StringAtom
+            when String
               arg.length
             else
               0

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,11 @@ 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(:log          , ns).assign(Nydp::Builtin::RubyWrap::Log.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,34 +49,40 @@ 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(:"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("regexp"           , ns).assign(Nydp::Builtin::Regexp.instance)
+      Symbol.mk("to-string"        , ns).assign(Nydp::Builtin::ToString.instance)
+      Symbol.mk("to-integer"       , ns).assign(Nydp::Builtin::ToInteger.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