atomy 0.1.1 → 0.6.3

data/lib/atomy/code/assign.rb

@@ -0,0 +1,64 @@
+module Atomy
+  module Code
+    class Assign
+      def initialize(pattern, value)
+        @pattern = pattern
+        @value = value
+      end
+
+      def bytecode(gen, mod)
+        pattern = mod.pattern(@pattern)
+
+        # [value]
+        mod.compile(gen, @value)
+
+        # [value, value]
+        gen.dup
+        # [pattern, value, value]
+        mod.compile(gen, pattern)
+        # [value, pattern, value]
+        gen.swap
+
+        # [value, pattern, value, pattern, value]
+        gen.dup_many(2)
+
+        mismatch = gen.new_label
+        done = gen.new_label
+
+        # [bool, value, pattern, value]
+        gen.send(:matches?, 1)
+
+        # [value, pattern, value]
+        gen.gif(mismatch)
+
+        # [value, pattern, value]
+        pattern.assign(gen)
+
+        # [value]
+        gen.pop_many(2)
+
+        # [value]
+        gen.goto(done)
+
+        # [value, pattern, value]
+        mismatch.set!
+
+        # [::, value, pattern, value]
+        gen.push_cpath_top
+        # [::Atomy, value, pattern, value]
+        gen.find_const(:Atomy)
+        # [::Atomy::PatternMismatch, value, pattern, value]
+        gen.find_const(:PatternMismatch)
+        # [value, pattern, ::Atomy::PatternMismatch, value]
+        gen.move_down(2)
+        # [#<Atomy::PatternMismatch>, value]
+        gen.send(:new, 2)
+        # exception
+        gen.raise_exc
+
+        # [value]
+        done.set!
+      end
+    end
+  end
+end

data/lib/atomy/code/block.rb

@@ -0,0 +1,98 @@
+module Atomy
+  module Code
+    class Block
+      def initialize(body, args = [], proc_argument = nil, lambda_style = true)
+        @body = body
+
+        @arguments = args.dup
+        if args.last.is_a?(Atomy::Grammar::AST::Prefix) && args.last.operator == :*
+          @splat_argument = @arguments.pop
+        end
+
+        @proc_argument = proc_argument
+
+        @lambda_style = lambda_style
+      end
+
+      def bytecode(gen, mod)
+        blk = build_block(gen.state.scope, mod)
+
+        if @lambda_style
+          gen.push_cpath_top
+          gen.find_const :Proc
+        end
+
+        gen.create_block(blk)
+
+        if @lambda_style
+          gen.send(:__from_block__, 1)
+          gen.dup
+          gen.send(:lambda_style!, 0)
+          gen.pop
+        end
+      end
+
+      private
+
+      def build_block(scope, mod)
+        Atomy::Compiler.generate(mod.file) do |blk|
+          # close over the outer scope
+          blk.state.scope.parent = scope
+
+          # for now, only allow a fixed set of arguments
+          blk.required_args = blk.total_args = @arguments.size
+
+          if @lambda_style
+            # discard extra arguments
+            blk.splat_index = @arguments.size
+          end
+
+          # this bubbles up to Proc#arity and BlockEnvironment, though it
+          # doesn't appear to change actual behavior of the block
+          if @splat_argument
+            # this is + 1 so that if there are no args the arity is -1, not -0
+            # (which is not a thing)
+            blk.arity = -(@arguments.size + 1)
+          else
+            blk.arity = @arguments.size
+          end
+
+          # create a local for each argument name
+          @arguments.each.with_index do |a, i|
+            blk.state.scope.new_local(:"arg:#{i}")
+          end
+
+          # local for discarded splat args
+          blk.state.scope.new_local(:"arg:extra")
+
+          # pattern-match all args
+          @arguments.each.with_index do |a, i|
+            Assign.new(a, Variable.new(:"arg:#{i}")).bytecode(blk, mod)
+          end
+
+          # pattern-match the splat arg
+          if @splat_argument
+            Assign.new(@splat_argument, Variable.new(:"arg:extra")).bytecode(blk, mod)
+          end
+
+          # pattern-match the proc arg
+          if @proc_argument
+            Assign.new(@proc_argument, PushProc.new).bytecode(blk, mod)
+          end
+
+          # build the block's body
+          mod.compile(blk, @body)
+        end
+      end
+
+      class PushProc
+        def initialize
+        end
+
+        def bytecode(gen, mod)
+          gen.push_proc
+        end
+      end
+    end
+  end
+end

data/lib/atomy/code/class_variable.rb

@@ -0,0 +1,17 @@
+module Atomy
+  module Code
+    class ClassVariable
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def bytecode(gen, mod)
+        gen.push_scope
+        gen.push_literal(:"@@#{@name}")
+        gen.send(:class_variable_get, 1)
+      end
+    end
+  end
+end

data/lib/atomy/code/constant.rb

@@ -0,0 +1,21 @@
+module Atomy
+  module Code
+    class Constant
+      attr_reader :name, :parent
+
+      def initialize(name, parent = nil)
+        @name = name
+        @parent = parent
+      end
+
+      def bytecode(gen, mod)
+        if @parent
+          mod.compile(gen, @parent)
+          gen.find_const(@name)
+        else
+          gen.push_const(@name)
+        end
+      end
+    end
+  end
+end

data/lib/atomy/code/define.rb

@@ -0,0 +1,242 @@
+module Atomy
+  module Code
+    class Define
+      def initialize(name, body = nil, receiver = nil, arguments = [],
+                     default_arguments = [], splat_argument = nil,
+                     post_arguments = [], proc_argument = nil)
+        @name = name
+        @body = body
+        @receiver = receiver
+        @arguments = arguments
+        @default_arguments = default_arguments
+        @splat_argument = splat_argument
+        @post_arguments = post_arguments
+        @proc_argument = proc_argument
+      end
+
+      private
+
+      def push_branch(gen, mod)
+        gen.push_cpath_top
+        gen.find_const(:Atomy)
+        gen.find_const(:Method)
+        gen.find_const(:Branch)
+
+        if @receiver
+          mod.compile(gen, receiver_pattern(mod))
+        else
+          gen.push_nil
+        end
+
+        pre_argument_patterns(mod).each do |p|
+          mod.compile(gen, p)
+        end
+        gen.make_array(@arguments.size)
+
+        default_argument_patterns(mod).each do |d, p|
+          mod.compile(gen, p)
+        end
+        gen.make_array(@default_arguments.size)
+
+        if p = splat_argument_pattern(mod)
+          mod.compile(gen, p)
+        else
+          gen.push_nil
+        end
+
+        post_argument_patterns(mod).each do |p|
+          mod.compile(gen, p)
+        end
+        gen.make_array(@post_arguments.size)
+
+        if p = proc_argument_pattern(mod)
+          mod.compile(gen, p)
+        else
+          gen.push_nil
+        end
+
+        gen.create_block(build_block(gen.state.scope, mod, @name, @body))
+
+        gen.send_with_block(:new, 6)
+      end
+
+      def build_block(scope, mod, name, body)
+        Atomy::Compiler.generate(mod.file) do |blk|
+          # set method name so calls to super work
+          blk.name = name
+
+          # close over the outer scope
+          blk.state.scope.parent = scope
+
+          total_patterns = 0
+          total_patterns += 1 if @receiver
+          total_patterns += @arguments.size + @default_arguments.size + @post_arguments.size
+          total_patterns += 1 if @splat_argument
+          total_patterns += 1 if @proc_argument
+
+          blk.total_args = total_patterns * 2
+          blk.required_args = blk.total_args
+
+          # this bubbles up to Proc#arity and BlockEnvironment, though it
+          # doesn't appear to change actual behavior of the block
+          blk.arity = blk.total_args
+
+          arg = 0
+
+          if @receiver
+            blk.state.scope.new_local("arg:self:pat")
+            blk.state.scope.new_local("arg:self")
+          end
+
+          @arguments.size.times do
+            blk.state.scope.new_local(:"arg:#{arg}:pat")
+            blk.state.scope.new_local(:"arg:#{arg}")
+            arg += 1
+          end
+
+          @default_arguments.size.times do
+            blk.state.scope.new_local(:"arg:#{arg}:pat")
+            blk.state.scope.new_local(:"arg:#{arg}")
+            arg += 1
+          end
+
+          if @splat_argument
+            blk.state.scope.new_local(:"arg:splat:pat")
+            blk.state.scope.new_local(:"arg:splat")
+          end
+
+          @post_arguments.size.times do
+            blk.state.scope.new_local(:"arg:#{arg}:pat")
+            blk.state.scope.new_local(:"arg:#{arg}")
+            arg += 1
+          end
+
+          if @proc_argument
+            blk.state.scope.new_local(:"arg:proc:pat")
+            blk.state.scope.new_local(:"arg:proc")
+          end
+
+          loc = 0
+          if p = receiver_pattern(mod)
+            blk.push_local(loc)
+            blk.push_local(loc+1)
+            p.assign(blk)
+            blk.pop_many(2)
+
+            loc += 2
+          end
+
+          pre_argument_patterns(mod).each do |p|
+            blk.push_local(loc)
+            blk.push_local(loc+1)
+            p.assign(blk)
+            blk.pop_many(2)
+
+            loc += 2
+          end
+
+          default_argument_patterns(mod).each do |d, p|
+            assign = blk.new_label
+
+            # [pat]
+            blk.push_local(loc)
+
+            # [val, pat]
+            blk.push_local(loc+1)
+
+            # [val, val, pat]
+            blk.dup
+
+            # [val, pat]
+            blk.goto_if_not_undefined(assign)
+
+            # [pat]
+            blk.pop
+
+            # [val, pat]
+            mod.compile(blk, d.default)
+
+            assign.set!
+
+            # [val, pat]
+            p.assign(blk)
+
+            # []
+            blk.pop_many(2)
+
+            loc += 2
+          end
+
+          if p = splat_argument_pattern(mod)
+            blk.push_local(loc)
+            blk.push_local(loc+1)
+            p.assign(blk)
+            blk.pop_many(2)
+
+            loc += 2
+          end
+
+          post_argument_patterns(mod).each do |p|
+            blk.push_local(loc)
+            blk.push_local(loc+1)
+            p.assign(blk)
+            blk.pop_many(2)
+
+            loc += 2
+          end
+
+          if p = proc_argument_pattern(mod)
+            blk.push_local(loc)
+            blk.push_local(loc+1)
+            p.assign(blk)
+            blk.pop_many(2)
+
+            loc += 2
+          end
+
+          # build the method branch's body
+          mod.compile(blk, body)
+        end
+      end
+
+      def receiver_pattern(mod)
+        return unless @receiver
+
+        @receiver_pattern ||= mod.pattern(@receiver)
+      end
+
+      def pre_argument_patterns(mod)
+        @pre_argument_patterns ||=
+          @arguments.collect do |a|
+            mod.pattern(a)
+          end
+      end
+
+      def default_argument_patterns(mod)
+        @default_argument_patterns ||=
+          @default_arguments.collect do |d|
+            [d, mod.pattern(d.node)]
+          end
+      end
+
+      def post_argument_patterns(mod)
+        @post_argument_patterns ||=
+          @post_arguments.collect do |a|
+            mod.pattern(a)
+          end
+      end
+
+      def splat_argument_pattern(mod)
+        return unless @splat_argument
+
+        @splat_argument_pattern ||= mod.pattern(@splat_argument)
+      end
+
+      def proc_argument_pattern(mod)
+        return unless @proc_argument
+
+        @proc_argument_pattern ||= mod.pattern(@proc_argument)
+      end
+    end
+  end
+end

data/lib/atomy/code/define_function.rb

@@ -0,0 +1,51 @@
+require "atomy/compiler"
+require "atomy/code/define"
+
+module Atomy
+  module Code
+    class DefineFunction < Define
+      def bytecode(gen, mod)
+        var = assignment_local(gen, :"#{@name}:function")
+
+        gen.push_rubinius
+        gen.find_const(:BlockEnvironment)
+        gen.find_const(:AsMethod)
+
+        gen.push_rubinius
+        gen.find_const(:BlockEnvironment)
+        gen.send(:new, 0)
+
+        if @body
+          gen.push_variables
+
+          gen.push_cpath_top
+          gen.find_const(:Atomy)
+          gen.push_scope
+          gen.push_literal(@name)
+          push_branch(gen, mod)
+          gen.send(:register_branch, 3)
+          gen.send(:first, 0)
+          gen.send(:build, 0)
+
+          gen.send(:under_context, 2)
+        end
+
+        gen.send(:new, 1)
+
+        var.set_bytecode(gen)
+      end
+
+      private
+
+      def assignment_local(gen, name)
+        var = gen.state.scope.search_local(name)
+
+        if var && var.depth == 0
+          var
+        else
+          gen.state.scope.new_local(name).nested_reference
+        end
+      end
+    end
+  end
+end