# 2.11BSD#431 - /usr/src/new/rcs/src/rcskeep.c

##### Functions

    checknum          X
    getoldkeys        X
    getprevdate       X
    main              X

##### Variables

    RCSfilename       X
    dummy             X
    prevRCS           X
    prevauthor        X
    prevdate          X
    prevlocker        X
    prevrev           X
    prevsource        X
    prevstate         X
    workfilename      X

##### Macros

    IDLENGTH          X

       1: /*
       2:  *                     RCS keyword extraction
       3:  */
       4: #ifndef lint
       5: static char rcsid[]= "$Id: rcskeep.c,v 4.4 87/12/18 11:44:21 narten Exp $ Purdue CS";
       6: #endif
       7: /*****************************************************************************
       8:  *                       main routine: getoldkeys()
       9:  *                       Testprogram: define KEEPTEST
      10:  *****************************************************************************
      11:  *
      12:  * Copyright (C) 1982 by Walter F. Tichy
      13:  *                       Purdue University
      14:  *                       Computer Science Department
      15:  *                       West Lafayette, IN 47907
      16:  *
      17:  * All rights reserved. No part of this software may be sold or distributed
      18:  * in any form or by any means without the prior written permission of the
      19:  * author.
      20:  * Report problems and direct all inquiries to Tichy@purdue (ARPA net).
      21:  */
      22:
      23:
      24:
      25: /* $Log:	rcskeep.c,v $
      26:  * Revision 4.4  87/12/18  11:44:21  narten
      27:  * more lint cleanups (Guy Harris)
      28:  *
      29:  * Revision 4.3  87/10/18  10:35:50  narten
      30:  * Updating version numbers. Changes relative to 1.1 actually relative
      31:  * to 4.1
      32:  *
      33:  * Revision 1.3  87/09/24  14:00:00  narten
      34:  * Sources now pass through lint (if you ignore printf/sprintf/fprintf
      35:  * warnings)
      36:  *
      37:  * Revision 1.2  87/03/27  14:22:29  jenkins
      38:  * Port to suns
      39:  *
      40:  * Revision 1.1  84/01/23  14:50:30  kcs
      41:  * Initial revision
      42:  *
      43:  * Revision 4.1  83/05/10  16:26:44  wft
      44:  * Added new markers Id and RCSfile; extraction added.
      45:  * Marker matching with trymatch().
      46:  *
      47:  * Revision 3.2  82/12/24  12:08:26  wft
      48:  * added missing #endif.
      49:  *
      50:  * Revision 3.1  82/12/04  13:22:41  wft
      51:  * Initial revision.
      52:  *
      53:  */
      54:
      55: /*
      56: #define KEEPTEST
      57: /* Testprogram; prints out the keyword values found. */
      58:
      59: #include  "rcsbase.h"
      60: extern char * checkid();
      61: extern FILE * fopen();
      62: static int getval();
      63: extern enum markers trymatch();
      64:
      65: FILE * fp;
      66: #define IDLENGTH 30
      67: char prevauthor[IDLENGTH];
      68: char prevdate[datelength];
      69: char prevRCS[NCPFN];
      70: char prevrev[revlength];
      71: char prevsource[NCPPN];
      72: char prevstate [IDLENGTH];
      73: char prevlocker[IDLENGTH];
      74: char dummy[IDLENGTH];
      75:
      76: getoldkeys(fname)
      77: char * fname;
      78: /* Function: Tries to read keyword values for author, date,
      79:  * revision number, RCS file, (both with and without path),
      80:  * state, and workfilename out of the file fname.
      81:  * The results are placed into
      82:  * prevauthor, prevdate, prevRCS, prevrev, prevsource, prevstate.
      83:  * Aborts immediately if it finds an error and returns false.
      84:  * If it returns true, it doesn't mean that any of the
      85:  * values were found; instead, check to see whether the corresponding arrays
      86:  * contain the empty string.
      87:  */
      88: {
      89:     register int c;
      90:     char keyword[keylength+2];
      91:     register char * tp;
      92:     enum markers mresult;
      93:
      94:     /* initialize to empty */
      95:     prevauthor[0]=prevsource[0]=prevstate[0]=prevdate[0]=prevrev[0]= '\0';
      96:
      97:     if ( (fp = fopen(fname, "r") ) == NULL ) {
      98:        error("Can't open %s\n", fname);
      99:        return false;
     100:     }
     101:     while( (c=getc(fp)) != EOF) {
     102:         if ( c==KDELIM) {
     103:             /* try to get keyword */
     104:             tp = keyword;
     105:         while( (c=getc(fp))!=EOF && (tp< keyword+keylength) && (c!='\n')
     106:            && (c!=KDELIM) && (c!=VDELIM))
     107:           *tp++ = c;
     108:
     109:             if (c==KDELIM) {VOID ungetc(c,fp);continue;}
     110:             if (c!=VDELIM) continue;
     111:         *tp++ = c;
     112:             *tp='\0';
     113:             while ((c=getc(fp))==' '||c=='\t'); /* skip blanks */
     114:             VOID ungetc(c,fp); /* needed for getval */
     115:
     116:         switch (mresult=trymatch(keyword,true)) {
     117:             case Author:
     118:                 if (getval(prevauthor,IDLENGTH,true))
     119:                     if (!checkid(prevauthor, '\0')) goto errexit;
     120:                 break;
     121:             case Date:
     122:                 if (!getprevdate(true)) goto errexit;
     123:                 break;
     124:             case Header:
     125:             case Id:
     126:         if (mresult==Header) {
     127:             if (!getval(prevsource,NCPPN,true)) break; /*unexpanded*/
     128:         } else {
     129:             if (!getval(prevRCS,NCPFN,true))    break; /*unexpanded*/
     130:         }
     131:         if (!getval(prevrev,revlength,false)) goto errexit;
     132:         if (!checknum(prevrev,-1)) {
     133:             error("Bad revision number");
     134:             goto errexit;
     135:         }
     136:         if (!getprevdate(false)) goto errexit;
     137:         if (!getval(prevauthor,IDLENGTH,false)) goto errexit;
     138:         if (!checkid(prevauthor, '\0')) goto errexit;
     139:         if (!getval(prevstate,IDLENGTH,false)) goto errexit;
     140:         if (!checkid(prevstate, '\0')) goto errexit;
     141:         VOID getval(dummy, IDLENGTH, true);    /* optional locker*/
     142:         VOID getval(prevlocker,IDLENGTH,true); /* optional locker*/
     143:                 break;
     144:             case Locker:
     145:                 VOID getval(prevlocker,IDLENGTH,true);
     146:         if (!checkid(prevlocker, '\0')) goto errexit;
     147:                 break;
     148:             case Log:
     149:         VOID getval(prevRCS,NCPPN,true);
     150:                 break;
     151:             case RCSfile:
     152:                 VOID getval(prevRCS,NCPFN,true);
     153:                 break;
     154:             case Revision:
     155:                 if (getval(prevrev,revlength,true))
     156:                     if (!checknum(prevrev,-1)) {
     157:                         error("Bad revision number");
     158:                         goto errexit;
     159:                     }
     160:                 break;
     161:             case Source:
     162:                 VOID getval(prevsource,NCPPN,true);
     163:                 break;
     164:             case State:
     165:                 if (getval(prevstate,IDLENGTH,true))
     166:                     if (!checkid(prevstate, '\0')) goto errexit;
     167:                 break;
     168:             default:
     169:                continue;
     170:             }
     171:             if (getc(fp)!=KDELIM)
     172:                 warn("Closing %c missing on keyword",KDELIM);
     173:             if (prevauthor[0]!='\0'&&prevrev[0]!='\0'&&prevstate[0]!='\0'&&
     174:                 prevdate[0]!='\0' &&
     175:          ((prevsource[0]!='\0')||(prevRCS[0]!='\0'))){
     176:                 /* done; prevlocker is irrelevant */
     177:                 break;
     178:            }
     179:         }
     180:     }
     181:     VOID fclose(fp);
     182:     return true;
     183:
     184: errexit:
     185:     prevauthor[0]=prevsource[0]=prevstate[0]=prevdate[0]=prevrev[0]= '\0';
     186:     VOID fclose(fp); return false;
     187: }
     188:
     189:
     190: static int getval(target,maxchars,optional)
     191: char * target; int maxchars, optional;
     192: /* Function: Places a keyword value into target, but not more
     193:  * than maxchars characters. Prints an error if optional==false
     194:  * and there is no keyword. Returns true if one is found, false otherwise.
     195:  */
     196: {   register char * tp;
     197:     register int c;
     198:
     199:     tp=target;
     200:     c=getc(fp);
     201:     if (c==KDELIM) {
     202:         if (!optional)
     203:             error("Missing keyword value");
     204:         VOID ungetc(c,fp);
     205:         return false;
     206:     } else {
     207:         while (!(c==' '||c=='\n'||c=='\t'||c==KDELIM||c==EOF)) {
     208:             if (tp-target>=maxchars-1) {
     209:                 error("keyword value too long");
     210:                 return false;
     211:             } else {
     212:                 *tp++ =c;
     213:                 c=getc(fp);
     214:             }
     215:         }
     216:         *tp= '\0';
     217: #       ifdef KEEPTEST
     218:         VOID printf("getval: %s\n",target);
     219: #       endif
     220:         while(c==' '||c=='\t') c=getc(fp); /* skip trailing blanks */
     221:     }
     222:     VOID ungetc(c,fp);
     223:     return true;
     224: }
     225:
     226:
     227: int getprevdate(optional)
     228: int optional;
     229: /* Function: reads a date prevdate; checks format
     230:  * If there is not date and optional==false, an error is printed.
     231:  * Returns false on error, true otherwise.
     232:  */
     233: {   char prevday[10];
     234:     char prevtime[10];
     235:
     236:     prevday[0]=prevtime[0]='\0';
     237:     if (!getval(prevday,9,optional)) return optional;
     238:     if (!getval(prevtime,9,false)) return false;
     239:     /*process date */
     240:     prevday[2]=prevday[5]=prevday[8]=prevtime[2]=prevtime[5]='.';
     241:     prevday[9]='\0';
     242:     VOID strcpy(prevdate,prevday);
     243:     VOID strcat(prevdate,prevtime);
     244:     if (!checknum(prevdate,5)) {
     245:             error("Bad date: %s",prevdate);
     246:             prevdate[0]='\0';
     247:             return false;
     248:     }
     249:     return true;
     250: }
     251:
     252: int checknum(sp,fields)
     253: register char * sp; int fields;
     254: {    register int dotcount;
     255:      if (sp==nil||*sp=='\0') return true;
     256:      dotcount=0;
     257:      while(*sp) {
     258:         if (*sp=='.') dotcount++;
     259:         elsif (ctab[*sp]!=DIGIT) return false;
     260:         sp++;
     261:      }
     262:      if (fields >= 0 && dotcount!=fields) return false;
     263:      return true;
     264: }
     265:
     266:
     267:
     268: #ifdef KEEPTEST
     269: char * RCSfilename, * workfilename;
     270:
     271: main(argc, argv)
     272: int  argc; char  *argv[];
     273: {
     274:     cmdid="keeptest";
     275:         while (*(++argv)) {
     276:                 if (getoldkeys(*argv))
     277:                 VOID printf("%s:  revision: %s, date: %s, author: %s, state: %s\n",
     278:                         *argv, prevrev, prevdate, prevauthor,prevstate);
     279:         VOID printf("Source: %s, RCSfile: %s\n",prevsource,prevRCS);
     280:     }
     281:     exit(0);
     282: }
     283: #endif

#### Defined functions

checknum defined in line 252; used 3 times

- in line 132, 156, 244

getoldkeys defined in line 76; used 2 times

- in line 276
- in /usr/src/new/rcs/src/ci.c line 366

getprevdate defined in line 227; used 2 times

- in line 122, 136

getval defined in line 190; used 17 times

- in line 62, 118, 127-131(3), 137-155(8), 162-165(2), 237-238(2)

main defined in line 271; never used

#### Defined variables

RCSfilename defined in line 269; never used
dummy defined in line 74; used 1 times

- in line 141

prevRCS defined in line 69; used 5 times

- in line 129, 149-152(2), 175, 279

prevauthor defined in line 67; used 11 times

- in line 95, 118-119(2), 137-138(2), 173, 185, 278
- in /usr/src/new/rcs/src/ci.c line 373, 399-400(2)

prevdate defined in line 68; used 12 times

- in line 95, 174, 185, 242-246(5), 278
- in /usr/src/new/rcs/src/ci.c line 371, 409-410(2)

prevlocker defined in line 73; used 3 times

- in line 142-146(3)

prevrev defined in line 70; used 9 times

- in line 95, 131-132(2), 155-156(2), 173, 185, 278
- in /usr/src/new/rcs/src/ci.c line 367

prevsource defined in line 71; used 6 times

- in line 95, 127, 162, 175, 185, 279

prevstate defined in line 72; used 11 times

- in line 95, 139-140(2), 165-166(2), 173, 185, 278
- in /usr/src/new/rcs/src/ci.c line 375, 404-405(2)

rcsid defined in line 5; never used
workfilename defined in line 269; never used

#### Defined macros

IDLENGTH defined in line 66; used 11 times

- in line 67-74(4), 118, 137-145(5), 165

Last modified: 1988-02-18 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 908 |