fancy 0.3.0

data/AUTHORS

@@ -0,0 +1,7 @@
+# Here's a (YAML-formatted) list of all people that have contributed to Fancy.
+
+- Christopher Bertels: { email: chris@fancy-lang.org, website: http://www.fancy-lang.org, irc: bakkdoor }
+- Christian Kruse:
+- Jose Narvaez: { email: goyox86@gmail.com, irc: goyox86, twitter: goyox86 }
+- Nils Haldenwang: { email: n.haldenwang@googlemail.com, website: http://www.nils-haldenwang.de, irc: NilsH }
+- Victor Hugo Borja: { email: vic.borja@gmail.com, irc: vborja, twitter: vborja }

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010, 2011, Christopher Bertels
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+      disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the original authors nor the names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,173 @@
+The Fancy Programming Language
+(C) 2010, 2011 Christopher Bertels <chris@fancy-lang.org>
+http://www.fancy-lang.org
+
+----------------------------------------------------------------------
+
+Fancy is a dynamic, object-oriented programming language heavily
+inspired by Smalltalk, Ruby and Erlang. It supports dynamic code
+evaluation (as in Ruby & Smalltalk), class-based mixins, (simple)
+pattern matching, runtime introspection & reflection, "monkey
+patching" and much more. It runs on Rubinius, the Ruby VM, and thus
+has first-class integration with Ruby's core library and any
+additional Ruby libraries that run on Rubinius, including most
+C-extensions.
+It will support concurrency via the actor-model, including first-class
+futures and async operation semantics built into the language.
+
+For a quick feature overview, have a look at doc/features.md
+
+----------------------------------------------------------------------
+
+It’s still in development, the implementation has evolved from an
+interpreter written in C++ to a fully bootstrapped bytecode compiler
+for the Rubinius VM (http://www.rubini.us).
+You can see the self-hosted compiler implementation in lib/compiler/.
+
+If you want to help out, feel free to contact us:
+http://github.com/bakkdoor/fancy/wiki/Get-in-touch
+
+For some example code have a look at the examples/ directory.
+
+There's also lots of test coverage code. Have a look at the tests/
+directory for these. The tests are written in FancySpec, a simple
+testing library (somewhat similar to Ruby's RSpec). FancySpec's
+implementation can be viewed in lib/fancy_spec.fy.
+
+----------------------------------------------------------------------
+
+Compiling / Installing from source:
+------------------------------------
+
+Dependencies:
+------------------------
+
+- Rubinius.
+  For now you'll need a recent version from the git repository.
+  We suggest using rvm and installing rbx-head.
+  See http://rvm.beginrescueend.com/ for more information.
+- Rake.
+- GNU Bison ( version 2.4 and higher otherwise you will get a Segmentation fault ).
+- GNU Flex.
+
+Given the tools & libraries mentioned above, Fancy _should_ build without problems
+on most *nix systems. We successfully have built Fancy on Debian & Ubuntu, OpenSuSE
+and Mac OS X 10.5 and 10.6.
+
+Standard building procedure:
+------------------------
+
+Building Fancy is just that easy:
+
+  $ cd <fancy_source_path>
+  $ rake
+
+This should go pretty fast. It actually compiles Fancy's standard
+library and compiler several times. Once via the bootstrap compiler
+written in Ruby (see boot/rbx-compiler), and then via the self-hosted
+compiler (see lib/compiler/) itself.
+
+Once the bootstrapping process is done, you can run the hello world example:
+
+  $ ./bin/fancy examples/hello_world.fy
+
+----------------------------
+Some technical information:
+----------------------------
+
+As the language is running on the Rubinius VM, Fancy shares the same
+runtime with Ruby. All of Fancy is built upon Ruby objects, so for
+example when you open the String class in Fancy, it's just Ruby's
+String class.
+
+Because of this, and because in Fancy's standard library (lib/*.fy) we
+can define methods with the same name as they're defined in Ruby (but
+taking no arguments), we have decided not to overwrite the Ruby
+methods.
+This ensures that all Ruby libraries for example can use Ruby's
+Kernel#print or any other method in Ruby's kernel and work seamlessly.
+
+Here's an example:
+
+    class Object {
+      def print {
+        "Print itself to the Console."
+        Console print: self
+      }
+    }
+
+To meet this goal, the Fancy compiler renames Fancy methods taking no
+arguments (like the previous "print" example) to a method named
+":print". Using explicit parens syntax will allow you to invoke any
+Ruby method.
+
+   someObject print    # Will actually invoke the Fancy ":print" method.
+   someObject print()  # With explicit parens invokes the Ruby method.
+
+Ruby method invocation supports passing a block variable to Ruby as a proc.
+
+    class Something {
+      def open: block {
+        someRubyMethod(arg0, arg1, &block)
+      }
+    }
+    Something new open: |s| { s work }
+
+    # with this syntax, calling ruby's inject is just as easy.
+    # This example will print the number 6
+    [1, 2, 3] inject(0) |sum, num| { sum + num } println
+
+
+What's already working?
+------------------------
+
+  - Class definitions
+    (including nested classes that work like modules / namespaces)
+  - Instance & class method definitions
+  - Default arguments
+  - Literal syntax for:
+    - Strings, Symbols, Integers, Floats, Arrays, Hashes (HashMaps), Blocks (closures),
+      Ranges, Tuples, Regular Expressions
+  - Method & Operator calls
+  - Instance & class variable access
+  - Dynamic getter and setter method definitions (similar to Ruby's attr_acessor)
+  - Loops
+  - Support for closures via Blocks
+  - Local & non-local returns from Blocks & Methods
+  - File reading and writing
+  - Class-Mixins (including methods of one class into another)
+  - Exception handling (try, catch, finally & retry)
+  - Simple pattern matching (work-in-progress)
+  - Calling, using and extending arbitrary Ruby classes and methods
+    (including C-extensions), as well as passing blocks and splat
+    arguments to Ruby methods.
+
+
+What's still missing?
+----------------------
+
+  - Concurrency stuff (Actor-model based concurrency, Futures etc)
+  - Some more advanced stuff, e.g. runtime inspection of method calls
+    via MethodContext etc. (saved for later)
+
+
+How is it implemented?
+-----------------------
+
+  - The lexer & parser are built with GNU Flex & GNU Bison.
+    And used as a Ruby c-extension from Rubinius.
+    The parser simply invokes methods on Fancy::Parser to build the AST.
+    See: rbx/parser/parser.y & rbx/parser/parser.rb
+
+  - Once the AST is built, we use Rubinius' excellent compiler chain
+    to compile it to bytecode.
+
+  - The bin/fancy file is simply a Rubinius code loader for .fy files.
+
+----------------------------------------------------------------------
+
+Copyright:
+-----------
+
+Fancy is licensed under the terms of the BSD license. For more
+information on licensing issues have a look at the LICENSE file.

data/Rakefile

@@ -0,0 +1,255 @@
+require 'rbconfig'
+
+def say(*msg)
+  puts(*msg) unless RakeFileUtils.verbose_flag == false
+end
+
+def sh!(*args, &block)
+  old_verbose = RakeFileUtils.verbose_flag
+  begin
+    RakeFileUtils.verbose_flag = nil if RakeFileUtils.verbose_flag == :default
+    sh(*args, &block)
+  ensure
+    RakeFileUtils.verbose_flag = old_verbose
+  end
+end
+
+def _(f, base = File.dirname(__FILE__))
+  File.expand_path(f, base)
+end
+
+
+dl_ext    = RbConfig::CONFIG['DLEXT']
+ext_dir   = _("lib/parser/ext")
+parser_e  = _("fancy_parser.#{dl_ext}", ext_dir)
+load_rb   = _("boot/load.rb")
+
+namespace :parser do
+
+  lexer_lex = _("lexer.lex", ext_dir)
+  lexer_c   = _("lexer.c", ext_dir)
+  parser_y  = _("parser.y", ext_dir)
+  parser_c  = _("parser.c", ext_dir)
+  extconf   = _("extconf.rb", ext_dir)
+  makefile  = _("Makefile", ext_dir)
+
+  file lexer_c => file(lexer_lex) do
+    Dir.chdir(ext_dir) do
+      sh! 'flex', '--outfile', lexer_c, '--header-file=lexer.h', lexer_lex
+    end
+  end
+
+  file parser_c => file(parser_y) do
+    Dir.chdir(ext_dir) { sh! 'bison', '--output', parser_c, '-d', '-v', parser_y }
+  end
+
+  file makefile => file(extconf) do
+    Dir.chdir(ext_dir) { sh! 'rbx', extconf }
+  end
+
+  desc "Generate parser source from flex/bison"
+  task :generate => [parser_c, lexer_c, makefile]
+
+  file parser_e => file(makefile) do
+    sh! 'make', '-C', ext_dir
+  end
+
+  desc "Compile the parser extension"
+  task :compile => file(parser_e)
+
+  desc "Removed generated parser sources"
+  task :remove do
+    rm_f [_("parser.h", ext_dir), _("lexer.h", ext_dir)], :verbose => false
+    rm_f [makefile, parser_c, lexer_c], :verbose => false
+  end
+
+  desc "Clean compiled files."
+  task :clean do
+    rm_f Dir.glob(_("*.{o,so,rbc,log,output,bundle}", ext_dir)), :verbose => false
+    rm_rf [_("conftest.dSYM", ext_dir)], :verbose => true
+  end
+
+end
+
+
+namespace :compiler do
+
+  boot_parser_e = _("boot/compiler/parser/ext/"+File.basename(parser_e))
+
+  file boot_parser_e => file(parser_e) do
+    mkdir_p File.dirname(boot_parser_e), :verbose => false
+    cp parser_e, boot_parser_e, :verbose => false
+  end
+
+  task :clean do
+    rm_f boot_parser_e, :verbose => false
+    rm_rf _("boot/rbx-compiler/parser/conftest.dSYM")
+    rm_rf _("boot/compiler"), :verbose => false
+  end
+
+  desc "Compile fancy using the stable compiler (from boot/compiler)."
+  task :compile => file(boot_parser_e) do
+    say "Compiling fancy using stable compiler."
+
+    cmd = ['rbx -Xint', load_rb]
+    cmd << _("boot/compiler/boot.fyc")
+    cmd << _("boot/compiler/compiler.fyc")
+    cmd << _("boot/compiler/compiler/command.fyc")
+    cmd << _("boot/compiler/compile.fyc")
+    cmd << "--"
+    cmd << "--batch" if RakeFileUtils.verbose_flag == true
+
+    sources = Dir.glob("lib/**/*.fy")
+    system (cmd + sources).join(" ")
+  end
+
+  load("boot/rbx-compiler/parser/Rakefile")
+
+  desc "Compile fancy using boot/rbx-compiler into boot/compiler/"
+  task :rootstrap => "compiler:rbx_parser:ext" do
+    say "Compiling fancy into boot/compiler using ruby-based compiler from boot/rbx-compiler."
+
+    output = _("boot/compiler")
+
+    cmd = ['rbx -Xint']
+    cmd << _("boot/rbx-compiler/compiler.rb")
+    cmd << "--batch" if RakeFileUtils.verbose_flag == true
+    cmd << "--output-path" << output
+
+    src_path = ["--source-path", _("lib")]
+    sources = Dir.glob(_("lib/**/*.fy"))
+    system (cmd + src_path + sources).join(" ")
+
+    src_path = ["--source-path", _("boot")]
+    sources = Dir.glob(_("boot/*.fy"))
+    system (cmd + src_path + sources).join(" ")
+
+    sh! "rbx", _("boot/rbx-compiler/compiler.rb"), _("boot/compile.fy")
+
+  end
+
+  desc "Compile fancy using lib/ compiler into boot/compiler/"
+  task :wootstrap do
+
+    say "Compiling fancy into boot/compiler using development compiler from lib/"
+
+    output = _("boot/.wootstrap")
+
+    cmd = ['rbx -Xint', load_rb]
+    cmd << _("lib/boot.fyc")
+    cmd << _("lib/compiler.fyc")
+    cmd << _("lib/compiler/command.fyc")
+    cmd << _("boot/compiler/compile.fyc")
+    cmd << "--"
+    cmd << "--batch" if RakeFileUtils.verbose_flag == true
+    cmd << "--output-path" << output
+
+    sources = Dir.glob("lib/**/*.fy")
+    system (cmd + sources).join(" ")
+
+    mkdir_p _("parser/ext", output), :verbose => false
+    cp parser_e, _("parser/ext", output), :verbose => false
+
+    say "Using fresh built compiler as `stable compiler' in boot/compiler"
+
+    rm_rf _("boot/compiler")
+    mv _("boot/.wootstrap"), _("boot/compiler")
+  end
+
+  task :bootstrap => ["parser:generate", "rbx_parser:ext", file(boot_parser_e)] do
+    ["compiler:rootstrap", "compiler:compile", "compiler:wootstrap"].each do |t|
+      task(t).reenable
+      task(t).execute
+    end
+  end
+
+  task :diff do
+    require 'open3'
+    sources = Dir.glob(_("lib/**/*.fy"))
+
+    say "Compiling fancy using stable compiler."
+    cmd = ['rbx', load_rb]
+    cmd << _("lib/boot.fyc")
+    cmd << _("lib/compiler.fyc")
+    cmd << _("lib/compiler/command.fyc")
+    cmd << _("boot/compiler/compiler.fyc")
+    cmd << "--"
+
+    sources.each do |file|
+      f = file.gsub(_("lib"), _("diff/fy-compiler")).gsub(/.fy$/, ".asm")
+      puts f
+      mkdir_p File.dirname(f), :verbose => false
+      Open3.popen3 *(cmd + [file, "-B"]) do |stdin, stdout, stderr|
+        File.open(f, "w") { |bc| bc.print stdout.read }
+      end
+    end
+
+
+    cmd = ['rbx']
+    cmd << _("boot/rbx-compiler/compiler.rb")
+
+    sources.each do |file|
+      f = file.gsub(_("lib"), _("diff/rb-compiler")).gsub(/.fy$/, ".asm")
+      puts f
+      mkdir_p File.dirname(f), :verbose => false
+      Open3.popen3 *(cmd + [file, "-B"]) do |stdin, stdout, stderr|
+        File.open(f, "w") { |bc| bc.print stdout.read }
+      end
+    end
+
+    sources.each do |file|
+      a = file.gsub(_("lib"), _("diff/rb-compiler")).gsub(/.fy$/, ".asm")
+      b = file.gsub(_("lib"), _("diff/fy-compiler")).gsub(/.fy$/, ".asm")
+      f = file.gsub(_("lib"), _("diff/diffs")).gsub(/.fy$/, ".diff")
+      mkdir_p File.dirname(f), :verbose => false
+      puts f
+      Open3.popen3 'diff', '-u9999', a, b do |stdin, stdout|
+        File.open(f, "w") { |bc| bc.print stdout.read }
+      end
+    end
+
+  end
+
+end
+
+desc "Deletes all .rbc and .fyc files."
+task :clean_compiled do
+  compiled = Dir.glob(_ "**/*.{rbc,fyc}")
+  rm_f compiled, :verbose => false
+end
+
+desc "Clean compiled files."
+task :clean => ["parser:clean", "parser:remove", "compiler:clean", :clean_compiled]
+
+
+def compile(source)
+  cmd = ['rbx', _("boot/load.rb")]
+  cmd << _("lib/boot.fyc")
+  cmd << _("lib/compiler.fyc")
+  cmd << _("lib/compiler/command.fyc")
+  cmd << _("boot/compile.fyc")
+  cmd << "--"
+  cmd << "--batch" if RakeFileUtils.verbose_flag == true
+  cmd << source.to_s
+  sh! *cmd
+end
+
+sources = Dir.glob(_("{lib,boot}/**/*.fy")).map { |f| file f }
+compiled = sources.map { |s| file((s.to_s+"c") => [s, file(parser_e)]) { compile s } }
+
+task :bootstrap_if_needed do
+  task(:bootstrap).invoke unless File.directory? _("boot/compiler")
+end
+
+task :compile => compiled
+
+desc "Runs the test suite."
+task :test do
+  sh! _('bin/fancy'),
+  '-e', 'ARGV rest rest each: |f| { require: f }',
+  *Dir.glob(_("tests/*.fy"))
+end
+
+task :bootstrap => ["compiler:bootstrap"]
+
+task :default => [:bootstrap_if_needed, :compile]