rubinius-melbourne 2.1.0.0 → 2.2.0.0

data/ext/rubinius/melbourne/melbourne.cpp

@@ -32,17 +32,12 @@ VALUE MELBOURNE_FILE_TO_AST(VALUE self, VALUE fname, VALUE start) {
 }
 
 void Init_melbourne(void) {
-  VALUE rb_cMelbourne, rb_mToolSets, rb_mToolSet;
+  VALUE rb_mCodeTools, rb_cMelbourne;
 
   MELBOURNE::init_symbols();
 
-#ifndef RUBINIUS
-  VALUE rb_mRubinius = rb_const_get(rb_cObject, rb_intern("Rubinius"));
-#endif
-
-  rb_mToolSets = rb_const_get(rb_mRubinius, rb_intern("ToolSets"));
-  rb_mToolSet = rb_funcall(rb_mToolSets, rb_intern("current"), 0);
-  rb_cMelbourne = rb_define_class_under(rb_mToolSet, "Melbourne", rb_cObject);
+  rb_mCodeTools = rb_const_get(rb_cObject, rb_intern("CodeTools"));
+  rb_cMelbourne = rb_define_class_under(rb_mCodeTools, "Melbourne", rb_cObject);
   rb_define_method(rb_cMelbourne, "string_to_ast",
       RUBY_METHOD_FUNC(MELBOURNE_STRING_TO_AST), 3);
   rb_define_method(rb_cMelbourne, "file_to_ast",

data/ext/rubinius/melbourne/node.hpp

@@ -37,11 +37,30 @@ namespace MELBOURNE {
       struct RNode *node;
       ID id;
       long state;
+      struct rb_args_info *args;
       long cnt;
       VALUE value;
     } u3;
   } NODE;
 
+  struct rb_args_info {
+    NODE *pre_init;
+    NODE *post_init;
+
+    int pre_args_num;  /* count of mandatory pre-arguments */
+    int post_args_num; /* count of mandatory post-arguments */
+
+    ID first_post_arg;
+
+    ID rest_arg;
+    ID block_arg;
+
+    NODE *kw_args;
+    NODE *kw_rest_arg;
+
+    NODE *opt_args;
+  };
+
 #define RNODE(obj)  ((NODE*)(obj))
 
 /* 0..4:T_TYPES, 5:FL_MARK, 6:reserved, 7:NODE_FL_NEWLINE */
@@ -105,6 +124,7 @@ namespace MELBOURNE {
 #define nd_recv  u1.node
 #define nd_mid   u2.id
 #define nd_args  u3.node
+#define nd_ainfo u3.args
 
 #define nd_noex  u3.id
 #define nd_defn  u3.node
@@ -162,7 +182,7 @@ namespace MELBOURNE {
 #define NEW_UNTIL(c,b,n)        NEW_NODE(NODE_UNTIL,c,b,n)
 #define NEW_FOR(v,i,b)          NEW_NODE(NODE_FOR,v,b,i)
 #define NEW_ITER(a,b)           NEW_NODE(NODE_ITER,0,NEW_SCOPE(a,b),0)
-#define NEW_LAMBDA(a)           NEW_NODE(NODE_LAMBDA,a,0,0)
+#define NEW_LAMBDA(a,b)         NEW_NODE(NODE_LAMBDA,0,NEW_SCOPE(a,b),0)
 #define NEW_BREAK(s)            NEW_NODE(NODE_BREAK,s,0,0)
 #define NEW_NEXT(s)             NEW_NODE(NODE_NEXT,s,0,0)
 #define NEW_REDO()              NEW_NODE(NODE_REDO,0,0,0)
@@ -192,6 +212,7 @@ namespace MELBOURNE {
 #define NEW_OP_ASGN22(i,o)      NEW_NODE(NODE_OP_ASGN2,i,o,rb_id_attrset(i))
 #define NEW_OP_ASGN_OR(i,val)   NEW_NODE(NODE_OP_ASGN_OR,i,val,0)
 #define NEW_OP_ASGN_AND(i,val)  NEW_NODE(NODE_OP_ASGN_AND,i,val,0)
+#define NEW_OP_CDECL(v,op,val)  NEW_NODE(NODE_OP_CDECL,v,val,op)
 #define NEW_GVAR(v)             NEW_NODE(NODE_GVAR,v,0,0)
 #define NEW_LVAR(v)             NEW_NODE(NODE_LVAR,v,0,0)
 #define NEW_DVAR(v)             NEW_NODE(NODE_DVAR,v,0,0)
@@ -218,6 +239,7 @@ namespace MELBOURNE {
 #define NEW_ARGS(m,o)           NEW_NODE(NODE_ARGS,o,m,0)
 #define NEW_ARGS_AUX(r,b)       NEW_NODE(NODE_ARGS_AUX,r,b,0)
 #define NEW_OPT_ARG(i,v)        NEW_NODE(NODE_OPT_ARG,i,v,0)
+#define NEW_KW_ARG(i,v)         NEW_NODE(NODE_KW_ARG,i,v,0)
 #define NEW_POSTARG(i,v)        NEW_NODE(NODE_POSTARG,i,v,0)
 #define NEW_ARGSCAT(a,b)        NEW_NODE(NODE_ARGSCAT,a,b,0)
 #define NEW_ARGSPUSH(a,b)       NEW_NODE(NODE_ARGSPUSH,a,b,0)
@@ -251,6 +273,8 @@ namespace MELBOURNE {
 #define NEW_FILE()              NEW_NODE(NODE_FILE,0,0,0)
 #define NEW_NUMBER(l)           NEW_NODE(NODE_NUMBER,REF(l),0,0)
 #define NEW_FLOAT(l)            NEW_NODE(NODE_FLOAT,REF(l),0,0)
+#define NEW_RATIONAL(l)         NEW_NODE(NODE_RATIONAL,REF(l),0,0)
+#define NEW_IMAGINARY(l)        NEW_NODE(NODE_IMAGINARY,REF(l),0,0)
 #define NEW_ENCODING(n)         NEW_NODE(NODE_ENCODING,REF(n),0,0)
 
 #define NOEX_PUBLIC             0x00,

data/ext/rubinius/melbourne/node_types.cpp

@@ -41,6 +41,7 @@ namespace MELBOURNE {
     "op_asgn2\0"
     "op_asgn_and\0"
     "op_asgn_or\0"
+    "op_cdecl\0"
     "call\0"
     "fcall\0"
     "vcall\0"
@@ -74,6 +75,7 @@ namespace MELBOURNE {
     "args\0"
     "args_aux\0"
     "opt_arg\0"
+    "kw_arg\0"
     "postarg\0"
     "argscat\0"
     "argspush\0"
@@ -118,6 +120,8 @@ namespace MELBOURNE {
     "float\0"
     "encoding\0"
     "preexe\0"
+    "rational\0"
+    "imaginary\0"
   };
 
   static const unsigned short node_types_offsets[] = {
@@ -156,87 +160,91 @@ namespace MELBOURNE {
     195,
     207,
     218,
-    223,
-    229,
-    235,
-    241,
-    248,
-    254,
-    261,
-    268,
-    273,
-    280,
-    286,
-    291,
-    296,
-    301,
-    306,
-    312,
-    317,
-    325,
+    227,
+    232,
+    238,
+    244,
+    250,
+    257,
+    263,
+    270,
+    277,
+    282,
+    289,
+    295,
+    300,
+    305,
+    310,
+    315,
+    321,
+    326,
     334,
-    340,
-    347,
-    354,
-    358,
-    362,
+    343,
+    349,
+    356,
+    363,
     367,
-    372,
-    378,
-    384,
-    390,
-    401,
-    406,
+    371,
+    376,
+    381,
+    387,
+    393,
+    399,
+    410,
     415,
-    423,
-    431,
+    424,
+    432,
     439,
-    448,
-    454,
-    461,
-    471,
-    482,
+    447,
+    455,
+    464,
+    470,
+    477,
     487,
-    492,
     498,
-    505,
-    511,
-    517,
-    524,
-    531,
-    538,
-    545,
-    550,
-    555,
+    503,
+    508,
+    514,
+    521,
+    527,
+    533,
+    540,
+    547,
+    554,
     561,
-    567,
-    572,
-    576,
-    581,
-    587,
-    595,
+    566,
+    571,
+    577,
+    583,
+    588,
+    592,
+    597,
     603,
     611,
-    618,
-    626,
-    631,
-    637,
+    619,
+    627,
+    634,
     642,
-    651,
-    659,
-    666,
+    647,
+    653,
+    658,
+    667,
     675,
-    680,
-    685,
+    682,
     691,
-    698,
-    704,
-    713,
-    720
+    696,
+    701,
+    707,
+    714,
+    720,
+    729,
+    736,
+    745,
+    755
   };
 
   const char *get_node_type_string(enum node_type node) {
-    if(node < 111) {
+    if(node < 115) {
       return node_types + node_types_offsets[node];
     } else {
 #define NODE_STRING_MESSAGE_LEN 20

data/ext/rubinius/melbourne/node_types.hpp

@@ -38,6 +38,7 @@ namespace MELBOURNE {
     NODE_OP_ASGN2,
     NODE_OP_ASGN_AND,
     NODE_OP_ASGN_OR,
+    NODE_OP_CDECL,
     NODE_CALL,
     NODE_FCALL,
     NODE_VCALL,
@@ -71,6 +72,7 @@ namespace MELBOURNE {
     NODE_ARGS,
     NODE_ARGS_AUX,
     NODE_OPT_ARG,
+    NODE_KW_ARG,
     NODE_POSTARG,
     NODE_ARGSCAT,
     NODE_ARGSPUSH,
@@ -114,7 +116,9 @@ namespace MELBOURNE {
     NODE_NUMBER,
     NODE_FLOAT,
     NODE_ENCODING,
-    NODE_PREEXE
+    NODE_PREEXE,
+    NODE_RATIONAL,
+    NODE_IMAGINARY
   };
 
   const char *get_node_type_string(enum node_type nt);

data/ext/rubinius/melbourne/node_types.rb

@@ -33,6 +33,7 @@ node_types = %w[
   op_asgn2
   op_asgn_and
   op_asgn_or
+  op_cdecl
   call
   fcall
   vcall
@@ -66,6 +67,7 @@ node_types = %w[
   args
   args_aux
   opt_arg
+  kw_arg
   postarg
   argscat
   argspush
@@ -110,6 +112,8 @@ node_types = %w[
   float
   encoding
   preexe
+  rational
+  imaginary
 ]
 
 def write_node_types(list)
@@ -117,6 +121,7 @@ def write_node_types(list)
     f.puts <<EOF
 /* This file is generated by node_types.rb. Do not edit. */
 
+#include "namespace.h"
 #include "node_types.hpp"
 
 #include <stdio.h>

data/ext/rubinius/melbourne/parser_state.hpp

@@ -12,21 +12,42 @@
 
 namespace MELBOURNE {
 
-  enum lex_state_e {
-    EXPR_BEG,       /* ignore newline, +/- is a sign. */
-    EXPR_END,       /* newline significant, +/- is an operator. */
-    EXPR_ENDARG,    /* ditto, and unbound braces. */
-    EXPR_ENDFN,     /* ditto, and unbound braces. */
-    EXPR_ARG,       /* newline significant, +/- is an operator. */
-    EXPR_CMDARG,    /* newline significant, +/- is an operator. */
-    EXPR_MID,       /* newline significant, +/- is an operator. */
-    EXPR_FNAME,     /* ignore newline, no reserved words. */
-    EXPR_DOT,       /* right after `.' or `::', no reserved words. */
-    EXPR_CLASS,     /* immediate after `class', no here document. */
-    EXPR_VALUE,     /* like EXPR_BEG but label is disallowed. */
+  enum lex_state_bits {
+    EXPR_BEG_BIT = 0,   /* ignore newline, +/- is a sign. */
+    EXPR_END_BIT,       /* newline significant, +/- is an operator. */
+    EXPR_ENDARG_BIT,    /* ditto, and unbound braces. */
+    EXPR_ENDFN_BIT,     /* ditto, and unbound braces. */
+    EXPR_ARG_BIT,       /* newline significant, +/- is an operator. */
+    EXPR_CMDARG_BIT,    /* newline significant, +/- is an operator. */
+    EXPR_MID_BIT,       /* newline significant, +/- is an operator. */
+    EXPR_FNAME_BIT,     /* ignore newline, no reserved words. */
+    EXPR_DOT_BIT,       /* right after `.' or `::', no reserved words. */
+    EXPR_CLASS_BIT,     /* immediate after `class', no here document. */
+    EXPR_VALUE_BIT,     /* like EXPR_BEG but label is disallowed. */
     EXPR_MAX_STATE
   };
 
+  enum lex_state_e {
+#define EXPR(e) EXPR_##e = (1 << EXPR_##e##_BIT)
+    EXPR(BEG),
+    EXPR(END),
+    EXPR(ENDARG),
+    EXPR(ENDFN),
+    EXPR(ARG),
+    EXPR(CMDARG),
+    EXPR(MID),
+    EXPR(FNAME),
+    EXPR(DOT),
+    EXPR(CLASS),
+    EXPR(VALUE),
+    EXPR_BEG_ANY  = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS),
+    EXPR_ARG_ANY  = (EXPR_ARG | EXPR_CMDARG),
+    EXPR_END_ANY  = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
+  };
+
+#define lex_state_of_p(x, s)  ((x) & (s))
+#define lex_state_p(s)        lex_state_of_p(lex_state, s)
+
 typedef VALUE stack_type;
 
   struct StartPosition {
@@ -50,11 +71,13 @@ typedef VALUE stack_type;
     int class_nest;
     int in_single;
     int in_def;
+    int brace_nest;
     int compile_for_eval;
     ID cur_mid;
     char *token_buffer;
     int tokidx;
     int toksiz;
+    int tokline;
     int emit_warnings;
     /* Mirror'ing the 1.8 parser, There are 2 input methods,
        from IO and directly from a string. */
@@ -77,9 +100,9 @@ typedef VALUE stack_type;
     VALUE lex_lastline;
     VALUE lex_nextline;
 
-    char *lex_pbeg;
-    char *lex_p;
-    char *lex_pend;
+    const char *lex_pbeg;
+    const char *lex_p;
+    const char *lex_pend;
     int lex_str_used;
 
     enum lex_state_e lex_state;
@@ -143,11 +166,13 @@ typedef VALUE stack_type;
 #define class_nest          PARSER_VAR(class_nest)
 #define in_single           PARSER_VAR(in_single)
 #define in_def              PARSER_VAR(in_def)
+#define brace_nest          PARSER_VAR(brace_nest)
 #define compile_for_eval    PARSER_VAR(compile_for_eval)
 #define cur_mid             PARSER_VAR(cur_mid)
 #define tokenbuf            PARSER_VAR(token_buffer)
 #define tokidx              PARSER_VAR(tokidx)
 #define toksiz              PARSER_VAR(toksiz)
+#define tokline             PARSER_VAR(tokline)
 #define emit_warnings       PARSER_VAR(emit_warnings)
 #define lex_gets            PARSER_VAR(lex_gets)
 #define line_buffer         PARSER_VAR(line_buffer)

data/ext/rubinius/melbourne/symbols.cpp

@@ -57,8 +57,10 @@ namespace MELBOURNE {
   ID rb_sHash;
   ID rb_sIAsgn;
   ID rb_sIf;
+  ID rb_sImaginary;
   ID rb_sIter;
   ID rb_sIVar;
+  ID rb_sKwArg;
   ID rb_sLAsgn;
   ID rb_sLambda;
   ID rb_sLit;
@@ -83,6 +85,7 @@ namespace MELBOURNE {
   ID rb_sPostExe;
   ID rb_sPostArg;
   ID rb_sPreExe;
+  ID rb_sRational;
   ID rb_sRedo;
   ID rb_sRegex;
   ID rb_sResbody;
@@ -169,8 +172,10 @@ namespace MELBOURNE {
     rb_sHash        = rb_intern("process_hash");
     rb_sIAsgn       = rb_intern("process_iasgn");
     rb_sIf          = rb_intern("process_if");
+    rb_sImaginary   = rb_intern("process_imaginary");
     rb_sIter        = rb_intern("process_iter");
     rb_sIVar        = rb_intern("process_ivar");
+    rb_sKwArg       = rb_intern("process_kw_arg");
     rb_sLAsgn       = rb_intern("process_lasgn");
     rb_sLambda      = rb_intern("process_lambda");
     rb_sLit         = rb_intern("process_lit");
@@ -195,6 +200,7 @@ namespace MELBOURNE {
     rb_sPostExe     = rb_intern("process_postexe");
     rb_sPostArg     = rb_intern("process_postarg");
     rb_sPreExe      = rb_intern("process_preexe");
+    rb_sRational    = rb_intern("process_rational");
     rb_sRedo        = rb_intern("process_redo");
     rb_sRegex       = rb_intern("process_regex");
     rb_sResbody     = rb_intern("process_resbody");