apricot 0.0.1 → 0.0.2

data/lib/apricot/ast.rb

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

data/lib/apricot/ast/identifier.rb

@@ -1,111 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,240 +0,0 @@
-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