apricot 0.0.1

data/lib/apricot/ast/variables.rb

@@ -0,0 +1,64 @@
+module Apricot
+  module AST
+    class LocalReference
+      attr_reader :slot, :depth
+
+      def initialize(slot, depth = 0)
+        @slot = slot
+        @depth = depth
+      end
+
+      def bytecode(g)
+        if @depth == 0
+          g.push_local @slot
+        else
+          g.push_local_depth @depth, @slot
+        end
+      end
+    end
+
+    class NamespaceReference
+      def initialize(name, ns = nil)
+        @name = name
+        @ns = ns || Apricot.current_namespace
+      end
+
+      def bytecode(g)
+        if @ns.is_a?(Namespace) && !@ns.vars.include?(@name)
+          g.compile_error "Unable to resolve name #{@name} in namespace #{@ns}"
+        end
+
+        ns_id = Apricot::Identifier.intern(@ns.name)
+        g.push_const ns_id.const_names.first
+        ns_id.const_names.drop(1).each {|n| g.find_const(n) }
+
+        g.push_literal @name
+
+        if @ns.is_a? Namespace
+          g.send :get_var, 1
+        else # @ns is a regular Ruby module
+          g.send :method, 1
+        end
+      end
+
+      def meta
+        @ns.is_a?(Namespace) && @ns.vars[@name] && @ns.vars[@name].apricot_meta
+      end
+
+      def fn?
+        @ns.is_a?(Namespace) && @ns.fns.include?(@name)
+      end
+
+      def method?
+        !@ns.is_a?(Namespace) && @ns.respond_to?(@name)
+      end
+    end
+
+    # For the 'self' identifier. Just like Ruby's 'self'.
+    class SelfReference
+      def bytecode(g)
+        g.push_self
+      end
+    end
+  end
+end

data/lib/apricot/ast.rb

@@ -0,0 +1,3 @@
+%w[node literals identifier list scopes variables toplevel].each do |r|
+  require "apricot/ast/#{r}"
+end

data/lib/apricot/compiler.rb

@@ -0,0 +1,55 @@
+module Apricot
+  class Compiler < Rubinius::Compiler
+    def self.compile(file, output = nil, debug = false)
+      compiler = new :apricot_file, :compiled_file
+
+      compiler.parser.input file
+      compiler.packager.print(BytecodePrinter) if debug
+      compiler.writer.name = output || Rubinius::Compiler.compiled_name(file)
+
+      prepare_compiled_code compiler.run
+    end
+
+    def self.compile_string(code, file = nil, line = 1, debug = false)
+      compiler = new :apricot_string, :compiled_method
+
+      compiler.parser.input(code, file || "(none)", line)
+      compiler.packager.print(BytecodePrinter) if debug
+
+      prepare_compiled_code compiler.run
+    end
+
+    def self.compile_node(node, file = "(none)", line = 1, debug = false)
+      compiler = new :apricot_bytecode, :compiled_method
+
+      compiler.generator.input AST::TopLevel.new([node], file, line, false)
+      compiler.packager.print(BytecodePrinter) if debug
+
+      prepare_compiled_code compiler.run
+    end
+
+    def self.compile_form(node, file = "(none)", line = 1, debug = false)
+      compile_node(AST::Node.from_value(node, line), file, line, debug)
+    end
+
+    def self.prepare_compiled_code(cc)
+      cc.scope = Rubinius::ConstantScope.new(Object)
+      cc
+    end
+
+    def self.eval(code, file = "(eval)", line = 1, debug = false)
+      cc = compile_string(code, file, line, debug)
+      Rubinius.run_script cc
+    end
+
+    def self.eval_form(form, file = "(eval)", line = 1, debug = false)
+      cc = compile_form(form, file, line, debug)
+      Rubinius.run_script cc
+    end
+
+    def self.eval_node(node, file = "(eval)", line = 1, debug = false)
+      cc = compile_node(node, file, line, debug)
+      Rubinius.run_script cc
+    end
+  end
+end

data/lib/apricot/cons.rb

@@ -0,0 +1,27 @@
+module Apricot
+  class Cons
+    include Seq
+
+    def initialize(head, tail)
+      @head = head
+      @tail = tail.to_seq
+    end
+
+    def first
+      @head
+    end
+
+    def next
+      if @tail
+        @tail
+      else
+        nil
+      end
+    end
+
+    def each
+      yield first
+      @tail.each {|x| yield x }
+    end
+  end
+end

data/lib/apricot/errors.rb

@@ -0,0 +1,38 @@
+module Apricot
+  class SyntaxError < StandardError
+    attr_reader :filename, :line, :msg
+
+    def initialize(filename, line, msg, incomplete = false)
+      @filename = filename
+      @line = line
+      @msg = msg
+      @incomplete = incomplete
+    end
+
+    def incomplete?
+      @incomplete
+    end
+
+    def to_s
+      "#{@filename}:#{@line}: #{@msg}"
+    end
+  end
+
+  class CompileError < StandardError
+    attr_reader :filename, :line, :msg
+
+    def initialize(filename, line, msg)
+      @filename = filename
+      @line = line
+      @msg = msg
+    end
+
+    def to_s
+      "#{@filename}:#{@line}: #{@msg}"
+    end
+  end
+
+  def self.compile_error(file, line, msg)
+    raise CompileError.new(file, line, msg)
+  end
+end

data/lib/apricot/generator.rb

@@ -0,0 +1,15 @@
+module Apricot
+  class Generator < Rubinius::Generator
+    def scopes
+      @scopes ||= []
+    end
+
+    def scope
+      @scopes.last
+    end
+
+    def compile_error(msg)
+      raise CompileError.new(file, line, msg)
+    end
+  end
+end

data/lib/apricot/identifier.rb

@@ -0,0 +1,91 @@
+module Apricot
+  class Identifier
+    attr_reader :name, :ns, :unqualified_name
+
+    @table = {}
+
+    def self.intern(name)
+      name = name.to_sym
+      @table[name] ||= new(name)
+    end
+
+    private_class_method :new
+
+    def initialize(name)
+      @name = name
+
+      if @name =~ /\A(?:[A-Z]\w*::)*[A-Z]\w*\z/
+        @constant = true
+        @const_names = @name.to_s.split('::').map(&:to_sym)
+      elsif @name =~ /\A(.+?)\/(.+)\z/
+        @qualified = true
+        ns_id = Identifier.intern($1)
+        raise 'namespace in identifier must be a constant' unless ns_id.constant?
+
+        @ns = ns_id.const_names.reduce(Object) do |mod, name|
+          mod.const_get(name)
+        end
+
+        @unqualified_name = $2.to_sym
+      else
+        @ns = Apricot.current_namespace
+        @unqualified_name = name
+      end
+    end
+
+    def qualified?
+      @qualified
+    end
+
+    def unqualified_name
+      @unqualified_name
+    end
+
+    def constant?
+      @constant
+    end
+
+    def const_names
+      raise "#{@name} is not a constant" unless constant?
+      @const_names
+    end
+
+    # Copying Identifiers is not allowed.
+    def initialize_copy(other)
+      raise TypeError, "copy of #{self.class} is not allowed"
+    end
+
+    private :initialize_copy
+
+    alias_method :==, :equal?
+    alias_method :eql?, :equal?
+
+    def hash
+      @name.hash
+    end
+
+    def inspect
+      case @name
+      when :true, :false, :nil, /\A(?:\+|-)?\d/
+        # Use arbitrary identifier syntax for identifiers that would otherwise
+        # be parsed as keywords or numbers
+        str = @name.to_s.gsub(/(\\.)|\|/) { $1 || '\|' }
+        "#|#{str}|"
+      when /\A#{Apricot::Parser::IDENTIFIER}+\z/
+        @name.to_s
+      else
+        str = @name.to_s.inspect[1..-2]
+        str.gsub!(/(\\.)|\|/) { $1 || '\|' }
+        "#|#{str}|"
+      end
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+    def to_sym
+      @name
+    end
+  end
+end

data/lib/apricot/list.rb

@@ -0,0 +1,96 @@
+module Apricot
+  # A linked list implementation representing (a b c) syntax in Apricot
+  class List
+    include Seq
+
+    def self.[](*args)
+      list = EmptyList
+      args.reverse_each do |arg|
+        list = list.cons(arg)
+      end
+      list
+    end
+
+    attr_reader :head, :tail
+
+    def initialize(head, tail)
+      @head = head
+      @tail = tail
+    end
+
+    def cons(x)
+      List.new(x, self)
+    end
+
+    def each
+      list = self
+      until list.empty?
+        yield list.head
+        list = list.tail
+      end
+    end
+
+    def ==(other)
+      return true if self.equal? other
+      return false unless other.is_a? List
+
+      list = self
+
+      until list.empty?
+        return false if other.empty? || list.head != other.head
+
+        list = list.tail
+        other = other.tail
+      end
+
+      other.empty?
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      hashes = map {|x| x.hash }
+      hashes.reduce(hashes.size) {|acc,hash| acc ^ hash }
+    end
+
+    def empty?
+      !@tail
+    end
+
+    def initialize_copy(other)
+      super
+      @tail = other.tail.dup if other.tail && !other.tail.empty?
+    end
+
+    private :initialize_copy
+
+    def to_list
+      self
+    end
+
+    def first
+      empty? ? nil : @head
+    end
+
+    def next
+      @tail.empty? ? nil : @tail
+    end
+
+    def to_seq
+      empty? ? nil : self
+    end
+
+    def inspect
+      return '()' if empty?
+
+      str = '('
+      each {|x| str << x.apricot_inspect << ' ' }
+      str.chop!
+      str << ')'
+    end
+
+    alias_method :to_s, :inspect
+
+    EmptyList = new(nil, nil)
+  end
+end

data/lib/apricot/macroexpand.rb

@@ -0,0 +1,47 @@
+module Apricot
+  def self.macroexpand(form)
+    ex = macroexpand_1(form)
+    ex.equal?(form) ? ex : macroexpand(ex)
+  end
+
+  def self.macroexpand_1(form)
+    return form unless form.is_a? List
+
+    callee = form.first
+    return form unless callee.is_a?(Identifier) && !callee.constant?
+
+    name = callee.name
+    name_s = name.to_s
+    args = form.tail
+
+    # Handle the (.method receiver args*) send expression form
+    if name.length > 1 && name_s != '..' && name_s.start_with?('.')
+      raise ArgumentError, "Too few arguments to send expression, expecting (.method receiver ...)" if args.empty?
+
+      dot = Identifier.intern(:'.')
+      method = Identifier.intern(name_s[1..-1])
+      return List[dot, args.first, method, *args.tail]
+    end
+
+    # Handle the (Class. args*) shorthand new form
+    if name.length > 1 && name_s != '..' && name_s.end_with?('.')
+      dot = Identifier.intern(:'.')
+      klass = Identifier.intern(name_s[0..-2])
+      new = Identifier.intern(:new)
+      return List[dot, klass, new, *args]
+    end
+
+    # Handle defined macros
+    if callee.ns.is_a?(Namespace) && callee.ns.vars.include?(callee.unqualified_name)
+      potential_macro = callee.ns.get_var(callee.unqualified_name)
+      meta = potential_macro.apricot_meta
+
+      if meta && meta[:macro]
+        return potential_macro.call(*args)
+      end
+    end
+
+    # Default case
+    form
+  end
+end

data/lib/apricot/misc.rb

@@ -0,0 +1,11 @@
+# This file contains some things that are used in a bunch of places and don't
+# fit anywhere in particular.
+
+module Apricot
+  # TODO: Should this counter be thread-local?
+  @gensym = 0
+
+  def self.gensym(prefix = 'g')
+    :"#{prefix}__#{@gensym += 1}"
+  end
+end

data/lib/apricot/namespace.rb

@@ -0,0 +1,59 @@
+module Apricot
+  class Namespace < Module
+    def self.find_or_create(constant)
+      ns = constant.const_names.reduce(Object) do |mod, name|
+        if mod.const_defined? name
+          next_mod = mod.const_get name
+          raise TypeError, "#{mod}::#{name} (#{next_mod}) is not a Module" unless next_mod.is_a? Module
+          next_mod
+        else
+          mod.const_set(name, Namespace.new)
+        end
+      end
+
+      raise TypeError, "#{constant.name} is not a Namespace" unless ns.is_a? Namespace
+
+      ns
+    end
+
+    attr_reader :vars, :fns
+
+    def initialize
+      @vars = {}
+      @fns = Set[]
+    end
+
+    def set_var(name, val)
+      @vars[name] = val
+
+      val = val.to_proc if val.is_a? Method
+
+      if val.is_a?(Proc) && (@fns.include?(name) || !self.respond_to?(name))
+        @fns.add name
+        define_singleton_method(name, val)
+      elsif @fns.include?(name)
+        @fns.delete name
+        singleton_class.send(:undef_method, name)
+      end
+
+      val
+    end
+
+    def get_var(name)
+      # raise may be a function defined on the namespace so we need to
+      # explicitly call the Ruby raise method.
+      Kernel.raise NameError, "Undefined variable '#{name}' on #{self}" unless @vars.include? name
+      @vars[name]
+    end
+  end
+
+  class << self
+    def current_namespace
+      Core.get_var(:"*ns*")
+    end
+
+    def current_namespace=(ns)
+      Core.set_var(:"*ns*", ns)
+    end
+  end
+end