Interpreter

lib/ahem.rb

 require 'ahem/ast'
 require 'ahem/cli'
+require 'ahem/core'
+require 'ahem/environment'
+require 'ahem/interpreter'
 require 'ahem/lexer'
 require 'ahem/parser'
 require 'ahem/token'

lib/ahem/ast/array.rb

   def ==(other)
     other.is_a?(AST::Array) && other.elements == @elements
   end
+
+  def execute(env)
+    @elements.map { |el| el.execute(env) }
+  end
 end

lib/ahem/ast/binary.rb

     other.operation == @operation && other.left == @left &&
       other.right == @right
   end
+
+  def execute(env)
+    case @operation
+    when AST::Operators::ADD
+      @left.execute(env) + @right.execute(env)
+    when AST::Operators::SUBTRACT
+      @left.execute(env) - @right.execute(env)
+    when AST::Operators::MULTIPLY
+      @left.execute(env) * @right.execute(env)
+    when AST::Operators::DIVIDE
+      @left.execute(env) / @right.execute(env)
+    when AST::Operators::LESS_THAN
+      @left.execute(env) < @right.execute(env)
+    when AST::Operators::LESS_THAN_OR_EQUAL
+      @left.execute(env) <= @right.execute(env)
+    when AST::Operators::GREATER_THAN
+      @left.execute(env) > @right.execute(env)
+    when AST::Operators::GREATER_THAN_OR_EQUAL
+      @left.execute(env) >= @right.execute(env)
+    when AST::Operators::DOUBLE_EQUALS
+      @left.execute(env) == @right.execute(env)
+    when AST::Operators::OR
+      @left.execute(env) || @right.execute(env)
+    when AST::Operators::AND
+      @left.execute(env) && @right.execute(env)
+    end
+  end
 end

lib/ahem/ast/boolean.rb

   def ==(other)
     other.is_a?(AST::Boolean) && other.value == @value
   end
+
+  def execute(env)
+    @value
+  end
 end

lib/ahem/ast/conditional.rb

   def ==(other)
     other.is_a?(AST::Conditional) && other.branches == @branches
   end
+
+  def execute(env)
+    @branches.each do |branch|
+      if branch.condition.execute(env)
+        value = nil
+        branch.block.statements.each do |statement|
+          value = statement.execute(env)
+        end
+
+        return value
+      end
+    end
+  end
 end

lib/ahem/ast/function_call.rb

     other.is_a?(AST::FunctionCall) && other.function == @function &&
       other.arguments == @arguments
   end
+
+  def execute(env)
+    function = env.get(@function.name)
+
+    if function.is_a?(AST::FunctionDefinition)
+      if @arguments.size != function.parameters.size
+        throw "Arity mismatch in call to function #{function.name}"
+      end
+
+      function.parameters.each_with_index do |param, i|
+        env.set(param.name, @arguments[i].execute(env))
+      end
+
+      value = nil
+
+      function.body.statements.each do |statement|
+        value = statement.execute(env)
+      end
+
+      value
+    elsif function.is_a?(Proc)
+      arguments = @arguments.map { |arg| arg.execute(env) }
+      function.call(*arguments)
+    end
+  end
 end

lib/ahem/ast/function_definition.rb

       other.parameters == @parameters &&
       other.body == @body
   end
+
+  def execute(env)
+    env.set(@name.name, self)
+  end
 end

lib/ahem/ast/identifier.rb

   def ==(other)
     other.is_a?(AST::Identifier) && other.name == @name
   end
+
+  def execute(env)
+    value = env.get(@name)
+
+    if value.respond_to?(:execute)
+      value.execute(env)
+    else
+      value
+    end
+  end
 end

lib/ahem/ast/null.rb

   def ==(other)
     other.is_a?(AST::Null)
   end
+
+  def execute(env)
+    nil
+  end
 end

lib/ahem/ast/number.rb

   def ==(other)
     other.is_a?(AST::Number) && other.value == @value
   end
+
+  def execute(env)
+    @value
+  end
 end

lib/ahem/ast/operators.rb

   GREATER_THAN = :>
   LESS_THAN_OR_EQUAL = :<=
   GREATER_THAN_OR_EQUAL = :>=
+  DOUBLE_EQUALS = :==
   OR = :or
   AND = :and
 end

lib/ahem/ast/string.rb

   def ==(other)
     other.is_a?(AST::String) && other.value == @value
   end
+
+  def execute(env)
+    @value
+  end
 end

lib/ahem/ast/variable_declaration.rb

     other.is_a?(AST::VariableDeclaration) && other.name == @name &&
       other.value == @value
   end
+
+  def execute(env)
+    env.set(@name.name, @value)
+  end
 end

lib/ahem/cli.rb

-require 'pp'
-
 class CLI
   def self.run
     file = ARGV.first
     source = File.read(file).strip
-    Parser.new(Lexer.new(source)).parse.each { |node| pp node }
+    Interpreter.new(Parser.new(Lexer.new(source)).parse).interpret
   end
 end

lib/ahem/core.rb

+CORE = {
+  :print => -> *args do
+    args.each do |arg|
+      if arg.is_a?(Array)
+        puts "[#{arg.join(', ')}]"
+      else
+        puts arg
+      end
+    end
+  end,
+}

lib/ahem/environment.rb

+class Environment
+  attr_reader :data
+
+  def initialize(parent = nil)
+    @data = Hash.new
+
+    CORE.each do |k, v|
+      @data[k.to_s] = v
+    end
+
+    unless parent.nil?
+      parent.data.each do |k, v|
+        @data[k] = v
+      end
+    end
+  end
+
+  def get(name)
+    if @data.has_key?(name)
+      @data[name]
+    else
+      throw "Undefined variable #{name}"
+    end
+  end
+
+  def set(name, value)
+    @data[name] = value
+  end
+end

lib/ahem/interpreter.rb

+class Interpreter
+  def initialize(tree, env = Environment.new)
+    @tree = tree
+    @env = env
+  end
+
+  def interpret
+    @tree.each do |node|
+      node.execute(@env)
+    end
+  end
+end

lib/ahem/lexer.rb

     elsif source.match(/^\./)
       @position += 1
       Token.new(TokenKinds::DOT)
+    elsif source.match(/^==/)
+      @position += 2
+      Token.new(TokenKinds::OPERATOR, :==)      
     elsif source.match(/^\<=/)
       @position += 2
       Token.new(TokenKinds::OPERATOR, :<=)

lib/ahem/parser.rb

   end
 
   def expression
-    expr = binary
-    if @current_token.type == TokenKinds::LPAREN
-      args = arguments
-      AST::FunctionCall.new(expr, args)
-    else
-      expr
-    end
+    binary
   end
 
   private
 
   def primary
     token = @current_token
-    case token.type
+    expr = case token.type
     when TokenKinds::NULL
       advance
       AST::Null.new
     else
       throw "Unexpected token #{token.type}"
     end
+
+    if @current_token.type == TokenKinds::LPAREN
+      args = arguments
+      AST::FunctionCall.new(expr, args)
+    else
+      expr
+    end
   end
 
   def identifier

spec/lexer_spec.rb

   end
 
   it 'lexes operators' do
-    expect(Lexer.new('+-*/<<=>>= and or').scan_all).to eq(
+    expect(Lexer.new('+-*/<<=>>=== and or').scan_all).to eq(
       [
         Token.new(TokenKinds::OPERATOR, :+),
         Token.new(TokenKinds::OPERATOR, :-),
         Token.new(TokenKinds::OPERATOR, :<=),
         Token.new(TokenKinds::OPERATOR, :>),
         Token.new(TokenKinds::OPERATOR, :>=),
+        Token.new(TokenKinds::OPERATOR, :==),
         Token.new(TokenKinds::OPERATOR, :and),
         Token.new(TokenKinds::OPERATOR, :or),
         Token.new(TokenKinds::EOF)

spec/parser_spec.rb

       ]
     )
   end
+
+  it 'gives function calls higher precedence than binary operations' do
+    expect(parse('x + func(y);')).to eq(
+      [
+          AST::Binary.new(
+            AST::Operators::ADD,
+            AST::Identifier.new('x'),
+            AST::FunctionCall.new(
+              AST::Identifier.new('func'),
+              [
+                AST::Identifier.new('y'),
+              ]
+            )
+          )
+      ]
+    )
+  end
 end