![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcs.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 rcs.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / rcs / src |
1.1 root 1: /*
2: * RCS create/change operation
3: */
4: #ifndef lint
5: static char rcsid[]=
6: "$Header: /usr/src/local/bin/rcs/src/RCS/rcs.c,v 4.7 87/12/18 11:37:17 narten Exp $ Purdue CS";
7: #endif
8: /***************************************************************************
9: * create RCS files or change RCS file attributes
10: * Compatibility with release 2: define COMPAT2
11: ***************************************************************************
12: *
13: * Copyright (C) 1982 by Walter F. Tichy
14: * Purdue University
15: * Computer Science Department
16: * West Lafayette, IN 47907
17: *
18: * All rights reserved. No part of this software may be sold or distributed
19: * in any form or by any means without the prior written permission of the
20: * author.
21: */
22:
23:
24:
25: /* $Log: rcs.c,v $
26: * Revision 4.7 87/12/18 11:37:17 narten
27: * lint cleanups (Guy Harris)
28: *
29: * Revision 4.6 87/10/18 10:28:48 narten
30: * Updating verison numbers. Changes relative to 1.1 are actually
31: * relative to 4.3
32: *
33: * Revision 1.4 87/09/24 13:58:52 narten
34: * Sources now pass through lint (if you ignore printf/sprintf/fprintf
35: * warnings)
36: *
37: * Revision 1.3 87/03/27 14:21:55 jenkins
38: * Port to suns
39: *
40: * Revision 1.2 85/12/17 13:59:09 albitz
41: * Changed setstate to rcs_setstate because of conflict with random.o.
42: *
43: * Revision 1.1 84/01/23 14:50:09 kcs
44: * Initial revision
45: *
46: * Revision 4.3 83/12/15 12:27:33 wft
47: * rcs -u now breaks most recent lock if it can't find a lock by the caller.
48: *
49: * Revision 4.2 83/12/05 10:18:20 wft
50: * Added conditional compilation for sending mail.
51: * Alternatives: V4_2BSD, V6, USG, and other.
52: *
53: * Revision 4.1 83/05/10 16:43:02 wft
54: * Simplified breaklock(); added calls to findlock() and getcaller().
55: * Added option -b (default branch). Updated -s and -w for -b.
56: * Removed calls to stat(); now done by pairfilenames().
57: * Replaced most catchints() calls with restoreints().
58: * Removed check for exit status of delivermail().
59: * Directed all interactive output to stderr.
60: *
61: * Revision 3.9.1.1 83/12/02 22:08:51 wft
62: * Added conditional compilation for 4.2 sendmail and 4.1 delivermail.
63: *
64: * Revision 3.9 83/02/15 15:38:39 wft
65: * Added call to fastcopy() to copy remainder of RCS file.
66: *
67: * Revision 3.8 83/01/18 17:37:51 wft
68: * Changed sendmail(): now uses delivermail, and asks whether to break the lock.
69: *
70: * Revision 3.7 83/01/15 18:04:25 wft
71: * Removed putree(); replaced with puttree() in rcssyn.c.
72: * Combined putdellog() and scanlogtext(); deleted putdellog().
73: * Cleaned up diagnostics and error messages. Fixed problem with
74: * mutilated files in case of deletions in 2 files in a single command.
75: * Changed marking of selector from 'D' to DELETE.
76: *
77: * Revision 3.6 83/01/14 15:37:31 wft
78: * Added ignoring of interrupts while new RCS file is renamed;
79: * Avoids deletion of RCS files by interrupts.
80: *
81: * Revision 3.5 82/12/10 21:11:39 wft
82: * Removed unused variables, fixed checking of return code from diff,
83: * introduced variant COMPAT2 for skipping Suffix on -A files.
84: *
85: * Revision 3.4 82/12/04 13:18:20 wft
86: * Replaced getdelta() with gettree(), changed breaklock to update
87: * field lockedby, added some diagnostics.
88: *
89: * Revision 3.3 82/12/03 17:08:04 wft
90: * Replaced getlogin() with getpwuid(), flcose() with ffclose(),
91: * /usr/ucb/Mail with macro MAIL. Removed handling of Suffix (-x).
92: * fixed -u for missing revno. Disambiguated structure members.
93: *
94: * Revision 3.2 82/10/18 21:05:07 wft
95: * rcs -i now generates a file mode given by the umask minus write permission;
96: * otherwise, rcs keeps the mode, but removes write permission.
97: * I added a check for write error, fixed call to getlogin(), replaced
98: * curdir() with getfullRCSname(), cleaned up handling -U/L, and changed
99: * conflicting, long identifiers.
100: *
101: * Revision 3.1 82/10/13 16:11:07 wft
102: * fixed type of variables receiving from getc() (char -> int).
103: */
104:
105:
106: #include <sys/types.h>
107: #include <sys/stat.h>
108: #include "rcsbase.h"
109: #ifndef lint
110: static char rcsbaseid[] = RCSBASE;
111: #endif
112:
113: extern FILE * fopen();
114: extern char * bindex();
115: extern int expandsym(); /* get numeric revision name */
116: extern struct hshentry * getnum();
117: extern struct lock * addlock(); /* add a lock */
118: extern char * getid();
119: extern char * getkeyval();
120: extern char * Klog, *Khead, *Kaccess, *Ktext;
121: #ifdef COMPAT2
122: extern char * Ksuffix;
123: #endif
124: extern char * getcaller(); /* get login of caller */
125: extern char * malloc();
126: extern struct hshentry * genrevs();
127: extern struct hshentry * breaklock(); /* remove locks (forward) */
128: extern struct hshentry * findlock(); /* find and remove lock */
129: extern char * checkid(); /* check an identifier */
130: extern char * getfullRCSname(); /* get full path name of RCS file */
131: extern char * mktempfile(); /* temporary file name generator */
132: extern free();
133: extern void catchints();
134: extern void ignoreints();
135: extern int nextc; /* next input character */
136: extern int nerror; /* counter for errors */
137: extern int quietflag; /* diagnoses suppressed if true */
138: extern char curlogmsg[]; /* current log message */
139: extern char * resultfile, *editfile; /* filename for fcopy and fedit */
140: extern FILE *fcopy; /* result file during editing */
141: extern FILE *fedit; /* edit file */
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, * cutfilename;
148: char * RCSfilename, * workfilename;
149: extern struct stat RCSstat, workstat; /* file status of RCS and work file */
150: extern int haveRCSstat, haveworkstat;/* status indicators */
151:
152: char accessorlst[strtsize];
153: FILE * fcut; /* temporary file to rebuild delta tree */
154: int oldumask; /* save umask */
155:
156: int initflag, strictlock, strict_selected, textflag;
157: char * textfile, * accessfile;
158: char * caller, numrev[30]; /* caller's login; */
159: struct access * newaccessor, * rmvaccessor, * rplaccessor;
160: struct access *curaccess, *rmaccess;
161: struct hshentry * gendeltas[hshsize];
162:
163: struct Lockrev {
164: char * revno;
165: struct Lockrev * nextrev;
166: };
167:
168: struct Symrev {
169: char * revno;
170: char * ssymbol;
171: int override;
172: struct Symrev * nextsym;
173: };
174:
175: struct Status {
176: char * revno;
177: char * status;
178: struct Status * nextstatus;
179: };
180:
181: struct delrevpair {
182: char * strt;
183: char * end;
184: int code;
185: };
186:
187: struct Lockrev * newlocklst, * rmvlocklst;
188: struct Symrev * assoclst, * lastassoc;
189: struct Status * statelst, * laststate;
190: struct delrevpair * delrev;
191: struct hshentry * cuthead, *cuttail, * delstrt;
192: char branchnum[revlength], * branchsym;
193: struct hshentry branchdummy;
194: char command[80], * commsyml;
195: char * headstate;
196: int lockhead,unlockcaller,chgheadstate,branchflag,commentflag;
197: int delaccessflag;
198: enum stringwork {copy, edit, empty}; /* expand and edit_expand not needed */
199:
200:
201: main (argc, argv)
202: int argc;
203: char * argv[];
204: {
205: char *comdusge;
206: int result;
207: struct access *removeaccess(), * getaccessor();
208: struct Lockrev *rmnewlocklst();
209: struct Lockrev *curlock, * rmvlock, *lockpt;
210: struct Status * curstate;
211: struct access *temp, *temptr;
212:
213: nerror = 0;
214: catchints();
215: cmdid = "rcs";
216: quietflag = false;
217: comdusge ="command format:\nrcs -i -alogins -Alogins -e[logins] -b[rev] -c[commentleader] -l[rev] -u[rev] -L -U -nname[:rev] -Nname[:rev] -orange -sstate[:rev] -t[textfile] file....";
218: rplaccessor = nil; delstrt = nil;
219: accessfile = textfile = caller = nil;
220: branchflag = commentflag = chgheadstate = false;
221: lockhead = false; unlockcaller=false;
222: initflag= textflag = false;
223: strict_selected = 0;
224:
225: caller=getcaller();
226: laststate = statelst = nil;
227: lastassoc = assoclst = nil;
228: curlock = rmvlock = newlocklst = rmvlocklst = nil;
229: curaccess = rmaccess = rmvaccessor = newaccessor = nil;
230: delaccessflag = false;
231:
232: /* preprocessing command options */
233: while (--argc,++argv, argc>=1 && ((*argv)[0] == '-')) {
234: switch ((*argv)[1]) {
235:
236: case 'i': /* initail version */
237: initflag = true;
238: break;
239:
240: case 'b': /* change default branch */
241: if (branchflag)warn("Redfinition of option -b");
242: branchflag= true;
243: branchsym = (*argv)+2;
244: break;
245:
246: case 'c': /* change comment symbol */
247: if (commentflag)warn("Redefinition of option -c");
248: commentflag = true;
249: commsyml = (*argv)+2;
250: break;
251:
252: case 'a': /* add new accessor */
253: if ( (*argv)[2] == '\0') {
254: error("Login name missing after -a");
255: }
256: if ( (temp = getaccessor((*argv)+1)) ) {
257: if ( newaccessor )
258: curaccess->nextaccess = temp->nextaccess;
259: else
260: newaccessor = temp->nextaccess;
261: temp->nextaccess = nil;
262: curaccess = temp;
263: }
264: break;
265:
266: case 'A': /* append access list according to accessfile */
267: if ( (*argv)[2] == '\0') {
268: error("Missing file name after -A");
269: break;
270: }
271: if ( accessfile) warn("Redefinition of option -A");
272: *argv = *argv+2;
273: if( pairfilenames(1, argv, true, false) > 0) {
274: releaselst(newaccessor);
275: newaccessor = curaccess = nil;
276: releaselst(rmvaccessor);
277: rmvaccessor = rmaccess = nil;
278: accessfile = RCSfilename;
279: }
280: else
281: accessfile = nil;
282: break;
283:
284: case 'e': /* remove accessors */
285: if ( (*argv)[2] == '\0' ) {
286: delaccessflag = true;
287: break;
288: }
289: if ( (temp = getaccessor((*argv)+1)) ) {
290: if ( rmvaccessor )
291: rmaccess->nextaccess = temp->nextaccess;
292: else
293: rmvaccessor = temp->nextaccess;
294: temptr = temp->nextaccess;
295: temp->nextaccess = nil;
296: rmaccess = temp;
297: while( temptr ) {
298: newaccessor = removeaccess(temptr,newaccessor,false);
299: temptr = temptr->nextaccess;
300: }
301: curaccess = temp = newaccessor;
302: while( temp){
303: curaccess = temp;
304: temp = temp->nextaccess;
305: }
306: }
307: break;
308:
309: case 'l': /* lock a revision if it is unlocked */
310: if ( (*argv)[2] == '\0'){ /* lock head or def. branch */
311: lockhead = true;
312: break;
313: }
314: lockpt = (struct Lockrev *)malloc(sizeof(struct Lockrev));
315: lockpt->revno = (*argv)+2;
316: lockpt->nextrev = nil;
317: if ( curlock )
318: curlock->nextrev = lockpt;
319: else
320: newlocklst = lockpt;
321: curlock = lockpt;
322: break;
323:
324: case 'u': /* release lock of a locked revision */
325: if ( (*argv)[2] == '\0'){ /* unlock head */
326: unlockcaller=true;
327: break;
328: }
329: lockpt = (struct Lockrev *)malloc(sizeof(struct Lockrev));
330: lockpt->revno = (*argv)+2;
331: lockpt->nextrev = nil;
332: if (rmvlock)
333: rmvlock->nextrev = lockpt;
334: else
335: rmvlocklst = lockpt;
336: rmvlock = lockpt;
337:
338: curlock = rmnewlocklst(lockpt);
339: break;
340:
341: case 'L': /* set strict locking */
342: if (strict_selected++) { /* Already selected L or U? */
343: if (!strictlock) /* Already selected -U? */
344: warn("Option -L overrides -U");
345: }
346: strictlock = true;
347: break;
348:
349: case 'U': /* release strict locking */
350: if (strict_selected++) { /* Already selected L or U? */
351: if (strictlock) /* Already selected -L? */
352: warn("Option -L overrides -U");
353: }
354: else
355: strictlock = false;
356: break;
357:
358: case 'n': /* add new association: error, if name exists */
359: if ( (*argv)[2] == '\0') {
360: error("Missing symbolic name after -n");
361: break;
362: }
363: getassoclst(false, (*argv)+1);
364: break;
365:
366: case 'N': /* add or change association */
367: if ( (*argv)[2] == '\0') {
368: error("Missing symbolic name after -N");
369: break;
370: }
371: getassoclst(true, (*argv)+1);
372: break;
373:
374: case 'o': /* delete revisins */
375: if (delrev) warn("Redefinition of option -o");
376: if ( (*argv)[2] == '\0' ) {
377: error("Missing revision range after -o");
378: break;
379: }
380: getdelrev( (*argv)+1 );
381: break;
382:
383: case 's': /* change state attribute of a revision */
384: if ( (*argv)[2] == '\0') {
385: error("State missing after -s");
386: break;
387: }
388: getstates( (*argv)+1);
389: break;
390:
391: case 't': /* change descriptive text */
392: textflag=true;
393: if ((*argv)[2]!='\0'){
394: if (textfile!=nil)warn("Redefinition of -t option");
395: textfile = (*argv)+2;
396: }
397: break;
398:
399: case 'q':
400: quietflag = true;
401: break;
402: default:
403: faterror("Unknown option: %s\n%s", *argv, comdusge);
404: };
405: } /* end processing of options */
406:
407: if (argc<1) faterror("No input file\n%s", comdusge);
408: if (nerror) { /* exit, if any error in command options */
409: diagnose("%s aborted",cmdid);
410: exit(1);
411: }
412: if (accessfile) /* get replacement for access list */
413: getrplaccess();
414: if (nerror) {
415: diagnose("%s aborted",cmdid);
416: exit(1);
417: }
418:
419: /* now handle all filenames */
420: do {
421: rewriteflag = false;
422: finptr=frewrite=NULL;
423: nerror=0;
424:
425: if ( initflag ) {
426: switch( pairfilenames(argc, argv, false, false) ) {
427: case -1: break; /* not exist; ok */
428: case 0: continue; /* error */
429: case 1: error("file %s exists already", RCSfilename);
430: VOID fclose(finptr);
431: continue;
432: }
433: }
434: else {
435: switch( pairfilenames(argc, argv, true, false) ) {
436: case -1: continue; /* not exist */
437: case 0: continue; /* errors */
438: case 1: break; /* file exists; ok*/
439: }
440: }
441:
442:
443: /* now RCSfilename contains the name of the RCS file, and
444: * workfilename contains the name of the working file.
445: * if !initflag, finptr contains the file descriptor for the
446: * RCS file. The admin node is initialized.
447: */
448:
449: diagnose("RCS file: %s", RCSfilename);
450:
451: if (!trydiraccess(RCSfilename)) continue; /* give up */
452: if (!initflag && !checkaccesslist(caller)) continue; /* give up */
453: if (!trysema(RCSfilename,true)) continue; /* give up */
454:
455: gettree(); /* read in delta tree */
456:
457: /* update admin. node */
458: if (strict_selected) StrictLocks = strictlock;
459: if (commentflag) Comment = commsyml;
460:
461: /* update default branch */
462: if (branchflag && expandsym(branchsym, branchnum)) {
463: if (countnumflds(branchnum)>0) {
464: branchdummy.num=branchnum;
465: Dbranch = &branchdummy;
466: } else
467: Dbranch = nil;
468: }
469:
470: /* update access list */
471: if ( delaccessflag ) AccessList = nil;
472: if ( accessfile ) {
473: temp = rplaccessor;
474: while( temp ) {
475: temptr = temp->nextaccess;
476: if ( addnewaccess(temp) )
477: temp->nextaccess = nil;
478: temp = temptr;
479: }
480: }
481: temp = rmvaccessor;
482: while(temp) { /* remove accessors from accesslist */
483: AccessList = removeaccess(temp, AccessList,true);
484: temp = temp->nextaccess;
485: }
486: temp = newaccessor;
487: while( temp) { /* add new accessors */
488: temptr = temp->nextaccess;
489: if ( addnewaccess( temp ) )
490: temp->nextaccess = nil;
491: temp = temptr;
492: }
493:
494: updateassoc(); /* update association list */
495:
496: updatelocks(); /* update locks */
497:
498: /* update state attribution */
499: if (chgheadstate) {
500: /* change state of default branch or head */
501: if (Dbranch==nil) {
502: if (Head==nil)
503: warn("Can't change states in an empty tree");
504: else Head->state = headstate;
505: } else {
506: rcs_setstate(Dbranch->num,headstate); /* Can't set directly */
507: }
508: }
509: curstate = statelst;
510: while( curstate ) {
511: rcs_setstate(curstate->revno,curstate->status);
512: curstate = curstate->nextstatus;
513: }
514:
515: cuthead = cuttail = nil;
516: if ( delrev && removerevs()) {
517: /* rebuild delta tree if some deltas are deleted */
518: if ( cuttail )
519: VOID genrevs(cuttail->num, (char *)nil,(char *)nil,
520: (char *)nil, gendeltas);
521: buildtree();
522: }
523:
524:
525: /* prepare for rewriting the RCS file */
526: newRCSfilename=mktempfile(RCSfilename,NEWRCSFILE);
527: oldumask = umask(0222); /* turn off write bits */
528: if ((frewrite=fopen(newRCSfilename, "w"))==NULL) {
529: VOID fclose(finptr);
530: error("Can't open file %s",newRCSfilename);
531: continue;
532: }
533: VOID umask(oldumask);
534: putadmin(frewrite);
535: if ( Head )
536: puttree(Head, frewrite);
537: VOID putdesc(initflag,textflag,textfile,quietflag);
538: rewriteflag = false;
539:
540: if ( Head) {
541: if (!delrev) {
542: /* no revision deleted */
543: fastcopy(finptr,frewrite);
544: } else {
545: if ( cuttail )
546: buildeltatext(gendeltas);
547: else
548: scanlogtext((struct hshentry *)nil,empty);
549: /* copy rest of delta text nodes that are not deleted */
550: }
551: }
552: ffclose(frewrite); frewrite = NULL;
553: if ( ! nerror ) { /* move temporary file to RCS file if no error */
554: ignoreints(); /* ignore interrupts */
555: if(rename(newRCSfilename,RCSfilename)<0) {
556: error("Can't create RCS file %s; saved in %s",
557: RCSfilename, newRCSfilename);
558: newRCSfilename[0] = '\0'; /* avoid deletion by cleanup */
559: restoreints();
560: VOID cleanup();
561: break;
562: }
563: newRCSfilename[0]='\0'; /* avoid re-unlinking by cleanup()*/
564: /* update mode */
565: result=0;
566: if (!initflag) /* preserve mode bits */
567: result=chmod(RCSfilename,RCSstat.st_mode & ~0222);
568: elsif (haveworkstat==0) /* initialization, and work file exists */
569: result=chmod(RCSfilename,workstat.st_mode & ~0222);
570: if (result<0) warn("Can't set mode of %s",RCSfilename);
571:
572: restoreints(); /* catch them all again */
573: diagnose("done");
574: } else {
575: diagnose("%s aborted; %s unchanged.",cmdid,RCSfilename);
576: }
577: } while (cleanup(),
578: ++argv, --argc >=1);
579:
580: exit(nerror!=0);
581: } /* end of main (rcs) */
582:
583:
584:
585: getassoclst(flag, sp)
586: int flag;
587: char * sp;
588: /* Function: associate a symbolic name to a revision or branch, */
589: /* and store in assoclst */
590:
591: {
592: struct Symrev * pt;
593: char * temp, *temp2;
594: int c;
595:
596: while( (c=(*++sp)) == ' ' || c == '\t' || c =='\n') ;
597: temp = sp;
598: temp2=checkid(sp, ':'); /* check for invalid symbolic name */
599: sp = temp2; c = *sp; *sp = '\0';
600: while( c == ' ' || c == '\t' || c == '\n') c = *++sp;
601:
602: if ( c != ':' && c != '\0') {
603: error("Invalid string %s after option -n or -N",sp);
604: return;
605: }
606:
607: pt = (struct Symrev *)malloc(sizeof(struct Symrev));
608: pt->ssymbol = temp;
609: pt->override = flag;
610: if (c == '\0') /* delete symbol */
611: pt->revno = nil;
612: else {
613: while( (c = *++sp) == ' ' || c == '\n' || c == '\t') ;
614: if ( c == '\0' )
615: pt->revno = nil;
616: else
617: pt->revno = sp;
618: }
619: pt->nextsym = nil;
620: if (lastassoc)
621: lastassoc->nextsym = pt;
622: else
623: assoclst = pt;
624: lastassoc = pt;
625: return;
626: }
627:
628:
629:
630: struct access * getaccessor( sp)
631: char *sp;
632: /* Function: get the accessor list of options -e and -a, */
633: /* and store in curpt */
634:
635:
636: {
637: struct access * curpt, * pt, *pre;
638: char *temp;
639: register c;
640:
641: while( ( c = *++sp) == ' ' || c == '\n' || c == '\t' || c == ',') ;
642: if ( c == '\0') {
643: error("Missing login name after option -a or -e");
644: return nil;
645: }
646:
647: curpt = pt = nil;
648: while( c != '\0') {
649: temp=checkid(sp,',');
650: pt = (struct access *)malloc(sizeof(struct access));
651: pt->login = sp;
652: if ( curpt )
653: pre->nextaccess = pt;
654: else
655: curpt = pt;
656: pt->nextaccess = curpt;
657: pre = pt;
658: sp = temp; c = *sp; *sp = '\0';
659: while( c == ' ' || c == '\n' || c == '\t'|| c == ',')c =(*++sp);
660: }
661: return pt;
662: }
663:
664:
665:
666: getstates(sp)
667: char *sp;
668: /* Function: get one state attribute and the corresponding */
669: /* revision and store in statelst */
670:
671: {
672: char *temp, *temp2;
673: struct Status *pt;
674: register c;
675:
676: while( (c=(*++sp)) ==' ' || c == '\t' || c == '\n') ;
677: temp = sp;
678: temp2=checkid(sp,':'); /* check for invalid state attribute */
679: sp = temp2; c = *sp; *sp = '\0';
680: while( c == ' ' || c == '\t' || c == '\n' ) c = *++sp;
681:
682: if ( c == '\0' ) { /* change state of def. branch or Head */
683: chgheadstate = true;
684: headstate = temp;
685: return;
686: }
687: else if ( c != ':' ) {
688: error("Missing ':' after state in option -s");
689: return;
690: }
691:
692: while( (c = *++sp) == ' ' || c == '\t' || c == '\n') ;
693: pt = (struct Status *)malloc(sizeof(struct Status));
694: pt->status = temp;
695: pt->revno = sp;
696: pt->nextstatus = nil;
697: if (laststate)
698: laststate->nextstatus = pt;
699: else
700: statelst = pt;
701: laststate = pt;
702: }
703:
704:
705:
706: getrplaccess()
707: /* Function : get the accesslist of the 'accessfile' */
708: /* and place in rplaccessor */
709: {
710: register char *id, *nextp;
711: struct access *newaccess, *curaccess;
712:
713: if ( (finptr=fopen(accessfile, "r")) == NULL) {
714: faterror("Can't open file %s", accessfile);
715: }
716: Lexinit();
717: nextp = &accessorlst[0];
718:
719: if ( ! getkey(Khead)) faterror("Missing head in %s", accessfile);
720: VOID getnum();
721: if ( ! getlex(SEMI) ) serror("Missing ';' after head in %s",accessfile);
722:
723: #ifdef COMPAT2
724: /* read suffix. Only in release 2 format */
725: if (getkey(Ksuffix)) {
726: if (nexttok==STRING) {
727: readstring(); nextlex(); /*through away the suffix*/
728: } elsif(nexttok==ID) {
729: nextlex();
730: }
731: if ( ! getlex(SEMI) ) serror("Missing ';' after suffix in %s",accessfile);
732: }
733: #endif
734:
735: if (! getkey(Kaccess))fatserror("Missing access list in %s",accessfile);
736: curaccess = nil;
737: while( id =getid() ) {
738: newaccess = (struct access *)malloc(sizeof(struct access));
739: newaccess->login = nextp;
740: newaccess->nextaccess = nil;
741: while( ( *nextp++ = *id++) != '\0') ;
742: if ( curaccess )
743: curaccess->nextaccess = newaccess;
744: else
745: rplaccessor = newaccess;
746: curaccess = newaccess;
747: }
748: if ( ! getlex(SEMI))serror("Missing ';' after access list in %s",accessfile);
749: return;
750: }
751:
752:
753:
754: getdelrev(sp)
755: char *sp;
756: /* Function: get revision range or branch to be deleted, */
757: /* and place in delrev */
758: {
759: int c;
760: struct delrevpair *pt;
761:
762: if (delrev) free((char *)delrev);
763:
764: pt = (struct delrevpair *)malloc(sizeof(struct delrevpair));
765: while((c = (*++sp)) == ' ' || c == '\n' || c == '\t') ;
766:
767: if ( c == '<' || c == '-' ) { /* -o -rev or <rev */
768: while( (c = (*++sp)) == ' ' || c == '\n' || c == '\t') ;
769: pt->strt = sp; pt->code = 1;
770: while( c != ' ' && c != '\n' && c != '\t' && c != '\0') c =(*++sp);
771: *sp = '\0';
772: pt->end = nil; delrev = pt;
773: return;
774: }
775: else {
776: pt->strt = sp;
777: while( c != ' ' && c != '\n' && c != '\t' && c != '\0'
778: && c != '-' && c != '<' ) c = *++sp;
779: *sp = '\0';
780: while( c == ' ' || c == '\n' || c == '\t' ) c = *++sp;
781: if ( c == '\0' ) { /* -o rev or branch */
782: pt->end = nil; pt->code = 0;
783: delrev = pt;
784: return;
785: }
786: if ( c != '-' && c != '<') {
787: faterror("Invalid range %s %s after -o", pt->strt, sp);
788: free((char *)pt);
789: return;
790: }
791: while( (c = *++sp) == ' ' || c == '\n' || c == '\t') ;
792: if ( c == '\0') { /* -o rev- or rev< */
793: pt->end = nil; pt->code = 2;
794: delrev = pt;
795: return;
796: }
797: }
798: /* -o rev1-rev2 or rev1<rev2 */
799: pt->end = sp; pt->code = 3; delrev = pt;
800: while( c!= ' ' && c != '\n' && c != '\t' && c != '\0') c = *++sp;
801: *sp = '\0';
802: }
803:
804:
805:
806:
807: scanlogtext(delta,func)
808: struct hshentry * delta; enum stringwork func;
809: /* Function: Scans delta text nodes up to and including the one given
810: * by delta, or up to last one present, if delta==nil.
811: * For the one given by delta (if delta!=nil), the log message is saved into
812: * curlogmsg and the text is processed according to parameter func.
813: * Assumes the initial lexeme must be read in first.
814: * Does not advance nexttok after it is finished, except if delta==nil.
815: */
816: { struct hshentry * nextdelta;
817:
818: do {
819: rewriteflag = false;
820: nextlex();
821: if (!(nextdelta=getnum())) {
822: if(delta)
823: faterror("Can't find delta for revision %s", delta->num);
824: else return; /* no more delta text nodes */
825: }
826: if ( nextdelta->selector != DELETE) {
827: rewriteflag = true;
828: VOID fprintf(frewrite,DELNUMFORM,nextdelta->num,Klog);
829: }
830: if (!getkey(Klog) || nexttok!=STRING)
831: serror("Missing log entry");
832: elsif (delta==nextdelta) {
833: VOID savestring(curlogmsg,logsize);
834: delta->log=curlogmsg;
835: } else {readstring();
836: if (delta!=nil) delta->log="";
837: }
838: nextlex();
839: if (!getkey(Ktext) || nexttok!=STRING)
840: fatserror("Missing delta text");
841:
842: if(delta==nextdelta)
843: /* got the one we're looking for */
844: switch (func) {
845: case copy: copystring();
846: break;
847: case edit: editstring((struct hshentry *)nil);
848: break;
849: default: faterror("Wrong scanlogtext");
850: }
851: else readstring(); /* skip over it */
852:
853: } while (delta!=nextdelta);
854: }
855:
856:
857:
858: releaselst(sourcelst)
859: struct access * sourcelst;
860: /* Function: release the storages whose address are in sourcelst */
861:
862: {
863: struct access * pt;
864:
865: pt = sourcelst;
866: while(pt) {
867: free((char *)pt);
868: pt = pt->nextaccess;
869: }
870: }
871:
872:
873:
874: struct Lockrev * rmnewlocklst(which)
875: struct Lockrev * which;
876: /* Function: remove lock to revision which->revno form newlocklst */
877:
878: {
879: struct Lockrev * pt, *pre;
880:
881: while( newlocklst && (! strcmp(newlocklst->revno, which->revno))){
882: free((char *)newlocklst);
883: newlocklst = newlocklst->nextrev;
884: }
885:
886: pt = pre = newlocklst;
887: while( pt ) {
888: if ( ! strcmp(pt->revno, which->revno) ) {
889: free((char *)pt);
890: pt = pt->nextrev;
891: pre->nextrev = pt;
892: }
893: else {
894: pre = pt;
895: pt = pt->nextrev;
896: }
897: }
898: return pre;
899: }
900:
901:
902:
903: struct access * removeaccess( who, sourcelst,flag)
904: struct access * who, * sourcelst;
905: int flag;
906: /* Function: remove the accessor-- who from sourcelst */
907:
908: {
909: struct access *pt, *pre;
910:
911: pt = sourcelst;
912: while( pt && (! strcmp(who->login, pt->login) )) {
913: free((char *)pt);
914: flag = false;
915: pt = pt->nextaccess;
916: }
917: pre = sourcelst = pt;
918: while( pt ) {
919: if ( ! strcmp(who->login, pt->login) ) {
920: free((char *)pt);
921: flag = false;
922: pt = pt->nextaccess;
923: pre->nextaccess = pt;
924: }
925: else {
926: pre = pt;
927: pt = pt->nextaccess;
928: }
929: }
930: if ( flag ) warn("Can't remove a nonexisting accessor %s",who->login);
931: return sourcelst;
932: }
933:
934:
935:
936: int addnewaccess( who )
937: struct access * who;
938: /* Function: add new accessor-- who into AccessList */
939:
940: {
941: struct access *pt, *pre;
942:
943: pre = pt = AccessList;
944:
945: while( pt ) {
946: if ( strcmp( who->login, pt->login) ) {
947: pre = pt;
948: pt = pt->nextaccess;
949: }
950: else
951: return 0;
952: }
953: if ( pre == pt )
954: AccessList = who;
955: else
956: pre->nextaccess = who;
957: return 1;
958: }
959:
960:
961: sendmail(Delta, who)
962: char * Delta, *who;
963: /* Function: mail to who, informing him that his lock on delta was
964: * broken by caller. Ask first whether to go ahead. Return false on
965: * error or if user decides not to break the lock.
966: */
967: {
968: char * messagefile;
969: int old1, old2, c, response;
970: FILE * mailmess;
971:
972:
973: VOID fprintf(stderr, "Revision %s is already locked by %s.\n", Delta, who);
974: VOID fprintf(stderr, "Do you want to break the lock? [ny](n): ");
975: response=c=getchar();
976: while (!(c==EOF || c=='\n')) c=getchar();/*skip to end of line*/
977: if (response=='\n'||response=='n'||response=='N') return false;
978:
979: /* go ahead with breaking */
980: messagefile=mktempfile("/tmp/", "RCSmailXXXXXX");
981: if ( (mailmess = fopen(messagefile, "w")) == NULL) {
982: faterror("Can't open file %s", messagefile);
983: }
984:
985: VOID fprintf(mailmess, "Subject: Broken lock on %s\n\n",bindex(RCSfilename,'/'));
986: VOID fprintf(mailmess, "Your lock on revision %s of file %s\n",Delta, getfullRCSname());
987: VOID fprintf(mailmess,"has been broken by %s for the following reason:\n",caller);
988: VOID fputs("State the reason for breaking the lock:\n", stderr);
989: VOID fputs("(terminate with ^D or single '.')\n>> ", stderr);
990:
991: old1 = '\n'; old2 = ' ';
992: for (; ;) {
993: c = getchar();
994: if ( c == EOF ) {
995: VOID putc('\n',stderr);
996: VOID fprintf(mailmess, "%c\n", old1);
997: break;
998: }
999: else if ( c == '\n' && old1 == '.' && old2 == '\n')
1000: break;
1001: else {
1002: VOID fputc( old1, mailmess);
1003: old2 = old1; old1 = c;
1004: if (c== '\n') VOID fputs(">> ", stderr);
1005: }
1006: }
1007: ffclose(mailmess);
1008:
1009: #ifdef SENDMAIL
1010: VOID sprintf(command, "/usr/lib/sendmail %s < %s",who,messagefile);
1011: #else
1012: # ifdef DELIVERMAIL
1013: VOID sprintf(command, "/etc/delivermail -w %s < %s",who,messagefile);
1014: # else
1015: VOID sprintf(command, "/bin/mail %s < %s",who,messagefile);
1016: # endif DELIVERMAIL
1017: #endif SENDMAIL
1018:
1019: VOID system(command);
1020: /* ignore the exit status, even if delivermail unsuccessful */
1021: VOID unlink(messagefile);
1022: return(true);
1023: }
1024:
1025:
1026:
1027: struct hshentry * breaklock(who,delta)
1028: char * who; struct hshentry * delta;
1029: /* function: Finds the lock held by who on delta,
1030: * removes it, and returns a pointer to the delta.
1031: * Sends mail if a lock different from the caller's is broken.
1032: * Prints an error message and returns nil if there is no such lock or error.
1033: */
1034: {
1035: register struct lock * next, * trail;
1036: char * num;
1037: struct lock dummy;
1038: int whor, numr;
1039:
1040: num=delta->num;
1041: dummy.nextlock=next=Locks;
1042: trail = &dummy;
1043: while (next!=nil) {
1044: if (num != nil)
1045: numr = strcmp(num, next->delta->num);
1046:
1047: whor=strcmp(who,next->login);
1048: if (whor==0 && numr==0) break; /* exact match */
1049: if (numr==0 && whor !=0) {
1050: if (!sendmail( num, next->login)){
1051: diagnose("%s still locked by %s",num,next->login);
1052: return nil;
1053: } else break; /* continue after loop */
1054: }
1055: trail=next;
1056: next=next->nextlock;
1057: }
1058: if (next!=nil) {
1059: /*found one */
1060: diagnose("%s unlocked",next->delta->num);
1061: trail->nextlock=next->nextlock;
1062: next->delta->lockedby=nil;
1063: Locks=dummy.nextlock;
1064: return next->delta;
1065: } else {
1066: error("no lock set on revision %s", num);
1067: return nil;
1068: }
1069: }
1070:
1071:
1072:
1073: struct hshentry *searchcutpt(object, length, store)
1074: char * object;
1075: int length;
1076: struct hshentry * * store;
1077: /* Function: Search store and return entry with number being object. */
1078: /* cuttail = nil, if the entry is Head; otherwise, cuttail */
1079: /* is the entry point to the one with number being object */
1080:
1081: {
1082: while( compartial( (*store++)->num, object, length) ) ;
1083: store--;
1084:
1085: if ( *store == Head)
1086: cuthead = nil;
1087: else
1088: cuthead = *(store -1);
1089: return *store;
1090: }
1091:
1092:
1093:
1094: int branchpoint(strt, tail)
1095: struct hshentry *strt, *tail;
1096: /* Function: check whether the deltas between strt and tail */
1097: /* are locked or branch point, return 1 if any is */
1098: /* locked or branch point; otherwise, return 0 and */
1099: /* mark DELETE on selector */
1100:
1101: {
1102: struct hshentry *pt;
1103: struct lock *lockpt;
1104: int flag;
1105:
1106:
1107: pt = strt;
1108: flag = false;
1109: while( pt != tail) {
1110: if ( pt->branches ){ /* a branch point */
1111: flag = true;
1112: error("Can't remove branch point %s", pt->num);
1113: }
1114: lockpt = Locks;
1115: while(lockpt && lockpt->delta != pt)
1116: lockpt = lockpt->nextlock;
1117: if ( lockpt ) {
1118: flag = true;
1119: error("Can't remove locked revision %s",pt->num);
1120: }
1121: pt = pt->next;
1122: }
1123:
1124: if ( ! flag ) {
1125: pt = strt;
1126: while( pt != tail ) {
1127: pt->selector = DELETE;
1128: diagnose("deleting revision %s ",pt->num);
1129: pt = pt->next;
1130: }
1131: }
1132: return flag;
1133: }
1134:
1135:
1136:
1137: removerevs()
1138: /* Function: get the revision range to be removed, and place the */
1139: /* first revision removed in delstrt, the revision before */
1140: /* delstrt in cuthead( nil, if delstrt is head), and the */
1141: /* revision after the last removed revision in cuttail(nil */
1142: /* if the last is a leaf */
1143:
1144: {
1145: struct hshentry *target, *target2, * temp, *searchcutpt();
1146: int length, flag;
1147:
1148: flag = false;
1149: if ( ! expandsym(delrev->strt, &numrev[0]) ) return 0;
1150: target = genrevs(&numrev[0], (char *)nil, (char *)nil, (char *)nil, gendeltas);
1151: if ( ! target ) return 0;
1152: if ( cmpnum(target->num, &numrev[0]) ) flag = true;
1153: length = countnumflds( &numrev[0] );
1154:
1155: if ( delrev->code == 0 ) { /* -o rev or -o branch */
1156: if ( length % 2)
1157: temp=searchcutpt(target->num,length+1,gendeltas);
1158: else if (flag) {
1159: error("Revision %s does not exist", &numrev[0]);
1160: return 0;
1161: }
1162: else
1163: temp = searchcutpt(&numrev[0],length,gendeltas);
1164: cuttail = target->next;
1165: if ( branchpoint(temp, cuttail) ) {
1166: cuttail = nil;
1167: return 0;
1168: }
1169: delstrt = temp; /* first revision to be removed */
1170: return 1;
1171: }
1172:
1173: if ( length % 2 ) { /* invalid branch after -o */
1174: error("Invalid branch range %s after -o", &numrev[0]);
1175: return 0;
1176: }
1177:
1178: if ( delrev->code == 1 ) { /* -o -rev */
1179: if ( length > 2 ) {
1180: temp = searchcutpt( target->num, length-1, gendeltas);
1181: cuttail = target->next;
1182: }
1183: else {
1184: temp = searchcutpt(target->num, length, gendeltas);
1185: cuttail = target;
1186: while( cuttail && ! cmpnumfld(target->num,cuttail->num,1) )
1187: cuttail = cuttail->next;
1188: }
1189: if ( branchpoint(temp, cuttail) ){
1190: cuttail = nil;
1191: return 0;
1192: }
1193: delstrt = temp;
1194: return 1;
1195: }
1196:
1197: if ( delrev->code == 2 ) { /* -o rev- */
1198: if ( length == 2 ) {
1199: temp = searchcutpt(target->num, 1,gendeltas);
1200: if ( flag)
1201: cuttail = target;
1202: else
1203: cuttail = target->next;
1204: }
1205: else {
1206: if ( flag){
1207: cuthead = target;
1208: if ( !(temp = target->next) ) return 0;
1209: }
1210: else
1211: temp = searchcutpt(target->num, length, gendeltas);
1212: getbranchno(temp->num, &numrev[0]); /* get branch number */
1213: target = genrevs(&numrev[0], (char *)nil, (char *)nil, (char *)nil, gendeltas);
1214: }
1215: if ( branchpoint( temp, cuttail ) ) {
1216: cuttail = nil;
1217: return 0;
1218: }
1219: delstrt = temp;
1220: return 1;
1221: }
1222:
1223: /* -o rev1-rev2 */
1224: if ( ! expandsym(delrev->end, &numrev[0]) ) return 0;
1225: if ( length != countnumflds( &numrev[0] ) ) {
1226: error("Invalid revision range %s-%s", target->num, &numrev[0]);
1227: return 0;
1228: }
1229: if ( length > 2 && compartial( &numrev[0], target->num, length-1) ) {
1230: error("Invalid revision range %s-%s", target->num, &numrev[0]);
1231: return 0;
1232: }
1233:
1234: target2 = genrevs( &numrev[0], (char *)nil, (char *)nil, (char *)nil,gendeltas);
1235: if ( ! target2 ) return 0;
1236:
1237: if ( length > 2) { /* delete revisions on branches */
1238: if ( cmpnum(target->num, target2->num) > 0) {
1239: if ( cmpnum(target2->num, &numrev[0]) )
1240: flag = true;
1241: else
1242: flag = false;
1243: temp = target;
1244: target = target2;
1245: target2 = temp;
1246: }
1247: if ( flag ) {
1248: if ( ! cmpnum(target->num, target2->num) ) {
1249: error("Revisions %s-%s don't exist", delrev->strt,delrev->end);
1250: return 0;
1251: }
1252: cuthead = target;
1253: temp = target->next;
1254: }
1255: else
1256: temp = searchcutpt(target->num, length, gendeltas);
1257: cuttail = target2->next;
1258: }
1259: else { /* delete revisions on trunk */
1260: if ( cmpnum( target->num, target2->num) < 0 ) {
1261: temp = target;
1262: target = target2;
1263: target2 = temp;
1264: }
1265: else
1266: if ( cmpnum(target2->num, &numrev[0]) )
1267: flag = true;
1268: else
1269: flag = false;
1270: if ( flag ) {
1271: if ( ! cmpnum(target->num, target2->num) ) {
1272: error("Revisions %s-%s don't exist", delrev->strt, delrev->end);
1273: return 0;
1274: }
1275: cuttail = target2;
1276: }
1277: else
1278: cuttail = target2->next;
1279: temp = searchcutpt(target->num, length, gendeltas);
1280: }
1281: if ( branchpoint(temp, cuttail) ) {
1282: cuttail = nil;
1283: return 0;
1284: }
1285: delstrt = temp;
1286: return 1;
1287: }
1288:
1289:
1290:
1291: updateassoc()
1292: /* Function: add or delete(if revno is nil) association */
1293: /* which is stored in assoclst */
1294:
1295: {
1296: struct Symrev * curassoc;
1297: struct assoc * pre, * pt;
1298: struct hshentry * target;
1299:
1300: /* add new associations */
1301: curassoc = assoclst;
1302: while( curassoc ) {
1303: if ( curassoc->revno == nil ) { /* delete symbol */
1304: pre = pt = Symbols;
1305: while( pt && strcmp(pt->symbol,curassoc->ssymbol) ) {
1306: pre = pt;
1307: pt = pt->nextassoc;
1308: }
1309: if ( pt )
1310: if ( pre == pt )
1311: Symbols = pt->nextassoc;
1312: else
1313: pre->nextassoc = pt->nextassoc;
1314: else
1315: warn("Can't delete nonexisting symbol %s",curassoc->ssymbol);
1316: }
1317: else if ( expandsym( curassoc->revno, &numrev[0] ) ) {
1318: /* add symbol */
1319: target = (struct hshentry *) malloc(sizeof(struct hshentry));
1320: target->num = &numrev[0];
1321: VOID addsymbol(target, curassoc->ssymbol, curassoc->override);
1322: }
1323: curassoc = curassoc->nextsym;
1324: }
1325:
1326: }
1327:
1328:
1329:
1330: updatelocks()
1331: /* Function: remove lock for caller or first lock if unlockcaller==true;
1332: * remove locks which are stored in rmvlocklst,
1333: * add new locks which are stored in newlocklst,
1334: * add lock for Dbranch or Head if lockhead==true.
1335: */
1336: {
1337: struct hshentry *target;
1338: struct Lockrev *lockpt;
1339:
1340: if(unlockcaller == true) { /* find lock for caller */
1341: if ( Head ) {
1342: if (Locks) {
1343: target=findlock(caller,true);
1344: if (target==nil) {
1345: breaklock(caller, Locks->delta); /* remove most recent lock */
1346: } else {
1347: diagnose("%s unlocked",target->num);
1348: }
1349: } else {
1350: warn("There are no locks set.");
1351: }
1352: } else {
1353: warn("Can't unlock an empty tree");
1354: }
1355: }
1356:
1357: /* remove locks which are stored in rmvlocklst */
1358: lockpt = rmvlocklst;
1359: while( lockpt ) {
1360: if (expandsym(lockpt->revno, numrev)) {
1361: target = genrevs(numrev, (char *)nil, (char *)nil, (char *)nil, gendeltas);
1362: if ( target )
1363: if ( !(countnumflds(numrev)%2) && cmpnum(target->num,numrev))
1364: error("Can't unlock nonexisting revision %s",lockpt->revno);
1365: else
1366: breaklock(caller, target);
1367: /* breaklock does its own diagnose */
1368: }
1369: lockpt = lockpt->nextrev;
1370: }
1371:
1372: /* add new locks which stored in newlocklst */
1373: lockpt = newlocklst;
1374: while( lockpt ) {
1375: setlock(lockpt->revno,caller);
1376: lockpt = lockpt->nextrev;
1377: }
1378:
1379: if ( lockhead == true) { /* lock default branch or head */
1380: if (Dbranch) {
1381: setlock(Dbranch->num,caller);
1382: } elsif ( Head) {
1383: if (addlock(Head, caller))
1384: diagnose("%s locked",Head->num);
1385: } else {
1386: warn("Can't lock an empty tree");
1387: }
1388: }
1389:
1390: }
1391:
1392:
1393:
1394: setlock(rev,who)
1395: char * rev, * who;
1396: /* Function: Given a revision or branch number, finds the correponding
1397: * delta and locks it for who.
1398: */
1399: {
1400: struct lock *lpt;
1401: struct hshentry *target;
1402:
1403: if (expandsym(rev, &numrev[0]) ){
1404: target = genrevs(&numrev[0],(char *) nil,(char *) nil,
1405: (char *)nil, gendeltas);
1406: if ( target )
1407: if ( !(countnumflds(&numrev[0])%2) && cmpnum(target->num,&numrev[0]))
1408: error("Can't lock nonexisting revision %s",numrev);
1409: else
1410: if(lpt=addlock(target, who))
1411: diagnose("%s locked",lpt->delta->num);
1412: }
1413: }
1414:
1415:
1416:
1417: rcs_setstate(rev,status)
1418: char * rev, * status;
1419: /* Function: Given a revision or branch number, finds the corresponding delta
1420: * and sets its state to status.
1421: */
1422: {
1423: struct hshentry *target;
1424:
1425: if ( expandsym(rev, &numrev[0]) ) {
1426: target = genrevs(&numrev[0],(char *) nil, (char *)nil,
1427: (char *) nil, gendeltas);
1428: if ( target )
1429: if ( !(countnumflds(&numrev[0])%2) && cmpnum(target->num, &numrev[0]) )
1430: error("Can't set state of nonexisting revision %s to %s",
1431: numrev,status);
1432: else
1433: target->state = status;
1434: }
1435: }
1436:
1437:
1438:
1439:
1440:
1441: buildeltatext(deltas)
1442: struct hshentry ** deltas;
1443: /* Function: put the delta text on frewrite and make necessary */
1444: /* change to delta text */
1445: {
1446: int i, c, exit_stats;
1447:
1448: cuttail->selector = DELETE;
1449: initeditfiles("/tmp/");
1450: scanlogtext(deltas[0], copy);
1451: i = 1;
1452: if ( cuthead ) {
1453: cutfilename=mktempfile("/tmp/", "RCScutXXXXXX");
1454: if ( (fcut = fopen(cutfilename, "w")) == NULL) {
1455: faterror("Can't open temporary file %s", cutfilename);
1456: }
1457:
1458: while( deltas[i-1] != cuthead ) {
1459: scanlogtext(deltas[i++], edit);
1460: }
1461:
1462: finishedit((struct hshentry *)nil); rewind(fcopy);
1463: while( (c = getc(fcopy)) != EOF) VOID putc(c, fcut);
1464: swapeditfiles(false);
1465: ffclose(fcut);
1466: }
1467:
1468: while( deltas[i-1] != cuttail)
1469: scanlogtext(deltas[i++], edit);
1470: finishedit((struct hshentry *)nil); ffclose(fcopy);
1471:
1472: if ( cuthead ) {
1473: diffilename=mktempfile("/tmp/", "RCSdifXXXXXX");
1474: VOID sprintf(command, "%s -n %s %s > %s", DIFF,cutfilename, resultfile, diffilename);
1475: exit_stats = system (command);
1476: if (exit_stats != 0 && exit_stats != (1 << BYTESIZ))
1477: faterror ("diff failed");
1478: if(!putdtext(cuttail->num,curlogmsg,diffilename,frewrite)) return;
1479: }
1480: else
1481: if (!putdtext(cuttail->num,curlogmsg,resultfile,frewrite)) return;
1482:
1483: scanlogtext((struct hshentry *)nil,empty); /* read the rest of the deltas */
1484: }
1485:
1486:
1487:
1488: buildtree()
1489: /* Function: actually removes revisions whose selector field */
1490: /* is DELETE, and rebuilds the linkage of deltas. */
1491: /* asks for reconfirmation if deleting last revision*/
1492: {
1493: int c, response;
1494:
1495: struct hshentry * Delta;
1496: struct branchhead *pt, *pre;
1497:
1498: if ( cuthead )
1499: if ( cuthead->next == delstrt )
1500: cuthead->next = cuttail;
1501: else {
1502: pre = pt = cuthead->branches;
1503: while( pt && pt->hsh != delstrt ) {
1504: pre = pt;
1505: pt = pt->nextbranch;
1506: }
1507: if ( cuttail )
1508: pt->hsh = cuttail;
1509: else if ( pt == pre )
1510: cuthead->branches = pt->nextbranch;
1511: else
1512: pre->nextbranch = pt->nextbranch;
1513: }
1514: else {
1515: if ( cuttail == nil && !quietflag) {
1516: VOID fprintf(stderr,"Do you really want to delete all revisions ?[ny](n): ");
1517: c = response = getchar();
1518: while( c != EOF && c != '\n') c = getchar();
1519: if ( response != 'y' && response != 'Y') {
1520: diagnose("No revision deleted");
1521: Delta = delstrt;
1522: while( Delta) {
1523: Delta->selector = 'S';
1524: Delta = Delta->next;
1525: }
1526: return;
1527: }
1528: }
1529: Head = cuttail;
1530: }
1531: return;
1532: }
1533:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.