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