contrib/ntp/sntp/libopts/sort.c

   1
   2 /*
   3  * \file sort.c
   4  *
   5  *  This module implements argument sorting.
   6  *
   7  * @addtogroup autoopts
   8  * @{
   9  */
  10 /*
  11  *  This file is part of AutoOpts, a companion to AutoGen.
  12  *  AutoOpts is free software.
  13  *  AutoOpts is Copyright (C) 1992-2015 by Bruce Korb - all rights reserved
  14  *
  15  *  AutoOpts is available under any one of two licenses.  The license
  16  *  in use must be one of these two and the choice is under the control
  17  *  of the user of the license.
  18  *
  19  *   The GNU Lesser General Public License, version 3 or later
  20  *      See the files "COPYING.lgplv3" and "COPYING.gplv3"
  21  *
  22  *   The Modified Berkeley Software Distribution License
  23  *      See the file "COPYING.mbsd"
  24  *
  25  *  These files have the following sha256 sums:
  26  *
  27  *  8584710e9b04216a394078dc156b781d0b47e1729104d666658aecef8ee32e95  COPYING.gplv3
  28  *  4379e7444a0e2ce2b12dd6f5a52a27a4d02d39d247901d3285c88cf0d37f477b  COPYING.lgplv3
  29  *  13aa749a5b0a454917a944ed8fffc530b784f5ead522b1aacaf4ec8aa55a6239  COPYING.mbsd
  30  */
  31
  32 /* = = = START-STATIC-FORWARD = = = */
  33 static tSuccess
  34 must_arg(tOptions * opts, char * arg_txt, tOptState * pOS,
  35          char ** opt_txt, uint32_t * opt_idx);
  36
  37 static tSuccess
  38 maybe_arg(tOptions * opts, char * arg_txt, tOptState * pOS,
  39           char ** opt_txt, uint32_t * opt_idx);
  40
  41 static tSuccess
  42 short_opt_ck(tOptions * opts, char * arg_txt, tOptState * pOS,
  43              char ** opt_txt, uint32_t * opt_idx);
  44 /* = = = END-STATIC-FORWARD = = = */
  45
  46 /*
  47  *  "must_arg" and "maybe_arg" are really similar.  The biggest
  48  *  difference is that "may" will consume the next argument only if it
  49  *  does not start with a hyphen and "must" will consume it, hyphen or not.
  50  */
  51 static tSuccess
  52 must_arg(tOptions * opts, char * arg_txt, tOptState * pOS,
  53          char ** opt_txt, uint32_t * opt_idx)
  54 {
  55     /*
  56      *  An option argument is required.  Long options can either have
  57      *  a separate command line argument, or an argument attached by
  58      *  the '=' character.  Figure out which.
  59      */
  60     switch (pOS->optType) {
  61     case TOPT_SHORT:
  62         /*
  63          *  See if an arg string follows the flag character.  If not,
  64          *  the next arg must be the option argument.
  65          */
  66         if (*arg_txt != NUL)
  67             return SUCCESS;
  68         break;
  69
  70     case TOPT_LONG:
  71         /*
  72          *  See if an arg string has already been assigned (glued on
  73          *  with an `=' character).  If not, the next is the opt arg.
  74          */
  75         if (pOS->pzOptArg != NULL)
  76             return SUCCESS;
  77         break;
  78
  79     default:
  80         return FAILURE;
  81     }
  82     if (opts->curOptIdx >= opts->origArgCt)
  83         return FAILURE;
  84
  85     opt_txt[ (*opt_idx)++ ] = opts->origArgVect[ (opts->curOptIdx)++ ];
  86     return SUCCESS;
  87 }
  88
  89 static tSuccess
  90 maybe_arg(tOptions * opts, char * arg_txt, tOptState * pOS,
  91           char ** opt_txt, uint32_t * opt_idx)
  92 {
  93     /*
  94      *  An option argument is optional.
  95      */
  96     switch (pOS->optType) {
  97     case TOPT_SHORT:
  98         /*
  99          *  IF nothing is glued on after the current flag character,
 100          *  THEN see if there is another argument.  If so and if it
 101          *  does *NOT* start with a hyphen, then it is the option arg.
 102          */
 103         if (*arg_txt != NUL)
 104             return SUCCESS;
 105         break;
 106
 107     case TOPT_LONG:
 108         /*
 109          *  Look for an argument if we don't already have one (glued on
 110          *  with a `=' character)
 111          */
 112         if (pOS->pzOptArg != NULL)
 113             return SUCCESS;
 114         break;
 115
 116     default:
 117         return FAILURE;
 118     }
 119     if (opts->curOptIdx >= opts->origArgCt)
 120         return PROBLEM;
 121
 122     arg_txt = opts->origArgVect[ opts->curOptIdx ];
 123     if (*arg_txt != '-')
 124         opt_txt[ (*opt_idx)++ ] = opts->origArgVect[ (opts->curOptIdx)++ ];
 125     return SUCCESS;
 126 }
 127
 128 /*
 129  *  Process a string of short options glued together.  If the last one
 130  *  does or may take an argument, the do the argument processing and leave.
 131  */
 132 static tSuccess
 133 short_opt_ck(tOptions * opts, char * arg_txt, tOptState * pOS,
 134              char ** opt_txt, uint32_t * opt_idx)
 135 {
 136     while (*arg_txt != NUL) {
 137         if (FAILED(opt_find_short(opts, (uint8_t)*arg_txt, pOS)))
 138             return FAILURE;
 139
 140         /*
 141          *  See if we can have an arg.
 142          */
 143         if (OPTST_GET_ARGTYPE(pOS->pOD->fOptState) == OPARG_TYPE_NONE) {
 144             arg_txt++;
 145
 146         } else if (pOS->pOD->fOptState & OPTST_ARG_OPTIONAL) {
 147             /*
 148              *  Take an argument if it is not attached and it does not
 149              *  start with a hyphen.
 150              */
 151             if (arg_txt[1] != NUL)
 152                 return SUCCESS;
 153
 154             arg_txt = opts->origArgVect[ opts->curOptIdx ];
 155             if (*arg_txt != '-')
 156                 opt_txt[ (*opt_idx)++ ] =
 157                     opts->origArgVect[ (opts->curOptIdx)++ ];
 158             return SUCCESS;
 159
 160         } else {
 161             /*
 162              *  IF we need another argument, be sure it is there and
 163              *  take it.
 164              */
 165             if (arg_txt[1] == NUL) {
 166                 if (opts->curOptIdx >= opts->origArgCt)
 167                     return FAILURE;
 168                 opt_txt[ (*opt_idx)++ ] =
 169                     opts->origArgVect[ (opts->curOptIdx)++ ];
 170             }
 171             return SUCCESS;
 172         }
 173     }
 174     return SUCCESS;
 175 }
 176
 177 /*
 178  *  If the program wants sorted options (separated operands and options),
 179  *  then this routine will to the trick.
 180  */
 181 LOCAL void
 182 optionSort(tOptions * opts)
 183 {
 184     char **  opt_txt;
 185     char **  ppzOpds;
 186     uint32_t optsIdx = 0;
 187     uint32_t opdsIdx = 0;
 188
 189     tOptState os = OPTSTATE_INITIALIZER(DEFINED);
 190
 191     /*
 192      *  Disable for POSIX conformance, or if there are no operands.
 193      */
 194     if (  (getenv("POSIXLY_CORRECT") != NULL)
 195        || NAMED_OPTS(opts))
 196         return;
 197
 198     /*
 199      *  Make sure we can allocate two full-sized arg vectors.
 200      */
 201     opt_txt = malloc(opts->origArgCt * sizeof(char *));
 202     if (opt_txt == NULL)
 203         goto exit_no_mem;
 204
 205     ppzOpds = malloc(opts->origArgCt * sizeof(char *));
 206     if (ppzOpds == NULL) {
 207         free(opt_txt);
 208         goto exit_no_mem;
 209     }
 210
 211     opts->curOptIdx = 1;
 212     opts->pzCurOpt  = NULL;
 213
 214     /*
 215      *  Now, process all the options from our current position onward.
 216      *  (This allows interspersed options and arguments for the few
 217      *  non-standard programs that require it.)
 218      */
 219     for (;;) {
 220         char * arg_txt;
 221         tSuccess res;
 222
 223         /*
 224          *  If we're out of arguments, we're done.  Join the option and
 225          *  operand lists into the original argument vector.
 226          */
 227         if (opts->curOptIdx >= opts->origArgCt) {
 228             errno = 0;
 229             goto joinLists;
 230         }
 231
 232         arg_txt = opts->origArgVect[ opts->curOptIdx ];
 233         if (*arg_txt != '-') {
 234             ppzOpds[ opdsIdx++ ] = opts->origArgVect[ (opts->curOptIdx)++ ];
 235             continue;
 236         }
 237
 238         switch (arg_txt[1]) {
 239         case NUL:
 240             /*
 241              *  A single hyphen is an operand.
 242              */
 243             ppzOpds[ opdsIdx++ ] = opts->origArgVect[ (opts->curOptIdx)++ ];
 244             continue;
 245
 246         case '-':
 247             /*
 248              *  Two consecutive hypens.  Put them on the options list and then
 249              *  _always_ force the remainder of the arguments to be operands.
 250              */
 251             if (arg_txt[2] == NUL) {
 252                 opt_txt[ optsIdx++ ] =
 253                     opts->origArgVect[ (opts->curOptIdx)++ ];
 254                 goto restOperands;
 255             }
 256             res = opt_find_long(opts, arg_txt+2, &os);
 257             break;
 258
 259         default:
 260             /*
 261              *  If short options are not allowed, then do long
 262              *  option processing.  Otherwise the character must be a
 263              *  short (i.e. single character) option.
 264              */
 265             if ((opts->fOptSet & OPTPROC_SHORTOPT) == 0) {
 266                 res = opt_find_long(opts, arg_txt+1, &os);
 267             } else {
 268                 res = opt_find_short(opts, (uint8_t)arg_txt[1], &os);
 269             }
 270             break;
 271         }
 272         if (FAILED(res)) {
 273             errno = EINVAL;
 274             goto freeTemps;
 275         }
 276
 277         /*
 278          *  We've found an option.  Add the argument to the option list.
 279          *  Next, we have to see if we need to pull another argument to be
 280          *  used as the option argument.
 281          */
 282         opt_txt[ optsIdx++ ] = opts->origArgVect[ (opts->curOptIdx)++ ];
 283
 284         if (OPTST_GET_ARGTYPE(os.pOD->fOptState) == OPARG_TYPE_NONE) {
 285             /*
 286              *  No option argument.  If we have a short option here,
 287              *  then scan for short options until we get to the end
 288              *  of the argument string.
 289              */
 290             if (  (os.optType == TOPT_SHORT)
 291                && FAILED(short_opt_ck(opts, arg_txt+2, &os, opt_txt,
 292                                       &optsIdx)) )  {
 293                 errno = EINVAL;
 294                 goto freeTemps;
 295             }
 296
 297         } else if (os.pOD->fOptState & OPTST_ARG_OPTIONAL) {
 298             switch (maybe_arg(opts, arg_txt+2, &os, opt_txt, &optsIdx)) {
 299             case FAILURE: errno = EIO; goto freeTemps;
 300             case PROBLEM: errno = 0;   goto joinLists;
 301             }
 302
 303         } else {
 304             switch (must_arg(opts, arg_txt+2, &os, opt_txt, &optsIdx)) {
 305             case PROBLEM:
 306             case FAILURE: errno = EIO; goto freeTemps;
 307             }
 308         }
 309     } /* for (;;) */
 310
 311  restOperands:
 312     while (opts->curOptIdx < opts->origArgCt)
 313         ppzOpds[ opdsIdx++ ] = opts->origArgVect[ (opts->curOptIdx)++ ];
 314
 315  joinLists:
 316     if (optsIdx > 0)
 317         memcpy(opts->origArgVect + 1, opt_txt,
 318                (size_t)optsIdx * sizeof(char *));
 319     if (opdsIdx > 0)
 320         memcpy(opts->origArgVect + 1 + optsIdx, ppzOpds,
 321                (size_t)opdsIdx * sizeof(char *));
 322
 323  freeTemps:
 324     free(opt_txt);
 325     free(ppzOpds);
 326     return;
 327
 328  exit_no_mem:
 329     errno = ENOMEM;
 330     return;
 331 }
 332
 333 /** @}
 334  *
 335  * Local Variables:
 336  * mode: C
 337  * c-file-style: "stroustrup"
 338  * indent-tabs-mode: nil
 339  * End:
 340  * end of autoopts/sort.c */