From a1d736909644af35e9ecc584d8dc88b31b7efe63 Mon Sep 17 00:00:00 2001 From: JIe Date: Mon, 23 Sep 2024 19:50:16 +0800 Subject: [PATCH] init --- .clangd | 2 + .idea/.gitignore | 8 + .idea/inspectionProfiles/Project_Default.xml | 46 + .idea/modules.xml | 8 + .idea/serialt.iml | 2 + demo.exe | Bin 0 -> 170557 bytes include/serial.h | 140 + main.cc | 24 + third/ctre.hpp | 5983 ++++++++++++++++++ third/serialib.cpp | 1134 ++++ third/serialib.h | 269 + 11 files changed, 7616 insertions(+) create mode 100644 .clangd create mode 100644 .idea/.gitignore create mode 100644 .idea/inspectionProfiles/Project_Default.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/serialt.iml create mode 100644 demo.exe create mode 100644 include/serial.h create mode 100644 main.cc create mode 100644 third/ctre.hpp create mode 100644 third/serialib.cpp create mode 100644 third/serialib.h diff --git a/.clangd b/.clangd new file mode 100644 index 0000000..30a5ba3 --- /dev/null +++ b/.clangd @@ -0,0 +1,2 @@ +CompileFlags: + Add: [-std=c++20] diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..13566b8 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..e4b0f61 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,46 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..41f0e76 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/serialt.iml b/.idea/serialt.iml new file mode 100644 index 0000000..4c94235 --- /dev/null +++ b/.idea/serialt.iml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/demo.exe b/demo.exe new file mode 100644 index 0000000000000000000000000000000000000000..5aaf0300733c30482b8c0f2de34a82aa2ce788db GIT binary patch literal 170557 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 literal 0 HcmV?d00001 diff --git a/include/serial.h b/include/serial.h new file mode 100644 index 0000000..d81b7fe --- /dev/null +++ b/include/serial.h @@ -0,0 +1,140 @@ +#ifndef SERIAL_H +#define SERIAL_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include "../third/serialib.h" + +using namespace std::literals::chrono_literals; + +template +concept SupportString = requires{ + std::is_same_v; + std::is_same_v; +}; + +enum class +[[maybe_unused]] +ErrorCode{ + SUCCESS, + TIMEOUT, + SETTIMEOUTERROR, + WRITEINGERROR, + READINGERROR, +}; + +class Serial +{ +private: + serialib ser; + const char* endChar = "\r\n"; + std::function logCallBack; + +public: + Serial() = default; + + std::string GetTimeNow(){ + auto now = std::chrono::system_clock::now(); + auto now_c = std::chrono::system_clock::to_time_t(now); + return std::ctime(&now_c); + } + + template + bool OpenDevice(T PortName, unsigned int bauds) + { + int code; + if constexpr (std::is_same_v){ + code = ser.openDevice(PortName.c_str(), bauds); + } + else{ + code = ser.openDevice(PortName, bauds); + } + if(code == 1){ + return true; + }else{ + return false; + } + } + + void Log(const std::string& log){ + if(logCallBack){ + auto msg = GetTimeNow() + " "+ log + "\n"; + logCallBack(msg); + } + } + + void SetLogCallBack(std::function callBack){ + logCallBack = callBack; + } + + void CloseDevice(){ + ser.closeDevice(); + } + + ~Serial() = default; + + + template + std::optional GetAtResponse(T command, int timeout = 50){ + ser.flushReceiver(); + std::string reallyCommand; + std::string response; + if constexpr (std::is_same_v){ + reallyCommand = command + endChar; + } + else{ + reallyCommand = std::string(command) + endChar; + } + ser.writeString(reallyCommand.c_str()); + Log("Send: " + reallyCommand); + std::this_thread::sleep_for(10ms); + // char buffer[ser.available()] = {0}; + char* buffer = (char*)malloc(sizeof(char)*ser.available()); + std::cout< 0){ + response = std::string(buffer); + Log("Receive: " + response); + delete[] buffer; + return response; + } + delete[] buffer; + return std::nullopt; + } + + template + bool GetAtUntil(T command, T expect = "OK",int timeout = 50){ + auto endTime = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout); + ser.flushReceiver(); + std::string reallyCommand; + if constexpr (std::is_same_v){ + reallyCommand = command + endChar; + } + else{ + reallyCommand = std::string(command) + endChar; + } + ser.writeString(reallyCommand.c_str()); + Log("Send : " + reallyCommand); + while(std::chrono::system_clock::now() < endTime){ + std::this_thread::sleep_for(10ms); + auto buffer = new char[ser.available()]; + auto size = ser.readBytes(buffer, sizeof(buffer), timeout); + auto str = std::string(buffer); + delete[] buffer; + if(size > 0) + Log("Receive: "+str); + if(str.find(expect) != std::string::npos){ + return true; + } + } + return false; + } +}; + +#endif // SERIAL_H diff --git a/main.cc b/main.cc new file mode 100644 index 0000000..5df52a7 --- /dev/null +++ b/main.cc @@ -0,0 +1,24 @@ +#include "include/serial.h" +#include +#include +using namespace std::literals::chrono_literals; + +void PrintLog(const std::string& msg){ + std::cout<(endTime-startTime).count(); +} diff --git a/third/ctre.hpp b/third/ctre.hpp new file mode 100644 index 0000000..813c73f --- /dev/null +++ b/third/ctre.hpp @@ -0,0 +1,5983 @@ +/* + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. + + +--- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. +*/ +#ifndef CTRE_V2__CTRE__HPP +#define CTRE_V2__CTRE__HPP + +#ifndef CTRE_V2__CTRE__LITERALS__HPP +#define CTRE_V2__CTRE__LITERALS__HPP + +#ifndef CTRE_V2__CTLL__HPP +#define CTRE_V2__CTLL__HPP + +#ifndef CTLL__PARSER__HPP +#define CTLL__PARSER__HPP + +#ifndef CTLL__FIXED_STRING__GPP +#define CTLL__FIXED_STRING__GPP + +#ifndef CTLL_IN_A_MODULE +#include +#include +#include +#include +#include +#endif + +namespace ctll { + +struct length_value_t { + uint32_t value; + uint8_t length; +}; + +constexpr length_value_t length_and_value_of_utf8_code_point(uint8_t first_unit) noexcept { + if ((first_unit & 0b1000'0000) == 0b0000'0000) return {static_cast(first_unit), 1}; + else if ((first_unit & 0b1110'0000) == 0b1100'0000) return {static_cast(first_unit & 0b0001'1111), 2}; + else if ((first_unit & 0b1111'0000) == 0b1110'0000) return {static_cast(first_unit & 0b0000'1111), 3}; + else if ((first_unit & 0b1111'1000) == 0b1111'0000) return {static_cast(first_unit & 0b0000'0111), 4}; + else if ((first_unit & 0b1111'1100) == 0b1111'1000) return {static_cast(first_unit & 0b0000'0011), 5}; + else if ((first_unit & 0b1111'1100) == 0b1111'1100) return {static_cast(first_unit & 0b0000'0001), 6}; + else return {0, 0}; +} + +constexpr char32_t value_of_trailing_utf8_code_point(uint8_t unit, bool & correct) noexcept { + if ((unit & 0b1100'0000) == 0b1000'0000) return unit & 0b0011'1111; + else { + correct = false; + return 0; + } +} + +constexpr length_value_t length_and_value_of_utf16_code_point(uint16_t first_unit) noexcept { + if ((first_unit & 0b1111110000000000) == 0b1101'1000'0000'0000) return {static_cast(first_unit & 0b0000001111111111), 2}; + else return {first_unit, 1}; +} + +struct construct_from_pointer_t { }; + +constexpr auto construct_from_pointer = construct_from_pointer_t{}; + +template struct fixed_string { + char32_t content[N] = {}; + size_t real_size{0}; + bool correct_flag{true}; + + template constexpr fixed_string(construct_from_pointer_t, const T * input) noexcept { + if constexpr (std::is_same_v) { + #ifdef CTRE_STRING_IS_UTF8 + size_t out{0}; + for (size_t i{0}; i < N; ++i) { + if ((i == (N-1)) && (input[i] == 0)) break; + length_value_t info = length_and_value_of_utf8_code_point(input[i]); + switch (info.length) { + case 6: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 5: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 4: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 3: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 2: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 1: + content[out++] = static_cast(info.value); + real_size++; + break; + default: + correct_flag = false; + return; + } + } + #else + for (size_t i{0}; i < N; ++i) { + content[i] = static_cast(input[i]); + if ((i == (N-1)) && (input[i] == 0)) break; + real_size++; + } + #endif + #if __cpp_char8_t + } else if constexpr (std::is_same_v) { + size_t out{0}; + for (size_t i{0}; i < N; ++i) { + if ((i == (N-1)) && (input[i] == 0)) break; + length_value_t info = length_and_value_of_utf8_code_point(input[i]); + switch (info.length) { + case 6: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 5: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 4: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 3: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 2: + if (++i < N) info.value = (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag); + [[fallthrough]]; + case 1: + content[out++] = static_cast(info.value); + real_size++; + break; + default: + correct_flag = false; + return; + } + } + #endif + } else if constexpr (std::is_same_v) { + size_t out{0}; + for (size_t i{0}; i < N; ++i) { + length_value_t info = length_and_value_of_utf16_code_point(input[i]); + if (info.length == 2) { + if (++i < N) { + if ((input[i] & 0b1111'1100'0000'0000) == 0b1101'1100'0000'0000) { + content[out++] = ((info.value << 10) | (input[i] & 0b0000'0011'1111'1111)) + 0x10000; + } else { + correct_flag = false; + break; + } + } + } else { + if ((i == (N-1)) && (input[i] == 0)) break; + content[out++] = info.value; + } + } + real_size = out; + } else if constexpr (std::is_same_v || std::is_same_v) { + for (size_t i{0}; i < N; ++i) { + content[i] = static_cast(input[i]); + if ((i == (N-1)) && (input[i] == 0)) break; + real_size++; + } + } + } + + template constexpr fixed_string(const std::array & in) noexcept: fixed_string{construct_from_pointer, in.data()} { } + template constexpr fixed_string(const T (&input)[N+1]) noexcept: fixed_string{construct_from_pointer, input} { } + + constexpr fixed_string(const fixed_string & other) noexcept { + for (size_t i{0}; i < N; ++i) { + content[i] = other.content[i]; + } + real_size = other.real_size; + correct_flag = other.correct_flag; + } + constexpr bool correct() const noexcept { + return correct_flag; + } + constexpr size_t size() const noexcept { + return real_size; + } + constexpr const char32_t * begin() const noexcept { + return content; + } + constexpr const char32_t * end() const noexcept { + return content + size(); + } + constexpr char32_t operator[](size_t i) const noexcept { + return content[i]; + } + template constexpr bool is_same_as(const fixed_string & rhs) const noexcept { + if (real_size != rhs.size()) return false; + for (size_t i{0}; i != real_size; ++i) { + if (content[i] != rhs[i]) return false; + } + return true; + } + constexpr operator std::basic_string_view() const noexcept { + return std::basic_string_view{content, size()}; + } +}; + +template <> class fixed_string<0> { + static constexpr char32_t empty[1] = {0}; +public: + template constexpr fixed_string(const T *) noexcept { + + } + constexpr fixed_string(std::initializer_list) noexcept { + + } + constexpr fixed_string(const fixed_string &) noexcept { + + } + constexpr bool correct() const noexcept { + return true; + } + constexpr size_t size() const noexcept { + return 0; + } + constexpr const char32_t * begin() const noexcept { + return empty; + } + constexpr const char32_t * end() const noexcept { + return empty + size(); + } + constexpr char32_t operator[](size_t) const noexcept { + return 0; + } + constexpr operator std::basic_string_view() const noexcept { + return std::basic_string_view{empty, 0}; + } +}; + +template fixed_string(const CharT (&)[N]) -> fixed_string; +template fixed_string(const std::array &) -> fixed_string; + +template fixed_string(fixed_string) -> fixed_string; + +} + +#endif + +#ifndef CTLL__TYPE_STACK__HPP +#define CTLL__TYPE_STACK__HPP + +#ifndef CTLL__UTILITIES__HPP +#define CTLL__UTILITIES__HPP + +#ifndef CTLL_IN_A_MODULE +#include +#endif + +#ifdef CTLL_IN_A_MODULE +#define CTLL_EXPORT +#else +#define CTLL_EXPORT export +#endif + +#if defined __cpp_nontype_template_parameter_class + #define CTLL_CNTTP_COMPILER_CHECK 1 +#elif defined __cpp_nontype_template_args +// compiler which defines correctly feature test macro (not you clang) + #if __cpp_nontype_template_args >= 201911L + #define CTLL_CNTTP_COMPILER_CHECK 1 + #elif __cpp_nontype_template_args >= 201411L +// appleclang 13+ + #if defined __apple_build_version__ + #if defined __clang_major__ && __clang_major__ >= 13 +// but only in c++20 and more + #if __cplusplus > 201703L + #define CTLL_CNTTP_COMPILER_CHECK 1 + #endif + #endif + #else +// clang 12+ + #if defined __clang_major__ && __clang_major__ >= 12 +// but only in c++20 and more + #if __cplusplus > 201703L + #define CTLL_CNTTP_COMPILER_CHECK 1 + #endif + #endif + #endif + #endif +#endif + +#ifndef CTLL_CNTTP_COMPILER_CHECK + #define CTLL_CNTTP_COMPILER_CHECK 0 +#endif + +#ifdef _MSC_VER +#define CTLL_FORCE_INLINE __forceinline +#else +#define CTLL_FORCE_INLINE __attribute__((always_inline)) +#endif + +namespace ctll { + +template struct conditional_helper; + +template <> struct conditional_helper { + template using type = A; +}; + +template <> struct conditional_helper { + template using type = B; +}; + +template using conditional = typename conditional_helper::template type; + +} + +#endif + +namespace ctll { + +template struct list { }; + +struct _nothing { }; + +using empty_list = list<>; + +// calculate size of list content +template constexpr auto size(list) noexcept { return sizeof...(Ts); } + + +// check if the list is empty +template constexpr bool empty(list) noexcept { return false; } +constexpr bool empty(empty_list) { return true; } + +// concat two lists together left to right +template constexpr auto concat(list, list) noexcept -> list { return {}; } + +// push something to the front of a list +template constexpr auto push_front(T, list) noexcept -> list { return {}; } + +// pop element from the front of a list +template constexpr auto pop_front(list) noexcept -> list { return {}; } +constexpr auto pop_front(empty_list) -> empty_list; + +// pop element from the front of a list and return new typelist too +template struct list_pop_pair { + Front front{}; + List list{}; + constexpr list_pop_pair() = default; +}; + +template constexpr auto pop_and_get_front(list, T = T()) noexcept -> list_pop_pair> { return {}; } +template constexpr auto pop_and_get_front(empty_list, T = T()) noexcept -> list_pop_pair { return {}; } + +// return front of the list +template constexpr auto front(list, T = T()) noexcept -> Head { return {}; } +template constexpr auto front(empty_list, T = T()) noexcept -> T { return {}; } + +// rotate list +template struct rotate_item { + template friend constexpr auto operator+(list, rotate_item) noexcept -> list { return {}; } +}; + +template constexpr auto rotate(list) -> decltype((list<>{} + ... + rotate_item{})) { + return {}; +} + +// set operations +template struct item_matcher { + struct not_selected { + template friend constexpr auto operator+(list, not_selected) -> list; + }; + template struct wrapper { + template friend constexpr auto operator+(list, wrapper) -> list; + }; + + static constexpr auto check(T) { return std::true_type{}; } + static constexpr auto check(...) { return std::false_type{}; } + static constexpr auto select(T) { return not_selected{}; } + template static constexpr auto select(Y) { return wrapper{}; } +}; + +template constexpr bool exists_in(T, list) noexcept { + return (item_matcher::check(Ts{}) || ... || false); +} + +template constexpr auto add_item(T item, list l) noexcept { + if constexpr (exists_in(item, l)) { + return l; + } else { + return list{}; + } +} + +template constexpr auto remove_item(T, list) noexcept { + item_matcher matcher; + return decltype((list<>{} + ... + matcher.select(Ts{}))){}; +} + +} + +#endif + +#ifndef CTLL__GRAMMARS__HPP +#define CTLL__GRAMMARS__HPP + +namespace ctll { + +// terminal type representing symbol / character of any type +template struct term { + static constexpr auto value = v; +}; + +// epsilon = nothing on input tape +// also used as an command for parsing means "do nothing" +struct epsilon { + static constexpr auto value = '-'; +}; + +// empty_stack_symbol = nothing on stack +struct empty_stack_symbol {}; + +// push is alias to list +template using push = list; + +// accept/reject type for controlling output of LL1 machine +struct accept { constexpr explicit operator bool() noexcept { return true; } }; +struct reject { constexpr explicit operator bool() noexcept { return false; } }; + +// action type, every action item in grammar must inherit from +struct action { + struct action_tag { }; +}; + +// move one character forward and pop it from stack command +struct pop_input { + struct pop_input_tag { }; +}; + +// additional overloads for type list +template constexpr auto push_front(pop_input, list) -> list { return {}; } + +template constexpr auto push_front(epsilon, list) -> list { return {}; } + +template constexpr auto push_front(list, list) -> list { return {}; } + +template constexpr auto pop_front_and_push_front(T item, list l) { + return push_front(item, pop_front(l)); +} + +// SPECIAL matching types for nicer grammars + +// match any term +struct anything { + constexpr inline anything() noexcept { } + template constexpr anything(term) noexcept; +}; + +// match range of term A-B +template struct range { + constexpr inline range() noexcept { } + //template constexpr range(term) noexcept requires (A <= V) && (V <= B); + template > constexpr range(term) noexcept; +}; + +#ifdef __EDG__ +template struct contains { + static constexpr bool value = ((Set == V) || ... || false); +}; +#endif + +// match terms defined in set +template struct set { + constexpr inline set() noexcept { } + #ifdef __EDG__ + template ::value>> constexpr set(term) noexcept; + #else + template > constexpr set(term) noexcept; + #endif +}; + +// match terms not defined in set +template struct neg_set { + constexpr inline neg_set() noexcept { } + + #ifdef __EDG__ + template ::value>> constexpr neg_set(term) noexcept; + #else + template > constexpr neg_set(term) noexcept; + #endif +}; + +// AUGMENTED grammar which completes user-defined grammar for all other cases +template struct augment_grammar: public Grammar { + // start nonterminal is defined in parent type + using typename Grammar::_start; + + // grammar rules are inherited from Grammar parent type + using Grammar::rule; + + // term on stack and on input means pop_input; + template static constexpr auto rule(term, term) -> ctll::pop_input; + + // if the type on stack (range, set, neg_set, anything) is constructible from the terminal => pop_input + template static constexpr auto rule(Expected, term) -> std::enable_if_t>, ctll::pop_input>; + + // empty stack and empty input means we are accepting + static constexpr auto rule(empty_stack_symbol, epsilon) -> ctll::accept; + + // not matching anything else => reject + static constexpr auto rule(...) -> ctll::reject; + + // start stack is just a list; + using start_stack = list; +}; + +} + +#endif + +#ifndef CTLL__ACTIONS__HPP +#define CTLL__ACTIONS__HPP + +namespace ctll { + struct empty_subject { }; + + struct empty_actions { + // dummy operator so using Actions::operator() later will not give error + template static constexpr auto apply(Action, InputSymbol, Subject subject) { + return subject; + } + }; + + template struct identity: public Actions { + using Actions::apply; + // allow empty_subject to exists + template constexpr static auto apply(Action, term, empty_subject) -> empty_subject { return {}; } + template constexpr static auto apply(Action, epsilon, empty_subject) -> empty_subject { return {}; } + }; + + template struct ignore_unknown: public Actions { + using Actions::apply; + // allow flow thru unknown actions + template constexpr static auto apply(Action, term, Subject) -> Subject { return {}; } + template constexpr static auto apply(Action, epsilon, Subject) -> Subject { return {}; } + }; +} + +#endif + +#ifndef CTLL_IN_A_MODULE +#include +#endif + +namespace ctll { + +enum class decision { + reject, + accept, + undecided +}; + +struct placeholder { }; + +template using index_placeholder = placeholder; + +#if CTLL_CNTTP_COMPILER_CHECK +template struct parser { // in c++20 +#else +template struct parser { +#endif + + #ifdef __GNUC__ // workaround to GCC bug + #if CTLL_CNTTP_COMPILER_CHECK + static constexpr auto _input = input; // c++20 mode + #else + static constexpr auto & _input = input; // c++17 mode + #endif + #else + static constexpr auto _input = input; // everyone else + #endif + + using Actions = ctll::conditional, identity>; + using grammar = augment_grammar; + + template struct results { + + static constexpr bool is_correct = Decision == decision::accept; + + constexpr inline CTLL_FORCE_INLINE operator bool() const noexcept { + return is_correct; + } + + #ifdef __GNUC__ // workaround to GCC bug + #if CTLL_CNTTP_COMPILER_CHECK + static constexpr auto _input = input; // c++20 mode + #else + static constexpr auto & _input = input; // c++17 mode + #endif + #else + static constexpr auto _input = input; // everyone else + #endif + + using output_type = Subject; + static constexpr size_t position = Pos; + + constexpr auto operator+(placeholder) const noexcept { + if constexpr (Decision == decision::undecided) { + // parse for current char (RPos) with previous stack and subject :) + return parser::template decide({}, {}); + } else { + // if there is decision already => just push it to the end of fold expression + return *this; + } + } + }; + + template static constexpr auto get_current_term() noexcept { + if constexpr (Pos < input.size()) { + constexpr auto value = input[Pos]; + if constexpr (value <= static_cast((std::numeric_limits::max)())) { + return term(value)>{}; + } else { + return term{}; + } + + } else { + // return epsilon if we are past the input + return epsilon{}; + } + } + template static constexpr auto get_previous_term() noexcept { + if constexpr (Pos == 0) { + // there is no previous character on input if we are on start + return epsilon{}; + } else if constexpr ((Pos-1) < input.size()) { + constexpr auto value = input[Pos-1]; + if constexpr (value <= static_cast((std::numeric_limits::max)())) { + return term(value)>{}; + } else { + return term{}; + } + } else { + return epsilon{}; + } + } + // if rule is accept => return true and subject + template + static constexpr auto move(ctll::accept, Terminal, Stack, Subject) noexcept { + return typename parser::template results(); + } + // if rule is reject => return false and subject + template + static constexpr auto move(ctll::reject, Terminal, Stack, Subject) noexcept { + return typename parser::template results(); + } + // if rule is pop_input => move to next character + template + static constexpr auto move(ctll::pop_input, Terminal, Stack, Subject) noexcept { + return typename parser::template results(); + } + // if rule is string => push it to the front of stack + template + static constexpr auto move(push string, Terminal, Stack stack, Subject subject) noexcept { + return decide(push_front(string, stack), subject); + } + // if rule is epsilon (empty string) => continue + template + static constexpr auto move(epsilon, Terminal, Stack stack, Subject subject) noexcept { + return decide(stack, subject); + } + // if rule is string with current character at the beginning (term) => move to next character + // and push string without the character (quick LL(1)) + template + static constexpr auto move(push, Content...>, term, Stack stack, Subject) noexcept { + constexpr auto local_input = input; + return typename parser::template results(), stack)), Subject, decision::undecided>(); + } + // if rule is string with any character at the beginning (compatible with current term) => move to next character + // and push string without the character (quick LL(1)) + template + static constexpr auto move(push, term, Stack stack, Subject) noexcept { + constexpr auto local_input = input; + return typename parser::template results(), stack)), Subject, decision::undecided>(); + } + // decide if we need to take action or move + template static constexpr auto decide(Stack previous_stack, Subject previous_subject) noexcept { + // each call means we pop something from stack + auto top_symbol = decltype(ctll::front(previous_stack, empty_stack_symbol()))(); + // gcc pedantic warning + [[maybe_unused]] auto stack = decltype(ctll::pop_front(previous_stack))(); + + // in case top_symbol is action type (apply it on previous subject and get new one) + if constexpr (std::is_base_of_v) { + auto subject = Actions::apply(top_symbol, get_previous_term(), previous_subject); + + // in case that semantic action is error => reject input + if constexpr (std::is_same_v) { + return typename parser::template results(); + } else { + return decide(stack, subject); + } + } else { + // all other cases are ordinary for LL(1) parser + auto current_term = get_current_term(); + auto rule = decltype(grammar::rule(top_symbol,current_term))(); + return move(rule, current_term, stack, previous_subject); + } + } + + // trampolines with folded expression + template static constexpr auto trampoline_decide(Subject, std::index_sequence) noexcept { + // parse everything for first char and than for next and next ... + // Pos+1 is needed as we want to finish calculation with epsilons on stack + auto v = (decide<0, typename grammar::start_stack, Subject>({}, {}) + ... + index_placeholder()); + return v; + } + + template static constexpr auto trampoline_decide(Subject subject = {}) noexcept { + // there will be no recursion, just sequence long as the input + return trampoline_decide(subject, std::make_index_sequence()); + } + + template using output = decltype(trampoline_decide()); + template static inline constexpr bool correct_with = trampoline_decide(); + +}; + +} // end of ctll namespace + +#endif + +#endif + +#ifndef CTRE__PCRE_ACTIONS__HPP +#define CTRE__PCRE_ACTIONS__HPP + +#ifndef CTRE__PCRE__HPP +#define CTRE__PCRE__HPP + +// THIS FILE WAS GENERATED BY DESATOMAT TOOL, DO NOT MODIFY THIS FILE + +namespace ctre { + +struct pcre { + +// NONTERMINALS: + struct a {}; + struct b {}; + struct backslash {}; + struct backslash_range {}; + struct block {}; + struct block_name2 {}; + struct block_name {}; + struct c {}; + struct class_named_name {}; + struct content2 {}; + struct content {}; + struct content_in_capture {}; + struct content_or_empty {}; + struct d {}; + struct e {}; + struct f {}; + struct g {}; + struct h {}; + struct hexdec_repeat {}; + struct i {}; + struct j {}; + struct k {}; + struct l {}; + struct m {}; + struct mod {}; + struct mode_switch2 {}; + struct n {}; + struct number2 {}; + struct number {}; + struct o {}; + struct p {}; + struct property_name2 {}; + struct property_name {}; + struct property_value2 {}; + struct property_value {}; + struct range {}; + struct repeat {}; + struct s {}; using _start = s; + struct set2a {}; + struct set2b {}; + struct string2 {}; + +// 'action' types: + struct class_digit: ctll::action {}; + struct class_horizontal_space: ctll::action {}; + struct class_named_alnum: ctll::action {}; + struct class_named_alpha: ctll::action {}; + struct class_named_ascii: ctll::action {}; + struct class_named_blank: ctll::action {}; + struct class_named_cntrl: ctll::action {}; + struct class_named_digit: ctll::action {}; + struct class_named_graph: ctll::action {}; + struct class_named_lower: ctll::action {}; + struct class_named_print: ctll::action {}; + struct class_named_punct: ctll::action {}; + struct class_named_space: ctll::action {}; + struct class_named_upper: ctll::action {}; + struct class_named_word: ctll::action {}; + struct class_named_xdigit: ctll::action {}; + struct class_non_horizontal_space: ctll::action {}; + struct class_non_vertical_space: ctll::action {}; + struct class_nondigit: ctll::action {}; + struct class_nonnewline: ctll::action {}; + struct class_nonspace: ctll::action {}; + struct class_nonword: ctll::action {}; + struct class_space: ctll::action {}; + struct class_vertical_space: ctll::action {}; + struct class_word: ctll::action {}; + struct create_hexdec: ctll::action {}; + struct create_number: ctll::action {}; + struct finish_hexdec: ctll::action {}; + struct look_finish: ctll::action {}; + struct make_alternate: ctll::action {}; + struct make_atomic: ctll::action {}; + struct make_back_reference: ctll::action {}; + struct make_capture: ctll::action {}; + struct make_capture_with_name: ctll::action {}; + struct make_lazy: ctll::action {}; + struct make_optional: ctll::action {}; + struct make_possessive: ctll::action {}; + struct make_property: ctll::action {}; + struct make_property_negative: ctll::action {}; + struct make_range: ctll::action {}; + struct make_relative_back_reference: ctll::action {}; + struct make_sequence: ctll::action {}; + struct mode_case_insensitive: ctll::action {}; + struct mode_case_sensitive: ctll::action {}; + struct mode_multiline: ctll::action {}; + struct mode_singleline: ctll::action {}; + struct negate_class_named: ctll::action {}; + struct prepare_capture: ctll::action {}; + struct push_assert_begin: ctll::action {}; + struct push_assert_end: ctll::action {}; + struct push_assert_subject_begin: ctll::action {}; + struct push_assert_subject_end: ctll::action {}; + struct push_assert_subject_end_with_lineend: ctll::action {}; + struct push_character: ctll::action {}; + struct push_character_alarm: ctll::action {}; + struct push_character_anything: ctll::action {}; + struct push_character_escape: ctll::action {}; + struct push_character_formfeed: ctll::action {}; + struct push_character_newline: ctll::action {}; + struct push_character_null: ctll::action {}; + struct push_character_return_carriage: ctll::action {}; + struct push_character_tab: ctll::action {}; + struct push_empty: ctll::action {}; + struct push_hexdec: ctll::action {}; + struct push_name: ctll::action {}; + struct push_not_word_boundary: ctll::action {}; + struct push_number: ctll::action {}; + struct push_property_name: ctll::action {}; + struct push_property_value: ctll::action {}; + struct push_word_boundary: ctll::action {}; + struct repeat_ab: ctll::action {}; + struct repeat_at_least: ctll::action {}; + struct repeat_exactly: ctll::action {}; + struct repeat_plus: ctll::action {}; + struct repeat_star: ctll::action {}; + struct reset_capture: ctll::action {}; + struct set_combine: ctll::action {}; + struct set_make: ctll::action {}; + struct set_make_negative: ctll::action {}; + struct set_start: ctll::action {}; + struct start_atomic: ctll::action {}; + struct start_lookahead_negative: ctll::action {}; + struct start_lookahead_positive: ctll::action {}; + struct start_lookbehind_negative: ctll::action {}; + struct start_lookbehind_positive: ctll::action {}; + +// (q)LL1 function: + using _others = ctll::neg_set<'!','$','\x28','\x29','*','+',',','-','.','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','?','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','[','\\','\"',']','^','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','\x7B','|','\x7D'>; + static constexpr auto rule(s, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(s, ctll::term<'['>) -> ctll::push; + static constexpr auto rule(s, ctll::term<'\x28'>) -> ctll::push; + static constexpr auto rule(s, ctll::term<'^'>) -> ctll::push; + static constexpr auto rule(s, ctll::term<'$'>) -> ctll::push; + static constexpr auto rule(s, ctll::set<'!',',','-','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"',']','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + static constexpr auto rule(s, _others) -> ctll::push; + static constexpr auto rule(s, ctll::term<'.'>) -> ctll::push; + static constexpr auto rule(s, ctll::term<'|'>) -> ctll::push; + static constexpr auto rule(s, ctll::epsilon) -> ctll::push; + static constexpr auto rule(s, ctll::set<'\x29','*','+','?','\x7B','\x7D'>) -> ctll::reject; + + static constexpr auto rule(a, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(a, ctll::term<'['>) -> ctll::push; + static constexpr auto rule(a, ctll::term<'\x28'>) -> ctll::push; + static constexpr auto rule(a, ctll::term<'^'>) -> ctll::push; + static constexpr auto rule(a, ctll::term<'$'>) -> ctll::push; + static constexpr auto rule(a, ctll::set<'!',',','-','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"',']','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + static constexpr auto rule(a, _others) -> ctll::push; + static constexpr auto rule(a, ctll::term<'.'>) -> ctll::push; + static constexpr auto rule(a, ctll::term<'\x29'>) -> ctll::push; + static constexpr auto rule(a, ctll::epsilon) -> ctll::push; + static constexpr auto rule(a, ctll::set<'*','+','?','\x7B','|','\x7D'>) -> ctll::reject; + + static constexpr auto rule(b, ctll::term<','>) -> ctll::push; + static constexpr auto rule(b, ctll::term<'\x7D'>) -> ctll::push; + + static constexpr auto rule(backslash, ctll::term<'d'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'h'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'H'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'V'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'D'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'N'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'S'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'W'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'s'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'v'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'w'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::set<'1','2','3','4','5','6','7','8','9'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'g'>) -> ctll::push, m>; + static constexpr auto rule(backslash, ctll::term<'p'>) -> ctll::push, property_name, ctll::term<'\x7D'>, make_property>; + static constexpr auto rule(backslash, ctll::term<'P'>) -> ctll::push, property_name, ctll::term<'\x7D'>, make_property_negative>; + static constexpr auto rule(backslash, ctll::term<'u'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'x'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'A'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'z'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'Z'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::set<'$','\x28','\x29','*','+','-','.','/','<','>','?','[','\\','\"',']','^','\x7B','|','\x7D'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'a'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'e'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'f'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'n'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'0'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'r'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'t'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'B'>) -> ctll::push; + static constexpr auto rule(backslash, ctll::term<'b'>) -> ctll::push; + + static constexpr auto rule(backslash_range, ctll::term<'u'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::term<'x'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::set<'$','\x28','\x29','*','+','-','.','/','<','>','?','[','\\','\"',']','^','\x7B','|','\x7D'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::term<'a'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::term<'e'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::term<'f'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::term<'n'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::term<'0'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::term<'r'>) -> ctll::push; + static constexpr auto rule(backslash_range, ctll::term<'t'>) -> ctll::push; + + static constexpr auto rule(block, ctll::term<'\\'>) -> ctll::push>; + static constexpr auto rule(block, ctll::term<'['>) -> ctll::push>; + static constexpr auto rule(block, ctll::term<'?'>) -> ctll::push; + static constexpr auto rule(block, ctll::term<'\x28'>) -> ctll::push>; + static constexpr auto rule(block, ctll::term<'^'>) -> ctll::push>; + static constexpr auto rule(block, ctll::term<'$'>) -> ctll::push>; + static constexpr auto rule(block, ctll::set<'!',',','-','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"',']','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push>; + static constexpr auto rule(block, _others) -> ctll::push>; + static constexpr auto rule(block, ctll::term<'.'>) -> ctll::push>; + static constexpr auto rule(block, ctll::term<'|'>) -> ctll::push>; + static constexpr auto rule(block, ctll::term<'\x29'>) -> ctll::push; + static constexpr auto rule(block, ctll::set<'*','+','\x7B','\x7D'>) -> ctll::reject; + + static constexpr auto rule(block_name2, ctll::set<'>','\x7D'>) -> ctll::epsilon; + static constexpr auto rule(block_name2, ctll::set<'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + + static constexpr auto rule(block_name, ctll::set<'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + + static constexpr auto rule(c, ctll::term<'['>) -> ctll::push, i, range, set_start, set2b, set_make, ctll::term<']'>>; + static constexpr auto rule(c, ctll::term<'\\'>) -> ctll::push>; + static constexpr auto rule(c, ctll::set<'!','$','\x28','\x29','*','+',',','.','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','?','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','\x7B','|','\x7D'>) -> ctll::push>; + static constexpr auto rule(c, _others) -> ctll::push>; + static constexpr auto rule(c, ctll::term<'^'>) -> ctll::push>; + static constexpr auto rule(c, ctll::set<'-',']'>) -> ctll::reject; + + static constexpr auto rule(class_named_name, ctll::term<'x'>) -> ctll::push, ctll::term<'i'>, ctll::term<'g'>, ctll::term<'i'>, ctll::term<'t'>, class_named_xdigit>; + static constexpr auto rule(class_named_name, ctll::term<'d'>) -> ctll::push, ctll::term<'g'>, ctll::term<'i'>, ctll::term<'t'>, class_named_digit>; + static constexpr auto rule(class_named_name, ctll::term<'b'>) -> ctll::push, ctll::term<'a'>, ctll::term<'n'>, ctll::term<'k'>, class_named_blank>; + static constexpr auto rule(class_named_name, ctll::term<'c'>) -> ctll::push, ctll::term<'t'>, ctll::term<'r'>, ctll::term<'l'>, class_named_cntrl>; + static constexpr auto rule(class_named_name, ctll::term<'w'>) -> ctll::push, ctll::term<'r'>, ctll::term<'d'>, class_named_word>; + static constexpr auto rule(class_named_name, ctll::term<'l'>) -> ctll::push, ctll::term<'w'>, ctll::term<'e'>, ctll::term<'r'>, class_named_lower>; + static constexpr auto rule(class_named_name, ctll::term<'s'>) -> ctll::push, ctll::term<'a'>, ctll::term<'c'>, ctll::term<'e'>, class_named_space>; + static constexpr auto rule(class_named_name, ctll::term<'u'>) -> ctll::push, ctll::term<'p'>, ctll::term<'e'>, ctll::term<'r'>, class_named_upper>; + static constexpr auto rule(class_named_name, ctll::term<'g'>) -> ctll::push, ctll::term<'a'>, ctll::term<'p'>, ctll::term<'h'>, class_named_graph>; + static constexpr auto rule(class_named_name, ctll::term<'a'>) -> ctll::push; + static constexpr auto rule(class_named_name, ctll::term<'p'>) -> ctll::push; + + static constexpr auto rule(content2, ctll::term<'\x29'>) -> ctll::epsilon; + static constexpr auto rule(content2, ctll::epsilon) -> ctll::epsilon; + static constexpr auto rule(content2, ctll::term<'|'>) -> ctll::push; + + static constexpr auto rule(content, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(content, ctll::term<'['>) -> ctll::push; + static constexpr auto rule(content, ctll::term<'\x28'>) -> ctll::push; + static constexpr auto rule(content, ctll::term<'^'>) -> ctll::push; + static constexpr auto rule(content, ctll::term<'$'>) -> ctll::push; + static constexpr auto rule(content, ctll::set<'!',',','-','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"',']','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + static constexpr auto rule(content, _others) -> ctll::push; + static constexpr auto rule(content, ctll::term<'.'>) -> ctll::push; + static constexpr auto rule(content, ctll::set<'\x29','*','+','?','\x7B','|','\x7D'>) -> ctll::reject; + + static constexpr auto rule(content_in_capture, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::term<'['>) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::term<'\x28'>) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::term<'^'>) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::term<'$'>) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::set<'!',',','-','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"',']','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + static constexpr auto rule(content_in_capture, _others) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::term<'.'>) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::term<'|'>) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::term<'\x29'>) -> ctll::push; + static constexpr auto rule(content_in_capture, ctll::set<'*','+','?','\x7B','\x7D'>) -> ctll::reject; + + static constexpr auto rule(content_or_empty, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(content_or_empty, ctll::term<'['>) -> ctll::push; + static constexpr auto rule(content_or_empty, ctll::term<'\x28'>) -> ctll::push; + static constexpr auto rule(content_or_empty, ctll::term<'^'>) -> ctll::push; + static constexpr auto rule(content_or_empty, ctll::term<'$'>) -> ctll::push; + static constexpr auto rule(content_or_empty, ctll::set<'!',',','-','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"',']','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + static constexpr auto rule(content_or_empty, _others) -> ctll::push; + static constexpr auto rule(content_or_empty, ctll::term<'.'>) -> ctll::push; + static constexpr auto rule(content_or_empty, ctll::term<'\x29'>) -> ctll::push; + static constexpr auto rule(content_or_empty, ctll::set<'*','+','?','\x7B','|','\x7D'>) -> ctll::reject; + + static constexpr auto rule(d, ctll::term<'i'>) -> ctll::push; + static constexpr auto rule(d, ctll::term<'c'>) -> ctll::push; + static constexpr auto rule(d, ctll::term<'m'>) -> ctll::push; + static constexpr auto rule(d, ctll::term<'s'>) -> ctll::push; + static constexpr auto rule(d, ctll::term<'<'>) -> ctll::push; + static constexpr auto rule(d, ctll::term<':'>) -> ctll::push>; + static constexpr auto rule(d, ctll::term<'>'>) -> ctll::push>; + static constexpr auto rule(d, ctll::term<'!'>) -> ctll::push>; + static constexpr auto rule(d, ctll::term<'='>) -> ctll::push>; + + static constexpr auto rule(e, ctll::term<'d'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'h'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'H'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'V'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'D'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'N'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'S'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'W'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'s'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'v'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'w'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'p'>) -> ctll::push, property_name, ctll::term<'\x7D'>, make_property>; + static constexpr auto rule(e, ctll::term<'P'>) -> ctll::push, property_name, ctll::term<'\x7D'>, make_property_negative>; + static constexpr auto rule(e, ctll::term<'u'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'x'>) -> ctll::push; + static constexpr auto rule(e, ctll::set<'$','\x28','\x29','*','+','-','.','/','<','>','?','[','\\','\"',']','^','\x7B','|','\x7D'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'a'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'e'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'f'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'n'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'0'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'r'>) -> ctll::push; + static constexpr auto rule(e, ctll::term<'t'>) -> ctll::push; + + static constexpr auto rule(f, ctll::term<'d'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'h'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'H'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'V'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'D'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'N'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'S'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'W'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'s'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'v'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'w'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'p'>) -> ctll::push, property_name, ctll::term<'\x7D'>, make_property>; + static constexpr auto rule(f, ctll::term<'P'>) -> ctll::push, property_name, ctll::term<'\x7D'>, make_property_negative>; + static constexpr auto rule(f, ctll::term<'u'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'x'>) -> ctll::push; + static constexpr auto rule(f, ctll::set<'$','\x28','\x29','*','+','-','.','/','<','>','?','[','\\','\"',']','^','\x7B','|','\x7D'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'a'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'e'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'f'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'n'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'0'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'r'>) -> ctll::push; + static constexpr auto rule(f, ctll::term<'t'>) -> ctll::push; + + static constexpr auto rule(g, ctll::term<'s'>) -> ctll::push, ctll::term<'i'>, ctll::term<'i'>, class_named_ascii>; + static constexpr auto rule(g, ctll::term<'l'>) -> ctll::push; + + static constexpr auto rule(h, ctll::term<'r'>) -> ctll::push, ctll::term<'n'>, ctll::term<'t'>, class_named_print>; + static constexpr auto rule(h, ctll::term<'u'>) -> ctll::push, ctll::term<'c'>, ctll::term<'t'>, class_named_punct>; + + static constexpr auto rule(hexdec_repeat, ctll::term<'\x7D'>) -> ctll::epsilon; + static constexpr auto rule(hexdec_repeat, ctll::set<'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','a','b','c','d','e','f'>) -> ctll::push; + + static constexpr auto rule(i, ctll::term<'^'>) -> ctll::push, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'x'>) -> ctll::push, ctll::term<'i'>, ctll::term<'g'>, ctll::term<'i'>, ctll::term<'t'>, class_named_xdigit, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'d'>) -> ctll::push, ctll::term<'g'>, ctll::term<'i'>, ctll::term<'t'>, class_named_digit, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'b'>) -> ctll::push, ctll::term<'a'>, ctll::term<'n'>, ctll::term<'k'>, class_named_blank, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'c'>) -> ctll::push, ctll::term<'t'>, ctll::term<'r'>, ctll::term<'l'>, class_named_cntrl, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'w'>) -> ctll::push, ctll::term<'r'>, ctll::term<'d'>, class_named_word, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'l'>) -> ctll::push, ctll::term<'w'>, ctll::term<'e'>, ctll::term<'r'>, class_named_lower, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'s'>) -> ctll::push, ctll::term<'a'>, ctll::term<'c'>, ctll::term<'e'>, class_named_space, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'u'>) -> ctll::push, ctll::term<'p'>, ctll::term<'e'>, ctll::term<'r'>, class_named_upper, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'g'>) -> ctll::push, ctll::term<'a'>, ctll::term<'p'>, ctll::term<'h'>, class_named_graph, ctll::term<':'>, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'a'>) -> ctll::push, ctll::term<']'>>; + static constexpr auto rule(i, ctll::term<'p'>) -> ctll::push, ctll::term<']'>>; + + static constexpr auto rule(j, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(j, ctll::set<'!','$','\x28','\x29','*','+',',','.','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','?','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"','^','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','\x7B','|','\x7D'>) -> ctll::push; + static constexpr auto rule(j, _others) -> ctll::push; + static constexpr auto rule(j, ctll::set<'-','[',']'>) -> ctll::reject; + + static constexpr auto rule(k, ctll::term<'\x7B'>) -> ctll::push, push_hexdec, hexdec_repeat, ctll::term<'\x7D'>, finish_hexdec>; + static constexpr auto rule(k, ctll::set<'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','a','b','c','d','e','f'>) -> ctll::push, push_hexdec, ctll::set<'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','a','b','c','d','e','f'>, push_hexdec, ctll::set<'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','a','b','c','d','e','f'>, push_hexdec, finish_hexdec>; + + static constexpr auto rule(l, ctll::term<'\x7B'>) -> ctll::push, push_hexdec, hexdec_repeat, ctll::term<'\x7D'>, finish_hexdec>; + static constexpr auto rule(l, ctll::set<'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','a','b','c','d','e','f'>) -> ctll::push, push_hexdec, finish_hexdec>; + + static constexpr auto rule(m, ctll::set<'0','1','2','3','4','5','6','7','8','9'>) -> ctll::push, make_back_reference>; + static constexpr auto rule(m, ctll::term<'-'>) -> ctll::push, make_relative_back_reference>; + static constexpr auto rule(m, ctll::set<'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push, make_back_reference>; + + static constexpr auto rule(mod, ctll::set<'!','$','\x28','\x29',',','-','.','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','[','\\','\"',']','^','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','|'>) -> ctll::epsilon; + static constexpr auto rule(mod, ctll::epsilon) -> ctll::epsilon; + static constexpr auto rule(mod, _others) -> ctll::epsilon; + static constexpr auto rule(mod, ctll::term<'?'>) -> ctll::push; + static constexpr auto rule(mod, ctll::term<'+'>) -> ctll::push; + static constexpr auto rule(mod, ctll::set<'*','\x7B','\x7D'>) -> ctll::reject; + + static constexpr auto rule(mode_switch2, ctll::term<'i'>) -> ctll::push; + static constexpr auto rule(mode_switch2, ctll::term<'c'>) -> ctll::push; + static constexpr auto rule(mode_switch2, ctll::term<'m'>) -> ctll::push; + static constexpr auto rule(mode_switch2, ctll::term<'s'>) -> ctll::push; + static constexpr auto rule(mode_switch2, ctll::term<'\x29'>) -> ctll::push; + + static constexpr auto rule(n, ctll::set<'0','1','2','3','4','5','6','7','8','9'>) -> ctll::push, mod>; + static constexpr auto rule(n, ctll::term<'\x7D'>) -> ctll::push; + + static constexpr auto rule(number2, ctll::set<',','\x7D'>) -> ctll::epsilon; + static constexpr auto rule(number2, ctll::set<'0','1','2','3','4','5','6','7','8','9'>) -> ctll::push; + + static constexpr auto rule(number, ctll::set<'0','1','2','3','4','5','6','7','8','9'>) -> ctll::push; + + static constexpr auto rule(o, ctll::set<'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push'>, content_in_capture, make_capture_with_name, ctll::term<'\x29'>>; + static constexpr auto rule(o, ctll::term<'!'>) -> ctll::push>; + static constexpr auto rule(o, ctll::term<'='>) -> ctll::push>; + + static constexpr auto rule(p, ctll::term<'p'>) -> ctll::push, ctll::term<'a'>, class_named_alpha>; + static constexpr auto rule(p, ctll::term<'n'>) -> ctll::push, ctll::term<'m'>, class_named_alnum>; + + static constexpr auto rule(property_name2, ctll::term<'\x7D'>) -> ctll::epsilon; + static constexpr auto rule(property_name2, ctll::term<'='>) -> ctll::push; + static constexpr auto rule(property_name2, ctll::set<'.','0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + + static constexpr auto rule(property_name, ctll::set<'.','0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + + static constexpr auto rule(property_value2, ctll::term<'\x7D'>) -> ctll::epsilon; + static constexpr auto rule(property_value2, ctll::set<'.','0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + + static constexpr auto rule(property_value, ctll::set<'.','0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + + static constexpr auto rule(range, ctll::set<'!','$','\x28','\x29','*','+',',','.','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','?','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','[','\\','\"',']','^','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','\x7B','|','\x7D'>) -> ctll::epsilon; + static constexpr auto rule(range, ctll::epsilon) -> ctll::epsilon; + static constexpr auto rule(range, _others) -> ctll::epsilon; + static constexpr auto rule(range, ctll::term<'-'>) -> ctll::push; + + static constexpr auto rule(repeat, ctll::set<'!','$','\x28','\x29',',','-','.','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','[','\\','\"',']','^','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','|'>) -> ctll::epsilon; + static constexpr auto rule(repeat, ctll::epsilon) -> ctll::epsilon; + static constexpr auto rule(repeat, _others) -> ctll::epsilon; + static constexpr auto rule(repeat, ctll::term<'?'>) -> ctll::push; + static constexpr auto rule(repeat, ctll::term<'\x7B'>) -> ctll::push; + static constexpr auto rule(repeat, ctll::term<'+'>) -> ctll::push; + static constexpr auto rule(repeat, ctll::term<'*'>) -> ctll::push; + static constexpr auto rule(repeat, ctll::term<'\x7D'>) -> ctll::reject; + + static constexpr auto rule(set2a, ctll::term<']'>) -> ctll::epsilon; + static constexpr auto rule(set2a, ctll::term<'['>) -> ctll::push, i, range, set_start, set2b>; + static constexpr auto rule(set2a, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(set2a, ctll::set<'!','$','\x28','\x29','*','+',',','.','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','?','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"','^','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','\x7B','|','\x7D'>) -> ctll::push; + static constexpr auto rule(set2a, _others) -> ctll::push; + static constexpr auto rule(set2a, ctll::term<'-'>) -> ctll::reject; + + static constexpr auto rule(set2b, ctll::term<']'>) -> ctll::epsilon; + static constexpr auto rule(set2b, ctll::term<'['>) -> ctll::push, i, range, set_combine, set2b>; + static constexpr auto rule(set2b, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(set2b, ctll::set<'!','$','\x28','\x29','*','+',',','.','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','?','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"','^','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','\x7B','|','\x7D'>) -> ctll::push; + static constexpr auto rule(set2b, _others) -> ctll::push; + static constexpr auto rule(set2b, ctll::term<'-'>) -> ctll::reject; + + static constexpr auto rule(string2, ctll::set<'\x29','|'>) -> ctll::epsilon; + static constexpr auto rule(string2, ctll::epsilon) -> ctll::epsilon; + static constexpr auto rule(string2, ctll::term<'\\'>) -> ctll::push; + static constexpr auto rule(string2, ctll::term<'['>) -> ctll::push; + static constexpr auto rule(string2, ctll::term<'\x28'>) -> ctll::push; + static constexpr auto rule(string2, ctll::term<'^'>) -> ctll::push; + static constexpr auto rule(string2, ctll::term<'$'>) -> ctll::push; + static constexpr auto rule(string2, ctll::set<'!',',','-','/','0','1','2','3','4','5','6','7','8','9',':','<','=','>','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','\"',']','_','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'>) -> ctll::push; + static constexpr auto rule(string2, _others) -> ctll::push; + static constexpr auto rule(string2, ctll::term<'.'>) -> ctll::push; + static constexpr auto rule(string2, ctll::set<'*','+','?','\x7B','\x7D'>) -> ctll::reject; + +}; + +} + +#endif //CTRE__PCRE__HPP + +#ifndef CTRE__ROTATE__HPP +#define CTRE__ROTATE__HPP + +#ifndef CTRE__ATOMS__HPP +#define CTRE__ATOMS__HPP + +#ifndef CTRE__ATOMS_CHARACTERS__HPP +#define CTRE__ATOMS_CHARACTERS__HPP + +#ifndef CTRE__UTILITY__HPP +#define CTRE__UTILITY__HPP + +#define CTRE_CNTTP_COMPILER_CHECK CTLL_CNTTP_COMPILER_CHECK + +#ifdef CTRE_IN_A_MODULE +#define CTRE_EXPORT export +#else +#define CTRE_EXPORT +#endif + +#if __GNUC__ > 9 +#if __has_cpp_attribute(likely) +#define CTRE_LIKELY [[likely]] +#else +#define CTRE_LIKELY +#endif + +#if __has_cpp_attribute(unlikely) +#define CTRE_UNLIKELY [[unlikely]] +#else +#define CTRE_UNLIKELY +#endif +#else +#define CTRE_LIKELY +#define CTRE_UNLIKELY +#endif + +#ifdef _MSC_VER +#define CTRE_FORCE_INLINE __forceinline +#if __has_cpp_attribute(msvc::flatten) +#define CTRE_FLATTEN [[msvc::flatten]] +#elif _MSC_VER >= 1930 && !defined(__clang__) +#define CTRE_FLATTEN [[msvc::flatten]] +#else +#define CTRE_FLATTEN +#endif +#else +#define CTRE_FORCE_INLINE inline __attribute__((always_inline)) +#define CTRE_FLATTEN __attribute__((flatten)) +#endif + +#endif + +#ifndef CTRE_V2__CTRE__FLAGS_AND_MODES__HPP +#define CTRE_V2__CTRE__FLAGS_AND_MODES__HPP + +namespace ctre { + +struct singleline { }; +struct multiline { }; + +struct case_sensitive { }; +struct case_insensitive { }; + +using ci = case_insensitive; +using cs = case_sensitive; + +template struct flag_list { }; + +struct flags { + bool block_empty_match = false; + bool multiline = false; + bool case_insensitive = false; + + constexpr flags() = default; + constexpr flags(const flags &) = default; + constexpr flags(flags &&) = default; + + constexpr CTRE_FORCE_INLINE flags(ctre::singleline v) noexcept { set_flag(v); } + constexpr CTRE_FORCE_INLINE flags(ctre::multiline v) noexcept { set_flag(v); } + constexpr CTRE_FORCE_INLINE flags(ctre::case_sensitive v) noexcept { set_flag(v); } + constexpr CTRE_FORCE_INLINE flags(ctre::case_insensitive v) noexcept { set_flag(v); } + + + template constexpr CTRE_FORCE_INLINE flags(ctll::list) noexcept { + (this->set_flag(Args{}), ...); + } + + constexpr friend CTRE_FORCE_INLINE auto operator+(flags f, pcre::mode_case_insensitive) noexcept { + f.case_insensitive = true; + return f; + } + + constexpr friend CTRE_FORCE_INLINE auto operator+(flags f, pcre::mode_case_sensitive) noexcept { + f.case_insensitive = false; + return f; + } + + constexpr friend CTRE_FORCE_INLINE auto operator+(flags f, pcre::mode_singleline) noexcept { + f.multiline = false; + return f; + } + + constexpr friend CTRE_FORCE_INLINE auto operator+(flags f, pcre::mode_multiline) noexcept { + f.multiline = true; + return f; + } + + constexpr CTRE_FORCE_INLINE void set_flag(ctre::singleline) noexcept { + multiline = false; + } + + constexpr CTRE_FORCE_INLINE void set_flag(ctre::multiline) noexcept { + multiline = true; + } + + constexpr CTRE_FORCE_INLINE void set_flag(ctre::case_insensitive) noexcept { + case_insensitive = true; + } + + constexpr CTRE_FORCE_INLINE void set_flag(ctre::case_sensitive) noexcept { + case_insensitive = false; + } +}; + +constexpr CTRE_FORCE_INLINE auto not_empty_match(flags f) { + f.block_empty_match = true; + return f; +} + +constexpr CTRE_FORCE_INLINE auto consumed_something(flags f, bool condition = true) { + if (condition) f.block_empty_match = false; + return f; +} + +constexpr CTRE_FORCE_INLINE bool cannot_be_empty_match(flags f) { + return f.block_empty_match; +} + +constexpr CTRE_FORCE_INLINE bool multiline_mode(flags f) { + return f.multiline; +} + +constexpr CTRE_FORCE_INLINE bool is_case_insensitive(flags f) { + return f.case_insensitive; +} + +} // namespace ctre + +#endif + +#ifndef CTRE_IN_A_MODULE +#include +#endif + +namespace ctre { + +// sfinae check for types here + +template class MatchesCharacter { + template static auto test(CharT c) -> decltype(Y::match_char(c, std::declval()), std::true_type()); + template static auto test(...) -> std::false_type; +public: + template static inline constexpr bool value = decltype(test(std::declval()))(); +}; + +template constexpr CTRE_FORCE_INLINE bool is_ascii_alpha(T v) { + return ((v >= static_cast('a') && v <= static_cast('z')) || (v >= static_cast('A') && v <= static_cast('Z'))); +} + +template constexpr CTRE_FORCE_INLINE bool is_ascii_alpha_lowercase(T v) { + return (v >= static_cast('a')) && (v <= static_cast('z')); +} + +template constexpr CTRE_FORCE_INLINE bool is_ascii_alpha_uppercase(T v) { + return (v >= static_cast('A')) && v <= (static_cast('Z')); +} + +template struct character { + template CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags & f) noexcept { + if constexpr (is_ascii_alpha(V)) { + if (is_case_insensitive(f)) { + if (value == (V ^ static_cast(0x20))) { + return true;// + } + } + } + return value == V; + } +}; + +template struct negative_set { + template CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags & f) noexcept { + return !(Content::match_char(value, f) || ... || false); + } +}; + +template struct set { + template CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags & f) noexcept { + return (Content::match_char(value, f) || ... || false); + } +}; + +template struct enumeration : set...> { }; + +template struct negate { + template CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags & f) noexcept { + return !(Content::match_char(value, f) || ... || false); + } +}; + +template struct char_range { + template CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags & f) noexcept { + if constexpr (is_ascii_alpha_lowercase(A) && is_ascii_alpha_lowercase(B)) { + if (is_case_insensitive(f)) { + if (value >= (A ^ static_cast(0x20)) && value <= (B ^ static_cast(0x20))) { + return true;// + } + } + } else if constexpr (is_ascii_alpha_uppercase(A) && is_ascii_alpha_uppercase(B)) { + if (is_case_insensitive(f)) { + if (value >= (A ^ static_cast(0x20)) && value <= (B ^ static_cast(0x20))) { + return true;// + } + } + } + return (value >= A) && (value <= B); + } +}; +using word_chars = set, char_range<'a','z'>, char_range<'0','9'>, character<'_'> >; + +using space_chars = enumeration<' ', '\t', '\n', '\v', '\f', '\r'>; + +using vertical_space_chars = enumeration< + char{0x000A}, // Linefeed (LF) + char{0x000B}, // Vertical tab (VT) + char{0x000C}, // Form feed (FF) + char{0x000D}, // Carriage return (CR) + char32_t{0x0085}, // Next line (NEL) + char32_t{0x2028}, // Line separator + char32_t{0x2029} // Paragraph separator +>; + +using horizontal_space_chars = enumeration< + char{0x0009}, // Horizontal tab (HT) + char{0x0020}, // Space + char32_t{0x00A0}, // Non-break space + char32_t{0x1680}, // Ogham space mark + char32_t{0x180E}, // Mongolian vowel separator + char32_t{0x2000}, // En quad + char32_t{0x2001}, // Em quad + char32_t{0x2002}, // En space + char32_t{0x2003}, // Em space + char32_t{0x2004}, // Three-per-em space + char32_t{0x2005}, // Four-per-em space + char32_t{0x2006}, // Six-per-em space + char32_t{0x2007}, // Figure space + char32_t{0x2008}, // Punctuation space + char32_t{0x2009}, // Thin space + char32_t{0x200A}, // Hair space + char32_t{0x202F}, // Narrow no-break space + char32_t{0x205F}, // Medium mathematical space + char32_t{0x3000} // Ideographic space +>; + +using alphanum_chars = set, char_range<'a','z'>, char_range<'0','9'> >; + +using alpha_chars = set, char_range<'a','z'> >; + +using xdigit_chars = set, char_range<'a','f'>, char_range<'0','9'> >; + +using punct_chars + = enumeration<'!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', + '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', + '^', '_', '`', '{', '|', '}', '~'>; + +using digit_chars = char_range<'0','9'>; + +using ascii_chars = char_range<'\x00','\x7F'>; + +} + +#endif + +#ifndef CTRE_IN_A_MODULE +#include +#endif + +namespace ctre { + +// special helpers for matching +struct accept { }; +struct reject { }; +struct start_mark { }; +struct end_mark { }; +struct end_cycle_mark { }; +struct end_lookahead_mark { }; +struct end_lookbehind_mark { }; +template struct numeric_mark { }; + +struct any { }; + +// actual AST of regexp +template struct string { }; +template struct select { }; +template struct sequence { }; +struct empty { }; + +template struct repeat { }; +template using plus = repeat<1,0,Content...>; +template using star = repeat<0,0,Content...>; + +template struct lazy_repeat { }; +template using lazy_plus = lazy_repeat<1,0,Content...>; +template using lazy_star = lazy_repeat<0,0,Content...>; + +template struct possessive_repeat { }; +template using possessive_plus = possessive_repeat<1,0,Content...>; +template using possessive_star = possessive_repeat<0,0,Content...>; + +template using optional = repeat<0,1,Content...>; +template using lazy_optional = lazy_repeat<0,1,Content...>; +template using possessive_optional = possessive_repeat<0,1,Content...>; + +template struct capture { }; + +template struct capture_with_name { }; + +template struct back_reference { }; +template struct back_reference_with_name { }; + +template struct look_start { }; + +template struct lookahead_positive { }; +template struct lookahead_negative { }; + +template struct lookbehind_positive { }; +template struct lookbehind_negative { }; + +struct atomic_start { }; + +template struct atomic_group { }; + +template struct boundary { }; +template struct not_boundary { }; + +using word_boundary = boundary; +using not_word_boundary = not_boundary; + +struct assert_subject_begin { }; +struct assert_subject_end { }; +struct assert_subject_end_line{ }; +struct assert_line_begin { }; +struct assert_line_end { }; + +template struct mode_switch { }; + +} + +#endif + +#ifndef CTRE__ATOMS_UNICODE__HPP +#define CTRE__ATOMS_UNICODE__HPP + +// master branch is not including unicode db (for now) +#ifndef H_COR3NTIN_UNICODE_SYNOPSYS +#define H_COR3NTIN_UNICODE_SYNOPSYS + +#ifndef UNICODE_DB_IN_A_MODULE +#include +#endif + +namespace uni +{ + enum class category; + enum class property; + enum class version : unsigned char; + enum class script ; + enum class block; + + struct script_extensions_view { + constexpr script_extensions_view(char32_t); + + struct sentinel {}; + struct iterator { + + constexpr iterator(char32_t c); + constexpr script operator*() const; + + constexpr iterator& operator++(int); + + constexpr iterator operator++(); + + constexpr bool operator==(sentinel) const; + constexpr bool operator!=(sentinel) const; + + private: + char32_t m_c; + script m_script; + int idx = 1; + }; + + constexpr iterator begin() const; + constexpr sentinel end() const; + + private: + char32_t c; + }; + + struct numeric_value { + + constexpr double value() const; + constexpr long long numerator() const; + constexpr int denominator() const; + constexpr bool is_valid() const; + + protected: + constexpr numeric_value() = default; + constexpr numeric_value(long long n, int16_t d); + + long long _n = 0; + int16_t _d = 0; + friend constexpr numeric_value cp_numeric_value(char32_t cp); + }; + + constexpr category cp_category(char32_t cp); + constexpr script cp_script(char32_t cp); + constexpr script_extensions_view cp_script_extensions(char32_t cp); + constexpr version cp_age(char32_t cp); + constexpr block cp_block(char32_t cp); + constexpr bool cp_is_valid(char32_t cp); + constexpr bool cp_is_assigned(char32_t cp); + constexpr bool cp_is_ascii(char32_t cp); + constexpr numeric_value cp_numeric_value(char32_t cp); + + template