[Openmp-commits] [openmp] 2d8a394 - [libomp] Add kmp_str_ref (ADT 1/2) (#176162)
via Openmp-commits
openmp-commits at lists.llvm.org
Mon Jun 15 08:28:44 PDT 2026
Author: Robert Imschweiler
Date: 2026-06-15T17:20:56+02:00
New Revision: 2d8a394129b3b538071f7774e34c31d7cbf3c882
URL: https://github.com/llvm/llvm-project/commit/2d8a394129b3b538071f7774e34c31d7cbf3c882
DIFF: https://github.com/llvm/llvm-project/commit/2d8a394129b3b538071f7774e34c31d7cbf3c882.diff
LOG: [libomp] Add kmp_str_ref (ADT 1/2) (#176162)
libomp currently has two limitations:
1) although it's C++, it doesn't link against the C++ stdlib 2) it
cannot link against the implementation of LLVM ADTs
These limitations shall not be altered at the moment.
As a result, this commit introduces kmp_str_ref, which is similar to
LLVM's StringRef. It currently only includes methods I need at the
moment, but it's easily extensible.
Added:
openmp/runtime/src/kmp_adt.cpp
openmp/runtime/src/kmp_adt.h
openmp/runtime/unittests/ADT/CMakeLists.txt
openmp/runtime/unittests/ADT/TestStringRef.cpp
Modified:
openmp/runtime/src/CMakeLists.txt
openmp/runtime/src/kmp_str.cpp
openmp/runtime/src/kmp_str.h
openmp/runtime/unittests/CMakeLists.txt
openmp/runtime/unittests/String/TestKmpStr.cpp
Removed:
################################################################################
diff --git a/openmp/runtime/src/CMakeLists.txt b/openmp/runtime/src/CMakeLists.txt
index 463b8fe2f14aa..f8b9260af8c17 100644
--- a/openmp/runtime/src/CMakeLists.txt
+++ b/openmp/runtime/src/CMakeLists.txt
@@ -81,6 +81,7 @@ if(STUBS_LIBRARY)
else()
# Get C++ files
set(LIBOMP_CXXFILES
+ kmp_adt.cpp
kmp_alloc.cpp
kmp_atomic.cpp
kmp_csupport.cpp
diff --git a/openmp/runtime/src/kmp_adt.cpp b/openmp/runtime/src/kmp_adt.cpp
new file mode 100644
index 0000000000000..b960b4e0aaf31
--- /dev/null
+++ b/openmp/runtime/src/kmp_adt.cpp
@@ -0,0 +1,63 @@
+/*
+ * kmp_adt.cpp -- Advanced Data Types used internally
+ *
+ * FIXME: This is in intermediate solution until we agree and implement some
+ * common resource according to
+ * https://discourse.llvm.org/t/meta-rfc-adts-without-c-runtime-dependency/90317.
+ * As soon as we will have this common resource that can be used for runtimes
+ * such as openmp that want to avoid the link dependency to the C++ STL, this
+ * shall be refactored.
+ */
+
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "kmp_adt.h"
+#include "kmp.h"
+#include "kmp_str.h"
+
+#include <cctype>
+#include <cstring>
+
+bool kmp_str_ref::consume_integer(int &value, bool allow_zero,
+ bool allow_negative) {
+ kmp_str_ref orig = *this; // save state
+ bool is_negative = consume_front("-");
+ if (is_negative && !allow_negative) {
+ *this = orig;
+ return false;
+ }
+ size_t num_digits = count_while(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+ if (!num_digits) {
+ *this = orig;
+ return false;
+ }
+ value = __kmp_basic_str_to_int(data, num_digits);
+ if (value == INT_MAX) {
+ *this = orig;
+ return false;
+ }
+ drop_front(num_digits);
+ if (is_negative)
+ value = -value;
+ if (!allow_zero && value == 0) {
+ *this = orig;
+ return false;
+ }
+ return true;
+}
+
+char *kmp_str_ref::copy() const {
+ char *copy_str = static_cast<char *>(KMP_INTERNAL_MALLOC(len + 1));
+ if (!copy_str)
+ KMP_FATAL(MemoryAllocFailed);
+ memcpy(copy_str, data, len);
+ copy_str[len] = '\0';
+ return copy_str;
+}
diff --git a/openmp/runtime/src/kmp_adt.h b/openmp/runtime/src/kmp_adt.h
new file mode 100644
index 0000000000000..c0321d9faefb3
--- /dev/null
+++ b/openmp/runtime/src/kmp_adt.h
@@ -0,0 +1,142 @@
+/*
+ * kmp_adt.h -- Advanced Data Types used internally
+ *
+ * FIXME: This is in intermediate solution until we agree and implement some
+ * common resource according to
+ * https://discourse.llvm.org/t/meta-rfc-adts-without-c-runtime-dependency/90317.
+ * As soon as we will have this common resource that can be used for runtimes
+ * such as openmp that want to avoid the link dependency to the C++ STL, this
+ * shall be refactored.
+ */
+
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef KMP_ADT_H
+#define KMP_ADT_H
+
+#include <cassert>
+#include <cctype>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+
+/// kmp_str_ref is a non-owning string class (similar to llvm::StringRef).
+class kmp_str_ref final {
+ const char *data;
+ size_t len;
+
+public:
+ static constexpr size_t npos = SIZE_MAX;
+
+ kmp_str_ref(const char *str) : data(str), len(str ? strlen(str) : 0) {}
+ kmp_str_ref(const char *str, size_t len) : data(str), len(len) {
+ assert((data || !len) && "len must be 0 for nullptr data");
+ }
+
+ kmp_str_ref(const kmp_str_ref &other) = default;
+ kmp_str_ref &operator=(const kmp_str_ref &other) = default;
+
+ /// Check if the string starts with the given prefix and remove it from the
+ /// string afterwards.
+ bool consume_front(kmp_str_ref prefix) {
+ if (len < prefix.len)
+ return false;
+ if (empty() || prefix.empty()) // avoid calling memcmp on potential nullptr
+ return true;
+ if (memcmp(data, prefix.data, prefix.len) != 0)
+ return false;
+ drop_front(prefix.len);
+ return true;
+ }
+
+ /// Start consuming an integer from the start of the string and remove it from
+ /// the string afterwards.
+ /// The maximum integer value that can currently be parsed is INT_MAX - 1.
+ bool consume_integer(int &value, bool allow_zero = true,
+ bool allow_negative = false);
+
+ /// Get an own duplicate of the string.
+ /// Must be freed with KMP_INTERNAL_FREE().
+ char *copy() const;
+
+ /// Count the number of characters in the string while the predicate returns
+ /// true.
+ template <typename Fn> size_t count_while(const Fn &predicate) const {
+ static_assert(std::is_invocable_r_v<bool, Fn, char>,
+ "predicate must be callable as bool(char)");
+ size_t n = find_if_not(predicate);
+ return n == npos ? len : n;
+ }
+
+ /// Drop the first n characters from the string.
+ /// (Limit n to the length of the string.)
+ void drop_front(size_t n) {
+ if (n > len)
+ n = len;
+ data += n;
+ len -= n;
+ }
+
+ /// Drop characters from the string while the predicate returns true.
+ template <typename Fn> void drop_while(const Fn &predicate) {
+ static_assert(std::is_invocable_r_v<bool, Fn, char>,
+ "predicate must be callable as bool(char)");
+ drop_front(count_while(predicate));
+ }
+
+ /// Check if the string is empty.
+ bool empty() const { return len == 0; }
+
+ /// Return the index of the first character in the string for which the
+ /// predicate returns true.
+ /// Returns npos if no match is found.
+ template <typename Fn> size_t find_if(const Fn &predicate) const {
+ static_assert(std::is_invocable_r_v<bool, Fn, char>,
+ "predicate must be callable as bool(char)");
+ size_t i = 0;
+ while (i < len && !predicate(data[i]))
+ ++i;
+ return i < len ? i : npos;
+ }
+
+ /// Return the index of the first character in the string for which the
+ /// predicate returns false.
+ /// Returns npos if no match is found.
+ template <typename Fn> size_t find_if_not(const Fn &predicate) const {
+ static_assert(std::is_invocable_r_v<bool, Fn, char>,
+ "predicate must be callable as bool(char)");
+ return find_if([predicate](char c) { return !predicate(c); });
+ }
+
+ /// Get the length of the string.
+ size_t length() const { return len; }
+ size_t size() const { return length(); }
+
+ /// Drop space from the start of the string.
+ void skip_space() {
+ drop_while([](char c) {
+ return static_cast<bool>(isspace(static_cast<unsigned char>(c)));
+ });
+ }
+
+ /// Construct a new string with the longest prefix of the original string that
+ /// satisfies the predicate. Doesn't modify the original string.
+ template <typename Fn> kmp_str_ref take_while(const Fn &predicate) const {
+ static_assert(std::is_invocable_r_v<bool, Fn, char>,
+ "predicate must be callable as bool(char)");
+ return kmp_str_ref(data, count_while(predicate));
+ }
+
+ /// Iterator support (raw pointers work as iterators for contiguous storage)
+ const char *begin() const { return data; }
+ const char *end() const { return data + len; }
+};
+
+#endif // KMP_ADT_H
diff --git a/openmp/runtime/src/kmp_str.cpp b/openmp/runtime/src/kmp_str.cpp
index 12cce53074821..83387678f6b73 100644
--- a/openmp/runtime/src/kmp_str.cpp
+++ b/openmp/runtime/src/kmp_str.cpp
@@ -619,13 +619,13 @@ char *__kmp_str_token(
return token;
} // __kmp_str_token
-int __kmp_basic_str_to_int(char const *str) {
+int __kmp_basic_str_to_int(char const *str, size_t maxlen) {
int result;
char const *t;
result = 0;
- for (t = str; *t != '\0'; ++t) {
+ for (t = str; *t != '\0' && maxlen > 0; ++t, --maxlen) {
if (*t < '0' || *t > '9')
break;
// Cap parsing to create largest integer
diff --git a/openmp/runtime/src/kmp_str.h b/openmp/runtime/src/kmp_str.h
index 11f633cd8024f..9b0d2bbd56960 100644
--- a/openmp/runtime/src/kmp_str.h
+++ b/openmp/runtime/src/kmp_str.h
@@ -13,6 +13,7 @@
#ifndef KMP_STR_H
#define KMP_STR_H
+#include <limits.h>
#include <stdarg.h>
#include <string.h>
@@ -112,7 +113,7 @@ int __kmp_str_match_true(char const *data);
void __kmp_str_replace(char *str, char search_for, char replace_with);
void __kmp_str_split(char *str, char delim, char **head, char **tail);
char *__kmp_str_token(char *str, char const *delim, char **buf);
-int __kmp_basic_str_to_int(char const *str);
+int __kmp_basic_str_to_int(char const *str, size_t maxlen = SIZE_MAX);
int __kmp_str_to_int(char const *str, char sentinel);
void __kmp_str_to_size(char const *str, size_t *out, size_t dfactor,
diff --git a/openmp/runtime/unittests/ADT/CMakeLists.txt b/openmp/runtime/unittests/ADT/CMakeLists.txt
new file mode 100644
index 0000000000000..a29e70afe6df6
--- /dev/null
+++ b/openmp/runtime/unittests/ADT/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_openmp_unittest(ADTTests
+ TestStringRef.cpp
+)
+
diff --git a/openmp/runtime/unittests/ADT/TestStringRef.cpp b/openmp/runtime/unittests/ADT/TestStringRef.cpp
new file mode 100644
index 0000000000000..8e161eb78f50a
--- /dev/null
+++ b/openmp/runtime/unittests/ADT/TestStringRef.cpp
@@ -0,0 +1,736 @@
+//===- TestStringRef.cpp - Tests for kmp_str_ref class -------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "kmp_adt.h"
+#include "kmp.h"
+#include "gtest/gtest.h"
+#include <cstring>
+
+namespace {
+
+// Helper to compare kmp_str_ref content with a C string
+static bool equals(const kmp_str_ref &s, const char *expected) {
+ size_t expected_len = strlen(expected);
+ if (s.length() != expected_len)
+ return false;
+ return memcmp(s.begin(), expected, expected_len) == 0;
+}
+
+//===----------------------------------------------------------------------===//
+// Construction and Basic Properties
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, ConstructFromCString) {
+ kmp_str_ref s("Hello");
+ EXPECT_EQ(s.length(), 5u);
+ EXPECT_TRUE(equals(s, "Hello"));
+}
+
+TEST(kmp_str_ref_test, ConstructFromCStringWithLength) {
+ kmp_str_ref s("Hello World", 5);
+ EXPECT_EQ(s.length(), 5u);
+ EXPECT_TRUE(equals(s, "Hello"));
+}
+
+TEST(kmp_str_ref_test, ConstructEmpty) {
+ kmp_str_ref s("");
+ EXPECT_EQ(s.length(), 0u);
+ EXPECT_TRUE(s.empty());
+}
+
+TEST(kmp_str_ref_test, ConstructFromNullptr) {
+ const char *null_str = nullptr;
+ kmp_str_ref s(null_str);
+ EXPECT_EQ(s.length(), 0u);
+ EXPECT_TRUE(s.empty());
+}
+
+TEST(kmp_str_ref_test, ConstructFromNullptrWithLength) {
+ kmp_str_ref s(nullptr, 0);
+ EXPECT_EQ(s.length(), 0u);
+ EXPECT_TRUE(s.empty());
+}
+
+TEST(kmp_str_ref_test, NullptrOperations) {
+ const char *null_str = nullptr;
+ kmp_str_ref s(null_str);
+
+ // Iterators on a null-backed string must be consistent and yield no
+ // elements.
+ EXPECT_EQ(s.begin(), s.end());
+ EXPECT_EQ(s.end() - s.begin(), 0);
+
+ std::string result;
+ for (char c : s)
+ result += c;
+ EXPECT_TRUE(result.empty());
+
+ // Consuming the empty prefix must succeed and leave the string empty.
+ EXPECT_TRUE(s.consume_front(""));
+ EXPECT_TRUE(s.empty());
+
+ // Consuming a non-empty prefix must fail without dereferencing data.
+ EXPECT_FALSE(s.consume_front("x"));
+
+ // count_while must not dereference data when the string is empty.
+ EXPECT_EQ(s.count_while([](char) { return true; }), 0u);
+}
+
+TEST(kmp_str_ref_test, Length) {
+ EXPECT_EQ(kmp_str_ref("").length(), 0u);
+ EXPECT_EQ(kmp_str_ref("a").length(), 1u);
+ EXPECT_EQ(kmp_str_ref("hello").length(), 5u);
+ EXPECT_EQ(kmp_str_ref("hello world").length(), 11u);
+}
+
+TEST(kmp_str_ref_test, Size) {
+ EXPECT_EQ(kmp_str_ref("").size(), 0u);
+ EXPECT_EQ(kmp_str_ref("a").size(), 1u);
+ EXPECT_EQ(kmp_str_ref("hello").size(), 5u);
+ EXPECT_EQ(kmp_str_ref("hello world").size(), 11u);
+}
+
+//===----------------------------------------------------------------------===//
+// empty
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, EmptyString) {
+ kmp_str_ref s("");
+ EXPECT_TRUE(s.empty());
+}
+
+TEST(kmp_str_ref_test, NonEmptyString) {
+ kmp_str_ref s("hello");
+ EXPECT_FALSE(s.empty());
+}
+
+TEST(kmp_str_ref_test, EmptyAfterConsumeFront) {
+ kmp_str_ref s("hello");
+ EXPECT_FALSE(s.empty());
+
+ s.consume_front("hello");
+
+ EXPECT_TRUE(s.empty());
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, EmptyAfterDropFront) {
+ kmp_str_ref s("abc");
+ EXPECT_FALSE(s.empty());
+
+ s.drop_front(3);
+
+ EXPECT_TRUE(s.empty());
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, EmptyAfterDropWhile) {
+ kmp_str_ref s("12345");
+ EXPECT_FALSE(s.empty());
+
+ s.drop_while([](char c) {
+ return static_cast<bool>(isdigit(static_cast<unsigned char>(c)));
+ });
+
+ EXPECT_TRUE(s.empty());
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, EmptyAfterConsumeInteger) {
+ kmp_str_ref s("42");
+ int value = 0;
+ EXPECT_FALSE(s.empty());
+
+ s.consume_integer(value);
+
+ EXPECT_TRUE(s.empty());
+ EXPECT_EQ(s.length(), 0u);
+ EXPECT_EQ(value, 42);
+}
+
+TEST(kmp_str_ref_test, NotEmptyAfterPartialConsume) {
+ kmp_str_ref s("123abc");
+ int value = 0;
+
+ s.consume_integer(value);
+
+ EXPECT_FALSE(s.empty());
+ EXPECT_EQ(s.length(), 3u);
+ EXPECT_TRUE(equals(s, "abc"));
+}
+
+//===----------------------------------------------------------------------===//
+// Iterators
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, BeginEnd) {
+ kmp_str_ref s("Hello");
+ EXPECT_EQ(s.end() - s.begin(), 5);
+ EXPECT_EQ(*s.begin(), 'H');
+}
+
+TEST(kmp_str_ref_test, RangeBasedFor) {
+ kmp_str_ref s("abc");
+ std::string result;
+ for (char c : s) {
+ result += c;
+ }
+ EXPECT_EQ(result, "abc");
+}
+
+//===----------------------------------------------------------------------===//
+// Assignment
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, Assignment) {
+ kmp_str_ref s1("First");
+ kmp_str_ref s2("Second");
+
+ s1 = s2;
+
+ EXPECT_TRUE(equals(s1, "Second"));
+ EXPECT_EQ(s1.length(), 6u);
+}
+
+TEST(kmp_str_ref_test, SelfAssignment) {
+ kmp_str_ref s("Test");
+ kmp_str_ref &s_ref = s;
+ s = s_ref; // Avoid self-assignment warning
+ EXPECT_TRUE(equals(s, "Test"));
+ EXPECT_EQ(s.length(), 4u);
+}
+
+//===----------------------------------------------------------------------===//
+// consume_front
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, ConsumeFrontSuccess) {
+ kmp_str_ref s("Hello World");
+
+ EXPECT_TRUE(s.consume_front("Hello"));
+ EXPECT_EQ(s.length(), 6u);
+ EXPECT_TRUE(equals(s, " World"));
+}
+
+TEST(kmp_str_ref_test, ConsumeFrontFailure) {
+ kmp_str_ref s("Hello World");
+
+ EXPECT_FALSE(s.consume_front("World"));
+ EXPECT_EQ(s.length(), 11u);
+ EXPECT_TRUE(equals(s, "Hello World"));
+}
+
+TEST(kmp_str_ref_test, ConsumeFrontEmpty) {
+ kmp_str_ref s("Hello");
+
+ EXPECT_TRUE(s.consume_front(""));
+ EXPECT_EQ(s.length(), 5u);
+}
+
+TEST(kmp_str_ref_test, ConsumeFrontTooLong) {
+ kmp_str_ref s("Hi");
+
+ EXPECT_FALSE(s.consume_front("Hello"));
+ EXPECT_EQ(s.length(), 2u);
+}
+
+TEST(kmp_str_ref_test, ConsumeFrontExact) {
+ kmp_str_ref s("Hello");
+
+ EXPECT_TRUE(s.consume_front("Hello"));
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, ConsumeFrontMultiple) {
+ kmp_str_ref s("prefix:middle:suffix");
+
+ EXPECT_TRUE(s.consume_front("prefix"));
+ EXPECT_TRUE(s.consume_front(":"));
+ EXPECT_TRUE(s.consume_front("middle"));
+ EXPECT_TRUE(s.consume_front(":"));
+ EXPECT_TRUE(equals(s, "suffix"));
+}
+
+//===----------------------------------------------------------------------===//
+// consume_integer
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, ConsumeIntegerSimple) {
+ kmp_str_ref s("42");
+ int value = 0;
+
+ EXPECT_TRUE(s.consume_integer(value));
+ EXPECT_EQ(value, 42);
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerWithTrailing) {
+ kmp_str_ref s("123abc");
+ int value = 0;
+
+ EXPECT_TRUE(s.consume_integer(value));
+ EXPECT_EQ(value, 123);
+ EXPECT_TRUE(equals(s, "abc"));
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerZero) {
+ kmp_str_ref s("0");
+ int value = -1;
+
+ // allow_zero = true by default
+ EXPECT_TRUE(s.consume_integer(value));
+ EXPECT_EQ(value, 0);
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerZeroNotAllowed) {
+ kmp_str_ref s("0rest");
+ int value = -1;
+
+ EXPECT_FALSE(s.consume_integer(value, /*allow_zero=*/false));
+ // State should be restored on failure
+ EXPECT_TRUE(equals(s, "0rest"));
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerNoDigits) {
+ kmp_str_ref s("abc");
+ int value = -1;
+
+ // No digits to consume, should fail
+ EXPECT_FALSE(s.consume_integer(value));
+ // String should be unchanged
+ EXPECT_TRUE(equals(s, "abc"));
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerEmpty) {
+ kmp_str_ref s("");
+ int value = -1;
+
+ // Empty string has no digits, should fail
+ EXPECT_FALSE(s.consume_integer(value));
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerLeadingZero) {
+ kmp_str_ref s("007");
+ int value = -1;
+
+ EXPECT_TRUE(s.consume_integer(value));
+ EXPECT_EQ(value, 7);
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerNegativeAllowed) {
+ kmp_str_ref s("-42rest");
+ int value = 0;
+
+ EXPECT_TRUE(s.consume_integer(value, true, true));
+ EXPECT_EQ(value, -42);
+ EXPECT_TRUE(equals(s, "rest"));
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerNegativeNotAllowed) {
+ kmp_str_ref s("-42");
+ int value = 0;
+
+ EXPECT_FALSE(s.consume_integer(value, true, false));
+ // State should be restored on failure
+ EXPECT_TRUE(equals(s, "-42"));
+}
+
+TEST(kmp_str_ref_test, ConsumeIntegerMultipleDigits) {
+ kmp_str_ref s("1234567890");
+ int value = 0;
+
+ EXPECT_TRUE(s.consume_integer(value));
+ EXPECT_EQ(value, 1234567890);
+}
+
+//===----------------------------------------------------------------------===//
+// copy
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, Copy) {
+ kmp_str_ref s("Hello");
+ char *copied = s.copy();
+
+ EXPECT_NE(copied, nullptr);
+ EXPECT_STREQ(copied, "Hello");
+ EXPECT_NE(copied, s.begin()); // Different pointer
+
+ KMP_INTERNAL_FREE(copied);
+}
+
+TEST(kmp_str_ref_test, CopyEmpty) {
+ kmp_str_ref s("");
+ char *copied = s.copy();
+
+ EXPECT_NE(copied, nullptr);
+ EXPECT_STREQ(copied, "");
+
+ KMP_INTERNAL_FREE(copied);
+}
+
+TEST(kmp_str_ref_test, CopySubstring) {
+ // Test copying a substring that doesn't have a null terminator at len
+ kmp_str_ref full("device-0)rest");
+ kmp_str_ref sub = full.take_while([](char c) { return c != ')'; });
+
+ EXPECT_EQ(sub.length(), 8u); // "device-0"
+
+ char *copied = sub.copy();
+
+ EXPECT_NE(copied, nullptr);
+ EXPECT_STREQ(copied, "device-0"); // Should NOT include ")"
+ EXPECT_EQ(strlen(copied), 8u);
+
+ KMP_INTERNAL_FREE(copied);
+}
+
+//===----------------------------------------------------------------------===//
+// drop_front
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, DropFront) {
+ kmp_str_ref s("Hello World");
+
+ s.drop_front(6);
+
+ EXPECT_EQ(s.length(), 5u);
+ EXPECT_TRUE(equals(s, "World"));
+}
+
+TEST(kmp_str_ref_test, DropFrontZero) {
+ kmp_str_ref s("Hello");
+
+ s.drop_front(0);
+
+ EXPECT_EQ(s.length(), 5u);
+ EXPECT_TRUE(equals(s, "Hello"));
+}
+
+TEST(kmp_str_ref_test, DropFrontAll) {
+ kmp_str_ref s("Hello");
+
+ s.drop_front(5);
+
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, DropFrontMoreThanLength) {
+ kmp_str_ref s("Hi");
+
+ s.drop_front(100);
+
+ EXPECT_EQ(s.length(), 0u);
+}
+
+//===----------------------------------------------------------------------===//
+// drop_while
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, DropWhileDigits) {
+ kmp_str_ref s("123abc");
+
+ s.drop_while([](char c) {
+ return static_cast<bool>(isdigit(static_cast<unsigned char>(c)));
+ });
+
+ EXPECT_TRUE(equals(s, "abc"));
+}
+
+TEST(kmp_str_ref_test, DropWhileSpaces) {
+ kmp_str_ref s(" hello");
+
+ s.drop_while([](char c) { return c == ' '; });
+
+ EXPECT_TRUE(equals(s, "hello"));
+}
+
+TEST(kmp_str_ref_test, DropWhileNone) {
+ kmp_str_ref s("hello");
+
+ s.drop_while([](char c) { return c == ' '; });
+
+ EXPECT_TRUE(equals(s, "hello"));
+}
+
+TEST(kmp_str_ref_test, DropWhileAll) {
+ kmp_str_ref s("12345");
+
+ s.drop_while([](char c) {
+ return static_cast<bool>(isdigit(static_cast<unsigned char>(c)));
+ });
+
+ EXPECT_EQ(s.length(), 0u);
+}
+
+//===----------------------------------------------------------------------===//
+// count_while
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, CountWhileDigits) {
+ kmp_str_ref s("123abc");
+
+ size_t n = s.count_while(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+
+ EXPECT_EQ(n, 3u);
+}
+
+TEST(kmp_str_ref_test, CountWhileAll) {
+ kmp_str_ref s("12345");
+
+ size_t n = s.count_while(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+
+ EXPECT_EQ(n, s.length());
+}
+
+TEST(kmp_str_ref_test, CountWhileNone) {
+ kmp_str_ref s("abc");
+
+ size_t n = s.count_while(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+
+ EXPECT_EQ(n, 0u);
+}
+
+TEST(kmp_str_ref_test, CountWhileEmpty) {
+ kmp_str_ref s("");
+
+ size_t n = s.count_while([](char c) { return c == 'a'; });
+
+ EXPECT_EQ(n, 0u);
+}
+
+//===----------------------------------------------------------------------===//
+// find_if
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, FindIfDigit) {
+ kmp_str_ref s("abc123");
+
+ size_t i = s.find_if(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+
+ EXPECT_EQ(i, 3u);
+}
+
+TEST(kmp_str_ref_test, FindIfFirstChar) {
+ kmp_str_ref s("hello");
+
+ size_t i = s.find_if([](char c) { return c == 'h'; });
+
+ EXPECT_EQ(i, 0u);
+}
+
+TEST(kmp_str_ref_test, FindIfLastChar) {
+ kmp_str_ref s("hello");
+
+ size_t i = s.find_if([](char c) { return c == 'o'; });
+
+ EXPECT_EQ(i, 4u);
+}
+
+TEST(kmp_str_ref_test, FindIfNoMatch) {
+ kmp_str_ref s("hello");
+
+ size_t i = s.find_if(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+
+ EXPECT_EQ(i, kmp_str_ref::npos);
+}
+
+TEST(kmp_str_ref_test, FindIfEmpty) {
+ kmp_str_ref s("");
+
+ size_t i = s.find_if([](char c) { return c == 'a'; });
+
+ EXPECT_EQ(i, kmp_str_ref::npos);
+}
+
+//===----------------------------------------------------------------------===//
+// find_if_not
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, FindIfNotDigit) {
+ kmp_str_ref s("123abc");
+
+ size_t i = s.find_if_not(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+
+ EXPECT_EQ(i, 3u);
+}
+
+TEST(kmp_str_ref_test, FindIfNotAllMatch) {
+ kmp_str_ref s("12345");
+
+ size_t i = s.find_if_not(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+
+ EXPECT_EQ(i, kmp_str_ref::npos);
+}
+
+TEST(kmp_str_ref_test, FindIfNotNoneMatch) {
+ kmp_str_ref s("abc");
+
+ size_t i = s.find_if_not(
+ [](char c) { return isdigit(static_cast<unsigned char>(c)) != 0; });
+
+ EXPECT_EQ(i, 0u);
+}
+
+TEST(kmp_str_ref_test, FindIfNotEmpty) {
+ kmp_str_ref s("");
+
+ size_t i = s.find_if_not([](char c) { return c == 'a'; });
+
+ EXPECT_EQ(i, kmp_str_ref::npos);
+}
+
+//===----------------------------------------------------------------------===//
+// skip_space
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, SkipSpace) {
+ kmp_str_ref s(" hello");
+
+ s.skip_space();
+
+ EXPECT_TRUE(equals(s, "hello"));
+}
+
+TEST(kmp_str_ref_test, SkipSpaceNoSpaces) {
+ kmp_str_ref s("hello");
+
+ s.skip_space();
+
+ EXPECT_TRUE(equals(s, "hello"));
+}
+
+TEST(kmp_str_ref_test, SkipSpaceAllSpaces) {
+ kmp_str_ref s(" ");
+
+ s.skip_space();
+
+ EXPECT_EQ(s.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, SkipSpaceOnlyLeading) {
+ kmp_str_ref s(" hello world ");
+
+ s.skip_space();
+
+ EXPECT_TRUE(equals(s, "hello world "));
+}
+
+TEST(kmp_str_ref_test, SkipSpaceWithTabs) {
+ kmp_str_ref s("\t\n hello");
+
+ s.skip_space();
+
+ EXPECT_TRUE(equals(s, "hello"));
+}
+
+//===----------------------------------------------------------------------===//
+// take_while
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, TakeWhileDigits) {
+ kmp_str_ref s("123abc");
+
+ kmp_str_ref digits = s.take_while([](char c) {
+ return static_cast<bool>(isdigit(static_cast<unsigned char>(c)));
+ });
+
+ EXPECT_EQ(digits.length(), 3u);
+ EXPECT_TRUE(equals(digits, "123"));
+ // Original unchanged
+ EXPECT_EQ(s.length(), 6u);
+}
+
+TEST(kmp_str_ref_test, TakeWhileAlpha) {
+ kmp_str_ref s("hello123");
+
+ kmp_str_ref alpha = s.take_while([](char c) {
+ return static_cast<bool>(isalpha(static_cast<unsigned char>(c)));
+ });
+
+ EXPECT_EQ(alpha.length(), 5u);
+ EXPECT_TRUE(equals(alpha, "hello"));
+}
+
+TEST(kmp_str_ref_test, TakeWhileNone) {
+ kmp_str_ref s("123abc");
+
+ kmp_str_ref result = s.take_while([](char c) {
+ return static_cast<bool>(isalpha(static_cast<unsigned char>(c)));
+ });
+
+ EXPECT_EQ(result.length(), 0u);
+}
+
+TEST(kmp_str_ref_test, TakeWhileAll) {
+ kmp_str_ref s("hello");
+
+ kmp_str_ref result = s.take_while([](char c) {
+ return static_cast<bool>(isalpha(static_cast<unsigned char>(c)));
+ });
+
+ EXPECT_EQ(result.length(), 5u);
+ EXPECT_TRUE(equals(result, "hello"));
+}
+
+//===----------------------------------------------------------------------===//
+// Integration / Complex Scenarios
+//===----------------------------------------------------------------------===//
+
+TEST(kmp_str_ref_test, ParseKeyValuePair) {
+ kmp_str_ref s("key=value");
+
+ kmp_str_ref key = s.take_while([](char c) { return c != '='; });
+ s.drop_front(key.length());
+ s.consume_front("=");
+
+ EXPECT_EQ(key.length(), 3u);
+ EXPECT_TRUE(equals(key, "key"));
+ EXPECT_TRUE(equals(s, "value"));
+}
+
+TEST(kmp_str_ref_test, ParseCommaSeparated) {
+ kmp_str_ref s("1,2,3");
+ int values[3] = {0, 0, 0};
+ int count = 0;
+
+ while (s.length() > 0 && count < 3) {
+ s.consume_integer(values[count++]);
+ s.consume_front(",");
+ }
+
+ EXPECT_EQ(count, 3);
+ EXPECT_EQ(values[0], 1);
+ EXPECT_EQ(values[1], 2);
+ EXPECT_EQ(values[2], 3);
+}
+
+TEST(kmp_str_ref_test, ParseWithWhitespace) {
+ kmp_str_ref s(" hello world ");
+
+ s.skip_space();
+ kmp_str_ref word1 = s.take_while([](char c) { return c != ' '; });
+ s.drop_front(word1.length());
+ s.skip_space();
+ kmp_str_ref word2 = s.take_while([](char c) { return c != ' '; });
+
+ EXPECT_EQ(word1.length(), 5u);
+ EXPECT_TRUE(equals(word1, "hello"));
+ EXPECT_EQ(word2.length(), 5u);
+ EXPECT_TRUE(equals(word2, "world"));
+}
+
+} // namespace
diff --git a/openmp/runtime/unittests/CMakeLists.txt b/openmp/runtime/unittests/CMakeLists.txt
index 6b85b70ea47b5..8335c94cfb6d9 100644
--- a/openmp/runtime/unittests/CMakeLists.txt
+++ b/openmp/runtime/unittests/CMakeLists.txt
@@ -67,4 +67,5 @@ add_openmp_testsuite(
DEPENDS OpenMPUnitTests
)
+add_subdirectory(ADT)
add_subdirectory(String)
diff --git a/openmp/runtime/unittests/String/TestKmpStr.cpp b/openmp/runtime/unittests/String/TestKmpStr.cpp
index 87497b93c7538..5436ef1058c74 100644
--- a/openmp/runtime/unittests/String/TestKmpStr.cpp
+++ b/openmp/runtime/unittests/String/TestKmpStr.cpp
@@ -111,6 +111,33 @@ TEST(KmpStrTest, BasicStrToIntInvalid) {
EXPECT_EQ(__kmp_basic_str_to_int("7.5"), 7);
}
+// Test basic string to int conversion with maxlen parameter
+TEST(KmpStrTest, BasicStrToIntMaxLen) {
+ // maxlen limits how many characters are parsed
+ EXPECT_EQ(__kmp_basic_str_to_int("12345", 3), 123);
+ EXPECT_EQ(__kmp_basic_str_to_int("12345", 1), 1);
+ EXPECT_EQ(__kmp_basic_str_to_int("12345", 5), 12345);
+
+ // maxlen larger than string length parses entire string
+ EXPECT_EQ(__kmp_basic_str_to_int("42", 10), 42);
+ EXPECT_EQ(__kmp_basic_str_to_int("123", 100), 123);
+
+ // maxlen of 0 returns 0 (no characters parsed)
+ EXPECT_EQ(__kmp_basic_str_to_int("12345", 0), 0);
+
+ // maxlen with mixed content: stops at maxlen or non-digit, whichever first
+ EXPECT_EQ(__kmp_basic_str_to_int("123abc", 2), 12);
+ EXPECT_EQ(__kmp_basic_str_to_int("123abc", 5),
+ 123); // stops at 'a' before maxlen
+
+ // maxlen with leading zeros
+ EXPECT_EQ(__kmp_basic_str_to_int("007", 2), 0);
+ EXPECT_EQ(__kmp_basic_str_to_int("007", 3), 7);
+
+ // Default maxlen (INT_MAX) behaves like before
+ EXPECT_EQ(__kmp_basic_str_to_int("999"), 999);
+}
+
// Test string match
TEST(KmpStrTest, StrMatch) {
const char *data = "Hello World";
More information about the Openmp-commits
mailing list