Annotation of embedaddon/ntp/sntp/libopts/putshell.c, revision 1.1
1.1 ! misho 1:
! 2: /**
! 3: * \file putshell.c
! 4: *
! 5: * Time-stamp: "2010-09-05 06:10:56 bkorb"
! 6: *
! 7: * This module will interpret the options set in the tOptions
! 8: * structure and print them to standard out in a fashion that
! 9: * will allow them to be interpreted by the Bourne or Korn shells.
! 10: *
! 11: * This file is part of AutoOpts, a companion to AutoGen.
! 12: * AutoOpts is free software.
! 13: * AutoOpts is Copyright (c) 1992-2011 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 md5sums:
! 26: *
! 27: * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
! 28: * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
! 29: * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
! 30: */
! 31: static char const zOptValFmt[] = "%s_%s=";
! 32: static char const zOptEnd[] = "\nexport %s_%s\n";
! 33: static char const zOptNumFmt[] = "%1$s_%2$s=%3$d # 0x%3$X\nexport %1$s_%2$s\n";
! 34:
! 35: /* = = = START-STATIC-FORWARD = = = */
! 36: static void
! 37: print_quot_str(tCC* pzStr);
! 38:
! 39: static void
! 40: print_enumeration(tOptions * pOpts, tOptDesc * pOD);
! 41:
! 42: static void
! 43: print_membership(tOptions * pOpts, tOptDesc * pOD);
! 44:
! 45: static void
! 46: print_stacked_arg(tOptions * pOpts, tOptDesc * pOD);
! 47:
! 48: static void
! 49: print_reordering(tOptions * pOpts);
! 50: /* = = = END-STATIC-FORWARD = = = */
! 51:
! 52: /*
! 53: * Make sure embedded single quotes come out okay. The initial quote has
! 54: * been emitted and the closing quote will be upon return.
! 55: */
! 56: static void
! 57: print_quot_str(tCC* pzStr)
! 58: {
! 59: /*
! 60: * Handle empty strings to make the rest of the logic simpler.
! 61: */
! 62: if ((pzStr == NULL) || (*pzStr == NUL)) {
! 63: fputs("''", stdout);
! 64: return;
! 65: }
! 66:
! 67: /*
! 68: * Emit any single quotes/apostrophes at the start of the string and
! 69: * bail if that is all we need to do.
! 70: */
! 71: while (*pzStr == '\'') {
! 72: fputs("\\'", stdout);
! 73: pzStr++;
! 74: }
! 75: if (*pzStr == NUL)
! 76: return;
! 77:
! 78: /*
! 79: * Start the single quote string
! 80: */
! 81: fputc('\'', stdout);
! 82: for (;;) {
! 83: tCC* pz = strchr(pzStr, '\'');
! 84: if (pz == NULL)
! 85: break;
! 86:
! 87: /*
! 88: * Emit the string up to the single quote (apostrophe) we just found.
! 89: */
! 90: (void)fwrite(pzStr, (size_t)(pz - pzStr), (size_t)1, stdout);
! 91: fputc('\'', stdout);
! 92: pzStr = pz;
! 93:
! 94: /*
! 95: * Emit an escaped apostrophe for every one we find.
! 96: * If that ends the string, do not re-open the single quotes.
! 97: */
! 98: while (*++pzStr == '\'') fputs("\\'", stdout);
! 99: if (*pzStr == NUL)
! 100: return;
! 101:
! 102: fputc('\'', stdout);
! 103: }
! 104:
! 105: /*
! 106: * If we broke out of the loop, we must still emit the remaining text
! 107: * and then close the single quote string.
! 108: */
! 109: fputs(pzStr, stdout);
! 110: fputc('\'', stdout);
! 111: }
! 112:
! 113: static void
! 114: print_enumeration(tOptions * pOpts, tOptDesc * pOD)
! 115: {
! 116: uintptr_t e_val = pOD->optArg.argEnum;
! 117: printf(zOptValFmt, pOpts->pzPROGNAME, pOD->pz_NAME);
! 118:
! 119: /*
! 120: * Convert value to string, print that and restore numeric value.
! 121: */
! 122: (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
! 123: printf("'%s'", pOD->optArg.argString);
! 124: if (pOD->fOptState & OPTST_ALLOC_ARG)
! 125: AGFREE(pOD->optArg.argString);
! 126: pOD->optArg.argEnum = e_val;
! 127:
! 128: printf(zOptEnd, pOpts->pzPROGNAME, pOD->pz_NAME);
! 129: }
! 130:
! 131: static void
! 132: print_membership(tOptions * pOpts, tOptDesc * pOD)
! 133: {
! 134: char const * pz;
! 135: uintptr_t val = 1;
! 136: printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
! 137: (int)(uintptr_t)(pOD->optCookie));
! 138: pOD->optCookie = (void*)(uintptr_t)~0UL;
! 139: (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
! 140:
! 141: /*
! 142: * We are building the typeset list. The list returned starts with
! 143: * 'none + ' for use by option saving stuff. We must ignore that.
! 144: */
! 145: pz = pOD->optArg.argString + 7;
! 146: while (*pz != NUL) {
! 147: printf("typeset -x -i %s_", pOD->pz_NAME);
! 148: while (IS_PLUS_N_SPACE_CHAR(*pz)) pz++;
! 149:
! 150: for (;;) {
! 151: int ch = *(pz++);
! 152: if (IS_LOWER_CASE_CHAR(ch)) fputc(toupper(ch), stdout);
! 153: else if (IS_UPPER_CASE_CHAR(ch)) fputc(ch, stdout);
! 154: else if (IS_PLUS_N_SPACE_CHAR(ch)) goto name_done;
! 155: else if (ch == NUL) { pz--; goto name_done; }
! 156: else fputc('_', stdout);
! 157: } name_done:;
! 158: printf("=%1$lu # 0x%1$lX\n", (unsigned long)val);
! 159: val <<= 1;
! 160: }
! 161:
! 162: AGFREE(pOD->optArg.argString);
! 163: pOD->optArg.argString = NULL;
! 164: pOD->fOptState &= ~OPTST_ALLOC_ARG;
! 165: }
! 166:
! 167: static void
! 168: print_stacked_arg(tOptions * pOpts, tOptDesc * pOD)
! 169: {
! 170: tSCC zOptCookieCt[] = "%1$s_%2$s_CT=%3$d\nexport %1$s_%2$s_CT\n";
! 171:
! 172: tArgList* pAL = (tArgList*)pOD->optCookie;
! 173: tCC** ppz = pAL->apzArgs;
! 174: int ct = pAL->useCt;
! 175:
! 176: printf(zOptCookieCt, pOpts->pzPROGNAME, pOD->pz_NAME, ct);
! 177:
! 178: while (--ct >= 0) {
! 179: tSCC numarg_z[] = "%s_%s_%d=";
! 180: tSCC end_z[] = "\nexport %s_%s_%d\n";
! 181:
! 182: printf(numarg_z, pOpts->pzPROGNAME, pOD->pz_NAME,
! 183: pAL->useCt - ct);
! 184: print_quot_str(*(ppz++));
! 185: printf(end_z, pOpts->pzPROGNAME, pOD->pz_NAME,
! 186: pAL->useCt - ct);
! 187: }
! 188: }
! 189:
! 190: static void
! 191: print_reordering(tOptions * pOpts)
! 192: {
! 193: int optIx;
! 194:
! 195: fputs("set --", stdout);
! 196:
! 197: for (optIx = pOpts->curOptIdx; optIx < pOpts->origArgCt; optIx++) {
! 198:
! 199: char* pzArg = pOpts->origArgVect[ optIx ];
! 200:
! 201: if (strchr(pzArg, '\'') == NULL)
! 202: printf(" '%s'", pzArg);
! 203:
! 204: else {
! 205: fputs(" '", stdout);
! 206: for (;;) {
! 207: char ch = *(pzArg++);
! 208: switch (ch) {
! 209: case '\'': fputs("'\\''", stdout); break;
! 210: case NUL: goto arg_done;
! 211: default: fputc(ch, stdout); break;
! 212: }
! 213: } arg_done:;
! 214: fputc('\'', stdout);
! 215: }
! 216: }
! 217: fputs("\nOPTION_CT=0\n", stdout);
! 218: }
! 219:
! 220: /*=export_func optionPutShell
! 221: * what: write a portable shell script to parse options
! 222: * private:
! 223: * arg: tOptions*, pOpts, the program options descriptor
! 224: * doc: This routine will emit portable shell script text for parsing
! 225: * the options described in the option definitions.
! 226: =*/
! 227: void
! 228: optionPutShell(tOptions* pOpts)
! 229: {
! 230: int optIx = 0;
! 231: tSCC zOptCtFmt[] = "OPTION_CT=%d\nexport OPTION_CT\n";
! 232: tSCC zOptDisabl[] = "%1$s_%2$s=%3$s\nexport %1$s_%2$s\n";
! 233: tSCC zFullOptFmt[]= "%1$s_%2$s='%3$s'\nexport %1$s_%2$s\n";
! 234: tSCC zEquivMode[] = "%1$s_%2$s_MODE='%3$s'\nexport %1$s_%2$s_MODE\n";
! 235:
! 236: printf(zOptCtFmt, pOpts->curOptIdx-1);
! 237:
! 238: do {
! 239: tOptDesc* pOD = pOpts->pOptDesc + optIx;
! 240:
! 241: if (SKIP_OPT(pOD))
! 242: continue;
! 243:
! 244: /*
! 245: * Equivalence classes are hard to deal with. Where the
! 246: * option data wind up kind of squishes around. For the purposes
! 247: * of emitting shell state, they are not recommended, but we'll
! 248: * do something. I guess we'll emit the equivalenced-to option
! 249: * at the point in time when the base option is found.
! 250: */
! 251: if (pOD->optEquivIndex != NO_EQUIVALENT)
! 252: continue; /* equivalence to a different option */
! 253:
! 254: /*
! 255: * Equivalenced to a different option. Process the current option
! 256: * as the equivalenced-to option. Keep the persistent state bits,
! 257: * but copy over the set-state bits.
! 258: */
! 259: if (pOD->optActualIndex != optIx) {
! 260: tOptDesc* p = pOpts->pOptDesc + pOD->optActualIndex;
! 261: p->optArg = pOD->optArg;
! 262: p->fOptState &= OPTST_PERSISTENT_MASK;
! 263: p->fOptState |= pOD->fOptState & ~OPTST_PERSISTENT_MASK;
! 264: printf(zEquivMode, pOpts->pzPROGNAME, pOD->pz_NAME, p->pz_NAME);
! 265: pOD = p;
! 266: }
! 267:
! 268: /*
! 269: * If the argument type is a set membership bitmask, then we always
! 270: * emit the thing. We do this because it will always have some sort
! 271: * of bitmask value and we need to emit the bit values.
! 272: */
! 273: if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP) {
! 274: print_membership(pOpts, pOD);
! 275: continue;
! 276: }
! 277:
! 278: /*
! 279: * IF the option was either specified or it wakes up enabled,
! 280: * then we will emit information. Otherwise, skip it.
! 281: * The idea is that if someone defines an option to initialize
! 282: * enabled, we should tell our shell script that it is enabled.
! 283: */
! 284: if (UNUSED_OPT(pOD) && DISABLED_OPT(pOD)) {
! 285: continue;
! 286: }
! 287:
! 288: /*
! 289: * Handle stacked arguments
! 290: */
! 291: if ( (pOD->fOptState & OPTST_STACKED)
! 292: && (pOD->optCookie != NULL) ) {
! 293: print_stacked_arg(pOpts, pOD);
! 294: continue;
! 295: }
! 296:
! 297: /*
! 298: * If the argument has been disabled,
! 299: * Then set its value to the disablement string
! 300: */
! 301: if ((pOD->fOptState & OPTST_DISABLED) != 0) {
! 302: printf(zOptDisabl, pOpts->pzPROGNAME, pOD->pz_NAME,
! 303: (pOD->pz_DisablePfx != NULL)
! 304: ? pOD->pz_DisablePfx : "false");
! 305: continue;
! 306: }
! 307:
! 308: /*
! 309: * If the argument type is numeric, the last arg pointer
! 310: * is really the VALUE of the string that was pointed to.
! 311: */
! 312: if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_NUMERIC) {
! 313: printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
! 314: (int)pOD->optArg.argInt);
! 315: continue;
! 316: }
! 317:
! 318: /*
! 319: * If the argument type is an enumeration, then it is much
! 320: * like a text value, except we call the callback function
! 321: * to emit the value corresponding to the "optArg" number.
! 322: */
! 323: if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_ENUMERATION) {
! 324: print_enumeration(pOpts, pOD);
! 325: continue;
! 326: }
! 327:
! 328: /*
! 329: * If the argument type is numeric, the last arg pointer
! 330: * is really the VALUE of the string that was pointed to.
! 331: */
! 332: if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_BOOLEAN) {
! 333: printf(zFullOptFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
! 334: (pOD->optArg.argBool == 0) ? "false" : "true");
! 335: continue;
! 336: }
! 337:
! 338: /*
! 339: * IF the option has an empty value,
! 340: * THEN we set the argument to the occurrence count.
! 341: */
! 342: if ( (pOD->optArg.argString == NULL)
! 343: || (pOD->optArg.argString[0] == NUL) ) {
! 344:
! 345: printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
! 346: pOD->optOccCt);
! 347: continue;
! 348: }
! 349:
! 350: /*
! 351: * This option has a text value
! 352: */
! 353: printf(zOptValFmt, pOpts->pzPROGNAME, pOD->pz_NAME);
! 354: print_quot_str(pOD->optArg.argString);
! 355: printf(zOptEnd, pOpts->pzPROGNAME, pOD->pz_NAME);
! 356:
! 357: } while (++optIx < pOpts->presetOptCt );
! 358:
! 359: if ( ((pOpts->fOptSet & OPTPROC_REORDER) != 0)
! 360: && (pOpts->curOptIdx < pOpts->origArgCt))
! 361: print_reordering(pOpts);
! 362:
! 363: fflush(stdout);
! 364: }
! 365:
! 366: /*
! 367: * Local Variables:
! 368: * mode: C
! 369: * c-file-style: "stroustrup"
! 370: * indent-tabs-mode: nil
! 371: * End:
! 372: * end of autoopts/putshell.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to putshell.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