apricot 0.0.1 → 0.0.2

data/lib/apricot/boot.rb

@@ -0,0 +1,24 @@
+module Apricot
+  LIB_PATH = File.expand_path("../../../kernel", __FILE__)
+  $LOAD_PATH << LIB_PATH
+
+  Core = Namespace.new
+
+  Core.set_var(:"*ns*", Core)
+
+  Core.set_var(:"in-ns", lambda do |constant|
+    Apricot.current_namespace = Namespace.find_or_create constant
+  end)
+
+  Core.set_var(:ns, lambda do |constant|
+    List[Identifier.intern(:"in-ns"),
+      List[Identifier.intern(:quote), constant]]
+  end)
+  Core.get_var(:ns).apricot_meta = {:macro => true}
+
+  Apricot.require "core"
+
+#  ::User = Namespace.new
+  Apricot.current_namespace = Core
+  # TODO: make Apricot::Core public vars visible in User, default to User
+end

data/lib/apricot/code_loader.rb

@@ -0,0 +1,108 @@
+module Apricot
+  def self.load(file)
+    CodeLoader.load(file)
+  end
+
+  def self.require(file)
+    CodeLoader.require(file)
+  end
+
+  module CodeLoader
+    module_function
+
+    def load(path)
+      full_path = find_source(path)
+      raise LoadError, "no such file to load -- #{path}" unless full_path
+
+      load_file full_path
+      true
+    end
+
+    def require(path)
+      full_path = find_source(path)
+      raise LoadError, "no such file to load -- #{path}" unless full_path
+
+      if loaded? full_path
+        false
+      else
+        load_file full_path
+        $LOADED_FEATURES << full_path
+        true
+      end
+    end
+
+    def load_file(path)
+      compiled_name = Rubinius::ToolSet::Runtime::Compiler.compiled_name(path)
+
+      stat = File::Stat.stat path
+      compiled_stat = File::Stat.stat compiled_name
+
+      # Try to load the cached bytecode if it exists and is newer than the
+      # source file.
+      if stat && compiled_stat && stat.mtime < compiled_stat.mtime
+        begin
+          code = Rubinius.invoke_primitive :compiledfile_load, compiled_name,
+            Rubinius::Signature, Rubinius::RUBY_LIB_VERSION
+          usable = true
+        rescue Rubinius::Internal
+          usable = false
+        end
+
+        if usable
+          Rubinius.run_script code
+          return
+        end
+      end
+
+      Compiler.compile_and_eval_file path
+    end
+
+    def find_source(path)
+      path += ".apr" unless has_extension? path
+      path = File.expand_path path if home_path? path
+
+      if qualified_path? path
+        if loadable? path
+          path
+        else
+          false
+        end
+      else
+        search_load_path path
+      end
+    end
+
+    def search_load_path(path)
+      $LOAD_PATH.each do |dir|
+        full_path = "#{dir}/#{path}"
+        return full_path if loadable? full_path
+      end
+
+      false
+    end
+
+    def has_extension?(path)
+      !File.extname(path).empty?
+    end
+
+    def home_path?(path)
+      path[0] == '~'
+    end
+
+    def qualified_path?(path)
+      # TODO: fix for Windows
+      path[0] == '/' || path.prefix?("./") || path.prefix?("../")
+    end
+
+    # Returns true if the path exists, is a regular file, and is readable.
+    def loadable?(path)
+      @stat = File::Stat.stat path
+      return false unless @stat
+      @stat.file? and @stat.readable?
+    end
+
+    def loaded?(path)
+      $LOADED_FEATURES.include?(path)
+    end
+  end
+end

data/lib/apricot/compiler.rb

@@ -1,55 +1,288 @@
 module Apricot
-  class Compiler < Rubinius::Compiler
-    def self.compile(file, output = nil, debug = false)
-      compiler = new :apricot_file, :compiled_file
+  module Compiler
+    module_function
 
-      compiler.parser.input file
-      compiler.packager.print(BytecodePrinter) if debug
-      compiler.writer.name = output || Rubinius::Compiler.compiled_name(file)
+    def generate(forms, file = "(none)", line = 1, evaluate = false)
+      g = Generator.new
+      g.name = :__apricot__
+      g.file = file.to_sym
 
-      prepare_compiled_code compiler.run
-    end
+      g.scopes << TopLevelScope.new
+
+      g.set_line(line)
+
+      if forms.empty?
+        g.push_nil
+      else
+        forms.each_with_index do |e, i|
+          g.pop unless i == 0
+          bytecode(g, e)
+
+          # We evaluate top level forms as we generate the bytecode for them
+          # so macros can be used immediately after their definitions.
+          eval_form(e, file) if evaluate
+        end
+      end
 
-    def self.compile_string(code, file = nil, line = 1, debug = false)
-      compiler = new :apricot_string, :compiled_method
+      g.ret
 
-      compiler.parser.input(code, file || "(none)", line)
-      compiler.packager.print(BytecodePrinter) if debug
+      scope = g.scopes.pop
+      g.local_count = scope.local_count
+      g.local_names = scope.local_names
 
-      prepare_compiled_code compiler.run
+      g.close
+      g.encode
+      cc = g.package(Rubinius::CompiledCode)
+      cc.scope = Rubinius::ConstantScope.new(Object)
+      cc
     end
 
-    def self.compile_node(node, file = "(none)", line = 1, debug = false)
-      compiler = new :apricot_bytecode, :compiled_method
+    def compile_and_eval_file(file)
+      cc = generate(Reader.read_file(file), file, 1, true)
+
+      if Rubinius::CodeLoader.save_compiled?
+        compiled_name = Rubinius::ToolSet::Runtime::Compiler.compiled_name(file)
 
-      compiler.generator.input AST::TopLevel.new([node], file, line, false)
-      compiler.packager.print(BytecodePrinter) if debug
+        dir = File.dirname(compiled_name)
 
-      prepare_compiled_code compiler.run
+        unless File.directory?(dir)
+          parts = []
+
+          until dir == "/" or dir == "."
+            parts << dir
+            dir = File.dirname(dir)
+          end
+
+          parts.reverse_each do |d|
+            Dir.mkdir d unless File.directory?(d)
+          end
+        end
+
+        Rubinius::ToolSet::Runtime::CompiledFile.dump cc, compiled_name,
+          Rubinius::Signature, Rubinius::RUBY_LIB_VERSION
+      end
+
+      cc
     end
 
-    def self.compile_form(node, file = "(none)", line = 1, debug = false)
-      compile_node(AST::Node.from_value(node, line), file, line, debug)
+    def compile_form(form, file = "(eval)", line = 1)
+      generate([form], file, line)
     end
 
-    def self.prepare_compiled_code(cc)
-      cc.scope = Rubinius::ConstantScope.new(Object)
-      cc
+    def eval_form(form, file = "(eval)", line = 1)
+      Rubinius.run_script(compile_form(form, file, line))
     end
 
-    def self.eval(code, file = "(eval)", line = 1, debug = false)
-      cc = compile_string(code, file, line, debug)
-      Rubinius.run_script cc
+    def eval(code, file = "(eval)", line = 1)
+      forms = Reader.read_string(code, file,line)
+
+      return nil if forms.empty?
+
+      forms[0..-2].each do |form|
+        eval_form(form, file, line)
+      end
+
+      # Return the result of the last form in the program.
+      eval_form(forms.last, file, line)
     end
 
-    def self.eval_form(form, file = "(eval)", line = 1, debug = false)
-      cc = compile_form(form, file, line, debug)
-      Rubinius.run_script cc
+    SELF = Identifier.intern(:self)
+
+    def bytecode(g, form, quoted = false, macroexpand = true)
+      pos(g, form)
+
+      case form
+      when Identifier
+        if quoted
+          g.push_const :Apricot
+          g.find_const :Identifier
+          g.push_literal form.name
+          g.send :intern, 1
+        else
+          if form.constant?
+            g.push_const form.const_names.first
+            form.const_names.drop(1).each {|n| g.find_const n }
+          elsif form == SELF
+            g.push_self
+          elsif form.qualified?
+            QualifiedReference.new(form.unqualified_name, form.qualifier).bytecode(g)
+          else
+            g.scope.find_var(form.name).bytecode(g)
+          end
+        end
+
+      when Seq
+        if quoted || form.empty?
+          g.push_const :Apricot
+          g.find_const :List
+
+          if form.empty?
+            g.find_const :EMPTY_LIST
+          else
+            form.each {|e| bytecode(g, e, true) }
+            g.send :[], form.count
+          end
+        else
+          callee, args = form.first, form.rest
+
+          # Handle special forms such as def, let, fn, quote, etc
+          if callee.is_a?(Identifier)
+            if special = SpecialForm[callee.name]
+              special.bytecode(g, args)
+              return
+            end
+
+            if macroexpand
+              form = Apricot.macroexpand(form)
+
+              if form.is_a?(Seq)
+                # Avoid recursing and macroexpanding again if expansion returns a list
+                bytecode(g, form, false, false)
+              else
+                bytecode(g, form)
+              end
+
+              return
+            end
+
+            meta = callee.meta
+
+            # Handle inlinable function calls
+            if meta && meta[:inline] && (!meta[:'inline-arities'] ||
+                                         meta[:'inline-arities'].apricot_call(args.count))
+              begin
+                inlined_form = meta[:inline].apricot_call(*args)
+              rescue => e
+                g.compile_error "Inliner function for '#{callee.name}' raised an exception:\n  #{e}"
+              end
+
+              g.tail_position = false
+              bytecode(g, inlined_form)
+              return
+            end
+
+            if callee.fn? || callee.method?
+              qualifier_id = Identifier.intern(callee.qualifier.name)
+              first_name, *rest_names = qualifier_id.const_names
+
+              g.push_const first_name
+              rest_names.each {|n| g.find_const(n) }
+
+              args.each {|arg| bytecode(g, arg) }
+              g.send callee.unqualified_name, args.count
+              return
+            end
+          end
+
+          # Handle everything else
+          g.tail_position = false
+          bytecode(g, callee)
+          args.each {|arg| bytecode(g, arg) }
+          g.send :apricot_call, args.count
+        end
+
+      when Symbol
+        g.push_literal form
+
+      when Array
+        form.each {|e| bytecode(g, e, quoted) }
+        g.make_array form.size
+
+      when String
+        g.push_literal form
+        g.string_dup # Duplicate string to prevent mutating the literal
+
+      when Hash
+        # Create a new Hash
+        g.push_const :Hash
+        g.push form.size
+        g.send :new_from_literal, 1
+
+        # Add keys and values
+        form.each_pair do |key, value|
+          g.dup # the Hash
+          bytecode(g, key, quoted)
+          bytecode(g, value, quoted)
+          g.send :[]=, 2
+          g.pop # drop the return value of []=
+        end
+
+      when Fixnum
+        g.push form
+
+      when true
+        g.push :true
+
+      when nil
+        g.push :nil
+
+      when false
+        g.push :false
+
+      when Float
+        g.push_unique_literal form
+
+      when Regexp
+        once(g) do
+          g.push_const :Regexp
+          g.push_literal form.source
+          g.push form.options
+          g.send :new, 2
+        end
+
+      when Rational
+        once(g) do
+          g.push_self
+          g.push form.numerator
+          g.push form.denominator
+          g.send :Rational, 2, true
+        end
+
+      when Set
+        g.push_const :Set
+        g.send :new, 0 # TODO: Inline this new?
+
+        form.each do |elem|
+          bytecode(g, elem, quoted)
+          g.send :add, 1
+        end
+
+      when Bignum
+        g.push_unique_literal form
+
+      else
+        g.compile_error "Can't generate bytecode for #{form} (#{form.class})"
+      end
+    end
+
+    # Some literals, such as regexps and rationals, should only be created the
+    # first time they are encountered. We push a literal nil here, and then
+    # overwrite the literal value with the created object if it is nil, i.e.
+    # the first time only. Subsequent encounters will use the previously
+    # created object. This idea was copied from Rubinius::AST::RegexLiteral.
+    #
+    # The passed block should take a generator and generate the bytecode to
+    # create the object the first time.
+    def once(g)
+      idx = g.add_literal(nil)
+      g.push_literal_at idx
+      g.dup
+      g.is_nil
+
+      lbl = g.new_label
+      g.gif lbl
+      g.pop
+
+      yield g
+
+      g.set_literal idx
+      lbl.set!
     end
 
-    def self.eval_node(node, file = "(eval)", line = 1, debug = false)
-      cc = compile_node(node, file, line, debug)
-      Rubinius.run_script cc
+    def pos(g, form)
+      if (meta = form.apricot_meta) && (line = meta[:line])
+        g.set_line(line)
+      end
     end
   end
 end