debase-ruby_core_source 0.10.18 → 3.2.1

data/lib/debase/ruby_core_source/ruby-3.2.0-preview2/internal/struct.h

@@ -1,153 +0,0 @@
-#ifndef INTERNAL_STRUCT_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_STRUCT_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for Struct.
- */
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "internal/gc.h"        /* for RB_OBJ_WRITE */
-#include "ruby/ruby.h"          /* for struct RBasic */
-
-enum {
-    RSTRUCT_EMBED_LEN_MAX = RVALUE_EMBED_LEN_MAX,
-    RSTRUCT_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER1),
-    RSTRUCT_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+1),
-    RSTRUCT_TRANSIENT_FLAG = FL_USER3,
-};
-
-struct RStruct {
-    struct RBasic basic;
-    union {
-        struct {
-            long len;
-            const VALUE *ptr;
-        } heap;
-        const VALUE ary[RSTRUCT_EMBED_LEN_MAX];
-    } as;
-};
-
-#define RSTRUCT(obj) ((struct RStruct *)(obj))
-
-#ifdef RSTRUCT_LEN
-# undef RSTRUCT_LEN
-#endif
-
-#ifdef RSTRUCT_PTR
-# undef RSTRUCT_PTR
-#endif
-
-#ifdef RSTRUCT_SET
-# undef RSTRUCT_SET
-#endif
-
-#ifdef RSTRUCT_GET
-# undef RSTRUCT_GET
-#endif
-
-#define RSTRUCT_LEN internal_RSTRUCT_LEN
-#define RSTRUCT_SET internal_RSTRUCT_SET
-#define RSTRUCT_GET internal_RSTRUCT_GET
-
-/* struct.c */
-VALUE rb_struct_init_copy(VALUE copy, VALUE s);
-VALUE rb_struct_lookup(VALUE s, VALUE idx);
-VALUE rb_struct_s_keyword_init(VALUE klass);
-static inline const VALUE *rb_struct_const_heap_ptr(VALUE st);
-static inline bool RSTRUCT_TRANSIENT_P(VALUE st);
-static inline void RSTRUCT_TRANSIENT_SET(VALUE st);
-static inline void RSTRUCT_TRANSIENT_UNSET(VALUE st);
-static inline long RSTRUCT_EMBED_LEN(VALUE st);
-static inline long RSTRUCT_LEN(VALUE st);
-static inline int RSTRUCT_LENINT(VALUE st);
-static inline const VALUE *RSTRUCT_CONST_PTR(VALUE st);
-static inline void RSTRUCT_SET(VALUE st, long k, VALUE v);
-static inline VALUE RSTRUCT_GET(VALUE st, long k);
-
-static inline bool
-RSTRUCT_TRANSIENT_P(VALUE st)
-{
-#if USE_TRANSIENT_HEAP
-    return FL_TEST_RAW(st, RSTRUCT_TRANSIENT_FLAG);
-#else
-    return false;
-#endif
-}
-
-static inline void
-RSTRUCT_TRANSIENT_SET(VALUE st)
-{
-#if USE_TRANSIENT_HEAP
-    FL_SET_RAW(st, RSTRUCT_TRANSIENT_FLAG);
-#endif
-}
-
-static inline void
-RSTRUCT_TRANSIENT_UNSET(VALUE st)
-{
-#if USE_TRANSIENT_HEAP
-    FL_UNSET_RAW(st, RSTRUCT_TRANSIENT_FLAG);
-#endif
-}
-
-static inline long
-RSTRUCT_EMBED_LEN(VALUE st)
-{
-    long ret = FL_TEST_RAW(st, RSTRUCT_EMBED_LEN_MASK);
-    ret >>= RSTRUCT_EMBED_LEN_SHIFT;
-    return ret;
-}
-
-static inline long
-RSTRUCT_LEN(VALUE st)
-{
-    if (FL_TEST_RAW(st, RSTRUCT_EMBED_LEN_MASK)) {
-        return RSTRUCT_EMBED_LEN(st);
-    }
-    else {
-        return RSTRUCT(st)->as.heap.len;
-    }
-}
-
-static inline int
-RSTRUCT_LENINT(VALUE st)
-{
-    return rb_long2int(RSTRUCT_LEN(st));
-}
-
-static inline const VALUE *
-RSTRUCT_CONST_PTR(VALUE st)
-{
-    const struct RStruct *p = RSTRUCT(st);
-
-    if (FL_TEST_RAW(st, RSTRUCT_EMBED_LEN_MASK)) {
-        return p->as.ary;
-    }
-    else {
-        return p->as.heap.ptr;
-    }
-}
-
-static inline void
-RSTRUCT_SET(VALUE st, long k,  VALUE v)
-{
-    RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[k], v);
-}
-
-static inline VALUE
-RSTRUCT_GET(VALUE st, long k)
-{
-    return RSTRUCT_CONST_PTR(st)[k];
-}
-
-static inline const VALUE *
-rb_struct_const_heap_ptr(VALUE st)
-{
-    /* TODO: check embed on debug mode */
-    return RSTRUCT(st)->as.heap.ptr;
-}
-
-#endif /* INTERNAL_STRUCT_H */

data/lib/debase/ruby_core_source/ruby-3.2.0-preview2/mjit_compiler.h

@@ -1,58 +0,0 @@
-// This file is parsed by tool/mjit/generate.rb for MJIT's C/Ruby interop.
-#ifndef MJIT_COMPILER_H
-#define MJIT_COMPILER_H
-
-#include "ruby/internal/config.h"
-#include "vm_core.h"
-#include "vm_callinfo.h"
-#include "builtin.h"
-#include "mjit.h"
-#include "mjit_unit.h"
-
-// Macros to check if a position is already compiled using compile_status.stack_size_for_pos
-#define NOT_COMPILED_STACK_SIZE -1
-#define ALREADY_COMPILED_P(status, pos) (status->stack_size_for_pos[pos] != NOT_COMPILED_STACK_SIZE)
-
-// Storage to keep data which is consistent in each conditional branch.
-// This is created and used for one `compile_insns` call and its values
-// should be copied for extra `compile_insns` call.
-struct compile_branch {
-    unsigned int stack_size; // this simulates sp (stack pointer) of YARV
-    bool finish_p; // if true, compilation in this branch should stop and let another branch to be compiled
-};
-
-// For propagating information needed for lazily pushing a frame.
-struct inlined_call_context {
-    int orig_argc; // ci->orig_argc
-    VALUE me; // vm_cc_cme(cc)
-    int param_size; // def_iseq_ptr(vm_cc_cme(cc)->def)->body->param.size
-    int local_size; // def_iseq_ptr(vm_cc_cme(cc)->def)->body->local_table_size
-};
-
-// Storage to keep compiler's status.  This should have information
-// which is global during one `mjit_compile` call.  Ones conditional
-// in each branch should be stored in `compile_branch`.
-struct compile_status {
-    bool success; // has true if compilation has had no issue
-    int *stack_size_for_pos; // stack_size_for_pos[pos] has stack size for the position (otherwise -1)
-    // If true, JIT-ed code will use local variables to store pushed values instead of
-    // using VM's stack and moving stack pointer.
-    bool local_stack_p;
-    // Safely-accessible ivar cache entries copied from main thread.
-    union iseq_inline_storage_entry *is_entries;
-    // Index of call cache entries captured to compiled_iseq to be marked on GC
-    int cc_entries_index;
-    // A pointer to root (i.e. not inlined) iseq being compiled.
-    const struct rb_iseq_constant_body *compiled_iseq;
-    int compiled_id; // Just a copy of compiled_iseq->jit_unit->id
-    // Mutated optimization levels
-    struct rb_mjit_compile_info *compile_info;
-    bool merge_ivar_guards_p; // If true, merge guards of ivar accesses
-    rb_serial_t ivar_serial; // ic_serial of IVC in is_entries (used only when merge_ivar_guards_p)
-    size_t max_ivar_index; // Max IVC index in is_entries (used only when merge_ivar_guards_p)
-    // If `inlined_iseqs[pos]` is not NULL, `mjit_compile_body` tries to inline ISeq there.
-    const struct rb_iseq_constant_body **inlined_iseqs;
-    struct inlined_call_context inline_context;
-};
-
-#endif /* MJIT_COMPILER_H */

data/lib/debase/ruby_core_source/ruby-3.2.0-preview2/mjit_unit.h

@@ -1,29 +0,0 @@
-#ifndef MJIT_UNIT_H
-#define MJIT_UNIT_H
-
-#include "ccan/list/list.h"
-
-// The unit structure that holds metadata of ISeq for MJIT.
-struct rb_mjit_unit {
-    struct ccan_list_node unode;
-    // Unique order number of unit.
-    int id;
-    // Dlopen handle of the loaded object file.
-    void *handle;
-    rb_iseq_t *iseq;
-#if defined(_WIN32)
-    // DLL cannot be removed while loaded on Windows. If this is set, it'll be lazily deleted.
-    char *so_file;
-#endif
-    // Only used by unload_units. Flag to check this unit is currently on stack or not.
-    bool used_code_p;
-    // True if it's a unit for JIT compaction
-    bool compact_p;
-    // mjit_compile's optimization switches
-    struct rb_mjit_compile_info compile_info;
-    // captured CC values, they should be marked with iseq.
-    const struct rb_callcache **cc_entries;
-    unsigned int cc_entries_size; // ISEQ_BODY(iseq)->ci_size + ones of inlined iseqs
-};
-
-#endif /* MJIT_UNIT_H */

data/lib/debase/ruby_core_source/ruby-3.2.0-preview2/node_name.inc

@@ -1,208 +0,0 @@
-      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_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-3.2.0-preview2/parse.h

@@ -1,214 +0,0 @@
-/* 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, 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
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   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.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-/* Token type.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-  enum yytokentype
-  {
-    END_OF_INPUT = 0,
-    keyword_class = 258,
-    keyword_module = 259,
-    keyword_def = 260,
-    keyword_undef = 261,
-    keyword_begin = 262,
-    keyword_rescue = 263,
-    keyword_ensure = 264,
-    keyword_end = 265,
-    keyword_if = 266,
-    keyword_unless = 267,
-    keyword_then = 268,
-    keyword_elsif = 269,
-    keyword_else = 270,
-    keyword_case = 271,
-    keyword_when = 272,
-    keyword_while = 273,
-    keyword_until = 274,
-    keyword_for = 275,
-    keyword_break = 276,
-    keyword_next = 277,
-    keyword_redo = 278,
-    keyword_retry = 279,
-    keyword_in = 280,
-    keyword_do = 281,
-    keyword_do_cond = 282,
-    keyword_do_block = 283,
-    keyword_do_LAMBDA = 284,
-    keyword_return = 285,
-    keyword_yield = 286,
-    keyword_super = 287,
-    keyword_self = 288,
-    keyword_nil = 289,
-    keyword_true = 290,
-    keyword_false = 291,
-    keyword_and = 292,
-    keyword_or = 293,
-    keyword_not = 294,
-    modifier_if = 295,
-    modifier_unless = 296,
-    modifier_while = 297,
-    modifier_until = 298,
-    modifier_rescue = 299,
-    keyword_alias = 300,
-    keyword_defined = 301,
-    keyword_BEGIN = 302,
-    keyword_END = 303,
-    keyword__LINE__ = 304,
-    keyword__FILE__ = 305,
-    keyword__ENCODING__ = 306,
-    tIDENTIFIER = 307,
-    tFID = 308,
-    tGVAR = 309,
-    tIVAR = 310,
-    tCONSTANT = 311,
-    tCVAR = 312,
-    tLABEL = 313,
-    tINTEGER = 314,
-    tFLOAT = 315,
-    tRATIONAL = 316,
-    tIMAGINARY = 317,
-    tCHAR = 318,
-    tNTH_REF = 319,
-    tBACK_REF = 320,
-    tSTRING_CONTENT = 321,
-    tREGEXP_END = 322,
-    tSP = 323,
-    tUPLUS = 132,
-    tUMINUS = 133,
-    tPOW = 134,
-    tCMP = 135,
-    tEQ = 140,
-    tEQQ = 141,
-    tNEQ = 142,
-    tGEQ = 139,
-    tLEQ = 138,
-    tANDOP = 148,
-    tOROP = 149,
-    tMATCH = 143,
-    tNMATCH = 144,
-    tDOT2 = 128,
-    tDOT3 = 129,
-    tBDOT2 = 130,
-    tBDOT3 = 131,
-    tAREF = 145,
-    tASET = 146,
-    tLSHFT = 136,
-    tRSHFT = 137,
-    tANDDOT = 150,
-    tCOLON2 = 147,
-    tCOLON3 = 324,
-    tOP_ASGN = 325,
-    tASSOC = 326,
-    tLPAREN = 327,
-    tLPAREN_ARG = 328,
-    tRPAREN = 329,
-    tLBRACK = 330,
-    tLBRACE = 331,
-    tLBRACE_ARG = 332,
-    tSTAR = 333,
-    tDSTAR = 334,
-    tAMPER = 335,
-    tLAMBDA = 336,
-    tSYMBEG = 337,
-    tSTRING_BEG = 338,
-    tXSTRING_BEG = 339,
-    tREGEXP_BEG = 340,
-    tWORDS_BEG = 341,
-    tQWORDS_BEG = 342,
-    tSYMBOLS_BEG = 343,
-    tQSYMBOLS_BEG = 344,
-    tSTRING_END = 345,
-    tSTRING_DEND = 346,
-    tSTRING_DBEG = 347,
-    tSTRING_DVAR = 348,
-    tLAMBEG = 349,
-    tLABEL_END = 350,
-    tLOWEST = 351,
-    tUMINUS_NUM = 352,
-    tLAST_TOKEN = 353
-  };
-#endif
-
-/* Value type.  */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-union YYSTYPE
-{
-
-    VALUE val;
-    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
-#endif
-
-/* Location type.  */
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE YYLTYPE;
-struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-};
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-
-int yyparse (struct parser_params *p);
-
-#endif /* !YY_YY_Y_TAB_H_INCLUDED  */