summaryrefslogtreecommitdiff
path: root/string.c
AgeCommit message (Collapse)Author
2025-07-24Suppress gcc 15 unterminated-string-initialization warningsNobuyoshi Nakada
2024-11-30merge revision(s) 02b70256b5171d4b85ea7eeab836d3d7cfb3dbfc, ↵nagachika
6b4f8945d600168bf530d21395da8293fbd5e8ba: [Backport #20909] Check negative integer underflow Many of Oniguruma functions need valid encoding strings
2024-07-15merge revision(s) 7e4b1f8e1935a10df3c41ee60ca0987d73281126: [Backport #20322]nagachika
[Bug #20322] Fix rb_enc_interned_str_cstr null encoding The documentation for `rb_enc_interned_str_cstr` notes that `enc` can be a null pointer, but this currently causes a segmentation fault when trying to autoload the encoding. This commit fixes the issue by checking for NULL before calling `rb_enc_autoload`.
2024-07-15Revert "merge revision(s) 5e0c17145131e073814c7e5b15227d0b4e73cabe: ↵nagachika
[Backport #20169]" This reverts commit 6b73406833dd22e489114fa77c1c80c4b7af2ed0.
2024-07-15Revert "merge revision(s) e04146129ec6898dd6a9739dad2983c6e9b68056, ↵nagachika
d5080f6e8b77364483ff6727b1065e45e180f05d: [Backport #20292]" This reverts commit a54c717c7a74b91a3cdf20742c355e3ea42052d1.
2024-07-15Revert "follow-up for a54c717c7a74b91a3cdf20742c355e3ea42052d1."nagachika
This reverts commit 715633ba6e982dc5404abeafc5246c31af92ac10.
2024-07-15follow-up for a54c717c7a74b91a3cdf20742c355e3ea42052d1.nagachika
2024-07-15merge revision(s) e04146129ec6898dd6a9739dad2983c6e9b68056, ↵nagachika
d5080f6e8b77364483ff6727b1065e45e180f05d: [Backport #20292] [Bug #20292] Truncate embedded string to new capacity Fix -Wsign-compare on String#initialize MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ../string.c:1886:57: warning: comparison of integer expressions of different signedness: ‘size_t’ {aka ‘long unsigned int’} and ‘long int’ [-Wsign-compare] 1886 | if (STR_EMBED_P(str)) RUBY_ASSERT(osize <= str_embed_capa(str)); | ^~
2024-07-15merge revision(s) 5e0c17145131e073814c7e5b15227d0b4e73cabe: [Backport #20169]nagachika
Make io_fwrite safe for compaction [Bug #20169] Embedded strings are not safe for system calls without the GVL because compaction can cause pages to be locked causing the operation to fail with EFAULT. This commit changes io_fwrite to use rb_str_tmp_frozen_no_embed_acquire, which guarantees that the return string is not embedded.
2024-05-14Fix `String#index` to clear MatchData when a regexp is passedJean Boussier
[Bug #20421] The bug was fixed in Ruby 3.3 via 9dcdffb8bf8a3654fd78bf1a58b30c8e13888a7a
2024-03-31merge revision(s) ade56737e2273847426214035c0ff2340b43799a: [Backport #20190]nagachika
Fix coderange of invalid_encoding_string.<<(ord) Appending valid encoding character can change coderange from invalid to valid. Example: "\x95".force_encoding('sjis')<<0x5C will be a valid string "\x{955C}" --- string.c | 6 +++++- test/ruby/test_string.rb | 3 +++ 2 files changed, 8 insertions(+), 1 deletion(-)
2024-01-18merge revision(s) b3d612804946e841e47d14e09b6839224a79c1a4: [Backport #20150]nagachika
Fix memory leak in grapheme clusters [Bug #20150] String#grapheme_cluters and String#each_grapheme_cluster leaks memory because if the string is not UTF-8, then the created regex will not be freed. For example: str = "hello world".encode(Encoding::UTF_32LE) 10.times do 1_000.times do str.grapheme_clusters end puts `ps -o rss= -p #{$$}` end Before: 26000 42256 59008 75792 92528 109232 125936 142672 159392 176160 After: 9264 9504 9808 10000 10128 10224 10352 10544 10704 10896 --- string.c | 98 +++++++++++++++++++++++++++++++----------------- test/ruby/test_string.rb | 11 ++++++ 2 files changed, 75 insertions(+), 34 deletions(-)
2023-09-30merge revision(s) 6b66b5fdedb2c9a9ee48e290d57ca7f8d55e01a2: [Backport #19902]nagachika
[Bug #19902] Update the coderange regarding the changed region --- ext/-test-/string/set_len.c | 10 ++++++++++ string.c | 27 +++++++++++++++++++++++++++ test/-ext-/string/test_set_len.rb | 29 +++++++++++++++++++++++++++++ 3 files changed, 66 insertions(+)
2023-09-30merge revision(s) 2214bcb70d9f9120f1f3790ca340236c8f080991: [Backport #19792]nagachika
Fix premature string collection during append Previously, the following crashed due to use-after-free with AArch64 Alpine Linux 3.18.3 (aarch64-linux-musl): ```ruby str = 'a' * (32*1024*1024) p({z: str}) ``` 32 MiB is the default for `GC_MALLOC_LIMIT_MAX`, and the crash could be dodged by setting `RUBY_GC_MALLOC_LIMIT_MAX` to large values. Under a debugger, one can see the `str2` of rb_str_buf_append() getting prematurely collected while str_buf_cat4() allocates capacity. Add GC guards so the buffer of `str2` lives across the GC run initiated in str_buf_cat4(). [Bug #19792] --- string.c | 2 ++ 1 file changed, 2 insertions(+)
2023-07-22merge revision(s) bc3ac1872e4523334e3ed04c2bb70a55c4c43f98: [Backport #19748]nagachika
[Bug #19748] Fix out-of-bound access in `String#byteindex` --- string.c | 17 +++++++---------- test/ruby/test_string.rb | 3 +++ 2 files changed, 10 insertions(+), 10 deletions(-)
2023-03-17merge revision(s) d78ae78fd76e556e281a743c75bea4c0bb81ed8c: [Backport #19468]NARUSE, Yui
rb_str_modify_expand: clear the string coderange [Bug #19468] b0b9f7201acab05c2a3ad92c3043a1f01df3e17f errornously stopped clearing the coderange. Since `rb_str_modify` clears it, `rb_str_modify_expand` should too. --- string.c | 1 + 1 file changed, 1 insertion(+)
2023-01-31merge revision(s) 9726736006b3f74635fd8af05814fe0908e2cf84: [Backport #19327]NARUSE, Yui
Set STR_SHARED_ROOT flag on root of string --- string.c | 1 + 1 file changed, 1 insertion(+)
2023-01-20merge revision(s) f7b72462aa27716370c6bea1f2c240983aca9a55: [Backport #19356]NARUSE, Yui
String#bytesplice should return self In Feature #19314, we concluded that the return value of String#bytesplice should be changed from the source string to the receiver, because the source string is useless and confusing when extra arguments are added. This change should be included in Ruby 3.2.1. --- string.c | 4 ++-- test/ruby/test_string.rb | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-)
2023-01-19merge revision(s) 3be2acfafd3b3c6168e2266c7c6561d143d7ae5c: [Backport #19327]NARUSE, Yui
Fix re-embedding of strings during compaction The reference updating code for strings is not re-embedding strings because the code is incorrectly wrapped inside of a `if (STR_SHARED_P(obj))` clause. Shared strings can't be re-embedded so this ends up being a no-op. This means that strings can be moved to a large size pool during compaction, but won't be re-embedded, which would waste the space. --- gc.c | 16 +++++++++------- string.c | 12 ++++++++---- test/ruby/test_gc_compact.rb | 8 ++++---- 3 files changed, 21 insertions(+), 15 deletions(-)
2023-01-19merge revision(s) d8ef0a98c670449b20436947f5ebbd327ed5ab0d: [Backport #19319]NARUSE, Yui
[Bug #19319] Fix crash in rb_str_casemap The following code crashes on my machine: ``` GC.stress = true str = "testing testing testing" puts str.capitalize ``` We need to ensure that the object `buffer_anchor` remains on the stack so it does not get GC'd. --- string.c | 2 ++ 1 file changed, 2 insertions(+)
2022-12-22[DOC] Fix typoNobuyoshi Nakada
2022-12-02Introduce encoding check macroS-H-GAMELINKS
Notes: Merged: https://github.com/ruby/ruby/pull/6700
2022-11-24Make String#rstrip{,!} raise Encoding::CompatibilityError for broken coderangeJeremy Evans
It's questionable whether we want to allow rstrip to work for strings where the broken coderange occurs before the trailing whitespace and not after, but this approach is probably simpler, and I don't think users should expect string operations like rstrip to work on broken strings. In some cases, this changes rstrip to raise Encoding::CompatibilityError instead of ArgumentError. However, as the problem is related to an encoding issue in the receiver, and due not due to an issue with an argument, I think Encoding::CompatibilityError is the more appropriate error. Fixes [Bug #18931] Notes: Merged: https://github.com/ruby/ruby/pull/6282
2022-11-16Using UNDEF_P macroS-H-GAMELINKS
Notes: Merged: https://github.com/ruby/ruby/pull/6721
2022-11-15Rewrite Symbol#to_sym and #intern in Ruby (#6683)Takashi Kokubun
Notes: Merged-By: k0kubun <takashikkbn@gmail.com>
2022-11-14Use string's capacity to determine if reembeddablePeter Zhu
During auto-compaction, using length to determine whether or not a string can be re-embedded may be a problem for newly created strings. This is because usually it requires a malloc before setting the length. If the malloc triggers compaction, then the string may be re-embedded and can cause crashes.
2022-11-03Make str_alloc_heap return a STR_NOEMBED stringPeter Zhu
This commit refactors str_alloc_heap to return a string with the STR_NOEMBED flag set. Notes: Merged: https://github.com/ruby/ruby/pull/6663
2022-10-04Correcting example for swapcase! methodVaevictusnet
Example, line 3, swapcase! was incorrect. implied that the swapcase! did /not/ change the starting string. Notes: Merged: https://github.com/ruby/ruby/pull/6474
2022-09-28Fix bug when slicing a string with broken encodingPeter Zhu
Commit aa2a428 introduced a bug where non-embedded string slices copied the encoding of the original string. If the original string had a broken encoding but the slice has valid encoding, then the slice would be incorrectly marked as broken encoding. Notes: Merged: https://github.com/ruby/ruby/pull/6456
2022-09-28Make string slices views rather than copiesPeter Zhu
Just like commit 1c16645 for arrays, this commit changes string slices to be a view rather than a copy even if it can be allocated through VWA. Notes: Merged: https://github.com/ruby/ruby/pull/6456
2022-09-26Refactor str_substr and str_subseqPeter Zhu
This commit extracts common code between str_substr and rb_str_subseq into a function called str_subseq. This commit also applies optimizations in commit 2e88bca to rb_str_subseq. Notes: Merged: https://github.com/ruby/ruby/pull/6447
2022-09-26string.c: don't create a frozen copy for str_new_sharedJean Boussier
str_new_shared already has all the necessary logic to do this and is also smart enough to skip this step if the source string is already a shared string itself. This saves a useless String allocation on each call. Notes: Merged: https://github.com/ruby/ruby/pull/6443
2022-09-26Fix coderange calculation in String#bKazuki Yamaguchi
Leave the new coderange unknown if the original encoding is not ASCII-compatible. Non-ASCII-compatible encoding strings with valid or broken coderange can end up as ascii-only. Fixes 9a8f6e392fbd ("Cheaply derive code range for String#b return value", 2022-07-25).
2022-09-23Revert "Revert "error.c: Let Exception#inspect inspect its message""Yusuke Endoh
This reverts commit b9f030954a8a1572032f3548b39c5b8ac35792ce. [Bug #18170]
2022-09-12Remove get_actual_encoding() and the dynamic endian detection for dummy ↵Benoit Daloze
UTF-16/UTF-32 * And simplify callers of get_actual_encoding(). * See [Feature #18949]. * See https://github.com/ruby/ruby/pull/6322#issuecomment-1242758474
2022-09-09Avoid unnecessary copying when removing the leading part of a stringKazuki Yamaguchi
Remove the superfluous str_modify_keep_cr() call from rb_str_update(). It ends up calling either rb_str_drop_bytes() or rb_str_splice_0(), which already does checks if necessary. The extra call makes the string "independent". This is not always wanted, in other words, it can keep the same shared root when merely removing the leading part of a shared string. Notes: Merged: https://github.com/ruby/ruby/pull/6336
2022-09-08rb_str_concat_literals: use rb_str_buf_appendJean Boussier
That's about 1.30x faster. Notes: Merged: https://github.com/ruby/ruby/pull/6334
2022-09-08[DOC] non-positive `base` in `Kernel#Integer` and `String#to_i`Nobuyoshi Nakada
2022-08-31[Bug #18973] Promote US-ASCII to ASCII-8BIT when adding 8-bit charNobuyoshi Nakada
Notes: Merged: https://github.com/ruby/ruby/pull/6306
2022-08-27[DOC] Fix a typo [ci skip]Nobuyoshi Nakada
2022-08-20Check if encoding capable object before check if ASCII compatibleNobuyoshi Nakada
Notes: Merged: https://github.com/ruby/ruby/pull/6260
2022-08-18rb_str_resize: Only clear coderange on truncationJean Boussier
If we are expanding the string or only stripping extra capacity then coderange won't change, so clearing it is wasteful. Notes: Merged: https://github.com/ruby/ruby/pull/6178
2022-08-11Fix inspect for unicode codepoint 0x85Jeremy Evans
This is an inelegant hack, by manually checking for this specific code point in rb_str_inspect. Some testing indicates that this is the only code point affected. It's possible a better fix would be inside of lower-level encoding code, such that rb_enc_isprint would return false and not true for codepoint 0x85. Fixes [Bug #16842] Notes: Merged: https://github.com/ruby/ruby/pull/4229
2022-07-26Adjust indent [ci skip]Nobuyoshi Nakada
2022-07-26Cheaply derive code range for String#b return valueKevin Menard
The result of String#b is a string with an ASCII_8BIT/BINARY encoding. That encoding is ASCII-compatible and has no byte sequences that are invalid for the encoding. If we know the receiver's code range, we can derive the resulting string's code range without needing to perform a full code range scan. Notes: Merged: https://github.com/ruby/ruby/pull/6183
2022-07-25rb_str_buf_append: add a fast path for ENC_CODERANGE_VALIDJean Boussier
If the RHS has valid encoding, and both strings have the same encoding, we can use the fast path. However we need to update the LHS coderange. ``` compare-ruby: ruby 3.2.0dev (2022-07-21T14:46:32Z master cdbb9b8555) [arm64-darwin21] built-ruby: ruby 3.2.0dev (2022-07-25T07:25:41Z string-concat-vali.. 11a2772bdd) [arm64-darwin21] warming up... | |compare-ruby|built-ruby| |:-------------------|-----------:|---------:| |binary_concat_7bit | 554.816k| 556.460k| | | -| 1.00x| |utf8_concat_7bit | 556.367k| 555.101k| | | 1.00x| -| |utf8_concat_UTF8 | 412.555k| 556.824k| | | -| 1.35x| ``` Notes: Merged: https://github.com/ruby/ruby/pull/6163
2022-07-21Expand tabs [ci skip]Takashi Kokubun
[Misc #18891] Notes: Merged: https://github.com/ruby/ruby/pull/6094
2022-07-21Make String#each_line work correctly with paragraph separator and chompJeremy Evans
Previously, it was including one newline when chomp was used, which is inconsistent with IO#each_line behavior. This makes behavior consistent with IO#each_line, chomping all paragraph separators (multiple consecutive newlines), but not single newlines. Partially Fixes [Bug #18768] Notes: Merged: https://github.com/ruby/ruby/pull/5960
2022-07-21string.c: use str_enc_fastpath in TERM_LENJean Boussier
Not having to fetch the rb_encoding save a significant amount of time. Additionally, even when we have to fetch it, we can do it faster using `ENCODING_GET` rather than `rb_enc_get`. ``` compare-ruby: ruby 3.2.0dev (2022-07-19T08:41:40Z master cb9fd920a3) [arm64-darwin21] built-ruby: ruby 3.2.0dev (2022-07-21T11:16:16Z faster-buffer-conc.. 4f001f0748) [arm64-darwin21] warming up... | |compare-ruby|built-ruby| |:---------------------|-----------:|---------:| |binary_concat_utf8 | 510.580k| 565.600k| | | -| 1.11x| |binary_concat_binary | 512.653k| 571.483k| | | -| 1.11x| |utf8_concat_utf8 | 511.396k| 566.879k| | | -| 1.11x| ``` Notes: Merged: https://github.com/ruby/ruby/pull/6160
2022-07-19str_buf_cat: preserve coderange when going through fastpathJean Boussier
rb_str_modify clear the coderange, which in this case isn't necessary. ``` compare-ruby: ruby 3.2.0dev (2022-07-12T15:01:11Z master 71aec68566) [arm64-darwin21] built-ruby: ruby 3.2.0dev (2022-07-19T07:17:01Z faster-buffer-conc.. 3cad62aab4) [arm64-darwin21] warming up... | |compare-ruby|built-ruby| |:---------------------|-----------:|---------:| |binary_concat_utf8 | 360.617k| 605.091k| | | -| 1.68x| |binary_concat_binary | 446.650k| 605.053k| | | -| 1.35x| |utf8_concat_utf8 | 454.166k| 597.311k| | | -| 1.32x| ``` ``` | |compare-ruby|built-ruby| |:-----------|-----------:|---------:| |erb_render | 1.790M| 2.045M| | | -| 1.14x| ``` Notes: Merged: https://github.com/ruby/ruby/pull/6120
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-15 10:02:51 +0000