![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sccstorcs.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 sccstorcs.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src |
1.1 root 1: static char *RCSid =
2: "$Header: sccstorcs.c,v 1.4 84/10/17 21:12:11 root Exp $";
3:
4: /*
5: * SCCSTORCS - build RCS file from SCCS file preserving deltas.
6: * Author: Ken Greer
7: *
8: * Copyright (c) 1983 by Kenneth L. Greer
9: *
10: * All rights reserved. No part of this software may be sold or distributed
11: * in any form or by any means without the prior written permission of the
12: * author.
13: *
14: * $Log: sccstorcs.c,v $
15: * Revision 1.4 84/10/17 21:12:11 root
16: * Added check for having multiple deltas in a row for the same revision.
17: * --ks
18: *
19: * Revision 1.3 84/10/17 20:53:18 root
20: * Put in SCCS string in comment for telling who checked it in..
21: * --ks
22: *
23: * Revision 1.2 84/10/17 12:22:14 root
24: * Fixed the case when a delta was removed.
25: * Also, use -f on checkin so comments are kept even if the file
26: * didn't change between deltas.
27: * --ks
28: *
29: * Revision 1.1 84/10/07 14:59:47 root
30: * Initial revision
31: *
32: * Revision 1.2 83/03/27 11:21:17 root
33: * Returns non-zero exit codes on soft errors also.
34: *
35: * Revision 1.1 83/03/24 14:33:24 root
36: * Initial revision
37: *
38: */
39:
40: #include <stdio.h>
41:
42: #define TRUE 1
43: #define FALSE 0
44: #define SOH 001 /* SCCS lines start with SOH (Control-A) */
45: #define RCS "rcs -q"
46: #define GET "get -s"
47: #define CI "ci -q -f"
48:
49: #define prefix(a, b) (strncmp(a, b, strlen(a)) == 0)
50: #define null(str) ((str) == NULL ? "<null>\n" : (str))
51:
52: int
53: trace = FALSE, /* just show what would be done, don't run commands */
54: verbose = FALSE; /* Print commands before executing */
55:
56: typedef struct delta
57: {
58: char *revision;
59: char *commentary;
60: struct delta *next;
61: } DELTA;
62:
63: typedef struct userlist
64: {
65: char *user;
66: struct userlist *next;
67: } USERLIST;
68:
69: typedef struct header
70: {
71: DELTA *deltas;
72: USERLIST *userlist;
73: char *description;
74: } HEADER;
75:
76:
77: quit (fmt, args)
78: char *fmt;
79: {
80: fprintf (stderr, "sccstorcs: ");
81: _doprnt(fmt, &args, stderr);
82: exit (1);
83: }
84:
85: char *
86: xalloc (size)
87: unsigned size;
88: {
89: extern char *malloc ();
90: char *p;
91: if ((p = malloc (size)) == NULL)
92: quit ("Out of Memory.\n");
93: return (p);
94: }
95:
96: /*
97: * Allocate space for string and copy str to it.
98: */
99: char *
100: string (str)
101: char *str;
102: {
103: register char *p = xalloc ((unsigned) (strlen (str) + 1));
104: strcpy (p, str);
105: return (p);
106: }
107:
108: /*
109: * Return pointer to the final file name in a path.
110: * I.e. sname ("/foo/baz/mumble") returns a pointer to "mumble".
111: */
112: char *
113: sname (s)
114: register char *s;
115: {
116: register char *p;
117:
118: for (p = s; *p;)
119: if (*p++ == '/')
120: s = p;
121: return (s);
122: }
123:
124: DELTA *
125: new_delta (line)
126: char *line;
127: {
128: register DELTA *delta;
129: char rev[32];
130:
131: sscanf (line, "%*s %*s %s", rev);
132: delta = (DELTA *) xalloc (sizeof (DELTA));
133: delta -> revision = string (rev);
134: delta -> commentary = NULL;
135: return (delta);
136: }
137:
138: char *
139: concat (old_str, str)
140: char *old_str, *str;
141: {
142: register int len;
143: register char *newstring;
144:
145: if (old_str == NULL)
146: return (string (str));
147:
148: len = strlen (old_str) + strlen (str);
149: newstring = (char *) xalloc ((unsigned) (len + 1));
150: strcpy (newstring, old_str);
151: strcat (newstring, str);
152: free (old_str);
153: return (newstring);
154: }
155:
156: trimtail (line)
157: char *line;
158: {
159: register char *p = line;
160: while (*p) p++;
161: while (p > line && p[-1] <= ' ')
162: p--;
163: *p = '\0';
164: }
165:
166: USERLIST *
167: collect_userlist (fd)
168: FILE *fd;
169: {
170: char line[128];
171: USERLIST *userlist = NULL, *newuser;
172: while (fgets (line, sizeof line, fd))
173: {
174: if (line[0] == SOH && line[1] == 'U') /* End of userlist */
175: break;
176: trimtail (line);
177: newuser = (USERLIST *) xalloc (sizeof (USERLIST));
178: newuser -> user = string (line);
179: newuser -> next = userlist;
180: userlist = newuser;
181: }
182: return (userlist);
183: }
184:
185: HEADER *
186: collect_header (fd)
187: FILE *fd;
188: {
189: DELTA *head = NULL, *delta;
190: USERLIST *userlist = NULL;
191: static HEADER header;
192: char line[512], *description = NULL;
193: while (fgets (line, sizeof line, fd))
194: {
195: if (line[0] != SOH)
196: continue;
197: if (line[1] == 'I') /* The first INCLUDE */
198: break;
199: switch (line[1])
200: {
201: case 'd': /* New delta */
202: #ifdef PURDUE_EE
203: if (line[3] == 'R')
204: while (fgets (line, sizeof line, fd))
205: if (line[0] == SOH && line[1] == 'd' && line[3] != 'R')
206: break;
207: #endif
208: delta = new_delta (line);
209: #ifdef PURDUE_EE
210: if (!head || strcmp(delta -> revision, head -> revision)) {
211: #endif
212: delta -> next = head;
213: head = delta;
214: #ifdef PURDUE_EE
215: }
216: #endif
217: #ifndef PURDUE_EE
218: break;
219: #endif
220: case 'c': /* Commentary */
221: delta -> commentary = concat (delta -> commentary, &line[3]);
222: break;
223: case 'u':
224: userlist = collect_userlist (fd);
225: break;
226: case 't':
227: while (fgets (line, sizeof line, fd) && !prefix("\1T", line))
228: description = concat (description, line);
229: }
230: }
231: header.userlist = userlist;
232: header.deltas = head;
233: header.description = description;
234: return (&header);
235: }
236:
237: /*
238: * Convert SCCS file to RCS file
239: */
240: HEADER *
241: read_sccs (sccsfile)
242: char *sccsfile;
243: {
244: HEADER *header;
245: FILE *fd;
246: if (strncmp (sname (sccsfile), "s.", 2) != 0) /* An SCCS file? */
247: {
248: fprintf (stderr, "%s: not an SCCS file.\n", sccsfile);
249: return (NULL);
250: }
251: if ((fd = fopen (sccsfile, "r")) == NULL)
252: {
253: fprintf (stderr, "%s: cannot open.\n", sccsfile);
254: return (NULL);
255: }
256: header = collect_header (fd);
257: fclose (fd);
258: return (header);
259: }
260:
261: install_userlist (userlist, rcsfile)
262: register USERLIST *userlist;
263: char *rcsfile;
264: {
265: char command[512];
266: int count;
267: if (userlist == NULL)
268: return (0);
269: sprintf (command, "%s -a", RCS);
270: for (count = 0; userlist; userlist = userlist -> next, count++)
271: {
272: if (count > 0)
273: strcat (command, ",");
274: strcat (command, userlist -> user);
275: }
276: strcat (command, " ");
277: strcat (command, rcsfile);
278: if (trace || verbose)
279: printf ("%% %s\n", command);
280: if (trace)
281: return (0);
282: return (system (command));
283: }
284:
285: initialize_rcsfile (description, rcsfile)
286: char *description, *rcsfile;
287: {
288: char command[512];
289: extern FILE *popen();
290: FILE *pd;
291:
292: sprintf (command, "%s -i -U %s", RCS, rcsfile);
293: if (trace || verbose)
294: printf ("%% %s\n", command);
295: if (trace)
296: {
297: printf ("Description:\n%s\n", null(description));
298: return (0);
299: }
300: if ((pd = popen (command, "w")) == NULL)
301: return (-1);
302: fprintf (pd, "%s", description ? description : "\n");
303: return (pclose (pd));
304: }
305:
306: install_deltas (delta, sccsfile, rcsfile)
307: register DELTA *delta;
308: char *sccsfile, *rcsfile;
309: {
310: char command[512];
311: for (; delta; delta = delta -> next)
312: {
313: /*
314: * Get the SCCS file.
315: */
316: sprintf (command, "%s -p -r%s %s > %s",
317: GET, delta -> revision, sccsfile, rcsfile);
318: if (trace || verbose)
319: printf("%% %s\n", command);
320: if (!trace)
321: {
322: if (system (command))
323: return (-1);
324: }
325:
326: sprintf (command, "%s -r%s %s", CI, delta -> revision, rcsfile);
327: if (trace || verbose)
328: printf("%% %s\n", command);
329: if (trace)
330: printf("Commentary:\n%s\n", null(delta -> commentary));
331: else
332: {
333: extern FILE *popen ();
334: FILE *pd;
335: int x;
336: if ((pd = popen (command, "w")) == NULL)
337: return (-1);
338: if (delta -> commentary)
339: fprintf (pd, delta -> commentary);
340: if ((x = pclose (pd)) != 0)
341: return (x);
342: }
343: }
344: return (0);
345: }
346:
347: finalize_rcsfile (rcsfile)
348: char *rcsfile;
349: {
350: char command[512];
351: sprintf (command, "%s -L %s", RCS, rcsfile);
352: if (trace || verbose)
353: printf ("%% %s\n", command);
354: if (trace)
355: return (0);
356: return (system (command));
357: }
358:
359: build_new_rcs_file (header, sccsfile)
360: HEADER *header;
361: char *sccsfile;
362: {
363: char *rcsfile = &(sname (sccsfile))[2];
364:
365: if (initialize_rcsfile (header -> description, rcsfile))
366: quit ("Error initializing new rcs file %s\n", rcsfile);
367:
368: if (install_userlist (header -> userlist, rcsfile))
369: quit ("Error installing user access list to rcs file %s\n", rcsfile);
370:
371: if (install_deltas (header -> deltas, sccsfile, rcsfile))
372: quit ("Error installing delta to rcs file %s\n", rcsfile);
373:
374: if (finalize_rcsfile (rcsfile))
375: quit ("Error setting defaults to rcs file %s\n", rcsfile);
376: }
377:
378: print_header (sccsfile, header)
379: char *sccsfile;
380: register HEADER *header;
381: {
382: register DELTA *d;
383: register USERLIST *u;
384:
385: printf ("\n%s:\n", sccsfile);
386: printf ("------------------------------------------------------------\n");
387: if (header -> description)
388: printf ("Descriptive text:\n%s", header -> description);
389:
390: if (header -> userlist)
391: {
392: printf ("\nUser access list:\n");
393: for (u = header -> userlist; u; u = u -> next)
394: printf ("%s\n", u -> user);
395: }
396:
397: for (d = header -> deltas; d; d = d -> next)
398: {
399: printf ("\nRelease: %s\n", d -> revision);
400: printf ("Commentary:\n%s", d -> commentary);
401: }
402: printf ("------------------------------------------------------------\n");
403: }
404:
405: main (argc, argv)
406: char **argv;
407: {
408: int errors = 0;
409:
410: for (; argc > 1 && argv[1][0] == '-'; argc--, argv++)
411: {
412: switch (argv[1][1])
413: {
414: case 'v':
415: verbose = TRUE;
416: break;
417: case 't':
418: trace = TRUE;
419: break;
420: default:
421: fprintf (stderr, "Unknown switch \"%s\".\n", argv[1]);
422: exit (1);
423: }
424: }
425:
426: if (argc <= 1)
427: quit ("Usage: sccstorcs [-t -v] s.file ...\n");
428:
429: for (; argc > 1; argc--, argv++)
430: {
431: HEADER *header;
432: char *sccsfile;
433: sccsfile = argv[1];
434: if ((header = read_sccs (sccsfile)) != NULL)
435: {
436: if (trace)
437: print_header (sccsfile, header);
438: build_new_rcs_file (header, sccsfile);
439: }
440: else
441: errors++;
442: }
443: exit (errors);
444: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.