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