symbol.c

   1 /**********************************************************************
   2
   3   symbol.h -
   4
   5   $Author$
   6   created at: Tue Jul  8 15:49:54 JST 2014
   7
   8   Copyright (C) 2014 Yukihiro Matsumoto
   9
  10 **********************************************************************/
  11
  12 #include "internal.h"
  13 #include "internal/error.h"
  14 #include "internal/gc.h"
  15 #include "internal/hash.h"
  16 #include "internal/object.h"
  17 #include "internal/symbol.h"
  18 #include "internal/vm.h"
  19 #include "probes.h"
  20 #include "ruby/encoding.h"
  21 #include "ruby/st.h"
  22 #include "symbol.h"
  23 #include "vm_sync.h"
  24 #include "builtin.h"
  25
  26 #if defined(USE_SYMBOL_GC) && !(USE_SYMBOL_GC+0)
  27 # undef USE_SYMBOL_GC
  28 # define USE_SYMBOL_GC 0
  29 #else
  30 # undef USE_SYMBOL_GC
  31 # define USE_SYMBOL_GC 1
  32 #endif
  33 #if defined(SYMBOL_DEBUG) && (SYMBOL_DEBUG+0)
  34 # undef SYMBOL_DEBUG
  35 # define SYMBOL_DEBUG 1
  36 #else
  37 # undef SYMBOL_DEBUG
  38 # define SYMBOL_DEBUG 0
  39 #endif
  40 #ifndef CHECK_ID_SERIAL
  41 # define CHECK_ID_SERIAL SYMBOL_DEBUG
  42 #endif
  43
  44 #define SYMBOL_PINNED_P(sym) (RSYMBOL(sym)->id&~ID_SCOPE_MASK)
  45
  46 #define STATIC_SYM2ID(sym) RSHIFT((VALUE)(sym), RUBY_SPECIAL_SHIFT)
  47
  48 static ID register_static_symid(ID, const char *, long, rb_encoding *);
  49 static ID register_static_symid_str(ID, VALUE);
  50 #define REGISTER_SYMID(id, name) register_static_symid((id), (name), strlen(name), enc)
  51 #include "id.c"
  52
  53 #define is_identchar(p,e,enc) (ISALNUM((unsigned char)*(p)) || (*(p)) == '_' || !ISASCII(*(p)))
  54
  55 #define op_tbl_count numberof(op_tbl)
  56 STATIC_ASSERT(op_tbl_name_size, sizeof(op_tbl[0].name) == 3);
  57 #define op_tbl_len(i) (!op_tbl[i].name[1] ? 1 : !op_tbl[i].name[2] ? 2 : 3)
  58
  59 static void
  60 Init_op_tbl(void)
  61 {
  62     int i;
  63     rb_encoding *const enc = rb_usascii_encoding();
  64
  65     for (i = '!'; i <= '~'; ++i) {
  66         if (!ISALNUM(i) && i != '_') {
  67             char c = (char)i;
  68             register_static_symid(i, &c, 1, enc);
  69         }
  70     }
  71     for (i = 0; i < op_tbl_count; ++i) {
  72         register_static_symid(op_tbl[i].token, op_tbl[i].name, op_tbl_len(i), enc);
  73     }
  74 }
  75
  76 static const int ID_ENTRY_UNIT = 512;
  77
  78 enum id_entry_type {
  79     ID_ENTRY_STR,
  80     ID_ENTRY_SYM,
  81     ID_ENTRY_SIZE
  82 };
  83
  84 rb_symbols_t ruby_global_symbols = {tNEXT_ID-1};
  85
  86 static const struct st_hash_type symhash = {
  87     rb_str_hash_cmp,
  88     rb_str_hash,
  89 };
  90
  91 void
  92 Init_sym(void)
  93 {
  94     rb_symbols_t *symbols = &ruby_global_symbols;
  95
  96     VALUE dsym_fstrs = rb_ident_hash_new();
  97     symbols->dsymbol_fstr_hash = dsym_fstrs;
  98     rb_vm_register_global_object(dsym_fstrs);
  99     rb_obj_hide(dsym_fstrs);
 100
 101     symbols->str_sym = st_init_table_with_size(&symhash, 1000);
 102     symbols->ids = rb_ary_hidden_new(0);
 103     rb_vm_register_global_object(symbols->ids);
 104
 105     Init_op_tbl();
 106     Init_id();
 107 }
 108
 109 WARN_UNUSED_RESULT(static VALUE dsymbol_alloc(rb_symbols_t *symbols, const VALUE klass, const VALUE str, rb_encoding *const enc, const ID type));
 110 WARN_UNUSED_RESULT(static VALUE dsymbol_check(rb_symbols_t *symbols, const VALUE sym));
 111 WARN_UNUSED_RESULT(static ID lookup_str_id(VALUE str));
 112 WARN_UNUSED_RESULT(static VALUE lookup_str_sym_with_lock(rb_symbols_t *symbols, const VALUE str));
 113 WARN_UNUSED_RESULT(static VALUE lookup_str_sym(const VALUE str));
 114 WARN_UNUSED_RESULT(static VALUE lookup_id_str(ID id));
 115 WARN_UNUSED_RESULT(static ID intern_str(VALUE str, int mutable));
 116
 117 #define GLOBAL_SYMBOLS_ENTER(symbols) rb_symbols_t *symbols = &ruby_global_symbols; RB_VM_LOCK_ENTER()
 118 #define GLOBAL_SYMBOLS_LEAVE()        RB_VM_LOCK_LEAVE()
 119
 120 ID
 121 rb_id_attrset(ID id)
 122 {
 123     VALUE str, sym;
 124     int scope;
 125
 126     if (!is_notop_id(id)) {
 127         switch (id) {
 128           case tAREF: case tASET:
 129             return tASET;       /* only exception */
 130         }
 131         rb_name_error(id, "cannot make operator ID :%"PRIsVALUE" attrset",
 132                       rb_id2str(id));
 133     }
 134     else {
 135         scope = id_type(id);
 136         switch (scope) {
 137           case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
 138           case ID_CONST: case ID_CLASS: case ID_JUNK:
 139             break;
 140           case ID_ATTRSET:
 141             return id;
 142           default:
 143             {
 144                 if ((str = lookup_id_str(id)) != 0) {
 145                     rb_name_error(id, "cannot make unknown type ID %d:%"PRIsVALUE" attrset",
 146                                   scope, str);
 147                 }
 148                 else {
 149                     rb_name_error_str(Qnil, "cannot make unknown type anonymous ID %d:%"PRIxVALUE" attrset",
 150                                       scope, (VALUE)id);
 151                 }
 152             }
 153         }
 154     }
 155
 156     /* make new symbol and ID */
 157     if (!(str = lookup_id_str(id))) {
 158         static const char id_types[][8] = {
 159             "local",
 160             "instance",
 161             "invalid",
 162             "global",
 163             "attrset",
 164             "const",
 165             "class",
 166             "junk",
 167         };
 168         rb_name_error(id, "cannot make anonymous %.*s ID %"PRIxVALUE" attrset",
 169                       (int)sizeof(id_types[0]), id_types[scope], (VALUE)id);
 170     }
 171     str = rb_str_dup(str);
 172     rb_str_cat(str, "=", 1);
 173     sym = lookup_str_sym(str);
 174     id = sym ? rb_sym2id(sym) : intern_str(str, 1);
 175     return id;
 176 }
 177
 178 static int
 179 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
 180 {
 181     int mb = 0;
 182
 183     if (m >= e) return 0;
 184     if (is_global_name_punct(*m)) {
 185         ++m;
 186     }
 187     else if (*m == '-') {
 188         if (++m >= e) return 0;
 189         if (is_identchar(m, e, enc)) {
 190             if (!ISASCII(*m)) mb = 1;
 191             m += rb_enc_mbclen(m, e, enc);
 192         }
 193     }
 194     else {
 195         if (!ISDIGIT(*m)) return 0;
 196         do {
 197             if (!ISASCII(*m)) mb = 1;
 198             ++m;
 199         } while (m < e && ISDIGIT(*m));
 200     }
 201     return m == e ? mb + 1 : 0;
 202 }
 203
 204 int
 205 rb_symname_p(const char *name)
 206 {
 207     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
 208 }
 209
 210 int
 211 rb_enc_symname_p(const char *name, rb_encoding *enc)
 212 {
 213     return rb_enc_symname2_p(name, strlen(name), enc);
 214 }
 215
 216 static int
 217 rb_sym_constant_char_p(const char *name, long nlen, rb_encoding *enc)
 218 {
 219     int c, len;
 220     const char *end = name + nlen;
 221
 222     if (nlen < 1) return FALSE;
 223     if (ISASCII(*name)) return ISUPPER(*name);
 224     c = rb_enc_precise_mbclen(name, end, enc);
 225     if (!MBCLEN_CHARFOUND_P(c)) return FALSE;
 226     len = MBCLEN_CHARFOUND_LEN(c);
 227     c = rb_enc_mbc_to_codepoint(name, end, enc);
 228     if (rb_enc_isupper(c, enc)) return TRUE;
 229     if (rb_enc_islower(c, enc)) return FALSE;
 230     if (ONIGENC_IS_UNICODE(enc)) {
 231         static int ctype_titlecase = 0;
 232         if (!ctype_titlecase) {
 233             static const UChar cname[] = "titlecaseletter";
 234             static const UChar *const end = cname + sizeof(cname) - 1;
 235             ctype_titlecase = ONIGENC_PROPERTY_NAME_TO_CTYPE(enc, cname, end);
 236         }
 237         if (rb_enc_isctype(c, ctype_titlecase, enc)) return TRUE;
 238     }
 239     else {
 240         /* fallback to case-folding */
 241         OnigUChar fold[ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM];
 242         const OnigUChar *beg = (const OnigUChar *)name;
 243         int r = enc->mbc_case_fold(ONIGENC_CASE_FOLD,
 244                                    &beg, (const OnigUChar *)end,
 245                                    fold, enc);
 246         if (r > 0 && (r != len || memcmp(fold, name, r)))
 247             return TRUE;
 248     }
 249     return FALSE;
 250 }
 251
 252 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
 253 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET))
 254
 255 struct enc_synmane_type_leading_chars_tag {
 256     const enum { invalid, stophere, needmore, } kind;
 257     const enum ruby_id_types type;
 258     const long nread;
 259 };
 260
 261 #define t struct enc_synmane_type_leading_chars_tag
 262
 263 static struct enc_synmane_type_leading_chars_tag
 264 enc_synmane_type_leading_chars(const char *name, long len, rb_encoding *enc, int allowed_attrset)
 265 {
 266     const char *m = name;
 267     const char *e = m + len;
 268
 269     if (! rb_enc_asciicompat(enc)) {
 270         return (t) { invalid, 0, 0, };
 271     }
 272     else if (! m) {
 273         return (t) { invalid, 0, 0, };
 274     }
 275     else if ( len <= 0 ) {
 276         return (t) { invalid, 0, 0, };
 277     }
 278     switch (*m) {
 279       case '\0':
 280         return (t) { invalid, 0, 0, };
 281
 282       case '$':
 283         if (is_special_global_name(++m, e, enc)) {
 284             return (t) { stophere, ID_GLOBAL, len, };
 285         }
 286         else {
 287             return (t) { needmore, ID_GLOBAL, 1, };
 288         }
 289
 290       case '@':
 291         switch (*++m) {
 292           default:  return (t) { needmore, ID_INSTANCE, 1, };
 293           case '@': return (t) { needmore, ID_CLASS,    2, };
 294         }
 295
 296       case '<':
 297         switch (*++m) {
 298           default:  return (t) { stophere, ID_JUNK, 1, };
 299           case '<': return (t) { stophere, ID_JUNK, 2, };
 300           case '=':
 301             switch (*++m) {
 302               default:  return (t) { stophere, ID_JUNK, 2, };
 303               case '>': return (t) { stophere, ID_JUNK, 3, };
 304             }
 305         }
 306
 307       case '>':
 308         switch (*++m) {
 309           default:            return (t) { stophere, ID_JUNK, 1, };
 310           case '>': case '=': return (t) { stophere, ID_JUNK, 2, };
 311         }
 312
 313       case '=':
 314         switch (*++m) {
 315           default:  return (t) { invalid,  0,       1, };
 316           case '~': return (t) { stophere, ID_JUNK, 2, };
 317           case '=':
 318             switch (*++m) {
 319               default:  return (t) { stophere, ID_JUNK, 2, };
 320               case '=': return (t) { stophere, ID_JUNK, 3, };
 321             }
 322         }
 323
 324       case '*':
 325         switch (*++m) {
 326           default:  return (t) { stophere, ID_JUNK, 1, };
 327           case '*': return (t) { stophere, ID_JUNK, 2, };
 328         }
 329
 330       case '+': case '-':
 331         switch (*++m) {
 332           default:  return (t) { stophere, ID_JUNK, 1, };
 333           case '@': return (t) { stophere, ID_JUNK, 2, };
 334         }
 335
 336       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
 337         return (t) { stophere, ID_JUNK, 1, };
 338
 339       case '[':
 340         switch (*++m) {
 341           default: return (t) { needmore, ID_JUNK, 0, };
 342           case ']':
 343             switch (*++m) {
 344               default:  return (t) { stophere, ID_JUNK, 2, };
 345               case '=': return (t) { stophere, ID_JUNK, 3, };
 346             }
 347         }
 348
 349       case '!':
 350         switch (*++m) {
 351           case '=': case '~': return (t) { stophere, ID_JUNK, 2, };
 352           default:
 353             if (allowed_attrset & (1U << ID_JUNK)) {
 354                 return (t) { needmore, ID_JUNK, 1, };
 355             }
 356             else {
 357                 return (t) { stophere, ID_JUNK, 1, };
 358             }
 359         }
 360
 361       default:
 362         if (rb_sym_constant_char_p(name, len, enc)) {
 363             return (t) { needmore, ID_CONST, 0, };
 364         }
 365         else {
 366             return (t) { needmore, ID_LOCAL, 0, };
 367         }
 368     }
 369 }
 370 #undef t
 371
 372 int
 373 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
 374 {
 375     const struct enc_synmane_type_leading_chars_tag f =
 376         enc_synmane_type_leading_chars(name, len, enc, allowed_attrset);
 377     const char *m = name + f.nread;
 378     const char *e = name + len;
 379     int type = (int)f.type;
 380
 381     switch (f.kind) {
 382       case invalid:  return -1;
 383       case stophere: break;
 384       case needmore:
 385
 386         if (m >= e || (*m != '_' && !ISALPHA(*m) && ISASCII(*m))) {
 387             if (len > 1 && *(e-1) == '=') {
 388                 type = rb_enc_symname_type(name, len-1, enc, allowed_attrset);
 389                 if (allowed_attrset & (1U << type)) return ID_ATTRSET;
 390             }
 391             return -1;
 392         }
 393         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
 394         if (m >= e) break;
 395         switch (*m) {
 396           case '!': case '?':
 397             if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
 398             type = ID_JUNK;
 399             ++m;
 400             if (m + 1 < e || *m != '=') break;
 401             /* fall through */
 402           case '=':
 403             if (!(allowed_attrset & (1U << type))) return -1;
 404             type = ID_ATTRSET;
 405             ++m;
 406             break;
 407         }
 408     }
 409
 410     return m == e ? type : -1;
 411 }
 412
 413 int
 414 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
 415 {
 416     return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
 417 }
 418
 419 static int
 420 rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
 421 {
 422     const char *ptr = StringValuePtr(name);
 423     long len = RSTRING_LEN(name);
 424     int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_attrset);
 425     RB_GC_GUARD(name);
 426     return type;
 427 }
 428
 429 static void
 430 set_id_entry(rb_symbols_t *symbols, rb_id_serial_t num, VALUE str, VALUE sym)
 431 {
 432     ASSERT_vm_locking();
 433     RUBY_ASSERT_BUILTIN_TYPE(str, T_STRING);
 434     RUBY_ASSERT_BUILTIN_TYPE(sym, T_SYMBOL);
 435
 436     size_t idx = num / ID_ENTRY_UNIT;
 437
 438     VALUE ary, ids = symbols->ids;
 439     if (idx >= (size_t)RARRAY_LEN(ids) || NIL_P(ary = rb_ary_entry(ids, (long)idx))) {
 440         ary = rb_ary_hidden_new(ID_ENTRY_UNIT * ID_ENTRY_SIZE);
 441         rb_ary_store(ids, (long)idx, ary);
 442     }
 443     idx = (num % ID_ENTRY_UNIT) * ID_ENTRY_SIZE;
 444     rb_ary_store(ary, (long)idx + ID_ENTRY_STR, str);
 445     rb_ary_store(ary, (long)idx + ID_ENTRY_SYM, sym);
 446 }
 447
 448 static VALUE
 449 get_id_serial_entry(rb_id_serial_t num, ID id, const enum id_entry_type t)
 450 {
 451     VALUE result = 0;
 452
 453     GLOBAL_SYMBOLS_ENTER(symbols);
 454     {
 455         if (num && num <= symbols->last_id) {
 456             size_t idx = num / ID_ENTRY_UNIT;
 457             VALUE ids = symbols->ids;
 458             VALUE ary;
 459             if (idx < (size_t)RARRAY_LEN(ids) && !NIL_P(ary = rb_ary_entry(ids, (long)idx))) {
 460                 long pos = (long)(num % ID_ENTRY_UNIT) * ID_ENTRY_SIZE;
 461                 result = rb_ary_entry(ary, pos + t);
 462
 463                 if (NIL_P(result)) {
 464                     result = 0;
 465                 }
 466                 else if (CHECK_ID_SERIAL) {
 467                     if (id) {
 468                         VALUE sym = result;
 469                         if (t != ID_ENTRY_SYM)
 470                           sym = rb_ary_entry(ary, pos + ID_ENTRY_SYM);
 471                         if (STATIC_SYM_P(sym)) {
 472                             if (STATIC_SYM2ID(sym) != id) result = 0;
 473                         }
 474                         else {
 475                             if (RSYMBOL(sym)->id != id) result = 0;
 476                         }
 477                     }
 478                 }
 479             }
 480         }
 481     }
 482     GLOBAL_SYMBOLS_LEAVE();
 483
 484     if (result) {
 485         switch (t) {
 486           case ID_ENTRY_STR:
 487             RUBY_ASSERT_BUILTIN_TYPE(result, T_STRING);
 488             break;
 489           case ID_ENTRY_SYM:
 490             RUBY_ASSERT_BUILTIN_TYPE(result, T_SYMBOL);
 491             break;
 492           default:
 493             break;
 494         }
 495     }
 496
 497     return result;
 498 }
 499
 500 static VALUE
 501 get_id_entry(ID id, const enum id_entry_type t)
 502 {
 503     return get_id_serial_entry(rb_id_to_serial(id), id, t);
 504 }
 505
 506 int
 507 rb_static_id_valid_p(ID id)
 508 {
 509     return STATIC_ID2SYM(id) == get_id_entry(id, ID_ENTRY_SYM);
 510 }
 511
 512 static inline ID
 513 rb_id_serial_to_id(rb_id_serial_t num)
 514 {
 515     if (is_notop_id((ID)num)) {
 516         VALUE sym = get_id_serial_entry(num, 0, ID_ENTRY_SYM);
 517         if (sym) return SYM2ID(sym);
 518         return ((ID)num << ID_SCOPE_SHIFT) | ID_INTERNAL | ID_STATIC_SYM;
 519     }
 520     else {
 521         return (ID)num;
 522     }
 523 }
 524
 525 static int
 526 register_sym_update_callback(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
 527 {
 528     if (existing) {
 529         rb_fatal("symbol :% "PRIsVALUE" is already registered with %"PRIxVALUE,
 530                  (VALUE)*key, (VALUE)*value);
 531     }
 532     *value = arg;
 533     return ST_CONTINUE;
 534 }
 535
 536 static void
 537 register_sym(rb_symbols_t *symbols, VALUE str, VALUE sym)
 538 {
 539     ASSERT_vm_locking();
 540
 541     if (SYMBOL_DEBUG) {
 542         st_update(symbols->str_sym, (st_data_t)str,
 543                   register_sym_update_callback, (st_data_t)sym);
 544     }
 545     else {
 546         st_add_direct(symbols->str_sym, (st_data_t)str, (st_data_t)sym);
 547     }
 548 }
 549
 550 void
 551 rb_free_static_symid_str(void)
 552 {
 553     GLOBAL_SYMBOLS_ENTER(symbols)
 554     {
 555         st_free_table(symbols->str_sym);
 556     }
 557     GLOBAL_SYMBOLS_LEAVE();
 558 }
 559
 560 static void
 561 unregister_sym(rb_symbols_t *symbols, VALUE str, VALUE sym)
 562 {
 563     ASSERT_vm_locking();
 564
 565     st_data_t str_data = (st_data_t)str;
 566     if (!st_delete(symbols->str_sym, &str_data, NULL)) {
 567         rb_bug("%p can't remove str from str_id (%s)", (void *)sym, RSTRING_PTR(str));
 568     }
 569 }
 570
 571 static ID
 572 register_static_symid(ID id, const char *name, long len, rb_encoding *enc)
 573 {
 574     VALUE str = rb_enc_str_new(name, len, enc);
 575     return register_static_symid_str(id, str);
 576 }
 577
 578 static ID
 579 register_static_symid_str(ID id, VALUE str)
 580 {
 581     rb_id_serial_t num = rb_id_to_serial(id);
 582     VALUE sym = STATIC_ID2SYM(id);
 583
 584     OBJ_FREEZE(str);
 585     str = rb_fstring(str);
 586
 587     RUBY_DTRACE_CREATE_HOOK(SYMBOL, RSTRING_PTR(str));
 588
 589     GLOBAL_SYMBOLS_ENTER(symbols)
 590     {
 591         register_sym(symbols, str, sym);
 592         set_id_entry(symbols, num, str, sym);
 593     }
 594     GLOBAL_SYMBOLS_LEAVE();
 595
 596     return id;
 597 }
 598
 599 static int
 600 sym_check_asciionly(VALUE str, bool fake_str)
 601 {
 602     if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
 603     switch (rb_enc_str_coderange(str)) {
 604       case ENC_CODERANGE_BROKEN:
 605         if (fake_str) {
 606             str = rb_enc_str_new(RSTRING_PTR(str), RSTRING_LEN(str), rb_enc_get(str));
 607         }
 608         rb_raise(rb_eEncodingError, "invalid symbol in encoding %s :%+"PRIsVALUE,
 609                  rb_enc_name(rb_enc_get(str)), str);
 610       case ENC_CODERANGE_7BIT:
 611         return TRUE;
 612     }
 613     return FALSE;
 614 }
 615
 616 #if 0
 617 /*
 618  * _str_ itself will be registered at the global symbol table.  _str_
 619  * can be modified before the registration, since the encoding will be
 620  * set to ASCII-8BIT if it is a special global name.
 621  */
 622
 623 static inline void
 624 must_be_dynamic_symbol(VALUE x)
 625 {
 626     if (UNLIKELY(!DYNAMIC_SYM_P(x))) {
 627         if (STATIC_SYM_P(x)) {
 628             VALUE str = lookup_id_str(RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT));
 629
 630             if (str) {
 631                 rb_bug("wrong argument: %s (inappropriate Symbol)", RSTRING_PTR(str));
 632             }
 633             else {
 634                 rb_bug("wrong argument: inappropriate Symbol (%p)", (void *)x);
 635             }
 636         }
 637         else {
 638             rb_bug("wrong argument type %s (expected Symbol)", rb_builtin_class_name(x));
 639         }
 640     }
 641 }
 642 #endif
 643
 644 static VALUE
 645 dsymbol_alloc(rb_symbols_t *symbols, const VALUE klass, const VALUE str, rb_encoding * const enc, const ID type)
 646 {
 647     ASSERT_vm_locking();
 648
 649     NEWOBJ_OF(obj, struct RSymbol, klass, T_SYMBOL | FL_WB_PROTECTED, sizeof(struct RSymbol), 0);
 650
 651     long hashval;
 652
 653     rb_enc_set_index((VALUE)obj, rb_enc_to_index(enc));
 654     OBJ_FREEZE((VALUE)obj);
 655     RB_OBJ_WRITE((VALUE)obj, &obj->fstr, str);
 656     obj->id = type;
 657
 658     /* we want hashval to be in Fixnum range [ruby-core:15713] r15672 */
 659     hashval = (long)rb_str_hash(str);
 660     obj->hashval = RSHIFT((long)hashval, 1);
 661     register_sym(symbols, str, (VALUE)obj);
 662     rb_hash_aset(symbols->dsymbol_fstr_hash, str, Qtrue);
 663     RUBY_DTRACE_CREATE_HOOK(SYMBOL, RSTRING_PTR(obj->fstr));
 664
 665     return (VALUE)obj;
 666 }
 667
 668 static inline VALUE
 669 dsymbol_check(rb_symbols_t *symbols, const VALUE sym)
 670 {
 671     ASSERT_vm_locking();
 672
 673     if (UNLIKELY(rb_objspace_garbage_object_p(sym))) {
 674         const VALUE fstr = RSYMBOL(sym)->fstr;
 675         const ID type = RSYMBOL(sym)->id & ID_SCOPE_MASK;
 676         RSYMBOL(sym)->fstr = 0;
 677         unregister_sym(symbols, fstr, sym);
 678         return dsymbol_alloc(symbols, rb_cSymbol, fstr, rb_enc_get(fstr), type);
 679     }
 680     else {
 681         return sym;
 682     }
 683 }
 684
 685 static ID
 686 lookup_str_id(VALUE str)
 687 {
 688     st_data_t sym_data;
 689     int found;
 690
 691     GLOBAL_SYMBOLS_ENTER(symbols);
 692     {
 693         found = st_lookup(symbols->str_sym, (st_data_t)str, &sym_data);
 694     }
 695     GLOBAL_SYMBOLS_LEAVE();
 696
 697     if (found) {
 698         const VALUE sym = (VALUE)sym_data;
 699
 700         if (STATIC_SYM_P(sym)) {
 701             return STATIC_SYM2ID(sym);
 702         }
 703         else if (DYNAMIC_SYM_P(sym)) {
 704             ID id = RSYMBOL(sym)->id;
 705             if (id & ~ID_SCOPE_MASK) return id;
 706         }
 707         else {
 708             rb_bug("non-symbol object %s:%"PRIxVALUE" for %"PRIsVALUE" in symbol table",
 709                    rb_builtin_class_name(sym), sym, str);
 710         }
 711     }
 712     return (ID)0;
 713 }
 714
 715 static VALUE
 716 lookup_str_sym_with_lock(rb_symbols_t *symbols, const VALUE str)
 717 {
 718     st_data_t sym_data;
 719     if (st_lookup(symbols->str_sym, (st_data_t)str, &sym_data)) {
 720         VALUE sym = (VALUE)sym_data;
 721         if (DYNAMIC_SYM_P(sym)) {
 722             sym = dsymbol_check(symbols, sym);
 723         }
 724         return sym;
 725     }
 726     else {
 727         return Qfalse;
 728     }
 729 }
 730
 731 static VALUE
 732 lookup_str_sym(const VALUE str)
 733 {
 734     VALUE sym;
 735
 736     GLOBAL_SYMBOLS_ENTER(symbols);
 737     {
 738         sym = lookup_str_sym_with_lock(symbols, str);
 739     }
 740     GLOBAL_SYMBOLS_LEAVE();
 741
 742     return sym;
 743 }
 744
 745 static VALUE
 746 lookup_id_str(ID id)
 747 {
 748     return get_id_entry(id, ID_ENTRY_STR);
 749 }
 750
 751 ID
 752 rb_intern3(const char *name, long len, rb_encoding *enc)
 753 {
 754     VALUE sym;
 755     struct RString fake_str;
 756     VALUE str = rb_setup_fake_str(&fake_str, name, len, enc);
 757     OBJ_FREEZE(str);
 758     sym = lookup_str_sym(str);
 759     if (sym) return rb_sym2id(sym);
 760     str = rb_enc_str_new(name, len, enc); /* make true string */
 761     return intern_str(str, 1);
 762 }
 763
 764 static ID
 765 next_id_base_with_lock(rb_symbols_t *symbols)
 766 {
 767     ID id;
 768     rb_id_serial_t next_serial = symbols->last_id + 1;
 769
 770     if (next_serial == 0) {
 771         id = (ID)-1;
 772     }
 773     else {
 774         const size_t num = ++symbols->last_id;
 775         id = num << ID_SCOPE_SHIFT;
 776     }
 777
 778     return id;
 779 }
 780
 781 static ID
 782 next_id_base(void)
 783 {
 784     ID id;
 785     GLOBAL_SYMBOLS_ENTER(symbols);
 786     {
 787         id = next_id_base_with_lock(symbols);
 788     }
 789     GLOBAL_SYMBOLS_LEAVE();
 790     return id;
 791 }
 792
 793 static ID
 794 intern_str(VALUE str, int mutable)
 795 {
 796     ID id;
 797     ID nid;
 798
 799     id = rb_str_symname_type(str, IDSET_ATTRSET_FOR_INTERN);
 800     if (id == (ID)-1) id = ID_JUNK;
 801     if (sym_check_asciionly(str, false)) {
 802         if (!mutable) str = rb_str_dup(str);
 803         rb_enc_associate(str, rb_usascii_encoding());
 804     }
 805     if ((nid = next_id_base()) == (ID)-1) {
 806         str = rb_str_ellipsize(str, 20);
 807         rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %"PRIsVALUE")",
 808                  str);
 809     }
 810     id |= nid;
 811     id |= ID_STATIC_SYM;
 812     return register_static_symid_str(id, str);
 813 }
 814
 815 ID
 816 rb_intern2(const char *name, long len)
 817 {
 818     return rb_intern3(name, len, rb_usascii_encoding());
 819 }
 820
 821 #undef rb_intern
 822 ID
 823 rb_intern(const char *name)
 824 {
 825     return rb_intern2(name, strlen(name));
 826 }
 827
 828 ID
 829 rb_intern_str(VALUE str)
 830 {
 831     VALUE sym = lookup_str_sym(str);
 832
 833     if (sym) {
 834         return SYM2ID(sym);
 835     }
 836
 837     return intern_str(str, 0);
 838 }
 839
 840 void
 841 rb_gc_free_dsymbol(VALUE sym)
 842 {
 843     VALUE str = RSYMBOL(sym)->fstr;
 844
 845     if (str) {
 846         RSYMBOL(sym)->fstr = 0;
 847
 848         GLOBAL_SYMBOLS_ENTER(symbols);
 849         {
 850             unregister_sym(symbols, str, sym);
 851             rb_hash_delete_entry(symbols->dsymbol_fstr_hash, str);
 852         }
 853         GLOBAL_SYMBOLS_LEAVE();
 854     }
 855 }
 856
 857 /*
 858  *  call-seq:
 859  *     str.intern   -> symbol
 860  *     str.to_sym   -> symbol
 861  *
 862  *  Returns the +Symbol+ corresponding to <i>str</i>, creating the
 863  *  symbol if it did not previously exist. See Symbol#id2name.
 864  *
 865  *     "Koala".intern         #=> :Koala
 866  *     s = 'cat'.to_sym       #=> :cat
 867  *     s == :cat              #=> true
 868  *     s = '@cat'.to_sym      #=> :@cat
 869  *     s == :@cat             #=> true
 870  *
 871  *  This can also be used to create symbols that cannot be represented using the
 872  *  <code>:xxx</code> notation.
 873  *
 874  *     'cat and dog'.to_sym   #=> :"cat and dog"
 875  */
 876
 877 VALUE
 878 rb_str_intern(VALUE str)
 879 {
 880     VALUE sym;
 881
 882     GLOBAL_SYMBOLS_ENTER(symbols);
 883     {
 884         sym = lookup_str_sym_with_lock(symbols, str);
 885
 886         if (sym) {
 887             // ok
 888         }
 889         else if (USE_SYMBOL_GC) {
 890             rb_encoding *enc = rb_enc_get(str);
 891             rb_encoding *ascii = rb_usascii_encoding();
 892             if (enc != ascii && sym_check_asciionly(str, false)) {
 893                 str = rb_str_dup(str);
 894                 rb_enc_associate(str, ascii);
 895                 OBJ_FREEZE(str);
 896                 enc = ascii;
 897             }
 898             else {
 899                 str = rb_str_dup(str);
 900                 OBJ_FREEZE(str);
 901             }
 902             str = rb_fstring(str);
 903             int type = rb_str_symname_type(str, IDSET_ATTRSET_FOR_INTERN);
 904             if (type < 0) type = ID_JUNK;
 905             sym = dsymbol_alloc(symbols, rb_cSymbol, str, enc, type);
 906         }
 907         else {
 908             ID id = intern_str(str, 0);
 909             sym = ID2SYM(id);
 910         }
 911     }
 912     GLOBAL_SYMBOLS_LEAVE();
 913     return sym;
 914 }
 915
 916 ID
 917 rb_sym2id(VALUE sym)
 918 {
 919     ID id;
 920     if (STATIC_SYM_P(sym)) {
 921         id = STATIC_SYM2ID(sym);
 922     }
 923     else if (DYNAMIC_SYM_P(sym)) {
 924         GLOBAL_SYMBOLS_ENTER(symbols);
 925         {
 926             sym = dsymbol_check(symbols, sym);
 927             id = RSYMBOL(sym)->id;
 928
 929             if (UNLIKELY(!(id & ~ID_SCOPE_MASK))) {
 930                 VALUE fstr = RSYMBOL(sym)->fstr;
 931                 ID num = next_id_base_with_lock(symbols);
 932
 933                 RSYMBOL(sym)->id = id |= num;
 934                 /* make it permanent object */
 935
 936                 set_id_entry(symbols, rb_id_to_serial(num), fstr, sym);
 937                 rb_hash_delete_entry(symbols->dsymbol_fstr_hash, fstr);
 938             }
 939         }
 940         GLOBAL_SYMBOLS_LEAVE();
 941     }
 942     else {
 943         rb_raise(rb_eTypeError, "wrong argument type %s (expected Symbol)",
 944                  rb_builtin_class_name(sym));
 945     }
 946     return id;
 947 }
 948
 949 #undef rb_id2sym
 950 VALUE
 951 rb_id2sym(ID x)
 952 {
 953     if (!DYNAMIC_ID_P(x)) return STATIC_ID2SYM(x);
 954     return get_id_entry(x, ID_ENTRY_SYM);
 955 }
 956
 957 /*
 958  *  call-seq:
 959  *    name -> string
 960  *
 961  *  Returns a frozen string representation of +self+ (not including the leading colon):
 962  *
 963  *    :foo.name         # => "foo"
 964  *    :foo.name.frozen? # => true
 965  *
 966  *  Related: Symbol#to_s, Symbol#inspect.
 967  */
 968
 969 VALUE
 970 rb_sym2str(VALUE sym)
 971 {
 972     VALUE str;
 973     if (DYNAMIC_SYM_P(sym)) {
 974         str = RSYMBOL(sym)->fstr;
 975         RUBY_ASSERT_BUILTIN_TYPE(str, T_STRING);
 976     }
 977     else {
 978         str = rb_id2str(STATIC_SYM2ID(sym));
 979         if (str) RUBY_ASSERT_BUILTIN_TYPE(str, T_STRING);
 980     }
 981
 982     return str;
 983 }
 984
 985 VALUE
 986 rb_id2str(ID id)
 987 {
 988     return lookup_id_str(id);
 989 }
 990
 991 const char *
 992 rb_id2name(ID id)
 993 {
 994     VALUE str = rb_id2str(id);
 995
 996     if (!str) return 0;
 997     return RSTRING_PTR(str);
 998 }
 999
1000 ID
1001 rb_make_internal_id(void)
1002 {
1003     return next_id_base() | ID_INTERNAL | ID_STATIC_SYM;
1004 }
1005
1006 ID
1007 rb_make_temporary_id(size_t n)
1008 {
1009     const ID max_id = RB_ID_SERIAL_MAX & ~0xffff;
1010     const ID id = max_id - (ID)n;
1011     if (id <= ruby_global_symbols.last_id) {
1012         rb_raise(rb_eRuntimeError, "too big to make temporary ID: %" PRIdSIZE, n);
1013     }
1014     return (id << ID_SCOPE_SHIFT) | ID_STATIC_SYM | ID_INTERNAL;
1015 }
1016
1017 static int
1018 symbols_i(st_data_t key, st_data_t value, st_data_t arg)
1019 {
1020     VALUE ary = (VALUE)arg;
1021     VALUE sym = (VALUE)value;
1022
1023     if (STATIC_SYM_P(sym)) {
1024         rb_ary_push(ary, sym);
1025         return ST_CONTINUE;
1026     }
1027     else if (!DYNAMIC_SYM_P(sym)) {
1028         rb_bug("invalid symbol: %s", RSTRING_PTR((VALUE)key));
1029     }
1030     else if (!SYMBOL_PINNED_P(sym) && rb_objspace_garbage_object_p(sym)) {
1031         RSYMBOL(sym)->fstr = 0;
1032         return ST_DELETE;
1033     }
1034     else {
1035         rb_ary_push(ary, sym);
1036         return ST_CONTINUE;
1037     }
1038
1039 }
1040
1041 VALUE
1042 rb_sym_all_symbols(void)
1043 {
1044     VALUE ary;
1045
1046     GLOBAL_SYMBOLS_ENTER(symbols);
1047     {
1048         ary = rb_ary_new2(symbols->str_sym->num_entries);
1049         st_foreach(symbols->str_sym, symbols_i, ary);
1050     }
1051     GLOBAL_SYMBOLS_LEAVE();
1052
1053     return ary;
1054 }
1055
1056 size_t
1057 rb_sym_immortal_count(void)
1058 {
1059     return (size_t)ruby_global_symbols.last_id;
1060 }
1061
1062 int
1063 rb_is_const_id(ID id)
1064 {
1065     return is_const_id(id);
1066 }
1067
1068 int
1069 rb_is_class_id(ID id)
1070 {
1071     return is_class_id(id);
1072 }
1073
1074 int
1075 rb_is_global_id(ID id)
1076 {
1077     return is_global_id(id);
1078 }
1079
1080 int
1081 rb_is_instance_id(ID id)
1082 {
1083     return is_instance_id(id);
1084 }
1085
1086 int
1087 rb_is_attrset_id(ID id)
1088 {
1089     return is_attrset_id(id);
1090 }
1091
1092 int
1093 rb_is_local_id(ID id)
1094 {
1095     return is_local_id(id);
1096 }
1097
1098 int
1099 rb_is_junk_id(ID id)
1100 {
1101     return is_junk_id(id);
1102 }
1103
1104 int
1105 rb_is_const_sym(VALUE sym)
1106 {
1107     return is_const_sym(sym);
1108 }
1109
1110 int
1111 rb_is_attrset_sym(VALUE sym)
1112 {
1113     return is_attrset_sym(sym);
1114 }
1115
1116 ID
1117 rb_check_id(volatile VALUE *namep)
1118 {
1119     VALUE tmp;
1120     VALUE name = *namep;
1121
1122     if (STATIC_SYM_P(name)) {
1123         return STATIC_SYM2ID(name);
1124     }
1125     else if (DYNAMIC_SYM_P(name)) {
1126         if (SYMBOL_PINNED_P(name)) {
1127             return RSYMBOL(name)->id;
1128         }
1129         else {
1130             *namep = RSYMBOL(name)->fstr;
1131             return 0;
1132         }
1133     }
1134     else if (!RB_TYPE_P(name, T_STRING)) {
1135         tmp = rb_check_string_type(name);
1136         if (NIL_P(tmp)) {
1137             rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a symbol nor a string",
1138                      name);
1139         }
1140         name = tmp;
1141         *namep = name;
1142     }
1143
1144     sym_check_asciionly(name, false);
1145
1146     return lookup_str_id(name);
1147 }
1148
1149 // Used by yjit for handling .send without throwing exceptions
1150 ID
1151 rb_get_symbol_id(VALUE name)
1152 {
1153     if (STATIC_SYM_P(name)) {
1154         return STATIC_SYM2ID(name);
1155     }
1156     else if (DYNAMIC_SYM_P(name)) {
1157         if (SYMBOL_PINNED_P(name)) {
1158             return RSYMBOL(name)->id;
1159         }
1160         else {
1161             return 0;
1162         }
1163     }
1164     else if (RB_TYPE_P(name, T_STRING)) {
1165         return lookup_str_id(name);
1166     }
1167     else {
1168         return 0;
1169     }
1170 }
1171
1172
1173 VALUE
1174 rb_check_symbol(volatile VALUE *namep)
1175 {
1176     VALUE sym;
1177     VALUE tmp;
1178     VALUE name = *namep;
1179
1180     if (STATIC_SYM_P(name)) {
1181         return name;
1182     }
1183     else if (DYNAMIC_SYM_P(name)) {
1184         if (!SYMBOL_PINNED_P(name)) {
1185             GLOBAL_SYMBOLS_ENTER(symbols);
1186             {
1187                 name = dsymbol_check(symbols, name);
1188             }
1189             GLOBAL_SYMBOLS_LEAVE();
1190
1191             *namep = name;
1192         }
1193         return name;
1194     }
1195     else if (!RB_TYPE_P(name, T_STRING)) {
1196         tmp = rb_check_string_type(name);
1197         if (NIL_P(tmp)) {
1198             rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a symbol nor a string",
1199                      name);
1200         }
1201         name = tmp;
1202         *namep = name;
1203     }
1204
1205     sym_check_asciionly(name, false);
1206
1207     if ((sym = lookup_str_sym(name)) != 0) {
1208         return sym;
1209     }
1210
1211     return Qnil;
1212 }
1213
1214 ID
1215 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
1216 {
1217     struct RString fake_str;
1218     const VALUE name = rb_setup_fake_str(&fake_str, ptr, len, enc);
1219
1220     sym_check_asciionly(name, true);
1221
1222     return lookup_str_id(name);
1223 }
1224
1225 VALUE
1226 rb_check_symbol_cstr(const char *ptr, long len, rb_encoding *enc)
1227 {
1228     VALUE sym;
1229     struct RString fake_str;
1230     const VALUE name = rb_setup_fake_str(&fake_str, ptr, len, enc);
1231
1232     sym_check_asciionly(name, true);
1233
1234     if ((sym = lookup_str_sym(name)) != 0) {
1235         return sym;
1236     }
1237
1238     return Qnil;
1239 }
1240
1241 #undef rb_sym_intern_ascii_cstr
1242 #ifdef __clang__
1243 NOINLINE(VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc));
1244 #else
1245 FUNC_MINIMIZED(VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc));
1246 FUNC_MINIMIZED(VALUE rb_sym_intern_ascii(const char *ptr, long len));
1247 FUNC_MINIMIZED(VALUE rb_sym_intern_ascii_cstr(const char *ptr));
1248 #endif
1249
1250 VALUE
1251 rb_sym_intern(const char *ptr, long len, rb_encoding *enc)
1252 {
1253     struct RString fake_str;
1254     const VALUE name = rb_setup_fake_str(&fake_str, ptr, len, enc);
1255     return rb_str_intern(name);
1256 }
1257
1258 VALUE
1259 rb_sym_intern_ascii(const char *ptr, long len)
1260 {
1261     return rb_sym_intern(ptr, len, rb_usascii_encoding());
1262 }
1263
1264 VALUE
1265 rb_sym_intern_ascii_cstr(const char *ptr)
1266 {
1267     return rb_sym_intern_ascii(ptr, strlen(ptr));
1268 }
1269
1270 VALUE
1271 rb_to_symbol_type(VALUE obj)
1272 {
1273     return rb_convert_type_with_id(obj, T_SYMBOL, "Symbol", idTo_sym);
1274 }
1275
1276 int
1277 rb_is_const_name(VALUE name)
1278 {
1279     return rb_str_symname_type(name, 0) == ID_CONST;
1280 }
1281
1282 int
1283 rb_is_class_name(VALUE name)
1284 {
1285     return rb_str_symname_type(name, 0) == ID_CLASS;
1286 }
1287
1288 int
1289 rb_is_instance_name(VALUE name)
1290 {
1291     return rb_str_symname_type(name, 0) == ID_INSTANCE;
1292 }
1293
1294 int
1295 rb_is_local_name(VALUE name)
1296 {
1297     return rb_str_symname_type(name, 0) == ID_LOCAL;
1298 }
1299
1300 #include "id_table.c"
1301 #include "symbol.rbinc"