/***************************************************************************
 *
 * $Id$ 
 *
 ************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you 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.
 *
 * Copyright 2005-2008 Rogue Wave Software, Inc.
 * 
 **************************************************************************/

// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC

#include <rw_cmdopt.h>

#include <ctype.h>    // isdigit(), isspace()
#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, ...

#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

    int            minval_;         // minimum value of a numerical argument
    int            maxval_;         // maximum value of a numerical argument
    size_t         maxcount_;       // how many times option can be invoked
    size_t         count_;          // how many times it has been invoked

    unsigned       arg_ : 1;        // option takes an argument
    unsigned       inv_ : 1;        // callback invocation inverted
    unsigned       tristate_ : 1;   // option is a tristate
    unsigned       envseen_ : 1;    // environment option already processed
};


// total number of registered options
static size_t _rw_ncmdopts;

// number of default (always defined) options
static size_t     _rw_ndefopts;
static cmdopts_t  _rw_cmdoptbuf [32];
static cmdopts_t *_rw_cmdopts = _rw_cmdoptbuf;
static size_t     _rw_optbufsize = sizeof _rw_cmdoptbuf / sizeof *_rw_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 != _rw_ncmdopts; ++i) {

        // for convenience
        const cmdopts_t* const opt = _rw_cmdopts + i;

        // get a pointer to the name of the long option, if any
        const char* const lopt = opt->lopt_ ? opt->lopt_ : opt->loptbuf_;

        if (opthelp && *opthelp) {

            if (   (opt->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;
            }
        }

        // separate options with help functionality (which typically
        // produce multiline output) from previous options without
        // it (and thus very brief output)
        if (i && 0 == _rw_cmdopts [i - 1].callback_ && opt->callback_)
            puts ("");

        printf ("     ");

        if (opt->sopt_) {
            printf ("-%c", opt->sopt_);

            if (lopt)
                printf (" | ");
        }

        const char *pfx = "";
        const char *sfx = pfx;

        if (lopt) {
            printf ("-%s", lopt);
            if (opt->arg_ && '=' != lopt [strlen (lopt) - 1]) {
                pfx = " [ ";
                sfx = " ]";
            }
        }

        const char* const arg =
               _RWSTD_INT_MIN < opt->minval_
            || opt->maxval_ < _RWSTD_INT_MAX ? "int" : "arg";

        if (opt->arg_) {
            // print argument (in brackets when it's optional)
            printf ("%s<%s>%s", pfx, arg, sfx);
        }

        if (opt->pcntr_)
            printf (" | -%s=<%s>", lopt, arg);

        if ('i' == *arg) {
            printf (", with ");

            if (_RWSTD_INT_MIN < opt->minval_)
                printf ("%d <= ", opt->minval_);

            printf ("<%s>", arg);

            if (opt->maxval_ < _RWSTD_INT_MAX)
                printf (" <= %d", opt->maxval_);

            printf ("\n      ");
        }

        if (_RWSTD_SIZE_MAX == opt->maxcount_)
            printf (" (each occurrence evaluated)\n");
        else if (1 < opt->maxcount_)
            printf (" (at most %u occurrences evaluated)\n",
                    unsigned (opt->maxcount_));
        else
            printf (" (only the first occurrence evaluated)\n");

        // invoke callback with the "--help" option
        if (opt->callback_) {

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

            opt->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 != _rw_ncmdopts; ++i) {

        // free any storage allocated for the option name
        free (_rw_cmdopts [i].lopt_);
    }

    if (_rw_cmdopts != _rw_cmdoptbuf) {
        // free the storage allocated for all the options
        free (_rw_cmdopts);
    }

    // reset the options pointer to point at the statically
    // allocated buffer and the count back to 0
    _rw_ncmdopts   = 0;
    _rw_cmdopts    = _rw_cmdoptbuf;
    _rw_optbufsize = sizeof _rw_cmdoptbuf / sizeof *_rw_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 != _rw_ncmdopts)
        return;

    static int recursive;

    if (recursive)
        return;

    ++recursive;

    rw_setopts (""
                "|-help: "       // argument optional
                "|-ignenv ",
                _rw_print_help,
                _rw_set_ignenv);

    _rw_ndefopts = _rw_ncmdopts;

    recursive = 0;
}

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

#ifndef _RWSTD_NO_VA_LIST_ARRAY
   // va_list is an array type
#  define RW_VA_LIST_ARG_PTR                 va_list
#  define RW_VA_LIST_ARG_TO_PTR(va)          va
#  define RW_VA_LIST_PTR_ARG_TO_VA_LIST(va)  va
#else   // if defined (_RWSTD_NO_VA_LIST_ARRAY)
   // va_list is an object type
#  define RW_VA_LIST_ARG_PTR                 va_list*
#  define RW_VA_LIST_ARG_TO_PTR(va)          &va
#  define RW_VA_LIST_PTR_ARG_TO_VA_LIST(pva) *pva
#endif   // _RWSTD_NO_VA_LIST_ARRAY


static const char*
_rw_getbounds (const char *next, char sep, RW_VA_LIST_ARG_PTR pva)
{
    ++next;

    if (   '*' == *next || '+' == *next || '-' == *next || sep == *next
        || isdigit (*next)) {

        bool have_maxval = false;

        if (*next == sep && '-' != sep) {
            have_maxval = true;
            ++next;
        }
        
        char *end = 0;

        // '*' designates an int va_arg argument
        const long val = '*' == *next ?
              long (va_arg (RW_VA_LIST_PTR_ARG_TO_VA_LIST (pva), int))
            : strtol (next, &end, 10);

#if _RWSTD_INT_SIZE < _RWSTD_LONG_SIZE
        // validate
        if (val < _RWSTD_INT_MIN || _RWSTD_INT_MAX < val) {
            fprintf (stderr,
                     "lower bound %ld out of range [%d, %d]: "
                     "%s\n", val, _RWSTD_INT_MIN, _RWSTD_INT_MAX,
                     next);
            return 0;
        }
#endif   // INT_SIZE < LONG_SIZE

        next = end ? end : next + 1;

        if (have_maxval) {
            _rw_cmdopts [_rw_ncmdopts].minval_ = 0;
            _rw_cmdopts [_rw_ncmdopts].maxval_ = int (val);
        }
        else
            _rw_cmdopts [_rw_ncmdopts].minval_ = int (val);

        if (sep == *next && !have_maxval) {
            ++next;

            if (   '*' == *next
                || '+' == *next
                || (val < 0 && '-' == *next)
                || isdigit (*next)) {

                end = 0;

                // '*' designates an int va_arg argument
                const long maxval = '*' == *next ?
                      long (va_arg (RW_VA_LIST_PTR_ARG_TO_VA_LIST (pva), int))
                    : strtol (next, &end, 10);

#if _RWSTD_INT_SIZE < _RWSTD_LONG_SIZE
                // validate
                if (maxval < _RWSTD_INT_MIN || _RWSTD_INT_MAX < maxval) {

                    fprintf (stderr,
                             "upper bound %ld out of range [%ld, %d]: "
                             "%s\n", maxval, val, _RWSTD_INT_MAX,
                             next);
                    return 0;
                }
#endif   // INT_SIZE < LONG_SIZE

                if ('-' == sep && maxval < val) {
                    // invalid range (upper bound < lower bound
                    fprintf (stderr,
                             "invalid range [%ld, %ld]: %s\n",
                             val, maxval, next);
                    return 0;
                }

                next = end ? end : next + 1;
                _rw_cmdopts [_rw_ncmdopts].maxval_ = int (maxval);
            }
            else {
                // syntax error in range
                fprintf (stderr,
                         "syntax error in range specification: %s\n",
                         next);
                return 0;
            }
        }
        else if (*next && !isspace (*next)) {
            // syntax error in numeric argument
            fprintf (stderr,
                     "syntax error numeric argument: %s\n",
                     next);
            return 0;
        }
        else if (!have_maxval) {
            // no upper bound on the value of the option argument
            _rw_cmdopts [_rw_ncmdopts].maxval_ = _RWSTD_INT_MAX;
        }
    }
    else if (':' == sep) {
        // special value indicating no bits specified for a tristate
        _rw_cmdopts [_rw_ncmdopts].minval_ = 0;
        _rw_cmdopts [_rw_ncmdopts].maxval_ = 0;
    }
    else {
        // no minimum/maximum value for this option is set
        _rw_cmdopts [_rw_ncmdopts].minval_ = _RWSTD_INT_MIN;
        _rw_cmdopts [_rw_ncmdopts].maxval_ = _RWSTD_INT_MAX;
    }

    // an unlimited number of occurrences of the option
    // are allowed and will be counted
    _rw_cmdopts [_rw_ncmdopts].maxcount_ = _RWSTD_SIZE_MAX;

    return next;
}


_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 ( ; ; ++_rw_ncmdopts) {

        while (isspace (*next))
            ++next;

        if ('\0' == *next) {
            break;
        }

        if (_rw_ncmdopts == _rw_optbufsize) {

            const size_t newbufsize = 2 * _rw_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, _rw_cmdopts, _rw_ncmdopts * sizeof (cmdopts_t));

            if (_rw_cmdopts != _rw_cmdoptbuf)
                free (_rw_cmdopts);

            _rw_cmdopts    = newopts;
            _rw_optbufsize = newbufsize;
        }

        // clear the next option info
        memset (_rw_cmdopts + _rw_ncmdopts, 0, sizeof *_rw_cmdopts);

        // for convenience
        cmdopts_t* const lastopt = _rw_cmdopts + _rw_ncmdopts;

        lastopt->minval_ = _RWSTD_INT_MIN;
        lastopt->maxval_ = _RWSTD_INT_MAX;

        if ('|' != *next)
            lastopt->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 lastopt->loptbuf_)
                lopt = lastopt->loptbuf_;
            else {
                lopt = (char*)malloc (optlen + 1);
                if (0 == lopt)
                    return -1;   // error
                lastopt->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
        lastopt->maxcount_ = 1;

        int arg_is_callback = true;

        RW_ASSERT (0 != next);

        if ('#' == *next) {
            // examples of option specification:
            //   --foo#     option takes an optional numeric argument
            //   --foo#3    numeric argument must be equal to 3
            //   --foo#1-5  numeric argument must be in the range [1,5]

            // instead 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 N, the value of N will be stored instead
            next = _rw_getbounds (next, '-', RW_VA_LIST_ARG_TO_PTR (va));

            if (0 == next)
                return -1;   // error

            arg_is_callback = false;

        }
        else if ('~' == *next) {
            // examples of option specification:
            //   --foo~      word 0
            //   --foo~3     word 3
            //   --foo~:4    word 0, bit 2
            //   --foo~3:6   word 3, bits 2 and 3

            // get the optional word number and bit number
            next = _rw_getbounds (next, ':', RW_VA_LIST_ARG_TO_PTR (va));

            if (0 == next)
                return -1;   // error

            // unlimited number of tristates are allowed
            lastopt->tristate_ = 1;

            // no callback function expected
            arg_is_callback = false;
        }
        else if (':' == *next || '=' == *next) {
            // ':' : argument optional
            // '=' : argument required
            lastopt->arg_ = true;

            // check if the value of the argument is restricted
            next = _rw_getbounds (next, '-', RW_VA_LIST_ARG_TO_PTR (va));

            if (0 == next)
                return -1;   // error
        }

        if ('@' == *next) {

            ++next;

            // at most how many occurrences of an option can be processed?
            if ('*' == *next) {
                // unlimited
                lastopt->maxcount_ = _RWSTD_SIZE_MAX;
                ++next;
            }
            else {
                // at most this many
                char *end;
                lastopt->maxcount_ = strtoul (next, &end, 10);
                next = end;
            }
        }
        else if ('!' == *next) {
            lastopt->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)
            lastopt->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
            lastopt->pcntr_ = va_arg (va, int*);
        }

        if (   '-' != lastopt->sopt_
            && 0 == lastopt->callback_
            && 0 == lastopt->pcntr_) {

            // get a pointer to the long option name
            const char* const lopt = lastopt->lopt_
                ? lastopt->lopt_ : lastopt->loptbuf_;

            if (*lopt)
                fprintf (stderr, "null handler for option -%s\n", lopt);
            else
                fprintf (stderr, "null handler for option -%c\n",
                         lastopt->sopt_);
                
            abort ();
        }
    }

    return int (_rw_ncmdopts - _rw_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;
}

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

// validates (and optionally stores) a restricted numeric option argument
static int
_rw_getarg (cmdopts_t *optspec, const char *opt, const char *arg)
{
    RW_ASSERT (0 != optspec);
    RW_ASSERT (0 != arg);

    // obtain the numeric argument
    char *end = 0;
    const long optval = strtol (arg, &end, 0);

    int status = 0;

    if (end && '\0' != *end) {
        fprintf (stderr, "expected numeric argument: %s\n", opt);
        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, opt);
        errno  = EINVAL;
        status = 1;
    }

#endif   // _RWSTD_INT_SIZE < _RWSTD_LONG_SIZE

    else if (   optval < long (optspec->minval_)
             || long (optspec->maxval_) < optval) {
        
        // numeric argument out of range
        fprintf (stderr, "numeric argument %ld out of range"
                 " [%d, %d]: %s\n", optval,
                 optspec->minval_, optspec->maxval_, opt);
        errno  = EINVAL;
        status = 1;
    }
    else if (optspec->pcntr_) {

        // set the counter
        *optspec->pcntr_ = int (optval);
    }

    return status;
}

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

static bool
_rw_runopt_recursive = false;


// processes a single command line option and its arguments
static int
_rw_runopt (cmdopts_t *optspec, int argc, char *argv[])
{
    RW_ASSERT (0 != optspec);
    RW_ASSERT (0 != argv);

    // 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 (optspec->count_ && _rw_runopt_recursive)
        return 0;

    // if the option has been evaluated the maximum number
    // of times, avoid evaluating it and continue processing
    if (optspec->maxcount_ <= optspec->count_)
        return 0;

    int status = 0;

    char* equals = strchr (argv [0], '=');

    if (optspec->callback_) {
        // option matched the specification

        if (!optspec->inv_) {
            // option is not inverted (i.e., is processed when seen
            // on the command line as opposed processed when missing)

            const char* const lopt = optspec->lopt_ ?
                optspec->lopt_ : optspec->loptbuf_;

            if (   optspec->arg_
                && (   _RWSTD_INT_MIN < optspec->minval_
                    || optspec->maxval_ < _RWSTD_INT_MAX)) {

                if (equals) {
                    if (strchr (lopt, '=')) {
                        // option requires a restricted numeric argument
                        // retrieve and validate it before invoking the
                        // callback

                        status = _rw_getarg (optspec, argv [0], equals + 1);
                    }
                }
                else if (1 < argc && '-' != argv [1][0]) {

                    const char *arg = argv [1];

                    // handle escaped minus (necessary to disambiguate
                    // it from a leading dash that introduces an option)
                    if ('\\' == arg [0] && '-' == arg [1])
                        ++arg;

                    status = _rw_getarg (optspec, argv [0], arg);
                }
            }

            if (0 == status)
                status = optspec->callback_ (argc, argv);
        }
    }
    else if (equals) {
        // option takes an optional numeric argument

        RW_ASSERT (0 != optspec->pcntr_);

        status = _rw_getarg (optspec, argv [0], equals + 1);
    }
    else {
        // option must not be a tristate (those are handled elsewhere)
        RW_ASSERT (0 == optspec->tristate_);
        RW_ASSERT (0 != optspec->pcntr_);
        ++*optspec->pcntr_;
    }

    ++optspec->count_;

    if (_rw_runopt_recursive)
        optspec->envseen_ = true;

    return status;
}

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

// tries to match the option named by optname with the option
// specification opt and returns a non-zero value on success,
// 0 otherwise; the returned value is negative when the matched
// option is being disabled and positive when it's being
// enabled
static int
_rw_match_tristate (const cmdopts_t *opt, const char *optname)
{
    RW_ASSERT (0 != opt);
    RW_ASSERT (0 != optname);

    static const char* const prefix[] = {
        "+enable", "+use", "+with", 
        "-disable", "-no", "-without",
        0
    };

    int tristate = 0;

    if ('-' == optname [0] && '-' != optname [2]) {

        ++optname;

        const size_t optlen = strlen (optname);

        for (size_t i = 0; prefix [i]; ++i) {
            const char* const pfx    = prefix [i] + 1;
            const size_t      pfxlen = strlen (pfx);

            if (pfxlen < optlen && 0 == memcmp (optname, pfx, pfxlen)) {
                const char* const name = optname + pfxlen;

                // return -1 to disable, +1 to enable, 0 when not found
                const char* const lopt =
                    opt->lopt_ ? opt->lopt_ : opt->loptbuf_;

                if (0 == strcmp (lopt, name)) {
                    tristate = '+' == prefix [i][0] ? 1 : -1;
                    break;
                }
            }
        }
    }

    return tristate;
}

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

// returns a bitmap all of whose bits are set starting with the most
// significant non-zero bit corresponding to first such bit in val
// e.g., _rw_set_bits(4) --> 7
static int
_rw_set_bits (int val)
{
    int res = 0;

    for (unsigned uval = val; uval; uval >>= 1) {
        res = (res << 1) | 1;
    }

    return res;
}


_TEST_EXPORT int
rw_runopts (int argc, char *argv[])
{
    _rw_set_myopts ();

    // ignore options set in the environment?
    int ignenv = _rw_runopt_recursive;

    // return status
    int status = 0;

    // number of options processed
    int nopts = 0;

    // pointer to the option whose callback will be invoked
    // for command line options that do not match any other
    cmdopts_t* not_found_opt = 0;

    // 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;

        // the argc and argv to pass to the option handler
        const int    opt_argc = argc - i;
        char** const opt_argv = argv + i;

        // 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 != _rw_ncmdopts; ++j) {

            // for convenience
            cmdopts_t* const opt = _rw_cmdopts + j;

            if ('-' == opt->sopt_)
                not_found_opt = opt;

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

                const size_t cmplen =
                    eq && opt->pcntr_ ? optlen - 1 : optlen;

                // get a pointer to the (possibly empty) name
                // of the long option
                const char* const lopt = opt->lopt_ ? 
                    opt->lopt_ : opt->loptbuf_;

                if (opt->tristate_) {
                    // option specification denotes a tristate, see if it
                    // matches and if so, whether it's being disabled or
                    // enabled (-1 or +1, respectively)
                    const int tristate = _rw_match_tristate (opt, optname);

                    if (tristate) {
                        RW_ASSERT (0 != opt->pcntr_);

                        const int word_bits = _RWSTD_CHAR_BIT * sizeof (int);

                        // the optional minval_ specifies the bit number
                        // of the first of a sequence of bits in an array
                        // stored at pcntr_
                        const int word_inx = opt->minval_ / word_bits;
                        const int bit_inx  = opt->minval_ % word_bits;

                        const int bit_val = _RWSTD_INT_MAX == opt->maxval_
                            ? 1 : opt->maxval_;

                        if (bit_val) {
                            const int bit_mask =
                                _rw_set_bits (bit_val) << bit_inx;

                            // clear the bit field
                            opt->pcntr_ [word_inx] &= ~bit_mask;

                            if (tristate < 0)
                                opt->pcntr_ [word_inx] = ~(bit_val << bit_inx);
                            else
                                opt->pcntr_ [word_inx] |= bit_val << bit_inx;
                        }
                        else {
                            // special case
                            opt->pcntr_ [word_inx] = tristate < 0 ? -1 : +1;
                        }

                        // matching option has been found
                        found = true;

                        // increment the number of options processed
                        ++nopts;
                    }

                    // avoid ordinary option processing below
                    continue;
                }

                // 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))
                    || (   opt->sopt_
                        && optname [0] == opt->sopt_
                        && (1 == optlen || opt->arg_))) {

                    // matching option has been found
                    found = true;

                    // process it and its arguments, if any
                    status = _rw_runopt (opt, opt_argc, opt_argv);

                    // increment the number of options processed
                    // (whether successfully or otherwise)
                    ++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 (0 != not_found_opt) {

                // 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 = not_found_opt->callback_ (opt_argc, opt_argv);
                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) {
            _rw_runopt_recursive = true;
            rw_runopts (envar);
            _rw_runopt_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 != _rw_ncmdopts; ++j) {

        // for convenience
        cmdopts_t* const opt = _rw_cmdopts + j;

        if (opt->inv_ && 0 == opt->count_ && 0 == status) {

            if (opt->callback_)
                status = opt->callback_ (0, 0);
            else {
                RW_ASSERT (0 != opt->pcntr_);
                ++*opt->pcntr_;
            }
        }

        opt->count_   = 0;
        opt->envseen_ = false;
    }

    return status;
}

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

_TEST_EXPORT int
rw_runopts (const char *str)
{
    RW_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 || isspace (*s)) {
            if (argc > 0) 
                *s = 0;

            // skip over leading spaces
            if (argc > 0 || isspace (*s))
                while (isspace (*++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;
}