Return to args.c CVS log

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

Annotation of researchv8dc/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 'D':
                     35:                        p = index (optarg, '=');
                     36:                        if (p == NULL) {
                     37:                                fprintf (stderr, "invalid option %s\n", optarg);
                     38:                                exit (1);
                     39:                        }
                     40:                        rl = new (struct replist);
                     41: 
                     42:                        /* copy the pathname to rl->source */
                     43:                        rl->source = alloc ((unsigned) (p - optarg + 1));
                     44:                        p = rl->source;
                     45:                        q = optarg;
                     46:                        while (*q != '=')
                     47:                                *p++ = *q++;
                     48:                        *p = '\0';
                     49: 
                     50:                        /* now expand rl->source */
                     51:                        p = rl->source;
                     52:                        rl->source = copy (fullname (p));
                     53:                        free (p);
                     54: 
                     55:                        /* expand rl->dest */
                     56:                        rl->dest = copy (fullname (q + 1));
                     57: 
                     58:                        /* link rl into the chain */
                     59:                        rl->link = replist;
                     60:                        replist = rl;
                     61:                        break;
                     62: 
                     63:                case 'K':
                     64:                        Kflag++;
                     65:                        keyfile = optarg;
                     66:                        break;
                     67: 
                     68:                case '?':
                     69:                default:
                     70:                        rc++;
                     71:                        break;
                     72:                }
                     73:        }
                     74: 
                     75:        if (rc) {
                     76:                fprintf (stderr, "%s: bad argument\n", argv[0]);
                     77:                exit (rc);
                     78:        }
                     79: 
                     80:        if (kflag && Kflag) {
                     81:                fprintf (stderr, "%s: cannot specify both k and K\n", argv[0]);
                     82:                exit (1);
                     83:        }
                     84: 
                     85:        /* read key from terminal if requested */
                     86:        if (kflag) {
                     87:                register char *p;
                     88:                p = getpass ("Key:");
                     89: 
                     90:                /* a null key is treated as no key at all */
                     91:                if (p && *p)
                     92:                        setup (p);
                     93:                else
                     94:                        kflag = 0;
                     95:        }
                     96:        
                     97:        /* read key from file if requested */
                     98:        if (Kflag) {
                     99:                char key[100];
                    100:                register FILE *kf;
                    101:                register char *p;
                    102: 
                    103:                /* try to open the file */
                    104:                kf = fopen (keyfile, "r");
                    105:                if (kf == NULL) {
                    106:                        perror (keyfile);
                    107:                        exit (1);
                    108:                }
                    109: 
                    110:                /* read the first line */
                    111:                p = fgets (key, sizeof (key), kf);
                    112: 
                    113:                fclose (kf);
                    114: 
                    115:                /* if EOF, assume no key */
                    116:                if (p == NULL) {
                    117:                        Kflag = 0;
                    118:                } else {
                    119: 
                    120:                        /* delete the trailing newline */
                    121:                        p = key;
                    122:                        while (*p != '\n' && *p != '\0')
                    123:                                p++;
                    124:                        *p = '\0';
                    125: 
                    126:                        /* if the key is empty, assume no key */
                    127:                        if (key[0] == '\0')
                    128:                                Kflag = 0;
                    129:                        else
                    130:                                setup (key);
                    131:                }
                    132:        }
                    133: 
                    134:        if (func) {
                    135:                /* process the arguments */
                    136:                if (optind >= argc)
                    137:                        rc = (*func) (stdin, "standard input");
                    138:                else {
                    139:                        register int i;
                    140:                        for (i = optind; i < argc; i++) {
                    141:                                register char *fn = argv[i];
                    142:                                register FILE *f = fopen (fn, "r");
                    143:                                if (f) {
                    144:                                        rc += (*func) (f, argv[i]);
                    145:                                        fclose (f);
                    146:                                } else {
                    147:                                        fprintf (stderr, "%s: can't open %s\n", argv[0], fn);
                    148:                                        rc++;
                    149:                                }
                    150:                        }
                    151:                }
                    152:        }
                    153: 
                    154:        return rc;
                    155: }

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