Return to getopts.c CVS log

Up to [MW Coherent from dump] / coherent / a / usr / bob / korn

Annotation of coherent/a/usr/bob/korn/getopts.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Reimplementation of SysVr3 sh builtin command "getopts" for S5R2 shell.
                      3:  *
                      4:  * created by Arnold Robbins
                      5:  * modified by Doug Gwyn
                      6:  * modified for PD ksh by Eric Gisin
                      7:  */
                      8: 
                      9: static char *RCSid = "$Header: getopts.c,v 3.1 88/11/03 09:16:01 egisin Exp $";
                     10: 
                     11: #include <stddef.h>
                     12: #include <stdlib.h>
                     13: #include <string.h>
                     14: #include <errno.h>
                     15: #include <setjmp.h>
                     16: #include "sh.h"
                     17: #include "table.h"
                     18: 
                     19: /*
                     20:  * The following is derived from getopt() source placed into the public
                     21:  * domain by AT&T (the only time they're known to have done that).
                     22:  *
                     23:  * It has been modified somewhat to fit into the context of the shell.
                     24:  *
                     25:  * -D"FASCIST" if you really want to strictly enforce ALL the
                     26:  * Command Syntax Standard rules (not recommended).
                     27:  */
                     28: 
                     29: #define GETOPTEOF      (-1)
                     30: #define ERR(S, C)      shellf("%s%c\n", (S), (C))
                     31: 
                     32:        int     optind;
                     33: static char    *optarg;
                     34: static int     sp;
                     35: 
                     36: static int
                     37: getopt(argc, argv, opts)
                     38:        int argc;
                     39:        register char **argv, *opts;
                     40: {
                     41:        register int c;
                     42:        register char *cp;
                     43: 
                     44:        if (sp == 1)
                     45:                if (optind >= argc ||
                     46:                   argv[optind][0] != '-' || argv[optind][1] == '\0')
                     47:                        return(GETOPTEOF);
                     48:                else if (strcmp(argv[optind], "--") == 0) {
                     49:                        optind++;
                     50:                        return(GETOPTEOF);
                     51:                }
                     52:        c = argv[optind][sp];
                     53:        if (c == ':' || (cp=strchr(opts, c)) == NULL) {
                     54:                ERR("illegal option -- ", c);
                     55:                if (argv[optind][++sp] == '\0') {
                     56:                        optind++;
                     57:                        sp = 1;
                     58:                }
                     59:                optarg = NULL;
                     60:                return('?');
                     61:        }
                     62:        if (*++cp == ':') {
                     63: #if FASCIST
                     64:                if (sp != 1) {
                     65:                        ERR("option must not be grouped -- ", c );
                     66:                        optind++;
                     67:                        sp = 1;
                     68:                        optarg = NULL;
                     69:                        return('?');
                     70:                } else
                     71: #endif
                     72:                if (argv[optind][sp+1] != '\0') {
                     73: #if FASCIST
                     74:                        ERR("option must be followed by whitespace -- ", c );
                     75:                        optind++;
                     76:                        sp = 1;
                     77:                        optarg = NULL;
                     78:                        return('?');
                     79: #else
                     80:                        optarg = &argv[optind++][sp+1];
                     81: #endif
                     82:                } else if (++optind >= argc) {
                     83:                        ERR("option requires an argument -- ", c);
                     84:                        sp = 1;
                     85:                        optarg = NULL;
                     86:                        return('?');
                     87:                } else
                     88:                        optarg = argv[optind++];
                     89:                sp = 1;
                     90:        } else {
                     91:                if (argv[optind][++sp] == '\0') {
                     92:                        sp = 1;
                     93:                        optind++;
                     94:                }
                     95:                optarg = NULL;
                     96:        }
                     97:        return(c);
                     98: }
                     99: 
                    100: /*
                    101:  * The following were created by Arnold Robbins.
                    102:  */
                    103: 
                    104: /* resetopts --- magic code for when OPTIND is reset to 1 */
                    105: 
                    106: void
                    107: resetopts ()
                    108: {
                    109:        optind = 1;
                    110:        sp = 1;
                    111: }
                    112: 
                    113: int
                    114: c_getopts(wp)
                    115:        char **wp;
                    116: {
                    117:        int ret;
                    118:        register int argc;
                    119:        char temp[2];
                    120:        char *optstr;                   /* list of options */
                    121:        char *name;                     /* variable to get flag val */
                    122: 
                    123:        if ((optstr = *++wp) == NULL || (name = *++wp) == NULL)
                    124:                errorf("missing arguments\n");
                    125: 
                    126:        for (argc = 1; wp[argc] != NULL; argc++)
                    127:                ;
                    128: 
                    129:        if (argc > 1)
                    130:                ret = getopt(argc, wp, optstr);
                    131:        else
                    132:                ret = getopt(e.loc->argc+1, e.loc->argv, optstr);
                    133: 
                    134:        /*
                    135:         * set the OPTIND variable in any case, to handle "--" skipping
                    136:         */
                    137: 
                    138:        setint(global("OPTIND"), (long)optind);
                    139: 
                    140:        if (ret == GETOPTEOF)           /* end of args */
                    141:                return (1);
                    142: 
                    143:        /*
                    144:         * else, got an arg, set the various shell variables
                    145:         */
                    146: 
                    147:        if (optarg != NULL)
                    148:                setstr(global("OPTARG"), optarg);
                    149: 
                    150:        temp[0] = (char) ret;
                    151:        temp[1] = '\0';
                    152:        setstr(global(name), temp);
                    153: 
                    154:        return (0);
                    155: }
                    156: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.