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