1 /* 2 * Copyright (C) 1986-2005 The Free Software Foundation, Inc. 3 * 4 * Portions Copyright (C) 1998-2005 Derek Price, Ximbiot <http://ximbiot.com>, 5 * and others. 6 * 7 * Portions Copyright (C) 1992, Brian Berliner and Jeff Polk 8 * Portions Copyright (C) 1989-1992, Brian Berliner 9 * 10 * You may distribute under the terms of the GNU General Public License as 11 * specified in the README file that comes with the CVS source distribution. 12 * 13 * Print Log Information 14 * 15 * Prints the RCS "log" (rlog) information for the specified files. With no 16 * argument, prints the log information for all the files in the directory 17 * (recursive by default). 18 */ 19 20 #include "cvs.h" 21 #include <assert.h> 22 23 /* This structure holds information parsed from the -r option. */ 24 25 struct option_revlist 26 { 27 /* The next -r option. */ 28 struct option_revlist *next; 29 /* The first revision to print. This is NULL if the range is 30 :rev, or if no revision is given. */ 31 char *first; 32 /* The last revision to print. This is NULL if the range is rev:, 33 or if no revision is given. If there is no colon, first and 34 last are the same. */ 35 char *last; 36 /* Nonzero if there was a trailing `.', which means to print only 37 the head revision of a branch. */ 38 int branchhead; 39 /* Nonzero if first and last are inclusive. */ 40 int inclusive; 41 }; 42 43 /* This structure holds information derived from option_revlist given 44 a particular RCS file. */ 45 46 struct revlist 47 { 48 /* The next pair. */ 49 struct revlist *next; 50 /* The first numeric revision to print. */ 51 char *first; 52 /* The last numeric revision to print. */ 53 char *last; 54 /* The number of fields in these revisions (one more than 55 numdots). */ 56 int fields; 57 /* Whether first & last are to be included or excluded. */ 58 int inclusive; 59 }; 60 61 /* This structure holds information parsed from the -d option. */ 62 63 struct datelist 64 { 65 /* The next date. */ 66 struct datelist *next; 67 /* The starting date. */ 68 char *start; 69 /* The ending date. */ 70 char *end; 71 /* Nonzero if the range is inclusive rather than exclusive. */ 72 int inclusive; 73 }; 74 75 /* This structure is used to pass information through start_recursion. */ 76 struct log_data 77 { 78 /* Nonzero if the -R option was given, meaning that only the name 79 of the RCS file should be printed. */ 80 int nameonly; 81 /* Nonzero if the -h option was given, meaning that only header 82 information should be printed. */ 83 int header; 84 /* Nonzero if the -t option was given, meaning that only the 85 header and the descriptive text should be printed. */ 86 int long_header; 87 /* Nonzero if the -N option was seen, meaning that tag information 88 should not be printed. */ 89 int notags; 90 /* Nonzero if the -b option was seen, meaning that only revisions 91 on the default branch should be printed. */ 92 int default_branch; 93 /* Nonzero if the -S option was seen, meaning that the header/name 94 should be suppressed if no revisions are selected. */ 95 int sup_header; 96 /* If not NULL, the value given for the -r option, which lists 97 sets of revisions to be printed. */ 98 struct option_revlist *revlist; 99 /* If not NULL, the date pairs given for the -d option, which 100 select date ranges to print. */ 101 struct datelist *datelist; 102 /* If not NULL, the single dates given for the -d option, which 103 select specific revisions to print based on a date. */ 104 struct datelist *singledatelist; 105 /* If not NULL, the list of states given for the -s option, which 106 only prints revisions of given states. */ 107 List *statelist; 108 /* If not NULL, the list of login names given for the -w option, 109 which only prints revisions checked in by given users. */ 110 List *authorlist; 111 }; 112 113 /* This structure is used to pass information through walklist. */ 114 struct log_data_and_rcs 115 { 116 struct log_data *log_data; 117 struct revlist *revlist; 118 RCSNode *rcs; 119 }; 120 121 static int rlog_proc (int argc, char **argv, char *xwhere, 122 char *mwhere, char *mfile, int shorten, 123 int local_specified, char *mname, char *msg); 124 static Dtype log_dirproc (void *callerdat, const char *dir, 125 const char *repository, const char *update_dir, 126 List *entries); 127 static int log_fileproc (void *callerdat, struct file_info *finfo); 128 static struct option_revlist *log_parse_revlist (const char *); 129 static void log_parse_date (struct log_data *, const char *); 130 static void log_parse_list (List **, const char *); 131 static struct revlist *log_expand_revlist (RCSNode *, char *, 132 struct option_revlist *, int); 133 static void log_free_revlist (struct revlist *); 134 static int log_version_requested (struct log_data *, struct revlist *, 135 RCSNode *, RCSVers *); 136 static int log_symbol (Node *, void *); 137 static int log_count (Node *, void *); 138 static int log_fix_singledate (Node *, void *); 139 static int log_count_print (Node *, void *); 140 static void log_tree (struct log_data *, struct revlist *, 141 RCSNode *, const char *); 142 static void log_abranch (struct log_data *, struct revlist *, 143 RCSNode *, const char *); 144 static void log_version (struct log_data *, struct revlist *, 145 RCSNode *, RCSVers *, int); 146 static int log_branch (Node *, void *); 147 static int version_compare (const char *, const char *, int); 148 149 static struct log_data log_data; 150 static int is_rlog; 151 152 static const char *const log_usage[] = 153 { 154 "Usage: %s %s [-lRhtNb] [-r[revisions]] [-d dates] [-s states]\n", 155 " [-w[logins]] [files...]\n", 156 "\t-l\tLocal directory only, no recursion.\n", 157 "\t-b\tOnly list revisions on the default branch.\n", 158 "\t-h\tOnly print header.\n", 159 "\t-R\tOnly print name of RCS file.\n", 160 "\t-t\tOnly print header and descriptive text.\n", 161 "\t-N\tDo not list tags.\n", 162 "\t-S\tDo not print name/header if no revisions selected. -d, -r,\n", 163 "\t\t-s, & -w have little effect in conjunction with -b, -h, -R, and\n", 164 "\t\t-t without this option.\n", 165 "\t-r[revisions]\tA comma-separated list of revisions to print:\n", 166 "\t rev1:rev2 Between rev1 and rev2, including rev1 and rev2.\n", 167 "\t rev1::rev2 Between rev1 and rev2, excluding rev1.\n", 168 "\t rev: rev and following revisions on the same branch.\n", 169 "\t rev:: After rev on the same branch.\n", 170 "\t :rev rev and previous revisions on the same branch.\n", 171 "\t ::rev rev and previous revisions on the same branch.\n", 172 "\t rev Just rev.\n", 173 "\t branch All revisions on the branch.\n", 174 "\t branch. The last revision on the branch.\n", 175 "\t-d dates\tA semicolon-separated list of dates\n", 176 "\t \t(D1<D2 for range, D for latest before).\n", 177 "\t-s states\tOnly list revisions with specified states.\n", 178 "\t-w[logins]\tOnly list revisions checked in by specified logins.\n", 179 "(Specify the --help global option for a list of other help options)\n", 180 NULL 181 }; 182 183 #ifdef CLIENT_SUPPORT 184 185 186 187 /* Helper function for send_arg_list. */ 188 static int 189 send_one (Node *node, void *closure) 190 { 191 char *option = closure; 192 193 send_to_server ("Argument ", 0); 194 send_to_server (option, 0); 195 if (strcmp (node->key, "@@MYSELF") == 0) 196 /* It is a bare -w option. Note that we must send it as 197 -w rather than messing with getcaller() or something (which on 198 the client will return garbage). */ 199 ; 200 else 201 send_to_server (node->key, 0); 202 send_to_server ("\012", 0); 203 return 0; 204 } 205 206 207 208 /* For each element in ARG, send an argument consisting of OPTION 209 concatenated with that element. */ 210 static void 211 send_arg_list (char *option, List *arg) 212 { 213 if (arg == NULL) 214 return; 215 walklist (arg, send_one, option); 216 } 217 218 #endif 219 220 221 222 int 223 cvslog (int argc, char **argv) 224 { 225 int c; 226 int err = 0; 227 int local = 0; 228 struct option_revlist **prl; 229 230 is_rlog = (strcmp (cvs_cmd_name, "rlog") == 0); 231 232 if (argc == -1) 233 usage (log_usage); 234 235 memset (&log_data, 0, sizeof log_data); 236 prl = &log_data.revlist; 237 238 getoptreset (); 239 while ((c = getopt (argc, argv, "+bd:hlNSRr::s:tw::")) != -1) 240 { 241 switch (c) 242 { 243 case 'b': 244 log_data.default_branch = 1; 245 break; 246 case 'd': 247 log_parse_date (&log_data, optarg); 248 break; 249 case 'h': 250 log_data.header = 1; 251 break; 252 case 'l': 253 local = 1; 254 break; 255 case 'N': 256 log_data.notags = 1; 257 break; 258 case 'S': 259 log_data.sup_header = 1; 260 break; 261 case 'R': 262 log_data.nameonly = 1; 263 break; 264 case 'r': 265 *prl = log_parse_revlist (optarg); 266 prl = &(*prl)->next; 267 break; 268 case 's': 269 log_parse_list (&log_data.statelist, optarg); 270 break; 271 case 't': 272 log_data.long_header = 1; 273 break; 274 case 'w': 275 if (optarg != NULL) 276 log_parse_list (&log_data.authorlist, optarg); 277 else 278 log_parse_list (&log_data.authorlist, "@@MYSELF"); 279 break; 280 case '?': 281 default: 282 usage (log_usage); 283 break; 284 } 285 } 286 argc -= optind; 287 argv += optind; 288 289 wrap_setup (); 290 291 #ifdef CLIENT_SUPPORT 292 if (current_parsed_root->isremote) 293 { 294 struct datelist *p; 295 struct option_revlist *rp; 296 char datetmp[MAXDATELEN]; 297 298 /* We're the local client. Fire up the remote server. */ 299 start_server (); 300 301 if (is_rlog && !supported_request ("rlog")) 302 error (1, 0, "server does not support rlog"); 303 304 ign_setup (); 305 306 if (log_data.default_branch) 307 send_arg ("-b"); 308 309 while (log_data.datelist != NULL) 310 { 311 p = log_data.datelist; 312 log_data.datelist = p->next; 313 send_to_server ("Argument -d\012", 0); 314 send_to_server ("Argument ", 0); 315 date_to_internet (datetmp, p->start); 316 send_to_server (datetmp, 0); 317 if (p->inclusive) 318 send_to_server ("<=", 0); 319 else 320 send_to_server ("<", 0); 321 date_to_internet (datetmp, p->end); 322 send_to_server (datetmp, 0); 323 send_to_server ("\012", 0); 324 if (p->start) 325 free (p->start); 326 if (p->end) 327 free (p->end); 328 free (p); 329 } 330 while (log_data.singledatelist != NULL) 331 { 332 p = log_data.singledatelist; 333 log_data.singledatelist = p->next; 334 send_to_server ("Argument -d\012", 0); 335 send_to_server ("Argument ", 0); 336 date_to_internet (datetmp, p->end); 337 send_to_server (datetmp, 0); 338 send_to_server ("\012", 0); 339 if (p->end) 340 free (p->end); 341 free (p); 342 } 343 344 if (log_data.header) 345 send_arg ("-h"); 346 if (local) 347 send_arg("-l"); 348 if (log_data.notags) 349 send_arg("-N"); 350 if (log_data.sup_header) 351 send_arg("-S"); 352 if (log_data.nameonly) 353 send_arg("-R"); 354 if (log_data.long_header) 355 send_arg("-t"); 356 357 while (log_data.revlist != NULL) 358 { 359 rp = log_data.revlist; 360 log_data.revlist = rp->next; 361 send_to_server ("Argument -r", 0); 362 if (rp->branchhead) 363 { 364 if (rp->first != NULL) 365 send_to_server (rp->first, 0); 366 send_to_server (".", 1); 367 } 368 else 369 { 370 if (rp->first != NULL) 371 send_to_server (rp->first, 0); 372 send_to_server (":", 1); 373 if (!rp->inclusive) 374 send_to_server (":", 1); 375 if (rp->last != NULL) 376 send_to_server (rp->last, 0); 377 } 378 send_to_server ("\012", 0); 379 if (rp->first) 380 free (rp->first); 381 if (rp->last) 382 free (rp->last); 383 free (rp); 384 } 385 send_arg_list ("-s", log_data.statelist); 386 dellist (&log_data.statelist); 387 send_arg_list ("-w", log_data.authorlist); 388 dellist (&log_data.authorlist); 389 send_arg ("--"); 390 391 if (is_rlog) 392 { 393 int i; 394 for (i = 0; i < argc; i++) 395 send_arg (argv[i]); 396 send_to_server ("rlog\012", 0); 397 } 398 else 399 { 400 send_files (argc, argv, local, 0, SEND_NO_CONTENTS); 401 send_file_names (argc, argv, SEND_EXPAND_WILD); 402 send_to_server ("log\012", 0); 403 } 404 err = get_responses_and_close (); 405 return err; 406 } 407 #endif 408 409 /* OK, now that we know we are local/server, we can resolve @@MYSELF 410 into our user name. */ 411 if (findnode (log_data.authorlist, "@@MYSELF") != NULL) 412 log_parse_list (&log_data.authorlist, getcaller ()); 413 414 if (is_rlog) 415 { 416 DBM *db; 417 int i; 418 db = open_module (); 419 for (i = 0; i < argc; i++) 420 { 421 err += do_module (db, argv[i], MISC, "Logging", rlog_proc, 422 NULL, 0, local, 0, 0, NULL); 423 } 424 close_module (db); 425 } 426 else 427 { 428 err = rlog_proc (argc + 1, argv - 1, NULL, NULL, NULL, 0, local, NULL, 429 NULL); 430 } 431 432 while (log_data.revlist) 433 { 434 struct option_revlist *rl = log_data.revlist->next; 435 if (log_data.revlist->first) 436 free (log_data.revlist->first); 437 if (log_data.revlist->last) 438 free (log_data.revlist->last); 439 free (log_data.revlist); 440 log_data.revlist = rl; 441 } 442 while (log_data.datelist) 443 { 444 struct datelist *nd = log_data.datelist->next; 445 if (log_data.datelist->start) 446 free (log_data.datelist->start); 447 if (log_data.datelist->end) 448 free (log_data.datelist->end); 449 free (log_data.datelist); 450 log_data.datelist = nd; 451 } 452 while (log_data.singledatelist) 453 { 454 struct datelist *nd = log_data.singledatelist->next; 455 if (log_data.singledatelist->start) 456 free (log_data.singledatelist->start); 457 if (log_data.singledatelist->end) 458 free (log_data.singledatelist->end); 459 free (log_data.singledatelist); 460 log_data.singledatelist = nd; 461 } 462 dellist (&log_data.statelist); 463 dellist (&log_data.authorlist); 464 465 return err; 466 } 467 468 469 470 static int 471 rlog_proc (int argc, char **argv, char *xwhere, char *mwhere, char *mfile, 472 int shorten, int local, char *mname, char *msg) 473 { 474 /* Begin section which is identical to patch_proc--should this 475 be abstracted out somehow? */ 476 char *myargv[2]; 477 int err = 0; 478 int which; 479 char *repository = NULL; 480 char *where; 481 482 if (is_rlog) 483 { 484 repository = xmalloc (strlen (current_parsed_root->directory) 485 + strlen (argv[0]) 486 + (mfile == NULL ? 0 : strlen (mfile) + 1) + 2); 487 (void)sprintf (repository, "%s/%s", 488 current_parsed_root->directory, argv[0]); 489 where = xmalloc (strlen (argv[0]) 490 + (mfile == NULL ? 0 : strlen (mfile) + 1) 491 + 1); 492 (void)strcpy (where, argv[0]); 493 494 /* If mfile isn't null, we need to set up to do only part of theu 495 * module. 496 */ 497 if (mfile != NULL) 498 { 499 char *cp; 500 char *path; 501 502 /* If the portion of the module is a path, put the dir part on 503 * repos. 504 */ 505 if ((cp = strrchr (mfile, '/')) != NULL) 506 { 507 *cp = '\0'; 508 (void)strcat (repository, "/"); 509 (void)strcat (repository, mfile); 510 (void)strcat (where, "/"); 511 (void)strcat (where, mfile); 512 mfile = cp + 1; 513 } 514 515 /* take care of the rest */ 516 path = Xasprintf ("%s/%s", repository, mfile); 517 if (isdir (path)) 518 { 519 /* directory means repository gets the dir tacked on */ 520 (void)strcpy (repository, path); 521 (void)strcat (where, "/"); 522 (void)strcat (where, mfile); 523 } 524 else 525 { 526 myargv[0] = argv[0]; 527 myargv[1] = mfile; 528 argc = 2; 529 argv = myargv; 530 } 531 free (path); 532 } 533 534 /* cd to the starting repository */ 535 if (CVS_CHDIR (repository) < 0) 536 { 537 error (0, errno, "cannot chdir to %s", repository); 538 free (repository); 539 free (where); 540 return 1; 541 } 542 /* End section which is identical to patch_proc. */ 543 544 which = W_REPOS | W_ATTIC; 545 } 546 else 547 { 548 repository = NULL; 549 where = NULL; 550 which = W_LOCAL | W_REPOS | W_ATTIC; 551 } 552 553 err = start_recursion (log_fileproc, NULL, log_dirproc, 554 NULL, &log_data, 555 argc - 1, argv + 1, local, which, 0, CVS_LOCK_READ, 556 where, 1, repository); 557 558 if (!(which & W_LOCAL)) free (repository); 559 if (where) free (where); 560 561 return err; 562 } 563 564 565 566 /* 567 * Parse a revision list specification. 568 */ 569 static struct option_revlist * 570 log_parse_revlist (const char *argstring) 571 { 572 char *orig_copy, *copy; 573 struct option_revlist *ret, **pr; 574 575 /* Unfortunately, rlog accepts -r without an argument to mean that 576 latest revision on the default branch, so we must support that 577 for compatibility. */ 578 if (argstring == NULL) 579 argstring = ""; 580 581 ret = NULL; 582 pr = &ret; 583 584 /* Copy the argument into memory so that we can change it. We 585 don't want to change the argument because, at least as of this 586 writing, we will use it if we send the arguments to the server. */ 587 orig_copy = copy = xstrdup (argstring); 588 while (copy != NULL) 589 { 590 char *comma; 591 struct option_revlist *r; 592 593 comma = strchr (copy, ','); 594 if (comma != NULL) 595 *comma++ = '\0'; 596 597 r = xmalloc (sizeof *r); 598 r->next = NULL; 599 r->first = copy; 600 r->branchhead = 0; 601 r->last = strchr (copy, ':'); 602 if (r->last != NULL) 603 { 604 *r->last++ = '\0'; 605 r->inclusive = (*r->last != ':'); 606 if (!r->inclusive) 607 r->last++; 608 } 609 else 610 { 611 r->last = r->first; 612 r->inclusive = 1; 613 if (r->first[0] != '\0' && r->first[strlen (r->first) - 1] == '.') 614 { 615 r->branchhead = 1; 616 r->first[strlen (r->first) - 1] = '\0'; 617 } 618 } 619 620 if (*r->first == '\0') 621 r->first = NULL; 622 if (*r->last == '\0') 623 r->last = NULL; 624 625 if (r->first != NULL) 626 r->first = xstrdup (r->first); 627 if (r->last != NULL) 628 r->last = xstrdup (r->last); 629 630 *pr = r; 631 pr = &r->next; 632 633 copy = comma; 634 } 635 636 free (orig_copy); 637 return ret; 638 } 639 640 641 642 /* 643 * Parse a date specification. 644 */ 645 static void 646 log_parse_date (struct log_data *log_data, const char *argstring) 647 { 648 char *orig_copy, *copy; 649 650 /* Copy the argument into memory so that we can change it. We 651 don't want to change the argument because, at least as of this 652 writing, we will use it if we send the arguments to the server. */ 653 orig_copy = copy = xstrdup (argstring); 654 while (copy != NULL) 655 { 656 struct datelist *nd, **pd; 657 char *cpend, *cp, *ds, *de; 658 659 nd = xmalloc (sizeof *nd); 660 661 cpend = strchr (copy, ';'); 662 if (cpend != NULL) 663 *cpend++ = '\0'; 664 665 pd = &log_data->datelist; 666 nd->inclusive = 0; 667 668 if ((cp = strchr (copy, '>')) != NULL) 669 { 670 *cp++ = '\0'; 671 if (*cp == '=') 672 { 673 ++cp; 674 nd->inclusive = 1; 675 } 676 ds = cp; 677 de = copy; 678 } 679 else if ((cp = strchr (copy, '<')) != NULL) 680 { 681 *cp++ = '\0'; 682 if (*cp == '=') 683 { 684 ++cp; 685 nd->inclusive = 1; 686 } 687 ds = copy; 688 de = cp; 689 } 690 else 691 { 692 ds = NULL; 693 de = copy; 694 pd = &log_data->singledatelist; 695 } 696 697 if (ds == NULL) 698 nd->start = NULL; 699 else if (*ds != '\0') 700 nd->start = Make_Date (ds); 701 else 702 { 703 /* 1970 was the beginning of time, as far as get_date and 704 Make_Date are concerned. FIXME: That is true only if time_t 705 is a POSIX-style time and there is nothing in ANSI that 706 mandates that. It would be cleaner to set a flag saying 707 whether or not there is a start date. */ 708 nd->start = Make_Date ("1/1/1970 UTC"); 709 } 710 711 if (*de != '\0') 712 nd->end = Make_Date (de); 713 else 714 { 715 /* We want to set the end date to some time sufficiently far 716 in the future to pick up all revisions that have been 717 created since the specified date and the time `cvs log' 718 completes. FIXME: The date in question only makes sense 719 if time_t is a POSIX-style time and it is 32 bits 720 and signed. We should instead be setting a flag saying 721 whether or not there is an end date. Note that using 722 something like "next week" would break the testsuite (and, 723 perhaps less importantly, loses if the clock is set grossly 724 wrong). */ 725 nd->end = Make_Date ("2038-01-01"); 726 } 727 728 nd->next = *pd; 729 *pd = nd; 730 731 copy = cpend; 732 } 733 734 free (orig_copy); 735 } 736 737 738 739 /* 740 * Parse a comma separated list of items, and add each one to *PLIST. 741 */ 742 static void 743 log_parse_list (List **plist, const char *argstring) 744 { 745 while (1) 746 { 747 Node *p; 748 char *cp; 749 750 p = getnode (); 751 752 cp = strchr (argstring, ','); 753 if (cp == NULL) 754 p->key = xstrdup (argstring); 755 else 756 { 757 size_t len; 758 759 len = cp - argstring; 760 p->key = xmalloc (len + 1); 761 strncpy (p->key, argstring, len); 762 p->key[len] = '\0'; 763 } 764 765 if (*plist == NULL) 766 *plist = getlist (); 767 if (addnode (*plist, p) != 0) 768 freenode (p); 769 770 if (cp == NULL) 771 break; 772 773 argstring = cp + 1; 774 } 775 } 776 777 778 779 static int 780 printlock_proc (Node *lock, void *foo) 781 { 782 cvs_output ("\n\t", 2); 783 cvs_output (lock->data, 0); 784 cvs_output (": ", 2); 785 cvs_output (lock->key, 0); 786 return 0; 787 } 788 789 790 791 /* 792 * Do an rlog on a file 793 */ 794 static int 795 log_fileproc (void *callerdat, struct file_info *finfo) 796 { 797 struct log_data *log_data = callerdat; 798 Node *p; 799 char *baserev; 800 int selrev = -1; 801 RCSNode *rcsfile; 802 char buf[50]; 803 struct revlist *revlist = NULL; 804 struct log_data_and_rcs log_data_and_rcs; 805 806 rcsfile = finfo->rcs; 807 p = findnode (finfo->entries, finfo->file); 808 if (p != NULL) 809 { 810 Entnode *e = p->data; 811 baserev = e->version; 812 if (baserev[0] == '-') ++baserev; 813 } 814 else 815 baserev = NULL; 816 817 if (rcsfile == NULL) 818 { 819 /* no rcs file. What *do* we know about this file? */ 820 if (baserev != NULL) 821 { 822 if (baserev[0] == '0' && baserev[1] == '\0') 823 { 824 if (!really_quiet) 825 error (0, 0, "%s has been added, but not committed", 826 finfo->file); 827 return 0; 828 } 829 } 830 831 if (!really_quiet) 832 error (0, 0, "nothing known about %s", finfo->file); 833 834 return 1; 835 } 836 837 if (log_data->sup_header || !log_data->nameonly) 838 { 839 840 /* We will need all the information in the RCS file. */ 841 RCS_fully_parse (rcsfile); 842 843 /* Turn any symbolic revisions in the revision list into numeric 844 revisions. */ 845 revlist = log_expand_revlist (rcsfile, baserev, log_data->revlist, 846 log_data->default_branch); 847 if (log_data->sup_header 848 || (!log_data->header && !log_data->long_header)) 849 { 850 log_data_and_rcs.log_data = log_data; 851 log_data_and_rcs.revlist = revlist; 852 log_data_and_rcs.rcs = rcsfile; 853 854 /* If any single dates were specified, we need to identify the 855 revisions they select. Each one selects the single 856 revision, which is otherwise selected, of that date or 857 earlier. The log_fix_singledate routine will fill in the 858 start date for each specific revision. */ 859 if (log_data->singledatelist != NULL) 860 walklist (rcsfile->versions, log_fix_singledate, 861 &log_data_and_rcs); 862 863 selrev = walklist (rcsfile->versions, log_count_print, 864 &log_data_and_rcs); 865 if (log_data->sup_header && selrev == 0) 866 { 867 log_free_revlist (revlist); 868 return 0; 869 } 870 } 871 872 } 873 874 if (log_data->nameonly) 875 { 876 cvs_output (rcsfile->print_path, 0); 877 cvs_output ("\n", 1); 878 log_free_revlist (revlist); 879 return 0; 880 } 881 882 /* The output here is intended to be exactly compatible with the 883 output of rlog. I'm not sure whether this code should be here 884 or in rcs.c; I put it here because it is specific to the log 885 function, even though it uses information gathered by the 886 functions in rcs.c. */ 887 888 cvs_output ("\n", 1); 889 890 cvs_output ("RCS file: ", 0); 891 cvs_output (rcsfile->print_path, 0); 892 893 if (!is_rlog) 894 { 895 cvs_output ("\nWorking file: ", 0); 896 if (finfo->update_dir[0] != '\0') 897 { 898 cvs_output (finfo->update_dir, 0); 899 cvs_output ("/", 0); 900 } 901 cvs_output (finfo->file, 0); 902 } 903 904 cvs_output ("\nhead:", 0); 905 if (rcsfile->head != NULL) 906 { 907 cvs_output (" ", 1); 908 cvs_output (rcsfile->head, 0); 909 } 910 911 cvs_output ("\nbranch:", 0); 912 if (rcsfile->branch != NULL) 913 { 914 cvs_output (" ", 1); 915 cvs_output (rcsfile->branch, 0); 916 } 917 918 cvs_output ("\nlocks:", 0); 919 if (rcsfile->strict_locks) 920 cvs_output (" strict", 0); 921 walklist (RCS_getlocks (rcsfile), printlock_proc, NULL); 922 923 cvs_output ("\naccess list:", 0); 924 if (rcsfile->access != NULL) 925 { 926 const char *cp; 927 928 cp = rcsfile->access; 929 while (*cp != '\0') 930 { 931 const char *cp2; 932 933 cvs_output ("\n\t", 2); 934 cp2 = cp; 935 while (!isspace ((unsigned char)*cp2) && *cp2 != '\0') 936 ++cp2; 937 cvs_output (cp, cp2 - cp); 938 cp = cp2; 939 while (isspace ((unsigned char)*cp) && *cp != '\0') 940 ++cp; 941 } 942 } 943 944 if (!log_data->notags) 945 { 946 List *syms; 947 948 cvs_output ("\nsymbolic names:", 0); 949 syms = RCS_symbols (rcsfile); 950 walklist (syms, log_symbol, NULL); 951 } 952 953 cvs_output ("\nkeyword substitution: ", 0); 954 if (rcsfile->expand == NULL) 955 cvs_output ("kv", 2); 956 else 957 cvs_output (rcsfile->expand, 0); 958 959 cvs_output ("\ntotal revisions: ", 0); 960 sprintf (buf, "%d", walklist (rcsfile->versions, log_count, NULL)); 961 cvs_output (buf, 0); 962 963 if (selrev >= 0) 964 { 965 cvs_output (";\tselected revisions: ", 0); 966 sprintf (buf, "%d", selrev); 967 cvs_output (buf, 0); 968 } 969 970 cvs_output ("\n", 1); 971 972 if (!log_data->header || log_data->long_header) 973 { 974 cvs_output ("description:\n", 0); 975 if (rcsfile->desc != NULL) 976 cvs_output (rcsfile->desc, 0); 977 } 978 979 if (!log_data->header && ! log_data->long_header && rcsfile->head != NULL) 980 { 981 p = findnode (rcsfile->versions, rcsfile->head); 982 if (p == NULL) 983 error (1, 0, "can not find head revision in `%s'", 984 finfo->fullname); 985 while (p != NULL) 986 { 987 RCSVers *vers = p->data; 988 989 log_version (log_data, revlist, rcsfile, vers, 1); 990 if (vers->next == NULL) 991 p = NULL; 992 else 993 { 994 p = findnode (rcsfile->versions, vers->next); 995 if (p == NULL) 996 error (1, 0, "can not find next revision `%s' in `%s'", 997 vers->next, finfo->fullname); 998 } 999 } 1000 1001 log_tree (log_data, revlist, rcsfile, rcsfile->head); 1002 } 1003 1004 cvs_output("\ 1005 =============================================================================\n", 1006 0); 1007 1008 /* Free up the new revlist and restore the old one. */ 1009 log_free_revlist (revlist); 1010 1011 /* If singledatelist is not NULL, free up the start dates we added 1012 to it. */ 1013 if (log_data->singledatelist != NULL) 1014 { 1015 struct datelist *d; 1016 1017 for (d = log_data->singledatelist; d != NULL; d = d->next) 1018 { 1019 if (d->start != NULL) 1020 free (d->start); 1021 d->start = NULL; 1022 } 1023 } 1024 1025 return 0; 1026 } 1027 1028 1029 1030 /* 1031 * Fix up a revision list in order to compare it against versions. 1032 * Expand any symbolic revisions. 1033 */ 1034 static struct revlist * 1035 log_expand_revlist (RCSNode *rcs, char *baserev, 1036 struct option_revlist *revlist, int default_branch) 1037 { 1038 struct option_revlist *r; 1039 struct revlist *ret, **pr; 1040 1041 ret = NULL; 1042 pr = &ret; 1043 for (r = revlist; r != NULL; r = r->next) 1044 { 1045 struct revlist *nr; 1046 1047 nr = xmalloc (sizeof *nr); 1048 nr->inclusive = r->inclusive; 1049 1050 if (r->first == NULL && r->last == NULL) 1051 { 1052 /* If both first and last are NULL, it means that we want 1053 just the head of the default branch, which is RCS_head. */ 1054 nr->first = RCS_head (rcs); 1055 if (!nr->first) 1056 { 1057 if (!really_quiet) 1058 error (0, 0, "No head revision in archive `%s'.", 1059 rcs->path); 1060 nr->last = NULL; 1061 nr->fields = 0; 1062 } 1063 else 1064 { 1065 nr->last = xstrdup (nr->first); 1066 nr->fields = numdots (nr->first) + 1; 1067 } 1068 } 1069 else if (r->branchhead) 1070 { 1071 char *branch; 1072 1073 /* Print just the head of the branch. */ 1074 if (isdigit ((unsigned char) r->first[0])) 1075 nr->first = RCS_getbranch (rcs, r->first, 1); 1076 else 1077 { 1078 branch = RCS_whatbranch (rcs, r->first); 1079 if (branch == NULL) 1080 nr->first = NULL; 1081 else 1082 { 1083 nr->first = RCS_getbranch (rcs, branch, 1); 1084 free (branch); 1085 } 1086 } 1087 if (!nr->first) 1088 { 1089 if (!really_quiet) 1090 error (0, 0, "warning: no branch `%s' in `%s'", 1091 r->first, rcs->print_path); 1092 nr->last = NULL; 1093 nr->fields = 0; 1094 } 1095 else 1096 { 1097 nr->last = xstrdup (nr->first); 1098 nr->fields = numdots (nr->first) + 1; 1099 } 1100 } 1101 else 1102 { 1103 if (r->first == NULL || isdigit ((unsigned char) r->first[0])) 1104 nr->first = xstrdup (r->first); 1105 else 1106 { 1107 if (baserev && strcmp (r->first, TAG_BASE) == 0) 1108 nr->first = xstrdup (baserev); 1109 else if (RCS_nodeisbranch (rcs, r->first)) 1110 nr->first = RCS_whatbranch (rcs, r->first); 1111 else 1112 nr->first = RCS_gettag (rcs, r->first, 1, NULL); 1113 if (nr->first == NULL && !really_quiet) 1114 { 1115 error (0, 0, "warning: no revision `%s' in `%s'", 1116 r->first, rcs->print_path); 1117 } 1118 } 1119 1120 if (r->last == r->first || (r->last != NULL && r->first != NULL && 1121 strcmp (r->last, r->first) == 0)) 1122 nr->last = xstrdup (nr->first); 1123 else if (r->last == NULL || isdigit ((unsigned char) r->last[0])) 1124 nr->last = xstrdup (r->last); 1125 else 1126 { 1127 if (baserev && strcmp (r->last, TAG_BASE) == 0) 1128 nr->last = xstrdup (baserev); 1129 else if (RCS_nodeisbranch (rcs, r->last)) 1130 nr->last = RCS_whatbranch (rcs, r->last); 1131 else 1132 nr->last = RCS_gettag (rcs, r->last, 1, NULL); 1133 if (nr->last == NULL && !really_quiet) 1134 { 1135 error (0, 0, "warning: no revision `%s' in `%s'", 1136 r->last, rcs->print_path); 1137 } 1138 } 1139 1140 /* Process the revision numbers the same way that rlog 1141 does. This code is a bit cryptic for my tastes, but 1142 keeping the same implementation as rlog ensures a 1143 certain degree of compatibility. */ 1144 if (r->first == NULL && nr->last != NULL) 1145 { 1146 nr->fields = numdots (nr->last) + 1; 1147 if (nr->fields < 2) 1148 nr->first = xstrdup (".0"); 1149 else 1150 { 1151 char *cp; 1152 1153 nr->first = xstrdup (nr->last); 1154 cp = strrchr (nr->first, '.'); 1155 assert (cp); 1156 strcpy (cp + 1, "0"); 1157 } 1158 } 1159 else if (r->last == NULL && nr->first != NULL) 1160 { 1161 nr->fields = numdots (nr->first) + 1; 1162 nr->last = xstrdup (nr->first); 1163 if (nr->fields < 2) 1164 nr->last[0] = '\0'; 1165 else 1166 { 1167 char *cp; 1168 1169 cp = strrchr (nr->last, '.'); 1170 assert (cp); 1171 *cp = '\0'; 1172 } 1173 } 1174 else if (nr->first == NULL || nr->last == NULL) 1175 nr->fields = 0; 1176 else if (strcmp (nr->first, nr->last) == 0) 1177 nr->fields = numdots (nr->last) + 1; 1178 else 1179 { 1180 int ord; 1181 int dots1 = numdots (nr->first); 1182 int dots2 = numdots (nr->last); 1183 if (dots1 > dots2 || (dots1 == dots2 && 1184 version_compare (nr->first, nr->last, dots1 + 1) > 0)) 1185 { 1186 char *tmp = nr->first; 1187 nr->first = nr->last; 1188 nr->last = tmp; 1189 nr->fields = dots2 + 1; 1190 dots2 = dots1; 1191 dots1 = nr->fields - 1; 1192 } 1193 else 1194 nr->fields = dots1 + 1; 1195 dots1 += (nr->fields & 1); 1196 ord = version_compare (nr->first, nr->last, dots1); 1197 if (ord > 0 || (nr->fields > 2 && ord < 0)) 1198 { 1199 error (0, 0, 1200 "invalid branch or revision pair %s:%s in `%s'", 1201 r->first, r->last, rcs->print_path); 1202 free (nr->first); 1203 nr->first = NULL; 1204 free (nr->last); 1205 nr->last = NULL; 1206 nr->fields = 0; 1207 } 1208 else 1209 { 1210 if (nr->fields <= dots2 && (nr->fields & 1)) 1211 { 1212 char *p = Xasprintf ("%s.0", nr->first); 1213 free (nr->first); 1214 nr->first = p; 1215 ++nr->fields; 1216 } 1217 while (nr->fields <= dots2) 1218 { 1219 char *p; 1220 int i; 1221 1222 nr->next = NULL; 1223 *pr = nr; 1224 nr = xmalloc (sizeof *nr); 1225 nr->inclusive = 1; 1226 nr->first = xstrdup ((*pr)->last); 1227 nr->last = xstrdup ((*pr)->last); 1228 nr->fields = (*pr)->fields; 1229 p = (*pr)->last; 1230 for (i = 0; i < nr->fields; i++) 1231 p = strchr (p, '.') + 1; 1232 p[-1] = '\0'; 1233 p = strchr (nr->first + (p - (*pr)->last), '.'); 1234 if (p != NULL) 1235 { 1236 *++p = '0'; 1237 *++p = '\0'; 1238 nr->fields += 2; 1239 } 1240 else 1241 ++nr->fields; 1242 pr = &(*pr)->next; 1243 } 1244 } 1245 } 1246 } 1247 1248 nr->next = NULL; 1249 *pr = nr; 1250 pr = &nr->next; 1251 } 1252 1253 /* If the default branch was requested, add a revlist entry for 1254 it. This is how rlog handles this option. */ 1255 if (default_branch 1256 && (rcs->head != NULL || rcs->branch != NULL)) 1257 { 1258 struct revlist *nr; 1259 1260 nr = xmalloc (sizeof *nr); 1261 if (rcs->branch != NULL) 1262 nr->first = xstrdup (rcs->branch); 1263 else 1264 { 1265 char *cp; 1266 1267 nr->first = xstrdup (rcs->head); 1268 assert (nr->first); 1269 cp = strrchr (nr->first, '.'); 1270 assert (cp); 1271 *cp = '\0'; 1272 } 1273 nr->last = xstrdup (nr->first); 1274 nr->fields = numdots (nr->first) + 1; 1275 nr->inclusive = 1; 1276 1277 nr->next = NULL; 1278 *pr = nr; 1279 } 1280 1281 return ret; 1282 } 1283 1284 1285 1286 /* 1287 * Free a revlist created by log_expand_revlist. 1288 */ 1289 static void 1290 log_free_revlist (struct revlist *revlist) 1291 { 1292 struct revlist *r; 1293 1294 r = revlist; 1295 while (r != NULL) 1296 { 1297 struct revlist *next; 1298 1299 if (r->first != NULL) 1300 free (r->first); 1301 if (r->last != NULL) 1302 free (r->last); 1303 next = r->next; 1304 free (r); 1305 r = next; 1306 } 1307 } 1308 1309 1310 1311 /* 1312 * Return nonzero if a revision should be printed, based on the 1313 * options provided. 1314 */ 1315 static int 1316 log_version_requested (struct log_data *log_data, struct revlist *revlist, 1317 RCSNode *rcs, RCSVers *vnode) 1318 { 1319 /* Handle the list of states from the -s option. */ 1320 if (log_data->statelist != NULL 1321 && findnode (log_data->statelist, vnode->state) == NULL) 1322 { 1323 return 0; 1324 } 1325 1326 /* Handle the list of authors from the -w option. */ 1327 if (log_data->authorlist != NULL) 1328 { 1329 if (vnode->author != NULL 1330 && findnode (log_data->authorlist, vnode->author) == NULL) 1331 { 1332 return 0; 1333 } 1334 } 1335 1336 /* rlog considers all the -d options together when it decides 1337 whether to print a revision, so we must be compatible. */ 1338 if (log_data->datelist != NULL || log_data->singledatelist != NULL) 1339 { 1340 struct datelist *d; 1341 1342 for (d = log_data->datelist; d != NULL; d = d->next) 1343 { 1344 int cmp; 1345 1346 cmp = RCS_datecmp (vnode->date, d->start); 1347 if (cmp > 0 || (cmp == 0 && d->inclusive)) 1348 { 1349 cmp = RCS_datecmp (vnode->date, d->end); 1350 if (cmp < 0 || (cmp == 0 && d->inclusive)) 1351 break; 1352 } 1353 } 1354 1355 if (d == NULL) 1356 { 1357 /* Look through the list of specific dates. We want to 1358 select the revision with the exact date found in the 1359 start field. The commit code ensures that it is 1360 impossible to check in multiple revisions of a single 1361 file in a single second, so checking the date this way 1362 should never select more than one revision. */ 1363 for (d = log_data->singledatelist; d != NULL; d = d->next) 1364 { 1365 if (d->start != NULL 1366 && RCS_datecmp (vnode->date, d->start) == 0) 1367 { 1368 break; 1369 } 1370 } 1371 1372 if (d == NULL) 1373 return 0; 1374 } 1375 } 1376 1377 /* If the -r or -b options were used, REVLIST will be non NULL, 1378 and we print the union of the specified revisions. */ 1379 if (revlist != NULL) 1380 { 1381 char *v; 1382 int vfields; 1383 struct revlist *r; 1384 1385 /* This code is taken from rlog. */ 1386 v = vnode->version; 1387 vfields = numdots (v) + 1; 1388 for (r = revlist; r != NULL; r = r->next) 1389 { 1390 if (vfields == r->fields + (r->fields & 1) && 1391 (r->inclusive ? version_compare (v, r->first, r->fields) >= 0 : 1392 version_compare (v, r->first, r->fields) > 0) 1393 && version_compare (v, r->last, r->fields) <= 0) 1394 { 1395 return 1; 1396 } 1397 } 1398 1399 /* If we get here, then the -b and/or the -r option was used, 1400 but did not match this revision, so we reject it. */ 1401 1402 return 0; 1403 } 1404 1405 /* By default, we print all revisions. */ 1406 return 1; 1407 } 1408 1409 1410 1411 /* 1412 * Output a single symbol. This is called via walklist. 1413 */ 1414 /*ARGSUSED*/ 1415 static int 1416 log_symbol (Node *p, void *closure) 1417 { 1418 cvs_output ("\n\t", 2); 1419 cvs_output (p->key, 0); 1420 cvs_output (": ", 2); 1421 cvs_output (p->data, 0); 1422 return 0; 1423 } 1424 1425 1426 1427 /* 1428 * Count the number of entries on a list. This is called via walklist. 1429 */ 1430 /*ARGSUSED*/ 1431 static int 1432 log_count (Node *p, void *closure) 1433 { 1434 return 1; 1435 } 1436 1437 1438 1439 /* 1440 * Sort out a single date specification by narrowing down the date 1441 * until we find the specific selected revision. 1442 */ 1443 static int 1444 log_fix_singledate (Node *p, void *closure) 1445 { 1446 struct log_data_and_rcs *data = closure; 1447 Node *pv; 1448 RCSVers *vnode; 1449 struct datelist *holdsingle, *holddate; 1450 int requested; 1451 1452 pv = findnode (data->rcs->versions, p->key); 1453 if (pv == NULL) 1454 error (1, 0, "missing version `%s' in RCS file `%s'", 1455 p->key, data->rcs->print_path); 1456 vnode = pv->data; 1457 1458 /* We are only interested if this revision passes any other tests. 1459 Temporarily clear log_data->singledatelist to avoid confusing 1460 log_version_requested. We also clear log_data->datelist, 1461 because rlog considers all the -d options together. We don't 1462 want to reject a revision because it does not match a date pair 1463 if we are going to select it on the basis of the singledate. */ 1464 holdsingle = data->log_data->singledatelist; 1465 data->log_data->singledatelist = NULL; 1466 holddate = data->log_data->datelist; 1467 data->log_data->datelist = NULL; 1468 requested = log_version_requested (data->log_data, data->revlist, 1469 data->rcs, vnode); 1470 data->log_data->singledatelist = holdsingle; 1471 data->log_data->datelist = holddate; 1472 1473 if (requested) 1474 { 1475 struct datelist *d; 1476 1477 /* For each single date, if this revision is before the 1478 specified date, but is closer than the previously selected 1479 revision, select it instead. */ 1480 for (d = data->log_data->singledatelist; d != NULL; d = d->next) 1481 { 1482 if (RCS_datecmp (vnode->date, d->end) <= 0 1483 && (d->start == NULL 1484 || RCS_datecmp (vnode->date, d->start) > 0)) 1485 { 1486 if (d->start != NULL) 1487 free (d->start); 1488 d->start = xstrdup (vnode->date); 1489 } 1490 } 1491 } 1492 1493 return 0; 1494 } 1495 1496 1497 1498 /* 1499 * Count the number of revisions we are going to print. 1500 */ 1501 static int 1502 log_count_print (Node *p, void *closure) 1503 { 1504 struct log_data_and_rcs *data = closure; 1505 Node *pv; 1506 1507 pv = findnode (data->rcs->versions, p->key); 1508 if (pv == NULL) 1509 error (1, 0, "missing version `%s' in RCS file `%s'", 1510 p->key, data->rcs->print_path); 1511 if (log_version_requested (data->log_data, data->revlist, data->rcs, 1512 pv->data)) 1513 return 1; 1514 else 1515 return 0; 1516 } 1517 1518 1519 1520 /* 1521 * Print the list of changes, not including the trunk, in reverse 1522 * order for each branch. 1523 */ 1524 static void 1525 log_tree (struct log_data *log_data, struct revlist *revlist, RCSNode *rcs, 1526 const char *ver) 1527 { 1528 Node *p; 1529 RCSVers *vnode; 1530 1531 p = findnode (rcs->versions, ver); 1532 if (p == NULL) 1533 error (1, 0, "missing version `%s' in RCS file `%s'", 1534 ver, rcs->print_path); 1535 vnode = p->data; 1536 if (vnode->next != NULL) 1537 log_tree (log_data, revlist, rcs, vnode->next); 1538 if (vnode->branches != NULL) 1539 { 1540 Node *head, *branch; 1541 1542 /* We need to do the branches in reverse order. This breaks 1543 the List abstraction, but so does most of the branch 1544 manipulation in rcs.c. */ 1545 head = vnode->branches->list; 1546 for (branch = head->prev; branch != head; branch = branch->prev) 1547 { 1548 log_abranch (log_data, revlist, rcs, branch->key); 1549 log_tree (log_data, revlist, rcs, branch->key); 1550 } 1551 } 1552 } 1553 1554 1555 1556 /* 1557 * Log the changes for a branch, in reverse order. 1558 */ 1559 static void 1560 log_abranch (struct log_data *log_data, struct revlist *revlist, RCSNode *rcs, 1561 const char *ver) 1562 { 1563 Node *p; 1564 RCSVers *vnode; 1565 1566 p = findnode (rcs->versions, ver); 1567 if (p == NULL) 1568 error (1, 0, "missing version `%s' in RCS file `%s'", 1569 ver, rcs->print_path); 1570 vnode = p->data; 1571 if (vnode->next != NULL) 1572 log_abranch (log_data, revlist, rcs, vnode->next); 1573 log_version (log_data, revlist, rcs, vnode, 0); 1574 } 1575 1576 1577 1578 /* 1579 * Print the log output for a single version. 1580 */ 1581 static void 1582 log_version (struct log_data *log_data, struct revlist *revlist, RCSNode *rcs, 1583 RCSVers *ver, int trunk) 1584 { 1585 Node *p; 1586 int year, mon, mday, hour, min, sec; 1587 char buf[100]; 1588 Node *padd, *pdel; 1589 1590 if (! log_version_requested (log_data, revlist, rcs, ver)) 1591 return; 1592 1593 cvs_output ("----------------------------\nrevision ", 0); 1594 cvs_output (ver->version, 0); 1595 1596 p = findnode (RCS_getlocks (rcs), ver->version); 1597 if (p != NULL) 1598 { 1599 cvs_output ("\tlocked by: ", 0); 1600 cvs_output (p->data, 0); 1601 cvs_output (";", 1); 1602 } 1603 cvs_output ("\n", 1); 1604 1605 cvs_output_tagged ("text", "date: "); 1606 (void)sscanf (ver->date, SDATEFORM, &year, &mon, &mday, &hour, &min, 1607 &sec); 1608 if (year < 1900) 1609 year += 1900; 1610 sprintf (buf, "%04d-%02d-%02d %02d:%02d:%02d +0000", year, mon, mday, 1611 hour, min, sec); 1612 cvs_output_tagged ("date", buf); 1613 1614 cvs_output_tagged ("text", "; author: "); 1615 cvs_output_tagged ("text", ver->author); 1616 1617 cvs_output_tagged ("text", "; state: "); 1618 cvs_output_tagged ("text", ver->state); 1619 cvs_output_tagged ("text", ";"); 1620 1621 if (! trunk) 1622 { 1623 padd = findnode (ver->other, ";add"); 1624 pdel = findnode (ver->other, ";delete"); 1625 } 1626 else if (ver->next == NULL) 1627 { 1628 padd = NULL; 1629 pdel = NULL; 1630 } 1631 else 1632 { 1633 Node *nextp; 1634 RCSVers *nextver; 1635 1636 nextp = findnode (rcs->versions, ver->next); 1637 if (nextp == NULL) 1638 error (1, 0, "missing version `%s' in `%s'", ver->next, 1639 rcs->print_path); 1640 nextver = nextp->data; 1641 pdel = findnode (nextver->other, ";add"); 1642 padd = findnode (nextver->other, ";delete"); 1643 } 1644 1645 if (padd != NULL) 1646 { 1647 assert (pdel); 1648 cvs_output_tagged ("text", " lines: +"); 1649 cvs_output_tagged ("text", padd->data); 1650 cvs_output_tagged ("text", " -"); 1651 cvs_output_tagged ("text", pdel->data); 1652 cvs_output_tagged ("text", ";"); 1653 } 1654 1655 p = findnode(ver->other_delta,"commitid"); 1656 if(p && p->data) 1657 { 1658 cvs_output_tagged ("text", " commitid: "); 1659 cvs_output_tagged ("text", p->data); 1660 cvs_output_tagged ("text", ";"); 1661 } 1662 1663 cvs_output_tagged ("newline", NULL); 1664 1665 if (ver->branches != NULL) 1666 { 1667 cvs_output ("branches:", 0); 1668 walklist (ver->branches, log_branch, NULL); 1669 cvs_output ("\n", 1); 1670 } 1671 1672 p = findnode (ver->other, "log"); 1673 /* The p->date == NULL case is the normal one for an empty log 1674 message (rcs-14 in sanity.sh). I don't think the case where 1675 p->data is "" can happen (getrcskey in rcs.c checks for an 1676 empty string and set the value to NULL in that case). My guess 1677 would be the p == NULL case would mean an RCS file which was 1678 missing the "log" keyword (which is invalid according to 1679 rcsfile.5). */ 1680 if (p == NULL || p->data == NULL || *(char *)p->data == '\0') 1681 cvs_output ("*** empty log message ***\n", 0); 1682 else 1683 { 1684 /* FIXME: Technically, the log message could contain a null 1685 byte. */ 1686 cvs_output (p->data, 0); 1687 if (((char *)p->data)[strlen (p->data) - 1] != '\n') 1688 cvs_output ("\n", 1); 1689 } 1690 } 1691 1692 1693 1694 /* 1695 * Output a branch version. This is called via walklist. 1696 */ 1697 /*ARGSUSED*/ 1698 static int 1699 log_branch (Node *p, void *closure) 1700 { 1701 cvs_output (" ", 2); 1702 if ((numdots (p->key) & 1) == 0) 1703 cvs_output (p->key, 0); 1704 else 1705 { 1706 char *f, *cp; 1707 1708 f = xstrdup (p->key); 1709 cp = strrchr (f, '.'); 1710 *cp = '\0'; 1711 cvs_output (f, 0); 1712 free (f); 1713 } 1714 cvs_output (";", 1); 1715 return 0; 1716 } 1717 1718 1719 1720 /* 1721 * Print a warm fuzzy message 1722 */ 1723 /* ARGSUSED */ 1724 static Dtype 1725 log_dirproc (void *callerdat, const char *dir, const char *repository, 1726 const char *update_dir, List *entries) 1727 { 1728 if (!isdir (dir)) 1729 return R_SKIP_ALL; 1730 1731 if (!quiet) 1732 error (0, 0, "Logging %s", update_dir); 1733 return R_PROCESS; 1734 } 1735 1736 1737 1738 /* 1739 * Compare versions. This is taken from RCS compartial. 1740 */ 1741 static int 1742 version_compare (const char *v1, const char *v2, int len) 1743 { 1744 while (1) 1745 { 1746 int d1, d2, r; 1747 1748 if (*v1 == '\0') 1749 return 1; 1750 if (*v2 == '\0') 1751 return -1; 1752 1753 while (*v1 == '0') 1754 ++v1; 1755 for (d1 = 0; isdigit ((unsigned char) v1[d1]); ++d1) 1756 ; 1757 1758 while (*v2 == '0') 1759 ++v2; 1760 for (d2 = 0; isdigit ((unsigned char) v2[d2]); ++d2) 1761 ; 1762 1763 if (d1 != d2) 1764 return d1 < d2 ? -1 : 1; 1765 1766 r = memcmp (v1, v2, d1); 1767 if (r != 0) 1768 return r; 1769 1770 --len; 1771 if (len == 0) 1772 return 0; 1773 1774 v1 += d1; 1775 v2 += d1; 1776 1777 if (*v1 == '.') 1778 ++v1; 1779 if (*v2 == '.') 1780 ++v2; 1781 } 1782 } 1783