[PATCH v3 4/8] gdbsupport: add extract_next_field helper

[Matthieu Longo <matthieu.longo@arm.com>]

Add extract_next_field, a helper for extracting a view from a buffer
up to a given separator. The helper also returns an iterator to the
beginning of the next entry, skipping consecutive separators.

The helper supports views whose value type is 'char', such as
gdb::array_view<char> and std::string_view (from c++20).
---
 gdb/unittests/common-utils-selftests.c | 32 +++++++++++++++++
 gdbsupport/common-utils.h              | 50 ++++++++++++++++++++++++++
 2 files changed, 82 insertions(+)

diff --git a/gdb/unittests/common-utils-selftests.c b/gdb/unittests/common-utils-selftests.c
index eb9c83616f0..bbd8b00a2de 100644
--- a/gdb/unittests/common-utils-selftests.c
+++ b/gdb/unittests/common-utils-selftests.c
@@ -19,6 +19,8 @@
 
 #include "gdbsupport/selftest.h"
 
+#include "gdbsupport/array-view.h"
+
 namespace selftests {
 
 /* Type of both 'string_printf' and the 'format' function below.  Used
@@ -125,6 +127,34 @@ string_vappendf_tests ()
   test_appendf_func (string_vappendf_wrapper);
 }
 
+static void
+extract_next_field_tests ()
+{
+  auto bytewise_match = [] (const auto &s1, const auto &s2) -> bool
+  {
+    return std::equal (s1.begin (), s1.end (), s2.begin (), s2.end ());
+  };
+
+  std::string s = "\n1234\nabc\n\ndef";
+  std::vector<std::string> expected = { "1234", "abc", "def" };
+  {
+    using view_t = gdb::array_view<char>;
+    std::vector<view_t> lines;
+    view_t buffer (s.data (), s.size ());
+    for (auto it = buffer.begin (); it != buffer.end ();)
+      {
+	auto [line, next_line_begin]
+	  = extract_next_field (buffer, it, '\n');
+	lines.emplace_back (line);
+	it = next_line_begin;
+      }
+
+    SELF_CHECK (expected.size () == lines.size ());
+    for (auto i = 0; i < expected.size () && i < lines.size (); ++i)
+      SELF_CHECK (bytewise_match (expected[i], lines[i]));
+  }
+}
+
 } /* namespace selftests */
 
 INIT_GDB_FILE (common_utils_selftests)
@@ -134,4 +164,6 @@ INIT_GDB_FILE (common_utils_selftests)
   selftests::register_test ("string_appendf", selftests::string_appendf_tests);
   selftests::register_test ("string_vappendf",
 			    selftests::string_vappendf_tests);
+  selftests::register_test ("extract_next_field",
+			    selftests::extract_next_field_tests);
 }
diff --git a/gdbsupport/common-utils.h b/gdbsupport/common-utils.h
index de83a715ac4..a4042b24644 100644
--- a/gdbsupport/common-utils.h
+++ b/gdbsupport/common-utils.h
@@ -279,4 +279,54 @@ struct string_view_hash
 
 } /* namespace gdb */
 
+/* Extract a view from BUFFER starting at START.
+
+   Leading occurrences of SEPARATOR at START are skipped.  The returned view
+   extends from the first non-separator character to the next occurrence of
+   SEPARATOR, or to BUFFER.end () if no separator is found.
+
+   Return the extracted view together with an iterator pointing to the first
+   non-separator character after the extracted view.  Successive separators
+   are skipped.  If there is no following non-separator character, the returned
+   iterator is BUFFER.end ().
+
+   If START does not point into BUFFER, return an empty view and BUFFER.end ().
+
+   ViewT may be gdb::array_view<char> or std::string_view.  The later requires
+   C++20, which added the constructor taking the range [first, last).  */
+
+template <class ViewT>
+std::pair<ViewT, typename ViewT::iterator>
+extract_next_field (ViewT buffer,
+		    typename ViewT::iterator start,
+		    char separator = '\0')
+{
+  static_assert (!std::is_reference_v <ViewT>);
+  static_assert (std::is_same_v <typename ViewT::value_type, char>);
+
+  auto next_start = buffer.end ();
+
+  /* Reject a START iterator that does not point into BUFFER.  */
+  if (start < buffer.begin () || start >= buffer.end ())
+    return {ViewT (), next_start};
+
+  /* Skip leading occurrences of the separator.  */
+  while (start != buffer.end () && *start == separator)
+    ++start;
+
+  auto it = std::find (start, buffer.end (), separator);
+
+  /* If no separator is found, the remainder of BUFFER is the final string.  */
+  if (it != buffer.end ())
+    {
+      /* Otherwise, skip successive separators so that NEXT_START points to
+	 the beginning of the next string, if any.  */
+      for (next_start = std::next (it);
+	   next_start != buffer.end () && *next_start == separator;
+	   next_start = std::next (next_start));
+    }
+
+  return {ViewT (start, it), next_start};
+}
+
 #endif /* GDBSUPPORT_COMMON_UTILS_H */
-- 
2.55.0