home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / CMDS / rcs4.lha / rcskeep.c < prev    next >
C/C++ Source or Header  |  1993-03-03  |  8KB  |  284 lines
  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
  284.