nydp 0.0.1

data/lib/nydp/assignment.rb

@@ -0,0 +1,40 @@
+module Nydp
+  class AssignmentInstruction
+    def initialize name
+      @name = name
+    end
+
+    def execute vm
+      @name.assign vm.peek_arg, vm.peek_context
+    end
+
+    def to_s
+      "#assign #{@name}"
+    end
+  end
+
+  class Assignment
+    include Helper
+
+    def self.build args, bindings
+      name = Compiler.compile args.car, bindings
+      raise "can't assign to #{name.inspect} : expression was #{args}" unless name.respond_to?(:assign)
+      value_expr = args.cdr.car
+      Assignment.new name, Compiler.compile(value_expr, bindings), value_expr
+    end
+
+    def initialize name, value, value_src
+      @value_src = value_src
+      n = AssignmentInstruction.new name
+      @instructions = cons(value, cons(n))
+    end
+
+    def to_s
+      "#assignment #{@instructions.cdr.car} #{@value_src}"
+    end
+
+    def execute vm
+      vm.push_instructions @instructions, vm.peek_context
+    end
+  end
+end

data/lib/nydp/builtin.rb

@@ -0,0 +1,8 @@
+require 'nydp'
+
+module Nydp::Builtin
+end
+
+Dir[File.join(File.dirname(__FILE__), "builtin", "**/*.rb")].each {|f|
+  require f
+}

data/lib/nydp/builtin/apply.rb

@@ -0,0 +1,16 @@
+class Nydp::Builtin::Apply
+  include Nydp::Helper
+
+  def invoke vm, args
+    args.car.invoke vm, apply_args(args.cdr)
+  end
+
+  private
+
+  def apply_args args
+    raise "Apply: expected a list : got #{args.inspect}" unless pair? args
+    raise "Apply: improper list : cdr is ruby nil" if args.cdr.nil?
+    return args.car if Nydp.NIL.is? args.cdr
+    cons args.car, apply_args(args.cdr)
+  end
+end

data/lib/nydp/builtin/car.rb

@@ -0,0 +1,5 @@
+class Nydp::Builtin::Car
+  def invoke vm, args
+    vm.push_arg args.car.car
+  end
+end

data/lib/nydp/builtin/cdr.rb

@@ -0,0 +1,5 @@
+class Nydp::Builtin::Cdr
+  def invoke vm, args
+    vm.push_arg args.car.cdr
+  end
+end

data/lib/nydp/builtin/cdr_set.rb

@@ -0,0 +1,8 @@
+class Nydp::Builtin::CdrSet
+  def invoke vm, args
+    pair = args.car
+    arg = args.cdr.car
+    pair.cdr = arg
+    vm.push_arg pair
+  end
+end

data/lib/nydp/builtin/comment.rb

@@ -0,0 +1,5 @@
+class Nydp::Builtin::Comment
+  def invoke vm, args
+    vm.push_arg Nydp.NIL
+  end
+end

data/lib/nydp/builtin/cons.rb

@@ -0,0 +1,16 @@
+module Nydp::Builtin
+  class Cons
+    def invoke vm, args
+      vm.push_arg Nydp::Pair.new(args.car, args.cdr.car)
+    end
+  end
+
+  class IsPair
+    include Nydp::Helper
+    def invoke vm, args
+      arg = args.car
+      result = pair?(arg) ? Nydp.T : Nydp.NIL
+      vm.push_arg result
+    end
+  end
+end

data/lib/nydp/builtin/divide.rb

@@ -0,0 +1,13 @@
+class Nydp::Builtin::Divide
+  def invoke vm, args
+    vm.push_arg divide(args.cdr, args.car)
+  end
+
+  def divide args, accum
+    if Nydp.NIL.is? args
+      accum
+    else
+      divide(args.cdr, (accum / args.car))
+    end
+  end
+end

data/lib/nydp/builtin/error.rb

@@ -0,0 +1,6 @@
+class Nydp::Builtin::Error
+  def invoke vm, args
+    s = args.map { |a| a.to_s }
+    raise Nydp::Error.new(args.inspect)
+  end
+end

data/lib/nydp/builtin/eval.rb

@@ -0,0 +1,14 @@
+class Nydp::Builtin::Eval
+  def initialize ns
+    @ns = ns
+  end
+
+  def invoke vm, args
+    evaluator = Nydp::Runner.new Nydp::VM.new, @ns
+    vm.push_arg evaluator.evaluate args.car
+  end
+
+  def to_s
+    "Builtin:eval"
+  end
+end

data/lib/nydp/builtin/greater_than.rb

@@ -0,0 +1,10 @@
+class Nydp::Builtin::GreaterThan
+  def invoke vm, args
+    vm.push_arg (greater_than(args.car, args.cdr) ? Nydp.T : Nydp.NIL)
+  end
+
+  def greater_than arg, args
+    return true if Nydp.NIL.is? args
+    (arg > args.car) && greater_than(args.car, args.cdr)
+  end
+end

data/lib/nydp/builtin/hash.rb

@@ -0,0 +1,30 @@
+class Nydp::Builtin::Hash
+  def invoke vm, args
+    vm.push_arg({ })
+  end
+end
+
+class Nydp::Builtin::HashGet
+  def invoke vm, args
+    hash = args.car
+    key = args.cdr.car
+    vm.push_arg(hash[key] || Nydp.NIL)
+  end
+end
+
+class Nydp::Builtin::HashSet
+  def invoke vm, args
+    hash = args.car
+    key = args.cdr.car
+    value = args.cdr.cdr.car
+    hash[key] = value
+    vm.push_arg value
+  end
+end
+
+class Nydp::Builtin::HashKeys
+  def invoke vm, args
+    hash = args.car
+    vm.push_arg Nydp::Pair.from_list hash.keys
+  end
+end

data/lib/nydp/builtin/inspect.rb

@@ -0,0 +1,5 @@
+class Nydp::Builtin::Inspect
+  def invoke vm, args
+    vm.push_arg args.car.inspect
+  end
+end

data/lib/nydp/builtin/is_equal.rb

@@ -0,0 +1,5 @@
+class Nydp::Builtin::IsEqual
+  def invoke vm, args
+    vm.push_arg ((args.car == args.cdr.car) ? Nydp.T : Nydp.NIL)
+  end
+end

data/lib/nydp/builtin/less_than.rb

@@ -0,0 +1,10 @@
+class Nydp::Builtin::LessThan
+  def invoke vm, args
+    vm.push_arg (less_than(args.car, args.cdr) ? Nydp.T : Nydp.NIL)
+  end
+
+  def less_than arg, args
+    return true if Nydp.NIL.is? args
+    (arg < args.car) && less_than(args.car, args.cdr)
+  end
+end

data/lib/nydp/builtin/millisecs.rb

@@ -0,0 +1,7 @@
+class Nydp::Builtin::Millisecs
+  include Nydp::Helper
+
+  def invoke vm, args
+    vm.push_arg (Time.now.to_f * 1000).to_i
+  end
+end

data/lib/nydp/builtin/minus.rb

@@ -0,0 +1,13 @@
+class Nydp::Builtin::Minus
+  def invoke vm, args
+    vm.push_arg diff(args.cdr, args.car)
+  end
+
+  def diff args, accum
+    if Nydp.NIL.is? args
+      accum
+    else
+      diff(args.cdr, (accum - args.car))
+    end
+  end
+end

data/lib/nydp/builtin/plus.rb

@@ -0,0 +1,28 @@
+class Nydp::Builtin::Plus
+  def invoke vm, args
+    vm.push_arg sum(args, origin(args.car))
+  end
+
+  def sum args, accum
+    if Nydp.NIL.is? args
+      accum
+    else
+      sum(args.cdr, (accum + args.car))
+    end
+  end
+
+  def origin obj
+    case obj
+    when Fixnum
+      0
+    when Nydp::Pair
+      Nydp.NIL
+    when String, Nydp::StringAtom
+      Nydp::StringAtom.new ""
+    end
+  end
+
+  def to_s
+    "Builtin:+"
+  end
+end

data/lib/nydp/builtin/pre_compile.rb

@@ -0,0 +1,5 @@
+class Nydp::Builtin::PreCompile
+  def invoke vm, args
+    vm.push_arg args.car
+  end
+end

data/lib/nydp/builtin/puts.rb

@@ -0,0 +1,7 @@
+class Nydp::Builtin::Puts
+  def invoke vm, args
+    s = args.map { |a| a.to_s }
+    puts s.join ' '
+    vm.push_arg args.car
+  end
+end

data/lib/nydp/builtin/quit.rb

@@ -0,0 +1,5 @@
+class Nydp::Builtin::Quit
+  def invoke vm, args
+    exit
+  end
+end

data/lib/nydp/builtin/random_string.rb

@@ -0,0 +1,11 @@
+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 invoke vm, args
+    s = ""
+    1.upto(10) {
+      s << @@random_chars[rand(@@random_chars.size)]
+    }
+    Nydp::StringAtom.new s
+  end
+end

data/lib/nydp/builtin/times.rb

@@ -0,0 +1,13 @@
+class Nydp::Builtin::Times
+  def invoke vm, args
+    vm.push_arg multiply(args, 1)
+  end
+
+  def multiply args, accum
+    if Nydp.NIL.is? args
+      accum
+    else
+      multiply(args.cdr, (accum * args.car))
+    end
+  end
+end

data/lib/nydp/builtin/to_string.rb

@@ -0,0 +1,12 @@
+class Nydp::Builtin::ToString
+  def 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
+  end
+end

data/lib/nydp/builtin/to_sym.rb

@@ -0,0 +1,21 @@
+class Nydp::Builtin::ToSym
+  def initialize ns
+    @ns = ns
+  end
+  def invoke vm, args
+    arg = args.car
+    val = case arg.class
+          when Nydp::Symbol
+            arg
+          else
+            Nydp::Symbol.mk arg.to_s.to_sym, @ns
+          end
+    vm.push_arg val
+  end
+end
+
+
+
+
+
+

data/lib/nydp/builtin/vm_info.rb

@@ -0,0 +1,13 @@
+class Nydp::Builtin::VmInfo
+  VMINFO_NS    = { }
+  CONTEXTS     = Nydp::Symbol.mk :contexts,     VMINFO_NS
+  INSTRUCTIONS = Nydp::Symbol.mk :instructions, VMINFO_NS
+  ARGS         = Nydp::Symbol.mk :args,         VMINFO_NS
+
+  def 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]
+  end
+end

data/lib/nydp/closure.rb

@@ -0,0 +1,17 @@
+module Nydp
+  class Closure
+    attr_accessor :ifn, :context
+
+    def initialize ifn, context
+      @ifn, @context = ifn, context
+    end
+
+    def invoke vm, arg_values
+      ifn.invoke vm, context, arg_values
+    end
+
+    def to_s
+      "(closure #{context.inspect} : #{ifn.to_s})"
+    end
+  end
+end

data/lib/nydp/compiler.rb

@@ -0,0 +1,49 @@
+require 'nydp/cond'
+require 'nydp/function_invocation'
+require 'nydp/interpreted_function'
+require 'nydp/literal'
+
+module Nydp
+  class Compiler
+    extend Helper
+
+    def self.compile expression, bindings
+      if expression.is_a? Nydp::Symbol
+        SymbolLookup.build expression, bindings
+      elsif literal? expression
+        Literal.build expression, bindings
+      elsif expression.is_a? Nydp::Pair
+        compile_pair expression, bindings
+      end
+    end
+
+    def self.maybe_cons a, b
+      Nydp.NIL.is?(a) ? b : cons(a, b)
+    end
+
+    def self.compile_each expr, bindings
+      if Nydp.NIL.is?(expr)
+        expr
+      elsif pair?(expr)
+        maybe_cons compile(expr.car, bindings), compile_each(expr.cdr, bindings)
+      else
+        compile(expr, bindings)
+      end
+    end
+
+    def self.compile_pair expression, bindings
+      key = expression.car
+      if sym?(key, :cond)
+        Cond.build expression.cdr, bindings
+      elsif sym?(key, :quote)
+        Literal.build expression.cadr, bindings
+      elsif sym?(key, :assign)
+        Assignment.build expression.cdr, bindings
+      elsif sym?(key, :fn)
+        InterpretedFunction.build expression.cadr, expression.cddr, bindings
+      else
+        FunctionInvocation.build expression, bindings
+      end
+    end
+  end
+end