atomy 0.1.1 → 0.6.3

data/lib/ast/binary_send.rb

@@ -1,44 +0,0 @@
-module Atomy
-  module AST
-    class BinarySend < Node
-      children :lhs, :rhs
-      attributes :operator
-      slots [:private, "false"], :namespace?
-      generate
-
-      alias :method_name :operator
-
-      def register_macro(body, let = false)
-        Atomy::Macro.register(
-          @operator,
-          [@lhs, @rhs].collect do |n|
-            Atomy::Macro.macro_pattern n
-          end,
-          body,
-          let
-        )
-      end
-
-      def message_name
-        Atomy.namespaced(@namespace, @operator)
-      end
-
-      def prepare
-        resolve.expand
-      end
-
-      def bytecode(g)
-        pos(g)
-        @lhs.compile(g)
-        g.push_literal message_name.to_sym unless @namespace == "_"
-        @rhs.compile(g)
-        if @namespace == "_"
-          g.send @operator.to_sym, 1
-        else
-          g.send :atomy_send, 2
-          #g.call_custom method_name.to_sym, 1
-        end
-      end
-    end
-  end
-end

data/lib/ast/block.rb

@@ -1,268 +0,0 @@
-module Atomy
-  module AST
-    class Block < Rubinius::AST::Iter
-      include NodeLike
-      extend SentientNode
-
-      children [:contents], [:arguments]
-      generate
-
-      def block_arguments
-        BlockArguments.new @arguments
-      end
-
-      def block_body
-        BlockBody.new @line, @contents
-      end
-
-      def body
-        InlinedBody.new @line, @contents
-      end
-
-      alias :caller :body
-
-      def bytecode(g)
-        pos(g)
-
-        state = g.state
-        state.scope.nest_scope self
-
-        blk = new_block_generator g, block_arguments
-
-        blk.push_state self
-        blk.state.push_super state.super
-        blk.state.push_eval state.eval
-
-        blk.state.push_name blk.name
-
-        # Push line info down.
-        pos(blk)
-
-        block_arguments.bytecode(blk)
-
-        blk.state.push_block
-        blk.push_modifiers
-        blk.break = nil
-        blk.next = nil
-        blk.redo = blk.new_label
-        blk.redo.set!
-
-        block_body.compile(blk)
-
-        blk.pop_modifiers
-        blk.state.pop_block
-        blk.ret
-        blk.close
-        blk.pop_state
-
-        blk.splat_index = block_arguments.splat_index
-        blk.local_count = local_count
-        blk.local_names = local_names
-
-        g.create_block blk
-
-        g.push_cpath_top
-        g.find_const :Proc
-        g.swap
-        g.send :__from_block__, 1
-      end
-
-      def as_message(send)
-        case send.receiver
-        when Send
-          if send.receiver.method_name == "[]"
-            dup.tap do |b|
-              b.arguments = send.receiver.arguments
-            end.as_message(send.receiver)
-          else
-            send.receiver.dup.tap do |s|
-              s.block = self
-            end
-          end
-        when Variable, Unquote,
-             Constant, ScopedConstant, ToplevelConstant
-          send.receiver = send.receiver.to_send
-          as_message(send)
-        when List
-          dup.tap do |b|
-            b.arguments = send.receiver.elements
-          end
-        else
-          unless send.method_name
-            raise "unknown receiver for block: #{send.receiver.inspect}"
-          end
-        end
-      end
-    end
-
-    class InlinedBody < Node
-      children [:expressions]
-      generate
-
-      attr_accessor :parent
-
-      def variables
-        @variables ||= {}
-      end
-
-      def local_count
-        @parent.local_names
-      end
-
-      def local_names
-        @parent.local_names
-      end
-
-      def allocate_slot
-        @parent.allocate_slot
-      end
-
-      def nest_scope(scope)
-        scope.parent = self
-      end
-
-      def search_local(name)
-        if variable = variables[name]
-          variable.nested_reference
-        else
-          @parent.search_local(name)
-        end
-      end
-
-      def pseudo_local(name)
-        if variable = variables[name]
-          variable.nested_reference
-        elsif reference = @parent.search_local(name)
-          reference.depth += 1
-          reference
-        end
-      end
-
-      def new_local(name)
-        variables[name] =
-          @parent.new_local(name + ":" + @parent.allocate_slot.to_s)
-      end
-
-      def new_nested_local(name)
-        @parent.new_local(name).nested_reference
-      end
-
-      def empty?
-        @expressions.empty?
-      end
-
-      def setup(g)
-        g.state.scope.nest_scope self
-
-        blk = g.state.block?
-        ens = g.state.ensure?
-        res = g.state.rescue?
-        lop = g.state.loop?
-        msn = g.state.masgn?
-
-        g.push_state self
-
-        g.state.push_block if blk
-        g.state.push_ensure if ens
-        g.state.push_rescue(res) if res
-        g.state.push_loop if lop
-        g.state.push_masgn if msn
-      end
-
-      def reset(g)
-        g.pop_state
-      end
-
-      def bytecode(g)
-        pos(g)
-
-        setup(g)
-
-        g.push_nil if empty?
-
-        @expressions.each_with_index do |node,idx|
-          g.pop unless idx == 0
-          node.compile(g)
-        end
-
-        reset(g)
-      end
-    end
-
-    class BlockArguments
-      attr_reader :arguments
-
-      def initialize(args)
-        @arguments = args.collect(&:to_pattern)
-      end
-
-      def bytecode(g)
-        return if @arguments.empty?
-
-        if @arguments.last.kind_of?(Patterns::BlockPass)
-          g.push_block_arg
-          @arguments.pop.deconstruct(g)
-        end
-
-        g.cast_for_splat_block_arg
-        @arguments.each do |a|
-          if a.kind_of?(Patterns::Splat)
-            a.pattern.deconstruct(g)
-            return
-          else
-            g.shift_array
-            a.match(g)
-          end
-        end
-        g.pop
-      end
-
-      def local_names
-        @arguments.collect { |a| a.local_names }.flatten
-      end
-
-      def size
-        @arguments.size
-      end
-
-      def locals
-        local_names.size
-      end
-
-      def required_args
-        size
-      end
-
-      def total_args
-        size
-      end
-
-      def splat_index
-        @arguments.each do |a,i|
-          return i if a.kind_of?(Patterns::Splat)
-        end
-        nil
-      end
-    end
-
-    class BlockBody < Node
-      children [:expressions]
-      generate
-
-      def empty?
-        @expressions.empty?
-      end
-
-      def bytecode(g)
-        pos(g)
-
-        g.push_nil if empty?
-
-        @expressions.each_with_index do |node,idx|
-          g.pop unless idx == 0
-          node.compile(g)
-        end
-      end
-    end
-  end
-end

data/lib/ast/constant.rb

@@ -1,88 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,247 +0,0 @@
-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