atomy 0.1.1

data/lib/ast/constant.rb

@@ -0,0 +1,88 @@
+module Atomy
+  module AST
+    class Constant < Node
+      attributes :identifier
+      generate
+
+      def name
+        @identifier.to_sym
+      end
+
+      def bytecode(g)
+        pos(g)
+        g.push_const name
+      end
+
+      def assign(g, v)
+        g.push_scope
+        g.push_literal name
+        v.compile(g)
+        g.send :const_set, 2
+      end
+
+      def as_message(send)
+        send.dup.tap do |s|
+          s.method_name = @identifier
+        end
+      end
+    end
+
+    class ToplevelConstant < Node
+      attributes :identifier
+      generate
+
+      def name
+        @identifier.to_sym
+      end
+
+      def bytecode(g)
+        pos(g)
+        g.push_cpath_top
+        g.find_const name
+      end
+
+      def assign(g, v)
+        g.push_cpath_top
+        g.push_literal name
+        v.compile(g)
+        g.send :const_set, 2
+      end
+
+      def as_message(send)
+        send.dup.tap do |s|
+          s.method_name = @identifier
+        end
+      end
+    end
+
+    class ScopedConstant < Node
+      children :parent
+      attributes :identifier
+      generate
+
+      def name
+        @identifier.to_sym
+      end
+
+      def bytecode(g)
+        pos(g)
+        @parent.compile(g)
+        g.find_const name
+      end
+
+      def assign(g, v)
+        @parent.compile(g)
+        g.push_literal name
+        v.compile(g)
+        g.send :const_set, 2
+      end
+
+      def as_message(send)
+        send.dup.tap do |s|
+          s.method_name = @identifier
+          s.receiver = @parent
+        end
+      end
+    end
+  end
+end

data/lib/ast/internal/assign.rb

@@ -0,0 +1,19 @@
+module Atomy
+  module AST
+    class Assign < 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)
+      end
+    end
+  end
+end

data/lib/ast/internal/block_pass.rb

@@ -0,0 +1,21 @@
+module Atomy::AST
+  class BlockPass < Node
+    children :body
+    generate
+    def bytecode(g)
+      @body.compile(g)
+      nil_block = g.new_label
+      g.dup
+      g.is_nil
+      g.git nil_block
+
+      g.push_cpath_top
+      g.find_const :Proc
+
+      g.swap
+      g.send :__from_block__, 1
+
+      nil_block.set!
+    end
+  end
+end

data/lib/ast/internal/catch.rb

@@ -0,0 +1,247 @@
+module Atomy
+  module AST
+    class Catch < Node
+      children :body, [:handlers], :else?
+      generate
+
+      # via Rubinius::AST::Rescue
+      def bytecode(g)
+        pos(g)
+
+        g.push_modifiers
+        if @body.nil?
+          if @else.nil?
+            # Stupid. No body and no else.
+            g.push :nil
+          else
+            # Only an else, run it.
+            @else.compile(g)
+          end
+        else
+          outer_retry = g.retry
+
+          this_retry = g.new_label
+          reraise = g.new_label
+          els     = g.new_label
+          done    = g.new_label
+
+          # Save the current exception into a stack local
+          g.push_exception_state
+          outer_exc_state = g.new_stack_local
+          g.set_stack_local outer_exc_state
+          g.pop
+
+          this_retry.set!
+          ex = g.new_label
+          g.setup_unwind ex, Rubinius::AST::RescueType
+
+          # TODO: ?
+          g.new_label.set!
+
+          if current_break = g.break
+            # Make a break available to use, which we'll use to
+            # lazily generate a cleanup area
+            g.break = g.new_label
+          end
+
+          # Setup a lazy cleanup area for next'ing out of the handler
+          current_next = g.next
+          g.next = g.new_label
+
+          # Use a lazy label to patch up prematuraly leaving a begin
+          # body via retry.
+          if outer_retry
+            g.retry = g.new_label
+          end
+
+          # Also handle redo unwinding through the rescue
+          if current_redo = g.redo
+            g.redo = g.new_label
+          end
+
+          @body.compile(g)
+          g.pop_unwind
+          g.goto els
+
+          if current_break
+            if g.break.used?
+              g.break.set!
+              g.pop_unwind
+
+              # Reset the outer exception
+              g.push_stack_local outer_exc_state
+              g.restore_exception_state
+
+              g.goto current_break
+            end
+
+            g.break = current_break
+          end
+
+          if g.next.used?
+            g.next.set!
+            g.pop_unwind
+
+            # Reset the outer exception
+            g.push_stack_local outer_exc_state
+            g.restore_exception_state
+
+            if current_next
+              g.goto current_next
+            else
+              g.ret
+            end
+          end
+
+          g.next = current_next
+
+          if current_redo
+            if g.redo.used?
+              g.redo.set!
+              g.pop_unwind
+
+              # Reset the outer exception
+              g.push_stack_local outer_exc_state
+              g.restore_exception_state
+
+              g.goto current_redo
+            end
+
+            g.redo = current_redo
+          end
+
+          if outer_retry
+            if g.retry.used?
+              g.retry.set!
+              g.pop_unwind
+
+              # Reset the outer exception
+              g.push_stack_local outer_exc_state
+              g.restore_exception_state
+
+              g.goto outer_retry
+            end
+
+            g.retry = outer_retry
+          end
+
+          # We jump here if an exception has occured in the body
+          ex.set!
+
+          # Expose the retry label here only, not before this.
+          g.retry = this_retry
+
+          # Save exception state to use in reraise
+          g.push_exception_state
+
+          raised_exc_state = g.new_stack_local
+          g.set_stack_local raised_exc_state
+          g.pop
+
+          # Save the current exception, so that calling #=== can't trample
+          # it.
+          g.push_current_exception
+
+          @handlers.each_with_index do |p, i|
+            last = i + 1 == @handlers.size
+            n = last ? nil : g.new_label
+            handler_bytecode(g, p.lhs.to_pattern, p.rhs, reraise, done, outer_exc_state, n)
+            n.set! unless last
+          end
+
+          reraise.set!
+
+          # Restore the exception state we saved and the reraise. The act
+          # of checking if an exception matches can run any code, which
+          # can easily trample on the current exception.
+          #
+          # Remove the direct exception so we can get to the state
+          g.pop
+
+          # Restore the state and reraise
+          g.push_stack_local raised_exc_state
+          g.restore_exception_state
+          g.reraise
+
+          els.set!
+          if @else
+            g.pop
+            @else.compile(g)
+          end
+
+          done.set!
+
+          g.push_stack_local outer_exc_state
+          g.restore_exception_state
+        end
+        g.pop_modifiers
+      end
+
+      def handler_bytecode(g, pattern, expression, reraise, done, outer_exc_state, next_handler = nil)
+        body = g.new_label
+
+        g.dup
+        pattern.matches?(g)
+        g.git body
+
+        if next_handler
+          g.goto next_handler
+        else
+          g.goto reraise
+        end
+
+        body.set!
+
+        pattern.deconstruct(g)
+
+        current_break = g.break
+        g.break = g.new_label
+
+        current_next = g.next
+        g.next = g.new_label
+
+        g.state.push_rescue(outer_exc_state)
+        expression.compile(g)
+        g.state.pop_rescue
+
+        g.clear_exception
+        g.goto done
+
+        if g.break.used?
+          g.break.set!
+          g.clear_exception
+
+          # Reset the outer exception
+          g.push_stack_local outer_exc_state
+          g.restore_exception_state
+
+          if current_break
+            g.goto current_break
+          else
+            g.raise_break
+          end
+        end
+
+        g.break = current_break
+
+        if g.next.used?
+          g.next.set!
+
+          g.clear_exception
+
+          # Reset the outer exception
+          g.push_stack_local outer_exc_state
+          g.restore_exception_state
+
+          if current_next
+            g.goto current_next
+          else
+            g.ret
+          end
+        end
+
+        g.next = current_next
+      end
+    end
+  end
+end

data/lib/ast/internal/class.rb

@@ -0,0 +1,30 @@
+module Atomy
+  module AST
+    class Class < Node
+      children :name, :body, [:superclass, "Primitive.new(0, :nil)"]
+      generate
+
+      def class_name
+        case @name
+        when Constant
+          Rubinius::AST::ClassName.new @line, @name.name, @superclass
+        when ToplevelConstant
+          Rubinius::AST::ToplevelModuleName.new @line, @name, @superclass
+        when ScopedConstant
+          Rubinius::AST::ScopedClassName.new @line, @name, @superclass
+        else
+          @name
+        end
+      end
+
+      def class_body
+        Rubinius::AST::ClassScope.new @line, class_name, @body
+      end
+
+      def bytecode(g)
+        class_name.bytecode(g)
+        class_body.bytecode(g)
+      end
+    end
+  end
+end

data/lib/ast/internal/class_variable.rb

@@ -0,0 +1,23 @@
+module Atomy
+  module AST
+    class ClassVariable < Node
+      attributes :identifier
+      generate
+
+      def name
+        ("@@" + @identifier).to_sym
+      end
+
+      def bytecode(g)
+        pos(g)
+        if g.state.scope.module?
+          g.push :self
+        else
+          g.push_scope
+        end
+        g.push_literal name
+        g.send :class_variable_get, 1
+      end
+    end
+  end
+end

data/lib/ast/internal/define.rb

@@ -0,0 +1,174 @@
+module Atomy
+  module AST
+    class Define < Node
+      children :pattern, :body
+      slots :namespace?
+      generate
+
+      def arguments
+        return @arguments if @arguments
+
+        case pattern
+        when BinarySend
+          args = [pattern.rhs]
+        when Variable, Unary
+          args = []
+        else
+          args = pattern.arguments
+        end
+
+        @arguments = args.collect(&:to_pattern)
+      end
+
+      def receiver
+        return @receiver if @receiver
+
+        case pattern
+        when BinarySend
+          recv = pattern.lhs
+        when Variable
+          recv = Primitive.new(pattern.line, :self)
+        else
+          recv = pattern.receiver
+        end
+
+        @receiver = recv.to_pattern
+      end
+
+      def method_name
+        case pattern
+        when Variable
+          pattern.name
+        else
+          pattern.method_name
+        end
+      end
+
+      def ns_method_name(g)
+        if method_name == "initialize"
+          g.push_literal :initialize
+          return
+        end
+
+        if @namespace
+          g.push_literal(
+            Atomy.namespaced(@namespace, method_name).to_sym
+          )
+          return
+        end
+
+        no_ns = g.new_label
+        done = g.new_label
+
+        g.push_cpath_top
+        g.find_const :Atomy
+        g.push_cpath_top
+        g.find_const :Atomy
+        g.find_const :Namespace
+        g.send :get, 0
+        g.dup
+        g.gif no_ns
+
+        g.send :name, 0
+        g.send :to_s, 0
+        g.push_literal method_name
+        g.send :namespaced, 2
+        g.goto done
+
+        no_ns.set!
+        g.pop
+        g.pop
+        g.push_literal method_name
+
+        done.set!
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        defn = receiver.kind_of?(Patterns::Match) && receiver.value == :self
+
+        if defn
+          g.push_rubinius
+          ns_method_name(g)
+          g.send :to_sym, 0
+          g.dup
+          g.push_cpath_top
+          g.find_const :Atomy
+          g.swap
+        else
+          g.push_cpath_top
+          g.find_const :Atomy
+          receiver.target(g)
+          ns_method_name(g)
+          g.send :to_sym, 0
+        end
+
+        create = g.new_label
+        added = g.new_label
+        receiver.construct(g)
+        arguments.each do |p|
+          p.construct(g)
+        end
+        g.make_array arguments.size
+        g.make_array 2
+        @body.construct(g, nil)
+        g.make_array 2
+
+        receiver.target(g)
+        g.push_literal "@atomy::"
+        ns_method_name(g)
+        g.string_build 2
+        g.send :to_sym, 0
+        g.send :instance_variable_get, 1
+        g.dup
+        g.gif create
+
+        g.push_cpath_top
+        g.find_const :Atomy
+        g.move_down 2
+        g.send :insert_method, 2
+        g.goto added
+
+        create.set!
+        g.pop
+        g.make_array 1
+        receiver.target(g)
+        g.swap
+        g.push_literal "@atomy::"
+        ns_method_name(g)
+        g.string_build 2
+        g.send :to_sym, 0
+        g.swap
+        g.send :instance_variable_set, 2
+
+        added.set!
+
+        if defn
+          g.push_false
+          g.push_scope
+          g.send :active_path, 0
+          g.push_int @line
+          g.send :build_method, 5
+          g.push_scope
+          g.push_variables
+          g.send :method_visibility, 0
+          g.send :add_defn_method, 4
+        else
+          g.push_scope
+          g.send :add_method, 4
+        end
+      end
+
+      def local_count
+        local_names.size
+      end
+
+      def local_names
+        arguments.inject(receiver.local_names) do |acc, a|
+          acc + a.local_names
+        end
+      end
+    end
+  end
+end