/*      $NetBSD: find.c,v 1.9 2024/08/18 20:47:24 christos Exp $        */

/**
* @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  = __UNCONST(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 */