![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcsgen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / rcs / src|
Return to rcsgen.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / rcs / src |
1.1 root 1: /*
2: * RCS revision generation
3: */
4: #ifndef lint
5: static char rcsid[]= "$Id: rcsgen.c,v 3.8 89/08/15 21:38:51 bostic Exp $ Purdue CS";
6: #endif
7:
8: /* Copyright (C) 1982, 1988, 1989 Walter Tichy
9: * All rights reserved.
10: *
11: * Redistribution and use in source and binary forms are permitted
12: * provided that the above copyright notice and this paragraph are
13: * duplicated in all such forms and that any documentation,
14: * advertising materials, and other materials related to such
15: * distribution and use acknowledge that the software was developed
16: * by Walter Tichy.
17: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
18: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
19: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20: *
21: * Report all problems and direct all questions to:
22: * [email protected]
23: *
24:
25:
26:
27:
28:
29:
30:
31: */
32:
33:
34:
35: /* $Log: rcsgen.c,v $
36: * Revision 3.8 89/08/15 21:38:51 bostic
37: * Version 4 from Tom Narten at Purdue
38: *
39: * Revision 4.7 89/05/01 15:12:49 narten
40: * changed copyright header to reflect current distribution rules
41: *
42: * Revision 4.6 88/11/08 12:01:13 narten
43: * changes from [email protected] (Paul Eggert)
44: *
45: * Revision 4.6 88/08/28 14:59:10 eggert
46: * Shrink stdio code size; allow cc -R; remove lint; isatty() -> ttystdin()
47: *
48: * Revision 4.5 87/12/18 11:43:25 narten
49: * additional lint cleanups, and a bug fix from the 4.3BSD version that
50: * keeps "ci" from sticking a '\377' into the description if you run it
51: * with a zero-length file as the description. (Guy Harris)
52: *
53: * Revision 4.4 87/10/18 10:35:10 narten
54: * Updating version numbers. Changes relative to 1.1 actually relative to
55: * 4.2
56: *
57: * Revision 1.3 87/09/24 13:59:51 narten
58: * Sources now pass through lint (if you ignore printf/sprintf/fprintf
59: * warnings)
60: *
61: * Revision 1.2 87/03/27 14:22:27 jenkins
62: * Port to suns
63: *
64: * Revision 1.1 84/01/23 14:50:28 kcs
65: * Initial revision
66: *
67: * Revision 4.2 83/12/02 23:01:39 wft
68: * merged 4.1 and 3.3.1.1 (clearerr(stdin)).
69: *
70: * Revision 4.1 83/05/10 16:03:33 wft
71: * Changed putamin() to abort if trying to reread redirected stdin.
72: * Fixed getdesc() to output a prompt on initial newline.
73: *
74: * Revision 3.3.1.1 83/10/19 04:21:51 lepreau
75: * Added clearerr(stdin) for re-reading description from stdin.
76: *
77: * Revision 3.3 82/11/28 21:36:49 wft
78: * 4.2 prerelease
79: *
80: * Revision 3.3 82/11/28 21:36:49 wft
81: * Replaced ferror() followed by fclose() with ffclose().
82: * Putdesc() now suppresses the prompts if stdin
83: * is not a terminal. A pointer to the current log message is now
84: * inserted into the corresponding delta, rather than leaving it in a
85: * global variable.
86: *
87: * Revision 3.2 82/10/18 21:11:26 wft
88: * I added checks for write errors during editing, and improved
89: * the prompt on putdesc().
90: *
91: * Revision 3.1 82/10/13 15:55:09 wft
92: * corrected type of variables assigned to by getc (char --> int)
93: */
94:
95:
96:
97:
98: #include "rcsbase.h"
99:
100: extern struct hshentry * getnum();
101: extern FILE * fopen();
102: extern savestring();
103: extern editstring();
104:
105: extern int nextc; /* next character from lexical analyzer */
106: extern char Ktext[]; /* keywords from syntax analyzer */
107: extern char Klog[]; /* Keyword "log" */
108: extern char Kdesc[]; /* Keyword for description */
109: extern FILE * frewrite; /* new RCS file */
110: extern FILE * fcopy; /* result file during editing */
111: extern char * resultfile; /* file name for fcopy */
112: extern int rewriteflag; /* indicates whether to rewrite the input file */
113:
114:
115: char curlogmsg[logsize]; /* buffer for current log message */
116:
117: enum stringwork {copy, edit, expand, edit_expand };
118: /* parameter to scandeltatext() */
119:
120:
121:
122:
123: char * buildrevision(deltas, target, dir, expandflag)
124: struct hshentry ** deltas, * target;
125: char * dir; int expandflag;
126: /* Function: Generates the revision given by target
127: * by retrieving all deltas given by parameter deltas and combining them.
128: * If dir==nil, the revision is printed on the standard output,
129: * otherwise written into a temporary file in directory dir.
130: * if expandflag==true, keyword expansion is performed.
131: * returns false on errors, the name of the file with the revision otherwise.
132: *
133: * Algorithm: Copy inital revision unchanged. Then edit all revisions but
134: * the last one into it, alternating input and output files (resultfile and
135: * editfile). The last revision is then edited in, performing simultaneous
136: * keyword substitution (this saves one extra pass).
137: * All this simplifies if only one revision needs to be generated,
138: * or no keyword expansion is necessary, or if output goes to stdout.
139: */
140: {
141: int i;
142:
143: if (deltas[0]==target) {
144: /* only latest revision to generate */
145: if (dir==nil) {/* print directly to stdout */
146: fcopy=stdout;
147: scandeltatext(target,expand);
148: return(char *) true;
149: } else {
150: initeditfiles(dir);
151: scandeltatext(target,expandflag?expand:copy);
152: ffclose(fcopy);
153: return(resultfile);
154: }
155: } else {
156: /* several revisions to generate */
157: initeditfiles(dir?dir:"/tmp/");
158: /* write initial revision into fcopy, no keyword expansion */
159: scandeltatext(deltas[0],copy);
160: i = 1;
161: while (deltas[i+1] != nil) {
162: /* do all deltas except last one */
163: scandeltatext(deltas[i++],edit);
164: }
165: if (!expandflag) {
166: /* no keyword expansion; only invoked from ci */
167: scandeltatext(deltas[i],edit);
168: finishedit((struct hshentry *)nil);
169: ffclose(fcopy);
170: } else {
171: /* perform keyword expansion*/
172: /* first, get to beginning of file*/
173: finishedit((struct hshentry *)nil); swapeditfiles(dir==nil);
174: scandeltatext(deltas[i],edit_expand);
175: finishedit(deltas[i]);
176: if (dir!=nil) ffclose(fcopy);
177: }
178: return(resultfile); /*doesn't matter for dir==nil*/
179: }
180: }
181:
182:
183:
184: scandeltatext(delta,func)
185: struct hshentry * delta; enum stringwork func;
186: /* Function: Scans delta text nodes up to and including the one given
187: * by delta. For the one given by delta, the log message is saved into
188: * curlogmsg and the text is processed according to parameter func.
189: * Assumes the initial lexeme must be read in first.
190: * Does not advance nexttok after it is finished.
191: */
192: { struct hshentry * nextdelta;
193:
194: do {
195: nextlex();
196: if (!(nextdelta=getnum())) {
197: fatserror("Can't find delta for revision %s", delta->num);
198: }
199: if (!getkey(Klog) || nexttok!=STRING)
200: serror("Missing log entry");
201: elsif (delta==nextdelta) {
202: VOID savestring(curlogmsg,logsize);
203: delta->log=curlogmsg;
204: } else {readstring();
205: delta->log= "";
206: }
207: nextlex();
208: if (!getkey(Ktext) || nexttok!=STRING)
209: fatserror("Missing delta text");
210:
211: if(delta==nextdelta)
212: /* got the one we're looking for */
213: switch (func) {
214: case copy: copystring();
215: break;
216: case expand: xpandstring(delta);
217: break;
218: case edit: editstring((struct hshentry *)nil);
219: break;
220: case edit_expand: editstring(delta);
221: break;
222: }
223: else readstring(); /* skip over it */
224:
225: } while (delta!=nextdelta);
226: }
227:
228:
229: int stdinread; /* stdinread>0 if redirected stdin has been read once */
230:
231: int ttystdin()
232: {
233: static int initialized, istty;
234: if (!initialized) {
235: istty = isatty(fileno(stdin));
236: initialized = 1;
237: }
238: return istty;
239: }
240:
241: putdesc(initflag,textflag,textfile,quietflag)
242: int initflag,textflag; char * textfile; int quietflag;
243: /* Function: puts the descriptive text into file frewrite.
244: * if !initflag && !textflag, the text is copied from the old description.
245: * Otherwise, if the textfile!=nil, the text is read from that
246: * file, or from stdin, if textfile==nil.
247: * Increments stdinread if text is read from redirected stdin.
248: * if initflag&&quietflag&&!textflag, an empty text is inserted.
249: * if !initflag, the old descriptive text is discarded.
250: */
251: { register FILE * txt; register int c, old1, old2;
252: register FILE * frew;
253: #ifdef lint
254: if (quietflag == 0) initflag = quietflag; /* silencelint */
255: #endif
256:
257: frew = frewrite;
258: if (!initflag && !textflag) {
259: /* copy old description */
260: VOID fprintf(frew,"\n\n%s%c",Kdesc,nextc);
261: rewriteflag=true; getdesc(false);
262: } else {
263: /* get new description */
264: if (!initflag) {
265: /*skip old description*/
266: rewriteflag=false; getdesc(false);
267: }
268: VOID fprintf(frew,"\n\n%s\n%c",Kdesc,SDELIM);
269: if (textfile) {
270: old1='\n';
271: /* copy textfile */
272: if ((txt=fopen(textfile,"r"))!=NULL) {
273: while ((c=getc(txt))!=EOF) {
274: if (c==SDELIM) VOID putc(c,frew); /*double up*/
275: VOID putc(c,frew);
276: old1=c;
277: }
278: if (old1!='\n') VOID putc('\n',frew);
279: VOID fclose(txt);
280: VOID putc(SDELIM,frew);
281: VOID fputs("\n\n", frew);
282: return;
283: } else {
284: error("Can't open file %s with description",textfile);
285: if (!ttystdin()) return;
286: /* otherwise, get description from terminal */
287: }
288: }
289: /* read text from stdin */
290: if (ttystdin()) {
291: VOID fputs("enter description, terminated with ^D or '.':\n",stderr);
292: VOID fputs("NOTE: This is NOT the log message!\n>> ",stderr);
293: if (feof(stdin))
294: clearerr(stdin);
295: } else { /* redirected stdin */
296: if (stdinread>0)
297: faterror("Can't reread redirected stdin for description; use -t<file>");
298: stdinread++;
299: }
300: c = '\0'; old2= '\n';
301: if ((old1=getchar())==EOF) {
302: if (ttystdin()) {
303: VOID putc('\n',stderr);
304: clearerr(stdin);
305: }
306: } else {
307: if (old1=='\n' && ttystdin())
308: VOID fputs(">> ",stderr);
309: for (;;) {
310: c=getchar();
311: if (c==EOF) {
312: if (ttystdin()) {
313: VOID putc('\n',stderr);
314: clearerr(stdin);
315: }
316: VOID putc(old1,frew);
317: if (old1!='\n') VOID putc('\n',frew);
318: break;
319: }
320: if (c=='\n' && old1=='.' && old2=='\n') {
321: break;
322: }
323: if (c=='\n' && ttystdin()) VOID fputs(">> ",stderr);
324: if(old1==SDELIM) VOID putc(old1,frew); /* double up*/
325: VOID putc(old1,frew);
326: old2=old1;
327: old1=c;
328: } /* end for */
329: }
330: VOID putc(SDELIM,frew); VOID fputs("\n\n",frew);
331: }
332: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.