Return to numeric.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / sntp / libopts

Annotation of embedaddon/ntp/sntp/libopts/numeric.c, revision 1.1

1.1     ! misho       1: 
        !             2: /**
        !             3:  * \file numeric.c
        !             4:  *
        !             5:  *  Time-stamp:      "2011-03-25 16:26:10 bkorb"
        !             6:  *
        !             7:  *  This file is part of AutoOpts, a companion to AutoGen.
        !             8:  *  AutoOpts is free software.
        !             9:  *  AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved
        !            10:  *
        !            11:  *  AutoOpts is available under any one of two licenses.  The license
        !            12:  *  in use must be one of these two and the choice is under the control
        !            13:  *  of the user of the license.
        !            14:  *
        !            15:  *   The GNU Lesser General Public License, version 3 or later
        !            16:  *      See the files "COPYING.lgplv3" and "COPYING.gplv3"
        !            17:  *
        !            18:  *   The Modified Berkeley Software Distribution License
        !            19:  *      See the file "COPYING.mbsd"
        !            20:  *
        !            21:  *  These files have the following md5sums:
        !            22:  *
        !            23:  *  43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
        !            24:  *  06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
        !            25:  *  66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
        !            26:  */
        !            27: 
        !            28: /*=export_func  optionShowRange
        !            29:  * private:
        !            30:  *
        !            31:  * what:  
        !            32:  * arg:   + tOptions* + pOpts     + program options descriptor  +
        !            33:  * arg:   + tOptDesc* + pOptDesc  + the descriptor for this arg +
        !            34:  * arg:   + void *    + rng_table + the value range tables      +
        !            35:  * arg:   + int       + rng_count + the number of entries       +
        !            36:  *
        !            37:  * doc:
        !            38:  *   Show information about a numeric option with range constraints.
        !            39: =*/
        !            40: void
        !            41: optionShowRange(tOptions* pOpts, tOptDesc* pOD, void * rng_table, int rng_ct)
        !            42: {
        !            43:     static char const bullet[] = "\t\t\t\t- ";
        !            44:     static char const deepin[] = "\t\t\t\t  ";
        !            45:     static char const onetab[] = "\t";
        !            46: 
        !            47:     const struct {long const rmin, rmax;} * rng = rng_table;
        !            48: 
        !            49:     char const * pz_indent    = bullet;
        !            50: 
        !            51:     /*
        !            52:      * The range is shown only for full usage requests and an error
        !            53:      * in this particular option.
        !            54:      */
        !            55:     if (pOpts != OPTPROC_EMIT_USAGE) {
        !            56:         if (pOpts <= OPTPROC_EMIT_LIMIT)
        !            57:             return;
        !            58:         pz_indent = onetab;
        !            59: 
        !            60:         fprintf(option_usage_fp, zRangeErr, pOpts->pzProgName,
        !            61:                 pOD->pz_Name, pOD->optArg.argString);
        !            62:         pz_indent = "";
        !            63:     }
        !            64: 
        !            65:     if (pOD->fOptState & OPTST_SCALED_NUM)
        !            66:         fprintf(option_usage_fp, zRangeScaled, pz_indent);
        !            67: 
        !            68:     fprintf(option_usage_fp, (rng_ct > 1) ? zRangeLie : zRangeOnly, pz_indent);
        !            69:     pz_indent = (pOpts != OPTPROC_EMIT_USAGE) ? onetab : deepin;
        !            70: 
        !            71:     for (;;) {
        !            72:         if (rng->rmax == LONG_MIN)
        !            73:             fprintf(option_usage_fp, zRangeExact, pz_indent, rng->rmin);
        !            74:         else if (rng->rmin == LONG_MIN)
        !            75:             fprintf(option_usage_fp, zRangeUpto, pz_indent, rng->rmax);
        !            76:         else if (rng->rmax == LONG_MAX)
        !            77:             fprintf(option_usage_fp, zRangeAbove, pz_indent, rng->rmin);
        !            78:         else
        !            79:             fprintf(option_usage_fp, zRange, pz_indent, rng->rmin,
        !            80:                     rng->rmax);
        !            81: 
        !            82:         if  (--rng_ct <= 0) {
        !            83:             fputc('\n', option_usage_fp);
        !            84:             break;
        !            85:         }
        !            86:         fputs(zRangeOr, option_usage_fp);
        !            87:         rng++;
        !            88:     }
        !            89: 
        !            90:     if (pOpts > OPTPROC_EMIT_LIMIT)
        !            91:         pOpts->pUsageProc(pOpts, EXIT_FAILURE);
        !            92: }
        !            93: 
        !            94: /*=export_func  optionNumericVal
        !            95:  * private:
        !            96:  *
        !            97:  * what:  process an option with a numeric value.
        !            98:  * arg:   + tOptions* + pOpts    + program options descriptor +
        !            99:  * arg:   + tOptDesc* + pOptDesc + the descriptor for this arg +
        !           100:  *
        !           101:  * doc:
        !           102:  *  Decipher a numeric value.
        !           103: =*/
        !           104: void
        !           105: optionNumericVal(tOptions* pOpts, tOptDesc* pOD )
        !           106: {
        !           107:     char* pz;
        !           108:     long  val;
        !           109: 
        !           110:     /*
        !           111:      *  Numeric options may have a range associated with it.
        !           112:      *  If it does, the usage procedure requests that it be
        !           113:      *  emitted by passing a NULL pOD pointer.  Also bail out
        !           114:      *  if there is no option argument or if we are being reset.
        !           115:      */
        !           116:     if (  (pOD == NULL)
        !           117:        || (pOD->optArg.argString == NULL)
        !           118:        || ((pOD->fOptState & OPTST_RESET) != 0))
        !           119:         return;
        !           120: 
        !           121:     errno = 0;
        !           122:     val = strtol(pOD->optArg.argString, &pz, 0);
        !           123:     if ((pz == pOD->optArg.argString) || (errno != 0))
        !           124:         goto bad_number;
        !           125: 
        !           126:     if ((pOD->fOptState & OPTST_SCALED_NUM) != 0)
        !           127:         switch (*(pz++)) {
        !           128:         case '\0': pz--; break;
        !           129:         case 't':  val *= 1000;
        !           130:         case 'g':  val *= 1000;
        !           131:         case 'm':  val *= 1000;
        !           132:         case 'k':  val *= 1000; break;
        !           133: 
        !           134:         case 'T':  val *= 1024;
        !           135:         case 'G':  val *= 1024;
        !           136:         case 'M':  val *= 1024;
        !           137:         case 'K':  val *= 1024; break;
        !           138: 
        !           139:         default:   goto bad_number;
        !           140:         }
        !           141: 
        !           142:     if (*pz != NUL)
        !           143:         goto bad_number;
        !           144: 
        !           145:     if (pOD->fOptState & OPTST_ALLOC_ARG) {
        !           146:         AGFREE(pOD->optArg.argString);
        !           147:         pOD->fOptState &= ~OPTST_ALLOC_ARG;
        !           148:     }
        !           149: 
        !           150:     pOD->optArg.argInt = val;
        !           151:     return;
        !           152: 
        !           153:     bad_number:
        !           154: 
        !           155:     fprintf( stderr, zNotNumber, pOpts->pzProgName, pOD->optArg.argString );
        !           156:     if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
        !           157:         (*(pOpts->pUsageProc))(pOpts, EXIT_FAILURE);
        !           158: 
        !           159:     errno = EINVAL;
        !           160:     pOD->optArg.argInt = ~0;
        !           161: }
        !           162: 
        !           163: /*
        !           164:  * Local Variables:
        !           165:  * mode: C
        !           166:  * c-file-style: "stroustrup"
        !           167:  * indent-tabs-mode: nil
        !           168:  * End:
        !           169:  * end of autoopts/numeric.c */