dagon 0.1.0

data/core/object.rb

@@ -0,0 +1,50 @@
+require "core/class"
+
+module Dagon
+  module Core
+    class DG_Object
+      attr_reader :klass
+      def initialize klass = nil
+        @ivars = {}
+        @klass = klass || DG_Class.new
+      end
+
+      def dagon_define_class name, parent
+        name = name.to_sym
+        klass = DG_Class.new(name, parent)
+        @klass.dagon_const_set(name, klass)
+        klass
+      end
+
+      def dagon_const_set constant, value
+        @klass.dagon_const_set(constant, value)
+      end
+
+      def dagon_const_get constant
+        @klass.dagon_const_get(constant)
+      end
+
+      def dagon_send interpreter, name, *args
+        method = @klass.get_method(name)
+        if method
+          frame = Frame.new(self, self)
+          interpreter.push_frame frame
+          return_value = method.call(interpreter, self, *args) || Dvoid
+          interpreter.pop_frame
+          return_value
+        else
+          $stderr.puts "undefined method '#{name}' for #{self.inspect}:#{self.klass.name}"
+          exit(1)
+        end
+      end
+
+      def set_instance_variable name, value
+        @ivars[name.to_sym] = value
+      end
+
+      def get_instance_variable name
+        @ivars[name.to_sym]
+      end
+    end
+  end
+end

data/core/string.rb

@@ -0,0 +1,57 @@
+module Dagon
+  module Core
+    class DG_String < 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_StringClass < DG_Class
+      def initialize
+        super("String", Dagon::Core::DG_Class.new)
+      end
+
+      def boot
+        add_method "init", ->(vm, ref, value) {
+          ref.instance_variable_set("@value", value)
+        }
+        add_method "+", ->(vm, ref, other) {
+          dagon_new(vm, ref.value + other.value)
+        }
+        add_method "=", ->(vm, ref, other) {
+          ref.value == other.value ? Dtrue : Dfalse
+        }
+        add_method "!=", ->(vm, ref, other) {
+          ref.value != other.value ? Dtrue : Dfalse
+        }
+        add_method 'length', ->(vm, ref) {
+          vm.get_class("Integer").instance(ref.value.length)
+        }
+        add_method 'to-i', ->(vm, ref) {
+          vm.get_class("Integer").instance(ref.value.to_i)
+        }
+        add_method 'to-f', ->(vm, ref) {
+          vm.get_class("Float").instance(ref.value.to_f)
+        }
+      end
+
+      def dagon_new interpreter, string = ""
+        DG_String.new(string, self)
+      end
+    end
+  end
+end

data/core/true.rb

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

data/core/vm.rb

@@ -0,0 +1,125 @@
+CORE = %w(object class array block false float frame integer string true void hash)
+CORE.each do |klass|
+  require "core/#{klass}"
+end
+
+require "pry"
+
+module Dagon
+  module Core
+    class VM
+      attr_reader :globals
+      def initialize main = nil
+        @load_paths = [File.expand_path(".")]
+        @required_files = []
+        @object = main || Dagon::Core::DG_Object.new
+        @stack = []
+        @stack.push Frame.new(@object, '(toplevel)')
+        @globals = {}
+        @classes = {}
+        boot_core
+      end
+
+      def boot_core
+        add_class("Array", DG_ArrayClass.new)
+        add_class("Block", DG_BlockClass.new)
+        add_class("False", DG_FalseClass.new)
+        add_class("Float", DG_FloatClass.new)
+        add_class("Hash", DG_HashClass.new)
+        add_class("Integer", DG_IntegerClass.new)
+        add_class("String", DG_StringClass.new)
+        add_class("True", DG_TrueClass.new)
+        add_class("Void", DG_VoidClass.new)
+
+        unless Kernel.const_defined?("Dtrue")
+          Kernel.const_set("Dtrue", Dagon::Core::True.instance)
+        end
+        unless Kernel.const_defined?("Dfalse")
+          Kernel.const_set("Dfalse", Dagon::Core::False.instance)
+        end
+        unless Kernel.const_defined?("Dvoid")
+          Kernel.const_set("Dvoid", Dagon::Core::Void.instance)
+        end
+      end
+
+      def current_object
+        @stack[0].object
+      end
+
+      def add_class name, klass
+        current_object.dagon_const_set(name, klass)
+      end
+
+      def get_class name
+        current_object.dagon_const_get(name)
+      end
+
+      def add_load_path path
+        unless @load_paths.include? path
+          @load_paths << path
+        end
+      end
+
+      def frame
+        @stack.last
+      end
+
+      def push_frame frame
+        @stack.push frame
+        @object = frame.object
+      end
+
+      def pop_frame
+        @stack.pop
+        @object = frame.object
+      end
+
+      def dagon_define_class name, parent
+        @object.dagon_define_class name, parent
+      end
+
+      def define_function name, block
+        if @object.respond_to? :add_method
+          @object.add_method name, block
+        else
+          @object.klass.add_method name, block
+        end
+      end
+
+      def find_file_path filename
+        @load_paths.each do |path|
+          if File.exists? File.join(path, "#{filename}.dg")
+            return File.join(path, "#{filename}.dg")
+          end
+        end
+        nil
+      end
+
+      def load_file filename
+        path = find_file_path(filename.value)
+        if path
+          @required_files << path
+          program = File.read(path)
+          tokens = Dagon::Scanner.tokenize(program, filename)
+          tree = Dagon::Parser.parse(tokens, filename, false)
+          tree.evaluate(self)
+          Dtrue
+        else
+          error "No such file or directory - #{filename.value}\n" +
+          "Searched: \n" +
+          @load_paths.map{ |path| " #{path}"}.join("\n")
+        end
+      end
+
+      def loaded? filename
+        @required_files.include? filename
+      end
+
+      def error message
+        $stderr.puts message
+        exit(1)
+      end
+    end
+  end
+end
+

data/core/void.rb

@@ -0,0 +1,37 @@
+require 'singleton'
+
+module Dagon
+  module Core
+    class Void < DG_Object
+      include Singleton
+      def initialize
+        @klass = DG_VoidClass.new
+      end
+
+      def to_s
+        ""
+      end
+
+      def value # TODO: determine if there is a better way than this for checking equality
+        nil
+      end
+
+      def inspect
+        "void"
+      end
+    end
+
+    class DG_VoidClass < DG_Class
+      undef :dagon_new
+      def initialize
+        super("Void", Dagon::Core::DG_Class.new)
+      end
+
+      def boot
+        add_method "=", ->(vm, ref, other) {
+          ref == other ? Dtrue : Dfalse
+        }
+      end
+    end
+  end
+end

data/dagon.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.name          = "dagon"
+  gem.version       = "0.1.0"
+  gem.authors       = ["Caleb Thompson", "Matt Mongeau"]
+  gem.email         = ["cjaysson@gmail.com", "halogenandtoast@gmail.com"]
+  gem.description   = "The Dagon programming language: whitespace, enumerators, blocks, One Way"
+  gem.summary       = "The Esoteric Order of Dagon"
+  gem.homepage      = "https://github.com/calebthompson/dagon"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/(dagon|dspec|idgr)}).map{ |f| File.basename(f) }
+  gem.require_paths = %w{core dagon}
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'racc'
+  gem.add_development_dependency 'pry'
+end

data/dagon.vim

@@ -0,0 +1,45 @@
+" Vim syntax file
+" Language: Dagon
+" Maintainer: Caleb Thompson
+" Latest Revision: 16 January 2013
+
+au BufRead,BufNewFile *.dg set filetype=dagon
+
+if exists("b:current_syntax")
+    finish
+endif
+
+syntax keyword dagonConditional if elseif else while break
+syntax keyword dagonBoolean true false
+syntax keyword dagonKeyword void
+syntax keyword dagonFunction print puts
+syntax match dagonNumber '\d'
+syntax match dagonFloat '\d+\.\d+'
+syntax region String start="'" end="'"
+syntax region String start='"' end='"'
+syntax region Array start="\[" end="\]"
+syntax match dagonComment "\v#.*$"
+syntax match dagonConstant "\v[A-Z][A-Za-z]*"
+syntax match dagonIdentifier "\v-?[a-z][a-z0-9-]+"
+syntax match dagonFunctionDefinition "\v-?[a-z][a-z0-9-]+:"
+syntax region dagonFunctionDefinitionArgumentList start="\v-?[a-z][a-z0-9-]+\(" end="):"
+syntax region dagonFunctionCall start="\v-?[a-z][a-z0-9-]+\(" end=")"
+syntax match dagonOperator "\v \*\* "
+syntax match dagonOperator "\v \* "
+syntax match dagonOperator "\v / "
+syntax match dagonOperator "\v \+ "
+syntax match dagonOperator "\v - "
+syntax match dagonAssignment ": "
+
+highlight link dagonConditional Conditional
+highlight link dagonKeyword Keyword
+highlight link dagonBoolean Boolean
+highlight link dagonIdentifier dagonFunction
+highlight link dagonFunctionDefinition dagonFunction
+highlight link dagonFunction Function
+
+highlight link dagonComment Comment
+highlight link dagonOperator Operator
+highlight link dagonConstant Constant
+
+let b:current_syntax = "dagon"

data/dagon/ast/array_node.rb

@@ -0,0 +1,17 @@
+require 'core/array'
+
+module Dagon
+  module AST
+    class ArrayNode < Node
+      def initialize filename, line_number, list
+        super filename, line_number
+        @list = list
+      end
+
+      def evaluate interpreter
+        evaluated_list = @list.map { |item| item.evaluate(interpreter) }
+        interpreter.get_class("Array").dagon_new(interpreter, evaluated_list)
+      end
+    end
+  end
+end

data/dagon/ast/assignment_node.rb

@@ -0,0 +1,21 @@
+module Dagon
+  module AST
+    class AssignmentNode < Node
+      attr_reader :variable_name
+      attr_reader :variable_value
+      def initialize filename, line_number, variable_name, value
+        super filename, line_number
+        @variable_name = variable_name
+        @variable_value = value
+      end
+
+      def evaluate interpreter
+        if variable_name[0] == "@"
+          interpreter.frame.object.set_instance_variable(variable_name, value.evaluate(interpreter))
+        else
+          interpreter.frame[variable_name] = variable_value.evaluate(interpreter)
+        end
+      end
+    end
+  end
+end

data/dagon/ast/block_node.rb

@@ -0,0 +1,19 @@
+require 'core/block'
+
+module Dagon
+  module AST
+
+    class BlockNode < Node
+      def initialize filename, line_number, statements, arguments
+        super filename, line_number
+        @statements = statements
+        @arguments = arguments
+      end
+
+      def evaluate interpreter
+        arguments = @arguments.map(&:variable_name)
+        interpreter.get_class("Block").dagon_new(interpreter, @statements, interpreter.frame, arguments)
+      end
+    end
+  end
+end

data/dagon/ast/class_definition_node.rb

@@ -0,0 +1,24 @@
+require 'core/frame'
+require 'core/class'
+
+module Dagon
+  module AST
+    class ClassDefinitionNode < Node
+      def initialize filename, line_number, class_name, statements
+        super filename, line_number
+        @class_name = class_name
+        @statements = statements
+      end
+
+      def evaluate interpreter
+        klass = interpreter.dagon_define_class @class_name, Dagon::Core::DG_Class.new
+        frame = Dagon::Core::Frame.new(klass, klass.name)
+        interpreter.push_frame frame
+        @statements.each do |statement|
+          statement.evaluate interpreter
+        end
+        interpreter.pop_frame
+      end
+    end
+  end
+end