CmdLineParser.cc

Go to the documentation of this file.

/*
 * CmdLineParser.cc
 *
 * Smalltalk like class library for C++
 * Command line arguments parser.
 *
 * Copyright (c) 2006 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stlib/tools/CmdLineParser.h>
#include <stlib/Callback.h>

#include <stlib/tools/CmdLineMissingArgument.h>
#include <stlib/tools/CmdLineUnknownArgument.h>
#include <stlib/tools/CmdLineUnsufficientParams.h>

#include <stlib/Array.h>
#include <stlib/Character.h>
#include <stlib/Iterator.h>
#include <stlib/Object.h>
#include <stlib/OrderedCollection.h>
#include <stlib/String.h>
#include <stlib/WriteStream.h>
#include <stlib/POOBoundsError.h>

#include <getopt.h>

namespace Tools {

class CommandLineArgument : public Core::Object
{
  protected:
    String *long_argument;
    Character *short_argument;
    bool _mandatory;
    Callback<void> *_callback;
    Object *user_data;
    bool _evaluated;

  public:
    CommandLineArgument(String *longArg, Character *shortArg, bool mandatory,
                        Callback<void> *callback, Object *userData = nil)
    {
        long_argument = longArg;
        short_argument = shortArg;
        _mandatory = mandatory;
        _callback = callback;
        user_data = userData;
        _evaluated = false;
    }

    /* Printing protocol */
    virtual void printGetOptShortOn(Stream *stream)
    {
        if (short_argument == nil) return;

        stream->nextPut(short_argument);
        if (acceptsParameter())
            stream->nextPut(':');
    }

    /* Processing protocol */
    virtual void performCallback(void)
    {
        _callback->executeWith(user_data);
        _evaluated = true;
    }

    virtual void performCallbackWith(String *param)
    {
        _callback->executeWith(param);
        _evaluated = true;
    }

    /* Testing protocol */
    virtual bool acceptsParameter(void)
    {
        return _callback->argumentsNumber() > 0 && user_data == nil;
    }

    virtual bool matchShortArgument(int character)
    {
        return short_argument->isEqual((char) character);
    }

    virtual bool isMandatory(void)
    {
        return _mandatory;
    }

    virtual bool wasEvaluated(void)
    {
        return _evaluated;
    }

    /* Utilities protocol */
    virtual void fillGetOptLongOption(struct option *longopt)
    {
        longopt->name = long_argument->asCString();
        longopt->has_arg = acceptsParameter() ? 1 : 0;
        longopt->flag = NULL;
        if (short_argument == nil) longopt->val = 0;
        else
            longopt->val = short_argument->asInteger();
    }
};

/* Class-accessing protocol */
CommandLineParser::CommandLineParser(void)
{
    _arguments = new OrderedCollection;
    extra_argument_handler = nil;
    parameters_mandatory = false;
}

String *CommandLineParser::className(void) const
{
    return new String("CommandLineParser");
}

/* Initialize protocol */
void CommandLineParser::parametersMandatory(bool isMandatory)
{
    parameters_mandatory = isMandatory;
}

/* Processing protocol */
void CommandLineParser::process(int argc, char **argv)
{
    int option_index = 0;
    char *shortOptions = collectShortOptions()->asCString();
    struct option *longOptions = collectLongOptions();
    CommandLineArgument *argument;

    optind = 0;     /* to force getopt start from beginning */
    while (1) {
        int c;
        c = getopt_long(argc, argv, shortOptions, longOptions, &option_index);
        if (c == -1) break;

        if (c == 0) {           /* long argument found */
            if (option_index >= _arguments->size()) {
                (new CommandLineUnknownArgument(__PRETTY_FUNCTION__, new String(argv[optind-1])))
                    ->raiseFrom(this);
            }
            argument = dynamic_cast<CommandLineArgument *>(_arguments->at(option_index));
        } else {                /* short argument found */
            Iterator *i = _arguments->iterator();
            while (!i->finished()) {
                argument = dynamic_cast<CommandLineArgument *>(i->value());
                if (argument->matchShortArgument(c)) break;
                i->next();
            }
            if (i->finished()) {  /* argument not found */
                (new CommandLineUnknownArgument(__PRETTY_FUNCTION__, new String(argv[optind-1])))
                    ->raiseFrom(this);
            }
        }

        if (argument->acceptsParameter()) {
            argument->performCallbackWith(new String(optarg));
        } else {
            argument->performCallback();
        }
    }

    /* handle parameters */
    if (optind < argc) {
        if (extra_argument_handler != nil) {
            Array *extras = new Array(argc - optind);
            for (int i = 0; optind + i < argc; i++) {
                extras->put(i, new String(argv[optind]));
            }
            extra_argument_handler->executeWith(extras);
        }
    } else if (parameters_mandatory) {
        (new CommandLineUnsufficientParameters(__PRETTY_FUNCTION__))
            ->raiseFrom(this);
    }

    checkMissingArguments();
}

/* Private protocol */
void CommandLineParser::addArgument(String *longArg, Character *shortArg,
                                    bool mandatory, Callback<void> *callback,
                                    Object *userData)
{
    CommandLineArgument *argument;
    argument = new CommandLineArgument(longArg, shortArg, mandatory,
                                       callback, userData);
    _arguments->add(argument);
}

String *CommandLineParser::collectShortOptions(void)
{
    Iterator *i;
    Stream *stream;
    stream = (new String(2 * _arguments->size()))->writeStream();

    for (i = _arguments->iterator(); !i->finished(); i->next())
    {
        dynamic_cast<CommandLineArgument *>(i->value())->printGetOptShortOn(stream);
    }
    return dynamic_cast<String *>(stream->contents());
}

struct option *CommandLineParser::collectLongOptions(void)
{
    struct option *longOptions;
    CommandLineArgument *argument;
    Iterator *i;
    int index;

    longOptions = (struct option *) GC_malloc((_arguments->size() + 1) * sizeof(struct option));
    for (i = _arguments->iterator(), index = 0; !i->finished(); i->next(), index++) {
        argument = dynamic_cast<CommandLineArgument *>(i->value());
        argument->fillGetOptLongOption(&longOptions[index]);
    }
    /* last item must by zero-filled */
    longOptions[index].name = NULL;
    longOptions[index].has_arg = 0;
    longOptions[index].flag = NULL;
    longOptions[index].val = 0;
    return longOptions;
}

void CommandLineParser::checkMissingArguments(void)
{
    CommandLineArgument *argument;
    Iterator *i;

    for (i = _arguments->iterator(); !i->finished(); i->next()) {
        argument = dynamic_cast<CommandLineArgument *>(i->value());
        if (argument->isMandatory() && !argument->wasEvaluated()) {
            (new CommandLineMissingArgument(__PRETTY_FUNCTION__, argument))
                ->raiseFrom(this);
        }
    }
}

}; /* namespace Tools */

---