Migrate to percy::variant

Author: jansvoboda11

CMakeLists.txt

@@ -1,8 +1,73 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(percy)
+project(Percy)
 
 set(CMAKE_CXX_STANDARD 20)
 
-add_subdirectory(example)
-add_subdirectory(tests)
+add_library(Percy INTERFACE)
+
+option(PERCY_BUILD_EXAMPLE "Build example project build with Percy." OFF)
+option(PERCY_BUILD_TESTS "Build tests of Percy." OFF)
+option(PERCY_RUNTIME_TESTS "Evaluate tests of Percy at run-time instead of compile-time." OFF)
+
+include(cmake/PercyVariant.cmake)
+
+target_link_libraries(Percy INTERFACE Percy::Variant)
+
+target_include_directories(
+  Percy
+  INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+set(PERCY_CMAKE_CONFIG_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Percy")
+
+include(CMakePackageConfigHelpers)
+
+configure_package_config_file(
+  ${CMAKE_CURRENT_LIST_DIR}/cmake/PercyConfig.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/PercyConfig.cmake
+  INSTALL_DESTINATION
+  ${PERCY_CMAKE_CONFIG_DESTINATION}
+)
+
+install(
+  TARGETS
+    Percy
+  EXPORT
+    PercyTargets
+  DESTINATION
+    ${CMAKE_INSTALL_LIBDIR}
+)
+
+install(
+  EXPORT
+    PercyTargets
+  NAMESPACE
+    Percy::
+  DESTINATION
+    ${PERCY_CMAKE_CONFIG_DESTINATION}
+)
+
+install(
+  DIRECTORY
+    "include/"
+  DESTINATION
+    "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+install(
+  FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/PercyConfig.cmake"
+  DESTINATION
+    ${PERCY_CMAKE_CONFIG_DESTINATION}
+)
+
+if(${PERCY_BUILD_EXAMPLE} STREQUAL ON)
+  add_subdirectory(example)
+endif()
+
+if(${PERCY_BUILD_TESTS} STREQUAL ON)
+  add_subdirectory(tests)
+endif()

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Jan Svoboda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

README.md

@@ -0,0 +1,8 @@
+# Percy
+
+Percy is an ergonomic parser combinator library written in `constexpr` C++20.
+
+## TODO
+
+- [ ] Mark tests in `test_all.cpp` and the example as `constexpr` when possible.
+- [ ] Properly manage memory in the example.

cmake/Catch2.cmake

@@ -0,0 +1,8 @@
+include(FetchContent)
+
+FetchContent_Declare(Catch2
+  GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+  GIT_TAG v2.11.3
+)
+
+FetchContent_MakeAvailable(Catch2)

cmake/PercyConfig.cmake.in

@@ -0,0 +1,3 @@
+@PACKAGE_INIT@
+
+include(${CMAKE_CURRENT_LIST_DIR}/PercyTargets.cmake)

example/CMakeLists.txt

@@ -1,7 +1,9 @@
-include_directories(${percy_SOURCE_DIR}/include/ include/)
-
 file(READ input.txt CODE)
 
 add_definitions(-DINPUT_CODE="${CODE}")
 
+include_directories(include/)
+
 add_executable(example src/example.cpp)
+
+target_link_libraries(example Percy)

example/include/example/ast.hpp

@@ -1,47 +1,34 @@
 #ifndef PERCY_EXAMPLE_AST
 #define PERCY_EXAMPLE_AST
 
-#include <variant>
-
-#include <cstdint>
+#include <percy/variant.hpp>
 
 namespace example::ast {
 struct expr;
 
 struct literal {
-  constexpr explicit literal(std::uint8_t val) : val(val) {}
-  std::uint8_t val;
+  constexpr explicit literal(char value) : value_(value) {}
+  char value_;
 };
 
 struct variable {
-  constexpr explicit variable(char name) : name(name) {}
-  char name;
+  constexpr explicit variable(char name) : name_(name) {}
+  char name_;
 };
 
 struct call {
   constexpr explicit call(char name, const expr* arg1, const expr* arg2) : name_(name), arg1_(arg1), arg2_(arg2) {}
   char name_;
   const expr* arg1_;
   const expr* arg2_;
-  constexpr ~call();
 };
 
 struct expr {
-  constexpr explicit expr(literal value) : value(value) {}
-  constexpr explicit expr(variable value) : value(value) {}
-  constexpr explicit expr(call value) : value(value) {}
-  std::variant<literal, variable, call> value;
+  constexpr explicit expr(literal l) : value_(l) {}
+  constexpr explicit expr(variable v) : value_(v) {}
+  constexpr explicit expr(call c) : value_(c) {}
+  percy::variant<literal, variable, call> value_;
 };
-
-constexpr call::~call() {
-  if (arg1_) {
-    delete arg1_;
-  }
-
-  if (arg2_) {
-    delete arg2_;
-  }
-}
 } // namespace example::ast
 
 #endif

example/include/example/grammar.hpp

@@ -37,8 +37,8 @@ struct call {
 struct expr {
   using rule = percy::one_of<call, literal, variable>;
 
-  constexpr static auto action(percy::result<std::variant<ast::call, ast::literal, ast::variable>> parsed) {
-    return std::visit([](auto item) { return new ast::expr(item); }, parsed.get());
+  constexpr static auto action(percy::result<percy::variant<ast::call, ast::literal, ast::variable>> parsed) {
+    return percy::visit([](auto item) { return new ast::expr(item); }, parsed.get());
   }
 };
 

example/src/example.cpp

@@ -5,10 +5,9 @@
 int main() {
   using parser = percy::parser<example::grammar::grammar>;
 
-  constexpr auto exit_code = [](){
+  auto exit_code = [](){
     auto input = percy::static_input(INPUT_CODE);
     auto result = parser::parse(input);
-    delete result.get();
     return result.is_success() ? 0 : 1;
   }();
 

include/percy.hpp

@@ -6,6 +6,5 @@
 #include "percy/rules.hpp"
 #include "percy/static_input.hpp"
 #include "percy/type_traits.hpp"
-#include "percy/variant.hpp"
 
 #endif

include/percy/parser.hpp

@@ -4,9 +4,10 @@
 #include "result.hpp"
 #include "rules.hpp"
 
+#include <percy/variant.hpp>
+
 #include <string_view>
 #include <tuple>
-#include <variant>
 #include <vector>
 
 namespace percy {
@@ -178,7 +179,7 @@ struct parser<either<Rule, AlternativeRule, AlternativeRules...>> {
 
 template <typename Rule>
 struct parser<one_of<Rule>> {
-  using result_type = result<std::variant<result_value_t<parser_result_t<Rule>>>>;
+  using result_type = result<percy::variant<result_value_t<parser_result_t<Rule>>>>;
 
   template <typename Input>
   constexpr static result_type parse(Input input) {
@@ -197,17 +198,17 @@ struct parser<one_of<Rule>> {
 template <typename Rule, typename AlternativeRule, typename... AlternativeRules>
 struct parser<one_of<Rule, AlternativeRule, AlternativeRules...>> {
   // clang-format off
-  using result_type = result<std::variant<result_value_t<parser_result_t<Rule>>,
-                                          result_value_t<parser_result_t<AlternativeRule>>,
-                                          result_value_t<parser_result_t<AlternativeRules>>...>>;
+  using result_type = result<percy::variant<result_value_t<parser_result_t<Rule>>,
+                                            result_value_t<parser_result_t<AlternativeRule>>,
+                                            result_value_t<parser_result_t<AlternativeRules>>...>>;
   // clang-format on
 
   template <typename Input>
   constexpr static result_type parse(Input input) {
     using variant_type = result_value_t<result_type>;
 
     auto cast_variant = [](auto small_variant) {
-      return std::visit([](auto item) { return variant_type(item); }, small_variant);
+      return percy::visit([](auto item) { return variant_type(item); }, small_variant);
     };
 
     auto result = parser<one_of<Rule>>::parse(input);

include/percy/result.hpp

@@ -1,7 +1,7 @@
 #ifndef PERCY_RESULT
 #define PERCY_RESULT
 
-#include <variant>
+#include <percy/variant.hpp>
 
 namespace percy {
 class input_span {
@@ -35,7 +35,7 @@ class error {};
 
 template <typename T>
 class result {
-  std::variant<T, error> value_;
+  percy::variant<T, error> value_;
   input_span span_;
 
   template <typename U>
@@ -51,11 +51,11 @@ class result {
   constexpr result(const failure& fail) : value_(error()), span_(fail.span()) {}
 
   constexpr bool is_success() const {
-    return std::holds_alternative<T>(value_);
+    return percy::holds_alternative<T>(value_);
   }
 
   constexpr bool is_failure() const {
-    return std::holds_alternative<error>(value_);
+    return percy::holds_alternative<error>(value_);
   }
 
   constexpr operator bool() const {
@@ -75,7 +75,7 @@ class result {
   }
 
   constexpr auto get() const {
-    return std::get<T>(value_);
+    return percy::get<T>(value_);
   }
 };
 

include/percy/type_traits.hpp

@@ -96,7 +96,7 @@ struct contains<U, T, Ts...> {
 
 /// Determines whether the list `Ts...` contains the type `U`.
 template <typename U, typename... Ts>
-constexpr inline bool contains_v = contains<U, Ts...>::value;
+constexpr inline bool has_same_v = contains<U, Ts...>::value;
 
 template <std::size_t N, typename... Ts>
 struct nth;