fancy 0.3.0

data/boot/rbx-compiler/compiler/ast/ruby_args.rb

@@ -0,0 +1,35 @@
+class Fancy
+  class AST
+
+    class RubyArgs < Node
+      def initialize(line, args, block = nil)
+        super(line)
+        @args = args
+        # If no block given and last arg is a block identifier
+        if block.nil? &&
+            args.array.last.kind_of?(Fancy::AST::Identifier) &&
+            args.array.last.identifier =~ /^&\w/
+          block = args.array.pop
+          block = Fancy::AST::Identifier.new(block.line, block.identifier[1..-1])
+        end
+        @block = block
+      end
+
+      def bytecode(g)
+        @args.array.each do |a|
+          a.bytecode(g)
+        end
+        @block.bytecode(g) if @block
+      end
+
+      def size
+        @args.array.size
+      end
+
+      def has_block?
+        not @block.nil?
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/script.rb

@@ -0,0 +1,56 @@
+class Fancy
+  class AST
+
+    class Script < Node
+      attr_reader :body, :filename
+
+      @@stack = []
+
+      def push_script
+        @@stack.push self
+      end
+
+      def pop_script
+        @@stack.pop
+      end
+
+      def self.current
+        @@stack.last
+      end
+
+      def initialize(line, filename, body)
+        super(line)
+        @filename = filename
+        @body = body
+      end
+
+      def bytecode(g)
+        begin
+          push_script
+
+          #docs, code = body.expressions.partition do |s|
+          #  s.kind_of?(Rubinius::AST::StringLiteral)
+          #end
+
+          #if code.empty?
+            # only literal string found, we have to evaluate to it, not
+            # use as documentation.
+          #  docs, code = [], docs
+          #end
+
+          #code.each { |c| c.bytecode(g) }
+          @body.bytecode(g)
+
+          # the docs array has top-level expressions that are
+          # simply string literals, we can use them for file-level
+          # documentation.
+          # TODO: implement file documentation here.
+        ensure
+          pop_script
+        end
+      end
+
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/singleton_method_def.rb

@@ -0,0 +1,39 @@
+class Fancy
+  class AST
+
+    class SingletonMethodDef < Rubinius::AST::DefineSingleton
+      def initialize(line, obj_ident, method_ident, args, body, access = :public)
+        @line = line
+        @receiver = obj_ident
+        @name = method_ident.method_name(@receiver)
+        @arguments = args
+        @body = SingletonMethodDefScope.new line, @name, args, body
+        @access = access
+      end
+
+      def bytecode(g)
+        g.push_self
+        g.send @access, 0
+        g.pop
+        super(g)
+      end
+    end
+
+    class SingletonMethodDefScope < Rubinius::AST::DefineSingletonScope
+      def initialize(line, name, args, body)
+        @line = line
+        @name = name
+        @arguments = args
+        @body = body
+      end
+
+      def bytecode(g, recv)
+        #docstring = @body.shift_docstring
+        super(g, recv)
+        #MethodDef.set_docstring(g, docstring, @line, @arguments.names)
+      end
+
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/string_literal.rb

@@ -0,0 +1,14 @@
+class Fancy
+  class AST
+    class StringLiteral < Rubinius::AST::StringLiteral
+      def initialize(line, str)
+        super(line, unescape_chars(str))
+      end
+
+      def unescape_chars(str)
+        str.gsub("\\r", "\r").gsub("\\t", "\t").gsub("\\n", "\n").gsub("\\v", "\v").gsub("\\b", "\b").
+          gsub("\\f", "\f").gsub("\\a", "\a").gsub("\\\\", "\\").gsub("\\?", "\?").gsub("\\'", "\'").gsub('\\"', '\"').gsub("\\\"", "\"")
+      end
+    end
+  end
+end

data/boot/rbx-compiler/compiler/ast/super.rb

@@ -0,0 +1,25 @@
+class Fancy
+  class AST
+
+    class Super < Node
+      def initialize(line)
+        super(line)
+      end
+    end
+
+    class SuperSend < Node
+      def initialize(line, method_name, args)
+        super(line)
+        @method_name = method_name.name.to_sym
+        @args = args
+      end
+
+      def bytecode(g)
+        pos(g)
+        @args.bytecode(g)
+        g.send_super @method_name, @args.size
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/try_catch_block.rb

@@ -0,0 +1,220 @@
+class Fancy
+  class AST
+
+    class TryCatchBlock < Node
+      def initialize(line, body, handlers, finally)
+        super(line)
+        @body = body
+        @handlers = handlers
+        @finally = finally || Rubinius::AST::NilLiteral.new(line)
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        g.push_modifiers
+
+        outer_retry = g.new_label
+        this_retry = g.new_label
+        reraise = g.new_label
+
+        # save the current exception into a stack local
+        g.push_exception_state
+        outer_ex = g.new_stack_local
+        g.set_stack_local outer_ex
+        g.pop
+
+        # retry label for re-entering the try body
+        this_retry.set!
+
+        handler = g.new_label
+        finally = g.new_label
+        done = g.new_label
+
+        g.setup_unwind handler, Rubinius::AST::RescueType
+
+        # make a break available to use
+        if current_break = g.break
+          g.break = g.new_label
+        end
+
+        # use lazy label to patch up prematuraly leaving a try body
+        # via retry
+        if outer_retry
+          g.retry = g.new_label
+        end
+
+        # also handle redo unwinding through the rescue
+        if current_redo = g.redo
+          g.redo = g.new_label
+        end
+
+        @body.bytecode(g)
+
+        g.pop_unwind
+        g.pop
+        g.goto finally
+
+
+        if current_break
+          if g.break.used?
+            g.break.set!
+            g.pop_unwind
+
+            # Reset the outer exception
+            g.push_stack_local outer_ex
+            g.restore_exception_state
+
+            g.goto current_break
+          end
+
+          g.break = current_break
+        end
+
+        if current_redo
+          if g.redo.used?
+            g.redo.set!
+            g.pop_unwind
+
+            # Reset the outer exception
+            g.push_stack_local outer_ex
+            g.restore_exception_state
+
+            g.goto current_redo
+          end
+
+          g.redo = current_redo
+        end
+
+        if outer_retry
+          if g.retry.used?
+            g.retry.set!
+            g.pop_unwind
+
+            # Reset the outer exception
+            g.push_stack_local outer_ex
+            g.restore_exception_state
+
+            g.goto outer_retry
+          end
+
+          g.retry = outer_retry
+        end
+
+
+        # We jump here if an exception has occurred in the body
+        handler.set!
+
+        # Expose the retry label here only, not before this
+        g.retry = this_retry
+
+        # Save exception state to use in reraise
+        g.push_exception_state
+
+        raised_exc_state = g.new_stack_local
+        g.set_stack_local raised_exc_state
+        g.pop
+
+        # Save the current exception, so that calling #=== can't trample
+        # it.
+        g.push_current_exception
+
+        @handlers.bytecode(g, finally)
+
+        reraise.set!
+        # Execute the finally block before propagating the exception
+        @finally.bytecode(g)
+
+        # remove the exception so we have the state
+        g.pop
+        # restore the state and reraise
+        g.push_stack_local raised_exc_state
+        g.restore_exception_state
+        g.reraise
+
+        finally.set!
+        @finally.bytecode(g)
+
+        done.set!
+
+        g.push_stack_local outer_ex
+        g.restore_exception_state
+        g.pop_modifiers
+      end
+
+    end
+
+    class ExceptHandler < Node
+      def initialize(line, condition, var, body)
+        super(line)
+        @condition = condition
+        @var = var
+        @body = body
+      end
+
+      def bytecode(g, finally)
+        nothing = g.new_label
+
+        @condition.bytecode(g)
+        g.push_current_exception
+        g.send :===, 1
+        g.gif nothing
+
+        if @var
+          Fancy::AST::Assignment.new(line, @var, CurrentException.new(line)).bytecode(g)
+          g.pop
+        end
+
+        @body.bytecode(g)
+        g.pop unless @body.empty?
+
+        g.clear_exception
+        g.pop
+
+        g.goto finally
+        nothing.set!
+      end
+
+    end
+
+    class CurrentException < Node
+      def initialize(line)
+        super(line)
+      end
+
+      def bytecode(g)
+        g.push_current_exception
+      end
+    end
+
+    class Handlers < Node
+      def initialize(line, *handlers)
+        super(line)
+        @handlers = handlers
+      end
+
+      def bytecode(g, finally)
+        @handlers.each do |handler|
+          handler.bytecode(g, finally)
+        end
+      end
+
+      def add_handler(handler)
+        @handlers.push(handler)
+        self
+      end
+    end
+
+    class Retry < Node
+      def initialize(line)
+        super(line)
+      end
+
+      def bytecode(g)
+        g.pop
+        g.goto g.retry
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/tuple_literal.rb

@@ -0,0 +1,33 @@
+class Fancy
+  class AST
+
+    class TupleLiteral < Node
+      attr_accessor :elements
+      def initialize(line, *elements)
+        super(line)
+        @elements = elements
+      end
+
+      def bytecode(g)
+        ms = MessageSend.new(@line,
+                             Identifier.new(@line, "Rubinius::Tuple"),
+                             Identifier.new(@line, "new"),
+                             MessageArgs.new(@line,
+                                             RubyArgs.new(@line,
+                                                          ArrayLiteral.new(@line, Rubinius::AST::FixnumLiteral.new(@line, @elements.size)))))
+        ms.bytecode(g)
+        @elements.each_with_index do |e, i|
+          g.dup
+          MessageSend.new(@line,
+                          Nothing.new,
+                          Identifier.new(@line, "at:put:"),
+                          MessageArgs.new(@line,
+                                          Rubinius::AST::FixnumLiteral.new(@line, i),
+                                          e)).bytecode(g)
+          g.pop
+        end
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/command.rb

@@ -0,0 +1,39 @@
+require 'fileutils'
+
+class Fancy
+  class Compiler
+    class Command
+      def self.option_flag(argv, name)
+        argv.delete name
+      end
+
+      def self.option_value(argv, name)
+        if idx = argv.index(name)
+          value = argv.delete_at(idx + 1)
+          argv.delete_at(idx)
+          value
+        end
+      end
+
+      def self.run(argv)
+        batch = option_flag(argv, "--batch")
+        print = option_flag(argv, "-B")
+        src_path = option_value(argv, "--source-path")
+        out_path = option_value(argv, "--output-path")
+        argv.each do |f|
+          out = nil
+          if out_path && src_path
+            out = f.sub(src_path, out_path) + "c"
+          end
+          compile(f, out, batch, print)
+        end
+      end
+
+      def self.compile(file, out = nil, info_output = false, print = false)
+        puts "Compiling #{file}" if info_output
+        FileUtils.mkdir_p(File.dirname(out)) if out
+        Compiler.compile_fancy_file file, out, 1, print
+      end
+    end
+  end
+end