nydp 0.3.0 → 0.4.0

data/lib/nydp/compiler.rb

@@ -40,7 +40,7 @@ module Nydp
     def self.compile_pair expression, bindings
       key = expression.car
       if sym?(key, :cond)
-        Cond.build expression.cdr, bindings
+        Cond.build expression.cdr, bindings # todo: replace with function? (cond x (fn () iftrue) (fn () iffalse)) -->> performance issues, creating two closures for every cond invocation
       elsif sym?(key, :quote)
         Literal.build expression.cadr, bindings
       elsif sym?(key, :assign)

data/lib/nydp/cond.rb

@@ -28,8 +28,7 @@ module Nydp
     end
 
     def execute vm
-      vm.instructions.push conditional
-      vm.contexts.push vm.current_context
+      vm.push_ctx_instructions conditional
       condition.execute vm
     end
 
@@ -78,8 +77,7 @@ module Nydp
   class Cond_LEX < CondBase
     def execute vm
       truth = !Nydp::NIL.is?(@condition.value vm.current_context)
-      vm.instructions.push (truth ? @when_true : @when_false)
-      vm.contexts.push vm.current_context
+      vm.push_ctx_instructions (truth ? @when_true : @when_false)
     end
 
     def self.build cond, when_true, when_false
@@ -171,8 +169,7 @@ module Nydp
 
   class Cond_SYM < CondBase
     def execute vm
-      vm.instructions.push (Nydp::NIL.is?(@condition.value) ? @when_false : @when_true)
-      vm.contexts.push vm.current_context
+      vm.push_ctx_instructions (Nydp::NIL.is?(@condition.value) ? @when_false : @when_true)
     end
   end
 end

data/lib/nydp/context_symbol.rb

@@ -1,11 +1,16 @@
 module Nydp
   class ContextSymbol
-    def self.build depth, name, binding_index
-      cname = "ContextSymbol_#{depth}_#{binding_index}"
-
-      existing = const_get(cname) rescue nil
-      return existing.new(name) if existing
+    def self.const_missing const
+      if const.to_s =~ /^ContextSymbol_\d+_\d+$/
+        name          = const.to_s.split(/_/)
+        define_klass(const, name[1].to_i, name[2].to_i)
+        const_get const
+      else
+        super(const)
+      end
+    end
 
+    def self.define_klass name, depth, binding_index
       getctx = ([".parent"] * depth).join
       at_index = if binding_index < 10
                    "at_#{binding_index}"
@@ -19,34 +24,37 @@ module Nydp
                     "set_index(#{binding_index}, value)"
                   end
 
-      klass = <<KLASS
-class #{cname} < Nydp::ContextSymbol
-  def initialize name
-    @name = name
-  end
-
-  def value ctx
-    ctx#{getctx}.#{at_index} || Nydp::NIL
-  end
-
-  def assign value, ctx
-    ctx#{getctx}.#{set_index}
-  rescue StandardError => e
-    raise "problem in \#{self.class.name}#assign, name is \#{@name}, depth is \#{depth}, index is #{binding_index}"
-  end
-
-  def execute vm
-    vm.push_arg value vm.current_context
-  end
-
-  def depth   ; #{depth}                               ; end
-  def inspect ; to_s                                   ; end
-  def to_s    ; "[#{depth}##{binding_index}]\#{@name}" ; end
-end
-KLASS
+      code = <<-KLASS
+        def initialize name
+          @name = name
+        end
+
+        def value ctx
+          ctx#{getctx}.#{at_index} || Nydp::NIL
+        end
+
+        def assign value, ctx
+          ctx#{getctx}.#{set_index}
+        rescue StandardError => e
+          raise "problem in \#{self.class.name}#assign, name is \#{@name}, depth is \#{depth}, index is #{binding_index}"
+        end
+
+        def execute vm
+          vm.push_arg value vm.current_context
+        end
+
+        def depth   ; #{depth}                               ; end
+        def inspect ; to_s                                   ; end
+        def to_s    ; "[#{depth}##{binding_index}]\#{@name}" ; end
+      KLASS
+
+      const_set name, Class.new(Nydp::ContextSymbol) {
+        eval code
+      }
+    end
 
-      eval klass
-      const_get(cname).new(name)
+    def self.build depth, name, binding_index
+      const_get(:"ContextSymbol_#{depth}_#{binding_index}").new(name)
     end
   end
 end

data/lib/nydp/core.rb

@@ -71,8 +71,14 @@ module Nydp
       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(:"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
+      Symbol.mk(:"math-ceiling", ns).assign Nydp::Builtin::MathCeiling.instance
+      Symbol.mk(:"math-round"  , ns).assign Nydp::Builtin::MathRound.instance
     end
   end
 end

data/lib/nydp/function_invocation.rb

@@ -24,7 +24,7 @@ module Nydp
           raise
         else
           if e.is_a?(NoMethodError) && !f.respond_to?(invoker)
-            raise InvocationFailed.new("#{f} is not a function")
+            raise InvocationFailed.new("#{f.inspect} is not a function: args were #{args.inspect}")
           else
             msg  = args.map { |a| "  #{a.inspect}"}.join("\n")
             msg  =  "failed to execute invocation #{f.inspect}\n#{msg}"
@@ -323,10 +323,8 @@ module Nydp
 
     def execute vm
 ##      Invocation.sig @sig
-      vm.instructions.push function_instruction
-      vm.contexts    .push vm.current_context
-      vm.instructions.push argument_instructions
-      vm.contexts    .push vm.current_context
+      vm.push_ctx_instructions function_instruction
+      vm.push_ctx_instructions argument_instructions
     end
 
     def inspect ; @source.inspect ; end

data/lib/nydp/image_store.rb

@@ -0,0 +1,21 @@
+require 'digest'
+
+module Nydp
+  class ImageStore
+    attr_accessor :store
+
+    def initialize store=nil
+      @store = store
+      FileUtils.mkdir_p(store, mode: 0775) if store
+    end
+
+    def digest          ; Digest::MD5.hexdigest(Nydp.all_files.map { |f| File.read f }.join) ; end
+    def file_name    id ; File.join @store, "#{id}.nydp_image"                               ; end
+    def load?     fname ; File.binread(fname) if File.exists?(fname)                         ; end
+    def load         id ; load?(file_name id) if @store                                      ; end
+    def store id, image ; File.open(file_name(id), "wb") { |f| f.write(image) } if @store    ; end
+    def generate     id ; Marshal.dump(::Nydp.build_nydp).tap { |im| store id, im }          ; end
+    def resurrect    id ; load(id) || generate(id)                                           ; end
+    def get             ; Marshal.load(@image ||= resurrect(digest))                         ; end
+  end
+end

data/lib/nydp/interpreted_function.rb

@@ -10,41 +10,37 @@ module Nydp
   end
 
   class InterpretedFunction
+    NIL = Nydp::NIL
     include Helper
     extend Helper
 
     attr_accessor :arg_names, :body, :context_builder
 
     def invoke_1 vm, parent_context
-      vm.instructions.push self.body
-      vm.contexts.push set_args_0 parent_context
+      vm.push_instructions self.body, set_args_0(parent_context)
     end
 
     def invoke_2 vm, parent_context, arg
-      vm.instructions.push self.body
-      vm.contexts.push set_args_1(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.instructions.push self.body
-      vm.contexts.push set_args_2(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.instructions.push self.body
-      vm.contexts.push set_args_3(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.instructions.push self.body
-      vm.contexts.push set_args(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 Nydp::NIL.isnt? names
+      elsif NIL != names
         context.set names, values
       end
     end
@@ -75,7 +71,7 @@ module Nydp
       if pair? arg_list
         index_parameters arg_list.car, hsh
         index_parameters arg_list.cdr, hsh
-      elsif Nydp::NIL.isnt? arg_list
+      elsif NIL != arg_list
         hsh[arg_list] = hsh.size
       end
     end

data/lib/nydp/lexical_context_builder.rb

@@ -1,6 +1,17 @@
 module Nydp::LexicalContextBuilder
   extend Nydp::Helper
 
+  def self.const_missing(const)
+    if const.to_s =~ /^B_\d+(_Rest)?$/
+      name = const.to_s.split(/_/)
+      size = name[1].to_i
+      name[2] ? build_builder_rest_class(const, size) : build_builder_class(const, size)
+      const_get const
+    else
+      super(const)
+    end
+  end
+
   def self.mklc nexpected
     (nexpected > 0) ? "lc = Nydp::LexicalContext.new lc\n    " : ""
   end
@@ -70,40 +81,20 @@ module Nydp::LexicalContextBuilder
 "
   end
 
-  def self.get_builder_class expected_arg_count
-    name      = "B_#{expected_arg_count}"
-    existing  = const_get(name) rescue nil
-    return name if existing
+  def self.define_module name, code
+    const_set name.to_sym, Module.new { eval code }
+  end
 
+  def self.build_builder_class name, expected_arg_count
     n_methods = (0..3).map { |given| build_set_args_n_method given, expected_arg_count }
     x_method  = build_set_args_method expected_arg_count
-    klass     = <<KLASS
-module #{name}
-#{n_methods.join "\n"}
-#{x_method}
-end
-KLASS
-
-    eval klass
-    name
+    define_module name, "#{n_methods.join "\n"}\n#{x_method}"
   end
 
-  def self.get_builder_rest_class proper_arg_count
-    name      = "B_#{proper_arg_count}_Rest"
-    existing  = const_get(name) rescue nil
-    return name if existing
-
+  def self.build_builder_rest_class name, proper_arg_count
     n_methods = (0..3).map { |given| build_set_args_n_rest_method given, proper_arg_count }
     x_method  = build_set_args_rest_method proper_arg_count
-    klass     = <<KLASS
-module #{name}
-#{n_methods.join "\n"}
-#{x_method}
-end
-KLASS
-
-    eval klass
-    name
+    define_module name, "#{n_methods.join "\n"}\n#{x_method}"
   end
 
   def self.select arg_names
@@ -114,13 +105,6 @@ KLASS
       size   = 0
       proper = Nydp::NIL.is? arg_names
     end
-
-    if proper
-      class_name = get_builder_class size
-    else
-      class_name = get_builder_rest_class size
-    end
-
-    self.const_get(class_name.to_sym)
+    const_get(proper ? :"B_#{size}" : :"B_#{size}_Rest")
   end
 end

data/lib/nydp/pair.rb

@@ -1,4 +1,5 @@
 class Nydp::Pair
+  NIL = Nydp::NIL
   include Nydp::Helper, Enumerable
   extend Nydp::Helper
 
@@ -51,7 +52,7 @@ class Nydp::Pair
   end
 
   def == other
-    Nydp::NIL.isnt?(other) && (other.respond_to? :car) && (self.car == other.car) && (self.cdr == other.cdr)
+    (NIL != other) && (other.respond_to? :car) && (self.car == other.car) && (self.cdr == other.cdr)
   end
 
   def proper?

data/lib/nydp/parser.rb

@@ -121,6 +121,10 @@ module Nydp
     INTERPOLATION_SIGN = /~/
     INTERPOLATION_ESCAPES = { /~\s/ => true, /~~/ => "~" }
 
+    def embedded token_stream
+      string token_stream, "", :eof
+    end
+
     def string token_stream, open_delimiter, close_delimiter
       fragments = [sym(:"string-pieces")]
       string_token = token_stream.next_string_fragment(open_delimiter, close_delimiter, INTERPOLATION_SIGN, INTERPOLATION_ESCAPES)

data/lib/nydp/plugin.rb

@@ -1,12 +1,15 @@
+require 'nydp/image_store'
+
 module Nydp
   PLUGINS = []
+  @@image_store = Nydp::ImageStore.new
 
-  def self.plug_in plugin ; PLUGINS << plugin                   ; end
-  def self.load_rake_tasks; PLUGINS.each &:load_rake_tasks      ; end
-  def self.setup ns;        PLUGINS.each { |plg| plg.setup ns } ; end
-  def self.loadfiles;       PLUGINS.map(&:loadfiles).flatten    ; end
-  def self.testfiles;       PLUGINS.map(&:testfiles).flatten    ; end
-  def self.plugin_names   ; PLUGINS.map(&:name)                 ; end
+  def self.plug_in  plugin ; PLUGINS << plugin                   ; end
+  def self.load_rake_tasks ; PLUGINS.each &:load_rake_tasks      ; end
+  def self.setup        ns ; PLUGINS.each { |plg| plg.setup ns } ; end
+  def self.loadfiles       ; PLUGINS.map(&:loadfiles).flatten    ; end
+  def self.testfiles       ; PLUGINS.map(&:testfiles).flatten    ; end
+  def self.plugin_names    ; PLUGINS.map(&:name)                 ; end
   def self.loadall ns, plugin, files
     vm = VM.new(ns)
     apply_function ns, :"script-run", :"plugin-start", plugin.name if plugin
@@ -20,14 +23,18 @@ module Nydp
     apply_function ns, :"script-run", :"plugin-end", plugin.name if plugin
   end
 
-  def self.build_nydp extra_files=nil, &block
+  def self.all_files ; PLUGINS.each_with_object([]) { |plg, list|  plg.loadfiles.each { |f| list << f } } ; end
+  def self.set_image_store store ; @@image_store = store ; end
+
+  def self.get_nydp ; @@image_store.get ; end
+
+  def self.build_nydp &block
     ns = Namespace.new
     setup(ns)
     PLUGINS.each { |plg|
       loadall ns, plg, plg.loadfiles, &block
       loadall ns, plg, plg.testfiles, &block
     }
-    loadall ns, nil, extra_files, &block if extra_files
     ns
   end
 end

data/lib/nydp/runner.rb

@@ -49,7 +49,7 @@ module Nydp
 
     def compile_and_eval expr
       begin
-        vm.thread Pair.new(Compiler.compile(expr, Nydp::NIL), Nydp::NIL)
+        vm.thread_with_expr Pair.new(Compiler.compile(expr, Nydp::NIL), Nydp::NIL)
       rescue StandardError => e
         raise Nydp::Error, "failed to eval #{expr.inspect}"
       end
@@ -68,8 +68,8 @@ module Nydp
     def initialize vm, ns, stream, printer=nil, name=nil
       super vm, ns, name
       @printer    = printer
-      @parser     = Nydp::Parser.new(ns)
-      @tokens     = Nydp::Tokeniser.new stream
+      @parser     = Nydp.new_parser(ns)
+      @tokens     = Nydp.new_tokeniser stream
     end
 
     def print val

data/lib/nydp/symbol.rb

@@ -1,4 +1,6 @@
 class Nydp::Symbol
+  class Unbound < StandardError ; end
+
   EMPTY = :""
   attr_accessor :name
   attr_reader   :hash
@@ -15,7 +17,7 @@ class Nydp::Symbol
   end
 
   def value context=nil
-    raise Nydp::Error.new("unbound symbol: #{self.inspect}") if @value == nil
+    raise Unbound.new("unbound symbol: #{self.inspect}") if @value == nil
     @value
   end
 

data/lib/nydp/symbol_lookup.rb

@@ -5,7 +5,7 @@ module Nydp
     extend Helper
 
     def self.skip_empty bindings
-      while Nydp::NIL.isnt?(bindings) && bindings.car.empty?
+      while (NIL != bindings) && bindings.car.empty?
         bindings = bindings.cdr
       end
       bindings
@@ -14,7 +14,7 @@ module Nydp
     def self.build name, bindings
       bindings = skip_empty bindings
       depth = 0
-      while Nydp::NIL.isnt? bindings
+      while NIL != bindings
         here = bindings.car
         if here.key? name
           binding_index = here[name]