home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / CMDS / rcs4.lha / rcsfcmp.c < prev    next >
Text File  |  1993-03-03  |  6KB  |  201 lines
  1. /*
  2.  *                     RCS file comparison
  3.  */
  4. #ifndef lint
  5. static char rcsid[]= "$Id: rcsfcmp.c,v 4.3 87/12/18 11:40:02 narten Exp $ Purdue CS";
  6. #endif
  7. /*****************************************************************************
  8.  *                       rcsfcmp()
  9.  *                       Testprogram: define FCMPTEST
  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:    rcsfcmp.c,v $
  26.  * Revision 4.3  87/12/18  11:40:02  narten
  27.  * lint cleanups (Guy Harris)
  28.  * 
  29.  * Revision 4.2  87/10/18  10:33:06  narten
  30.  * updting version number. Changes relative to 1.1 actually relative to 
  31.  * 4.1
  32.  * 
  33.  * Revision 1.2  87/03/27  14:22:19  jenkins
  34.  * Port to suns
  35.  * 
  36.  * Revision 1.1  84/01/23  14:50:23  kcs
  37.  * Initial revision
  38.  * 
  39.  * Revision 4.1  83/05/10  16:24:04  wft
  40.  * Marker matching now uses trymatch(). Marker pattern is now
  41.  * checked precisely.
  42.  * 
  43.  * Revision 3.1  82/12/04  13:21:40  wft
  44.  * Initial revision.
  45.  *
  46.  */
  47.  
  48. /*
  49. #define FCMPTEST
  50. /* Testprogram; prints out whether two files are identical,
  51.  * except for keywords
  52.  */
  53.  
  54. #include  "rcsbase.h"
  55. extern FILE * fopen();
  56. extern enum markers trymatch(); /* check for keywords */
  57.  
  58.  
  59. rcsfcmp(xfname,uxfname,delta)
  60. char * xfname, *uxfname; struct hshentry *delta;
  61. /* Function: compares the files xfname and uxfname. Returns true
  62.  * if xfname has the same contents as uxfname, while disregarding
  63.  * keyword values. For the LOG-keyword, rcsfcmp skips the log message
  64.  * given by the parameter delta in xfname. Thus, rcsfcmp returns true
  65.  * if xfname contains the same as uxfname, with the keywords expanded.
  66.  * Implementation: character-by-character comparison until $ is found.
  67.  * If a $ is found, read in the marker keywords; if they are real keywords
  68.  * and identical, read in keyword value. If value is terminated properly,
  69.  * disregard it and optionally skip log message; otherwise, compare value.
  70.  */
  71. {
  72.     register int xc,uxc;
  73.     char xkeyword[keylength+2],   uxkeyword[keylength+2];
  74.     char xkeyval[keyvallength+1], uxkeyval[keyvallength+1];
  75.     register char * tp;
  76.     FILE * xfp, * uxfp;
  77.     int result;
  78.     enum markers match1,match2;
  79.  
  80.     if ((xfp=fopen(tp=xfname,"r"))==NULL || (uxfp=fopen(tp=uxfname,"r"))==NULL) {
  81.        faterror("Can't open %s\n", tp);
  82.        return false;
  83.     }
  84.     result=false;
  85.     xc=getc(xfp); uxc=getc(uxfp);
  86.     while( xc == uxc) { /* comparison loop */
  87.         if (xc==EOF) { /* finished; everything is the same*/
  88.             result=true;
  89.             break;
  90.         }
  91.         if ( xc!=KDELIM) {
  92.             /* get the next characters */
  93.             xc=getc(xfp); uxc=getc(uxfp);
  94.         } else {
  95.             /* try to get both keywords */
  96.             tp = xkeyword;
  97.             while( (xc=getc(xfp))!=EOF && (tp< xkeyword+keylength) && (xc!='\n')
  98.                    && (xc!=KDELIM) && (xc!=VDELIM))
  99.                 *tp++ = xc;
  100.         *tp++ = xc;  /* add closing K/VDELIM */
  101.             *tp='\0';
  102.             tp = uxkeyword;
  103.             while( (uxc=getc(uxfp))!=EOF && (tp< uxkeyword+keylength) && (uxc!='\n')
  104.                    && (uxc!=KDELIM) && (uxc!=VDELIM))
  105.                 *tp++ = uxc;
  106.         *tp++ = xc;  /* add closing K/VDELIM */
  107.             *tp='\0';
  108.             /* now we have 2 keywords, or something thal looks like it.*/
  109.         match1=trymatch(xkeyword,false);
  110.         match2=trymatch(uxkeyword,false);
  111.         if (match1 != match2) break; /* not identical */
  112. #ifdef FCMPTEST
  113.         VOID printf("found potential keywords %s and %s\n",xkeyword,uxkeyword);
  114. #endif
  115.  
  116.         if (match1 == Nomatch) {
  117.         /* not a keyword pattern, but could still be identical */
  118.         if (strcmp(xkeyword,uxkeyword)==0)
  119.              continue;
  120.         else break;
  121.         }
  122. #ifdef FCMPTEST
  123.         VOID printf("found common keyword %s\n",xkeyword);
  124. #endif
  125.         tp=xkeyval;
  126.         if (xc==VDELIM) {/* get value */
  127.         while (((xc=getc(xfp))!=KDELIM) && (xc!='\n') && (xc!=EOF) &&
  128.             (tp<xkeyval+keyvallength))
  129.             *tp++ = xc;
  130.         }
  131.         *tp = '\0';   /*xkeyval now filled with value; possibly empty*/
  132.         tp=uxkeyval;
  133.         if (uxc==VDELIM) {/* get value */
  134.         while (((uxc=getc(uxfp))!=KDELIM) && (uxc!='\n') && (uxc!=EOF) &&
  135.             (tp<uxkeyval+keyvallength))
  136.             *tp++ = uxc;
  137.         }
  138.         *tp = '\0';   /*uxkeyval now filled with value; possibly empty*/
  139.         if (xc!=uxc) break; /* not the same */
  140.         if (xc==KDELIM) {
  141.         xc=getc(xfp); uxc=getc(uxfp); /* skip closing KDELIM */
  142.         /* if the keyword is LOG, also skip the log message in xfp*/
  143.         if (match1==Log) {
  144.             /* first, compute the number of line feeds in log msg */
  145.             int lncnt, ccnt;
  146.             lncnt=2; tp=delta->log;
  147.             while(*tp) if(*tp++=='\n') lncnt++;
  148.             while(xc!=EOF) {
  149.             if (xc=='\n')
  150.                 if(--lncnt==0) break;
  151.             xc=getc(xfp);
  152.             }
  153.             /* skip last comment leader */
  154.             /* Can't just skip another line here, because there may be */
  155.             /* additional characters on the line (after the Log....$)  */
  156.             for (ccnt=strlen(Comment); ccnt>=0; lncnt--) {
  157.             xc=getc(xfp);
  158.             if(xc=='\n') break;
  159.             /* reads to the end of the comment leader or '\n',     */
  160.             /* whatever comes first. This is because some editors  */
  161.             /* strip off trailing blanks from a leader like " * ". */
  162.             }
  163.         }
  164.         } else {
  165.         /* both end in the same character, but not a KDELIM */
  166.         /* must compare string values.*/
  167. #ifdef FCMPTEST
  168.         VOID printf("non-terminated keywords %s, potentially different values\n",xkeyword);
  169. #endif
  170.         if (strcmp(xkeyval,uxkeyval)!=0) break; /*different */
  171.         xc=getc(xfp); uxc=getc(uxfp); /* skip closing char  */
  172.             }
  173.         }
  174.     }
  175.     VOID fclose(xfp); VOID fclose(uxfp);
  176.     return result;
  177. }
  178.  
  179.  
  180.  
  181. #ifdef FCMPTEST
  182. char * RCSfilename, * workfilename;
  183.  
  184. char * Comment;
  185.  
  186. main(argc, argv)
  187. int  argc; char  *argv[];
  188. /* first argument: comment leader; 2nd: log message, 3rd: expanded file,
  189.  * 4th: unexpanded file
  190.  */
  191. {       struct hshentry delta;
  192.  
  193.         cmdid="rcsfcmp";
  194.         Comment=argv[1];
  195.         delta.log=argv[2];
  196.         if (rcsfcmp(argv[3],argv[4],&delta))
  197.                 VOID printf("files are the same\n");
  198.         else    VOID printf("files are different\n");
  199. }
  200. #endif
  201.