usr/dash/mkinit.c

/*-
 * Copyright (c) 1991, 1993
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1997-2005
 *	Herbert Xu <herbert@gondor.apana.org.au>.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Kenneth Almquist.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * This program scans all the source files for code to handle various
 * special events and combines this code into one file.  This (allegedly)
 * improves the structure of the program since there is no need for
 * anyone outside of a module to know that that module performs special
 * operations on particular events.
 *
 * Usage:  mkinit sourcefile...
 */


#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>


/*
 * OUTFILE is the name of the output file.  Output is initially written
 * to the file OUTTEMP, which is then moved to OUTFILE.
 */

#define OUTFILE "init.c"
#define OUTTEMP "init.c.new"


/*
 * A text structure is basicly just a string that grows as more characters
 * are added onto the end of it.  It is implemented as a linked list of
 * blocks of characters.  The routines addstr and addchar append a string
 * or a single character, respectively, to a text structure.  Writetext
 * writes the contents of a text structure to a file.
 */

#define BLOCKSIZE 512

struct text {
	char *nextc;
	int nleft;
	struct block *start;
	struct block *last;
};

struct block {
	struct block *next;
	char text[BLOCKSIZE];
};


/*
 * There is one event structure for each event that mkinit handles.
 */

struct event {
	char *name;		/* name of event (e.g. INIT) */
	char *routine;		/* name of routine called on event */
	char *comment;		/* comment describing routine */
	struct text code;	/* code for handling event */
};


char writer[] = "\
/*\n\
 * This file was generated by the mkinit program.\n\
 */\n\
\n";

char init[] = "\
/*\n\
 * Initialization code.\n\
 */\n";

char reset[] = "\
/*\n\
 * This routine is called when an error or an interrupt occurs in an\n\
 * interactive shell and control is returned to the main command loop.\n\
 */\n";


struct event event[] = {
	{"INIT", "init", init},
	{"RESET", "reset", reset},
	{NULL, NULL}
};


char *curfile;				/* current file */
int linno;				/* current line */
char *header_files[200];		/* list of header files */
struct text defines;			/* #define statements */
struct text decls;			/* declarations */
int amiddecls;				/* for formatting */


void readfile(char *);
int match(char *, char *);
int gooddefine(char *);
void doevent(struct event *, FILE *, char *);
void doinclude(char *);
void dodecl(char *, FILE *);
void output(void);
void addstr(char *, struct text *);
void addchar(int, struct text *);
void writetext(struct text *, FILE *);
FILE *ckfopen(char *, char *);
void *ckmalloc(int);
char *savestr(char *);
static void error(char *);
int main(int, char **);

#define equal(s1, s2)	(strcmp(s1, s2) == 0)

int
main(int argc, char **argv)
{
	char **ap;

	header_files[0] = "\"shell.h\"";
	header_files[1] = "\"mystring.h\"";
	header_files[2] = "\"init.h\"";
	for (ap = argv + 1 ; *ap ; ap++)
		readfile(*ap);
	output();
	rename(OUTTEMP, OUTFILE);
	exit(0);
	/* NOTREACHED */
}


/*
 * Parse an input file.
 */

void
readfile(char *fname)
{
	FILE *fp;
	char line[1024];
	struct event *ep;

	fp = ckfopen(fname, "r");
	curfile = fname;
	linno = 0;
	amiddecls = 0;
	while (fgets(line, sizeof line, fp) != NULL) {
		linno++;
		for (ep = event ; ep->name ; ep++) {
			if (line[0] == ep->name[0] && match(ep->name, line)) {
				doevent(ep, fp, fname);
				break;
			}
		}
		if (line[0] == 'I' && match("INCLUDE", line))
			doinclude(line);
		if (line[0] == 'M' && match("MKINIT", line))
			dodecl(line, fp);
		if (line[0] == '#' && gooddefine(line)) {
		        char *cp;
			char line2[1024];
			static const char undef[] = "#undef ";

			strcpy(line2, line);
			memcpy(line2, undef, sizeof(undef) - 1);
			cp = line2 + sizeof(undef) - 1;
			while(*cp && (*cp == ' ' || *cp == '\t'))
			        cp++;
			while(*cp && *cp != ' ' && *cp != '\t' && *cp != '\n')
			        cp++;
			*cp++ = '\n'; *cp = '\0';
			addstr(line2, &defines);
			addstr(line, &defines);
		}
	}
	fclose(fp);
}


int
match(char *name, char *line)
{
	char *p, *q;

	p = name, q = line;
	while (*p) {
		if (*p++ != *q++)
			return 0;
	}
	if (*q != '{' && *q != ' ' && *q != '\t' && *q != '\n')
		return 0;
	return 1;
}


int
gooddefine(char *line)
{
	char *p;

	if (! match("#define", line))
		return 0;			/* not a define */
	p = line + 7;
	while (*p == ' ' || *p == '\t')
		p++;
	while (*p != ' ' && *p != '\t') {
		if (*p == '(')
			return 0;		/* macro definition */
		p++;
	}
	while (*p != '\n' && *p != '\0')
		p++;
	if (p[-1] == '\\')
		return 0;			/* multi-line definition */
	return 1;
}


void
doevent(struct event *ep, FILE *fp, char *fname)
{
	char line[1024];
	int indent;
	char *p;

	sprintf(line, "\n      /* from %s: */\n", fname);
	addstr(line, &ep->code);
	addstr("      {\n", &ep->code);
	for (;;) {
		linno++;
		if (fgets(line, sizeof line, fp) == NULL)
			error("Unexpected EOF");
		if (equal(line, "}\n"))
			break;
		indent = 6;
		for (p = line ; *p == '\t' ; p++)
			indent += 8;
		for ( ; *p == ' ' ; p++)
			indent++;
		if (*p == '\n' || *p == '#')
			indent = 0;
		while (indent >= 8) {
			addchar('\t', &ep->code);
			indent -= 8;
		}
		while (indent > 0) {
			addchar(' ', &ep->code);
			indent--;
		}
		addstr(p, &ep->code);
	}
	addstr("      }\n", &ep->code);
}


void
doinclude(char *line)
{
	char *p;
	char *name;
	char **pp;

	for (p = line ; *p != '"' && *p != '<' && *p != '\0' ; p++);
	if (*p == '\0')
		error("Expecting '\"' or '<'");
	name = p;
	while (*p != ' ' && *p != '\t' && *p != '\n')
		p++;
	if (p[-1] != '"' && p[-1] != '>')
		error("Missing terminator");
	*p = '\0';

	/* name now contains the name of the include file */
	for (pp = header_files ; *pp && ! equal(*pp, name) ; pp++);
	if (*pp == NULL)
		*pp = savestr(name);
}


void
dodecl(char *line1, FILE *fp)
{
	char line[1024];
	char *p, *q;

	if (strcmp(line1, "MKINIT\n") == 0) { /* start of struct/union decl */
		addchar('\n', &decls);
		do {
			linno++;
			if (fgets(line, sizeof line, fp) == NULL)
				error("Unterminated structure declaration");
			addstr(line, &decls);
		} while (line[0] != '}');
		amiddecls = 0;
	} else {
		if (! amiddecls)
			addchar('\n', &decls);
		q = NULL;
		for (p = line1 + 6 ; *p && strchr("=/\n", *p) == NULL; p++)
			continue;
		if (*p == '=') {		/* eliminate initialization */
			for (q = p ; *q && *q != ';' ; q++);
			if (*q == '\0')
				q = NULL;
			else {
				while (p[-1] == ' ')
					p--;
				*p = '\0';
			}
		}
		addstr("extern", &decls);
		addstr(line1 + 6, &decls);
		if (q != NULL)
			addstr(q, &decls);
		amiddecls = 1;
	}
}


/*
 * Write the output to the file OUTTEMP.
 */

void
output(void)
{
	FILE *fp;
	char **pp;
	struct event *ep;

	fp = ckfopen(OUTTEMP, "w");
	fputs(writer, fp);
	for (pp = header_files ; *pp ; pp++)
		fprintf(fp, "#include %s\n", *pp);
	fputs("\n\n\n", fp);
	writetext(&defines, fp);
	fputs("\n\n", fp);
	writetext(&decls, fp);
	for (ep = event ; ep->name ; ep++) {
		fputs("\n\n\n", fp);
		fputs(ep->comment, fp);
		fprintf(fp, "\nvoid\n%s() {\n", ep->routine);
		writetext(&ep->code, fp);
		fprintf(fp, "}\n");
	}
	fclose(fp);
}


/*
 * A text structure is simply a block of text that is kept in memory.
 * Addstr appends a string to the text struct, and addchar appends a single
 * character.
 */

void
addstr(char *s, struct text *text)
{
	while (*s) {
		if (--text->nleft < 0)
			addchar(*s++, text);
		else
			*text->nextc++ = *s++;
	}
}


void
addchar(int c, struct text *text)
{
	struct block *bp;

	if (--text->nleft < 0) {
		bp = ckmalloc(sizeof *bp);
		if (text->start == NULL)
			text->start = bp;
		else
			text->last->next = bp;
		text->last = bp;
		text->nextc = bp->text;
		text->nleft = BLOCKSIZE - 1;
	}
	*text->nextc++ = c;
}

/*
 * Write the contents of a text structure to a file.
 */
void
writetext(struct text *text, FILE *fp)
{
	struct block *bp;

	if (text->start != NULL) {
		for (bp = text->start ; bp != text->last ; bp = bp->next) {
			if ((fwrite(bp->text, sizeof (char), BLOCKSIZE, fp)) != BLOCKSIZE)
				error("Can't write data\n");
		}
		if ((fwrite(bp->text, sizeof (char), BLOCKSIZE - text->nleft, fp)) != (BLOCKSIZE - text->nleft))
			error("Can't write data\n");
	}
}

FILE *
ckfopen(char *file, char *mode)
{
	FILE *fp;

	if ((fp = fopen(file, mode)) == NULL) {
		fprintf(stderr, "Can't open %s\n", file);
		exit(2);
	}
	return fp;
}

void *
ckmalloc(int nbytes)
{
	char *p;

	if ((p = malloc(nbytes)) == NULL)
		error("Out of space");
	return p;
}

char *
savestr(char *s)
{
	char *p;

	p = ckmalloc(strlen(s) + 1);
	strcpy(p, s);
	return p;
}

static void
error(char *msg)
{
	if (curfile != NULL)
		fprintf(stderr, "%s:%d: ", curfile, linno);
	fprintf(stderr, "%s\n", msg);
	exit(2);
	/* NOTREACHED */
}
1	niro	532	/*-
2			* Copyright (c) 1991, 1993
3			* The Regents of the University of California. All rights reserved.
4			* Copyright (c) 1997-2005
5			* Herbert Xu <herbert@gondor.apana.org.au>. All rights reserved.
6			*
7			* This code is derived from software contributed to Berkeley by
8			* Kenneth Almquist.
9			*
10			* Redistribution and use in source and binary forms, with or without
11			* modification, are permitted provided that the following conditions
12			* are met:
13			* 1. Redistributions of source code must retain the above copyright
14			* notice, this list of conditions and the following disclaimer.
15			* 2. Redistributions in binary form must reproduce the above copyright
16			* notice, this list of conditions and the following disclaimer in the
17			* documentation and/or other materials provided with the distribution.
18			* 3. Neither the name of the University nor the names of its contributors
19			* may be used to endorse or promote products derived from this software
20			* without specific prior written permission.
21			*
22			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32			* SUCH DAMAGE.
33			*/
34
35			/*
36			* This program scans all the source files for code to handle various
37			* special events and combines this code into one file. This (allegedly)
38			* improves the structure of the program since there is no need for
39			* anyone outside of a module to know that that module performs special
40			* operations on particular events.
41			*
42			* Usage: mkinit sourcefile...
43			*/
44
45
46			#include <sys/types.h>
47			#include <stdio.h>
48			#include <stdlib.h>
49			#include <string.h>
50			#include <fcntl.h>
51			#include <unistd.h>
52
53
54			/*
55			* OUTFILE is the name of the output file. Output is initially written
56			* to the file OUTTEMP, which is then moved to OUTFILE.
57			*/
58
59			#define OUTFILE "init.c"
60			#define OUTTEMP "init.c.new"
61
62
63			/*
64			* A text structure is basicly just a string that grows as more characters
65			* are added onto the end of it. It is implemented as a linked list of
66			* blocks of characters. The routines addstr and addchar append a string
67			* or a single character, respectively, to a text structure. Writetext
68			* writes the contents of a text structure to a file.
69			*/
70
71			#define BLOCKSIZE 512
72
73			struct text {
74			char *nextc;
75			int nleft;
76			struct block *start;
77			struct block *last;
78			};
79
80			struct block {
81			struct block *next;
82			char text[BLOCKSIZE];
83			};
84
85
86			/*
87			* There is one event structure for each event that mkinit handles.
88			*/
89
90			struct event {
91			char name; / name of event (e.g. INIT) */
92			char routine; / name of routine called on event */
93			char comment; / comment describing routine */
94			struct text code; /* code for handling event */
95			};
96
97
98			char writer[] = "\
99			/*\n\
100			* This file was generated by the mkinit program.\n\
101			*/\n\
102			\n";
103
104			char init[] = "\
105			/*\n\
106			* Initialization code.\n\
107			*/\n";
108
109			char reset[] = "\
110			/*\n\
111			* This routine is called when an error or an interrupt occurs in an\n\
112			* interactive shell and control is returned to the main command loop.\n\
113			*/\n";
114
115
116			struct event event[] = {
117			{"INIT", "init", init},
118			{"RESET", "reset", reset},
119			{NULL, NULL}
120			};
121
122
123			char curfile; / current file */
124			int linno; /* current line */
125			char header_files[200]; / list of header files */
126			struct text defines; /* #define statements */
127			struct text decls; /* declarations */
128			int amiddecls; /* for formatting */
129
130
131			void readfile(char *);
132			int match(char , char );
133			int gooddefine(char *);
134			void doevent(struct event , FILE , char *);
135			void doinclude(char *);
136			void dodecl(char , FILE );
137			void output(void);
138			void addstr(char , struct text );
139			void addchar(int, struct text *);
140			void writetext(struct text , FILE );
141			FILE ckfopen(char , char *);
142			void *ckmalloc(int);
143			char savestr(char );
144			static void error(char *);
145			int main(int, char **);
146
147			#define equal(s1, s2) (strcmp(s1, s2) == 0)
148
149			int
150			main(int argc, char **argv)
151			{
152			char **ap;
153
154			header_files[0] = "\"shell.h\"";
155			header_files[1] = "\"mystring.h\"";
156			header_files[2] = "\"init.h\"";
157			for (ap = argv + 1 ; *ap ; ap++)
158			readfile(*ap);
159			output();
160			rename(OUTTEMP, OUTFILE);
161			exit(0);
162			/* NOTREACHED */
163			}
164
165
166			/*
167			* Parse an input file.
168			*/
169
170			void
171			readfile(char *fname)
172			{
173			FILE *fp;
174			char line[1024];
175			struct event *ep;
176
177			fp = ckfopen(fname, "r");
178			curfile = fname;
179			linno = 0;
180			amiddecls = 0;
181			while (fgets(line, sizeof line, fp) != NULL) {
182			linno++;
183			for (ep = event ; ep->name ; ep++) {
184			if (line[0] == ep->name[0] && match(ep->name, line)) {
185			doevent(ep, fp, fname);
186			break;
187			}
188			}
189			if (line[0] == 'I' && match("INCLUDE", line))
190			doinclude(line);
191			if (line[0] == 'M' && match("MKINIT", line))
192			dodecl(line, fp);
193			if (line[0] == '#' && gooddefine(line)) {
194			char *cp;
195			char line2[1024];
196			static const char undef[] = "#undef ";
197
198			strcpy(line2, line);
199			memcpy(line2, undef, sizeof(undef) - 1);
200			cp = line2 + sizeof(undef) - 1;
201			while(cp && (cp == ' ' \|\| *cp == '\t'))
202			cp++;
203			while(cp && cp != ' ' && cp != '\t' && cp != '\n')
204			cp++;
205			cp++ = '\n'; cp = '\0';
206			addstr(line2, &defines);
207			addstr(line, &defines);
208			}
209			}
210			fclose(fp);
211			}
212
213
214			int
215			match(char name, char line)
216			{
217			char p, q;
218
219			p = name, q = line;
220			while (*p) {
221			if (p++ != q++)
222			return 0;
223			}
224			if (q != '{' && q != ' ' && q != '\t' && q != '\n')
225			return 0;
226			return 1;
227			}
228
229
230			int
231			gooddefine(char *line)
232			{
233			char *p;
234
235			if (! match("#define", line))
236			return 0; /* not a define */
237			p = line + 7;
238			while (p == ' ' \|\| p == '\t')
239			p++;
240			while (p != ' ' && p != '\t') {
241			if (*p == '(')
242			return 0; /* macro definition */
243			p++;
244			}
245			while (p != '\n' && p != '\0')
246			p++;
247			if (p[-1] == '\\')
248			return 0; /* multi-line definition */
249			return 1;
250			}
251
252
253			void
254			doevent(struct event ep, FILE fp, char *fname)
255			{
256			char line[1024];
257			int indent;
258			char *p;
259
260			sprintf(line, "\n /* from %s: */\n", fname);
261			addstr(line, &ep->code);
262			addstr(" {\n", &ep->code);
263			for (;;) {
264			linno++;
265			if (fgets(line, sizeof line, fp) == NULL)
266			error("Unexpected EOF");
267			if (equal(line, "}\n"))
268			break;
269			indent = 6;
270			for (p = line ; *p == '\t' ; p++)
271			indent += 8;
272			for ( ; *p == ' ' ; p++)
273			indent++;
274			if (p == '\n' \|\| p == '#')
275			indent = 0;
276			while (indent >= 8) {
277			addchar('\t', &ep->code);
278			indent -= 8;
279			}
280			while (indent > 0) {
281			addchar(' ', &ep->code);
282			indent--;
283			}
284			addstr(p, &ep->code);
285			}
286			addstr(" }\n", &ep->code);
287			}
288
289
290			void
291			doinclude(char *line)
292			{
293			char *p;
294			char *name;
295			char **pp;
296
297			for (p = line ; p != '"' && p != '<' && *p != '\0' ; p++);
298			if (*p == '\0')
299			error("Expecting '\"' or '<'");
300			name = p;
301			while (p != ' ' && p != '\t' && *p != '\n')
302			p++;
303			if (p[-1] != '"' && p[-1] != '>')
304			error("Missing terminator");
305			*p = '\0';
306
307			/* name now contains the name of the include file */
308			for (pp = header_files ; pp && ! equal(pp, name) ; pp++);
309			if (*pp == NULL)
310			*pp = savestr(name);
311			}
312
313
314			void
315			dodecl(char line1, FILE fp)
316			{
317			char line[1024];
318			char p, q;
319
320			if (strcmp(line1, "MKINIT\n") == 0) { /* start of struct/union decl */
321			addchar('\n', &decls);
322			do {
323			linno++;
324			if (fgets(line, sizeof line, fp) == NULL)
325			error("Unterminated structure declaration");
326			addstr(line, &decls);
327			} while (line[0] != '}');
328			amiddecls = 0;
329			} else {
330			if (! amiddecls)
331			addchar('\n', &decls);
332			q = NULL;
333			for (p = line1 + 6 ; p && strchr("=/\n", p) == NULL; p++)
334			continue;
335			if (p == '=') { / eliminate initialization */
336			for (q = p ; q && q != ';' ; q++);
337			if (*q == '\0')
338			q = NULL;
339			else {
340			while (p[-1] == ' ')
341			p--;
342			*p = '\0';
343			}
344			}
345			addstr("extern", &decls);
346			addstr(line1 + 6, &decls);
347			if (q != NULL)
348			addstr(q, &decls);
349			amiddecls = 1;
350			}
351			}
352
353
354
355			/*
356			* Write the output to the file OUTTEMP.
357			*/
358
359			void
360			output(void)
361			{
362			FILE *fp;
363			char **pp;
364			struct event *ep;
365
366			fp = ckfopen(OUTTEMP, "w");
367			fputs(writer, fp);
368			for (pp = header_files ; *pp ; pp++)
369			fprintf(fp, "#include %s\n", *pp);
370			fputs("\n\n\n", fp);
371			writetext(&defines, fp);
372			fputs("\n\n", fp);
373			writetext(&decls, fp);
374			for (ep = event ; ep->name ; ep++) {
375			fputs("\n\n\n", fp);
376			fputs(ep->comment, fp);
377			fprintf(fp, "\nvoid\n%s() {\n", ep->routine);
378			writetext(&ep->code, fp);
379			fprintf(fp, "}\n");
380			}
381			fclose(fp);
382			}
383
384
385			/*
386			* A text structure is simply a block of text that is kept in memory.
387			* Addstr appends a string to the text struct, and addchar appends a single
388			* character.
389			*/
390
391			void
392			addstr(char s, struct text text)
393			{
394			while (*s) {
395			if (--text->nleft < 0)
396			addchar(*s++, text);
397			else
398			text->nextc++ = s++;
399			}
400			}
401
402
403			void
404			addchar(int c, struct text *text)
405			{
406			struct block *bp;
407
408			if (--text->nleft < 0) {
409			bp = ckmalloc(sizeof *bp);
410			if (text->start == NULL)
411			text->start = bp;
412			else
413			text->last->next = bp;
414			text->last = bp;
415			text->nextc = bp->text;
416			text->nleft = BLOCKSIZE - 1;
417			}
418			*text->nextc++ = c;
419			}
420
421			/*
422			* Write the contents of a text structure to a file.
423			*/
424			void
425			writetext(struct text text, FILE fp)
426			{
427			struct block *bp;
428
429			if (text->start != NULL) {
430	niro	815	for (bp = text->start ; bp != text->last ; bp = bp->next) {
431			if ((fwrite(bp->text, sizeof (char), BLOCKSIZE, fp)) != BLOCKSIZE)
432			error("Can't write data\n");
433			}
434			if ((fwrite(bp->text, sizeof (char), BLOCKSIZE - text->nleft, fp)) != (BLOCKSIZE - text->nleft))
435			error("Can't write data\n");
436	niro	532	}
437			}
438
439			FILE *
440			ckfopen(char file, char mode)
441			{
442			FILE *fp;
443
444			if ((fp = fopen(file, mode)) == NULL) {
445			fprintf(stderr, "Can't open %s\n", file);
446			exit(2);
447			}
448			return fp;
449			}
450
451			void *
452			ckmalloc(int nbytes)
453			{
454			char *p;
455
456			if ((p = malloc(nbytes)) == NULL)
457			error("Out of space");
458			return p;
459			}
460
461			char *
462			savestr(char *s)
463			{
464			char *p;
465
466			p = ckmalloc(strlen(s) + 1);
467			strcpy(p, s);
468			return p;
469			}
470
471			static void
472			error(char *msg)
473			{
474			if (curfile != NULL)
475			fprintf(stderr, "%s:%d: ", curfile, linno);
476			fprintf(stderr, "%s\n", msg);
477			exit(2);
478			/* NOTREACHED */
479			}