Return to alpha.seek.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / bib / src

Annotation of 43BSDReno/contrib/bib/src/alpha.seek.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)alpha.seek.c       2.2     9/23/83";
        !             3: #endif not lint
        !             4: #
        !             5: 
        !             6: # include "stdio.h"
        !             7: # include "ctype.h"
        !             8: # include "streams.h"
        !             9: # define  nexttry           ((high+low)/2)
        !            10: 
        !            11: /*  alpha_seek(stream, word, s_size, fold)
        !            12:         seeks the first line in stream that is at least word.
        !            13:     assumes that stream is a sorted file of lines.  (last char must be \n)
        !            14:     if fold, assumes that word is lowercase and folds stream to lowercase.
        !            15:     s_size = size of stream
        !            16:     returns 1 if word = line, 0 o.w.
        !            17: */
        !            18: int alpha_seek(stream, word, s_size, fold)
        !            19: FILE *stream;
        !            20: char *word;
        !            21: long int s_size;
        !            22: int  fold;
        !            23: {   long int high, low, mid;    /*  point to beginning of a line in stream  */
        !            24:     int      ans;               /*  line(low) < word <= line(high)          */
        !            25:     char     line[maxstr];
        !            26: 
        !            27: 
        !            28:     /*  initialize low (return if first line >= word)       */
        !            29:         low= 0L;
        !            30:         pos(low); getline(stream, line);
        !            31:         if (fold) foldline(line);
        !            32:         ans= strcmp(line,word);
        !            33: 
        !            34:         if ( ans >= 0)
        !            35:         {   pos(low);   return(ans==0); }
        !            36: 
        !            37:     /*  initialize high to "line" after last line           */
        !            38:         high= s_size;
        !            39: 
        !            40:     mid= nextline(stream, nexttry );
        !            41:     while (mid < high )
        !            42:     {   getline(stream,line);
        !            43:         if (fold) foldline(line);
        !            44:         if (strcmp(line,word) < 0)    low=  mid;
        !            45:         else                          high= mid;
        !            46:         mid= nextline(stream, nexttry );
        !            47:     }
        !            48: 
        !            49:     /* linear search from low to high   */
        !            50:         low= nextline(stream,low);
        !            51:         for(;;)
        !            52:         {   if (low>=high)      break;
        !            53: 
        !            54:             getline(stream,line);
        !            55:             if (fold) foldline(line);
        !            56:             ans=strcmp(line,word);
        !            57: 
        !            58:             if (ans>=0)         break;
        !            59:             low= ftell(stream);
        !            60:         }
        !            61: 
        !            62:     pos(low);
        !            63:     if (low==high)  return(0);
        !            64:     else            return(ans==0);
        !            65: }
        !            66: 
        !            67: 
        !            68: /*  foldline(p):    change all uppercase to lowercase in string p
        !            69: */
        !            70: foldline(p)
        !            71: char *p;
        !            72: {   for (; *p!=NULL;  p++)
        !            73:     {   if (isupper(*p))    *p = tolower(*p);
        !            74:     }
        !            75: }

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