Return to look.c CVS log

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

Annotation of 41BSD/cmd/look.c, revision 1.1

1.1     ! root        1: static char *sccsid = "@(#)look.c      4.1 (Berkeley) 10/1/80";
        !             2: #include <stdio.h>
        !             3: #include <ctype.h>
        !             4: 
        !             5: FILE *dfile;
        !             6: char *filenam  = "/usr/dict/words";
        !             7: 
        !             8: int fold;
        !             9: int dict;
        !            10: int tab;
        !            11: char entry[250];
        !            12: char word[250];
        !            13: char key[50];
        !            14: 
        !            15: main(argc,argv)
        !            16: char **argv;
        !            17: {
        !            18:        register c;
        !            19:        long top,bot,mid;
        !            20:        while(argc>=2 && *argv[1]=='-') {
        !            21:                for(;;) {
        !            22:                        switch(*++argv[1]) {
        !            23:                        case 'd':
        !            24:                                dict++;
        !            25:                                continue;
        !            26:                        case 'f':
        !            27:                                fold++;
        !            28:                                continue;
        !            29:                        case 't':
        !            30:                                tab = argv[1][1];
        !            31:                                if(tab)
        !            32:                                        ++argv[1];
        !            33:                                continue;
        !            34:                        case 0:
        !            35:                                break;
        !            36:                        default:
        !            37:                                continue;
        !            38:                        }
        !            39:                        break;
        !            40:                }
        !            41:                argc --;
        !            42:                argv++;
        !            43:        }
        !            44:        if(argc<=1)
        !            45:                return;
        !            46:        if(argc==2) {
        !            47:                fold++;
        !            48:                dict++;
        !            49:        } else
        !            50:                filenam = argv[2];
        !            51:        dfile = fopen(filenam,"r");
        !            52:        if(dfile==NULL) {
        !            53:                fprintf(stderr,"look: can't open %s\n",filenam);
        !            54:                exit(2);
        !            55:        }
        !            56:        canon(argv[1],key);
        !            57:        bot = 0;
        !            58:        fseek(dfile,0L,2);
        !            59:        top = ftell(dfile);
        !            60:        for(;;) {
        !            61:                mid = (top+bot)/2;
        !            62:                fseek(dfile,mid,0);
        !            63:                do {
        !            64:                        c = getc(dfile);
        !            65:                        mid++;
        !            66:                } while(c!=EOF && c!='\n');
        !            67:                if(!getword(entry))
        !            68:                        break;
        !            69:                canon(entry,word);
        !            70:                switch(compare(key,word)) {
        !            71:                case -2:
        !            72:                case -1:
        !            73:                case 0:
        !            74:                        if(top<=mid)
        !            75:                                break;
        !            76:                        top = mid;
        !            77:                        continue;
        !            78:                case 1:
        !            79:                case 2:
        !            80:                        bot = mid;
        !            81:                        continue;
        !            82:                }
        !            83:                break;
        !            84:        }
        !            85:        fseek(dfile,bot,0);
        !            86:        while(ftell(dfile)<top) {
        !            87:                if(!getword(entry))
        !            88:                        return;
        !            89:                canon(entry,word);
        !            90:                switch(compare(key,word)) {
        !            91:                case -2:
        !            92:                        return;
        !            93:                case -1:
        !            94:                case 0:
        !            95:                        puts(entry,stdout);
        !            96:                        break;
        !            97:                case 1:
        !            98:                case 2:
        !            99:                        continue;
        !           100:                }
        !           101:                break;
        !           102:        }
        !           103:        while(getword(entry)) {
        !           104:                canon(entry,word);
        !           105:                switch(compare(key,word)) {
        !           106:                case -1:
        !           107:                case 0:
        !           108:                        puts(entry,stdout);
        !           109:                        continue;
        !           110:                }
        !           111:                break;
        !           112:        }
        !           113: }
        !           114: 
        !           115: compare(s,t)
        !           116: register char *s,*t;
        !           117: {
        !           118:        for(;*s==*t;s++,t++)
        !           119:                if(*s==0)
        !           120:                        return(0);
        !           121:        return(*s==0? -1:
        !           122:                *t==0? 1:
        !           123:                *s<*t? -2:
        !           124:                2);
        !           125: }
        !           126: 
        !           127: getword(w)
        !           128: char *w;
        !           129: {
        !           130:        register c;
        !           131:        for(;;) {
        !           132:                c = getc(dfile);
        !           133:                if(c==EOF)
        !           134:                        return(0);
        !           135:                if(c=='\n')
        !           136:                        break;
        !           137:                *w++ = c;
        !           138:        }
        !           139:        *w = 0;
        !           140:        return(1);
        !           141: }
        !           142: 
        !           143: canon(old,new)
        !           144: char *old,*new;
        !           145: {
        !           146:        register c;
        !           147:        for(;;) {
        !           148:                *new = c = *old++;
        !           149:                if(c==0||c==tab) {
        !           150:                        *new = 0;
        !           151:                        break;
        !           152:                }
        !           153:                if(dict) {
        !           154:                        if(!isalnum(c))
        !           155:                                continue;
        !           156:                }
        !           157:                if(fold) {
        !           158:                        if(isupper(c))
        !           159:                                *new += 'a' - 'A';
        !           160:                }
        !           161:                new++;
        !           162:        }
        !           163: }

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