fancy 0.3.0

data/lib/block.fy

@@ -0,0 +1,88 @@
+class Block {
+  """
+  The Block class (also BlockEnvironment) is the class of all
+  Block-literal values.
+  A Block is a piece of unevaluated code, that can be passed around as
+  any other value and evaluated by calling the +call+ or +call:+ methods.
+
+  Blocks also work properly with their enclosing environment in that
+  they preserve any local variables that get used within the Block,
+  even if the context in which they got defined has been destroyed.
+  => Blocks are proper closures.
+
+  See: http://en.wikipedia.org/wiki/Closure_(computer_science) for
+  more information.
+  """
+
+  def while_false: block {
+    """
+    Executes a given Block while self evals to nil
+    Example:
+      i = 0
+      { i >= 10 } while_false: {
+        i println
+        i = i + 1
+      }
+    """
+
+    { self call not } while_true: block
+  }
+
+  def while_nil: block {
+    "Same as Block#while_false:"
+
+    while_false: block
+  }
+
+  alias_method: 'while_do: for: 'while_true:
+
+  def until_do: block {
+    """
+    Calls a given Block as long as @self returns @nil or @false.
+    """
+
+    loop: {
+      self call if_do: |val| {
+        return val
+      } else: {
+        block call
+      }
+    }
+  }
+
+  def && other_block {
+    """
+    Short-circuiting && (boolean AND).
+    """
+
+    if: (self call) then: {
+      other_block call
+    } else: {
+      return false
+    }
+  }
+
+  def || other_block {
+    """
+    Short-circuiting || (boolean OR).
+    """
+
+    if: (self call) then: {
+      return true
+    } else: {
+      other_block call
+    }
+  }
+
+  def if: obj {
+    "Calls itself if the given object is true-ish."
+
+    if: obj then: { self call }
+  }
+
+  def unless: obj {
+    "Opposite of Block#if:. Calls itself if the given object is false-ish."
+
+    unless: obj do: { self call }
+  }
+}

data/lib/boot.fy

@@ -0,0 +1,41 @@
+# boot.fnc
+# This file gets loaded & run by Fancy automatically.
+# It loads in Fancy's standard library & core classes.
+
+# NOTE:
+# Order DOES matter here, so watch out what you're doing.
+# In general, it's best to add any autoload-files at the end of the
+# current list (if adding them here is really necessary at all).
+
+# rbx.fy loads all the files in lib/rbx/ in the correct order, which
+# define all the functionality to let fancy run on rbx.
+# also, they might override functionality defined in lib/ to reuse
+# existing ruby methods etc.
+require: "rbx.fy"
+
+require: "object"
+require: "class"
+require: "true_class"
+require: "nil_class"
+require: "number"
+require: "enumerable"
+require: "string"
+require: "array"
+require: "tuple"
+require: "block"
+require: "file"
+require: "directory"
+require: "fancy_spec"
+require: "hash"
+require: "set"
+require: "symbol"
+require: "method"
+require: "stack"
+
+# version holds fancy's version number
+require: "version"
+require: "argv"
+
+require: "documentation"
+
+require: "package.fy"

data/lib/class.fy

@@ -0,0 +1,106 @@
+class Class {
+  """
+  This class is the class of @Class@ objects - e.g. @Object@, @Array@,
+  @String@ etc.
+  Any class in the language is an instance of this class, as in Ruby
+  or Smalltalk.
+  """
+
+  def define_slot_reader: slotname {
+    """
+    @slotname Name of the slot to define a getter method for.
+
+    Defines a slot reader method with a given name.
+    E.g. for a slotname @count it will define the following method:
+        def count {
+          get_slot: 'count
+        }
+    """
+
+    define_method: slotname with: {
+      get_slot: slotname
+    }
+  }
+
+  def define_slot_writer: slotname {
+    """
+    @slotname Name of the slot to defnie define a setter method for.
+
+    Defines a slot writer method with a given name.
+    E.g. for a slotname @count it will define the following method:
+        def count: c {
+          set_slot: 'count value: c
+        }
+    """
+
+    define_method: (slotname to_s + ":") with: |val| {
+      set_slot: slotname value: val
+    }
+  }
+
+  def read_slots: slots {
+    """
+    @slots @Array@ of slotnames to define getter methods for.
+
+    Defines slot reader methods for all given slotnames.
+    """
+
+    slots each: |s| {
+      define_slot_reader: s
+    }
+  }
+
+  def write_slots: slots {
+    """
+    @slots @Array@ of slotnames to define setter methods for.
+
+    Defines slot writer methods for all given slotnames.
+    """
+
+    slots each: |s| {
+      define_slot_writer: s
+    }
+  }
+
+  def read_write_slots: slots {
+    """
+    @slots @Array@ of slotnames to define getter & setter methods for.
+
+    Defines slot reader & writer methods for all given slotnames.
+    """
+
+    slots each: |s| {
+      define_slot_reader: s
+      define_slot_writer: s
+    }
+  }
+
+  def subclass?: class_obj {
+    """
+    @class_obj Class object to check for, if @self is a subclass of @class_obj.
+    @return @true, if @self is a subclass of @class_obj, @false otherwise.
+
+    Indicates, if a Class is a subclass of another Class.
+    """
+
+    if: (self == class_obj) then: {
+      true
+    } else: {
+      # take care of Object class, as Object is its own superclass
+      unless: (self superclass nil?) do: {
+        self superclass subclass?: class_obj
+      }
+    }
+  }
+
+  def alias_method: new_method_name for: old_method_name {
+    """
+    @new_method_name New method name to be used as an alias for @old_method_name.
+    @old_method_name Name of method to alias (must exist in the @Class@).
+
+    Defines an alias method for another method.
+    """
+
+    alias_method_rbx: new_method_name for: old_method_name
+  }
+}

data/lib/compiler.fy

@@ -0,0 +1,14 @@
+#!/usr/bin/env fancy
+
+# A Fancy to rbx bytecode compiler.
+
+require: "compiler/compiler"
+require: "compiler/stages"
+require: "compiler/ast"
+
+require: "parser"
+
+if: (__FILE__ == (ARGV[0])) then: {
+  require: "compiler/command"
+  Fancy Compiler Command run: ARGV
+}

data/lib/compiler/ast.fy

@@ -0,0 +1,40 @@
+"""
+  AST nodes are an object representation of source files.
+
+
+  For example for a source code containing only the following expression:
+
+     Console println: hello
+
+  An AST tree like the following will be created:
+
+     Script:
+      @body: ExpressionList
+        @expressions:
+          - MessageSend
+             @receiver:
+               Constant @string: Console
+             @name:
+               Identifier @string: println:
+             @args:
+               - Identifier @string: hello
+"""
+
+require: "ast/node"
+require: "ast/script"
+require: "ast/expression_list"
+require: "ast/identifier"
+require: "ast/message_send"
+require: "ast/method_def"
+require: "ast/singleton_method_def"
+require: "ast/super"
+require: "ast/literals"
+require: "ast/assign"
+require: "ast/block"
+require: "ast/class_def"
+require: "ast/tuple_literal"
+require: "ast/range"
+require: "ast/require"
+require: "ast/match"
+require: "ast/try_catch"
+require: "ast/return"

data/lib/compiler/ast/assign.fy

@@ -0,0 +1,96 @@
+class Fancy AST {
+
+  class Assignment : Node {
+    def initialize: @line var: @lvalue value: @rvalue { }
+
+    def bytecode: g {
+      pos(g)
+      @lvalue bytecode: g assign: @rvalue
+    }
+  }
+
+  class MultipleAssignment : Node {
+    class MultipleAssignmentExpr : Node {
+      def initialize: @line index: @index {
+      }
+
+      def bytecode: g {
+        pos(g)
+        margs = MessageArgs new: @line args: [FixnumLiteral new: @line value: @index]
+        recv = StackTop new: @line
+        msg = Identifier from: "at:" line: @line
+        MessageSend new: @line message: msg to: recv args: margs . bytecode: g
+      }
+    }
+
+    class SplatAssignmentExpr : Node {
+      def initialize: @line start_index: @start_index {
+      }
+
+      def bytecode: g {
+        pos(g)
+        margs = MessageArgs new: @line args: [FixnumLiteral new: @line value: @start_index, FixnumLiteral new: @line value: -1]
+        recv = StackTop new: @line
+        msg = Identifier from: "from:to:" line: @line
+        MessageSend new: @line message: msg to: recv args: margs . bytecode: g
+      }
+    }
+
+    def initialize: @line var: @idents value: @values {
+    }
+
+    def bytecode: g {
+      pos(g)
+      if: (@values size > 1) then: {
+        ArrayLiteral new: @line array: @values . bytecode: g
+      } else: {
+        # in this case we just have one value for multi-assign
+        # so we expect it to be a collection type and get values by
+        # calling "at:" method (see above)
+        @values first bytecode: g
+      }
+
+      max_idx  = @idents size - 1
+      @idents each_with_index: |ident idx| {
+        var = ident
+        value = MultipleAssignmentExpr new: @line index: idx
+        match ident string -> {
+          case /^\*/ ->
+            value = SplatAssignmentExpr new: @line start_index: idx
+            var = Identifier from: (ident string rest) line: (ident line)
+        }
+        Assignment new: @line var: var value: value . bytecode: g
+        g pop()
+      }
+    }
+  }
+
+  class Identifier {
+    def bytecode: g assign: value {
+      pos(g)
+      Rubinius AST LocalVariableAssignment new(@line, self name, value) bytecode(g)
+    }
+  }
+
+  class InstanceVariable {
+    def bytecode: g assign: value {
+      pos(g)
+      Rubinius AST InstanceVariableAssignment new(@line, self name, value) bytecode(g)
+    }
+  }
+
+  class ClassVariable {
+    def bytecode: g assign: value {
+      pos(g)
+      Rubinius AST ClassVariableAssignment new(@line, self name, value) bytecode(g)
+    }
+  }
+
+  class Constant {
+    def bytecode: g assign: value {
+      pos(g)
+      Rubinius AST ConstantAssignment new(@line, self name, value) bytecode(g)
+    }
+  }
+
+}

data/lib/compiler/ast/block.fy

@@ -0,0 +1,84 @@
+class Fancy AST {
+  class BlockLiteral : Rubinius AST Iter {
+    def initialize: @line args: @args body: @body (NilLiteral new: line) partial: @partial (false) {
+      if: (@body empty?) then: {
+        @body unshift_expression: $ NilLiteral new: @line
+      }
+      initialize(@line, @args, @body)
+      @args create_locals: self
+      if: (@args total_args == 0) then: {
+        @arguments prelude=(nil)
+      }
+      if: (@args.total_args > 1) then: {
+        @arguments prelude=('multi)
+      }
+      @arguments required_args=(@args required_args)
+
+      if: @partial then: {
+        first_expr = @body expressions first
+
+        # if first expression is an identifier, use that as a 0-arg
+        # method name to send to new receiver (use a generated symbol
+        # name created in lib/parser/methods.fy / Fancy Parser#ast:partial_block:)
+        # if first expression is a message send where its receiver is
+        # an identifier, use that as the message name in a send to
+        # self and use the result as the receiver value for the rest.
+        new_receiver = Identifier from: (@args args first to_s) line: @line
+        match first_expr -> {
+          case Identifier ->
+            @body expressions shift()
+            @body unshift_expression: $ MessageSend new: @line message: first_expr to: (new_receiver) args: (MessageArgs new: @line args: [])
+          case MessageSend ->
+            match first_expr receiver -> {
+              case Self ->
+                first_expr receiver: new_receiver
+              case Identifier ->
+                first_expr receiver: $ MessageSend new: @line message: (first_expr receiver) to: (new_receiver) args: (MessageArgs new: @line args: [])
+            }
+        }
+      }
+    }
+
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class BlockArgs : Node {
+    read_write_slots: ['args, 'block]
+
+    def initialize: @line args: @args ([]) {
+      @args = @args map: |a| { a name to_sym() }
+    }
+
+    def bytecode: g {
+      pos(g)
+      if: (@args size > 1) then: {
+        @args each_with_index: |a i| {
+            g shift_array()
+            g set_local(i)
+            g pop()
+        }
+      } else: {
+        @args each_with_index: |a i| {
+          g set_local(i)
+        }
+      }
+    }
+
+    def total_args {
+      @args size
+    }
+
+    def required_args {
+      self total_args
+    }
+
+    def create_locals: block {
+      @args each: |a| {
+        block new_local(a)
+      }
+    }
+  }
+}