debase-ruby_core_source 0.10.9 → 0.10.13

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.1.0-preview1}/node.h

@@ -1,3 +1,5 @@
+#ifndef RUBY_NODE_H
+#define RUBY_NODE_H 1
 /**********************************************************************
 
   node.h -
@@ -9,9 +11,6 @@
 
 **********************************************************************/
 
-#ifndef RUBY_NODE_H
-#define RUBY_NODE_H 1
-
 #if defined(__cplusplus)
 extern "C" {
 #if 0
@@ -122,9 +121,9 @@ enum node_type {
     NODE_DSYM,
     NODE_ATTRASGN,
     NODE_LAMBDA,
-    NODE_METHREF,
     NODE_ARYPTN,
     NODE_HSHPTN,
+    NODE_FNDPTN,
     NODE_LAST
 };
 
@@ -139,7 +138,7 @@ typedef struct rb_code_location_struct {
 } rb_code_location_t;
 
 static inline rb_code_location_t
-code_loc_gen(rb_code_location_t *loc1, rb_code_location_t *loc2)
+code_loc_gen(const rb_code_location_t *loc1, const rb_code_location_t *loc2)
 {
     rb_code_location_t loc;
     loc.beg_pos = loc1->beg_pos;
@@ -165,18 +164,18 @@ typedef struct RNode {
 	struct RNode *node;
 	ID id;
 	long state;
-	struct rb_global_entry *entry;
 	struct rb_args_info *args;
-        struct rb_ary_pattern_info *apinfo;
+	struct rb_ary_pattern_info *apinfo;
+	struct rb_fnd_pattern_info *fpinfo;
 	VALUE value;
     } u3;
     rb_code_location_t nd_loc;
     int node_id;
 } NODE;
 
-#define RNODE(obj)  (R_CAST(RNode)(obj))
+#define RNODE(obj)  ((struct RNode *)(obj))
 
-/* FL     : 0..4: T_TYPES, 5: KEEP_WB, 6: PROMOTED, 7: FINALIZE, 8: TAINT, 9: UNTRUSTED, 10: EXIVAR, 11: FREEZE */
+/* FL     : 0..4: T_TYPES, 5: KEEP_WB, 6: PROMOTED, 7: FINALIZE, 8: UNUSED, 9: UNUSED, 10: EXIVAR, 11: FREEZE */
 /* NODE_FL: 0..4: T_TYPES, 5: KEEP_WB, 6: PROMOTED, 7: NODE_FL_NEWLINE,
  *          8..14: nd_type,
  *          15..: nd_line
@@ -188,6 +187,8 @@ typedef struct RNode {
 
 #define nd_type(n) ((int) (((n)->flags & NODE_TYPEMASK)>>NODE_TYPESHIFT))
 #define nd_set_type(n,t) \
+    rb_node_set_type(n, t)
+#define nd_init_type(n,t) \
     (n)->flags=(((n)->flags&~NODE_TYPEMASK)|((((unsigned long)(t))<<NODE_TYPESHIFT)&NODE_TYPEMASK))
 
 #define NODE_LSHIFT (NODE_TYPESHIFT+7)
@@ -228,7 +229,7 @@ typedef struct RNode {
 
 #define nd_stts  u1.node
 
-#define nd_entry u3.entry
+#define nd_entry u3.id
 #define nd_vid   u1.id
 #define nd_cflag u2.id
 #define nd_cval  u3.value
@@ -280,6 +281,8 @@ typedef struct RNode {
 
 #define nd_apinfo u3.apinfo
 
+#define nd_fpinfo u3.fpinfo
+
 #define NEW_NODE(t,a0,a1,a2,loc) rb_node_newnode((t),(VALUE)(a0),(VALUE)(a1),(VALUE)(a2),loc)
 #define NEW_NODE_WITH_LOCALS(t,a1,a2,loc) node_newnode_with_locals(p, (t),(VALUE)(a1),(VALUE)(a2),loc)
 
@@ -314,7 +317,7 @@ typedef struct RNode {
 #define NEW_ZLIST(loc) NEW_NODE(NODE_ZLIST,0,0,0,loc)
 #define NEW_HASH(a,loc)  NEW_NODE(NODE_HASH,a,0,0,loc)
 #define NEW_MASGN(l,r,loc)   NEW_NODE(NODE_MASGN,l,0,r,loc)
-#define NEW_GASGN(v,val,loc) NEW_NODE(NODE_GASGN,v,val,rb_global_entry(v),loc)
+#define NEW_GASGN(v,val,loc) NEW_NODE(NODE_GASGN,v,val,v,loc)
 #define NEW_LASGN(v,val,loc) NEW_NODE(NODE_LASGN,v,val,0,loc)
 #define NEW_DASGN(v,val,loc) NEW_NODE(NODE_DASGN,v,val,0,loc)
 #define NEW_DASGN_CURR(v,val,loc) NEW_NODE(NODE_DASGN_CURR,v,val,0,loc)
@@ -327,7 +330,7 @@ typedef struct RNode {
 #define NEW_OP_ASGN_OR(i,val,loc) NEW_NODE(NODE_OP_ASGN_OR,i,val,0,loc)
 #define NEW_OP_ASGN_AND(i,val,loc) NEW_NODE(NODE_OP_ASGN_AND,i,val,0,loc)
 #define NEW_OP_CDECL(v,op,val,loc) NEW_NODE(NODE_OP_CDECL,v,val,op,loc)
-#define NEW_GVAR(v,loc) NEW_NODE(NODE_GVAR,v,0,rb_global_entry(v),loc)
+#define NEW_GVAR(v,loc) NEW_NODE(NODE_GVAR,v,0,v,loc)
 #define NEW_LVAR(v,loc) NEW_NODE(NODE_LVAR,v,0,0,loc)
 #define NEW_DVAR(v,loc) NEW_NODE(NODE_DVAR,v,0,0,loc)
 #define NEW_IVAR(v,loc) NEW_NODE(NODE_IVAR,v,0,0,loc)
@@ -378,7 +381,6 @@ typedef struct RNode {
 #define NEW_PREEXE(b,loc) NEW_SCOPE(b,loc)
 #define NEW_POSTEXE(b,loc) NEW_NODE(NODE_POSTEXE,0,b,0,loc)
 #define NEW_ATTRASGN(r,m,a,loc) NEW_NODE(NODE_ATTRASGN,r,m,a,loc)
-#define NEW_METHREF(r,m,loc) NEW_NODE(NODE_METHREF,r,m,0,loc)
 
 #define NODE_SPECIAL_REQUIRED_KEYWORD ((NODE *)-1)
 #define NODE_REQUIRED_KEYWORD_P(node) ((node)->nd_value == NODE_SPECIAL_REQUIRED_KEYWORD)
@@ -396,7 +398,10 @@ typedef struct node_buffer_struct node_buffer_t;
 typedef struct rb_ast_body_struct {
     const NODE *root;
     VALUE compile_option;
-    int line_count;
+    VALUE script_lines;
+    // script_lines is either:
+    // - a Fixnum that represents the line count of the original source, or
+    // - an Array that contains the lines of the original source
 } rb_ast_body_t;
 typedef struct rb_ast_struct {
     VALUE flags;
@@ -406,6 +411,7 @@ typedef struct rb_ast_struct {
 rb_ast_t *rb_ast_new(void);
 void rb_ast_mark(rb_ast_t*);
 void rb_ast_update_references(rb_ast_t*);
+void rb_ast_add_local_table(rb_ast_t*, ID *buf);
 void rb_ast_dispose(rb_ast_t*);
 void rb_ast_free(rb_ast_t*);
 size_t rb_ast_memsize(const rb_ast_t*);
@@ -416,22 +422,15 @@ void rb_ast_delete_node(rb_ast_t*, NODE *n);
 VALUE rb_parser_new(void);
 VALUE rb_parser_end_seen_p(VALUE);
 VALUE rb_parser_encoding(VALUE);
-VALUE rb_parser_get_yydebug(VALUE);
 VALUE rb_parser_set_yydebug(VALUE, VALUE);
 VALUE rb_parser_dump_tree(const NODE *node, int comment);
 void rb_parser_set_options(VALUE, int, int, int, int);
 
-rb_ast_t *rb_parser_compile_cstr(VALUE, const char*, const char*, int, int);
 rb_ast_t *rb_parser_compile_string(VALUE, const char*, VALUE, int);
-rb_ast_t *rb_parser_compile_file(VALUE, const char*, VALUE, int);
 rb_ast_t *rb_parser_compile_string_path(VALUE vparser, VALUE fname, VALUE src, int line);
 rb_ast_t *rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE input, int line);
 rb_ast_t *rb_parser_compile_generic(VALUE vparser, VALUE (*lex_gets)(VALUE, int), VALUE fname, VALUE input, int line);
 
-rb_ast_t *rb_compile_cstr(const char*, const char*, int, int);
-rb_ast_t *rb_compile_string(const char*, VALUE, int);
-rb_ast_t *rb_compile_file(const char*, VALUE, int);
-
 void rb_node_init(NODE *n, enum node_type type, VALUE a0, VALUE a1, VALUE a2);
 const char *ruby_node_name(int node);
 
@@ -453,7 +452,9 @@ struct rb_args_info {
     NODE *kw_rest_arg;
 
     NODE *opt_args;
-    int no_kwarg;
+    unsigned int no_kwarg: 1;
+    unsigned int ruby2_keywords: 1;
+
     VALUE imemo;
 };
 
@@ -461,7 +462,12 @@ struct rb_ary_pattern_info {
     NODE *pre_args;
     NODE *rest_arg;
     NODE *post_args;
-    VALUE imemo;
+};
+
+struct rb_fnd_pattern_info {
+    NODE *pre_rest_arg;
+    NODE *args;
+    NODE *post_rest_arg;
 };
 
 struct parser_params;
@@ -470,9 +476,19 @@ void *rb_parser_realloc(struct parser_params *, void *, size_t);
 void *rb_parser_calloc(struct parser_params *, size_t, size_t);
 void rb_parser_free(struct parser_params *, void *);
 PRINTF_ARGS(void rb_parser_printf(struct parser_params *parser, const char *fmt, ...), 2, 3);
+void rb_ast_node_type_change(NODE *n, enum node_type type);
 
 RUBY_SYMBOL_EXPORT_END
 
+static inline VALUE
+rb_node_set_type(NODE *n, enum node_type t)
+{
+#if RUBY_DEBUG
+    rb_ast_node_type_change(n, t);
+#endif
+    return nd_init_type(n, t);
+}
+
 #if defined(__cplusplus)
 #if 0
 { /* satisfy cc-mode */

data/lib/debase/ruby_core_source/ruby-3.1.0-preview1/node_name.inc

@@ -0,0 +1,210 @@
+      case NODE_SCOPE:
+	return "NODE_SCOPE";
+      case NODE_BLOCK:
+	return "NODE_BLOCK";
+      case NODE_IF:
+	return "NODE_IF";
+      case NODE_UNLESS:
+	return "NODE_UNLESS";
+      case NODE_CASE:
+	return "NODE_CASE";
+      case NODE_CASE2:
+	return "NODE_CASE2";
+      case NODE_CASE3:
+	return "NODE_CASE3";
+      case NODE_WHEN:
+	return "NODE_WHEN";
+      case NODE_IN:
+	return "NODE_IN";
+      case NODE_WHILE:
+	return "NODE_WHILE";
+      case NODE_UNTIL:
+	return "NODE_UNTIL";
+      case NODE_ITER:
+	return "NODE_ITER";
+      case NODE_FOR:
+	return "NODE_FOR";
+      case NODE_FOR_MASGN:
+	return "NODE_FOR_MASGN";
+      case NODE_BREAK:
+	return "NODE_BREAK";
+      case NODE_NEXT:
+	return "NODE_NEXT";
+      case NODE_REDO:
+	return "NODE_REDO";
+      case NODE_RETRY:
+	return "NODE_RETRY";
+      case NODE_BEGIN:
+	return "NODE_BEGIN";
+      case NODE_RESCUE:
+	return "NODE_RESCUE";
+      case NODE_RESBODY:
+	return "NODE_RESBODY";
+      case NODE_ENSURE:
+	return "NODE_ENSURE";
+      case NODE_AND:
+	return "NODE_AND";
+      case NODE_OR:
+	return "NODE_OR";
+      case NODE_MASGN:
+	return "NODE_MASGN";
+      case NODE_LASGN:
+	return "NODE_LASGN";
+      case NODE_DASGN:
+	return "NODE_DASGN";
+      case NODE_DASGN_CURR:
+	return "NODE_DASGN_CURR";
+      case NODE_GASGN:
+	return "NODE_GASGN";
+      case NODE_IASGN:
+	return "NODE_IASGN";
+      case NODE_CDECL:
+	return "NODE_CDECL";
+      case NODE_CVASGN:
+	return "NODE_CVASGN";
+      case NODE_OP_ASGN1:
+	return "NODE_OP_ASGN1";
+      case NODE_OP_ASGN2:
+	return "NODE_OP_ASGN2";
+      case NODE_OP_ASGN_AND:
+	return "NODE_OP_ASGN_AND";
+      case NODE_OP_ASGN_OR:
+	return "NODE_OP_ASGN_OR";
+      case NODE_OP_CDECL:
+	return "NODE_OP_CDECL";
+      case NODE_CALL:
+	return "NODE_CALL";
+      case NODE_OPCALL:
+	return "NODE_OPCALL";
+      case NODE_FCALL:
+	return "NODE_FCALL";
+      case NODE_VCALL:
+	return "NODE_VCALL";
+      case NODE_QCALL:
+	return "NODE_QCALL";
+      case NODE_SUPER:
+	return "NODE_SUPER";
+      case NODE_ZSUPER:
+	return "NODE_ZSUPER";
+      case NODE_LIST:
+	return "NODE_LIST";
+      case NODE_ZLIST:
+	return "NODE_ZLIST";
+      case NODE_VALUES:
+	return "NODE_VALUES";
+      case NODE_HASH:
+	return "NODE_HASH";
+      case NODE_RETURN:
+	return "NODE_RETURN";
+      case NODE_YIELD:
+	return "NODE_YIELD";
+      case NODE_LVAR:
+	return "NODE_LVAR";
+      case NODE_DVAR:
+	return "NODE_DVAR";
+      case NODE_GVAR:
+	return "NODE_GVAR";
+      case NODE_IVAR:
+	return "NODE_IVAR";
+      case NODE_CONST:
+	return "NODE_CONST";
+      case NODE_CVAR:
+	return "NODE_CVAR";
+      case NODE_NTH_REF:
+	return "NODE_NTH_REF";
+      case NODE_BACK_REF:
+	return "NODE_BACK_REF";
+      case NODE_MATCH:
+	return "NODE_MATCH";
+      case NODE_MATCH2:
+	return "NODE_MATCH2";
+      case NODE_MATCH3:
+	return "NODE_MATCH3";
+      case NODE_LIT:
+	return "NODE_LIT";
+      case NODE_STR:
+	return "NODE_STR";
+      case NODE_DSTR:
+	return "NODE_DSTR";
+      case NODE_XSTR:
+	return "NODE_XSTR";
+      case NODE_DXSTR:
+	return "NODE_DXSTR";
+      case NODE_EVSTR:
+	return "NODE_EVSTR";
+      case NODE_DREGX:
+	return "NODE_DREGX";
+      case NODE_ONCE:
+	return "NODE_ONCE";
+      case NODE_ARGS:
+	return "NODE_ARGS";
+      case NODE_ARGS_AUX:
+	return "NODE_ARGS_AUX";
+      case NODE_OPT_ARG:
+	return "NODE_OPT_ARG";
+      case NODE_KW_ARG:
+	return "NODE_KW_ARG";
+      case NODE_POSTARG:
+	return "NODE_POSTARG";
+      case NODE_ARGSCAT:
+	return "NODE_ARGSCAT";
+      case NODE_ARGSPUSH:
+	return "NODE_ARGSPUSH";
+      case NODE_SPLAT:
+	return "NODE_SPLAT";
+      case NODE_BLOCK_PASS:
+	return "NODE_BLOCK_PASS";
+      case NODE_DEFN:
+	return "NODE_DEFN";
+      case NODE_DEFS:
+	return "NODE_DEFS";
+      case NODE_ALIAS:
+	return "NODE_ALIAS";
+      case NODE_VALIAS:
+	return "NODE_VALIAS";
+      case NODE_UNDEF:
+	return "NODE_UNDEF";
+      case NODE_CLASS:
+	return "NODE_CLASS";
+      case NODE_MODULE:
+	return "NODE_MODULE";
+      case NODE_SCLASS:
+	return "NODE_SCLASS";
+      case NODE_COLON2:
+	return "NODE_COLON2";
+      case NODE_COLON3:
+	return "NODE_COLON3";
+      case NODE_DOT2:
+	return "NODE_DOT2";
+      case NODE_DOT3:
+	return "NODE_DOT3";
+      case NODE_FLIP2:
+	return "NODE_FLIP2";
+      case NODE_FLIP3:
+	return "NODE_FLIP3";
+      case NODE_SELF:
+	return "NODE_SELF";
+      case NODE_NIL:
+	return "NODE_NIL";
+      case NODE_TRUE:
+	return "NODE_TRUE";
+      case NODE_FALSE:
+	return "NODE_FALSE";
+      case NODE_ERRINFO:
+	return "NODE_ERRINFO";
+      case NODE_DEFINED:
+	return "NODE_DEFINED";
+      case NODE_POSTEXE:
+	return "NODE_POSTEXE";
+      case NODE_DSYM:
+	return "NODE_DSYM";
+      case NODE_ATTRASGN:
+	return "NODE_ATTRASGN";
+      case NODE_LAMBDA:
+	return "NODE_LAMBDA";
+      case NODE_ARYPTN:
+	return "NODE_ARYPTN";
+      case NODE_HSHPTN:
+	return "NODE_HSHPTN";
+      case NODE_FNDPTN:
+	return "NODE_FNDPTN";

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview3 → ruby-3.1.0-preview1}/opt_sc.inc

@@ -73,7 +73,6 @@ static const VALUE sc_insn_info[][SC_STATE_SIZE] = {
     NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC,
     NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC,
     NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC,
-    NO_SC, NO_SC, NO_SC, NO_SC, NO_SC, NO_SC,
 #undef NO_SC
 };
 
@@ -103,7 +102,6 @@ static const VALUE sc_insn_next[] = {
     SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX,
     SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX,
     SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX,
-    SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX, SCS_XX,
 };
 
 ASSERT_VM_INSTRUCTION_SIZE(sc_insn_next);

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview3 → ruby-3.1.0-preview1}/optinsn.inc

@@ -109,19 +109,19 @@ rb_insn_unified_local_var_level(VALUE insn)
     /* optimize rule */
     switch (insn) {
       default:
-   return -1; /* do nothing */;
+	return -1; /* do nothing */;
       case BIN(getlocal_WC_0):
-   return 0;
+	return 0;
       case BIN(getlocal_WC_1):
-   return 1;
+	return 1;
       case BIN(setlocal_WC_0):
-   return 0;
+	return 0;
       case BIN(setlocal_WC_1):
-   return 1;
+	return 1;
       case BIN(putobject_INT2FIX_0_):
-   return INT2FIX(0);
+	return INT2FIX(0);
       case BIN(putobject_INT2FIX_1_):
-   return INT2FIX(1);
+	return INT2FIX(1);
     }
 #endif
     return -1;

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview3 → ruby-3.1.0-preview1}/optunifs.inc

@@ -38,6 +38,6 @@
 
 /* Let .bss section automatically initialize this variable */
 /* cf. Section 6.7.8 of ISO/IEC 9899:1999 */
-static const int *const *const unified_insns_data[206];
+static const int *const *const unified_insns_data[200];
 
 ASSERT_VM_INSTRUCTION_SIZE(unified_insns_data);

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.1.0-preview1}/parse.h

@@ -1,8 +1,9 @@
-/* A Bison parser, made by GNU Bison 3.0.4.  */
+/* A Bison parser, made by GNU Bison 3.5.1.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
+   Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -30,6 +31,9 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
+
 #ifndef YY_YY_Y_TAB_H_INCLUDED
 # define YY_YY_Y_TAB_H_INCLUDED
 /* Debug traces.  */
@@ -135,7 +139,6 @@ extern int yydebug;
     tRSHFT = 137,
     tANDDOT = 150,
     tCOLON2 = 147,
-    tMETHREF = 151,
     tCOLON3 = 324,
     tOP_ASGN = 325,
     tASSOC = 326,
@@ -171,7 +174,6 @@ extern int yydebug;
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-
 union YYSTYPE
 {
 
@@ -179,11 +181,13 @@ union YYSTYPE
     NODE *node;
     ID id;
     int num;
+    st_table *tbl;
     const struct vtable *vars;
     struct rb_strterm_struct *strterm;
+    struct lex_context ctxt;
 
-};
 
+};
 typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview3 → ruby-3.1.0-preview1}/probes_helper.h

@@ -12,18 +12,20 @@ struct ruby_dtrace_method_hook_args {
     volatile VALUE name;
 };
 
+MJIT_SYMBOL_EXPORT_BEGIN
 NOINLINE(int rb_dtrace_setup(rb_execution_context_t *, VALUE, ID, struct ruby_dtrace_method_hook_args *));
+MJIT_SYMBOL_EXPORT_END
 
 #define RUBY_DTRACE_METHOD_HOOK(name, ec, klazz, id) \
 do { \
     if (UNLIKELY(RUBY_DTRACE_##name##_ENABLED())) { \
-   struct ruby_dtrace_method_hook_args args; \
-   if (rb_dtrace_setup(ec, klazz, id, &args)) { \
-       RUBY_DTRACE_##name(args.classname, \
-                  args.methodname, \
-                  args.filename, \
-                  args.line_no); \
-   } \
+	struct ruby_dtrace_method_hook_args args; \
+	if (rb_dtrace_setup(ec, klazz, id, &args)) { \
+	    RUBY_DTRACE_##name(args.classname, \
+			       args.methodname, \
+			       args.filename, \
+			       args.line_no); \
+	} \
     } \
 } while (0)