apricot 0.0.1

data/lib/apricot/ast/identifier.rb

@@ -0,0 +1,111 @@
+module Apricot
+  module AST
+    class Identifier < Node
+      def initialize(line, name)
+        super(line)
+        @id = Apricot::Identifier.intern(name)
+      end
+
+      def reference(g)
+        @reference ||= if name == :self
+                         SelfReference.new
+                       elsif qualified?
+                         NamespaceReference.new(unqualified_name, ns)
+                       else
+                         g.scope.find_var(name)
+                       end
+      end
+
+      def name
+        @id.name
+      end
+
+      def constant?
+        @id.constant?
+      end
+
+      def qualified?
+        @id.qualified?
+      end
+
+      def ns
+        @id.ns
+      end
+
+      def unqualified_name
+        @id.unqualified_name
+      end
+
+      def const_names
+        @id.const_names
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        if constant?
+          g.push_const const_names.first
+          const_names.drop(1).each {|n| g.find_const n }
+        else
+          reference(g).bytecode(g)
+        end
+      end
+
+      # called by (def <identifier> <value>)
+      def assign_bytecode(g, value)
+        if constant?
+          if const_names.length == 1
+            g.push_scope
+          else
+            g.push_const const_names[0]
+            const_names[1..-2].each {|n| g.find_const n }
+          end
+
+          g.push_literal const_names.last
+          value.bytecode(g)
+          g.send :const_set, 2
+        else
+          g.compile_error "Can't change the value of self" if name == :self
+
+          g.push_const :Apricot
+          g.send :current_namespace, 0
+          g.push_literal name
+          value.bytecode(g)
+          g.send :set_var, 2
+        end
+      end
+
+      def quote_bytecode(g)
+        pos(g)
+
+        g.push_const :Apricot
+        g.find_const :Identifier
+        g.push_literal name
+        g.send :intern, 1
+      end
+
+      def meta(g)
+        ref = reference(g)
+        ref.is_a?(NamespaceReference) && ref.meta
+      end
+
+      def namespace_fn?(g)
+        ref = reference(g)
+        ref.is_a?(NamespaceReference) && ref.fn?
+      end
+
+      def module_method?(g)
+        ref = reference(g)
+        ref.is_a?(NamespaceReference) && ref.method?
+      end
+
+      def to_value
+        @id
+      end
+
+      def node_equal?(other)
+        self.name == other.name
+      end
+    end
+  end
+end

data/lib/apricot/ast/list.rb

@@ -0,0 +1,99 @@
+module Apricot::AST
+  class List < Node
+    attr_reader :elements
+
+    def initialize(line, elements)
+      super(line)
+      @elements = elements
+    end
+
+    def bytecode(g, macroexpand = true)
+      pos(g)
+
+      if @elements.empty?
+        quote_bytecode(g)
+        return
+      end
+
+      callee = @elements.first
+      args = @elements.drop(1)
+
+      # Handle special forms such as def, let, fn, quote, etc
+      if callee.is_a?(Identifier) && special = Apricot::SpecialForm[callee.name]
+        special.bytecode(g, args)
+        return
+      end
+
+      if macroexpand
+        form = Node.from_value(Apricot.macroexpand(self.to_value), line)
+
+        # Avoid recursing and macroexpanding again if expansion returns a list
+        if form.is_a?(List)
+          form.bytecode(g, false)
+        else
+          form.bytecode(g)
+        end
+        return
+      end
+
+      # Handle (foo ...) and (Foo/bar ...) calls
+      if callee.is_a?(Identifier)
+        meta = callee.meta(g)
+
+        # Handle inlinable function calls
+        if meta && meta[:inline] && (!meta[:'inline-arities'] ||
+                                     meta[:'inline-arities'].apricot_call(args.length))
+          # Apply the inliner macro to the arguments and compile the result.
+          inliner = meta[:inline]
+          args.map!(&:to_value)
+
+          begin
+            inlined_form = inliner.apricot_call(*args)
+          rescue => e
+            g.compile_error "Inliner macro for '#{callee.name}' raised an exception:\n  #{e}"
+          end
+
+          Node.from_value(inlined_form, line).bytecode(g)
+          return
+        elsif callee.namespace_fn?(g) || callee.module_method?(g)
+          ns_id = Apricot::Identifier.intern(callee.ns.name)
+          g.push_const ns_id.const_names.first
+          ns_id.const_names.drop(1).each {|n| g.find_const(n) }
+
+          args.each {|arg| arg.bytecode(g) }
+          g.send callee.unqualified_name, args.length
+          return
+        end
+      end
+
+      # Handle everything else
+      callee.bytecode(g)
+      args.each {|arg| arg.bytecode(g) }
+      g.send :apricot_call, args.length
+    end
+
+    def quote_bytecode(g)
+      g.push_const :Apricot
+      g.find_const :List
+
+      if @elements.empty?
+        g.find_const :EmptyList
+      else
+        @elements.each {|e| e.quote_bytecode(g) }
+        g.send :[], @elements.length
+      end
+    end
+
+    def to_value
+      Apricot::List[*@elements.map(&:to_value)]
+    end
+
+    def node_equal?(other)
+      self.elements == other.elements
+    end
+
+    def [](*i)
+      @elements[*i]
+    end
+  end
+end

data/lib/apricot/ast/literals.rb

@@ -0,0 +1,240 @@
+module Apricot::AST
+  class BasicLiteral < Node
+    def quote_bytecode(g)
+      bytecode(g)
+    end
+  end
+
+  class Literal < BasicLiteral
+    attr_reader :value
+
+    def initialize(line, value)
+      super(line)
+      @value = value
+    end
+
+    def bytecode(g)
+      pos(g)
+      g.push @value
+    end
+
+    def to_value
+      case @value
+      when :true then true
+      when :false then false
+      when :nil then nil
+      else @value
+      end
+    end
+
+    def node_equal?(other)
+      self.value == other.value
+    end
+  end
+
+  def self.new_integer(line, value)
+    case value
+    when Bignum
+      BignumLiteral.new(line, value)
+    when Fixnum
+      Literal.new(line, value)
+    else
+      raise TypeError, "#{value} is not an integer"
+    end
+  end
+
+  class BignumLiteral < Literal
+    def bytecode(g)
+      pos(g)
+      g.push_unique_literal @value
+    end
+  end
+
+  class FloatLiteral < Literal
+    def bytecode(g)
+      pos(g)
+      g.push_unique_literal @value
+    end
+  end
+
+  class SymbolLiteral < Literal
+    def bytecode(g)
+      pos(g)
+      g.push_literal @value
+    end
+  end
+
+  class StringLiteral < Literal
+    def bytecode(g)
+      pos(g)
+      g.push_literal @value
+      g.string_dup # Duplicate string to avoid mutating the literal
+    end
+  end
+
+  class RationalLiteral < BasicLiteral
+    attr_reader :numerator, :denominator
+
+    def initialize(line, numerator, denominator)
+      super(line)
+      @numerator = numerator
+      @denominator = denominator
+    end
+
+    def bytecode(g)
+      pos(g)
+
+      # A rational literal should only be converted to a Rational the first
+      # time it is encountered. We push a literal nil here, and then overwrite
+      # the literal value with the created Rational if it is nil, i.e. the
+      # first time only. Subsequent encounters will use the previously created
+      # Rational. This idea was copied from Rubinius::AST::RegexLiteral.
+      idx = g.add_literal(nil)
+      g.push_literal_at idx
+      g.dup
+      g.is_nil
+
+      lbl = g.new_label
+      g.gif lbl
+      g.pop
+      g.push_self
+      g.push @numerator
+      g.push @denominator
+      g.send :Rational, 2, true
+      g.set_literal idx
+      lbl.set!
+    end
+
+    def to_value
+      Rational(@numerator, @denominator)
+    end
+
+    def node_equal?(other)
+      self.numerator == other.numerator && self.denominator == other.denominator
+    end
+  end
+
+  class RegexLiteral < BasicLiteral
+    attr_accessor :pattern, :options
+
+    def initialize(line, pattern, options)
+      super(line)
+      @pattern = pattern
+      @options = options
+    end
+
+    def bytecode(g)
+      pos(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
+      g.push_const :Regexp
+      g.push_literal @pattern
+      g.push @options
+      g.send :new, 2
+      g.set_literal idx
+      lbl.set!
+    end
+
+    def to_value
+      Regexp.new(@pattern, @options)
+    end
+
+    def node_equal?(other)
+      self.pattern == other.pattern && self.options == other.options
+    end
+  end
+
+  class CollectionLiteral < Node
+    attr_reader :elements
+
+    def initialize(line, elements)
+      super(line)
+      @elements = elements
+    end
+
+    def quote_bytecode(g)
+      bytecode(g, true)
+    end
+
+    def node_equal?(other)
+      self.elements == other.elements
+    end
+
+    def [](*i)
+      @elements[*i]
+    end
+  end
+
+  class ArrayLiteral < CollectionLiteral
+    def bytecode(g, quoted = false)
+      pos(g)
+
+      @elements.each {|e| quoted ? e.quote_bytecode(g) : e.bytecode(g) }
+      g.make_array @elements.length
+    end
+
+    def to_value
+      @elements.map(&:to_value)
+    end
+  end
+
+  class HashLiteral < CollectionLiteral
+    def bytecode(g, quoted = false)
+      pos(g)
+
+      # Create a new Hash
+      g.push_const :Hash
+      g.push(@elements.length / 2)
+      g.send :new_from_literal, 1
+
+      # Add keys and values
+      @elements.each_slice(2) do |k, v|
+        g.dup # The Hash
+
+        if quoted
+          k.quote_bytecode(g)
+          v.quote_bytecode(g)
+        else
+          k.bytecode(g)
+          v.bytecode(g)
+        end
+
+        g.send :[]=, 2
+        g.pop # []= leaves v on the stack
+      end
+    end
+
+    def to_value
+      h = {}
+      @elements.each_slice(2) {|k,v| h[k.to_value] = v.to_value }
+      h
+    end
+  end
+
+  class SetLiteral < CollectionLiteral
+    def bytecode(g, quoted = false)
+      pos(g)
+
+      g.push_const :Set
+      g.send :new, 0 # TODO: Inline this new?
+
+      @elements.each do |e|
+        quoted ? e.quote_bytecode(g) : e.bytecode(g)
+        g.send :add, 1
+      end
+    end
+
+    def to_value
+      s = Set.new
+      @elements.each {|e| s << e.to_value }
+      s
+    end
+  end
+end

data/lib/apricot/ast/node.rb

@@ -0,0 +1,45 @@
+module Apricot
+  module AST
+    class Node
+      attr_reader :line
+
+      def initialize(line)
+        @line = line
+      end
+
+      def pos(g)
+        g.set_line(@line)
+      end
+
+      def ==(other)
+        return true if self.equal?(other)
+        return false unless self.class == other.class
+        self.node_equal?(other)
+      end
+
+      def self.from_value(val, line = 0)
+        case val
+        when true     then Literal.new(line, :true)
+        when false    then Literal.new(line, :false)
+        when nil      then Literal.new(line, :nil)
+        when Integer  then AST.new_integer(line, val)
+        when Symbol   then SymbolLiteral.new(line, val)
+        when Float    then FloatLiteral.new(line, val)
+        when String   then StringLiteral.new(line, val)
+        when Rational then RationalLiteral.new(line, val.numerator, val.denominator)
+        when Regexp   then RegexLiteral.new(line, val.source, val.options)
+        when Array    then ArrayLiteral.new(line, val.map {|x| from_value x, line})
+        when Set      then SetLiteral.new(line, val.map {|x| from_value x, line})
+        when Apricot::Identifier then Identifier.new(line, val.name)
+        when Apricot::Seq        then List.new(line, val.map {|x| from_value x, line})
+        when Hash
+          elems = []
+          val.each_pair {|k,v| elems << from_value(k, line) << from_value(v, line) }
+          HashLiteral.new(line, elems)
+        else
+          raise TypeError, "No AST node for #{val} (#{val.class})"
+        end
+      end
+    end
+  end
+end

data/lib/apricot/ast/scopes.rb

@@ -0,0 +1,147 @@
+module Apricot
+  module AST
+    # This is a scope with real local variable storage, i.e. it is part of a
+    # block of code like a fn or the top level program. Let scopes do not have
+    # storage and must ask for storage from one of these.
+    module StorageScope
+      def variable_names
+        @variable_names ||= []
+      end
+
+      def store_new_local(name)
+        slot = next_slot
+        variable_names << name
+        slot
+      end
+
+      def next_slot
+        variable_names.size
+      end
+
+      def local_count
+        variable_names.size
+      end
+
+      def local_names
+        variable_names
+      end
+    end
+
+    class Scope
+      attr_reader :parent, :variables
+      # The loop label stores the code location where a (recur) form should
+      # jump to. The secondary loop label is used in the case of recur in a fn
+      # overload with variadic arguments. If the array passed for the variadic
+      # arguments in the recur is empty, it should instead jump to the
+      # matching non-variadic overload, if applicable.
+      attr_accessor :loop_label, :secondary_loop_label
+
+      def initialize(parent)
+        @parent = parent
+        @variables = {}
+        @loop_label = nil
+      end
+    end
+
+    class FnScope < Scope
+      attr_reader :name, :self_reference
+
+      def initialize(parent, name)
+        super(parent)
+
+        if name
+          @name = name
+          name_slot = @parent.store_new_local(name)
+          @self_reference = LocalReference.new(name_slot, 1)
+        end
+      end
+
+      # An identifier or a nested scope is looking up a variable. If the
+      # variable is found here, return a reference to it. Otherwise look it up
+      # on the parent and increment its depth because it is beyond the bounds
+      # of the current block of code (fn).
+      def find_var(name, depth = 0)
+        return @self_reference if name == @name
+
+        @parent.find_var(name, depth + 1)
+      end
+
+      # A (recur) is looking for a recursion target (ie. a loop or a fn
+      # overload scope).
+      def find_recur_target
+        @parent.find_recur_target
+      end
+    end
+
+    class OverloadScope < Scope
+      include StorageScope
+
+      attr_accessor :splat
+      alias_method :splat?, :splat
+
+      attr_accessor :block_arg
+
+      def initialize(parent_fn)
+        super(parent_fn)
+      end
+
+      # An identifier or a nested scope is looking up a variable. If the
+      # variable is found here, return a reference to it. Otherwise look it up
+      # on the parent (a fn). Don't increase the depth, the lookup on the fn
+      # will do that, and if we do it twice then the generated
+      # push_local_depth instructions look up too many scopes.
+      def find_var(name, depth = 0)
+        if slot = @variables[name]
+          LocalReference.new(slot, depth)
+        else
+          @parent.find_var(name, depth)
+        end
+      end
+
+      # Create a new local on the current level.
+      def new_local(name)
+        name = name.name if name.is_a? Identifier
+        @variables[name] = store_new_local(name)
+      end
+
+      # A (recur) is looking for a recursion target. This, being a fn
+      # overload, is one.
+      def find_recur_target
+        self
+      end
+    end
+
+    # The let scope doesn't have real storage for locals. It stores its locals
+    # on the nearest enclosing real scope, which is any separate block of code
+    # such as a fn, defn, defmacro or the top level of the program.
+    class LetScope < Scope
+      # An identifier or a nested scope is looking up a variable.
+      def find_var(name, depth = 0)
+        if slot = @variables[name]
+          LocalReference.new(slot, depth)
+        else
+          @parent.find_var(name, depth)
+        end
+      end
+
+      # Create a new local on the current level, with storage on the nearest
+      # enclosing real scope.
+      def new_local(name)
+        name = name.name if name.is_a? Identifier
+        @variables[name] = @parent.store_new_local(name)
+      end
+
+      # A deeper let is asking for a new local slot. Pass it along to the
+      # parent so it eventually reaches a real scope.
+      def store_new_local(name)
+        @parent.store_new_local(name)
+      end
+
+      # A (recur) is looking for a recursion target. This is one only if it is
+      # a (loop) form.
+      def find_recur_target
+        loop_label ? self : @parent.find_recur_target
+      end
+    end
+  end
+end

data/lib/apricot/ast/toplevel.rb

@@ -0,0 +1,66 @@
+module Apricot
+  module AST
+    class TopLevel < Node
+      include StorageScope
+
+      attr_reader :elements, :file
+
+      def initialize(elements, file, line = 1, evaluate = false)
+        @elements = elements
+        @file = file
+        @line = line
+        @evaluate = evaluate
+      end
+
+      def bytecode(g)
+        g.name = :__top_level__
+        g.file = @file.to_sym
+
+        g.scopes << self
+
+        pos(g)
+
+        if @elements.empty?
+          g.push_nil
+        else
+          @elements.each_with_index do |e, i|
+            g.pop unless i == 0
+            e.bytecode(g)
+            # We evaluate top level forms as we generate the bytecode for them
+            # so macros defined in a file can be used immediately after the
+            # definition.
+            Apricot::Compiler.eval_node(e, @file) if @evaluate
+          end
+        end
+
+        g.ret
+
+        g.scopes.pop
+
+        g.local_count = local_count
+        g.local_names = local_names
+      end
+
+      # A nested scope is looking up a variable. There are no local variables
+      # at the top level, so look up the variable on the current namespace.
+      def find_var(name, depth = nil)
+        # Ignore depth, it has no bearing on namespace lookups.
+        NamespaceReference.new(name)
+      end
+
+      def node_equal?(other)
+        self.file == other.file && self.elements == other.elements
+      end
+
+      def [](*i)
+        @elements[*i]
+      end
+
+      # A (recur) is looking for a recursion target. Since this is the top
+      # level, which has no parent, the lookup has failed.
+      def find_recur_target
+        nil
+      end
+    end
+  end
+end