Arguments.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <wctype.h>
 
#include <dcl/Charset.h>
#include <dcl/Writer.h>
#include <dcl/Arguments.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/Arguments.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(Arguments, Object)
 
Arguments::Arguments(
    Writer& _output, Writer& _errout,
    const wchar_t* _program_version,
    const wchar_t* _program_bug_address,
    const wchar_t* _arg_doc,
    const wchar_t* _doc,
    const Option   _options[]
    )
    : __output(_output), __errout(_errout)
{
    __program_version = _program_version;
    __program_bug_address = _program_bug_address;
    __arg_doc = _arg_doc;
    __doc = _doc;
    __options = _options;
}
 
#define KEY_USAGE -1
static Arguments::Option __options__[] =
{
    { L"help",    L'?',      NULL, 0, L"Give this help list"        },
    { L"usage",   KEY_USAGE, NULL, 0, L"Give a short usage message" },
    { L"version", L'V',      NULL, 0, L"Print program version"      },
    { NULL }
};
 
void Arguments::onOption(int _key, const String& _arg)
        __DCL_THROWS1(Exception*)
{
}
 
String Arguments::onValidate()
{
    return String();
}
 
static void __add_help(StringBuilder& _sb, const Arguments::Option* _options)
{
    while (_options->name || _options->doc) {
        if (_options->name) {
            StringBuilder sb = L"  ";
            if (iswprint(_options->key)) {
                sb += L'-';
                sb += (wchar_t)_options->key;
                sb += L", ";
            }
            else {
                sb += L"    ";
            }
 
            sb += L"--";
            sb += _options->name;
 
            if (_options->arg) {
                sb += L'=';
                sb += _options->arg;
            }
 
            if (_options->doc) {
                if (sb.length() < 28) {
                    String pad(L' ', 28 - sb.length());
                    sb += pad;
                }
                else {
                    sb += L'\n';
                    String pad(L' ', 28);
                    sb += pad;
                }
                sb += _options->doc;
            }
 
            _sb += L'\n';
            _sb += sb.toString();
        }
        else {
            _sb += L"\n\n ";
            _sb += _options->doc;
        }
 
        _options++;
    }
}
 
String Arguments::help() const
{
    StringBuilder sb = shortUsage();
    if (__doc) {
        sb += L'\n';
        sb += __doc;
    }
    sb += L'\n';
 
    __add_help(sb, __options);
    sb += L'\n';
    __add_help(sb, __options__);
 
    if (__program_bug_address) {
        sb += L"\n\n";
        sb += L"Report bugs to ";
        sb += __program_bug_address;
    }
    return sb;
}
 
String Arguments::shortUsage() const
{
    StringBuilder sb = L"Usage: ";
    sb += __value0;
    sb += L" [OPTION...] ";
    if (__arg_doc) {
        sb += __arg_doc;
    }
    return sb;
}
 
String Arguments::tryUsage() const
{
    StringBuilder sb = L"Try `";
    sb += __value0;
    sb += L" --help' or `";
    sb += __value0;
    sb += L" --usage' for more information.";
    return sb;
}
 
String Arguments::argRequired(const String& _option) const
{
    StringBuilder sb = __value0;
    sb += L": option '";
    sb += _option;
    sb += L"' requires an argument";
    return sb;
}
 
String __key_options(const Arguments::Option* _options)
{
    StringBuilder sb;
    while (_options->name || _options->doc) {
        if (iswprint(_options->key)) {
            sb += (wchar_t)_options->key;
        }
        _options++;
    }
    return sb;
}
 
static void __add_key_arg_options(
        StringArray& _a,
        const Arguments::Option* _options
    )
{
    while (_options->name || _options->doc) {
        if (iswprint(_options->key) && _options->arg) {
            StringBuilder sb = L"-";
            sb += (wchar_t)_options->key;
            sb += L" ";
            sb += _options->arg;
            _a.add(sb);
        }
        _options++;
    }
}
 
static void __add_name_options(
        StringArray& _a,
        const Arguments::Option* _options
    )
{
    while (_options->name || _options->doc) {
        if (_options->name && _options->arg == NULL) {
            StringBuilder sb;
            sb += L"--";
            sb += _options->name;
            _a.add(sb);
        }
        _options++;
    }
}
 
static void __add_name_arg_options(
        StringArray& _a,
        const Arguments::Option* _options
    )
{
    while (_options->name || _options->doc) {
        if (_options->name && _options->arg) {
            StringBuilder sb;
            sb += L"--";
            sb += _options->name;
            sb += L"=";
            sb += _options->arg;
            _a.add(sb);
        }
        _options++;
    }
}
 
String Arguments::usage() const
{
    StringArray a;
    {
        String s = __key_options(__options)
            + __key_options(__options__)
            ;
        if (!s.isEmpty()) {
            a.add(L"-" + s);
        }
    }
    __add_key_arg_options(a, __options);
    __add_name_arg_options(a, __options);
    __add_name_options(a, __options);
    __add_name_options(a, __options__);
 
    StringBuilder sb = L"Usage: ";
    sb += __value0;
    String padding(L' ', 10);
    size_t n = sb.length();
    for (size_t i = 0; i < a.size(); i++) {
        const String& s = a[i];
        if ((n + s.length() + 3) > 80) {
            sb += L"\n";
            sb += padding;
            n = padding.length();
        }
        n += s.length() + 3;
        sb += L" [";
        sb += s;
        sb += L"]";
    }
 
    if (__arg_doc) {
        if (n + String::length(__arg_doc) + 1 > 80) {
            sb += L"\n";
            sb += padding;
        }
        sb += L" ";
        sb += __arg_doc;
    }
 
    return sb;
}
 
String Arguments::version() const
{
    StringBuilder sb; // = L"Version: ";
    if (__program_version) {
        sb += __program_version;
    }
 
    return sb;
}
 
static const Arguments::Option* __find_key(
        const String& _s,
        const Arguments::Option* _options
    )
{
    if (_s.length() > 2 && _s.startsWith(L"--")) {
        String name = _s.substring(2);
        while (_options->name || _options->doc) {
            if (_options->name && name.compare(_options->name,
                String::length(_options->name)) == 0) {
                return _options;
            }
            _options++;
        }
    }
    else if (_s.length() > 1) {
        int key = _s[1];
        while (_options->name || _options->doc) {
            if (_options->key == key) {
                return _options;
            }
            _options++;
        }
    }
    return NULL;
}
 
bool Arguments::parse(
        int _argc, char* _argv[], bool _argv_required
    )
{
    LocaleDecoder decoder;
    StringArray argv(_argc);
    for (int i = 0; i < _argc; i++) {
        argv[i] = decoder.decode(_argv[i]);
    }
 
    __value0 = argv[0];
    argv.erase((size_t)0);
 
    for (size_t i = 0; i < argv.size(); i++) {
        const String& s = argv[i];
        if (s.startsWith(L"-")) {
            const Option* option = __find_key(s, __options__);
            if (option != NULL) {
                switch (option->key) {
                case L'?':
                    __output << help() << endl;
                    break;
                case KEY_USAGE:
                    __output << usage() << endl;
                    break;
                case L'V':
                    __output << version() << endl;
                }               
                return false;
            }
        }
    }
 
    for (size_t i = 0; i < argv.size(); ) {
    //  __DCL_TRACE3(L"[%zd][%zd][%ls]\n", i, argv.size(), argv.toString().data());
        // argv[i]는 erase 될 수 있으므로
        // 참조가 아닌 복사본 이어야 한다.
        const String key = argv[i];
        if (key.startsWith(L"-")) {
            const Option* option = __find_key(key, __options);
            if (option == NULL) {
                __errout << __value0 + L": unrecognized option '"
                    << key << L"'" << endl
                    << tryUsage() << endl;
                return false;
            }
 
            argv.erase(i);
            String arg;
            if (option->arg) {
                if (key.startsWith(L"--")) {
                    size_t index = key.indexOf(L'=');
                    if (index != (size_t)-1) {
                        arg = key.substring(index + 1);
                    }
                }
                else {
                    if (key.length() > 2) {
                        arg = key.substring(2);
                    }
                }
                if (arg.isEmpty()) {
                    if (i < argv.size()) {
                        arg = argv[i];
                        argv.erase(i);
                    }
                }
    //          __DCL_TRACE2(L"[%ls][%ls]\n", key.data(), arg.data());
                if (arg.isEmpty()) {
                    __errout << argRequired(key) << endl
                        << tryUsage() << endl;
                    return false;
                }
            }
 
            try {
                onOption(option->key, arg);
            }
            catch (Exception* e) {
                __errout << e->toStringAll() << endl;
                e->destroy();
                return false;
            }
        }
        else {
            i++;
        }
    }
 
    try {
        String msg = onValidate();
        if (!msg.isEmpty()) {
            __errout << __value0 << L": " << msg << endl
                << tryUsage() << endl;
            return false;
        }
    }
    catch (Exception* e) {
        __errout << e->toStringAll() << endl;
        e->destroy();
        return false;
    }
 
    if (_argv_required && argv.isEmpty()) {
        __errout << shortUsage() << endl
            << tryUsage() << endl;
        return false;
    }
 
    __values = argv;
    return true;
}
 
__DCL_END_NAMESPACE