Return to streams.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / bib / src

Annotation of 43BSDTahoe/new/bib/src/streams.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)streams.c  2.4     3/5/87";
        !             3: #endif not lint
        !             4: #
        !             5: 
        !             6: # include "stdio.h"
        !             7: # include "streams.h"
        !             8: # include "ctype.h"
        !             9: 
        !            10: /*  getword(stream,p,ignore):
        !            11:         read next sequence of nonspaces on current line into *p.
        !            12:     null if no more words on current line.
        !            13:     %x (x in ignore) terminates line and any following non-blank lines that
        !            14:        don't begin with '%'
        !            15:     all words of the form %a are returned as null.
        !            16:     *p is a null terminated string (char p[maxstr]).
        !            17: */
        !            18: getword(stream,p,ignore)
        !            19: FILE *stream;
        !            20: char *p, *ignore;
        !            21: {   char c;
        !            22:     char *oldp, *stop;
        !            23:     long save;
        !            24: 
        !            25:     oldp= p;
        !            26:     stop= p+maxstr-1;
        !            27:     do{ c= getc(stream);
        !            28:     }   while (isspace(c) && c!='\n');
        !            29: 
        !            30:     while (!isspace(c))
        !            31:     {   *p= c;
        !            32:         if (p < stop)  p++;
        !            33:         c= getc(stream);
        !            34:     }
        !            35:     *p= NULL;
        !            36: 
        !            37:     if (oldp[0]=='%')
        !            38:     {   oldp[0]= NULL;
        !            39:         if (index(ignore, oldp[1]) != NULL)
        !            40:        {   do{ while (c!='\n') c=getc(stream);
        !            41:                 save= ftell(stream);
        !            42:                 c= getc(stream);
        !            43:            }   while (c!= EOF && !isspace(c) && c!='%');
        !            44:             pos(save);
        !            45:        }
        !            46:     }
        !            47: }
        !            48: 
        !            49: 
        !            50: 
        !            51: /*  recsize(stream,start):
        !            52:     returns length of record beginning at start
        !            53:     (record ends at blank line or eof)
        !            54:     assumes and retains stream positioned at start
        !            55: */
        !            56: long int recsize(stream,start)
        !            57: FILE *stream;
        !            58: long int start;
        !            59: {   char c;                 /*  length = # of chars from start to beginning */
        !            60:     long int length;        /*  of current line.  c in current line.        */
        !            61:     int nonspaces;          /*  nonspaces = # of nonspaces in current line. */
        !            62: 
        !            63:     nonspaces= 0;
        !            64:     c= getc(stream);
        !            65:     length= 0L;
        !            66: 
        !            67:     while ( (c!='\n' || nonspaces!=0) && c!=EOF)
        !            68:     {   if      (c=='\n')
        !            69:         {   length= ftell(stream)-start;
        !            70:             nonspaces= 0;
        !            71:         }
        !            72:         else if (!isspace(c))    nonspaces++;
        !            73: 
        !            74:         c= getc(stream);
        !            75:     }
        !            76: 
        !            77:     pos(start);
        !            78:     return(length);
        !            79: }
        !            80: 
        !            81: 
        !            82: /*  nextrecord(stream,x): seeks in stream for first non-blank line
        !            83:         at or after char x in stream. seeks to eof if x is past last record.
        !            84:         x is the index of a character in the file (not eof).
        !            85:     returns position in stream.  (returns EOF, if seeks to EOF)
        !            86: */
        !            87: long int nextrecord(stream,x)
        !            88: FILE *stream;
        !            89: long int x;
        !            90: {   long int start;         /*  position of the beginning of the line  */
        !            91:     char c;                 /*      containing c                       */
        !            92: 
        !            93:     pos(x);
        !            94:     start= x;
        !            95:     /*  find start of first non-blank record        */
        !            96:         c= getc(stream);
        !            97:         for(;;)
        !            98:         {   if      (c=='\n')          {start= ftell(stream); c= getc(stream);}
        !            99:             else if (c=='#')           while (c!='\n') c=getc(stream);
        !           100:             else if (!isspace(c))      break;
        !           101:             else                       c= getc(stream);
        !           102:         }
        !           103: 
        !           104:     if (feof(stream))   { pos(start);  start= EOF;  }
        !           105:     else                pos(start);
        !           106:     return(start);
        !           107: }
        !           108: 
        !           109: /*  nextline(stream,x): seeks in stream after first newline at or after
        !           110:         char x in stream. seeks to eof if x is in last line.
        !           111:         x is the index of a character in the file (not eof).
        !           112:     returns position in stream
        !           113: */
        !           114: long int nextline(stream,x)
        !           115: FILE *stream;
        !           116: long int x;
        !           117: {   pos(x);
        !           118:     while (getc(stream)!='\n') ;
        !           119:     return(ftell(stream));
        !           120: }
        !           121: 
        !           122: 
        !           123: /*  printline(stream): copies stream up to a newline
        !           124: */
        !           125: printline(stream)
        !           126: FILE *stream;
        !           127: {   char c;
        !           128:     while ((c=getc(stream)) != '\n' && c!=EOF)  putchar(c);
        !           129:     putchar('\n');
        !           130: }
        !           131: 
        !           132: /*  getline(stream,p):  store in *p next chars in stream up to \n
        !           133:         advance stream past \n.
        !           134:     limit of  maxstr-1 chars may be stored at p.
        !           135: */
        !           136: getline(stream,p)
        !           137: FILE *stream;
        !           138: char *p;
        !           139: {   char *stop;
        !           140:     stop= p+maxstr-1;
        !           141:     while ( (*p= getc(stream)) != '\n' && *p!=EOF)
        !           142:         if (p<stop)    p++;
        !           143:     *p= NULL;
        !           144: }
        !           145: 
        !           146: /* replace string old at the head of subj by new */
        !           147: strreplace(subj, old, new)
        !           148:        char *subj, *old, *new;
        !           149: {
        !           150:        char buf[128];
        !           151:        int lg;
        !           152:        strcpy(buf, &subj[strlen(old)]);
        !           153:        strcpy(subj, new);
        !           154:        strcat(subj, buf);
        !           155: }

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