From 1b75372deb7a9e9ff6dff1b051d8e19220c1d51d Mon Sep 17 00:00:00 2001 From: Herb Sutter Date: Thu, 10 Oct 2024 15:48:32 -0700 Subject: [PATCH 1/4] Switch to Apache 2.0 with LLVM Exceptions --- CITATION.cff | 2 +- LICENSE | 264 +++++- include/cpp2regex.h | 347 ++++--- include/cpp2regex.h2 | 15 +- include/cpp2util.h | 15 +- regression-tests/test-results/version | 12 +- source/build.info | 2 +- source/common.h | 26 +- source/cppfront.cpp | 15 +- source/io.h | 15 +- source/lex.h | 15 +- source/parse.h | 15 +- source/reflect.h | 1257 ++++++++++++------------- source/reflect.h2 | 15 +- source/sema.h | 15 +- source/to_cpp1.h | 15 +- 16 files changed, 1109 insertions(+), 936 deletions(-) diff --git a/CITATION.cff b/CITATION.cff index b10aea847e..9d8190f124 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -9,4 +9,4 @@ authors: family-names: Sutter repository-code: 'https://github.com/hsutter/cppfront' abstract: A personal experimental C++ Syntax 2 -> Syntax 1 compiler -license: CC-BY-NC-ND-4.0 +license: Apache-2.0 WITH LLVM-exception diff --git a/LICENSE b/LICENSE index 1689a5eac9..f9ada7be27 100644 --- a/LICENSE +++ b/LICENSE @@ -1,11 +1,255 @@ -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. +Copyright 2022-2024 Herb Sutter +SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + + 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. + + +============================================================================== +The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: +============================================================================== + + 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. + +============================================================================== +Software from third parties included in the Cppfront Project: +============================================================================== + +The Cppfront Project does not currently contain third party software that +is under different license terms. If such code is added in the future, +all such code will be identified clearly using at least one of two +mechanisms: + +1) It will be in a separate directory tree with its own `LICENSE.txt` or + `LICENSE` file at the top containing the specific license and restrictions + which apply to that software, or + +2) It will contain specific license and restriction terms at the top of every + file. diff --git a/include/cpp2regex.h b/include/cpp2regex.h index e19398634e..ee0fd2c543 100644 --- a/include/cpp2regex.h +++ b/include/cpp2regex.h @@ -10,67 +10,67 @@ #line 1 "cpp2regex.h2" -#line 27 "cpp2regex.h2" +#line 22 "cpp2regex.h2" namespace cpp2 { namespace regex { -#line 43 "cpp2regex.h2" +#line 38 "cpp2regex.h2" template class match_group; -#line 53 "cpp2regex.h2" +#line 48 "cpp2regex.h2" template class match_return; -#line 61 "cpp2regex.h2" +#line 56 "cpp2regex.h2" template class match_context; -#line 122 "cpp2regex.h2" +#line 117 "cpp2regex.h2" class true_end_func; -#line 130 "cpp2regex.h2" +#line 125 "cpp2regex.h2" class no_reset; -#line 137 "cpp2regex.h2" +#line 132 "cpp2regex.h2" template class on_return; -#line 164 "cpp2regex.h2" +#line 159 "cpp2regex.h2" template class single_class_entry; -#line 173 "cpp2regex.h2" +#line 168 "cpp2regex.h2" template class range_class_entry; -#line 182 "cpp2regex.h2" +#line 177 "cpp2regex.h2" template class combined_class_entry; -#line 191 "cpp2regex.h2" +#line 186 "cpp2regex.h2" template class list_class_entry; -#line 200 "cpp2regex.h2" +#line 195 "cpp2regex.h2" template class named_class_entry; -#line 207 "cpp2regex.h2" +#line 202 "cpp2regex.h2" template class negated_class_entry; -#line 216 "cpp2regex.h2" +#line 211 "cpp2regex.h2" template class shorthand_class_entry; -#line 264 "cpp2regex.h2" +#line 259 "cpp2regex.h2" template class alternative_token_matcher; -#line 342 "cpp2regex.h2" +#line 337 "cpp2regex.h2" template class class_token_matcher; -#line 497 "cpp2regex.h2" +#line 492 "cpp2regex.h2" class range_flags; -#line 506 "cpp2regex.h2" +#line 501 "cpp2regex.h2" template class range_token_matcher; -#line 678 "cpp2regex.h2" +#line 673 "cpp2regex.h2" template class regular_expression; -#line 761 "cpp2regex.h2" +#line 756 "cpp2regex.h2" } } @@ -79,16 +79,11 @@ template class regular_expression; #line 1 "cpp2regex.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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== @@ -104,7 +99,7 @@ using matcher_wrapper_type = typename matcher_wrapper::template wrap using matcher_context_type = typename matcher::context; -#line 27 "cpp2regex.h2" +#line 22 "cpp2regex.h2" namespace cpp2 { namespace regex { @@ -130,7 +125,7 @@ template class match_group public: match_group(auto const& start_, auto const& end_, auto const& matched_); public: match_group(); -#line 49 "cpp2regex.h2" +#line 44 "cpp2regex.h2" }; // Return value for every matcher. @@ -142,7 +137,7 @@ template class match_return public: match_return(auto const& matched_, auto const& pos_); public: match_return(); -#line 57 "cpp2regex.h2" +#line 52 "cpp2regex.h2" }; // Modifiable state during matching. @@ -156,13 +151,13 @@ template class match_context public: explicit match_context(Iter const& begin_, Iter const& end_); -#line 73 "cpp2regex.h2" +#line 68 "cpp2regex.h2" public: match_context(match_context const& that); -#line 73 "cpp2regex.h2" +#line 68 "cpp2regex.h2" public: auto operator=(match_context const& that) -> match_context& ; -#line 73 "cpp2regex.h2" +#line 68 "cpp2regex.h2" public: match_context(match_context&& that) noexcept; -#line 73 "cpp2regex.h2" +#line 68 "cpp2regex.h2" public: auto operator=(match_context&& that) noexcept -> match_context& ; // Getter and setter for groups @@ -171,22 +166,22 @@ template class match_context public: [[nodiscard]] auto get_group_end(auto const& group) const& -> int; -#line 85 "cpp2regex.h2" +#line 80 "cpp2regex.h2" public: [[nodiscard]] auto get_group_start(auto const& group) const& -> int; -#line 91 "cpp2regex.h2" +#line 86 "cpp2regex.h2" public: [[nodiscard]] auto get_group_string(auto const& group) const& -> std::string; -#line 98 "cpp2regex.h2" +#line 93 "cpp2regex.h2" public: auto set_group_end(auto const& group, auto const& pos) & -> void; -#line 103 "cpp2regex.h2" +#line 98 "cpp2regex.h2" public: auto set_group_invalid(auto const& group) & -> void; -#line 107 "cpp2regex.h2" +#line 102 "cpp2regex.h2" public: auto set_group_start(auto const& group, auto const& pos) & -> void; -#line 111 "cpp2regex.h2" +#line 106 "cpp2regex.h2" public: [[nodiscard]] auto size() const& -> decltype(auto); // Misc functions @@ -195,7 +190,7 @@ template class match_context public: [[nodiscard]] auto pass(cpp2::impl::in cur) const& -> decltype(auto); }; -#line 120 "cpp2regex.h2" +#line 115 "cpp2regex.h2" // End function that returns a valid match. // class true_end_func @@ -203,7 +198,7 @@ class true_end_func public: [[nodiscard]] auto operator()(auto const& cur, auto& ctx) const& -> decltype(auto); }; -#line 128 "cpp2regex.h2" +#line 123 "cpp2regex.h2" // Empty group reset function. // class no_reset @@ -211,30 +206,30 @@ class no_reset public: auto operator()([[maybe_unused]] auto& unnamed_param_2) const& -> void; }; -#line 136 "cpp2regex.h2" +#line 131 "cpp2regex.h2" // Evaluate func on destruction of the handle. template class on_return { private: Func func; public: explicit on_return(Func const& f); -#line 141 "cpp2regex.h2" +#line 136 "cpp2regex.h2" public: auto operator=(Func const& f) -> on_return& ; -#line 145 "cpp2regex.h2" +#line 140 "cpp2regex.h2" public: ~on_return() noexcept; public: on_return(on_return const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(on_return const&) -> void = delete; -#line 148 "cpp2regex.h2" +#line 143 "cpp2regex.h2" }; -#line 151 "cpp2regex.h2" +#line 146 "cpp2regex.h2" // Helper for auto deduction of the Func type. template [[nodiscard]] auto make_on_return(Func const& func) -> decltype(auto); -#line 155 "cpp2regex.h2" +#line 150 "cpp2regex.h2" //----------------------------------------------------------------------- // // Character classes for regular expressions. @@ -252,10 +247,10 @@ template class single_class_entry public: single_class_entry(single_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(single_class_entry const&) -> void = delete; -#line 168 "cpp2regex.h2" +#line 163 "cpp2regex.h2" }; -#line 171 "cpp2regex.h2" +#line 166 "cpp2regex.h2" // Class syntax: - Example: a-c // template class range_class_entry @@ -266,10 +261,10 @@ template class range_class_entry public: range_class_entry(range_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(range_class_entry const&) -> void = delete; -#line 177 "cpp2regex.h2" +#line 172 "cpp2regex.h2" }; -#line 180 "cpp2regex.h2" +#line 175 "cpp2regex.h2" // Helper for combining two character classes // template class combined_class_entry @@ -280,10 +275,10 @@ template class combined_class_entry public: combined_class_entry(combined_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(combined_class_entry const&) -> void = delete; -#line 186 "cpp2regex.h2" +#line 181 "cpp2regex.h2" }; -#line 189 "cpp2regex.h2" +#line 184 "cpp2regex.h2" // Class syntax: Example: abcd // template class list_class_entry @@ -294,10 +289,10 @@ template class list_class_entry public: list_class_entry(list_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(list_class_entry const&) -> void = delete; -#line 195 "cpp2regex.h2" +#line 190 "cpp2regex.h2" }; -#line 198 "cpp2regex.h2" +#line 193 "cpp2regex.h2" // Class syntax: [: class named_class_entry @@ -308,10 +303,10 @@ template class n public: named_class_entry(named_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(named_class_entry const&) -> void = delete; -#line 204 "cpp2regex.h2" +#line 199 "cpp2regex.h2" }; -#line 207 "cpp2regex.h2" +#line 202 "cpp2regex.h2" template class negated_class_entry : public Inner { @@ -320,10 +315,10 @@ template class negated_class_entry public: negated_class_entry(negated_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(negated_class_entry const&) -> void = delete; -#line 211 "cpp2regex.h2" +#line 206 "cpp2regex.h2" }; -#line 214 "cpp2regex.h2" +#line 209 "cpp2regex.h2" // Short class syntax: \ Example: \w // template class shorthand_class_entry @@ -334,10 +329,10 @@ template class s public: shorthand_class_entry(shorthand_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(shorthand_class_entry const&) -> void = delete; -#line 220 "cpp2regex.h2" +#line 215 "cpp2regex.h2" }; -#line 223 "cpp2regex.h2" +#line 218 "cpp2regex.h2" // Named basic character classes // template using digits_class = named_class_entry>; @@ -374,7 +369,7 @@ template using short_not_space_class = nega template using short_not_vert_space_class = negated_class_entry>>; template using short_not_word_class = negated_class_entry>>; -#line 260 "cpp2regex.h2" +#line 255 "cpp2regex.h2" // Regex syntax: | Example: ab|ba // // Non greedy implementation. First alternative that matches is chosen. @@ -383,22 +378,22 @@ template class alternative_token_matcher { public: [[nodiscard]] static auto match(auto const& cur, auto& ctx, auto const& end_func, auto const& tail, auto const& ...functions) -> auto; -#line 270 "cpp2regex.h2" +#line 265 "cpp2regex.h2" private: template [[nodiscard]] static auto match_first(auto const& cur, auto& ctx, auto const& end_func, auto const& tail, auto const& cur_func, auto const& cur_reset, Other const& ...other) -> auto; public: alternative_token_matcher() = default; public: alternative_token_matcher(alternative_token_matcher const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(alternative_token_matcher const&) -> void = delete; -#line 288 "cpp2regex.h2" +#line 283 "cpp2regex.h2" }; -#line 291 "cpp2regex.h2" +#line 286 "cpp2regex.h2" // Regex syntax: . // template [[nodiscard]] auto any_token_matcher(auto& cur, auto& ctx) -> bool; -#line 306 "cpp2regex.h2" +#line 301 "cpp2regex.h2" // TODO: Check if vectorization works at some point with this implementation. // char_token_matcher: (inout cur, inout ctx) -> bool = { // if !(std::distance(cur, ctx.end) < tokens..size()) { @@ -432,21 +427,21 @@ template [[nodiscard]] auto any_token_matcher( // return matched; // } -#line 340 "cpp2regex.h2" +#line 335 "cpp2regex.h2" // Regex syntax: [] Example: [abcx-y[:digits:]] // template class class_token_matcher { public: [[nodiscard]] static auto match(auto& cur, auto& ctx) -> bool; -#line 373 "cpp2regex.h2" +#line 368 "cpp2regex.h2" private: template [[nodiscard]] static auto match_any(cpp2::impl::in c) -> bool; public: class_token_matcher() = default; public: class_token_matcher(class_token_matcher const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(class_token_matcher const&) -> void = delete; -#line 386 "cpp2regex.h2" +#line 381 "cpp2regex.h2" // TODO: Implement proper to string // to_string: () -> bstring = { // r: bstring = "["; @@ -458,10 +453,10 @@ template c // return r; // } -#line 397 "cpp2regex.h2" +#line 392 "cpp2regex.h2" }; -#line 400 "cpp2regex.h2" +#line 395 "cpp2regex.h2" // Named short classes // template using named_class_no_new_line = class_token_matcher>; @@ -477,7 +472,7 @@ template usi template using named_class_not_ver_space = class_token_matcher>; template using named_class_not_word = class_token_matcher>; -#line 416 "cpp2regex.h2" +#line 411 "cpp2regex.h2" // Regex syntax: \ Example: \1 // \g{name_or_number} // \k{name_or_number} @@ -486,27 +481,27 @@ template usi // template [[nodiscard]] auto group_ref_token_matcher(auto& cur, auto& ctx) -> bool; -#line 453 "cpp2regex.h2" +#line 448 "cpp2regex.h2" // Regex syntax: $ Example: aa$ // template [[nodiscard]] auto line_end_token_matcher(auto const& cur, auto& ctx) -> bool; -#line 469 "cpp2regex.h2" +#line 464 "cpp2regex.h2" // Regex syntax: ^ Example: ^aa // template [[nodiscard]] auto line_start_token_matcher(auto const& cur, auto& ctx) -> bool; -#line 478 "cpp2regex.h2" +#line 473 "cpp2regex.h2" // Regex syntax: (?=) or (?!) or (*pla), etc. Example: (?=AA) // // Parsed in group_token. // template [[nodiscard]] auto lookahead_token_matcher(auto const& cur, auto& ctx, auto const& func) -> bool; -#line 493 "cpp2regex.h2" +#line 488 "cpp2regex.h2" // TODO: @enum as template parameter currently not working. See issue https://github.com/hsutter/cppfront/issues/1147 -#line 496 "cpp2regex.h2" +#line 491 "cpp2regex.h2" // Options for range matching. class range_flags { public: static const int not_greedy;// Try to take as few as possible. @@ -517,9 +512,9 @@ class range_flags { public: range_flags(range_flags const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(range_flags const&) -> void = delete; }; -#line 502 "cpp2regex.h2" +#line 497 "cpp2regex.h2" -#line 504 "cpp2regex.h2" +#line 499 "cpp2regex.h2" // Regex syntax: {min, max} Example: a{2,4} // template class range_token_matcher @@ -527,42 +522,42 @@ template class range_tok public: template [[nodiscard]] static auto match(Iter const& cur, auto& ctx, auto const& inner, auto const& reset_func, auto const& end_func, auto const& tail) -> auto; -#line 522 "cpp2regex.h2" +#line 517 "cpp2regex.h2" private: [[nodiscard]] static auto is_below_upper_bound(cpp2::impl::in count) -> bool; -#line 527 "cpp2regex.h2" +#line 522 "cpp2regex.h2" private: [[nodiscard]] static auto is_below_lower_bound(cpp2::impl::in count) -> bool; -#line 532 "cpp2regex.h2" +#line 527 "cpp2regex.h2" private: [[nodiscard]] static auto is_in_range(cpp2::impl::in count) -> bool; -#line 538 "cpp2regex.h2" +#line 533 "cpp2regex.h2" private: template [[nodiscard]] static auto match_min_count(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, int& count_r) -> auto; -#line 554 "cpp2regex.h2" +#line 549 "cpp2regex.h2" private: template [[nodiscard]] static auto match_greedy(cpp2::impl::in count, Iter const& cur, Iter const& last_valid, auto& ctx, auto const& inner, auto const& reset_func, auto const& end_func, auto const& other) -> match_return; -#line 584 "cpp2regex.h2" +#line 579 "cpp2regex.h2" private: template [[nodiscard]] static auto match_possessive(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> match_return; -#line 612 "cpp2regex.h2" +#line 607 "cpp2regex.h2" private: template [[nodiscard]] static auto match_not_greedy(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> match_return; public: range_token_matcher() = default; public: range_token_matcher(range_token_matcher const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(range_token_matcher const&) -> void = delete; -#line 638 "cpp2regex.h2" +#line 633 "cpp2regex.h2" }; -#line 641 "cpp2regex.h2" +#line 636 "cpp2regex.h2" // Regex syntax: \b or \B Example: \bword\b // // Matches the start end end of word boundaries. // template [[nodiscard]] auto word_boundary_token_matcher(auto& cur, auto& ctx) -> bool; -#line 670 "cpp2regex.h2" +#line 665 "cpp2regex.h2" //----------------------------------------------------------------------- // // Regular expression implementation. @@ -584,7 +579,7 @@ template class regular_expression public: explicit search_return(cpp2::impl::in matched_, context const& ctx_, Iter const& pos_); -#line 695 "cpp2regex.h2" +#line 690 "cpp2regex.h2" public: [[nodiscard]] auto group_number() const& -> decltype(auto); public: [[nodiscard]] auto group(cpp2::impl::in g) const& -> decltype(auto); public: [[nodiscard]] auto group_start(cpp2::impl::in g) const& -> decltype(auto); @@ -599,7 +594,7 @@ template class regular_expression public: auto operator=(search_return const&) -> void = delete; -#line 711 "cpp2regex.h2" +#line 706 "cpp2regex.h2" }; public: [[nodiscard]] auto match(cpp2::impl::in> str) const& -> decltype(auto); @@ -607,13 +602,13 @@ template class regular_expression public: [[nodiscard]] auto match(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto); public: template [[nodiscard]] auto match(Iter const& start, Iter const& end) const& -> search_return; -#line 724 "cpp2regex.h2" +#line 719 "cpp2regex.h2" public: [[nodiscard]] auto search(cpp2::impl::in> str) const& -> decltype(auto); public: [[nodiscard]] auto search(cpp2::impl::in> str, auto const& start) const& -> decltype(auto); public: [[nodiscard]] auto search(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto); public: template [[nodiscard]] auto search(Iter const& start, Iter const& end) const& -> search_return; -#line 747 "cpp2regex.h2" +#line 742 "cpp2regex.h2" public: [[nodiscard]] auto to_string() const& -> decltype(auto); // Helper functions @@ -624,7 +619,7 @@ template class regular_expression public: auto operator=(regular_expression const&) -> void = delete; -#line 759 "cpp2regex.h2" +#line 754 "cpp2regex.h2" }; } @@ -636,7 +631,7 @@ template class regular_expression #line 1 "cpp2regex.h2" -#line 27 "cpp2regex.h2" +#line 22 "cpp2regex.h2" namespace cpp2 { namespace regex { @@ -651,55 +646,55 @@ template match_return::match_return(auto const& matched_, , pos{ pos_ }{} template match_return::match_return(){} -#line 68 "cpp2regex.h2" +#line 63 "cpp2regex.h2" template match_context::match_context(Iter const& begin_, Iter const& end_) : begin{ begin_ } , end{ end_ }{ -#line 71 "cpp2regex.h2" +#line 66 "cpp2regex.h2" } -#line 73 "cpp2regex.h2" +#line 68 "cpp2regex.h2" template match_context::match_context(match_context const& that) : begin{ that.begin } , end{ that.end } , groups{ that.groups }{} -#line 73 "cpp2regex.h2" +#line 68 "cpp2regex.h2" template auto match_context::operator=(match_context const& that) -> match_context& { begin = that.begin; end = that.end; groups = that.groups; return *this; } -#line 73 "cpp2regex.h2" +#line 68 "cpp2regex.h2" template match_context::match_context(match_context&& that) noexcept : begin{ std::move(that).begin } , end{ std::move(that).end } , groups{ std::move(that).groups }{} -#line 73 "cpp2regex.h2" +#line 68 "cpp2regex.h2" template auto match_context::operator=(match_context&& that) noexcept -> match_context& { begin = std::move(that).begin; end = std::move(that).end; groups = std::move(that).groups; return *this; } -#line 77 "cpp2regex.h2" +#line 72 "cpp2regex.h2" template [[nodiscard]] auto match_context::get_group(auto const& group) const& -> decltype(auto) { return CPP2_ASSERT_IN_BOUNDS(groups, group); } -#line 79 "cpp2regex.h2" +#line 74 "cpp2regex.h2" template [[nodiscard]] auto match_context::get_group_end(auto const& group) const& -> int{ if (cpp2::impl::cmp_greater_eq(group,max_groups) || !(CPP2_ASSERT_IN_BOUNDS(groups, group).matched)) { return 0; } return cpp2::unchecked_narrow(std::distance(begin, CPP2_ASSERT_IN_BOUNDS(groups, group).end)); } -#line 85 "cpp2regex.h2" +#line 80 "cpp2regex.h2" template [[nodiscard]] auto match_context::get_group_start(auto const& group) const& -> int{ if (cpp2::impl::cmp_greater_eq(group,max_groups) || !(CPP2_ASSERT_IN_BOUNDS(groups, group).matched)) { return 0; } return cpp2::unchecked_narrow(std::distance(begin, CPP2_ASSERT_IN_BOUNDS(groups, group).start)); } -#line 91 "cpp2regex.h2" +#line 86 "cpp2regex.h2" template [[nodiscard]] auto match_context::get_group_string(auto const& group) const& -> std::string{ if (cpp2::impl::cmp_greater_eq(group,max_groups) || !(CPP2_ASSERT_IN_BOUNDS(groups, group).matched)) { return ""; @@ -707,97 +702,97 @@ template match_return::match_return(){} return std::string(CPP2_ASSERT_IN_BOUNDS(groups, group).start, CPP2_ASSERT_IN_BOUNDS(groups, group).end); } -#line 98 "cpp2regex.h2" +#line 93 "cpp2regex.h2" template auto match_context::set_group_end(auto const& group, auto const& pos) & -> void{ CPP2_ASSERT_IN_BOUNDS(groups, group).end = pos; CPP2_ASSERT_IN_BOUNDS(groups, group).matched = true; } -#line 103 "cpp2regex.h2" +#line 98 "cpp2regex.h2" template auto match_context::set_group_invalid(auto const& group) & -> void{ CPP2_ASSERT_IN_BOUNDS(groups, group).matched = false; } -#line 107 "cpp2regex.h2" +#line 102 "cpp2regex.h2" template auto match_context::set_group_start(auto const& group, auto const& pos) & -> void{ CPP2_ASSERT_IN_BOUNDS(groups, group).start = pos; } -#line 111 "cpp2regex.h2" +#line 106 "cpp2regex.h2" template [[nodiscard]] auto match_context::size() const& -> decltype(auto) { return max_groups; } -#line 115 "cpp2regex.h2" +#line 110 "cpp2regex.h2" template [[nodiscard]] auto match_context::fail() const& -> decltype(auto) { return match_return(false, end); } -#line 116 "cpp2regex.h2" +#line 111 "cpp2regex.h2" template [[nodiscard]] auto match_context::pass(cpp2::impl::in cur) const& -> decltype(auto) { return match_return(true, cur); } -#line 124 "cpp2regex.h2" +#line 119 "cpp2regex.h2" [[nodiscard]] auto true_end_func::operator()(auto const& cur, auto& ctx) const& -> decltype(auto) { return ctx.pass(cur); } -#line 132 "cpp2regex.h2" +#line 127 "cpp2regex.h2" auto no_reset::operator()([[maybe_unused]] auto& unnamed_param_2) const& -> void{} -#line 141 "cpp2regex.h2" +#line 136 "cpp2regex.h2" template on_return::on_return(Func const& f) : func{ f }{ -#line 143 "cpp2regex.h2" +#line 138 "cpp2regex.h2" } -#line 141 "cpp2regex.h2" +#line 136 "cpp2regex.h2" template auto on_return::operator=(Func const& f) -> on_return& { func = f; return *this; -#line 143 "cpp2regex.h2" +#line 138 "cpp2regex.h2" } -#line 145 "cpp2regex.h2" +#line 140 "cpp2regex.h2" template on_return::~on_return() noexcept{ cpp2::move(*this).func(); } -#line 152 "cpp2regex.h2" +#line 147 "cpp2regex.h2" template [[nodiscard]] auto make_on_return(Func const& func) -> decltype(auto) { return on_return(func); } -#line 166 "cpp2regex.h2" +#line 161 "cpp2regex.h2" template [[nodiscard]] auto single_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return c == C; } -#line 167 "cpp2regex.h2" +#line 162 "cpp2regex.h2" template [[nodiscard]] auto single_class_entry::to_string() -> decltype(auto) { return bstring(1, C); } -#line 175 "cpp2regex.h2" +#line 170 "cpp2regex.h2" template [[nodiscard]] auto range_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return [_0 = Start, _1 = c, _2 = End]{ return cpp2::impl::cmp_less_eq(_0,_1) && cpp2::impl::cmp_less_eq(_1,_2); }(); } -#line 176 "cpp2regex.h2" +#line 171 "cpp2regex.h2" template [[nodiscard]] auto range_class_entry::to_string() -> decltype(auto) { return "" + cpp2::to_string(Start) + "-" + cpp2::to_string(End) + ""; } -#line 184 "cpp2regex.h2" +#line 179 "cpp2regex.h2" template [[nodiscard]] auto combined_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return (false || ... || List::includes(c)); } -#line 185 "cpp2regex.h2" +#line 180 "cpp2regex.h2" template [[nodiscard]] auto combined_class_entry::to_string() -> decltype(auto) { return (bstring() + ... + List::to_string()); } -#line 193 "cpp2regex.h2" +#line 188 "cpp2regex.h2" template [[nodiscard]] auto list_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return (false || ... || (List == c)); } -#line 194 "cpp2regex.h2" +#line 189 "cpp2regex.h2" template [[nodiscard]] auto list_class_entry::to_string() -> decltype(auto) { return (bstring() + ... + List); } -#line 202 "cpp2regex.h2" +#line 197 "cpp2regex.h2" template [[nodiscard]] auto named_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return Inner::includes(c); } -#line 203 "cpp2regex.h2" +#line 198 "cpp2regex.h2" template [[nodiscard]] auto named_class_entry::to_string() -> decltype(auto) { return "[:" + cpp2::to_string(Name.data()) + ":]"; } -#line 210 "cpp2regex.h2" +#line 205 "cpp2regex.h2" template [[nodiscard]] auto negated_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return !(Inner::includes(c)); } -#line 218 "cpp2regex.h2" +#line 213 "cpp2regex.h2" template [[nodiscard]] auto shorthand_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return Inner::includes(c); } -#line 219 "cpp2regex.h2" +#line 214 "cpp2regex.h2" template [[nodiscard]] auto shorthand_class_entry::to_string() -> decltype(auto) { return Name.str(); } -#line 266 "cpp2regex.h2" +#line 261 "cpp2regex.h2" template [[nodiscard]] auto alternative_token_matcher::match(auto const& cur, auto& ctx, auto const& end_func, auto const& tail, auto const& ...functions) -> auto{ return match_first(cur, ctx, end_func, tail, functions...); } -#line 270 "cpp2regex.h2" +#line 265 "cpp2regex.h2" template template [[nodiscard]] auto alternative_token_matcher::match_first(auto const& cur, auto& ctx, auto const& end_func, auto const& tail, auto const& cur_func, auto const& cur_reset, Other const& ...other) -> auto { auto inner_call {[_0 = (tail), _1 = (end_func)](auto const& tail_cur, auto& tail_ctx) -> auto{ @@ -817,7 +812,7 @@ template [[nodiscard]] auto make_on_return(Func const& func) -> d } } -#line 293 "cpp2regex.h2" +#line 288 "cpp2regex.h2" template [[nodiscard]] auto any_token_matcher(auto& cur, auto& ctx) -> bool { if ( cur != ctx.end // any char except the end @@ -830,7 +825,7 @@ template [[nodiscard]] auto any_token_matcher( return false; } -#line 344 "cpp2regex.h2" +#line 339 "cpp2regex.h2" template [[nodiscard]] auto class_token_matcher::match(auto& cur, auto& ctx) -> bool { if constexpr (case_insensitive) @@ -860,7 +855,7 @@ template [[nodiscard]] auto any_token_matcher( } } -#line 373 "cpp2regex.h2" +#line 368 "cpp2regex.h2" template template [[nodiscard]] auto class_token_matcher::match_any(cpp2::impl::in c) -> bool { bool r {First::includes(c)}; @@ -874,7 +869,7 @@ template [[nodiscard]] auto any_token_matcher( return r; } -#line 422 "cpp2regex.h2" +#line 417 "cpp2regex.h2" template [[nodiscard]] auto group_ref_token_matcher(auto& cur, auto& ctx) -> bool { auto g {ctx.get_group(group)}; @@ -905,7 +900,7 @@ template [[nodiscard]] auto gr } } -#line 455 "cpp2regex.h2" +#line 450 "cpp2regex.h2" template [[nodiscard]] auto line_end_token_matcher(auto const& cur, auto& ctx) -> bool { if (cur == ctx.end || (match_new_line && *cpp2::impl::assert_not_null(cur) == '\n')) { @@ -919,14 +914,14 @@ template [[ }} } -#line 471 "cpp2regex.h2" +#line 466 "cpp2regex.h2" template [[nodiscard]] auto line_start_token_matcher(auto const& cur, auto& ctx) -> bool { return cur == ctx.begin || // Start of string (match_new_line && *cpp2::impl::assert_not_null((cur - 1)) == '\n'); // Start of new line } -#line 482 "cpp2regex.h2" +#line 477 "cpp2regex.h2" template [[nodiscard]] auto lookahead_token_matcher(auto const& cur, auto& ctx, auto const& func) -> bool { auto r {func(cur, ctx, true_end_func())}; @@ -937,12 +932,12 @@ template [[nodiscard]] auto lookahead_token_match return cpp2::move(r).matched; } -#line 498 "cpp2regex.h2" +#line 493 "cpp2regex.h2" inline CPP2_CONSTEXPR int range_flags::not_greedy{ 1 }; inline CPP2_CONSTEXPR int range_flags::greedy{ 2 }; inline CPP2_CONSTEXPR int range_flags::possessive{ 3 }; -#line 509 "cpp2regex.h2" +#line 504 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match(Iter const& cur, auto& ctx, auto const& inner, auto const& reset_func, auto const& end_func, auto const& tail) -> auto { if (range_flags::possessive == kind) { @@ -956,26 +951,26 @@ template [[nodiscard]] auto lookahead_token_match }} } -#line 522 "cpp2regex.h2" +#line 517 "cpp2regex.h2" template [[nodiscard]] auto range_token_matcher::is_below_upper_bound(cpp2::impl::in count) -> bool{ if (-1 == max_count) {return true; } else {return cpp2::impl::cmp_less(count,max_count); } } -#line 527 "cpp2regex.h2" +#line 522 "cpp2regex.h2" template [[nodiscard]] auto range_token_matcher::is_below_lower_bound(cpp2::impl::in count) -> bool{ if (-1 == min_count) {return false; } else {return cpp2::impl::cmp_less(count,min_count); } } -#line 532 "cpp2regex.h2" +#line 527 "cpp2regex.h2" template [[nodiscard]] auto range_token_matcher::is_in_range(cpp2::impl::in count) -> bool{ if (-1 != min_count && cpp2::impl::cmp_less(count,min_count)) {return false; } if (-1 != max_count && cpp2::impl::cmp_greater(count,max_count)) {return false; } return true; } -#line 538 "cpp2regex.h2" +#line 533 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match_min_count(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, int& count_r) -> auto { // TODO: count_r as out parameter introduces a performance loss. auto res {ctx.pass(cur)}; @@ -992,7 +987,7 @@ template [[nodiscard]] auto lookahead_token_match return res; } -#line 554 "cpp2regex.h2" +#line 549 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match_greedy(cpp2::impl::in count, Iter const& cur, Iter const& last_valid, auto& ctx, auto const& inner, auto const& reset_func, auto const& end_func, auto const& other) -> match_return { auto inner_call {[_0 = (count + 1), _1 = (cur), _2 = (inner), _3 = (reset_func), _4 = (end_func), _5 = (other)](auto const& tail_cur, auto& tail_ctx) -> auto{ @@ -1023,7 +1018,7 @@ template [[nodiscard]] auto lookahead_token_match return r; } -#line 584 "cpp2regex.h2" +#line 579 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match_possessive(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> match_return { auto count {0}; @@ -1052,7 +1047,7 @@ template [[nodiscard]] auto lookahead_token_match return other(cpp2::move(pos), ctx, end_func); } -#line 612 "cpp2regex.h2" +#line 607 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match_not_greedy(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> match_return { auto count {0}; @@ -1080,7 +1075,7 @@ template [[nodiscard]] auto lookahead_token_match return other(cpp2::move(pos), ctx, end_func); // Upper bound reached. } -#line 645 "cpp2regex.h2" +#line 640 "cpp2regex.h2" template [[nodiscard]] auto word_boundary_token_matcher(auto& cur, auto& ctx) -> bool { word_class words {}; @@ -1105,32 +1100,32 @@ template [[nodiscard]] auto word_boundary_token_mat return is_match; } -#line 689 "cpp2regex.h2" +#line 684 "cpp2regex.h2" template template regular_expression::search_return::search_return(cpp2::impl::in matched_, context const& ctx_, Iter const& pos_) : matched{ matched_ } , ctx{ ctx_ } , pos{ cpp2::unchecked_narrow(std::distance(ctx_.begin, pos_)) }{ -#line 693 "cpp2regex.h2" +#line 688 "cpp2regex.h2" } -#line 695 "cpp2regex.h2" +#line 690 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search_return::group_number() const& -> decltype(auto) { return ctx.size(); } -#line 696 "cpp2regex.h2" +#line 691 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search_return::group(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_string(g); } -#line 697 "cpp2regex.h2" +#line 692 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search_return::group_start(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_start(g); } -#line 698 "cpp2regex.h2" +#line 693 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search_return::group_end(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_end(g); } -#line 700 "cpp2regex.h2" +#line 695 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search_return::group(cpp2::impl::in> g) const& -> decltype(auto) { return group(get_group_id(g)); } -#line 701 "cpp2regex.h2" +#line 696 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search_return::group_start(cpp2::impl::in> g) const& -> decltype(auto) { return group_start(get_group_id(g)); } -#line 702 "cpp2regex.h2" +#line 697 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search_return::group_end(cpp2::impl::in> g) const& -> decltype(auto) { return group_end(get_group_id(g)); } -#line 704 "cpp2regex.h2" +#line 699 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search_return::get_group_id(cpp2::impl::in> g) const& -> auto{ auto group_id {matcher::get_named_group_index(g)}; if (-1 == group_id) { @@ -1139,13 +1134,13 @@ template [[nodiscard]] auto word_boundary_token_mat return group_id; } -#line 713 "cpp2regex.h2" +#line 708 "cpp2regex.h2" template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str) const& -> decltype(auto) { return match(str.begin(), str.end()); } -#line 714 "cpp2regex.h2" +#line 709 "cpp2regex.h2" template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str, auto const& start) const& -> decltype(auto) { return match(get_iter(str, start), str.end()); } -#line 715 "cpp2regex.h2" +#line 710 "cpp2regex.h2" template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto) { return match(get_iter(str, start), get_iter(str, start + length)); } -#line 716 "cpp2regex.h2" +#line 711 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::match(Iter const& start, Iter const& end) const& -> search_return { context ctx {start, end}; @@ -1154,13 +1149,13 @@ template [[nodiscard]] auto word_boundary_token_mat return search_return(r.matched && r.pos == end, cpp2::move(ctx), r.pos); } -#line 724 "cpp2regex.h2" +#line 719 "cpp2regex.h2" template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str) const& -> decltype(auto) { return search(str.begin(), str.end()); } -#line 725 "cpp2regex.h2" +#line 720 "cpp2regex.h2" template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str, auto const& start) const& -> decltype(auto) { return search(get_iter(str, start), str.end()); } -#line 726 "cpp2regex.h2" +#line 721 "cpp2regex.h2" template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto) { return search(get_iter(str, start), get_iter(str, start + length)); } -#line 727 "cpp2regex.h2" +#line 722 "cpp2regex.h2" template template [[nodiscard]] auto regular_expression::search(Iter const& start, Iter const& end) const& -> search_return { context ctx {start, end}; @@ -1181,10 +1176,10 @@ template [[nodiscard]] auto word_boundary_token_mat return search_return(r.matched, cpp2::move(ctx), cpp2::move(r).pos); } -#line 747 "cpp2regex.h2" +#line 742 "cpp2regex.h2" template [[nodiscard]] auto regular_expression::to_string() const& -> decltype(auto) { return matcher_wrapper::to_string(); } -#line 751 "cpp2regex.h2" +#line 746 "cpp2regex.h2" template [[nodiscard]] auto regular_expression::get_iter(cpp2::impl::in> str, auto const& pos) -> auto{ if (cpp2::impl::cmp_less(pos,str.size())) { return str.begin() + pos; @@ -1194,7 +1189,7 @@ template [[nodiscard]] auto word_boundary_token_mat } } -#line 761 "cpp2regex.h2" +#line 756 "cpp2regex.h2" } } diff --git a/include/cpp2regex.h2 b/include/cpp2regex.h2 index 41d6999038..04b3add740 100644 --- a/include/cpp2regex.h2 +++ b/include/cpp2regex.h2 @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== diff --git a/include/cpp2util.h b/include/cpp2util.h index ebedeb5fb2..c59de36024 100644 --- a/include/cpp2util.h +++ b/include/cpp2util.h @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== diff --git a/regression-tests/test-results/version b/regression-tests/test-results/version index 3e9d5db235..d580164395 100644 --- a/regression-tests/test-results/version +++ b/regression-tests/test-results/version @@ -1,11 +1,5 @@ -cppfront compiler v0.8.0 Build 9A10:0946 -Copyright(c) Herb Sutter All rights reserved +cppfront compiler v0.8.0 Build 9A10:1540 +Copyright 2022-2024 Herb Sutter -SPDX-License-Identifier: CC-BY-NC-ND-4.0 - No commercial use - No forks/derivatives - Note: This license emphasizes that this is a personal - experiment; it will be upgraded if that changes - -Absolutely no warranty - try at your own risk +SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception diff --git a/source/build.info b/source/build.info index 4aced96680..71b5052e32 100644 --- a/source/build.info +++ b/source/build.info @@ -1 +1 @@ -"9A10:0946" \ No newline at end of file +"9A10:1540" \ No newline at end of file diff --git a/source/common.h b/source/common.h index 5839b4cd80..2b46e9d2ba 100644 --- a/source/common.h +++ b/source/common.h @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. // We want cppfront to build cleanly at very high warning levels, with warnings @@ -912,16 +907,11 @@ class cmdline_processor help_requested = true; print("\ncppfront compiler " #include "version.info" - " Build " + " Build " #include "build.info" ); - print("\nCopyright(c) Herb Sutter All rights reserved\n"); - print("\nSPDX-License-Identifier: CC-BY-NC-ND-4.0"); - print("\n No commercial use"); - print("\n No forks/derivatives"); - print("\n Note: This license emphasizes that this is a personal"); - print("\n experiment; it will be upgraded if that changes\n"); - print("\nAbsolutely no warranty - try at your own risk\n"); + print("\nSPDX-License-Identifier Apache-2.0 WITH LLVM-exception"); + print("\nCopyright (c) 2022-2024 Herb Sutter\n"); } } cmdline; diff --git a/source/cppfront.cpp b/source/cppfront.cpp index a408252892..15226521da 100644 --- a/source/cppfront.cpp +++ b/source/cppfront.cpp @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== diff --git a/source/io.h b/source/io.h index a2fc7aaf53..9da2128e7c 100644 --- a/source/io.h +++ b/source/io.h @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== diff --git a/source/lex.h b/source/lex.h index ef4d23a5b5..8dce934065 100644 --- a/source/lex.h +++ b/source/lex.h @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== diff --git a/source/parse.h b/source/parse.h index a8ad4bd9e6..1290fcdba9 100644 --- a/source/parse.h +++ b/source/parse.h @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== diff --git a/source/reflect.h b/source/reflect.h index 27765339ea..c73e5a4970 100644 --- a/source/reflect.h +++ b/source/reflect.h @@ -10,103 +10,103 @@ #line 1 "reflect.h2" -#line 22 "reflect.h2" +#line 17 "reflect.h2" namespace cpp2 { namespace meta { -#line 34 "reflect.h2" +#line 29 "reflect.h2" class compiler_services; -#line 233 "reflect.h2" +#line 228 "reflect.h2" class declaration_base; -#line 259 "reflect.h2" +#line 254 "reflect.h2" class declaration; -#line 341 "reflect.h2" +#line 336 "reflect.h2" class function_declaration; -#line 432 "reflect.h2" +#line 427 "reflect.h2" class object_declaration; -#line 468 "reflect.h2" +#line 463 "reflect.h2" class type_declaration; -#line 606 "reflect.h2" +#line 601 "reflect.h2" class alias_declaration; -#line 1056 "reflect.h2" +#line 1051 "reflect.h2" class value_member_info; -#line 1574 "reflect.h2" +#line 1569 "reflect.h2" class expression_flags; -#line 1590 "reflect.h2" +#line 1585 "reflect.h2" class regex_token; -#line 1616 "reflect.h2" +#line 1611 "reflect.h2" class regex_token_check; -#line 1635 "reflect.h2" +#line 1630 "reflect.h2" class regex_token_code; -#line 1654 "reflect.h2" +#line 1649 "reflect.h2" class regex_token_empty; -#line 1670 "reflect.h2" +#line 1665 "reflect.h2" class regex_token_list; -#line 1709 "reflect.h2" +#line 1704 "reflect.h2" class parse_context_group_state; -#line 1770 "reflect.h2" +#line 1765 "reflect.h2" class parse_context_branch_reset_state; -#line 1813 "reflect.h2" +#line 1808 "reflect.h2" class parse_context; -#line 2211 "reflect.h2" +#line 2206 "reflect.h2" class generation_function_context; -#line 2229 "reflect.h2" +#line 2224 "reflect.h2" class generation_context; -#line 2427 "reflect.h2" +#line 2422 "reflect.h2" class alternative_token; -#line 2442 "reflect.h2" +#line 2437 "reflect.h2" class alternative_token_gen; -#line 2494 "reflect.h2" +#line 2489 "reflect.h2" class any_token; -#line 2512 "reflect.h2" +#line 2507 "reflect.h2" class char_token; -#line 2615 "reflect.h2" +#line 2610 "reflect.h2" class class_token; -#line 2830 "reflect.h2" +#line 2825 "reflect.h2" class group_ref_token; -#line 2961 "reflect.h2" +#line 2956 "reflect.h2" class group_token; -#line 3248 "reflect.h2" +#line 3243 "reflect.h2" class lookahead_token; -#line 3329 "reflect.h2" +#line 3324 "reflect.h2" class range_token; -#line 3477 "reflect.h2" +#line 3472 "reflect.h2" class special_range_token; -#line 3544 "reflect.h2" +#line 3539 "reflect.h2" template class regex_generator; -#line 3791 "reflect.h2" +#line 3786 "reflect.h2" } } @@ -116,16 +116,11 @@ template class regex_generator; #line 1 "reflect.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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== @@ -136,16 +131,16 @@ template class regex_generator; #include "cpp2regex.h" using namespace cpp2::regex; -#line 22 "reflect.h2" +#line 17 "reflect.h2" namespace cpp2 { namespace meta { -#line 34 "reflect.h2" +#line 29 "reflect.h2" class compiler_services { -#line 38 "reflect.h2" +#line 33 "reflect.h2" private: std::vector* errors; private: std::set* includes; private: int errors_original_size; @@ -155,7 +150,7 @@ class compiler_services private: std::vector metafunction_args {}; private: bool metafunctions_used {false}; -#line 49 "reflect.h2" +#line 44 "reflect.h2" public: explicit compiler_services( std::vector* errors_, @@ -163,59 +158,59 @@ class compiler_services stable_vector* generated_tokens_ ); -#line 65 "reflect.h2" +#line 60 "reflect.h2" public: auto set_metafunction_name(cpp2::impl::in name, cpp2::impl::in> args) & -> void; -#line 71 "reflect.h2" +#line 66 "reflect.h2" public: [[nodiscard]] auto get_metafunction_name() const& -> std::string_view; public: [[nodiscard]] auto get_argument(cpp2::impl::in index) & -> std::string; -#line 81 "reflect.h2" +#line 76 "reflect.h2" public: [[nodiscard]] auto get_arguments() & -> std::vector; -#line 86 "reflect.h2" +#line 81 "reflect.h2" public: [[nodiscard]] auto arguments_were_used() const& -> bool; using parse_statement_ret = std::unique_ptr; -#line 88 "reflect.h2" +#line 83 "reflect.h2" protected: [[nodiscard]] auto parse_statement( std::string_view source ) & -> parse_statement_ret; -#line 141 "reflect.h2" +#line 136 "reflect.h2" public: [[nodiscard]] auto add_runtime_support_include(cpp2::impl::in s) & -> decltype(auto); public: [[nodiscard]] virtual auto position() const -> source_position; -#line 152 "reflect.h2" +#line 147 "reflect.h2" public: auto require( cpp2::impl::in b, cpp2::impl::in msg ) const& -> void; -#line 163 "reflect.h2" +#line 158 "reflect.h2" public: auto error(cpp2::impl::in msg) const& -> void; -#line 175 "reflect.h2" +#line 170 "reflect.h2" public: auto report_violation(auto const& msg) const& -> void; -#line 183 "reflect.h2" +#line 178 "reflect.h2" public: [[nodiscard]] auto is_active() const& -> decltype(auto); public: virtual ~compiler_services() noexcept; public: compiler_services(compiler_services const& that); -#line 184 "reflect.h2" +#line 179 "reflect.h2" }; -#line 233 "reflect.h2" +#line 228 "reflect.h2" class declaration_base : public compiler_services { -#line 237 "reflect.h2" +#line 232 "reflect.h2" protected: declaration_node* n; protected: explicit declaration_base( @@ -224,28 +219,28 @@ class declaration_base cpp2::impl::in s ); -#line 250 "reflect.h2" +#line 245 "reflect.h2" public: [[nodiscard]] auto position() const -> source_position override; public: [[nodiscard]] auto print() const& -> std::string; public: virtual ~declaration_base() noexcept; public: declaration_base(declaration_base const& that); -#line 253 "reflect.h2" +#line 248 "reflect.h2" }; -#line 259 "reflect.h2" +#line 254 "reflect.h2" class declaration : public declaration_base { -#line 263 "reflect.h2" +#line 258 "reflect.h2" public: explicit declaration( declaration_node* n_, cpp2::impl::in s ); -#line 272 "reflect.h2" +#line 267 "reflect.h2" public: [[nodiscard]] auto is_public() const& -> bool; public: [[nodiscard]] auto is_protected() const& -> bool; public: [[nodiscard]] auto is_private() const& -> bool; @@ -264,7 +259,7 @@ class declaration public: [[nodiscard]] auto name() const& -> std::string_view; -#line 293 "reflect.h2" +#line 288 "reflect.h2" public: [[nodiscard]] auto has_initializer() const& -> bool; public: [[nodiscard]] auto is_global() const& -> bool; @@ -306,21 +301,21 @@ class declaration public: declaration(declaration const& that); -#line 335 "reflect.h2" +#line 330 "reflect.h2" }; -#line 341 "reflect.h2" +#line 336 "reflect.h2" class function_declaration : public declaration { -#line 345 "reflect.h2" +#line 340 "reflect.h2" public: explicit function_declaration( declaration_node* n_, cpp2::impl::in s ); -#line 355 "reflect.h2" +#line 350 "reflect.h2" public: [[nodiscard]] auto index_of_parameter_named(cpp2::impl::in s) const& -> int; public: [[nodiscard]] auto has_parameter_named(cpp2::impl::in s) const& -> bool; public: [[nodiscard]] auto has_in_parameter_named(cpp2::impl::in s) const& -> bool; @@ -361,7 +356,7 @@ class function_declaration public: [[nodiscard]] auto get_parameters() const& -> std::vector; -#line 403 "reflect.h2" +#line 398 "reflect.h2" public: [[nodiscard]] auto is_binary_comparison_function() const& -> bool; public: [[nodiscard]] auto default_to_virtual() & -> decltype(auto); @@ -372,94 +367,94 @@ class function_declaration public: function_declaration(function_declaration const& that); -#line 426 "reflect.h2" +#line 421 "reflect.h2" }; -#line 432 "reflect.h2" +#line 427 "reflect.h2" class object_declaration : public declaration { -#line 436 "reflect.h2" +#line 431 "reflect.h2" public: explicit object_declaration( declaration_node* n_, cpp2::impl::in s ); -#line 446 "reflect.h2" +#line 441 "reflect.h2" public: [[nodiscard]] auto is_const() const& -> bool; public: [[nodiscard]] auto has_wildcard_type() const& -> bool; public: [[nodiscard]] auto type() const& -> std::string; -#line 456 "reflect.h2" +#line 451 "reflect.h2" public: [[nodiscard]] auto initializer() const& -> std::string; public: object_declaration(object_declaration const& that); -#line 462 "reflect.h2" +#line 457 "reflect.h2" }; -#line 468 "reflect.h2" +#line 463 "reflect.h2" class type_declaration : public declaration { -#line 472 "reflect.h2" +#line 467 "reflect.h2" public: explicit type_declaration( declaration_node* n_, cpp2::impl::in s ); -#line 482 "reflect.h2" +#line 477 "reflect.h2" public: auto reserve_names(cpp2::impl::in name, auto&& ...etc) const& -> void; -#line 496 "reflect.h2" +#line 491 "reflect.h2" public: [[nodiscard]] auto is_polymorphic() const& -> bool; public: [[nodiscard]] auto is_final() const& -> bool; public: [[nodiscard]] auto make_final() & -> bool; public: [[nodiscard]] auto get_member_functions() const& -> std::vector; -#line 511 "reflect.h2" +#line 506 "reflect.h2" public: [[nodiscard]] auto get_member_functions_needing_initializer() const& -> std::vector; -#line 526 "reflect.h2" +#line 521 "reflect.h2" public: [[nodiscard]] auto get_member_objects() const& -> std::vector; -#line 536 "reflect.h2" +#line 531 "reflect.h2" public: [[nodiscard]] auto get_member_types() const& -> std::vector; -#line 546 "reflect.h2" +#line 541 "reflect.h2" public: [[nodiscard]] auto get_member_aliases() const& -> std::vector; -#line 556 "reflect.h2" +#line 551 "reflect.h2" public: [[nodiscard]] auto get_members() const& -> std::vector; struct query_declared_value_set_functions_ret { bool out_this_in_that; bool out_this_move_that; bool inout_this_in_that; bool inout_this_move_that; }; -#line 566 "reflect.h2" +#line 561 "reflect.h2" public: [[nodiscard]] auto query_declared_value_set_functions() const& -> query_declared_value_set_functions_ret; -#line 582 "reflect.h2" +#line 577 "reflect.h2" public: auto add_member(cpp2::impl::in source) & -> void; -#line 596 "reflect.h2" +#line 591 "reflect.h2" public: [[nodiscard]] auto remove_marked_members() & -> decltype(auto); public: [[nodiscard]] auto remove_all_members() & -> decltype(auto); public: [[nodiscard]] auto disable_member_function_generation() & -> decltype(auto); public: type_declaration(type_declaration const& that); -#line 600 "reflect.h2" +#line 595 "reflect.h2" }; -#line 606 "reflect.h2" +#line 601 "reflect.h2" class alias_declaration : public declaration { -#line 610 "reflect.h2" +#line 605 "reflect.h2" public: explicit alias_declaration( declaration_node* n_, @@ -468,65 +463,65 @@ class alias_declaration public: alias_declaration(alias_declaration const& that); -#line 619 "reflect.h2" +#line 614 "reflect.h2" }; -#line 634 "reflect.h2" +#line 629 "reflect.h2" auto add_virtual_destructor(meta::type_declaration& t) -> void; -#line 652 "reflect.h2" +#line 647 "reflect.h2" auto interface(meta::type_declaration& t) -> void; -#line 698 "reflect.h2" +#line 693 "reflect.h2" auto polymorphic_base(meta::type_declaration& t) -> void; -#line 743 "reflect.h2" +#line 738 "reflect.h2" auto ordered_impl( meta::type_declaration& t, cpp2::impl::in ordering ) -> void; -#line 772 "reflect.h2" +#line 767 "reflect.h2" auto ordered(meta::type_declaration& t) -> void; -#line 780 "reflect.h2" +#line 775 "reflect.h2" auto weakly_ordered(meta::type_declaration& t) -> void; -#line 788 "reflect.h2" +#line 783 "reflect.h2" auto partially_ordered(meta::type_declaration& t) -> void; -#line 810 "reflect.h2" +#line 805 "reflect.h2" auto copyable(meta::type_declaration& t) -> void; -#line 843 "reflect.h2" +#line 838 "reflect.h2" auto hashable(meta::type_declaration& t) -> void; -#line 876 "reflect.h2" +#line 871 "reflect.h2" auto basic_value(meta::type_declaration& t) -> void; -#line 904 "reflect.h2" +#line 899 "reflect.h2" auto value(meta::type_declaration& t) -> void; -#line 910 "reflect.h2" +#line 905 "reflect.h2" auto weakly_ordered_value(meta::type_declaration& t) -> void; -#line 916 "reflect.h2" +#line 911 "reflect.h2" auto partially_ordered_value(meta::type_declaration& t) -> void; -#line 945 "reflect.h2" +#line 940 "reflect.h2" auto cpp1_rule_of_zero(meta::type_declaration& t) -> void; -#line 987 "reflect.h2" +#line 982 "reflect.h2" auto cpp2_struct(meta::type_declaration& t) -> void; -#line 1056 "reflect.h2" +#line 1051 "reflect.h2" class value_member_info { public: std::string name; public: std::string type; public: std::string value; public: value_member_info(auto const& name_, auto const& type_, auto const& value_); -#line 1060 "reflect.h2" +#line 1055 "reflect.h2" }; auto basic_enum( @@ -535,22 +530,22 @@ auto basic_enum( cpp2::impl::in bitwise ) -> void; -#line 1326 "reflect.h2" +#line 1321 "reflect.h2" auto cpp2_enum(meta::type_declaration& t) -> void; -#line 1353 "reflect.h2" +#line 1348 "reflect.h2" auto flag_enum(meta::type_declaration& t) -> void; -#line 1399 "reflect.h2" +#line 1394 "reflect.h2" auto cpp2_union(meta::type_declaration& t) -> void; -#line 1550 "reflect.h2" +#line 1545 "reflect.h2" auto print(cpp2::impl::in t) -> void; -#line 1570 "reflect.h2" +#line 1565 "reflect.h2" using error_func = std::function x)>; -#line 1574 "reflect.h2" +#line 1569 "reflect.h2" class expression_flags { private: cpp2::u8 _value; private: constexpr expression_flags(cpp2::impl::in _val); @@ -585,20 +580,20 @@ public: [[nodiscard]] auto to_code() const& -> std::string; public: [[nodiscard]] static auto from_string(cpp2::impl::in s) -> expression_flags; public: [[nodiscard]] static auto from_code(cpp2::impl::in s) -> expression_flags; -#line 1582 "reflect.h2" +#line 1577 "reflect.h2" }; -#line 1590 "reflect.h2" +#line 1585 "reflect.h2" class regex_token { public: std::string string_rep; public: explicit regex_token(cpp2::impl::in str); -#line 1598 "reflect.h2" +#line 1593 "reflect.h2" public: explicit regex_token(); -#line 1603 "reflect.h2" +#line 1598 "reflect.h2" public: virtual auto generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void = 0; public: virtual auto add_groups([[maybe_unused]] std::set& unnamed_param_2) const -> void; @@ -609,24 +604,24 @@ class regex_token public: regex_token(regex_token const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(regex_token const&) -> void = delete; -#line 1608 "reflect.h2" +#line 1603 "reflect.h2" }; using token_ptr = std::shared_ptr; using token_vec = std::vector; -#line 1614 "reflect.h2" +#line 1609 "reflect.h2" // Adds a check in code generation. // class regex_token_check : public regex_token { -#line 1620 "reflect.h2" +#line 1615 "reflect.h2" private: std::string check; public: explicit regex_token_check(cpp2::impl::in str, cpp2::impl::in check_); -#line 1627 "reflect.h2" +#line 1622 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; public: virtual ~regex_token_check() noexcept; @@ -634,21 +629,21 @@ class regex_token_check public: auto operator=(regex_token_check const&) -> void = delete; -#line 1630 "reflect.h2" +#line 1625 "reflect.h2" }; -#line 1633 "reflect.h2" +#line 1628 "reflect.h2" // Adds code in code generation. // class regex_token_code : public regex_token { -#line 1639 "reflect.h2" +#line 1634 "reflect.h2" private: std::string code; public: explicit regex_token_code(cpp2::impl::in str, cpp2::impl::in code_); -#line 1646 "reflect.h2" +#line 1641 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; public: virtual ~regex_token_code() noexcept; @@ -656,19 +651,19 @@ class regex_token_code public: auto operator=(regex_token_code const&) -> void = delete; -#line 1649 "reflect.h2" +#line 1644 "reflect.h2" }; -#line 1652 "reflect.h2" +#line 1647 "reflect.h2" // Token that does not influence the matching. E.g. comment. // class regex_token_empty : public regex_token { -#line 1658 "reflect.h2" +#line 1653 "reflect.h2" public: explicit regex_token_empty(cpp2::impl::in str); -#line 1662 "reflect.h2" +#line 1657 "reflect.h2" public: auto generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void override; public: virtual ~regex_token_empty() noexcept; @@ -676,27 +671,27 @@ class regex_token_empty public: auto operator=(regex_token_empty const&) -> void = delete; -#line 1665 "reflect.h2" +#line 1660 "reflect.h2" }; -#line 1668 "reflect.h2" +#line 1663 "reflect.h2" // Represents a list of regex tokens as one token. // class regex_token_list : public regex_token { -#line 1674 "reflect.h2" +#line 1669 "reflect.h2" public: token_vec tokens; public: explicit regex_token_list(cpp2::impl::in t); -#line 1681 "reflect.h2" +#line 1676 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 1687 "reflect.h2" +#line 1682 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; -#line 1693 "reflect.h2" +#line 1688 "reflect.h2" public: [[nodiscard]] static auto gen_string(cpp2::impl::in vec) -> std::string; public: virtual ~regex_token_list() noexcept; @@ -704,10 +699,10 @@ class regex_token_list public: auto operator=(regex_token_list const&) -> void = delete; -#line 1700 "reflect.h2" +#line 1695 "reflect.h2" }; -#line 1703 "reflect.h2" +#line 1698 "reflect.h2" // // Parse and generation context. // @@ -723,33 +718,33 @@ class parse_context_group_state // Start a new alternative. public: auto next_alternative() & -> void; -#line 1723 "reflect.h2" +#line 1718 "reflect.h2" // Swap this state with the other one. NOLINTNEXTLINE(performance-noexcept-swap) public: auto swap(parse_context_group_state& t) & -> void; -#line 1730 "reflect.h2" +#line 1725 "reflect.h2" // Convert this state into a regex token. public: [[nodiscard]] auto get_as_token() & -> token_ptr; -#line 1742 "reflect.h2" +#line 1737 "reflect.h2" // Add a token to the current matcher list. public: auto add(cpp2::impl::in token) & -> void; -#line 1747 "reflect.h2" +#line 1742 "reflect.h2" // True if current matcher list is empty. public: [[nodiscard]] auto empty() const& -> bool; -#line 1751 "reflect.h2" +#line 1746 "reflect.h2" // Apply optimizations to the matcher list. public: static auto post_process_list(token_vec& list) -> void; public: parse_context_group_state(auto const& cur_match_list_, auto const& alternate_match_lists_, auto const& modifiers_); public: parse_context_group_state(); -#line 1765 "reflect.h2" +#line 1760 "reflect.h2" }; -#line 1768 "reflect.h2" +#line 1763 "reflect.h2" // State for the branch reset. Takes care of the group numbering. See '(|)'. // class parse_context_branch_reset_state @@ -762,25 +757,25 @@ class parse_context_branch_reset_state // Next group identifier. public: [[nodiscard]] auto next() & -> int; -#line 1786 "reflect.h2" +#line 1781 "reflect.h2" // Set next group identifier. public: auto set_next(cpp2::impl::in g) & -> void; -#line 1792 "reflect.h2" +#line 1787 "reflect.h2" // Start a new alternative branch. public: auto next_alternative() & -> void; -#line 1799 "reflect.h2" +#line 1794 "reflect.h2" // Initialize for a branch reset group. public: auto set_active_reset(cpp2::impl::in restart) & -> void; public: parse_context_branch_reset_state(auto const& is_active_, auto const& cur_group_, auto const& max_group_, auto const& from_); public: parse_context_branch_reset_state(); -#line 1806 "reflect.h2" +#line 1801 "reflect.h2" }; -#line 1809 "reflect.h2" +#line 1804 "reflect.h2" // Context during parsing of the regular expressions. // // Keeps track of the distributed group identifiers, current parsed group and branch resets. @@ -794,7 +789,7 @@ class parse_context private: parse_context_group_state cur_group_state {}; private: parse_context_branch_reset_state cur_branch_reset_state {}; -#line 1823 "reflect.h2" +#line 1818 "reflect.h2" public: std::map named_groups {}; private: error_func error_out; // TODO: Declaring std::function fails for cpp2. @@ -802,64 +797,64 @@ class parse_context public: explicit parse_context(cpp2::impl::in r, auto const& e); -#line 1834 "reflect.h2" +#line 1829 "reflect.h2" // State management functions // // Returned group state needs to be stored and provided in `end_group`. public: [[nodiscard]] auto start_group() & -> parse_context_group_state; -#line 1847 "reflect.h2" +#line 1842 "reflect.h2" // `old_state` argument needs to be from start group. public: [[nodiscard]] auto end_group(cpp2::impl::in old_state) & -> token_ptr; -#line 1855 "reflect.h2" +#line 1850 "reflect.h2" public: [[nodiscard]] auto get_modifiers() const& -> expression_flags; -#line 1859 "reflect.h2" +#line 1854 "reflect.h2" public: auto set_modifiers(cpp2::impl::in mod) & -> void; -#line 1863 "reflect.h2" +#line 1858 "reflect.h2" // Branch reset management functions // public: [[nodiscard]] auto branch_reset_new_state() & -> parse_context_branch_reset_state; -#line 1875 "reflect.h2" +#line 1870 "reflect.h2" public: auto branch_reset_restore_state(cpp2::impl::in old_state) & -> void; -#line 1882 "reflect.h2" +#line 1877 "reflect.h2" public: auto next_alternative() & -> void; -#line 1888 "reflect.h2" +#line 1883 "reflect.h2" // Regex token management // public: auto add_token(cpp2::impl::in token) & -> void; -#line 1894 "reflect.h2" +#line 1889 "reflect.h2" public: [[nodiscard]] auto has_token() const& -> bool; -#line 1898 "reflect.h2" +#line 1893 "reflect.h2" public: [[nodiscard]] auto pop_token() & -> token_ptr; -#line 1909 "reflect.h2" +#line 1904 "reflect.h2" public: [[nodiscard]] auto get_as_token() & -> token_ptr; -#line 1913 "reflect.h2" +#line 1908 "reflect.h2" // Group management // public: [[nodiscard]] auto get_cur_group() const& -> int; -#line 1919 "reflect.h2" +#line 1914 "reflect.h2" public: [[nodiscard]] auto next_group() & -> int; -#line 1923 "reflect.h2" +#line 1918 "reflect.h2" public: auto set_named_group(cpp2::impl::in name, cpp2::impl::in id) & -> void; -#line 1930 "reflect.h2" +#line 1925 "reflect.h2" public: [[nodiscard]] auto get_named_group(cpp2::impl::in name) const& -> int; -#line 1941 "reflect.h2" +#line 1936 "reflect.h2" // Position management functions // public: [[nodiscard]] auto current() const& -> char; @@ -867,51 +862,51 @@ class parse_context // Get the next token in the regex, skipping spaces according to the parameters. See `x` and `xx` modifiers. private: [[nodiscard]] auto get_next_position(cpp2::impl::in in_class, cpp2::impl::in no_skip) const& -> size_t; -#line 1985 "reflect.h2" +#line 1980 "reflect.h2" // Return true if next token is available. private: [[nodiscard]] auto next_impl(cpp2::impl::in in_class, cpp2::impl::in no_skip) & -> bool; -#line 1997 "reflect.h2" +#line 1992 "reflect.h2" public: [[nodiscard]] auto next() & -> decltype(auto); public: [[nodiscard]] auto next_in_class() & -> decltype(auto); public: [[nodiscard]] auto next_no_skip() & -> decltype(auto); public: [[nodiscard]] auto next_n(cpp2::impl::in n) & -> bool; -#line 2010 "reflect.h2" +#line 2005 "reflect.h2" public: [[nodiscard]] auto has_next() const& -> bool; private: [[nodiscard]] auto grab_until_impl(cpp2::impl::in e, cpp2::impl::out r, cpp2::impl::in any) & -> bool; -#line 2033 "reflect.h2" +#line 2028 "reflect.h2" public: [[nodiscard]] auto grab_until(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto); public: [[nodiscard]] auto grab_until(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto); public: [[nodiscard]] auto grab_until_one_of(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto); public: [[nodiscard]] auto grab_n(cpp2::impl::in n, cpp2::impl::out r) & -> bool; -#line 2050 "reflect.h2" +#line 2045 "reflect.h2" public: [[nodiscard]] auto grab_number() & -> std::string; -#line 2071 "reflect.h2" +#line 2066 "reflect.h2" private: [[nodiscard]] auto peek_impl(cpp2::impl::in in_class) const& -> char; -#line 2081 "reflect.h2" +#line 2076 "reflect.h2" public: [[nodiscard]] auto peek() const& -> decltype(auto); public: [[nodiscard]] auto peek_in_class() const& -> decltype(auto); -#line 2085 "reflect.h2" +#line 2080 "reflect.h2" // Parsing functions // public: [[nodiscard]] auto parser_group_modifiers(cpp2::impl::in change_str, expression_flags& parser_modifiers) & -> bool; -#line 2141 "reflect.h2" +#line 2136 "reflect.h2" public: [[nodiscard]] auto parse_until(cpp2::impl::in term) & -> bool; -#line 2179 "reflect.h2" +#line 2174 "reflect.h2" public: [[nodiscard]] auto parse(cpp2::impl::in modifiers) & -> bool; -#line 2194 "reflect.h2" +#line 2189 "reflect.h2" // Misc functions public: [[nodiscard]] auto get_pos() const& -> decltype(auto); @@ -923,10 +918,10 @@ class parse_context public: auto operator=(parse_context const&) -> void = delete; -#line 2205 "reflect.h2" +#line 2200 "reflect.h2" }; -#line 2208 "reflect.h2" +#line 2203 "reflect.h2" // Context for one function generation. Generation of functions can be interleaved, // therefore we buffer the code for one function here. // @@ -936,16 +931,16 @@ class generation_function_context { public: auto add_tabs(cpp2::impl::in c) & -> void; -#line 2222 "reflect.h2" +#line 2217 "reflect.h2" public: auto remove_tabs(cpp2::impl::in c) & -> void; public: generation_function_context(auto const& code_, auto const& tabs_); public: generation_function_context(); -#line 2225 "reflect.h2" +#line 2220 "reflect.h2" }; -#line 2228 "reflect.h2" +#line 2223 "reflect.h2" // Context for generating the state machine. class generation_context { @@ -965,68 +960,68 @@ class generation_context // Add code line. public: auto add(cpp2::impl::in s) & -> void; -#line 2250 "reflect.h2" +#line 2245 "reflect.h2" // Add check for token. The check needs to be a function call that returns a boolean. public: auto add_check(cpp2::impl::in check) & -> void; -#line 2256 "reflect.h2" +#line 2251 "reflect.h2" // Add a stateful check. The check needs to return a `match_return`. public: auto add_statefull(cpp2::impl::in next_func, cpp2::impl::in check) & -> void; -#line 2265 "reflect.h2" +#line 2260 "reflect.h2" protected: auto start_func_named(cpp2::impl::in name) & -> void; -#line 2276 "reflect.h2" +#line 2271 "reflect.h2" protected: [[nodiscard]] auto start_func() & -> std::string; -#line 2283 "reflect.h2" +#line 2278 "reflect.h2" protected: auto end_func_statefull(cpp2::impl::in s) & -> void; -#line 2302 "reflect.h2" +#line 2297 "reflect.h2" // Generate the function for a token. public: [[nodiscard]] auto generate_func(cpp2::impl::in token) & -> std::string; -#line 2312 "reflect.h2" +#line 2307 "reflect.h2" // Generate the reset for a list of group identifiers. public: [[nodiscard]] auto generate_reset(cpp2::impl::in> groups) & -> std::string; -#line 2335 "reflect.h2" +#line 2330 "reflect.h2" // Name generation // protected: [[nodiscard]] auto gen_func_name() & -> std::string; -#line 2343 "reflect.h2" +#line 2338 "reflect.h2" public: [[nodiscard]] auto next_func_name() & -> std::string; -#line 2347 "reflect.h2" +#line 2342 "reflect.h2" protected: [[nodiscard]] auto gen_reset_func_name() & -> std::string; -#line 2353 "reflect.h2" +#line 2348 "reflect.h2" public: [[nodiscard]] auto gen_temp() & -> std::string; -#line 2359 "reflect.h2" +#line 2354 "reflect.h2" // Context management // public: [[nodiscard]] auto new_context() & -> generation_function_context*; -#line 2369 "reflect.h2" +#line 2364 "reflect.h2" public: auto finish_context() & -> void; -#line 2377 "reflect.h2" +#line 2372 "reflect.h2" // Misc functions // private: [[nodiscard]] auto get_current() & -> generation_function_context*; -#line 2383 "reflect.h2" +#line 2378 "reflect.h2" private: [[nodiscard]] auto get_base() & -> generation_function_context*; -#line 2387 "reflect.h2" +#line 2382 "reflect.h2" public: [[nodiscard]] auto get_entry_func() const& -> std::string; -#line 2391 "reflect.h2" +#line 2386 "reflect.h2" public: [[nodiscard]] auto create_named_group_lookup(cpp2::impl::in> named_groups) const& -> std::string; -#line 2415 "reflect.h2" +#line 2410 "reflect.h2" // Run the generation for the token. public: [[nodiscard]] auto run(cpp2::impl::in token) & -> std::string; public: generation_context() = default; @@ -1034,7 +1029,7 @@ class generation_context public: auto operator=(generation_context const&) -> void = delete; -#line 2421 "reflect.h2" +#line 2416 "reflect.h2" }; // Regex syntax: | Example: ab|ba @@ -1054,24 +1049,24 @@ class alternative_token public: auto operator=(alternative_token const&) -> void = delete; -#line 2440 "reflect.h2" +#line 2435 "reflect.h2" }; class alternative_token_gen : public regex_token { -#line 2446 "reflect.h2" +#line 2441 "reflect.h2" private: token_vec alternatives; public: explicit alternative_token_gen(cpp2::impl::in a); -#line 2453 "reflect.h2" +#line 2448 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 2470 "reflect.h2" +#line 2465 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; -#line 2477 "reflect.h2" +#line 2472 "reflect.h2" public: [[nodiscard]] static auto gen_string(cpp2::impl::in a) -> std::string; public: virtual ~alternative_token_gen() noexcept; @@ -1079,19 +1074,19 @@ class alternative_token_gen public: auto operator=(alternative_token_gen const&) -> void = delete; -#line 2489 "reflect.h2" +#line 2484 "reflect.h2" }; -#line 2492 "reflect.h2" +#line 2487 "reflect.h2" // Regex syntax: . // class any_token : public regex_token_check { -#line 2498 "reflect.h2" +#line 2493 "reflect.h2" public: explicit any_token(cpp2::impl::in single_line); -#line 2502 "reflect.h2" +#line 2497 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; public: virtual ~any_token() noexcept; @@ -1099,37 +1094,37 @@ class any_token public: auto operator=(any_token const&) -> void = delete; -#line 2507 "reflect.h2" +#line 2502 "reflect.h2" }; -#line 2510 "reflect.h2" +#line 2505 "reflect.h2" // Regex syntax: a // class char_token : public regex_token { -#line 2516 "reflect.h2" +#line 2511 "reflect.h2" private: std::string token; private: bool ignore_case; public: explicit char_token(cpp2::impl::in t, cpp2::impl::in ignore_case_); -#line 2525 "reflect.h2" +#line 2520 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 2529 "reflect.h2" +#line 2524 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 2552 "reflect.h2" +#line 2547 "reflect.h2" public: auto gen_case_insensitive(cpp2::impl::in lower, cpp2::impl::in upper, generation_context& ctx) const& -> void; -#line 2573 "reflect.h2" +#line 2568 "reflect.h2" public: auto gen_case_sensitive(generation_context& ctx) const& -> void; -#line 2591 "reflect.h2" +#line 2586 "reflect.h2" public: [[nodiscard]] auto add_escapes(std::string str) const& -> std::string; -#line 2606 "reflect.h2" +#line 2601 "reflect.h2" public: auto append(char_token const& that) & -> void; public: virtual ~char_token() noexcept; @@ -1137,30 +1132,30 @@ class char_token public: auto operator=(char_token const&) -> void = delete; -#line 2610 "reflect.h2" +#line 2605 "reflect.h2" }; -#line 2613 "reflect.h2" +#line 2608 "reflect.h2" // Regex syntax: [] Example: [abcx-y[:digits:]] // class class_token : public regex_token { -#line 2619 "reflect.h2" +#line 2614 "reflect.h2" private: bool negate; private: bool case_insensitive; private: std::string class_str; public: explicit class_token(cpp2::impl::in negate_, cpp2::impl::in case_insensitive_, cpp2::impl::in class_str_, cpp2::impl::in str); -#line 2631 "reflect.h2" +#line 2626 "reflect.h2" // TODO: Rework class generation: Generate check functions for classes. public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 2757 "reflect.h2" +#line 2752 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 2762 "reflect.h2" +#line 2757 "reflect.h2" private: [[nodiscard]] static auto create_matcher(cpp2::impl::in name, cpp2::impl::in template_arguments) -> std::string; public: virtual ~class_token() noexcept; @@ -1168,20 +1163,20 @@ class class_token public: auto operator=(class_token const&) -> void = delete; -#line 2769 "reflect.h2" +#line 2764 "reflect.h2" }; -#line 2772 "reflect.h2" +#line 2767 "reflect.h2" // Regex syntax: \a or \n or \[ // [[nodiscard]] auto escape_token_parse(parse_context& ctx) -> token_ptr; -#line 2813 "reflect.h2" +#line 2808 "reflect.h2" // Regex syntax: \K Example: ab\Kcd // [[nodiscard]] auto global_group_reset_token_parse(parse_context& ctx) -> token_ptr; -#line 2824 "reflect.h2" +#line 2819 "reflect.h2" // Regex syntax: \ Example: \1 // \g{name_or_number} // \k{name_or_number} @@ -1191,16 +1186,16 @@ class class_token class group_ref_token : public regex_token { -#line 2834 "reflect.h2" +#line 2829 "reflect.h2" private: int id; private: bool case_insensitive; public: explicit group_ref_token(cpp2::impl::in id_, cpp2::impl::in case_insensitive_, cpp2::impl::in str); -#line 2844 "reflect.h2" +#line 2839 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 2945 "reflect.h2" +#line 2940 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; public: virtual ~group_ref_token() noexcept; @@ -1208,10 +1203,10 @@ class group_ref_token public: auto operator=(group_ref_token const&) -> void = delete; -#line 2948 "reflect.h2" +#line 2943 "reflect.h2" }; -#line 2951 "reflect.h2" +#line 2946 "reflect.h2" // Regex syntax: () Example: (abc) // (?:) (?i:abc) @@ -1225,22 +1220,22 @@ class group_ref_token class group_token : public regex_token { -#line 2965 "reflect.h2" +#line 2960 "reflect.h2" private: int number {-1}; private: token_ptr inner {nullptr}; public: [[nodiscard]] static auto parse_lookahead(parse_context& ctx, cpp2::impl::in syntax, cpp2::impl::in positive) -> token_ptr; -#line 2982 "reflect.h2" +#line 2977 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 3119 "reflect.h2" +#line 3114 "reflect.h2" public: [[nodiscard]] static auto gen_string(cpp2::impl::in name, cpp2::impl::in name_brackets, cpp2::impl::in has_modifier, cpp2::impl::in modifiers, cpp2::impl::in inner_) -> std::string; -#line 3137 "reflect.h2" +#line 3132 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 3157 "reflect.h2" +#line 3152 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; public: virtual ~group_token() noexcept; @@ -1249,25 +1244,25 @@ class group_token public: auto operator=(group_token const&) -> void = delete; -#line 3164 "reflect.h2" +#line 3159 "reflect.h2" }; -#line 3167 "reflect.h2" +#line 3162 "reflect.h2" // Regex syntax: \x or \x{} Example: \x{62} // [[nodiscard]] auto hexadecimal_token_parse(parse_context& ctx) -> token_ptr; -#line 3208 "reflect.h2" +#line 3203 "reflect.h2" // Regex syntax: $ Example: aa$ // [[nodiscard]] auto line_end_token_parse(parse_context& ctx) -> token_ptr; -#line 3228 "reflect.h2" +#line 3223 "reflect.h2" // Regex syntax: ^ Example: ^aa // [[nodiscard]] auto line_start_token_parse(parse_context& ctx) -> token_ptr; -#line 3244 "reflect.h2" +#line 3239 "reflect.h2" // Regex syntax: (?=) or (?!) or (*pla), etc. Example: (?=AA) // // Parsed in group_token. @@ -1275,16 +1270,16 @@ class group_token class lookahead_token : public regex_token { -#line 3252 "reflect.h2" +#line 3247 "reflect.h2" protected: bool positive; public: token_ptr inner {nullptr}; public: explicit lookahead_token(cpp2::impl::in positive_); -#line 3259 "reflect.h2" +#line 3254 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 3265 "reflect.h2" +#line 3260 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; public: virtual ~lookahead_token() noexcept; @@ -1292,26 +1287,26 @@ class lookahead_token public: auto operator=(lookahead_token const&) -> void = delete; -#line 3268 "reflect.h2" +#line 3263 "reflect.h2" }; -#line 3271 "reflect.h2" +#line 3266 "reflect.h2" // Named character classes // [[nodiscard]] auto named_class_token_parse(parse_context& ctx) -> token_ptr; -#line 3299 "reflect.h2" +#line 3294 "reflect.h2" // Regex syntax: \o{} Example: \o{142} // [[nodiscard]] auto octal_token_parse(parse_context& ctx) -> token_ptr; -#line 3327 "reflect.h2" +#line 3322 "reflect.h2" // Regex syntax: {min, max} Example: a{2,4} // class range_token : public regex_token { -#line 3333 "reflect.h2" +#line 3328 "reflect.h2" protected: int min_count {-1}; protected: int max_count {-1}; protected: int kind {range_flags::greedy}; @@ -1321,19 +1316,19 @@ class range_token public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 3413 "reflect.h2" +#line 3408 "reflect.h2" public: auto parse_modifier(parse_context& ctx) & -> void; -#line 3425 "reflect.h2" +#line 3420 "reflect.h2" public: [[nodiscard]] auto gen_mod_string() const& -> std::string; -#line 3438 "reflect.h2" +#line 3433 "reflect.h2" public: [[nodiscard]] auto gen_range_string() const& -> std::string; -#line 3457 "reflect.h2" +#line 3452 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 3468 "reflect.h2" +#line 3463 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; public: virtual ~range_token() noexcept; @@ -1341,16 +1336,16 @@ class range_token public: auto operator=(range_token const&) -> void = delete; -#line 3472 "reflect.h2" +#line 3467 "reflect.h2" }; -#line 3475 "reflect.h2" +#line 3470 "reflect.h2" // Regex syntax: *, +, or ? Example: aa* // class special_range_token : public range_token { -#line 3481 "reflect.h2" +#line 3476 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; public: virtual ~special_range_token() noexcept; @@ -1359,17 +1354,17 @@ class special_range_token public: auto operator=(special_range_token const&) -> void = delete; -#line 3511 "reflect.h2" +#line 3506 "reflect.h2" }; -#line 3514 "reflect.h2" +#line 3509 "reflect.h2" // Regex syntax: \b or \B Example: \bword\b // // Matches the start end end of word boundaries. // [[nodiscard]] auto word_boundary_token_parse(parse_context& ctx) -> token_ptr; -#line 3536 "reflect.h2" +#line 3531 "reflect.h2" //----------------------------------------------------------------------- // // Parser for regular expression. @@ -1390,24 +1385,24 @@ template class regex_generator public: explicit regex_generator(cpp2::impl::in r, Error_out const& e); -#line 3559 "reflect.h2" +#line 3554 "reflect.h2" public: [[nodiscard]] auto parse() & -> std::string; -#line 3594 "reflect.h2" +#line 3589 "reflect.h2" private: auto extract_modifiers() & -> void; public: regex_generator(regex_generator const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(regex_generator const&) -> void = delete; -#line 3608 "reflect.h2" +#line 3603 "reflect.h2" }; template [[nodiscard]] auto generate_regex(cpp2::impl::in regex, Err const& err) -> std::string; -#line 3620 "reflect.h2" +#line 3615 "reflect.h2" auto regex_gen(meta::type_declaration& t) -> void; -#line 3675 "reflect.h2" +#line 3670 "reflect.h2" //----------------------------------------------------------------------- // // apply_metafunctions @@ -1418,7 +1413,7 @@ auto regex_gen(meta::type_declaration& t) -> void; auto const& error ) -> bool; -#line 3791 "reflect.h2" +#line 3786 "reflect.h2" } } @@ -1428,12 +1423,12 @@ auto regex_gen(meta::type_declaration& t) -> void; #line 1 "reflect.h2" -#line 22 "reflect.h2" +#line 17 "reflect.h2" namespace cpp2 { namespace meta { -#line 27 "reflect.h2" +#line 22 "reflect.h2" //----------------------------------------------------------------------- // // Compiler services @@ -1441,14 +1436,14 @@ namespace meta { //----------------------------------------------------------------------- // -#line 36 "reflect.h2" +#line 31 "reflect.h2" // Common data members // -#line 47 "reflect.h2" +#line 42 "reflect.h2" // Constructor // -#line 49 "reflect.h2" +#line 44 "reflect.h2" compiler_services::compiler_services( std::vector* errors_, @@ -1460,25 +1455,25 @@ namespace meta { , errors_original_size{ cpp2::unchecked_narrow(std::ssize(*cpp2::impl::assert_not_null(errors))) } , generated_tokens{ generated_tokens_ } , parser{ *cpp2::impl::assert_not_null(errors), *cpp2::impl::assert_not_null(includes) } -#line 55 "reflect.h2" +#line 50 "reflect.h2" { -#line 61 "reflect.h2" +#line 56 "reflect.h2" } // Common API // -#line 65 "reflect.h2" +#line 60 "reflect.h2" auto compiler_services::set_metafunction_name(cpp2::impl::in name, cpp2::impl::in> args) & -> void{ metafunction_name = name; metafunction_args = args; metafunctions_used = CPP2_UFCS(empty)(args); } -#line 71 "reflect.h2" +#line 66 "reflect.h2" [[nodiscard]] auto compiler_services::get_metafunction_name() const& -> std::string_view { return metafunction_name; } -#line 73 "reflect.h2" +#line 68 "reflect.h2" [[nodiscard]] auto compiler_services::get_argument(cpp2::impl::in index) & -> std::string{ metafunctions_used = true; if (([_0 = 0, _1 = index, _2 = CPP2_UFCS(ssize)(metafunction_args)]{ return cpp2::impl::cmp_less_eq(_0,_1) && cpp2::impl::cmp_less(_1,_2); }())) { @@ -1487,16 +1482,16 @@ namespace meta { return ""; } -#line 81 "reflect.h2" +#line 76 "reflect.h2" [[nodiscard]] auto compiler_services::get_arguments() & -> std::vector{ metafunctions_used = true; return metafunction_args; } -#line 86 "reflect.h2" +#line 81 "reflect.h2" [[nodiscard]] auto compiler_services::arguments_were_used() const& -> bool { return metafunctions_used; } -#line 88 "reflect.h2" +#line 83 "reflect.h2" [[nodiscard]] auto compiler_services::parse_statement( std::string_view source @@ -1504,7 +1499,7 @@ namespace meta { { cpp2::impl::deferred_init> ret; -#line 94 "reflect.h2" +#line 89 "reflect.h2" auto original_source {source}; CPP2_UFCS(push_back)(generated_lines, std::vector()); @@ -1519,7 +1514,7 @@ auto newline_pos{CPP2_UFCS(find)(source, '\n')}; // First split this string into source_lines // -#line 106 "reflect.h2" +#line 101 "reflect.h2" if ( cpp2::impl::cmp_greater(CPP2_UFCS(ssize)(source),1) && newline_pos != source.npos) { @@ -1532,7 +1527,7 @@ auto newline_pos{CPP2_UFCS(find)(source, '\n')}; } } -#line 117 "reflect.h2" +#line 112 "reflect.h2" if (!(CPP2_UFCS(empty)(source))) { cpp2::move(add_line)(cpp2::move(source)); } @@ -1557,10 +1552,10 @@ auto newline_pos{CPP2_UFCS(find)(source, '\n')}; }return std::move(ret.value()); } -#line 141 "reflect.h2" +#line 136 "reflect.h2" [[nodiscard]] auto compiler_services::add_runtime_support_include(cpp2::impl::in s) & -> decltype(auto) { return static_cast(CPP2_UFCS(emplace)((*cpp2::impl::assert_not_null(includes)), s)); } -#line 143 "reflect.h2" +#line 138 "reflect.h2" [[nodiscard]] auto compiler_services::position() const -> source_position { @@ -1570,7 +1565,7 @@ auto newline_pos{CPP2_UFCS(find)(source, '\n')}; // Error diagnosis and handling, integrated with compiler output // Unlike a contract violation, .requires continues further processing // -#line 152 "reflect.h2" +#line 147 "reflect.h2" auto compiler_services::require( cpp2::impl::in b, @@ -1582,7 +1577,7 @@ auto newline_pos{CPP2_UFCS(find)(source, '\n')}; } } -#line 163 "reflect.h2" +#line 158 "reflect.h2" auto compiler_services::error(cpp2::impl::in msg) const& -> void { auto message {cpp2::impl::as_(msg)}; @@ -1595,7 +1590,7 @@ auto newline_pos{CPP2_UFCS(find)(source, '\n')}; // Enable custom contracts on this object, integrated with compiler output // Unlike .requires, a contract violation stops further processing // -#line 175 "reflect.h2" +#line 170 "reflect.h2" auto compiler_services::report_violation(auto const& msg) const& -> void{ error(msg); throw(std::runtime_error( @@ -1604,7 +1599,7 @@ auto newline_pos{CPP2_UFCS(find)(source, '\n')}; )); } -#line 183 "reflect.h2" +#line 178 "reflect.h2" [[nodiscard]] auto compiler_services::is_active() const& -> decltype(auto) { return true; } compiler_services::~compiler_services() noexcept{} @@ -1618,7 +1613,7 @@ compiler_services::compiler_services(compiler_services const& that) , metafunction_args{ that.metafunction_args } , metafunctions_used{ that.metafunctions_used }{} -#line 187 "reflect.h2" +#line 182 "reflect.h2" /* //----------------------------------------------------------------------- // @@ -1655,7 +1650,7 @@ type_id: @polymorphic_base @copyable type = } */ -#line 224 "reflect.h2" +#line 219 "reflect.h2" //----------------------------------------------------------------------- // // Declarations @@ -1666,7 +1661,7 @@ type_id: @polymorphic_base @copyable type = // All declarations are wrappers around a pointer to node // -#line 239 "reflect.h2" +#line 234 "reflect.h2" declaration_base::declaration_base( declaration_node* n_, @@ -1674,17 +1669,17 @@ type_id: @polymorphic_base @copyable type = ) : compiler_services{ s } , n{ n_ } -#line 244 "reflect.h2" +#line 239 "reflect.h2" { -#line 247 "reflect.h2" +#line 242 "reflect.h2" if (cpp2::cpp2_default.is_active() && !(n) ) { cpp2::cpp2_default.report_violation(CPP2_CONTRACT_MSG("a meta::declaration must point to a valid declaration_node, not null")); } } -#line 250 "reflect.h2" +#line 245 "reflect.h2" [[nodiscard]] auto declaration_base::position() const -> source_position { return CPP2_UFCS(position)((*cpp2::impl::assert_not_null(n))); } -#line 252 "reflect.h2" +#line 247 "reflect.h2" [[nodiscard]] auto declaration_base::print() const& -> std::string { return CPP2_UFCS(pretty_print_visualize)((*cpp2::impl::assert_not_null(n)), 0); } declaration_base::~declaration_base() noexcept{} @@ -1692,126 +1687,126 @@ declaration_base::declaration_base(declaration_base const& that) : compiler_services{ static_cast(that) } , n{ that.n }{} -#line 256 "reflect.h2" +#line 251 "reflect.h2" //----------------------------------------------------------------------- // All declarations // -#line 263 "reflect.h2" +#line 258 "reflect.h2" declaration::declaration( declaration_node* n_, cpp2::impl::in s ) : declaration_base{ n_, s } -#line 268 "reflect.h2" +#line 263 "reflect.h2" { } -#line 272 "reflect.h2" +#line 267 "reflect.h2" [[nodiscard]] auto declaration::is_public() const& -> bool { return CPP2_UFCS(is_public)((*cpp2::impl::assert_not_null(n))); } -#line 273 "reflect.h2" +#line 268 "reflect.h2" [[nodiscard]] auto declaration::is_protected() const& -> bool { return CPP2_UFCS(is_protected)((*cpp2::impl::assert_not_null(n))); } -#line 274 "reflect.h2" +#line 269 "reflect.h2" [[nodiscard]] auto declaration::is_private() const& -> bool { return CPP2_UFCS(is_private)((*cpp2::impl::assert_not_null(n))); } -#line 275 "reflect.h2" +#line 270 "reflect.h2" [[nodiscard]] auto declaration::is_default_access() const& -> bool { return CPP2_UFCS(is_default_access)((*cpp2::impl::assert_not_null(n))); } -#line 277 "reflect.h2" +#line 272 "reflect.h2" [[nodiscard]] auto declaration::default_to_public() & -> decltype(auto) { return static_cast(CPP2_UFCS(make_public)((*cpp2::impl::assert_not_null(n)))); } -#line 278 "reflect.h2" +#line 273 "reflect.h2" [[nodiscard]] auto declaration::default_to_protected() & -> decltype(auto) { return static_cast(CPP2_UFCS(make_protected)((*cpp2::impl::assert_not_null(n)))); } -#line 279 "reflect.h2" +#line 274 "reflect.h2" [[nodiscard]] auto declaration::default_to_private() & -> decltype(auto) { return static_cast(CPP2_UFCS(make_private)((*cpp2::impl::assert_not_null(n)))); } -#line 281 "reflect.h2" +#line 276 "reflect.h2" [[nodiscard]] auto declaration::make_public() & -> bool { return CPP2_UFCS(make_public)((*cpp2::impl::assert_not_null(n))); } -#line 282 "reflect.h2" +#line 277 "reflect.h2" [[nodiscard]] auto declaration::make_protected() & -> bool { return CPP2_UFCS(make_protected)((*cpp2::impl::assert_not_null(n))); } -#line 283 "reflect.h2" +#line 278 "reflect.h2" [[nodiscard]] auto declaration::make_private() & -> bool { return CPP2_UFCS(make_private)((*cpp2::impl::assert_not_null(n))); } -#line 285 "reflect.h2" +#line 280 "reflect.h2" [[nodiscard]] auto declaration::has_name() const& -> bool { return CPP2_UFCS(has_name)((*cpp2::impl::assert_not_null(n))); } -#line 286 "reflect.h2" +#line 281 "reflect.h2" [[nodiscard]] auto declaration::has_name(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_name)((*cpp2::impl::assert_not_null(n)), s); } -#line 288 "reflect.h2" +#line 283 "reflect.h2" [[nodiscard]] auto declaration::name() const& -> std::string_view{ if (has_name()) {return CPP2_UFCS(as_string_view)((*cpp2::impl::assert_not_null(CPP2_UFCS(name)(*cpp2::impl::assert_not_null(n))))); } else { return ""; } } -#line 293 "reflect.h2" +#line 288 "reflect.h2" [[nodiscard]] auto declaration::has_initializer() const& -> bool { return CPP2_UFCS(has_initializer)((*cpp2::impl::assert_not_null(n))); } -#line 295 "reflect.h2" +#line 290 "reflect.h2" [[nodiscard]] auto declaration::is_global() const& -> bool { return CPP2_UFCS(is_global)((*cpp2::impl::assert_not_null(n))); } -#line 296 "reflect.h2" +#line 291 "reflect.h2" [[nodiscard]] auto declaration::is_function() const& -> bool { return CPP2_UFCS(is_function)((*cpp2::impl::assert_not_null(n))); } -#line 297 "reflect.h2" +#line 292 "reflect.h2" [[nodiscard]] auto declaration::is_object() const& -> bool { return CPP2_UFCS(is_object)((*cpp2::impl::assert_not_null(n))); } -#line 298 "reflect.h2" +#line 293 "reflect.h2" [[nodiscard]] auto declaration::is_base_object() const& -> bool { return CPP2_UFCS(is_base_object)((*cpp2::impl::assert_not_null(n))); } -#line 299 "reflect.h2" +#line 294 "reflect.h2" [[nodiscard]] auto declaration::is_member_object() const& -> bool { return CPP2_UFCS(is_member_object)((*cpp2::impl::assert_not_null(n))); } -#line 300 "reflect.h2" +#line 295 "reflect.h2" [[nodiscard]] auto declaration::is_type() const& -> bool { return CPP2_UFCS(is_type)((*cpp2::impl::assert_not_null(n))); } -#line 301 "reflect.h2" +#line 296 "reflect.h2" [[nodiscard]] auto declaration::is_namespace() const& -> bool { return CPP2_UFCS(is_namespace)((*cpp2::impl::assert_not_null(n))); } -#line 302 "reflect.h2" +#line 297 "reflect.h2" [[nodiscard]] auto declaration::is_alias() const& -> bool { return CPP2_UFCS(is_alias)((*cpp2::impl::assert_not_null(n))); } -#line 304 "reflect.h2" +#line 299 "reflect.h2" [[nodiscard]] auto declaration::is_type_alias() const& -> bool { return CPP2_UFCS(is_type_alias)((*cpp2::impl::assert_not_null(n))); } -#line 305 "reflect.h2" +#line 300 "reflect.h2" [[nodiscard]] auto declaration::is_namespace_alias() const& -> bool { return CPP2_UFCS(is_namespace_alias)((*cpp2::impl::assert_not_null(n))); } -#line 306 "reflect.h2" +#line 301 "reflect.h2" [[nodiscard]] auto declaration::is_object_alias() const& -> bool { return CPP2_UFCS(is_object_alias)((*cpp2::impl::assert_not_null(n))); } -#line 308 "reflect.h2" +#line 303 "reflect.h2" [[nodiscard]] auto declaration::is_function_expression() const& -> bool { return CPP2_UFCS(is_function_expression)((*cpp2::impl::assert_not_null(n))); } -#line 310 "reflect.h2" +#line 305 "reflect.h2" [[nodiscard]] auto declaration::as_function() const& -> function_declaration { return function_declaration(n, (*this)); } -#line 311 "reflect.h2" +#line 306 "reflect.h2" [[nodiscard]] auto declaration::as_object() const& -> object_declaration { return object_declaration(n, (*this)); } -#line 312 "reflect.h2" +#line 307 "reflect.h2" [[nodiscard]] auto declaration::as_type() const& -> type_declaration { return type_declaration(n, (*this)); } -#line 313 "reflect.h2" +#line 308 "reflect.h2" [[nodiscard]] auto declaration::as_alias() const& -> alias_declaration { return alias_declaration(n, (*this)); } -#line 315 "reflect.h2" +#line 310 "reflect.h2" [[nodiscard]] auto declaration::get_parent() const& -> declaration { return declaration((*cpp2::impl::assert_not_null(n)).parent_declaration, (*this)); } -#line 317 "reflect.h2" +#line 312 "reflect.h2" [[nodiscard]] auto declaration::parent_is_function() const& -> bool { return CPP2_UFCS(parent_is_function)((*cpp2::impl::assert_not_null(n))); } -#line 318 "reflect.h2" +#line 313 "reflect.h2" [[nodiscard]] auto declaration::parent_is_object() const& -> bool { return CPP2_UFCS(parent_is_object)((*cpp2::impl::assert_not_null(n))); } -#line 319 "reflect.h2" +#line 314 "reflect.h2" [[nodiscard]] auto declaration::parent_is_type() const& -> bool { return CPP2_UFCS(parent_is_type)((*cpp2::impl::assert_not_null(n))); } -#line 320 "reflect.h2" +#line 315 "reflect.h2" [[nodiscard]] auto declaration::parent_is_namespace() const& -> bool { return CPP2_UFCS(parent_is_namespace)((*cpp2::impl::assert_not_null(n))); } -#line 321 "reflect.h2" +#line 316 "reflect.h2" [[nodiscard]] auto declaration::parent_is_alias() const& -> bool { return CPP2_UFCS(parent_is_alias)((*cpp2::impl::assert_not_null(n))); } -#line 323 "reflect.h2" +#line 318 "reflect.h2" [[nodiscard]] auto declaration::parent_is_type_alias() const& -> bool { return CPP2_UFCS(parent_is_type_alias)((*cpp2::impl::assert_not_null(n))); } -#line 324 "reflect.h2" +#line 319 "reflect.h2" [[nodiscard]] auto declaration::parent_is_namespace_alias() const& -> bool { return CPP2_UFCS(parent_is_namespace_alias)((*cpp2::impl::assert_not_null(n))); } -#line 325 "reflect.h2" +#line 320 "reflect.h2" [[nodiscard]] auto declaration::parent_is_object_alias() const& -> bool { return CPP2_UFCS(parent_is_object_alias)((*cpp2::impl::assert_not_null(n))); } -#line 327 "reflect.h2" +#line 322 "reflect.h2" [[nodiscard]] auto declaration::parent_is_polymorphic() const& -> bool { return CPP2_UFCS(parent_is_polymorphic)((*cpp2::impl::assert_not_null(n))); } -#line 329 "reflect.h2" +#line 324 "reflect.h2" auto declaration::mark_for_removal_from_enclosing_type() & -> void // this precondition should be sufficient ... { if (cpp2::type_safety.is_active() && !(parent_is_type()) ) { cpp2::type_safety.report_violation(""); } -#line 332 "reflect.h2" +#line 327 "reflect.h2" auto test {CPP2_UFCS(type_member_mark_for_removal)((*cpp2::impl::assert_not_null(n)))}; if (cpp2::cpp2_default.is_active() && !(cpp2::move(test)) ) { cpp2::cpp2_default.report_violation(""); }// ... to ensure this assert is true } @@ -1820,95 +1815,95 @@ declaration_base::declaration_base(declaration_base const& that) declaration::declaration(declaration const& that) : declaration_base{ static_cast(that) }{} -#line 338 "reflect.h2" +#line 333 "reflect.h2" //----------------------------------------------------------------------- // Function declarations // -#line 345 "reflect.h2" +#line 340 "reflect.h2" function_declaration::function_declaration( declaration_node* n_, cpp2::impl::in s ) : declaration{ n_, s } -#line 350 "reflect.h2" +#line 345 "reflect.h2" { if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(is_function)((*cpp2::impl::assert_not_null(n)))) ) { cpp2::cpp2_default.report_violation(""); } } -#line 355 "reflect.h2" +#line 350 "reflect.h2" [[nodiscard]] auto function_declaration::index_of_parameter_named(cpp2::impl::in s) const& -> int { return CPP2_UFCS(index_of_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 356 "reflect.h2" +#line 351 "reflect.h2" [[nodiscard]] auto function_declaration::has_parameter_named(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 357 "reflect.h2" +#line 352 "reflect.h2" [[nodiscard]] auto function_declaration::has_in_parameter_named(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_in_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 358 "reflect.h2" +#line 353 "reflect.h2" [[nodiscard]] auto function_declaration::has_in_ref_parameter_named(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_in_ref_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 359 "reflect.h2" +#line 354 "reflect.h2" [[nodiscard]] auto function_declaration::has_copy_parameter_named(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_copy_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 360 "reflect.h2" +#line 355 "reflect.h2" [[nodiscard]] auto function_declaration::has_inout_parameter_named(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_inout_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 361 "reflect.h2" +#line 356 "reflect.h2" [[nodiscard]] auto function_declaration::has_out_parameter_named(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_out_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 362 "reflect.h2" +#line 357 "reflect.h2" [[nodiscard]] auto function_declaration::has_move_parameter_named(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_move_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 363 "reflect.h2" +#line 358 "reflect.h2" [[nodiscard]] auto function_declaration::has_forward_parameter_named(cpp2::impl::in s) const& -> bool { return CPP2_UFCS(has_forward_parameter_named)((*cpp2::impl::assert_not_null(n)), s); } -#line 364 "reflect.h2" +#line 359 "reflect.h2" [[nodiscard]] auto function_declaration::first_parameter_name() const& -> std::string { return CPP2_UFCS(first_parameter_name)((*cpp2::impl::assert_not_null(n))); } -#line 366 "reflect.h2" +#line 361 "reflect.h2" [[nodiscard]] auto function_declaration::has_parameter_with_name_and_pass(cpp2::impl::in s, cpp2::impl::in pass) const& -> bool { return CPP2_UFCS(has_parameter_with_name_and_pass)((*cpp2::impl::assert_not_null(n)), s, pass); } -#line 368 "reflect.h2" +#line 363 "reflect.h2" [[nodiscard]] auto function_declaration::is_function_with_this() const& -> bool { return CPP2_UFCS(is_function_with_this)((*cpp2::impl::assert_not_null(n))); } -#line 369 "reflect.h2" +#line 364 "reflect.h2" [[nodiscard]] auto function_declaration::is_virtual() const& -> bool { return CPP2_UFCS(is_virtual_function)((*cpp2::impl::assert_not_null(n))); } -#line 370 "reflect.h2" +#line 365 "reflect.h2" [[nodiscard]] auto function_declaration::is_defaultable() const& -> bool { return CPP2_UFCS(is_defaultable_function)((*cpp2::impl::assert_not_null(n))); } -#line 371 "reflect.h2" +#line 366 "reflect.h2" [[nodiscard]] auto function_declaration::is_constructor() const& -> bool { return CPP2_UFCS(is_constructor)((*cpp2::impl::assert_not_null(n))); } -#line 372 "reflect.h2" +#line 367 "reflect.h2" [[nodiscard]] auto function_declaration::is_default_constructor() const& -> bool { return CPP2_UFCS(is_default_constructor)((*cpp2::impl::assert_not_null(n))); } -#line 373 "reflect.h2" +#line 368 "reflect.h2" [[nodiscard]] auto function_declaration::is_move() const& -> bool { return CPP2_UFCS(is_move)((*cpp2::impl::assert_not_null(n))); } -#line 374 "reflect.h2" +#line 369 "reflect.h2" [[nodiscard]] auto function_declaration::is_swap() const& -> bool { return CPP2_UFCS(is_swap)((*cpp2::impl::assert_not_null(n))); } -#line 375 "reflect.h2" +#line 370 "reflect.h2" [[nodiscard]] auto function_declaration::is_constructor_with_that() const& -> bool { return CPP2_UFCS(is_constructor_with_that)((*cpp2::impl::assert_not_null(n))); } -#line 376 "reflect.h2" +#line 371 "reflect.h2" [[nodiscard]] auto function_declaration::is_constructor_with_in_that() const& -> bool { return CPP2_UFCS(is_constructor_with_in_that)((*cpp2::impl::assert_not_null(n))); } -#line 377 "reflect.h2" +#line 372 "reflect.h2" [[nodiscard]] auto function_declaration::is_constructor_with_move_that() const& -> bool { return CPP2_UFCS(is_constructor_with_move_that)((*cpp2::impl::assert_not_null(n))); } -#line 378 "reflect.h2" +#line 373 "reflect.h2" [[nodiscard]] auto function_declaration::is_assignment() const& -> bool { return CPP2_UFCS(is_assignment)((*cpp2::impl::assert_not_null(n))); } -#line 379 "reflect.h2" +#line 374 "reflect.h2" [[nodiscard]] auto function_declaration::is_assignment_with_that() const& -> bool { return CPP2_UFCS(is_assignment_with_that)((*cpp2::impl::assert_not_null(n))); } -#line 380 "reflect.h2" +#line 375 "reflect.h2" [[nodiscard]] auto function_declaration::is_assignment_with_in_that() const& -> bool { return CPP2_UFCS(is_assignment_with_in_that)((*cpp2::impl::assert_not_null(n))); } -#line 381 "reflect.h2" +#line 376 "reflect.h2" [[nodiscard]] auto function_declaration::is_assignment_with_move_that() const& -> bool { return CPP2_UFCS(is_assignment_with_move_that)((*cpp2::impl::assert_not_null(n))); } -#line 382 "reflect.h2" +#line 377 "reflect.h2" [[nodiscard]] auto function_declaration::is_destructor() const& -> bool { return CPP2_UFCS(is_destructor)((*cpp2::impl::assert_not_null(n))); } -#line 384 "reflect.h2" +#line 379 "reflect.h2" [[nodiscard]] auto function_declaration::is_copy_or_move() const& -> bool { return is_constructor_with_that() || is_assignment_with_that(); } -#line 386 "reflect.h2" +#line 381 "reflect.h2" [[nodiscard]] auto function_declaration::has_declared_return_type() const& -> bool { return CPP2_UFCS(has_declared_return_type)((*cpp2::impl::assert_not_null(n))); } -#line 387 "reflect.h2" +#line 382 "reflect.h2" [[nodiscard]] auto function_declaration::has_deduced_return_type() const& -> bool { return CPP2_UFCS(has_deduced_return_type)((*cpp2::impl::assert_not_null(n))); } -#line 388 "reflect.h2" +#line 383 "reflect.h2" [[nodiscard]] auto function_declaration::has_bool_return_type() const& -> bool { return CPP2_UFCS(has_bool_return_type)((*cpp2::impl::assert_not_null(n))); } -#line 389 "reflect.h2" +#line 384 "reflect.h2" [[nodiscard]] auto function_declaration::has_non_void_return_type() const& -> bool { return CPP2_UFCS(has_non_void_return_type)((*cpp2::impl::assert_not_null(n))); } -#line 391 "reflect.h2" +#line 386 "reflect.h2" [[nodiscard]] auto function_declaration::unnamed_return_type() const& -> std::string { return CPP2_UFCS(unnamed_return_type_to_string)((*cpp2::impl::assert_not_null(n))); } -#line 393 "reflect.h2" +#line 388 "reflect.h2" [[nodiscard]] auto function_declaration::get_parameters() const& -> std::vector { @@ -1919,19 +1914,19 @@ declaration::declaration(declaration const& that) return ret; } -#line 403 "reflect.h2" +#line 398 "reflect.h2" [[nodiscard]] auto function_declaration::is_binary_comparison_function() const& -> bool { return CPP2_UFCS(is_binary_comparison_function)((*cpp2::impl::assert_not_null(n))); } -#line 405 "reflect.h2" +#line 400 "reflect.h2" [[nodiscard]] auto function_declaration::default_to_virtual() & -> decltype(auto) { return static_cast(CPP2_UFCS(make_function_virtual)((*cpp2::impl::assert_not_null(n)))); } -#line 407 "reflect.h2" +#line 402 "reflect.h2" [[nodiscard]] auto function_declaration::make_virtual() & -> bool { return CPP2_UFCS(make_function_virtual)((*cpp2::impl::assert_not_null(n))); } -#line 409 "reflect.h2" +#line 404 "reflect.h2" auto function_declaration::add_initializer(cpp2::impl::in source) & -> void -#line 412 "reflect.h2" +#line 407 "reflect.h2" { if ((*this).is_active() && !(!(has_initializer())) ) { (*this).report_violation(CPP2_CONTRACT_MSG("cannot add an initializer to a function that already has one")); } if ((*this).is_active() && !(parent_is_type()) ) { (*this).report_violation(CPP2_CONTRACT_MSG("cannot add an initializer to a function that isn't in a type scope")); } @@ -1940,7 +1935,7 @@ declaration::declaration(declaration const& that) //require( parent_is_type(), // "cannot add an initializer to a function that isn't in a type scope"); -#line 418 "reflect.h2" +#line 413 "reflect.h2" auto stmt {parse_statement(source)}; if (!((cpp2::impl::as_(stmt)))) { error("cannot add an initializer that is not a valid statement"); @@ -1953,30 +1948,30 @@ declaration::declaration(declaration const& that) function_declaration::function_declaration(function_declaration const& that) : declaration{ static_cast(that) }{} -#line 429 "reflect.h2" +#line 424 "reflect.h2" //----------------------------------------------------------------------- // Object declarations // -#line 436 "reflect.h2" +#line 431 "reflect.h2" object_declaration::object_declaration( declaration_node* n_, cpp2::impl::in s ) : declaration{ n_, s } -#line 441 "reflect.h2" +#line 436 "reflect.h2" { if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(is_object)((*cpp2::impl::assert_not_null(n)))) ) { cpp2::cpp2_default.report_violation(""); } } -#line 446 "reflect.h2" +#line 441 "reflect.h2" [[nodiscard]] auto object_declaration::is_const() const& -> bool { return CPP2_UFCS(is_const)((*cpp2::impl::assert_not_null(n))); } -#line 447 "reflect.h2" +#line 442 "reflect.h2" [[nodiscard]] auto object_declaration::has_wildcard_type() const& -> bool { return CPP2_UFCS(has_wildcard_type)((*cpp2::impl::assert_not_null(n))); } -#line 449 "reflect.h2" +#line 444 "reflect.h2" [[nodiscard]] auto object_declaration::type() const& -> std::string{ auto ret {CPP2_UFCS(object_type)((*cpp2::impl::assert_not_null(n)))}; require(!(contains(ret, "(*ERROR*)")), @@ -1984,7 +1979,7 @@ declaration::declaration(declaration const& that) return ret; } -#line 456 "reflect.h2" +#line 451 "reflect.h2" [[nodiscard]] auto object_declaration::initializer() const& -> std::string{ auto ret {CPP2_UFCS(object_initializer)((*cpp2::impl::assert_not_null(n)))}; require(!(contains(ret, "(*ERROR*)")), @@ -1995,25 +1990,25 @@ declaration::declaration(declaration const& that) object_declaration::object_declaration(object_declaration const& that) : declaration{ static_cast(that) }{} -#line 465 "reflect.h2" +#line 460 "reflect.h2" //----------------------------------------------------------------------- // Type declarations // -#line 472 "reflect.h2" +#line 467 "reflect.h2" type_declaration::type_declaration( declaration_node* n_, cpp2::impl::in s ) : declaration{ n_, s } -#line 477 "reflect.h2" +#line 472 "reflect.h2" { if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(is_type)((*cpp2::impl::assert_not_null(n)))) ) { cpp2::cpp2_default.report_violation(""); } } -#line 482 "reflect.h2" +#line 477 "reflect.h2" auto type_declaration::reserve_names(cpp2::impl::in name, auto&& ...etc) const& -> void { // etc is not declared ':string_view' for compatibility with GCC 10.x for ( @@ -2028,14 +2023,14 @@ declaration::declaration(declaration const& that) } } -#line 496 "reflect.h2" +#line 491 "reflect.h2" [[nodiscard]] auto type_declaration::is_polymorphic() const& -> bool { return CPP2_UFCS(is_polymorphic)((*cpp2::impl::assert_not_null(n))); } -#line 497 "reflect.h2" +#line 492 "reflect.h2" [[nodiscard]] auto type_declaration::is_final() const& -> bool { return CPP2_UFCS(is_type_final)((*cpp2::impl::assert_not_null(n))); } -#line 498 "reflect.h2" +#line 493 "reflect.h2" [[nodiscard]] auto type_declaration::make_final() & -> bool { return CPP2_UFCS(make_type_final)((*cpp2::impl::assert_not_null(n))); } -#line 500 "reflect.h2" +#line 495 "reflect.h2" [[nodiscard]] auto type_declaration::get_member_functions() const& -> std::vector { @@ -2047,7 +2042,7 @@ declaration::declaration(declaration const& that) return ret; } -#line 511 "reflect.h2" +#line 506 "reflect.h2" [[nodiscard]] auto type_declaration::get_member_functions_needing_initializer() const& -> std::vector { @@ -2063,7 +2058,7 @@ declaration::declaration(declaration const& that) return ret; } -#line 526 "reflect.h2" +#line 521 "reflect.h2" [[nodiscard]] auto type_declaration::get_member_objects() const& -> std::vector { @@ -2074,7 +2069,7 @@ declaration::declaration(declaration const& that) return ret; } -#line 536 "reflect.h2" +#line 531 "reflect.h2" [[nodiscard]] auto type_declaration::get_member_types() const& -> std::vector { @@ -2085,7 +2080,7 @@ declaration::declaration(declaration const& that) return ret; } -#line 546 "reflect.h2" +#line 541 "reflect.h2" [[nodiscard]] auto type_declaration::get_member_aliases() const& -> std::vector { @@ -2096,7 +2091,7 @@ declaration::declaration(declaration const& that) return ret; } -#line 556 "reflect.h2" +#line 551 "reflect.h2" [[nodiscard]] auto type_declaration::get_members() const& -> std::vector { @@ -2107,16 +2102,16 @@ declaration::declaration(declaration const& that) return ret; } -#line 566 "reflect.h2" +#line 561 "reflect.h2" [[nodiscard]] auto type_declaration::query_declared_value_set_functions() const& -> query_declared_value_set_functions_ret -#line 573 "reflect.h2" +#line 568 "reflect.h2" { cpp2::impl::deferred_init out_this_in_that; cpp2::impl::deferred_init out_this_move_that; cpp2::impl::deferred_init inout_this_in_that; cpp2::impl::deferred_init inout_this_move_that; -#line 574 "reflect.h2" +#line 569 "reflect.h2" auto declared {CPP2_UFCS(find_declared_value_set_functions)((*cpp2::impl::assert_not_null(n)))}; out_this_in_that.construct(declared.out_this_in_that != nullptr); out_this_move_that.construct(declared.out_this_move_that != nullptr); @@ -2125,7 +2120,7 @@ declaration::declaration(declaration const& that) return { std::move(out_this_in_that.value()), std::move(out_this_move_that.value()), std::move(inout_this_in_that.value()), std::move(inout_this_move_that.value()) }; // NOLINT(performance-move-const-arg) } -#line 582 "reflect.h2" +#line 577 "reflect.h2" auto type_declaration::add_member(cpp2::impl::in source) & -> void { auto decl {parse_statement(source)}; @@ -2140,30 +2135,30 @@ declaration::declaration(declaration const& that) std::string("unexpected error while attempting to add member:\n") + source); } -#line 596 "reflect.h2" +#line 591 "reflect.h2" [[nodiscard]] auto type_declaration::remove_marked_members() & -> decltype(auto) { return CPP2_UFCS(type_remove_marked_members)((*cpp2::impl::assert_not_null(n))); } -#line 597 "reflect.h2" +#line 592 "reflect.h2" [[nodiscard]] auto type_declaration::remove_all_members() & -> decltype(auto) { return CPP2_UFCS(type_remove_all_members)((*cpp2::impl::assert_not_null(n))); } -#line 599 "reflect.h2" +#line 594 "reflect.h2" [[nodiscard]] auto type_declaration::disable_member_function_generation() & -> decltype(auto) { return CPP2_UFCS(type_disable_member_function_generation)((*cpp2::impl::assert_not_null(n))); } type_declaration::type_declaration(type_declaration const& that) : declaration{ static_cast(that) }{} -#line 603 "reflect.h2" +#line 598 "reflect.h2" //----------------------------------------------------------------------- // Alias declarations // -#line 610 "reflect.h2" +#line 605 "reflect.h2" alias_declaration::alias_declaration( declaration_node* n_, cpp2::impl::in s ) : declaration{ n_, s } -#line 615 "reflect.h2" +#line 610 "reflect.h2" { if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(is_alias)((*cpp2::impl::assert_not_null(n)))) ) { cpp2::cpp2_default.report_violation(""); } @@ -2172,7 +2167,7 @@ declaration::declaration(declaration const& that) alias_declaration::alias_declaration(alias_declaration const& that) : declaration{ static_cast(that) }{} -#line 622 "reflect.h2" +#line 617 "reflect.h2" //----------------------------------------------------------------------- // // Metafunctions - these are hardwired for now until we get to the @@ -2185,13 +2180,13 @@ declaration::declaration(declaration const& that) // Some common metafunction helpers (metafunctions are just functions, // so they can be factored as usual) // -#line 634 "reflect.h2" +#line 629 "reflect.h2" auto add_virtual_destructor(meta::type_declaration& t) -> void { CPP2_UFCS(add_member)(t, "operator=: (virtual move this) = { }"); } -#line 640 "reflect.h2" +#line 635 "reflect.h2" //----------------------------------------------------------------------- // // "... an abstract base class defines an interface ..." @@ -2204,7 +2199,7 @@ auto add_virtual_destructor(meta::type_declaration& t) -> void // // an abstract base class having only pure virtual functions // -#line 652 "reflect.h2" +#line 647 "reflect.h2" auto interface(meta::type_declaration& t) -> void { auto has_dtor {false}; @@ -2231,7 +2226,7 @@ auto interface(meta::type_declaration& t) -> void } } -#line 679 "reflect.h2" +#line 674 "reflect.h2" //----------------------------------------------------------------------- // // "C.35: A base class destructor should be either public and @@ -2251,7 +2246,7 @@ auto interface(meta::type_declaration& t) -> void // // Unlike an interface, it can have nonpublic and nonvirtual functions. // -#line 698 "reflect.h2" +#line 693 "reflect.h2" auto polymorphic_base(meta::type_declaration& t) -> void { auto has_dtor {false}; @@ -2276,7 +2271,7 @@ auto polymorphic_base(meta::type_declaration& t) -> void } } -#line 723 "reflect.h2" +#line 718 "reflect.h2" //----------------------------------------------------------------------- // // "... A totally ordered type ... requires operator<=> that @@ -2297,7 +2292,7 @@ auto polymorphic_base(meta::type_declaration& t) -> void //----------------------------------------------------------------------- // -#line 743 "reflect.h2" +#line 738 "reflect.h2" auto ordered_impl( meta::type_declaration& t, cpp2::impl::in ordering// must be "strong_ordering" etc. @@ -2327,7 +2322,7 @@ auto ordered_impl( // // Note: the ordering that should be encouraged as default gets the nice name // -#line 772 "reflect.h2" +#line 767 "reflect.h2" auto ordered(meta::type_declaration& t) -> void { ordered_impl(t, "strong_ordering"); @@ -2336,7 +2331,7 @@ auto ordered(meta::type_declaration& t) -> void //----------------------------------------------------------------------- // weakly_ordered - a weakly ordered type // -#line 780 "reflect.h2" +#line 775 "reflect.h2" auto weakly_ordered(meta::type_declaration& t) -> void { ordered_impl(t, "weak_ordering"); @@ -2345,13 +2340,13 @@ auto weakly_ordered(meta::type_declaration& t) -> void //----------------------------------------------------------------------- // partially_ordered - a partially ordered type // -#line 788 "reflect.h2" +#line 783 "reflect.h2" auto partially_ordered(meta::type_declaration& t) -> void { ordered_impl(t, "partial_ordering"); } -#line 794 "reflect.h2" +#line 789 "reflect.h2" //----------------------------------------------------------------------- // // "A value is ... a regular type. It must have all public @@ -2368,7 +2363,7 @@ auto partially_ordered(meta::type_declaration& t) -> void // // A type with (copy and move) x (construction and assignment) // -#line 810 "reflect.h2" +#line 805 "reflect.h2" auto copyable(meta::type_declaration& t) -> void { // If the user explicitly wrote any of the copy/move functions, @@ -2402,7 +2397,7 @@ auto copyable(meta::type_declaration& t) -> void // // A memberwise hashable type // -#line 843 "reflect.h2" +#line 838 "reflect.h2" auto hashable(meta::type_declaration& t) -> void { CPP2_UFCS(require)(t, !(CPP2_UFCS(empty)(CPP2_UFCS(get_member_objects)(t))), @@ -2428,7 +2423,7 @@ auto hashable(meta::type_declaration& t) -> void CPP2_UFCS(add_member)(t, cpp2::move(hash) + "\n return ret;\n }"); } -#line 869 "reflect.h2" +#line 864 "reflect.h2" //----------------------------------------------------------------------- // // basic_value @@ -2436,7 +2431,7 @@ auto hashable(meta::type_declaration& t) -> void // A regular type: copyable, plus has public default construction // and no protected or virtual functions // -#line 876 "reflect.h2" +#line 871 "reflect.h2" auto basic_value(meta::type_declaration& t) -> void { CPP2_UFCS(copyable)(t); @@ -2465,28 +2460,28 @@ auto basic_value(meta::type_declaration& t) -> void // // Note: the ordering that should be encouraged as default gets the nice name // -#line 904 "reflect.h2" +#line 899 "reflect.h2" auto value(meta::type_declaration& t) -> void { CPP2_UFCS(ordered)(t); CPP2_UFCS(basic_value)(t); } -#line 910 "reflect.h2" +#line 905 "reflect.h2" auto weakly_ordered_value(meta::type_declaration& t) -> void { CPP2_UFCS(weakly_ordered)(t); CPP2_UFCS(basic_value)(t); } -#line 916 "reflect.h2" +#line 911 "reflect.h2" auto partially_ordered_value(meta::type_declaration& t) -> void { CPP2_UFCS(partially_ordered)(t); CPP2_UFCS(basic_value)(t); } -#line 923 "reflect.h2" +#line 918 "reflect.h2" //----------------------------------------------------------------------- // // C.20: If you can avoid defining default operations, do @@ -2509,7 +2504,7 @@ auto partially_ordered_value(meta::type_declaration& t) -> void // // a type without declared copy/move/destructor functions // -#line 945 "reflect.h2" +#line 940 "reflect.h2" auto cpp1_rule_of_zero(meta::type_declaration& t) -> void { for ( auto& mf : CPP2_UFCS(get_member_functions)(t) ) @@ -2552,7 +2547,7 @@ auto cpp1_rule_of_zero(meta::type_declaration& t) -> void // parameters instead of concrete forwarding parameters (mainly used // for cppfront internal use, so cppfront builds under GCC 10) // -#line 987 "reflect.h2" +#line 982 "reflect.h2" auto cpp2_struct(meta::type_declaration& t) -> void { std::string ctor_params {}; @@ -2609,7 +2604,7 @@ value_member_info::value_member_info(auto const& name_, auto const& type_, auto , type{ type_ } , value{ value_ }{} -#line 1039 "reflect.h2" +#line 1034 "reflect.h2" //----------------------------------------------------------------------- // // "C enumerations constitute a curiously half-baked concept. ... @@ -2628,7 +2623,7 @@ value_member_info::value_member_info(auto const& name_, auto const& type_, auto // a type together with named constants that are its possible values // -#line 1062 "reflect.h2" +#line 1057 "reflect.h2" auto basic_enum( meta::type_declaration& t, auto const& nextval, @@ -2653,7 +2648,7 @@ auto basic_enum( { std::string value{"-1"}; -#line 1085 "reflect.h2" +#line 1080 "reflect.h2" for ( auto const& m : CPP2_UFCS(get_members)(t) ) if ( CPP2_UFCS(is_member_object)(m)) @@ -2695,7 +2690,7 @@ std::string value{"-1"}; } } -#line 1125 "reflect.h2" +#line 1120 "reflect.h2" if ((CPP2_UFCS(empty)(enumerators))) { CPP2_UFCS(error)(t, "an enumeration must contain at least one enumerator value"); return ; @@ -2746,7 +2741,7 @@ std::string value{"-1"}; } } -#line 1176 "reflect.h2" +#line 1171 "reflect.h2" // 2. Replace: Erase the contents and replace with modified contents // // Note that most values and functions are declared as '==' compile-time values, i.e. Cpp1 'constexpr' @@ -2796,7 +2791,7 @@ std::string to_string_impl{" to_string_impl: (this, prefix: std::string_view" // Provide 'to_string' and 'to_code' functions to print enumerator // name(s) as human-readable strings or as code expressions -#line 1223 "reflect.h2" +#line 1218 "reflect.h2" { if (bitwise) { to_string_impl += ", separator: std::string_view ) -> std::string = { \n" @@ -2837,7 +2832,7 @@ std::string to_string_impl{" to_string_impl: (this, prefix: std::string_view" } } -#line 1262 "reflect.h2" +#line 1257 "reflect.h2" if (bitwise) { CPP2_UFCS(add_member)(t, " to_string: (this) -> std::string = to_string_impl( \"\", \", \" );"); CPP2_UFCS(add_member)(t, " to_code : (this) -> std::string = to_string_impl( \"" + cpp2::to_string(CPP2_UFCS(name)(t)) + "::\", \" | \" );"); @@ -2851,7 +2846,7 @@ std::string from_string{" from_string: (s: std::string_view) -> " + cpp2::to_ // Provide a 'from_string' function to parse strings into enumerators -#line 1273 "reflect.h2" +#line 1268 "reflect.h2" { std::string_view prefix {""}; std::string_view combine_op {"return"}; @@ -2873,7 +2868,7 @@ std::string from_string{" from_string: (s: std::string_view) -> " + cpp2::to_ { std::string_view else_{""}; -#line 1293 "reflect.h2" +#line 1288 "reflect.h2" for ( auto const& e : cpp2::move(enumerators) ) { from_string += " " + cpp2::to_string(else_) + "if \"" + cpp2::to_string(e.name) + "\" == x { " + cpp2::to_string(combine_op) + " " + cpp2::to_string(e.name) + "; }\n"; @@ -2881,7 +2876,7 @@ std::string_view else_{""}; } } -#line 1299 "reflect.h2" +#line 1294 "reflect.h2" if (bitwise) { from_string += " else { break outer; }\n" " }\n" @@ -2897,11 +2892,11 @@ std::string_view else_{""}; } } -#line 1313 "reflect.h2" +#line 1308 "reflect.h2" CPP2_UFCS(add_member)(t, " from_code: (s: std::string_view) -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = { str: std::string = s; return from_string( cpp2::string_util::replace_all(str, \"" + cpp2::to_string(CPP2_UFCS(name)(t)) + "::\", \"\" ) ); }"); } -#line 1317 "reflect.h2" +#line 1312 "reflect.h2" //----------------------------------------------------------------------- // // "An enum[...] is a totally ordered value type that stores a @@ -2911,7 +2906,7 @@ std::string_view else_{""}; // // -- P0707R4, section 3 // -#line 1326 "reflect.h2" +#line 1321 "reflect.h2" auto cpp2_enum(meta::type_declaration& t) -> void { // Let basic_enum do its thing, with an incrementing value generator @@ -2928,7 +2923,7 @@ auto cpp2_enum(meta::type_declaration& t) -> void ); } -#line 1343 "reflect.h2" +#line 1338 "reflect.h2" //----------------------------------------------------------------------- // // "flag_enum expresses an enumeration that stores values @@ -2939,7 +2934,7 @@ auto cpp2_enum(meta::type_declaration& t) -> void // // -- P0707R4, section 3 // -#line 1353 "reflect.h2" +#line 1348 "reflect.h2" auto flag_enum(meta::type_declaration& t) -> void { // Let basic_enum do its thing, with a power-of-two value generator @@ -2961,7 +2956,7 @@ auto flag_enum(meta::type_declaration& t) -> void ); } -#line 1375 "reflect.h2" +#line 1370 "reflect.h2" //----------------------------------------------------------------------- // // "As with void*, programmers should know that unions [...] are @@ -2986,7 +2981,7 @@ auto flag_enum(meta::type_declaration& t) -> void // a type that contains exactly one of a fixed set of values at a time // -#line 1399 "reflect.h2" +#line 1394 "reflect.h2" auto cpp2_union(meta::type_declaration& t) -> void { std::vector alternatives {}; @@ -2995,7 +2990,7 @@ auto value{0}; // 1. Gather: All the user-written members, and find/compute the max size -#line 1406 "reflect.h2" +#line 1401 "reflect.h2" for ( auto const& m : CPP2_UFCS(get_members)(t) ) { do @@ -3025,7 +3020,7 @@ auto value{0}; } while (false); ++value; } } -#line 1434 "reflect.h2" +#line 1429 "reflect.h2" std::string discriminator_type {}; if (cpp2::impl::cmp_less(CPP2_UFCS(ssize)(alternatives),std::numeric_limits::max())) { discriminator_type = "i8"; @@ -3040,7 +3035,7 @@ auto value{0}; discriminator_type = "i64"; }}} -#line 1449 "reflect.h2" +#line 1444 "reflect.h2" // 2. Replace: Erase the contents and replace with modified contents CPP2_UFCS(remove_marked_members)(t); @@ -3049,7 +3044,7 @@ std::string storage{" _storage: cpp2::aligned_storage t) -> void { std::cout << CPP2_UFCS(print)(t) << "\n"; @@ -3254,7 +3249,7 @@ return none; [[nodiscard]] auto expression_flags::from_code(cpp2::impl::in s) -> expression_flags{ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::move(str), "expression_flags::", "")); } -#line 1556 "reflect.h2" +#line 1551 "reflect.h2" //----------------------------------------------------------------------- // // regex - creates regular expressions from members @@ -3270,11 +3265,11 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov // ``` // -#line 1572 "reflect.h2" +#line 1567 "reflect.h2" // Possible modifiers for a regular expression. // -#line 1576 "reflect.h2" +#line 1571 "reflect.h2" // mod: i // mod: m // mod: s @@ -3282,106 +3277,106 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov // mod: x // mod: xx -#line 1585 "reflect.h2" +#line 1580 "reflect.h2" // Tokens for regular expressions. // // Basic class for a regex token. // -#line 1594 "reflect.h2" +#line 1589 "reflect.h2" regex_token::regex_token(cpp2::impl::in str) : string_rep{ str }{ -#line 1596 "reflect.h2" +#line 1591 "reflect.h2" } -#line 1598 "reflect.h2" +#line 1593 "reflect.h2" regex_token::regex_token() : string_rep{ "" }{ -#line 1600 "reflect.h2" +#line 1595 "reflect.h2" } //parse: (inout ctx: parse_context) -> token_ptr; // Generate the matching code. -#line 1605 "reflect.h2" +#line 1600 "reflect.h2" auto regex_token::add_groups([[maybe_unused]] std::set& unnamed_param_2) const -> void{}// Adds all group indices to the set. -#line 1606 "reflect.h2" +#line 1601 "reflect.h2" [[nodiscard]] auto regex_token::to_string() const& -> std::string{return string_rep; }// Create a string representation. -#line 1607 "reflect.h2" +#line 1602 "reflect.h2" auto regex_token::set_string(cpp2::impl::in s) & -> void{string_rep = s; } regex_token::~regex_token() noexcept{}// Set the string representation. -#line 1622 "reflect.h2" +#line 1617 "reflect.h2" regex_token_check::regex_token_check(cpp2::impl::in str, cpp2::impl::in check_) : regex_token{ str } , check{ check_ }{ -#line 1625 "reflect.h2" +#line 1620 "reflect.h2" } -#line 1627 "reflect.h2" +#line 1622 "reflect.h2" auto regex_token_check::generate_code(generation_context& ctx) const -> void{ ctx.add_check(check + "(" + ctx.match_parameters() + ")"); } regex_token_check::~regex_token_check() noexcept{} -#line 1641 "reflect.h2" +#line 1636 "reflect.h2" regex_token_code::regex_token_code(cpp2::impl::in str, cpp2::impl::in code_) : regex_token{ str } , code{ code_ }{ -#line 1644 "reflect.h2" +#line 1639 "reflect.h2" } -#line 1646 "reflect.h2" +#line 1641 "reflect.h2" auto regex_token_code::generate_code(generation_context& ctx) const -> void{ ctx.add(code); } regex_token_code::~regex_token_code() noexcept{} -#line 1658 "reflect.h2" +#line 1653 "reflect.h2" regex_token_empty::regex_token_empty(cpp2::impl::in str) : regex_token{ str }{ -#line 1660 "reflect.h2" +#line 1655 "reflect.h2" } -#line 1662 "reflect.h2" +#line 1657 "reflect.h2" auto regex_token_empty::generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void{ // Nothing. } regex_token_empty::~regex_token_empty() noexcept{} -#line 1676 "reflect.h2" +#line 1671 "reflect.h2" regex_token_list::regex_token_list(cpp2::impl::in t) : regex_token{ gen_string(t) } , tokens{ t }{ -#line 1679 "reflect.h2" +#line 1674 "reflect.h2" } -#line 1681 "reflect.h2" +#line 1676 "reflect.h2" auto regex_token_list::generate_code(generation_context& ctx) const -> void{ for ( auto const& token : tokens ) { (*cpp2::impl::assert_not_null(token)).generate_code(ctx); } } -#line 1687 "reflect.h2" +#line 1682 "reflect.h2" auto regex_token_list::add_groups(std::set& groups) const -> void{ for ( auto const& token : tokens ) { (*cpp2::impl::assert_not_null(token)).add_groups(groups); } } -#line 1693 "reflect.h2" +#line 1688 "reflect.h2" [[nodiscard]] auto regex_token_list::gen_string(cpp2::impl::in vec) -> std::string{ std::string r {""}; for ( auto const& token : vec ) { @@ -3392,7 +3387,7 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov regex_token_list::~regex_token_list() noexcept{} -#line 1716 "reflect.h2" +#line 1711 "reflect.h2" auto parse_context_group_state::next_alternative() & -> void{ token_vec new_list {}; std::swap(new_list, cur_match_list); @@ -3400,14 +3395,14 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov static_cast(alternate_match_lists.insert(alternate_match_lists.end(), CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, cpp2::move(new_list)))); } -#line 1724 "reflect.h2" +#line 1719 "reflect.h2" auto parse_context_group_state::swap(parse_context_group_state& t) & -> void{// NOLINT(performance-noexcept-swap) std::swap(cur_match_list, t.cur_match_list); std::swap(alternate_match_lists, t.alternate_match_lists); std::swap(modifiers, t.modifiers); } -#line 1731 "reflect.h2" +#line 1726 "reflect.h2" [[nodiscard]] auto parse_context_group_state::get_as_token() & -> token_ptr{ if (alternate_match_lists.empty()) { post_process_list(cur_match_list); @@ -3419,15 +3414,15 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov } } -#line 1743 "reflect.h2" +#line 1738 "reflect.h2" auto parse_context_group_state::add(cpp2::impl::in token) & -> void{ cur_match_list.push_back(token); } -#line 1748 "reflect.h2" +#line 1743 "reflect.h2" [[nodiscard]] auto parse_context_group_state::empty() const& -> bool { return cur_match_list.empty(); } -#line 1752 "reflect.h2" +#line 1747 "reflect.h2" auto parse_context_group_state::post_process_list(token_vec& list) -> void{ // Merge all characters auto merge_pos {list.begin()}; @@ -3448,7 +3443,7 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov , modifiers{ modifiers_ }{} parse_context_group_state::parse_context_group_state(){} -#line 1778 "reflect.h2" +#line 1773 "reflect.h2" [[nodiscard]] auto parse_context_branch_reset_state::next() & -> int{ auto g {cur_group}; cur_group += 1; @@ -3457,20 +3452,20 @@ parse_context_group_state::parse_context_group_state(){} return g; } -#line 1787 "reflect.h2" +#line 1782 "reflect.h2" auto parse_context_branch_reset_state::set_next(cpp2::impl::in g) & -> void{ cur_group = g; max_group = max(max_group, g); } -#line 1793 "reflect.h2" +#line 1788 "reflect.h2" auto parse_context_branch_reset_state::next_alternative() & -> void{ if (is_active) { cur_group = from; } } -#line 1800 "reflect.h2" +#line 1795 "reflect.h2" auto parse_context_branch_reset_state::set_active_reset(cpp2::impl::in restart) & -> void{ is_active = true; cur_group = restart; @@ -3485,16 +3480,16 @@ parse_context_group_state::parse_context_group_state(){} , from{ from_ }{} parse_context_branch_reset_state::parse_context_branch_reset_state(){} -#line 1828 "reflect.h2" +#line 1823 "reflect.h2" parse_context::parse_context(cpp2::impl::in r, auto const& e) : regex{ r } , root{ CPP2_UFCS_TEMPLATE_NONLOCAL(cpp2_new)(cpp2::shared, "") } , error_out{ e }{ -#line 1832 "reflect.h2" +#line 1827 "reflect.h2" } -#line 1838 "reflect.h2" +#line 1833 "reflect.h2" [[nodiscard]] auto parse_context::start_group() & -> parse_context_group_state { parse_context_group_state old_state {}; @@ -3504,7 +3499,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return old_state; } -#line 1848 "reflect.h2" +#line 1843 "reflect.h2" [[nodiscard]] auto parse_context::end_group(cpp2::impl::in old_state) & -> token_ptr { auto inner {cur_group_state.get_as_token()}; @@ -3512,17 +3507,17 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return inner; } -#line 1855 "reflect.h2" +#line 1850 "reflect.h2" [[nodiscard]] auto parse_context::get_modifiers() const& -> expression_flags{ return cur_group_state.modifiers; } -#line 1859 "reflect.h2" +#line 1854 "reflect.h2" auto parse_context::set_modifiers(cpp2::impl::in mod) & -> void{ cur_group_state.modifiers = mod; } -#line 1866 "reflect.h2" +#line 1861 "reflect.h2" [[nodiscard]] auto parse_context::branch_reset_new_state() & -> parse_context_branch_reset_state { parse_context_branch_reset_state old_state {}; @@ -3532,7 +3527,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return old_state; } -#line 1875 "reflect.h2" +#line 1870 "reflect.h2" auto parse_context::branch_reset_restore_state(cpp2::impl::in old_state) & -> void { auto max_group {cur_branch_reset_state.max_group}; @@ -3540,24 +3535,24 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} cur_branch_reset_state.set_next(cpp2::move(max_group)); } -#line 1882 "reflect.h2" +#line 1877 "reflect.h2" auto parse_context::next_alternative() & -> void { cur_group_state.next_alternative(); cur_branch_reset_state.next_alternative(); } -#line 1890 "reflect.h2" +#line 1885 "reflect.h2" auto parse_context::add_token(cpp2::impl::in token) & -> void{ cur_group_state.add(token); } -#line 1894 "reflect.h2" +#line 1889 "reflect.h2" [[nodiscard]] auto parse_context::has_token() const& -> bool{ return !(cur_group_state.empty()); } -#line 1898 "reflect.h2" +#line 1893 "reflect.h2" [[nodiscard]] auto parse_context::pop_token() & -> token_ptr { token_ptr r {nullptr}; @@ -3569,22 +3564,22 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return r; } -#line 1909 "reflect.h2" +#line 1904 "reflect.h2" [[nodiscard]] auto parse_context::get_as_token() & -> token_ptr{ return root; } -#line 1915 "reflect.h2" +#line 1910 "reflect.h2" [[nodiscard]] auto parse_context::get_cur_group() const& -> int{ return cur_branch_reset_state.cur_group; } -#line 1919 "reflect.h2" +#line 1914 "reflect.h2" [[nodiscard]] auto parse_context::next_group() & -> int{ return cur_branch_reset_state.next(); } -#line 1923 "reflect.h2" +#line 1918 "reflect.h2" auto parse_context::set_named_group(cpp2::impl::in name, cpp2::impl::in id) & -> void { if (!(named_groups.contains(name))) {// Redefinition of group name is not an error. The left most one is retained. @@ -3592,7 +3587,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 1930 "reflect.h2" +#line 1925 "reflect.h2" [[nodiscard]] auto parse_context::get_named_group(cpp2::impl::in name) const& -> int { auto iter {named_groups.find(name)}; @@ -3604,10 +3599,10 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 1943 "reflect.h2" +#line 1938 "reflect.h2" [[nodiscard]] auto parse_context::current() const& -> char{return CPP2_ASSERT_IN_BOUNDS(regex, pos); } -#line 1946 "reflect.h2" +#line 1941 "reflect.h2" [[nodiscard]] auto parse_context::get_next_position(cpp2::impl::in in_class, cpp2::impl::in no_skip) const& -> size_t { auto perl_syntax {false}; @@ -3647,7 +3642,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return cur; } -#line 1986 "reflect.h2" +#line 1981 "reflect.h2" [[nodiscard]] auto parse_context::next_impl(cpp2::impl::in in_class, cpp2::impl::in no_skip) & -> bool { pos = get_next_position(in_class, no_skip); @@ -3659,14 +3654,14 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 1997 "reflect.h2" +#line 1992 "reflect.h2" [[nodiscard]] auto parse_context::next() & -> decltype(auto) { return next_impl(false, false); } -#line 1998 "reflect.h2" +#line 1993 "reflect.h2" [[nodiscard]] auto parse_context::next_in_class() & -> decltype(auto) { return next_impl(true, false); } -#line 1999 "reflect.h2" +#line 1994 "reflect.h2" [[nodiscard]] auto parse_context::next_no_skip() & -> decltype(auto) { return next_impl(false, true); } -#line 2001 "reflect.h2" +#line 1996 "reflect.h2" [[nodiscard]] auto parse_context::next_n(cpp2::impl::in n) & -> bool{ auto r {true}; auto cur {0}; @@ -3676,10 +3671,10 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return r; } -#line 2010 "reflect.h2" +#line 2005 "reflect.h2" [[nodiscard]] auto parse_context::has_next() const& -> bool{return cpp2::impl::cmp_less(pos,regex.size()); } -#line 2012 "reflect.h2" +#line 2007 "reflect.h2" [[nodiscard]] auto parse_context::grab_until_impl(cpp2::impl::in e, cpp2::impl::out r, cpp2::impl::in any) & -> bool { auto end {pos}; // NOLINT(clang-analyzer-deadcode.DeadStores) @@ -3701,14 +3696,14 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2033 "reflect.h2" +#line 2028 "reflect.h2" [[nodiscard]] auto parse_context::grab_until(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto) { return grab_until_impl(e, cpp2::impl::out(&r), false); } -#line 2034 "reflect.h2" +#line 2029 "reflect.h2" [[nodiscard]] auto parse_context::grab_until(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto) { return grab_until_impl(std::string(1, e), cpp2::impl::out(&r), false); } -#line 2035 "reflect.h2" +#line 2030 "reflect.h2" [[nodiscard]] auto parse_context::grab_until_one_of(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto) { return grab_until_impl(e, cpp2::impl::out(&r), true); } -#line 2037 "reflect.h2" +#line 2032 "reflect.h2" [[nodiscard]] auto parse_context::grab_n(cpp2::impl::in n, cpp2::impl::out r) & -> bool { if (cpp2::impl::cmp_less_eq(pos + cpp2::impl::as_(n),regex.size())) { @@ -3722,7 +3717,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2050 "reflect.h2" +#line 2045 "reflect.h2" [[nodiscard]] auto parse_context::grab_number() & -> std::string { auto start {pos}; @@ -3744,7 +3739,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return cpp2::move(r.value()); } -#line 2071 "reflect.h2" +#line 2066 "reflect.h2" [[nodiscard]] auto parse_context::peek_impl(cpp2::impl::in in_class) const& -> char{ auto next_pos {get_next_position(in_class, false)}; if (cpp2::impl::cmp_less(next_pos,regex.size())) { @@ -3755,12 +3750,12 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2081 "reflect.h2" +#line 2076 "reflect.h2" [[nodiscard]] auto parse_context::peek() const& -> decltype(auto) { return peek_impl(false); } -#line 2082 "reflect.h2" +#line 2077 "reflect.h2" [[nodiscard]] auto parse_context::peek_in_class() const& -> decltype(auto) { return peek_impl(true); } -#line 2087 "reflect.h2" +#line 2082 "reflect.h2" [[nodiscard]] auto parse_context::parser_group_modifiers(cpp2::impl::in change_str, expression_flags& parser_modifiers) & -> bool { auto is_negative {false}; @@ -3815,7 +3810,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return true; } -#line 2141 "reflect.h2" +#line 2136 "reflect.h2" [[nodiscard]] auto parse_context::parse_until(cpp2::impl::in term) & -> bool{ token_ptr cur_token {}; @@ -3854,7 +3849,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return true; } -#line 2179 "reflect.h2" +#line 2174 "reflect.h2" [[nodiscard]] auto parse_context::parse(cpp2::impl::in modifiers) & -> bool { @@ -3870,21 +3865,21 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return r; } -#line 2196 "reflect.h2" +#line 2191 "reflect.h2" [[nodiscard]] auto parse_context::get_pos() const& -> decltype(auto) { return pos; } -#line 2197 "reflect.h2" +#line 2192 "reflect.h2" [[nodiscard]] auto parse_context::get_range(cpp2::impl::in start, cpp2::impl::in end) const& -> decltype(auto) { return std::string(regex.substr(start, end - start + 1)); } -#line 2198 "reflect.h2" +#line 2193 "reflect.h2" [[nodiscard]] auto parse_context::valid() const& -> bool{return has_next() && !(has_error); } -#line 2200 "reflect.h2" +#line 2195 "reflect.h2" [[nodiscard]] auto parse_context::error(cpp2::impl::in err) & -> token_ptr{ has_error = true; error_out("Error during parsing of regex '" + cpp2::to_string(regex) + "' at position '" + cpp2::to_string(pos) + "': " + cpp2::to_string(err) + ""); return nullptr; } -#line 2215 "reflect.h2" +#line 2210 "reflect.h2" auto generation_function_context::add_tabs(cpp2::impl::in c) & -> void{ int i {0}; for( ; cpp2::impl::cmp_less(i,c); i += 1 ) { @@ -3892,7 +3887,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2222 "reflect.h2" +#line 2217 "reflect.h2" auto generation_function_context::remove_tabs(cpp2::impl::in c) & -> void{ tabs = tabs.substr(0, (cpp2::impl::as_(c)) * 2); } @@ -3902,22 +3897,22 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} , tabs{ tabs_ }{} generation_function_context::generation_function_context(){} -#line 2240 "reflect.h2" +#line 2235 "reflect.h2" [[nodiscard]] auto generation_context::match_parameters() const& -> std::string{return "r.pos, ctx"; } -#line 2245 "reflect.h2" +#line 2240 "reflect.h2" auto generation_context::add(cpp2::impl::in s) & -> void{ auto cur {get_current()}; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + cpp2::to_string(s) + "\n"; } -#line 2251 "reflect.h2" +#line 2246 "reflect.h2" auto generation_context::add_check(cpp2::impl::in check) & -> void{ auto cur {get_current()}; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + "if !cpp2::regex::" + cpp2::to_string(check) + " { r.matched = false; break; }\n"; } -#line 2257 "reflect.h2" +#line 2252 "reflect.h2" auto generation_context::add_statefull(cpp2::impl::in next_func, cpp2::impl::in check) & -> void { end_func_statefull(check); @@ -3926,7 +3921,7 @@ generation_function_context::generation_function_context(){} start_func_named(cpp2::move(name)); } -#line 2265 "reflect.h2" +#line 2260 "reflect.h2" auto generation_context::start_func_named(cpp2::impl::in name) & -> void { auto cur {new_context()}; @@ -3938,7 +3933,7 @@ generation_function_context::generation_function_context(){} (*cpp2::impl::assert_not_null(cpp2::move(cur))).add_tabs(3); } -#line 2276 "reflect.h2" +#line 2271 "reflect.h2" [[nodiscard]] auto generation_context::start_func() & -> std::string { auto name {gen_func_name()}; @@ -3946,7 +3941,7 @@ generation_function_context::generation_function_context(){} return cpp2::move(name) + "()"; } -#line 2283 "reflect.h2" +#line 2278 "reflect.h2" auto generation_context::end_func_statefull(cpp2::impl::in s) & -> void { auto cur {get_current()}; @@ -3966,7 +3961,7 @@ generation_function_context::generation_function_context(){} finish_context(); } -#line 2303 "reflect.h2" +#line 2298 "reflect.h2" [[nodiscard]] auto generation_context::generate_func(cpp2::impl::in token) & -> std::string { auto name {start_func()}; @@ -3976,7 +3971,7 @@ generation_function_context::generation_function_context(){} return name; } -#line 2313 "reflect.h2" +#line 2308 "reflect.h2" [[nodiscard]] auto generation_context::generate_reset(cpp2::impl::in> groups) & -> std::string { if (groups.empty()) { @@ -3999,33 +3994,33 @@ generation_function_context::generation_function_context(){} return cpp2::move(name) + "()"; } -#line 2337 "reflect.h2" +#line 2332 "reflect.h2" [[nodiscard]] auto generation_context::gen_func_name() & -> std::string{ auto cur_id {matcher_func}; matcher_func += 1; return "func_" + cpp2::to_string(cpp2::move(cur_id)) + ""; } -#line 2343 "reflect.h2" +#line 2338 "reflect.h2" [[nodiscard]] auto generation_context::next_func_name() & -> std::string{ return gen_func_name() + "()"; } -#line 2347 "reflect.h2" +#line 2342 "reflect.h2" [[nodiscard]] auto generation_context::gen_reset_func_name() & -> std::string{ auto cur_id {reset_func}; reset_func += 1; return "reset_" + cpp2::to_string(cpp2::move(cur_id)) + ""; } -#line 2353 "reflect.h2" +#line 2348 "reflect.h2" [[nodiscard]] auto generation_context::gen_temp() & -> std::string{ auto cur_id {temp_name}; temp_name += 1; return "tmp_" + cpp2::to_string(cpp2::move(cur_id)) + ""; } -#line 2361 "reflect.h2" +#line 2356 "reflect.h2" [[nodiscard]] auto generation_context::new_context() & -> generation_function_context*{ gen_stack.push_back(generation_function_context()); auto cur {get_current()}; @@ -4034,7 +4029,7 @@ generation_function_context::generation_function_context(){} return cur; } -#line 2369 "reflect.h2" +#line 2364 "reflect.h2" auto generation_context::finish_context() & -> void{ auto cur {get_current()}; auto base {get_base()}; @@ -4043,22 +4038,22 @@ generation_function_context::generation_function_context(){} gen_stack.pop_back(); } -#line 2379 "reflect.h2" +#line 2374 "reflect.h2" [[nodiscard]] auto generation_context::get_current() & -> generation_function_context*{ return &gen_stack.back(); } -#line 2383 "reflect.h2" +#line 2378 "reflect.h2" [[nodiscard]] auto generation_context::get_base() & -> generation_function_context*{ return &CPP2_ASSERT_IN_BOUNDS_LITERAL(gen_stack, 0); } -#line 2387 "reflect.h2" +#line 2382 "reflect.h2" [[nodiscard]] auto generation_context::get_entry_func() const& -> std::string{ return entry_func; } -#line 2391 "reflect.h2" +#line 2386 "reflect.h2" [[nodiscard]] auto generation_context::create_named_group_lookup(cpp2::impl::in> named_groups) const& -> std::string { std::string res {"get_named_group_index: (name) -> int = {\n"}; @@ -4082,18 +4077,18 @@ generation_function_context::generation_function_context(){} return res; } -#line 2416 "reflect.h2" +#line 2411 "reflect.h2" [[nodiscard]] auto generation_context::run(cpp2::impl::in token) & -> std::string{ entry_func = generate_func(token); return (*cpp2::impl::assert_not_null(get_base())).code; } -#line 2431 "reflect.h2" +#line 2426 "reflect.h2" alternative_token::alternative_token() : regex_token_empty{ "" }{} -#line 2433 "reflect.h2" +#line 2428 "reflect.h2" [[nodiscard]] auto alternative_token::parse(parse_context& ctx) -> token_ptr{ if (ctx.current() != '|') {return nullptr; } @@ -4104,15 +4099,15 @@ generation_function_context::generation_function_context(){} alternative_token::~alternative_token() noexcept{} -#line 2448 "reflect.h2" +#line 2443 "reflect.h2" alternative_token_gen::alternative_token_gen(cpp2::impl::in a) : regex_token{ gen_string(a) } , alternatives{ a }{ -#line 2451 "reflect.h2" +#line 2446 "reflect.h2" } -#line 2453 "reflect.h2" +#line 2448 "reflect.h2" auto alternative_token_gen::generate_code(generation_context& ctx) const -> void { std::string functions {""}; @@ -4130,7 +4125,7 @@ generation_function_context::generation_function_context(){} ctx.add_statefull(next_name, "cpp2::regex::alternative_token_matcher::match(" + cpp2::to_string(ctx.match_parameters()) + ", other, " + cpp2::to_string(next_name) + " " + cpp2::to_string(cpp2::move(functions)) + ")"); } -#line 2470 "reflect.h2" +#line 2465 "reflect.h2" auto alternative_token_gen::add_groups(std::set& groups) const -> void { for ( auto const& cur : alternatives ) { @@ -4138,7 +4133,7 @@ generation_function_context::generation_function_context(){} } } -#line 2477 "reflect.h2" +#line 2472 "reflect.h2" [[nodiscard]] auto alternative_token_gen::gen_string(cpp2::impl::in a) -> std::string { std::string r {""}; @@ -4154,14 +4149,14 @@ generation_function_context::generation_function_context(){} alternative_token_gen::~alternative_token_gen() noexcept{} -#line 2498 "reflect.h2" +#line 2493 "reflect.h2" any_token::any_token(cpp2::impl::in single_line) : regex_token_check{ ".", "any_token_matcher" }{ -#line 2500 "reflect.h2" +#line 2495 "reflect.h2" } -#line 2502 "reflect.h2" +#line 2497 "reflect.h2" [[nodiscard]] auto any_token::parse(parse_context& ctx) -> token_ptr{ if ('.' != ctx.current()) {return nullptr; } @@ -4170,21 +4165,21 @@ generation_function_context::generation_function_context(){} any_token::~any_token() noexcept{} -#line 2519 "reflect.h2" +#line 2514 "reflect.h2" char_token::char_token(cpp2::impl::in t, cpp2::impl::in ignore_case_) : regex_token{ std::string(1, t) } , token{ t } , ignore_case{ ignore_case_ }{ -#line 2523 "reflect.h2" +#line 2518 "reflect.h2" } -#line 2525 "reflect.h2" +#line 2520 "reflect.h2" [[nodiscard]] auto char_token::parse(parse_context& ctx) -> token_ptr{ return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, ctx.current(), ctx.get_modifiers().has(expression_flags::case_insensitive)); } -#line 2529 "reflect.h2" +#line 2524 "reflect.h2" auto char_token::generate_code(generation_context& ctx) const -> void { if (ignore_case) { @@ -4193,14 +4188,14 @@ generation_function_context::generation_function_context(){} { size_t i{0}; -#line 2535 "reflect.h2" +#line 2530 "reflect.h2" for( ; cpp2::impl::cmp_less(i,token.size()); i += 1 ) { CPP2_ASSERT_IN_BOUNDS(lower, i) = string_util::safe_tolower(CPP2_ASSERT_IN_BOUNDS(token, i)); CPP2_ASSERT_IN_BOUNDS(upper, i) = string_util::safe_toupper(CPP2_ASSERT_IN_BOUNDS(token, i)); } } -#line 2540 "reflect.h2" +#line 2535 "reflect.h2" if (upper != lower) { gen_case_insensitive(cpp2::move(lower), cpp2::move(upper), ctx); } @@ -4213,7 +4208,7 @@ size_t i{0}; } } -#line 2552 "reflect.h2" +#line 2547 "reflect.h2" auto char_token::gen_case_insensitive(cpp2::impl::in lower, cpp2::impl::in upper, generation_context& ctx) const& -> void { std::string name {"str_" + cpp2::to_string(ctx.gen_temp()) + ""}; @@ -4235,7 +4230,7 @@ size_t i{0}; ctx.add("else { break; }"); } -#line 2573 "reflect.h2" +#line 2568 "reflect.h2" auto char_token::gen_case_sensitive(generation_context& ctx) const& -> void { std::string name {"str_" + cpp2::to_string(ctx.gen_temp()) + ""}; @@ -4254,7 +4249,7 @@ size_t i{0}; ctx.add("else { break; }"); } -#line 2591 "reflect.h2" +#line 2586 "reflect.h2" [[nodiscard]] auto char_token::add_escapes(std::string str) const& -> std::string { str = string_util::replace_all(str, "\\", "\\\\"); @@ -4270,7 +4265,7 @@ size_t i{0}; return cpp2::move(str); } -#line 2606 "reflect.h2" +#line 2601 "reflect.h2" auto char_token::append(char_token const& that) & -> void{ (*this).token += that.token; (*this).string_rep += that.string_rep; @@ -4278,19 +4273,19 @@ size_t i{0}; char_token::~char_token() noexcept{} -#line 2623 "reflect.h2" +#line 2618 "reflect.h2" class_token::class_token(cpp2::impl::in negate_, cpp2::impl::in case_insensitive_, cpp2::impl::in class_str_, cpp2::impl::in str) : regex_token{ str } , negate{ negate_ } , case_insensitive{ case_insensitive_ } , class_str{ class_str_ } -#line 2624 "reflect.h2" +#line 2619 "reflect.h2" { -#line 2629 "reflect.h2" +#line 2624 "reflect.h2" } -#line 2632 "reflect.h2" +#line 2627 "reflect.h2" [[nodiscard]] auto class_token::parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '[') {return nullptr; } @@ -4416,13 +4411,13 @@ size_t i{0}; ); } -#line 2757 "reflect.h2" +#line 2752 "reflect.h2" auto class_token::generate_code(generation_context& ctx) const -> void { ctx.add_check("class_token_matcher::match(" + cpp2::to_string(ctx.match_parameters()) + ")"); } -#line 2762 "reflect.h2" +#line 2757 "reflect.h2" [[nodiscard]] auto class_token::create_matcher(cpp2::impl::in name, cpp2::impl::in template_arguments) -> std::string { auto sep {", "}; @@ -4433,12 +4428,12 @@ size_t i{0}; class_token::~class_token() noexcept{} -#line 2774 "reflect.h2" +#line 2769 "reflect.h2" [[nodiscard]] auto escape_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '\\') {return nullptr; } -#line 2779 "reflect.h2" +#line 2774 "reflect.h2" if (std::string::npos == std::string("afenrt^.[]()*{}?+|\\").find(ctx.peek())) { return nullptr; } @@ -4472,7 +4467,7 @@ size_t i{0}; } -#line 2815 "reflect.h2" +#line 2810 "reflect.h2" [[nodiscard]] auto global_group_reset_token_parse(parse_context& ctx) -> token_ptr { if (!((ctx.current() == '\\' && ctx.peek() == 'K'))) {return nullptr; } @@ -4481,18 +4476,18 @@ size_t i{0}; return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, "\\K", "ctx..set_group_start(0, r.pos);"); } -#line 2837 "reflect.h2" +#line 2832 "reflect.h2" group_ref_token::group_ref_token(cpp2::impl::in id_, cpp2::impl::in case_insensitive_, cpp2::impl::in str) : regex_token{ str } , id{ id_ } , case_insensitive{ case_insensitive_ } -#line 2838 "reflect.h2" +#line 2833 "reflect.h2" { -#line 2842 "reflect.h2" +#line 2837 "reflect.h2" } -#line 2844 "reflect.h2" +#line 2839 "reflect.h2" [[nodiscard]] auto group_ref_token::parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '\\') {return nullptr; } @@ -4594,14 +4589,14 @@ size_t i{0}; return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, cpp2::move(group_id), ctx.get_modifiers().has(expression_flags::case_insensitive), cpp2::move(str)); } -#line 2945 "reflect.h2" +#line 2940 "reflect.h2" auto group_ref_token::generate_code(generation_context& ctx) const -> void{ ctx.add_check("group_ref_token_matcher(" + cpp2::to_string(ctx.match_parameters()) + ")"); } group_ref_token::~group_ref_token() noexcept{} -#line 2968 "reflect.h2" +#line 2963 "reflect.h2" [[nodiscard]] auto group_token::parse_lookahead(parse_context& ctx, cpp2::impl::in syntax, cpp2::impl::in positive) -> token_ptr { static_cast(ctx.next());// Skip last token defining the syntax @@ -4616,7 +4611,7 @@ size_t i{0}; return r; } -#line 2982 "reflect.h2" +#line 2977 "reflect.h2" [[nodiscard]] auto group_token::parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '(') {return nullptr; } @@ -4754,7 +4749,7 @@ size_t i{0}; } } -#line 3119 "reflect.h2" +#line 3114 "reflect.h2" [[nodiscard]] auto group_token::gen_string(cpp2::impl::in name, cpp2::impl::in name_brackets, cpp2::impl::in has_modifier, cpp2::impl::in modifiers, cpp2::impl::in inner_) -> std::string { std::string start {"("}; @@ -4773,7 +4768,7 @@ size_t i{0}; return cpp2::move(start) + (*cpp2::impl::assert_not_null(inner_)).to_string() + ")"; } -#line 3137 "reflect.h2" +#line 3132 "reflect.h2" auto group_token::generate_code(generation_context& ctx) const -> void { if (-1 != number) { @@ -4794,7 +4789,7 @@ size_t i{0}; } } -#line 3157 "reflect.h2" +#line 3152 "reflect.h2" auto group_token::add_groups(std::set& groups) const -> void { (*cpp2::impl::assert_not_null(inner)).add_groups(groups); @@ -4805,7 +4800,7 @@ size_t i{0}; group_token::~group_token() noexcept{} -#line 3169 "reflect.h2" +#line 3164 "reflect.h2" [[nodiscard]] auto hexadecimal_token_parse(parse_context& ctx) -> token_ptr { if (!((ctx.current() == '\\' && ctx.peek() == 'x'))) {return nullptr; } @@ -4844,7 +4839,7 @@ size_t i{0}; return r; } -#line 3210 "reflect.h2" +#line 3205 "reflect.h2" [[nodiscard]] auto line_end_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() == '$' || (ctx.current() == '\\' && ctx.peek() == '$')) { @@ -4862,7 +4857,7 @@ size_t i{0}; }} } -#line 3230 "reflect.h2" +#line 3225 "reflect.h2" [[nodiscard]] auto line_start_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '^' && !((ctx.current() == '\\' && ctx.peek() == 'A'))) {return nullptr; } @@ -4876,29 +4871,29 @@ size_t i{0}; } } -#line 3255 "reflect.h2" +#line 3250 "reflect.h2" lookahead_token::lookahead_token(cpp2::impl::in positive_) : regex_token{ "" } , positive{ positive_ }{ -#line 3257 "reflect.h2" +#line 3252 "reflect.h2" } -#line 3259 "reflect.h2" +#line 3254 "reflect.h2" auto lookahead_token::generate_code(generation_context& ctx) const -> void{ auto inner_name {ctx.generate_func(inner)}; ctx.add_check("lookahead_token_matcher(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ")"); } -#line 3265 "reflect.h2" +#line 3260 "reflect.h2" auto lookahead_token::add_groups(std::set& groups) const -> void{ (*cpp2::impl::assert_not_null(inner)).add_groups(groups); } lookahead_token::~lookahead_token() noexcept{} -#line 3273 "reflect.h2" +#line 3268 "reflect.h2" [[nodiscard]] auto named_class_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '\\') {return nullptr; } @@ -4924,7 +4919,7 @@ size_t i{0}; return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, "\\" + cpp2::to_string(ctx.current()) + "", "" + cpp2::to_string(cpp2::move(name)) + "::match"); } -#line 3301 "reflect.h2" +#line 3296 "reflect.h2" [[nodiscard]] auto octal_token_parse(parse_context& ctx) -> token_ptr { if (!((ctx.current() == '\\' && ctx.peek() == 'o'))) {return nullptr; } @@ -4950,11 +4945,11 @@ size_t i{0}; return r; } -#line 3338 "reflect.h2" +#line 3333 "reflect.h2" range_token::range_token() : regex_token{ "" }{} -#line 3340 "reflect.h2" +#line 3335 "reflect.h2" [[nodiscard]] auto range_token::parse(parse_context& ctx) -> token_ptr { auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared)}; @@ -5028,7 +5023,7 @@ size_t i{0}; return nullptr; } -#line 3413 "reflect.h2" +#line 3408 "reflect.h2" auto range_token::parse_modifier(parse_context& ctx) & -> void { if (ctx.peek() == '?') { @@ -5041,7 +5036,7 @@ size_t i{0}; }} } -#line 3425 "reflect.h2" +#line 3420 "reflect.h2" [[nodiscard]] auto range_token::gen_mod_string() const& -> std::string { if (kind == range_flags::not_greedy) { @@ -5055,7 +5050,7 @@ size_t i{0}; }} } -#line 3438 "reflect.h2" +#line 3433 "reflect.h2" [[nodiscard]] auto range_token::gen_range_string() const& -> std::string { std::string r {""}; @@ -5075,7 +5070,7 @@ size_t i{0}; return r; } -#line 3457 "reflect.h2" +#line 3452 "reflect.h2" auto range_token::generate_code(generation_context& ctx) const -> void { auto inner_name {ctx.generate_func(inner_token)}; @@ -5087,14 +5082,14 @@ size_t i{0}; ctx.add_statefull(next_name, "cpp2::regex::range_token_matcher::match(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ", " + cpp2::to_string(cpp2::move(reset_name)) + ", other, " + cpp2::to_string(next_name) + ")"); } -#line 3468 "reflect.h2" +#line 3463 "reflect.h2" auto range_token::add_groups(std::set& groups) const -> void{ (*cpp2::impl::assert_not_null(inner_token)).add_groups(groups); } range_token::~range_token() noexcept{} -#line 3481 "reflect.h2" +#line 3476 "reflect.h2" [[nodiscard]] auto special_range_token::parse(parse_context& ctx) -> token_ptr { auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared)}; @@ -5118,7 +5113,7 @@ size_t i{0}; if (!(ctx.has_token())) {return ctx.error("'" + cpp2::to_string(ctx.current()) + "' without previous element."); } -#line 3505 "reflect.h2" +#line 3500 "reflect.h2" (*cpp2::impl::assert_not_null(r)).parse_modifier(ctx); (*cpp2::impl::assert_not_null(r)).inner_token = ctx.pop_token(); @@ -5128,7 +5123,7 @@ size_t i{0}; special_range_token::~special_range_token() noexcept{} -#line 3518 "reflect.h2" +#line 3513 "reflect.h2" [[nodiscard]] auto word_boundary_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '\\') {return nullptr; } @@ -5146,15 +5141,15 @@ size_t i{0}; }} } -#line 3554 "reflect.h2" +#line 3549 "reflect.h2" template regex_generator::regex_generator(cpp2::impl::in r, Error_out const& e) : regex{ r } , error_out{ e }{ -#line 3557 "reflect.h2" +#line 3552 "reflect.h2" } -#line 3559 "reflect.h2" +#line 3554 "reflect.h2" template [[nodiscard]] auto regex_generator::parse() & -> std::string { // Extract modifiers and adapt regex. @@ -5190,7 +5185,7 @@ size_t i{0}; return source; } -#line 3594 "reflect.h2" +#line 3589 "reflect.h2" template auto regex_generator::extract_modifiers() & -> void { if (regex.find_first_of("'/") == 0) { @@ -5206,7 +5201,7 @@ size_t i{0}; } } -#line 3610 "reflect.h2" +#line 3605 "reflect.h2" template [[nodiscard]] auto generate_regex(cpp2::impl::in regex, Err const& err) -> std::string { regex_generator parser {regex, err}; @@ -5215,7 +5210,7 @@ template [[nodiscard]] auto generate_regex(cpp2::impl::in void { auto has_default {false}; @@ -5270,7 +5265,7 @@ auto regex_gen(meta::type_declaration& t) -> void CPP2_UFCS(add_runtime_support_include)(t, "cpp2regex.h"); } -#line 3679 "reflect.h2" +#line 3674 "reflect.h2" [[nodiscard]] auto apply_metafunctions( declaration_node& n, type_declaration& rtype, @@ -5382,7 +5377,7 @@ auto regex_gen(meta::type_declaration& t) -> void return true; } -#line 3791 "reflect.h2" +#line 3786 "reflect.h2" } } diff --git a/source/reflect.h2 b/source/reflect.h2 index 734fa728a9..8c99c06adb 100644 --- a/source/reflect.h2 +++ b/source/reflect.h2 @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== diff --git a/source/sema.h b/source/sema.h index f3d8ac63f1..424261a69b 100644 --- a/source/sema.h +++ b/source/sema.h @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== diff --git a/source/to_cpp1.h b/source/to_cpp1.h index 3e08d83e6d..73b904ecba 100644 --- a/source/to_cpp1.h +++ b/source/to_cpp1.h @@ -1,14 +1,9 @@ -// 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. +// Copyright 2022-2024 Herb Sutter +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information. //=========================================================================== From 8bb2dbd97190a473177dbc618ada9fa0174863f1 Mon Sep 17 00:00:00 2001 From: Herb Sutter Date: Thu, 10 Oct 2024 15:50:10 -0700 Subject: [PATCH 2/4] Tweak formatting --- regression-tests/test-results/version | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/regression-tests/test-results/version b/regression-tests/test-results/version index d580164395..419132af78 100644 --- a/regression-tests/test-results/version +++ b/regression-tests/test-results/version @@ -1,5 +1,4 @@ -cppfront compiler v0.8.0 Build 9A10:1540 -Copyright 2022-2024 Herb Sutter - -SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +cppfront compiler v0.8.0 Build 9A10:1540 +SPDX-License-Identifier Apache-2.0 WITH LLVM-exception +Copyright (c) 2022-2024 Herb Sutter From 4f737a1ac5f6ca5956d00e6983ccca069e17b314 Mon Sep 17 00:00:00 2001 From: Herb Sutter Date: Sun, 20 Oct 2024 16:08:36 -0700 Subject: [PATCH 3/4] Update LICENSE --- LICENSE | 63 ++++++++++++++++++++------------------------------------- 1 file changed, 22 insertions(+), 41 deletions(-) diff --git a/LICENSE b/LICENSE index f9ada7be27..e582264d18 100644 --- a/LICENSE +++ b/LICENSE @@ -15,17 +15,15 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception limitations under the License. -============================================================================== -The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: -============================================================================== +Cppfront is under the Apache License v2.0 with LLVM Exception: Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - 1. Definitions. + 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. @@ -84,14 +82,14 @@ The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: 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 + 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 + 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, @@ -107,7 +105,7 @@ The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: 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 + 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: @@ -148,7 +146,7 @@ The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. - 5. Submission of Contributions. Unless You explicitly state otherwise, + 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. @@ -156,12 +154,12 @@ The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: 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 + 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 + 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 @@ -171,7 +169,7 @@ The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: 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, + 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 @@ -183,7 +181,7 @@ The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: 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 + 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 @@ -194,9 +192,9 @@ The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. - END OF TERMS AND CONDITIONS + END OF TERMS AND CONDITIONS - APPENDIX: How to apply the Apache License to your work. + 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 "[]" @@ -207,20 +205,19 @@ The Cppfront Project is under the Apache License v2.0 with LLVM Exceptions: same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright [yyyy] [name of copyright owner] + 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 + 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. - + 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 ---- @@ -237,19 +234,3 @@ 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. - -============================================================================== -Software from third parties included in the Cppfront Project: -============================================================================== - -The Cppfront Project does not currently contain third party software that -is under different license terms. If such code is added in the future, -all such code will be identified clearly using at least one of two -mechanisms: - -1) It will be in a separate directory tree with its own `LICENSE.txt` or - `LICENSE` file at the top containing the specific license and restrictions - which apply to that software, or - -2) It will contain specific license and restriction terms at the top of every - file. From e2ae2672919604b6aef88727100b48fab47afa8c Mon Sep 17 00:00:00 2001 From: Herb Sutter Date: Sun, 20 Oct 2024 16:53:29 -0700 Subject: [PATCH 4/4] Add new CLA --- CONTRIBUTING.md | 13 +++++++------ docs/Cppfront CLA 2024-10 - sample.pdf | Bin 0 -> 169145 bytes 2 files changed, 7 insertions(+), 6 deletions(-) create mode 100644 docs/Cppfront CLA 2024-10 - sample.pdf diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d27b74165e..386cba3c5a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,9 +1,10 @@ -This is the contributor license agreement. If you are looking for the usage license, see here: [usage license](https://github.com/hsutter/cppfront/blob/main/LICENSE) +## Contributing -## cppfront Contributor License Agreement +This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant the rights to use your contribution. A sample of the CLA is below. -By contributing content to cppfront (i.e., submitting a pull request for inclusion in this repository): -- You warrant that your material is original, or you have the right to contribute it. -- With respect to the material that you own, you grant a worldwide, non-exclusive, irrevocable, transferable, and royalty-free license to your contributed material to Herb Sutter to display, reproduce, perform, distribute, and create derivative works of that material for commercial or non-commercial use. -- With respect to any other material you contribute, such material must be under a worldwide, non-exclusive, irrevocable, transferable, and royalty-free license sufficient to allow Herb Sutter to display, reproduce, perform, distribute, and create derivative works of that material for commercial or non-commercial use. +When you submit a pull request, a CLA bot or human will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided. You will only need to do this once for all your contributions to cppfront. + +## Cppfront Contribution License Agreement (Sample) + +A sample can be found here: [Cppfront CLA 2024-10 - sample.pdf](docs/Cppfront CLA 2024-10 - sample.pdf) diff --git a/docs/Cppfront CLA 2024-10 - sample.pdf b/docs/Cppfront CLA 2024-10 - sample.pdf new file mode 100644 index 0000000000000000000000000000000000000000..85f8a4cb6019f8c901bfe6dbb5d6ce4f5f189dfe GIT binary patch literal 169145 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
OfHFk4$cRR934rL8f|QBS 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