fancy 0.3.0

data/boot/rbx-compiler/parser/parser.rb

@@ -0,0 +1,356 @@
+
+class Fancy
+
+  # This module has methods that can be used as callbacks from
+  # the parser, so that we can have a relatively simple fancy.y
+  # For example, when the parser sees a literal (or any other node)
+  # it just calls methods defined here. that create actual
+  # AST nodes, returning them to the parser to be stored on
+  # $$
+  class Parser
+
+    class ParseError < StandardError; end
+
+    def self.parse_file(filename, lineno = 1)
+      new(filename, lineno).parse_file.script
+    end
+
+    def self.parse_string(code, lineno = 1, filename = "(eval)")
+      new(filename, lineno).parse_string(code).script
+    end
+
+    attr_reader :filename, :lineno, :script
+
+    def initialize(filename, lineno)
+      @filename, @lineno = filename, lineno
+    end
+
+    def body=(expression_list)
+      @script = AST::Script.new(lineno, filename, expression_list)
+    end
+
+    def string_literal(line, yytext)
+      str = yytext[1..-2] # omit the starting and ending quotes
+      AST::StringLiteral.new(line, str)
+    end
+
+    def multiline_string_literal(line, yytext)
+      str = yytext[3..-4] # omit the starting and ending triple-quotes
+      AST::StringLiteral.new(line, str)
+    end
+
+    def integer_literal(line, yytext, base = 10)
+      AST::FixnumLiteral.new(line, yytext.to_i(base))
+    end
+
+    def double_literal(line, yytext)
+      AST::NumberLiteral.new(line, yytext.to_f)
+    end
+
+    def symbol_literal(line, yytext)
+      str = yytext[1..-1] # omit the quote
+      AST::SymbolLiteral.new(line, str.to_sym)
+    end
+
+    def parse_error(line, yytext)
+      raise ParseError.new "Parse error at line #{line}, unexpected token: #{yytext.inspect}"
+    end
+
+    def file_error(*error)
+      raise ParseError.new error.join(" ")
+    end
+
+    def const_identifier(line, identifier, parent = nil)
+      if parent
+        AST::ScopedConstant.new(line, parent, identifier.name)
+      else
+        identifier
+      end
+    end
+
+    def ruby_send_open(line, yytext)
+      # A ruby send is identified by the parser by seeing an
+      # identifier immediatly followed by a left-paren.
+      # NO SPACE IS ALLOWED BETWEEN THEM.
+      # So the parser gives yytext as the identifier with its
+      # left-paren as last character.
+      # Remove the paren and simply create an identifier.
+      identifier(line, yytext[0..-2])
+    end
+
+    def identifier(line, yytext)
+      if yytext == "self"
+        AST::Self.new(line)
+      else
+        AST::Identifier.new(line, yytext)
+      end
+    end
+
+    def msg_send_basic(line, receiver, identifier)
+      args = AST::MessageArgs.new(line)
+      AST::MessageSend.new(line, receiver, identifier, args)
+    end
+
+    def oper_send_basic(line, receiver, operator, argument)
+      args = AST::MessageArgs.new(line, argument)
+      AST::MessageSend.new(line, receiver, operator, args)
+    end
+
+    def assignment(line, identifier, value)
+      AST::Assignment.new(line, identifier, value)
+    end
+
+    def multiple_assignment(line, identifiers, values)
+      AST::MultipleAssignment.new(line, identifiers, values)
+    end
+
+    def identifier_list(line, identifier_list, identifier)
+      if identifier_list.kind_of?(Array)
+        identifier_list.push(identifier)
+      else
+        [identifier_list, identifier]
+      end
+    end
+
+    def send_args(line, selector, value, ary = [])
+      selector = AST::Identifier.new(selector.line, selector.identifier+":")
+      ary.push Struct.new(:selector, :value).new(selector, value)
+    end
+
+    def operator_def(line, operator, parameter, method_body, access = :public)
+      args = AST::MethodArgs.new(line, parameter.identifier)
+      AST::MethodDef.new(line, operator, args, method_body, access)
+    end
+
+    def sin_operator_def(line, identifier, operator, parameter, method_body, access = :public)
+      args = AST::MethodArgs.new(line, parameter.identifier)
+      AST::SingletonMethodDef.new(line, identifier, operator, args, method_body, access)
+    end
+
+    def method_def_no_args(line, method_ident, method_body, access = :public)
+      args = AST::MethodArgs.new(line)
+      AST::MethodDef.new(line, method_ident, args, method_body, access)
+    end
+
+    def method_arg(line, selector, variable, default = nil)
+      selector = AST::Identifier.new(selector.line, selector.identifier+":")
+      Struct.new(:selector, :variable, :default).new(selector, variable, default)
+    end
+
+    def helper_method_name(method_args)
+      method_args.map { |a| a.selector.identifier }.join("")
+    end
+
+    # Creates a single MethodDef node.
+    def method_def(line, method_args, method_body, access)
+      name = helper_method_name(method_args)
+      method_ident = AST::Identifier.new(line, name)
+      args = method_args.map { |a| a.variable.identifier }
+      args = AST::MethodArgs.new(line, *args)
+      AST::MethodDef.new(line, method_ident, args, method_body, access)
+    end
+
+    def method_delegators(method_args)
+      # find the first default argument
+      idx = method_args.index { |a| a.default }
+      return unless idx
+
+      line = method_args.first.selector.line
+      target = helper_method_name(method_args)
+
+      (method_args.size - idx).times do |pos|
+
+        required = method_args[0...idx+pos]
+        default = method_args[idx+pos..-1]
+
+        params = required.map(&:variable) + default.map(&:default)
+
+        forward = AST::MessageSend.new(line,
+                                              AST::Self.new(line),
+                                              AST::Identifier.new(line, target),
+                                              AST::MessageArgs.new(line, *params))
+        doc = AST::StringLiteral.new(line, "Forward to message #{target}")
+        body = AST::ExpressionList.new(line, doc, forward)
+
+        yield required, body
+      end
+    end
+
+
+    # Generate an expression list of method_defs
+    def method_def_expand(line, method_args, method_body, access = :public)
+      defs = []
+      method_delegators(method_args) do |sel, fwd|
+        defs << method_def(line, sel, fwd, access)
+      end
+      defs << method_def(line, method_args, method_body, access)
+      AST::ExpressionList.new(line, *defs)
+    end
+
+    def sin_method_def_expand(line, identifier, method_args, method_body, access = :public)
+      defs = []
+      method_delegators(method_args) do |sel, fwd|
+        defs << sin_method_def(line, identifier, sel, fwd, access)
+      end
+      defs << sin_method_def(line, identifier, method_args, method_body, access)
+      AST::ExpressionList.new(line, *defs)
+    end
+
+    def sin_method_def(line, identifier, method_args, method_body, access = :public)
+      name = method_args.map { |a| a.selector.identifier }.join("")
+      method_name = AST::Identifier.new(line, name)
+      args = method_args.map { |a| a.variable.identifier }
+      args = AST::MethodArgs.new(line, *args)
+      AST::SingletonMethodDef.new(line, identifier, method_name, args, method_body, access)
+    end
+
+    def sin_method_def_no_args(line, identifier, method_name, method_body, access = :public)
+      args = AST::MethodArgs.new(line)
+      AST::SingletonMethodDef.new(line, identifier, method_name, args, method_body, access)
+    end
+
+    def msg_send_args(line, receiver, method_args)
+      receiver ||= AST::Self.new(line)
+      name = method_args.map { |a| a.selector.identifier }.join("")
+      name = AST::Identifier.new(line, name)
+      args = AST::MessageArgs.new line, *method_args.map { |a| a.value }
+      AST::MessageSend.new(line, receiver, name, args)
+    end
+
+    def msg_send_ruby(line, receiver, identifier, args = nil)
+      receiver ||= AST::Self.new(line)
+      args ||= ruby_args(line)
+      arguments = AST::MessageArgs.new line, args
+      AST::MessageSend.new(line, receiver, identifier, arguments)
+    end
+
+    def nil_literal(line)
+      Rubinius::AST::NilLiteral.new(line)
+    end
+
+    def block_literal(line, block_args, block_body)
+      block_args ||= Array.new
+      args = AST::BlockArgs.new line, *block_args
+      AST::BlockLiteral.new(line, args, block_body)
+    end
+
+    def tuple_literal(line, expr_ary = [])
+      # when we have a tuple with 1 element, it's not actually a tuple
+      # but a grouped expression, e.g. (obj foo: bar)
+      # 1-tuples don't make much sense anyway, so we won't support
+      # them via tuple literal syntax.
+      if expr_ary.size == 1
+        expr_ary.first
+      else
+        AST::TupleLiteral.new(line, *expr_ary)
+      end
+    end
+
+    def range_literal(line, from, to)
+      AST::RangeLiteral.new(line, from, to)
+    end
+
+    def block_args(line, identifier, ary = [])
+      ary.push identifier
+    end
+
+    def expr_list(line, expr = nil, expr_list = nil)
+      expr_list = AST::ExpressionList.new(line) unless expr_list
+      expr_list.add_expression(expr) if expr
+      expr_list
+    end
+
+    def class_def(line, name, parent, body)
+      AST::ClassDef.new(line, name, parent, body)
+    end
+
+    def expr_ary(line, exp, ary = [])
+      if exp.is_a? Array
+        ary += exp
+      else
+        ary.push exp
+      end
+    end
+
+    def array_literal(line, expr_ary = [])
+      AST::ArrayLiteral.new(line, *expr_ary)
+    end
+
+    def ruby_args(line, array_literal = nil, block = nil)
+      if array_literal.kind_of?(Array)
+         array_literal = AST::ArrayLiteral.new(line, *array_literal)
+      end
+      if array_literal.nil?
+         array_literal = AST::ArrayLiteral.new(line)
+      end
+      AST::RubyArgs.new(line, array_literal, block)
+    end
+
+    def super_exp(line)
+      AST::Super.new(line)
+    end
+
+    def retry_exp(line)
+      AST::Retry.new(line)
+    end
+
+    def catch_handlers(line, handler = nil, handlers = nil)
+      handlers ||= AST::Handlers.new(line)
+      handlers.add_handler handler if handler
+      handlers
+    end
+
+    def catch_handler(line, body = nil, condition = nil, var = nil)
+      condition ||= AST::Identifier.new(line, "Object")
+      AST::ExceptHandler.new(line, condition, var, body)
+    end
+
+    def try_catch_finally(line, body, handlers, finally = nil)
+      handlers ||= AST::Handlers.new(line)
+      AST::TryCatchBlock.new(line, body, handlers, finally)
+    end
+
+    def key_value_list(line, key, value, ary = [])
+      ary.push key
+      ary.push value
+      ary
+    end
+
+    def hash_literal(line, key_values = [])
+      AST::HashLiteral.new(line, *key_values)
+    end
+
+    def regex_literal(line, regexp_str)
+      regexp_str = regexp_str[1..-2]
+      AST::RegexLiteral.new(line, regexp_str, 0)
+    end
+
+    def require_stmt(line, identifier)
+      AST::Require.new(line, identifier)
+    end
+
+    def return_stmt(line, expr = nil)
+      expr ||= nil_literal(expr)
+      AST::Return.new(line, expr)
+    end
+
+    def return_local(line, expr = nil)
+      expr ||= nil_literal(expr)
+      AST::Return.new(line, expr)
+    end
+
+    def match_expr(line, expr, clauses = nil)
+      clauses ||= []
+      AST::Match.new(line, expr, clauses)
+    end
+
+    def match_body(line, match_clause, match_clauses = [])
+      match_clauses.push(match_clause)
+    end
+
+    def match_clause(line, match_expr, val_expr, match_arg=nil)
+      AST::MatchClause.new(line, match_expr, val_expr, match_arg)
+    end
+  end
+
+end

data/boot/rbx-compiler/parser/parser.y

@@ -0,0 +1,711 @@
+%{
+#include "ruby.h"
+
+int yyerror(VALUE, char *s);
+int yylex(VALUE);
+
+VALUE fy_terminal_node(VALUE, char *);
+VALUE fy_terminal_node_from(VALUE, char *, char*);
+
+extern int yylineno;
+extern char *yytext;
+
+%}
+
+%lex-param   { VALUE self }
+%parse-param { VALUE self }
+
+%union{
+  VALUE object;
+  ID    symbol;
+}
+
+%start	programm
+
+%token                  LPAREN
+%token                  RPAREN
+%token                  LCURLY
+%token                  RCURLY
+%token                  LBRACKET
+%token                  RBRACKET
+%token                  LHASH
+%token                  RHASH
+%token                  STAB
+%token                  ARROW
+%token                  THIN_ARROW
+%token                  COMMA
+%token                  SEMI
+%token                  NL
+%token                  COLON
+%token                  RETURN_LOCAL
+%token                  RETURN
+%token                  REQUIRE
+%token                  TRY
+%token                  CATCH
+%token                  FINALLY
+%token                  RETRY
+%token                  SUPER
+%token                  PRIVATE
+%token                  PROTECTED
+%token                  CLASS
+%token                  DEF
+%token                  DOT
+%token                  DOLLAR
+%token                  EQUALS
+%token                  MATCH
+%token                  CASE
+%token                  IDENTIFIER
+%token                  RUBY_SEND_OPEN
+%token                  RUBY_OPER_OPEN
+%token                  CONSTANT
+
+%token                  INTEGER_LITERAL
+%token                  HEX_LITERAL
+%token                  OCT_LITERAL
+%token                  BIN_LITERAL
+%token                  DOUBLE_LITERAL
+%token                  STRING_LITERAL
+%token                  MULTI_STRING_LITERAL
+%token                  SYMBOL_LITERAL
+%token                  REGEX_LITERAL
+%token                  OPERATOR
+
+%left                   DOT
+%right                  DOLLAR
+
+%type <object>          integer_literal
+%type <object>          hex_literal
+%type <object>          oct_literal
+%type <object>          bin_literal
+%type <object>          double_literal
+%type <object>          string_literal
+%type <object>          symbol_literal
+%type <object>          regex_literal
+%type <object>          operator
+
+
+%type  <object>         identifier
+%type  <object>         any_identifier
+%type  <object>         constant
+%type  <object>         literal_value
+%type  <object>         block_literal
+%type  <object>         block_args
+%type  <object>         block_args_without_comma
+%type  <object>         block_args_with_comma
+%type  <object>         hash_literal
+%type  <object>         array_literal
+%type  <object>         empty_array
+%type  <object>         tuple_literal
+%type  <object>         range_literal
+
+%type  <object>         key_value_list
+%type  <object>         exp_comma_list
+
+%type  <object>         code
+%type  <object>         expression_list
+%type  <object>         expression_block
+%type  <object>         exp
+%type  <object>         assignment
+%type  <object>         multiple_assignment
+%type  <object>         identifier_list
+%type  <object>         return_local_statement
+%type  <object>         return_statement
+%type  <object>         require_statement
+
+%type  <object>         def
+
+%type  <object>         const_identifier
+%type  <object>         class_def
+%type  <object>         class_no_super
+%type  <object>         class_super
+%type  <object>         class_method_w_args
+%type  <object>         class_method_no_args
+
+%type  <object>         method_def
+%type  <object>         method_args
+%type  <object>         method_arg
+%type  <object>         method_args_default
+%type  <object>         method_arg_default
+%type  <object>         method_w_args
+%type  <object>         method_no_args
+%type  <object>         operator_def
+%type  <object>         class_operator_def
+
+%type  <object>         message_send
+%type  <object>         ruby_send_open
+%type  <object>         ruby_oper_open
+%type  <object>         ruby_send
+%type  <object>         ruby_oper_send
+%type  <object>         ruby_args
+%type  <object>         operator_send
+%type  <object>         send_args
+%type  <object>         arg_exp
+
+%type  <object>         try_catch_block
+%type  <object>         catch_blocks
+%type  <object>         finally_block
+%type  <object>         catch_block
+%type  <object>         required_catch_blocks
+
+%type  <object>         match_expr
+%type  <object>         match_body
+%type  <object>         match_clause
+
+%%
+
+programm:       /*empty*/
+                | expression_list {
+                  rb_funcall(self, rb_intern("body="), 1, $1);
+                }
+                ;
+
+delim:          nls
+                | SEMI
+                | delim delim
+                ;
+
+nls:            NL
+                | nls NL
+                ;
+
+space:          /* */
+                | nls
+                ;
+
+code:           statement
+                | exp
+                ;
+
+expression_list: code {
+                   $$ = rb_funcall(self, rb_intern("expr_list"), 2, INT2NUM(yylineno), $1);
+                }
+                | expression_list code {
+                   $$ = rb_funcall(self, rb_intern("expr_list"), 3, INT2NUM(yylineno), $2, $1);
+                }
+                | delim expression_list {
+                   $$ = $2;
+                }
+                | expression_list delim {
+                   $$ = $1;
+                }
+                ;
+
+expression_block: LCURLY space expression_list space RCURLY {
+                   $$ = $3;
+                }
+                | LCURLY space RCURLY {
+                   $$ = rb_funcall(self, rb_intern("expr_list"), 1, INT2NUM(yylineno));
+                }
+                ;
+
+statement:      assignment
+                | return_local_statement
+                | return_statement
+                | require_statement
+                ;
+
+exp:            method_def
+                | class_def
+                | try_catch_block
+                | match_expr
+                | message_send
+                | operator_send
+                | ruby_send
+                | ruby_oper_send
+                | literal_value
+                | any_identifier
+                | SUPER { $$ = rb_funcall(self, rb_intern("super_exp"), 1, INT2NUM(yylineno)); }
+                | RETRY { $$ = rb_funcall(self, rb_intern("retry_exp"), 1, INT2NUM(yylineno)); }
+                | LPAREN space exp space RPAREN {
+                  $$ = $3;
+                }
+                | exp DOT space {
+                  $$ = $1;
+                }
+                ;
+
+assignment:     any_identifier EQUALS space exp {
+                  $$ = rb_funcall(self, rb_intern("assignment"), 3, INT2NUM(yylineno), $1, $4);
+                }
+                | multiple_assignment
+                ;
+
+multiple_assignment: identifier_list EQUALS exp_comma_list {
+                  $$ = rb_funcall(self, rb_intern("multiple_assignment"), 3, INT2NUM(yylineno), $1, $3);
+                }
+                ;
+
+operator:       OPERATOR {
+                  $$ = fy_terminal_node(self, "identifier");
+                }
+                ;
+
+constant:       CONSTANT {
+                  $$ = fy_terminal_node(self, "identifier");
+                }
+                ;
+
+identifier:     IDENTIFIER {
+                  $$ = fy_terminal_node(self, "identifier");
+                }
+                | MATCH {
+                  $$ = fy_terminal_node_from(self, "identifier", "match");
+                }
+                | CLASS {
+                  $$ = fy_terminal_node_from(self, "identifier", "class");
+                }
+                ;
+
+any_identifier: const_identifier
+                | identifier
+                ;
+
+identifier_list: any_identifier {
+                  $$ = $1;
+                }
+                | identifier_list COMMA any_identifier {
+                  $$ = rb_funcall(self, rb_intern("identifier_list"), 3, INT2NUM(yylineno), $1, $3);
+                }
+                ;
+
+return_local_statement: RETURN_LOCAL exp {
+                  $$ = rb_funcall(self, rb_intern("return_local"), 2, INT2NUM(yylineno), $2);
+                }
+                | RETURN_LOCAL {
+                  $$ = rb_funcall(self, rb_intern("return_local"), 1, INT2NUM(yylineno));
+                }
+                ;
+
+return_statement: RETURN exp {
+                  $$ = rb_funcall(self, rb_intern("return_stmt"), 2, INT2NUM(yylineno), $2);
+                }
+                | RETURN {
+                  $$ = rb_funcall(self, rb_intern("return_stmt"), 1, INT2NUM(yylineno));
+                }
+                ;
+
+require_statement: REQUIRE string_literal {
+                  $$ = rb_funcall(self, rb_intern("require_stmt"), 2, INT2NUM(yylineno), $2);
+                }
+                | REQUIRE any_identifier {
+                  $$ = rb_funcall(self, rb_intern("require_stmt"), 2, INT2NUM(yylineno), $2);
+                }
+                ;
+
+class_def:      class_no_super
+                | class_super
+                ;
+
+const_identifier: constant {
+                  $$ = rb_funcall(self, rb_intern("const_identifier"), 2, INT2NUM(yylineno), $1);
+                }
+                | const_identifier constant {
+                  $$ = rb_funcall(self, rb_intern("const_identifier"), 3, INT2NUM(yylineno), $2, $1);
+                }
+                ;
+
+def:            DEF PRIVATE { $$ = rb_intern("private"); }
+                | DEF PROTECTED { $$ = rb_intern("protected"); }
+                | DEF { $$ = rb_intern("public"); }
+                ;
+
+class_no_super: CLASS const_identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("class_def"), 4, INT2NUM(yylineno), $2, Qnil, $3);
+                }
+                ;
+
+class_super:    CLASS const_identifier COLON const_identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("class_def"), 4, INT2NUM(yylineno), $2, $4, $5);
+                }
+                ;
+
+method_def:     method_w_args
+                | method_no_args
+                | class_method_w_args
+                | class_method_no_args
+                | operator_def
+                | class_operator_def
+                ;
+
+method_arg:     identifier COLON identifier {
+                  $$ = rb_funcall(self, rb_intern("method_arg"), 3, INT2NUM(yylineno), $1, $3);
+                }
+                ;
+
+method_args:    method_arg {
+                  $$ = rb_funcall(self, rb_intern("expr_ary"), 2, INT2NUM(yylineno), $1);
+                }
+                | method_args method_arg {
+                  $$ = rb_funcall(self, rb_intern("expr_ary"), 3, INT2NUM(yylineno), $2, $1);
+                }
+                | method_args method_args_default {
+                  $$ = rb_funcall(self, rb_intern("expr_ary"), 3, INT2NUM(yylineno), $2, $1);
+                }
+                ;
+
+method_arg_default: identifier COLON identifier LPAREN space exp space RPAREN {
+                  $$ = rb_funcall(self, rb_intern("method_arg"), 4, INT2NUM(yylineno), $1, $3, $6);
+                }
+                ;
+
+method_args_default: method_arg_default {
+                  $$ = rb_funcall(self, rb_intern("expr_ary"), 2, INT2NUM(yylineno), $1);
+                }
+                | method_args_default space method_arg_default {
+                  $$ = rb_funcall(self, rb_intern("expr_ary"), 3, INT2NUM(yylineno), $3, $1);
+                }
+                ;
+
+method_w_args:  def method_args expression_block {
+                  $$ = rb_funcall(self, rb_intern("method_def_expand"), 4, INT2NUM(yylineno), $2, $3, $1);
+                }
+                ;
+
+
+method_no_args: def identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("method_def_no_args"), 4, INT2NUM(yylineno), $2, $3, $1);
+                }
+                ;
+
+
+class_method_w_args: def any_identifier method_args expression_block {
+                  $$ = rb_funcall(self, rb_intern("sin_method_def_expand"), 5, INT2NUM(yylineno), $2, $3, $4, $1);
+                }
+                ;
+
+class_method_no_args: def any_identifier identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("sin_method_def_no_args"), 5, INT2NUM(yylineno), $2, $3, $4, $1);
+                }
+                ;
+
+operator_def:   def operator identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("operator_def"), 5, INT2NUM(yylineno), $2, $3, $4, $1);
+                }
+                | def LBRACKET RBRACKET identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("operator_def"), 5,
+                                  INT2NUM(yylineno), fy_terminal_node_from(self, "identifier", "[]"), $4, $5, $1);
+                }
+                ;
+
+class_operator_def: def any_identifier operator identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("sin_operator_def"), 6, INT2NUM(yylineno), $2, $3, $4, $5, $1);
+                }
+                | def any_identifier LBRACKET RBRACKET identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("sin_operator_def"), 6,
+                                  INT2NUM(yylineno), $2, fy_terminal_node_from(self, "identifier", "[]"), $5, $6, $1);
+                }
+                ;
+
+message_send:   exp identifier {
+                  $$ = rb_funcall(self, rb_intern("msg_send_basic"), 3, INT2NUM(yylineno), $1, $2);
+                }
+                | exp send_args {
+                  $$ = rb_funcall(self, rb_intern("msg_send_args"), 3, INT2NUM(yylineno), $1, $2);
+                }
+                | send_args {
+                  $$ = rb_funcall(self, rb_intern("msg_send_args"), 3, INT2NUM(yylineno), Qnil, $1);
+                }
+                ;
+
+/* ruby_send_open is just an identifier immediatly followed by a left-paren
+   NO SPACE ALLOWED between the identifier and the left-paren. that's why we
+   need a parse rule.
+*/
+ruby_send_open: RUBY_SEND_OPEN {
+                  // remove the trailing left paren and create an identifier.
+                  $$ = fy_terminal_node(self, "ruby_send_open");
+                };
+ruby_oper_open: RUBY_OPER_OPEN {
+                  // remove the trailing left paren and create an identifier.
+                  $$ = fy_terminal_node(self, "ruby_send_open");
+                };
+
+ruby_send:      exp ruby_send_open ruby_args {
+                  $$ = rb_funcall(self, rb_intern("msg_send_ruby"), 4, INT2NUM(yylineno), $1, $2, $3);
+                }
+                | ruby_send_open ruby_args {
+                  $$ = rb_funcall(self, rb_intern("msg_send_ruby"), 4, INT2NUM(yylineno), Qnil, $1, $2);
+                }
+                ;
+
+/*
+   The closing part of ruby_send_open.
+   We explicitly require parens for ALL ruby sends now, so there will always be
+   a closing paren.
+*/
+ruby_args:      RPAREN block_literal  {
+                  $$ = rb_funcall(self, rb_intern("ruby_args"), 3, INT2NUM(yylineno), Qnil, $2);
+                }
+                | exp_comma_list RPAREN block_literal {
+                  $$ = rb_funcall(self, rb_intern("ruby_args"), 3, INT2NUM(yylineno), $1, $3);
+                }
+                | RPAREN {
+                  $$ = rb_funcall(self, rb_intern("ruby_args"), 1, INT2NUM(yylineno));
+                }
+                | exp_comma_list RPAREN {
+                  $$ = rb_funcall(self, rb_intern("ruby_args"), 2, INT2NUM(yylineno), $1);
+                }
+                ;
+
+operator_send:  exp operator arg_exp {
+                  $$ = rb_funcall(self, rb_intern("oper_send_basic"), 4, INT2NUM(yylineno), $1, $2, $3);
+                }
+                | exp operator DOT space arg_exp {
+                  $$ = rb_funcall(self, rb_intern("oper_send_basic"), 4, INT2NUM(yylineno), $1, $2, $5);
+                }
+                | exp LBRACKET exp RBRACKET {
+                  $$ = rb_funcall(self, rb_intern("oper_send_basic"), 4,
+                                  INT2NUM(yylineno), $1, fy_terminal_node_from(self, "identifier", "[]"), $3);
+                }
+                ;
+
+ruby_oper_send: exp ruby_oper_open ruby_args {
+                  $$ = rb_funcall(self, rb_intern("msg_send_ruby"), 4, INT2NUM(yylineno), $1, $2, $3);
+                }
+                ;
+
+
+send_args:      identifier COLON arg_exp {
+                  $$ = rb_funcall(self, rb_intern("send_args"), 3, INT2NUM(yylineno), $1, $3);
+                }
+                | identifier COLON space arg_exp {
+                  $$ = rb_funcall(self, rb_intern("send_args"), 3, INT2NUM(yylineno), $1, $4);
+                }
+                | send_args identifier COLON arg_exp {
+                  $$ = rb_funcall(self, rb_intern("send_args"), 4, INT2NUM(yylineno), $2, $4, $1);
+                }
+                | send_args identifier COLON space arg_exp {
+                  $$ = rb_funcall(self, rb_intern("send_args"), 4, INT2NUM(yylineno), $2, $5, $1);
+                }
+                ;
+
+arg_exp:        any_identifier {
+                  $$ = $1;
+                }
+                | LPAREN exp RPAREN {
+                  $$ = $2;
+                }
+                | literal_value {
+                  $$ = $1;
+                }
+                | DOLLAR exp {
+                  $$ = $2;
+                }
+                ;
+
+try_catch_block: TRY expression_block catch_blocks finally_block {
+                  $$ = rb_funcall(self, rb_intern("try_catch_finally"), 4, INT2NUM(yylineno), $2, $3, $4);
+                }
+                | TRY expression_block required_catch_blocks {
+                  $$ = rb_funcall(self, rb_intern("try_catch_finally"), 3, INT2NUM(yylineno), $2, $3);
+                }
+                ;
+
+catch_block:    CATCH expression_block  {
+                  $$ = rb_funcall(self, rb_intern("catch_handler"), 2, INT2NUM(yylineno), $2);
+                }
+                | CATCH exp expression_block {
+                  $$ = rb_funcall(self, rb_intern("catch_handler"), 3, INT2NUM(yylineno), $3, $2);
+                }
+                | CATCH exp ARROW identifier expression_block {
+                  $$ = rb_funcall(self, rb_intern("catch_handler"), 4, INT2NUM(yylineno), $5, $2, $4);
+                }
+                ;
+
+required_catch_blocks: catch_block {
+                  $$ = rb_funcall(self, rb_intern("catch_handlers"), 2, INT2NUM(yylineno), $1);
+                }
+                | required_catch_blocks catch_block {
+                  $$ = rb_funcall(self, rb_intern("catch_handlers"), 3, INT2NUM(yylineno), $2, $1);
+                }
+                ;
+
+catch_blocks:   catch_block {
+                  $$ = rb_funcall(self, rb_intern("catch_handlers"), 2, INT2NUM(yylineno), $1);
+                }
+                | catch_blocks catch_block {
+                  $$ = rb_funcall(self, rb_intern("catch_handlers"), 3, INT2NUM(yylineno), $2, $1);
+                }
+                | /* empty */ {
+                  $$ = rb_funcall(self, rb_intern("catch_handlers"), 1, INT2NUM(yylineno));
+                }
+                ;
+
+finally_block:  FINALLY expression_block {
+                  $$ = $2;
+                }
+                ;
+
+integer_literal: INTEGER_LITERAL {
+                  $$ = fy_terminal_node(self, "integer_literal");
+                }
+                ;
+double_literal: DOUBLE_LITERAL {
+                  $$ = fy_terminal_node(self, "double_literal");
+                }
+                ;
+string_literal: STRING_LITERAL {
+                  $$ = fy_terminal_node(self, "string_literal");
+                }
+                | MULTI_STRING_LITERAL {
+                  $$ = fy_terminal_node(self, "multiline_string_literal");
+                }
+                ;
+symbol_literal: SYMBOL_LITERAL {
+                  $$ = fy_terminal_node(self, "symbol_literal");
+                }
+                ;
+regex_literal: REGEX_LITERAL {
+                  $$ = fy_terminal_node(self, "regex_literal");
+                }
+                ;
+
+hex_literal:    HEX_LITERAL {
+                  $$ = rb_funcall(self, rb_intern("integer_literal"), 3,
+                                  INT2NUM(yylineno), rb_str_new2(yytext), INT2NUM(16));
+                }
+                ;
+
+oct_literal:    OCT_LITERAL {
+                  $$ = rb_funcall(self, rb_intern("integer_literal"), 3,
+                                  INT2NUM(yylineno), rb_str_new2(yytext), INT2NUM(8));
+                }
+                ;
+
+bin_literal:    BIN_LITERAL {
+                  $$ = rb_funcall(self, rb_intern("integer_literal"), 3,
+                                  INT2NUM(yylineno), rb_str_new2(yytext), INT2NUM(2));
+                }
+                ;
+
+literal_value:  integer_literal
+                | hex_literal
+                | oct_literal
+                | bin_literal
+                | double_literal
+                | string_literal
+                | symbol_literal
+                | hash_literal
+                | array_literal
+                | regex_literal
+                | block_literal
+                | tuple_literal
+                | range_literal
+                ;
+
+array_literal:  empty_array {
+                  $$ = $1;
+                }
+                | LBRACKET space exp_comma_list space RBRACKET {
+                  $$ = rb_funcall(self, rb_intern("array_literal"), 2, INT2NUM(yylineno), $3);
+                }
+                ;
+
+exp_comma_list: exp {
+                  $$ = rb_funcall(self, rb_intern("expr_ary"), 2, INT2NUM(yylineno), $1);
+                }
+                | exp_comma_list COMMA space exp {
+                  $$ = rb_funcall(self, rb_intern("expr_ary"), 3, INT2NUM(yylineno), $4, $1);
+                }
+                | exp_comma_list COMMA {
+                  $$ = $1;
+                }
+                ;
+
+empty_array:    LBRACKET space RBRACKET {
+                  $$ = rb_funcall(self, rb_intern("array_literal"), 1, INT2NUM(yylineno));
+                }
+                ;
+
+hash_literal:   LHASH space key_value_list space RHASH {
+                  $$ = rb_funcall(self, rb_intern("hash_literal"), 2, INT2NUM(yylineno), $3);
+                }
+                | LHASH space RHASH {
+                  $$ = rb_funcall(self, rb_intern("hash_literal"), 1, INT2NUM(yylineno));
+                }
+                ;
+
+block_literal:  expression_block {
+                  $$ = rb_funcall(self, rb_intern("block_literal"), 3, INT2NUM(yylineno), Qnil, $1);
+                }
+                | STAB block_args STAB space expression_block {
+                  $$ = rb_funcall(self, rb_intern("block_literal"), 3, INT2NUM(yylineno), $2, $5);
+                }
+                ;
+
+tuple_literal:  LPAREN exp_comma_list RPAREN {
+                  $$ = rb_funcall(self, rb_intern("tuple_literal"), 2, INT2NUM(yylineno), $2);
+                }
+                ;
+
+range_literal:  LPAREN exp DOT DOT exp RPAREN {
+                  $$ = rb_funcall(self, rb_intern("range_literal"), 3, INT2NUM(yylineno), $2, $5);
+                }
+                ;
+
+block_args:     block_args_with_comma
+                | block_args_without_comma
+                ;
+
+block_args_without_comma: identifier {
+                  $$ = rb_funcall(self, rb_intern("block_args"), 2, INT2NUM(yylineno), $1);
+                }
+                | block_args_without_comma identifier {
+                  $$ = rb_funcall(self, rb_intern("block_args"), 3, INT2NUM(yylineno), $2, $1);
+                }
+                ;
+
+block_args_with_comma: identifier {
+                  $$ = rb_funcall(self, rb_intern("block_args"), 2, INT2NUM(yylineno), $1);
+                }
+                | block_args_with_comma COMMA identifier {
+                  $$ = rb_funcall(self, rb_intern("block_args"), 3, INT2NUM(yylineno), $3, $1);
+                }
+                ;
+
+key_value_list: exp space ARROW space exp {
+                  $$ = rb_funcall(self, rb_intern("key_value_list"), 3, INT2NUM(yylineno), $1, $5);
+                }
+                | key_value_list COMMA space exp space ARROW space exp {
+                  $$ = rb_funcall(self, rb_intern("key_value_list"), 4, INT2NUM(yylineno), $4, $8, $1);
+                }
+                ;
+
+match_expr:     MATCH exp THIN_ARROW LCURLY space match_body space RCURLY {
+                  $$ = rb_funcall(self, rb_intern("match_expr"), 3, INT2NUM(yylineno), $2, $6);
+                }
+                ;
+
+match_body:     match_clause {
+                  $$ = rb_funcall(self, rb_intern("match_body"), 2, INT2NUM(yylineno), $1);
+                }
+                | match_body match_clause {
+                  $$ = rb_funcall(self, rb_intern("match_body"), 3, INT2NUM(yylineno), $2, $1);
+                }
+                ;
+
+match_clause:   CASE exp THIN_ARROW expression_list {
+                  $$ = rb_funcall(self, rb_intern("match_clause"), 3, INT2NUM(yylineno), $2, $4);
+                }
+                | CASE exp THIN_ARROW STAB identifier STAB expression_list {
+                  $$ = rb_funcall(self, rb_intern("match_clause"), 4, INT2NUM(yylineno), $2, $7, $5);
+                }
+                ;
+
+%%
+
+
+VALUE fy_terminal_node(VALUE self, char* method) {
+  return rb_funcall(self, rb_intern(method), 2, INT2NUM(yylineno), rb_str_new2(yytext));
+}
+
+VALUE fy_terminal_node_from(VALUE self, char* method, char* text) {
+  return rb_funcall(self, rb_intern(method), 2, INT2NUM(yylineno), rb_str_new2(text));
+}
+
+int yyerror(VALUE self, char *s)
+{
+  rb_funcall(self, rb_intern("parse_error"), 2, INT2NUM(yylineno), rb_str_new2(yytext));
+  return 1;
+}
+