/***************************************************************************

 *

 * $Id: cmdopt.cpp 348342 2005-11-23 02:03:26Z sebor $

 *

 ************************************************************************

 *

 * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave

 * Software division. Licensed under the Apache License, Version 2.0 (the

 * "License");  you may  not use this file except  in compliance with the

 * License.    You    may   obtain   a   copy   of    the   License    at

 * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by

 * applicable law  or agreed to  in writing,  software  distributed under

 * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR

 * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License

 * for the specific language governing permissions  and limitations under

 * the License.

 * 

 **************************************************************************/

// expand _TEST_EXPORT macros

#define _RWSTD_TEST_SRC

#include <cmdopt.h>

#include <assert.h>   // for assert

#include <errno.h>    // for errno

#include <stdarg.h>   // for va_arg, ...

#include <stdio.h>    // for fprintf

#include <stdlib.h>   // for atexit, free, malloc

#include <string.h>   // for memcpy, strcpy, strcmp, ...

#ifdef __ARMCC__

#pragma diag_suppress 61

#pragma diag_suppress 63

#endif

#ifndef EINVAL

#  define EINVAL   22   /* e.g., HP-UX, Linux, Solaris */

#endif   // EINVAL

/**************************************************************************/

typedef int (optcallback_t)(int, char*[]);

struct cmdopts_t

{

    char           loptbuf_ [32];   // buffer for long option name

    optcallback_t *callback_;       // function to call to process option

    // counter to increment for each occurrence of an option

    // or to set to the numeric argument (when specified)

    int           *pcntr_;

    char          *lopt_;           // long option name

    char           sopt_;           // short option name

    size_t         maxcalls_;       // how many times option can be invoked

    size_t         ncalls_;         // how many times it has been invoked

    unsigned       arg_ : 1;        // option takes an argument?

    unsigned       inv_ : 1;        // callback invocation inverted

    unsigned       envseen_ : 1;    // environment option already processed

};

// total number of registered options

static size_t ncmdopts;

// number of default (always defined) options

static size_t ndefopts;

static cmdopts_t cmdoptbuf [32];

static cmdopts_t *cmdopts = cmdoptbuf;

static size_t optbufsize = sizeof cmdoptbuf / sizeof *cmdoptbuf;

/**************************************************************************/

static int

rw_print_help (int argc, char *argv[])

{

    if (1 == argc && argv && 0 == argv [0]) {

        static const char helpstr[] = {

            "Without an argument, prints this help to stdout and exits with\n"

            "a status of 0 without further processing.\n"

            "With the optional argument prints help on the option with that\n"

            "name, if one exists, and exits with a status of 0. If an option\n"

            "with the specified name does not exist, prints an error message\n"

            "to stderr and exits with a status of 1.\n"

            "The leading underscores in the name of an option are optional.\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    // the option name to get help on, if any

    const char* opthelp = 1 < argc ? argv [1] : 0;

    // remove the optional one or two leading underscores

    if (opthelp && '-' == opthelp [0] && opthelp [1])

        opthelp += 1 + ('-' == opthelp [1]);

    if (0 == opthelp)

        printf ("OPTIONS\n");

    // set to a non-zero when the specified option is found

    int option_found = 0;

    for (size_t i = 0; i != ncmdopts; ++i) {

        // get a pointer to the name of the long option, if any

        const char* const lopt =

            cmdopts [i].lopt_ ? cmdopts [i].lopt_ : cmdopts [i].loptbuf_;

        if (opthelp && *opthelp) {

            if (   cmdopts [i].sopt_ == opthelp [0] && '\0' == opthelp [1]

                || *lopt && 0 == strcmp (lopt + 1, opthelp)) {

                // remember that we found the option whose (short

                // or long) name we're to give help on; after printing

                // the help text on the option keep looping in case

                // there is another option and callback with the same

                // name (unlikely but possible)

                option_found = 1;

            }

            else {

                // the option doesn't match, continue searching

                continue;

            }

        }

        printf ("     ");

        if (cmdopts [i].sopt_) {

            printf ("-%c", cmdopts [i].sopt_);

            if (lopt)

                printf (" | ");

        }

        const char *pfx = "";

        const char *sfx = pfx;

        if (lopt) {

            printf ("-%s", lopt);

            if (   cmdopts [i].arg_

                && '=' != lopt [strlen (lopt) - 1]) {

                pfx = " [ ";

                sfx = " ]";

            }

        }

        printf ("%s%s%s", pfx, cmdopts [i].arg_ ? "<arg>" : "", sfx);

        if (_RWSTD_SIZE_MAX == cmdopts [i].maxcalls_)

            printf (" (each occurrence evaluated)\n");

        else if (1 < cmdopts [i].maxcalls_)

            printf (" (at most %u occurrences evaluated)\n",

                    unsigned (cmdopts [i].maxcalls_));

        else

            printf (" (only the first occurrence evaluated)\n");

        // invoke callback with the "--help" option

        if (cmdopts [i].callback_) {

            char* help [2] = { 0, 0 };

            cmdopts [i].callback_ (1, help);

            for (const char *line = help [0]; line; ) {

                const char* const nl = strchr (line, '\n');

                const int len = nl ? int (nl - line) : int (strlen (line));

                printf ("       %.*s\n", len, line);

                line = nl;

                if (nl)

                    ++line;

            }

        }

    }

    if (opthelp && !option_found) {

        fprintf (stderr, "Unknown option \"%s\".\n", opthelp);

        exit (1);

    }

    exit (0);

    return 0;

}

/**************************************************************************/

static int

rw_set_ignenv (int argc, char *argv[])

{

    if (1 == argc && argv && 0 == argv [0]) {

        static const char helpstr[] = {

            "Prevents options specified in the RWSTD_TESTOPTS environment\n"

            "variable from taking effect.\n"

            "Unless this option is specified, the RWSTD_TESTOPTS environment\n"

            "variable is processed as if its value were specified on the \n"

            "command line.\n"

            "For example, setting the value of the variable to the string\n"

            "\"--verbose --no-wchar\" and invoking this program with no\n"

            "command line arguments will have the same effect as invoking\n"

            "it with the two arguments on the command line.\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    return 0;

}

extern "C" {

static void

rw_clear_opts ()

{

    // reset all options, deallocating dynamically allocated storage

    for (size_t i = 0; i != ncmdopts; ++i) {

        // free any storage allocated for the option name

        free (cmdopts [i].lopt_);

    }

    if (cmdopts != cmdoptbuf) {

        // free the storage allocated for all the options

        free (cmdopts);

    }

    // reset the options pointer to point at the statically

    // allocated buffer and the count back to 0

    ncmdopts   = 0;

    cmdopts    = cmdoptbuf;

    optbufsize = sizeof cmdoptbuf / sizeof *cmdoptbuf;

}

}

static void

rw_set_myopts ()

{

    static int cleanup_handler_registered;

    if (0 == cleanup_handler_registered) {

        atexit (rw_clear_opts);

        cleanup_handler_registered = 1;

    }

    if (0 != ncmdopts)

        return;

    static int recursive;

    if (recursive)

        return;

    ++recursive;

    rw_setopts ("|-help: "   // argument optional

                "|-ignenv ",

                rw_print_help,

                rw_set_ignenv);

    ndefopts = ncmdopts;

    recursive = 0;

}

/**************************************************************************/

//////////////////////////////////////////////////////////////////////

// syntax of the option description string:

//

// opts ::= opt [ ':' | '=' | '#' ] [ @N | @* | '!' ] [ opts ]

// opt  ::= <sopt> [ '|' <lopt>]

//      ::= '|' <lopt>

// sopt ::= char

// lopt ::= char char*

// char ::= A-Z a-z _ 0-9

_TEST_EXPORT int

rw_vsetopts (const char *opts, va_list va)

{

    if (0 == opts) {

        rw_clear_opts ();

        return 0;

    }

    rw_set_myopts ();

    const char *next = opts;

    for ( ; ; ++ncmdopts) {

        while (' ' == *next)

            ++next;

        if ('\0' == *next) {

            break;

        }

        if (ncmdopts == optbufsize) {

            const size_t newbufsize = 2 * ncmdopts + 1;

            cmdopts_t* const newopts =

                (cmdopts_t*)malloc (newbufsize * sizeof (cmdopts_t));

            if (0 == newopts) {

                fprintf (stderr, "%s%d: failed to allocate memory\n",

                         __FILE__, __LINE__);

                abort ();

            }

            memcpy (newopts, cmdopts, ncmdopts * sizeof (cmdopts_t));

            if (cmdopts != cmdoptbuf)

                free (cmdopts);

            cmdopts    = newopts;

            optbufsize = newbufsize;

        }

        // clear the next option info

        memset (cmdopts + ncmdopts, 0, sizeof *cmdopts);

        if ('|' != *next)

            cmdopts [ncmdopts].sopt_ = *next++;

        if ('|' == *next) {

            const char* end = strpbrk (++next, "|@:=*!# ");

            if (0 == end)

                end = next + strlen (next);

            // copy the option name up to but not including the delimiter

            // (except when the delimiter is the equals sign ('='), which

            // becomes the last character of the option name

            const size_t optlen = size_t (end - next) + ('=' == *end);

            char *lopt = 0;

            if (optlen < sizeof cmdopts [ncmdopts].loptbuf_)

                lopt = cmdopts [ncmdopts].loptbuf_;

            else {

                lopt = (char*)malloc (optlen + 1);

                cmdopts [ncmdopts].lopt_ = lopt;

            }

            memcpy (lopt, next, optlen);

            lopt [optlen] = '\0';

            next = end;

        }

        // only the first occurrence of each command line option

        // causes an invocation of the callback, all subsequent

        // ones will be ignored by default

        cmdopts [ncmdopts].maxcalls_ = 1;

        int arg_is_callback = true;

        if ('#' == *next) {

            // insead of a pointer to a callback, the argument

            // is a pointer to an int counter that is to be

            // incremented for each occurrence of the option

            // during processing; when the option is immediately

            // followed by the equals sign ('=') and a numeric

            // argument the value of the argument will be stored

            arg_is_callback = false;

            ++next;

            // an unlimited number of occurrences of the option

            // are allowed and will be counted

            cmdopts [ncmdopts].maxcalls_ = _RWSTD_SIZE_MAX;

        }

        else if (':' == *next || '=' == *next) {

            // ':' : argument optional

            // '=' : argument required

            cmdopts [ncmdopts].arg_ = true;

            ++next;

        }

        if ('@' == *next) {

            ++next;

            // at most how many occurrences of an option can be processed?

            if ('*' == *next) {

                // unlimited

                cmdopts [ncmdopts].maxcalls_ = _RWSTD_SIZE_MAX;

                ++next;

            }

            else {

                // at most this many

                char *end;

                cmdopts [ncmdopts].maxcalls_ = strtoul (next, &end, 10);

                next = end;

            }

        }

        else if ('!' == *next) {

            cmdopts [ncmdopts].inv_ = true;

            ++next;

        }

        if (arg_is_callback) {

            // retrieve the callback and verify it's not null

            // (null callback is permitted in the special case when

            // the short option is '-', i.e., when setting up or

            // resetting an "unknown option" handler)

            cmdopts [ncmdopts].callback_ = va_arg (va, optcallback_t*);

        }

        else {

            // retrieve the address of the int counter where to keep

            // track of the number of occurrences of the option, or

            // where to store the value of the numeric argument of

            // the option

            cmdopts [ncmdopts].pcntr_ = va_arg (va, int*);

        }

        if (   '-' != cmdopts [ncmdopts].sopt_

            && 0 == cmdopts [ncmdopts].callback_

            && 0 == cmdopts [ncmdopts].pcntr_) {

            // get a pointer to the long option name

            const char* const lopt = cmdopts [ncmdopts].lopt_

                ? cmdopts [ncmdopts].lopt_ : cmdopts [ncmdopts].loptbuf_;

            if (*lopt)

                fprintf (stderr, "null handler for option -%s\n", lopt);

            else

                fprintf (stderr, "null handler for option -%c\n",

                         cmdopts [ncmdopts].sopt_);

            abort ();

        }

    }

    return int (ncmdopts - ndefopts);

}

/**************************************************************************/

_TEST_EXPORT int

rw_setopts (const char *opts, ...)

{

    va_list va;

    va_start (va, opts);

    const int result = rw_vsetopts (opts, va);

    va_end (va);

    return result;

}

/**************************************************************************/

_TEST_EXPORT int

rw_runopts (int argc, char *argv[])

{

    rw_set_myopts ();

    static int recursive = false;

    // ignore options set in the environment?

    int ignenv = recursive;

    // return status

    int status = 0;

    // number of options processed

    int nopts = 0;

    // index of registered option whose callback should be invoked

    // for command line options that do not match any other

    size_t not_found_inx = _RWSTD_SIZE_MAX;

    // iterate over the command line arguments until a callback

    // returns a non-zero value or until all options have been

    // successfully processed

    for (int i = 0; i < argc && argv [i] && 0 == status; ++i) {

        if (0 == strcmp ("--ignore-environment", argv [i])) {

            // ignore options set in the environment

            ignenv = true;

            continue;

        }

        if (0 == strcmp ("--", argv [i])) {

            // "--" terminates options, everything

            // after it is treated as an argument

            break;

        }

        // the name of the option without the leading dash

        const char* const optname = argv [i] + 1;

        // look for the first equals sign

        const char* const eq = strchr (optname, '=');

        // compute the length of the option including the equals sign (if any)

        const size_t optlen = eq ? size_t (eq - optname + 1) : strlen (optname);

        int found = false;

        // look up each command line option (i.e., a string that starts

        // with a dash ('-')) and invoke the callback associated with it

        for (size_t j = 0; j != ncmdopts; ++j) {

            if ('-' == cmdopts [j].sopt_)

                not_found_inx = j;

            if ('-' == argv [i][0]) {

                const size_t cmplen =

                    eq && cmdopts [j].pcntr_ ? optlen - 1 : optlen;

                // get a pointer to the (possibly empty) name

                // of the long option

                const char* const lopt = cmdopts [j].lopt_ ? 

                    cmdopts [j].lopt_ : cmdopts [j].loptbuf_;

                // try to match the long option first, and only if it

                // doesn't match try the short single-character option

                if (   cmplen == strlen (lopt)

                    && 0 == memcmp (optname, lopt, cmplen)

                    || cmdopts [j].sopt_

                    && optname [0] == cmdopts [j].sopt_

                    && (1 == optlen || cmdopts [j].arg_)) {

                    // matching option has been found

                    found = true;

                    // ignore the option if invoked recursively (by processing

                    // options set in the environment) and the option has

                    // already been seen (this prevents duplicate processing

                    // of options that are set both on the command line and

                    // in the environment and allows option with an argument

                    // set on the command line to override those set in the

                    // environment)

                    if (cmdopts [j].ncalls_ && recursive)

                        continue;

                    // if the option has been evaluated the maximum number

                    // of times, avoid evaluating it and continue processing

                    if (cmdopts [j].maxcalls_ <= cmdopts [j].ncalls_)

                        continue;

                    if (cmdopts [j].callback_) {

                        if (!cmdopts [j].inv_) {

                            // when the command line argument matched

                            // the option,  invoke the callback function

                            status = cmdopts [j].callback_ (argc - i, argv + i);

                        }

                    }

                    else if (eq) {

                        assert (0 != cmdopts [j].pcntr_);

                        // obtain the numeric argument

                        char *end = 0;

                        const long optval = strtol (eq + 1, &end, 0);

                        if (end && '\0' != *end) {

                            fprintf (stderr, "expected numeric argument: %s\n",

                                     optname);

                            ignenv = true;

                            errno  = EINVAL;

                            status = 1;

                        }

#if _RWSTD_INT_SIZE < _RWSTD_LONG_SIZE

                        else if (   optval < _RWSTD_INT_MIN

                                 || _RWSTD_INT_MAX < optval) {

                            fprintf (stderr, "numeric argument %ld out of range"

                                     " [%d, %d]: %s\n", optval,

                                     _RWSTD_INT_MIN, _RWSTD_INT_MAX, optname);

                            ignenv = true;

                            errno  = EINVAL;

                            status = 1;

                        }

#endif   // _RWSTD_INT_SIZE < _RWSTD_LONG_SIZE

                        else {

                            *cmdopts [j].pcntr_ = optval;

                        }

                    }

                    else {

                        assert (0 != cmdopts [j].pcntr_);

                        ++*cmdopts [j].pcntr_;

                    }

                    ++cmdopts [j].ncalls_;

                    if (recursive)

                        cmdopts [j].envseen_ = true;

                    ++nopts;

                    if (status) {

                        // when the status returned from the last callback

                        // is non-0 stop further processing (including

                        // any options set in the environment) and return

                        // status to the caller

                        ignenv = true;

                        break;

                    }

                }

            }

        }

        if (!found && '-' == argv [i][0]) {

            // invoke the appropriate error handler for an option

            // that was not found

            if (_RWSTD_SIZE_MAX != not_found_inx) {

                // invoke the error handler set up through rw_setopts()

                // and let the handler decide whether to go on processing

                // other options or whether to abort

                status = cmdopts [not_found_inx].callback_ (argc - i, argv + i);

                if (status) {

                    // no further processing done

                    ignenv = true;

                    break;

                }

            }

            else {

                // print an error message to stderr when no error

                // handler has been set up

                fprintf (stderr, "unknown option: %s\n", argv [i]);

                ignenv = true;

                errno  = EINVAL;

                status = 1;

                break;

            }

        }

    }

    if (!ignenv) {

        // process options from the environment

        const char* const envar = getenv ("RWSTD_TESTOPTS");

        if (envar) {

            recursive = true;

            rw_runopts (envar);

            recursive = false;

        }

    }

    // invoke any inverted callbacks or bump their user-specified counters,

    // and reset internal counters indicating if/how many times each option

    // has been processed

    for (size_t j = 0; j != ncmdopts; ++j) {

        if (cmdopts [j].inv_ && 0 == cmdopts [j].ncalls_ && 0 == status) {

            if (cmdopts [j].callback_)

                status = cmdopts [j].callback_ (0, 0);

            else {

                assert (0 != cmdopts [j].pcntr_);

                ++*cmdopts [j].pcntr_;

            }

        }

        cmdopts [j].ncalls_  = 0;

        cmdopts [j].envseen_ = false;

    }

    return status;

}

/**************************************************************************/

_TEST_EXPORT int

rw_runopts (const char *str)

{

    assert (0 != str);

    rw_set_myopts ();

    char buf [80];      // fixed size buffer to copy `str' into

    char *pbuf = buf;   // a modifiable copy of `str'

    size_t len = strlen (str);

    if (len >= sizeof buf) {

        // allocate if necessary

        pbuf = (char*)malloc (len + 1);

        if (!pbuf)

            return -1;

    }

    // copy `str' to modifiable buffer

    memcpy (pbuf, str, len + 1);

    char *tmp_argv_buf [32] = { 0 };   // fixed size argv buffer

    char **argv = tmp_argv_buf;        // array of arguments

    // initial size of argument array (will grow as necessary)

    size_t argv_size = sizeof tmp_argv_buf / sizeof *tmp_argv_buf;

    size_t argc = 0;   // number of arguments in array

    int in_quotes = 0;   // quoted argument being processed

    for (char *s = pbuf; *s; ++s) {

        if ('"' == *s) {

            in_quotes = !in_quotes;

            continue;

        }

        if (in_quotes)

            continue;

        // split up unquoted space-separated arguments

        if (argc == 0 || ' ' == *s) {

            if (argc > 0) 

                *s = 0;

            // skip over leading spaces

            if (argc > 0 || ' ' == *s)

                while (' ' == *++s);

            if (*s) {

                if (argc == argv_size) {

                    // grow `argv' as necessary

                    char **tmp = (char**)malloc (sizeof *tmp * argv_size * 2);

                    if (!tmp) {

                        if (argv != tmp_argv_buf)

                            free (argv);

                        return -1;

                    }

                    // copy existing elementes and zero out any new entries

                    memcpy (tmp, argv, sizeof *tmp * argv_size);

                    memset (tmp + argv_size, 0, sizeof *tmp * argv_size);

                    // free existing buffer if necessary

                    if (argv != tmp_argv_buf)

                        free (argv);

                    // reassign buffer and increase size

                    argv       = tmp;

                    argv_size *= 2;

                }

                // add argument to array

                argv [argc++] = s;

            }

        }

    }

    // process `argc' options pointed to by `argv'

    const int status = rw_runopts (int (argc), argv);

    // free buffers if necessary

    if (argv != tmp_argv_buf)

        free (argv);

    if (pbuf != buf)

        free (pbuf);

    return status;

}