#ifndef _WIN32
#include <sys/ioctl.h>
#include <termios.h>
#else
#include <windows.h>
#endif

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <errno.h>
#include <ctype.h>

#include "cliopts.h"


enum {
    CLIOPTS_ERR_SUCCESS,
    CLIOPTS_ERR_NEED_ARG,
    CLIOPTS_ERR_ISSWITCH,
    CLIOPTS_ERR_BADOPT,
    CLIOPTS_ERR_BAD_VALUE,
    CLIOPTS_ERR_UNRECOGNIZED
};

struct cliopts_priv {
    cliopts_entry *entries;

    cliopts_entry *prev;
    cliopts_entry *current;
    struct cliopts_extra_settings *settings;

    char *errstr;
    int errnum;

    int argsplit;
    int wanted;

    char current_key[4096];
    char current_value[4096];
};

enum {
    WANT_OPTION,
    WANT_VALUE,

    MODE_ERROR,
    MODE_RESTARGS,
    MODE_HELP
};

#define INDENT "  "

#ifdef CLIOPTS_DEBUG

#define cliopt_debug(...) \
    fprintf(stderr, "(%s:%d) ", __func__, __LINE__); \
    fprintf(stderr, __VA_ARGS__); \
    fprintf(stderr, "\n")

#else
/** variadic macros not c89 */
static void cliopt_debug(void *unused, ...) { (void)unused; }
#endif /* CLIOPT_DEBUG */

static int
parse_option(struct cliopts_priv *ctx, const char *key);


static int
parse_value(struct cliopts_priv *ctx, const char *value);

static void
add_list_value(const char *src, size_t nsrc, cliopts_list *l)
{
    char *cp = malloc(nsrc + 1);

    if (!l->nalloc) {
        l->nalloc = 2;
        l->values = malloc(l->nalloc * sizeof(*l->values));
    } else {
        l->nalloc *= 1.5;
        l->values = realloc(l->values, sizeof(*l->values) * l->nalloc);
    }

    l->values[l->nvalues++] = cp;
    cp[nsrc] = '\0';
    memcpy(cp, src, nsrc);
}

CLIOPTS_API
void
cliopts_list_clear(cliopts_list *l)
{
    size_t ii;
    for (ii = 0; ii < l->nvalues; ii++) {
        free(l->values[ii]);
    }
    free(l->values);
    l->values = NULL;
    l->nvalues = 0;
    l->nalloc = 0;
}

static void
add_pair_list_value(const char *src, size_t nsrc, cliopts_pair_list *l)
{
    char *key = NULL, *val = NULL;
    char *sep = memchr(src, '=', nsrc);
    if (sep == NULL) {
        key = malloc(nsrc + 1);
        memcpy(key, src, nsrc);
        key[nsrc] = '\0';
        val = malloc(1);
        val[0] = '\0';
    } else {
        char *pp = sep;
        size_t nkey = sep - src;
        size_t nval = nsrc - nkey - 1;
        for (; pp > src; pp--, nkey--) {
            if (*pp != ' ' && *pp != '\t' && *pp != '\0') {
                break;
            }
        }
        key = malloc(nkey + 1);
        memcpy(key, src, nkey);
        key[nkey] = '\0';
        val = malloc(nval + 1);
        memcpy(val, sep + 1, nval);
        val[nval] = '\0';
    }

    if (!l->nalloc) {
        l->nalloc = 2;
        l->keys = malloc(l->nalloc * sizeof(*l->keys));
        l->values = malloc(l->nalloc * sizeof(*l->values));
    } else {
        l->nalloc *= 1.5;
        l->keys = realloc(l->keys, sizeof(*l->keys) * l->nalloc);
        l->values = realloc(l->values, sizeof(*l->values) * l->nalloc);
    }

    l->keys[l->nvalues] = key;
    l->values[l->nvalues] = val;
    l->nvalues++;
}

CLIOPTS_API
void
cliopts_pair_list_clear(cliopts_pair_list *l)
{
    size_t ii;
    for (ii = 0; ii < l->nvalues; ii++) {
        free(l->keys[ii]);
        free(l->values[ii]);
    }
    free(l->keys);
    free(l->values);
    l->keys = NULL;
    l->values = NULL;
    l->nvalues = 0;
    l->nalloc = 0;
}

/**
 * Various extraction/conversion functions for numerics
 */

#define _VERIFY_INT_COMMON(m1, m2) \
    if (value == m1 || value > m2) { *errp = "Value too large"; return -1; } \
    if (*endptr != '\0') { *errp = "Trailing garbage"; return -1; }

static int
extract_int(const char *s, void *dest, char **errp)
{
    long int value;
    char *endptr = NULL;
    value = strtol(s, &endptr, 10);
    _VERIFY_INT_COMMON(LONG_MAX, INT_MAX)
    *(int*)dest = value;
    return 0;
}

static int
extract_uint(const char *s, void *dest, char **errp)
{
    unsigned long int value;
    char *endptr = NULL;
    value = strtoul(s, &endptr, 10);
    _VERIFY_INT_COMMON(ULONG_MAX, UINT_MAX)
    *(unsigned int*)dest = value;
    return 0;
}

#ifdef ULLONG_MAX
static int
extract_ulonglong(const char *s, void *dest, char **errp)
{
    unsigned long long value;
    char *endptr = NULL;
#ifdef _WIN32
    value = _strtoui64(s, &endptr, 10);
#else
    value = strtoull(s, &endptr, 10);
#endif
    _VERIFY_INT_COMMON(ULLONG_MAX, ULLONG_MAX);
    *(unsigned long long *)dest = value;
    return 0;
}
#else
static int extract_ulonglong(const char *s, void *dest, char **errp)
{
    *errp = "long long not available";
    return -1;
}
#endif /* ULLONG_MAX */

static int
extract_hex(const char *s, void *dest, char **errp)
{
    unsigned long value;
    char *endptr = NULL;
    value = strtoul(s, &endptr, 16);
    _VERIFY_INT_COMMON(ULONG_MAX, UINT_MAX);
    *(unsigned int*)dest = value;
    return 0;
}

#undef _VERIFY_INT_COMMON

static int
extract_float(const char *s, void *dest, char **errp)
{
    char dummy_buf[4096];
    float value;
    if (sscanf(s, "%f%s", &value, dummy_buf) != 1) {
        *errp = "Found trailing garbage";
        return -1;
    }
    *(float*)dest = value;
    return 0;
}

typedef int(*cliopts_extractor_func)(const char*, void*, char**);


/**
 * This function tries to extract a single value for an option key.
 * If it successfully has extracted a value, it returns MODE_VALUE.
 * If the entry takes no arguments, then the current string is a key,
 * and it will return MODE_OPTION. On error, MODE_ERROR is set, and errp
 * will point to a string.
 *
 * @param entry The current entry
 * @param value the string which might be a value
 * @errp a pointer which will be populated with the address of the error, if any
 *
 * @return a MODE_* type
 */
static int
parse_value(struct cliopts_priv *ctx,
            const char *value)
{
    cliopts_entry *entry = ctx->current;

    size_t vlen = strlen(value);
    cliopts_extractor_func exfn = NULL;
    int exret;
    int is_option = 0;

    cliopt_debug("Called with %s, want=%d", value, ctx->wanted);

    if (ctx->argsplit) {
        if (vlen > 2 && strncmp(value, "--", 2) == 0) {
            is_option = 1;
        } else if (*value == '-') {
            is_option = 1;
        }
    }

    if (is_option) {
        ctx->errstr = "Expected option. Got '-' or '--' prefixed value "
                        "(use = if this is really a value)";
        ctx->errnum = CLIOPTS_ERR_NEED_ARG;
        return MODE_ERROR;
    }

    if (entry->ktype == CLIOPTS_ARGT_STRING) {
        char *vp = malloc(vlen+1);
        vp[vlen] = 0;
        strcpy(vp, value);
        free(*(char**)entry->dest);
        *(char**)entry->dest = vp;
        return WANT_OPTION;
    }

    if (entry->ktype == CLIOPTS_ARGT_LIST) {
        add_list_value(value, vlen, (cliopts_list *)entry->dest);
        return WANT_OPTION;
    }
    if (entry->ktype == CLIOPTS_ARGT_PAIR_LIST) {
        add_pair_list_value(value, vlen, (cliopts_pair_list *)entry->dest);
        return WANT_OPTION;
    }

    if (entry->ktype == CLIOPTS_ARGT_FLOAT) {
        exfn = extract_float;
    } else if (entry->ktype == CLIOPTS_ARGT_HEX) {
        exfn = extract_hex;
    } else if (entry->ktype == CLIOPTS_ARGT_INT) {
        exfn = extract_int;
    } else if (entry->ktype == CLIOPTS_ARGT_UINT) {
        exfn = extract_uint;
    } else if (entry->ktype == CLIOPTS_ARGT_ULONGLONG) {
        exfn = extract_ulonglong;
    } else {
        fprintf(stderr, "Unrecognized type %d.\n", entry->ktype);
        return MODE_ERROR;
    }

    exret = exfn(value, entry->dest, &ctx->errstr);
    if (exret == 0) {
        return WANT_OPTION;
    } else {
        ctx->errnum = CLIOPTS_ERR_BAD_VALUE;
    }

    return MODE_ERROR;
}

/**
 * Like parse_value, except for keys.
 *
 * @param entries all option entries
 * @param key the current string from argv
 * @param errp a pointer which will be populated with the address of an error
 * string
 *
 * @param found_entry a pointer to be populated with the relevant entry
 * structure
 * @param kp a pointer which will be poplated with the address of the 'sanitized'
 * key string
 *
 * @param valp if the string is actually a key-value pair (i.e. --foo=bar) then
 * this will be populated with the address of that string
 *
 * @return MODE_OPTION if an option was found, MODE_VALUE if the current option
 * is a value, or MODE_ERROR on error
 */
static int
parse_option(struct cliopts_priv *ctx,
          const char *key)
{
    cliopts_entry *cur = NULL;
    int prefix_len = 0;
    unsigned ii = 0;
    const char *valp = NULL;
    size_t klen;

    klen = strlen(key);
    ctx->errstr = NULL;
    ctx->prev = ctx->current;
    ctx->current = NULL;

    cliopt_debug("Called with %s, want=%d", key, ctx->wanted);
    if (klen == 0) {
        ctx->errstr = "Got an empty string";
        ctx->errnum = CLIOPTS_ERR_BADOPT;
        return MODE_ERROR;
    }

    /**
     * figure out what type of option it is..
     * it can either be a -c, --long, or --long=value
     */
    while (*key == '-') {
        key++;
        prefix_len++;
        klen--;
    }

    for (ii = 0; ii < klen; ii++) {
        if (key[ii] == '"' || key[ii] == '\'') {
            ii = klen;
            break;

        } else if (key[ii] == '=' && prefix_len == 2) {
            /* only split on '=' if we're called as '--' */
            valp = key + (ii + 1);
            klen = ii;
            break;
        }
    }

    GT_PARSEOPT:
    memset(ctx->current_value, 0, sizeof(ctx->current_value));
    memcpy(ctx->current_key, key, klen);
    ctx->current_key[ii] = '\0';

    if (valp) {
        strcpy(ctx->current_value, valp);
    }

    if (prefix_len == 0 || prefix_len > 2) {
        if (ctx->settings->restargs) {
            key -= prefix_len;
            ctx->settings->restargs[ctx->settings->nrestargs++] = key;
            return WANT_OPTION;
        } else if (ctx->prev && ctx->prev->ktype == CLIOPTS_ARGT_NONE) {
            ctx->errstr = "Option does not accept a value";
            ctx->errnum = CLIOPTS_ERR_ISSWITCH;
        } else {
            ctx->errstr = "Options must begin with either '-' or '--'";
            ctx->errnum = CLIOPTS_ERR_BADOPT;
        }
        return MODE_ERROR;
    }

    /**
     * --help or -?
     */

    if ( (prefix_len == 1 && *key == '?') ||
            (prefix_len == 2 && strcmp(key, "help") == 0)) {
        return MODE_HELP;
    }

    /**
     * Bare --
     */
    if (prefix_len == 2 && *key == '\0') {
        if (ctx->settings->restargs) {

        }
        if (ctx->wanted == WANT_VALUE) {
            ctx->errnum = CLIOPTS_ERR_NEED_ARG;
            ctx->errstr = "Found bare '--', but value wanted";
            return MODE_ERROR;
        }

        return MODE_RESTARGS;
    }

    for (cur = ctx->entries; cur->dest; cur++) {
        int optlen;
        if (prefix_len == 1) {
            if (cur->kshort == ctx->current_key[0]) {
                ctx->current = cur;
                break;
            }
            continue;
        }
        /** else, prefix_len is 2 */
        if (cur->klong == NULL ||
                (optlen = strlen(cur->klong) != klen) ||
                strncmp(cur->klong, ctx->current_key, klen) != 0) {

            continue;
        }

        ctx->current = cur;
        break;
    }

    if (!ctx->current) {
        ctx->errstr = "Unknown option";
        ctx->errnum = CLIOPTS_ERR_UNRECOGNIZED;
        return MODE_ERROR;
    }

    ctx->current->found++;
    if (ctx->current->ktype != CLIOPTS_ARGT_NONE) {
        ctx->wanted = WANT_VALUE;
    }

    if (ctx->current_value[0]) {
        /* --foo=bar */
        if (ctx->current->ktype == CLIOPTS_ARGT_NONE) {
            ctx->errnum = CLIOPTS_ERR_ISSWITCH;
            ctx->errstr = "Option takes no arguments";
            return MODE_ERROR;
        } else {
            return parse_value(ctx, ctx->current_value);
        }
    }

    if (ctx->current->ktype == CLIOPTS_ARGT_NONE) {
        *(char*)ctx->current->dest = 1;

        if (prefix_len == 1 && klen > 1) {
            /**
             * e.g. ls -lsh
             */
            klen--;
            key++;

            /**
             * While we can also possibly recurse, this may be a security risk
             * as it wouldn't take much to cause a deep recursion on the stack
             * which will cause all sorts of nasties.
             */
            goto GT_PARSEOPT;
        }
        return WANT_OPTION;

    } else if (prefix_len == 1 && klen > 1) {

        /* e.g. patch -p0 */
        ctx->wanted = WANT_VALUE;
        return parse_value(ctx, key + 1);
    }
    return WANT_VALUE;
}

static char *
get_option_name(cliopts_entry *entry, char *buf)
{
    /* [-s,--option] */
    char *bufp = buf;
    bufp += sprintf(buf, "[");
    if (entry->kshort) {
        bufp += sprintf(bufp, "-%c", entry->kshort);
    }
    if (entry->klong) {
        if (entry->kshort) {
            bufp += sprintf(bufp, ",");
        }
        bufp += sprintf(bufp, "--%s", entry->klong);
    }
    sprintf(bufp, "]");
    return buf;
}

static int get_terminal_width(void)
{
#ifndef _WIN32
    struct winsize max;
    if (ioctl(0, TIOCGWINSZ, &max) != -1) {
        return max.ws_col;
    } else {
        return 80;
    }
#else
    CONSOLE_SCREEN_BUFFER_INFO cbsi;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cbsi);
    return cbsi.srWindow.Right - cbsi.srWindow.Left;
#endif
}

static char*
format_option_help(cliopts_entry *entry,
                   char *buf,
                   struct cliopts_extra_settings *settings)
{
    char *bufp = buf;
    if (entry->kshort) {
        bufp += sprintf(bufp, " -%c ", entry->kshort);
    }

#define _advance_margin(offset) \
    while(bufp-buf < offset || *bufp) { \
        if (!*bufp) { \
            *bufp = ' '; \
        } \
        bufp++; \
    }

    _advance_margin(4)

    if (entry->klong) {
        bufp += sprintf(bufp, " --%s ", entry->klong);
    }

    if (entry->vdesc) {
        bufp += sprintf(bufp, " <%s> ", entry->vdesc);
    }

    _advance_margin(35)
#undef _advance_margin

    if (entry->help) {
        unsigned initial_indent = bufp - buf + 1;
        int curpos = initial_indent;
        const char *help_p = entry->help;

        for (; *help_p; help_p++, curpos++, bufp++) {

            if (curpos >= settings->line_max) {
                unsigned ii;
                if (!isspace(*help_p) && !isspace(*(help_p-1))) {
                    *bufp = '-';
                    bufp++;
                }
                *bufp = '\n';
                bufp++;

                for (ii = 0; ii < initial_indent+1; ii++, bufp++) {
                    *bufp = ' ';
                }

                curpos = initial_indent;
                if (isspace(*help_p)) {
                    bufp--;
                    continue;
                }
            }
            *bufp = *help_p;
        }
    }

    *bufp = '\0';
    return buf;
}

static void
print_help(struct cliopts_priv *ctx, struct cliopts_extra_settings *settings)
{
    cliopts_entry *cur;
    cliopts_entry helpent = { 0 };
    char helpbuf[1024] = { 0 };

    helpent.klong = "help";
    helpent.kshort = '?';
    helpent.help = "this message";

    fprintf(stderr, "Usage:\n");
    fprintf(stderr, "  %s %s\n\n", settings->progname, settings->argstring);
    if (settings->shortdesc) {
        fprintf(stderr, "%s", settings->shortdesc);
        fprintf(stderr, "\n");
    }


    for (cur = ctx->entries; cur->dest; cur++) {
        if (cur->hidden) {
            continue;
        }

        memset(helpbuf, 0, sizeof(helpbuf));
        format_option_help(cur, helpbuf, settings);
        fprintf(stderr, INDENT "%s", helpbuf);


        if (settings->show_defaults) {
            fprintf(stderr, " [Default=");

            switch (cur->ktype) {
            case CLIOPTS_ARGT_STRING:
                fprintf(stderr, "'%s'", (cur->dest && *(char **)cur->dest) ?
                        *(char**)cur->dest : "");
                break;
            case CLIOPTS_ARGT_LIST: {
                size_t ii;
                cliopts_list *l = (cliopts_list *)cur->dest;
                for (ii = 0; ii < l->nvalues; ii++) {
                    fprintf(stderr, "'%s'", l->values[ii]);
                    if (ii != l->nvalues-1) {
                        fprintf(stderr, ", ");
                    }
                }
                break;
            }
            case CLIOPTS_ARGT_PAIR_LIST: {
                size_t ii;
                cliopts_pair_list *l = (cliopts_pair_list *)cur->dest;
                for (ii = 0; ii < l->nvalues; ii++) {
                    fprintf(stderr, "'%s=%s'", l->keys[ii], l->values[ii]);
                    if (ii != l->nvalues-1) {
                        fprintf(stderr, ", ");
                    }
                }
                break;
            }
            case CLIOPTS_ARGT_FLOAT:
                fprintf(stderr, "%0.2f", *(float*)cur->dest);
                break;
            case CLIOPTS_ARGT_HEX:
                fprintf(stderr, "0x%x", *(int*)cur->dest);
                break;
            case CLIOPTS_ARGT_INT:
                fprintf(stderr, "%d", *(int*)cur->dest);
                break;
            case CLIOPTS_ARGT_UINT:
                fprintf(stderr, "%u", *(unsigned int*)cur->dest);
                break;
#ifdef ULLONG_MAX
            case CLIOPTS_ARGT_ULONGLONG:
                fprintf(stderr, "%llu", *(unsigned long long*)cur->dest);
                break;
#endif
            case CLIOPTS_ARGT_NONE:
                fprintf(stderr, "%s", *(int*)cur->dest ? "TRUE" : "FALSE");
                break;
            default:
                fprintf(stderr, "Unknown option type '%d'", (int)cur->ktype);
                break;
            }
            fprintf(stderr, "]");
        }
        fprintf(stderr, "\n");
    }
    memset(helpbuf, 0, sizeof(helpbuf));
    fprintf(stderr, INDENT "%s\n",
            format_option_help(&helpent, helpbuf, settings));

}

static void
dump_error(struct cliopts_priv *ctx)
{
    fprintf(stderr, "Couldn't parse options: %s\n", ctx->errstr);
    if (ctx->errnum == CLIOPTS_ERR_BADOPT) {
        fprintf(stderr, "Bad option: %s", ctx->current_key);
    } else if (ctx->errnum == CLIOPTS_ERR_BAD_VALUE) {
        fprintf(stderr, "Bad value '%s' for %s",
                ctx->current_value,
                ctx->current_key);
    } else if (ctx->errnum == CLIOPTS_ERR_UNRECOGNIZED) {
        fprintf(stderr, "No such option: %s", ctx->current_key);
    } else if (ctx->errnum == CLIOPTS_ERR_ISSWITCH) {
        char optbuf[64] = { 0 };
        fprintf(stderr, "Option %s takes no arguments",
                get_option_name(ctx->prev, optbuf));
    }
    fprintf(stderr, "\n");

}

CLIOPTS_API
int
cliopts_parse_options(cliopts_entry *entries,
                      int argc,
                      char **argv,
                      int *lastidx,
                      struct cliopts_extra_settings *settings)
{
    /**
     * Now let's build ourselves a
     */
    int curmode;
    int ii, ret = 0, lastidx_s = 0;
    struct cliopts_priv ctx = { 0 };
    struct cliopts_extra_settings default_settings = { 0 };

    if (!lastidx) {
        lastidx = &lastidx_s;
    }

    ctx.entries = entries;

    if (!settings) {
        settings = &default_settings;
        settings->show_defaults = 1;
    }
    if (!settings->progname) {
        settings->progname = argv[0];
    }
    if (!settings->argstring) {
        settings->argstring = "[OPTIONS...]";
    }
    settings->nrestargs = 0;

    if (!settings->line_max) {
        settings->line_max = get_terminal_width() - 3;
    }

    ii = (settings->argv_noskip) ? 0 : 1;

    if (ii >= argc) {
        *lastidx = 0;
        ret = 0;
        goto GT_CHECK_REQ;
        return 0;
    }

    curmode = WANT_OPTION;
    ctx.wanted = curmode;
    ctx.settings = settings;

    for (; ii < argc; ii++) {

        if (curmode == WANT_OPTION) {
            curmode = parse_option(&ctx, argv[ii]);
        } else if (curmode == WANT_VALUE) {
            curmode = parse_value(&ctx, argv[ii]);
        }

        if (curmode == MODE_ERROR) {
            if (settings->error_nohelp == 0) {
                dump_error(&ctx);
            }
            ret = -1;
            break;
        } else if (curmode == MODE_HELP) {
            if (settings->help_noflag) {
                /* ignore it ? */
                continue;
            }

            print_help(&ctx, settings);
            if (!settings->help_noexit) {
                exit(0);
            }

        } else if (curmode == MODE_RESTARGS) {
            ii++;
            break;
        } else {
            ctx.wanted = curmode;
        }
    }

    *lastidx = ii;

    if (curmode == WANT_VALUE) {
        ret = -1;

        if (settings->error_nohelp == 0) {
            fprintf(stderr,
                    "Option %s requires argument\n",
                    ctx.current_key);
        }
        goto GT_RET;
    }

    GT_CHECK_REQ:
    {
        cliopts_entry *cur_ent;
        for (cur_ent = entries; cur_ent->dest; cur_ent++) {
            char entbuf[128] = { 0 };
            if (cur_ent->found || cur_ent->required == 0) {
                continue;
            }

            ret = -1;
            if (settings->error_nohelp) {
                goto GT_RET;
            }

            fprintf(stderr, "Required option %s missing\n",
                    get_option_name(cur_ent, entbuf));
        }
    }

    GT_RET:
    if (ret == -1) {
        if (settings->error_nohelp == 0) {
            print_help(&ctx, settings);
        }
        if (settings->error_noexit == 0) {
            exit(EXIT_FAILURE);
        }
    }
    return ret;
}

CLIOPTS_API
int cliopts_split_args(char *args, int *argc, char ***argv)
{
    char *p = args;
    char *current = NULL;
    int skip = 0;

    *argc = 0;
    *argv = NULL;

#define ch(x) (*(x + skip))

    while (1) {

        while (ch(p) && isspace(ch(p))) {
            p++;
        }
        if (*p) {
            int insq = 0;
            int done = 0;

            if (current == NULL) {
                current = p;
            }
            while (!done) {
                if (insq) {
                    if (ch(p) == '\\' && ch(p + 1) == '\'') {
                        skip++;
                    } else if (ch(p) == '\'') {
                        if (ch(p + 1) && !isspace(ch(p + 1))) {
                            // do not consider single quote inside word as terminating
                        } else {
                            *p = '\0';
                            p++;
                            done = 1;
                        }
                    } else if (!*p) {
                        cliopt_debug("unterminated single quote");
                        goto err;
                    }
                } else {
                    switch (ch(p)) {
                    case '\'':
                        if (current == p) {
                            current++;
                            insq = 1;
                        }
                        break;
                    case ' ':
                    case '\n':
                    case '\r':
                    case '\t':
                        *p = '\0';
                        p++;
                    case '\0':
                        done = 1;
                        break;
                    }
                }
                if (skip) {
                    *p = ch(p);
                }
                if (*p && !done) {
                    p++;
                }
            }
            *argv = realloc(*argv, (*argc + 1) * sizeof(char *));
            (*argv)[*argc] = current;
            (*argc)++;
            current = NULL;
        } else {
            return 0;
        }
    }

err:
    free(*argv);
    *argc = 0;
    *argv = NULL;
    return 1;
}
