[BACK]Return to rcsdiff.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / rcs

Diff for /src/usr.bin/rcs/rcsdiff.c between version 1.68 and 1.69

version 1.68, 2006/07/31 06:51:55 version 1.69, 2006/09/21 15:30:07
Line 29 
Line 29 
 #include "rcsprog.h"  #include "rcsprog.h"
 #include "diff.h"  #include "diff.h"
   
 static int rcsdiff_file(RCSFILE *, RCSNUM *, const char *);  static int rcsdiff_file(RCSFILE *, RCSNUM *, const char *, int);
 static int rcsdiff_rev(RCSFILE *, RCSNUM *, RCSNUM *);  static int rcsdiff_rev(RCSFILE *, RCSNUM *, RCSNUM *, int);
   static void push_ignore_pats(char *);
   
 static int flags = 0;  static int quiet;
 static int kflag = RCS_KWEXP_ERR;  static int kflag = RCS_KWEXP_ERR;
   static char *diff_ignore_pats;
   
 int  int
 rcsdiff_main(int argc, char **argv)  rcsdiff_main(int argc, char **argv)
 {  {
         int fd, i, ch, status;          int fd, i, ch, dflags, status;
         RCSNUM *rev1, *rev2;          RCSNUM *rev1, *rev2;
         RCSFILE *file;          RCSFILE *file;
         char fpath[MAXPATHLEN], *rev_str1, *rev_str2;          char fpath[MAXPATHLEN], *rev_str1, *rev_str2;
           const char *errstr;
   
         rev1 = rev2 = NULL;          rev1 = rev2 = NULL;
         rev_str1 = rev_str2 = NULL;          rev_str1 = rev_str2 = NULL;
         status = D_SAME;          status = D_SAME;
           dflags = 0;
   
         if (strlcpy(diffargs, "diff", sizeof(diffargs)) >= sizeof(diffargs))          if (strlcpy(diffargs, "diff", sizeof(diffargs)) >= sizeof(diffargs))
                 errx(D_ERROR, "diffargs too long");                  errx(D_ERROR, "diffargs too long");
   
         while ((ch = rcs_getopt(argc, argv, "ck:nqr:TuVx::z::")) != -1) {          while ((ch = rcs_getopt(argc, argv, "abC:cdI:ik:npqr:TtU:uVwx::z::")) != -1) {
                 switch (ch) {                  switch (ch) {
                   case 'a':
                           if (strlcat(diffargs, " -a", sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           dflags |= D_FORCEASCII;
                           break;
                   case 'b':
                           if (strlcat(diffargs, " -b", sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           dflags |= D_FOLDBLANKS;
                           break;
                   case 'C':
                           (void)strlcat(diffargs, " -C", sizeof(diffargs));
                           if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           diff_context = strtonum(rcs_optarg, 0, INT_MAX, &errstr);
                           if (errstr)
                                   errx(D_ERROR, "context is %s: %s",
                                       errstr, rcs_optarg);
                           diff_format = D_CONTEXT;
                           break;
                 case 'c':                  case 'c':
                         if (strlcat(diffargs, " -c", sizeof(diffargs)) >=                          if (strlcat(diffargs, " -c", sizeof(diffargs)) >=
                             sizeof(diffargs))                              sizeof(diffargs))
                                 errx(D_ERROR, "diffargs too long");                                  errx(D_ERROR, "diffargs too long");
                         diff_format = D_CONTEXT;                          diff_format = D_CONTEXT;
                         break;                          break;
                   case 'd':
                           if (strlcat(diffargs, " -d", sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           dflags |= D_MINIMAL;
                           break;
                   case 'i':
                           if (strlcat(diffargs, " -i", sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           dflags |= D_IGNORECASE;
                           break;
                   case 'I':
                           (void)strlcat(diffargs, " -I", sizeof(diffargs));
                           if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           push_ignore_pats(rcs_optarg);
                           break;
                 case 'k':                  case 'k':
                         kflag = rcs_kflag_get(rcs_optarg);                          kflag = rcs_kflag_get(rcs_optarg);
                         if (RCS_KWEXP_INVAL(kflag)) {                          if (RCS_KWEXP_INVAL(kflag)) {
Line 72 
Line 118 
                                 errx(D_ERROR, "diffargs too long");                                  errx(D_ERROR, "diffargs too long");
                         diff_format = D_RCSDIFF;                          diff_format = D_RCSDIFF;
                         break;                          break;
                   case 'p':
                           if (strlcat(diffargs, " -p", sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           dflags |= D_PROTOTYPE;
                           break;
                 case 'q':                  case 'q':
                         flags |= QUIET;                          quiet = 1;
                         break;                          break;
                 case 'r':                  case 'r':
                         rcs_setrevstr2(&rev_str1, &rev_str2, rcs_optarg);                          rcs_setrevstr2(&rev_str1, &rev_str2, rcs_optarg);
Line 83 
Line 135 
                          * kept for compatibility                           * kept for compatibility
                          */                           */
                         break;                          break;
                   case 't':
                           if (strlcat(diffargs, " -t", sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           dflags |= D_EXPANDTABS;
                           break;
                   case 'U':
                           (void)strlcat(diffargs, " -U", sizeof(diffargs));
                           if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           diff_context = strtonum(rcs_optarg, 0, INT_MAX, &errstr);
                           if (errstr)
                                   errx(D_ERROR, "context is %s: %s",
                                       errstr, rcs_optarg);
                           diff_format = D_UNIFIED;
                           break;
                 case 'u':                  case 'u':
                         if (strlcat(diffargs, " -u", sizeof(diffargs)) >=                          if (strlcat(diffargs, " -u", sizeof(diffargs)) >=
                             sizeof(diffargs))                              sizeof(diffargs))
Line 92 
Line 161 
                 case 'V':                  case 'V':
                         printf("%s\n", rcs_version);                          printf("%s\n", rcs_version);
                         exit(0);                          exit(0);
                   case 'w':
                           if (strlcat(diffargs, " -w", sizeof(diffargs)) >=
                               sizeof(diffargs))
                                   errx(D_ERROR, "diffargs too long");
                           dflags |= D_IGNOREBLANKS;
                           break;
                 case 'x':                  case 'x':
                         /* Use blank extension if none given. */                          /* Use blank extension if none given. */
                         rcs_suffixes = rcs_optarg ? rcs_optarg : "";                          rcs_suffixes = rcs_optarg ? rcs_optarg : "";
Line 114 
Line 189 
                 exit(D_ERROR);                  exit(D_ERROR);
         }          }
   
           if (diff_ignore_pats != NULL) {
                   char buf[BUFSIZ];
                   int error;
   
                   diff_ignore_re = xmalloc(sizeof(*diff_ignore_re));
                   if ((error = regcomp(diff_ignore_re, diff_ignore_pats,
                       REG_NEWLINE | REG_EXTENDED)) != 0) {
                           regerror(error, diff_ignore_re, buf, sizeof(buf));
                           if (*diff_ignore_pats != '\0')
                                   errx(D_ERROR, "%s: %s", diff_ignore_pats, buf);
                           else
                                   errx(D_ERROR, "%s", buf);
                   }
           }
   
         for (i = 0; i < argc; i++) {          for (i = 0; i < argc; i++) {
                 fd = rcs_choosefile(argv[i], fpath, sizeof(fpath));                  fd = rcs_choosefile(argv[i], fpath, sizeof(fpath));
                 if (fd < 0) {                  if (fd < 0) {
Line 136 
Line 226 
                                 errx(D_ERROR, "bad revision number");                                  errx(D_ERROR, "bad revision number");
                 }                  }
   
                 if (!(flags & QUIET)) {                  if (!quiet) {
                         fprintf(stderr, "%s\n", RCS_DIFF_DIV);                          fprintf(stderr, "%s\n", RCS_DIFF_DIV);
                         fprintf(stderr, "RCS file: %s\n", fpath);                          fprintf(stderr, "RCS file: %s\n", fpath);
                 }                  }
Line 145 
Line 235 
   
                 /* No revisions given. */                  /* No revisions given. */
                 if (rev_str1 == NULL)                  if (rev_str1 == NULL)
                         status = rcsdiff_file(file, file->rf_head, argv[i]);                          status = rcsdiff_file(file, file->rf_head, argv[i],
                               dflags);
                 /* One revision given. */                  /* One revision given. */
                 else if (rev_str2 == NULL)                  else if (rev_str2 == NULL)
                         status = rcsdiff_file(file, rev1, argv[i]);                          status = rcsdiff_file(file, rev1, argv[i], dflags);
                 /* Two revisions given. */                  /* Two revisions given. */
                 else                  else
                         status = rcsdiff_rev(file, rev1, rev2);                          status = rcsdiff_rev(file, rev1, rev2, dflags);
   
                 rcs_close(file);                  rcs_close(file);
   
Line 177 
Line 268 
 }  }
   
 static int  static int
 rcsdiff_file(RCSFILE *file, RCSNUM *rev, const char *filename)  rcsdiff_file(RCSFILE *file, RCSNUM *rev, const char *filename, int dflags)
 {  {
         int ret, fd;          int ret, fd;
         time_t t;          time_t t;
Line 204 
Line 295 
         }          }
   
         rcsnum_tostr(rev, rbuf, sizeof(rbuf));          rcsnum_tostr(rev, rbuf, sizeof(rbuf));
         if (!(flags & QUIET)) {          if (!quiet) {
                 fprintf(stderr, "retrieving revision %s\n", rbuf);                  fprintf(stderr, "retrieving revision %s\n", rbuf);
                 fprintf(stderr, "%s -r%s %s\n", diffargs, rbuf, filename);                  fprintf(stderr, "%s -r%s %s\n", diffargs, rbuf, filename);
         }          }
Line 251 
Line 342 
         if (utimes(path2, (const struct timeval *)&tv2) < 0)          if (utimes(path2, (const struct timeval *)&tv2) < 0)
                 warn("utimes");                  warn("utimes");
   
         ret = rcs_diffreg(path1, path2, NULL);          ret = rcs_diffreg(path1, path2, NULL, dflags);
   
 out:  out:
         if (fd != -1)          if (fd != -1)
Line 269 
Line 360 
 }  }
   
 static int  static int
 rcsdiff_rev(RCSFILE *file, RCSNUM *rev1, RCSNUM *rev2)  rcsdiff_rev(RCSFILE *file, RCSNUM *rev1, RCSNUM *rev2, int dflags)
 {  {
         struct timeval tv[2], tv2[2];          struct timeval tv[2], tv2[2];
         BUF *b1, *b2;          BUF *b1, *b2;
Line 286 
Line 377 
         path1 = path2 = NULL;          path1 = path2 = NULL;
   
         rcsnum_tostr(rev1, rbuf1, sizeof(rbuf1));          rcsnum_tostr(rev1, rbuf1, sizeof(rbuf1));
         if (!(flags & QUIET))          if (!quiet)
                 fprintf(stderr, "retrieving revision %s\n", rbuf1);                  fprintf(stderr, "retrieving revision %s\n", rbuf1);
   
         if ((b1 = rcs_getrev(file, rev1)) == NULL) {          if ((b1 = rcs_getrev(file, rev1)) == NULL) {
Line 299 
Line 390 
         tv[1].tv_sec = tv[0].tv_sec;          tv[1].tv_sec = tv[0].tv_sec;
   
         rcsnum_tostr(rev2, rbuf2, sizeof(rbuf2));          rcsnum_tostr(rev2, rbuf2, sizeof(rbuf2));
         if (!(flags & QUIET))          if (!quiet)
                 fprintf(stderr, "retrieving revision %s\n", rbuf2);                  fprintf(stderr, "retrieving revision %s\n", rbuf2);
   
         if ((b2 = rcs_getrev(file, rev2)) == NULL) {          if ((b2 = rcs_getrev(file, rev2)) == NULL) {
Line 311 
Line 402 
         tv2[0].tv_sec = (long)rcs_rev_getdate(file, rev2);          tv2[0].tv_sec = (long)rcs_rev_getdate(file, rev2);
         tv2[1].tv_sec = tv2[0].tv_sec;          tv2[1].tv_sec = tv2[0].tv_sec;
   
         if (!(flags & QUIET))          if (!quiet)
                 fprintf(stderr, "%s -r%s -r%s\n", diffargs, rbuf1, rbuf2);                  fprintf(stderr, "%s -r%s -r%s\n", diffargs, rbuf1, rbuf2);
   
         (void)xasprintf(&path1, "%s/diff1.XXXXXXXXXX", rcs_tmpdir);          (void)xasprintf(&path1, "%s/diff1.XXXXXXXXXX", rcs_tmpdir);
Line 332 
Line 423 
         if (utimes(path2, (const struct timeval *)&tv2) < 0)          if (utimes(path2, (const struct timeval *)&tv2) < 0)
                 warn("utimes");                  warn("utimes");
   
         ret = rcs_diffreg(path1, path2, NULL);          ret = rcs_diffreg(path1, path2, NULL, dflags);
   
 out:  out:
         if (b1 != NULL)          if (b1 != NULL)
Line 345 
Line 436 
                 xfree(path2);                  xfree(path2);
   
         return (ret);          return (ret);
   }
   
   static void
   push_ignore_pats(char *pattern)
   {
           size_t len;
   
           if (diff_ignore_pats == NULL) {
                   len = strlen(pattern) + 1;
                   diff_ignore_pats = xmalloc(len);
                   strlcpy(diff_ignore_pats, pattern, len);
           } else {
                   /* old + "|" + new + NUL */
                   len = strlen(diff_ignore_pats) + strlen(pattern) + 2;
                   diff_ignore_pats = xrealloc(diff_ignore_pats, len, 1);
                   strlcat(diff_ignore_pats, "|", len);
                   strlcat(diff_ignore_pats, pattern, len);
           }
 }  }
Legend:
Removed from v.1.68  
changed lines
  Added in v.1.69