![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rlog.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / rcs / src|
Return to rlog.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / rcs / src |
1.1 ! root 1: /* ! 2: * RLOG operation ! 3: */ ! 4: #ifndef lint ! 5: static char rcsid[]= ! 6: "$Header: /usr/src/local/bin/rcs/src/RCS/rlog.c,v 4.7 89/05/01 15:13:48 narten Exp $ Purdue CS"; ! 7: #endif ! 8: /***************************************************************************** ! 9: * print contents of RCS files ! 10: ***************************************************************************** ! 11: */ ! 12: ! 13: /* Copyright (C) 1982, 1988, 1989 Walter Tichy ! 14: * All rights reserved. ! 15: * ! 16: * Redistribution and use in source and binary forms are permitted ! 17: * provided that the above copyright notice and this paragraph are ! 18: * duplicated in all such forms and that any documentation, ! 19: * advertising materials, and other materials related to such ! 20: * distribution and use acknowledge that the software was developed ! 21: * by Walter Tichy. ! 22: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 23: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 24: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 25: * ! 26: * Report all problems and direct all questions to: ! 27: * [email protected] ! 28: * ! 29: ! 30: ! 31: ! 32: ! 33: ! 34: ! 35: ! 36: */ ! 37: ! 38: ! 39: ! 40: ! 41: /* $Log: rlog.c,v $ ! 42: * Revision 4.7 89/05/01 15:13:48 narten ! 43: * changed copyright header to reflect current distribution rules ! 44: * ! 45: * Revision 4.6 88/11/08 11:59:40 narten ! 46: * changes from [email protected] (Paul Eggert) ! 47: * ! 48: * Revision 4.6 88/08/09 19:13:28 eggert ! 49: * Check for memory exhaustion; don't access freed storage. ! 50: * Shrink stdio code size; remove lint. ! 51: * ! 52: * Revision 4.5 87/12/18 11:46:38 narten ! 53: * more lint cleanups (Guy Harris) ! 54: * ! 55: * Revision 4.4 87/10/18 10:41:12 narten ! 56: * Updating version numbers ! 57: * Changes relative to 1.1 actually relative to 4.2 ! 58: * ! 59: * Revision 1.3 87/09/24 14:01:10 narten ! 60: * Sources now pass through lint (if you ignore printf/sprintf/fprintf ! 61: * warnings) ! 62: * ! 63: * Revision 1.2 87/03/27 14:22:45 jenkins ! 64: * Port to suns ! 65: * ! 66: * Revision 1.1 84/01/23 14:50:45 kcs ! 67: * Initial revision ! 68: * ! 69: * Revision 4.2 83/12/05 09:18:09 wft ! 70: * changed rewriteflag to external. ! 71: * ! 72: * Revision 4.1 83/05/11 16:16:55 wft ! 73: * Added -b, updated getnumericrev() accordingly. ! 74: * Replaced getpwuid() with getcaller(). ! 75: * ! 76: * Revision 3.7 83/05/11 14:24:13 wft ! 77: * Added options -L and -R; ! 78: * Fixed selection bug with -l on multiple files. ! 79: * Fixed error on dates of the form -d'>date' (rewrote getdatepair()). ! 80: * ! 81: * Revision 3.6 82/12/24 15:57:53 wft ! 82: * shortened output format. ! 83: * ! 84: * Revision 3.5 82/12/08 21:45:26 wft ! 85: * removed call to checkaccesslist(); used DATEFORM to format all dates; ! 86: * removed unused variables. ! 87: * ! 88: * Revision 3.4 82/12/04 13:26:25 wft ! 89: * Replaced getdelta() with gettree(); removed updating of field lockedby. ! 90: * ! 91: * Revision 3.3 82/12/03 14:08:20 wft ! 92: * Replaced getlogin with getpwuid(), %02d with %.2d, fancydate with PRINTDATE. ! 93: * Fixed printing of nil, removed printing of Suffix, ! 94: * added shortcut if no revisions are printed, disambiguated struct members. ! 95: * ! 96: * Revision 3.2 82/10/18 21:09:06 wft ! 97: * call to curdir replaced with getfullRCSname(), ! 98: * fixed call to getlogin(), cosmetic changes on output, ! 99: * changed conflicting long identifiers. ! 100: * ! 101: * Revision 3.1 82/10/13 16:07:56 wft ! 102: * fixed type of variables receiving from getc() (char -> int). ! 103: */ ! 104: ! 105: ! 106: ! 107: #include "time.h" ! 108: #include "rcsbase.h" ! 109: #ifndef lint ! 110: static char rcsbaseid[] = RCSBASE; ! 111: #endif ! 112: ! 113: extern char * partialno(); ! 114: extern char * getcaller(); /*get login of caller */ ! 115: extern free(); ! 116: extern int countnumflds(); ! 117: extern int compartial(); ! 118: extern int expandsym(); /*get numeric name of a revision */ ! 119: extern int nextc; /*next input character */ ! 120: extern char Klog[]; ! 121: extern char Ktext[]; ! 122: extern int partime(); ! 123: extern long maketime(); /*convert parsed time to unix time. */ ! 124: extern struct tm * localtime(); /*convert unixtime into a tm-structure */ ! 125: extern int pairfilenames(); ! 126: extern struct hshentry * getnum(); ! 127: extern FILE * finptr; /* RCS input file */ ! 128: extern FILE * frewrite; /* new RCS file */ ! 129: extern int rewriteflag; /* indicates whether input should be */ ! 130: /* echoed to frewrite */ ! 131: extern int nerror; /* error counter */ ! 132: ! 133: char * RCSfilename, * workfilename; ! 134: ! 135: char * caller; /* caller's login; */ ! 136: int descflag, selectflag, selectop; /* option to print access list, symbolic */ ! 137: /* names, descriptive text, locks and */ ! 138: /* Head */ ! 139: int onlylockflag; /* option to print only files */ ! 140: /* with locks */ ! 141: int onlyRCSflag; /* option to print only RCS file name */ ! 142: int lockflag; /* whether locker option is set */ ! 143: int revno; /* number of revision chosen */ ! 144: ! 145: struct lockers { /* lockers in locker option; stored */ ! 146: char * login; /* lockerlist */ ! 147: struct lockers * lockerlink; ! 148: } ; ! 149: ! 150: struct stateattri { /* states in state option; stored in */ ! 151: char * status; /* statelist */ ! 152: struct stateattri * nextstate; ! 153: } ; ! 154: ! 155: struct authors { /* login names in author option; */ ! 156: char * login; /* stored in authorlist */ ! 157: struct authors * nextauthor; ! 158: } ; ! 159: ! 160: struct Revpairs{ /* revision or branch range in -r */ ! 161: int numfld; /* option; stored in revlist */ ! 162: char * strtrev; ! 163: char * endrev; ! 164: struct Revpairs * rnext; ! 165: } ; ! 166: ! 167: struct Datepairs{ /* date range in -d option; stored in */ ! 168: char strtdate[datelength]; /* duelst and datelist */ ! 169: char enddate[datelength]; ! 170: struct Datepairs * dnext; ! 171: }; ! 172: ! 173: char Dotstring[200]; /* string of numeric revision name */ ! 174: char * Nextdotstring; /* next available place of Dotstring */ ! 175: struct Datepairs * datelist, * duelst; ! 176: struct Revpairs * revlist, * Revlst; ! 177: int branchflag; /* set on -b */ ! 178: struct lockers * lockerlist; ! 179: struct stateattri * statelist; ! 180: struct authors * authorlist; ! 181: ! 182: ! 183: ! 184: main (argc, argv) ! 185: int argc; ! 186: char * argv[]; ! 187: { ! 188: struct Datepairs * currdate; ! 189: struct assoc * curassoc; ! 190: struct access * curaccess; ! 191: struct lock * currlock; ! 192: char * cmdusage; ! 193: ! 194: cmdusage = "command format:\nrlog -L -R -h -t -b -ddates -l[lockers] -rrevisions -sstates -w[logins] file ..."; ! 195: cmdid = "rlog"; ! 196: descflag = selectflag = true; ! 197: lockflag = onlylockflag = selectop = false; ! 198: onlyRCSflag = false; ! 199: lockerlist = nil; ! 200: authorlist = nil; ! 201: statelist = nil; ! 202: Revlst = revlist = nil; ! 203: branchflag= false; ! 204: duelst = datelist = nil; ! 205: caller=getcaller(); ! 206: ! 207: while (--argc,++argv, argc>=1 && ((*argv)[0] == '-')) { ! 208: switch ((*argv)[1]) { ! 209: ! 210: case 'L': ! 211: onlylockflag = true; ! 212: break; ! 213: ! 214: case 'R': ! 215: onlyRCSflag =true; ! 216: break; ! 217: ! 218: case 'l': ! 219: selectop = true; ! 220: lockflag = true; ! 221: getlocker( (*argv)+2 ); ! 222: break; ! 223: ! 224: case 'b': ! 225: selectop = true; ! 226: branchflag = true; ! 227: break; ! 228: ! 229: case 'r': ! 230: selectop = true; ! 231: getrevpairs( (*argv)+2 ); ! 232: break; ! 233: ! 234: case 'd': ! 235: selectop = true; ! 236: getdatepair( (*argv)+2 ); ! 237: break; ! 238: ! 239: case 's': ! 240: selectop = true; ! 241: getstate( (*argv)+2); ! 242: break; ! 243: ! 244: case 'w': ! 245: selectop = true; ! 246: getauthor( (*argv)+2); ! 247: break; ! 248: ! 249: case 'h': ! 250: if ( ! selectflag ) warn("option -t overrides -h"); ! 251: else descflag = false; ! 252: break; ! 253: ! 254: case 't': ! 255: selectflag = false; ! 256: if ( ! descflag ) warn("option -t overrides -h"); ! 257: descflag = true; ! 258: break; ! 259: ! 260: default: ! 261: faterror("unknown option: %s\n%s", *argv,cmdusage); ! 262: ! 263: }; ! 264: } /* end of option processing */ ! 265: ! 266: if (argc<1) faterror("No input file\n%s",cmdusage); ! 267: ! 268: ! 269: /* now handle all filenames */ ! 270: do { ! 271: rewriteflag=false; ! 272: finptr=frewrite=nil; ! 273: ! 274: ! 275: if (!pairfilenames(argc, argv, true,false)) continue; ! 276: ! 277: /* now RCSfilename contains the name of the RCS file, and finptr ! 278: * the file descriptor. Workfilename contains the name of the ! 279: * working file. ! 280: */ ! 281: ! 282: if ( !trysema(RCSfilename, false)) goto loopend; /* give up */ ! 283: ! 284: /* do nothing if -L is given and there are no locks*/ ! 285: if ( onlylockflag && Locks == nil ) goto loopend; ! 286: ! 287: if ( onlyRCSflag ) { ! 288: VOID fprintf(stdout, "%s\n", RCSfilename); ! 289: goto loopend; ! 290: } ! 291: /* print RCS filename , working filename and optional ! 292: administrative information */ ! 293: VOID fprintf(stdout, "\nRCS file: %s; ",RCSfilename); ! 294: /* could use getfullRCSname() here, but that is very slow */ ! 295: VOID fprintf(stdout, "Working file: %s\n", workfilename); ! 296: VOID fprintf(stdout, "head: %s\n", Head==nil?"":Head->num); ! 297: VOID fprintf(stdout, "branch: %s\n", Dbranch==nil?"":Dbranch->num); ! 298: ! 299: VOID fputs("locks: ", stdout); /* print locker list */ ! 300: currlock = Locks; ! 301: while( currlock ) { ! 302: VOID fprintf(stdout," %s: %s;", currlock->login, ! 303: currlock->delta->num); ! 304: currlock = currlock->nextlock; ! 305: } ! 306: if ( StrictLocks ) ! 307: VOID fputs(Locks==nil?" ; strict":" strict",stdout); ! 308: ! 309: VOID fputs("\naccess list: ", stdout); /* print access list */ ! 310: curaccess = AccessList; ! 311: while(curaccess) { ! 312: VOID fputs(" ",stdout); ! 313: VOID fputs(curaccess->login, stdout); ! 314: curaccess = curaccess->nextaccess; ! 315: } ! 316: ! 317: VOID fputs("\nsymbolic names:", stdout); /* print symbolic names */ ! 318: curassoc = Symbols; ! 319: while( curassoc ) { ! 320: VOID fprintf(stdout, " %s: %s;",curassoc->symbol, ! 321: curassoc->delta->num); ! 322: curassoc = curassoc->nextassoc; ! 323: } ! 324: ! 325: VOID fprintf(stdout,"\ncomment leader: \"%s\"\n",Comment); ! 326: ! 327: gettree(); ! 328: VOID fprintf(stdout, "total revisions: %d; ", TotalDeltas); ! 329: if ( Head == nil || !selectflag || !descflag) { ! 330: VOID putc('\n',stdout); ! 331: if (descflag) VOID fputs("description:\n", stdout); ! 332: getdesc(descflag); ! 333: VOID fputs("=============================================================================\n",stdout); ! 334: goto loopend; ! 335: } ! 336: ! 337: ! 338: /* keep only those locks given by -l */ ! 339: if (lockflag) ! 340: trunclocks(); ! 341: getnumericrev(); /* get numeric revision or branch names */ ! 342: revno = 0; ! 343: ! 344: exttree(Head); ! 345: ! 346: /* get most recently date of the dates pointed by duelst */ ! 347: currdate = duelst; ! 348: while( currdate) { ! 349: recentdate(Head, currdate); ! 350: currdate = currdate->dnext; ! 351: } ! 352: ! 353: extdate(Head); ! 354: ! 355: /* reinitialize the date specification list */ ! 356: currdate = duelst; ! 357: while(currdate) { ! 358: VOID sprintf(currdate->strtdate,DATEFORM,0,0,0,0,0,0); ! 359: currdate = currdate->dnext; ! 360: } ! 361: ! 362: if ( selectop || ( selectflag && descflag) ) ! 363: VOID fprintf(stdout, "selected revisions: %d", revno); ! 364: VOID putc('\n', stdout); ! 365: if (descflag) VOID fputs("description:\n", stdout); ! 366: getdesc(descflag); ! 367: while( (nexttok != EOFILE) && readdeltalog()); ! 368: if (selectflag && descflag && revno) { ! 369: putrunk(); ! 370: putree(Head); ! 371: if (nextlex(), nexttok != EOFILE) ! 372: fatserror("syntax error; expecting EOF"); ! 373: } ! 374: VOID fputs("=============================================================================\n",stdout); ! 375: loopend: ! 376: VOID fclose(finptr); ! 377: } while( ++argv, --argc >= 1); ! 378: exit(nerror!=0); ! 379: } ! 380: ! 381: ! 382: ! 383: putrunk() ! 384: /* function: print revisions chosen, which are in trunk */ ! 385: ! 386: { ! 387: struct hshentry * ptr, * pre; ! 388: ! 389: if (Head == nil) return; /* empty tree */ ! 390: ! 391: pre = Head; ! 392: ptr = Head->next; ! 393: while( ptr ) { ! 394: putadelta(pre,ptr,true); ! 395: pre = ptr; ! 396: ptr = ptr->next; ! 397: } ! 398: putadelta(pre,ptr,true); ! 399: } ! 400: ! 401: ! 402: ! 403: putree(root) ! 404: struct hshentry *root; ! 405: /* function: print delta tree( not include trunck) in reversed calender ! 406: order on each branch */ ! 407: ! 408: { ! 409: if ( root == nil ) return; ! 410: ! 411: putree(root->next); ! 412: ! 413: putforest(root->branches); ! 414: } ! 415: ! 416: ! 417: ! 418: ! 419: putforest(branchroot) ! 420: struct branchhead * branchroot; ! 421: /* function: print branches that has the same direct ancestor */ ! 422: { ! 423: ! 424: if ( branchroot == nil ) return; ! 425: ! 426: putforest(branchroot->nextbranch); ! 427: ! 428: putabranch(branchroot->hsh); ! 429: putree(branchroot->hsh); ! 430: } ! 431: ! 432: ! 433: ! 434: ! 435: putabranch(root) ! 436: struct hshentry *root; ! 437: /* function : print one branch */ ! 438: ! 439: { ! 440: ! 441: if ( root == nil) return; ! 442: ! 443: putabranch(root->next); ! 444: ! 445: putadelta(root, root, false); ! 446: } ! 447: ! 448: ! 449: ! 450: ! 451: ! 452: putadelta(node,editscript,trunk) ! 453: register struct hshentry * node; ! 454: register struct hshentry * editscript; ! 455: int trunk; ! 456: /* function: print delta node if node->selector is 's'. */ ! 457: /* editscript indicates where the editscript is stored */ ! 458: /* trunk indicated whether this node is in trunk */ ! 459: { ! 460: struct branchhead * newbranch; ! 461: char * branchnum, branch[40]; ! 462: ! 463: if ( ( node == nil) || ( node->selector == 'u')) ! 464: return; ! 465: ! 466: VOID fprintf(stdout,"----------------------------\n"); ! 467: VOID fprintf(stdout, "revision %s ",node->num); ! 468: if ( node->lockedby ) ! 469: VOID fprintf(stdout, "locked by: %s; ", node->lockedby); ! 470: VOID putc('\n', stdout); ! 471: ! 472: VOID fputs("date: ",stdout); ! 473: VOID PRINTDATE(stdout,node->date); VOID putc(' ',stdout); ! 474: VOID PRINTTIME(stdout,node->date); ! 475: VOID fprintf(stdout, "; author: %s; ", node->author); ! 476: VOID fprintf(stdout, "state: %s; ", node->state); ! 477: ! 478: if ( editscript ) ! 479: if(trunk) ! 480: VOID fprintf(stdout,"lines added/del: %d/%d", ! 481: editscript->deletelns, editscript->insertlns); ! 482: else ! 483: VOID fprintf(stdout,"lines added/del: %d/%d", ! 484: editscript->insertlns, editscript->deletelns); ! 485: ! 486: VOID putc('\n', stdout); ! 487: ! 488: branchnum = & (branch[0]); ! 489: newbranch = node->branches; ! 490: if ( newbranch ) { ! 491: VOID fputs("branches: ", stdout); ! 492: while( newbranch ) { ! 493: getbranchno(newbranch->hsh->num, branchnum); ! 494: VOID fprintf(stdout, "%s; ", branchnum); ! 495: newbranch = newbranch->nextbranch; ! 496: } ! 497: VOID putc('\n', stdout); ! 498: } ! 499: ! 500: VOID fputs(node->log,stdout); ! 501: } ! 502: ! 503: ! 504: ! 505: ! 506: ! 507: readdeltalog() ! 508: /* Function : get the log message and skip the text of a deltatext node. ! 509: * Return false if current block does not start with a number. ! 510: * Assumes the current lexeme is not yet in nexttok; does not ! 511: * advance nexttok. ! 512: */ ! 513: { ! 514: register struct hshentry * Delta; ! 515: ! 516: nextlex(); ! 517: if ( !(Delta = getnum() )) return(false); ! 518: if ( ! getkey(Klog) || ( nexttok != STRING ) ) ! 519: fatserror("Missing log entry"); ! 520: Delta->log = talloc(logsize); ! 521: VOID savestring(Delta->log, logsize); ! 522: nextlex(); ! 523: if ( ! getkey(Ktext) || (nexttok != STRING) ) ! 524: fatserror("Missing delta text"); ! 525: Delta->insertlns = Delta->deletelns = 0; ! 526: if ( Delta != Head) ! 527: getscript(Delta); ! 528: else ! 529: readstring(); ! 530: return true; ! 531: } ! 532: ! 533: ! 534: ! 535: getscript(Delta) ! 536: struct hshentry * Delta; ! 537: /* function: read edit script of Delta and count how many lines added */ ! 538: /* and deleted in the script */ ! 539: ! 540: { ! 541: int ed; /* editor command */ ! 542: register FILE * fin; ! 543: register int c; ! 544: register int i; ! 545: int length; ! 546: ! 547: fin = finptr; ! 548: while( (ed = getc(fin)) != EOF) { ! 549: /* assume first none white character is command name */ ! 550: while( ed == '\n' || ed == ' ' || ed == '\t') ! 551: ed = getc(fin); ! 552: if (ed == SDELIM) break; /* script text is ended */ ! 553: while( ( c = getc(fin)) == ' ' ); /* skip blank */ ! 554: if ( ! ('0' <= c && c <= '9')) { ! 555: faterror("Missing line number in edit script"); ! 556: break; ! 557: } ! 558: while( '0' <= (c = getc(fin)) && c <= '9' ) ; ! 559: ! 560: while( c == ' ')c = getc(fin); /* skip blanks */ ! 561: if ( !('0' <= c && c <= '9' ) ) { ! 562: faterror("Incorrect range in edit script"); ! 563: break; ! 564: } ! 565: length = c - '0'; ! 566: while( '0' <= (c = getc(fin)) && c <= '9' ) ! 567: length = length * 10 + c - '0'; ! 568: while( c != '\n' && c != EOF) c = getc(fin); ! 569: switch (ed) { ! 570: case 'd' : ! 571: Delta->deletelns += length; ! 572: break; ! 573: ! 574: case 'a' : ! 575: /* skip scripted lines */ ! 576: for ( i=length; i > 0 && c != EOF; i--){ ! 577: while( (c=getc(fin)) != '\n' && c != EOF); ! 578: Delta->insertlns++; ! 579: } ! 580: break; ! 581: ! 582: default: ! 583: faterror("Unknown command in edit script: %c", ed); ! 584: break; ! 585: } ! 586: } ! 587: nextc = getc(fin); ! 588: } ! 589: ! 590: ! 591: ! 592: ! 593: ! 594: ! 595: ! 596: exttree(root) ! 597: struct hshentry *root; ! 598: /* function: select revisions , starting with root */ ! 599: ! 600: { ! 601: struct branchhead * newbranch; ! 602: ! 603: if (root == nil) return; ! 604: ! 605: extractdelta(root); ! 606: exttree(root->next); ! 607: ! 608: newbranch = root->branches; ! 609: while( newbranch ) { ! 610: exttree(newbranch->hsh); ! 611: newbranch = newbranch->nextbranch; ! 612: } ! 613: } ! 614: ! 615: ! 616: ! 617: ! 618: getlocker(argv) ! 619: char * argv; ! 620: /* function : get the login names of lockers from command line */ ! 621: /* and store in lockerlist. */ ! 622: ! 623: { ! 624: register char c; ! 625: struct lockers * newlocker; ! 626: argv--; ! 627: while( ( c = (*++argv)) == ',' || c == ' ' || c == '\t' || ! 628: c == '\n' || c == ';') ; ! 629: if ( c == '\0') { ! 630: lockerlist=nil; ! 631: return; ! 632: } ! 633: ! 634: while( c != '\0' ) { ! 635: newlocker = ( struct lockers *)talloc( sizeof(struct lockers) ); ! 636: newlocker->lockerlink = lockerlist; ! 637: newlocker->login = argv; ! 638: lockerlist = newlocker; ! 639: while ( ( c = (*++argv)) != ',' && c != '\0' && c != ' ' ! 640: && c != '\t' && c != '\n' && c != ';') ; ! 641: *argv = '\0'; ! 642: if ( c == '\0' ) return; ! 643: while( ( c = (*++argv)) == ',' || c == ' ' || c == '\t' || ! 644: c == '\n' || c == ';') ; ! 645: } ! 646: } ! 647: ! 648: ! 649: ! 650: getauthor(argv) ! 651: char *argv; ! 652: /* function: get the author's name form command line */ ! 653: /* and store in aauthorlist */ ! 654: ! 655: { ! 656: register c; ! 657: struct authors * newauthor; ! 658: ! 659: argv--; ! 660: while( ( c = (*++argv)) == ',' || c == ' ' || c == '\t' || ! 661: c == '\n' || c == ';') ; ! 662: if ( c == '\0' ) { ! 663: authorlist = (struct authors *)talloc(sizeof(struct authors)); ! 664: authorlist->login = caller; ! 665: authorlist->nextauthor = nil; ! 666: return; ! 667: } ! 668: ! 669: while( c != '\0' ) { ! 670: newauthor = (struct authors *)talloc(sizeof(struct authors)); ! 671: newauthor->nextauthor = authorlist; ! 672: newauthor->login = argv; ! 673: authorlist = newauthor; ! 674: while( ( c = *++argv) != ',' && c != '\0' && c != ' ' ! 675: && c != '\t' && c != '\n' && c != ';') ; ! 676: * argv = '\0'; ! 677: if ( c == '\0') return; ! 678: while( ( c = (*++argv)) == ',' || c == ' ' || c == '\t' || ! 679: c == '\n' || c == ';') ; ! 680: } ! 681: } ! 682: ! 683: ! 684: ! 685: ! 686: getstate(argv) ! 687: char * argv; ! 688: /* function : get the states of revisions from command line */ ! 689: /* and store in statelist */ ! 690: ! 691: { ! 692: register char c; ! 693: struct stateattri *newstate; ! 694: ! 695: argv--; ! 696: while( ( c = (*++argv)) == ',' || c == ' ' || c == '\t' || ! 697: c == '\n' || c == ';') ; ! 698: if ( c == '\0'){ ! 699: warn(" Missing state attributes after -s options"); ! 700: return; ! 701: } ! 702: ! 703: while( c != '\0' ) { ! 704: newstate = (struct stateattri *)talloc(sizeof(struct stateattri)); ! 705: newstate->nextstate = statelist; ! 706: newstate->status = argv; ! 707: statelist = newstate; ! 708: while( (c = (*++argv)) != ',' && c != '\0' && c != ' ' ! 709: && c != '\t' && c != '\n' && c != ';') ; ! 710: *argv = '\0'; ! 711: if ( c == '\0' ) return; ! 712: while( ( c = (*++argv)) == ',' || c == ' ' || c == '\t' || ! 713: c == '\n' || c == ';') ; ! 714: } ! 715: } ! 716: ! 717: ! 718: ! 719: trunclocks() ! 720: /* Function: Truncate the list of locks to those that are held by the */ ! 721: /* id's on lockerlist. Do not truncate if lockerlist empty. */ ! 722: ! 723: { ! 724: struct lockers * plocker; ! 725: struct lock * plocked, * nextlocked; ! 726: ! 727: if ( (lockerlist == nil) || (Locks == nil)) return; ! 728: ! 729: /* shorten Locks to those contained in lockerlist */ ! 730: plocked = Locks; ! 731: Locks = nil; ! 732: while( plocked != nil) { ! 733: plocker = lockerlist; ! 734: while((plocker != nil) && ( strcmp(plocker->login, plocked->login)!=0)) ! 735: plocker = plocker->lockerlink; ! 736: nextlocked = plocked->nextlock; ! 737: if ( plocker != nil) { ! 738: plocked->nextlock = Locks; ! 739: Locks = plocked; ! 740: } ! 741: plocked = nextlocked; ! 742: } ! 743: } ! 744: ! 745: ! 746: ! 747: recentdate(root, pd) ! 748: struct hshentry * root; ! 749: struct Datepairs * pd; ! 750: /* function: Finds the delta that is closest to the cutoff date given by */ ! 751: /* pd among the revisions selected by exttree. */ ! 752: /* Successively narrows down the interfal given by pd, */ ! 753: /* and sets the strtdate of pd to the date of the selected delta */ ! 754: { ! 755: struct branchhead * newbranch; ! 756: ! 757: if ( root == nil) return; ! 758: if ( root->selector == 's') { ! 759: if ( cmpnum(root->date, pd->strtdate) >= 0 && ! 760: cmpnum(root->date, pd->enddate) <= 0) ! 761: VOID strcpy(pd->strtdate, root->date); ! 762: } ! 763: ! 764: recentdate(root->next, pd); ! 765: newbranch = root->branches; ! 766: while( newbranch) { ! 767: recentdate(newbranch->hsh, pd); ! 768: newbranch = newbranch->nextbranch; ! 769: } ! 770: } ! 771: ! 772: ! 773: ! 774: ! 775: ! 776: ! 777: extdate(root) ! 778: struct hshentry * root; ! 779: /* function: select revisions which are in the date range specified */ ! 780: /* in duelst and datelist, start at root */ ! 781: ! 782: { ! 783: struct branchhead * newbranch; ! 784: struct Datepairs * pdate; ! 785: ! 786: if ( root == nil) return; ! 787: ! 788: if ( datelist || duelst) { ! 789: pdate = datelist; ! 790: while( pdate ) { ! 791: if ( (pdate->strtdate)[0] == '\0' || cmpnum(root->date,pdate->strtdate) >= 0){ ! 792: if ((pdate->enddate)[0] == '\0' || cmpnum(pdate->enddate,root->date) >= 0) ! 793: break; ! 794: } ! 795: pdate = pdate->dnext; ! 796: } ! 797: if ( pdate == nil) { ! 798: pdate = duelst; ! 799: while(pdate) { ! 800: if ( cmpnum(root->date, pdate->strtdate) == 0) ! 801: break; ! 802: pdate = pdate->dnext; ! 803: } ! 804: } ! 805: if ( pdate == nil) ! 806: root->selector = 'u'; ! 807: } ! 808: if (root->selector == 's') revno++; ! 809: ! 810: extdate(root->next); ! 811: ! 812: newbranch = root->branches; ! 813: while( newbranch ) { ! 814: extdate(newbranch->hsh); ! 815: newbranch = newbranch->nextbranch; ! 816: } ! 817: } ! 818: ! 819: ! 820: ! 821: extractdelta(pdelta) ! 822: struct hshentry * pdelta; ! 823: /* function: compare information of pdelta to the authorlst, lockerlist, */ ! 824: /* statelist, revlist and mark 's' on selector if pdelta is */ ! 825: /* selected; otherwise, mark 'u' */ ! 826: ! 827: { ! 828: struct lock * plock; ! 829: struct stateattri * pstate; ! 830: struct authors * pauthor; ! 831: struct Revpairs * prevision; ! 832: int length; ! 833: ! 834: pdelta->selector = 's'; ! 835: if ( authorlist ) { /* certain author's revisions wanted only */ ! 836: pauthor = authorlist; ! 837: while((pauthor != nil) && ( strcmp(pauthor->login, pdelta->author)!=0)) ! 838: pauthor = pauthor->nextauthor; ! 839: if ( pauthor == nil ) { ! 840: pdelta->selector = 'u'; ! 841: return; ! 842: } ! 843: } ! 844: if ( statelist ) { /* revisions with certain state wanted */ ! 845: pstate = statelist; ! 846: while((pstate != nil) && (strcmp(pstate->status, pdelta->state)!=0)) ! 847: pstate = pstate->nextstate; ! 848: if ( pstate == nil ) { ! 849: pdelta->selector = 'u'; ! 850: return; ! 851: } ! 852: } ! 853: if ( lockflag ) { /* locked revisions */ ! 854: plock = Locks; ! 855: while( plock && (plock->delta != pdelta)) ! 856: plock = plock->nextlock; ! 857: if (plock == nil ) { ! 858: pdelta->selector = 'u'; ! 859: return; ! 860: } ! 861: } ! 862: if ( Revlst ) { /* revisions or branches selected */ ! 863: ! 864: prevision = Revlst; ! 865: while( prevision != nil ) { ! 866: length = prevision->numfld; ! 867: if ( length % 2 == 1) { /* a branch number */ ! 868: if ( countnumflds(pdelta->num) ==(length+1)) ! 869: if ( (compartial(pdelta->num, prevision->strtrev,length) >= 0)&& ! 870: (compartial(prevision->endrev, pdelta->num, length) >= 0) ) ! 871: break; ! 872: } ! 873: else if ( countnumflds(pdelta->num ) == length) /* a revision */ ! 874: if ( (compartial(pdelta->num, prevision->strtrev, length) >= 0) && ! 875: (compartial(prevision->endrev, pdelta->num, length) >= 0) ) ! 876: break; ! 877: prevision = prevision->rnext; ! 878: } ! 879: if (prevision == nil) { ! 880: pdelta->selector = 'u'; ! 881: return; ! 882: } ! 883: } ! 884: } ! 885: ! 886: ! 887: ! 888: char * procdate(target, source) ! 889: char * target, * source; ! 890: /* Function: Parses a free-format date in target, converts it ! 891: * into RCS internal format, and stores the result into source. ! 892: * Returns target on success, nil otherwise. ! 893: */ ! 894: { ! 895: long unixtime; ! 896: struct tm parseddate, *ftm; ! 897: ! 898: if ( partime(source, &parseddate) == 0) { ! 899: error("Can't parse date/time: %s", source); ! 900: *target= '\0'; ! 901: return nil; ! 902: } ! 903: if ( (unixtime = maketime(&parseddate)) == 0L) { ! 904: error("Inconsistent date/time: %s", source); ! 905: *target='\0'; ! 906: return nil; ! 907: } ! 908: ftm = localtime(&unixtime); ! 909: VOID sprintf(target,DATEFORM, ! 910: ftm->tm_year,ftm->tm_mon+1,ftm->tm_mday,ftm->tm_hour,ftm->tm_min,ftm->tm_sec); ! 911: return target; ! 912: } ! 913: ! 914: ! 915: ! 916: getdatepair(argv) ! 917: char * argv; ! 918: /* function: get time range from command line and store in datelist if */ ! 919: /* a time range specified or in duelst if a time spot specified */ ! 920: ! 921: { ! 922: register char c; ! 923: struct Datepairs * nextdate; ! 924: char * rawdate; ! 925: int switchflag; ! 926: ! 927: argv--; ! 928: while( ( c = (*++argv)) == ',' || c == ' ' || c == '\t' || ! 929: c == '\n' || c == ';') ; ! 930: if ( c == '\0' ) { ! 931: warn("Missing date/time after -d"); ! 932: return; ! 933: } ! 934: ! 935: while( c != '\0' ) { ! 936: switchflag = false; ! 937: nextdate = (struct Datepairs *) talloc(sizeof(struct Datepairs)); ! 938: if ( c == '<' ) { /* case: -d <date */ ! 939: c = *++argv; ! 940: (nextdate->strtdate)[0] = '\0'; ! 941: } elsif (c == '>') { /* case: -d >date */ ! 942: c = *++argv; ! 943: (nextdate->enddate)[0] = '\0'; ! 944: switchflag = true; ! 945: } else { ! 946: rawdate = argv; ! 947: while( c != '<' && c != '>' && c != ';' && c != '\0') ! 948: c = *++argv; ! 949: *argv = '\0'; ! 950: if ( c == '>' ) switchflag=true; ! 951: if (procdate(switchflag?nextdate->enddate:nextdate->strtdate, ! 952: rawdate)==nil) continue; ! 953: if ( c == ';' || c == '\0') { /* case: -d date */ ! 954: VOID strcpy(nextdate->enddate,nextdate->strtdate); ! 955: VOID sprintf(nextdate->strtdate,DATEFORM,0,0,0,0,0,0); ! 956: nextdate->dnext = duelst; ! 957: duelst = nextdate; ! 958: goto end; ! 959: } else { ! 960: /* case: -d date< or -d date>; see switchflag */ ! 961: while ( (c= *++argv) == ' ' || c=='\t' || c=='\n'); ! 962: if ( c == ';' || c == '\0') { ! 963: /* second date missing */ ! 964: if (switchflag) ! 965: *nextdate->strtdate= '\0'; ! 966: else ! 967: *nextdate->enddate= '\0'; ! 968: nextdate->dnext = datelist; ! 969: datelist = nextdate; ! 970: goto end; ! 971: } ! 972: } ! 973: } ! 974: rawdate = argv; ! 975: while( c != '>' && c != '<' && c != ';' && c != '\0') ! 976: c = *++argv; ! 977: *argv = '\0'; ! 978: if (procdate(switchflag?nextdate->strtdate:nextdate->enddate, ! 979: rawdate)==nil) continue; ! 980: nextdate->dnext = datelist; ! 981: datelist = nextdate; ! 982: end: ! 983: /* ! 984: VOID printf("startdate: %s; enddate: %s;\n", nextdate->strtdate,nextdate->enddate); ! 985: */ ! 986: if ( c == '\0') return; ! 987: while( (c = *++argv) == ';' || c == ' ' || c == '\t' || c =='\n'); ! 988: } ! 989: } ! 990: ! 991: ! 992: ! 993: ! 994: ! 995: getnumericrev() ! 996: /* function: get the numeric name of revisions which stored in revlist */ ! 997: /* and then stored the numeric names in Revlst */ ! 998: /* if branchflag, also add default branch */ ! 999: ! 1000: { ! 1001: struct Revpairs * ptr, *pt; ! 1002: int flag; ! 1003: char *temprev; ! 1004: ! 1005: /* free the previous numeric revision list */ ! 1006: pt = Revlst; ! 1007: while( pt) { ! 1008: ptr = pt->rnext; ! 1009: free((char *)pt); ! 1010: pt = ptr; ! 1011: } ! 1012: Nextdotstring = &Dotstring[0]; /* reset buffer */ ! 1013: ! 1014: ! 1015: Revlst = nil; ! 1016: ptr = revlist; ! 1017: while( ptr ) { ! 1018: pt = (struct Revpairs *) talloc(sizeof(struct Revpairs)); ! 1019: if ( ptr->numfld == 1 ){ /* case: -r rev */ ! 1020: if ( (flag = expandsym(ptr->strtrev, Nextdotstring)) == true ) { ! 1021: pt->numfld = countnumflds(Nextdotstring); ! 1022: pt->strtrev = pt->endrev = Nextdotstring; ! 1023: while( *Nextdotstring++ != '\0' ) ; ! 1024: } ! 1025: } ! 1026: else if( ptr->numfld == 2){ /* case: -r rev- */ ! 1027: if ( (flag = expandsym(ptr->strtrev, Nextdotstring)) == true) { ! 1028: pt->numfld = countnumflds(Nextdotstring); ! 1029: pt->strtrev = Nextdotstring; ! 1030: while( *Nextdotstring++ != '\0' ) ; ! 1031: pt->endrev = Nextdotstring; ! 1032: if ( pt->numfld > 2) choptail(pt->strtrev); ! 1033: * Nextdotstring++ = '\0'; ! 1034: } ! 1035: } ! 1036: else if(ptr->numfld == 3) { /* case: -r -rev */ ! 1037: if ( (flag = expandsym(ptr->endrev, Nextdotstring)) == true) { ! 1038: pt->endrev = Nextdotstring; ! 1039: while( *Nextdotstring++ != '\0' ) ; ! 1040: pt->numfld = countnumflds(pt->endrev); ! 1041: pt->strtrev = Nextdotstring; ! 1042: if ( pt->numfld == 2) ! 1043: *Nextdotstring++ = '1'; ! 1044: else ! 1045: choptail(pt->endrev); ! 1046: *Nextdotstring++ = '.'; ! 1047: *Nextdotstring++ = '1'; ! 1048: *Nextdotstring++ = '\0'; ! 1049: } ! 1050: } ! 1051: else { /* case: -r rev1-rev2 */ ! 1052: if ( (flag = expandsym(ptr->strtrev, Nextdotstring)) == true ) { ! 1053: pt->strtrev = Nextdotstring; ! 1054: while( *Nextdotstring++ != '\0' ) ; ! 1055: if ( ( flag = expandsym(ptr->endrev, Nextdotstring)) == true) { ! 1056: pt->numfld = countnumflds(pt->strtrev); ! 1057: pt->endrev = Nextdotstring; ! 1058: while( *Nextdotstring++ != '\0' ) ; ! 1059: if((flag = checkrevpair(pt->strtrev, pt->endrev)) == true) ! 1060: /* switch pt->strtrev with pt->endrev, if pt->strtrev > pt->endre */ ! 1061: if (compartial(pt->strtrev, pt->endrev, pt->numfld) > 0 ) { ! 1062: temprev = pt->strtrev; ! 1063: pt->strtrev = pt->endrev; ! 1064: pt->endrev = temprev; ! 1065: } ! 1066: } ! 1067: } ! 1068: } ! 1069: ! 1070: if ( flag ){ ! 1071: pt->rnext = Revlst; ! 1072: Revlst = pt; ! 1073: } ! 1074: else ! 1075: free((char *)pt); ! 1076: ptr = ptr->rnext; ! 1077: } ! 1078: /* Now take care of branchflag */ ! 1079: if (branchflag) { ! 1080: flag =true; ! 1081: pt = (struct Revpairs *) talloc(sizeof(struct Revpairs)); ! 1082: if (Dbranch) { ! 1083: pt->strtrev = pt->endrev = Dbranch->num; ! 1084: } elsif (Head!=nil) { ! 1085: pt->strtrev = pt->endrev = /* branch number of head */ ! 1086: partialno(Nextdotstring,Head->num,1); ! 1087: while( *Nextdotstring++ != '\0' ) ; ! 1088: } else flag = false; ! 1089: if (flag) { /* prepend new node */ ! 1090: pt->rnext=Revlst; Revlst=pt; ! 1091: pt->numfld = countnumflds(pt->strtrev); ! 1092: } ! 1093: } ! 1094: ! 1095: } ! 1096: ! 1097: ! 1098: ! 1099: checkrevpair(num1,num2) ! 1100: char *num1, *num2; ! 1101: /* function: check whether num1, num2 are legal pair,i.e. ! 1102: only the last field are different and have same number of ! 1103: feilds( if length <= 2, may be different if first field) */ ! 1104: ! 1105: { ! 1106: int length; ! 1107: ! 1108: if ( (length = countnumflds(num1)) != countnumflds(num2) ) { ! 1109: error(" Invalid branch or revision pair %s : %s", num1, num2); ! 1110: return false; ! 1111: } ! 1112: if ( length > 2 ) ! 1113: if (compartial(num1, num2, length-1) != 0) { ! 1114: error("Invalid branch or revision pair %s : %s", num1, num2); ! 1115: return false; ! 1116: } ! 1117: ! 1118: return true; ! 1119: } ! 1120: ! 1121: ! 1122: ! 1123: getrevpairs(argv) ! 1124: register char * argv; ! 1125: /* function: get revision or branch range from command line, and */ ! 1126: /* store in revlist */ ! 1127: ! 1128: { ! 1129: register char c; ! 1130: struct Revpairs * nextrevpair; ! 1131: int flag; ! 1132: ! 1133: argv--; ! 1134: while( ( c = (*++argv)) == ',' || c == ' ' || c == '\t' || ! 1135: c == '\n' || c == ';') ; ! 1136: if ( c == '\0' ) { ! 1137: warn(" Missing revision or branch number after -r"); ! 1138: return; ! 1139: } ! 1140: ! 1141: while( c != '\0') { ! 1142: while( c == ',' || c == ' ' || c == '\t' || ! 1143: c == '\n' || c == ';') c = *++argv; ! 1144: if (c == '\0') return; ! 1145: nextrevpair = (struct Revpairs *) talloc(sizeof(struct Revpairs)); ! 1146: nextrevpair->rnext = revlist; ! 1147: revlist = nextrevpair; ! 1148: nextrevpair->numfld = nil; ! 1149: nextrevpair->strtrev = nil; ! 1150: nextrevpair->endrev = nil; ! 1151: flag = false; ! 1152: if ( c == '<' || c == '-' ) { /* case: -r -rev or -r <rev */ ! 1153: flag = true; ! 1154: while( (c =(*++argv)) == ' ' || c == '\t' || c =='\n') ; ! 1155: } ! 1156: else { ! 1157: nextrevpair->strtrev = argv; ! 1158: /* get a revision or branch name */ ! 1159: while( c != ',' && c != ';' && c != ' ' && c != '\0' && c != '-' ! 1160: && c != '\t' && c != '\n' && c != '<') c = *++argv; ! 1161: ! 1162: *argv = '\0'; ! 1163: ! 1164: if ( c != '<' && c != '-') { /* case: rev */ ! 1165: nextrevpair->numfld = 1; ! 1166: continue; ! 1167: } ! 1168: ! 1169: if ( (c =(*++argv)) == ',' || c == '\0' || c == ' ' ! 1170: || c == '\t' || c == '\n' || c == ';') {/* case: rev_ */ ! 1171: nextrevpair->numfld = 2; ! 1172: continue; ! 1173: } ! 1174: } ! 1175: nextrevpair->endrev = argv; ! 1176: while( c != ',' && c != ' ' && c != '\0' && c != '\t' && c != '<' ! 1177: && c != '\n' && c != '-' && c != ';') c = *++argv; ! 1178: ! 1179: * argv = '\0'; ! 1180: if ( c == '<'){ ! 1181: error("separator expected near %s", nextrevpair->endrev); ! 1182: while( (c = *++argv) != ',' && c != ' ' && c != '\0' && ! 1183: c != '\t' && c != '\n' && c != ';' ) ; ! 1184: revlist = nextrevpair->rnext; ! 1185: continue; ! 1186: } ! 1187: else { ! 1188: if (flag) /* case: -rev */ ! 1189: nextrevpair->numfld = 3; ! 1190: ! 1191: else /* rev1-rev2 appears */ ! 1192: nextrevpair->numfld = 4; ! 1193: } ! 1194: } ! 1195: } ! 1196: ! 1197: ! 1198: ! 1199: choptail(strhead) ! 1200: char * strhead; ! 1201: /* function : chop off the last field of a branch or a revision number */ ! 1202: ! 1203: { ! 1204: char *pt, *sp; ! 1205: ! 1206: for(pt = Nextdotstring-1; pt != strhead && *pt != '.'; pt--) ; ! 1207: for(sp = strhead; sp < pt; sp++) *Nextdotstring++ = *sp; ! 1208: } ! 1209:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.