![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcsrev.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 rcsrev.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src |
1.1 root 1:
2: /*
3: * RCS revision number handling
4: */
5: static char rcsid[]=
6: "$Header: /usr/wft/RCS/SRC/RCS/rcsrev.c,v 3.4 82/12/04 13:24:08 wft Exp $ Purdue CS";
7: /*********************************************************************************
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: /* $Log: rcsrev.c,v $
23: * Revision 3.4 82/12/04 13:24:08 wft
24: * Replaced getdelta() with gettree().
25: *
26: * Revision 3.3 82/11/28 21:33:15 wft
27: * fixed compartial() and compnum() for nil-parameters; fixed nils
28: * in error messages. Testprogram output shortenend.
29: *
30: * Revision 3.2 82/10/18 21:19:47 wft
31: * renamed compnum->cmpnum, compnumfld->cmpnumfld,
32: * numericrevno->numricrevno.
33: *
34: * Revision 3.1 82/10/11 19:46:09 wft
35: * changed expandsym() to check for source==nil; returns zero length string
36: * in that case.
37: */
38:
39:
40:
41: /*
42: #define REVTEST
43: /* version REVTEST is for testing the routines that generate a sequence
44: * of delta numbers needed to regenerate a given delta.
45: */
46:
47: #include "rcsbase.h"
48:
49: extern FILE * finptr; /* RCS input file */
50: extern char * getid();
51: extern struct hshentry * getnum();
52: extern int getkey();
53: extern int getlex();
54:
55: extern char * getkeyval();
56: extern int delta(), deltatext();
57: struct hshentry * genbranch(); /* forward */
58:
59:
60:
61: int countnumflds(s)
62: char * s;
63: /* Given a pointer s to a dotted number (date or revision number),
64: * countnumflds returns the number of digitfields in s.
65: */
66: { register char * sp;
67: register int count;
68: if ((sp=s)==nil) return(0);
69: if (*sp == '\0') return(0);
70: count = 1;
71: while (*sp) {
72: if (*sp++ == '.') count++;
73: }
74: if (*(--sp) == '.') count--; /*trailing periods don't count*/
75: return(count);
76: }
77:
78: getbranchno(revno,branchno)
79: char * revno, * branchno;
80: /* Given a non-nil revision number revno, getbranchno copies the number of the branch
81: * on which revno is into branchnumber. If revno itself is a branch number,
82: * it is copied unchanged.
83: */
84: {
85: register int i, numflds;
86: register char * tp, * sp;
87:
88: numflds=countnumflds(revno);
89: if (numflds%2 == 1)
90: strcpy(branchno,revno);
91: else {
92: sp=revno; tp=branchno;
93: for (i=1;i<numflds;i++) {
94: while(*sp!='.') *tp++ = *sp++;
95: *tp++ = *sp++;
96: }
97: *(tp-1)='\0';
98: }
99: }
100:
101:
102:
103: int cmpnum(num1, num2)
104: char * num1, * num2;
105: /* compares the two dotted numbers num1 and num2 lexicographically
106: * by field. Individual fields are compared numerically.
107: * returns <0, 0, >0 if num1<num2, num1==num2, and num1>num2, resp.
108: * omitted fields are assumed to be higher than the existing ones.
109: */
110: {
111: register char * s1, *s2;
112: register int n1, n2;
113:
114: s1=num1==nil?"":num1;
115: s2=num2==nil?"":num2;
116:
117: do {
118: n1 = 0;
119: while (('0' <= *s1) && (*s1 <= '9')) {
120: n1 = n1*10 + (*s1 - '0');
121: s1++;
122: }
123: /* skip '.' */
124: if (*s1=='.') s1++;
125:
126: n2 = 0;
127: while (('0' <= *s2) && (*s2 <= '9')) {
128: n2 = n2*10 + (*s2 - '0');
129: s2++;
130: }
131: /* skip '.' */
132: if (*s2=='.') s2++;
133:
134: } while ((n1==n2) && (*s1!='\0') && (*s2!='\0'));
135:
136: if (((*s1=='\0') && (*s2=='\0')) || (n1!=n2))
137: return (n1 - n2);
138: /*now n1==n2 and one of s1 or s2 is shorter*/
139: /*give precedence to shorter one*/
140: if (*s1=='\0') return 1;
141: else return -1;
142:
143: }
144:
145:
146:
147: int cmpnumfld(num1, num2, fld)
148: char * num1, * num2; int fld;
149: /* compares the two dotted numbers at field fld and returns
150: * num1[fld]-num2[fld]. Assumes that num1 and num2 have at least fld fields.
151: */
152: {
153: register char * s1, *s2;
154: register int n1, n2;
155:
156: s1=num1; n1=fld-1;
157: /* skip fld-1 fields */
158: while (n1) {
159: while(*s1 != '.') s1++;
160: n1--; s1++;
161: }
162: s2 = num2; n2=fld-1;
163: while (n2) {
164: while(*s2 != '.') s2++;
165: n2--; s2++;
166: }
167: /* Don't put the above into a single loop! */
168: /* Now s1 and s2 point to the beginning of the respective fields */
169: /* compute numerical value and compare */
170: n1 = 0;
171: while (('0' <= *s1) && (*s1 <= '9')) {
172: n1 = n1*10 + (*s1 - '0');
173: s1++;
174: }
175: n2 = 0;
176: while (('0' <= *s2) && (*s2 <= '9')) {
177: n2 = n2*10 + (*s2 - '0');
178: s2++;
179: }
180: return (n1 - n2);
181: }
182:
183:
184: int compartial(num1, num2, length)
185: char * num1;
186: char * num2;
187: int length;
188:
189: /* compare the first "length" fields of two dot numbers;
190: the omitted field is considered to be larger than any number */
191: /* restriction: at least one number has length or more fields */
192:
193: {
194: register char *s1, *s2;
195: register int n1, n2;
196:
197:
198: s1 = num1; s2 = num2;
199: if ( s1==nil || *s1 == '\0' ) return 1;
200: if ( s2==nil || *s2 == '\0' ) return -1;
201:
202: do {
203: n1 = 0;
204: while( ('0' <= *s1) && (*s1 <= '9') ) {
205: n1 = n1 * 10 + (*s1 - '0') ;
206: s1++;
207: }
208: if ( *s1 == '.' ) s1++; /* skip . */
209:
210: n2 = 0;
211: while( ( '0' <= *s2) && ( *s2 <= '9' ) ) {
212: n2 = n2 * 10 + ( *s2 - '0' ) ;
213: s2++;
214: }
215: if (*s2 == '.') s2++;
216: } while( ( n1 == n2) && ((--length) != 0) &&
217: ( *s1 != '\0') && (*s2 != '\0') );
218:
219: if ( (n1 != n2) || (length == 0) ){
220: return(n1-n2); }
221:
222: if ( *s1 == '\0' ) return 1;
223: if ( *s2 == '\0' ) return -1;
224: }
225:
226:
227:
228: incnum(onum,nnum)
229: char * onum, *nnum;
230: /* increments the last field of revision number onum by one and
231: * places the result into nnum
232: */
233: {
234: register char * sp, *tp;
235: register int i;
236:
237: sp = onum; tp = nnum;
238: for (i=countnumflds(onum)-1; i>0; i--) {
239: while (*sp != '.') *tp++ = *sp++;
240: *tp++ = *sp++; /* copy dot also */
241: }
242: sprintf(tp,"%d",atoi(sp)+1);
243: }
244:
245:
246: char * partialno(rev1,rev2,length)
247: char * rev1, * rev2; register int length;
248: /* Function: Copies length fields of revision number rev2 into rev1.
249: * returns rev1.
250: */
251: { register char * r1,* r2;
252:
253: r1=rev1; r2=rev2;
254: while (length) {
255: while(*r2 != '.' && *r2!='\0') *r1++ = *r2++;
256: *r1++ = *r2++;
257: length--;
258: }
259: /* eliminate last '.'*/
260: *(r1-1)='\0';
261: return rev1;
262: }
263:
264:
265:
266: char * getancestor(r1, r2, r3)
267: char * r1, *r2, *r3;
268: /* function: finds the common ancestor of r1 and r2 and
269: * places it into r3.
270: * returns r3 if successful, false otherwise.
271: * works reliably only if r1 and r2 are not branch numbers.
272: */
273: { int l1, l2, l3;
274: char t1[revlength], t2[revlength];
275:
276: l1=countnumflds(r1); l2=countnumflds(r2);
277: if ((l1<=2 && l2<=2)||(cmpnum(r1,r2)==0)) {
278: /* on main trunk or identical */
279: error("Common ancestor of %s and %s undefined.", r1, r2);
280: return false;
281: }
282:
283: l3=0;
284: while ((cmpnumfld(r1, r2, l3+1)==0) && (cmpnumfld(r1, r2, l3+2)==0)){
285: l3=l3+2;
286: }
287: /* This will terminate since r1 and r2 are not the same; see above*/
288: if (l3==0) {
289: /* no common prefix. Common ancestor on main trunk. */
290: partialno(t1,r1,l1>2?2:l1);partialno(t2,r2,l2>2?2:l2);
291: if (cmpnum(t1,t2)<0)
292: strcpy(r3,t1);
293: else strcpy(r3,t2);
294: if ((cmpnum(r3,r1)==0)||(cmpnum(r3,r2)==0)) {
295: error("Ancestor for %s and %s undefined.",r1,r2);
296: return false;
297: }
298: return r3;
299: } else {
300: if (cmpnumfld(r1,r2,l3+1)==0) {
301: error("Ancestor for %s and %s undefined.",r1,r2);
302: return false;
303: }
304: return(partialno(r3,r1,l3));
305: }
306: }
307:
308:
309:
310:
311: struct hshentry * genrevs(revno,date,author,state,store)
312: char * revno, * date, * author, * state;
313: struct hshentry * * store;
314: /* Function: finds the deltas needed for reconstructing the
315: * revision given by revno, date, author, and state, and stores pointers
316: * to these deltas into an array whose starting address is given by store.
317: * The last pointer stored is nil. The last delta (target delta) is returned.
318: * If the proper delta could not be found, nil is returned.
319: */
320: {
321: int length;
322: register struct hshentry * next;
323: int result;
324: char * branchnum;
325: char t[revlength];
326:
327: if (Head == nil) {
328: error("RCSfile empty.");
329: return nil;
330: }
331:
332: length = countnumflds(revno);
333: next=Head;
334:
335: if (length >= 1) {
336: /* at least one field; find branch exactly */
337: while ((next!=nil) &&
338: ((result=cmpnumfld(revno,next->num,1))<0)) {
339: /*puts(next->num);*/
340: *store++ = next;
341: next = next->next;
342: }
343:
344: if (next==nil) {error("Branch number %s too low.",partialno(t,revno,1));return nil;}
345: if (result>0) {error("Branch number %s not present.",partialno(t,revno,1));return nil;}
346: }
347: if (length<=1){
348: /* pick latest one on given branch */
349: branchnum = next->num; /* works even for empty revno*/
350: while ((next!=nil) &&
351: (cmpnumfld(branchnum,next->num,1)==0) &&
352: !(
353: (date==nil?1:(cmpnum(date,next->date)>=0)) &&
354: (author==nil?1:(strcmp(author,next->author)==0)) &&
355: (state ==nil?1:(strcmp(state, next->state) ==0))
356: )
357: )
358: { /*puts(next->num);*/
359: *store ++ = next;
360: next=next->next;
361: }
362: if ((next==nil) ||
363: (cmpnumfld(branchnum,next->num,1)!=0))/*overshot*/ {
364: error("Cannot find revision on branch %s with a date before %s, author %s, and state %s.",
365: length==0?partialno(t,branchnum,1):revno,date==nil?"<now>":date,
366: author==nil?"<any>":author, state==nil?"<any>":state);
367: return nil;
368: } else {
369: /*puts(next->num);*/
370: *store++ = next;
371: }
372: *store = nil;
373: return next;
374: }
375:
376: /* length >=2 */
377: /* find revision; may go low if length==2*/
378: while ((next!=nil) &&
379: ((result =cmpnumfld(revno,next->num,2)) <0) &&
380: (cmpnumfld(revno,next->num,1)==0) ) {
381: /*puts(next->num);*/
382: *store++ = next;
383: next = next->next;
384: }
385:
386: if ((next==nil) || (cmpnumfld(revno,next->num,1)!=0)) {
387: error("Revision number %s too low.",partialno(t,revno,2));
388: return nil;
389: }
390: if ((length>2) && (result!=0)) {
391: error("Revision %s not present.",partialno(t,revno,2));
392: return nil;
393: }
394:
395: /* print last one */
396: /*puts(next->num);*/
397: *store++ = next;
398:
399: if (length>2)
400: return genbranch(next,revno,length,date,author,state,store);
401: else { /* length == 2*/
402: if ((date!=nil) && (cmpnum(date,next->date)<0)){
403: error("Revision %s has date %s.",next->num, next->date);
404: return nil;
405: }
406: if ((author!=nil)&&(strcmp(author,next->author)!=0)) {
407: error("Revision %s has author %s.",next->num,next->author);
408: return nil;
409: }
410: if ((state!=nil)&&(strcmp(state,next->state)!=0)) {
411: error("Revision %s has state %s.",next->num,
412: next->state==nil?"<empty>":next->state);
413: return nil;
414: }
415: *store=nil;
416: return next;
417: }
418: }
419:
420:
421:
422:
423: struct hshentry * genbranch(bpoint, revno, length,date,author,state,store)
424: struct hshentry * bpoint;
425: char * revno; int length;
426: char * date, * author, * state;
427: struct hshentry ** store;
428: /* Function: given a branchpoint, a revision number, date, author, and state,
429: * genbranch finds the deltas necessary to reconstruct the given revision
430: * from the branch point on.
431: * Pointers to the found deltas are stored in an array beginning with store.
432: * revno must be on a side branch.
433: * return nil on error
434: */
435: {
436: int field;
437: register struct hshentry * next, * trail;
438: register struct branchhead * bhead;
439: int result;
440: char t[revlength];
441:
442: bhead = bpoint->branches;
443:
444: for (field=3; field<=length; field=field+2) {
445:
446: if (bhead==nil) {error("No side branches present for %s.",partialno(t,revno,field-1));return nil;}
447:
448: /*find branch head*/
449: /*branches are arranged in increasing order*/
450: while ((bhead!=nil) &&
451: ((result=cmpnumfld(revno,bhead->hsh->num,field))>0)) {
452: bhead = bhead->nextbranch;
453: }
454:
455: if (bhead==nil) {error("Branch number %s too high.",partialno(t,revno,field));return nil;}
456: if (result<0) {error("Branch number %s not present.",partialno(t,revno,field));return nil;}
457:
458: next = bhead->hsh;
459: if (length==field) {
460: /* pick latest one on that branch */
461: trail=nil;
462: do { if ((date==nil?1:(cmpnum(date,next->date)>=0)) &&
463: (author==nil?1:(strcmp(author,next->author)==0)) &&
464: (state ==nil?1:(strcmp(state, next->state) ==0))
465: ) trail = next;
466: next=next->next;
467: } while (next!=nil);
468:
469: if (trail==nil) {
470: error("Cannot find revision on branch %s with a date before %s, author %s, and state %s.",
471: revno, date==nil?"<now>":date,
472: author==nil?"<any>":author, state==nil?"<any>":state);
473: return nil;
474: } else { /* print up to last one suitable */
475: next = bhead->hsh;
476: while (next!=trail) {
477: /*puts(next->num);*/
478: *store++ = next;
479: next=next->next;
480: }
481: /*puts(next->num);*/
482: *store++ = next;
483: }
484: *store = nil;
485: return next;
486: }
487:
488: /* length > field */
489: /* find revision */
490: /* check low */
491: if (cmpnumfld(revno,next->num,field+1)<0) {
492: error("Revision number %s too low.",partialno(t,revno,field+1));
493: return(nil);
494: }
495: do { /*puts(next->num);*/
496: *store++ = next;
497: trail = next;
498: next = next->next;
499: } while ((next!=nil) &&
500: (cmpnumfld(revno,next->num,field+1) >=0));
501:
502: if ((length>field+1) && /*need exact hit */
503: (cmpnumfld(revno,trail->num,field+1) !=0)){
504: error("Revision %s not present.",partialno(t,revno,field+1));
505: return(nil);
506: }
507: if (length == field+1) {
508: if ((date!=nil) && (cmpnum(date,trail->date)<0)){
509: error("Revision %s has date %s.",trail->num, trail->date);
510: return nil;
511: }
512: if ((author!=nil)&&(strcmp(author,trail->author)!=0)) {
513: error("Revision %s has author %s.",trail->num,trail->author);
514: return nil;
515: }
516: if ((state!=nil)&&(strcmp(state,trail->state)!=0)) {
517: error("Revision %s has state %s.",trail->num,
518: trail->state==nil?"<empty>":trail->state);
519: return nil;
520: }
521: }
522: bhead = trail->branches;
523:
524: }
525: * store = nil;
526: return trail;
527: }
528:
529:
530: char * lookupsym(id)
531: char * id;
532: /* Function: looks up id in the list of symbolic names starting
533: * with pointer SYMBOLS, and returns a pointer to the corresponding
534: * revision number. Returns nil if not present.
535: */
536: {
537: register struct assoc * next;
538: next = Symbols;
539: while (next!=nil) {
540: if (strcmp(id, next->symbol)==0)
541: return(next->delta->num);
542: else next=next->nextassoc;
543: }
544: return nil;
545: }
546:
547: int expandsym(source, target)
548: char * source, * target;
549: /* Function: Source points to a revision number. Expandsym copies
550: * the number to target, but replaces all symbolic fields in the
551: * source number with their numeric values.
552: * A trailing '.' is omitted; leading zeroes are compressed.
553: * returns false on error;
554: */
555: { register char * sp, * tp, *bp;
556: char symbuf[30];
557: register enum tokens d;
558:
559: sp = source; tp=target;
560: if (sp == nil) { /*accept nil pointer as a legal value*/
561: *tp='\0';
562: return true;
563: }
564:
565: while (*sp != '\0') {
566: if (ctab[*sp] == DIGIT) {
567: if (*sp=='0') {
568: /* skip leading zeroes */
569: sp++;
570: while(*sp == '0') sp++;
571: if (*sp=='\0' || *sp=='.') *tp++ = '0'; /*single zero*/
572: }
573: while(ctab[*sp] == DIGIT) *tp++ = *sp++;
574: if ((*sp == '\0') || ((*sp=='.')&&(*(sp+1)=='\0'))) {
575: *tp='\0'; return true;
576: }
577: if (*sp == '.') *tp++ = *sp++;
578: else {
579: error("Improper revision number: %s",source);
580: *tp = '\0';
581: return false;
582: }
583: } elsif (ctab[*sp] == LETTER) {
584: bp = symbuf;
585: do { *bp++ = *sp++;
586: } while(((d=ctab[*sp])==LETTER) || (d==DIGIT) ||
587: (d==IDCHAR));
588: *bp= '\0';
589: bp=lookupsym(symbuf);
590: if (bp==nil) {
591: error("Symbolic number %s is undefined.",symbuf);
592: *tp='\0';
593: return false;
594: } else { /* copy number */
595: while (*tp++ = *bp++); /* copies the trailing \0*/
596: }
597: if ((*sp == '\0') || ((*sp=='.')&&(*(sp+1)=='\0')))
598: return true;
599: if (*sp == '.') {
600: *(tp-1) = *sp++;
601: } else {
602: error("Improper revision number: %s",source);
603: return false;
604: }
605: }else {
606: error("Improper revision number: %s", source);
607: *tp = '\0';
608: return false;
609: }
610: }
611: *tp = '\0';
612: return true;
613: }
614:
615:
616:
617: #ifdef REVTEST
618:
619: main(argc,argv)
620: int argc; char * argv[];
621: {
622: char symrevno[revlength]; /* used for input of revision numbers */
623: char numricrevno[revlength];
624: char author[20];
625: char state[20];
626: char date[20];
627: struct hshentry * gendeltas[hshsize/2];
628: struct hshentry * target;
629: int i;
630:
631: cmdid = "revtest";
632: if (argc<2) {
633: fputs("No input file\n",stderr);
634: exit(-1);
635: }
636: if ((finptr=fopen(argv[1], "r")) == NULL) {
637: faterror("Can't open input file %s\n",argv[1]);
638: }
639: Lexinit();
640: getadmin();
641:
642: gettree();
643:
644: getdesc(false);
645:
646: do {
647: /* all output goes to stderr, to have diagnostics and */
648: /* errors in sequence. */
649: fprintf(stderr,"\nEnter revision number or <return> or '.': ");
650: if(gets(symrevno)==NULL) break;
651: if (*symrevno == '.') break;
652: fprintf(stderr,"%s;\n",symrevno);
653: expandsym(symrevno,numricrevno);
654: fprintf(stderr,"expanded number: %s; ",numricrevno);
655: fprintf(stderr,"Date: ");
656: gets(date); fprintf(stderr,"%s; ",date);
657: fprintf(stderr,"Author: ");
658: gets(author);fprintf(stderr,"%s; ",author);
659: fprintf(stderr,"State: ");
660: gets(state); fprintf(stderr, "%s;\n", state);
661: target=genrevs(numricrevno,*date=='\0'?nil:date, *author=='\0'?nil:author,
662: *state=='\0'?nil:state,gendeltas);
663: if (target!=nil) {
664: i=0;
665: while (gendeltas[i]!=nil) {
666: fprintf(stderr,"%s\n",gendeltas[i++]->num);
667: }
668: }
669: } while (true);
670: clearerr(stdin);
671: fprintf(stderr,"done\n");
672:
673: }
674:
675: cleanup(){}
676: /*dummy*/
677:
678: #endif REVTEST
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.