tools

optparser.hpp (8292B)

---

 // Copyright (c) 2020 Morel Bérenger
 // 
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 // 
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 // 
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would be
 //    appreciated but is not required.
 // 2. Altered source versions must be plainly marked as such, and must not be
 //    misrepresented as being the original software.
 // 3. This notice may not be removed or altered from any source distribution.
 
 // this file contains the definitions of structures and
 // functions to parse command-line options, with some C++
 // helpers (because templates rocks and C does not have
 // them).
 // C++ *should not* be required to use the core
 // functionnality, but actual C uses have not been tested:
 // you've been warned.
 // Other functions are planned to parse data from sources
 // different than argv, like getenv() or a configuration
 // file.
 // That's still on the TODO-list, though.
 
 #ifndef OPTPARSER_HPP
 #define OPTPARSER_HPP
 
 #include <stdbool.h>
 #include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #else
 #define nullptr 0
 #endif
 
 #define STD_HELP { "help", "shows this message", 'h', 0, nullptr, nullptr, nullptr }
 
 //TODO I wish this could be avoided, but FILE* is used there.
 #include <stdio.h>
 
 // this could probably be optimized, but considering it should not be used that
 // often, I think it's better to just keep it as easy to use as possible.
 // Some doc:
 // * option: long name of the option, what people should use for readable shell
 //           code, but won't in direct calls, because it's faster to use a
 //           possible shorter version.
 //           On cmd line, prefixed with "--" and folowed by a "=" if option is
 //           not a flag. For example, the "foo" option's value would be set on
 //           cmd line with "--foo=value".
 //           Must be a null-byte terminated UTF-8 string.
 //           Character '=' is reserved and must not be used.
 // * short_opt: character used as the short name. Short names are prefixed with
 //              "-" and directly followed by the value to affect to the option,
 //              for example: "-fvalue".
 // * description: how the program should show describe the option to people that
 //                don't read the docs (hint: most of us). Default values should
 //                not be repeated in that text.
 //                Must be a null-byte terminated UTF-8 string.
 // * value: a pointer to the variable to set, if applicable. If nullptr,
 //          occurrences will be counted.
 // * set: how to set value given an UTF-8 null-terminated string.
 // * show: how to render the current value. Should be used by an "help" option.
 // * count: how many times the option was found. Can be used for various things,
 //          like exiting if --version, -v, --help or -h were found, or if a
 //          mandatory option is missing.
 //          If the option appears too often, the count will stop incrementing.
 // TODO: implement a way to know which arguments were ignored (no match found)
 // TODO: implement the "--" option to mean end of options (and return it's index?)
 struct opt_desc_t
 {
 	char const* option;
 	char const* description;
 	uint32_t short_option;
 	uint32_t count;
 	void* value;
 	bool (*set) ( void* val, char * arg );
 	bool (*show)( void const* val, FILE_PTR target );
 };
 
 //see parse_error_msgs in implementation for descriptions
 enum parse_error_t
 {
 	NONE,
 	IGNORED,
 	MAX_COUNT,
 	SET_NO_VAL,
 	SET_VAL_IGN,
 	SET_FAIL,
 	BAD_ARGS,
 	BAD_SETTER,
 };
 
 extern char const *parse_error_msgs[];
 #define arg_warning( arg, err ) fprintf( stderr, "Warning: in arg \"%s\" => %s(error code: %04x)\n", \
 		arg, parse_error_msgs[err], err )
 #define arg_error( arg, err ) fprintf( stderr, "Error: in arg \"%s\" => %s(error code: %04x)\n", \
 		arg, parse_error_msgs[err], err )
 
 // checks if a string is a command-line argument and processes it if yes
 // return true if the argument was ignored, false if it was successfully
 // processed.
 // Range of checked options is: [start,end)
 parse_error_t parse_cmd_opt( char* arg, opt_desc_t* start, opt_desc_t const* end );
 
 // prints a message describing options and their current value if applicable.
 void print_opts( FILE_PTR target, opt_desc_t const* start, opt_desc_t const* end );
 
 #ifdef __cplusplus
 } //end of extern "C"
 
 // add some pretty generic and useful code for C++ users.
 // C users will have to implement their owns wrappers (and maybe contribute it?).
 //
 // This list is wished to grow with time, but should never depend on things that
 // have runtime cost (containers, exceptions, RTTI, etc).
 // It is hoped that it's performance will be improved when possible.
 
 // Depending on what you really use, you may have to define the following functions:
 // * strncpy   for static C string set()
 // * fputs     for C string show()
 // * strtoull  for unsigned integers show()
 // * strtoll   for signed integets show()
 // * strtold   for floating numbers show()
 // * fprintf   for all number related show()
 
 // stdio.h is *not* included, to fasten build time and to let user use
 // unlocked functions, which should be faster but not thread-safe.
 
 #include <type_traits>
 #include <limits>
 
 #include "utils.hpp"
 
 // C "semi-static" strings in pointer
 template <typename T>
 bool set(
 		typename std::enable_if <std::is_same<char const**,T>::value, void*>::type val,
 		char* arg )
 {
 	if( !val )
 	{
 		return true;
 	}
 
 	*static_cast<char const**>( val ) = arg;
 	return false;
 }
 
 // C strings in statically allocated buffer
 template <typename T, size_t SZ>
 bool set(
 		typename std::enable_if <std::is_same<char*,T>::value, void*>::type val,
 		char* arg )
 {
 	if( !val )
 	{
 		return true;
 	}
 
 	strncpy( static_cast<char*>( val ), arg, SZ - 1);
 	static_cast<char*>( val )[SZ-1] = 0;
 	return false;
 }
 
 template <typename T>
 bool show(
 		typename std::enable_if <std::is_same<char*,T>::value, void const*>::type val,
 		FILE* target )
 {
 	if( !val )
 	{
 		return true;
 	}
 
 	fputs( "(current value: \"", target );
 	char const* current = *static_cast<char *const*>( val );
 	current = current ? current : "";
 	esc_fputs( current, target );
 	fputs( "\")", target );
 	return false;
 }
 
 // signed integrals
 template <typename T>
 bool set(
 		typename std::enable_if
 		<
 			std::is_integral<T>::value && std::is_signed<T>::value,
 			void*
 		>::type val, char* arg )
 {
 	if( !val )
 	{
 		return true;
 	}
 
 	char* end;
 	auto v = strtoll( arg, &end, 0 );
 	if( false
 			|| errno
 			|| 0 != *end
 			|| std::numeric_limits<T>::min() > v
 			|| std::numeric_limits<T>::max() < v )
 	{
 		return true;
 	}
 	*static_cast<T*>( val ) = static_cast<T>( v );
 	return false;
 }
 
 template <typename T>
 bool show(
 		typename std::enable_if
 		<
 			std::is_integral<T>::value && std::is_signed<T>::value,
 			void const*
 		>::type val, FILE* target )
 {
 	if( !val )
 	{
 		return true;
 	}
 
 	fprintf( target, "(current value: %d)", *static_cast<T const*>( val ) );
 	return false;
 }
 
 // unsigned integrals
 template <typename T>
 bool set(
 		typename std::enable_if
 		<
 			std::is_integral<T>::value && std::is_unsigned<T>::value,
 			void*
 		>::type val, char* arg )
 {
 	if( !val )
 	{
 		return true;
 	}
 
 	char* end;
 	auto v = strtoull( arg, &end, 0 );
 	if( false
 			|| errno
 			|| 0 != *end
 			|| std::numeric_limits<T>::min() > v
 			|| std::numeric_limits<T>::max() < v )
 	{
 		return true;
 	}
 	*static_cast<T*>( val ) = static_cast<T>( v );
 	return false;
 }
 
 // floating numbers
 template <typename T>
 bool set(
 		typename std::enable_if
 		<
 			std::is_floating_point<T>::value,
 			void*
 		>::type val, char* arg )
 {
 	if( !val )
 	{
 		return true;
 	}
 
 	char* end;
 	auto v = strtold( arg, &end );
 	if( false
 			|| errno
 			|| 0 != *end
 			|| std::numeric_limits<T>::min() > v
 			|| std::numeric_limits<T>::max() < v )
 	{
 		return true;
 	}
 	*static_cast<T*>( val ) = static_cast<T>( v );
 	return false;
 }
 
 #endif
 
 #endif