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