488 lines
11 KiB
C
488 lines
11 KiB
C
/*-
|
|
* Copyright (c) 1991, 1993
|
|
* The Regents of the University of California. 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.
|
|
* 4. 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.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char const copyright[] =
|
|
"@(#) Copyright (c) 1991, 1993\n\
|
|
The Regents of the University of California. All rights reserved.\n";
|
|
#endif /* not lint */
|
|
|
|
#ifndef lint
|
|
#if 0
|
|
static char sccsid[] = "@(#)mkinit.c 8.2 (Berkeley) 5/4/95";
|
|
#endif
|
|
#endif /* not lint */
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
/*
|
|
* 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/cdefs.h>
|
|
#include <sys/types.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <errno.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 basically 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 {
|
|
const char *name; /* name of event (e.g. INIT) */
|
|
const char *routine; /* name of routine called on event */
|
|
const 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, { NULL, 0, NULL, NULL } },
|
|
{ "RESET", "reset", reset, { NULL, 0, NULL, NULL } },
|
|
{ NULL, NULL, NULL, { NULL, 0, NULL, NULL } }
|
|
};
|
|
|
|
|
|
const 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(const char *);
|
|
int match(const char *, const char *);
|
|
int gooddefine(const char *);
|
|
void doevent(struct event *, FILE *, const char *);
|
|
void doinclude(char *);
|
|
void dodecl(char *, FILE *);
|
|
void output(void);
|
|
void addstr(const char *, struct text *);
|
|
void addchar(int, struct text *);
|
|
void writetext(struct text *, FILE *);
|
|
FILE *ckfopen(const char *, const char *);
|
|
void *ckmalloc(size_t);
|
|
char *savestr(const char *);
|
|
void error(const char *);
|
|
|
|
#define equal(s1, s2) (strcmp(s1, s2) == 0)
|
|
|
|
int
|
|
main(int argc __unused, char *argv[])
|
|
{
|
|
char **ap;
|
|
|
|
header_files[0] = savestr("\"shell.h\"");
|
|
header_files[1] = savestr("\"mystring.h\"");
|
|
header_files[2] = savestr("\"init.h\"");
|
|
for (ap = argv + 1 ; *ap ; ap++)
|
|
readfile(*ap);
|
|
output();
|
|
rename(OUTTEMP, OUTFILE);
|
|
exit(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* Parse an input file.
|
|
*/
|
|
|
|
void
|
|
readfile(const 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(const char *name, const char *line)
|
|
{
|
|
const 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(const char *line)
|
|
{
|
|
const 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, const char *fname)
|
|
{
|
|
char line[1024];
|
|
int indent;
|
|
const 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(void)\n{\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(const 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)
|
|
fwrite(bp->text, sizeof (char), BLOCKSIZE, fp);
|
|
fwrite(bp->text, sizeof (char), BLOCKSIZE - text->nleft, fp);
|
|
}
|
|
}
|
|
|
|
FILE *
|
|
ckfopen(const char *file, const char *mode)
|
|
{
|
|
FILE *fp;
|
|
|
|
if ((fp = fopen(file, mode)) == NULL) {
|
|
fprintf(stderr, "Can't open %s: %s\n", file, strerror(errno));
|
|
exit(2);
|
|
}
|
|
return fp;
|
|
}
|
|
|
|
void *
|
|
ckmalloc(size_t nbytes)
|
|
{
|
|
char *p;
|
|
|
|
if ((p = malloc(nbytes)) == NULL)
|
|
error("Out of space");
|
|
return p;
|
|
}
|
|
|
|
char *
|
|
savestr(const char *s)
|
|
{
|
|
char *p;
|
|
|
|
p = ckmalloc(strlen(s) + 1);
|
|
strcpy(p, s);
|
|
return p;
|
|
}
|
|
|
|
void
|
|
error(const char *msg)
|
|
{
|
|
if (curfile != NULL)
|
|
fprintf(stderr, "%s:%d: ", curfile, linno);
|
|
fprintf(stderr, "%s\n", msg);
|
|
exit(2);
|
|
}
|