Return to alpha.seek.c CVS log

Up to [Research Unix] / researchv10no / cmd / prefer / pref

Annotation of researchv10no/cmd/prefer/pref/alpha.seek.c, revision 1.1.1.1

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

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