option.cpp

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <jwsc++/config.h>

#include <cstdlib>
#include <cstring>
#include <cctype>
#include <iostream>
#include <fstream>
#include <sstream>
#include <list>
#include <vector>

#include "jwsc++/base/exception.h"
#include "jwsc++/base/option.h"

#ifdef JWSCXX_HAVE_DMALLOC
#include <dmalloc.h>
#endif


using std::ios_base;
using std::istream;
using std::ostream;
using std::ifstream;
using std::ostringstream;
using std::list;
using std::vector;
using std::strlen;
using std::strcmp;
using std::strncmp;
using std::isspace;

using namespace jwscxx::base;


/* ----------------------------  Option  ------------------------------------ */

Option::Option(char s_name, const char* l_name, const char* desc) 
    throw (Arg_error)
{
    if (!s_name && !l_name)
    {
        throw Arg_error("Option must have a short and/or long name");
    }

    this->s_name = s_name;
    this->l_name = l_name;
    this->desc   = desc;
}


bool Option::is_s_name_option(const char* arg) const
{
    if (strlen(arg) != 2)
    {
        return false;
    }

    char str[3] = {'-', s_name, 0};

    return (strcmp(arg, str) == 0);
}


bool Option::is_l_name_option(const char* arg) const
{
    char str[3]  = {'-', '-', 0};

    if (strncmp(arg, str, 2) != 0)
    {
        return false;
    }

    arg += 2;

    const char* eq = arg;
    while (*eq != '=' && *eq != 0)
    {
        eq++;
    }

    size_t arg_len = eq - arg;

    if (arg_len != strlen(l_name))
    {
        return false;
    }

    return (strncmp(arg, l_name, arg_len) == 0);
}

/* -------------------------------------------------------------------------- */








/* --------------------------  Option_with_arg  ----------------------------- */

Option_with_arg::Option_with_arg
(
    char        s_name, 
    const char* l_name, 
    const char* desc,
    void (*func)(const char* arg) throw (Arg_error)
) 
throw (Arg_error)
    : Option(s_name, l_name, desc)
{
    this->func = func;
}



int Option_with_arg::process(int argc, char** argv) const 
    throw (Arg_error)
{
    for (int i = 0; i < argc; i++)
    {
        if (l_name && is_l_name_option(argv[ i ]))
        {
            func(get_l_name_arg(argv[ i ]));
            return i;
        }
        if (s_name && is_s_name_option(argv[ i ]))
        {
            func(((i+1) < argc) ? argv[ i+1 ] : 0);
            return i;
        }
    }

    return -1;
}


void Option_with_arg::print(ostream& out, int width) const throw (Arg_error)
{
    if (width > 60)
    {
        throw Arg_error("Option name field width > 60");
    }

    int s_name_len = 2;
    int l_name_len = 2 + ((l_name) ? strlen(l_name)+4 : 0);
    int opt_len    = 1 + s_name_len + 2 + l_name_len + 2;

    int opt_padding = (opt_len < width) ? width - opt_len : 0;

    out << " ";

    if (s_name)
        out << "-" << s_name;
    else
        out << "  ";

    if (s_name && l_name)
        out << ",";
    else
        out << " ";

    out << " ";

    if (l_name)
        out << "--" << l_name << "=ARG";
    else
        out << "      ";

    out << "  ";

    if (opt_padding > 0)
    {
        out.width(opt_padding);
        out << "";
        out.width(0);
    }

    if (!desc || strlen(desc) == 0)
    {
        out << "\n";
        return;
    }

    char        desc_buff[81]      = {0};
    char*       desc_buff_word_ptr = desc_buff;
    char*       desc_buff_ptr      = desc_buff;
    const char* desc_char_word_ptr = desc;
    const char* desc_char_ptr      = desc;

    int num_lines = 1;
    int len       = 0;

    while (*desc_char_ptr != '\0')
    {
        int desc_max_len;

        if (num_lines == 1)
        {
            desc_max_len = 80 - (opt_len + opt_padding);
        }
        else
        {
            desc_max_len = 80 - width;
        }

        if (len == desc_max_len)
        {
            if (desc_buff == desc_buff_word_ptr)
            {
                desc_char_word_ptr = desc_char_ptr;
            }
            else
            {
                desc_char_ptr = desc_char_word_ptr;
                *desc_buff_word_ptr = '\0';
            }

            if (num_lines > 1)
            {
                out.width(width);
                out << "";
                out.width(0);
            }

            desc_buff_ptr = desc_buff;
            while (*desc_buff_ptr == ' ')
                desc_buff_ptr++;
            out << desc_buff_ptr << "\n";

            desc_buff_word_ptr = desc_buff;
            desc_buff_ptr      = desc_buff;

            len = 0;
            num_lines++;
        }

        *desc_buff_ptr = *desc_char_ptr;
        desc_char_ptr++;
        desc_buff_ptr++;
        len++;

        if (*desc_char_ptr == ' ')
        {
            desc_buff_word_ptr = desc_buff_ptr;
            desc_char_word_ptr = desc_char_ptr;
        }
    }

    *desc_buff_ptr = *desc_char_ptr;

    if (*desc_buff != '\0')
    {
        if (num_lines > 1)
        {
            out.width(width);
            out << "";
            out.width(0);
        }

        desc_buff_ptr = desc_buff;
        while (*desc_buff_ptr == ' ')
            desc_buff_ptr++;
        out << desc_buff_ptr << "\n";
    }
}


const char* Option_with_arg::get_l_name_arg(const char* str) const
{
    while (*str && *str != '=')
    {
        str++;
    }

    if (*str)
    {
        return str+1;
    }

    return 0;
}

/* -------------------------------------------------------------------------- */








/* --------------------------  Option_no_arg  ------------------------------- */

Option_no_arg::Option_no_arg
(
    char        s_name, 
    const char* l_name, 
    const char* desc,
    void (*func)(void)
) 
throw (Arg_error)
    : Option(s_name, l_name, desc)
{
    this->func = func;
}


int Option_no_arg::process(int argc, char** argv) const throw (Arg_error)
{
    for (int i = 0; i < argc; i++)
    {
        if ((l_name && is_l_name_option(argv[ i ])) ||
            (s_name && is_s_name_option(argv[ i ])))
        {
            func();
            return i;
        }
    }

    return -1;
}


void Option_no_arg::print(ostream& out, int width) const throw (Arg_error)
{
    if (width > 60)
    {
        throw Arg_error("Option name field width > 60");
    }

    int s_name_len = 2;
    int l_name_len = 2 + ((l_name) ? strlen(l_name) : 0);
    int opt_len    = 1 + s_name_len + 2 + l_name_len + 2;

    int opt_padding = (opt_len < width) ? width - opt_len : 0;


    out << " ";

    if (s_name)
        out << "-" << s_name;
    else
        out << "  ";

    if (s_name && l_name)
        out << ",";
    else
        out << " ";

    out << " ";

    if (l_name)
        out << "--" << l_name;
    else
        out << "  ";

    out << "  ";

    if (opt_padding > 0)
    {
        out.width(opt_padding);
        out << "";
        out.width(0);
    }

    if (!desc || strlen(desc) == 0)
    {
        out << "\n";
        return;
    }

    char        desc_buff[81]      = {0};
    char*       desc_buff_word_ptr = desc_buff;
    char*       desc_buff_ptr      = desc_buff;
    const char* desc_char_word_ptr = desc;
    const char* desc_char_ptr      = desc;

    int num_lines = 1;
    int len       = 0;

    while (*desc_char_ptr != '\0')
    {
        int desc_max_len;

        if (num_lines == 1)
        {
            desc_max_len = 80 - (opt_len + opt_padding);
        }
        else
        {
            desc_max_len = 80 - width;
        }

        if (len == desc_max_len)
        {
            if (desc_buff == desc_buff_word_ptr)
            {
                desc_char_word_ptr = desc_char_ptr;
            }
            else
            {
                desc_char_ptr = desc_char_word_ptr;
                *desc_buff_word_ptr = '\0';
            }

            if (num_lines > 1)
            {
                out.width(width);
                out << "";
                out.width(0);
            }

            desc_buff_ptr = desc_buff;
            while (*desc_buff_ptr == ' ')
                desc_buff_ptr++;
            out << desc_buff_ptr << "\n";

            desc_buff_word_ptr = desc_buff;
            desc_buff_ptr      = desc_buff;

            len = 0;
            num_lines++;
        }

        *desc_buff_ptr = *desc_char_ptr;
        desc_char_ptr++;
        desc_buff_ptr++;
        len++;

        if (*desc_char_ptr == ' ')
        {
            desc_buff_word_ptr = desc_buff_ptr;
            desc_char_word_ptr = desc_char_ptr;
        }
    }

    *desc_buff_ptr = *desc_char_ptr;

    if (*desc_buff != '\0')
    {
        if (num_lines > 1)
        {
            out.width(width);
            out << "";
            out.width(0);
        }

        desc_buff_ptr = desc_buff;
        while (*desc_buff_ptr == ' ')
            desc_buff_ptr++;
        out << desc_buff_ptr << "\n";
    }
}

/* -------------------------------------------------------------------------- */








/* ----------------------------  Options  ----------------------------------- */

Options::~Options()
{
    for (list<Option*>::iterator it = opts.begin(); it != opts.end(); it++)
    {
        delete *it;
    }
}


void Options::add(Option* opt)
{
    opts.push_back(opt);
}


int Options::process(int argc, char** argv) const throw (Arg_error)
{
    int n = 0;

    for (int i = 0; i < argc; i++)
    {
        bool processed = false;

        for (list<Option*>::const_iterator it = opts.begin(); 
                it != opts.end(); it++)
        {
            if ((*it)->process(1, &(argv[ i ])) >= 0)
            {
                processed = true;
                break;
            }
        }

        if (!processed && is_an_option(argv[ i ]))
        {
            ostringstream ost;
            ost << "Unknown option '" << argv[ i ] << '\'';
            throw Arg_error(ost.str());
        }
        else if (!processed)
        {
            n++;
        }
    }

    return n;
}


void Options::process(const char* fname) const throw (IO_error, Arg_error)
{
    ostringstream ost;
    ifstream in;

    in.open(fname);
    if (in.fail())
    {
        ost << fname << ": Could not open file";
        throw IO_error(ost.str());
    }

    try
    {
        process(in);
    }
    catch (Arg_error e)
    {
        ost << fname << ": " << e.get_msg();
        throw Arg_error(ost.str());
    }

    in.close();
    if (in.fail())
    {
        ost << fname << ": Could not close file";
        throw IO_error(ost.str());
    }
}


void Options::process(istream& in) const throw (Arg_error)
{
    char  c;

    while (in.peek() != EOF)
    {
        c = in.get();
        if (in.fail())
        {
            throw Arg_error("Could not get character from input");
        }

        if (c == '#')
        {
            in.ignore(255, '\n');
            if (in.fail())
            {
                throw Arg_error("Could not ignore line");
            }
        }
        else if (!isspace(c))
        {
            // NEED TO ALLOCATE A CONSTANT STRING FOR EACH LINE READ
            char* buf = (char*) calloc(256, sizeof(char));
            buf[0] = '-';
            buf[1] = '-';
            buf[255] = 0;

            in.putback(c);
            in.getline(&(buf[2]), 253);
            if (in.fail())
            {
                throw Arg_error("Could not read line");
            }

            bool processed = false;

            for (list<Option*>::const_iterator it = opts.begin(); 
                    it != opts.end(); it++)
            {
                if ((*it)->process(1, &buf) >= 0)
                {
                    processed = true;
                    break;
                }
            }
            if (!processed && is_an_option(buf))
            {
                ostringstream ost;
                ost << "Unknown option '" << &(buf[2]) << '\'';
                throw Arg_error(ost.str());
            }
        }
    }
}


void Options::print(ostream& out, int width) const
{
    for (list<Option*>::const_iterator it = opts.begin(); 
            it != opts.end(); it++)
    {
        (*it)->print(out, width);
    }
}


bool Options::is_an_option(const char* arg) const
{
    int len = strlen(arg);

    if (len < 2)
    {
        return false;
    }

    if (len == 2 && arg[0] == '-')
    {
        return true;
    }

    if (arg[0] == '-' && arg[1] == '-')
    {
        return true;
    }

    return false;
}


/* -------------------------------------------------------------------------- */