Return to ident.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src

Annotation of 43BSD/contrib/rcs/src/ident.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *                     RCS identification operation
                      3:  */
                      4:  static char rcsid[] =
                      5:  "$Header: /usr/wft/RCS/SRC/RCS/ident.c,v 3.4 83/02/18 17:37:49 wft Exp $Purdue CS";
                      6: /*****************************************************************************
                      7:  *****************************************************************************
                      8:  *
                      9:  * Copyright (C) 1982 by Walter F. Tichy
                     10:  *                       Purdue University
                     11:  *                       Computer Science Department
                     12:  *                       West Lafayette, IN 47907
                     13:  *
                     14:  * All rights reserved. No part of this software may be sold or distributed
                     15:  * in any form or by any means without the prior written permission of the
                     16:  * author.
                     17:  * Report problems and direct all inquiries to Tichy@purdue (ARPA net).
                     18:  */
                     19: 
                     20: /* $Log:       ident.c,v $
                     21:  * Revision 3.4  83/02/18  17:37:49  wft
                     22:  * removed printing of new line after last file.
                     23:  * 
                     24:  * Revision 3.3  82/12/04  12:48:55  wft
                     25:  * Added LOCKER.
                     26:  *
                     27:  * Revision 3.2  82/11/28  18:24:17  wft
                     28:  * removed Suffix; added ungetc to avoid skipping over trailing KDELIM.
                     29:  *
                     30:  * Revision 3.1  82/10/13  15:58:51  wft
                     31:  * fixed type of variables receiving from getc() (char-->int).
                     32: */
                     33: 
                     34: #include  "rcsbase.h"
                     35: #define fflsbuf _flsbuf
                     36: /* redefinition of _flsbuf in putc not needed */
                     37: static char rcsbaseid[] = RCSBASE;
                     38: 
                     39: main(argc, argv)
                     40: int  argc; char  *argv[];
                     41: /*  Ident searches the named files for all occurrences
                     42:  *  of the pattern $keyword:...$, where the keywords are
                     43:  *  Author, Date, Header, Log, Revision, Source, and State.
                     44:  */
                     45: 
                     46: {
                     47:    FILE *fp, *fopen();
                     48:    register int c;
                     49:    register int matchcount;
                     50: 
                     51:    if (argc<2) {
                     52:         fprintf(stderr,  "ident error: no input file\n");
                     53:         exit(1);
                     54:    }
                     55:    while ( --argc > 0 ) {
                     56:       if ( (fp = fopen(*++argv, "r") ) == NULL ) {
                     57:          fprintf(stderr,  "ident error: can't open %s\n", *argv);
                     58:          continue;
                     59:       } else {
                     60:          matchcount = 0;
                     61:          printf( "%s:\n", *argv);   /*  print file name  */
                     62:          while( (c=getc(fp)) != EOF) {
                     63:             if ( (char)c==KDELIM)
                     64:                matchcount += match(fp);
                     65:          }
                     66:          if (matchcount == 0)
                     67:             fprintf(stderr, "ident warning: no id keywords in %s\n", *argv);
                     68:          if (argc>1) putchar('\n');
                     69:       }
                     70:       fclose(fp);
                     71:    }
                     72: }
                     73: 
                     74: match(fp)   /* group substring between two KDELIM's; then do pattern match */
                     75: FILE *fp;
                     76: 
                     77: {
                     78:    char line[keyvallength];
                     79:    register int c;
                     80:    register char * tp;
                     81: 
                     82:    tp = line;
                     83:    while( (c = getc(fp)) != KDELIM ) {
                     84:       *tp++ = c;
                     85:       if ( c==EOF || c=='\n' || tp>= line+keyvallength-2)
                     86:          return(0);
                     87:       }
                     88:    *tp++=c;     /*append trailing KDELIM*/
                     89:    *tp='\0';
                     90:    if (isprefix(line, AUTHOR))
                     91:        ;
                     92:    else if ( isprefix(line,DATE) )
                     93:        ;
                     94:    else if ( isprefix(line, HEADER) )
                     95:        ;
                     96:    else if ( isprefix(line, LOCKER) )
                     97:        ;
                     98:    else if ( isprefix(line, LOG) )
                     99:        ;
                    100:    else if (isprefix(line, REVISION) )
                    101:        ;
                    102:    else if (isprefix(line, SOURCE) )
                    103:        ;
                    104:    else if ( isprefix(line, STATE) )
                    105:        ;
                    106:    else {
                    107:       /* no match; put trailing KDELIM back into input */
                    108:       ungetc(c,fp );
                    109:       return(0);
                    110:    }
                    111:    fprintf(stdout,"     $%s\n",line);
                    112:    return(1);
                    113: }
                    114: 
                    115: 
                    116: isprefix(s,t) /*  return true if t is prefix of s; false otherwise  */
                    117: char s[], t[];
                    118: {
                    119:    int  j, k;
                    120: 
                    121:    for (j=0, k=0; t[k] != '\0' && s[j] != '\0' && s[j] == t[k]; ++j,++k)
                    122:       ;
                    123:    if ( t[k] != '\0' )
                    124:       return(false);
                    125:    if (s[j] == VDELIM)
                    126:       return(true);
                    127:    return(false);
                    128: }

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