shellScriptOptionParser.cpp File Reference

(v0.19-24-g0617ca1 with changes)

#include "OptionsChrono.h"
#include <limits>
#include <ratio>
#include <set>
#include <unistd.h>

Include dependency graph for shellScriptOptionParser.cpp:

Go to the source code of this file.

Classes
class	arrayOption< T >
class	mapOption< T >
class	listOption< T >

Enumerations
enum	typeModifierType { kSimple, kAsArray, kAsMap, kAsList }

Functions
template<typename T >
options::base *	fOptionFromStream (std::istream &aStream, T defaultValue, typeModifierType aAsWhat)
int	main (int argc, const char *argv[])

Enumeration Type Documentation

typeModifierType

enum typeModifierType

Enumerator
kSimple
kAsArray
kAsMap
kAsList

Definition at line 76 of file shellScriptOptionParser.cpp.

                      {
    kSimple,
    kAsArray,
    kAsMap,
    kAsList
};

Function Documentation

fOptionFromStream()

template<typename T >

options::base* fOptionFromStream	(	std::istream &	aStream,
		T	defaultValue,
		typeModifierType	aAsWhat
	)

Definition at line 83 of file shellScriptOptionParser.cpp.

                                                                                                                    {
    char shortName;
    std::string longName;
    std::string description;
 
    aStream >> shortName;
    aStream >> longName;
    aStream.ignore(std::numeric_limits<std::streamsize>::max(), ' ');
    std::getline(aStream, description);
 
    if (shortName == '-') {
        shortName = '\0';
    }
    switch (aAsWhat) {
        case kSimple:
            return new options::single<T>(shortName, longName, description, defaultValue);
        case kAsArray:
            return new arrayOption<T>(shortName, longName, description);
        case kAsMap:
            return new mapOption<T>(shortName, longName, description);
        case kAsList:
            return new listOption<T>(shortName, longName, description);
    }
    return nullptr;
}

References kAsArray, kAsList, kAsMap, and kSimple.

Referenced by main().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 110 of file shellScriptOptionParser.cpp.

                                       {
    std::string description;
    if (isatty(0) != 1) {
        while (std::cin.good()) {
            std::string line;
            if (std::cin.eof()) {
                break;
            }
            std::getline(std::cin, line);
            if (line.compare("options:") == 0) {
                break;
            }
            description += line;
            description += "\n";
        }
    }
    if (description.empty() || description == "\n") {
        std::cout << argv[0] << ": shell script option parser.\n"
                  "\treads description of options from stdandard input and writes shell\n"
                  "\tcommands that set variables to the parsed options to standard output\n"
                  "typical invocation looks like this:\n"
                  ". <(shellScriptOptionParser $\"(cd \"$(dirname \"$0\")\"; echo \"$(pwd)/$(basename \"$0\")\")\" \"$@\"<<EOF\n"
                  "description of script\n"
                  "options:\n"
                  "<options>\n"
                  "trailer:\n"
                  "trailing rest of explanation\n"
                  "EOF\n"
                  "test $? != 0 && echo exit\n"
                  ")\n"
                  "Option sytax is:\n"
                  "[export|array|map|list][positional number] type shortOpt longOpt descripton\n"
                  "\ttype may be one of 'int', 'uint', 'bool' or 'string'\n"
                  "\tfor (file)sizes the type 'size' which understands kMG.. postfixes\n"
                  "\tfor durations the type 'seconds' is provided\n"
                  "\tfor short durations the type 'milliseconds' is provided\n"
                  "\tfor very short durations the type 'microseconds' is provided\n"
                  "\tfor time stamps the type 'date' is provided with fractional seconds\n"
                  "\tfor time stamps the type 'idate' is provided with integer seconds\n"
                  "\tshortOpt is the one-letter variant, use '-' to have none\n"
                  "\tlongOpt is the long variant and the name of the shell variable\n"
                  "\tthe rest of the line is the description\n"
                  "\tif 'array' is set the option will be a shell array, which can be\n"
                  "\t  expanded with \"${longOpt[@]}\" which will produce words preserving spaces\n"
                  "\tif 'map' is set the option will be a shell array, which can be\n"
                  "\t  expanded with \"${longOpt[@]}\" which will produce words preserving spaces\n"
                  "\t  other than the 'array' variant maps have string subscripts\n"
                  "\tif 'list' is set the option will be a list, i.e. a variable with the\n"
                  "\t  values separated by spaces, i.e. values may not contain spaces\n"
                  "\tif 'export' is set the shell variable will be exported\n"
                  "\tif 'positional' is set the variable will be set as postional,\n"
                  "\t  with 'number' defining the order in the positional parameter list.\n"
                  "\tif the next line starts with 'range' the values following are added\n"
                  "\tto the allowed value range of the option, many range lines may follow!\n"
                  "\tif only two are given they denote a true range in the closed interval\n"
                  "\tif the next line starts with 'default' a default value\n"
                  "\t (the rest of line) is set\n"
                  "\tThe keyword 'minusMinusSpecialTreatment' will put the parameters\n"
                  "\tfollowing '--' into the shell variable following that keyword\n"
                  "\tThe keyword 'noPath' clears the search path for config files\n"
                  "\tThe keyword 'path' adds the (escaped) rest of the line\n"
                  "\tto the search path for config files\n"
                  "\tThe keyword 'minUnusedParameters' sets the min number of params\n"
                  "\tThe keyword 'maxUnusedParameters' sets the max number of params\n";
 
        return (1);
    }
 
    std::vector<options::base*> options;
    std::set<const options::base*> exportedOptions;
    std::string minusMinusSpecialTreatment = "";
    std::vector<std::string> searchPath({"/etc/", "~/.", "~/.config/", "./."});
 
    unsigned int minUnusedParameters = 0;
    unsigned int maxUnusedParameters = std::numeric_limits<unsigned int>::max();
    {
        options::parser throwAwayInstance("tAI1");
        std::string keyWord;
        bool exportNextOption = false;
        typeModifierType nextOptionAsWhat = kSimple;
        int nextOptionPositional = 0;
        while (std::cin.good()) {
            std::cin >> keyWord;
            if (std::cin.eof()) {
                break;
            }
            if (keyWord == "string") {
                options.push_back(fOptionFromStream<std::string>(std::cin, "", nextOptionAsWhat));
            } else if (keyWord == "int") {
                options.push_back(fOptionFromStream<int>(std::cin, 0, nextOptionAsWhat));
            } else if (keyWord == "uint") {
                options.push_back(fOptionFromStream<unsigned int>(std::cin, 0, nextOptionAsWhat));
            } else if (keyWord == "size") {
                options.push_back(fOptionFromStream<options::postFixedNumber<size_t>>(std::cin, 0, nextOptionAsWhat));
            } else if (keyWord == "bool") {
                options.push_back(fOptionFromStream<bool>(std::cin, false, nextOptionAsWhat));
            } else if (keyWord == "seconds") {
                options.push_back(fOptionFromStream<std::chrono::duration<long long>>(std::cin, std::chrono::seconds(1), nextOptionAsWhat));
            } else if (keyWord == "milliseconds") {
                options.push_back(fOptionFromStream<std::chrono::duration<long long, std::milli>>(std::cin, std::chrono::seconds(1), nextOptionAsWhat));
            } else if (keyWord == "microseconds") {
                options.push_back(fOptionFromStream<std::chrono::duration<long long, std::micro>>(std::cin, std::chrono::seconds(1), nextOptionAsWhat));
            } else if (keyWord == "date") {
                options.push_back(fOptionFromStream<std::chrono::system_clock::time_point>(std::cin, std::chrono::system_clock::now(), nextOptionAsWhat));
            } else if (keyWord == "idate") {
                options.push_back(fOptionFromStream<std::chrono::system_clock::time_point>(std::cin, std::chrono::system_clock::now(), nextOptionAsWhat));
                auto opt = dynamic_cast<options::valuePrinter<std::chrono::system_clock::time_point>*>(options.back());
                if (opt) {
                    opt->fSetValuePrinter([](std::ostream & aStream, const std::chrono::system_clock::time_point & aValue)->void {aStream << std::chrono::duration_cast<std::chrono::duration<long>>(aValue.time_since_epoch()).count();});
                }
            } else if (keyWord == "range") {
                options.back()->fAddToRangeFromStream(std::cin);
            } else if (keyWord == "default") {
                options.back()->fAddDefaultFromStream(std::cin);
            } else if (keyWord == "export") {
                exportNextOption = true;
                continue;
            } else if (keyWord == "array") {
                nextOptionAsWhat = kAsArray;
                continue;
            } else if (keyWord == "map") {
                nextOptionAsWhat = kAsMap;
                continue;
            } else if (keyWord == "list") {
                nextOptionAsWhat = kAsList;
                continue;
            } else if (keyWord == "positional") {
                std::cin >> nextOptionPositional;
                continue;
            } else if (keyWord == "minusMinusSpecialTreatment") {
                std::cin >> minusMinusSpecialTreatment;
                continue;
            } else if (keyWord == "minUnusedParameters") {
                std::cin >> minUnusedParameters;
                continue;
            } else if (keyWord == "maxUnusedParameters") {
                std::cin >> maxUnusedParameters;
                continue;
            } else if (keyWord == "noPath") {
                searchPath.clear();
                continue;
            } else if (keyWord == "path") {
                std::string buffer;
                using options::escapedIO::operator>>;
                std::cin >> buffer;
                searchPath.push_back(buffer);
            } else if (keyWord == "trailer:") {
                break;
            } else {
                std::cerr << "illegal option type '" << keyWord << "', giving up" << std::endl;
                return 1;
            }
            if (nextOptionPositional != 0) {
                options::internal::positional_base(nextOptionPositional, options.back());
            }
            if (exportNextOption) {
                exportedOptions.insert(options.back());
            }
            exportNextOption = false;
            nextOptionAsWhat = kSimple;
            nextOptionPositional = 0;
        }
    }
    std::string trailer;
    while (std::cin.good()) {
        std::string line;
        if (std::cin.eof()) {
            break;
        }
        std::getline(std::cin, line);
        trailer += line;
        trailer += "\n";
    }
 
    options::parser parser(description, trailer, searchPath);
    parser.fSetMessageStream(&std::cerr);
    parser.fSetHelpReturnValue(1);
    parser.fSetExecutableName(argv[1]);
    if (! minusMinusSpecialTreatment.empty()) {
        parser.fSetMinusMinusStartsExtraList();
    }
 
    auto unusedOptions = parser.fParse(argc - 1, argv + 1);
 
    if (unusedOptions.size() < minUnusedParameters ||
            unusedOptions.size() > maxUnusedParameters) {
        std::cerr << "illegal number of non-option parameters " << unusedOptions.size() << ", must be between " << minUnusedParameters << " and " << maxUnusedParameters << std::endl;
        parser.fHelp();
        return (1);
    }
 
 
    for (auto option : options) {
        if (exportedOptions.find(option) != exportedOptions.end()) {
            std::cout << "export ";
        }
        std::cout << option->fGetLongName() << "=";
        option->fWriteValue(std::cout);
        std::cout << "\n";
    }
    std::cout << "shift $#\n";
    if (unusedOptions.empty() == false) {
        std::cout << "set --";
        for (auto & unusedOption : unusedOptions) {
            std::cout << " " << unusedOption;
        }
        std::cout << "\n";
    }
    if (parser.fGetStuffAfterMinusMinus().empty() == false) {
        std::cout << minusMinusSpecialTreatment << "=\"";
        for (auto it =  parser.fGetStuffAfterMinusMinus().begin(); it != parser.fGetStuffAfterMinusMinus().end(); ++it) {
            if (it != parser.fGetStuffAfterMinusMinus().begin()) {
                std::cout << " ";
            }
            std::cout << *it;
        }
        std::cout << "\"\n";
    }
 
    return 0;
}

References options::parser::fGetStuffAfterMinusMinus(), options::parser::fHelp(), fOptionFromStream(), options::parser::fParse(), options::parser::fSetExecutableName(), options::parser::fSetHelpReturnValue(), options::parser::fSetMessageStream(), options::parser::fSetMinusMinusStartsExtraList(), options::valuePrinter< T >::fSetValuePrinter(), kAsArray, kAsList, kAsMap, and kSimple.

Here is the call graph for this function: