dagon 0.1.0

data/dagon/ast/constant_ref_node.rb

@@ -0,0 +1,15 @@
+module Dagon
+  module AST
+    class ConstantRefNode < Node
+      attr_reader :variable_name
+      def initialize filename, line_number, variable_name
+        super filename, line_number
+        @constant_name = variable_name
+      end
+
+      def evaluate interpreter
+        interpreter.current_object.dagon_const_get(@constant_name)
+      end
+    end
+  end
+end

data/dagon/ast/frame.rb

@@ -0,0 +1,23 @@
+module Dagon
+  module AST
+    class Frame
+      attr_reader :frame_name
+      def initialize frame_name
+        @frame_name = frame_name
+        @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/dagon/ast/function_call_node.rb

@@ -0,0 +1,33 @@
+module Dagon
+  module AST
+    class DagonError < StandardError; end
+    class DagonArgumentError < DagonError; end
+
+    class FunctionCallNode < Node
+      def initialize filename, line_number, object, function_name, arguments, block
+        super filename, line_number
+        @function_name = function_name
+        @arguments = arguments
+        @block = block
+        @object = object
+      end
+
+      def evaluate interpreter
+        arguments = @arguments.map { |argument| argument.evaluate interpreter }
+        if @block
+          arguments << @block.evaluate(interpreter)
+        end
+        object = if @object
+                   @object.evaluate interpreter
+                 else
+                   interpreter.frame.object
+                 end
+        frame = Dagon::Core::Frame.new(object, @function_name)
+        interpreter.push_frame frame
+        result = object.dagon_send interpreter, @function_name, *arguments
+        interpreter.pop_frame
+        result
+      end
+    end
+  end
+end

data/dagon/ast/function_definition_node.rb

@@ -0,0 +1,15 @@
+module Dagon
+  module AST
+    class FunctionDefinitionNode < Node
+      def initialize filename, line_number, function_name, function_object
+        super filename, line_number
+        @function_name = function_name
+        @function_object = function_object
+      end
+
+      def evaluate interpreter
+        interpreter.define_function @function_name, @function_object
+      end
+    end
+  end
+end

data/dagon/ast/function_node.rb

@@ -0,0 +1,23 @@
+module Dagon
+  module AST
+    class Function < Node
+      def initialize filename, line_number, params, body
+        super filename, line_number
+        @params = params.map(&:variable_name) # params must be unwrapped
+        @body = body
+      end
+
+      def call(interpreter, object, *args)
+        unless args.size == @params.size
+          $stderr.puts "Wrong"
+          exit(1)
+        end
+        frame = interpreter.frame
+        args.each_with_index do |arg, index|
+          frame[@params[index]] = arg
+        end
+        execute_list interpreter, @body
+      end
+    end
+  end
+end

data/dagon/ast/hash_node.rb

@@ -0,0 +1,16 @@
+require 'core/hash'
+
+module Dagon
+  module AST
+    class HashNode < Node
+      def initialize(filename, line_number, assignments)
+        super(filename, line_number)
+        @assignments = assignments
+      end
+
+      def evaluate(interpreter)
+        interpreter.get_class("Hash").dagon_new(interpreter, @assignments)
+      end
+    end
+  end
+end

data/dagon/ast/if_node.rb

@@ -0,0 +1,20 @@
+module Dagon
+  module AST
+    class IfNode < Node
+      def initialize filename, line_number, condition, true_statements, false_statements
+        super filename, line_number
+        @condition = condition
+        @true_statements = true_statements
+        @false_statements = false_statements
+      end
+
+      def evaluate interpreter
+        if @condition.evaluate(interpreter) == Dtrue
+          execute_list interpreter, @true_statements
+        else
+          execute_list interpreter, @false_statements if @false_statements
+        end
+      end
+    end
+  end
+end

data/dagon/ast/instance_init_node.rb

@@ -0,0 +1,28 @@
+module Dagon
+  module AST
+    class InstanceInitNode < Node
+      def initialize filename, line_number, klass_name, arguments, block
+        super filename, line_number
+        @klass_name = klass_name
+        @arguments = arguments
+        @block = block
+      end
+
+      def evaluate interpreter
+        arguments = @arguments.map { |argument| argument.evaluate interpreter }
+        if @block
+          arguments << BlockNode.new(@filename, @line_number, @block, interpreter.frame)
+        end
+
+        object = interpreter.frame.object
+        klass = object.dagon_const_get(@klass_name)
+        if klass.respond_to? :dagon_new
+          klass.dagon_new(interpreter, *arguments)
+        else
+          $stderr.puts "Cannot initialize object of type #{@klass_name}"
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/dagon/ast/instance_var_ref_node.rb

@@ -0,0 +1,21 @@
+module Dagon
+  module AST
+    class InstanceVarRefNode < Node
+      attr_reader :variable_name
+      def initialize filename, line_number, instance_variable_name
+        super filename, line_number
+        @instance_variable_name = instance_variable_name
+      end
+
+      def evaluate interpreter
+        current = interpreter.frame.object.get_instance_variable(@instance_variable_name)
+        if current
+          current
+        else
+          interpreter.frame.object.set_instance_variable(@instance_variable_name, Dvoid)
+          Dvoid
+        end
+      end
+    end
+  end
+end

data/dagon/ast/literal_node.rb

@@ -0,0 +1,23 @@
+require 'core/integer'
+require 'core/float'
+
+module Dagon
+  module AST
+    class LiteralNode < Node
+      def initialize filename, line_number, literal
+        super filename, line_number
+        @value = literal
+      end
+
+      def evaluate interpreter
+        case @value.class.name
+        when "Fixnum" then interpreter.get_class("Integer").instance(@value)
+        when "Float" then interpreter.get_class("Float").instance(@value)
+        when "TrueClass" then Dtrue
+        when "FalseClass" then Dfalse
+        when "NilClass" then Dvoid
+        end
+      end
+    end
+  end
+end

data/dagon/ast/node.rb

@@ -0,0 +1,22 @@
+module Dagon
+  module AST
+    class Node
+      attr_reader :filename, :line_number
+      def initialize filename, line_number
+        @filename = filename
+        @line_number = line_number
+      end
+
+      def execute_list interpreter, nodes
+        nodes.map do |node|
+          node.evaluate(interpreter)
+        end.last
+      end
+
+      def dagon_error! string
+        raise DagonError, "Problem? #{string}"
+      end
+
+    end
+  end
+end

data/dagon/ast/root_node.rb

@@ -0,0 +1,19 @@
+require "core/vm"
+
+module Dagon
+  module AST
+    class RootNode < Node
+      attr_accessor :vm
+      def initialize tree
+        super nil, nil
+        @tree = tree
+        @vm = Dagon::Core::VM.new
+      end
+
+      def evaluate vm = nil
+        actual_vm = vm || @vm
+        execute_list actual_vm, @tree
+      end
+    end
+  end
+end

data/dagon/ast/string_node.rb

@@ -0,0 +1,16 @@
+require 'core/string'
+
+module Dagon
+  module AST
+    class StringNode < Node
+      def initialize filename, line_number, string
+        super filename, line_number
+        @value = string
+      end
+
+      def evaluate interpreter
+        interpreter.get_class("String").dagon_new(interpreter, @value)
+      end
+    end
+  end
+end

data/dagon/ast/unary_function_call_node.rb

@@ -0,0 +1,17 @@
+module Dagon
+  module AST
+
+    class UnaryFunctionCallNode < Node
+      def initialize filename, line_number, object, function_name
+        super filename, line_number
+        @object = object
+        @function_name = function_name
+      end
+
+      def evaluate interpreter
+        object = @object.evaluate interpreter
+        object.dagon_send interpreter, "#{@function_name}@"
+      end
+    end
+  end
+end

data/dagon/ast/var_ref_node.rb

@@ -0,0 +1,19 @@
+module Dagon
+  module AST
+    class VarRefNode < Node
+      attr_reader :variable_name
+      def initialize filename, line_number, variable_name
+        super filename, line_number
+        @variable_name = variable_name
+      end
+
+      def evaluate interpreter
+        if interpreter.frame.local_variable? @variable_name
+          interpreter.frame[@variable_name]
+        else
+          interpreter.frame.object.dagon_send(interpreter, @variable_name)
+        end
+      end
+    end
+  end
+end

data/dagon/ast/while_node.rb

@@ -0,0 +1,17 @@
+module Dagon
+  module AST
+    class WhileNode < Node
+      def initialize filename, line_number, condition, statements
+        super filename, line_number
+        @condition = condition
+        @statements = statements
+      end
+
+      def evaluate interpreter
+        while @condition.evaluate(interpreter) == Dtrue
+          execute_list interpreter, @statements
+        end
+      end
+    end
+  end
+end

data/dagon/parser.y

@@ -0,0 +1,151 @@
+class Dagon::Parser
+prechigh
+  right EXPONENT
+  left '!'
+  left '&&' '||' '^'
+  left '*' '/'
+  left '+' '-'
+  left ':'
+  nonassoc '>' '<' '>=' '<=' '=' '!='
+preclow
+rule
+  program: { result = [] }
+         | statements { result = AST::RootNode.new(val[0]) }
+
+  block: INDENT statements DEDENT { result = val[1] }
+
+  statements: statements statement { result.push val[1] }
+            | statement { result = [val[0]] }
+
+  statement: class_definition
+           | method_definition
+           | assignment
+           | expression
+           | conditional_statement
+           | while_statement
+
+  while_statement: WHILE condition block { result = AST::WhileNode.new(@filename, nil, val[1], val[2]) }
+
+  conditional_statement: IF condition block else_stmt { result = AST::IfNode.new(@filename, nil, val[1], val[2], val[3]) }
+  else_stmt: { result = nil }
+           | ELSEIF condition block else_stmt{ result = [AST::IfNode.new(@filename, nil, val[1], val[2], val[3])] }
+           | ELSE block { result = val[1] }
+
+  class_definition: CONSTANT ':' block { result = AST::ClassDefinitionNode.new(@filename, nil, val[0].data, val[2]) }
+
+
+  assignment: method_name ASSIGNMENT expression { result = AST::AssignmentNode.new(@filename, nil, val[0].variable_name, val[2]) }
+            | '@' method_name ASSIGNMENT expression { result = AST::AssignmentNode.new(@filename, nil, "@#{val[1].variable_name}", val[3]) }
+
+  expression: expression '-' expression { result = call_on_object(val[0], '-', val[2]) }
+            | expression '+' expression { result = call_on_object(val[0], '+', val[2]) }
+            | expression '*' expression { result = call_on_object(val[0], '*', val[2]) }
+            | expression '/' expression { result = call_on_object(val[0], '/', val[2]) }
+            | expression '&&' expression { result = call_on_object(val[0], '&&', val[2]) }
+            | expression '||' expression { result = call_on_object(val[0], '||', val[2]) }
+            | expression '^' expression { result = call_on_object(val[0], '^', val[2]) }
+            | expression EXPONENT expression { result = call_on_object(val[0], '**', val[2]) }
+            | condition
+
+  unary_expression: '!' expression { result = AST::UnaryFunctionCallNode.new(@filename, nil, val[1], "!") }
+
+  condition: expression '>' expression { result = call_on_object(val[0], '>', val[2]) }
+           | expression '<' expression { result = call_on_object(val[0], '<', val[2]) }
+           | expression '<=' expression { result = call_on_object(val[0], '<=', val[2]) }
+           | expression '>=' expression { result = call_on_object(val[0], '>=', val[2]) }
+           | expression '=' expression { result = call_on_object(val[0], '=', val[2]) }
+           | expression '!=' expression { result = call_on_object(val[0], '!=', val[2]) }
+           | unary_expression
+           | term
+
+  hash: LBRACE hash_list RBRACE { result = AST::HashNode.new(@filename, nil, val[1]) }
+  hash_list: { result = [] }
+           | hash_member { result = val }
+           | hash_list COMMA hash_member { result << val }
+  hash_member: assignment { result = val[0] }
+
+  array: LBRACKET list RBRACKET { result = AST::ArrayNode.new(@filename, nil, val[1]) }
+  list: { result = [] }
+      | list_member { result = val }
+      | list COMMA list_member { result.push val[2] }
+  list_member: expression { result = val[0] }
+             | assignment { result = val[0] }
+
+
+  method_name: IDENTIFIER { result = AST::VarRefNode.new(@filename, nil, val[0].data) }
+
+  term: '@' IDENTIFIER { result = AST::InstanceVarRefNode.new(@filename, nil, "@#{val[1].data}") }
+      | IDENTIFIER { result = AST::VarRefNode.new(@filename, nil, val[0].data) }
+      | CONSTANT { result = AST::ConstantRefNode.new(@filename, nil, val[0].data) }
+      | literal
+      | array
+      | hash
+      | method_call
+      | object_call
+
+  literal: FLOAT { result = AST::LiteralNode.new(@filename, nil, val[0].data.to_f) }
+         | INTEGER { result = AST::LiteralNode.new(@filename, nil, val[0].data.to_i) }
+         | STRING { result = AST::StringNode.new(@filename, nil, val[0].data) }
+         | TRUE { result = AST::LiteralNode.new(@filename, nil, true) }
+         | FALSE { result = AST::LiteralNode.new(@filename, nil, false) }
+         | VOID { result = AST::LiteralNode.new(@filename, nil, nil) }
+
+
+  method_definition: method_name ':' block { result = AST::FunctionDefinitionNode.new(@filename, nil, val[0].variable_name, AST::Function.new(@filename, nil, [], val[2])) }
+                   | method_name LPAREN list RPAREN ':' block { result = AST::FunctionDefinitionNode.new(@filename, nil, val[0].variable_name, AST::Function.new(@filename, nil, val[2], val[5])) }
+
+  method_call: term DOT method_name lambda { result = AST::FunctionCallNode.new(@filename, nil, val[0], val[2].variable_name, [], val[3]) }
+             | term DOT method_name LPAREN list RPAREN lambda { result = AST::FunctionCallNode.new(@filename, nil, val[0], val[2].variable_name, val[4], val[6]) }
+             | method_name LPAREN list RPAREN lambda { result = AST::FunctionCallNode.new(@filename, nil, nil, val[0].variable_name, val[2], val[4]) }
+             | term '[' expression RBRACKET { result = AST::FunctionCallNode.new(@filename, nil, val[0], '[]', [val[2]], nil) }
+
+  object_call: CONSTANT LPAREN list RPAREN lambda { result = AST::InstanceInitNode.new(@filename, nil, val[0].data, val[2], val[4]) }
+
+  multiline_lambda: ARROW LPAREN list RPAREN block { result = AST::BlockNode.new(@filename, nil, val[4], val[2]) }
+                  | ARROW block { result = AST::BlockNode.new(@filename, nil, val[1], []) }
+
+  singleline_lambda: ARROW LPAREN list RPAREN LBRACE statement RBRACE { result = AST::BlockNode.new(@filename, nil, [val[5]], val[2]) }
+                   | ARROW LBRACE statement RBRACE { result = AST::BlockNode.new(@filename, nil, [val[2]], []) }
+  lambda: { result = nil }
+        | multiline_lambda { result = val[0] }
+        | singleline_lambda { result = val[0] }
+
+---- header
+%w(
+  node root_node function_call_node function_definition_node function_node
+  string_node literal_node var_ref_node if_node assignment_node while_node
+  class_definition_node instance_init_node block_node hash_node array_node
+  unary_function_call_node constant_ref_node instance_var_ref_node
+).each { |node| require_relative "../dagon/ast/#{node}" }
+
+---- inner
+
+  def initialize(tokens, filename, debug = false)
+    @yydebug = debug
+    @filename = filename
+    @tokens = tokens
+    @line = 0
+  end
+
+  def parse
+    do_parse
+  end
+
+  def self.parse(tokens, filename, debug = false)
+    new(tokens, filename, debug).parse
+  end
+
+  private
+  attr_accessor :tokens
+  def next_token
+    tokens.shift
+  end
+
+  def on_error error_token_id, error_value, value_stack
+    $stderr.puts "#{@filename}:#{error_value.line}: syntax error, unexpected #{error_value.data.inspect}", value_stack.inspect
+    exit
+  end
+
+  def call_on_object(object, method, *args)
+    AST::FunctionCallNode.new(@filename, nil, object, method, args, nil)
+  end