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