rubinius-melbourne 3.7 → 3.8

data/ext/rubinius/code/melbourne/grammar.y

@@ -451,6 +451,9 @@ static int scan_hex(const char *start, size_t len, size_t *retlen);
   keyword_class
   keyword_module
   keyword_def
+  keyword_defm
+  keyword_fun
+  keyword_funm
   keyword_undef
   keyword_begin
   keyword_rescue
@@ -1251,6 +1254,7 @@ reswords        : keyword__LINE__ | keyword__FILE__ | keyword__ENCODING__
                 | keyword_BEGIN | keyword_END
                 | keyword_alias | keyword_and | keyword_begin
                 | keyword_break | keyword_case | keyword_class | keyword_def
+                | keyword_defm | keyword_fun | keyword_funm
                 | keyword_defined | keyword_do | keyword_else | keyword_elsif
                 | keyword_end | keyword_ensure | keyword_false
                 | keyword_for | keyword_in | keyword_module | keyword_next
@@ -1887,6 +1891,60 @@ primary         : literal
                     in_def--;
                     cur_mid = $<id>3;
                   }
+                | k_defm fname
+                  {
+                    $<id>$ = cur_mid;
+                    cur_mid = $2;
+                    in_def++;
+                    local_push(0);
+                  }
+                  f_arglist
+                  bodystmt
+                  k_end
+                  {
+                    NODE* body = remove_begin($5);
+                    $$ = NEW_DEFNM($2, $4, body, NOEX_PRIVATE);
+                    nd_set_line($$, $<num>1);
+                    local_pop();
+                    in_def--;
+                    cur_mid = $<id>3;
+                  }
+                | k_fun fname
+                  {
+                    $<id>$ = cur_mid;
+                    cur_mid = $2;
+                    in_def++;
+                    local_push(0);
+                  }
+                  f_arglist
+                  bodystmt
+                  k_end
+                  {
+                    NODE* body = remove_begin($5);
+                    $$ = NEW_FUN($2, $4, body, NOEX_PRIVATE);
+                    nd_set_line($$, $<num>1);
+                    local_pop();
+                    in_def--;
+                    cur_mid = $<id>3;
+                  }
+                | k_funm fname
+                  {
+                    $<id>$ = cur_mid;
+                    cur_mid = $2;
+                    in_def++;
+                    local_push(0);
+                  }
+                  f_arglist
+                  bodystmt
+                  k_end
+                  {
+                    NODE* body = remove_begin($5);
+                    $$ = NEW_FUNM($2, $4, body, NOEX_PRIVATE);
+                    nd_set_line($$, $<num>1);
+                    local_pop();
+                    in_def--;
+                    cur_mid = $<id>3;
+                  }
                 | k_def singleton dot_or_colon {SET_LEX_STATE(EXPR_FNAME);} fname
                   {
                     $<num>4 = in_single;
@@ -1907,6 +1965,26 @@ primary         : literal
                     in_single = $<num>4 & 1;
                     current_arg = $<id>6;
                   }
+                | k_defm singleton dot_or_colon {SET_LEX_STATE(EXPR_FNAME);} fname
+                  {
+                    $<num>4 = in_single;
+                    in_single = 1;
+                    SET_LEX_STATE(EXPR_ENDFN | EXPR_LABEL); /* force for args */
+                    local_push(0);
+                    $<id>$ = current_arg;
+                    current_arg = 0;
+                  }
+                  f_arglist
+                  bodystmt
+                  k_end
+                  {
+                    NODE* body = remove_begin($8);
+                    $$ = NEW_DEFSM($2, $5, $7, body);
+                    nd_set_line($$, $<num>1);
+                    local_pop();
+                    in_single = $<num>4 & 1;
+                    current_arg = $<id>6;
+                  }
                 | keyword_break
                   {
                     $$ = NEW_BREAK(0);
@@ -1994,6 +2072,27 @@ k_def           : keyword_def
                   }
                 ;
 
+k_defm          : keyword_defm
+                  {
+                    token_info_push("defm");
+                    $<num>$ = sourceline;
+                  }
+                ;
+
+k_fun           : keyword_fun
+                  {
+                    token_info_push("fun");
+                    $<num>$ = sourceline;
+                  }
+                ;
+
+k_funm          : keyword_funm
+                  {
+                    token_info_push("funm");
+                    $<num>$ = sourceline;
+                  }
+                ;
+
 k_end           : keyword_end
                   {
                     token_info_pop("end");
@@ -6419,6 +6518,10 @@ retry:
     if(c == '\n') {
       space_seen = 1;
       goto retry; /* skip \\n */
+    } else if(c == '(' || c == '{') {
+      pushback(c);
+      SET_LEX_STATE(EXPR_ENDFN);
+      return tLAMBDA;
     }
     pushback(c);
     return '\\';

data/ext/rubinius/code/melbourne/lex.c.blt

@@ -28,18 +28,18 @@
 error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
 #endif
 
-struct kwtable {const char *name; int id[2]; enum lex_state_e state;};
+struct kwtable {const char* name; int id[2]; enum lex_state_e state;};
 const struct kwtable *rb_reserved_word(const char *, unsigned int);
 static const struct kwtable *reserved_word(const char *, unsigned int);
 #define rb_reserved_word(str, len) reserved_word(str, len)
 struct kwtable;
 
-#define TOTAL_KEYWORDS 41
+#define TOTAL_KEYWORDS 44
 #define MIN_WORD_LENGTH 2
 #define MAX_WORD_LENGTH 12
-#define MIN_HASH_VALUE 8
+#define MIN_HASH_VALUE 7
 #define MAX_HASH_VALUE 50
-/* maximum key range = 43, duplicates = 0 */
+/* maximum key range = 44, duplicates = 0 */
 
 static inline unsigned int hash(register const char* str, register unsigned int len)
 {
@@ -51,13 +51,13 @@ static inline unsigned int hash(register const char* str, register unsigned int
       51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
       51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
       51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
-      51, 51, 51, 26, 51, 51, 14, 51, 16,  8,
-      11, 13, 51, 51, 51, 51, 10, 51, 13, 51,
+      51, 51, 51, 30, 51, 51, 15, 51, 18, 10,
+      12, 14, 51, 51, 51, 51, 11, 51, 14, 51,
       51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
-      51, 51, 51, 51, 51, 11, 51, 13,  1, 26,
-       4,  1,  8, 28, 51, 23, 51,  1,  1, 27,
-       5, 19, 21, 51,  8,  3,  3, 11, 51, 21,
-      24, 16, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 12, 51,  6,  4, 35,
+      11,  1,  1, 29, 51, 27, 51,  3,  4, 20,
+       4, 10, 16, 51, 12,  1,  5,  8, 51, 12,
+      19, 18, 51, 51, 51, 51, 51, 51, 51, 51,
       51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
       51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
       51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
@@ -91,62 +91,62 @@ const struct kwtable* rb_reserved_word(register const char* str, register unsign
 {
   static const struct kwtable wordlist[] =
     {
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {"break", {keyword_break, keyword_break}, EXPR_MID},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {"else", {keyword_else, keyword_else}, EXPR_BEG},
-      {"nil", {keyword_nil, keyword_nil}, EXPR_END},
+      {"elsif", {keyword_elsif, keyword_elsif}, EXPR_VALUE},
       {"ensure", {keyword_ensure, keyword_ensure}, EXPR_BEG},
-      {"end", {keyword_end, keyword_end}, EXPR_END},
+      {"self", {keyword_self, keyword_self}, EXPR_END},
+      {"false", {keyword_false, keyword_false}, EXPR_END},
+      {"fun", {keyword_fun, keyword_fun}, EXPR_FNAME},
+      {"break", {keyword_break, keyword_break}, EXPR_MID},
       {"then", {keyword_then, keyword_then}, EXPR_BEG},
+      {"nil", {keyword_nil, keyword_nil}, EXPR_END},
+      {"def", {keyword_def, keyword_def}, EXPR_FNAME},
       {"not", {keyword_not, keyword_not}, EXPR_ARG},
-      {"false", {keyword_false, keyword_false}, EXPR_END},
-      {"self", {keyword_self, keyword_self}, EXPR_END},
-      {"elsif", {keyword_elsif, keyword_elsif}, EXPR_VALUE},
-      {"rescue", {keyword_rescue, modifier_rescue}, EXPR_MID},
       {"true", {keyword_true, keyword_true}, EXPR_END},
-      {"until", {keyword_until, modifier_until}, EXPR_VALUE},
       {"unless", {keyword_unless, modifier_unless}, EXPR_VALUE},
-      {"return", {keyword_return, keyword_return}, EXPR_MID},
-      {"def", {keyword_def, keyword_def}, EXPR_FNAME},
-      {"and", {keyword_and, keyword_and}, EXPR_VALUE},
+      {"rescue", {keyword_rescue, modifier_rescue}, EXPR_MID},
+      {"when", {keyword_when, keyword_when}, EXPR_VALUE},
+      {"until", {keyword_until, modifier_until}, EXPR_VALUE},
       {"do", {keyword_do, keyword_do}, EXPR_BEG},
-      {"yield", {keyword_yield, keyword_yield}, EXPR_ARG},
-      {"for", {keyword_for, keyword_for}, EXPR_VALUE},
-      {"undef", {keyword_undef, keyword_undef}, EXPR_FNAME},
       {"or", {keyword_or, keyword_or}, EXPR_VALUE},
-      {"in", {keyword_in, keyword_in}, EXPR_VALUE},
-      {"when", {keyword_when, keyword_when}, EXPR_VALUE},
-      {"retry", {keyword_retry, keyword_retry}, EXPR_END},
+      {"undef", {keyword_undef, keyword_undef}, EXPR_FNAME},
+      {"end", {keyword_end, keyword_end}, EXPR_END},
+      {"return", {keyword_return, keyword_return}, EXPR_MID},
+      {"for", {keyword_for, keyword_for}, EXPR_VALUE},
+      {"funm", {keyword_funm, keyword_funm}, EXPR_FNAME},
       {"if", {keyword_if, modifier_if}, EXPR_VALUE},
-      {"case", {keyword_case, keyword_case}, EXPR_VALUE},
-      {"redo", {keyword_redo, keyword_redo}, EXPR_END},
+      {"and", {keyword_and, keyword_and}, EXPR_VALUE},
       {"next", {keyword_next, keyword_next}, EXPR_MID},
+      {"in", {keyword_in, keyword_in}, EXPR_VALUE},
       {"super", {keyword_super, keyword_super}, EXPR_ARG},
+      {"yield", {keyword_yield, keyword_yield}, EXPR_ARG},
+      {"defm", {keyword_defm, keyword_defm}, EXPR_FNAME},
+      {"redo", {keyword_redo, keyword_redo}, EXPR_END},
       {"module", {keyword_module, keyword_module}, EXPR_VALUE},
+      {"alias", {keyword_alias, keyword_alias}, EXPR_FNAME},
+      {"retry", {keyword_retry, keyword_retry}, EXPR_END},
+      {"case", {keyword_case, keyword_case}, EXPR_VALUE},
       {"begin", {keyword_begin, keyword_begin}, EXPR_BEG},
       {"__LINE__", {keyword__LINE__, keyword__LINE__}, EXPR_END},
       {"__FILE__", {keyword__FILE__, keyword__FILE__}, EXPR_END},
+      {"while", {keyword_while, modifier_while}, EXPR_VALUE},
       {"__ENCODING__", {keyword__ENCODING__, keyword__ENCODING__}, EXPR_END},
-      {"END", {keyword_END, keyword_END}, EXPR_END},
-      {"alias", {keyword_alias, keyword_alias}, EXPR_FNAME},
-      {"BEGIN", {keyword_BEGIN, keyword_BEGIN}, EXPR_END},
-      {"defined?", {keyword_defined, keyword_defined}, EXPR_ARG},
       {"class", {keyword_class, keyword_class}, EXPR_CLASS},
-      {""}, {""},
-      {"while", {keyword_while, modifier_while}, EXPR_VALUE}
+      {"BEGIN", {keyword_BEGIN, keyword_BEGIN}, EXPR_END},
+      {"END", {keyword_END, keyword_END}, EXPR_END},
+      {"defined?", {keyword_defined, keyword_defined}, EXPR_ARG}
     };
 
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      register int key = hash(str, len);
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) {
+    register int key = hash(str, len);
 
-      if(key <= MAX_HASH_VALUE && key >= 0)
-        {
-          register const char *s = wordlist[key].name;
+    if(key <= MAX_HASH_VALUE && key >= 0) {
+      register const char *s = wordlist[key].name;
 
-          if(*str == *s && !strcmp(str + 1, s + 1))
-            return &wordlist[key];
-        }
+      if(*str == *s && !strcmp (str + 1, s + 1))
+        return &wordlist[key];
     }
+  }
   return 0;
 }

data/ext/rubinius/code/melbourne/node.hpp

@@ -170,6 +170,10 @@ namespace MELBOURNE {
 
 #define NEW_DEFN(i,a,d,p)       NEW_NODE(NODE_DEFN,0,i,NEW_SCOPE(a,d))
 #define NEW_DEFS(r,i,a,d)       NEW_NODE(NODE_DEFS,r,i,NEW_SCOPE(a,d))
+#define NEW_DEFNM(i,a,d,p)      NEW_NODE(NODE_DEFNM,0,i,NEW_SCOPE(a,d))
+#define NEW_DEFSM(r,i,a,d)      NEW_NODE(NODE_DEFSM,r,i,NEW_SCOPE(a,d))
+#define NEW_FUN(i,a,d,p)        NEW_NODE(NODE_FUN,0,i,NEW_SCOPE(a,d))
+#define NEW_FUNM(i,a,d,p)       NEW_NODE(NODE_FUNM,0,i,NEW_SCOPE(a,d))
 #define NEW_IFUNC(f,c)          NEW_NODE(NODE_IFUNC,f,c,0)
 #define NEW_SCOPE(a,b)          NEW_NODE(NODE_SCOPE,local_tbl(),b,a)
 #define NEW_BLOCK(a)            NEW_NODE(NODE_BLOCK,a,0,0)

data/ext/rubinius/code/melbourne/node_types.cpp

@@ -86,6 +86,10 @@ namespace MELBOURNE {
     "block_pass\0"
     "defn\0"
     "defs\0"
+    "defnm\0"
+    "defsm\0"
+    "fun\0"
+    "funm\0"
     "alias\0"
     "valias\0"
     "undef\0"
@@ -208,47 +212,51 @@ namespace MELBOURNE {
     509,
     514,
     520,
-    527,
-    533,
-    539,
-    546,
-    553,
+    526,
+    530,
+    535,
+    541,
+    548,
+    554,
     560,
     567,
-    572,
-    577,
-    583,
-    589,
-    594,
+    574,
+    581,
+    588,
+    593,
     598,
-    603,
-    609,
-    617,
-    625,
-    633,
-    640,
-    648,
-    653,
-    659,
-    664,
-    676,
+    604,
+    610,
+    615,
+    619,
+    624,
+    630,
+    638,
+    646,
+    654,
+    661,
+    669,
+    674,
+    680,
     685,
-    693,
-    700,
-    709,
+    697,
+    706,
     714,
-    719,
-    725,
-    732,
-    738,
-    747,
-    754,
-    763,
-    773
+    721,
+    730,
+    735,
+    740,
+    746,
+    753,
+    759,
+    768,
+    775,
+    784,
+    794
   };
 
   const char *get_node_type_string(enum node_type node) {
-    if(node < 117) {
+    if(node < 121) {
       return node_types + node_types_offsets[node];
     } else {
 #define NODE_STRING_MESSAGE_LEN 20

data/ext/rubinius/code/melbourne/node_types.hpp

@@ -83,6 +83,10 @@ namespace MELBOURNE {
     NODE_BLOCK_PASS,
     NODE_DEFN,
     NODE_DEFS,
+    NODE_DEFNM,
+    NODE_DEFSM,
+    NODE_FUN,
+    NODE_FUNM,
     NODE_ALIAS,
     NODE_VALIAS,
     NODE_UNDEF,

data/ext/rubinius/code/melbourne/node_types.rb

@@ -78,6 +78,10 @@ node_types = %w[
   block_pass
   defn
   defs
+  defnm
+  defsm
+  fun
+  funm
   alias
   valias
   undef

data/ext/rubinius/code/melbourne/symbols.cpp

@@ -34,7 +34,9 @@ namespace MELBOURNE {
   ID rb_sData;
   ID rb_sDefined;
   ID rb_sDefn;
+  ID rb_sDefnm;
   ID rb_sDefs;
+  ID rb_sDefsm;
   ID rb_sDot2;
   ID rb_sDot3;
   ID rb_sDRegx;
@@ -53,6 +55,8 @@ namespace MELBOURNE {
   ID rb_sFlip3;
   ID rb_sFloat;
   ID rb_sFor;
+  ID rb_sFun;
+  ID rb_sFunm;
   ID rb_sGAsgn;
   ID rb_sGVar;
   ID rb_sHash;
@@ -152,7 +156,9 @@ namespace MELBOURNE {
     rb_sData        = rb_intern("process_data");
     rb_sDefined     = rb_intern("process_defined");
     rb_sDefn        = rb_intern("process_defn");
+    rb_sDefnm       = rb_intern("process_defnm");
     rb_sDefs        = rb_intern("process_defs");
+    rb_sDefsm       = rb_intern("process_defsm");
     rb_sDot2        = rb_intern("process_dot2");
     rb_sDot3        = rb_intern("process_dot3");
     rb_sDRegx       = rb_intern("process_dregx");
@@ -171,6 +177,8 @@ namespace MELBOURNE {
     rb_sFlip3       = rb_intern("process_flip3");
     rb_sFloat       = rb_intern("process_float");
     rb_sFor         = rb_intern("process_for");
+    rb_sFun         = rb_intern("process_fun");
+    rb_sFunm        = rb_intern("process_funm");
     rb_sGAsgn       = rb_intern("process_gasgn");
     rb_sGVar        = rb_intern("process_gvar");
     rb_sHash        = rb_intern("process_hash");