Return to args.c CVS log

Up to [Research Unix] / researchv10no / cmd / asd

Annotation of researchv10no/cmd/asd/args.c, revision 1.1.1.1

1.1       root        1: #include "asd.h"
                      2: 
                      3: getargs (argc, argv, optkey, func)
                      4:        int argc;
                      5:        char **argv;
                      6:        char *optkey;
                      7:        int (*func)();
                      8: {
                      9:        register int c;
                     10:        int rc = 0;
                     11: 
                     12:        while ((c = getopt (argc, argv, optkey)) != EOF) {
                     13:                register struct replist *rl;
                     14:                register char *p, *q;
                     15: 
                     16:                switch (c) {
                     17: 
                     18:                case 'b':
                     19:                        bflag++;
                     20:                        break;
                     21: 
                     22:                case 'k':
                     23:                        kflag++;
                     24:                        break;
                     25: 
                     26:                case 'n':
                     27:                        nflag++;
                     28:                        break;
                     29:                
                     30:                case 'v':
                     31:                        vflag++;
                     32:                        break;
                     33: 
                     34:                case 'x':
                     35:                        if (xstr) {
                     36:                                fprintf (stderr, "duplicate -x ignored\n");
                     37:                                rc++;
                     38:                        } else if (Xstr) {
                     39:                                fprintf (stderr, "cannot have both -x and -X\n");
                     40:                                rc++;
                     41:                        } else
                     42:                                xstr = optarg;
                     43:                        break;
                     44: 
                     45:                case 'X':
                     46:                        if (Xstr) {
                     47:                                fprintf (stderr, "duplicate -X ignored\n");
                     48:                                rc++;
                     49:                        } else if (xstr) {
                     50:                                fprintf (stderr, "cannot have both -x and -X\n");
                     51:                                rc++;
                     52:                        } else
                     53:                                Xstr = copy (transname (optarg));
                     54:                        break;
                     55: 
                     56:                case 'D':
                     57:                        p = strchr (optarg, '=');
                     58:                        if (p == NULL) {
                     59:                                fprintf (stderr, "invalid option %s\n", optarg);
                     60:                                exit (1);
                     61:                        }
                     62:                        rl = new (struct replist);
                     63: 
                     64:                        /* copy the pathname to rl->source */
                     65:                        rl->source = alloc ((unsigned) (p - optarg + 1));
                     66:                        p = rl->source;
                     67:                        q = optarg;
                     68:                        while (*q != '=')
                     69:                                *p++ = *q++;
                     70:                        *p = '\0';
                     71: 
                     72:                        /* now expand rl->source */
                     73:                        p = rl->source;
                     74:                        rl->source = copy (fullname (p));
                     75:                        free (p);
                     76: 
                     77:                        /* expand rl->dest */
                     78:                        rl->dest = copy (fullname (q + 1));
                     79: 
                     80:                        /* link rl into the chain */
                     81:                        rl->link = replist;
                     82:                        replist = rl;
                     83:                        break;
                     84: 
                     85:                case 'K':
                     86:                        Kflag++;
                     87:                        keyfile = optarg;
                     88:                        break;
                     89: 
                     90:                case '?':
                     91:                default:
                     92:                        rc++;
                     93:                        break;
                     94:                }
                     95:        }
                     96: 
                     97:        if (rc) {
                     98:                fprintf (stderr, "%s: bad argument\n", argv[0]);
                     99:                exit (rc);
                    100:        }
                    101: 
                    102:        if (kflag && Kflag) {
                    103:                fprintf (stderr, "%s: cannot specify both k and K\n", argv[0]);
                    104:                exit (1);
                    105:        }
                    106: 
                    107:        /* read key from terminal if requested */
                    108:        if (kflag) {
                    109:                register char *p;
                    110:                p = getpass ("Key:");
                    111: 
                    112:                /* a null key is treated as no key at all */
                    113:                if (p && *p)
                    114:                        setup (p);
                    115:                else
                    116:                        kflag = 0;
                    117:        }
                    118:        
                    119:        /* read key from file if requested */
                    120:        if (Kflag) {
                    121:                char key[100];
                    122:                register FILE *kf;
                    123:                register char *p;
                    124: 
                    125:                /* try to open the file */
                    126:                kf = fopen (keyfile, "r");
                    127:                if (kf == NULL) {
                    128:                        perror (keyfile);
                    129:                        exit (1);
                    130:                }
                    131: 
                    132:                /* read the first line */
                    133:                p = fgets (key, sizeof (key), kf);
                    134: 
                    135:                fclose (kf);
                    136: 
                    137:                /* if EOF, assume no key */
                    138:                if (p == NULL) {
                    139:                        Kflag = 0;
                    140:                } else {
                    141: 
                    142:                        /* delete the trailing newline */
                    143:                        p = key;
                    144:                        while (*p != '\n' && *p != '\0')
                    145:                                p++;
                    146:                        *p = '\0';
                    147: 
                    148:                        /* if the key is empty, assume no key */
                    149:                        if (key[0] == '\0')
                    150:                                Kflag = 0;
                    151:                        else
                    152:                                setup (key);
                    153:                }
                    154:        }
                    155: 
                    156:        if (func) {
                    157:                /* process the arguments */
                    158:                if (optind >= argc)
                    159:                        rc = (*func) (stdin, "standard input");
                    160:                else {
                    161:                        register int i;
                    162:                        for (i = optind; i < argc; i++) {
                    163:                                register char *fn = argv[i];
                    164:                                register FILE *f = fopen (fn, "r");
                    165:                                if (f) {
                    166:                                        rc += (*func) (f, argv[i]);
                    167:                                        fclose (f);
                    168:                                } else {
                    169:                                        fprintf (stderr, "%s: can't open %s\n", argv[0], fn);
                    170:                                        rc++;
                    171:                                }
                    172:                        }
                    173:                }
                    174:        }
                    175: 
                    176:        return rc;
                    177: }

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