![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ci.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 ci.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / rcs / src |
1.1 ! root 1: /* ! 2: * RCS checkin operation ! 3: */ ! 4: #ifndef lint ! 5: static char rcsid[]= ! 6: "$Header: /usr/src/local/bin/rcs/src/RCS/ci.c,v 4.6 87/12/18 11:34:41 narten Exp $ Purdue CS"; ! 7: #endif ! 8: /******************************************************************* ! 9: * check revisions into 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: ! 25: /* $Log: ci.c,v $ ! 26: * Revision 4.6 87/12/18 11:34:41 narten ! 27: * lint cleanups (from Guy Harris) ! 28: * ! 29: * Revision 4.5 87/10/18 10:18:48 narten ! 30: * Updating version numbers. Changes relative to revision 1.1 are actually ! 31: * relative to 4.3 ! 32: * ! 33: * Revision 1.3 87/09/24 13:57:19 narten ! 34: * Sources now pass through lint (if you ignore printf/sprintf/fprintf ! 35: * warnings) ! 36: * ! 37: * Revision 1.2 87/03/27 14:21:33 jenkins ! 38: * Port to suns ! 39: * ! 40: * Revision 1.1 84/01/23 14:49:54 kcs ! 41: * Initial revision ! 42: * ! 43: * Revision 4.3 83/12/15 12:28:54 wft ! 44: * ci -u and ci -l now set mode of working file properly. ! 45: * ! 46: * Revision 4.2 83/12/05 13:40:54 wft ! 47: * Merged with 3.9.1.1: added calls to clearerr(stdin). ! 48: * made rewriteflag external. ! 49: * ! 50: * Revision 4.1 83/05/10 17:03:06 wft ! 51: * Added option -d and -w, and updated assingment of date, etc. to new delta. ! 52: * Added handling of default branches. ! 53: * Option -k generates std. log message; fixed undef. pointer in reading of log. ! 54: * Replaced getlock() with findlock(), link--unlink with rename(), ! 55: * getpwuid() with getcaller(). ! 56: * Moved all revision number generation to new routine addelta(). ! 57: * Removed calls to stat(); now done by pairfilenames(). ! 58: * Changed most calls to catchints() with restoreints(). ! 59: * Directed all interactive messages to stderr. ! 60: * ! 61: * Revision 3.9.1.1 83/10/19 04:21:03 lepreau ! 62: * Added clearerr(stdin) to getlogmsg() for re-reading stdin. ! 63: * ! 64: * Revision 3.9 83/02/15 15:25:44 wft ! 65: * 4.2 prerelease ! 66: * ! 67: * Revision 3.9 83/02/15 15:25:44 wft ! 68: * Added call to fastcopy() to copy remainder of RCS file. ! 69: * ! 70: * Revision 3.8 83/01/14 15:34:05 wft ! 71: * Added ignoring of interrupts while new RCS file is renamed; ! 72: * Avoids deletion of RCS files by interrupts. ! 73: * ! 74: * Revision 3.7 82/12/10 16:09:20 wft ! 75: * Corrected checking of return code from diff. ! 76: * ! 77: * Revision 3.6 82/12/08 21:34:49 wft ! 78: * Using DATEFORM to prepare date of checked-in revision; ! 79: * Fixed return from addbranch(). ! 80: * ! 81: * Revision 3.5 82/12/04 18:32:42 wft ! 82: * Replaced getdelta() with gettree(), SNOOPDIR with SNOOPFILE. Updated ! 83: * field lockedby in removelock(), moved getlogmsg() before calling diff. ! 84: * ! 85: * Revision 3.4 82/12/02 13:27:13 wft ! 86: * added option -k. ! 87: * ! 88: * Revision 3.3 82/11/28 20:53:31 wft ! 89: * Added mustcheckin() to check for redundant checkins. ! 90: * Added xpandfile() to do keyword expansion for -u and -l; ! 91: * -m appends linefeed to log message if necessary. ! 92: * getlogmsg() suppresses prompt if stdin is not a terminal. ! 93: * Replaced keeplock with lockflag, fclose() with ffclose(), ! 94: * %02d with %.2d, getlogin() with getpwuid(). ! 95: * ! 96: * Revision 3.2 82/10/18 20:57:23 wft ! 97: * An RCS file inherits its mode during the first ci from the working file, ! 98: * otherwise it stays the same, except that write permission is removed. ! 99: * Fixed ci -l, added ci -u (both do an implicit co after the ci). ! 100: * Fixed call to getlogin(), added call to getfullRCSname(), added check ! 101: * for write error. ! 102: * Changed conflicting identifiers. ! 103: * ! 104: * Revision 3.1 82/10/13 16:04:59 wft ! 105: * fixed type of variables receiving from getc() (char -> int). ! 106: * added include file dbm.h for getting BYTESIZ. This is used ! 107: * to check the return code from diff portably. ! 108: */ ! 109: ! 110: #include "rcsbase.h" ! 111: #ifndef lint ! 112: static char rcsbaseid[] = RCSBASE; ! 113: #endif ! 114: #include <sys/types.h> ! 115: #include <sys/stat.h> ! 116: #include "time.h" ! 117: ! 118: extern int rename(); /*rename files */ ! 119: extern char * getcaller(); /*login of caller */ ! 120: extern struct hshentry * genrevs(); /*generate delta numbers */ ! 121: extern int nextc; /*next input character */ ! 122: extern quietflag; /*suppresses diagnostics if true */ ! 123: extern int nerror; /*counter for errors */ ! 124: extern char * buildrevision(); /*constructs desired revision */ ! 125: extern char * checkid(); /*check identifiers */ ! 126: extern int partime(); /*parse free-format date/time */ ! 127: extern long maketime(); /*convert parsed time to unix time. */ ! 128: extern long time(); /*get date and time */ ! 129: extern struct tm * localtime(); /*convert unixtime into tm-structure */ ! 130: extern char * getdate(); /*formates current date (forward) */ ! 131: extern char * mktempfile(); /*temporary file name generator */ ! 132: extern struct lock * addlock(); /*adds a new lock */ ! 133: extern char * getlogmsg(); /*obtains log message; forward */ ! 134: extern struct hshentry * removelock(); /*finds a caller's lock (forward) */ ! 135: extern struct hshentry * findlock(); /*finds a lock */ ! 136: extern char * xpandfile(); /*perform keyword expansion; forward */ ! 137: ! 138: extern char prevauthor[]; ! 139: extern char prevdate[]; ! 140: extern char prevrev[]; ! 141: extern char prevstate []; ! 142: extern FILE * finptr; /* RCS input file */ ! 143: extern FILE * frewrite; /* new RCS file */ ! 144: extern int rewriteflag; /* indicates whether input should be */ ! 145: /* echoed to frewrite */ ! 146: ! 147: char * newRCSfilename, * diffilename; ! 148: char * RCSfilename,*workfilename,*expfilename,*newworkfilename; ! 149: extern struct stat RCSstat, workstat; /* file status of RCS and work file */ ! 150: extern int haveRCSstat, haveworkstat;/* status indicators */ ! 151: ! 152: ! 153: int copyflag; /* indicates whether a string should be copied into memory*/ ! 154: ! 155: char * rev, * state, *msg; ! 156: ! 157: int initflag, rcsinitflag; ! 158: int lockflag, keepworkingfile,keepflag; ! 159: int forceciflag; /* forces check in */ ! 160: int symrebindflag; char * symbol; ! 161: int textflag; char * textfile; ! 162: char * caller; /* caller's login; */ ! 163: char * author; /* alternate author for -w option */ ! 164: char altdate[datelength]; /* alternate date for -d */ ! 165: struct hshentry * targetdelta; /* old delta to be generated */ ! 166: char * olddeltanum; /* number of old delta */ ! 167: struct hshentry * gendeltas[hshsize]; /* stores deltas to be generated */ ! 168: char newdelnum[revlength]; /* holds new revision number */ ! 169: int newdnumlength; /* actual length of new rev. num. */ ! 170: char branchpointnum[revlength]; /* number of branchpoint */ ! 171: struct hshentry newdelta; /* new delta to be inserted */ ! 172: struct branchhead newbranch; /* new branch to be inserted */ ! 173: char logmsg[logsize]; /* buffer for log message */ ! 174: ! 175: main (argc, argv) ! 176: int argc; ! 177: char * argv[]; ! 178: { ! 179: char * nametest; ! 180: char * cmdusage; /* holds command format */ ! 181: char command[NCPPN+50]; /* holds diff commands */ ! 182: int msglen; /* length of message given by -m */ ! 183: int exit_stats; /* return code for system() calls */ ! 184: int newRCSmode; /* mode for RCS file */ ! 185: long unixtime; ! 186: struct tm parseddate, *ftm; ! 187: ! 188: catchints(); ! 189: cmdid = "ci"; ! 190: cmdusage = "command format:\nci -r[rev] -l[rev] -u[rev] -f[rev] -k[rev] -q[rev] -mmsg -nname -Nname -sstate -t[txtfile] file ..."; ! 191: rev = state = msg = symbol = textfile = nil; ! 192: initflag= rcsinitflag= symrebindflag= textflag= quietflag= false; ! 193: forceciflag= lockflag= keepworkingfile= keepflag= false; ! 194: caller = getcaller(); author = nil; /* author may be reset by -w */ ! 195: altdate[0]= '\0'; /* empty alternate date for -d */ ! 196: ! 197: while (--argc,++argv, argc>=1 && ((*argv)[0] == '-')) { ! 198: switch ((*argv)[1]) { ! 199: ! 200: case 'r': ! 201: lockflag=false; ! 202: revno: if ((*argv)[2]!='\0') { ! 203: if (rev!=nil) warn("Redefinition of revision number"); ! 204: rev = (*argv)+2; ! 205: } ! 206: break; ! 207: ! 208: case 'l': ! 209: keepworkingfile=lockflag=true; ! 210: goto revno; ! 211: ! 212: case 'u': ! 213: keepworkingfile=true; lockflag=false; ! 214: goto revno; ! 215: ! 216: case 'q': ! 217: quietflag=true; ! 218: goto revno; ! 219: ! 220: case 'f': ! 221: forceciflag=true; ! 222: goto revno; ! 223: ! 224: case 'k': ! 225: keepflag=true; ! 226: goto revno; ! 227: ! 228: case 'm': ! 229: if ((*argv)[2]!='\0'){ ! 230: if (msg!=nil)warn("Redefinition of -m option"); ! 231: msg = (*argv)+2; ! 232: msglen=strlen(msg); ! 233: if (msglen >= logsize) { ! 234: warn("log message truncated to %d characters", ! 235: logsize); ! 236: msg[logsize-2]='\n'; ! 237: msg[logsize-1]='\0'; ! 238: } ! 239: if (msg[msglen-1]!='\n') { ! 240: /*append linefeed*/ ! 241: VOID strcpy(logmsg,msg);msg=logmsg; ! 242: msg[msglen] = '\n'; ! 243: msg[++msglen]= '\0'; ! 244: } ! 245: } else warn("Missing message for -m option"); ! 246: break; ! 247: ! 248: case 'n': ! 249: symrebindflag=false; ! 250: if ((*argv)[2]!='\0'){ ! 251: if (symbol!=nil)warn("Redefinition of symbolic name"); ! 252: symbol = (*argv)+2; ! 253: if (!(nametest=checkid(symbol,' '))||*nametest) ! 254: faterror("Name %s must be one word",symbol); ! 255: } else warn("Missing name for -n option"); ! 256: break; ! 257: ! 258: case 'N': ! 259: symrebindflag=true; ! 260: if ((*argv)[2]!='\0'){ ! 261: if (symbol!=nil)warn("Redefinition of symbolic name"); ! 262: symbol = (*argv)+2; ! 263: if (!(nametest=checkid(symbol,' '))||*nametest) ! 264: faterror("Name %s must be one word",symbol); ! 265: } else warn("Missing name for -N option"); ! 266: break; ! 267: ! 268: case 's': ! 269: if ((*argv)[2]!='\0'){ ! 270: if (state!=nil)warn("Redefinition of -s option"); ! 271: state = (*argv)+2; ! 272: VOID checkid(state,' '); ! 273: } else warn("Missing state for -s option"); ! 274: break; ! 275: ! 276: case 't': ! 277: textflag=true; ! 278: if ((*argv)[2]!='\0'){ ! 279: if (textfile!=nil)warn("Redefinition of -t option"); ! 280: textfile = (*argv)+2; ! 281: } ! 282: break; ! 283: ! 284: case 'd': ! 285: if ((*argv)[2]!='\0'){ ! 286: if (altdate[0]!='\0')warn("Redefinition of -d option"); ! 287: /* process the date */ ! 288: if ( partime((*argv)+2, &parseddate) == 0) { ! 289: faterror("Can't parse date/time: %s", (*argv)+2); ! 290: break; ! 291: } ! 292: if ( (unixtime = maketime(&parseddate)) == 0L) { ! 293: faterror("Inconsistent date/time: %s",(*argv)+2); ! 294: break; ! 295: } ! 296: ftm = localtime(&unixtime); ! 297: VOID sprintf(altdate,DATEFORM, ! 298: ftm->tm_year,ftm->tm_mon+1,ftm->tm_mday,ftm->tm_hour,ftm->tm_min,ftm->tm_sec); ! 299: } else warn("Missing date for -d option"); ! 300: break; ! 301: ! 302: case 'w': ! 303: if ((*argv)[2]!='\0'){ ! 304: if (author!=nil)warn("Redefinition of -w option"); ! 305: author = (*argv)+2; ! 306: VOID checkid(author,' '); ! 307: } else warn("Missing author for -w option"); ! 308: break; ! 309: ! 310: ! 311: ! 312: ! 313: default: ! 314: faterror("unknown option: %s\n%s", *argv,cmdusage); ! 315: }; ! 316: } /* end processing of options */ ! 317: ! 318: if (argc<1) faterror("No input file\n%s",cmdusage); ! 319: ! 320: if (!isatty(fileno(stdin)) && msg==nil && textflag && textfile==nil) { ! 321: /* would need both log message and descriptive text from a file */ ! 322: faterror("Can't take both log and description from redirected stdin; use -ttextfile"); ! 323: } ! 324: /* now handle all filenames */ ! 325: do { ! 326: gendeltas[0] = nil; ! 327: copyflag=rewriteflag=false; ! 328: finptr=frewrite=NULL; ! 329: targetdelta=nil; ! 330: olddeltanum=nil; ! 331: ! 332: switch (pairfilenames(argc,argv,false,false)) { ! 333: ! 334: case -1: /* New RCS file */ ! 335: initflag=true; rcsinitflag=false; ! 336: break; ! 337: ! 338: case 0: /* Error */ ! 339: continue; ! 340: ! 341: case 1: /* Normal checkin with prev . RCS file */ ! 342: initflag=false; rcsinitflag=(Head==nil); ! 343: } ! 344: ! 345: /* now RCSfilename contains the name of the RCS file, and ! 346: * workfilename contains the name of the working file. ! 347: * if !initflag, finptr contains the file descriptor for the ! 348: * RCS file. The admin node is initialized. ! 349: * workstat and RCSstat are set. ! 350: */ ! 351: ! 352: diagnose("%s <-- %s", RCSfilename,workfilename); ! 353: ! 354: if (access(workfilename,4)!=0) { ! 355: error("working file %s not readable or nonexistent", ! 356: workfilename); ! 357: continue; ! 358: } ! 359: ! 360: if (!trydiraccess(RCSfilename)) continue; /* give up */ ! 361: if (!initflag && !checkaccesslist(caller)) continue; /* give up */ ! 362: if (!trysema(RCSfilename,true)) continue; /* give up */ ! 363: ! 364: if (keepflag) { ! 365: /* get keyword values from working file */ ! 366: if (!getoldkeys(workfilename)) continue; ! 367: if (rev==nil && *(rev=prevrev)=='\0') { ! 368: error("Can't find a revision number in %s",workfilename); ! 369: continue; ! 370: } ! 371: if (*prevdate=='\0' && *altdate=='\0') ! 372: warn("Can't find a date in %s",workfilename); ! 373: if (*prevauthor=='\0' && author==nil) ! 374: warn("Can't find an author in %s", workfilename); ! 375: if (*prevstate=='\0' && state==nil) ! 376: warn("Can't find a state in %s", workfilename); ! 377: } /* end processing keepflag */ ! 378: ! 379: gettree(); /* reads in the delta tree.*/ ! 380: ! 381: /* expand symbolic revision number */ ! 382: if (!expandsym(rev,newdelnum)) continue; ! 383: ! 384: /* splice new delta into tree */ ! 385: if (!addelta()) continue; ! 386: ! 387: if (initflag||rcsinitflag) { ! 388: diagnose("initial revision: %s",newdelnum); ! 389: } else diagnose("new revision: %s; previous revision: %s", ! 390: newdelnum,olddeltanum); ! 391: ! 392: newdelta.num=newdelnum; ! 393: newdelta.branches=nil; ! 394: newdelta.log=nil; ! 395: newdelta.lockedby=nil; /*might be changed by addlock() */ ! 396: /* set author */ ! 397: if (author!=nil) ! 398: newdelta.author=author; /* set author given by -w */ ! 399: elsif (keepflag && *prevauthor!='\0') ! 400: newdelta.author=prevauthor; /* preserve old author of possible*/ ! 401: else newdelta.author=caller; /* otherwise use caller's id */ ! 402: if (state!=nil) ! 403: newdelta.state=state; /* set state given by -s */ ! 404: elsif (keepflag && *prevstate!='\0') ! 405: newdelta.state=prevstate; /* preserve old state if possilbe */ ! 406: else newdelta.state=DEFAULTSTATE;/* otherwise use default state */ ! 407: if (*altdate!='\0') ! 408: newdelta.date=altdate; /* set date given by -d */ ! 409: elsif (keepflag && *prevdate!='\0') /* preserve old date if possible */ ! 410: newdelta.date =prevdate; ! 411: else ! 412: newdelta.date = getdate(); /* use current date */ ! 413: /* now check validity of date -- needed because of -d and -k */ ! 414: if (targetdelta!=nil && ! 415: cmpnum(newdelta.date,targetdelta->date)<=0) { ! 416: error("Date %s is not later than %s in existing revision %s", ! 417: newdelta.date,targetdelta->date, targetdelta->num); ! 418: continue; ! 419: } ! 420: ! 421: ! 422: if (lockflag && !addlock(&newdelta,caller)) continue; ! 423: if (symbol && !addsymbol(&newdelta,symbol,symrebindflag)) continue; ! 424: ! 425: /* prepare for rewriting the RCS file */ ! 426: newRCSfilename=mktempfile(RCSfilename,NEWRCSFILE); ! 427: if ((frewrite=fopen(newRCSfilename, "w"))==NULL) { ! 428: error("Can't open file %s",newRCSfilename); ! 429: continue; ! 430: } ! 431: putadmin(frewrite); ! 432: puttree(Head,frewrite); ! 433: VOID putdesc(initflag,textflag,textfile,quietflag); ! 434: ! 435: ! 436: /* build rest of file */ ! 437: if (initflag||rcsinitflag) { ! 438: /* get logmessage */ ! 439: newdelta.log=getlogmsg(); ! 440: if(!putdtext(newdelnum,newdelta.log,workfilename,frewrite)) continue; ! 441: ffclose(frewrite); frewrite=NULL; ! 442: } else { ! 443: diffilename=mktempfile("/tmp/",DIFFILE); ! 444: if (&newdelta==Head) { ! 445: /* prepend new one */ ! 446: rewriteflag=false; ! 447: if (!(expfilename= ! 448: buildrevision(gendeltas,targetdelta,"/tmp/",false))) continue; ! 449: if (!mustcheckin(expfilename,targetdelta)) continue; ! 450: /* don't check in files that aren't different, unless forced*/ ! 451: newdelta.log=getlogmsg(); ! 452: VOID sprintf(command,"%s -n %s %s > %s\n", DIFF, ! 453: workfilename,expfilename,diffilename); ! 454: exit_stats = system (command); ! 455: if (exit_stats != 0 && exit_stats != (1 << BYTESIZ)) ! 456: faterror ("diff failed"); ! 457: /* diff returns 2 in the upper byte on failure */ ! 458: if(!putdtext(newdelnum,newdelta.log,workfilename,frewrite)) continue; ! 459: if(!putdtext(olddeltanum,targetdelta->log,diffilename,frewrite)) continue; ! 460: } else { ! 461: /* insert new delta text */ ! 462: rewriteflag=true; ! 463: if (!(expfilename= ! 464: buildrevision(gendeltas,targetdelta,"/tmp/",false))) continue; ! 465: if (!mustcheckin(expfilename,targetdelta)) continue; ! 466: /* don't check in files that aren't different, unless forced*/ ! 467: newdelta.log=getlogmsg(); ! 468: VOID sprintf(command,"%s -n %s %s > %s\n", DIFF, ! 469: expfilename,workfilename,diffilename); ! 470: exit_stats = system (command); ! 471: if (exit_stats != 0 && exit_stats != (1 << BYTESIZ)) ! 472: faterror ("diff failed"); ! 473: if(!putdtext(newdelnum,newdelta.log,diffilename,frewrite)) continue; ! 474: } ! 475: ! 476: /* rewrite rest of RCS file */ ! 477: fastcopy(finptr,frewrite); ! 478: ffclose(frewrite); frewrite=NULL; ! 479: } ! 480: ignoreints(); ! 481: if (rename(newRCSfilename,RCSfilename)<0) { ! 482: error("Can't write new RCS file %s; saved in %s", ! 483: RCSfilename,newRCSfilename); ! 484: newRCSfilename[0]='\0'; /* avoid deletion by cleanup*/ ! 485: restoreints(); ! 486: VOID cleanup(); ! 487: break; ! 488: } ! 489: newRCSfilename[0]='\0'; /* avoid re-unlinking by cleanup()*/ ! 490: ! 491: newRCSmode= (initflag|rcsinitflag?workstat.st_mode:RCSstat.st_mode)& ~0222; ! 492: /* newRCSmode is also used to adjust mode of working file for -u and -l */ ! 493: if (chmod(RCSfilename,newRCSmode)<0) ! 494: warn("Can't set mode of %s",RCSfilename); ! 495: ! 496: restoreints(); ! 497: # ifdef SNOOPFILE ! 498: logcommand("ci",&newdelta,gendeltas,caller); ! 499: # endif ! 500: ! 501: if (!keepworkingfile) { ! 502: VOID unlink(workfilename); /* get rid of old file */ ! 503: } else { ! 504: /* expand keywords in file */ ! 505: newworkfilename= ! 506: xpandfile(workfilename,workfilename /*for directory*/,&newdelta); ! 507: if (!newworkfilename) continue; /* expand failed */ ! 508: ignoreints(); ! 509: if (rename(newworkfilename,workfilename) <0) { ! 510: error("Can't expand keywords in %s",workfilename); ! 511: restoreints(); ! 512: continue; ! 513: } ! 514: newworkfilename[0]='\0'; /* avoid re-unlink by cleanup */ ! 515: if (chmod(workfilename, WORKMODE(newRCSmode))<0) ! 516: warn("Can't adjust mode of %s",workfilename); ! 517: restoreints(); ! 518: } ! 519: diagnose("done"); ! 520: ! 521: } while (cleanup(), ! 522: ++argv, --argc >=1); ! 523: ! 524: exit(nerror!=0); ! 525: /*NOTREACHED*/ ! 526: } /* end of main (ci) */ ! 527: /*****************************************************************/ ! 528: /* the rest are auxiliary routines */ ! 529: ! 530: ! 531: int addelta() ! 532: /* Function: Appends a delta to the delta tree, whose number is ! 533: * given by newdelnum[]. Updates Head, newdelnum, newdenumlength, ! 534: * olddeltanum and the links in newdelta. ! 535: * Retruns false on error, true on success. ! 536: */ ! 537: { ! 538: register char * sp, * tp; ! 539: register int i; ! 540: ! 541: newdnumlength=countnumflds(newdelnum); ! 542: ! 543: if (initflag || rcsinitflag ) { ! 544: /* this covers non-existing RCS file and a file initialized with rcs -i */ ! 545: if ((newdnumlength==0)&&(Dbranch!=nil)) { ! 546: VOID strcpy(newdelnum,Dbranch->num); ! 547: newdnumlength=countnumflds(newdelnum); ! 548: } ! 549: if (newdnumlength==0) VOID strcpy(newdelnum,"1.1"); ! 550: elsif (newdnumlength==1) VOID strcat(newdelnum,".1"); ! 551: elsif (newdnumlength>2) { ! 552: error("Branch point does not exist for %s",newdelnum); ! 553: return false; ! 554: } /* newdnumlength == 2 is OK; */ ! 555: olddeltanum=nil; ! 556: Head = &newdelta; ! 557: newdelta.next=nil; ! 558: return true; ! 559: } ! 560: if (newdnumlength==0) { ! 561: /* derive new revision number from locks */ ! 562: targetdelta=findlock(caller,true); /*find and delete it*/ ! 563: if (targetdelta) { ! 564: /* found an old lock */ ! 565: olddeltanum=targetdelta->num; ! 566: /* check whether locked revision exists */ ! 567: if (!genrevs(olddeltanum,(char *)nil,(char *)nil,(char *)nil,gendeltas)) return false; ! 568: if (targetdelta==Head) { ! 569: /* make new head */ ! 570: newdelta.next=Head; ! 571: Head= &newdelta; ! 572: incnum(olddeltanum, newdelnum); ! 573: } elsif ((targetdelta->next==nil)&&(countnumflds(olddeltanum)>2)) { ! 574: /* new tip revision on side branch */ ! 575: targetdelta->next= &newdelta; ! 576: newdelta.next = nil; ! 577: incnum(olddeltanum, newdelnum); ! 578: } else { ! 579: /* middle revision; start a new branch */ ! 580: newdelnum[0]='\0'; ! 581: if (!addbranch(targetdelta,newdelnum)) return false; ! 582: } ! 583: return true; /* successfull use of existing lock */ ! 584: } else { ! 585: /* no existing lock; try Dbranch */ ! 586: /* update newdelnum */ ! 587: if (!((StrictLocks==false) && (getuid() == RCSstat.st_uid))) { ! 588: error("no lock set by %s",caller); ! 589: return false; ! 590: } ! 591: if (Dbranch) { ! 592: VOID strcpy(newdelnum,Dbranch->num); ! 593: } else { ! 594: incnum(Head->num,newdelnum); ! 595: } ! 596: newdnumlength=countnumflds(newdelnum); ! 597: /* now fall into next statement */ ! 598: } ! 599: } ! 600: if (newdnumlength<=2) { ! 601: /* add new head per given number */ ! 602: olddeltanum=Head->num; ! 603: if(newdnumlength==1) { ! 604: /* make a two-field number out of it*/ ! 605: if (cmpnumfld(newdelnum,olddeltanum,1)==0) ! 606: incnum(olddeltanum,newdelnum); ! 607: else VOID strcat(newdelnum, ".1"); ! 608: } ! 609: if (cmpnum(newdelnum,olddeltanum) <= 0) { ! 610: error("deltanumber %s too low; must be higher than %s", ! 611: newdelnum,Head->num); ! 612: return false; ! 613: } ! 614: if (!(targetdelta=removelock(caller,Head))) return false; ! 615: if (!(genrevs(olddeltanum,(char *)nil,(char *)nil,(char *)nil,gendeltas))) return false; ! 616: newdelta.next=Head; ! 617: Head= &newdelta; ! 618: } else { ! 619: /* put new revision on side branch */ ! 620: /*first, get branch point */ ! 621: tp=branchpointnum; sp=newdelnum; ! 622: for(i=newdnumlength-(newdnumlength%2==1?1:2);i>0;i--) { ! 623: while (*sp != '.') *tp++ = *sp++; /*copy field*/ ! 624: *tp++ = *sp++; /*copy dot */ ! 625: } ! 626: *(tp-1) = '\0'; /* kill final dot */ ! 627: olddeltanum=branchpointnum; /*temporary old delta*/ ! 628: if (!(targetdelta=genrevs(branchpointnum,(char *)nil,(char *)nil,(char *)nil,gendeltas))) ! 629: return false; ! 630: if (cmpnum(targetdelta->num,branchpointnum)!=0) { ! 631: error("Cannot find branchpoint %s",branchpointnum); ! 632: return false; ! 633: } ! 634: if (!addbranch(targetdelta,newdelnum)) return false; ! 635: } ! 636: return true; ! 637: } ! 638: ! 639: ! 640: ! 641: int addbranch(branchpoint,num) ! 642: struct hshentry * branchpoint; ! 643: char * num; ! 644: /* adds a new branch and branch delta at branchpoint. ! 645: * If num is the null string, appends the new branch, incrementing ! 646: * the highest branch number (initially 1), and setting the level number to 1. ! 647: * the new delta and branchhead are in globals newdelta and newbranch, resp. ! 648: * the new number is placed into num. ! 649: * returns false on error. ! 650: */ ! 651: { ! 652: struct branchhead * bhead, * btrail; ! 653: char branchnum[revlength]; ! 654: int numlength, result, field; ! 655: ! 656: numlength = countnumflds(num); ! 657: ! 658: if (branchpoint->branches==nil) { ! 659: /* start first branch */ ! 660: branchpoint->branches = &newbranch; ! 661: if (numlength==0) { ! 662: VOID strcpy(num, branchpoint->num); ! 663: VOID strcat(num,".1.1"); ! 664: } elsif(countnumflds(num)%2 == 1) ! 665: VOID strcat(num, ".1"); ! 666: newbranch.nextbranch=nil; ! 667: ! 668: } elsif (numlength==0) { ! 669: /* append new branch to the end */ ! 670: bhead=branchpoint->branches; ! 671: while (bhead->nextbranch) bhead=bhead->nextbranch; ! 672: bhead->nextbranch = &newbranch; ! 673: getbranchno(bhead->hsh->num,branchnum); ! 674: incnum(branchnum,num); ! 675: VOID strcat(num,".1"); ! 676: newbranch.nextbranch=nil; ! 677: } else { ! 678: /* place the branch properly */ ! 679: field = numlength - (numlength%2 ==1?0:1); ! 680: /* field of branch number */ ! 681: bhead=branchpoint->branches; ! 682: while ((bhead!=nil) && ! 683: ((result=cmpnumfld(num,bhead->hsh->num,field))>0)) { ! 684: btrail=bhead; ! 685: bhead=bhead->nextbranch; ! 686: } ! 687: if (bhead==nil || result<0) { ! 688: /* insert/append new branchhead */ ! 689: if (bhead==branchpoint->branches) ! 690: branchpoint->branches= &newbranch; ! 691: else btrail->nextbranch= &newbranch; ! 692: newbranch.nextbranch=bhead; ! 693: if (numlength%2 ==1) VOID strcat(num,".1"); ! 694: } else { ! 695: /* branch exists; append to end */ ! 696: getbranchno(num,branchnum); ! 697: if (!(targetdelta=genrevs(branchnum,(char *)nil,(char *)nil,(char *)nil, ! 698: gendeltas))) return false; ! 699: olddeltanum=targetdelta->num; ! 700: if (cmpnum(num,olddeltanum) <= 0) { ! 701: error("deltanumber %s too low; must be higher than %s", ! 702: num,olddeltanum); ! 703: return false; ! 704: } ! 705: if (!removelock(caller,targetdelta)) return false; ! 706: if (numlength%2==1) incnum(olddeltanum,num); ! 707: targetdelta->next= &newdelta; ! 708: newdelta.next=nil; ! 709: return true; /* Don't do anything to newbranch */ ! 710: } ! 711: } ! 712: newbranch.hsh = &newdelta; ! 713: newdelta.next=nil; ! 714: return true; ! 715: } ! 716: ! 717: ! 718: ! 719: struct hshentry * removelock(who,delta) ! 720: char * who; struct hshentry * delta; ! 721: /* function: Finds the lock held by who on delta, ! 722: * removes it, and returns a pointer to the delta. ! 723: * Prints an error message and returns nil if there is no such lock. ! 724: * An exception is if StrictLocks==false, and who is the owner of ! 725: * the RCS file. If who does not have a lock in this case, ! 726: * delta is returned. ! 727: */ ! 728: { ! 729: register struct lock * next, * trail; ! 730: char * num; ! 731: struct lock dummy; ! 732: int whomatch, nummatch; ! 733: ! 734: num=delta->num; ! 735: dummy.nextlock=next=Locks; ! 736: trail = &dummy; ! 737: while (next!=nil) { ! 738: whomatch=strcmp(who,next->login); ! 739: nummatch=strcmp(num,next->delta->num); ! 740: if ((whomatch==0) && (nummatch==0)) break; ! 741: /*found a lock on delta by who*/ ! 742: if ((whomatch!=0)&&(nummatch==0)) { ! 743: error("revision %s locked by %s",num,next->login); ! 744: return nil; ! 745: } ! 746: trail=next; ! 747: next=next->nextlock; ! 748: } ! 749: if (next!=nil) { ! 750: /*found one; delete it */ ! 751: trail->nextlock=next->nextlock; ! 752: Locks=dummy.nextlock; ! 753: next->delta->lockedby=nil; /* reset locked-by */ ! 754: return next->delta; ! 755: } else { ! 756: if (!((StrictLocks==false) && (getuid() == RCSstat.st_uid))) { ! 757: error("no lock set by %s for revision %s",who,num); ! 758: return nil; ! 759: } else { ! 760: return delta; ! 761: } ! 762: } ! 763: } ! 764: ! 765: ! 766: ! 767: char * getdate() ! 768: /* Function: returns a pointer to the current date in the form ! 769: * YY.MM.DD.hh.mm.ss\0 ! 770: */ ! 771: { ! 772: long clock; ! 773: struct tm * tm; ! 774: static char buffer[datelength]; /* date buffer */ ! 775: clock=time((long *)0); ! 776: tm=localtime(&clock); ! 777: VOID sprintf(buffer, DATEFORM, ! 778: tm->tm_year, tm->tm_mon+1, tm->tm_mday, ! 779: tm->tm_hour, tm->tm_min, tm->tm_sec); ! 780: return buffer; ! 781: } ! 782: ! 783: ! 784: char * xpandfile (unexfname,dir,delta) ! 785: char * unexfname, * dir; ! 786: struct hshentry * delta; ! 787: /* Function: Reads file unexpfname and copies it to a ! 788: * file in dir, performing keyword substitution with data from delta. ! 789: * returns the name of the expanded file if successful, nil otherwise. ! 790: */ ! 791: { char * targetfname; ! 792: FILE * unexfile, *exfile; ! 793: ! 794: targetfname=mktempfile(dir,TMPFILE3); ! 795: if ((unexfile=fopen(unexfname, "r" ))==NULL || ! 796: (exfile =fopen(targetfname,"w"))==NULL) { ! 797: error("Can't expand file %s",unexfname); ! 798: return nil; ! 799: } ! 800: while (expandline(unexfile,exfile,delta,false,false)); /*expand*/ ! 801: ffclose(unexfile);ffclose(exfile); ! 802: return targetfname; ! 803: } ! 804: ! 805: ! 806: mustcheckin (unexfname,delta) ! 807: char * unexfname; struct hshentry * delta; ! 808: /* Function: determines whether checkin should proceed. ! 809: * Compares the wrkfilename with unexfname, disregarding keywords. ! 810: * If the 2 files differ, returns true. If they do not differ, asks the user ! 811: * whether to return true or false (i.e., whether to checkin the file anyway. ! 812: * If the files do not differ, and quietflag==true, returns false. ! 813: * Shortcut: If forceciflag==true, mustcheckin() always returns true. ! 814: */ ! 815: { register int c; ! 816: int response, result; ! 817: ! 818: if (forceciflag) return true; ! 819: ! 820: if (!rcsfcmp(workfilename,unexfname,delta)) return true; ! 821: /* If files are different, must check them in. */ ! 822: ! 823: /* files are the same */ ! 824: diagnose("File %s is unchanged with respect to revision %s", ! 825: workfilename,delta->num); ! 826: if (quietflag || !isatty(fileno(stdin))) { ! 827: /* Files are the same, but can't ask, so don't checkin*/ ! 828: result=false; ! 829: } else { ! 830: /* ask user whether to check in */ ! 831: VOID fputs("checkin anyway? [ny](n): ",stderr); ! 832: response=c=getchar(); ! 833: while (!(c==EOF || c=='\n')) c=getchar();/*skip to end of line*/ ! 834: result=(response=='y'||response=='Y'); ! 835: } ! 836: if (result==false) { ! 837: if (quietflag) { ! 838: warn("checkin aborted since %s was not changed; %s %sdeleted.", ! 839: workfilename,workfilename,keepworkingfile?"not ":""); ! 840: } else { ! 841: diagnose("checkin aborted; %s %sdeleted.", ! 842: workfilename,keepworkingfile?"not ":""); ! 843: } ! 844: if (!keepworkingfile) VOID unlink(workfilename); ! 845: } ! 846: return result; ! 847: } ! 848: ! 849: ! 850: ! 851: ! 852: /* --------------------- G E T L O G M S G --------------------------------*/ ! 853: extern int stdinread; /* is >0 if redirected stdin has been read once. */ ! 854: ! 855: ! 856: char * getlogmsg() ! 857: /* Function: obtains a log message and returns a pointer to it. ! 858: * If a log message is given via the -m option, a pointer to that ! 859: * string is returned. ! 860: * If this is the initial revision, a standard log message is returned. ! 861: * Otherwise, reads a character string from the terminal. ! 862: * The string must be terminated with a control-d or a single '.' on a ! 863: * line. getlogmsg prompts the first time it is called for the ! 864: * log message; during all later calls it asks whether the previous ! 865: * log message can be reused. ! 866: * returns a pointer to the character string; the pointer is always non-nil. ! 867: */ ! 868: { ! 869: static logyet = false; /*indicates whether previous log present*/ ! 870: static char emptylog[] = "*** empty log message ***\n"; ! 871: static char initiallog[]= "Initial revision\n"; ! 872: char response; ! 873: int cin; ! 874: register char c, old1, old2, * tp; ! 875: ! 876: if (msg) return msg; ! 877: ! 878: if ((olddeltanum==nil)&& ! 879: ((cmpnum(newdelnum,"1.1")==0)||(cmpnum(newdelnum,"1.0")==0))) { ! 880: return initiallog; ! 881: } ! 882: if (keepflag) { ! 883: /* generate std. log message */ ! 884: VOID sprintf(logmsg, "checked in with -k by %s at %s.\n",caller,getdate()); ! 885: return(logmsg); ! 886: } ! 887: if (logyet) { ! 888: /*previous log available*/ ! 889: if (!isatty(fileno(stdin))) return logmsg; /* reuse if stdin is not a terminal*/ ! 890: /* otherwise ask */ ! 891: clearerr(stdin); /* reset EOF ptr */ ! 892: VOID fputs("reuse log message of previous file? [yn](y): ",stderr); ! 893: cin=getchar(); ! 894: response=cin; ! 895: while (!(cin==EOF || cin=='\n')) cin=getchar();/*skip to end of line*/ ! 896: if (response=='\n'||response=='y'||response=='Y') ! 897: return logmsg; ! 898: else ! 899: logmsg[0]='\0'; /*kill existing log message */ ! 900: } ! 901: ! 902: /* now read string from stdin */ ! 903: if (isatty(fileno(stdin))) { ! 904: VOID fputs("enter log message:\n(terminate with ^D or single '.')\n>> ",stderr); ! 905: } else { /* redirected stdin */ ! 906: if (stdinread>0) ! 907: faterror("Can't reread redirected stdin for log message; use -m"); ! 908: stdinread++; ! 909: } ! 910: ! 911: tp=logmsg; old1='\n'; old2=' '; ! 912: if (feof(stdin)) ! 913: clearerr(stdin); ! 914: for (;;) { ! 915: cin=getchar(); ! 916: if (cin==EOF) { ! 917: if(isatty(fileno(stdin))) VOID putc('\n',stderr); ! 918: if ((tp==logmsg)||(*(tp-1)!='\n')) *tp++ = '\n'; /* append newline */ ! 919: *tp = '\0'; /*terminate*/ ! 920: break; ! 921: } ! 922: if (cin=='\n' && old1=='.' && old2=='\n') { ! 923: *(tp-1) = '\0'; /*kill last period */ ! 924: break; ! 925: } ! 926: if (tp>=logmsg+logsize-2) { /* overflow */ ! 927: if (!isatty(fileno(stdin))) { ! 928: warn("log message truncated to %d characters",logsize); ! 929: logmsg[logsize-2]='\n';logmsg[logsize-1]='\0'; ! 930: return logmsg; ! 931: } ! 932: VOID fprintf(stderr,"log message too long. Maximum: %d\n",logsize); ! 933: VOID fputs("reenter log message:\n>> ",stderr); ! 934: tp=logmsg; old1='\n'; old2=' '; ! 935: while (cin!='\n') cin=getchar(); /*skip line */ ! 936: continue; ! 937: } ! 938: if (cin=='\n' && isatty(fileno(stdin))) VOID fputs(">> ",stderr); ! 939: *tp++ = cin; old2=old1; old1=cin; /* this is the actual work!*/ ! 940: /*SDELIM will be changed to double SDELIM by putdtext*/ ! 941: } /* end for */ ! 942: ! 943: /* now check whether the log message is not empty */ ! 944: tp=logmsg; ! 945: while ((c= *tp++)==' '||c=='\t'||c=='\n'||c=='\f'); ! 946: if (*tp=='\0') { ! 947: logyet=false; ! 948: return emptylog; ! 949: } else { ! 950: logyet=true; ! 951: return logmsg; ! 952: } ! 953: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.