nroff & install portability updates

[unix-history] / usr / src / usr.sbin / config / mkheaders.c

/*
* Copyright (c) 1980, 1993
*      The Regents of the University of California.  All rights reserved.
*
* %sccs.include.redist.c%
*/

#ifndef lint
static char sccsid[] = "@(#)mkheaders.c 8.1 (Berkeley) %G%";
#endif /* not lint */

/*
* Make all the .h files for the optional entries
*/

#include <stdio.h>
#include <ctype.h>
#include "config.h"
#include "y.tab.h"

headers()
{
       register struct file_list *fl;

       for (fl = ftab; fl != 0; fl = fl->f_next)
               if (fl->f_needs != 0)
                       do_count(fl->f_needs, fl->f_needs, 1);
}

/*
* count all the devices of a certain type and recurse to count
* whatever the device is connected to
*/
do_count(dev, hname, search)
       register char *dev, *hname;
       int search;
{
       register struct device *dp, *mp;
       register int count, hicount;

       /*
        * After this loop, "count" will be the actual number of units,
        * and "hicount" will be the highest unit declared.  do_header()
        * must use this higher of these values.
        */
       for (hicount = count = 0, dp = dtab; dp != 0; dp = dp->d_next)
               if (dp->d_unit != -1 && eq(dp->d_name, dev)) {
                       if (dp->d_type == PSEUDO_DEVICE) {
                               count =
                                   dp->d_slave != UNKNOWN ? dp->d_slave : 1;
                               break;
                       }
                       count++;
                       /*
                        * Allow holes in unit numbering,
                        * assumption is unit numbering starts
                        * at zero.
                        */
                       if (dp->d_unit + 1 > hicount)
                               hicount = dp->d_unit + 1;
                       if (search) {
                               mp = dp->d_conn;
                               if (mp != 0 && mp != TO_NEXUS &&
                                   mp->d_conn != 0 && mp->d_conn != TO_NEXUS) {
                                       do_count(mp->d_name, hname, 0);
                                       search = 0;
                               }
                       }
               }
       do_header(dev, hname, count > hicount ? count : hicount);
}

do_header(dev, hname, count)
       char *dev, *hname;
       int count;
{
       char *file, *name, *inw, *toheader(), *tomacro();
       struct file_list *fl, *fl_head, *tflp;
       FILE *inf, *outf;
       int inc, oldcount;

       file = toheader(hname);
       name = tomacro(dev);
       inf = fopen(file, "r");
       oldcount = -1;
       if (inf == 0) {
               outf = fopen(file, "w");
               if (outf == 0) {
                       perror(file);
                       exit(1);
               }
               fprintf(outf, "#define %s %d\n", name, count);
               (void) fclose(outf);
               return;
       }
       fl_head = NULL;
       for (;;) {
               char *cp;
               if ((inw = get_word(inf)) == 0 || inw == (char *)EOF)
                       break;
               if ((inw = get_word(inf)) == 0 || inw == (char *)EOF)
                       break;
               inw = ns(inw);
               cp = get_word(inf);
               if (cp == 0 || cp == (char *)EOF)
                       break;
               inc = atoi(cp);
               if (eq(inw, name)) {
                       oldcount = inc;
                       inc = count;
               }
               cp = get_word(inf);
               if (cp == (char *)EOF)
                       break;
               fl = (struct file_list *) malloc(sizeof *fl);
               bzero(fl, sizeof(*fl));
               fl->f_fn = inw;
               fl->f_type = inc;
               fl->f_next = fl_head;
               fl_head = fl;
       }
       (void) fclose(inf);
       if (count == oldcount) {
               for (fl = fl_head; fl != NULL; fl = tflp) {
                       tflp = fl->f_next;
                       free(fl);
               }
               return;
       }
       if (oldcount == -1) {
               fl = (struct file_list *) malloc(sizeof *fl);
               bzero(fl, sizeof(*fl));
               fl->f_fn = name;
               fl->f_type = count;
               fl->f_next = fl_head;
               fl_head = fl;
       }
       outf = fopen(file, "w");
       if (outf == 0) {
               perror(file);
               exit(1);
       }
       for (fl = fl_head; fl != NULL; fl = tflp) {
               fprintf(outf,
                   "#define %s %u\n", fl->f_fn, count ? fl->f_type : 0);
               tflp = fl->f_next;
               free(fl);
       }
       (void) fclose(outf);
}

/*
* convert a dev name to a .h file name
*/
char *
toheader(dev)
       char *dev;
{
       static char hbuf[80];

       (void) strcpy(hbuf, path(dev));
       (void) strcat(hbuf, ".h");
       return (hbuf);
}

/*
* convert a dev name to a macro name
*/
char *tomacro(dev)
       register char *dev;
{
       static char mbuf[20];
       register char *cp;

       cp = mbuf;
       *cp++ = 'N';
       while (*dev)
               *cp++ = islower(*dev) ? toupper(*dev++) : *dev++;
       *cp++ = 0;
       return (mbuf);
}