apricot 0.0.1 → 0.0.2

data/lib/apricot/ast/node.rb

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

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

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

data/lib/apricot/ast/variables.rb

@@ -1,64 +0,0 @@
-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/printers.rb

@@ -1,12 +0,0 @@
-module Apricot
-  class Compiler
-    class BytecodePrinter < Rubinius::Compiler::Printer
-      def run
-        puts @input.decode
-
-        @output = @input
-        run_next
-      end
-    end
-  end
-end

data/lib/apricot/stages.rb

@@ -1,60 +0,0 @@
-module Apricot
-  class Compiler
-    class Generator < Rubinius::Compiler::Stage
-      stage :apricot_bytecode
-      next_stage Rubinius::Compiler::Encoder
-
-      def initialize(compiler, last)
-        super
-        compiler.generator = self
-      end
-
-      def run
-        @output = Apricot::Generator.new
-        @input.bytecode @output
-        @output.close
-        run_next
-      end
-    end
-
-    class Parser < Rubinius::Compiler::Stage
-      def initialize(compiler, last)
-        super
-        compiler.parser = self
-      end
-
-      def run
-        @output = parse
-        run_next
-      end
-    end
-
-    class FileParser < Parser
-      stage :apricot_file
-      next_stage Generator
-
-      def input(file)
-        @file = file
-      end
-
-      def parse
-        Apricot::Parser.parse_file(@file)
-      end
-    end
-
-    class StringParser < Parser
-      stage :apricot_string
-      next_stage Generator
-
-      def input(code, file = "(none)", line = 1)
-        @input = code
-        @file = file
-        @line = line
-      end
-
-      def parse
-        Apricot::Parser.parse_string(@input, @file, @line)
-      end
-    end
-  end
-end

data/spec/parser_spec.rb

@@ -1,312 +0,0 @@
-describe Apricot::Parser do
-  def parse(s)
-    @ast = described_class.parse_string(s, "(spec)")
-    @first = @ast.elements.first
-    @ast.elements
-  end
-
-  def parse_one(s, klass)
-    parse(s).length.should == 1
-    @first.should be_a(klass)
-    @first
-  end
-
-  def expect_syntax_error(s)
-    expect { parse(s) }.to raise_error(Apricot::SyntaxError)
-  end
-
-  it 'parses nothing' do
-    parse('').should be_empty
-  end
-
-  it 'skips whitespace' do
-    parse(" \n\t,").should be_empty
-  end
-
-  it 'skips comments' do
-    parse('; example').should be_empty
-    parse('#!/usr/bin/env apricot').should be_empty
-  end
-
-  it 'discards commented forms' do
-    parse('#_form').should be_empty
-  end
-
-  it 'parses identifiers' do
-    parse_one('example', AST::Identifier)
-    @first.name.should == :example
-  end
-
-  it 'parses pipe identifiers' do
-    parse_one('#|example|', AST::Identifier).name.should == :example
-    parse_one('#|foo bar|', AST::Identifier).name.should == :"foo bar"
-    parse_one('#|foo\nbar|', AST::Identifier).name.should == :"foo\nbar"
-    parse_one('#|foo\|bar|', AST::Identifier).name.should == :"foo|bar"
-    parse_one('#|foo"bar|', AST::Identifier).name.should == :'foo"bar'
-  end
-
-  it 'parses constants' do
-    parse_one('Example', AST::Identifier)
-    @first.constant?.should be_true
-    @first.const_names.should == [:Example]
-  end
-
-  it 'parses invalid constants as identifiers' do
-    parse_one('Fo$o', AST::Identifier)
-    @first.constant?.should be_false
-  end
-
-  it 'parses scoped constants' do
-    parse_one('Foo::Bar::Baz', AST::Identifier)
-    @first.constant?.should be_true
-    @first.const_names.should == [:Foo, :Bar, :Baz]
-  end
-
-  it 'parses invalid scoped constants as identifiers' do
-    parse_one('Foo::', AST::Identifier)
-    @first.constant?.should be_false
-    parse_one('Foo:', AST::Identifier)
-    @first.constant?.should be_false
-    parse_one('Foo::a', AST::Identifier)
-    @first.constant?.should be_false
-    parse_one('Foo::::Bar', AST::Identifier)
-    @first.constant?.should be_false
-  end
-
-  it 'parses true, false, nil, and self' do
-    parse('true false nil self').length.should == 4
-    @ast[0].should be_a(AST::Literal)
-    @ast[0].value.should == :true
-    @ast[1].should be_a(AST::Literal)
-    @ast[1].value.should == :false
-    @ast[2].should be_a(AST::Literal)
-    @ast[2].value.should == :nil
-    @ast[3].should be_a(AST::Identifier)
-    @ast[3].name.should == :self
-  end
-
-  it 'parses fixnums' do
-    parse_one('123', AST::Literal)
-    @first.value.should == 123
-  end
-
-  it 'parses bignums' do
-    parse_one('12345678901234567890', AST::BignumLiteral)
-    @first.value.should == 12345678901234567890
-  end
-
-  it 'parses radix integers' do
-    parse_one('2r10', AST::Literal)
-    @first.value.should == 2
-  end
-
-  it 'parses floats' do
-    parse_one('1.23', AST::FloatLiteral)
-    @first.value.should == 1.23
-  end
-
-  it 'parses rationals' do
-    parse_one('12/34', AST::RationalLiteral)
-    @first.numerator.should == 12
-    @first.denominator.should == 34
-  end
-
-  it 'does not parse invalid numbers' do
-    expect_syntax_error '12abc'
-  end
-
-  it 'parses empty strings' do
-    parse_one('""', AST::StringLiteral)
-    @first.value.should == ''
-  end
-
-  it 'parses strings' do
-    parse_one('"Hello, world!"', AST::StringLiteral)
-    @first.value.should == 'Hello, world!'
-  end
-
-  it 'parses multiline strings' do
-    parse_one(%{"This is\na test"}, AST::StringLiteral)
-    @first.value.should == "This is\na test"
-  end
-
-  it 'does not parse unfinished strings' do
-    expect_syntax_error '"'
-  end
-
-  it 'parses strings with character escapes' do
-    parse_one('"\\a\\b\\t\\n\\v\\f\\r\\e\\"\\\\"', AST::StringLiteral)
-    @first.value.should == "\a\b\t\n\v\f\r\e\"\\"
-  end
-
-  it 'parses strings with octal escapes' do
-    parse_one('"\\1\\01\\001"', AST::StringLiteral)
-    @first.value.should == "\001\001\001"
-  end
-
-  it 'parses strings with hex escapes' do
-    parse_one('"\\x1\\x01"', AST::StringLiteral)
-    @first.value.should == "\001\001"
-  end
-
-  it 'does not parse strings with invalid hex escapes' do
-    expect_syntax_error '"\\x"'
-  end
-
-  it 'stops parsing hex/octal escapes in strings at non-hex/octal digits' do
-    parse_one('"\xAZ\082"', AST::StringLiteral)
-    @first.value.should == "\x0AZ\00082"
-  end
-
-  it 'parses regexes' do
-    parse_one('#r!!', AST::RegexLiteral).pattern.should == ''
-    parse_one('#r!egex!', AST::RegexLiteral).pattern.should == 'egex'
-    parse_one('#r(egex)', AST::RegexLiteral).pattern.should == 'egex'
-    parse_one('#r[egex]', AST::RegexLiteral).pattern.should == 'egex'
-    parse_one('#r{egex}', AST::RegexLiteral).pattern.should == 'egex'
-    parse_one('#r<egex>', AST::RegexLiteral).pattern.should == 'egex'
-    parse_one('#r!\!!', AST::RegexLiteral).pattern.should == '!'
-    parse_one('#r!foo\bar!', AST::RegexLiteral).pattern.should == 'foo\bar'
-    parse_one('#r!\\\\!', AST::RegexLiteral).pattern.should == "\\\\"
-  end
-
-  it 'parses regexes with trailing options' do
-    parse_one('#r//i', AST::RegexLiteral)
-    @first.options.should == Regexp::IGNORECASE
-    parse_one('#r/foo/x', AST::RegexLiteral)
-    @first.options.should == Regexp::EXTENDED
-    parse_one('#r//im', AST::RegexLiteral)
-    @first.options.should == Regexp::IGNORECASE | Regexp::MULTILINE
-  end
-
-  it 'does not parse regexes with unknown trailing options' do
-    expect_syntax_error '#r/foo/asdf'
-  end
-
-  it 'parses symbols' do
-    parse_one(':example', AST::SymbolLiteral)
-    @first.value.should == :example
-  end
-
-  it 'parses quoted symbols' do
-    parse_one(':"\x01()"', AST::SymbolLiteral)
-    @first.value.should == :"\x01()"
-  end
-
-  it 'does not parse unfinished quoted symbols' do
-    expect_syntax_error ':"'
-  end
-
-  it 'does not parse empty symbols' do
-    expect_syntax_error ':'
-  end
-
-  it 'does parse empty quoted symbols' do
-    parse_one(':""', AST::SymbolLiteral)
-    @first.value.should == :""
-  end
-
-  it 'parses empty lists' do
-    parse_one('()', AST::List)
-    @first.elements.should be_empty
-  end
-
-  it 'parses lists' do
-    parse_one('(1 two)', AST::List)
-    @first[0].should be_a(AST::Literal)
-    @first[1].should be_a(AST::Identifier)
-  end
-
-  it 'parses empty arrays' do
-    parse_one('[]', AST::ArrayLiteral)
-    @first.elements.should be_empty
-  end
-
-  it 'parses arrays' do
-    parse_one('[1 two]', AST::ArrayLiteral)
-    @first[0].should be_a(AST::Literal)
-    @first[1].should be_a(AST::Identifier)
-  end
-
-  it 'parses empty hashes' do
-    parse_one('{}', AST::HashLiteral)
-    @first.elements.should be_empty
-  end
-
-  it 'parses hashes' do
-    parse_one('{:example 1}', AST::HashLiteral)
-    @first[0].should be_a(AST::SymbolLiteral)
-    @first[1].should be_a(AST::Literal)
-  end
-
-  it 'does not parse invalid hashes' do
-    expect_syntax_error '{:foo 1 :bar}'
-  end
-
-  it 'parses empty sets' do
-    parse_one('#{}', AST::SetLiteral)
-    @first.elements.should be_empty
-  end
-
-  it 'parses sets' do
-    parse_one('#{1 two}', AST::SetLiteral)
-    @first[0].should be_a(AST::Literal)
-    @first[1].should be_a(AST::Identifier)
-  end
-
-  it 'parses multiple forms' do
-    parse('foo bar').length.should == 2
-    @ast[0].should be_a(AST::Identifier)
-    @ast[1].should be_a(AST::Identifier)
-  end
-
-  it 'parses quoted forms' do
-    parse_one("'test", AST::List)
-    @first.elements.length.should == 2
-    @first[0].should be_a(AST::Identifier)
-    @first[0].name.should == :quote
-    @first[1].should be_a(AST::Identifier)
-    @first[1].name.should == :test
-  end
-
-  it 'parses syntax quoted forms' do
-    begin
-      old_gensym = Apricot.instance_variable_get :@gensym
-      Apricot.instance_variable_set :@gensym, 41
-
-      parse_one("`(foo ~bar ~@baz quux#)", AST::List)
-      @first.should == AST::Node.from_value(
-        List[Identifier.intern(:concat),
-          List[Identifier.intern(:list),
-            List[Identifier.intern(:quote),
-              Identifier.intern(:foo)]],
-          List[Identifier.intern(:list),
-            Identifier.intern(:bar)],
-          Identifier.intern(:baz),
-          List[Identifier.intern(:list),
-            List[Identifier.intern(:quote),
-              Identifier.intern(:'quux#__42')]]])
-    ensure
-      Apricot.instance_variable_set :@gensym, old_gensym
-    end
-  end
-
-  it 'parses #() shorthand' do
-    Apricot.stub(:gensym).and_return(*:a..:z)
-
-    parse("#()").should == parse("(fn [] ())")
-    parse("#(foo)").should == parse("(fn [] (foo))")
-    parse("#(%)").should == parse("(fn [a] (a))")
-    parse("#(% %2)").should == parse("(fn [b c] (b c))")
-    parse("#(%1 %2)").should == parse("(fn [d e] (d e))")
-    parse("#(%2)").should == parse("(fn [g f] (f))")
-    parse("#(%&)").should == parse("(fn [& h] (h))")
-    parse("#(% %&)").should == parse("(fn [i & j] (i j))")
-
-    expect_syntax_error("#(%0)")
-    expect_syntax_error("#(%-1)")
-    expect_syntax_error("#(%x)")
-    expect_syntax_error("#(%1.1)")
-    expect_syntax_error("#(%1asdf)")
-  end
-end