nydp 0.4.2 → 0.5.1

data/lib/nydp/helper.rb

@@ -1,7 +1,39 @@
 module Nydp
   module AutoWrap
-    def _nydp_wrapper ; self ; end
-    def to_ruby       ; self ; end
+    # include this and be sure to either override #_nydp_ok? or #_nydp_whitelist
+    # #_nydp_whitelist should return a list of accessor (zero-arg) methods which are safe for nydp to invoke
+    # #_nydp_procify should return a list of methods that can be exposed to script code.
+    #
+    # class Blub
+    #   _nydp_procs << :blubme
+    #   def blubme where, when
+    #     puts "blubme #{where}, #{when}"
+    #   end
+    # end
+    #
+    # in nydp, if blub is an instance of Blub:
+    #
+    # (blub.blubme "here" "now")
+    #
+    # prints
+    #
+    # blubme here, now
+    #
+    def _nydp_wrapper                 ; self                                     ; end
+    def _nydp_ok?              method ; _nydp_whitelist.include? method          ; end
+    def _nydp_procify?         method ; _nydp_procs.include? method              ; end # override to allow returning Method instances for given method name
+    def _nydp_get                 key ; _nydp_safe_send(key.to_s.as_method_name) ; end
+    def to_ruby                       ; self                                     ; end
+    def _nydp_safe_send meth, *args
+      return send meth, *args if _nydp_ok?(meth)
+      return method(meth)     if _nydp_procify?(meth)
+    end
+  end
+
+  class Struct < ::Struct
+    include AutoWrap
+    def _nydp_whitelist ; members ; end
+    def _nydp_procs     ; []      ; end
   end
 
   module Converter
@@ -51,7 +83,7 @@ module Nydp
 
     def literal? expr
       case expr
-      when String, Float, Integer, Fixnum, Nydp::Symbol, Nydp::StringAtom, Nydp::Truth, Nydp::Nil
+      when String, Float, Integer, Integer, Nydp::Symbol, Nydp::Truth, Nydp::Nil
         true
       else
         false

data/lib/nydp/interpreted_function.rb

@@ -5,8 +5,8 @@ require 'nydp/closure'
 module Nydp
   class PopArg
     def self.execute vm ; vm.args.pop ; end
-    def self.to_s       ; ""         ; end
-    def self.inspect    ; "#pop_arg" ; end
+    def self.to_s       ; ""          ; end
+    def self.inspect    ; "#pop_arg"  ; end
   end
 
   class InterpretedFunction
@@ -16,42 +16,22 @@ module Nydp
 
     attr_accessor :arg_names, :body, :context_builder
 
-    def invoke_1 vm, parent_context
-      vm.push_instructions self.body, set_args_0(parent_context)
-    end
-
-    def invoke_2 vm, parent_context, arg
-      vm.push_instructions self.body, set_args_1(parent_context, arg)
-    end
-
-    def invoke_3 vm, parent_context, arg_0, arg_1
-      vm.push_instructions self.body, set_args_2(parent_context, arg_0, arg_1)
-    end
-
-    def invoke_4 vm, parent_context, arg_0, arg_1, arg_2
-      vm.push_instructions self.body, set_args_3(parent_context, arg_0, arg_1, arg_2)
-    end
-
-    def invoke vm, parent_context, arg_values
-      vm.push_instructions self.body, set_args(parent_context, arg_values)
-    end
-
-    def setup_context context, names, values
-      if pair? names
-        context.set names.car, values.car
-        setup_context context, names.cdr, values.cdr
-      elsif NIL != names
-        context.set names, values
-      end
+    def lexical_reach n
+      body.map { |b| b.lexical_reach(n - 1)  }.max
     end
 
     def self.build arg_list, body, bindings
       my_params = { }
       index_parameters arg_list, my_params
-      ifn = Nydp::InterpretedFunction.new
+      body = compile_body body, cons(my_params, bindings), []
+      reach = body.map { |b| b.lexical_reach(-1)  }.max
+
+      ifn_klass     = reach >= 0 ? InterpretedFunctionWithClosure : InterpretedFunctionWithoutClosure
+      ifn           = ifn_klass.new
       ifn.arg_names = arg_list
+      ifn.body      = body
+
       ifn.extend Nydp::LexicalContextBuilder.select arg_list
-      ifn.body = compile_body body, cons(my_params, bindings), []
       ifn
     end
 
@@ -62,6 +42,11 @@ module Nydp
       if Nydp::NIL.is? rest
         return Pair.from_list(instructions)
       else
+        # PopArg is necessary because each expression pushes an arg onto the arg stack.
+        # we only need to keep the arg pushed by the last expression in a function
+        # so we need the following line in order to remove unwanted args from the stack.
+        # Each expression at some executes vm.push_arg(thing)
+        # TODO find a more intelligent way to do this, eg change the meaning of vm or of push_arg in the expression vm.push_arg(thing)
         instructions << PopArg
         compile_body rest, bindings, instructions
       end
@@ -76,19 +61,62 @@ module Nydp
       end
     end
 
-    def execute vm
-      # TODO do not create a new Closure if this function does not refer to it
-      #      - including top-level function definitions
-      #      - and any other function that does not refer to any lexically-bound outer variable
-      #      - for example (fn (x) (* x x)) in (map λx(* x x) things) does not need a closure, because
-      #        the function does not refer to any lexical variable outside itself.
-      vm.push_arg Closure.new(self, vm.current_context)
-    end
-
     def nydp_type ; "fn" ; end
     def inspect   ; to_s ; end
     def to_s
       "(fn #{arg_names.inspect} #{body.map { |b| b.inspect}.join(' ')})"
     end
   end
+
+  class InterpretedFunctionWithClosure < InterpretedFunction
+    def invoke_1 vm, ctx
+      vm.push_instructions self.body, set_args_0(ctx)
+    end
+
+    def invoke_2 vm, ctx, arg
+      vm.push_instructions self.body, set_args_1(ctx, arg)
+    end
+
+    def invoke_3 vm, ctx, arg_0, arg_1
+      vm.push_instructions self.body, set_args_2(ctx, arg_0, arg_1)
+    end
+
+    def invoke_4 vm, ctx, arg_0, arg_1, arg_2
+      vm.push_instructions self.body, set_args_3(ctx, arg_0, arg_1, arg_2)
+    end
+
+    def invoke vm, ctx, arg_values
+      vm.push_instructions self.body, set_args(ctx, arg_values)
+    end
+
+    def execute vm
+      vm.push_arg Closure.new(self, vm.current_context)
+    end
+  end
+
+  class InterpretedFunctionWithoutClosure < InterpretedFunction
+    def invoke_1 vm
+      vm.push_instructions self.body, set_args_0(vm.current_context)
+    end
+
+    def invoke_2 vm, arg
+      vm.push_instructions self.body, set_args_1(vm.current_context, arg)
+    end
+
+    def invoke_3 vm, arg_0, arg_1
+      vm.push_instructions self.body, set_args_2(vm.current_context, arg_0, arg_1)
+    end
+
+    def invoke_4 vm, arg_0, arg_1, arg_2
+      vm.push_instructions self.body, set_args_3(vm.current_context, arg_0, arg_1, arg_2)
+    end
+
+    def invoke vm, arg_values
+      vm.push_instructions self.body, set_args(vm.current_context, arg_values)
+    end
+
+    def execute vm
+      vm.push_arg self
+    end
+  end
 end

data/lib/nydp/literal.rb

@@ -18,7 +18,7 @@ module Nydp
     def nydp_type ; :literal            ; end
     def inspect   ; @expression.inspect ; end
     def to_s      ; @expression.to_s    ; end
-    def to_ruby   ; n2r @expression ; end
+    def to_ruby   ; n2r @expression     ; end
 
     def coerce _
       [_, expression]

data/lib/nydp/pair.rb

@@ -16,7 +16,8 @@ class Nydp::Pair
   def cddr       ; cdr.cdr                                    ; end
   def car= thing ; @car = thing ; @_hash = nil                ; end
   def cdr= thing ; @cdr = thing ; @_hash = nil                ; end
-  def hash       ; @_hash ||= (car.hash + cdr.hash)           ; end
+  # def hash       ; @_hash ||= (car.hash + cdr.hash)           ; end
+  def hash       ; (car.hash + cdr.hash)                      ; end # can't cache hash of symbol, breaks when unmarshalling
   def eql? other ; self == other                              ; end
   def copy       ; cons(car, cdr.copy)                        ; end
   def +    other ; copy.append other                          ; end
@@ -24,12 +25,28 @@ class Nydp::Pair
   def inspect    ; "(#{inspect_rest})"                        ; end
   def &    other ; self.class.from_list((Set.new(self) & other).to_a)           ; end
   def |    other ; self.class.from_list((Set.new(self) | other).to_a)           ; end
+  def -    other ; self.class.from_list((Set.new(self) - other).to_a)           ; end
   def proper?    ; Nydp::NIL.is?(cdr) || (cdr.is_a?(Nydp::Pair) && cdr.proper?) ; end
 
+  def index_of x
+    if x == car
+      0
+    elsif pair?(cdr)
+      1 + cdr.index_of(x)
+    else
+      nil
+    end
+  end
+
   # returns Array of elements after calling #n2r on each element
-  def to_ruby list=[]
-    list << n2r(car)
-    cdr.is_a?(Nydp::Pair) ? cdr.to_ruby(list) : list
+  def to_ruby list=[], pair=self
+    list << n2r(pair.car)
+    while(pair.cdr.is_a?(Nydp::Pair))
+      pair = pair.cdr
+      list << n2r(pair.car)
+    end
+
+    list
   end
 
   # returns Array of elements as they are
@@ -50,7 +67,7 @@ class Nydp::Pair
     if n >= list.size
       last
     else
-      new list[n], from_list(list, last, n+1)
+      Nydp::Pair.new list[n], from_list(list, last, n+1)
     end
   end
 

data/lib/nydp/parser.rb

@@ -34,8 +34,7 @@ module Nydp
       when /^(.*),@$/
         prefix_list $1, Pair.from_list([sym(:"unquote-splicing"), list])
       else
-        pfx = Nydp::StringAtom.new prefix
-        Pair.from_list([sym(:"prefix-list"), pfx, list])
+        Pair.from_list([sym(:"prefix-list"), prefix, list])
       end
     end
 
@@ -45,15 +44,16 @@ module Nydp
 
     SYMBOL_OPERATORS =
       [
-        [ /%/,      "percent-syntax"    ],
         [ /\!/,     "bang-syntax"       ],
         [ /::/,     "colon-colon-syntax"],
         [ /:/,      "colon-syntax"      ],
         [ /&/,      "ampersand-syntax"  ],
+        [ /%/,      "percent-syntax"    ],
         [ /\./,     "dot-syntax"        ],
         [ /\$/,     "dollar-syntax"     ],
         [ /->/,     "arrow-syntax"      ],
         [ /[=][>]/, "rocket-syntax"     ],
+        [ /@/,      "at-syntax"         ],
       ]
 
     def parse_symbol txt
@@ -73,6 +73,8 @@ module Nydp
         Pair.from_list [sym(:unquote), parse_symbol($1)]
       when /^\.$/
         sym txt
+      when /^@$/
+        sym txt
       else
         SYMBOL_OPERATORS.each do |rgx, name|
           syms = txt.split(rgx, -1)
@@ -108,7 +110,7 @@ module Nydp
       when :symbol
         parse_symbol token.last
       when :comment
-        Pair.from_list [sym(:comment), Nydp::StringAtom.new(token.last)]
+        Pair.from_list [sym(:comment), token.last]
       else
         token.last
       end
@@ -129,14 +131,16 @@ module Nydp
       fragments = [sym(:"string-pieces")]
       string_token = token_stream.next_string_fragment(open_delimiter, close_delimiter, INTERPOLATION_SIGN, INTERPOLATION_ESCAPES)
       raise "unterminated string" if string_token.nil?
-      fragments << Nydp::StringAtom.new(string_token.string, string_token)
+      fragments << string_token.string if string_token.string != ""
       while !(string_token.is_a? StringFragmentCloseToken)
         fragments << expression(token_stream)
         string_token = token_stream.next_string_fragment('', close_delimiter, INTERPOLATION_SIGN, INTERPOLATION_ESCAPES)
-        fragments << Nydp::StringAtom.new(string_token.string, string_token)
+        fragments << string_token.string if string_token.string != ""
       end
 
-      if fragments.size == 2
+      if fragments.size == 1
+        return ""
+      elsif fragments.size == 2
         return fragments[1]
       else
         return Pair.from_list fragments

data/lib/nydp/string_atom.rb

@@ -1,9 +1,8 @@
 module Nydp
   class StringAtom
-    attr_accessor :string, :token
-    def initialize string, token=nil
-      @string, @token = string, token
-    end
+    attr_accessor :string
+
+    def initialize string ; @string = string ; end
 
     def nydp_type  ; :string                                     ; end
     def to_s       ; string                                      ; end

data/lib/nydp/symbol_lookup.rb

@@ -11,17 +11,17 @@ module Nydp
       bindings
     end
 
-    def self.build name, bindings
-      bindings = skip_empty bindings
-      depth = 0
-      while NIL != bindings
-        here = bindings.car
+    def self.build name, original_bindings
+      effective_bindings = skip_empty original_bindings
+      depth    = 0
+      while NIL != effective_bindings
+        here = effective_bindings.car
         if here.key? name
           binding_index = here[name]
-          return ContextSymbol.build(depth, name, binding_index)
+          return ContextSymbol.build(depth, name, binding_index, original_bindings.index_of(here))
         else
           depth += 1
-          bindings = skip_empty bindings.cdr
+          effective_bindings = skip_empty effective_bindings.cdr
         end
       end
       name

data/lib/nydp/tokeniser.rb

@@ -3,7 +3,7 @@ require "strscan"
 module Nydp
   class Tokeniser
     BACKSLASH = /\\/.freeze
-    COMMENT   = /;.*$/.freeze
+    COMMENT   = /;;?.*$/.freeze
     QUOTE     = /"/.freeze
     PIPE      = /\|/.freeze
     LIST_PFX  = /[^\s()]*\(/.freeze
@@ -89,7 +89,7 @@ module Nydp
           @finished = true
           return nil
         elsif comment = s.scan(COMMENT)
-          tok = [:comment, comment[1..-1].strip]
+          tok = [:comment, comment.gsub(/^;;?\s*/, '').strip]
         elsif open_str = s.scan(QUOTE)
           tok = [:string_open_delim, open_str]
         elsif open_sym = s.scan(PIPE)

data/lib/nydp/truth.rb

@@ -3,14 +3,14 @@ require 'singleton'
 module Nydp
   class Truth
     include Singleton
-    def init_with *; Nydp::T          ; end
-    def to_s       ; 't'              ; end
-    def inspect    ; 't[nydp::Truth]' ; end
-    def assign  *_ ; self             ; end
-    def nydp_type  ; :truth           ; end
-    def to_ruby    ; true             ; end
-    def _nydp_get    a ; Nydp::T      ; end
-    def _nydp_set a, v ; Nydp::T      ; end
+    def init_with *; Nydp::T     ; end
+    def to_s       ; 't'         ; end
+    def inspect    ; 't'         ; end
+    def assign  *_ ; self        ; end
+    def nydp_type  ; :truth      ; end
+    def to_ruby    ; true        ; end
+    def _nydp_get    a ; Nydp::T ; end
+    def _nydp_set a, v ; Nydp::T ; end
   end
 
   class Nil
@@ -19,8 +19,8 @@ module Nydp
     def car         ; self          ; end
     def cdr         ; self          ; end
     def size        ; 0             ; end
-    def is?   other ; self == other ; end
-    def isnt? other ; self != other ; end
+    def is?   other ; self.equal? other  ; end
+    def isnt? other ; !self.equal? other ; end
     def to_s        ; ""            ; end
     def + other     ; other         ; end
     def copy        ; self          ; end

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.4.2"
+  VERSION = "0.5.1"
 end

data/lib/nydp/vm.rb

@@ -116,6 +116,13 @@ module Nydp
       end
       msg << "\n"
       msg << "\n"
+      msg << "\nargs stack"
+      msg << "\n================="
+      args.each_with_index do |args, ix|
+        msg << "\args##{ix} :\n#{args}"
+      end
+      msg << "\n"
+      msg << "\n"
       msg
     end
   end

data/nydp.gemspec

@@ -18,8 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency 'rspec', '~> 3.1'
-  spec.add_development_dependency 'rspec_numbering_formatter'
+  spec.add_development_dependency "rake", "~> 12"
+  spec.add_development_dependency 'rspec' #, '~> 3.1'
 end