Return to look.c CVS log

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

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

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

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