fancy 0.3.0

data/lib/compiler/ast/class_def.fy

@@ -0,0 +1,33 @@
+class Fancy AST {
+  class ClassDef : Rubinius AST Class {
+    def initialize: @line name: @name parent: @parent body: @body {
+      name = nil
+      if: (@name is_a?: NestedConstant) then: {
+        name = @name scoped
+      } else: {
+        name = @name string to_sym()
+      }
+
+      if: (@body empty?) then: {
+        @body unshift_expression: $ NilLiteral new: @line
+      }
+
+      initialize(@line, name, @parent, @body)
+    }
+
+    def bytecode: g {
+      pos(g)
+      docstring = body() body() shift_docstring
+      docstring if_do: {
+        setdoc = MessageSend new: @line \
+                             message: (Identifier from: "for:append:" line: @line) \
+                             to: (Identifier from: "Fancy::Documentation" line: @line) \
+                             args: (MessageArgs new: @line args: [Self new: @line, docstring])
+
+        # Replace first string expression to set documentation.
+        body() body() unshift_expression: setdoc
+      }
+      bytecode(g)
+    }
+  }
+}

data/lib/compiler/ast/expression_list.fy

@@ -0,0 +1,47 @@
+class Fancy AST {
+
+  class ExpressionList : Node {
+    read_slots: ['expressions]
+    def initialize: @line list: @expressions ([]) {}
+
+    def unshift_expression: expression {
+      @expressions unshift(expression)
+    }
+
+    def add_expression: expression {
+      @expressions << expression
+    }
+
+    def empty? {
+      @expressions empty?
+    }
+
+    def bytecode: g {
+      pos(g)
+      size = @expressions size
+      @expressions each: |expr| {
+        size = size - 1
+        expr bytecode: g
+        { g pop() } if: (size > 0)
+      }
+    }
+
+    # This method is only used by Rubinius' compiler classes and
+    # defined to be able to use their bytecode generation toolchain.
+    def strip_arguments {
+      []
+    }
+
+    # 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)) then: {
+        @expressions shift()
+      }
+    }
+
+  }
+
+}

data/lib/compiler/ast/identifier.fy

@@ -0,0 +1,113 @@
+class Fancy AST {
+
+  class Identifier : Node {
+    read_slots: ['string, 'line]
+    read_write_slots: ['ruby_ident]
+
+    @@gen_ident_start = 0
+
+    def Identifier generate: line {
+      """
+      @line Line to be set for generated Identifier.
+      @return New generated Identifier, e.g. \"______gen_ident______1\"
+
+      Generates a new Identifier using a simple counter.
+      """
+
+      @@gen_ident_start = @@gen_ident_start + 1
+      Identifier from: ("______gen_ident______" ++ @@gen_ident_start) line: line
+    }
+
+    def initialize: @line string: @string ruby_ident: @ruby_ident (false) {}
+
+    def name {
+      @string to_sym()
+    }
+
+    def method_name: receiver ruby_send: ruby (false) {
+      ruby || @ruby_ident if_do: {
+        @string to_sym()
+      } else: {
+        @string =~ /:$/ . if_do: {
+          @string to_sym()
+        } else: {
+          ":" + @string . to_sym()
+        }
+      }
+    }
+
+    def self from: string line: line filename: filename (nil) {
+      type = match string -> {
+        case "__FILE__" -> return CurrentFile new: line filename: filename
+        case "__LINE__" -> return CurrentLine new: line
+        case "self" -> return Self new: line
+        case /^[A-Z].*::/ -> NestedConstant
+        case /^[A-Z]/ -> Constant
+        case /^@@/ -> ClassVariable
+        case /^@/ -> InstanceVariable
+        case _ -> Identifier
+      }
+      type new: line string: string
+    }
+
+    def bytecode: g {
+      pos(g)
+      match @string -> {
+        case "true" -> g push_true()
+        case "false" -> g push_false()
+        case "nil" -> g push_nil()
+        case _ -> Rubinius AST LocalVariableAccess new(@line, self name) bytecode(g)
+      }
+    }
+  }
+
+  class InstanceVariable : Identifier {
+    def initialize: @line string: @string {}
+    def bytecode: g {
+      pos(g)
+      Rubinius AST InstanceVariableAccess new(@line, self name) bytecode(g)
+    }
+  }
+
+  class ClassVariable : Identifier {
+    def initialize: @line string: @string {}
+    def bytecode: g {
+      pos(g)
+      Rubinius AST ClassVariableAccess new(@line, self name) bytecode(g)
+    }
+  }
+
+  class Constant : Identifier {
+    def initialize: @line string: @string {}
+    def bytecode: g {
+      pos(g)
+      Rubinius AST ConstantAccess new(@line, self name) bytecode(g)
+    }
+  }
+
+  class NestedConstant : Identifier {
+    def initialize: @line string: @string {
+    }
+
+    def initialize: @line const: const parent: parent {
+      @string = (parent string) ++ "::" ++ (const string)
+    }
+
+    def scoped {
+      names = @string split("::")
+      parent = Constant new: @line string: (names shift())
+      scoped = nil
+      names each() |name| {
+        scoped = Rubinius AST ScopedConstant new(@line, parent, name to_sym())
+        parent = scoped
+      }
+      scoped
+    }
+
+    def bytecode: g {
+      pos(g)
+      self scoped bytecode(g)
+    }
+  }
+
+}

data/lib/compiler/ast/literals.fy

@@ -0,0 +1,122 @@
+class Fancy AST {
+  class NilLiteral : Rubinius AST NilLiteral {
+    def initialize: line { initialize(line) }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class FixnumLiteral : Rubinius AST FixnumLiteral {
+    def initialize: line value: value { initialize(line, value) }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class NumberLiteral : Rubinius AST NumberLiteral {
+    def initialize: line value: value { initialize(line, value) }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class StringLiteral : Rubinius AST StringLiteral {
+    def initialize: line value: value { initialize(line, StringHelper unescape_string(value)) }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class CurrentFile : Node {
+    def initialize: @line filename: @filename { }
+    def bytecode: g {
+      pos(g)
+      args = MessageArgs new: @line args: [StringLiteral new: @line value: @filename]
+      MessageSend new: @line message: (Identifier from: "current_file:" line: @line) \
+                  to: (Identifier from: "Fancy::CodeLoader" line: @line) \
+                  args: args .
+        bytecode: g
+    }
+  }
+
+  class CurrentLine : Node {
+    def initialize: @line {}
+    def bytecode: g {
+      pos(g)
+      FixnumLiteral new: @line value: @line . bytecode: g
+    }
+  }
+
+  class Nothing : Node {
+    def initialize: @line { }
+    def bytecode: g { pos(g) }
+  }
+
+  class StackTop : Node {
+    def initialize: @line { }
+    def bytecode: g {
+      pos(g)
+      g dup()
+    }
+  }
+
+  class StackLocal : Node {
+    def initialize: @line { }
+    def set: g { @local = g new_stack_local(); g set_stack_local(@local) }
+    def bytecode: g {
+      pos(g)
+      g push_stack_local(@local)
+    }
+  }
+
+  class Self : Rubinius AST Self {
+    def initialize: line { initialize(line) }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class SymbolLiteral : Rubinius AST SymbolLiteral {
+    def initialize: line value: value { initialize(line, value) }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class RegexpLiteral : Rubinius AST RegexLiteral  {
+    def initialize: line value: value { initialize(line, value, 0) }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class ArrayLiteral : Rubinius AST ArrayLiteral {
+    read_slots: ['array]
+    def initialize: line array: @array {
+      @array if_nil: { @array = [] }
+      initialize(line, @array)
+    }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+
+  class HashLiteral : Rubinius AST HashLiteral {
+    def initialize: line entries: @key_values {
+      @key_values if_nil: { @key_values = [] }
+      initialize(line, @key_values)
+    }
+    def bytecode: g {
+      pos(g)
+      bytecode(g)
+    }
+  }
+}

data/lib/compiler/ast/match.fy

@@ -0,0 +1,88 @@
+class Fancy AST {
+
+  class Match : Node {
+    def initialize: @line expr: @expr body: @clauses {
+    }
+
+
+    def bytecode: g {
+      pos(g)
+
+      # create labels for each clause body.
+      clause_labels = []
+      @clauses size times: {
+        clause_labels << (g new_label())
+      }
+      end_label = g new_label()
+
+      # ok, let's emit the bytecode
+      @expr bytecode: g
+
+      @match_arg_vars = []
+
+      @clauses each_with_index: |c i| {
+        g dup() # save the @expr since we need to reuse it
+        c expr bytecode: g
+        g swap()
+        g send(':===, 1)
+
+        # if match_arg is given, get a localvar slot and set the
+        # result of the === call to it
+        if: (c match_args first) then: |marg| {
+          match_arg_var = g state() scope() new_local(marg)
+          @match_arg_vars << match_arg_var
+          g set_local(match_arg_var slot())
+        }
+
+        # for any remaining match arguments, set their values to
+        # whatever matcher[idx] returns (should be the matched data)
+        c match_args rest each_with_index: |match_arg idx| {
+          idx = idx + 1 # we only want from index 1 onwards
+          g dup() # dup the matcher object
+          match_arg_var = g state() scope() new_local(match_arg)
+          @match_arg_vars << match_arg_var
+          FixnumLiteral new: @line value: idx . bytecode: g
+          g send('at:, 1)
+          g set_local(match_arg_var slot())
+          g pop()
+        }
+
+        g git(clause_labels[i])
+      }
+      g pop()
+      g push_nil()
+      g goto(end_label)
+
+      clause_labels each_with_index: |label i| {
+        label set!()
+        g pop()
+        @clauses[i] body bytecode: g
+
+        # set match_arg locals slot to nil, so they're only visible
+        # within the case body
+        @match_arg_vars each: |marg_var| {
+          g push_nil()
+          g set_local(marg_var slot())
+          g pop()
+        }
+
+        g goto(end_label)
+      }
+
+      end_label set!()
+    }
+  }
+
+  class MatchClause : Node {
+    read_slots: ['expr, 'body, 'match_args]
+    def initialize: @line expr: @expr body: @body args: @match_args {
+      if: (@expr kind_of?: Identifier) then: {
+        if: (@expr string == "_") then: {
+          @expr = Identifier from: "Object" line: @line
+        }
+      }
+      @match_args = @match_args map: 'name
+    }
+  }
+
+}

data/lib/compiler/ast/message_send.fy

@@ -0,0 +1,110 @@
+class Fancy AST {
+
+  class MessageSend : Node {
+    read_write_slots: ['name, 'receiver, 'args]
+    def initialize: @line message: @name to: @receiver args: @args { }
+
+    def bytecode: g {
+      pos(g)
+      if: (@receiver is_a?: Super) then: {
+        SuperSend new: @line message: @name args: @args . bytecode: g
+      } else: {
+        @receiver bytecode: g
+        @args bytecode: g
+        pos(g)
+        { g allow_private() } if: (@receiver is_a?: Self)
+        sym = @name method_name: @receiver ruby_send: (self ruby_send?)
+        if: (self has_splat?) then: {
+          { g push_nil() } unless: $ self ruby_block?
+          g send_with_splat(sym, @args size, false)
+          return nil
+        }
+        if: (self ruby_block?) then: {
+          g send_with_block(sym, @args size, false)
+        } else: {
+          g send(sym, @args size, false)
+        }
+      }
+    }
+
+    def ruby_block? {
+      @args has_block?
+    }
+
+    def ruby_send? {
+      @args ruby_args?
+    }
+
+    def has_splat? {
+      @args has_splat?
+    }
+  }
+
+  class MessageArgs : Node {
+    read_slots: ['args]
+    def initialize: @line args: @args { }
+
+    def bytecode: g {
+      pos(g)
+      @args each: |a| {
+        a bytecode: g
+      }
+    }
+
+    def size {
+      @args size
+    }
+
+    def ruby_args? {
+      is_a?: RubyArgs
+    }
+
+    def has_block? {
+      false
+    }
+
+    def has_splat? {
+      false
+    }
+  }
+
+
+  class RubyArgs : MessageArgs {
+    def initialize: @line args: @args block: @block (nil) {
+      { @args = @args array } unless: (@args is_a?: Array)
+      @block if_nil: {
+        if: (@args last kind_of?: Identifier) then: {
+          if: (@args last string =~ /^&\w/) then: {
+            @block = @args pop()
+            @block = Identifier new: (@block line) string: (@block string from: 1 to: -1)
+          }
+        }
+      }
+
+      if: (@args last kind_of?: Identifier) then: {
+        if: (@args last string =~ /^\*\w/) then: {
+          @splat = @args pop()
+          @splat = Identifier new: (@splat line) string: (@splat string from: 1 to: -1)
+        }
+      }
+    }
+
+    def bytecode: g {
+      pos(g)
+      @args each: |a| {
+        a bytecode: g
+      }
+      { @splat bytecode: g; g cast_array() } if: @splat
+      { @block bytecode: g } if: @block
+    }
+
+    def has_block? {
+      @block nil? not
+    }
+
+    def has_splat? {
+      @splat nil? not
+    }
+  }
+
+}