![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcsrev.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 rcsrev.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / rcs / src |
1.1 ! root 1: /* ! 2: * RCS revision number handling ! 3: */ ! 4: #ifndef lint ! 5: static char rcsid[]= "$Id: rcsrev.c,v 4.3 87/10/18 10:38:42 narten Exp $ Purdue CS"; ! 6: #endif ! 7: /********************************************************************************* ! 8: ********************************************************************************* ! 9: * ! 10: * Copyright (C) 1982 by Walter F. 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: rcsrev.c,v $ ! 23: * Revision 4.3 87/10/18 10:38:42 narten ! 24: * Updating version numbers. Changes relative to version 1.1 actually ! 25: * relative to 4.1 ! 26: * ! 27: * Revision 1.3 87/09/24 14:00:37 narten ! 28: * Sources now pass through lint (if you ignore printf/sprintf/fprintf ! 29: * warnings) ! 30: * ! 31: * Revision 1.2 87/03/27 14:22:37 jenkins ! 32: * Port to suns ! 33: * ! 34: * Revision 1.1 84/01/23 14:50:37 kcs ! 35: * Initial revision ! 36: * ! 37: * Revision 4.1 83/03/25 21:10:45 wft ! 38: * Only changed $Header to $Id. ! 39: * ! 40: * Revision 3.4 82/12/04 13:24:08 wft ! 41: * Replaced getdelta() with gettree(). ! 42: * ! 43: * Revision 3.3 82/11/28 21:33:15 wft ! 44: * fixed compartial() and compnum() for nil-parameters; fixed nils ! 45: * in error messages. Testprogram output shortenend. ! 46: * ! 47: * Revision 3.2 82/10/18 21:19:47 wft ! 48: * renamed compnum->cmpnum, compnumfld->cmpnumfld, ! 49: * numericrevno->numricrevno. ! 50: * ! 51: * Revision 3.1 82/10/11 19:46:09 wft ! 52: * changed expandsym() to check for source==nil; returns zero length string ! 53: * in that case. ! 54: */ ! 55: ! 56: ! 57: ! 58: /* ! 59: #define REVTEST ! 60: /* version REVTEST is for testing the routines that generate a sequence ! 61: * of delta numbers needed to regenerate a given delta. ! 62: */ ! 63: ! 64: #include "rcsbase.h" ! 65: ! 66: extern FILE * finptr; /* RCS input file */ ! 67: extern char * getid(); ! 68: extern struct hshentry * getnum(); ! 69: extern int getkey(); ! 70: extern int getlex(); ! 71: ! 72: extern char * getkeyval(); ! 73: extern int delta(), deltatext(); ! 74: struct hshentry * genbranch(); /* forward */ ! 75: ! 76: ! 77: ! 78: int countnumflds(s) ! 79: char * s; ! 80: /* Given a pointer s to a dotted number (date or revision number), ! 81: * countnumflds returns the number of digitfields in s. ! 82: */ ! 83: { register char * sp; ! 84: register int count; ! 85: if ((sp=s)==nil) return(0); ! 86: if (*sp == '\0') return(0); ! 87: count = 1; ! 88: while (*sp) { ! 89: if (*sp++ == '.') count++; ! 90: } ! 91: if (*(--sp) == '.') count--; /*trailing periods don't count*/ ! 92: return(count); ! 93: } ! 94: ! 95: getbranchno(revno,branchno) ! 96: char * revno, * branchno; ! 97: /* Given a non-nil revision number revno, getbranchno copies the number of the branch ! 98: * on which revno is into branchnumber. If revno itself is a branch number, ! 99: * it is copied unchanged. ! 100: */ ! 101: { ! 102: register int i, numflds; ! 103: register char * tp, * sp; ! 104: ! 105: numflds=countnumflds(revno); ! 106: if (numflds%2 == 1) ! 107: VOID strcpy(branchno,revno); ! 108: else { ! 109: sp=revno; tp=branchno; ! 110: for (i=1;i<numflds;i++) { ! 111: while(*sp!='.') *tp++ = *sp++; ! 112: *tp++ = *sp++; ! 113: } ! 114: *(tp-1)='\0'; ! 115: } ! 116: } ! 117: ! 118: ! 119: ! 120: int cmpnum(num1, num2) ! 121: char * num1, * num2; ! 122: /* compares the two dotted numbers num1 and num2 lexicographically ! 123: * by field. Individual fields are compared numerically. ! 124: * returns <0, 0, >0 if num1<num2, num1==num2, and num1>num2, resp. ! 125: * omitted fields are assumed to be higher than the existing ones. ! 126: */ ! 127: { ! 128: register char * s1, *s2; ! 129: register int n1, n2; ! 130: ! 131: s1=num1==nil?"":num1; ! 132: s2=num2==nil?"":num2; ! 133: ! 134: do { ! 135: n1 = 0; ! 136: while (('0' <= *s1) && (*s1 <= '9')) { ! 137: n1 = n1*10 + (*s1 - '0'); ! 138: s1++; ! 139: } ! 140: /* skip '.' */ ! 141: if (*s1=='.') s1++; ! 142: ! 143: n2 = 0; ! 144: while (('0' <= *s2) && (*s2 <= '9')) { ! 145: n2 = n2*10 + (*s2 - '0'); ! 146: s2++; ! 147: } ! 148: /* skip '.' */ ! 149: if (*s2=='.') s2++; ! 150: ! 151: } while ((n1==n2) && (*s1!='\0') && (*s2!='\0')); ! 152: ! 153: if (((*s1=='\0') && (*s2=='\0')) || (n1!=n2)) ! 154: return (n1 - n2); ! 155: /*now n1==n2 and one of s1 or s2 is shorter*/ ! 156: /*give precedence to shorter one*/ ! 157: if (*s1=='\0') return 1; ! 158: else return -1; ! 159: ! 160: } ! 161: ! 162: ! 163: ! 164: int cmpnumfld(num1, num2, fld) ! 165: char * num1, * num2; int fld; ! 166: /* compares the two dotted numbers at field fld and returns ! 167: * num1[fld]-num2[fld]. Assumes that num1 and num2 have at least fld fields. ! 168: */ ! 169: { ! 170: register char * s1, *s2; ! 171: register int n1, n2; ! 172: ! 173: s1=num1; n1=fld-1; ! 174: /* skip fld-1 fields */ ! 175: while (n1) { ! 176: while(*s1 != '.') s1++; ! 177: n1--; s1++; ! 178: } ! 179: s2 = num2; n2=fld-1; ! 180: while (n2) { ! 181: while(*s2 != '.') s2++; ! 182: n2--; s2++; ! 183: } ! 184: /* Don't put the above into a single loop! */ ! 185: /* Now s1 and s2 point to the beginning of the respective fields */ ! 186: /* compute numerical value and compare */ ! 187: n1 = 0; ! 188: while (('0' <= *s1) && (*s1 <= '9')) { ! 189: n1 = n1*10 + (*s1 - '0'); ! 190: s1++; ! 191: } ! 192: n2 = 0; ! 193: while (('0' <= *s2) && (*s2 <= '9')) { ! 194: n2 = n2*10 + (*s2 - '0'); ! 195: s2++; ! 196: } ! 197: return (n1 - n2); ! 198: } ! 199: ! 200: ! 201: int compartial(num1, num2, length) ! 202: char * num1; ! 203: char * num2; ! 204: int length; ! 205: ! 206: /* compare the first "length" fields of two dot numbers; ! 207: the omitted field is considered to be larger than any number */ ! 208: /* restriction: at least one number has length or more fields */ ! 209: ! 210: { ! 211: register char *s1, *s2; ! 212: register int n1, n2; ! 213: ! 214: ! 215: s1 = num1; s2 = num2; ! 216: if ( s1==nil || *s1 == '\0' ) return 1; ! 217: if ( s2==nil || *s2 == '\0' ) return -1; ! 218: ! 219: do { ! 220: n1 = 0; ! 221: while( ('0' <= *s1) && (*s1 <= '9') ) { ! 222: n1 = n1 * 10 + (*s1 - '0') ; ! 223: s1++; ! 224: } ! 225: if ( *s1 == '.' ) s1++; /* skip . */ ! 226: ! 227: n2 = 0; ! 228: while( ( '0' <= *s2) && ( *s2 <= '9' ) ) { ! 229: n2 = n2 * 10 + ( *s2 - '0' ) ; ! 230: s2++; ! 231: } ! 232: if (*s2 == '.') s2++; ! 233: } while( ( n1 == n2) && ((--length) != 0) && ! 234: ( *s1 != '\0') && (*s2 != '\0') ); ! 235: ! 236: if ( (n1 != n2) || (length == 0) ){ ! 237: return(n1-n2); } ! 238: ! 239: if ( *s1 == '\0' ) return 1; ! 240: if ( *s2 == '\0' ) return -1; ! 241: fprintf(stderr, "RCS Internal error, routine: compartial\n"); ! 242: return(0); ! 243: /*NOTREACHED*/ ! 244: } ! 245: ! 246: ! 247: ! 248: incnum(onum,nnum) ! 249: char * onum, *nnum; ! 250: /* increments the last field of revision number onum by one and ! 251: * places the result into nnum ! 252: */ ! 253: { ! 254: register char * sp, *tp; ! 255: register int i; ! 256: ! 257: sp = onum; tp = nnum; ! 258: for (i=countnumflds(onum)-1; i>0; i--) { ! 259: while (*sp != '.') *tp++ = *sp++; ! 260: *tp++ = *sp++; /* copy dot also */ ! 261: } ! 262: VOID sprintf(tp,"%d",atoi(sp)+1); ! 263: } ! 264: ! 265: ! 266: char * partialno(rev1,rev2,length) ! 267: char * rev1, * rev2; register int length; ! 268: /* Function: Copies length fields of revision number rev2 into rev1. ! 269: * returns rev1. ! 270: */ ! 271: { register char * r1,* r2; ! 272: ! 273: r1=rev1; r2=rev2; ! 274: while (length) { ! 275: while(*r2 != '.' && *r2!='\0') *r1++ = *r2++; ! 276: *r1++ = *r2++; ! 277: length--; ! 278: } ! 279: /* eliminate last '.'*/ ! 280: *(r1-1)='\0'; ! 281: return rev1; ! 282: } ! 283: ! 284: ! 285: ! 286: char * getancestor(r1, r2, r3) ! 287: char * r1, *r2, *r3; ! 288: /* function: finds the common ancestor of r1 and r2 and ! 289: * places it into r3. ! 290: * returns r3 if successful, false otherwise. ! 291: * works reliably only if r1 and r2 are not branch numbers. ! 292: */ ! 293: { int l1, l2, l3; ! 294: char t1[revlength], t2[revlength]; ! 295: ! 296: l1=countnumflds(r1); l2=countnumflds(r2); ! 297: if ((l1<=2 && l2<=2)||(cmpnum(r1,r2)==0)) { ! 298: /* on main trunk or identical */ ! 299: error("Common ancestor of %s and %s undefined.", r1, r2); ! 300: return false; ! 301: } ! 302: ! 303: l3=0; ! 304: while ((cmpnumfld(r1, r2, l3+1)==0) && (cmpnumfld(r1, r2, l3+2)==0)){ ! 305: l3=l3+2; ! 306: } ! 307: /* This will terminate since r1 and r2 are not the same; see above*/ ! 308: if (l3==0) { ! 309: /* no common prefix. Common ancestor on main trunk. */ ! 310: VOID partialno(t1,r1,l1>2?2:l1); VOID partialno(t2,r2,l2>2?2:l2); ! 311: if (cmpnum(t1,t2)<0) ! 312: VOID strcpy(r3,t1); ! 313: else VOID strcpy(r3,t2); ! 314: if ((cmpnum(r3,r1)==0)||(cmpnum(r3,r2)==0)) { ! 315: error("Ancestor for %s and %s undefined.",r1,r2); ! 316: return false; ! 317: } ! 318: return r3; ! 319: } else { ! 320: if (cmpnumfld(r1,r2,l3+1)==0) { ! 321: error("Ancestor for %s and %s undefined.",r1,r2); ! 322: return false; ! 323: } ! 324: return(partialno(r3,r1,l3)); ! 325: } ! 326: } ! 327: ! 328: ! 329: ! 330: ! 331: struct hshentry * genrevs(revno,date,author,state,store) ! 332: char * revno, * date, * author, * state; ! 333: struct hshentry * * store; ! 334: /* Function: finds the deltas needed for reconstructing the ! 335: * revision given by revno, date, author, and state, and stores pointers ! 336: * to these deltas into an array whose starting address is given by store. ! 337: * The last pointer stored is nil. The last delta (target delta) is returned. ! 338: * If the proper delta could not be found, nil is returned. ! 339: */ ! 340: { ! 341: int length; ! 342: register struct hshentry * next; ! 343: int result; ! 344: char * branchnum; ! 345: char t[revlength]; ! 346: ! 347: if (Head == nil) { ! 348: error("RCSfile empty."); ! 349: return nil; ! 350: } ! 351: ! 352: length = countnumflds(revno); ! 353: next=Head; ! 354: ! 355: if (length >= 1) { ! 356: /* at least one field; find branch exactly */ ! 357: while ((next!=nil) && ! 358: ((result=cmpnumfld(revno,next->num,1))<0)) { ! 359: /*puts(next->num);*/ ! 360: *store++ = next; ! 361: next = next->next; ! 362: } ! 363: ! 364: if (next==nil) {error("Branch number %s too low.",partialno(t,revno,1));return nil;} ! 365: if (result>0) {error("Branch number %s not present.",partialno(t,revno,1));return nil;} ! 366: } ! 367: if (length<=1){ ! 368: /* pick latest one on given branch */ ! 369: branchnum = next->num; /* works even for empty revno*/ ! 370: while ((next!=nil) && ! 371: (cmpnumfld(branchnum,next->num,1)==0) && ! 372: !( ! 373: (date==nil?1:(cmpnum(date,next->date)>=0)) && ! 374: (author==nil?1:(strcmp(author,next->author)==0)) && ! 375: (state ==nil?1:(strcmp(state, next->state) ==0)) ! 376: ) ! 377: ) ! 378: { /*puts(next->num);*/ ! 379: *store ++ = next; ! 380: next=next->next; ! 381: } ! 382: if ((next==nil) || ! 383: (cmpnumfld(branchnum,next->num,1)!=0))/*overshot*/ { ! 384: error("Cannot find revision on branch %s with a date before %s, author %s, and state %s.", ! 385: length==0?partialno(t,branchnum,1):revno,date==nil?"<now>":date, ! 386: author==nil?"<any>":author, state==nil?"<any>":state); ! 387: return nil; ! 388: } else { ! 389: /*puts(next->num);*/ ! 390: *store++ = next; ! 391: } ! 392: *store = nil; ! 393: return next; ! 394: } ! 395: ! 396: /* length >=2 */ ! 397: /* find revision; may go low if length==2*/ ! 398: while ((next!=nil) && ! 399: ((result =cmpnumfld(revno,next->num,2)) <0) && ! 400: (cmpnumfld(revno,next->num,1)==0) ) { ! 401: /*puts(next->num);*/ ! 402: *store++ = next; ! 403: next = next->next; ! 404: } ! 405: ! 406: if ((next==nil) || (cmpnumfld(revno,next->num,1)!=0)) { ! 407: error("Revision number %s too low.",partialno(t,revno,2)); ! 408: return nil; ! 409: } ! 410: if ((length>2) && (result!=0)) { ! 411: error("Revision %s not present.",partialno(t,revno,2)); ! 412: return nil; ! 413: } ! 414: ! 415: /* print last one */ ! 416: /*puts(next->num);*/ ! 417: *store++ = next; ! 418: ! 419: if (length>2) ! 420: return genbranch(next,revno,length,date,author,state,store); ! 421: else { /* length == 2*/ ! 422: if ((date!=nil) && (cmpnum(date,next->date)<0)){ ! 423: error("Revision %s has date %s.",next->num, next->date); ! 424: return nil; ! 425: } ! 426: if ((author!=nil)&&(strcmp(author,next->author)!=0)) { ! 427: error("Revision %s has author %s.",next->num,next->author); ! 428: return nil; ! 429: } ! 430: if ((state!=nil)&&(strcmp(state,next->state)!=0)) { ! 431: error("Revision %s has state %s.",next->num, ! 432: next->state==nil?"<empty>":next->state); ! 433: return nil; ! 434: } ! 435: *store=nil; ! 436: return next; ! 437: } ! 438: } ! 439: ! 440: ! 441: ! 442: ! 443: struct hshentry * genbranch(bpoint, revno, length,date,author,state,store) ! 444: struct hshentry * bpoint; ! 445: char * revno; int length; ! 446: char * date, * author, * state; ! 447: struct hshentry ** store; ! 448: /* Function: given a branchpoint, a revision number, date, author, and state, ! 449: * genbranch finds the deltas necessary to reconstruct the given revision ! 450: * from the branch point on. ! 451: * Pointers to the found deltas are stored in an array beginning with store. ! 452: * revno must be on a side branch. ! 453: * return nil on error ! 454: */ ! 455: { ! 456: int field; ! 457: register struct hshentry * next, * trail; ! 458: register struct branchhead * bhead; ! 459: int result; ! 460: char t[revlength]; ! 461: ! 462: bhead = bpoint->branches; ! 463: ! 464: for (field=3; field<=length; field=field+2) { ! 465: ! 466: if (bhead==nil) {error("No side branches present for %s.",partialno(t,revno,field-1));return nil;} ! 467: ! 468: /*find branch head*/ ! 469: /*branches are arranged in increasing order*/ ! 470: while ((bhead!=nil) && ! 471: ((result=cmpnumfld(revno,bhead->hsh->num,field))>0)) { ! 472: bhead = bhead->nextbranch; ! 473: } ! 474: ! 475: if (bhead==nil) {error("Branch number %s too high.",partialno(t,revno,field));return nil;} ! 476: if (result<0) {error("Branch number %s not present.",partialno(t,revno,field));return nil;} ! 477: ! 478: next = bhead->hsh; ! 479: if (length==field) { ! 480: /* pick latest one on that branch */ ! 481: trail=nil; ! 482: do { if ((date==nil?1:(cmpnum(date,next->date)>=0)) && ! 483: (author==nil?1:(strcmp(author,next->author)==0)) && ! 484: (state ==nil?1:(strcmp(state, next->state) ==0)) ! 485: ) trail = next; ! 486: next=next->next; ! 487: } while (next!=nil); ! 488: ! 489: if (trail==nil) { ! 490: error("Cannot find revision on branch %s with a date before %s, author %s, and state %s.", ! 491: revno, date==nil?"<now>":date, ! 492: author==nil?"<any>":author, state==nil?"<any>":state); ! 493: return nil; ! 494: } else { /* print up to last one suitable */ ! 495: next = bhead->hsh; ! 496: while (next!=trail) { ! 497: /*puts(next->num);*/ ! 498: *store++ = next; ! 499: next=next->next; ! 500: } ! 501: /*puts(next->num);*/ ! 502: *store++ = next; ! 503: } ! 504: *store = nil; ! 505: return next; ! 506: } ! 507: ! 508: /* length > field */ ! 509: /* find revision */ ! 510: /* check low */ ! 511: if (cmpnumfld(revno,next->num,field+1)<0) { ! 512: error("Revision number %s too low.",partialno(t,revno,field+1)); ! 513: return(nil); ! 514: } ! 515: do { /*puts(next->num);*/ ! 516: *store++ = next; ! 517: trail = next; ! 518: next = next->next; ! 519: } while ((next!=nil) && ! 520: (cmpnumfld(revno,next->num,field+1) >=0)); ! 521: ! 522: if ((length>field+1) && /*need exact hit */ ! 523: (cmpnumfld(revno,trail->num,field+1) !=0)){ ! 524: error("Revision %s not present.",partialno(t,revno,field+1)); ! 525: return(nil); ! 526: } ! 527: if (length == field+1) { ! 528: if ((date!=nil) && (cmpnum(date,trail->date)<0)){ ! 529: error("Revision %s has date %s.",trail->num, trail->date); ! 530: return nil; ! 531: } ! 532: if ((author!=nil)&&(strcmp(author,trail->author)!=0)) { ! 533: error("Revision %s has author %s.",trail->num,trail->author); ! 534: return nil; ! 535: } ! 536: if ((state!=nil)&&(strcmp(state,trail->state)!=0)) { ! 537: error("Revision %s has state %s.",trail->num, ! 538: trail->state==nil?"<empty>":trail->state); ! 539: return nil; ! 540: } ! 541: } ! 542: bhead = trail->branches; ! 543: ! 544: } ! 545: * store = nil; ! 546: return trail; ! 547: } ! 548: ! 549: ! 550: char * lookupsym(id) ! 551: char * id; ! 552: /* Function: looks up id in the list of symbolic names starting ! 553: * with pointer SYMBOLS, and returns a pointer to the corresponding ! 554: * revision number. Returns nil if not present. ! 555: */ ! 556: { ! 557: register struct assoc * next; ! 558: next = Symbols; ! 559: while (next!=nil) { ! 560: if (strcmp(id, next->symbol)==0) ! 561: return(next->delta->num); ! 562: else next=next->nextassoc; ! 563: } ! 564: return nil; ! 565: } ! 566: ! 567: int expandsym(source, target) ! 568: char * source, * target; ! 569: /* Function: Source points to a revision number. Expandsym copies ! 570: * the number to target, but replaces all symbolic fields in the ! 571: * source number with their numeric values. ! 572: * A trailing '.' is omitted; leading zeroes are compressed. ! 573: * returns false on error; ! 574: */ ! 575: { register char * sp, * tp, *bp; ! 576: char symbuf[30]; ! 577: register enum tokens d; ! 578: ! 579: sp = source; tp=target; ! 580: if (sp == nil) { /*accept nil pointer as a legal value*/ ! 581: *tp='\0'; ! 582: return true; ! 583: } ! 584: ! 585: while (*sp != '\0') { ! 586: if (ctab[*sp] == DIGIT) { ! 587: if (*sp=='0') { ! 588: /* skip leading zeroes */ ! 589: sp++; ! 590: while(*sp == '0') sp++; ! 591: if (*sp=='\0' || *sp=='.') *tp++ = '0'; /*single zero*/ ! 592: } ! 593: while(ctab[*sp] == DIGIT) *tp++ = *sp++; ! 594: if ((*sp == '\0') || ((*sp=='.')&&(*(sp+1)=='\0'))) { ! 595: *tp='\0'; return true; ! 596: } ! 597: if (*sp == '.') *tp++ = *sp++; ! 598: else { ! 599: error("Improper revision number: %s",source); ! 600: *tp = '\0'; ! 601: return false; ! 602: } ! 603: } elsif (ctab[*sp] == LETTER) { ! 604: bp = symbuf; ! 605: do { *bp++ = *sp++; ! 606: } while(((d=ctab[*sp])==LETTER) || (d==DIGIT) || ! 607: (d==IDCHAR)); ! 608: *bp= '\0'; ! 609: bp=lookupsym(symbuf); ! 610: if (bp==nil) { ! 611: error("Symbolic number %s is undefined.",symbuf); ! 612: *tp='\0'; ! 613: return false; ! 614: } else { /* copy number */ ! 615: while (*tp++ = *bp++); /* copies the trailing \0*/ ! 616: } ! 617: if ((*sp == '\0') || ((*sp=='.')&&(*(sp+1)=='\0'))) ! 618: return true; ! 619: if (*sp == '.') { ! 620: *(tp-1) = *sp++; ! 621: } else { ! 622: error("Improper revision number: %s",source); ! 623: return false; ! 624: } ! 625: }else { ! 626: error("Improper revision number: %s", source); ! 627: *tp = '\0'; ! 628: return false; ! 629: } ! 630: } ! 631: *tp = '\0'; ! 632: return true; ! 633: } ! 634: ! 635: ! 636: ! 637: #ifdef REVTEST ! 638: ! 639: main(argc,argv) ! 640: int argc; char * argv[]; ! 641: { ! 642: char symrevno[revlength]; /* used for input of revision numbers */ ! 643: char numricrevno[revlength]; ! 644: char author[20]; ! 645: char state[20]; ! 646: char date[20]; ! 647: struct hshentry * gendeltas[hshsize/2]; ! 648: struct hshentry * target; ! 649: int i; ! 650: ! 651: cmdid = "revtest"; ! 652: if (argc<2) { ! 653: VOID fputs("No input file\n",stderr); ! 654: exit(-1); ! 655: } ! 656: if ((finptr=fopen(argv[1], "r")) == NULL) { ! 657: faterror("Can't open input file %s\n",argv[1]); ! 658: } ! 659: Lexinit(); ! 660: getadmin(); ! 661: ! 662: gettree(); ! 663: ! 664: getdesc(false); ! 665: ! 666: do { ! 667: /* all output goes to stderr, to have diagnostics and */ ! 668: /* errors in sequence. */ ! 669: VOID fprintf(stderr,"\nEnter revision number or <return> or '.': "); ! 670: if(gets(symrevno)==NULL) break; ! 671: if (*symrevno == '.') break; ! 672: VOID fprintf(stderr,"%s;\n",symrevno); ! 673: expandsym(symrevno,numricrevno); ! 674: VOID fprintf(stderr,"expanded number: %s; ",numricrevno); ! 675: VOID fprintf(stderr,"Date: "); ! 676: gets(date); VOID fprintf(stderr,"%s; ",date); ! 677: VOID fprintf(stderr,"Author: "); ! 678: gets(author);VOID fprintf(stderr,"%s; ",author); ! 679: VOID fprintf(stderr,"State: "); ! 680: gets(state); VOID fprintf(stderr, "%s;\n", state); ! 681: target=genrevs(numricrevno,*date=='\0'?(char *)nil:date, *author=='\0'?(char *)nil:author, ! 682: *state=='\0'?(char *)nil:state,gendeltas); ! 683: if (target!=nil) { ! 684: i=0; ! 685: while (gendeltas[i]!=nil) { ! 686: VOID fprintf(stderr,"%s\n",gendeltas[i++]->num); ! 687: } ! 688: } ! 689: } while (true); ! 690: VOID fprintf(stderr,"done\n"); ! 691: ! 692: } ! 693: ! 694: cleanup(){} ! 695: /*dummy*/ ! 696: ! 697: #endif REVTEST
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.