1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Replace assert with RUBY_ASSERT in string.c

Browse Source 
assert does not print the bug report, only the file and line number of
the assertion that failed. RUBY_ASSERT prints the full bug report, which
makes it much easier to debug.
This commit is contained in:
Peter Zhu 2024-02-08 09:37:56 -05:00
parent bb845ae879
commit ac38f259aa
1 changed files with 51 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
string.c
View File

@ -170,7 +170,7 @@ str_enc_fastpath(VALUE str)
}\ }\
}\ }\
else {\ else {\
assert(!FL_TEST((str), STR_SHARED)); \ RUBY_ASSERT(!FL_TEST((str), STR_SHARED)); \
SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, \ SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, \
(size_t)(capacity) + (termlen), STR_HEAP_SIZE(str)); \ (size_t)(capacity) + (termlen), STR_HEAP_SIZE(str)); \
RSTRING(str)->as.heap.aux.capa = (capacity);\ RSTRING(str)->as.heap.aux.capa = (capacity);\
@ -179,8 +179,8 @@ str_enc_fastpath(VALUE str)
#define STR_SET_SHARED(str, shared_str) do { \ #define STR_SET_SHARED(str, shared_str) do { \
if (!FL_TEST(str, STR_FAKESTR)) { \ if (!FL_TEST(str, STR_FAKESTR)) { \
assert(RSTRING_PTR(shared_str) <= RSTRING_PTR(str)); \ RUBY_ASSERT(RSTRING_PTR(shared_str) <= RSTRING_PTR(str)); \
assert(RSTRING_PTR(str) <= RSTRING_PTR(shared_str) + RSTRING_LEN(shared_str)); \ RUBY_ASSERT(RSTRING_PTR(str) <= RSTRING_PTR(shared_str) + RSTRING_LEN(shared_str)); \
RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \ RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \
FL_SET((str), STR_SHARED); \ FL_SET((str), STR_SHARED); \
FL_SET((shared_str), STR_SHARED_ROOT); \ FL_SET((shared_str), STR_SHARED_ROOT); \
@ -385,7 +385,7 @@ fstr_update_callback(st_data_t *key, st_data_t *value, st_data_t data, int exist
if (STR_SHARED_P(str)) { /* str should not be shared */ if (STR_SHARED_P(str)) { /* str should not be shared */
/* shared substring */ /* shared substring */
str_make_independent(str); str_make_independent(str);
assert(OBJ_FROZEN(str)); RUBY_ASSERT(OBJ_FROZEN(str));
} }
if (!BARE_STRING_P(str)) { if (!BARE_STRING_P(str)) {
str = str_new_frozen(rb_cString, str); str = str_new_frozen(rb_cString, str);
@ -418,7 +418,7 @@ rb_fstring(VALUE str)
} }
if (FL_TEST_RAW(str, STR_SHARED_ROOT | STR_SHARED) == STR_SHARED_ROOT) { if (FL_TEST_RAW(str, STR_SHARED_ROOT | STR_SHARED) == STR_SHARED_ROOT) {
assert(OBJ_FROZEN(str)); RUBY_ASSERT(OBJ_FROZEN(str));
return str; return str;
} }
} }
@ -452,10 +452,11 @@ register_fstring(VALUE str, bool copy)
} }
RB_VM_LOCK_LEAVE(); RB_VM_LOCK_LEAVE();
assert(OBJ_FROZEN(args.fstr)); RUBY_ASSERT(OBJ_FROZEN(args.fstr));
assert(!FL_TEST_RAW(args.fstr, STR_FAKESTR)); RUBY_ASSERT(!FL_TEST_RAW(args.fstr, STR_FAKESTR));
assert(!FL_TEST_RAW(args.fstr, FL_EXIVAR)); RUBY_ASSERT(!FL_TEST_RAW(args.fstr, FL_EXIVAR));
assert(RBASIC_CLASS(args.fstr) == rb_cString); RUBY_ASSERT(RBASIC_CLASS(args.fstr) == rb_cString);
return args.fstr; return args.fstr;
} }
@ -844,8 +845,8 @@ static inline VALUE
str_alloc_embed(VALUE klass, size_t capa) str_alloc_embed(VALUE klass, size_t capa)
{ {
size_t size = rb_str_embed_size(capa); size_t size = rb_str_embed_size(capa);
assert(size > 0); RUBY_ASSERT(size > 0);
assert(rb_gc_size_allocatable_p(size)); RUBY_ASSERT(rb_gc_size_allocatable_p(size));
NEWOBJ_OF(str, struct RString, klass, NEWOBJ_OF(str, struct RString, klass,
T_STRING | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0), size, 0); T_STRING | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0), size, 0);
@ -1295,7 +1296,8 @@ str_replace_shared_without_enc(VALUE str2, VALUE str)
root = rb_str_new_frozen(str); root = rb_str_new_frozen(str);
RSTRING_GETMEM(root, ptr, len); RSTRING_GETMEM(root, ptr, len);
} }
assert(OBJ_FROZEN(root)); RUBY_ASSERT(OBJ_FROZEN(root));
if (!STR_EMBED_P(str2) && !FL_TEST_RAW(str2, STR_SHARED|STR_NOFREE)) { if (!STR_EMBED_P(str2) && !FL_TEST_RAW(str2, STR_SHARED|STR_NOFREE)) {
if (FL_TEST_RAW(str2, STR_SHARED_ROOT)) { if (FL_TEST_RAW(str2, STR_SHARED_ROOT)) {
rb_fatal("about to free a possible shared root"); rb_fatal("about to free a possible shared root");
@ -1399,21 +1401,21 @@ rb_str_tmp_frozen_release(VALUE orig, VALUE tmp)
return; return;
if (STR_EMBED_P(tmp)) { if (STR_EMBED_P(tmp)) {
assert(OBJ_FROZEN_RAW(tmp)); RUBY_ASSERT(OBJ_FROZEN_RAW(tmp));
} }
else if (FL_TEST_RAW(orig, STR_SHARED) && else if (FL_TEST_RAW(orig, STR_SHARED) &&
!FL_TEST_RAW(orig, STR_TMPLOCK|RUBY_FL_FREEZE)) { !FL_TEST_RAW(orig, STR_TMPLOCK|RUBY_FL_FREEZE)) {
VALUE shared = RSTRING(orig)->as.heap.aux.shared; VALUE shared = RSTRING(orig)->as.heap.aux.shared;
if (shared == tmp && !FL_TEST_RAW(tmp, STR_BORROWED)) { if (shared == tmp && !FL_TEST_RAW(tmp, STR_BORROWED)) {
assert(RSTRING(orig)->as.heap.ptr == RSTRING(tmp)->as.heap.ptr); RUBY_ASSERT(RSTRING(orig)->as.heap.ptr == RSTRING(tmp)->as.heap.ptr);
assert(RSTRING_LEN(orig) == RSTRING_LEN(tmp)); RUBY_ASSERT(RSTRING_LEN(orig) == RSTRING_LEN(tmp));
/* Unshare orig since the root (tmp) only has this one child. */ /* Unshare orig since the root (tmp) only has this one child. */
FL_UNSET_RAW(orig, STR_SHARED); FL_UNSET_RAW(orig, STR_SHARED);
RSTRING(orig)->as.heap.aux.capa = RSTRING(tmp)->as.heap.aux.capa; RSTRING(orig)->as.heap.aux.capa = RSTRING(tmp)->as.heap.aux.capa;
RBASIC(orig)->flags |= RBASIC(tmp)->flags & STR_NOFREE; RBASIC(orig)->flags |= RBASIC(tmp)->flags & STR_NOFREE;
assert(OBJ_FROZEN_RAW(tmp)); RUBY_ASSERT(OBJ_FROZEN_RAW(tmp));
/* Make tmp embedded and empty so it is safe for sweeping. */ /* Make tmp embedded and empty so it is safe for sweeping. */
STR_SET_EMBED(tmp); STR_SET_EMBED(tmp);
@ -1431,8 +1433,8 @@ str_new_frozen(VALUE klass, VALUE orig)
static VALUE static VALUE
heap_str_make_shared(VALUE klass, VALUE orig) heap_str_make_shared(VALUE klass, VALUE orig)
{ {
assert(!STR_EMBED_P(orig)); RUBY_ASSERT(!STR_EMBED_P(orig));
assert(!STR_SHARED_P(orig)); RUBY_ASSERT(!STR_SHARED_P(orig));
VALUE str = str_alloc_heap(klass); VALUE str = str_alloc_heap(klass);
STR_SET_LEN(str, RSTRING_LEN(orig)); STR_SET_LEN(str, RSTRING_LEN(orig));
@ -1456,23 +1458,23 @@ str_new_frozen_buffer(VALUE klass, VALUE orig, int copy_encoding)
if (STR_EMBED_P(orig) || STR_EMBEDDABLE_P(len, termlen)) { if (STR_EMBED_P(orig) || STR_EMBEDDABLE_P(len, termlen)) {
str = str_new0(klass, RSTRING_PTR(orig), len, termlen); str = str_new0(klass, RSTRING_PTR(orig), len, termlen);
assert(STR_EMBED_P(str)); RUBY_ASSERT(STR_EMBED_P(str));
} }
else { else {
if (FL_TEST_RAW(orig, STR_SHARED)) { if (FL_TEST_RAW(orig, STR_SHARED)) {
VALUE shared = RSTRING(orig)->as.heap.aux.shared; VALUE shared = RSTRING(orig)->as.heap.aux.shared;
long ofs = RSTRING(orig)->as.heap.ptr - RSTRING_PTR(shared); long ofs = RSTRING(orig)->as.heap.ptr - RSTRING_PTR(shared);
long rest = RSTRING_LEN(shared) - ofs - RSTRING_LEN(orig); long rest = RSTRING_LEN(shared) - ofs - RSTRING_LEN(orig);
assert(ofs >= 0); RUBY_ASSERT(ofs >= 0);
assert(rest >= 0); RUBY_ASSERT(rest >= 0);
assert(ofs + rest <= RSTRING_LEN(shared)); RUBY_ASSERT(ofs + rest <= RSTRING_LEN(shared));
assert(OBJ_FROZEN(shared)); RUBY_ASSERT(OBJ_FROZEN(shared));
if ((ofs > 0) || (rest > 0) || if ((ofs > 0) || (rest > 0) ||
(klass != RBASIC(shared)->klass) || (klass != RBASIC(shared)->klass) ||
ENCODING_GET(shared) != ENCODING_GET(orig)) { ENCODING_GET(shared) != ENCODING_GET(orig)) {
str = str_new_shared(klass, shared); str = str_new_shared(klass, shared);
assert(!STR_EMBED_P(str)); RUBY_ASSERT(!STR_EMBED_P(str));
RSTRING(str)->as.heap.ptr += ofs; RSTRING(str)->as.heap.ptr += ofs;
STR_SET_LEN(str, RSTRING_LEN(str) - (ofs + rest)); STR_SET_LEN(str, RSTRING_LEN(str) - (ofs + rest));
} }
@ -1625,9 +1627,9 @@ str_shared_replace(VALUE str, VALUE str2)
} }
else { else {
if (STR_EMBED_P(str2)) { if (STR_EMBED_P(str2)) {
assert(!FL_TEST(str2, STR_SHARED)); RUBY_ASSERT(!FL_TEST(str2, STR_SHARED));
long len = RSTRING_LEN(str2); long len = RSTRING_LEN(str2);
assert(len + termlen <= str_embed_capa(str2)); RUBY_ASSERT(len + termlen <= str_embed_capa(str2));
char *new_ptr = ALLOC_N(char, len + termlen); char *new_ptr = ALLOC_N(char, len + termlen);
memcpy(new_ptr, RSTRING(str2)->as.embed.ary, len + termlen); memcpy(new_ptr, RSTRING(str2)->as.embed.ary, len + termlen);
@ -1686,7 +1688,7 @@ str_replace(VALUE str, VALUE str2)
len = RSTRING_LEN(str2); len = RSTRING_LEN(str2);
if (STR_SHARED_P(str2)) { if (STR_SHARED_P(str2)) {
VALUE shared = RSTRING(str2)->as.heap.aux.shared; VALUE shared = RSTRING(str2)->as.heap.aux.shared;
assert(OBJ_FROZEN(shared)); RUBY_ASSERT(OBJ_FROZEN(shared));
STR_SET_NOEMBED(str); STR_SET_NOEMBED(str);
STR_SET_LEN(str, len); STR_SET_LEN(str, len);
RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2); RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
@ -1704,8 +1706,8 @@ static inline VALUE
ec_str_alloc_embed(struct rb_execution_context_struct *ec, VALUE klass, size_t capa) ec_str_alloc_embed(struct rb_execution_context_struct *ec, VALUE klass, size_t capa)
{ {
size_t size = rb_str_embed_size(capa); size_t size = rb_str_embed_size(capa);
assert(size > 0); RUBY_ASSERT(size > 0);
assert(rb_gc_size_allocatable_p(size)); RUBY_ASSERT(rb_gc_size_allocatable_p(size));
NEWOBJ_OF(str, struct RString, klass, NEWOBJ_OF(str, struct RString, klass,
T_STRING | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0), size, ec); T_STRING | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0), size, ec);
@ -1734,8 +1736,8 @@ str_duplicate_setup(VALUE klass, VALUE str, VALUE dup)
if (STR_EMBED_P(str)) { if (STR_EMBED_P(str)) {
long len = RSTRING_LEN(str); long len = RSTRING_LEN(str);
assert(STR_EMBED_P(dup)); RUBY_ASSERT(STR_EMBED_P(dup));
assert(str_embed_capa(dup) >= len + 1); RUBY_ASSERT(str_embed_capa(dup) >= len + 1);
MEMCPY(RSTRING(dup)->as.embed.ary, RSTRING(str)->as.embed.ary, char, len + 1); MEMCPY(RSTRING(dup)->as.embed.ary, RSTRING(str)->as.embed.ary, char, len + 1);
} }
else { else {
@ -1747,8 +1749,8 @@ str_duplicate_setup(VALUE klass, VALUE str, VALUE dup)
root = str = str_new_frozen(klass, str); root = str = str_new_frozen(klass, str);
flags = FL_TEST_RAW(str, flag_mask); flags = FL_TEST_RAW(str, flag_mask);
} }
assert(!STR_SHARED_P(root)); RUBY_ASSERT(!STR_SHARED_P(root));
assert(RB_OBJ_FROZEN_RAW(root)); RUBY_ASSERT(RB_OBJ_FROZEN_RAW(root));
RSTRING(dup)->as.heap.ptr = RSTRING_PTR(str); RSTRING(dup)->as.heap.ptr = RSTRING_PTR(str);
FL_SET(root, STR_SHARED_ROOT); FL_SET(root, STR_SHARED_ROOT);
@ -1877,7 +1879,7 @@ rb_str_init(int argc, VALUE *argv, VALUE str)
str_modifiable(str); str_modifiable(str);
if (STR_EMBED_P(str)) { /* make noembed always */ if (STR_EMBED_P(str)) { /* make noembed always */
char *new_ptr = ALLOC_N(char, (size_t)capa + termlen); char *new_ptr = ALLOC_N(char, (size_t)capa + termlen);
assert(RSTRING_LEN(str) + 1 <= str_embed_capa(str)); RUBY_ASSERT(RSTRING_LEN(str) + 1 <= str_embed_capa(str));
memcpy(new_ptr, RSTRING(str)->as.embed.ary, RSTRING_LEN(str) + 1); memcpy(new_ptr, RSTRING(str)->as.embed.ary, RSTRING_LEN(str) + 1);
RSTRING(str)->as.heap.ptr = new_ptr; RSTRING(str)->as.heap.ptr = new_ptr;
} }
@ -2306,8 +2308,8 @@ rb_str_plus(VALUE str1, VALUE str2)
VALUE VALUE
rb_str_opt_plus(VALUE str1, VALUE str2) rb_str_opt_plus(VALUE str1, VALUE str2)
{ {
assert(RBASIC_CLASS(str1) == rb_cString); RUBY_ASSERT(RBASIC_CLASS(str1) == rb_cString);
assert(RBASIC_CLASS(str2) == rb_cString); RUBY_ASSERT(RBASIC_CLASS(str2) == rb_cString);
long len1, len2; long len1, len2;
MAYBE_UNUSED(char) *ptr1, *ptr2; MAYBE_UNUSED(char) *ptr1, *ptr2;
RSTRING_GETMEM(str1, ptr1, len1); RSTRING_GETMEM(str1, ptr1, len1);
@ -2623,7 +2625,7 @@ rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int terml
long capa = str_capacity(str, oldtermlen) + oldtermlen; long capa = str_capacity(str, oldtermlen) + oldtermlen;
long len = RSTRING_LEN(str); long len = RSTRING_LEN(str);
assert(capa >= len); RUBY_ASSERT(capa >= len);
if (capa - len < termlen) { if (capa - len < termlen) {
rb_check_lockedtmp(str); rb_check_lockedtmp(str);
str_make_independent_expand(str, len, 0L, termlen); str_make_independent_expand(str, len, 0L, termlen);
@ -2635,7 +2637,7 @@ rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int terml
else { else {
if (!STR_EMBED_P(str)) { if (!STR_EMBED_P(str)) {
/* modify capa instead of realloc */ /* modify capa instead of realloc */
assert(!FL_TEST((str), STR_SHARED)); RUBY_ASSERT(!FL_TEST((str), STR_SHARED));
RSTRING(str)->as.heap.aux.capa = capa - termlen; RSTRING(str)->as.heap.aux.capa = capa - termlen;
} }
if (termlen > oldtermlen) { if (termlen > oldtermlen) {
@ -2868,9 +2870,9 @@ str_subseq(VALUE str, long beg, long len)
{ {
VALUE str2; VALUE str2;
assert(beg >= 0); RUBY_ASSERT(beg >= 0);
assert(len >= 0); RUBY_ASSERT(len >= 0);
assert(beg+len <= RSTRING_LEN(str)); RUBY_ASSERT(beg+len <= RSTRING_LEN(str));
const int termlen = TERM_LEN(str); const int termlen = TERM_LEN(str);
if (!SHARABLE_SUBSTRING_P(beg, len, RSTRING_LEN(str))) { if (!SHARABLE_SUBSTRING_P(beg, len, RSTRING_LEN(str))) {
@ -2891,7 +2893,7 @@ str_subseq(VALUE str, long beg, long len)
} }
else { else {
str_replace_shared(str2, str); str_replace_shared(str2, str);
assert(!STR_EMBED_P(str2)); RUBY_ASSERT(!STR_EMBED_P(str2));
ENC_CODERANGE_CLEAR(str2); ENC_CODERANGE_CLEAR(str2);
RSTRING(str2)->as.heap.ptr += beg; RSTRING(str2)->as.heap.ptr += beg;
if (RSTRING_LEN(str2) > len) { if (RSTRING_LEN(str2) > len) {
@ -5408,8 +5410,9 @@ rb_str_update(VALUE str, long beg, long len, VALUE val)
if (beg < 0) { if (beg < 0) {
beg += slen; beg += slen;
} }
assert(beg >= 0); RUBY_ASSERT(beg >= 0);
assert(beg <= slen); RUBY_ASSERT(beg <= slen);
if (len > slen - beg) { if (len > slen - beg) {
len = slen - beg; len = slen - beg;
} }
@ -6363,8 +6366,9 @@ str_check_beg_len(VALUE str, long *beg, long *len)
if (*beg < 0) { if (*beg < 0) {
*beg += slen; *beg += slen;
} }
assert(*beg >= 0); RUBY_ASSERT(*beg >= 0);
assert(*beg <= slen); RUBY_ASSERT(*beg <= slen);
if (*len > slen - *beg) { if (*len > slen - *beg) {
*len = slen - *beg; *len = slen - *beg;
} }
@ -12133,7 +12137,7 @@ void
Init_String(void) Init_String(void)
{ {
rb_cString = rb_define_class("String", rb_cObject); rb_cString = rb_define_class("String", rb_cObject);
assert(rb_vm_fstring_table()); RUBY_ASSERT(rb_vm_fstring_table());
st_foreach(rb_vm_fstring_table(), fstring_set_class_i, rb_cString); st_foreach(rb_vm_fstring_table(), fstring_set_class_i, rb_cString);
rb_include_module(rb_cString, rb_mComparable); rb_include_module(rb_cString, rb_mComparable);
rb_define_alloc_func(rb_cString, empty_str_alloc); rb_define_alloc_func(rb_cString, empty_str_alloc);