dagon 0.1.0

data/core/array.rb

@@ -0,0 +1,64 @@
+module Dagon
+  module Core
+    class DG_Array < DG_Object
+      attr_reader :list
+      def initialize list, klass
+        @list = list
+        @klass = klass
+      end
+
+      def to_s
+        "["+@list.map(&:to_s).join(", ")+"]"
+      end
+    end
+
+    class DG_ArrayClass < DG_Class
+      def initialize
+        super("Array", Dagon::Core::DG_Class.new)
+      end
+
+      def boot
+        add_method "init", ->(vm, ref, value) {
+          ref.instance_variable_set("@value", value)
+        }
+        add_method "[]", ->(vm, ref, index) {
+          ref.list[index.value]
+        }
+        add_method "+", ->(vm, ref, other) {
+          DG_Array.new(ref.list + other.list, self)
+        }
+        add_method "-", ->(vm, ref, other) {
+          result = ref.list.reject { |item| other.list.include?(item) }
+          DG_Array.new(result, self)
+        }
+        add_method "=", ->(vm, ref, other) {
+          ref.list == other.list ? Dtrue : Dfalse
+        }
+        add_method "compact", ->(vm, ref) {
+          result = ref.list.reject{ |item| item == Dvoid }
+          DG_Array.new(result, self)
+        }
+        add_method "length", ->(vm, ref) {
+          vm.get_class("Integer").instance(ref.list.length)
+        }
+        add_method "each", ->(vm, ref, block) {
+          ref.list.each do |item|
+            if block.arity == 1
+              block.dagon_send(vm, "call", item)
+            else
+              block.dagon_send(vm, "call")
+            end
+          end
+        }
+      end
+
+      def dagon_new interpreter, value = []
+        if value.is_a? DG_Array
+          DG_Array.new(value.list, self)
+        else
+          DG_Array.new(value, self)
+        end
+      end
+    end
+  end
+end

data/core/block.rb

@@ -0,0 +1,38 @@
+module Dagon
+  module Core
+    class DG_Block < DG_Object
+      attr_accessor :statements, :frame, :arguments
+      def initialize(statements, frame, arguments, klass)
+        @statements = statements
+        @frame = frame
+        @klass = klass
+        @arguments = arguments
+      end
+
+      def arity
+        @arguments.length
+      end
+    end
+
+    class DG_BlockClass < DG_Class
+      def initialize
+        super("Block", Dagon::Core::DG_Class.new)
+      end
+
+      def boot
+        add_method "call", ->(vm, instance, *args) do
+          frame = instance.frame.dup
+          instance.arguments.each_with_index { |variable_name, index| frame[variable_name] = args[index] }
+          vm.push_frame(instance.frame)
+          result = instance.statements.map { |statement| statement.evaluate(vm) }.last
+          vm.pop_frame
+          result
+        end
+      end
+
+      def dagon_new interpreter, statements, frame, arguments
+        DG_Block.new(statements, frame, arguments, self)
+      end
+    end
+  end
+end

data/core/class.rb

@@ -0,0 +1,91 @@
+module Dagon
+  module Core
+    class DG_Class
+      attr_reader :name, :class_methods
+      def initialize name = nil, parent = nil
+        @constants = {}
+        @methods = {
+          methods: ->(vm, ref, *args) { vm.get_class("Array").dagon_new(vm, @methods.keys) },
+          init: ->(vm, ref, *args) { },
+          exit: ->(vm, ref, *args) { exit(0) },
+          puts: ->(vm, ref, *args) { puts *args.map(&:to_s) },
+          print: ->(vm, ref, *args) { print *args.map(&:to_s) },
+          gets: ->(vm, ref, *args) { vm.get_class("String").dagon_new(vm, $stdin.gets) },
+          eval: ->(vm, ref, *args) {
+            tokens = Dagon::Scanner.tokenize(args[0].value, '(eval)')
+            tree = Dagon::Parser.parse(tokens, '(eval)', false)
+            tree.evaluate(vm)
+          },
+          require: ->(vm, ref, *args) {
+            filename = args[0]
+            if vm.loaded? filename
+              Dfalse
+            else
+              vm.load_file filename
+              Dtrue
+            end
+          }
+        }
+        @class_ivars = {}
+        @class_methods = {
+          methods: ->(vm, ref) {
+            vm.get_class("Array").dagon_new(vm, ref.class_methods.keys)
+          },
+        }
+        @name = name || "Class"
+        @parent = parent
+        boot
+      end
+
+      def dagon_new
+        obj = ref.dagon_allocate
+        obj.dagon_send(vm, "init", *args)
+        obj
+      end
+
+      def boot
+        # noop
+      end
+
+      def dagon_const_get constant
+        @constants[constant.to_sym]
+      end
+
+      def dagon_const_set constant, value
+        @constants[constant.to_sym] = value
+      end
+
+      def add_class_method name, block
+        @class_methods[name.to_sym] = block
+      end
+
+      def add_method name, block
+        @methods[name.to_sym] = block
+      end
+
+      def get_method name
+        @methods[name.to_sym]
+      end
+
+      def dagon_allocate
+        DG_Object.new(self)
+      end
+
+      def dagon_send interpreter, name, *args
+        method = @class_methods[name.to_sym]
+        if method
+          method.call(interpreter, self, *args) || Dvoid
+        elsif @parent
+          @parent.dagon_send(interpreter, name, *args)
+        else
+          $stderr.puts "undefined method #{name} for #{to_s}"
+          exit(1)
+        end
+      end
+
+      def to_s
+        @name
+      end
+    end
+  end
+end

data/core/false.rb

@@ -0,0 +1,38 @@
+require 'singleton'
+
+module Dagon
+  module Core
+    class False < DG_Object
+      include Singleton
+
+      def initialize
+        @value = false
+        @klass = DG_FalseClass.new
+      end
+
+      def inspect
+        "false"
+      end
+    end
+
+    class DG_FalseClass < DG_Class
+      undef :dagon_new
+      def initialize
+        super("False", Dagon::Core::DG_Class.new)
+      end
+
+      def boot
+        add_method '!@', ->(vm, ref) {
+          Dtrue
+        }
+        add_method '=', ->(vm, ref, other) {
+          ref == other ? Dtrue : Dfalse
+        }
+        add_method '&&', ->(vm, ref, other) { Dfalse }
+        add_method '||', ->(vm, ref, other) { other }
+        add_method '^', ->(vm, ref, other) { other }
+        add_method 'to-s', ->(vm, ref) { vm.get_class("String").dagon_new(vm, "false") }
+      end
+    end
+  end
+end

data/core/float.rb

@@ -0,0 +1,93 @@
+module Dagon
+  module Core
+    class DG_Float < DG_Object
+      attr_reader :value
+      def initialize value, klass
+        @value = value
+        @klass = klass
+      end
+
+      def == other
+        value == other.value
+      end
+
+      def to_s
+        @value
+      end
+
+      def inspect
+        @value
+      end
+    end
+
+    class DG_FloatClass < DG_Class
+      undef :dagon_new
+
+      def initialize value = ""
+        super("Float", Dagon::Core::DG_Class.new)
+      end
+
+      def instance value
+        DG_Float.new(value, self)
+      end
+
+      def boot
+        add_method "+", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left + right)
+        }
+        add_method "-", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left - right)
+        }
+        add_method "*", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left * right)
+        }
+        add_method "/", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left / right)
+        }
+        add_method "**", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left ** right)
+        }
+        add_method "=", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left == right ? Dtrue : Dfalse
+        }
+        add_method "!=", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left != right ? Dtrue : Dfalse
+        }
+        add_method ">", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left > right ? Dtrue : Dfalse
+        }
+        add_method ">=", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left >= right ? Dtrue : Dfalse
+        }
+        add_method "<", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left < right ? Dtrue : Dfalse
+        }
+        add_method "<=", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left <= right ? Dtrue : Dfalse
+        }
+      end
+    end
+  end
+end

data/core/frame.rb

@@ -0,0 +1,24 @@
+module Dagon
+  module Core
+    class Frame
+      attr_reader :object, :frame_name, :local_variables
+      def initialize object, frame_name, local_variables = {}
+        @object = object
+        @frame_name = frame_name
+        @local_variables = local_variables
+      end
+
+      def local_variable? name
+        @local_variables.key? name
+      end
+
+      def [](key)
+        @local_variables[key]
+      end
+
+      def []=(key, value)
+        @local_variables[key] = value
+      end
+    end
+  end
+end

data/core/hash.rb

@@ -0,0 +1,51 @@
+module Dagon
+  module Core
+    class DG_Hash < DG_Object
+      attr_reader :hash
+      def initialize(assignments, klass)
+        @hash = convert_assignments_to_hash_values(assignments)
+        @klass = klass
+      end
+
+      def to_s
+        hash
+      end
+
+      def inspect
+        hash.inspect
+      end
+
+      private
+
+      def convert_assignments_to_hash_values(assignments)
+        hash = {}
+        assignments.each do |assignment|
+          hash[assignment.variable_name] = assignment.variable_value
+        end
+        hash
+      end
+    end
+
+    class DG_HashClass < DG_Class
+      def initialize
+        super("Hash", DG_Class.new)
+        boot
+      end
+
+      def boot
+
+        add_method "=", ->(vm, ref, other) do
+          ref.hash == other.hash ? Dtrue : Dfalse
+        end
+
+        add_method "!=", ->(vm, ref, other) do
+          ref.hash != other.hash ? Dtrue : Dfalse
+        end
+      end
+
+      def dagon_new interpreter, assignments
+        DG_Hash.new(assignments, self)
+      end
+    end
+  end
+end

data/core/integer.rb

@@ -0,0 +1,98 @@
+module Dagon
+  module Core
+    class DG_Integer < DG_Object
+      attr_reader :value
+      def initialize value, klass
+        @value = value
+        @klass = klass
+      end
+
+      def == other
+        value == other.value
+      end
+
+      def to_s
+        @value
+      end
+
+      def inspect
+        @value
+      end
+    end
+
+    class DG_IntegerClass < DG_Class
+      undef :dagon_new
+
+      def initialize value = ""
+        super("Integer", Dagon::Core::DG_Class.new)
+      end
+
+      def instance value
+        DG_Integer.new(value, self)
+      end
+
+      def boot
+        add_method "+", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left + right)
+        }
+        add_method "-", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left - right)
+        }
+        add_method "*", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left * right)
+        }
+        add_method "/", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left / right)
+        }
+        add_method "**", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          ref.klass.instance(left ** right)
+        }
+        add_method "=", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left == right ? Dtrue : Dfalse
+        }
+        add_method "!=", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left != right ? Dtrue : Dfalse
+        }
+        add_method ">", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left > right ? Dtrue : Dfalse
+        }
+        add_method ">=", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left >= right ? Dtrue : Dfalse
+        }
+        add_method "<", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left < right ? Dtrue : Dfalse
+        }
+        add_method "<=", ->(vm, ref, other) {
+          left = ref.value
+          right = other.value
+          left <= right ? Dtrue : Dfalse
+        }
+        add_method "times", ->(vm, ref, block) {
+          ref.value.times do
+            block.evaluate vm
+          end
+        }
+      end
+    end
+  end
+end