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