Regular expressions initial setup.

source/reflect.h2

@@ -16,6 +16,7 @@
 //===========================================================================
 
 #include "parse.h"
+#include "regex.h"
 
 cpp2: namespace = {
 
@@ -1337,6 +1338,78 @@ print: (t: meta::type_declaration) =
     std::cout << t.print() << "\n";
 }
 
+//-----------------------------------------------------------------------
+//
+//  regex - creates regular expressions from members
+//
+//  TODO
+//
+regex_gen: (inout t: meta::type_declaration) =
+{
+    has_default: bool = false;
+    expressions: std::map<std::string, std::string> = ();
+
+    for t.get_member_objects() do (inout m)
+    {
+        name: std::string = m.name();
+        prefix: std::string = "regex";
+
+        if name.starts_with(prefix) {
+
+            if !m.has_initializer() {
+                t.error("Regular expression must have an initializer.");
+            }
+            m.mark_for_removal_from_enclosing_type();
+
+            name = name.substr(prefix.size());
+
+            if name.starts_with("_") {
+                name = name.substr(1);
+            }
+
+            if name.empty() {
+                if has_default {
+                    t.error("Type can only contain one default named regular expression.");
+                }
+                has_default = true;
+            }
+
+            expr: std::string = m.initializer();
+            if !(expr.starts_with("\"") && expr.ends_with("")) {
+                t.error("Unknown string format '(expr)$'");
+            }
+            expr = expr.substr(1, expr.size() - 2);
+
+            expressions[name] = expr;
+        }
+
+
+        m.require( m.make_public(),
+                   "all struct members must be public");
+        if m.is_function() {
+            mf := m.as_function();
+            t.require( !mf.is_virtual(),
+                       "a struct may not have a virtual function");
+            t.require( !mf.has_name("operator="),
+                       "a struct may not have a user-defined operator=");
+        }
+    }
+
+    t.remove_marked_members();
+
+    for expressions do (expr) {
+        regular_expression: std::string = ::cpp2::regex::generate_template(expr.second);
+
+        name: std::string = expr.first;
+        if !name.empty() {
+            name = "_" + name;
+        }
+
+        t.add_member("regex(name)$: type == (regular_expression)$;");
+        t.add_member("match(name)$: (in this, str: std::string) -> bool = { ctx: ::cpp2::regex::match_context<char,4> = (); return regex(name)$::match(str, ctx).matched; }");
+    }
+}
+
 
 //-----------------------------------------------------------------------
 //
@@ -1422,9 +1495,12 @@ apply_metafunctions: (
         else if name == "print" {
             print( rtype );
         }
+        else if name == "regex" {
+            regex_gen( rtype );
+        }
         else {
             error( "unrecognized metafunction name: " + name );
-            error( "(temporary alpha limitation) currently the supported names are: interface, polymorphic_base, ordered, weakly_ordered, partially_ordered, copyable, basic_value, value, weakly_ordered_value, partially_ordered_value, struct, enum, flag_enum, union, print" );
+            error( "(temporary alpha limitation) currently the supported names are: interface, polymorphic_base, ordered, weakly_ordered, partially_ordered, copyable, basic_value, value, weakly_ordered_value, partially_ordered_value, struct, enum, flag_enum, union, print, regex" );
             return false;
         }
 

source/regex.h

@@ -0,0 +1,234 @@
+
+#ifndef REGEX_H_CPP2
+#define REGEX_H_CPP2
+
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "regex.h2"
+
+#line 13 "regex.h2"
+namespace cpp2 {
+
+namespace regex {
+
+#line 20 "regex.h2"
+class list_end;
+
+class match_return;
+
+#line 37 "regex.h2"
+template<typename CharT, size_t max_groups> class match_context;
+
+#line 49 "regex.h2"
+template<typename CharT> class any_matcher_logic;
+
+#line 55 "regex.h2"
+template<typename CharT, CharT C> class char_matcher_logic;
+
+#line 61 "regex.h2"
+template<typename CharT, typename ...List> class list_matcher_logic;
+
+#line 120 "regex.h2"
+}
+}
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "regex.h2"
+
+//  Copyright (c) Herb Sutter
+//  SPDX-License-Identifier: CC-BY-NC-ND-4.0
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#line 13 "regex.h2"
+namespace cpp2 {
+
+namespace regex {
+
+template<typename CharT> using view = std::basic_string_view<CharT>;
+template<typename CharT> using bstring = std::basic_string<CharT>;
+
+class list_end {
+      public: list_end() = default;
+      public: list_end(list_end const&) = delete; /* No 'that' constructor, suppress copy */
+      public: auto operator=(list_end const&) -> void = delete;
+};
+#line 21 "regex.h2"
+
+class match_return
+ {
+    public: bool matched {false}; 
+    public: size_t length {0}; 
+
+    public: [[nodiscard]] static auto create(auto const& m, auto const& l) -> match_return;
+
+#line 35 "regex.h2"
+};
+
+template<typename CharT, size_t max_groups> class match_context
+ {
+
+    private: std::array<view<CharT>,max_groups> groups; 
+    public: match_context() = default;
+    public: match_context(match_context const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(match_context const&) -> void = delete;
+
+
+#line 42 "regex.h2"
+};
+
+/*regular_expression: @interface <CharT> type = {
+
+    match: <Ctx> (str: view<CharT>, inout ctx: Ctx) -> bool;
+}*/
+
+template<typename CharT> class any_matcher_logic
+ {
+    public: [[nodiscard]] static auto match(cpp2::in<view<CharT>> str, auto& ctx) -> match_return;
+    public: [[nodiscard]] static auto to_string() -> bstring<CharT>;
+    public: any_matcher_logic() = default;
+    public: any_matcher_logic(any_matcher_logic const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(any_matcher_logic const&) -> void = delete;
+
+#line 53 "regex.h2"
+};
+
+template<typename CharT, CharT C> class char_matcher_logic
+ {
+    public: [[nodiscard]] static auto match(cpp2::in<view<CharT>> str, auto& ctx) -> match_return;
+    public: [[nodiscard]] static auto to_string() -> bstring<CharT>;
+    public: char_matcher_logic() = default;
+    public: char_matcher_logic(char_matcher_logic const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(char_matcher_logic const&) -> void = delete;
+
+#line 59 "regex.h2"
+};
+
+template<typename CharT, typename ...List> class list_matcher_logic
+ {
+    public: [[nodiscard]] static auto match(cpp2::in<view<CharT>> str, auto& ctx) -> match_return;
+
+#line 67 "regex.h2"
+    public: [[nodiscard]] static auto to_string() -> bstring<CharT>;
+
+#line 71 "regex.h2"
+    private: template<typename First, typename ...Other> [[nodiscard]] static auto match_all(cpp2::in<view<CharT>> str, auto& ctx) -> match_return;
+
+#line 90 "regex.h2"
+    private: [[nodiscard]] static auto match_all(cpp2::in<view<CharT>> str, auto& ctx) -> match_return;
+    public: list_matcher_logic() = default;
+    public: list_matcher_logic(list_matcher_logic const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(list_matcher_logic const&) -> void = delete;
+
+
+#line 94 "regex.h2"
+};
+
+[[nodiscard]] auto generate_template(cpp2::in<std::string_view> regex) -> std::string;
+
+#line 120 "regex.h2"
+}
+}
+
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "regex.h2"
+
+#line 13 "regex.h2"
+namespace cpp2 {
+
+namespace regex {
+
+#line 27 "regex.h2"
+    [[nodiscard]] auto match_return::create(auto const& m, auto const& l) -> match_return{
+      if (m) {
+        return { true, l }; 
+      }
+      else {
+        return { false, 0 }; 
+      }
+    }
+
+#line 51 "regex.h2"
+    template <typename CharT> [[nodiscard]] auto any_matcher_logic<CharT>::match(cpp2::in<view<CharT>> str, auto& ctx) -> match_return { return match_return::create(!(CPP2_UFCS(empty)(str)), 1);  }
+    template <typename CharT> [[nodiscard]] auto any_matcher_logic<CharT>::to_string() -> bstring<CharT> { return bstring<CharT>(1, '.');  }
+
+#line 57 "regex.h2"
+    template <typename CharT, CharT C> [[nodiscard]] auto char_matcher_logic<CharT,C>::match(cpp2::in<view<CharT>> str, auto& ctx) -> match_return { return match_return::create(!(CPP2_UFCS(empty)(str)) && CPP2_UFCS(front)(str) == C, 1);  }
+    template <typename CharT, CharT C> [[nodiscard]] auto char_matcher_logic<CharT,C>::to_string() -> bstring<CharT> { return bstring<CharT>(1, C);  }
+
+#line 63 "regex.h2"
+    template <typename CharT, typename ...List> [[nodiscard]] auto list_matcher_logic<CharT,List...>::match(cpp2::in<view<CharT>> str, auto& ctx) -> match_return{
+      return match_all<List...>(str, ctx); 
+    }
+
+    template <typename CharT, typename ...List> [[nodiscard]] auto list_matcher_logic<CharT,List...>::to_string() -> bstring<CharT>{
+      return { (bstring<CharT>() + ... + List::to_string()) }; 
+    }
+
+    template <typename CharT, typename ...List> template<typename First, typename ...Other> [[nodiscard]] auto list_matcher_logic<CharT,List...>::match_all(cpp2::in<view<CharT>> str, auto& ctx) -> match_return{
+      match_return r {First::match(str, ctx)}; 
+
+      if (r.matched) {
+        if constexpr (0 != sizeof...(Other)) {
+          match_return o {match_all<Other...>(CPP2_UFCS(substr)(str, 1), ctx)}; 
+
+          if (o.matched) {
+            r.length += std::move(o).length;
+          }
+          else {
+            r = { false, 0 };
+          }
+        }
+      }
+
+      return r; 
+    }
+
+    template <typename CharT, typename ...List> [[nodiscard]] auto list_matcher_logic<CharT,List...>::match_all(cpp2::in<view<CharT>> str, auto& ctx) -> match_return{
+      // TODO: Assert End == list_end
+      return { true, 0 }; 
+    }
+
+#line 96 "regex.h2"
+[[nodiscard]] auto generate_template(cpp2::in<std::string_view> regex) -> std::string{
+  std::string template_expression {""}; 
+  std::string seperator {""}; 
+
+  template_expression += "::cpp2::regex::list_matcher_logic<char, ";
+
+  for ( auto const& c : regex ) {
+    template_expression += seperator;
+    if (c == '.') {
+      template_expression += "::cpp2::regex::any_matcher_logic<char>";
+    }
+    else {
+      template_expression += "::cpp2::regex::char_matcher_logic<char, '" + cpp2::to_string(c) + "'>";
+    }
+
+    seperator = ", ";
+  }
+  template_expression += ">";
+
+  return template_expression; 
+
+#line 118 "regex.h2"
+}
+
+}
+}
+
+#endif

source/regex.h2

@@ -0,0 +1,121 @@
+
+//  Copyright (c) Herb Sutter
+//  SPDX-License-Identifier: CC-BY-NC-ND-4.0
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+cpp2: namespace = {
+
+regex: namespace = {
+
+view: <CharT> type == std::basic_string_view<CharT>;
+bstring: <CharT> type == std::basic_string<CharT>;
+
+list_end: type = {}
+
+match_return: @struct type =
+{
+    matched: bool = false;
+    length: size_t = 0;
+
+    create: (m, l) -> match_return = {
+      if m {
+        return (true, l);
+      }
+      else {
+        return (false, 0);
+      }
+    }
+}
+
+match_context: <CharT, max_groups: size_t> type =
+{
+
+    groups: std::array<view<CharT>, max_groups>;
+
+}
+
+/*regular_expression: @interface <CharT> type = {
+
+    match: <Ctx> (str: view<CharT>, inout ctx: Ctx) -> bool;
+}*/
+
+any_matcher_logic: <CharT> type =
+{
+    match: (str: view<CharT>, inout ctx: _) -> match_return = match_return::create(!str.empty(), 1);
+    to_string: () -> bstring<CharT> = bstring<CharT>(1, '.');
+}
+
+char_matcher_logic: <CharT, C: CharT> type =
+{
+    match: (str: view<CharT>, inout ctx: _) -> match_return = match_return::create(!str.empty() && str.front() == C, 1);
+    to_string: () -> bstring<CharT> = bstring<CharT>(1, C);
+}
+
+list_matcher_logic: <CharT, List ...> type =
+{
+    match: (str: view<CharT>, inout ctx: _) -> match_return = {
+      return match_all<List...>(str, ctx);
+    }
+
+    to_string: () -> bstring<CharT> = {
+      return (bstring<CharT>() + ... + List::to_string());
+    }
+
+    private match_all: <First, Other ...> (str: view<CharT>, inout ctx: _) -> match_return = {
+      r: match_return = First::match(str, ctx);
+
+      if r.matched {
+        if constexpr 0 != sizeof...(Other) {
+          o: match_return = match_all<Other...>(str.substr(1), ctx);
+
+          if o.matched {
+            r.length += o.length;
+          }
+          else {
+            r = (false, 0);
+          }
+        }
+      }
+
+      return r;
+    }
+
+    private match_all: (str: view<CharT>, inout ctx: _) -> match_return = {
+      // TODO: Assert End == list_end
+      return (true, 0);
+    }
+}
+
+generate_template: (regex: std::string_view) -> std::string = {
+  template_expression: std::string = "";
+  seperator: std::string = "";
+
+  template_expression += "::cpp2::regex::list_matcher_logic<char, ";
+
+  for regex do (c) {
+    template_expression += seperator;
+    if c == '.' {
+      template_expression += "::cpp2::regex::any_matcher_logic<char>";
+    }
+    else {
+      template_expression += "::cpp2::regex::char_matcher_logic<char, '(c)$'>";
+    }
+
+    seperator = ", ";
+  }
+  template_expression += ">";
+
+  return template_expression;
+
+
+}
+
+}
+}