fancy 0.3.0

data/lib/compiler/ast/method_def.fy

@@ -0,0 +1,90 @@
+class Fancy AST {
+
+  class MethodDef : Rubinius AST Define {
+    def initialize: @line name: @name args: @arguments body: @body access: @access {
+      @name = @name method_name: nil
+      self generate_ivar_assignment
+
+      if: (@body empty?) then: {
+        @body unshift_expression: $ NilLiteral new: @line
+      }
+    }
+
+    def generate_ivar_assignment {
+      @arguments required() reverse() each: |name| {
+        if: (name to_s =~ /^@/) then: {
+          ident = Identifier from: (name to_s) line: @line
+          value = Rubinius AST LocalVariableAccess new(@line, name)
+          asign = Assignment new: @line var: ident value: value
+          @body unshift_expression: asign
+        }
+      }
+    }
+
+    def bytecode: g {
+      pos(g)
+      g push_self()
+      g send(@access, 0)
+      g pop()
+
+      @name to_s =~ /^initialize:(\S)+/ if_do: {
+        define_constructor_class_method: g
+      }
+      @name to_s =~ /^unknown_message:with_params:$/ if_do: {
+        define_method_missing: g
+      }
+
+      docstring = @body shift_docstring
+      bytecode(g)
+      MethodDef set: g docstring: docstring line: @line argnames: $ @arguments names()
+    }
+
+    # Sets fancy documentation for the object currently
+    # on top of the stack
+    def MethodDef set: g docstring: docstring line: line argnames: argnames {
+      # prevent invoking documentation: when doesnt makes sense.
+      { return nil } unless: docstring
+      local = StackLocal new: line
+      local set: g
+      ms = MessageSend new: line \
+                       message: (Identifier from: "for:is:" line: line) \
+                       to: (Identifier from: "Fancy::Documentation" line: line) \
+                       args: $ MessageArgs new: line args: [local, docstring]
+      ms bytecode: g
+
+      meta = HashLiteral new: line entries: [SymbolLiteral new: line value: 'argnames,
+                                             ArrayLiteral new: line array: $ argnames map: |arg| { StringLiteral new: line value: $ arg to_s }]
+      ms = MessageSend new: line \
+                       message: (Identifier from: "meta:" line: line) \
+                       to: (Nothing new: line) \
+                       args: $ MessageArgs new: line args: [meta]
+      ms bytecode: g
+      g pop()
+    }
+
+    # defines a class method names "new:foo:" if we're defining a
+    # method named e.g. "initialize:foo:" (a constructor method).
+    def define_constructor_class_method: g {
+      method_ident = StringLiteral new(@line, @name to_s from: 11 to: -1)
+      ms = MessageSend new:     @line                                                             \
+                       message: (Identifier from: "define_constructor_class_method:" line: @line) \
+                       to:      (Self new: @line)                                                 \
+                       args:    (MessageArgs new: @line args: [method_ident])
+      ms bytecode: g
+    }
+
+    def define_method_missing: g {
+      ms = MessageSend new:     @line                                                          \
+                       message: (Identifier from: "define_forward_method_missing" line: @line) \
+                       to:      (Self new: @line)                                              \
+                       args:    (MessageArgs new: @line args: [])
+      ms bytecode: g
+    }
+  }
+
+  class MethodArgs : Rubinius AST FormalArguments {
+    def initialize: @line args: @array{
+      initialize(@line, @array map() |a| { a to_sym() }, nil, nil)
+    }
+  }
+}

data/lib/compiler/ast/node.fy

@@ -0,0 +1,7 @@
+class Fancy AST {
+
+  class Node : Rubinius AST Node {
+    define_method('bytecode) |g| { bytecode: g }
+  }
+
+}

data/lib/compiler/ast/range.fy

@@ -0,0 +1,16 @@
+class Fancy AST {
+  class RangeLiteral : Node {
+    read_slots: ['from, 'to]
+    def initialize: @line from: @from to: @to {
+    }
+
+    def bytecode: g {
+      pos(g)
+      ms = MessageSend new: @line                                           \
+                       message: (Identifier from: "new:to:" line: @line)    \
+                       to: (Identifier from: "Range" line: @line)           \
+                       args: (MessageArgs new: @line args: [@from, @to])
+      ms bytecode: g
+    }
+  }
+}

data/lib/compiler/ast/require.fy

@@ -0,0 +1,15 @@
+class Fancy AST {
+  class Require : Node {
+    def initialize: @line file: @string {
+    }
+
+    def bytecode: g {
+      pos(g)
+      ms = MessageSend new: @line \
+                       message: (Identifier from: "require:" line: @line)    \
+                       to: (Identifier from: "Fancy::CodeLoader" line: @line) \
+                       args: (MessageArgs new: @line args: [@string])
+      ms bytecode: g
+    }
+  }
+}

data/lib/compiler/ast/return.fy

@@ -0,0 +1,23 @@
+class Fancy AST {
+  class Return : Node {
+    def initialize: @line expr: @expr {
+    }
+
+    def bytecode: g {
+      pos(g)
+      @expr bytecode: g
+      g raise_return()
+    }
+  }
+
+  class ReturnLocal : Node {
+    def initialize: @line expr: @expr {
+    }
+
+    def bytecode: g {
+      pos(g)
+      @expr bytecode: g
+      g ret()
+    }
+  }
+}

data/lib/compiler/ast/script.fy

@@ -0,0 +1,52 @@
+class Fancy AST {
+
+  class Script : Node {
+    read_slots: ['file, 'line, 'body]
+
+    @@stack = []
+
+    def push_script {
+      @@stack push(self)
+    }
+
+    def pop_script {
+      @@stack pop()
+    }
+
+    def self current {
+      @@stack last()
+    }
+
+    def initialize: @line file: @file body: @body {
+    }
+
+    def bytecode: g {
+      pos(g)
+      try {
+        self 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.
+      } finally {
+        self pop_script
+      }
+    }
+  }
+
+}

data/lib/compiler/ast/singleton_method_def.fy

@@ -0,0 +1,35 @@
+class Fancy AST {
+  class SingletonMethodDef : Rubinius AST DefineSingleton {
+
+    def initialize: @line name: @name args: @arguments body: @body access: @access owner: @receiver {
+      name = @name method_name: @receiver
+      @body = SingletonMethodDefScope new: @line name: name args: @arguments body: @body
+    }
+
+    def bytecode: g {
+      pos(g)
+      g push_self()
+      g send(@access, 0)
+      g pop()
+      bytecode(g)
+    }
+
+  }
+
+  class SingletonMethodDefScope : Rubinius AST DefineSingletonScope {
+
+    def initialize: @line name: @name args: @arguments body: @body { }
+
+    define_method("bytecode") |g, recv| {
+      bytecode: g receiver: recv
+    }
+
+    def bytecode: g receiver: receiver {
+      pos(g)
+      docstring = @body shift_docstring
+      sup = Rubinius AST DefineSingletonScope instance_method('bytecode)
+      sup bind(self) call(g, receiver)
+      MethodDef set: g docstring: docstring line: @line argnames: $ @arguments names()
+    }
+  }
+}

data/lib/compiler/ast/super.fy

@@ -0,0 +1,17 @@
+class Fancy AST {
+
+  class Super : Node {
+    def initialize: @line { }
+  }
+
+  class SuperSend : Node {
+    def initialize: @line message: @name args: @args { }
+    def bytecode: g {
+      pos(g)
+      @args bytecode: g
+      name = @name method_name: nil
+      g send_super(name, @args size)
+    }
+  }
+
+}

data/lib/compiler/ast/try_catch.fy

@@ -0,0 +1,176 @@
+class Fancy AST {
+  class TryCatch : Node {
+
+    def initialize: @line body: @body handlers: @handlers ensure: @ensure {}
+
+    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-entring 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
+      current_break = g break()
+      if: current_break then: { g break=(g new_label()) }
+
+      # use lazy label to patch up prematuraly leaving a try body via retry
+      if: outer_retry then: { g retry=(g new_label()) }
+
+      # also handle redo unwinding through the rescue
+      current_redo = g redo()
+      if: current_redo then: { g redo=(g new_label()) }
+
+      @body bytecode(g)
+
+      g pop_unwind()
+      g pop()
+      g goto(finally_)
+
+      if: current_break then: {
+        if: (g break() used?()) then: {
+          g break() set!()
+          g pop_unwind()
+
+          # Reset the outer exception
+          g push_stack_local(outer_ex)
+          g restore_exception_state()
+
+          g goto(current_break)
+        }
+        g break=(current_break)
+      }
+
+      if: current_redo then: {
+        if: (g redo() used?()) then: {
+          g redo() set!()
+          g pop_unwind()
+
+          # Reset the outer exception
+          g push_stack_local(outer_ex)
+          g restore_exception_state()
+
+          g goto(current_redo)
+        }
+        g redo=(current_redo)
+      }
+
+      if: outer_retry then: {
+        if: (g retry() used?()) then: {
+          g retry() set!()
+          g pop_unwind()
+
+          # Reset the outer exception
+          g push_stack_local(outer_ex)
+          g restore_exception_state()
+
+          g goto(outer_retry)
+        }
+        g retry=(outer_retry)
+      }
+
+      # we jump here if an exception was thrown 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 calling #=== cant trample it.
+      g push_current_exception()
+
+      @handlers each: |h| { h bytecode: g final_tag: finally_ }
+
+      reraise set!()
+
+      # execte the finally block before propagating the exception
+      @ensure 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!()
+      @ensure bytecode: g
+
+      done set!()
+
+      g push_stack_local(outer_ex)
+      g restore_exception_state()
+      g pop_modifiers()
+    }
+  }
+
+  class ExceptionHandler : Node {
+    def initialize: @line condition: @condition var: @var body: @body {}
+
+    def bytecode: g final_tag: final_tag {
+      pos(g)
+      nothing = g new_label()
+      @condition bytecode: g
+      g push_current_exception()
+      g send('===, 1)
+      g gif(nothing)
+
+      if: @var then: {
+        Assignment new: @line var: @var value: (CurrentException new: @line) .
+          bytecode: g
+        g pop()
+      }
+
+      @body bytecode: g
+      { g pop() } unless: $ @body empty?
+
+      g clear_exception()
+      g pop()
+
+      g goto(final_tag)
+      nothing set!()
+    }
+  }
+
+  class CurrentException : Node {
+    def initialize: @line {}
+    def bytecode: g {
+      pos(g)
+      g push_current_exception()
+    }
+  }
+
+  class Retry : Node {
+    def initialize: @line {}
+    def bytecode: g {
+      pos(g)
+      g pop()
+      g goto(g retry())
+    }
+  }
+
+}

data/lib/compiler/ast/tuple_literal.fy

@@ -0,0 +1,34 @@
+class Fancy AST {
+  class TupleLiteral : Node {
+    def initialize: @line entries: @elements { }
+
+    def bytecode: g {
+      pos(g)
+      ary = ArrayLiteral new: @line array: [FixnumLiteral new: @line value: (@elements size)]
+
+      args = RubyArgs new: @line args: ary
+
+      msg_ident = Identifier from: "new" line: @line
+      msg_ident ruby_ident: true
+      ms = MessageSend new:     @line                                            \
+                       message: (msg_ident)                                      \
+                       to:      (Identifier from: "Rubinius::Tuple" line: @line) \
+                       args:    args
+
+      ms bytecode: g
+
+      @elements each_with_index() |e i| {
+        g dup()
+        ary = [FixnumLiteral new: @line value: i, e]
+
+        ms = MessageSend new:  @line                                       \
+                         message: (Identifier from: "at:put:" line: @line) \
+                         to:   (Nothing new: @line)                        \
+                         args: (MessageArgs new: @line args: ary)
+
+        ms bytecode: g
+        g pop()
+      }
+    }
+  }
+}