Merge pull request #1621 from jgonet/jgonet/binary-match

Implement binary:match/2 and binary:match/3

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

@@ -51,6 +51,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added Process.link/1 and unlink/1 to Elixir Process.ex
 - Added `erlang:module_loaded/1`
 - Added `binary:replace/3`, `binary:replace/4`
+- Added `binary:match/2` and `binary:match/3`
 
 ### Changed
 

src/libAtomVM/defaultatoms.def

@@ -185,3 +185,6 @@ X(CONNECT_ATOM, "\x7", "connect")
 X(SYSTEM_VERSION_ATOM, "\xE", "system_version")
 X(OTP_RELEASE_ATOM, "\xB", "otp_release")
 X(BREAK_IGNORED_ATOM, "\xD", "break_ignored")
+
+X(SCOPE_ATOM, "\x5", "scope")
+X(NOMATCH_ATOM, "\x7", "nomatch")

src/libAtomVM/nifs.c

@@ -96,6 +96,7 @@ 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_binary_match(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[]);
@@ -266,6 +267,12 @@ static const struct Nif binary_replace_nif =
     .nif_ptr = nif_binary_replace
 };
 
+static const struct Nif binary_match_nif =
+{
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_binary_match
+};
+
 static const struct Nif make_ref_nif =
 {
     .base.type = NIFFunctionType,
@@ -3387,6 +3394,142 @@ static term nif_binary_replace(Context *ctx, int argc, term argv[])
     return result_binary;
 }
 
+static bool get_binary_scope_slice(term binary, term options, BinaryPosLen *scope_slice)
+{
+    term scope_opt = term_invalid_term();
+    while (term_is_nonempty_list(options)) {
+        term head = term_get_list_head(options);
+        // BEAM ignores improper lists so we don't check for it
+        if (LIKELY(term_is_tuple(head) && term_get_tuple_arity(head) == 2 && term_get_tuple_element(head, 0) == SCOPE_ATOM)) {
+            scope_opt = term_get_tuple_element(head, 1);
+        } else {
+            return false;
+        }
+        options = term_get_list_tail(options);
+    }
+
+    if (term_is_invalid_term(scope_opt)) {
+        size_t size = term_binary_size(binary);
+        return term_normalize_binary_pos_len(binary, 0, (avm_int_t) size, scope_slice);
+    }
+
+    if (UNLIKELY(!term_is_tuple(scope_opt) || term_get_tuple_arity(scope_opt) != 2)) {
+        return false;
+    }
+
+    term pos_term = term_get_tuple_element(scope_opt, 0);
+    term len_term = term_get_tuple_element(scope_opt, 1);
+    if (UNLIKELY(!term_is_integer(pos_term) || !term_is_integer(len_term))) {
+        return false;
+    }
+
+    avm_int_t pos = term_to_int(pos_term);
+    avm_int_t len = term_to_int(len_term);
+    return term_normalize_binary_pos_len(binary, pos, len, scope_slice);
+}
+
+static bool is_valid_pattern(term t)
+{
+    if (term_is_binary(t)) {
+        return term_binary_size(t) > 0;
+    }
+
+    if (!term_is_nonempty_list(t)) {
+        return false;
+    }
+
+    while (term_is_nonempty_list(t)) {
+        term pattern_term = term_get_list_head(t);
+        if (UNLIKELY(!term_is_binary(pattern_term))) {
+            return false;
+        }
+        if (UNLIKELY(term_binary_size(pattern_term) == 0)) {
+            return false;
+        }
+        t = term_get_list_tail(t);
+    }
+    bool proper = term_is_nil(t);
+    if (UNLIKELY(!proper)) {
+        return false;
+    }
+    return true;
+}
+
+static BinaryPosLen find_pattern_in_binary(term binary_term, BinaryPosLen scope_slice, term pattern_term)
+{
+    const char *binary = term_binary_data(binary_term) + scope_slice.pos;
+    size_t size = scope_slice.len;
+    const char *pattern = term_binary_data(pattern_term);
+    size_t pattern_size = term_binary_size(pattern_term);
+
+    BinaryPosLen pattern_slice = term_nomatch_binary_pos_len();
+    const char *sub_binary = memmem(binary, size, pattern, pattern_size);
+    if (sub_binary != NULL) {
+        pattern_slice.len = pattern_size;
+        pattern_slice.pos = (sub_binary - binary) + scope_slice.pos;
+    }
+    return pattern_slice;
+}
+
+static BinaryPosLen select_earlier_slice(BinaryPosLen old_slice, BinaryPosLen new_slice)
+{
+    if (term_is_nomatch_binary_pos_len(new_slice)) {
+        return old_slice;
+    }
+    if (term_is_nomatch_binary_pos_len(old_slice)) {
+        return new_slice;
+    }
+    if (new_slice.pos < old_slice.pos) {
+        return new_slice;
+    }
+    if (new_slice.pos == old_slice.pos && new_slice.len > old_slice.len) {
+        return new_slice;
+    }
+    return old_slice;
+}
+
+static term nif_binary_match(Context *ctx, int argc, term argv[])
+{
+    term binary_term = argv[0];
+    term pattern_or_patterns_term = argv[1];
+    term options_term = argc == 3 ? argv[2] : term_nil();
+
+    VALIDATE_VALUE(binary_term, term_is_binary);
+    VALIDATE_VALUE(options_term, term_is_list);
+    VALIDATE_VALUE(pattern_or_patterns_term, is_valid_pattern);
+
+    BinaryPosLen scope_slice;
+    if (UNLIKELY(!get_binary_scope_slice(binary_term, options_term, &scope_slice))) {
+        RAISE_ERROR(BADARG_ATOM);
+    }
+
+    BinaryPosLen match_slice = term_nomatch_binary_pos_len();
+    if (term_is_binary(pattern_or_patterns_term)) {
+        term pattern_term = pattern_or_patterns_term;
+        match_slice = find_pattern_in_binary(binary_term, scope_slice, pattern_term);
+    } else {
+        term patterns = pattern_or_patterns_term;
+        while (term_is_nonempty_list(patterns)) {
+            term pattern_term = term_get_list_head(patterns);
+            BinaryPosLen new_match_slice = find_pattern_in_binary(binary_term, scope_slice, pattern_term);
+            match_slice = select_earlier_slice(match_slice, new_match_slice);
+            patterns = term_get_list_tail(patterns);
+        }
+    }
+
+    if (term_is_nomatch_binary_pos_len(match_slice)) {
+        return NOMATCH_ATOM;
+    }
+
+    if (UNLIKELY(memory_ensure_free_opt(ctx, TUPLE_SIZE(2), MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+        RAISE_ERROR(OUT_OF_MEMORY_ATOM);
+    }
+    term result_tuple = term_alloc_tuple(2, &ctx->heap);
+    term_put_tuple_element(result_tuple, 0, term_from_int(match_slice.pos));
+    term_put_tuple_element(result_tuple, 1, term_from_int(match_slice.len));
+    return result_tuple;
+}
+
 static term nif_erlang_throw(Context *ctx, int argc, term argv[])
 {
     UNUSED(argc);

src/libAtomVM/nifs.gperf

@@ -41,6 +41,8 @@ binary:split/2, &binary_split_nif
 binary:split/3, &binary_split_nif
 binary:replace/3, &binary_replace_nif
 binary:replace/4, &binary_replace_nif
+binary:match/2, &binary_match_nif
+binary:match/3, &binary_match_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

src/libAtomVM/term.h

@@ -1342,12 +1342,12 @@ static inline bool term_normalize_binary_pos_len(term binary, avm_int_t pos, avm
     return true;
 }
 
-static inline bool term_is_invalid_binary_pos_len(BinaryPosLen pos_len)
+static inline bool term_is_nomatch_binary_pos_len(BinaryPosLen pos_len)
 {
     return pos_len.pos == -1 && pos_len.len == -1;
 }
 
-static inline BinaryPosLen term_invalid_binary_pos_len(void)
+static inline BinaryPosLen term_nomatch_binary_pos_len()
 {
     return (BinaryPosLen) { .pos = -1, .len = -1 };
 }

tests/erlang_tests/CMakeLists.txt

@@ -285,6 +285,7 @@ compile_erlang(test_binary_part)
 compile_erlang(test_binary_split)
 compile_erlang(test_split_binary)
 compile_erlang(test_binary_replace)
+compile_erlang(test_binary_match)
 
 compile_erlang(plusone)
 compile_erlang(plusone2)
@@ -777,6 +778,7 @@ add_custom_target(erlang_test_modules DEPENDS
     test_binary_split.beam
     test_split_binary.beam
     test_binary_replace.beam
+    test_binary_match.beam
 
     plusone.beam
     plusone2.beam

tests/erlang_tests/test_binary_match.erl

@@ -0,0 +1,111 @@
+%
+% This file is part of AtomVM.
+%
+% Copyright 2025 Jakub Gonet <jakub.gonet@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_match).
+
+-export([start/0, id/1, fail_with_badarg/1]).
+-define(ID(Arg), ?MODULE:id(Arg)).
+
+start() ->
+    ok = fail_with_badarg(fun() -> binary:match(?ID(<<"a">>), ?ID(<<"">>)) end),
+    {0, 1} = binary:match(?ID(<<"a">>), ?ID(<<"a">>)),
+    {0, 1} = binary:match(?ID(<<"aa">>), ?ID(<<"a">>)),
+    {0, 2} = binary:match(?ID(<<"aba">>), ?ID(<<"ab">>)),
+
+    % empty subject
+    case get_otp_version() of
+        OTP when OTP =< 26 ->
+            nomatch = binary:match(?ID(<<"">>), ?ID(<<"">>)),
+            nomatch = binary:match(?ID(<<"">>), ?ID(<<"a">>)),
+            nomatch = binary:match(?ID(<<"">>), ?ID([])),
+            % for /3, nomatch only if empty subject + empty options
+            nomatch = binary:match(?ID(<<"">>), ?ID(not_binary), ?ID([]));
+        _AVM_or_newer_OTP ->
+            ok = fail_with_badarg(fun() -> binary:match(?ID(<<"">>), ?ID(<<"">>)) end),
+            nomatch = binary:match(?ID(<<"">>), ?ID(<<"a">>)),
+            ok = fail_with_badarg(fun() -> binary:match(?ID(<<"">>), ?ID([])) end),
+            ok = fail_with_badarg(fun() -> binary:match(?ID(<<"">>), ?ID(not_binary), ?ID([])) end)
+    end,
+
+    % list of patterns
+    ok = fail_with_badarg(fun() -> binary:match(?ID(<<"a">>), ?ID([])) end),
+    ok = fail_with_badarg(fun() -> binary:match(?ID(<<"a">>), ?ID([<<"">>])) end),
+    {0, 1} = binary:match(?ID(<<"a">>), ?ID([<<"a">>])),
+    {0, 1} = binary:match(?ID(<<"a">>), ?ID([<<"a">>, <<"a">>])),
+    {0, 2} = binary:match(?ID(<<"aa">>), ?ID([<<"a">>, <<"aa">>])),
+
+    % scope opt
+    nomatch = binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {0, 0}}])),
+    nomatch = binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {1, 0}}])),
+    nomatch = binary:match(?ID(<<"bab">>), ?ID(<<"b">>), ?ID([{scope, {1, 0}}])),
+    {2, 1} = binary:match(?ID(<<"bab">>), ?ID(<<"b">>), ?ID([{scope, {1, 2}}])),
+    % {scope, {1, -1}}: starts at 0, 1 byte long
+    {0, 1} = binary:match(?ID(<<"bab">>), ?ID(<<"b">>), ?ID([{scope, {1, -1}}])),
+
+    % bad inputs, subjects must be non-empty to not short-circuit
+    ok = fail_with_badarg(fun() -> binary:match(?ID(not_binary), ?ID(<<"a">>)) end),
+    ok = fail_with_badarg(fun() -> binary:match(?ID(<<"a">>), ?ID(not_binary)) end),
+    ok = fail_with_badarg(fun() -> binary:match(?ID(<<"a">>), ?ID([<<"a">> | <<"a">>])) end),
+    ok = fail_with_badarg(fun() -> binary:match(?ID(not_binary), ?ID(<<"a">>), ?ID([])) end),
+    ok = fail_with_badarg(fun() -> binary:match(?ID(<<"a">>), ?ID(not_binary), ?ID([])) end),
+    ok = fail_with_badarg(fun() -> binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID(not_list)) end),
+    ok = fail_with_badarg(fun() ->
+        binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {1, 0}}, badopt]))
+    end),
+    % following line should raise but BEAM doesn't do that
+    nomatch = binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {1, 0}} | badopt])),
+    ok = fail_with_badarg(fun() ->
+        binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, not_tuple}]))
+    end),
+    ok = fail_with_badarg(fun() -> binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {1}}])) end),
+    ok = fail_with_badarg(fun() ->
+        binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {1, 2, 3}}]))
+    end),
+
+    % bad scope
+    ok = fail_with_badarg(fun() ->
+        binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {0, 2}}]))
+    end),
+    ok = fail_with_badarg(fun() ->
+        binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {0, -1}}]))
+    end),
+    ok = fail_with_badarg(fun() ->
+        binary:match(?ID(<<"a">>), ?ID(<<"a">>), ?ID([{scope, {-1, 1}}]))
+    end),
+    0.
+
+id(X) ->
+    X.
+
+fail_with_badarg(Fun) ->
+    try Fun() of
+        Ret -> {unexpected, Ret}
+    catch
+        error:badarg -> ok;
+        C:E -> {unexpected, C, E}
+    end.
+
+get_otp_version() ->
+    case erlang:system_info(machine) of
+        "BEAM" ->
+            list_to_integer(erlang:system_info(otp_release));
+        _ ->
+            atomvm
+    end.

tests/libs/estdlib/tests.erl

@@ -59,6 +59,11 @@ get_non_networking_tests(OTPVersion) when
     (is_integer(OTPVersion) andalso OTPVersion >= 27) orelse OTPVersion =:= atomvm
 ->
     [test_sets | get_non_networking_tests(undefined)];
+% test_binary uses encode_hex/1 (OTP-24), encode_hex/2 (OTP-26)
+get_non_networking_tests(OTPVersion) when
+    (is_integer(OTPVersion) andalso OTPVersion >= 26) orelse OTPVersion =:= atomvm
+->
+    [test_binary | get_non_networking_tests(undefined)];
 get_non_networking_tests(_OTPVersion) ->
     [
         test_apply,

tests/test.c

@@ -326,6 +326,7 @@ struct Test tests[] = {
     TEST_CASE(test_binary_split),
     TEST_CASE(test_split_binary),
     TEST_CASE(test_binary_replace),
+    TEST_CASE(test_binary_match),
 
     TEST_CASE_COND(plusone, 134217728, LONG_MAX != 9223372036854775807),
 
@@ -634,18 +635,23 @@ static int test_atom(struct Test *test)
 static int test_beam(struct Test *test)
 {
     char command[512];
-    snprintf(command, sizeof(command),
+    size_t written = snprintf(command, sizeof(command),
         "erl -pa . -eval '"
-        "erlang:process_flag(trap_exit, false), " /* init(3) traps exists */
-        "R = %s:start(), "
-        "S = if"
-        " R =:= %i -> 0;"
-        " true -> io:format(\"Expected ~B, got ~p\n\", [%i, R]) "
-        "end, "
+        "erlang:process_flag(trap_exit, false), \n" /* init(3) traps exits */
+        "S = try %s:start() of\n"
+        "    R when R =:= %i -> 0;\n"
+        "    R               -> io:format(\"Expected ~B, got ~p\\n\", [%i, R]), 1\n"
+        "catch\n"
+        "    _C:E:ST -> io:format(\"Raised ~p, stacktrace:\\n~p\\n\", [E, ST]), 1\n"
+        "end,\n"
         "erlang:halt(S).' -noshell",
         test->test_module,
         test->expected_value,
         test->expected_value);
+    if (written >= sizeof(command) - 1) {
+        fprintf(stderr, "Exceeded buffer size for module %s\n", test->test_module);
+        return 1;
+    }
     return system(command);
 }