hsutter
diff --git a/Diff for: ‎include/cpp2regex.h
+4,141 b/Diff for: ‎include/cpp2regex.h
+4,141
diff --git a/Diff for: ‎include/cpp2regex.h2
+2,789 b/Diff for: ‎include/cpp2regex.h2
+2,789
diff --git a/Diff for: ‎include/cpp2util.h
+158-3 b/Diff for: ‎include/cpp2util.h
+158-3
diff --git a/Diff for: ‎regression-tests/pure2-regex_01_char_matcher.cpp2
+185 b/Diff for: ‎regression-tests/pure2-regex_01_char_matcher.cpp2
+185
@@ -36,10 +36,16 @@
 //      because it can't happen; using the name impl::deferred_init directly
 //      from program code is not supported.
 // 
+//  3)  Entities in other subnamespaces, such as cpp2::string_util
+// 
+//      These are typically metafunction "runtime-library" functions,
+//      implementation details called by metafunction-generated code.
+//      For example, @regex generates code that uses string_util:: functions.
+// 
 //===========================================================================
 
-#ifndef CPP2_UTIL_H
-#define CPP2_UTIL_H
+#ifndef CPP2_CPP2UTIL_H
+#define CPP2_CPP2UTIL_H
 
 //  If this implementation doesn't support source_location yet, disable it
 #include <version>
@@ -269,14 +275,17 @@
     #include <sstream>
     #include <iterator>
     #include <limits>
+    #include <map>
     #include <memory>
     #include <new>
     #include <random>
     #include <optional>
     #if defined(CPP2_USE_SOURCE_LOCATION)
         #include <source_location>
     #endif
+    #include <set>
     #include <span>
+    #include <sstream>
     #include <string>
     #include <string_view>
     #include <system_error>
@@ -320,7 +329,6 @@
     #define CPP2_CONSTEXPR constexpr
 #endif
 
-
 namespace cpp2 {
 
 
@@ -360,6 +368,152 @@ using _schar     = signed char;      // normally use i8 instead
 using _uchar     = unsigned char;    // normally use u8 instead
 
 
+//-----------------------------------------------------------------------
+//
+//  String utilities
+//
+
+namespace string_util {
+
+//  From https://stackoverflow.com/questions/216823/how-to-trim-a-stdstring
+
+//  Trim from start (in place)
+inline void ltrim(std::string &s) {
+    s.erase(
+        s.begin(), 
+        std::find_if(s.begin(), s.end(), [](unsigned char ch) { return !std::isspace(ch); })
+    );
+}
+
+//  Trim from end (in place)
+inline void rtrim(std::string &s) {
+    s.erase(
+        std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) { return !std::isspace(ch); }).base(), 
+        s.end()
+    );
+}
+
+//  Trim from both ends (in place)
+inline void trim(std::string &s) {
+    rtrim(s);
+    ltrim(s);
+}
+
+//  Trim from both ends (copying)
+inline std::string trim_copy(std::string_view s) {
+    std::string t(s);
+    trim(t);
+    return t;
+}
+
+//  From https://oleksandrkvl.github.io/2021/04/02/cpp-20-overview.html#nttp
+
+template<typename CharT, std::size_t N>
+struct fixed_string {
+    constexpr fixed_string(const CharT (&s)[N+1]) {
+        std::copy_n(s, N + 1, c_str);
+    }
+    constexpr const CharT* data() const {
+        return c_str;
+    }
+    constexpr std::size_t size() const {
+        return N;
+    }
+
+    constexpr auto str() const {
+        return std::basic_string<CharT>(c_str);
+    }
+
+    CharT c_str[N+1];
+};
+
+template<typename CharT, std::size_t N>
+fixed_string(const CharT (&)[N])->fixed_string<CharT, N-1>;
+
+//  Other string utility functions.
+
+inline bool is_escaped(std::string_view s) {
+    return 
+        s.starts_with("\"") 
+        && s.ends_with("\"")
+        ;
+}
+
+inline bool string_to_int(std::string const& s, int& v, int base = 10) {
+    try {
+        v = stoi(s, nullptr, base);
+        return true;
+    }
+    catch (std::invalid_argument const&)
+    {
+        return false;
+    }
+    catch (std::out_of_range const&)
+    {
+        return false;
+    }
+}
+
+template<int Base = 10>
+inline std::string int_to_string(int i) {
+    if constexpr (8 == Base) {
+        std::ostringstream oss;
+        oss << std::oct << i;
+        return oss.str();
+    }
+    else if constexpr (10 == Base) {
+        return std::to_string(i);
+    }
+    else if constexpr (16 == Base) {
+        std::ostringstream oss;
+        oss << std::hex << i;
+        return oss.str();
+    }
+    else {
+        [] <bool flag = false>() {
+            static_assert(flag, "Unsupported int_to_string Base");
+        }();
+    }
+}
+
+inline char safe_toupper(char ch) {
+    return static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
+}
+
+inline char safe_tolower(char ch) {
+    return static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
+}
+
+inline std::string replace_all(
+    std::string        str, 
+    const std::string& from, 
+    const std::string& to
+)
+{
+    size_t start_pos = 0;
+    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
+        str.replace(start_pos, from.length(), to);
+        start_pos += to.length();   // safe also when 'to' is a substring of 'from'
+    }
+    return str;
+}
+
+template<typename List>
+inline std::string join(List const& list) {
+    std::string r = "";
+    std::string sep = "";
+
+    for (auto const& cur : list) {
+        r += sep + cur;
+        sep = ", ";
+    }
+
+    return r;
+}
+
+} // namespace string_util
+
+
 //-----------------------------------------------------------------------
 //
 //  Conveniences for expressing Cpp1 references (rarely useful)
@@ -2365,6 +2519,7 @@ inline constexpr auto as_() -> decltype(auto)
 
 }
 
+#include "cpp2regex.h"
 
 using cpp2::cpp2_new;
 
 
@@ -0,0 +1,185 @@
+create_result: (resultExpr: std::string, r) -> std::string = {
+  result: std::string = "";
+
+  get_next := :(iter) -> _ = {
+		start := std::distance(resultExpr&$*.cbegin(), iter);
+    firstDollar := resultExpr&$*.find("$", start);
+    firstAt := resultExpr&$*.find("@", start);
+
+		end := std::min(firstDollar, firstAt);
+		if end != std::string::npos {
+			return resultExpr&$*.cbegin() + end;
+		}
+		else {
+			return resultExpr&$*.cend();
+		}
+  };
+  extract_group_and_advance := :(inout iter) -> _ = {
+    start := iter;
+
+    while std::isdigit(iter*) next iter++ {}
+
+    return std::stoi(std::string(start, iter));
+  };
+  extract_until := :(inout iter, to: char) -> _ = {
+    start := iter;
+
+    while (to != iter*) next iter++ {} // TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
+
+    return std::string(start, iter);
+  };
+
+  iter := resultExpr.begin();
+
+  while iter != resultExpr.end() {
+    next := get_next(iter);
+
+    if next != iter {
+      result += std::string(iter, next);
+    }
+    if next != resultExpr.end() {
+      if next* == '$' {
+        next++;
+
+        if next* == '&' {
+          next++;
+          result += r.group(0);
+        }
+        else if next* == '-' || next* == '+' {
+          is_start := next* == '-';
+          next++;
+          if next* == '{' {
+            next++; // Skip {
+            group := extract_until(next, '}');
+            next++; // Skip }
+            result += r.group(group);
+          }
+          else if next* == '[' {
+            next++; // Skip [
+            group := extract_group_and_advance(next);
+            next++; // Skip ]
+
+            if is_start {
+              result += std::to_string(r.group_start(group));
+            }
+            else {
+              result += std::to_string(r.group_end(group));
+            }
+          }
+          else {
+            // Return max group
+            result += r.group(r.group_number() - 1);
+          }
+        }
+        else if std::isdigit(next*) {
+          group := extract_group_and_advance(next);
+          result += r.group(group);
+        }
+        else {
+          std::cerr << "Not implemented";
+        }
+      }
+      else if next* == '@' {
+        next++;
+        
+        if next* == '-'  || next* == '+' {
+          i := 0;
+          while i < cpp2::unsafe_narrow<int>(r.group_number()) next i++ {
+            pos := 0;
+            if next* == '-' {
+              pos = r.group_start(i);
+            }
+            else {
+              pos = r.group_end(i);
+            }
+            result +=  std::to_string(pos);
+          }
+        }
+        else {
+          std::cerr << "Not implemented";
+        }
+      }
+      else {
+        std::cerr << "Not implemented.";
+      }
+    }
+    iter = next;
+  }
+
+  return result;
+}
+
+test: <M> (regex: M, id: std::string, regex_str: std::string, str: std::string, kind: std::string, resultExpr: std::string,
+           resultExpected: std::string) = {
+  
+  warning: std::string = "";
+  if regex.to_string() != regex_str {
+    warning = "Warning: Parsed regex does not match.";
+  }
+
+  status: std::string = "OK";
+
+  r := regex.search(str);
+
+  if "y" == kind || "yM" == kind || "yS" == kind || "yB" == kind {
+    if !r.matched {
+      status = "Failure: Regex should apply.";
+    }
+    else {
+      // Have a match check the result
+
+      result := create_result(resultExpr, r);
+
+      if result != resultExpected {
+        status = "Failure: Result is wrong. (is: (result)$)";
+      }
+    }
+  }
+  else if "n" == kind {
+    if r.matched {
+      status = "Failure: Regex should not apply. Result is '(r.group(0))$'";
+    }
+  } else {
+    status = "Unknown kind '(kind)$'";
+  }
+
+  if !warning.empty() {
+    warning += " ";
+  }
+  std::cout << "(id)$_(kind)$: (status)$ (warning)$regex: (regex_str)$ parsed_regex: (regex.to_string())$ str: (str)$ result_expr: (resultExpr)$ expected_results (resultExpected)$" << std::endl;
+}
+
+
+test_tests_01_char_matcher: @regex type = {
+  regex_01 := R"(abc)";
+  regex_02 := R"(abc)";
+  regex_03 := R"(abc)";
+  regex_04 := R"(abc)";
+  regex_05 := R"(abc)";
+  regex_06 := R"(abc)";
+  regex_07 := R"(abc)";
+  regex_08 := R"(abc)";
+  regex_09 := R"(abc)";
+  regex_10 := R"(abc)";
+  regex_11 := R"(abc)";
+  regex_12 := R"(abc)";
+  run: (this) = {
+    std::cout << "Running tests_01_char_matcher:"<< std::endl;
+    test(regex_01, "01", R"(abc)", "abc", "y", R"($&)", "abc");
+    test(regex_02, "02", R"(abc)", "abc", "y", R"($-[0])", "0");
+    test(regex_03, "03", R"(abc)", "abc", "y", R"($+[0])", "3");
+    test(regex_04, "04", R"(abc)", "xbc", "n", R"(-)", "-");
+    test(regex_05, "05", R"(abc)", "axc", "n", R"(-)", "-");
+    test(regex_06, "06", R"(abc)", "abx", "n", R"(-)", "-");
+    test(regex_07, "07", R"(abc)", "xabcy", "y", R"($&)", "abc");
+    test(regex_08, "08", R"(abc)", "xabcy", "y", R"($-[0])", "1");
+    test(regex_09, "09", R"(abc)", "xabcy", "y", R"($+[0])", "4");
+    test(regex_10, "10", R"(abc)", "ababc", "y", R"($&)", "abc");
+    test(regex_11, "11", R"(abc)", "ababc", "y", R"($-[0])", "2");
+    test(regex_12, "12", R"(abc)", "ababc", "y", R"($+[0])", "5");
+    std::cout << std::endl;
+  }
+}
+main: () = {
+    test_tests_01_char_matcher().run();
+}