Return to whatis.c CVS log

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

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

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

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