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