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