fancy 0.3.0

data/boot/rbx-compiler/compiler/ast/identifier.rb

@@ -0,0 +1,120 @@
+class Fancy
+  class AST
+
+    class Identifier < Node
+      attr_reader :identifier
+
+      def initialize(line, identifier)
+        super(line)
+        @identifier = identifier
+      end
+
+      def constant?
+        @identifier =~ /^[A-Z]/
+      end
+
+      def instance_variable?
+        @identifier =~ /^@/ && !class_variable?
+      end
+
+      def class_variable?
+        @identifier =~ /^@@/
+      end
+
+      def local_variable?
+        !(constant? || instance_variable? || class_variable?)
+      end
+
+      def nested_classname?
+        constant? && @identifier.include?("::")
+      end
+
+      def true?
+        @identifier == "true"
+      end
+
+      def false?
+        @identifier == "false"
+      end
+
+      def nil?
+        @identifier == "nil"
+      end
+
+      def operator?
+        @identifier !~ /^\w/
+      end
+
+      def name
+        if constant?
+          @identifier.to_sym
+        elsif class_variable?
+          @identifier.to_sym
+        elsif instance_variable?
+          @identifier.to_sym
+        else
+          @identifier.to_sym
+        end
+      end
+
+      def method_name(receiver = nil, with_ruby_args = false)
+        if with_ruby_args
+          rubyfied.to_sym
+        elsif @identifier !~ /:$/
+          # methods not ending with ':' have ':' prepended instead.
+          # so we dont create colissions with existing ruby methods.
+          # if we dont do this, whenever a ruby library tries to
+          # invoke (say, the print method) it will find the
+          # fancy version (not expecting arguments) and will fail.
+          ":#{@identifier}".to_sym
+        else
+          @identifier.to_sym
+        end
+      end
+
+      def rubyfied
+        if @identifier.split(":").size > 1
+          @identifier
+        else
+          if @identifier =~ /:$/
+            @identifier[0..-2]
+          else
+            @identifier[0..-1]
+          end
+        end
+      end
+
+      def bytecode(g)
+        if "__FILE__" == @identifier
+          Rubinius::AST::StringLiteral.new(line, Fancy::AST::Script.current.filename).
+            bytecode(g)
+        elsif "__LINE__" == @identifier
+          Rubinius::AST::FixnumLiteral.new(line, line).bytecode(g)
+        elsif nested_classname?
+          classnames = @identifier.split("::")
+          parent = Identifier.new(@line, classnames.shift)
+          classnames.each do |cn|
+            Rubinius::AST::ScopedConstant.new(@line, parent, cn.to_sym).bytecode(g)
+            child = Identifier.new(@line, cn)
+            parent = child
+          end
+        elsif constant?
+          Rubinius::AST::ConstantAccess.new(line, name).bytecode(g)
+        elsif class_variable?
+          Rubinius::AST::ClassVariableAccess.new(line, name).bytecode(g)
+        elsif instance_variable?
+          Rubinius::AST::InstanceVariableAccess.new(line, name).bytecode(g)
+        elsif true?
+          g.push_true
+        elsif false?
+          g.push_false
+        elsif nil?
+          g.push_nil
+        else
+          Rubinius::AST::LocalVariableAccess.new(line, name).bytecode(g)
+        end
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/match.rb

@@ -0,0 +1,81 @@
+class Fancy
+  class AST
+
+    class Match < Node
+      def initialize(line, expr, clauses)
+        super(line)
+        @expr = expr
+        @clauses = clauses
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        # create labels for each clause body.
+        clause_labels = []
+        @clauses.size.times do
+          clause_labels << g.new_label
+        end
+        end_label = g.new_label
+
+        # ok, let's emit the bytecode
+        @expr.bytecode(g)
+
+        @clauses.each_with_index do |c, i|
+          g.dup # save the @expr since we need to reuse it
+          c.match_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_arg
+            @match_arg_var = g.state.scope.new_local c.match_arg
+            g.set_local @match_arg_var.slot
+          end
+
+          g.git clause_labels[i]
+        end
+        g.pop
+        g.push_nil
+        g.goto end_label
+
+        clause_labels.each_with_index do |label, i|
+          label.set!
+          g.pop
+          @clauses[i].val_expr.bytecode(g)
+
+          # set match_arg local slot to nil, so it's only visible
+          # within the case body
+          if @match_arg_var
+            g.push_nil
+            g.set_local @match_arg_var.slot
+            g.pop
+          end
+
+          g.goto end_label
+        end
+
+        end_label.set!
+      end
+    end
+
+    class MatchClause < Node
+      attr_reader :match_expr, :val_expr, :match_arg
+      def initialize(line, match_expr, val_expr, match_arg)
+        super(line)
+        if match_expr.kind_of?(Fancy::AST::Identifier) && match_expr.identifier == "_"
+          match_expr = Fancy::AST::Identifier.new(match_expr.line, "Object")
+        end
+        @match_expr = match_expr
+        @val_expr = val_expr
+
+        if match_arg
+          # use name so we get the identifier as a symbol
+          @match_arg = match_arg.name
+        end
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/message_send.rb

@@ -0,0 +1,71 @@
+class Fancy
+  class AST
+
+    class MessageSend < Node
+      def initialize(line, receiver, message_name, message_args)
+        super(line)
+        @receiver = receiver
+        @message_name = message_name
+        @message_args = message_args
+      end
+
+      def bytecode(g)
+        if @receiver.is_a? Super
+          SuperSend.new(@line, @message_name, @message_args).bytecode(g)
+        else
+          @receiver.bytecode(g)
+          @message_args.bytecode(g)
+          pos(g)
+          g.allow_private if @receiver.is_a?(Rubinius::AST::Self)
+
+          name = @message_name.method_name(@receiver, ruby_send?)
+          if ruby_send_block?
+            g.send_with_block name, @message_args.size, false
+          else
+            g.send name, @message_args.size, false
+          end
+        end
+      end
+
+      def ruby_send_block?
+        @message_args.ruby_block?
+      end
+
+      def ruby_send?
+        @message_args.ruby_args?
+      end
+    end
+
+    class MessageArgs < Node
+      attr_reader :args
+
+      def initialize(line, *args)
+        super(line)
+        @args = args
+      end
+
+      def bytecode(g)
+        @args.each do |a|
+          a.bytecode(g)
+        end
+      end
+
+      def size
+        if ruby_args?
+          return @args.first.size
+        else
+          @args.size
+        end
+      end
+
+      def ruby_args?
+        @args.first.is_a? RubyArgs
+      end
+
+      def ruby_block?
+        ruby_args? && @args.first.has_block?
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/method_def.rb

@@ -0,0 +1,116 @@
+class Fancy
+  class AST
+
+    class MethodDef < Rubinius::AST::Define
+      def initialize(line, method_ident, args, body, access = :public)
+        @line = line
+        @name = method_ident.method_name
+        @arguments = args
+        @body = body
+        @access = access
+        generate_ivar_assignment
+
+        if body.empty?
+          body.unshift_expression Rubinius::AST::NilLiteral.new(line)
+        end
+      end
+
+      def generate_ivar_assignment
+        @arguments.required.reverse.each do |name|
+          if name.to_s =~ /^@/
+            ident = Fancy::AST::Identifier.new(line, name.to_s)
+            value = Rubinius::AST::LocalVariableAccess.new(line, name)
+            asign = Fancy::AST::Assignment.new(line, ident, value)
+            body.unshift_expression(asign)
+          end
+        end
+      end
+
+      def bytecode(g)
+        g.push_self
+        g.send @access, 0
+        g.pop
+
+        if @name.to_s =~ /^initialize:(\S)+/
+          define_constructor_class_method g
+        end
+        if @name.to_s =~ /^unknown_message:with_params:$/
+          define_method_missing(g)
+        end
+
+        docstring = @body.shift_docstring
+        super(g)
+        MethodDef.set_docstring(g, docstring, @line, @arguments.names)
+      end
+
+
+      # Sets fancy documentation for the object currently
+      # on top of the stack
+      def self.set_docstring(g, docstring, line, argnames = [])
+        # prevent invoking documentation: when doesnt makes sense.
+        return unless docstring
+        local = StackLocal.new
+        local.set!(g)
+        ms = MessageSend.new(line,
+                            Identifier.new(line, "Fancy::Documentation"),
+                            Identifier.new(line, "for:is:"),
+                            MessageArgs.new(line, local, docstring))
+        ms.bytecode(g)
+        meta = HashLiteral.new(line,
+          SymbolLiteral.new(line, :argnames),
+          ArrayLiteral.new(line, *argnames.map{|arg|StringLiteral.new(line, arg.to_s)})
+        )
+        ms = MessageSend.new(line,
+                             Nothing.new,
+                             Identifier.new(line, "meta:"),
+                             MessageArgs.new(line, meta))
+        ms.bytecode(g)
+        g.pop
+      end
+
+      # 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 = Rubinius::AST::StringLiteral.new(@line, @name.to_s[11..-1])
+        ms = MessageSend.new(@line,
+                             Rubinius::AST::Self.new(@line),
+                             Identifier.new(@line, "define_constructor_class_method:"),
+                             MessageArgs.new(@line, method_ident))
+        ms.bytecode(g)
+      end
+
+      def define_method_missing(g)
+        MessageSend.new(@line,
+                        Rubinius::AST::Self.new(@line),
+                        Identifier.new(@line, "define_forward_method_missing"),
+                        MessageArgs.new(@line)).bytecode(g)
+      end
+    end
+
+    SymbolLiteral = Rubinius::AST::SymbolLiteral
+
+    class Nothing
+      def bytecode(g)
+      end
+    end
+
+    class StackLocal
+      def set!(g)
+        # expects value to be on top of stack
+        @local = g.new_stack_local
+        g.set_stack_local @local
+      end
+
+      def bytecode(g)
+        g.push_stack_local @local
+      end
+    end
+
+    class MethodArgs < Rubinius::AST::FormalArguments
+      def initialize(line, *args)
+        super(line, args.map(&:to_sym), nil, nil)
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/node.rb

@@ -0,0 +1,6 @@
+class Fancy
+  class AST
+    [ :Node, :Self, :FixnumLiteral, :NumberLiteral, :RegexLiteral, :ScopedConstant ].
+      each { |n| const_set(n, Rubinius::AST.const_get(n)) }
+  end
+end

data/boot/rbx-compiler/compiler/ast/range_literal.rb

@@ -0,0 +1,22 @@
+class Fancy
+  class AST
+
+    class RangeLiteral < Node
+      attr_accessor :from, :to
+      def initialize(line, from, to)
+        super(line)
+        @from = from
+        @to = to
+      end
+
+      def bytecode(g)
+        ms = MessageSend.new(@line,
+                             Identifier.new(@line, "Range"),
+                             Identifier.new(@line, "new:to:"),
+                             MessageArgs.new(@line, @from, @to))
+        ms.bytecode(g)
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/require.rb

@@ -0,0 +1,20 @@
+class Fancy
+  class AST
+
+    class Require < Node
+      def initialize(line, string)
+        super(line)
+        @string = string
+      end
+
+      def bytecode(g)
+        Rubinius::AST::Self.new(1).bytecode(g)
+        @string.bytecode(g)
+        pos(g)
+        g.allow_private
+        g.send :fancy_require, 1, false
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/compiler/ast/return.rb

@@ -0,0 +1,29 @@
+class Fancy
+  class AST
+
+    class Return < Node
+      def initialize(line, expr)
+        super(line)
+        @expr = expr
+      end
+
+      def bytecode(g)
+        @expr.bytecode(g)
+        g.raise_return
+      end
+    end
+
+    class ReturnLocal < Node
+      def initialize(line, expr)
+        super(line)
+        @expr = expr
+      end
+
+      def bytecode(g)
+        @expr.bytecode(g)
+        g.ret
+      end
+    end
+
+  end
+end