fancy 0.3.0

data/boot/fancy_ext/object.rb

@@ -0,0 +1,34 @@
+class Object
+  define_method("ruby:with_block:") do |method, block|
+    self.send(method, &block)
+  end
+
+  define_method("ruby:args:with_block:") do |method, args, block|
+    self.send(method, *args, &block)
+  end
+
+  define_method("ruby:args:") do |method, args|
+    self.send(method, *args)
+  end
+
+  define_method(":to_s") do
+    return self.to_s
+  end
+
+  # HACK:
+  # When we define private/protected/public methods, we usually use
+  # Module#private, Module#protected & Module#public methods to set the
+  # access of that method.
+  # But in cases where we define methods not within a class
+  # definition, this fails. To make it work, we define these. Kinda
+  # stupid, i know, but oh well. Maybe need to fix this in the future.
+  def public
+    Rubinius::VariableScope.of_sender.method_visibility = nil
+  end
+  def private
+    Rubinius::VariableScope.of_sender.method_visibility = :private
+  end
+  def protected
+    Rubinius::VariableScope.of_sender.method_visibility = :protected
+  end
+end

data/boot/fancy_ext/string_helper.rb

@@ -0,0 +1,10 @@
+class Fancy
+  class AST
+    class StringHelper
+      def self.unescape_string(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/load.rb

@@ -0,0 +1,72 @@
+class Fancy
+  # This version of Fancy::CodeLoader is used only for bootstrapping
+  # This constant needs to be overloaded with fancy version of this.
+  class BootstrapCodeLoader
+
+    class << self
+      def path_stack
+        @path_stack ||= []
+      end
+
+      def file_stack
+        @file_stack ||= []
+      end
+
+      # This method may return an Fancy::Script object with source
+      # information.
+      def current_file(compiled_from)
+        # compiled_from is the filename captured at compile time.
+        # ie. the location where the fancy file was compiled from.
+
+        # file_stack.last is the filename being loaded
+        # possibly from a different location than it was compiled from
+
+        # Only return the current file being loaded.
+        file_stack.last
+      end
+      alias_method "current_file:", :current_file
+
+      def load_compiled_file(file, find_file = nil)
+        path_stack.push(File.expand_path(File.dirname(file), path_stack.last))
+
+        file = File.expand_path(File.basename(file), path_stack.last)
+
+        file = file + "c" if file =~ /.fy$/
+        file = file+".fyc" unless file =~ /\.fyc$/
+        raise "File not found #{file}" unless File.exist?(file)
+
+        cl = Rubinius::CodeLoader.new(file)
+        cm = cl.load_compiled_file(file, 0)
+
+        source = file.sub(/\.fyc/, ".fy")
+
+        file_stack.push(source)
+
+        script = cm.create_script(false)
+        script.file_path = source
+
+        MAIN.__send__ :__script__
+
+        file_stack.pop
+        path_stack.pop
+      end
+
+      alias_method "require:", :load_compiled_file
+    end
+  end
+
+  CodeLoader = BootstrapCodeLoader
+end
+
+
+if __FILE__ == $0
+  require File.expand_path("fancy_ext", File.dirname(__FILE__))
+  # Load files up to the --
+  if dash = ARGV.index("--")
+    load = ARGV.shift(dash + 1)
+    load.pop
+  else
+    load = ARGV.shift(ARGV.length)
+  end
+  load.each { |f| Fancy::CodeLoader.load_compiled_file File.expand_path(f) }
+end

data/boot/rbx-compiler/README

@@ -0,0 +1,12 @@
+This directory contains all the code for compiling Fancy source files
+(.fy) to Rubinius bytecode files (.fyc).
+
+The compiler implementation is in the compiler/ directory.
+
+The fancy_ext/ directory contains a small amount of methods defined in
+Ruby to existing classes in Rubinius to allow Fancy to run on rbx. See
+fancy_ext.rb for more information.
+
+The parser/ directory contains the bison & flex written parser and
+lexer which are used as a C-extension in rbx to generate the
+appropriate AST node instances in parser/parser.rb.

data/boot/rbx-compiler/compiler.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env rbx
+
+# A Fancy to rbx bytecode compiler.
+#
+# This compiler is written in Ruby, because it's easier to start
+# writing a working compiler with the given tools of Rubinius that are
+# written in Ruby than porting all that code to Fancy.
+#
+# Once we can compile Fancy to Rubinius we will reimplement the
+# compiler in Fancy and can still reuse the rubinius compiler
+# toolchain for actual bytecode file generation.
+#
+# This program is indended to be run using rbx.
+
+base = File.dirname(__FILE__)
+require base + '/compiler/compiler'
+require base + '/compiler/stages'
+require base + '/compiler/ast'
+require base + '/parser'
+
+if __FILE__ == $0
+  require base + '/compiler/command'
+  Fancy::Compiler::Command.run ARGV
+end

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

@@ -0,0 +1,23 @@
+base = File.dirname(__FILE__)
+
+require base + '/ast/node'
+require base + '/ast/script'
+require base + '/ast/expression_list'
+require base + '/ast/message_send'
+require base + '/ast/ruby_args'
+require base + '/ast/identifier'
+require base + '/ast/string_literal'
+require base + '/ast/method_def'
+require base + '/ast/singleton_method_def'
+require base + '/ast/require'
+require base + '/ast/class_def'
+require base + '/ast/block'
+require base + '/ast/assign'
+require base + '/ast/array_literal'
+require base + '/ast/tuple_literal'
+require base + '/ast/range_literal'
+require base + '/ast/hash_literal'
+require base + '/ast/super'
+require base + '/ast/try_catch_block'
+require base + '/ast/return'
+require base + '/ast/match'

data/boot/rbx-compiler/compiler/ast/README

@@ -0,0 +1,11 @@
+This directory contains all the AST Node classes used by the
+compiler. Most of them inherit from an equivalent Ruby Node class
+defined in rbx's lib/compiler/ directory.
+
+Each node class has a bytecode() method in which the actual bytecode
+generation is done by calling generator methods on the generator
+object, that is passed in as an argument.
+
+If there's no bytecode() method defined in a node class, this just
+means, we're simply using the bytecode() method of the superclass (the
+one defined by rbx's compiler library).

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

@@ -0,0 +1,13 @@
+class Fancy
+  class AST
+
+    class ArrayLiteral < Rubinius::AST::ArrayLiteral
+      attr_accessor :array
+      def initialize(line, *array)
+        super(line, array)
+        @array = array
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,57 @@
+class Fancy
+  class AST
+
+    class Assignment < Node
+      def initialize(line, ident, value)
+        super(line)
+        @ident = ident
+        @value = value
+      end
+
+      def bytecode(g)
+        if @ident.constant?
+          Rubinius::AST::ConstantAssignment.new(line, @ident.name, @value).bytecode(g)
+        elsif @ident.instance_variable?
+          Rubinius::AST::InstanceVariableAssignment.new(line, @ident.name, @value).
+            bytecode(g)
+        elsif @ident.class_variable?
+          Rubinius::AST::ClassVariableAssignment.new(line, @ident.name, @value).
+            bytecode(g)
+        else
+          Rubinius::AST::LocalVariableAssignment.new(line, @ident.name, @value).
+            bytecode(g)
+        end
+      end
+    end
+
+    class MultipleAssignment < Node
+
+      class MultipleAssignmentExpr < Node
+        def initialize(line)
+          super(line)
+        end
+        def bytecode(g)
+          g.shift_array
+        end
+      end
+
+      def initialize(line, idents, values)
+        super(line)
+        @idents = idents
+        @values = values
+      end
+
+      def bytecode(g)
+        @values.each do |val|
+          val.bytecode(g)
+        end
+        g.make_array @values.size
+        @idents.each do |ident|
+          Assignment.new(@line, ident, MultipleAssignmentExpr.new(@line)).bytecode(g)
+          g.pop
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,70 @@
+class Fancy
+  class AST
+
+    class BlockLiteral < Rubinius::AST::Iter
+      def initialize(line, args, body)
+        @args = args
+        body = body || Rubinius::AST::NilLiteral.new(line)
+
+        if body.empty?
+          body.unshift_expression Rubinius::AST::NilLiteral.new(line)
+        end
+
+        super(line, args, body)
+        args.create_locals(self)
+
+        if args.total_args == 0
+          @arguments.prelude = nil
+        end
+        if args.total_args > 1
+          @arguments.prelude = :multi
+        end
+        @arguments.required_args = args.required_args
+      end
+
+      def bytecode(g)
+        #docstring = body.shift_docstring
+        super(g)
+        #MethodDef.set_docstring(g, docstring, line, @args.args)
+      end
+    end
+
+    class BlockArgs < Node
+      attr_accessor :args, :block
+
+      def initialize(line, *args)
+        super(line)
+        @args = args.map{|a| a.name.to_sym}
+      end
+
+      def bytecode(g)
+        if @args.size > 1
+          @args.each_with_index do |a, i|
+            g.shift_array
+            g.set_local i
+            g.pop
+          end
+        else
+          @args.each_with_index do |a, i|
+            g.set_local i
+          end
+        end
+      end
+
+      def total_args
+        @args.size
+      end
+
+      def required_args
+        total_args
+      end
+
+      def create_locals(block)
+        @args.each do |a|
+          block.new_local(a)
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,35 @@
+class Fancy
+  class AST
+
+    class ClassDef < Rubinius::AST::Class
+      def initialize(line, name, parent, body)
+        if name.kind_of?(Fancy::AST::Identifier)
+          name = name.name
+        end
+
+        super(line, name, parent, body)
+
+        if body.empty?
+          body.unshift_expression Rubinius::AST::NilLiteral.new(line)
+        end
+      end
+
+      def bytecode(g)
+        docstring = body.body.shift_docstring
+        if docstring
+          setdoc = MessageSend.new(line,
+                                   Identifier.new(line, "Fancy::Documentation"),
+                                   Identifier.new(line, "for:append:"),
+                                   MessageArgs.new(line,
+                                                   Rubinius::AST::Self.new(line),
+                                                   docstring))
+          # Replace first string expression to set documentation.
+          body.body.expressions.unshift setdoc
+        end
+        super(g)
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,57 @@
+class Fancy
+  class AST
+
+    class ExpressionList < Node
+      attr_reader :expressions
+
+      def initialize(line, *expressions)
+        super(line)
+        @expressions = expressions
+      end
+
+      def unshift_expression(expression)
+        @expressions.unshift(expression)
+      end
+
+      def add_expression(expression)
+        @expressions << expression
+      end
+
+      def empty?
+        @expressions.empty?
+      end
+
+      def bytecode(g)
+        pos(g)
+        size = @expressions.size
+        @expressions.each do |expr|
+          size -= 1
+          expr.bytecode(g)
+          g.pop if size > 0
+        end
+      end
+
+      def empty?
+        @expressions.size == 0
+      end
+
+      # This method is only used by Rubinius' compiler classes and
+      # defined to be able to use their bytecode generation toolchain.
+      def strip_arguments
+        []
+      end
+
+      # If this expression list contains more than one expression
+      # and the first one is an string literal, it'll be used as doc.
+      # This method removes the first documentation string.
+      def shift_docstring
+        if expressions.first.kind_of?(Rubinius::AST::StringLiteral) &&
+            expressions.size > 1
+          expressions.shift
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+class Fancy
+  class AST
+
+    class HashLiteral < Rubinius::AST::HashLiteral
+      def initialize(line, *array)
+        super(line, array)
+      end
+    end
+
+  end
+end