Merge pull request #1704 from jgonet/jgonet/binary-replace

Add binary:replace/4

These changes are made under both the "Apache 2.0" and the "GNU Lesser General
Public License 2.1 or later" license terms (dual license).

SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later

Author: bettio

CHANGELOG.md

@@ -50,6 +50,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added WiFi support for ESP32P4 via esp-wifi-external for build with ESP-IDF v5.4 and later
 - Added Process.link/1 and unlink/1 to Elixir Process.ex
 - Added `erlang:module_loaded/1`
+- Added `binary:replace/3`, `binary:replace/4`
 
 ### Changed
 

libs/estdlib/src/binary.erl

@@ -25,7 +25,9 @@
 %%-----------------------------------------------------------------------------
 -module(binary).
 
--export([at/2, decode_hex/1, encode_hex/1, encode_hex/2, part/3, split/2, split/3]).
+-export([
+    at/2, decode_hex/1, encode_hex/1, encode_hex/2, part/3, split/2, split/3, replace/3, replace/4
+]).
 
 %%-----------------------------------------------------------------------------
 %% @param   Binary binary to get a byte from
@@ -115,3 +117,37 @@ split(_Binary, _Pattern) ->
 -spec split(Binary :: binary(), Pattern :: binary(), Option :: [global]) -> [binary()].
 split(_Binary, _Pattern, _Option) ->
     erlang:nif_error(undefined).
+
+%%-----------------------------------------------------------------------------
+%% @equiv replace(Binary, Pattern, Replacement, [])
+%% @param   Binary      binary where the replacements should occur
+%% @param   Pattern     binary pattern which is to be replaced
+%% @param   Replacement binary which will replace the pattern
+%% @return  resulting binary after replacements
+%% @doc     Replaces first occurrence of Pattern in Binary with Replacement.
+%%          If Pattern is not found, returns the original binary unchanged.
+%%          Pattern and Replacement must be binaries.
+%% @end
+%%-----------------------------------------------------------------------------
+-spec replace(Binary :: binary(), Pattern :: binary(), Replacement :: binary()) -> binary().
+replace(_Binary, _Pattern, _Replacement) ->
+    erlang:nif_error(undefined).
+
+%%-----------------------------------------------------------------------------
+%% @param   Binary      binary where the replacements should occur
+%% @param   Pattern     binary pattern which is to be replaced
+%% @param   Replacement binary which will replace the pattern
+%% @param   Options     list of options for the replacement operations.
+%% @return  resulting binary after replacements
+%% @doc     Replaces occurrences of Pattern in Binary with Replacement.
+%%          If Options includes `global', replaces all occurrences; otherwise, replaces just the first occurrence.
+%%          If Pattern is not found, returns the original binary unchanged.
+%%          Pattern and Replacement must be binaries.
+%%          Only implemented option is `global'.
+%% @end
+%%-----------------------------------------------------------------------------
+-spec replace(
+    Binary :: binary(), Pattern :: binary(), Replacement :: binary(), Options :: [global] | []
+) -> binary().
+replace(_Binary, _Pattern, _Replacement, _Options) ->
+    erlang:nif_error(undefined).

src/libAtomVM/nifs.c

@@ -95,6 +95,7 @@ static term nif_binary_first_1(Context *ctx, int argc, term argv[]);
 static term nif_binary_last_1(Context *ctx, int argc, term argv[]);
 static term nif_binary_part_3(Context *ctx, int argc, term argv[]);
 static term nif_binary_split(Context *ctx, int argc, term argv[]);
+static term nif_binary_replace(Context *ctx, int argc, term argv[]);
 static term nif_calendar_system_time_to_universal_time_2(Context *ctx, int argc, term argv[]);
 static term nif_erlang_delete_element_2(Context *ctx, int argc, term argv[]);
 static term nif_erlang_atom_to_binary(Context *ctx, int argc, term argv[]);
@@ -259,6 +260,12 @@ static const struct Nif binary_split_nif =
     .nif_ptr = nif_binary_split
 };
 
+static const struct Nif binary_replace_nif =
+{
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_binary_replace
+};
+
 static const struct Nif make_ref_nif =
 {
     .base.type = NIFFunctionType,
@@ -3280,6 +3287,106 @@ static term nif_binary_split(Context *ctx, int argc, term argv[])
     return result_list;
 }
 
+static term nif_binary_replace(Context *ctx, int argc, term argv[])
+{
+    term bin_term = argv[0];
+    term pattern = argv[1];
+    term replacement = argv[2];
+    term options = argc == 4 ? argv[3] : term_nil();
+
+    VALIDATE_VALUE(bin_term, term_is_binary);
+    VALIDATE_VALUE(pattern, term_is_binary);
+    VALIDATE_VALUE(replacement, term_is_binary);
+    VALIDATE_VALUE(options, term_is_list);
+
+    bool global = false;
+    while (term_is_nonempty_list(options)) {
+        term head = term_get_list_head(options);
+        if (LIKELY(head == GLOBAL_ATOM)) {
+            global = true;
+        } else {
+            RAISE_ERROR(BADARG_ATOM);
+        }
+        options = term_get_list_tail(options);
+    }
+
+    size_t bin_size = term_binary_size(bin_term);
+    size_t pattern_size = term_binary_size(pattern);
+    size_t repl_size = term_binary_size(replacement);
+
+    if (UNLIKELY(pattern_size == 0 || bin_size == 0)) {
+        RAISE_ERROR(BADARG_ATOM);
+    }
+
+    if (bin_size < pattern_size) {
+        return bin_term;
+    }
+
+    const char *bin_data = term_binary_data(bin_term);
+    const char *pattern_data = term_binary_data(pattern);
+    const char *repl_data = term_binary_data(replacement);
+
+    int pattern_n = 0;
+    const char *sub_bin = bin_data;
+    size_t sub_bin_size = bin_size;
+    while (sub_bin_size >= pattern_size) {
+        const char *found_pattern = memmem(sub_bin, sub_bin_size, pattern_data, pattern_size);
+        if (found_pattern == NULL) {
+            break;
+        }
+        ++pattern_n;
+        if (!global) {
+            break;
+        }
+        size_t found_offset = found_pattern - sub_bin;
+        sub_bin_size -= found_offset + pattern_size;
+        sub_bin = found_pattern + pattern_size;
+    }
+    size_t result_size = bin_size + pattern_n * (repl_size - pattern_size);
+
+    size_t size_binary = term_binary_data_size_in_terms(result_size);
+    term roots[3] = { bin_term, pattern, replacement };
+    if (UNLIKELY(memory_ensure_free_with_roots(ctx, size_binary, 3, roots, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+        RAISE_ERROR(OUT_OF_MEMORY_ATOM);
+    }
+    // update pointers after possible GC
+    bin_term = roots[0];
+    pattern = roots[1];
+    replacement = roots[2];
+    bin_data = term_binary_data(bin_term);
+    pattern_data = term_binary_data(pattern);
+    repl_data = term_binary_data(replacement);
+
+    term result_binary = term_create_uninitialized_binary(result_size, &ctx->heap, ctx->global);
+    char *result_data = (char *) term_binary_data(result_binary);
+
+    size_t bin_idx = 0;
+    size_t result_idx = 0;
+    while (bin_idx <= bin_size - pattern_size) {
+        bool pattern_found = memcmp(bin_data + bin_idx, pattern_data, pattern_size) == 0;
+        if (pattern_found) {
+            memcpy(result_data + result_idx, repl_data, repl_size);
+            result_idx += repl_size;
+            bin_idx += pattern_size;
+            if (!global) {
+                break;
+            }
+        } else {
+            result_data[result_idx] = bin_data[bin_idx];
+            ++result_idx;
+            ++bin_idx;
+        }
+    }
+
+    bool has_leftover = bin_idx < bin_size;
+    if (has_leftover) {
+        // result_idx is not updated, we don't need it
+        memcpy(result_data + result_idx, bin_data + bin_idx, bin_size - bin_idx);
+    }
+
+    return result_binary;
+}
+
 static term nif_erlang_throw(Context *ctx, int argc, term argv[])
 {
     UNUSED(argc);

src/libAtomVM/nifs.gperf

@@ -39,6 +39,8 @@ binary:last/1, &binary_last_nif
 binary:part/3, &binary_part_nif
 binary:split/2, &binary_split_nif
 binary:split/3, &binary_split_nif
+binary:replace/3, &binary_replace_nif
+binary:replace/4, &binary_replace_nif
 calendar:system_time_to_universal_time/2, &system_time_to_universal_time_nif
 erlang:atom_to_binary/1, &atom_to_binary_nif
 erlang:atom_to_binary/2, &atom_to_binary_nif

tests/erlang_tests/CMakeLists.txt

@@ -284,6 +284,7 @@ compile_erlang(test_unicode)
 compile_erlang(test_binary_part)
 compile_erlang(test_binary_split)
 compile_erlang(test_split_binary)
+compile_erlang(test_binary_replace)
 
 compile_erlang(plusone)
 compile_erlang(plusone2)
@@ -775,6 +776,7 @@ add_custom_target(erlang_test_modules DEPENDS
     test_binary_part.beam
     test_binary_split.beam
     test_split_binary.beam
+    test_binary_replace.beam
 
     plusone.beam
     plusone2.beam

tests/erlang_tests/test_binary_replace.erl

@@ -0,0 +1,91 @@
+%
+% This file is part of AtomVM.
+%
+% Copyright 2024 Tomasz Sobkiewicz <tomasz.sobkiewicz@swmansion.com>
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%    http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+%
+% SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
+%
+
+-module(test_binary_replace).
+
+-export([start/0]).
+
+start() ->
+    ok = replace(),
+    ok = global_replace(),
+    ok = invalid_args(),
+    0.
+
+replace() ->
+    <<"barbar">> = binary:replace(<<"foobar">>, <<"foo">>, <<"bar">>),
+    <<"foooobar">> = binary:replace(<<"foobar">>, <<"o">>, <<"ooo">>),
+    <<"">> = binary:replace(<<"foobar">>, <<"foobar">>, <<"">>),
+    <<"foobar">> = binary:replace(<<"o">>, <<"o">>, <<"foobar">>),
+    <<"fof">> = binary:replace(<<"foobar">>, <<"obar">>, <<"f">>),
+    <<"fobar">> = binary:replace(<<"foobar">>, <<"oo">>, <<"o">>),
+    <<"o">> = binary:replace(<<"o">>, <<"foobar">>, <<"o">>),
+    <<"foobar">> = binary:replace(<<"o">>, <<"o">>, <<"foobar">>),
+    <<"fobar">> = binary:replace(<<"foobar">>, <<"oo">>, <<"o">>, []),
+    <<"foo">> = binary:replace(<<"foofoo">>, <<"foo">>, <<"">>, []),
+    ok.
+
+global_replace() ->
+    <<"foobar">> = binary:replace(<<"foooobar">>, <<"oo">>, <<"o">>, [global]),
+    <<"foooobar">> = binary:replace(<<"foobar">>, <<"o">>, <<"oo">>, [global]),
+    <<"">> = binary:replace(<<"foofoo">>, <<"foo">>, <<"">>, [global]),
+    <<"foofoo">> = binary:replace(<<"oo">>, <<"o">>, <<"foo">>, [global]),
+    ok.
+
+invalid_args() ->
+    case vm_info() of
+        {beam, V} when V =< 26 ->
+            <<"">> = binary:replace(<<"">>, <<"">>, <<"">>),
+            <<"">> = binary:replace(<<"">>, <<"">>, <<"">>, [global]);
+        _Otp27OrAtomVm ->
+            ok = raises(badarg, fun() -> binary:replace(<<"">>, <<"">>, <<"">>) end),
+            ok = raises(badarg, fun() -> binary:replace(<<"">>, <<"">>, <<"">>, [global]) end)
+    end,
+    ok = raises(badarg, fun() -> binary:replace(<<"o">>, <<"">>, <<"">>) end),
+    ok = raises(badarg, fun() -> binary:replace(not_binary, <<"">>, <<"">>) end),
+    ok = raises(badarg, fun() -> binary:replace(<<"o">>, not_binary, <<"">>) end),
+    ok = raises(badarg, fun() -> binary:replace(<<"o">>, <<"">>, not_binary) end),
+    ok = raises(badarg, fun() -> binary:replace(<<"o">>, <<"">>, <<"">>, [global]) end),
+    ok = raises(badarg, fun() -> binary:replace(<<"o">>, <<"o">>, <<"">>, [{global, true}]) end),
+    % insert_replaced not supported
+    ok = raises(badarg, fun() ->
+        binary:replace(<<"o">>, <<"o">>, <<"">>, [global, {insert_replaced, 1}])
+    end),
+    ok = raises(badarg, fun() ->
+        binary:replace(<<"o">>, <<"o">>, <<"">>, [{insert_replaced, 1}])
+    end),
+    ok.
+
+raises(Error, F) ->
+    try F() of
+        V ->
+            {unexpected, V}
+    catch
+        error:Error -> ok;
+        C:E -> {unexpected, C, E}
+    end.
+
+vm_info() ->
+    case erlang:system_info(machine) of
+        "BEAM" ->
+            Otp = list_to_integer(erlang:system_info(otp_release)),
+            {beam, Otp};
+        _ ->
+            atomvm
+    end.

tests/test.c

@@ -325,6 +325,7 @@ struct Test tests[] = {
     TEST_CASE(test_binary_part),
     TEST_CASE(test_binary_split),
     TEST_CASE(test_split_binary),
+    TEST_CASE(test_binary_replace),
 
     TEST_CASE_COND(plusone, 134217728, LONG_MAX != 9223372036854775807),