atomy 0.1.1

data/lib/ast/internal/ensure.rb

@@ -0,0 +1,135 @@
+module Atomy
+  module AST
+    class Ensure < Node
+      children :body, :ensure
+      generate
+
+      def bytecode(g)
+        pos(g)
+
+        ok = g.new_label
+        ex = g.new_label
+        g.setup_unwind ex, Rubinius::AST::EnsureType
+
+        # TODO: ?
+        g.new_label.set!
+
+        g.push_exception_state
+        outer_exc_state = g.new_stack_local
+        g.set_stack_local outer_exc_state
+        g.pop
+
+        old_break = g.break
+        new_break = g.new_label
+        g.break = new_break
+
+        old_next = g.next
+        new_next = g.new_label
+        g.next = new_next
+
+        g.state.push_ensure
+        @body.compile(g)
+        g.state.pop_ensure
+
+        g.break = old_break
+        g.next = old_next
+
+        g.pop_unwind
+        g.goto ok
+
+        check_break = nil
+
+        if new_break.used?
+          used_break_local = g.new_stack_local
+          check_break = g.new_label
+
+          new_break.set!
+          g.pop_unwind
+
+          g.push :true
+          g.set_stack_local used_break_local
+          g.pop
+
+          g.goto check_break
+        end
+
+        check_next = nil
+
+        if new_next.used?
+          used_next_local = g.new_stack_local
+          check_next = g.new_label
+
+          new_next.set!
+          g.pop_unwind
+
+          g.push :true
+          g.set_stack_local used_next_local
+          g.pop
+
+          g.goto check_next
+        end
+
+        ex.set!
+
+        g.push_exception_state
+
+        g.state.push_rescue(outer_exc_state)
+        @ensure.compile(g)
+        g.state.pop_rescue
+        g.pop
+
+        g.restore_exception_state
+
+        # Re-raise the exception
+        g.reraise
+
+        ok.set!
+
+        if check_break
+          g.push :false
+          g.set_stack_local used_break_local
+          g.pop
+
+          check_break.set!
+        end
+
+        if check_next
+          g.push :false
+          g.set_stack_local used_next_local
+          g.pop
+
+          check_next.set!
+        end
+
+        # Now, re-emit the code for the ensure which will run if there was no
+        # exception generated.
+        @ensure.compile(g)
+        g.pop
+
+        if check_break
+          post = g.new_label
+
+          g.push_stack_local used_break_local
+          g.gif post
+
+          if g.break
+            g.goto g.break
+          else
+            g.raise_break
+          end
+          post.set!
+        end
+
+        if check_next
+          post = g.new_label
+
+          g.push_stack_local used_next_local
+          g.gif post
+
+          g.next ? g.goto(g.next) : g.ret
+          post.set!
+        end
+      end
+    end
+  end
+end

data/lib/ast/internal/file.rb

@@ -0,0 +1,14 @@
+module Atomy
+  module AST
+    class File < Node
+      generate
+
+      def bytecode(g)
+        pos(g)
+        g.push_scope
+        g.send :active_path, 0
+      end
+    end
+  end
+end
+

data/lib/ast/internal/global_variable.rb

@@ -0,0 +1,20 @@
+module Atomy
+  module AST
+    class GlobalVariable < Node
+      attributes :identifier
+      generate
+
+      def name
+        ("$" + @identifier).to_sym
+      end
+
+      def bytecode(g)
+        pos(g)
+        g.push_rubinius
+        g.find_const :Globals
+        g.push_literal name
+        g.send :[], 1
+      end
+    end
+  end
+end

data/lib/ast/internal/if_then_else.rb

@@ -0,0 +1,24 @@
+module Atomy
+  module AST
+    class IfThenElse < Node
+      children :condition, :then, :else
+      generate
+
+      def bytecode(g)
+        done = g.new_label
+        nope = g.new_label
+
+        @condition.compile(g)
+        g.gif nope
+
+        @then.compile(g)
+        g.goto done
+
+        nope.set!
+        @else.compile(g)
+
+        done.set!
+      end
+    end
+  end
+end

data/lib/ast/internal/instance_variable.rb

@@ -0,0 +1,17 @@
+module Atomy
+  module AST
+    class InstanceVariable < Node
+      attributes :identifier
+      generate
+
+      def name
+        ("@" + @identifier).to_sym
+      end
+
+      def bytecode(g)
+        pos(g)
+        g.push_ivar name
+      end
+    end
+  end
+end

data/lib/ast/internal/let_macro.rb

@@ -0,0 +1,35 @@
+module Atomy
+  module AST
+    class LetMacro < Node
+      children :body, [:macros]
+      generate
+
+      def bytecode(g)
+        pos(g)
+
+        defined = {}
+        @macros.each do |m|
+          defined[m.pattern.method_name] =
+            m.pattern.register_macro m.body, true
+        end
+
+        @body.compile(g)
+
+        @macros.each do |m|
+          name = defined[m.pattern.method_name]
+
+          Atomy::Macro::Environment.singleton_class.remove_method(name)
+
+          meth = Atomy::Macro::Environment.let[m.pattern.method_name]
+          next unless meth && !meth.empty?
+
+          Atomy::Macro::Environment.singleton_class.send(
+            :define_method,
+            name,
+            meth.pop
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ast/internal/macro_quote.rb

@@ -0,0 +1,23 @@
+module Atomy
+  module AST
+    class MacroQuote < Node
+      attributes :name, :contents, [:flags]
+      generate
+
+      def bytecode(g)
+        pos(g)
+        g.push_literal :impossible
+      end
+
+      def expand
+        Atomy::Macro::Environment.quote(
+          @name,
+          @contents,
+          @flags
+        ).to_node
+      end
+
+      alias :prepare :expand
+    end
+  end
+end

data/lib/ast/internal/match.rb

@@ -0,0 +1,53 @@
+module Atomy
+  module AST
+    class Match < Node
+      children :target, :body
+      generate
+
+      def bytecode(g)
+        pos(g)
+
+        done = g.new_label
+
+        @target.compile(g)
+
+        @body.contents.each do |e|
+          MatchBranch.new(e.line, e.lhs, e.rhs).bytecode(g, done)
+        end
+
+        g.pop
+        g.push_nil
+
+        done.set!
+      end
+    end
+
+    class MatchBranch < InlinedBody
+      children :pattern, :branch
+      generate
+
+      def bytecode(g, done)
+        pos(g)
+
+        setup(g)
+
+        skip = g.new_label
+
+        pat = @pattern.to_pattern
+        exp = @branch
+
+        g.dup
+        pat.matches?(g)
+        g.gif skip
+
+        pat.deconstruct(g)
+        exp.compile(g)
+        g.goto done
+
+        skip.set!
+
+        reset(g)
+      end
+    end
+  end
+end

data/lib/ast/internal/module.rb

@@ -0,0 +1,30 @@
+module Atomy
+  module AST
+    class Module < Node
+      children :name, :body
+      generate
+
+      def module_name
+        case @name
+        when Constant
+          Rubinius::AST::ModuleName.new @line, @name.name
+        when ToplevelConstant
+          Rubinius::AST::ToplevelModuleName.new @line, @name
+        when ScopedConstant
+          Rubinius::AST::ScopedModuleName.new @line, @name
+        else
+          @name
+        end
+      end
+
+      def module_body
+        Rubinius::AST::ModuleScope.new @line, module_name, @body
+      end
+
+      def bytecode(g)
+        module_name.bytecode(g)
+        module_body.bytecode(g)
+      end
+    end
+  end
+end

data/lib/ast/internal/pattern.rb

@@ -0,0 +1,17 @@
+module Atomy::AST
+  class Pattern < Node
+    attributes :pattern
+    generate
+
+    def construct(g, d = nil)
+      get(g)
+      g.push_int(@line)
+      @pattern.construct(g)
+      g.send :new, 2
+    end
+
+    def bytecode(g)
+      @pattern.construct(g)
+    end
+  end
+end

data/lib/ast/internal/return.rb

@@ -0,0 +1,29 @@
+module Atomy
+  module AST
+    class Return < Node
+      children :value
+      generate
+
+      def bytecode(g, force = false)
+        if @value
+          @value.compile(g)
+        else
+          g.push_nil
+        end
+
+        if lcl = g.state.rescue?
+          g.push_stack_local lcl
+          g.restore_exception_state
+        end
+
+        if g.state.block?
+          g.raise_return
+        elsif !force and g.state.ensure?
+          g.ensure_return
+        else
+          g.ret
+        end
+      end
+    end
+  end
+end

data/lib/ast/internal/set.rb

@@ -0,0 +1,19 @@
+module Atomy
+  module AST
+    class Set < Node
+      children :lhs, :rhs
+      generate
+
+      def bytecode(g)
+        pos(g)
+
+        if @lhs.respond_to?(:assign)
+          @lhs.assign(g, @rhs)
+          return
+        end
+
+        @lhs.to_pattern.assign(g, @rhs, true)
+      end
+    end
+  end
+end

data/lib/ast/internal/singleton_class.rb

@@ -0,0 +1,18 @@
+module Atomy
+  module AST
+    class SingletonClass < Node
+      children :receiver, :body
+      generate
+
+      def sclass_body
+        Rubinius::AST::SClassScope.new @line, @body
+      end
+
+      def bytecode(g)
+        pos(g)
+        @receiver.compile(g)
+        sclass_body.bytecode(g)
+      end
+    end
+  end
+end