Return to code.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / find

Annotation of 43BSD/usr.bin/find/code.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)code.c     4.2     (Berkeley)      7/21/83";
        !             3: #endif not lint
        !             4: 
        !             5: /*
        !             6:  * PURPOSE:    sorted list compressor (works with a modified 'find'
        !             7:  *             to encode/decode a filename database)
        !             8:  *
        !             9:  * USAGE:      bigram < list > bigrams
        !            10:  *             process bigrams (see updatedb) > common_bigrams
        !            11:  *             code common_bigrams < list > squozen_list
        !            12:  *
        !            13:  * METHOD:     Uses 'front compression' (see ";login:", March 1983, p. 8 ).
        !            14:  *             Output format is, per line, an offset differential count byte
        !            15:  *             followed by a partially bigram-encoded ascii residue. 
        !            16:  *
        !            17:  *     The codes are:
        !            18:  *
        !            19:  *     0-28    likeliest differential counts + offset to make nonnegative 
        !            20:  *     30      escape code for out-of-range count to follow in next word
        !            21:  *     128-255 bigram codes, (128 most common, as determined by 'updatedb')
        !            22:  *     32-127  single character (printable) ascii residue
        !            23:  *
        !            24:  * SEE ALSO:   updatedb.csh, bigram.c, find.c
        !            25:  * 
        !            26:  * AUTHOR:     James A. Woods, Informatics General Corp.,
        !            27:  *             NASA Ames Research Center, 10/82
        !            28:  */
        !            29: 
        !            30: #include <stdio.h>
        !            31: 
        !            32: #define MAXPATH 1024           /* maximum pathname length */
        !            33: #define        RESET   30              /* switch code */
        !            34: 
        !            35: char path[MAXPATH];
        !            36: char oldpath[MAXPATH] = " ";   
        !            37: char bigrams[257] = { 0 };
        !            38: 
        !            39: main ( argc, argv )
        !            40:        int argc; char *argv[];
        !            41: {
        !            42:        int count, oldcount, diffcount;
        !            43:        int j, code;
        !            44:        char bigram[3];
        !            45:        FILE *fp;
        !            46: 
        !            47:        oldcount = 0;
        !            48:        bigram[2] = NULL;
        !            49: 
        !            50:        if ((fp = fopen(argv[1], "r")) == NULL) {
        !            51:                printf("Usage: code common_bigrams < list > coded_list\n");
        !            52:                exit(1);
        !            53:        }
        !            54:        fgets ( bigrams, 257, fp );
        !            55:        fwrite ( bigrams, 1, 256, stdout );
        !            56: 
        !            57:        while ( gets ( path ) != NULL ) {
        !            58:                /*
        !            59:                   squelch unprintable chars so as not to botch decoding
        !            60:                */
        !            61:                for ( j = 0; path[j] != NULL; j++ ) {   
        !            62:                        path[j] &= 0177;                
        !            63:                        if ( path[j] < 040 || path[j] == 0177 )
        !            64:                                path[j] = '?';
        !            65:                }
        !            66:                count = prefix_length ( oldpath, path );
        !            67:                diffcount = count - oldcount;
        !            68:                if ( (diffcount < -14) || (diffcount > 14) ) {
        !            69:                        putc ( RESET, stdout );
        !            70:                        putw ( diffcount + 14, stdout );
        !            71:                }
        !            72:                else
        !            73:                        putc ( diffcount + 14, stdout );        
        !            74: 
        !            75:                for ( j = count; path[j] != NULL; j += 2 ) {
        !            76:                        if ( path[j + 1] == NULL ) {
        !            77:                                putchar ( path[j] );
        !            78:                                break;
        !            79:                        }
        !            80:                        bigram[0] = path[j];
        !            81:                        bigram[1] = path[j + 1];
        !            82:                        /*
        !            83:                            linear search for specific bigram in string table
        !            84:                        */
        !            85:                        if ( (code = strindex ( bigrams, bigram )) % 2 == 0 )
        !            86:                                putchar ( (code / 2) | 0200 );  
        !            87:                        else            
        !            88:                                fputs ( bigram, stdout );
        !            89:                }
        !            90:                strcpy ( oldpath, path );       
        !            91:                oldcount = count;
        !            92:        }
        !            93: }
        !            94: 
        !            95: strindex ( string, pattern )   /* return location of pattern in string or -1 */
        !            96:        char *string, *pattern;
        !            97: {
        !            98:        register char *s, *p, *q;
        !            99: 
        !           100:        for ( s = string; *s != NULL; s++ ) 
        !           101:                if ( *s == *pattern ) {         /* fast first char check */
        !           102:                        for ( p = pattern + 1, q = s + 1; *p != NULL; p++, q++ )
        !           103:                                if ( *q != *p )
        !           104:                                        break;
        !           105:                        if ( *p == NULL )       
        !           106:                                return ( q - strlen ( pattern ) - string );
        !           107:                }
        !           108:        return ( -1 );
        !           109: }
        !           110: 
        !           111: prefix_length ( s1, s2 )       /* return length of longest common prefix */
        !           112:        char *s1, *s2;          /* ... of strings s1 and s2 */
        !           113: {
        !           114:        register char *start;
        !           115: 
        !           116:        for ( start = s1; *s1 == *s2; s1++, s2++ )      
        !           117:                if ( *s1 == NULL )              
        !           118:                        break;
        !           119:        return ( s1 - start );
        !           120: }

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