Read-only mirrors. Development, issues and pull requests are on GitHub.

summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
authorMartin Hořeňovský2020-08-08 18:18:27 +0200
committerMartin Hořeňovský2020-08-10 20:30:40 +0200
commit24b83edf8aca78c975c5589baf22a5de311498a7 (patch)
tree5cd3db00515c33105d433f61fab46719d8c27d3c
parentb824d06844ab3faf4ddffa036a0ea7ef0eec117b (diff)
downloadcatch3-24b83edf8aca78c975c5589baf22a5de311498a7.tar.gz
Clara cleanups
* Clara is now split between a header and a cpp file. * Removed the deprecated `+` and `+=` operators for composing a parser. * Renamed `clara` and `detail` namespaces to be inline with the rest of Catch2 (they are now `Clara` and `Detail` respectively). * Taken most of user-exposed types out of the `Detail` namespace completely (instead of using `using` directives to bring them into the outer namespace).
-rw-r--r--src/CMakeLists.txt2
-rw-r--r--src/catch2/catch_all.hpp1
-rw-r--r--src/catch2/catch_session.cpp6
-rw-r--r--src/catch2/catch_session.hpp6
-rw-r--r--src/catch2/internal/catch_clara.cpp428
-rw-r--r--src/catch2/internal/catch_clara.hpp670
-rw-r--r--src/catch2/internal/catch_clara_upstream.hpp924
-rw-r--r--src/catch2/internal/catch_commandline.cpp8
-rw-r--r--src/catch2/internal/catch_commandline.hpp2
9 files changed, 1080 insertions, 967 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 5165d37d..de7010be 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -44,7 +44,6 @@ set(INTERNAL_HEADERS
${SOURCES_DIR}/catch_assertion_result.hpp
${SOURCES_DIR}/internal/catch_test_macro_impl.hpp
${SOURCES_DIR}/internal/catch_clara.hpp
- ${SOURCES_DIR}/internal/catch_clara_upstream.hpp
${SOURCES_DIR}/internal/catch_commandline.hpp
${SOURCES_DIR}/internal/catch_common.hpp
${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
@@ -138,6 +137,7 @@ set(IMPL_SOURCES
${SOURCES_DIR}/internal/catch_assertion_handler.cpp
${SOURCES_DIR}/catch_assertion_result.cpp
${SOURCES_DIR}/matchers/internal/catch_matchers_combined_tu.cpp
+ ${SOURCES_DIR}/internal/catch_clara.cpp
${SOURCES_DIR}/internal/catch_commandline.cpp
${SOURCES_DIR}/internal/catch_common.cpp
${SOURCES_DIR}/catch_config.cpp
diff --git a/src/catch2/catch_all.hpp b/src/catch2/catch_all.hpp
index 508f38db..a6448229 100644
--- a/src/catch2/catch_all.hpp
+++ b/src/catch2/catch_all.hpp
@@ -40,7 +40,6 @@
#include <catch2/interfaces/catch_interfaces_all.hpp>
#include <catch2/internal/catch_assertion_handler.hpp>
#include <catch2/internal/catch_clara.hpp>
-#include <catch2/internal/catch_clara_upstream.hpp>
#include <catch2/internal/catch_commandline.hpp>
#include <catch2/internal/catch_common.hpp>
#include <catch2/internal/catch_compiler_capabilities.hpp>
diff --git a/src/catch2/catch_session.cpp b/src/catch2/catch_session.cpp
index d163aaf8..e64299f3 100644
--- a/src/catch2/catch_session.cpp
+++ b/src/catch2/catch_session.cpp
@@ -176,7 +176,7 @@ namespace Catch {
if( m_startupExceptions )
return 1;
- auto result = m_cli.parse( clara::Args( argc, argv ) );
+ auto result = m_cli.parse( Clara::Args( argc, argv ) );
if( !result ) {
config();
getCurrentMutableContext().setConfig(m_config.get());
@@ -239,10 +239,10 @@ namespace Catch {
return exitCode;
}
- clara::Parser const& Session::cli() const {
+ Clara::Parser const& Session::cli() const {
return m_cli;
}
- void Session::cli( clara::Parser const& newParser ) {
+ void Session::cli( Clara::Parser const& newParser ) {
m_cli = newParser;
}
ConfigData& Session::configData() {
diff --git a/src/catch2/catch_session.hpp b/src/catch2/catch_session.hpp
index 8d646382..6c560c63 100644
--- a/src/catch2/catch_session.hpp
+++ b/src/catch2/catch_session.hpp
@@ -42,14 +42,14 @@ namespace Catch {
int run();
- clara::Parser const& cli() const;
- void cli( clara::Parser const& newParser );
+ Clara::Parser const& cli() const;
+ void cli( Clara::Parser const& newParser );
ConfigData& configData();
Config& config();
private:
int runInternal();
- clara::Parser m_cli;
+ Clara::Parser m_cli;
ConfigData m_configData;
Detail::unique_ptr<Config> m_config;
bool m_startupExceptions = false;
diff --git a/src/catch2/internal/catch_clara.cpp b/src/catch2/internal/catch_clara.cpp
new file mode 100644
index 00000000..1c03b641
--- /dev/null
+++ b/src/catch2/internal/catch_clara.cpp
@@ -0,0 +1,428 @@
+#include <algorithm>
+#include <catch2/internal/catch_clara.hpp>
+#include <catch2/internal/catch_console_width.hpp>
+#include <catch2/internal/catch_platform.hpp>
+#include <catch2/internal/catch_string_manip.hpp>
+#include <catch2/internal/catch_textflow.hpp>
+
+namespace {
+ bool isOptPrefix( char c ) {
+ return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+ || c == '/'
+#endif
+ ;
+ }
+
+ std::string normaliseOpt( std::string const& optName ) {
+#ifdef CATCH_PLATFORM_WINDOWS
+ if ( optName[0] == '/' )
+ return "-" + optName.substr( 1 );
+ else
+#endif
+ return optName;
+ }
+
+} // namespace
+
+namespace Catch {
+ namespace Clara {
+ namespace Detail {
+
+ void TokenStream::loadBuffer() {
+ m_tokenBuffer.clear();
+
+ // Skip any empty strings
+ while ( it != itEnd && it->empty() ) {
+ ++it;
+ }
+
+ if ( it != itEnd ) {
+ auto const& next = *it;
+ if ( isOptPrefix( next[0] ) ) {
+ auto delimiterPos = next.find_first_of( " :=" );
+ if ( delimiterPos != std::string::npos ) {
+ m_tokenBuffer.push_back(
+ { TokenType::Option,
+ next.substr( 0, delimiterPos ) } );
+ m_tokenBuffer.push_back(
+ { TokenType::Argument,
+ next.substr( delimiterPos + 1 ) } );
+ } else {
+ if ( next[1] != '-' && next.size() > 2 ) {
+ std::string opt = "- ";
+ for ( size_t i = 1; i < next.size(); ++i ) {
+ opt[1] = next[i];
+ m_tokenBuffer.push_back(
+ { TokenType::Option, opt } );
+ }
+ } else {
+ m_tokenBuffer.push_back(
+ { TokenType::Option, next } );
+ }
+ }
+ } else {
+ m_tokenBuffer.push_back(
+ { TokenType::Argument, next } );
+ }
+ }
+ }
+
+ TokenStream::TokenStream( Args const& args ):
+ TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+ TokenStream::TokenStream( Iterator it, Iterator itEnd ):
+ it( it ), itEnd( itEnd ) {
+ loadBuffer();
+ }
+
+ TokenStream& TokenStream::operator++() {
+ if ( m_tokenBuffer.size() >= 2 ) {
+ m_tokenBuffer.erase( m_tokenBuffer.begin() );
+ } else {
+ if ( it != itEnd )
+ ++it;
+ loadBuffer();
+ }
+ return *this;
+ }
+
+ ParserResult convertInto( std::string const& source,
+ std::string& target ) {
+ target = source;
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+
+ ParserResult convertInto( std::string const& source,
+ bool& target ) {
+ std::string srcLC = toLower( source );
+
+ if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
+ srcLC == "yes" || srcLC == "on" ) {
+ target = true;
+ } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" ||
+ srcLC == "no" || srcLC == "off" ) {
+ target = false;
+ } else {
+ return ParserResult::runtimeError(
+ "Expected a boolean value but did not recognise: '" +
+ source + "'" );
+ }
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+
+ InternalParseResult ParserBase::parse( Args const& args ) const {
+ return parse( args.exeName(), TokenStream( args ) );
+ }
+
+ ParseState::ParseState( ParseResultType type,
+ TokenStream const& remainingTokens ):
+ m_type( type ), m_remainingTokens( remainingTokens ) {}
+
+ ParserResult BoundFlagRef::setFlag( bool flag ) {
+ m_ref = flag;
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+
+ } // namespace Detail
+
+ Detail::InternalParseResult Arg::parse(std::string const&,
+ Detail::TokenStream const& tokens) const {
+ auto validationResult = validate();
+ if (!validationResult)
+ return Detail::InternalParseResult(validationResult);
+
+ auto remainingTokens = tokens;
+ auto const& token = *remainingTokens;
+ if (token.type != Detail::TokenType::Argument)
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ ParseResultType::NoMatch, remainingTokens));
+
+ assert(!m_ref->isFlag());
+ auto valueRef =
+ static_cast<Detail::BoundValueRefBase*>(m_ref.get());
+
+ auto result = valueRef->setValue(remainingTokens->token);
+ if (!result)
+ return Detail::InternalParseResult(result);
+ else
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ ParseResultType::Matched, ++remainingTokens));
+ }
+
+ Opt::Opt(bool& ref) :
+ ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
+
+ std::vector<Detail::HelpColumns> Opt::getHelpColumns() const {
+ std::ostringstream oss;
+ bool first = true;
+ for (auto const& opt : m_optNames) {
+ if (first)
+ first = false;
+ else
+ oss << ", ";
+ oss << opt;
+ }
+ if (!m_hint.empty())
+ oss << " <" << m_hint << '>';
+ return { { oss.str(), m_description } };
+ }
+
+ bool Opt::isMatch(std::string const& optToken) const {
+ auto normalisedToken = normaliseOpt(optToken);
+ for (auto const& name : m_optNames) {
+ if (normaliseOpt(name) == normalisedToken)
+ return true;
+ }
+ return false;
+ }
+
+ Detail::InternalParseResult Opt::parse(std::string const&,
+ Detail::TokenStream const& tokens) const {
+ auto validationResult = validate();
+ if (!validationResult)
+ return Detail::InternalParseResult(validationResult);
+
+ auto remainingTokens = tokens;
+ if (remainingTokens &&
+ remainingTokens->type == Detail::TokenType::Option) {
+ auto const& token = *remainingTokens;
+ if (isMatch(token.token)) {
+ if (m_ref->isFlag()) {
+ auto flagRef =
+ static_cast<Detail::BoundFlagRefBase*>(
+ m_ref.get());
+ auto result = flagRef->setFlag(true);
+ if (!result)
+ return Detail::InternalParseResult(result);
+ if (result.value() ==
+ ParseResultType::ShortCircuitAll)
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ result.value(), remainingTokens));
+ } else {
+ auto valueRef =
+ static_cast<Detail::BoundValueRefBase*>(
+ m_ref.get());
+ ++remainingTokens;
+ if (!remainingTokens)
+ return Detail::InternalParseResult::runtimeError(
+ "Expected argument following " +
+ token.token);
+ auto const& argToken = *remainingTokens;
+ if (argToken.type != Detail::TokenType::Argument)
+ return Detail::InternalParseResult::runtimeError(
+ "Expected argument following " +
+ token.token);
+ auto result = valueRef->setValue(argToken.token);
+ if (!result)
+ return Detail::InternalParseResult(result);
+ if (result.value() ==
+ ParseResultType::ShortCircuitAll)
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ result.value(), remainingTokens));
+ }
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ ParseResultType::Matched, ++remainingTokens));
+ }
+ }
+ return Detail::InternalParseResult::ok(
+ Detail::ParseState(ParseResultType::NoMatch, remainingTokens));
+ }
+
+ Detail::Result Opt::validate() const {
+ if (m_optNames.empty())
+ return Detail::Result::logicError("No options supplied to Opt");
+ for (auto const& name : m_optNames) {
+ if (name.empty())
+ return Detail::Result::logicError(
+ "Option name cannot be empty");
+#ifdef CATCH_PLATFORM_WINDOWS
+ if (name[0] != '-' && name[0] != '/')
+ return Detail::Result::logicError(
+ "Option name must begin with '-' or '/'");
+#else
+ if (name[0] != '-')
+ return Detail::Result::logicError(
+ "Option name must begin with '-'");
+#endif
+ }
+ return ParserRefImpl::validate();
+ }
+
+ ExeName::ExeName() :
+ m_name(std::make_shared<std::string>("<executable>")) {}
+
+ ExeName::ExeName(std::string& ref) : ExeName() {
+ m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
+ }
+
+ Detail::InternalParseResult
+ ExeName::parse(std::string const&,
+ Detail::TokenStream const& tokens) const {
+ return Detail::InternalParseResult::ok(
+ Detail::ParseState(ParseResultType::NoMatch, tokens));
+ }
+
+ ParserResult ExeName::set(std::string const& newName) {
+ auto lastSlash = newName.find_last_of("\\/");
+ auto filename = (lastSlash == std::string::npos)
+ ? newName
+ : newName.substr(lastSlash + 1);
+
+ *m_name = filename;
+ if (m_ref)
+ return m_ref->setValue(filename);
+ else
+ return ParserResult::ok(ParseResultType::Matched);
+ }
+
+
+
+
+ Parser& Parser::operator|=( Parser const& other ) {
+ m_options.insert( m_options.end(),
+ other.m_options.begin(),
+ other.m_options.end() );
+ m_args.insert(
+ m_args.end(), other.m_args.begin(), other.m_args.end() );
+ return *this;
+ }
+
+ std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
+ std::vector<Detail::HelpColumns> cols;
+ for ( auto const& o : m_options ) {
+ auto childCols = o.getHelpColumns();
+ cols.insert( cols.end(), childCols.begin(), childCols.end() );
+ }
+ return cols;
+ }
+
+ void Parser::writeToStream( std::ostream& os ) const {
+ if ( !m_exeName.name().empty() ) {
+ os << "usage:\n"
+ << " " << m_exeName.name() << ' ';
+ bool required = true, first = true;
+ for ( auto const& arg : m_args ) {
+ if ( first )
+ first = false;
+ else
+ os << ' ';
+ if ( arg.isOptional() && required ) {
+ os << '[';
+ required = false;
+ }
+ os << '<' << arg.hint() << '>';
+ if ( arg.cardinality() == 0 )
+ os << " ... ";
+ }
+ if ( !required )
+ os << ']';
+ if ( !m_options.empty() )
+ os << " options";
+ os << "\n\nwhere options are:\n";
+ }
+
+ auto rows = getHelpColumns();
+ size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH;
+ size_t optWidth = 0;
+ for ( auto const& cols : rows )
+ optWidth = ( std::max )( optWidth, cols.left.size() + 2 );
+
+ optWidth = ( std::min )( optWidth, consoleWidth / 2 );
+
+ for ( auto const& cols : rows ) {
+ auto row = TextFlow::Column( cols.left )
+ .width( optWidth )
+ .indent( 2 ) +
+ TextFlow::Spacer( 4 ) +
+ TextFlow::Column( cols.right )
+ .width( consoleWidth - 7 - optWidth );
+ os << row << '\n';
+ }
+ }
+
+ Detail::Result Parser::validate() const {
+ for ( auto const& opt : m_options ) {
+ auto result = opt.validate();
+ if ( !result )
+ return result;
+ }
+ for ( auto const& arg : m_args ) {
+ auto result = arg.validate();
+ if ( !result )
+ return result;
+ }
+ return Detail::Result::ok();
+ }
+
+ Detail::InternalParseResult
+ Parser::parse( std::string const& exeName,
+ Detail::TokenStream const& tokens ) const {
+
+ struct ParserInfo {
+ ParserBase const* parser = nullptr;
+ size_t count = 0;
+ };
+ std::vector<ParserInfo> parseInfos;
+ parseInfos.reserve( m_options.size() + m_args.size() );
+ for ( auto const& opt : m_options ) {
+ parseInfos.push_back( { &opt, 0 } );
+ }
+ for ( auto const& arg : m_args ) {
+ parseInfos.push_back( { &arg, 0 } );
+ }
+
+ m_exeName.set( exeName );
+
+ auto result = Detail::InternalParseResult::ok(
+ Detail::ParseState( ParseResultType::NoMatch, tokens ) );
+ while ( result.value().remainingTokens() ) {
+ bool tokenParsed = false;
+
+ for ( auto& parseInfo : parseInfos ) {
+ if ( parseInfo.parser->cardinality() == 0 ||
+ parseInfo.count < parseInfo.parser->cardinality() ) {
+ result = parseInfo.parser->parse(
+ exeName, result.value().remainingTokens() );
+ if ( !result )
+ return result;
+ if ( result.value().type() !=
+ ParseResultType::NoMatch ) {
+ tokenParsed = true;
+ ++parseInfo.count;
+ break;
+ }
+ }
+ }
+
+ if ( result.value().type() == ParseResultType::ShortCircuitAll )
+ return result;
+ if ( !tokenParsed )
+ return Detail::InternalParseResult::runtimeError(
+ "Unrecognised token: " +
+ result.value().remainingTokens()->token );
+ }
+ // !TBD Check missing required options
+ return result;
+ }
+
+ Args::Args(int argc, char const* const* argv) :
+ m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
+
+ Args::Args(std::initializer_list<std::string> args) :
+ m_exeName(*args.begin()),
+ m_args(args.begin() + 1, args.end()) {}
+
+
+ Help::Help( bool& showHelpFlag ):
+ Opt( [&]( bool flag ) {
+ showHelpFlag = flag;
+ return ParserResult::ok( ParseResultType::ShortCircuitAll );
+ } ) {
+ static_cast<Opt&> ( *this )(
+ "display usage information" )["-?"]["-h"]["--help"]
+ .optional();
+ }
+
+ } // namespace Clara
+} // namespace Catch
diff --git a/src/catch2/internal/catch_clara.hpp b/src/catch2/internal/catch_clara.hpp
index 927813b6..f85c8e14 100644
--- a/src/catch2/internal/catch_clara.hpp
+++ b/src/catch2/internal/catch_clara.hpp
@@ -6,46 +6,656 @@
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*
*/
-#ifndef TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
-#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
+#ifndef CATCH_CLARA_HPP_INCLUDED
+#define CATCH_CLARA_HPP_INCLUDED
-#include <catch2/internal/catch_console_width.hpp>
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#if defined( __clang__ )
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wweak-vtables"
+# pragma clang diagnostic ignored "-Wshadow"
+# pragma clang diagnostic ignored "-Wdeprecated"
#endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
-
-#if defined(__clang__)
- #pragma clang diagnostic push
- #pragma clang diagnostic ignored "-Wweak-vtables"
- #pragma clang diagnostic ignored "-Wshadow"
- #pragma clang diagnostic ignored "-Wdeprecated"
+#if defined( __GNUC__ )
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-conversion"
#endif
-#if defined(__GNUC__)
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wsign-conversion"
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+# ifdef __has_include
+# if __has_include( <optional>) && __cplusplus >= 201703L
+# include <optional>
+# define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+# endif
+# endif
#endif
-#include <catch2/internal/catch_clara_upstream.hpp>
+#include <cassert>
+#include <cctype>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <vector>
-#if defined(__clang__)
- #pragma clang diagnostic pop
-#endif
+namespace Catch {
+ namespace Clara {
-#if defined(__GNUC__)
- #pragma GCC diagnostic pop
-#endif
+ class Args;
+ class Parser;
+
+ // enum of result types from a parse
+ enum class ParseResultType {
+ Matched,
+ NoMatch,
+ ShortCircuitAll,
+ ShortCircuitSame
+ };
+
+ namespace Detail {
+
+ // Traits for extracting arg and return type of lambdas (for single
+ // argument lambdas)
+ template <typename L>
+ struct UnaryLambdaTraits
+ : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+ template <typename ClassT, typename ReturnT, typename... Args>
+ struct UnaryLambdaTraits<ReturnT ( ClassT::* )( Args... ) const> {
+ static const bool isValid = false;
+ };
+
+ template <typename ClassT, typename ReturnT, typename ArgT>
+ struct UnaryLambdaTraits<ReturnT ( ClassT::* )( ArgT ) const> {
+ static const bool isValid = true;
+ using ArgType = typename std::remove_const<
+ typename std::remove_reference<ArgT>::type>::type;
+ using ReturnType = ReturnT;
+ };
+
+ class TokenStream;
+
+ // Wraps a token coming from a token stream. These may not directly
+ // correspond to strings as a single string may encode an option +
+ // its argument if the : or = form is used
+ enum class TokenType { Option, Argument };
+ struct Token {
+ TokenType type;
+ std::string token;
+ };
+
+ // Abstracts iterators into args as a stream of tokens, with option
+ // arguments uniformly handled
+ class TokenStream {
+ using Iterator = std::vector<std::string>::const_iterator;
+ Iterator it;
+ Iterator itEnd;
+ std::vector<Token> m_tokenBuffer;
+
+ void loadBuffer();
+
+ public:
+ explicit TokenStream( Args const& args );
+ TokenStream( Iterator it, Iterator itEnd );
+
+ explicit operator bool() const {
+ return !m_tokenBuffer.empty() || it != itEnd;
+ }
+
+ size_t count() const {
+ return m_tokenBuffer.size() + ( itEnd - it );
+ }
+
+ Token operator*() const {
+ assert( !m_tokenBuffer.empty() );
+ return m_tokenBuffer.front();
+ }
+
+ Token const* operator->() const {
+ assert( !m_tokenBuffer.empty() );
+ return &m_tokenBuffer.front();
+ }
+
+ TokenStream& operator++();
+ };
+
+ class ResultBase {
+ public:
+ enum Type { Ok, LogicError, RuntimeError };
+
+ protected:
+ ResultBase( Type type ): m_type( type ) {}
+ virtual ~ResultBase() = default;
+
+ virtual void enforceOk() const = 0;
+
+ Type m_type;
+ };
+
+ template <typename T> class ResultValueBase : public ResultBase {
+ public:
+ auto value() const -> T const& {
+ enforceOk();
+ return m_value;
+ }
+
+ protected:
+ ResultValueBase( Type type ): ResultBase( type ) {}
+
+ ResultValueBase( ResultValueBase const& other ):
+ ResultBase( other ) {
+ if ( m_type == ResultBase::Ok )
+ new ( &m_value ) T( other.m_value );
+ }
+
+ ResultValueBase( Type, T const& value ): ResultBase( Ok ) {
+ new ( &m_value ) T( value );
+ }
+
+ auto operator=( ResultValueBase const& other )
+ -> ResultValueBase& {
+ if ( m_type == ResultBase::Ok )
+ m_value.~T();
+ ResultBase::operator=( other );
+ if ( m_type == ResultBase::Ok )
+ new ( &m_value ) T( other.m_value );
+ return *this;
+ }
+
+ ~ResultValueBase() override {
+ if ( m_type == Ok )
+ m_value.~T();
+ }
+
+ union {
+ T m_value;
+ };
+ };
+
+ template <> class ResultValueBase<void> : public ResultBase {
+ protected:
+ using ResultBase::ResultBase;
+ };
+
+ template <typename T = void>
+ class BasicResult : public ResultValueBase<T> {
+ public:
+ template <typename U>
+ explicit BasicResult( BasicResult<U> const& other ):
+ ResultValueBase<T>( other.type() ),
+ m_errorMessage( other.errorMessage() ) {
+ assert( type() != ResultBase::Ok );
+ }
+
+ template <typename U>
+ static auto ok( U const& value ) -> BasicResult {
+ return { ResultBase::Ok, value };
+ }
+ static auto ok() -> BasicResult { return { ResultBase::Ok }; }
+ static auto logicError( std::string const& message )
+ -> BasicResult {
+ return { ResultBase::LogicError, message };
+ }
+ static auto runtimeError( std::string const& message )
+ -> BasicResult {
+ return { ResultBase::RuntimeError, message };
+ }
+
+ explicit operator bool() const {
+ return m_type == ResultBase::Ok;
+ }
+ auto type() const -> ResultBase::Type { return m_type; }
+ auto errorMessage() const -> std::string {
+ return m_errorMessage;
+ }
+
+ protected:
+ void enforceOk() const override {
+
+ // Errors shouldn't reach this point, but if they do
+ // the actual error message will be in m_errorMessage
+ assert( m_type != ResultBase::LogicError );
+ assert( m_type != ResultBase::RuntimeError );
+ if ( m_type != ResultBase::Ok )
+ std::abort();
+ }
+
+ std::string
+ m_errorMessage; // Only populated if resultType is an error
+
+ BasicResult( ResultBase::Type type,
+ std::string const& message ):
+ ResultValueBase<T>( type ), m_errorMessage( message ) {
+ assert( m_type != ResultBase::Ok );
+ }
+
+ using ResultValueBase<T>::ResultValueBase;
+ using ResultBase::m_type;
+ };
+
+ class ParseState {
+ public:
+ ParseState( ParseResultType type,
+ TokenStream const& remainingTokens );
+
+ ParseResultType type() const { return m_type; }
+ TokenStream const& remainingTokens() const {
+ return m_remainingTokens;
+ }
+
+ private:
+ ParseResultType m_type;
+ TokenStream m_remainingTokens;
+ };
+
+ using Result = BasicResult<void>;
+ using ParserResult = BasicResult<ParseResultType>;
+ using InternalParseResult = BasicResult<ParseState>;
+
+ struct HelpColumns {
+ std::string left;
+ std::string right;
+ };
+
+ template <typename T>
+ ParserResult convertInto( std::string const& source, T& target ) {
+ std::stringstream ss( source );
+ ss >> target;
+ if ( ss.fail() ) {
+ return ParserResult::runtimeError(
+ "Unable to convert '" + source +
+ "' to destination type" );
+ } else {
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+ }
+ ParserResult convertInto( std::string const& source,
+ std::string& target );
+ ParserResult convertInto( std::string const& source, bool& target );
+