/**

 * @file check.c

 *

 * @brief Hunt for options in the option descriptor list

 *

 *  This file contains the routines that deal with processing quoted strings

 *  into an internal format.

 *

 * @addtogroup autoopts

 * @{

 */

/*

 *  This file is part of AutoOpts, a companion to AutoGen.

 *  AutoOpts is free software.

 *  AutoOpts is Copyright (C) 1992-2018 by Bruce Korb - all rights reserved

 *

 *  AutoOpts is available under any one of two licenses.  The license

 *  in use must be one of these two and the choice is under the control

 *  of the user of the license.

 *

 *   The GNU Lesser General Public License, version 3 or later

 *      See the files "COPYING.lgplv3" and "COPYING.gplv3"

 *

 *   The Modified Berkeley Software Distribution License

 *      See the file "COPYING.mbsd"

 *

 *  These files have the following sha256 sums:

 *

 *  8584710e9b04216a394078dc156b781d0b47e1729104d666658aecef8ee32e95  COPYING.gplv3

 *  4379e7444a0e2ce2b12dd6f5a52a27a4d02d39d247901d3285c88cf0d37f477b  COPYING.lgplv3

 *  13aa749a5b0a454917a944ed8fffc530b784f5ead522b1aacaf4ec8aa55a6239  COPYING.mbsd

 */

/**

 * find the name and name length we are looking for

 */

static int

parse_opt(char const ** nm_pp, char ** arg_pp, char * buf, size_t bufsz)

{

    int  res = 0;

    char const * p = *nm_pp;

    *arg_pp  = NULL;

    for (;;) {

        switch (*(p++)) {

        case NUL: return res;

        case '=':

            memcpy(buf, *nm_pp, (size_t)res);

            buf[res] = NUL;

            *nm_pp   = buf;

            *arg_pp  = (char *)p;

            return res;

        default:

            if (++res >= (int)bufsz)

                return -1;

        }

    }

}

/**

 *  print out the options that match the given name.

 *

 * @param pOpts      option data

 * @param opt_name   name of option to look for

 */

static void

opt_ambiguities(tOptions * opts, char const * name, int nm_len)

{

    char const * const hyph =

        NAMED_OPTS(opts) ? "" : LONG_OPT_MARKER;

    tOptDesc * pOD = opts->pOptDesc;

    int        idx = 0;

    fputs(zambig_list_msg, stderr);

    do  {

        if (pOD->pz_Name == NULL)

            continue; /* doc option */

        if (strneqvcmp(name, pOD->pz_Name, nm_len) == 0)

            fprintf(stderr, zambig_file, hyph, pOD->pz_Name);

        else if (  (pOD->pz_DisableName != NULL)

                && (strneqvcmp(name, pOD->pz_DisableName, nm_len) == 0)

                )

            fprintf(stderr, zambig_file, hyph, pOD->pz_DisableName);

    } while (pOD++, (++idx < opts->optCt));

}

/**

 *  Determine the number of options that match the name

 *

 * @param pOpts      option data

 * @param opt_name   name of option to look for

 * @param nm_len     length of provided name

 * @param index      pointer to int for option index

 * @param disable    pointer to bool to mark disabled option

 * @return count of options that match

 */

static int

opt_match_ct(tOptions * opts, char const * name, int nm_len,

             int * ixp, bool * disable)

{

    int   matchCt  = 0;

    int   idx      = 0;

    int   idxLim   = opts->optCt;

    tOptDesc * pOD = opts->pOptDesc;

    do  {

        /*

         *  If option disabled or a doc option, skip to next

         */

        if (pOD->pz_Name == NULL)

            continue;

        if (  SKIP_OPT(pOD)

           && (pOD->fOptState != (OPTST_OMITTED | OPTST_NO_INIT)))

            continue;

        if (strneqvcmp(name, pOD->pz_Name, nm_len) == 0) {

            /*

             *  IF we have a complete match

             *  THEN it takes priority over any already located partial

             */

            if (pOD->pz_Name[ nm_len ] == NUL) {

                *ixp = idx;

                return 1;

            }

        }

        /*

         *  IF       there is a disable name

         *     *AND* the option name matches the disable name

         *  THEN ...

         */

        else if (  (pOD->pz_DisableName != NULL)

                && (strneqvcmp(name, pOD->pz_DisableName, nm_len) == 0)

                )  {

            *disable = true;

            /*

             *  IF we have a complete match

             *  THEN it takes priority over any already located partial

             */

            if (pOD->pz_DisableName[ nm_len ] == NUL) {

                *ixp = idx;

                return 1;

            }

        }

        else

            continue; /* does not match any option */

        /*

         *  We found a full or partial match, either regular or disabling.

         *  Remember the index for later.

         */

        *ixp = idx;

        ++matchCt;

    } while (pOD++, (++idx < idxLim));

    return matchCt;

}

/**

 *  Set the option to the indicated option number.

 *

 * @param opts      option data

 * @param arg       option argument (if glued to name)

 * @param idx       option index

 * @param disable   mark disabled option

 * @param st        state about current option

 */

static tSuccess

opt_set(tOptions * opts, char * arg, int idx, bool disable, tOptState * st)

{

    tOptDesc * pOD = opts->pOptDesc + idx;

    if (SKIP_OPT(pOD)) {

        if ((opts->fOptSet & OPTPROC_ERRSTOP) == 0)

            return FAILURE;

        fprintf(stderr, zDisabledErr, opts->pzProgName, pOD->pz_Name);

        if (pOD->pzText != NULL)

            fprintf(stderr, SET_OFF_FMT, pOD->pzText);

        fputc(NL, stderr);

        (*opts->pUsageProc)(opts, EXIT_FAILURE);

        /* NOTREACHED */

        _exit(EXIT_FAILURE); /* to be certain */

    }

    /*

     *  IF we found a disablement name,

     *  THEN set the bit in the callers' flag word

     */

    if (disable)

        st->flags |= OPTST_DISABLED;

    st->pOD      = pOD;

    st->pzOptArg = arg;

    st->optType  = TOPT_LONG;

    return SUCCESS;

}

/**

 *  An option was not found.  Check for default option and set it

 *  if there is one.  Otherwise, handle the error.

 *

 * @param opts   option data

 * @param name   name of option to look for

 * @param arg    option argument

 * @param st     state about current option

 *

 * @return success status

 */

static tSuccess

opt_unknown(tOptions * opts, char const * name, char * arg, tOptState * st)

{

    /*

     *  IF there is no equal sign

     *     *AND* we are using named arguments

     *     *AND* there is a default named option,

     *  THEN return that option.

     */

    if (  (arg == NULL)

       && NAMED_OPTS(opts)

       && (opts->specOptIdx.default_opt != NO_EQUIVALENT)) {

        st->pOD      = opts->pOptDesc + opts->specOptIdx.default_opt;

        st->pzOptArg = name;

        st->optType  = TOPT_DEFAULT;

        return SUCCESS;

    }

    if ((opts->fOptSet & OPTPROC_ERRSTOP) != 0) {

        fprintf(stderr, zIllOptStr, opts->pzProgPath, name);

        (*opts->pUsageProc)(opts, EXIT_FAILURE);

        /* NOTREACHED */

        _exit(EXIT_FAILURE); /* to be certain */

    }

    return FAILURE;

}

/**

 *  Several options match the provided name.

 *

 * @param opts      option data

 * @param name      name of option to look for

 * @param match_ct  number of matching options

 *

 * @return success status (always FAILURE, if it returns)

 */

static tSuccess

opt_ambiguous(tOptions * opts, char const * name, int match_ct)

{

    if ((opts->fOptSet & OPTPROC_ERRSTOP) != 0) {

        fprintf(stderr, zambig_opt_fmt, opts->pzProgPath, name, match_ct);

        if (match_ct <= 4)

            opt_ambiguities(opts, name, (int)strlen(name));

        (*opts->pUsageProc)(opts, EXIT_FAILURE);

        /* NOTREACHED */

        _exit(EXIT_FAILURE); /* to be certain */

    }

    return FAILURE;

}

/*=export_func  optionVendorOption

 * private:

 *

 * what:  Process a vendor option

 * arg:   + tOptions * + pOpts    + program options descriptor +

 * arg:   + tOptDesc * + pOptDesc + the descriptor for this arg +

 *

 * doc:

 *  For POSIX specified utilities, the options are constrained to the options,

 *  @xref{config attributes, Program Configuration}.  AutoOpts clients should

 *  never specify this directly.  It gets referenced when the option

 *  definitions contain a "vendor-opt" attribute.

=*/

void

optionVendorOption(tOptions * pOpts, tOptDesc * pOD)

{

    tOptState     opt_st   = OPTSTATE_INITIALIZER(PRESET);

    char const *  vopt_str = pOD->optArg.argString;

    if (pOpts <= OPTPROC_EMIT_LIMIT)

        return;

    if ((pOD->fOptState & OPTST_RESET) != 0)

        return;

    if ((pOD->fOptState & OPTPROC_IMMEDIATE) == 0)

        opt_st.flags = OPTST_DEFINED;

    if (  ((pOpts->fOptSet & OPTPROC_VENDOR_OPT) == 0)

       || ! SUCCESSFUL(opt_find_long(pOpts, vopt_str, &opt_st))

       || ! SUCCESSFUL(get_opt_arg(pOpts, &opt_st)) )

    {

        fprintf(stderr, zIllVendOptStr, pOpts->pzProgName, vopt_str);

        (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);

        /* NOTREACHED */

        _exit(EXIT_FAILURE); /* to be certain */

    }

    /*

     *  See if we are in immediate handling state.

     */

    if (pOpts->fOptSet & OPTPROC_IMMEDIATE) {

        /*

         *  See if the enclosed option is okay with that state.

         */

        if (DO_IMMEDIATELY(opt_st.flags))

            (void)handle_opt(pOpts, &opt_st);

    } else {

        /*

         *  non-immediate direction.

         *  See if the enclosed option is okay with that state.

         */

        if (DO_NORMALLY(opt_st.flags) || DO_SECOND_TIME(opt_st.flags))

            (void)handle_opt(pOpts, &opt_st);

    }

}

/**

 *  Find the option descriptor by full name.

 *

 * @param opts      option data

 * @param opt_name  name of option to look for

 * @param state     state about current option

 *

 * @return success status

 */

static tSuccess

opt_find_long(tOptions * opts, char const * opt_name, tOptState * state)

{

    char    name_buf[128];

    char *  opt_arg;

    int     nm_len = parse_opt(&opt_name, &opt_arg, name_buf, sizeof(name_buf));

    int     idx = 0;

    bool    disable  = false;

    int     ct;

    if (nm_len <= 1) {

        if ((opts->fOptSet & OPTPROC_ERRSTOP) == 0)

            return FAILURE;

        fprintf(stderr, zInvalOptName, opts->pzProgName, opt_name);

        (*opts->pUsageProc)(opts, EXIT_FAILURE);

        /* NOTREACHED */

        _exit(EXIT_FAILURE); /* to be certain */

    }

    ct = opt_match_ct(opts, opt_name, nm_len, &idx, &disable);

    /*

     *  See if we found one match, no matches or multiple matches.

     */

    switch (ct) {

    case 1:  return opt_set(opts, opt_arg, idx, disable, state);

    case 0:  return opt_unknown(opts, opt_name, opt_arg, state);

    default: return opt_ambiguous(opts, opt_name, ct);

    }

}

/**

 *  Find the short option descriptor for the current option

 *

 * @param pOpts      option data

 * @param optValue   option flag character

 * @param pOptState  state about current option

 */

static tSuccess

opt_find_short(tOptions * pOpts, uint_t optValue, tOptState * pOptState)

{

    tOptDesc * pRes = pOpts->pOptDesc;

    int        ct   = pOpts->optCt;

    /*

     *  Search the option list

     */

    do  {

        if (optValue != pRes->optValue)

            continue;

        if (SKIP_OPT(pRes)) {

            if (  (pRes->fOptState == (OPTST_OMITTED | OPTST_NO_INIT))

               && (pRes->pz_Name != NULL)) {

                if ((pOpts->fOptSet & OPTPROC_ERRSTOP) == 0)

                    return FAILURE;

                fprintf(stderr, zDisabledErr, pOpts->pzProgPath, pRes->pz_Name);

                if (pRes->pzText != NULL)

                    fprintf(stderr, SET_OFF_FMT, pRes->pzText);

                fputc(NL, stderr);

                (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);

                /* NOTREACHED */

                _exit(EXIT_FAILURE); /* to be certain */

            }

            goto short_opt_error;

        }

        pOptState->pOD     = pRes;

        pOptState->optType = TOPT_SHORT;

        return SUCCESS;

    } while (pRes++, --ct > 0);

    /*

     *  IF    the character value is a digit

     *    AND there is a special number option ("-n")

     *  THEN the result is the "option" itself and the

     *       option is the specially marked "number" option.

     */

    if (  IS_DEC_DIGIT_CHAR(optValue)

       && (pOpts->specOptIdx.number_option != NO_EQUIVALENT) ) {

        pOptState->pOD = \

        pRes           = pOpts->pOptDesc + pOpts->specOptIdx.number_option;

        (pOpts->pzCurOpt)--;

        pOptState->optType = TOPT_SHORT;

        return SUCCESS;

    }

 short_opt_error:

    /*

     *  IF we are to stop on errors (the default, actually)

     *  THEN call the usage procedure.

     */

    if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {

        fprintf(stderr, zIllOptChr, pOpts->pzProgPath, optValue);

        (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);

        /* NOTREACHED */

        _exit(EXIT_FAILURE); /* to be certain */

    }

    return FAILURE;

}

/**

 *  Process option with a required argument.  Long options can either have a

 *  separate command line argument, or an argument attached by the '='

 *  character.  Figure out which.

 *

 *  @param[in,out] opts  the program option descriptor

 *  @param[in,out] o_st  the option processing state

 *  @returns SUCCESS or FAILURE

 */

static tSuccess

get_opt_arg_must(tOptions * opts, tOptState * o_st)

{

    switch (o_st->optType) {

    case TOPT_SHORT:

        /*

         *  See if an arg string follows the flag character

         */

        if (*++(opts->pzCurOpt) == NUL)

            opts->pzCurOpt = opts->origArgVect[ opts->curOptIdx++ ];

        o_st->pzOptArg = opts->pzCurOpt;

        break;

    case TOPT_LONG:

        /*

         *  See if an arg string has already been assigned (glued on

         *  with an `=' character)

         */

        if (o_st->pzOptArg == NULL)

            o_st->pzOptArg = opts->origArgVect[ opts->curOptIdx++ ];

        break;

    default:

#ifdef DEBUG

        fputs("AutoOpts lib error: option type not selected\n", stderr);

        option_exits(EXIT_FAILURE);

#endif

    case TOPT_DEFAULT:

        /*

         *  The option was selected by default.  The current token is

         *  the option argument.

         */

        break;

    }

    /*

     *  Make sure we did not overflow the argument list.

     */

    if (opts->curOptIdx > opts->origArgCt) {

        fprintf(stderr, zMisArg, opts->pzProgPath, o_st->pOD->pz_Name);

        return FAILURE;

    }

    opts->pzCurOpt = NULL;  /* next time advance to next arg */

    return SUCCESS;

}

/**

 * Process an option with an optional argument.  For short options, it looks

 * at the character after the option character, or it consumes the next full

 * argument.  For long options, it looks for an '=' character attachment to

 * the long option name before deciding to take the next command line

 * argument.

 *

 * @param pOpts      the option descriptor

 * @param o_st  a structure for managing the current processing state

 * @returns SUCCESS or does not return

 */

static tSuccess

get_opt_arg_may(tOptions * pOpts, tOptState * o_st)

{

    /*

     *  An option argument is optional.

     */

    switch (o_st->optType) {

    case TOPT_SHORT:

        if (*++pOpts->pzCurOpt != NUL)

            o_st->pzOptArg = pOpts->pzCurOpt;

        else {

            char * pzLA = pOpts->origArgVect[ pOpts->curOptIdx ];

            /*

             *  BECAUSE it is optional, we must make sure

             *  we did not find another flag and that there

             *  is such an argument.

             */

            if ((pzLA == NULL) || (*pzLA == '-'))

                o_st->pzOptArg = NULL;

            else {

                pOpts->curOptIdx++; /* argument found */

                o_st->pzOptArg = pzLA;

            }

        }

        break;

    case TOPT_LONG:

        /*

         *  Look for an argument if we don't already have one (glued on

         *  with a `=' character) *AND* we are not in named argument mode

         */

        if (  (o_st->pzOptArg == NULL)

           && (! NAMED_OPTS(pOpts))) {

            char * pzLA = pOpts->origArgVect[ pOpts->curOptIdx ];

            /*

             *  BECAUSE it is optional, we must make sure

             *  we did not find another flag and that there

             *  is such an argument.

             */

            if ((pzLA == NULL) || (*pzLA == '-'))

                o_st->pzOptArg = NULL;

            else {

                pOpts->curOptIdx++; /* argument found */

                o_st->pzOptArg = pzLA;

            }

        }

        break;

    default:

    case TOPT_DEFAULT:

        ao_bug(zbad_default_msg);

    }

    /*

     *  After an option with an optional argument, we will

     *  *always* start with the next option because if there

     *  were any characters following the option name/flag,

     *  they would be interpreted as the argument.

     */

    pOpts->pzCurOpt = NULL;

    return SUCCESS;

}

/**

 *  Process option that does not have an argument.

 *

 *  @param[in,out] opts  the program option descriptor

 *  @param[in,out] o_st  the option processing state

 *  @returns SUCCESS or FAILURE

 */

static tSuccess

get_opt_arg_none(tOptions * pOpts, tOptState * o_st)

{

    /*

     *  No option argument.  Make sure next time around we find

     *  the correct option flag character for short options

     */

    if (o_st->optType == TOPT_SHORT)

        (pOpts->pzCurOpt)++;

    /*

     *  It is a long option.  Make sure there was no ``=xxx'' argument

     */

    else if (o_st->pzOptArg != NULL) {

        fprintf(stderr, zNoArg, pOpts->pzProgPath, o_st->pOD->pz_Name);

        return FAILURE;

    }

    /*

     *  It is a long option.  Advance to next command line argument.

     */

    else

        pOpts->pzCurOpt = NULL;

    return SUCCESS;

}

/**

 *  Process option.  Figure out whether or not to look for an option argument.

 *

 *  @param[in,out] opts  the program option descriptor

 *  @param[in,out] o_st  the option processing state

 *  @returns SUCCESS or FAILURE

 */

static tSuccess

get_opt_arg(tOptions * opts, tOptState * o_st)

{

    o_st->flags |= (o_st->pOD->fOptState & OPTST_PERSISTENT_MASK);

    /*

     * Disabled options and options specified to not have arguments

     * are handled with the "none" procedure.  Otherwise, check the

     * optional flag and call either the "may" or "must" function.

     */

    if ((o_st->flags & OPTST_DISABLED) != 0)

        return get_opt_arg_none(opts, o_st);

    switch (OPTST_GET_ARGTYPE(o_st->flags)) {

    case OPARG_TYPE_STATIC:

    {

        /*

         * Propagate the static arg

         */

        tSuccess res = get_opt_arg_none(opts, o_st);

        o_st->pzOptArg = o_st->pOD->optArg.argString;

        return res;

    }

    case OPARG_TYPE_NONE:

        return get_opt_arg_none(opts, o_st);

    }

    if (o_st->flags & OPTST_ARG_OPTIONAL)

        return get_opt_arg_may( opts, o_st);

    return get_opt_arg_must(opts, o_st);

}

/**

 *  Find the option descriptor for the current option.

 *

 *  @param[in,out] opts  the program option descriptor

 *  @param[in,out] o_st  the option processing state

 *  @returns SUCCESS or FAILURE

 */

static tSuccess

find_opt(tOptions * opts, tOptState * o_st)

{

    /*

     *  IF we are continuing a short option list (e.g. -xyz...)

     *  THEN continue a single flag option.

     *  OTHERWISE see if there is room to advance and then do so.

     */

    if ((opts->pzCurOpt != NULL) && (*opts->pzCurOpt != NUL))

        return opt_find_short(opts, (uint8_t)*(opts->pzCurOpt), o_st);

    if (opts->curOptIdx >= opts->origArgCt)

        return PROBLEM; /* NORMAL COMPLETION */

    opts->pzCurOpt = opts->origArgVect[ opts->curOptIdx ];

    /*

     *  IF all arguments must be named options, ...

     */

    if (NAMED_OPTS(opts)) {

        char *      pz  = opts->pzCurOpt;

        int         def;

        tSuccess    res;

        uint16_t *  def_opt;

        opts->curOptIdx++;

        if (*pz != '-')

            return opt_find_long(opts, pz, o_st);

        /*

         *  The name is prefixed with one or more hyphens.  Strip them off

         *  and disable the "default_opt" setting.  Use heavy recasting to

         *  strip off the "const" quality of the "default_opt" field.

         */

        while (*(++pz) == '-')   ;

        def_opt  = VOIDP(&(opts->specOptIdx.default_opt));

        def      = *def_opt;

        *def_opt = NO_EQUIVALENT;

        res      = opt_find_long(opts, pz, o_st);

        *def_opt = (uint16_t)def;

        return res;

    }

    /*

     *  Note the kind of flag/option marker

     */

    if (*((opts->pzCurOpt)++) != '-')

        return PROBLEM; /* NORMAL COMPLETION - this + rest are operands */

    /*

     *  Special hack for a hyphen by itself

     */

    if (*(opts->pzCurOpt) == NUL)

        return PROBLEM; /* NORMAL COMPLETION - this + rest are operands */

    /*

     *  The current argument is to be processed as an option argument

     */

    opts->curOptIdx++;

    /*

     *  We have an option marker.

     *  Test the next character for long option indication

     */

    if (opts->pzCurOpt[0] == '-') {

        if (*++(opts->pzCurOpt) == NUL)

            /*

             *  NORMAL COMPLETION - NOT this arg, but rest are operands

             */

            return PROBLEM;

        /*

         *  We do not allow the hyphen to be used as a flag value.

         *  Therefore, if long options are not to be accepted, we punt.

         */

        if ((opts->fOptSet & OPTPROC_LONGOPT) == 0) {

            fprintf(stderr, zIllOptStr, opts->pzProgPath, opts->pzCurOpt-2);

            return FAILURE;

        }

        return opt_find_long(opts, opts->pzCurOpt, o_st);

    }

    /*

     *  If short options are not allowed, then do long

     *  option processing.  Otherwise the character must be a

     *  short (i.e. single character) option.

     */

    if ((opts->fOptSet & OPTPROC_SHORTOPT) != 0)

        return opt_find_short(opts, (uint8_t)*(opts->pzCurOpt), o_st);

    return opt_find_long(opts, opts->pzCurOpt, o_st);

}

/** @}

 *

 * Local Variables:

 * mode: C

 * c-file-style: "stroustrup"

 * indent-tabs-mode: nil

 * End:

 * end of autoopts/find.c */