atomy 0.1.1 → 0.6.3

data/lib/atomy/code/quote.rb

@@ -0,0 +1,13 @@
+module Atomy
+  module Code
+    class Quote
+      def initialize(node)
+        @node = node
+      end
+
+      def bytecode(gen, mod)
+        @node.construct(gen)
+      end
+    end
+  end
+end

data/lib/atomy/code/self.rb

@@ -0,0 +1,9 @@
+module Atomy
+  module Code
+    class Self
+      def bytecode(gen, mod)
+        gen.push_self
+      end
+    end
+  end
+end

data/lib/atomy/code/send.rb

@@ -0,0 +1,110 @@
+module Atomy
+  module Code
+    class Send
+      attr_reader :receiver, :message, :arguments, :proc_argument, :block
+
+      def initialize(receiver, message, arguments = [], splat_argument = nil, proc_argument = nil, block = nil)
+        @receiver = receiver
+        @message = message
+        @arguments = arguments
+        @splat_argument = splat_argument
+        @proc_argument = proc_argument
+        @block = block
+      end
+
+      def bytecode(gen, mod)
+        if @receiver.nil? && fun = gen.state.scope.search_local(:"#{@message}:function")
+          invoke_function(gen, mod, fun)
+        else
+          invoke_method(gen, mod)
+        end
+      end
+
+      private
+
+      def invoke_function(gen, mod, fun)
+        fun.get_bytecode(gen)
+
+        gen.dup
+        gen.send(:block_env, 0)
+        gen.send(:constant_scope, 0)
+        gen.send(:module, 0)
+
+        gen.push_literal(@message)
+
+        gen.swap
+
+        gen.push_self
+
+        @arguments.each do |arg|
+          mod.compile(gen, arg)
+        end
+        gen.make_array(@arguments.size)
+
+        if @splat_argument
+          mod.compile(gen, @splat_argument)
+          gen.send(:+, 1)
+        end
+
+        if @proc_argument
+          push_proc_argument(gen, mod)
+        elsif @block
+          mod.compile(gen, @block)
+        else
+          gen.push_nil
+        end
+
+        gen.send(:invoke, 5)
+      end
+
+      def invoke_method(gen, mod)
+        if @receiver
+          mod.compile(gen, @receiver)
+        else
+          gen.push_self
+        end
+
+        @arguments.each do |arg|
+          mod.compile(gen, arg)
+        end
+
+        if @splat_argument
+          mod.compile(gen, @splat_argument)
+          if @proc_argument
+            push_proc_argument(gen, mod)
+          elsif @block
+            mod.compile(gen, @block)
+          else
+            gen.push_nil
+          end
+          gen.allow_private unless @receiver
+          gen.send_with_splat(@message, @arguments.size)
+        elsif @proc_argument
+          push_proc_argument(gen, mod)
+          gen.allow_private unless @receiver
+          gen.send_with_block(@message, @arguments.size)
+        elsif @block
+          mod.compile(gen, @block)
+          gen.allow_private unless @receiver
+          gen.send_with_block(@message, @arguments.size)
+        else
+          gen.allow_private unless @receiver
+          gen.send(@message, @arguments.size)
+        end
+
+        def push_proc_argument(gen, mod)
+          nil_proc_arg = gen.new_label
+          mod.compile(gen, @proc_argument)
+          gen.dup
+          gen.is_nil
+          gen.git(nil_proc_arg)
+          gen.push_cpath_top
+          gen.find_const(:Proc)
+          gen.swap
+          gen.send(:__from_block__, 1)
+          nil_proc_arg.set!
+        end
+      end
+    end
+  end
+end

data/lib/atomy/code/sequence.rb

@@ -0,0 +1,23 @@
+module Atomy
+  module Code
+    class Sequence
+      attr_reader :nodes
+
+      def initialize(nodes)
+        @nodes = nodes
+      end
+
+      def bytecode(gen, mod)
+        if @nodes.empty?
+          gen.push_nil
+          return
+        end
+
+        @nodes.each.with_index do |node, idx|
+          gen.pop unless idx == 0
+          mod.compile(gen, node)
+        end
+      end
+    end
+  end
+end

data/lib/atomy/code/string_literal.rb

@@ -0,0 +1,53 @@
+module Atomy
+  module Code
+    class StringLiteral
+      ESCAPES = {
+        "n" => "\n", "s" => "\s", "r" => "\r", "t" => "\t", "v" => "\v",
+        "f" => "\f", "b" => "\b", "a" => "\a", "e" => "\e", "\\" => "\\"
+      }
+
+      def initialize(value, raw = false)
+        @value = value
+        @raw = raw
+      end
+
+      def bytecode(gen, mod)
+        if @raw
+          gen.push_literal(@value)
+        else
+          gen.push_literal(process_escapes(@value))
+        end
+
+        gen.string_dup
+      end
+
+      private
+
+      def process_escapes(str)
+        processed = str.dup
+
+        processed.gsub!(/\\[xX]([0-9a-fA-F]{1,5})/) do
+          [$1.to_i(16)].pack("U")
+        end
+
+        processed.gsub!(/\\(\d{1,6})/) do
+          [$1.to_i].pack("U")
+        end
+
+        processed.gsub!(/\\[oO]([0-7]{1,7})/) do
+          [$1.to_i(8)].pack("U")
+        end
+
+        processed.gsub!(/\\[uU]([0-9a-fA-F]{4})/) do
+          [$1.to_i(16)].pack("U")
+        end
+
+        processed.gsub!(/\\(.)/) do
+          ESCAPES[$1] || "\\#$1"
+        end
+
+        processed
+      end
+    end
+  end
+end

data/lib/atomy/code/symbol.rb

@@ -0,0 +1,13 @@
+module Atomy
+  module Code
+    class Symbol
+      def initialize(value)
+        @value = value
+      end
+
+      def bytecode(gen, mod)
+        gen.push_literal(@value)
+      end
+    end
+  end
+end

data/lib/atomy/code/true.rb

@@ -0,0 +1,9 @@
+module Atomy
+  module Code
+    class True
+      def bytecode(gen, mod)
+        gen.push_true
+      end
+    end
+  end
+end

data/lib/atomy/code/undefined.rb

@@ -0,0 +1,9 @@
+module Atomy
+  module Code
+    class Undefined
+      def bytecode(gen, mod)
+        gen.push_undef
+      end
+    end
+  end
+end

data/lib/atomy/code/variable.rb

@@ -0,0 +1,17 @@
+module Atomy
+  module Code
+    class Variable
+      def initialize(name)
+        @name = name
+      end
+
+      def bytecode(gen, mod)
+        if local = gen.state.scope.search_local(@name)
+          local.get_bytecode(gen)
+        else
+          Send.new(nil, @name).bytecode(gen, mod)
+        end
+      end
+    end
+  end
+end

data/lib/atomy/codeloader.rb

@@ -0,0 +1,218 @@
+require "atomy/bootstrap"
+require "atomy/compiler"
+require "atomy/parser"
+require "atomy/module"
+
+module Atomy
+  module CodeLoader
+    LOADED_MODULES = {}
+
+    extend self
+
+    def load_map
+      @load_map ||= {}
+    end
+
+    Lock = Object.new
+
+    class RequireRequest
+      def initialize(map, key)
+        @map = map
+        @key = key
+        @for = nil
+        @module = nil
+        @loaded = false
+        @remove = true
+      end
+
+      attr_accessor :module
+
+      def take!
+        lock
+        @for = Thread.current
+      end
+
+      def current_thread?
+        @for == Thread.current
+      end
+
+      def lock
+        Rubinius.lock(self)
+      end
+
+      def unlock
+        Rubinius.unlock(self)
+      end
+
+      def wait
+        Rubinius.synchronize(Lock) do
+          @remove = false
+        end
+
+        take!
+
+        Rubinius.synchronize(Lock) do
+          if @loaded
+            @map.delete @key
+          end
+        end
+
+        @loaded
+      end
+
+      def passed!
+        @loaded = true
+      end
+
+      def remove!
+        Rubinius.synchronize(Lock) do
+          if @loaded || @remove
+            @map.delete(@key)
+          end
+        end
+
+        unlock
+      end
+    end
+
+    def require(path)
+      file = find_source(path)
+
+      return super unless file
+
+      wait = false
+      req = nil
+
+      reqs = load_map
+
+      Rubinius.synchronize(Lock) do
+        if req = reqs[file]
+          return req.module if req.current_thread?
+          wait = true
+        else
+          req = RequireRequest.new(reqs, file)
+          reqs[file] = req
+          req.take!
+        end
+      end
+
+      if wait
+        if req.wait
+          # While waiting the code was loaded by another thread.
+          # We need to release the lock so other threads can continue too.
+          req.unlock
+          return req.module
+        end
+
+        # The other thread doing the lock raised an exception
+        # through the require, so we try and load it again here.
+      end
+
+      begin
+        mod = load_atomy(file)
+      else
+        req.module = mod
+        req.passed!
+      ensure
+        req.remove!
+      end
+
+      mod
+    end
+
+    def register_feature(file, mod)
+      LOADED_MODULES[file] = mod
+      $LOADED_FEATURES << file
+    end
+
+    def load_atomy(file)
+      if loaded?(file)
+        LOADED_MODULES[file]
+      else
+        _, mod = run_script(file)
+        register_feature(file, mod)
+        mod
+      end
+    end
+
+    def run_script(path)
+      file = find_source(path)
+
+      raise LoadError, "no such file to load -- #{path}" unless file
+
+      mod = Atomy::Module.new { use(Atomy::Bootstrap) }
+      mod.file = file.to_sym
+
+      node = Atomy::Parser.parse_file(file)
+
+      res = evaluate_sequences(node, mod)
+
+      [res, mod]
+    end
+
+    def evaluate_sequences(n, mod)
+      if n.is_a?(Atomy::Grammar::AST::Sequence)
+        res = nil
+
+        n.nodes.each do |sub|
+          res = evaluate_sequences(sub, mod)
+        end
+
+        res
+      else
+        mod.evaluate(n, mod.compile_context)
+      end
+    end
+
+    def find_source(path, search_in = $LOAD_PATH)
+      if qualified?(path)
+        expanded = File.expand_path(path)
+        return expanded if File.file?(expanded)
+
+        expanded = "#{expanded}#{source_extension}"
+        return expanded if File.file?(expanded)
+      else
+        search_path(path, search_in)
+      end
+    end
+
+    def find_atomy_source(path, search_in = $LOAD_PATH)
+      path += source_extension unless path.end_with?(source_extension)
+      find_source(path)
+    end
+
+    private
+
+    def loaded?(file)
+      $LOADED_FEATURES.include?(file)
+    end
+
+    def source_extension
+      ".ay"
+    end
+
+    def search_path(path, load_paths)
+      load_paths.each do |load_path|
+        if found = find_source("#{load_path}/#{path}")
+          return found
+        end
+      end
+
+      if found = find_source("#{kernel_path}/#{path}")
+        return found
+      end
+
+      nil
+    end
+
+    def kernel_path
+      @kernel_path ||= File.expand_path("../../../kernel", __FILE__)
+    end
+
+    # something that doesn't look like it should be grabbed from the load
+    # path
+    def qualified?(path)
+      path =~ /^([~\/]|\.\.?\/)/
+    end
+  end
+end