![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to co.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 co.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / rcs / src |
1.1 ! root 1: /* ! 2: * RCS checkout operation ! 3: */ ! 4: #ifndef lint ! 5: static char rcsid[]= ! 6: "$Header: /usr/src/local/bin/rcs/src/RCS/co.c,v 4.5 87/12/18 11:35:40 narten Exp $ Purdue CS"; ! 7: #endif ! 8: /***************************************************************************** ! 9: * check out revisions from RCS files ! 10: ***************************************************************************** ! 11: * ! 12: * Copyright (C) 1982 by Walter F. 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: co.c,v $ ! 25: * Revision 4.5 87/12/18 11:35:40 narten ! 26: * lint cleanups (from Guy Harris) ! 27: * ! 28: * Revision 4.4 87/10/18 10:20:53 narten ! 29: * Updating version numbers changes relative to 1.1, are actually ! 30: * relative to 4.2 ! 31: * ! 32: * Revision 1.3 87/09/24 13:58:30 narten ! 33: * Sources now pass through lint (if you ignore printf/sprintf/fprintf ! 34: * warnings) ! 35: * ! 36: * Revision 1.2 87/03/27 14:21:38 jenkins ! 37: * Port to suns ! 38: * ! 39: * Revision 1.1 84/01/23 14:49:58 kcs ! 40: * Initial revision ! 41: * ! 42: * Revision 4.2 83/12/05 13:39:48 wft ! 43: * made rewriteflag external. ! 44: * ! 45: * Revision 4.1 83/05/10 16:52:55 wft ! 46: * Added option -u and -f. ! 47: * Added handling of default branch. ! 48: * Replaced getpwuid() with getcaller(). ! 49: * Removed calls to stat(); now done by pairfilenames(). ! 50: * Changed and renamed rmoldfile() to rmworkfile(). ! 51: * Replaced catchints() calls with restoreints(), unlink()--link() with rename(); ! 52: * ! 53: * Revision 3.7 83/02/15 15:27:07 wft ! 54: * Added call to fastcopy() to copy remainder of RCS file. ! 55: * ! 56: * Revision 3.6 83/01/15 14:37:50 wft ! 57: * Added ignoring of interrupts while RCS file is renamed; this avoids ! 58: * deletion of RCS files during the unlink/link window. ! 59: * ! 60: * Revision 3.5 82/12/08 21:40:11 wft ! 61: * changed processing of -d to use DATEFORM; removed actual from ! 62: * call to preparejoin; re-fixed printing of done at the end. ! 63: * ! 64: * Revision 3.4 82/12/04 18:40:00 wft ! 65: * Replaced getdelta() with gettree(), SNOOPDIR with SNOOPFILE. ! 66: * Fixed printing of "done". ! 67: * ! 68: * Revision 3.3 82/11/28 22:23:11 wft ! 69: * Replaced getlogin() with getpwuid(), flcose() with ffclose(), ! 70: * %02d with %.2d, mode generation for working file with WORKMODE. ! 71: * Fixed nil printing. Fixed -j combined with -l and -p, and exit ! 72: * for non-existing revisions in preparejoin(). ! 73: * ! 74: * Revision 3.2 82/10/18 20:47:21 wft ! 75: * Mode of working file is now maintained even for co -l, but write permission ! 76: * is removed. ! 77: * The working file inherits its mode from the RCS file, plus write permission ! 78: * for the owner. The write permission is not given if locking is strict and ! 79: * co does not lock. ! 80: * An existing working file without write permission is deleted automatically. ! 81: * Otherwise, co asks (empty answer: abort co). ! 82: * Call to getfullRCSname() added, check for write error added, call ! 83: * for getlogin() fixed. ! 84: * ! 85: * Revision 3.1 82/10/13 16:01:30 wft ! 86: * fixed type of variables receiving from getc() (char -> int). ! 87: * removed unused variables. ! 88: */ ! 89: ! 90: ! 91: ! 92: ! 93: #include "rcsbase.h" ! 94: #include "time.h" ! 95: #include <sys/types.h> ! 96: #include <sys/stat.h> ! 97: ! 98: #ifndef lint ! 99: static char rcsbaseid[] = RCSBASE; ! 100: #endif ! 101: ! 102: extern FILE * fopen(); ! 103: extern int rename(); ! 104: extern char * getcaller(); /*get login of caller */ ! 105: extern char * malloc(); ! 106: extern struct hshentry * genrevs(); /*generate delta numbers */ ! 107: extern char * getancestor(); ! 108: extern int nextc; /*next input character */ ! 109: extern int nerror; /*counter for errors */ ! 110: extern char * Kdesc; /*keyword for description */ ! 111: extern char * buildrevision(); /*constructs desired revision */ ! 112: extern int buildjoin(); /*join several revisions */ ! 113: extern char * mktempfile(); /*temporary file name generator */ ! 114: extern struct hshentry * findlock();/*find (and delete) a lock */ ! 115: extern struct lock * addlock(); /*add a new lock */ ! 116: extern long maketime(); /*convert parsed time to unix time. */ ! 117: extern struct tm * localtime(); /*convert unixtime into a tm-structure */ ! 118: extern int StrictLocks; ! 119: extern FILE * finptr; /* RCS input file */ ! 120: extern FILE * frewrite; /* new RCS file */ ! 121: extern int rewriteflag; /* indicates whether input should be */ ! 122: /* echoed to frewrite */ ! 123: ! 124: char * newRCSfilename, * neworkfilename; ! 125: char * RCSfilename, * workfilename; ! 126: extern struct stat RCSstat, workstat; /* file status of RCS and work file */ ! 127: extern int haveRCSstat, haveworkstat;/* status indicators */ ! 128: ! 129: char * date, * rev, * state, * author, * join; ! 130: char finaldate[datelength]; ! 131: ! 132: int forceflag, lockflag, unlockflag, tostdout; ! 133: char * caller; /* caller's login; */ ! 134: extern quietflag; ! 135: ! 136: char numericrev[revlength]; /* holds expanded revision number */ ! 137: struct hshentry * gendeltas[hshsize]; /* stores deltas to be generated */ ! 138: struct hshentry * targetdelta; /* final delta to be generated */ ! 139: ! 140: char * joinlist[joinlength]; /* pointers to revisions to be joined */ ! 141: int lastjoin; /* index of last element in joinlist */ ! 142: ! 143: main (argc, argv) ! 144: int argc; ! 145: char * argv[]; ! 146: { ! 147: int killock; /* indicates whether a lock is removed*/ ! 148: char * cmdusage; ! 149: struct tm parseddate, *ftm; ! 150: char * rawdate; ! 151: long unixtime; ! 152: ! 153: catchints(); ! 154: cmdid = "co"; ! 155: cmdusage = "command format:\nco -f[rev] -l[rev] -p[rev] -q[rev] -r[rev] -ddate -sstate -w[login] -jjoinlist file ..."; ! 156: date = rev = state = author = join = nil; ! 157: forceflag = lockflag = unlockflag = tostdout = quietflag = false; ! 158: caller=getcaller(); ! 159: ! 160: while (--argc,++argv, argc>=1 && ((*argv)[0] == '-')) { ! 161: switch ((*argv)[1]) { ! 162: ! 163: case 'r': ! 164: revno: if ((*argv)[2]!='\0') { ! 165: if (rev!=nil) warn("Redefinition of revision number"); ! 166: rev = (*argv)+2; ! 167: } ! 168: break; ! 169: ! 170: case 'f': ! 171: forceflag=true; ! 172: goto revno; ! 173: ! 174: case 'l': ! 175: lockflag=true; ! 176: if (unlockflag) { ! 177: warn("-l has precedence over -u"); ! 178: unlockflag=false; ! 179: } ! 180: goto revno; ! 181: ! 182: case 'u': ! 183: unlockflag=true; ! 184: if (lockflag) { ! 185: warn("-l has precedence over -u"); ! 186: unlockflag=false; ! 187: } ! 188: goto revno; ! 189: ! 190: case 'p': ! 191: tostdout=true; ! 192: goto revno; ! 193: ! 194: case 'q': ! 195: quietflag=true; ! 196: goto revno; ! 197: ! 198: case 'd': ! 199: if ((*argv)[2]!='\0') { ! 200: if (date!=nil) warn("Redefinition of -d option"); ! 201: rawdate=(*argv)+2; ! 202: } ! 203: /* process date/time */ ! 204: if (partime(rawdate,&parseddate)==0) ! 205: faterror("Can't parse date/time: %s",rawdate); ! 206: if ((unixtime=maketime(&parseddate))== 0L) ! 207: faterror("Inconsistent date/time: %s",rawdate); ! 208: ftm=localtime(&unixtime); ! 209: VOID sprintf(finaldate,DATEFORM, ! 210: ftm->tm_year,ftm->tm_mon+1,ftm->tm_mday,ftm->tm_hour,ftm->tm_min,ftm->tm_sec); ! 211: date=finaldate; ! 212: break; ! 213: ! 214: case 'j': ! 215: if ((*argv)[2]!='\0'){ ! 216: if (join!=nil)warn("Redefinition of -j option"); ! 217: join = (*argv)+2; ! 218: } ! 219: break; ! 220: ! 221: case 's': ! 222: if ((*argv)[2]!='\0'){ ! 223: if (state!=nil)warn("Redefinition of -s option"); ! 224: state = (*argv)+2; ! 225: } ! 226: break; ! 227: ! 228: case 'w': ! 229: if (author!=nil)warn("Redefinition of -w option"); ! 230: if ((*argv)[2]!='\0') ! 231: author = (*argv)+2; ! 232: else author = caller; ! 233: break; ! 234: ! 235: default: ! 236: faterror("unknown option: %s\n%s", *argv,cmdusage); ! 237: ! 238: }; ! 239: } /* end of option processing */ ! 240: ! 241: if (argc<1) faterror("No input file\n%s",cmdusage); ! 242: ! 243: /* now handle all filenames */ ! 244: do { ! 245: rewriteflag=false; ! 246: finptr=frewrite=NULL; ! 247: neworkfilename=nil; ! 248: ! 249: if (!pairfilenames(argc,argv,true,tostdout)) continue; ! 250: ! 251: /* now RCSfilename contains the name of the RCS file, and finptr ! 252: * the file descriptor. If tostdout is false, workfilename contains ! 253: * the name of the working file, otherwise undefined (not nil!). ! 254: * Also, RCSstat, workstat, and haveworkstat have been set. ! 255: */ ! 256: diagnose("%s --> %s", RCSfilename,tostdout?"stdout":workfilename); ! 257: ! 258: ! 259: if (!tostdout && !trydiraccess(workfilename)) continue; /* give up */ ! 260: if ((lockflag||unlockflag) && !checkaccesslist(caller)) continue; /* give up */ ! 261: if (!trysema(RCSfilename,lockflag||unlockflag)) continue; /* give up */ ! 262: ! 263: ! 264: gettree(); /* reads in the delta tree */ ! 265: ! 266: if (Head==nil) { ! 267: /* no revisions; create empty file */ ! 268: diagnose("no revisions present; generating empty revision 0.0"); ! 269: if (!tostdout) ! 270: if (!creatempty()) continue; ! 271: else VOID putchar('\0'); /* end of file */ ! 272: /* Can't reserve a delta, so don't call addlock */ ! 273: } else { ! 274: if (rev!=nil) { ! 275: /* expand symbolic revision number */ ! 276: if (!expandsym(rev,numericrev)) ! 277: continue; ! 278: } elsif (unlockflag && (targetdelta=findlock(caller,false))!=nil) { ! 279: VOID strcpy(numericrev,targetdelta->num); ! 280: } elsif (Dbranch!=nil) { ! 281: VOID strcpy(numericrev,Dbranch->num); ! 282: } else numericrev[0]='\0'; /* empty */ ! 283: /* get numbers of deltas to be generated */ ! 284: if (!(targetdelta=genrevs(numericrev,date,author,state,gendeltas))) ! 285: continue; ! 286: /* check reservations */ ! 287: if (lockflag && !addlock(targetdelta,caller)) ! 288: continue; ! 289: ! 290: if (unlockflag) { ! 291: if((killock=rmlock(caller,targetdelta))== -1) ! 292: continue; ! 293: } else { ! 294: killock=0; ! 295: } ! 296: ! 297: if (join && !preparejoin()) continue; ! 298: ! 299: diagnose("revision %s %s",targetdelta->num, ! 300: lockflag?"(locked)": ! 301: (unlockflag?"(unlocked)":"")); ! 302: ! 303: /* remove old working file if necessary */ ! 304: if (!tostdout) ! 305: if (!rmworkfile()) continue; ! 306: ! 307: /* prepare for rewriting the RCS file */ ! 308: if (lockflag||(killock==1)) { ! 309: newRCSfilename=mktempfile(RCSfilename,NEWRCSFILE); ! 310: if ((frewrite=fopen(newRCSfilename, "w"))==NULL) { ! 311: error("Can't open file %s",newRCSfilename); ! 312: continue; ! 313: } ! 314: putadmin(frewrite); ! 315: puttree(Head,frewrite); ! 316: VOID fprintf(frewrite, "\n\n%s%c",Kdesc,nextc); ! 317: rewriteflag=true; ! 318: } ! 319: ! 320: /* skip description */ ! 321: getdesc(false); /* don't echo*/ ! 322: ! 323: if (!(neworkfilename=buildrevision(gendeltas,targetdelta, ! 324: tostdout?(join!=nil?"/tmp/":(char *)nil):workfilename,true))) ! 325: continue; ! 326: ! 327: if ((lockflag||killock==1)&&nerror==0) { ! 328: /* rewrite the rest of the RCSfile */ ! 329: fastcopy(finptr,frewrite); ! 330: ffclose(frewrite); frewrite=NULL; ! 331: ignoreints(); ! 332: if (rename(newRCSfilename,RCSfilename)<0) { ! 333: error("Can't rewrite %s; saved in: %s", ! 334: RCSfilename, newRCSfilename); ! 335: newRCSfilename[0]='\0'; /* avoid deletion*/ ! 336: restoreints(); ! 337: break; ! 338: } ! 339: newRCSfilename[0]='\0'; /* avoid re-deletion by cleanup()*/ ! 340: if (chmod(RCSfilename,RCSstat.st_mode & ~0222)<0) ! 341: warn("Can't preserve mode of %s",RCSfilename); ! 342: restoreints(); ! 343: } ! 344: ! 345: # ifdef SNOOPFILE ! 346: logcommand("co",targetdelta,gendeltas,caller); ! 347: # endif ! 348: ! 349: if (join) { ! 350: VOID rmsema(); /* kill semaphore file so other co's can proceed */ ! 351: if (!buildjoin(neworkfilename,tostdout)) continue; ! 352: } ! 353: if (!tostdout) { ! 354: if (rename(neworkfilename,workfilename) <0) { ! 355: error("Can't create %s; see %s",workfilename,neworkfilename); ! 356: neworkfilename[0]= '\0'; /*avoid deletion*/ ! 357: continue; ! 358: } ! 359: neworkfilename[0]= '\0'; /*avoid re-deletion by cleanup()*/ ! 360: } ! 361: } ! 362: if (!tostdout) ! 363: if (chmod(workfilename, WORKMODE(RCSstat.st_mode))<0) ! 364: warn("Can't adjust mode of %s",workfilename); ! 365: ! 366: ! 367: if (!tostdout) diagnose("done"); ! 368: } while (cleanup(), ! 369: ++argv, --argc >=1); ! 370: ! 371: exit(nerror!=0); ! 372: ! 373: } /* end of main (co) */ ! 374: ! 375: ! 376: /***************************************************************** ! 377: * The following routines are auxiliary routines ! 378: *****************************************************************/ ! 379: ! 380: int rmworkfile() ! 381: /* Function: unlinks workfilename, if it exists, under the following conditions: ! 382: * If it is read-only, workfilename is unlinked. ! 383: * Otherwise (file writable): ! 384: * if !quietmode asks the user whether to really delete it (default: fail); ! 385: * otherwise failure. ! 386: * Returns false on failure to unlink, true otherwise. ! 387: */ ! 388: { ! 389: int response, c; /* holds user response to queries */ ! 390: ! 391: if (haveworkstat< 0) /* File doesn't exist; set by pairfilenames*/ ! 392: return (true); /* No problem */ ! 393: ! 394: if ((workstat.st_mode & 0222)&&!forceflag) { /* File is writable */ ! 395: if (!quietflag) { ! 396: VOID fprintf(stderr,"writable %s exists; overwrite? [ny](n): ",workfilename); ! 397: /* must be stderr in case of IO redirect */ ! 398: c=response=getchar(); ! 399: while (!(c==EOF || c=='\n')) c=getchar(); /*skip rest*/ ! 400: if (!(response=='y'||response=='Y')) { ! 401: warn("checkout aborted."); ! 402: return false; ! 403: } ! 404: } else { ! 405: error("writable %s exists; checkout aborted.",workfilename); ! 406: return false; ! 407: } ! 408: } ! 409: /* now unlink: either not writable, forceflag, or permission given */ ! 410: if (unlink(workfilename) != 0) { /* Remove failed */ ! 411: error("Can't unlink %s",workfilename); ! 412: return false; ! 413: } ! 414: return true; ! 415: } ! 416: ! 417: ! 418: creatempty() ! 419: /* Function: creates an empty working file. ! 420: * First, removes an existing working file with rmworkfile(). ! 421: */ ! 422: { ! 423: int fdesc; /* file descriptor */ ! 424: ! 425: if (!rmworkfile()) return false; ! 426: fdesc=creat(workfilename,0666); ! 427: if (fdesc < 0) { ! 428: faterror("Cannot create %s",workfilename); ! 429: return false; ! 430: } else { ! 431: VOID close(fdesc); /* empty file */ ! 432: return true; ! 433: } ! 434: } ! 435: ! 436: ! 437: int rmlock(who,delta) ! 438: char * who; struct hshentry * delta; ! 439: /* Function: removes the lock held by who on delta. ! 440: * Returns -1 if someone else holds the lock, ! 441: * 0 if there is no lock on delta, ! 442: * and 1 if a lock was found and removed. ! 443: */ ! 444: { register struct lock * next, * trail; ! 445: char * num; ! 446: struct lock dummy; ! 447: int whomatch, nummatch; ! 448: ! 449: num=delta->num; ! 450: dummy.nextlock=next=Locks; ! 451: trail = &dummy; ! 452: while (next!=nil) { ! 453: whomatch=strcmp(who,next->login); ! 454: nummatch=strcmp(num,next->delta->num); ! 455: if ((whomatch==0) && (nummatch==0)) break; ! 456: /*found a lock on delta by who*/ ! 457: if ((whomatch!=0)&&(nummatch==0)) { ! 458: error("revision %s locked by %s; use co -r or rcs -u",num,next->login); ! 459: return -1; ! 460: } ! 461: trail=next; ! 462: next=next->nextlock; ! 463: } ! 464: if (next!=nil) { ! 465: /*found one; delete it */ ! 466: trail->nextlock=next->nextlock; ! 467: Locks=dummy.nextlock; ! 468: next->delta->lockedby=nil; /* reset locked-by */ ! 469: return 1; /*success*/ ! 470: } else return 0; /*no lock on delta*/ ! 471: } ! 472: ! 473: ! 474: ! 475: ! 476: /***************************************************************** ! 477: * The rest of the routines are for handling joins ! 478: *****************************************************************/ ! 479: ! 480: char * getrev(sp, tp, buffsize) ! 481: register char * sp, *tp; int buffsize; ! 482: /* Function: copies a symbolic revision number from sp to tp, ! 483: * appends a '\0', and returns a pointer to the character following ! 484: * the revision number; returns nil if the revision number is more than ! 485: * buffsize characters long. ! 486: * The revision number is terminated by space, tab, comma, colon, ! 487: * semicolon, newline, or '\0'. ! 488: * used for parsing the -j option. ! 489: */ ! 490: { ! 491: register char c; ! 492: register int length; ! 493: ! 494: length = 0; ! 495: while (((c= *sp)!=' ')&&(c!='\t')&&(c!='\n')&&(c!=':')&&(c!=',') ! 496: &&(c!=';')&&(c!='\0')) { ! 497: if (length>=buffsize) return false; ! 498: *tp++= *sp++; ! 499: length++; ! 500: } ! 501: *tp= '\0'; ! 502: return sp; ! 503: } ! 504: ! 505: ! 506: ! 507: int preparejoin() ! 508: /* Function: Parses a join list pointed to by join and places pointers to the ! 509: * revision numbers into joinlist. ! 510: */ ! 511: { ! 512: struct hshentry * (* joindeltas)[]; ! 513: struct hshentry * tmpdelta; ! 514: register char * j; ! 515: char symbolrev[revlength],numrev[revlength]; ! 516: ! 517: joindeltas = (struct hshentry * (*)[])malloc(hshsize*sizeof(struct hshentry *)); ! 518: j=join; ! 519: lastjoin= -1; ! 520: for (;;) { ! 521: while ((*j==' ')||(*j=='\t')||(*j==',')) j++; ! 522: if (*j=='\0') break; ! 523: if (lastjoin>=joinlength-2) { ! 524: error("too many joins"); ! 525: return(false); ! 526: } ! 527: if(!(j=getrev(j,symbolrev,revlength))) return false; ! 528: if (!expandsym(symbolrev,numrev)) return false; ! 529: tmpdelta=genrevs(numrev,(char *)nil,(char *)nil,(char *)nil,(struct hshentry * *)joindeltas); ! 530: if (tmpdelta==nil) ! 531: return false; ! 532: else joinlist[++lastjoin]=tmpdelta->num; ! 533: while ((*j==' ') || (*j=='\t')) j++; ! 534: if (*j == ':') { ! 535: j++; ! 536: while((*j==' ') || (*j=='\t')) j++; ! 537: if (*j!='\0') { ! 538: if(!(j=getrev(j,symbolrev,revlength))) return false; ! 539: if (!expandsym(symbolrev,numrev)) return false; ! 540: tmpdelta=genrevs(numrev,(char *)nil,(char *)nil,(char *)nil, (struct hshentry * *) joindeltas); ! 541: if (tmpdelta==nil) ! 542: return false; ! 543: else joinlist[++lastjoin]=tmpdelta->num; ! 544: } else { ! 545: error("join pair incomplete"); ! 546: return false; ! 547: } ! 548: } else { ! 549: if (lastjoin==0) { /* first pair */ ! 550: /* common ancestor missing */ ! 551: joinlist[1]=joinlist[0]; ! 552: lastjoin=1; ! 553: /*derive common ancestor*/ ! 554: joinlist[0]=malloc(revlength); ! 555: if (!getancestor(targetdelta->num,joinlist[1],joinlist[0])) ! 556: return false; ! 557: } else { ! 558: error("join pair incomplete"); ! 559: return false; ! 560: } ! 561: } ! 562: } ! 563: if (lastjoin<1) { ! 564: error("empty join"); ! 565: return false; ! 566: } else return true; ! 567: } ! 568: ! 569: ! 570: ! 571: buildjoin(initialfile, tostdout) ! 572: char * initialfile; int tostdout; ! 573: /* Function: merge pairs of elements in joinlist into initialfile ! 574: * If tostdout==true, copy result to stdout. ! 575: * All unlinking of initialfile, rev2, and rev3 should be done by cleanup(). ! 576: */ ! 577: { char command[NCPPN+80]; ! 578: char subs[revlength]; ! 579: char * rev2, * rev3; ! 580: int i; ! 581: ! 582: rev2=mktempfile("/tmp/",JOINFIL2); ! 583: rev3=mktempfile("/tmp/",JOINFIL3); ! 584: ! 585: i=0; ! 586: while (i<lastjoin) { ! 587: /*prepare marker for merge*/ ! 588: if (i==0) ! 589: VOID strcpy(subs,targetdelta->num); ! 590: else VOID sprintf(subs, "merge%d",i/2); ! 591: diagnose("revision %s",joinlist[i]); ! 592: VOID sprintf(command,"%s/co -p%s -q %s > %s\n",TARGETDIR,joinlist[i],RCSfilename,rev2); ! 593: if (system(command)) { ! 594: nerror++;return false; ! 595: } ! 596: diagnose("revision %s",joinlist[i+1]); ! 597: VOID sprintf(command,"%s/co -p%s -q %s > %s\n",TARGETDIR,joinlist[i+1],RCSfilename,rev3); ! 598: if (system(command)) { ! 599: nerror++; return false; ! 600: } ! 601: diagnose("merging..."); ! 602: VOID sprintf(command,"%s %s%s %s %s %s %s\n", MERGE, ! 603: ((i+2)>=lastjoin && tostdout)?"-p ":"", ! 604: initialfile,rev2,rev3,subs,joinlist[i+1]); ! 605: if (system(command)) { ! 606: nerror++; return false; ! 607: } ! 608: i=i+2; ! 609: } ! 610: return true; ! 611: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.