toylang 0.2.0

data/lib/toylang/interpreter/evaluation.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative '../parser/parser'
+require_relative '../runtime/object'
+require_relative '../runtime/class'
+require_relative '../runtime/method'
+require_relative '../runtime/context'
+require_relative '../runtime/bootstrap'
+
+class Nodes
+  def eval(context)
+    return_value = nil
+    nodes.each do |node|
+      return_value = node.eval(context)
+    end
+    return_value || Runtime['nil']
+  end
+end
+
+class NumberNode
+  def eval(_context)
+    Runtime['Number'].new_with_value(value)
+  end
+end
+
+class StringNode
+  def eval(_context)
+    Runtime['String'].new_with_value(value)
+  end
+end
+
+class TrueNode
+  def eval(_context)
+    Runtime['true']
+  end
+end
+
+class FalseNode
+  def eval(_context)
+    Runtime['false']
+  end
+end
+
+class NilNode
+  def eval(_context)
+    Runtime['nil']
+  end
+end
+
+class GetConstantNode
+  def eval(context)
+    context[name]
+  end
+end
+
+class GetLocalNode
+  def eval(context)
+    context.locals[name]
+  end
+end
+
+class SetConstantNode
+  def eval(context)
+    raise "Unable to re-assigne constant: #{name}" unless context[name].nil?
+
+    context[name] = value.eval(context)
+  end
+end
+
+class SetLocalNode
+  def eval(context)
+    context.locals[name] = value.eval(context)
+  end
+end
+
+class CallNode
+  def eval(context)
+    if receiver.nil? && context.locals[call_method] && arguments.empty?
+      context.locals[call_method]
+    else
+      value = if receiver
+                receiver.eval(context)
+              else
+                context.current_self
+              end
+      eval_arguments = arguments.map { |arg| arg.eval(context) }
+      value.call(call_method, eval_arguments)
+    end
+  end
+end
+
+class DefNode
+  def eval(context)
+    method = ToyLangMethod.new(params, body)
+    context.current_class.runtime_methods[name] = method
+  end
+end
+
+class ClassNode
+  def eval(context)
+    toylang_class = context[name]
+
+    unless toylang_class
+      toylang_class = ToyLangClass.new(Runtime[superclass || 'Object'])
+      context[name] = toylang_class
+    end
+
+    class_context = Context.new(toylang_class, toylang_class)
+    body.eval(class_context)
+
+    toylang_class
+  end
+end
+
+class IfElseNode
+  def eval(context)
+    if condition.eval(context).ruby_value
+      body.eval(context)
+    elsif else_body.nil?
+      Runtime['nil']
+    else
+      else_body.eval(context)
+    end
+  end
+end
+
+class WhileNode
+  def eval(context)
+    body.eval(context) while condition.eval(context).ruby_value
+  end
+end

data/lib/toylang/interpreter/interpreter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../parser/parser'
+require_relative '../runtime/bootstrap'
+
+class Interpreter
+  def initialize
+    @parser = Parser.new
+  end
+
+  def eval(code)
+    @parser.parse(code).eval(Runtime)
+  end
+end

data/lib/toylang/lexer/lexer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+class Lexer
+  KEYWORDS = %w[def class if else true false nil while].freeze
+
+  def tokenize(code)
+    code = code.chomp.gsub(/^$\n/, '')
+    tokens = []
+    parse_indent = true
+
+    current_indent = 0
+    indent_stack = []
+
+    position = 0
+    while position < code.size
+      chunk = code[position..-1]
+
+      if chunk.start_with?('#')
+        next_line = chunk.index("\n")
+        offset = if next_line.nil?
+                   chunk.size
+                 else
+                   next_line
+                 end
+
+      elsif (identifier = chunk[/\A([a-z]\w*)/, 1])
+        token, offset = tokenize_identifier(identifier)
+        tokens << token
+
+      elsif (constant = chunk[/\A([A-Z]\w*)/, 1])
+        tokens << [:CONSTANT, constant]
+        offset = constant.size
+
+      elsif (number = chunk[/\A(([0-9]*[.])?[0-9]+)/, 1])
+        tokens << [:NUMBER, number.to_numeric]
+        offset = number.size
+
+      elsif (string = chunk[/\A"([^"]*)"/, 1])
+        tokens << [:STRING, string]
+        offset = string.size + 2
+
+      # Matches ": <newline> <spaces>"
+      elsif parse_indent && (indent = chunk[/\A:\n( +)/m, 1])
+        if indent.size <= current_indent
+          raise "Bad indent level, got #{indent.size} indents, " \
+                "expected > #{current_indent}"
+        end
+        current_indent = indent.size
+        indent_stack.push(current_indent)
+        tokens << [:INDENT, indent.size]
+        offset = indent.size + 2
+
+      elsif parse_indent && (indent = chunk[/\A\n( *)/m, 1])
+        if indent.size == current_indent
+          tokens << [:NEWLINE, "\n"]
+        elsif indent.size < current_indent
+          while indent.size < current_indent
+            indent_stack.pop
+            current_indent = indent_stack.last || 0
+            tokens << [:DEDENT, indent.size]
+          end
+          tokens << [:NEWLINE, "\n"]
+        else
+          raise "Missing ':'"
+        end
+        offset = indent.size + 1
+
+      elsif (operator = chunk[
+        %r{\A(\|\||&&|==|!=|<=|>=|\+=|-=|\*=|/=|%=|\*\*=|&=|\|=|\^=|<<|>>|<<=|>>=|&&=|\|\|=|\*\*)}, 1])
+        tokens << [operator, operator]
+        offset = operator.size
+
+      elsif chunk.start_with?(' ')
+        offset = 1
+
+      else
+        value = chunk[0, 1]
+        tokens << [value, value]
+        offset = 1
+      end
+      position += offset
+    end
+
+    # Close all open blocks. If the code ends without dedenting, this will take care of
+    tokens << [:DEDENT, indent_stack.first || 0] while indent_stack.pop
+    tokens
+  end
+
+  def tokenize_identifier(identifier)
+    token = if KEYWORDS.include?(identifier)
+              # keywords will generate [:IF, "if"]
+              [identifier.upcase.to_sym, identifier]
+            else
+              [:IDENTIFIER, identifier]
+            end
+    [token, identifier.size]
+  end
+end

data/lib/toylang/monkey_patching/string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class String
+  def numeric_string?
+    !Float(self).nil?
+  rescue StandardError
+    false
+  end
+
+  def to_numeric
+    return unless numeric_string?
+
+    if index('.')
+      to_f
+    else
+      to_i
+    end
+  end
+end