[BACK]Return to egetopt.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / pr

Annotation of src/usr.bin/pr/egetopt.c, Revision 1.5

1.5     ! millert     1: /*     $OpenBSD: egetopt.c,v 1.4 2001/11/19 19:02:15 mpech Exp $       */
1.2       deraadt     2:
1.1       deraadt     3: /*-
                      4:  * Copyright (c) 1991 Keith Muller.
                      5:  * Copyright (c) 1993
                      6:  *     The Regents of the University of California.  All rights reserved.
                      7:  *
                      8:  * This code is derived from software contributed to Berkeley by
                      9:  * Keith Muller of the University of California, San Diego.
                     10:  *
                     11:  * Redistribution and use in source and binary forms, with or without
                     12:  * modification, are permitted provided that the following conditions
                     13:  * are met:
                     14:  * 1. Redistributions of source code must retain the above copyright
                     15:  *    notice, this list of conditions and the following disclaimer.
                     16:  * 2. Redistributions in binary form must reproduce the above copyright
                     17:  *    notice, this list of conditions and the following disclaimer in the
                     18:  *    documentation and/or other materials provided with the distribution.
1.5     ! millert    19:  * 3. Neither the name of the University nor the names of its contributors
1.1       deraadt    20:  *    may be used to endorse or promote products derived from this software
                     21:  *    without specific prior written permission.
                     22:  *
                     23:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     24:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     25:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     26:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     27:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     28:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     29:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     30:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     31:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     32:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     33:  * SUCH DAMAGE.
                     34:  */
                     35:
                     36: #ifndef lint
                     37: /* from: static char sccsid[] = "@(#)egetopt.c 8.1 (Berkeley) 6/6/93"; */
1.5     ! millert    38: static char *rcsid = "$OpenBSD: egetopt.c,v 1.4 2001/11/19 19:02:15 mpech Exp $";
1.1       deraadt    39: #endif /* not lint */
                     40:
                     41: #include <ctype.h>
                     42: #include <stdio.h>
                     43: #include <stdlib.h>
                     44: #include <string.h>
                     45:
                     46: #include "extern.h"
                     47:
                     48: /*
                     49:  * egetopt:    get option letter from argument vector (an extended
                     50:  *             version of getopt).
                     51:  *
                     52:  * Non standard additions to the ostr specs are:
                     53:  * 1) '?': immediate value following arg is optional (no white space
                     54:  *    between the arg and the value)
                     55:  * 2) '#': +/- followed by a number (with an optional sign but
                     56:  *    no white space between the arg and the number). The - may be
                     57:  *    combined with other options, but the + cannot.
                     58:  */
                     59:
                     60: int    eopterr = 1;            /* if error message should be printed */
                     61: int    eoptind = 1;            /* index into parent argv vector */
                     62: int    eoptopt;                /* character checked for validity */
                     63: char   *eoptarg;               /* argument associated with option */
                     64:
                     65: #define        BADCH   (int)'?'
                     66: #define        EMSG    ""
                     67:
                     68: int
                     69: egetopt(nargc, nargv, ostr)
                     70:        int nargc;
                     71:        char * const *nargv;
                     72:        const char *ostr;
                     73: {
                     74:        static char *place = EMSG;      /* option letter processing */
1.4       mpech      75:        char *oli;                      /* option letter list index */
1.1       deraadt    76:        static int delim;               /* which option delimeter */
1.4       mpech      77:        char *p;
1.1       deraadt    78:        static char savec = '\0';
                     79:
                     80:        if (savec != '\0') {
                     81:                *place = savec;
                     82:                savec = '\0';
                     83:        }
                     84:
                     85:        if (!*place) {
                     86:                /*
                     87:                 * update scanning pointer
                     88:                 */
                     89:                if ((eoptind >= nargc) ||
                     90:                    ((*(place = nargv[eoptind]) != '-') && (*place != '+'))) {
                     91:                        place = EMSG;
1.3       millert    92:                        return (-1);
1.1       deraadt    93:                }
                     94:
                     95:                delim = (int)*place;
                     96:                if (place[1] && *++place == '-' && !place[1]) {
                     97:                        /*
                     98:                         * found "--"
                     99:                         */
                    100:                        ++eoptind;
                    101:                        place = EMSG;
1.3       millert   102:                        return (-1);
1.1       deraadt   103:                }
                    104:        }
                    105:
                    106:        /*
                    107:         * check option letter
                    108:         */
                    109:        if ((eoptopt = (int)*place++) == (int)':' || (eoptopt == (int)'?') ||
                    110:            !(oli = strchr(ostr, eoptopt))) {
                    111:                /*
                    112:                 * if the user didn't specify '-' as an option,
                    113:                 * assume it means EOF when by itself.
                    114:                 */
                    115:                if ((eoptopt == (int)'-') && !*place)
1.3       millert   116:                        return (-1);
1.1       deraadt   117:                if (strchr(ostr, '#') && (isdigit(eoptopt) ||
                    118:                    (((eoptopt == (int)'-') || (eoptopt == (int)'+')) &&
                    119:                      isdigit(*place)))) {
                    120:                        /*
                    121:                         * # option: +/- with a number is ok
                    122:                         */
                    123:                        for (p = place; *p != '\0'; ++p) {
                    124:                                if (!isdigit(*p))
                    125:                                        break;
                    126:                        }
                    127:                        eoptarg = place-1;
                    128:
                    129:                        if (*p == '\0') {
                    130:                                place = EMSG;
                    131:                                ++eoptind;
                    132:                        } else {
                    133:                                place = p;
                    134:                                savec = *p;
                    135:                                *place = '\0';
                    136:                        }
                    137:                        return (delim);
                    138:                }
                    139:
                    140:                if (!*place)
                    141:                        ++eoptind;
                    142:                if (eopterr) {
                    143:                        if (!(p = strrchr(*nargv, '/')))
                    144:                                p = *nargv;
                    145:                        else
                    146:                                ++p;
                    147:                        (void)fprintf(stderr, "%s: illegal option -- %c\n",
                    148:                            p, eoptopt);
                    149:                }
                    150:                return (BADCH);
                    151:        }
                    152:        if (delim == (int)'+') {
                    153:                /*
                    154:                 * '+' is only allowed with numbers
                    155:                 */
                    156:                if (!*place)
                    157:                        ++eoptind;
                    158:                if (eopterr) {
                    159:                        if (!(p = strrchr(*nargv, '/')))
                    160:                                p = *nargv;
                    161:                        else
                    162:                                ++p;
                    163:                        (void)fprintf(stderr,
                    164:                                "%s: illegal '+' delimiter with option -- %c\n",
                    165:                                p, eoptopt);
                    166:                }
                    167:                return (BADCH);
                    168:        }
                    169:        ++oli;
                    170:        if ((*oli != ':') && (*oli != '?')) {
                    171:                /*
                    172:                 * don't need argument
                    173:                 */
                    174:                eoptarg = NULL;
                    175:                if (!*place)
                    176:                        ++eoptind;
                    177:                return (eoptopt);
                    178:        }
                    179:
                    180:        if (*place) {
                    181:                /*
                    182:                 * no white space
                    183:                 */
                    184:                eoptarg = place;
                    185:        } else if (*oli == '?') {
                    186:                /*
                    187:                 * no arg, but NOT required
                    188:                 */
                    189:                eoptarg = NULL;
                    190:        } else if (nargc <= ++eoptind) {
                    191:                /*
                    192:                 * no arg, but IS required
                    193:                 */
                    194:                place = EMSG;
                    195:                if (eopterr) {
                    196:                        if (!(p = strrchr(*nargv, '/')))
                    197:                                p = *nargv;
                    198:                        else
                    199:                                ++p;
                    200:                        (void)fprintf(stderr,
                    201:                            "%s: option requires an argument -- %c\n", p,
                    202:                            eoptopt);
                    203:                }
                    204:                return (BADCH);
                    205:        } else {
                    206:                /*
                    207:                 * arg has white space
                    208:                 */
                    209:                eoptarg = nargv[eoptind];
                    210:        }
                    211:        place = EMSG;
                    212:        ++eoptind;
                    213:        return (eoptopt);
                    214: }