Return to whatis.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/whatis.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <ctype.h>
                      3: /*
                      4:  * whatis - what the heck is that file anyways
                      5:  *
                      6:  * Bill Joy UCB
                      7:  */
                      8: 
                      9: char   *calloc();
                     10: char   *trim();
                     11: unsigned blklen();
                     12: 
                     13: main(argc, argv)
                     14:        int argc;
                     15:        char *argv[];
                     16: {
                     17:        register char **avp;
                     18: 
                     19:        argc--, argv++;
                     20:        if (argc == 0) {
                     21:                fprintf(stderr, "whatis name ...\n");
                     22:                exit(1);
                     23:        }
                     24:        if (freopen("/usr/lib/whatis", "r", stdin) == NULL) {
                     25:                perror("/usr/lib/whatis");
                     26:                exit (1);
                     27:        }
                     28:        argv[argc] = 0;
                     29:        for (avp = argv; *avp; avp++)
                     30:                *avp = trim(*avp);
                     31:        whatis(argv);
                     32:        exit(0);
                     33: }
                     34: 
                     35: whatis(argv)
                     36:        char **argv;
                     37: {
                     38:        char buf[BUFSIZ];
                     39:        register char *gotit;
                     40:        register char **vp;
                     41: 
                     42:        gotit = calloc(1, blklen(argv));
                     43:        while (fgets(buf, sizeof buf, stdin) != NULL)
                     44:                for (vp = argv; *vp; vp++)
                     45:                        if (match(buf, *vp)) {
                     46:                                printf("%s", buf);
                     47:                                gotit[vp - argv] = 1;
                     48:                                for (vp++; *vp; vp++)
                     49:                                        if (match(buf, *vp))
                     50:                                                gotit[vp - argv] = 1;
                     51:                                break;
                     52:                        }
                     53:        for (vp = argv; *vp; vp++)
                     54:                if (gotit[vp - argv] == 0)
                     55:                        printf("%s: not found\n", *vp);
                     56: }
                     57: 
                     58: match(buf, str)
                     59:        char *buf, *str;
                     60: {
                     61:        register char *bp, *cp;
                     62: 
                     63:        bp = buf;
                     64: again:
                     65:        cp = str;
                     66:        while (*bp && *cp && lmatch(*bp, *cp))
                     67:                bp++, cp++;
                     68:        if (*cp == 0 && (*bp == '(' || *bp == ',' || *bp == '\t' || *bp == ' '))
                     69:                return (1);
                     70:        while (isalpha(*bp) || isdigit(*bp))
                     71:                bp++;
                     72:        if (*bp != ',')
                     73:                return (0);
                     74:        bp++;
                     75:        while (isspace(*bp))
                     76:                bp++;
                     77:        goto again;
                     78: }
                     79: 
                     80: lmatch(c, d)
                     81:        char c, d;
                     82: {
                     83: 
                     84:        if (c == d)
                     85:                return (1);
                     86:        if (!isalpha(c) || !isalpha(d))
                     87:                return (0);
                     88:        if (islower(c))
                     89:                c = toupper(c);
                     90:        if (islower(d))
                     91:                d = toupper(d);
                     92:        return (c == d);
                     93: }
                     94: 
                     95: unsigned
                     96: blklen(ip)
                     97:        register char **ip;
                     98: {
                     99:        register int i = 0;
                    100: 
                    101:        while (*ip++)
                    102:                i++;
                    103:        return (i);
                    104: }
                    105: 
                    106: char *
                    107: trim(cp)
                    108:        register char *cp;
                    109: {
                    110:        register char *dp;
                    111: 
                    112:        for (dp = cp; *dp; dp++)
                    113:                if (*dp == '/')
                    114:                        cp = dp + 1;
                    115:        if (cp[0] != '.') {
                    116:                if (cp + 3 <= dp && dp[-2] == '.' && any(dp[-1], "cosa12345678npP"))
                    117:                        dp[-2] = 0;
                    118:                if (cp + 4 <= dp && dp[-3] == '.' && any(dp[-2], "13") && isalpha(dp[-1]))
                    119:                        dp[-3] = 0;
                    120:        }
                    121:        return (cp);
                    122: }
                    123: 
                    124: any(c, cp)
                    125:        register int c;
                    126:        register char *cp;
                    127: {
                    128: 
                    129:        while (*cp)
                    130:                if (c == *cp++)
                    131:                        return (1);
                    132:        return (0);
                    133: }

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