fancy 0.3.0

data/bin/fancy

@@ -0,0 +1,40 @@
+#!/usr/bin/env rbx
+# -*- ruby -*-
+
+base = File.dirname(__FILE__)
+require File.expand_path("../boot/fancy_ext", base)
+
+# Use the bootstrapping code loader.
+require File.expand_path("../boot/load", base)
+
+do_retry = true
+begin
+  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/boot", base)
+
+  # Remove the bootstrapping code loader
+  bcl = Fancy.send :remove_const, :CodeLoader
+  bcl.load_compiled_file File.expand_path("../lib/rbx/code_loader", base)
+
+  # Initialize the load path
+  Fancy::CodeLoader.push_loadpath File.expand_path("../lib", base)
+
+  # Load compiler+eval support
+  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/eval", base)
+
+  # Run main
+  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/main", base)
+
+rescue RuntimeError => e
+  if e.message =~ /File not found (.*)lib\/boot.fyc/
+    if do_retry
+      puts "Fancy hasn't been bootstrapped yet. Doing that now.\n\n"
+      `cd #{base} && rbx -S rake clean && rbx -S rake`
+      do_retry = false
+      retry
+    else
+      raise e
+    end
+  else
+    raise e
+  end
+end

data/bin/fdoc

@@ -0,0 +1,23 @@
+#!/usr/bin/env rbx
+# -*- ruby -*-
+
+class Fancy; end
+class Fancy::Parser; end
+
+# fdoc is a documentation generator for fancy.
+# This is a ruby script because we need to setup a hook
+# BEFORE any fancy code is loaded. So we can create
+# documentation for Fancy's builtin objects as well.
+# See fdoc.
+base = File.expand_path("../boot", File.dirname(__FILE__))
+require File.expand_path("rbx-compiler/parser/fancy_parser", base)
+require File.expand_path("rbx-compiler/compiler", base)
+require File.expand_path("code_loader", base)
+require File.expand_path("fancy_ext", base)
+
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/rbx/documentation.fyc", base)
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/fdoc_hook.fyc", base)
+
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/rbx.fyc", base)
+
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/fdoc.fyc", base)

data/bin/fyi

@@ -0,0 +1,22 @@
+#!/usr/bin/env fancy
+# -*- fancy -*-
+
+ARGV[1] if_do: |ident| {
+  "Documentation for: '" ++ ident ++ "' :" println;
+  ident includes?: "#" . if_true: {
+    parts = (ident split: "#");
+    obj = (parts[0]) eval;
+    method = obj method: (parts[1]);
+    method documentation println
+  } else: {
+    obj = ident eval;
+    obj documentation println
+  }
+} else: {
+  ["Prints the documentation string for a given object or one if its methods",
+   "Usage:",
+   "fyi [ObjectIdentifier]",
+   "fyi [ObjectIdentifier]#[MethodName]",
+   "",
+   "Example: fyi Array#each:"] println
+}

data/bin/ifancy

@@ -0,0 +1,46 @@
+#!/usr/bin/env fancy
+# -*- fancy -*-
+
+require("readline")
+
+["Welcome to the (still very simple) Fancy REPL",
+ "Fancy " ++ FANCY_VERSION] println
+
+ARGV rest each: |file| {
+  "LOADING: " ++ file println
+  require: file
+}
+
+# handle SIGINT
+trap("INT") {
+  "Quitting." println
+  System exit
+}
+
+Console newline;
+
+def double_or_empty?: line {
+  (line =~ /^\s*$/) or: (Readline HISTORY to_a[-2] == line)
+}
+
+
+try {
+  bnd = binding()
+
+  { Readline readline(">> ", true) } while_do: |line| {
+
+    double_or_empty?: line . if_true: {
+      Readline::HISTORY pop()
+    }
+
+    line =~ /^\s*$/ if_false: {
+      try {
+        Fancy eval: line binding: bnd . inspect println
+      } catch Exception => e {
+        e message() println
+      }
+    }
+  }
+} catch Interrupt => e {
+  System exit
+}

data/boot/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/code_loader.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/env rbx
+
+base = File.dirname(__FILE__) + "/"
+
+# load in fancy specific extensions
+require base + "fancy_ext"
+
+require base + "/rbx-compiler/compiler"
+require base + "/rbx-compiler/compiler/command"
+
+# only used for bin/fdoc at the moment
+# this is just temporary and was copied from and old version
+# of rbx/fancy_code_loader.rb
+
+class Fancy
+  class CodeLoader
+    class << self
+      SOURCE_FILE_EXTENSION = "fy"
+      COMPILED_FILE_EXTENSION = "fyc"
+
+      @@load_path = []
+      @@compiled = {}
+      @@loaded = {}
+      @@current_dir = []
+
+      def push_loadpath path
+        @@load_path << path unless @@load_path.include? path
+      end
+
+      # Throws an exception for a given filename that wasn't found and
+      # thus could not be loaded.
+      def load_error(filename)
+        raise "LoadError: Can't find file: #{filename}"
+      end
+
+      # Returns the name of a file or nil, if it doesn't exist.
+      # Might append a ".fy" extension, if it's missing for the given
+      # filename.
+      def find_file(filename)
+        filename_with_ext = filename + ".#{SOURCE_FILE_EXTENSION}"
+        if !File.exists?(filename) || File.directory?(filename)
+          return filename_with_ext if File.exists? filename_with_ext
+        else
+          return filename
+        end
+        nil
+      end
+
+      # Finds a file in a given path and returns the filename including
+      # the path.
+      def find_file_in_path(file, path)
+        find_file(path + "/" + file)
+      end
+
+      # Tries to find a file with a given name in the LOADPATH array
+      # (all paths that have been seen while loading other files so
+      # far), starting with the @current_dir (the directory, the current
+      # running fancy source file is in).
+      def filename_for(filename)
+        if f = find_file(filename)
+          return f
+        else
+          if @@current_dir.last && f = find_file_in_path(filename, @@current_dir.last)
+            return f
+          end
+          @@load_path.each do |p|
+            begin
+              if f = find_file_in_path(filename, p)
+                return f
+              end
+            rescue
+            end
+          end
+        end
+        load_error filename
+      end
+
+      # Returns the source filename for a given filename.
+      # E.g. "foo.fyc" => "foo.fy"
+      def source_filename_for(filename)
+        if filename =~ /.compiled.#{COMPILED_FILE_EXTENSION}$/
+          return filename[0..-14]
+        elsif filename =~ /.#{COMPILED_FILE_EXTENSION}$/
+          return filename[0..-2]
+        end
+        filename
+      end
+
+      # Returns the compiled filename for a given filename.
+      # E.g. "foo.fy" => "foo.fyc", "foo" => "foo.compiled.rbc"
+      def compiled_filename_for(filename)
+        if filename =~ /.#{COMPILED_FILE_EXTENSION}$/
+          return filename
+        end
+        if filename =~ /\.#{SOURCE_FILE_EXTENSION}$/
+          return filename + "c"
+        else
+          return filename + ".compiled.#{COMPILED_FILE_EXTENSION}"
+        end
+      end
+
+      # Optionally compiles a file, if not done yet and returns the
+      # compiled file's name.
+      def optionally_compile_file(f)
+        source_filename = source_filename_for(f)
+        filename = filename_for(source_filename)
+        compiled_file = compiled_filename_for(filename)
+        unless @@compiled[filename]
+          if !File.exists?(compiled_file) ||
+            File.stat(compiled_file).mtime < File.stat(filename).mtime
+            Compiler.compile_fancy_file filename, nil, 1, false
+          else
+            @@compiled[filename] = true
+          end
+        end
+        compiled_file
+      end
+
+      # Loads a compiled fancy bytecode file.
+      # If +find_file+ is set to false, it will just use the given
+      # filename without looking up the file in the LOADPATH.
+      def load_compiled_file(filename, find_file = true)
+        if find_file
+          filename = filename_for(filename)
+          file = compiled_filename_for(filename)
+        end
+
+        file = optionally_compile_file(file)
+
+        unless @@loaded[file]
+          unless File.exists? file
+            load_error file
+          end
+
+          dirname = File.dirname(file)
+          push_loadpath dirname
+          @@current_dir.push dirname
+          @@loaded[file] = true
+
+          cl = Rubinius::CodeLoader.new(file)
+          cm = cl.load_compiled_file(file, 0)
+
+          script = cm.create_script(false)
+          script.file_path = filename
+
+          MAIN.__send__ :__script__
+
+          @@current_dir.pop
+        end
+      end
+      alias_method "require:", :load_compiled_file
+    end
+  end
+end
+
+if $0 == __FILE__
+  # load & run file
+  file = ARGV.shift
+  raise "Expected a fancy file to load" unless file
+  if File.exists? file
+    Fancy::CodeLoader.load_compiled_file file
+  else
+    Fancy::CodeLoader.load_compiled_file(base + "../lib/main.fyc")
+  end
+end

data/boot/compile.fy

@@ -0,0 +1,3 @@
+# Bootstrap Usage:
+# rbx boot/load.rb boot/compiler/boot.fyc boot/compiler/compiler.fyc boot/compiler/command.fyc boot/compile.fyc -- <FILES_TO_COMPILE>
+Fancy Compiler Command run: ARGV

data/boot/fancy_ext.rb

@@ -0,0 +1,13 @@
+# The fancy_ext directory contains Rubinius-specific code (mostly
+# extension methods) for existing classes that need to be defined in
+# Ruby in order for Fancy to work correctly on rbx.
+# The amount of code should be kept as small as possible, as we want
+# to write as much in Fancy as possible.
+
+base = File.dirname(__FILE__) + "/fancy_ext/"
+require base + "kernel"
+require base + "module"
+require base + "object"
+require base + "block_env"
+require base + "class"
+require base + "string_helper"

data/boot/fancy_ext/block_env.rb

@@ -0,0 +1,29 @@
+# in Fancy we use the BlockEnvironment as Block
+Block = Rubinius::BlockEnvironment
+
+class Block
+  define_method("while_true:") do |block|
+    while tmp = self.call
+      block.call(tmp)
+    end
+  end
+
+  # call without arguments
+  alias_method :":call", :call
+
+  define_method("call:") do |args|
+    if args.first.is_a?(Array) && args.size == 1
+      call args.first
+    else
+      call *args
+    end
+  end
+
+  define_method("call_with_receiver:") do |obj|
+    call_under obj, method.scope
+  end
+
+  define_method("call:with_receiver:") do |args, obj|
+    call_under obj, method.scope, *args
+  end
+end

data/boot/fancy_ext/class.rb

@@ -0,0 +1,26 @@
+class Class
+  # the define_constructor_class_method: method defines a constructor
+  # class method.
+  # e.g. for an instance method named "initialize:foo:" we'll define a class
+  # method named "new:foo:" which creates a new instance of the class
+  # (via allocate) & call the "initialize:foo:" method on it, before
+  # returning the new instance.
+  # NOTE:
+  # the method_name argument to "define_constructor_class_method:"
+  # contains only the rest of the method name, not including the
+  # "initialize:" or "new:", so we'll have to prepend it ourselves
+  define_method("define_constructor_class_method:") do |method_name|
+    self.metaclass.send(:define_method, "new:" + method_name) do |*args|
+      obj = self.allocate
+      obj.send("initialize:" + method_name, *args)
+      return obj
+    end
+  end
+
+  define_method(":define_forward_method_missing") do
+    define_method("method_missing") do |method_name, *args|
+      self.send("unknown_message:with_params:", method_name, args)
+    end
+  end
+
+end

data/boot/fancy_ext/kernel.rb

@@ -0,0 +1,12 @@
+module Kernel
+
+  alias_method :":metaclass", :metaclass
+
+  def fancy_require(file, compile = false)
+    if compile
+      file = Fancy::CodeLoader.compile_file! file
+    end
+    find_file = !compile
+    Fancy::CodeLoader.load_compiled_file file, find_file
+  end
+end

data/boot/fancy_ext/module.rb

@@ -0,0 +1,89 @@
+class Module
+
+  # Fancy version does not restricts to only modules.
+  define_method :"include:" do |modules|
+    modules = [modules] unless modules.kind_of?(Array)
+    modules.reverse_each do |mod|
+      mod.send :"append_features:", self
+      mod.send :included, self
+    end
+  end
+
+  # Fancy version does not restricts to only modules.
+  ###
+  #
+  # Called when this Module is being included in another Module.
+  # This may be overridden for custom behaviour. The default
+  # is to add constants, instance methods and module variables
+  # of this Module and all Modules that this one includes to +klass+.
+  #
+  # See also #include.
+  #
+  define_method :"append_features:" do |klass|
+    # check other.frozen
+    # taint other from self
+
+    insert_at = klass
+    mod = self
+    changed = false
+
+    while mod
+
+      # Check for a cyclic include
+      if mod == klass
+        raise ArgumentError, "cyclic include detected"
+      end
+
+      # Try and detect check_mod in klass's heirarchy, and where.
+      #
+      # I (emp) tried to use Module#< here, but we need to also know
+      # where in the heirarchy the module is to change the insertion point.
+      # Since Module#< doesn't report that, we're going to just search directly.
+      #
+      superclass_seen = false
+      add = true
+
+      k = klass.direct_superclass
+      while k
+        if k.kind_of? Rubinius::IncludedModule
+          # Oh, we found it.
+          if k == mod
+            # ok, if we're still within the directly included modules
+            # of klass, then put future things after mod, not at the
+            # beginning.
+            insert_at = k unless superclass_seen
+            add = false
+            break
+          end
+        else
+          superclass_seen = true
+        end
+
+        k = k.direct_superclass
+      end
+
+      if add
+        if mod.kind_of? Rubinius::IncludedModule
+          original_mod = mod.module
+        else
+          original_mod = mod
+        end
+
+        im = Rubinius::IncludedModule.new(original_mod).attach_to insert_at
+        insert_at = im
+
+        changed = true
+      end
+
+      mod = mod.direct_superclass
+    end
+
+    if changed
+      method_table.each do |meth, obj, vis|
+        Rubinius::VM.reset_method_cache meth
+      end
+    end
+
+    return self
+  end
+end