222 lines
8.8 KiB
C++
222 lines
8.8 KiB
C++
/* Arg_parser - POSIX/GNU command-line argument parser. (C++ version)
|
|
Copyright (C) 2006-2026 Antonio Diaz Diaz.
|
|
|
|
This program is free software: you have unlimited permission to
|
|
copy, distribute, and modify it.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
/*
|
|
Exit status: 0 for a normal exit, 1 for environmental problems
|
|
(file not found, invalid command-line options, I/O errors, etc), 2 to
|
|
indicate a corrupt or invalid input file, 3 for an internal consistency
|
|
error (e.g., bug) which caused arg_parser to panic.
|
|
*/
|
|
|
|
#include <climits>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "arg_parser.h"
|
|
|
|
namespace {
|
|
|
|
const char * const program_name = "arg_parser";
|
|
const char * const program_year = "2026";
|
|
const char * invocation_name = program_name; // default value
|
|
unsigned verbosity = 0;
|
|
enum { opt_lo = 256 };
|
|
|
|
|
|
void show_help()
|
|
{
|
|
std::fputs(
|
|
"Arg_parser - POSIX/GNU command-line argument parser. (C++ version)\n"
|
|
"\nArg_parser is an argument parser that follows POSIX and GNU conventions for\n"
|
|
"command-line arguments. There exist C++ and C versions of Arg_parser. The\n"
|
|
"C++ version is implemented as a C++ class, while the C version is\n"
|
|
"implemented as a single struct plus associated functions. Both are simpler,\n"
|
|
"easier to use, and safer than 'getopt_long'.\n"
|
|
"\nFor maximum stability, Arg_parser is self-contained. It extracts all the\n"
|
|
"information it needs from its arguments to avoid referring to them later.\n"
|
|
"This avoids index-out-of-bounds errors and allows the parser object to be\n"
|
|
"passed as argument to other functions for further analysis.\n"
|
|
"\nArg_parser does not modify its arguments (argc, argv), nor uses any global\n"
|
|
"variables.\n"
|
|
"\nThe C++ version of Arg_parser can also parse options from configuration\n"
|
|
"files.\n"
|
|
"\nThe C++ version of Arg_parser is provided in the files 'arg_parser.h' and\n"
|
|
"'arg_parser.cc'. To learn how to use Arg_parser in your C++ programs, see\n"
|
|
"the C++ example in the manual and the example file 'main.cc' in the source\n"
|
|
"tarball.\n", stdout );
|
|
std::printf( "\nUsage: %s [options]\n", invocation_name );
|
|
std::fputs( "\nOptions:\n"
|
|
" -h, --help display this help and exit\n"
|
|
" -V, --version output version information and exit\n"
|
|
" -a, --append example of option with no argument\n"
|
|
" -b, --block=<arg> example of option with required argument\n"
|
|
" -c, --casual[=<arg>] example of option with optional argument\n"
|
|
" -e, --empty=<arg> example of option with maybe empty argument\n"
|
|
" -o <arg> example of short only option\n"
|
|
" --long-only example of long only option\n"
|
|
" -q, --quiet quiet operation\n"
|
|
" -u, --uncaught example of intentional bug\n"
|
|
" -v, --verbose verbose operation\n", stdout );
|
|
if( verbosity ) std::fputs(
|
|
" -H, --hidden example of hidden option (shown with -v -h)\n", stdout );
|
|
std::fputs(
|
|
"\nReport bugs to arg-parser-bug@nongnu.org\n"
|
|
"Arg_parser home page: http://www.nongnu.org/arg-parser/arg_parser.html\n", stdout );
|
|
}
|
|
|
|
|
|
void show_version()
|
|
{
|
|
std::printf( "%s %s\n", program_name, PROGVERSION );
|
|
std::printf( "Copyright (C) %s Antonio Diaz Diaz.\n", program_year );
|
|
std::fputs( "License 2-clause BSD.\n"
|
|
"This is free software: you are free to change and redistribute it.\n"
|
|
"There is NO WARRANTY, to the extent permitted by law.\n", stdout );
|
|
}
|
|
|
|
|
|
void show_error( const char * const msg, const int errcode = 0,
|
|
const bool help = false )
|
|
{
|
|
if( msg && msg[0] )
|
|
std::fprintf( stderr, "%s: %s%s%s\n", program_name, msg,
|
|
( errcode > 0 ) ? ": " : "",
|
|
( errcode > 0 ) ? std::strerror( errcode ) : "" );
|
|
if( help )
|
|
std::fprintf( stderr, "Try '%s --help' for more information.\n",
|
|
invocation_name );
|
|
}
|
|
|
|
|
|
void internal_error( const char * const msg )
|
|
{
|
|
std::fprintf( stderr, "%s: internal error: %s\n", program_name, msg );
|
|
std::exit( 3 );
|
|
}
|
|
|
|
|
|
void print_opt( const char * const arg, const char * const option_name,
|
|
const int code )
|
|
{
|
|
std::printf( "option '%s'", option_name );
|
|
if( arg[0] || code == 'e' ) std::printf( " with argument '%s'", arg );
|
|
if( code == INT_MIN || code == INT_MAX ) std::printf( " (code 0x%X)", code );
|
|
std::fputc( '\n', stdout );
|
|
}
|
|
|
|
|
|
bool process_options( const Arg_parser & parser )
|
|
{
|
|
verbosity = 0;
|
|
for( int argind = 0; argind < parser.arguments(); ++argind )
|
|
{
|
|
const int code = parser.code( argind );
|
|
const char * const pn = parser.parsed_name( argind ).c_str();
|
|
const char * const arg = parser.argument( argind ).c_str();
|
|
switch( code )
|
|
{
|
|
case 0: std::printf( "non-option argument '%s'\n", arg ); break;
|
|
case '.': case '0': case '1': case '2': case '3': case '4': case '5':
|
|
case '6': case '7': case '8': case '9': case 'a': case 'b': case 'c':
|
|
case 'e': print_opt( arg, pn, code ); break;
|
|
case 'h': show_help(); return false;
|
|
case 'H': case 'i': case 'I':
|
|
case 'o': print_opt( arg, pn, code ); break;
|
|
case 'q': print_opt( arg, pn, code ); verbosity = 0; break;
|
|
// case 'u': break; // intentionally not caught
|
|
case 'v': print_opt( arg, pn, code ); ++verbosity; break;
|
|
case 'V': show_version(); return false;
|
|
case opt_lo:
|
|
case INT_MIN: case INT_MAX: print_opt( arg, pn, code ); break;
|
|
default: internal_error( "uncaught option." );
|
|
}
|
|
} // end process arguments
|
|
return true;
|
|
}
|
|
|
|
} // end namespace
|
|
|
|
|
|
int main( const int argc, const char * const argv[] )
|
|
{
|
|
if( argc > 0 ) invocation_name = argv[0];
|
|
|
|
const Arg_parser::Option options[] =
|
|
{
|
|
// code, long_name, has_arg (no/yes/maybe/yesme)
|
|
{ '.', 0, Arg_parser::maybe },
|
|
{ '0', 0, Arg_parser::maybe },
|
|
{ '1', 0, Arg_parser::maybe },
|
|
{ '2', 0, Arg_parser::maybe },
|
|
{ '3', 0, Arg_parser::maybe },
|
|
{ '4', 0, Arg_parser::maybe },
|
|
{ '5', 0, Arg_parser::maybe },
|
|
{ '6', 0, Arg_parser::maybe },
|
|
{ '7', 0, Arg_parser::maybe },
|
|
{ '8', 0, Arg_parser::maybe },
|
|
{ '9', 0, Arg_parser::maybe },
|
|
{ 'a', "append", Arg_parser::no },
|
|
{ 'b', "block", Arg_parser::yes },
|
|
{ 'c', "casual", Arg_parser::maybe },
|
|
{ 'e', "empty", Arg_parser::yesme },
|
|
{ 'h', "help", Arg_parser::no },
|
|
{ 'H', "hidden", Arg_parser::no },
|
|
{ 'i', 0, Arg_parser::maybe },
|
|
{ 'I', 0, Arg_parser::maybe },
|
|
{ 'o', 0, Arg_parser::yes },
|
|
{ 'q', "quiet", Arg_parser::no },
|
|
{ 'u', "uncaught", Arg_parser::no },
|
|
{ 'v', "verbose", Arg_parser::no },
|
|
{ 'V', "version", Arg_parser::no },
|
|
{ opt_lo, "long-only", Arg_parser::no },
|
|
{ INT_MIN, "int-min", Arg_parser::no },
|
|
{ INT_MAX, "int-max", Arg_parser::no },
|
|
{ 0, 0, Arg_parser::no } };
|
|
|
|
{
|
|
const Arg_parser parser( argc, argv, options );
|
|
if( parser.error().size() ) // bad option
|
|
{ show_error( parser.error().c_str(), 0, true ); return 1; }
|
|
if( !process_options( parser ) ) return 0;
|
|
std::fputs( !parser.arguments() ?
|
|
"No arguments!\n" : "(options reordered)\n", stdout );
|
|
if( verbosity ) std::fputc( '\n', stdout ); else return 0;
|
|
}
|
|
{
|
|
const Arg_parser parser( argc, argv, options, Arg_parser::neg_non_opt );
|
|
if( parser.error().size() ) // bad option
|
|
{ show_error( parser.error().c_str(), 0, true ); return 1; }
|
|
process_options( parser );
|
|
std::fputs( "(options reordered"
|
|
" and negative numbers treated as non-options)\n", stdout );
|
|
if( verbosity == 1 ) return 0;
|
|
}
|
|
|
|
for( int flags = 1; flags < 16; ++flags )
|
|
{
|
|
if( flags == Arg_parser::neg_non_opt ) continue; // done above
|
|
std::fputc( '\n', stdout );
|
|
const Arg_parser parser( argc, argv, options, flags );
|
|
if( parser.error().size() ) // bad option
|
|
{ show_error( parser.error().c_str(), 0, true ); return 1; }
|
|
process_options( parser );
|
|
for( int i = parser.argv_index(); i < argc; ++i )
|
|
std::printf( "skipped non-option argument '%s'\n", argv[i] );
|
|
std::printf( "(0%s%s%s%s)\n",
|
|
(flags & parser.in_order) ? " | in_order" : "",
|
|
(flags & parser.in_order_stop) ? " | in_order_stop" : "",
|
|
(flags & parser.in_order_skip) ? " | in_order_skip" : "",
|
|
(flags & parser.neg_non_opt) ? " | neg_non_opt" : "" );
|
|
}
|
|
return 0;
|
|
}
|