d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed config.new from the release. It is unused by any current version

Browse Source 
of FreeBSD, and only serves to generate confusion and increase bloat.
This commit is contained in:
Nate Williams 1996-01-20 00:59:23 +00:00
parent c92a064d21
commit 8f9d4ec05d
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=13506
17 changed files with 3 additions and 4944 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
usr.sbin/Makefile
View File

@ -1,5 +1,5 @@
# From: @(#)Makefile 5.20 (Berkeley) 6/12/93
# $Id: Makefile,v 1.76 1996/01/05 09:53:49 graichen Exp $
# $Id: Makefile,v 1.77 1996/01/17 12:51:01 adam Exp $
# XXX MISSING: mkproto
SUBDIR= ac accton adduser amd arp bootparamd cdcontrol chown chroot \
@ -25,7 +25,7 @@ SUBDIR= ac accton adduser amd arp bootparamd cdcontrol chown chroot \
SUBDIR+=IPXrouted
.if make(clean) || make(cleandir)
SUBDIR+=apm apmconf bad144 cdplay config config.new fdformat fdwrite \
SUBDIR+=apm apmconf bad144 cdplay config fdformat fdwrite \
fdcontrol iostat kbdcontrol kbdmap lptcontrol mixer ncrcontrol \
rtprio sgsc sicontrol spkrtest vidcontrol
.elif ${MACHINE} == "hp300"
@ -39,11 +39,9 @@ SUBDIR+=config iostat
.elif ${MACHINE} == "mips"
SUBDIR+=config iostat
.elif ${MACHINE} == "sparc"
SUBDIR+=config.new eeprom
SUBDIR+=eeprom
.elif ${MACHINE} == "tahoe"
SUBDIR+=config iostat
.elif ${MACHINE} == "vax"
SUBDIR+=bad144 config iostat
.endif
.include <bsd.subdir.mk>

12
usr.sbin/config.new/Makefile
View File

@ -1,12 +0,0 @@
# @(#)Makefile 8.2 (Berkeley) 4/19/94
PROG= config.new
SRCS= files.c gram.y hash.c main.c mkheaders.c mkioconf.c mkmakefile.c \
mkswap.c pack.c scan.l sem.c util.c
CFLAGS+=-I${.CURDIR} -I.
CLEANFILES=gram.c scan.c y.tab.h
MAN8= config.new.8
.include <bsd.prog.mk>
.depend: gram.c scan.c

281
usr.sbin/config.new/config.h
View File

@ -1,281 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)config.h 8.1 (Berkeley) 6/6/93
*/
/*
* Name/value lists. Values can be strings or pointers and/or can carry
* integers. The names can be NULL, resulting in simple value lists.
*/
struct nvlist {
struct nvlist *nv_next;
const char *nv_name;
union {
const char *un_str;
void *un_ptr;
} nv_un;
#define nv_str nv_un.un_str
#define nv_ptr nv_un.un_ptr
int nv_int;
};
/*
* Kernel configurations.
*/
struct config {
struct config *cf_next; /* linked list */
const char *cf_name; /* "kernel" */
int cf_lineno; /* source line */
struct nvlist *cf_root; /* "root on ra0a" */
struct nvlist *cf_swap; /* "swap on ra0b and ra1b" */
struct nvlist *cf_dump; /* "dumps on ra0b" */
};
/*
* Attributes. These come in two flavors: "plain" and "interface".
* Plain attributes (e.g., "ether") simply serve to pull in files.
* Interface attributes (e.g., "scsi") carry three lists: locators,
* child devices, and references. The locators are those things
* that must be specified in order to configure a device instance
* using this attribute (e.g., "tg0 at scsi0"). The a_devs field
* lists child devices that can connect here (e.g., "tg"s), while
* the a_refs are parents that carry the attribute (e.g., actual
* SCSI host adapter drivers such as the SPARC "esp").
*/
struct attr {
const char *a_name; /* name of this attribute */
int a_iattr; /* true => allows children */
struct nvlist *a_locs; /* locators required */
int a_loclen; /* length of above list */
struct nvlist *a_devs; /* children */
struct nvlist *a_refs; /* parents */
};
/*
* The "base" part of a device ("uba", "sd"; but not "uba2" or
* "sd0"). It may be found "at" one or more attributes, including
* "at root" (this is represented by a NULL attribute).
*
* Each device may also export attributes. If any provide an output
* interface (e.g., "esp" provides "scsi"), other devices (e.g.,
* "tg"s) can be found at instances of this one (e.g., "esp"s).
* Such a connection must provide locators as specified by that
* interface attribute (e.g., "target").
*
* Each base carries a list of instances (via d_ihead). Note that this
* list "skips over" aliases; those must be found through the instances
* themselves.
*/
struct devbase {
const char *d_name; /* e.g., "sd" */
struct devbase *d_next; /* linked list */
int d_isdef; /* set once properly defined */
int d_ispseudo; /* is a pseudo-device */
int d_major; /* used for "root on sd0", e.g. */
struct nvlist *d_atlist; /* e.g., "at tg" (attr list) */
struct nvlist *d_vectors; /* interrupt vectors, if any */
struct nvlist *d_attrs; /* attributes, if any */
struct devi *d_ihead; /* first instance, if any */
struct devi **d_ipp; /* used for tacking on more instances */
int d_umax; /* highest unit number + 1 */
};
/*
* An "instance" of a device. The same instance may be listed more
* than once, e.g., "xx0 at isa? port FOO" + "xx0 at isa? port BAR".
*
* After everything has been read in and verified, the devi's are
* "packed" to collect all the information needed to generate ioconf.c.
* In particular, we try to collapse multiple aliases into a single entry.
* We then assign each "primary" (non-collapsed) instance a cfdata index.
* Note that there may still be aliases among these.
*/
struct devi {
/* created while parsing config file */
const char *i_name; /* e.g., "sd0" */
int i_unit; /* unit from name, e.g., 0 */
struct devbase *i_base;/* e.g., pointer to "sd" base */
struct devi *i_next; /* list of all instances */
struct devi *i_bsame; /* list on same base */
struct devi *i_alias; /* other aliases of this instance */
const char *i_at; /* where this is "at" (NULL if at root) */
struct attr *i_atattr; /* attr that allowed attach */
struct devbase *i_atdev;/* dev if "at <devname><unit>", else NULL */
const char **i_locs; /* locators (as given by i_atattr) */
int i_atunit; /* unit from "at" */
int i_cfflags; /* flags from config line */
int i_lineno; /* line # in config, for later errors */
/* created during packing or ioconf.c generation */
/* i_loclen via i_atattr->a_loclen */
short i_collapsed; /* set => this alias no longer needed */
short i_cfindex; /* our index in cfdata */
short i_pvlen; /* number of parents */
short i_pvoff; /* offset in parents.vec */
short i_locoff; /* offset in locators.vec */
short i_ivoff; /* offset in interrupt vectors, if any */
struct devi **i_parents;/* the parents themselves */
};
/* special units */
#define STAR (-1) /* unit number for, e.g., "sd*" */
#define WILD (-2) /* unit number for, e.g., "sd?" */
/*
* Files. Each file is either standard (always included) or optional,
* depending on whether it has names on which to *be* optional.
*/
struct files {
struct files *fi_next; /* linked list */
const char *fi_srcfile; /* the name of the "files" file that got us */
u_short fi_srcline; /* and the line number */
u_char fi_flags; /* as below */
char fi_lastc; /* last char from path */
const char *fi_path; /* full file path */
const char *fi_tail; /* name, i.e., rindex(fi_path, '/') + 1 */
const char *fi_base; /* tail minus ".c" (or whatever) */
struct nvlist *fi_opt; /* optional on ... */
const char *fi_mkrule; /* special make rule, if any */
};
/* flags */
#define FI_SEL 0x01 /* selected */
#define FI_CONFIGDEP 0x02 /* config-dependent */
#define FI_DRIVER 0x04 /* device-driver */
#define FI_NEEDSCOUNT 0x08 /* needs-count */
#define FI_NEEDSFLAG 0x10 /* needs-flag */
#define FI_HIDDEN 0x20 /* obscured by other(s), base names overlap */
/*
* Hash tables look up name=value pairs. The pointer value of the name
* is assumed to be constant forever; this can be arranged by interning
* the name. (This is fairly convenient since our lexer does this for
* all identifier-like strings---it has to save them anyway, lest yacc's
* look-ahead wipe out the current one.)
*/
struct hashtab;
const char *conffile; /* source file, e.g., "GENERIC.sparc" */
const char *confdirbase; /* basename of compile directory, usu. same */
const char *machine; /* machine type, e.g., "sparc" */
int errors; /* counts calls to error() */
int minmaxusers; /* minimum "maxusers" parameter */
int defmaxusers; /* default "maxusers" parameter */
int maxmaxusers; /* default "maxusers" parameter */
int maxusers; /* configuration's "maxusers" parameter */
struct nvlist *options; /* options */
struct nvlist *mkoptions; /* makeoptions */
struct hashtab *devbasetab; /* devbase lookup */
struct hashtab *selecttab; /* selects things that are "optional foo" */
struct hashtab *needcnttab; /* retains names marked "needs-count" */
struct devbase *allbases; /* list of all devbase structures */
struct config *allcf; /* list of configured kernels */
struct devi *alldevi; /* list of all instances */
struct devi *allpseudo; /* list of all pseudo-devices */
int ndevi; /* number of devi's (before packing) */
int npseudo; /* number of pseudo's */
struct files *allfiles; /* list of all kernel source files */
struct devi **packed; /* arrayified table for packed devi's */
int npacked; /* size of packed table, <= ndevi */
struct { /* pv[] table for config */
short *vec;
int used;
} parents;
struct { /* loc[] table for config */
const char **vec;
int used;
} locators;
/* files.c */
void initfiles __P((void));
void checkfiles __P((void));
int fixfiles __P((void)); /* finalize */
void addfile __P((const char *, struct nvlist *, int, const char *));
/* hash.c */
struct hashtab *ht_new __P((void));
int ht_insrep __P((struct hashtab *, const char *, void *, int));
#define ht_insert(ht, nam, val) ht_insrep(ht, nam, val, 0)
#define ht_replace(ht, nam, val) ht_insrep(ht, nam, val, 1)
void *ht_lookup __P((struct hashtab *, const char *));
void initintern __P((void));
const char *intern __P((const char *));
/* main.c */
void addoption __P((const char *name, const char *value));
void addmkoption __P((const char *name, const char *value));
/* mkheaders.c */
int mkheaders __P((void));
/* mkioconf.c */
int mkioconf __P((void));
/* mkmakefile.c */
int mkmakefile __P((void));
/* mkswap.c */
int mkswap __P((void));
/* pack.c */
void pack __P((void));
/* scan.l */
int currentline __P((void));
/* sem.c, other than for yacc actions */
void initsem __P((void));
/* util.c */
void *emalloc __P((size_t));
void *erealloc __P((void *, size_t));
char *path __P((const char *));
void error __P((const char *, ...)); /* immediate errs */
void xerror __P((const char *, int, const char *, ...)); /* delayed errs */
__dead void panic __P((const char *, ...));
struct nvlist *newnv __P((const char *, const char *, void *, int));
void nvfree __P((struct nvlist *));
void nvfreel __P((struct nvlist *));

167
usr.sbin/config.new/config.new.8
View File

@ -1,167 +0,0 @@
.\" Copyright (c) 1980, 1991, 1993
.\" The Regents of the University of California. All rights reserved.
.\"
.\" 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. All advertising materials mentioning features or use of this software
.\" must display the following acknowledgement:
.\" This product includes software developed by the University of
.\" California, Berkeley and its contributors.
.\" 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.
.\"
.\" @(#)config.8 8.2 (Berkeley) 4/19/94
.\"
.Dd April 19, 1994
.Dt CONFIG.NEW 8
.Os BSD 4
.Sh NAME
.Nm config.new
.Nd build kernel compilation directories
.Sh SYNOPSIS
.Nm config
.Op Fl p
.Ar system-name
.Sh DESCRIPTION
.Pp
This is the new version of the
.Nm config
program.
It understands the more modern autoconfiguration scheme
used on the SPARC and i386 platforms.
The old version of config is still used with the
HP300, DECstation, and derivative platforms.
Only the version of
.Nm config
applicable to the architecture that you are running
will be installed on your machine.
.Pp
.Nm Config
builds a set of configuration files from the file
.Ar system-name ,
which describes
the system to configure.
.Pp
.Nm Config
should run from the
.Pa conf
subdirectory of the top-level machine-specific directory
of the system source (usually
.Pa /sys/MACHINE/conf ,
where
.Pa MACHINE
is one of
.Pa vax ,
.Pa tahoe ,
.Pa hp300 ,
and so forth).
.Nm Config
assumes the directory
.Pa ../../compile
exists; it places all output files in a subdirectory there,
creating the subdirectory if necessary.
The subdirectory name is taken from the
.Ar system-name ;
thus, configuring with
.Dq Li config PICKLE
will use the directory
.Pa ../../compile/PICKLE .
.Pp
If the
.Fl p
option is supplied,
.Pa .PROF
is appended to the compilation directory name, and
.Nm config
acts as if the lines
.Dq Li makeoptions PROF="-pg"
and
.Dq Li options GPROF
appeared in the configuration file.
This will build a system that includes profiling code; see
.Xr kgmon 8
and
.Xr gprof 1 .
The
.Fl p
flag is expected to be used for
.Dq one-shot
profiles of existing systems;
for regular profiling,
it is probably wiser to make a separate configuration
containing the
.Li makeoptions
line.
.Pp
The old undocumented
.Fl g
flag is no longer supported.
Instead, use
.Dq Li makeoptions DEBUG="-g"
and (typically)
.Dq Li options KGDB .
.Pp
The output of
.Nm config
consists of a number of files, principally
.Pa ioconf.c ,
a description of I/O devices that may be attached to the system; and a
.Pa Makefile ,
used by
.Xr make 1
in building the kernel.
.Pp
After running
.Nm config ,
it is wise to run
.Dq Li make depend
in the directory where the new makefile
was created.
.Nm Config
prints a reminder of this when it completes.
.Pp
If
.Nm config
stops due to errors, the problems reported should be corrected and
.Nm config
should be run again.
.Nm Config
attempts to avoid changing the compilation directory
if there are configuration errors,
but this code is not well-tested,
and some problems (such as running out of disk space)
are unrecoverable.
.Sh SEE ALSO
The SYNOPSIS portion of each device in section 4.
.Rs
.%T "Building 4.4 BSD Systems with Config"
.\" .%T "Device Support in 4.4BSD"
.Re
.sp
.Xr config 8
.Sh HISTORY
The
.Nm
command appeared in
.Bx 4.1 .
It was completely revised in
.Bx 4.4 .

262
usr.sbin/config.new/files.c
View File

@ -1,262 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)files.c 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
extern const char *yyfile;
/*
* We check that each full path name is unique. File base names
* should generally also be unique, e.g., having both a net/xx.c and
* a kern/xx.c (or, worse, a net/xx.c and a new/xx.c++) is probably
* wrong, but is permitted under some conditions.
*/
static struct hashtab *basetab; /* file base names */
static struct hashtab *pathtab; /* full path names */
static struct files **nextfile;
static struct files **unchecked;
void
initfiles()
{
basetab = ht_new();
pathtab = ht_new();
nextfile = &allfiles;
unchecked = &allfiles;
}
static void
showprev(pref, fi)
const char *pref;
register struct files *fi;
{
xerror(fi->fi_srcfile, fi->fi_srcline,
"%sfile %s ...", pref, fi->fi_path);
errors--;
}
void
addfile(path, opts, flags, rule)
const char *path;
struct nvlist *opts;
int flags;
const char *rule;
{
struct files *fi;
const char *base, *dotp, *tail;
size_t baselen;
int needc, needf;
char buf[200];
/* check various errors */
needc = flags & FI_NEEDSCOUNT;
needf = flags & FI_NEEDSFLAG;
if (needc && needf) {
error("cannot mix needs-count and needs-flag");
goto bad;
}
if (opts == NULL && (needc || needf)) {
error("nothing to %s for %s", needc ? "count" : "flag", path);
goto bad;
}
if ((fi = ht_lookup(pathtab, path)) != NULL) {
showprev("", fi);
error("file %s listed again", path);
goto bad;
}
/* find last part of pathname, and same without trailing suffix */
tail = rindex(path, '/');
if (tail == NULL)
tail = path;
else
tail++;
dotp = rindex(tail, '.');
if (dotp == NULL || dotp[1] == 0 ||
(baselen = dotp - tail) >= sizeof(buf)) {
error("invalid pathname `%s'", path);
goto bad;
}
/*
* Make a copy of the path without the .c/.s/whatever suffix.
* This must be unique per "files" file (e.g., a specific
* file can override a standard file, but no standard file
* can override another standard file). This is not perfect
* but should catch any major errors.
*/
bcopy(tail, buf, baselen);
buf[baselen] = 0;
base = intern(buf);
if ((fi = ht_lookup(basetab, base)) != NULL) {
if (fi->fi_srcfile != yyfile) {
showprev("note: ", fi);
error("is overriden by %s", path);
errors--; /* take it away */
fi->fi_flags |= FI_HIDDEN;
} else {
showprev("", fi);
error("collides with %s (both make %s.o)",
path, base);
goto bad;
}
}
/*
* Commit this file to memory.
*/
fi = emalloc(sizeof *fi);
fi->fi_next = NULL;
fi->fi_srcfile = yyfile;
fi->fi_srcline = currentline();
fi->fi_flags = flags;
fi->fi_lastc = dotp[strlen(dotp) - 1];
fi->fi_path = path;
fi->fi_tail = tail;
fi->fi_base = base;
fi->fi_opt = opts;
fi->fi_mkrule = rule;
if (ht_insert(pathtab, path, fi))
panic("addfile: ht_insert(%s)", path);
(void)ht_replace(basetab, base, fi);
*nextfile = fi;
nextfile = &fi->fi_next;
return;
bad:
nvfreel(opts);
}
/*
* We have finished reading some "files" file, either ../../conf/files
* or ./files.$machine. Make sure that everything that is flagged as
* needing a count is reasonable. (This prevents ../../conf/files from
* depending on some machine-specific device.)
*/
void
checkfiles()
{
register struct files *fi, *last;
register struct nvlist *nv;
last = NULL;
for (fi = *unchecked; fi != NULL; last = fi, fi = fi->fi_next) {
if ((fi->fi_flags & FI_NEEDSCOUNT) == 0)
continue;
for (nv = fi->fi_opt; nv != NULL; nv = nv->nv_next)
if (ht_lookup(devbasetab, nv->nv_name) == NULL) {
xerror(fi->fi_srcfile, fi->fi_srcline,
"`%s' is not a countable device",
nv->nv_name);
/* keep fixfiles() from complaining again */
fi->fi_flags |= FI_HIDDEN;
}
}
if (last != NULL)
unchecked = &last->fi_next;
}
/*
* We have finished reading everything. Tack the files down: calculate
* selection and counts as needed.
*/
int
fixfiles()
{
register struct files *fi;
register struct nvlist *nv;
register struct devbase *dev;
int sel, err;
err = 0;
for (fi = allfiles; fi != NULL; fi = fi->fi_next) {
if (fi->fi_flags & FI_HIDDEN)
continue;
if ((nv = fi->fi_opt) == NULL) { /* standard */
fi->fi_flags |= FI_SEL;
continue;
}
/* figure out whether it is selected */
sel = 0;
if (fi->fi_flags & FI_NEEDSCOUNT) {
/* ... and compute counts too */
do {
dev = ht_lookup(devbasetab, nv->nv_name);
if (dev == NULL) {
xerror(fi->fi_srcfile, fi->fi_srcline,
"`%s' is not a countable device",
nv->nv_name);
err = 1;
} else {
if (dev->d_umax)
sel = 1;
nv->nv_int = dev->d_umax;
(void)ht_insert(needcnttab,
nv->nv_name, nv);
}
} while ((nv = nv->nv_next) != NULL);
} else {
do {
if (ht_lookup(selecttab, nv->nv_name)) {
sel = 1;
break;
}
} while ((nv = nv->nv_next) != NULL);
if (fi->fi_flags & FI_NEEDSFLAG)
for (nv = fi->fi_opt; nv; nv = nv->nv_next)
nv->nv_int = sel;
}
/* if selected, we are go */
if (sel)
fi->fi_flags |= FI_SEL;
}
return (err);
}

392
usr.sbin/config.new/gram.y
View File

@ -1,392 +0,0 @@
%{
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)gram.y 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "sem.h"
#define FORMAT(n) ((n) > -10 && (n) < 10 ? "%d" : "0x%x")
#define stop(s) error(s), exit(1)
int include __P((const char *, int));
void yyerror __P((const char *));
int yylex __P((void));
extern const char *lastfile;
static struct config conf; /* at most one active at a time */
/* the following is used to recover nvlist space after errors */
static struct nvlist *alloc[1000];
static int adepth;
#define new0(n,s,p,i) (alloc[adepth++] = newnv(n, s, p, i))
#define new_n(n) new0(n, NULL, NULL, 0)
#define new_ns(n, s) new0(n, s, NULL, 0)
#define new_si(s, i) new0(NULL, s, NULL, i)
#define new_nsi(n,s,i) new0(n, s, NULL, i)
#define new_np(n, p) new0(n, NULL, p, 0)
#define new_s(s) new0(NULL, s, NULL, 0)
#define new_p(p) new0(NULL, NULL, p, 0)
static void cleanup __P((void));
static void setmachine __P((const char *));
%}
%union {
struct attr *attr;
struct devbase *devb;
struct nvlist *list;
const char *str;
int val;
}
%token AND AT COMPILE_WITH CONFIG DEFINE DEVICE DUMPS ENDFILE
%token XFILE FLAGS INCLUDE XMACHINE MAJOR MAKEOPTIONS MAXUSERS MINOR
%token ON OPTIONS PSEUDO_DEVICE ROOT SWAP VECTOR
%token <val> FFLAG NUMBER
%token <str> PATHNAME WORD
%type <list> fopts
%type <val> fflgs
%type <str> rule
%type <attr> attr
%type <devb> devbase
%type <list> atlist interface_opt
%type <str> atname
%type <list> loclist_opt loclist locdef
%type <str> locdefault
%type <list> veclist_opt veclist
%type <list> attrs_opt attrs
%type <list> locators locator
%type <list> swapdev_list dev_spec
%type <str> device_instance
%type <str> attachment
%type <str> value
%type <val> major_minor signed_number npseudo
%type <val> flags_opt
%%
/*
* A configuration consists of a machine type, followed by the machine
* definition files (via the include() mechanism), followed by the
* configuration specification(s) proper. In effect, this is two
* separate grammars, with some shared terminals and nonterminals.
*/
Configuration:
hdrs machine_spec /* "machine foo" from machine descr. */
dev_defs dev_eof /* ../../conf/devices */
dev_defs dev_eof /* devices.foo */
specs; /* rest of machine description */
hdrs:
hdrs hdr |
/* empty */;
hdr:
include |
'\n';
machine_spec:
XMACHINE WORD = { setmachine($2); } |
error = { stop("cannot proceed without machine specifier"); };
dev_eof:
ENDFILE = { enddefs(lastfile); checkfiles(); };
/*
* Various nonterminals shared between the grammars.
*/
file:
XFILE PATHNAME fopts fflgs rule = { addfile($2, $3, $4, $5); };
/* order of options is important, must use right recursion */
fopts:
WORD fopts = { ($$ = new_n($1))->nv_next = $2; } |
/* empty */ = { $$ = NULL; };
fflgs:
fflgs FFLAG = { $$ = $1 | $2; } |
/* empty */ = { $$ = 0; };
rule:
COMPILE_WITH WORD = { $$ = $2; } |
/* empty */ = { $$ = NULL; };
include:
INCLUDE WORD = { (void)include($2, '\n'); };
/*
* The machine definitions grammar.
*/
dev_defs:
dev_defs dev_def |
/* empty */;
dev_def:
one_def '\n' = { adepth = 0; } |
'\n' |
error '\n' = { cleanup(); };
one_def:
file |
/* include | */
DEFINE WORD interface_opt = { (void)defattr($2, $3); } |
DEVICE devbase AT atlist veclist_opt interface_opt attrs_opt
= { defdev($2, 0, $4, $5, $6, $7); } |
MAXUSERS NUMBER NUMBER NUMBER = { setdefmaxusers($2, $3, $4); } |
PSEUDO_DEVICE devbase attrs_opt = { defdev($2,1,NULL,NULL,NULL,$3); } |
MAJOR '{' majorlist '}';
atlist:
atlist ',' atname = { ($$ = new_n($3))->nv_next = $1; } |
atname = { $$ = new_n($1); };
atname:
WORD = { $$ = $1; } |
ROOT = { $$ = NULL; };
veclist_opt:
VECTOR veclist = { $$ = $2; } |
/* empty */ = { $$ = NULL; };
/* veclist order matters, must use right recursion */
veclist:
WORD veclist = { ($$ = new_n($1))->nv_next = $2; } |
WORD = { $$ = new_n($1); };
devbase:
WORD = { $$ = getdevbase($1); };
interface_opt:
'{' loclist_opt '}' = { ($$ = new_n(""))->nv_next = $2; } |
/* empty */ = { $$ = NULL; };
loclist_opt:
loclist = { $$ = $1; } |
/* empty */ = { $$ = NULL; };
/* loclist order matters, must use right recursion */
loclist:
locdef ',' loclist = { ($$ = $1)->nv_next = $3; } |
locdef = { $$ = $1; };
/* "[ WORD locdefault ]" syntax may be unnecessary... */
locdef:
WORD locdefault = { $$ = new_nsi($1, $2, 0); } |
WORD = { $$ = new_nsi($1, NULL, 0); } |
'[' WORD locdefault ']' = { $$ = new_nsi($2, $3, 1); };
locdefault:
'=' value = { $$ = $2; };
value:
WORD = { $$ = $1; } |
signed_number = { char bf[40];
(void)sprintf(bf, FORMAT($1), $1);
$$ = intern(bf); };
signed_number:
NUMBER = { $$ = $1; } |
'-' NUMBER = { $$ = -$2; };
attrs_opt:
':' attrs = { $$ = $2; } |
/* empty */ = { $$ = NULL; };
attrs:
attrs ',' attr = { ($$ = new_p($3))->nv_next = $1; } |
attr = { $$ = new_p($1); };
attr:
WORD = { $$ = getattr($1); };
majorlist:
majorlist ',' majordef |
majordef;
majordef:
devbase '=' NUMBER = { setmajor($1, $3); };
/*
* The configuration grammar.
*/
specs:
specs spec |
/* empty */;
spec:
config_spec '\n' = { adepth = 0; } |
'\n' |
error '\n' = { cleanup(); };
config_spec:
file |
include |
OPTIONS opt_list |
MAKEOPTIONS mkopt_list |
MAXUSERS NUMBER = { setmaxusers($2); } |
CONFIG conf sysparam_list = { addconf(&conf); } |
PSEUDO_DEVICE WORD npseudo = { addpseudo($2, $3); } |
device_instance AT attachment locators flags_opt
= { adddev($1, $3, $4, $5); };
mkopt_list:
mkopt_list ',' mkoption |
mkoption;
mkoption:
WORD '=' value = { addmkoption($1, $3); }
opt_list:
opt_list ',' option |
option;
option:
WORD = { addoption($1, NULL); } |
WORD '=' value = { addoption($1, $3); };
conf:
WORD = { conf.cf_name = $1;
conf.cf_lineno = currentline();
conf.cf_root = NULL;
conf.cf_swap = NULL;
conf.cf_dump = NULL; };
sysparam_list:
sysparam_list sysparam |
sysparam;
sysparam:
ROOT on_opt dev_spec = { setconf(&conf.cf_root, "root", $3); } |
SWAP on_opt swapdev_list = { setconf(&conf.cf_swap, "swap", $3); } |
DUMPS on_opt dev_spec = { setconf(&conf.cf_dump, "dumps", $3); };
swapdev_list:
dev_spec AND swapdev_list = { ($$ = $1)->nv_next = $3; } |
dev_spec = { $$ = $1; };
dev_spec:
WORD = { $$ = new_si($1, NODEV); } |
major_minor = { $$ = new_si(NULL, $1); };
major_minor:
MAJOR NUMBER MINOR NUMBER = { $$ = makedev($2, $4); };
on_opt:
ON | /* empty */;
npseudo:
NUMBER = { $$ = $1; } |
/* empty */ = { $$ = 1; };
device_instance:
WORD '*' = { $$ = starref($1); } |
WORD = { $$ = $1; };
attachment:
ROOT = { $$ = NULL; } |
WORD '?' = { $$ = wildref($1); } |
WORD '*' = { $$ = starref($1); } |
WORD = { $$ = $1; };
locators:
locators locator = { ($$ = $2)->nv_next = $1; } |
/* empty */ = { $$ = NULL; };
locator:
WORD value = { $$ = new_ns($1, $2); } |
WORD '?' = { $$ = new_ns($1, NULL); };
flags_opt:
FLAGS NUMBER = { $$ = $2; } |
/* empty */ = { $$ = 0; };
%%
void
yyerror(s)
const char *s;
{
error("%s", s);
}
/*
* Cleanup procedure after syntax error: release any nvlists
* allocated during parsing the current line.
*/
static void
cleanup()
{
register struct nvlist **np;
register int i;
for (np = alloc, i = adepth; --i >= 0; np++)
nvfree(*np);
adepth = 0;
}
static void
setmachine(mch)
const char *mch;
{
char buf[MAXPATHLEN];
machine = mch;
(void)sprintf(buf, "files.%s", mch);
if (include(buf, ENDFILE) ||
include("../../conf/files.newconf", ENDFILE))
exit(1);
}

279
usr.sbin/config.new/hash.c
View File

@ -1,279 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)hash.c 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
/*
* Interned strings are kept in a hash table. By making each string
* unique, the program can compare strings by comparing pointers.
*/
struct hashent {
struct hashent *h_next; /* hash buckets are chained */
const char *h_name; /* the string */
u_int h_hash; /* its hash value */
void *h_value; /* other values (for name=value) */
};
struct hashtab {
size_t ht_size; /* size (power of 2) */
u_int ht_mask; /* == ht_size - 1 */
u_int ht_used; /* number of entries used */
u_int ht_lim; /* when to expand */
struct hashent **ht_tab; /* base of table */
};
static struct hashtab strings;
/*
* HASHFRACTION controls ht_lim, which in turn controls the average chain
* length. We allow a few entries, on average, as comparing them is usually
* cheap (the h_hash values prevent a strcmp).
*/
#define HASHFRACTION(sz) ((sz) * 3 / 2)
/* round up to next multiple of y, where y is a power of 2 */
#define ROUND(x, y) (((x) + (y) - 1) & ~((y) - 1))
/*
* Allocate space that will never be freed.
*/
static void *
poolalloc(size)
size_t size;
{
register char *p;
register size_t alloc;
static char *pool;
static size_t nleft;
if (nleft < size) {
/*
* Compute a `good' size to allocate via malloc.
* 16384 is a guess at a good page size for malloc;
* 32 is a guess at malloc's overhead.
*/
alloc = ROUND(size + 32, 16384) - 32;
p = emalloc(alloc);
nleft = alloc - size;
} else {
p = pool;
nleft -= size;
}
pool = p + size;
return (p);
}
/*
* Initialize a new hash table. The size must be a power of 2.
*/
static void
ht_init(ht, sz)
register struct hashtab *ht;
size_t sz;
{
register struct hashent **h;
register u_int n;
h = emalloc(sz * sizeof *h);
ht->ht_tab = h;
ht->ht_size = sz;
ht->ht_mask = sz - 1;
for (n = 0; n < sz; n++)
*h++ = NULL;
ht->ht_used = 0;
ht->ht_lim = HASHFRACTION(sz);
}
/*
* Expand an existing hash table.
*/
static void
ht_expand(ht)
register struct hashtab *ht;
{
register struct hashent *p, **h, **oldh, *q;
register u_int n, i;
n = ht->ht_size * 2;
h = emalloc(n * sizeof *h);
for (i = 0; i < n; i++)
h[i] = NULL;
oldh = ht->ht_tab;
n--;
for (i = ht->ht_size; i != 0; i--) {
for (p = *oldh++; p != NULL; p = q) {
q = p->h_next;
p->h_next = h[p->h_hash & n];
h[p->h_hash & n] = p;
}
}
free(ht->ht_tab);
ht->ht_tab = h;
ht->ht_mask = n;
ht->ht_size = ++n;
ht->ht_lim = HASHFRACTION(n);
}
/*
* Make a new hash entry, setting its h_next to NULL.
*/
static inline struct hashent *
newhashent(name, h)
const char *name;
u_int h;
{
register struct hashent *hp;
register char *m;
m = poolalloc(sizeof(*hp) + ALIGNBYTES);
hp = (struct hashent *)ALIGN(m);
hp->h_name = name;
hp->h_hash = h;
hp->h_next = NULL;
return (hp);
}
/*
* Hash a string.
*/
static inline u_int
hash(str)
register const char *str;
{
register u_int h;
for (h = 0; *str;)
h = (h << 5) + h + *str++;
return (h);
}
void
initintern()
{
ht_init(&strings, 128);
}
/*
* Generate a single unique copy of the given string. We expect this
* function to be used frequently, so it should be fast.
*/
const char *
intern(s)
register const char *s;
{
register struct hashtab *ht;
register struct hashent *hp, **hpp;
register u_int h;
register char *p;
register size_t l;
ht = &strings;
h = hash(s);
hpp = &ht->ht_tab[h & ht->ht_mask];
for (; (hp = *hpp) != NULL; hpp = &hp->h_next)
if (hp->h_hash == h && strcmp(hp->h_name, s) == 0)
return (hp->h_name);
l = strlen(s) + 1;
p = poolalloc(l);
bcopy(s, p, l);
*hpp = newhashent(p, h);
if (++ht->ht_used > ht->ht_lim)
ht_expand(ht);
return (p);
}
struct hashtab *
ht_new()
{
register struct hashtab *ht;
ht = emalloc(sizeof *ht);
ht_init(ht, 8);
return (ht);
}
/*
* Insert and/or replace.
*/
int
ht_insrep(ht, nam, val, replace)
register struct hashtab *ht;
register const char *nam;
void *val;
int replace;
{
register struct hashent *hp, **hpp;
register u_int h;
h = hash(nam);
hpp = &ht->ht_tab[h & ht->ht_mask];
for (; (hp = *hpp) != NULL; hpp = &hp->h_next) {
if (hp->h_name == nam) {
if (replace)
hp->h_value = val;
return (1);
}
}
*hpp = hp = newhashent(nam, h);
hp->h_value = val;
return (0);
}
void *
ht_lookup(ht, nam)
register struct hashtab *ht;
register const char *nam;
{
register struct hashent *hp, **hpp;
register u_int h;
h = hash(nam);
hpp = &ht->ht_tab[h & ht->ht_mask];
for (; (hp = *hpp) != NULL; hpp = &hp->h_next)
if (hp->h_name == nam)
return (hp->h_value);
return (NULL);
}

466
usr.sbin/config.new/main.c
View File

@ -1,466 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)main.c 8.1 (Berkeley) 6/6/93
*/
#ifndef lint
static char copyright[] =
"@(#) Copyright (c) 1992, 1993\n\
The Regents of the University of California. All rights reserved.\n";
#endif /* not lint */
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "config.h"
int firstfile __P((const char *));
int yyparse __P((void));
extern char *optarg;
extern int optind;
static struct hashtab *opttab;
static struct hashtab *mkopttab;
static struct nvlist **nextopt;
static struct nvlist **nextmkopt;
static __dead void stop __P((void));
static int do_option __P((struct hashtab *, struct nvlist ***,
const char *, const char *, const char *));
static int crosscheck __P((void));
static int badstar __P((void));
static int mksymlinks __P((void));
static int has_instances __P((struct devbase *, int));
static int hasparent __P((struct devi *));
static int cfcrosscheck __P((struct config *, const char *, struct nvlist *));
int
main(argc, argv)
int argc;
char **argv;
{
register char *p;
int pflag, ch;
struct stat st;
pflag = 0;
while ((ch = getopt(argc, argv, "gp")) != EOF) {
switch (ch) {
case 'g':
/*
* In addition to DEBUG, you probably wanted to
* set "options KGDB" and maybe others. We could
* do that for you, but you really should just
* put them in the config file.
*/
(void)fputs(
"-g is obsolete (use makeoptions DEBUG=\"-g\")\n",
stderr);
goto usage;
case 'p':
/*
* Essentially the same as makeoptions PROF="-pg",
* but also changes the path from ../../compile/FOO
* to ../../compile/FOO.prof; i.e., compile a
* profiling kernel based on a typical "regular"
* kernel.
*
* Note that if you always want profiling, you
* can (and should) use a "makeoptions" line.
*/
pflag = 1;
break;
case '?':
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 1) {
usage:
(void)fputs("usage: config [-p] sysname\n", stderr);
exit(1);
}
conffile = argv[0];
if (firstfile(conffile)) {
(void)fprintf(stderr, "config: cannot read %s: %s\n",
conffile, strerror(errno));
exit(2);
}
/*
* Init variables.
*/
minmaxusers = 1;
maxmaxusers = 10000;
initintern();
initfiles();
initsem();
devbasetab = ht_new();
selecttab = ht_new();
needcnttab = ht_new();
opttab = ht_new();
mkopttab = ht_new();
nextopt = &options;
nextmkopt = &mkoptions;
/*
* Handle profiling (must do this before we try to create any
* files).
*/
if (pflag) {
char *s;
s = emalloc(strlen(conffile) + sizeof(".PROF"));
(void)sprintf(s, "%s.PROF", conffile);
confdirbase = s;
(void)addmkoption(intern("PROF"), "-pg");
(void)addoption(intern("GPROF"), NULL);
} else
confdirbase = conffile;
/*
* Verify, creating if necessary, the compilation directory.
*/
p = path(NULL);
if (stat(p, &st)) {
if (mkdir(p, 0777)) {
(void)fprintf(stderr, "config: cannot create %s: %s\n",
p, strerror(errno));
exit(2);
}
} else if (!S_ISDIR(st.st_mode)) {
(void)fprintf(stderr, "config: %s is not a directory\n", p);
exit(2);
}
/*
* Parse config file (including machine definitions).
*/
if (yyparse())
stop();
/*
* Fix (as in `set firmly in place') files.
*/
if (fixfiles())
stop();
/*
* Perform cross-checking.
*/
if (maxusers == 0) {
if (defmaxusers) {
(void)printf("maxusers not specified; %d assumed\n",
defmaxusers);
maxusers = defmaxusers;
} else {
(void)fprintf(stderr,
"config: need \"maxusers\" line\n");
errors++;
}
}
if (crosscheck() || errors)
stop();
/*
* Squeeze things down and finish cross-checks (STAR checks must
* run after packing).
*/
pack();
if (badstar())
stop();
/*
* Ready to go. Build all the various files.
*/
if (mksymlinks() || mkmakefile() || mkheaders() || mkswap() ||
mkioconf())
stop();
(void)printf("Don't forget to run \"make depend\"\n");
exit(0);
}
/*
* Make a symlink for "machine" so that "#include <machine/foo.h>" works.
*/
static int
mksymlinks()
{
int ret;
char *p, buf[200];
p = path("machine");
(void)sprintf(buf, "../../%s/include", machine);
(void)unlink(p);
ret = symlink(buf, p);
if (ret)
(void)fprintf(stderr, "config: symlink(%s -> %s): %s\n",
p, buf, strerror(errno));
free(p);
return (ret);
}
static __dead void
stop()
{
(void)fprintf(stderr, "*** Stop.\n");
exit(1);
}
/*
* Add an option from "options FOO". Note that this selects things that
* are "optional foo".
*/
void
addoption(name, value)
const char *name, *value;
{
register const char *n;
register char *p, c;
char low[500];
if (do_option(opttab, &nextopt, name, value, "options"))
return;
/* make lowercase, then add to select table */
for (n = name, p = low; (c = *n) != '\0'; n++)
*p++ = isupper(c) ? tolower(c) : c;
*p = 0;
n = intern(low);
(void)ht_insert(selecttab, n, (void *)n);
}
/*
* Add a "make" option.
*/
void
addmkoption(name, value)
const char *name, *value;
{
(void)do_option(mkopttab, &nextmkopt, name, value, "mkoptions");
}
/*
* Add a name=value pair to an option list. The value may be NULL.
*/
static int
do_option(ht, nppp, name, value, type)
struct hashtab *ht;
struct nvlist ***nppp;
const char *name, *value, *type;
{
register struct nvlist *nv;
/* assume it will work */
nv = newnv(name, value, NULL, 0);
if (ht_insert(ht, name, nv) == 0) {
**nppp = nv;
*nppp = &nv->nv_next;
return (0);
}
/* oops, already got that option */
nvfree(nv);
if ((nv = ht_lookup(ht, name)) == NULL)
panic("do_option");
if (nv->nv_str != NULL)
error("already have %s `%s=%s'", type, name, nv->nv_str);
else
error("already have %s `%s'", type, name);
return (1);
}
/*
* Return true if there is at least one instance of the given unit
* on the given base (or any units, if unit == WILD).
*/
static int
has_instances(dev, unit)
register struct devbase *dev;
int unit;
{
register struct devi *i;
if (unit == WILD)
return (dev->d_ihead != NULL);
for (i = dev->d_ihead; i != NULL; i = i->i_bsame)
if (unit == i->i_unit)
return (1);
return (0);
}
static int
hasparent(i)
register struct devi *i;
{
register struct nvlist *nv;
int atunit = i->i_atunit;
if (i->i_atdev != NULL && has_instances(i->i_atdev, atunit))
return (1);
if (i->i_atattr != NULL)
for (nv = i->i_atattr->a_refs; nv != NULL; nv = nv->nv_next)
if (has_instances(nv->nv_ptr, atunit))
return (1);
return (0);
}
static int
cfcrosscheck(cf, what, nv)
register struct config *cf;
const char *what;
register struct nvlist *nv;
{
register struct devbase *dev;
int errs;
for (errs = 0; nv != NULL; nv = nv->nv_next) {
if (nv->nv_name == NULL)
continue;
dev = ht_lookup(devbasetab, nv->nv_name);
if (dev == NULL)
panic("cfcrosscheck(%s)", nv->nv_name);
if (has_instances(dev, STAR) ||
has_instances(dev, minor(nv->nv_int) >> 3))
continue;
(void)fprintf(stderr,
"%s%d: %s says %s on %s, but there's no %s\n",
conffile, cf->cf_lineno,
cf->cf_name, what, nv->nv_str, nv->nv_str);
errs++;
}
return (errs);
}
/*
* Cross-check the configuration: make sure that each target device
* or attribute (`at foo[0*?]') names at least one real device. Also
* see that the root, swap, and dump devices for all configurations
* are there.
*/
int
crosscheck()
{
register struct devi *i;
register struct config *cf;
int errs;
errs = 0;
for (i = alldevi; i != NULL; i = i->i_next) {
if (i->i_at == NULL || hasparent(i))
continue;
xerror(conffile, i->i_lineno,
"%s at %s is orphaned", i->i_name, i->i_at);
if (i->i_atunit == WILD)
(void)fprintf(stderr, " (no %s's declared)\n",
i->i_base->d_name);
else
(void)fprintf(stderr, " (no %s declared)\n", i->i_at);
errs++;
}
if (allcf == NULL) {
(void)fprintf(stderr, "%s has no configurations!\n",
conffile);
errs++;
}
for (cf = allcf; cf != NULL; cf = cf->cf_next) {
if (cf->cf_root != NULL) { /* i.e., not swap generic */
errs += cfcrosscheck(cf, "root", cf->cf_root);
errs += cfcrosscheck(cf, "swap", cf->cf_swap);
errs += cfcrosscheck(cf, "dumps", cf->cf_dump);
}
}
return (errs);
}
/*
* Check to see if there is more than one *'d unit for any device,
* or a *'d unit with a needs-count file.
*/
int
badstar()
{
register struct devbase *d;
register struct devi *i;
register int errs, n;
errs = 0;
for (d = allbases; d != NULL; d = d->d_next) {
for (i = d->d_ihead; i != NULL; i = i->i_bsame)
if (i->i_unit == STAR)
goto foundstar;
continue;
foundstar:
if (ht_lookup(needcnttab, d->d_name)) {
(void)fprintf(stderr,
"config: %s's cannot be *'d until its driver is fixed\n",
d->d_name);
errs++;
continue;
}
for (n = 0; i != NULL; i = i->i_alias)
if (!i->i_collapsed)
n++;
if (n < 1)
panic("badstar() n<1");
if (n == 1)
continue;
(void)fprintf(stderr,
"config: %d %s*'s in configuration; can only have 1\n",
n, d->d_name);
errs++;
}
return (errs);
}

148
usr.sbin/config.new/mkheaders.c
View File

@ -1,148 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)mkheaders.c 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
static int emitcnt __P((struct nvlist *));
static int err __P((const char *, char *, FILE *));
static char *cntname __P((const char *));
/*
* Make headers containing counts, as needed.
*/
int
mkheaders()
{
register struct files *fi;
for (fi = allfiles; fi != NULL; fi = fi->fi_next) {
if (fi->fi_flags & FI_HIDDEN)
continue;
if (fi->fi_flags & (FI_NEEDSCOUNT | FI_NEEDSFLAG) &&
emitcnt(fi->fi_opt))
return (1);
}
return (0);
}
static int
emitcnt(head)
register struct nvlist *head;
{
register struct nvlist *nv;
register FILE *fp;
register char *fname;
int cnt;
char nam[100];
char buf[BUFSIZ];
(void)sprintf(buf, "%s.h", head->nv_name);
fname = path(buf);
if ((fp = fopen(fname, "r")) == NULL)
goto writeit;
nv = head;
while (fgets(buf, sizeof(buf), fp) != NULL) {
if (nv == NULL)
goto writeit;
if (sscanf(buf, "#define %s %d", nam, &cnt) != 2 ||
strcmp(nam, cntname(nv->nv_name)) != 0 ||
cnt != nv->nv_int)
goto writeit;
nv = nv->nv_next;
}
if (ferror(fp))
return (err("read", fname, fp));
(void)fclose(fp);
if (nv == NULL)
return (0);
writeit:
if ((fp = fopen(fname, "w")) == NULL) {
(void)fprintf(stderr, "config: cannot write %s: %s\n",
fname, strerror(errno));
return (1);
}
for (nv = head; nv != NULL; nv = nv->nv_next)
if (fprintf(fp, "#define\t%s\t%d\n",
cntname(nv->nv_name), nv->nv_int) < 0)
return (err("writ", fname, fp));
if (fclose(fp))
return (err("writ", fname, NULL));
return (0);
}
static int
err(what, fname, fp)
const char *what;
char *fname;
FILE *fp;
{
(void)fprintf(stderr, "config: error %sing %s: %s\n",
what, fname, strerror(errno));
if (fp)
(void)fclose(fp);
free(fname);
return (1);
}
static char *
cntname(src)
register const char *src;
{
register char *dst, c;
static char buf[100];
dst = buf;
*dst++ = 'N';
while ((c = *src++) != 0)
*dst++ = islower(c) ? toupper(c) : c;
*dst = 0;
return (buf);
}

395
usr.sbin/config.new/mkioconf.c
View File

@ -1,395 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)mkioconf.c 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
/*
* Make ioconf.c.
*/
static int cforder __P((const void *, const void *));
static int emitcfdata __P((FILE *));
static int emitexterns __P((FILE *));
static int emithdr __P((FILE *));
static int emitloc __P((FILE *));
static int emitpseudo __P((FILE *));
static int emitpv __P((FILE *));
static int emitroots __P((FILE *));
static int emitvec __P((FILE *));
static char *vecname __P((char *, const char *, int));
static const char *s_i386;
#define SEP(pos, max) (((u_int)(pos) % (max)) == 0 ? "\n\t" : " ")
/*
* NEWLINE can only be used in the emitXXX functions.
* In most cases it can be subsumed into an fprintf.
*/
#define NEWLINE if (putc('\n', fp) < 0) return (1)
int
mkioconf()
{
register FILE *fp;
register char *fname;
int v;
s_i386 = intern("i386");
fname = path("ioconf.c");
qsort(packed, npacked, sizeof *packed, cforder);
if ((fp = fopen(fname, "w")) == NULL) {
(void)fprintf(stderr, "config: cannot write %s: %s\n",
fname, strerror(errno));
return (1);
}
v = emithdr(fp);
if (v != 0 || emitvec(fp) || emitexterns(fp) || emitloc(fp) ||
emitpv(fp) || emitcfdata(fp) || emitroots(fp) || emitpseudo(fp)) {
if (v >= 0)
(void)fprintf(stderr,
"config: error writing %s: %s\n",
fname, strerror(errno));
(void)fclose(fp);
/* (void)unlink(fname); */
free(fname);
return (1);
}
(void)fclose(fp);
free(fname);
return (0);
}
static int
cforder(a, b)
const void *a, *b;
{
register int n1, n2;
n1 = (*(struct devi **)a)->i_cfindex;
n2 = (*(struct devi **)b)->i_cfindex;
return (n1 - n2);
}
static int
emithdr(ofp)
register FILE *ofp;
{
register FILE *ifp;
register int n;
char ifn[200], buf[BUFSIZ];
if (fprintf(ofp, "\
/*\n\
* MACHINE GENERATED: DO NOT EDIT\n\
*\n\
* ioconf.c, from \"%s\"\n\
*/\n\n", conffile) < 0)
return (1);
(void)sprintf(ifn, "ioconf.incl.%s", machine);
if ((ifp = fopen(ifn, "r")) != NULL) {
while ((n = fread(buf, 1, sizeof(buf), ifp)) > 0)
if (fwrite(buf, 1, n, ofp) != n)
return (1);
if (ferror(ifp)) {
(void)fprintf(stderr, "config: error reading %s: %s\n",
ifn, strerror(errno));
(void)fclose(ifp);
return (-1);
}
(void)fclose(ifp);
} else {
if (fputs("\
#include <sys/param.h>\n\
#include <sys/device.h>\n", ofp) < 0)
return (1);
}
return (0);
}
static int
emitexterns(fp)
register FILE *fp;
{
register struct devbase *d;
NEWLINE;
for (d = allbases; d != NULL; d = d->d_next) {
if (d->d_ihead == NULL)
continue;
if (fprintf(fp, "extern struct cfdriver %scd;\n",
d->d_name) < 0)
return (1);
}
NEWLINE;
return (0);
}
static int
emitloc(fp)
register FILE *fp;
{
register int i;
if (fprintf(fp, "\n/* locators */\n\
static int loc[%d] = {", locators.used) < 0)
return (1);
for (i = 0; i < locators.used; i++)
if (fprintf(fp, "%s%s,", SEP(i, 8), locators.vec[i]) < 0)
return (1);
return (fprintf(fp, "\n};\n") < 0);
}
/*
* Emit global parents-vector.
*/
static int
emitpv(fp)
register FILE *fp;
{
register int i;
if (fprintf(fp, "\n/* parent vectors */\n\
static short pv[%d] = {", parents.used) < 0)
return (1);
for (i = 0; i < parents.used; i++)
if (fprintf(fp, "%s%d,", SEP(i, 16), parents.vec[i]) < 0)
return (1);
return (fprintf(fp, "\n};\n") < 0);
}
/*
* Emit the cfdata array.
*/
static int
emitcfdata(fp)
register FILE *fp;
{
register struct devi **p, *i, **par;
register int unit, v;
register const char *vs, *state, *basename;
register struct nvlist *nv;
register struct attr *a;
char *loc;
char locbuf[20];
if (fprintf(fp, "\n\
#define NORM FSTATE_NOTFOUND\n\
#define STAR FSTATE_STAR\n\
\n\
struct cfdata cfdata[] = {\n\
\t/* driver unit state loc flags parents ivstubs */\n") < 0)
return (1);
for (p = packed; (i = *p) != NULL; p++) {
/* the description */
if (fprintf(fp, "/*%3d: %s at ", i->i_cfindex, i->i_name) < 0)
return (1);
par = i->i_parents;
for (v = 0; v < i->i_pvlen; v++)
if (fprintf(fp, "%s%s", v == 0 ? "" : "|",
i->i_parents[v]->i_name) < 0)
return (1);
if (v == 0 && fputs("root", fp) < 0)
return (1);
a = i->i_atattr;
nv = a->a_locs;
for (nv = a->a_locs, v = 0; nv != NULL; nv = nv->nv_next, v++)
if (fprintf(fp, " %s %s",
nv->nv_name, i->i_locs[v]) < 0)
return (1);
if (fputs(" */\n", fp) < 0)
return (-1);
/* then the actual defining line */
basename = i->i_base->d_name;
if (i->i_unit == STAR) {
unit = i->i_base->d_umax;
state = "STAR";
} else {
unit = i->i_unit;
state = "NORM";
}
if (i->i_ivoff < 0) {
vs = "";
v = 0;
} else {
vs = "vec+";
v = i->i_ivoff;
}
if (i->i_locoff >= 0) {
(void)sprintf(locbuf, "loc+%3d", i->i_locoff);
loc = locbuf;
} else
loc = "loc";
if (fprintf(fp, "\
\t{&%scd,%s%2d, %s, %7s, %#6x, pv+%2d, %s%d},\n",
basename, strlen(basename) < 3 ? "\t\t" : "\t", unit,
state, loc, i->i_cfflags, i->i_pvoff, vs, v) < 0)
return (1);
}
return (fputs("\t{0}\n};\n", fp) < 0);
}
/*
* Emit the table of potential roots.
*/
static int
emitroots(fp)
register FILE *fp;
{
register struct devi **p, *i;
if (fputs("\nshort cfroots[] = {\n", fp) < 0)
return (1);
for (p = packed; (i = *p) != NULL; p++) {
if (i->i_at != NULL)
continue;
if (i->i_unit != 0 &&
(i->i_unit != STAR || i->i_base->d_umax != 0))
(void)fprintf(stderr,
"config: warning: `%s at root' is not unit 0\n",
i->i_name);
if (fprintf(fp, "\t%2d /* %s */,\n",
i->i_cfindex, i->i_name) < 0)
return (1);
}
return (fputs("\t-1\n};\n", fp) < 0);
}
/*
* Emit pseudo-device initialization.
*/
static int
emitpseudo(fp)
register FILE *fp;
{
register struct devi *i;
register struct devbase *d;
if (fputs("\n/* pseudo-devices */\n", fp) < 0)
return (1);
for (i = allpseudo; i != NULL; i = i->i_next)
if (fprintf(fp, "extern void %sattach __P((int));\n",
i->i_base->d_name) < 0)
return (1);
if (fputs("\nstruct pdevinit pdevinit[] = {\n", fp) < 0)
return (1);
for (i = allpseudo; i != NULL; i = i->i_next) {
d = i->i_base;
if (fprintf(fp, "\t{ %sattach, %d },\n",
d->d_name, d->d_umax) < 0)
return (1);
}
return (fputs("\t{ 0, 0 }\n};\n", fp) < 0);
}
/*
* Emit interrupt vector declarations, and calculate offsets.
*/
static int
emitvec(fp)
register FILE *fp;
{
register struct nvlist *head, *nv;
register struct devi **p, *i;
register int j, nvec, unit;
char buf[200];
nvec = 0;
for (p = packed; (i = *p) != NULL; p++) {
if ((head = i->i_base->d_vectors) == NULL)
continue;
if ((unit = i->i_unit) == STAR)
panic("emitvec unit==STAR");
if (nvec == 0)
NEWLINE;
for (j = 0, nv = head; nv != NULL; j++, nv = nv->nv_next)
if (fprintf(fp,
"/* IVEC %s %d */ extern void %s();\n",
nv->nv_name, unit,
vecname(buf, nv->nv_name, unit)) < 0)
return (1);
nvec += j + 1;
}
if (nvec == 0)
return (0);
if (fprintf(fp, "\nstatic void (*vec[%d]) __P((void)) = {", nvec) < 0)
return (1);
nvec = 0;
for (p = packed; (i = *p) != NULL; p++) {
if ((head = i->i_base->d_vectors) == NULL)
continue;
i->i_ivoff = nvec;
unit = i->i_unit;
for (nv = head; nv != NULL; nv = nv->nv_next)
if (fprintf(fp, "%s%s,",
SEP(nvec++, 4),
vecname(buf, nv->nv_name, unit)) < 0)
return (1);
if (fprintf(fp, "%s0,", SEP(nvec++, 4)) < 0)
return (1);
}
return (fputs("\n};\n", fp) < 0);
}
static char *
vecname(buf, name, unit)
char *buf;
const char *name;
int unit;
{
/* @#%* 386 uses a different name format */
if (machine == s_i386) {
(void)sprintf(buf, "V%s%d", name, unit);
return (buf);
}
(void)sprintf(buf, "X%s%d", name, unit);
return (buf);
}

364
usr.sbin/config.new/mkmakefile.c
View File

@ -1,364 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)mkmakefile.c 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
/*
* Make the Makefile.
*/
static int emitdefs __P((FILE *));
static int emitobjs __P((FILE *));
static int emitcfiles __P((FILE *));
static int emitsfiles __P((FILE *));
static int emitfiles __P((FILE *, int));
static int emitrules __P((FILE *));
static int emitload __P((FILE *));
int
mkmakefile()
{
register FILE *ifp, *ofp;
register int lineno;
register int (*fn) __P((FILE *));
register char *ofname;
char line[BUFSIZ], ifname[200];
(void)sprintf(ifname, "Makefile.%s", machine);
if ((ifp = fopen(ifname, "r")) == NULL) {
(void)fprintf(stderr, "config: cannot read %s: %s\n",
ifname, strerror(errno));
return (1);
}
ofname = path("Makefile");
if ((ofp = fopen(ofname, "w")) == NULL) {
(void)fprintf(stderr, "config: cannot write %s: %s\n",
ofname, strerror(errno));
free(ofname);
return (1);
}
if (emitdefs(ofp) != 0)
goto wrerror;
lineno = 0;
while (fgets(line, sizeof(line), ifp) != NULL) {
lineno++;
if (line[0] != '%') {
if (fputs(line, ofp) < 0)
goto wrerror;
continue;
}
if (strcmp(line, "%OBJS\n") == 0)
fn = emitobjs;
else if (strcmp(line, "%CFILES\n") == 0)
fn = emitcfiles;
else if (strcmp(line, "%SFILES\n") == 0)
fn = emitsfiles;
else if (strcmp(line, "%RULES\n") == 0)
fn = emitrules;
else if (strcmp(line, "%LOAD\n") == 0)
fn = emitload;
else {
xerror(ifname, lineno,
"unknown %% construct ignored: %s", line);
continue;
}
if ((*fn)(ofp))
goto wrerror;
}
if (ferror(ifp)) {
(void)fprintf(stderr,
"config: error reading %s (at line %d): %s\n",
ifname, lineno, strerror(errno));
goto bad;
/* (void)unlink(ofname); */
free(ofname);
return (1);
}
if (fclose(ofp)) {
ofp = NULL;
goto wrerror;
}
(void)fclose(ifp);
free(ofname);
return (0);
wrerror:
(void)fprintf(stderr, "config: error writing %s: %s\n",
ofname, strerror(errno));
bad:
if (ofp != NULL)
(void)fclose(ofp);
/* (void)unlink(ofname); */
free(ofname);
return (1);
}
static int
emitdefs(fp)
register FILE *fp;
{
register struct nvlist *nv;
register char *sp;
if (fputs("IDENT=", fp) < 0)
return (1);
sp = "";
for (nv = options; nv != NULL; nv = nv->nv_next) {
if (fprintf(fp, "%s-D%s%s%s", sp, nv->nv_name,
nv->nv_str ? "=" : "", nv->nv_str ? nv->nv_str : "") < 0)
return (1);
sp = " ";
}
if (putc('\n', fp) < 0)
return (1);
if (fprintf(fp, "PARAM=-DMAXUSERS=%d\n", maxusers) < 0)
return (1);
for (nv = mkoptions; nv != NULL; nv = nv->nv_next)
if (fprintf(fp, "%s=%s\n", nv->nv_name, nv->nv_str) < 0)
return (1);
return (0);
}
static int
emitobjs(fp)
register FILE *fp;
{
register struct files *fi;
register int lpos, len, sp;
if (fputs("OBJS=", fp) < 0)
return (1);
sp = '\t';
lpos = 7;
for (fi = allfiles; fi != NULL; fi = fi->fi_next) {
if ((fi->fi_flags & FI_SEL) == 0)
continue;
len = strlen(fi->fi_base) + 2;
if (lpos + len > 72) {
if (fputs(" \\\n", fp) < 0)
return (1);
sp = '\t';
lpos = 7;
}
if (fprintf(fp, "%c%s.o", sp, fi->fi_base) < 0)
return (1);
lpos += len + 1;
sp = ' ';
}
if (lpos != 7 && putc('\n', fp) < 0)
return (1);
return (0);
}
static int
emitcfiles(fp)
FILE *fp;
{
return (emitfiles(fp, 'c'));
}
static int
emitsfiles(fp)
FILE *fp;
{
return (emitfiles(fp, 's'));
}
static int
emitfiles(fp, suffix)
register FILE *fp;
int suffix;
{
register struct files *fi;
register struct config *cf;
register int lpos, len, sp;
char swapname[100];
if (fprintf(fp, "%cFILES=", toupper(suffix)) < 0)
return (1);
sp = '\t';
lpos = 7;
for (fi = allfiles; fi != NULL; fi = fi->fi_next) {
if ((fi->fi_flags & FI_SEL) == 0)
continue;
len = strlen(fi->fi_path);
if (fi->fi_path[len - 1] != suffix)
continue;
if (*fi->fi_path != '/')
len += 3; /* "$S/" */
if (lpos + len > 72) {
if (fputs(" \\\n", fp) < 0)
return (1);
sp = '\t';
lpos = 7;
}
if (fprintf(fp, "%c%s%s", sp, *fi->fi_path != '/' ? "$S/" : "",
fi->fi_path) < 0)
return (1);
lpos += len + 1;
sp = ' ';
}
/*
* The allfiles list does not include the configuration-specific
* C source files. These files should be eliminated someday, but
* for now, we have to add them to ${CFILES} (and only ${CFILES}).
*/
if (suffix == 'c') {
for (cf = allcf; cf != NULL; cf = cf->cf_next) {
if (cf->cf_root == NULL)
(void)sprintf(swapname,
"$S/%s/%s/swapgeneric.c",
machine, machine);
else
(void)sprintf(swapname, "swap%s.c",
cf->cf_name);
len = strlen(swapname);
if (lpos + len > 72) {
if (fputs(" \\\n", fp) < 0)
return (1);
sp = '\t';
lpos = 7;
}
if (fprintf(fp, "%c%s", sp, swapname) < 0)
return (1);
lpos += len + 1;
sp = ' ';
}
}
if (lpos != 7 && putc('\n', fp) < 0)
return (1);
return (0);
}
/*
* Emit the make-rules.
*/
static int
emitrules(fp)
register FILE *fp;
{
register struct files *fi;
register const char *cp;
int ch;
char buf[200];
for (fi = allfiles; fi != NULL; fi = fi->fi_next) {
if ((fi->fi_flags & FI_SEL) == 0)
continue;
if (fprintf(fp, "%s.o: %s%s\n", fi->fi_base,
*fi->fi_path != '/' ? "$S/" : "", fi->fi_path) < 0)
return (1);
if ((cp = fi->fi_mkrule) == NULL) {
cp = fi->fi_flags & FI_DRIVER ? "DRIVER" : "NORMAL";
ch = fi->fi_lastc;
if (islower(ch))
ch = toupper(ch);
(void)sprintf(buf, "${%s_%c%s}", cp, ch,
fi->fi_flags & FI_CONFIGDEP ? "_C" : "");
cp = buf;
}
if (fprintf(fp, "\t%s\n\n", cp) < 0)
return (1);
}
return (0);
}
/*
* Emit the load commands.
*
* This function is not to be called `spurt'.
*/
static int
emitload(fp)
register FILE *fp;
{
register struct config *cf;
register const char *nm, *swname;
int first;
if (fputs("all:", fp) < 0)
return (1);
for (cf = allcf; cf != NULL; cf = cf->cf_next) {
if (fprintf(fp, " %s", cf->cf_name) < 0)
return (1);
}
if (fputs("\n\n", fp) < 0)
return (1);
for (first = 1, cf = allcf; cf != NULL; cf = cf->cf_next) {
nm = cf->cf_name;
swname = cf->cf_root != NULL ? cf->cf_name : "generic";
if (fprintf(fp, "%s: ${SYSTEM_DEP} swap%s.o", nm, swname) < 0)
return (1);
if (first) {
if (fputs(" newvers", fp) < 0)
return (1);
first = 0;
}
if (fprintf(fp, "\n\
\t${SYSTEM_LD_HEAD}\n\
\t${SYSTEM_LD} swap%s.o\n\
\t${SYSTEM_LD_TAIL}\n\
\n\
swap%s.o: ", swname, swname) < 0)
return (1);
if (cf->cf_root != NULL) {
if (fprintf(fp, "swap%s.c\n", nm) < 0)
return (1);
} else {
if (fprintf(fp, "$S/%s/%s/swapgeneric.c\n",
machine, machine) < 0)
return (1);
}
if (fputs("\t${NORMAL_C}\n\n", fp) < 0)
return (1);
}
return (0);
}

118
usr.sbin/config.new/mkswap.c
View File

@ -1,118 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)mkswap.c 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
static int mkoneswap __P((struct config *));
/*
* Make the various swap*.c files. Nothing to do for generic swap.
*/
int
mkswap()
{
register struct config *cf;
for (cf = allcf; cf != NULL; cf = cf->cf_next)
if (cf->cf_root != NULL && mkoneswap(cf))
return (1);
return (0);
}
static int
mkoneswap(cf)
register struct config *cf;
{
register struct nvlist *nv;
register FILE *fp;
register char *fname;
char buf[200];
(void)sprintf(buf, "swap%s.c", cf->cf_name);
fname = path(buf);
if ((fp = fopen(fname, "w")) == NULL) {
(void)fprintf(stderr, "config: cannot write %s: %s\n",
fname, strerror(errno));
return (1);
}
if (fputs("\
#include <sys/param.h>\n\
#include <sys/conf.h>\n\n", fp) < 0)
goto wrerror;
nv = cf->cf_root;
if (fprintf(fp, "dev_t\trootdev = makedev(%d, %d);\t/* %s */\n",
major(nv->nv_int), minor(nv->nv_int), nv->nv_str) < 0)
goto wrerror;
nv = cf->cf_dump;
if (fprintf(fp, "dev_t\tdumpdev = makedev(%d, %d);\t/* %s */\n",
major(nv->nv_int), minor(nv->nv_int), nv->nv_str) < 0)
goto wrerror;
if (fputs("\nstruct\tswdevt swdevt[] = {\n", fp) < 0)
goto wrerror;
for (nv = cf->cf_swap; nv != NULL; nv = nv->nv_next)
if (fprintf(fp, "\t{ makedev(%d, %d),\t0,\t0 },\t/* %s */\n",
major(nv->nv_int), minor(nv->nv_int), nv->nv_str) < 0)
goto wrerror;
if (fputs("\t{ NODEV, 0, 0 }\n};\n", fp) < 0)
goto wrerror;
if (fclose(fp)) {
fp = NULL;
goto wrerror;
}
free(fname);
return (0);
wrerror:
(void)fprintf(stderr, "config: error writing %s: %s\n",
fname, strerror(errno));
if (fp != NULL)
(void)fclose(fp);
/* (void)unlink(fname); */
free(fname);
return (1);
}

520
usr.sbin/config.new/pack.c
View File

@ -1,520 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)pack.c 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
/*
* Packing. We have three separate kinds of packing here.
*
* First, we pack device instances, to collapse things like
*
* uba0 at sbi0 nexus ?
* uba0 at bi0 nexus ?
*
* into a single instance that is "at sbi0 or bi0".
*
* Second, we pack locators. Given something like
*
* hp0 at mba0 drive 0
* hp* at mba* drive ?
* ht0 at mba0 drive 0
* tu0 at ht0 slave 0
* ht* at mba* drive ?
* tu* at ht* slave ?
*
* (where the default drive and slave numbers are -1), we have three
* locators whose value is 0 and three whose value is -1. Rather than
* emitting six integers, we emit just two.
*
* Finally, we pack parent vectors. This is very much like packing
* locators. Unlike locators, however, parent vectors are always
* terminated by -1 (rather like the way C strings always end with
* a NUL).
*
* When packing locators, we would like to find sequences such as
* {1 2 3} {2 3 4} {3} {4 5}
* and turn this into the flat sequence {1 2 3 4 5}, with each subsequence
* given by the appropriate offset (here 0, 1, 2, and 3 respectively).
* When we pack parent vectors, overlap of this sort is impossible.
* Non-overlapping packing is much easier, and so we use that here
* and miss out on the chance to squeeze the locator sequence optimally.
* (So it goes.)
*/
typedef int (*vec_cmp_func) __P((const void *, int, int));
#define TAILHSIZE 128
#define PVHASH(i) ((i) & (TAILHSIZE - 1))
#define LOCHASH(l) (((int)(l) >> 2) & (TAILHSIZE - 1))
struct tails {
struct tails *t_next;
int t_ends_at;
};
static struct tails *tails[TAILHSIZE];
static int locspace;
static int pvecspace;
static int longest_pvec;
static void packdevi __P((void));
static void packlocs __P((void));
static void packpvec __P((void));
static void addparents __P((struct devi *src, struct devi *dst));
static int nparents __P((struct devi **, struct devbase *, int));
static int sameas __P((struct devi *, struct devi *));
static int findvec __P((const void *, int, int, vec_cmp_func, int));
static int samelocs __P((const void *, int, int));
static int addlocs __P((const char **, int));
static int loclencmp __P((const void *, const void *));
static int samepv __P((const void *, int, int));
static int addpv __P((short *, int));
static int pvlencmp __P((const void *, const void *));
static void resettails __P((void));
void
pack()
{
register struct devi *i;
register int n;
/* Pack instances and make parent vectors. */
packdevi();
/*
* Now that we know what we have, find upper limits on space
* needed for the loc[] and pv[] tables, and find the longest
* single pvec. The loc and pv table sizes are bounded by
* what we would get if no packing occurred.
*/
locspace = pvecspace = 0;
for (i = alldevi; i != NULL; i = i->i_next) {
if (i->i_collapsed)
continue;
locspace += i->i_atattr->a_loclen;
n = i->i_pvlen + 1;
if (n > longest_pvec)
longest_pvec = n;
pvecspace += n;
}
/* Allocate and pack loc[]. */
locators.vec = emalloc(locspace * sizeof(*locators.vec));
locators.used = 0;
packlocs();
/* Allocate and pack pv[]. */
parents.vec = emalloc(pvecspace * sizeof(*parents.vec));
parents.used = 0;
packpvec();
}
/*
* Pack instances together wherever possible. When everything is
* packed, go back and set up the parents for each. We must do this
* on a second pass because during the first one, we do not know which,
* if any, of the parents will collapse during packing.
*/
void
packdevi()
{
register struct devi *i, *l, *p;
register struct devbase *d;
register int j, m, n;
packed = emalloc((ndevi + 1) * sizeof *packed);
n = 0;
for (d = allbases; d != NULL; d = d->d_next) {
/*
* For each instance of each device, add or collapse
* all its aliases.
*/
for (i = d->d_ihead; i != NULL; i = i->i_bsame) {
m = n;
for (l = i; l != NULL; l = l->i_alias) {
l->i_pvlen = 0;
l->i_pvoff = -1;
l->i_locoff = -1;
l->i_ivoff = -1;
/* try to find an equivalent for l */
for (j = m; j < n; j++) {
p = packed[j];
if (sameas(l, p)) {
l->i_collapsed = 1;
l->i_cfindex = p->i_cfindex;
goto nextalias;
}
}
/* could not find a suitable alias */
l->i_collapsed = 0;
l->i_cfindex = n;
l->i_parents = emalloc(sizeof(*l->i_parents));
l->i_parents[0] = NULL;
packed[n++] = l;
nextalias:;
}
}
}
npacked = n;
packed[n] = NULL;
for (i = alldevi; i != NULL; i = i->i_next)
addparents(i, packed[i->i_cfindex]);
}
/*
* Return true if two aliases are "the same". In this case, they need
* to have the same config flags and the same locators.
*/
static int
sameas(i1, i2)
register struct devi *i1, *i2;
{
register const char **p1, **p2;
if (i1->i_cfflags != i2->i_cfflags)
return (0);
for (p1 = i1->i_locs, p2 = i2->i_locs; *p1 == *p2; p2++)
if (*p1++ == 0)
return (1);
return 0;
}
/*
* Add the parents associated with "src" to the (presumably uncollapsed)
* instance "dst".
*/
static void
addparents(src, dst)
register struct devi *src, *dst;
{
register struct nvlist *nv;
register struct devi *i, **p, **q;
register int j, n, old, new, ndup;
if (dst->i_collapsed)
panic("addparents() i_collapsed");
/* Collect up list of parents to add. */
if (src->i_at == NULL) /* none, 'cuz "at root" */
return;
if (src->i_atdev != NULL) {
n = nparents(NULL, src->i_atdev, src->i_atunit);
p = emalloc(n * sizeof *p);
if (n == 0)
return;
(void)nparents(p, src->i_atdev, src->i_atunit);
} else {
n = 0;
for (nv = src->i_atattr->a_refs; nv != NULL; nv = nv->nv_next)
n += nparents(NULL, nv->nv_ptr, src->i_atunit);
if (n == 0)
return;
p = emalloc(n * sizeof *p);
n = 0;
for (nv = src->i_atattr->a_refs; nv != NULL; nv = nv->nv_next)
n += nparents(p + n, nv->nv_ptr, src->i_atunit);
}
/* Now elide duplicates. */
ndup = 0;
for (j = 0; j < n; j++) {
i = p[j];
for (q = dst->i_parents; *q != NULL; q++) {
if (*q == i) {
ndup++;
p[j] = NULL;
break;
}
}
}
/* Finally, add all the non-duplicates. */
old = dst->i_pvlen;
new = old + (n - ndup);
if (old > new)
panic("addparents() old > new");
if (old == new) {
free(p);
return;
}
dst->i_parents = q = erealloc(dst->i_parents, (new + 1) * sizeof(*q));
dst->i_pvlen = new;
q[new] = NULL;
q += old;
for (j = 0; j < n; j++)
if (p[j] != NULL)
*q++ = p[j];
free(p);
}
/*
* Count up parents, and optionally store pointers to each.
*/
static int
nparents(p, dev, unit)
register struct devi **p;
register struct devbase *dev;
register int unit;
{
register struct devi *i, *l;
register int n;
n = 0;
/* for each instance ... */
for (i = dev->d_ihead; i != NULL; i = i->i_bsame) {
/* ... take each un-collapsed alias */
for (l = i; l != NULL; l = l->i_alias) {
if (!l->i_collapsed &&
(unit == WILD || unit == l->i_unit)) {
if (p != NULL)
*p++ = l;
n++;
}
}
}
return (n);
}
static void
packlocs()
{
register struct devi **p, *i;
register int l, o;
qsort(packed, npacked, sizeof *packed, loclencmp);
for (p = packed; (i = *p) != NULL; p++) {
if ((l = i->i_atattr->a_loclen) > 0) {
o = findvec(i->i_locs, LOCHASH(i->i_locs[l - 1]), l,
samelocs, locators.used);
i->i_locoff = o < 0 ? addlocs(i->i_locs, l) : o;
} else
i->i_locoff = -1;
}
resettails();
}
static void
packpvec()
{
register struct devi **p, *i, **par;
register int l, v, o;
register short *vec;
vec = emalloc(longest_pvec * sizeof(*vec));
qsort(packed, npacked, sizeof *packed, pvlencmp);
for (p = packed; (i = *p) != NULL; p++) {
l = i->i_pvlen;
if (l > longest_pvec) panic("packpvec");
par = i->i_parents;
for (v = 0; v < l; v++)
vec[v] = par[v]->i_cfindex;
if (l == 0 ||
(o = findvec(vec, PVHASH(vec[l - 1]), l,
samepv, parents.used)) < 0)
o = addpv(vec, l);
i->i_pvoff = o;
}
free(vec);
resettails();
}
/*
* Return the index at which the given vector already exists, or -1
* if it is not anywhere in the current set. If we return -1, we assume
* our caller will add it at the end of the current set, and we make
* sure that next time, we will find it there.
*/
static int
findvec(ptr, hash, len, cmp, nextplace)
const void *ptr;
int hash, len;
vec_cmp_func cmp;
int nextplace;
{
register struct tails *t, **hp;
register int off;
hp = &tails[hash];
for (t = *hp; t != NULL; t = t->t_next) {
off = t->t_ends_at - len;
if (off >= 0 && (*cmp)(ptr, off, len))
return (off);
}
t = emalloc(sizeof(*t));
t->t_next = *hp;
*hp = t;
t->t_ends_at = nextplace + len;
return (-1);
}
/*
* Comparison function for locators.
*/
static int
samelocs(ptr, off, len)
const void *ptr;
int off;
register int len;
{
register const char **p, **q;
for (p = &locators.vec[off], q = (const char **)ptr; --len >= 0;)
if (*p++ != *q++)
return (0); /* different */
return (1); /* same */
}
/*
* Add the given locators at the end of the global loc[] table.
*/
static int
addlocs(locs, len)
register const char **locs;
register int len;
{
register const char **p;
register int ret;
ret = locators.used;
if ((locators.used = ret + len) > locspace)
panic("addlocs: overrun");
for (p = &locators.vec[ret]; --len >= 0;)
*p++ = *locs++;
return (ret);
}
/*
* Comparison function for qsort-by-locator-length, longest first.
* We rashly assume that subtraction of these lengths does not overflow.
*/
static int
loclencmp(a, b)
const void *a, *b;
{
register int l1, l2;
l1 = (*(struct devi **)a)->i_atattr->a_loclen;
l2 = (*(struct devi **)b)->i_atattr->a_loclen;
return (l2 - l1);
}
/*
* Comparison function for parent vectors.
*/
static int
samepv(ptr, off, len)
const void *ptr;
int off;
register int len;
{
register short *p, *q;
for (p = &parents.vec[off], q = (short *)ptr; --len >= 0;)
if (*p++ != *q++)
return (0); /* different */
return (1); /* same */
}
/*
* Add the given parent vectors at the end of the global pv[] table.
*/
static int
addpv(pv, len)
register short *pv;
register int len;
{
register short *p;
register int ret;
static int firstend = -1;
/*
* If the vector is empty, reuse the first -1. It will be
* there if there are any nonempty vectors at all, since we
* do the longest first. If there are no nonempty vectors,
* something is probably wrong, but we will ignore that here.
*/
if (len == 0 && firstend >= 0)
return (firstend);
len++; /* account for trailing -1 */
ret = parents.used;
if ((parents.used = ret + len) > pvecspace)
panic("addpv: overrun");
for (p = &parents.vec[ret]; --len > 0;)
*p++ = *pv++;
*p = -1;
if (firstend < 0)
firstend = parents.used - 1;
return (ret);
}
/*
* Comparison function for qsort-by-parent-vector-length, longest first.
* We rashly assume that subtraction of these lengths does not overflow.
*/
static int
pvlencmp(a, b)
const void *a, *b;
{
register int l1, l2;
l1 = (*(struct devi **)a)->i_pvlen;
l2 = (*(struct devi **)b)->i_pvlen;
return (l2 - l1);
}
static void
resettails()
{
register struct tails **p, *t, *next;
register int i;
for (p = tails, i = TAILHSIZE; --i >= 0; p++) {
for (t = *p; t != NULL; t = next) {
next = t->t_next;
free(t);
}
*p = NULL;
}
}

238
usr.sbin/config.new/scan.l
View File

@ -1,238 +0,0 @@
%{
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)scan.l 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "config.h"
#include "y.tab.h"
int yyline;
const char *yyfile;
const char *lastfile;
int include __P((const char *, int));
/*
* Data for returning to previous files from include files.
*/
struct incl {
struct incl *in_prev; /* previous includes in effect, if any */
YY_BUFFER_STATE in_buf; /* previous lex state */
const char *in_fname; /* previous file name */
int in_lineno; /* previous line number */
int in_preveof; /* previous eoftoken */
};
static struct incl *incl;
static int eoftoken; /* current EOF token */
static void endinclude __P((void));
#define yywrap() 1
%}
PATH [-/A-Za-z0-9_.]*[./][-/A-Za-z0-9_.]*
WORD [A-Za-z_][-A-Za-z_0-9]*
%%
/* plain keywords */
and { return AND; }
at { return AT; }
compile-with { return COMPILE_WITH; }
config { return CONFIG; }
define { return DEFINE; }
device { return DEVICE; }
dumps { return DUMPS; }
flags { return FLAGS; }
file { return XFILE; }
include { return INCLUDE; }
machine { return XMACHINE; }
major { return MAJOR; }
makeoptions { return MAKEOPTIONS; }
maxusers { return MAXUSERS; }
minor { return MINOR; }
on { return ON; }
options { return OPTIONS; }
"pseudo-device" { return PSEUDO_DEVICE; }
root { return ROOT; }
swap { return SWAP; }
vector { return VECTOR; }
/* keywords with values */
config-dependent { yylval.val = FI_CONFIGDEP; return FFLAG; }
device-driver { yylval.val = FI_DRIVER; return FFLAG; }
needs-count { yylval.val = FI_NEEDSCOUNT; return FFLAG; }
needs-flag { yylval.val = FI_NEEDSFLAG; return FFLAG; }
/* all the rest */
{PATH} { yylval.str = intern(yytext); return PATHNAME; }
{WORD} { yylval.str = intern(yytext); return WORD; }
\"[^"]+/\" {
yylval.str = intern(yytext + 1);
(void)input(); /* eat closing quote */
return WORD;
}
0[0-7]* {
yylval.val = strtol(yytext, NULL, 8);
return NUMBER;
}
0[xX][0-9a-fA-F]+ {
yylval.val = strtol(yytext + 2, NULL, 16);
return NUMBER;
}
[1-9][0-9]* {
yylval.val = strtol(yytext, NULL, 10);
return NUMBER;
}
\n/[ \t] {
yyline++;
}
\n {
yyline++;
return '\n';
}
#.* { /* ignored (comment) */; }
[ \t]* { /* ignored (white space) */; }
. { return yytext[0]; }
<<EOF>> {
int tok;
tok = eoftoken;
eoftoken = YY_NULL;
if (incl != NULL)
endinclude();
return (tok);
}
%%
/*
* Open the "main" file (conffile).
*/
int
firstfile(fname)
const char *fname;
{
if ((yyin = fopen(fname, "r")) == NULL)
return (-1);
yyfile = conffile = fname;
yyline = 1;
eoftoken = YY_NULL;
return (0);
}
/*
* Open the named file for inclusion at the current point. Returns 0 on
* success (file opened and previous state pushed), nonzero on failure
* (fopen failed, complaint made). The `ateof' parameter controls the
* token to be returned at the end of the include file (typically '\n'
* or ENDFILE).
*/
int
include(fname, ateof)
const char *fname;
int ateof;
{
register FILE *fp;
register struct incl *in;
if ((fp = fopen(fname, "r")) == NULL) {
error("cannot open %s for reading: %s\n",
fname, strerror(errno));
return (-1);
}
in = emalloc(sizeof *in);
in->in_prev = incl;
in->in_buf = YY_CURRENT_BUFFER;
in->in_fname = yyfile;
in->in_lineno = yyline;
in->in_preveof = eoftoken;
incl = in;
yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
yyfile = intern(fname);
yyline = 1;
eoftoken = ateof;
return (0);
}
/*
* Terminate the most recent inclusion.
*/
static void
endinclude()
{
register struct incl *in;
if ((in = incl) == NULL)
panic("endinclude");
incl = in->in_prev;
lastfile = yyfile;
yy_delete_buffer(YY_CURRENT_BUFFER);
(void)fclose(yyin);
yy_switch_to_buffer(in->in_buf);
yyfile = in->in_fname;
yyline = in->in_lineno;
eoftoken = in->in_preveof;
free(in);
}
/*
* Return the current line number. If yacc has looked ahead and caused
* us to consume a newline, we have to subtract one. yychar is yacc's
* token lookahead, so we can tell.
*/
int
currentline()
{
extern int yychar;
return (yyline - (yychar == '\n'));
}

974
usr.sbin/config.new/sem.c
View File

@ -1,974 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)sem.c 8.1 (Berkeley) 6/6/93
*/
#include <sys/param.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
#include "sem.h"
/*
* config semantics.
*/
#define NAMESIZE 100 /* local name buffers */
static const char *s_generic;
static const char *s_qmark;
static struct hashtab *attrtab; /* for attribute lookup */
static struct hashtab *cfhashtab; /* for config lookup */
static struct hashtab *devitab; /* etc */
static struct attr errattr;
static struct devbase errdev;
static struct devbase **nextbase;
static struct config **nextcf;
static struct devi **nextdevi;
static struct devi **nextpseudo;
static int has_errobj __P((struct nvlist *, void *));
static struct nvlist *addtoattr __P((struct nvlist *, struct devbase *));
static int exclude __P((struct nvlist *, const char *, const char *));
static int resolve __P((struct nvlist **, const char *, const char *,
struct nvlist *, int));
static int lresolve __P((struct nvlist **, const char *, const char *,
struct nvlist *, int));
static struct devi *newdevi __P((const char *, int, struct devbase *d));
static struct devi *getdevi __P((const char *));
static const char *concat __P((const char *, int));
static int split __P((const char *, size_t, char *, size_t, int *));
static void selectbase __P((struct devbase *));
static int onlist __P((struct nvlist *, void *));
static const char **fixloc __P((const char *, struct attr *, struct nvlist *));
void
initsem()
{
attrtab = ht_new();
errattr.a_name = "<internal>";
allbases = NULL;
nextbase = &allbases;
cfhashtab = ht_new();
allcf = NULL;
nextcf = &allcf;
devitab = ht_new();
alldevi = NULL;
nextdevi = &alldevi;
errdev.d_name = "<internal>";
allpseudo = NULL;
nextpseudo = &allpseudo;
s_generic = intern("generic");
s_qmark = intern("?");
}
void
enddefs(fname)
const char *fname;
{
register struct devbase *dev;
for (dev = allbases; dev != NULL; dev = dev->d_next) {
if (!dev->d_isdef) {
(void)fprintf(stderr,
"%s: device `%s' used but not defined\n",
fname, dev->d_name);
errors++;
continue;
}
}
if (errors) {
(void)fprintf(stderr, "*** Stop.\n");
exit(1);
}
}
void
setdefmaxusers(min, def, max)
int min, def, max;
{
if (min < 1 || min > def || def > max)
error("maxusers must have 1 <= min <= default <= max");
else {
minmaxusers = min;
defmaxusers = def;
maxmaxusers = max;
}
}
void
setmaxusers(n)
int n;
{
if (maxusers != 0) {
error("duplicate maxusers parameter");
return;
}
maxusers = n;
if (n < minmaxusers) {
error("warning: minimum of %d maxusers assumed\n", minmaxusers);
errors--; /* take it away */
maxusers = minmaxusers;
} else if (n > maxmaxusers) {
error("warning: maxusers (%d) > %d", n, maxmaxusers);
errors--;
}
}
/*
* Define an attribute, optionally with an interface (a locator list).
* Since an empty locator list is logically different from "no interface",
* all locator lists include a dummy head node, which we discard here.
*/
int
defattr(name, locs)
const char *name;
struct nvlist *locs;
{
register struct attr *a;
register struct nvlist *nv;
register int len;
a = emalloc(sizeof *a);
if (ht_insert(attrtab, name, a)) {
free(a);
error("attribute `%s' already defined", name);
nvfreel(locs);
return (1);
}
a->a_name = name;
if (locs != NULL) {
a->a_iattr = 1;
a->a_locs = locs->nv_next;
nvfree(locs);
} else {
a->a_iattr = 0;
a->a_locs = NULL;
}
len = 0;
for (nv = a->a_locs; nv != NULL; nv = nv->nv_next)
len++;
a->a_loclen = len;
a->a_devs = NULL;
a->a_refs = NULL;
return (0);
}
/*
* Return true if the given `error object' is embedded in the given
* pointer list.
*/
static int
has_errobj(nv, obj)
register struct nvlist *nv;
register void *obj;
{
for (; nv != NULL; nv = nv->nv_next)
if (nv->nv_ptr == obj)
return (1);
return (0);
}
/*
* Add a device base to a list in an attribute (actually, to any list).
* Note that this does not check for duplicates, and does reverse the
* list order, but no one cares anyway.
*/
static struct nvlist *
addtoattr(l, dev)
register struct nvlist *l;
register struct devbase *dev;
{
register struct nvlist *n;
n = newnv(NULL, NULL, dev, 0);
n->nv_next = l;
return (n);
}
/*
* Device a device, giving its allowable parent attachments, if any.
* This may (or may not) also define an interface attribute and/or refer
* to existing attributes. There may be a list of vectors.
*/
void
defdev(dev, ispseudo, atlist, vectors, loclist, attrs)
register struct devbase *dev;
int ispseudo;
struct nvlist *atlist, *vectors, *loclist, *attrs;
{
register struct nvlist *nv;
register struct attr *a;
if (dev == &errdev)
goto bad;
if (dev->d_isdef) {
error("redefinition of `%s'", dev->d_name);
goto bad;
}
dev->d_isdef = 1;
if (has_errobj(attrs, &errattr))
goto bad;
/*
* Handle implicit attribute definition from locator list. Do
* this before scanning the `at' list so that we can have, e.g.:
* device foo at other, foo { slot = -1 }
* (where you can plug in a foo-bus extender to a foo-bus).
*/
if (loclist != NULL) {
nv = loclist;
loclist = NULL; /* defattr disposes of them for us */
if (defattr(dev->d_name, nv))
goto bad;
nv = newnv(dev->d_name, NULL, getattr(dev->d_name), 0);
nv->nv_next = attrs;
attrs = nv;
}
/* Committed! Set up fields. */
dev->d_ispseudo = ispseudo;
dev->d_atlist = atlist;
dev->d_vectors = vectors;
dev->d_attrs = attrs;
/*
* Turn the `at' list into interface attributes (map each
* nv_name to an attribute, or to NULL for root), and add
* this device to those attributes, so that children can
* be listed at this particular device if they are supported
* by that attribute.
*/
for (nv = atlist; nv != NULL; nv = nv->nv_next) {
if (nv->nv_name == NULL) {
nv->nv_ptr = NULL; /* at root */
continue;
}
nv->nv_ptr = a = getattr(nv->nv_name);
if (a == &errattr)
continue; /* already complained */
if (!a->a_iattr)
error("%s cannot be at plain attribute `%s'",
dev->d_name, a->a_name);
else
a->a_devs = addtoattr(a->a_devs, dev);
}
/*
* For each interface attribute this device refers to, add this
* device to its reference list. This makes, e.g., finding all
* "scsi"s easier.
*/
for (nv = attrs; nv != NULL; nv = nv->nv_next) {
a = nv->nv_ptr;
if (a->a_iattr)
a->a_refs = addtoattr(a->a_refs, dev);
}
return;
bad:
nvfreel(atlist);
nvfreel(vectors);
nvfreel(loclist);
nvfreel(attrs);
}
/*
* Look up a devbase. Also makes sure it is a reasonable name,
* i.e., does not end in a digit or contain special characters.
*/
struct devbase *
getdevbase(name)
const char *name;
{
register u_char *p;
register struct devbase *dev;
p = (u_char *)name;
if (!isalpha(*p))
goto badname;
while (*++p) {
if (!isalnum(*p) && *p != '_')
goto badname;
}
if (isdigit(*--p)) {
badname:
error("bad device base name `%s'", name);
return (&errdev);
}
dev = ht_lookup(devbasetab, name);
if (dev == NULL) {
dev = emalloc(sizeof *dev);
dev->d_name = name;
dev->d_next = NULL;
dev->d_isdef = 0;
dev->d_major = NODEV;
dev->d_atlist = NULL;
dev->d_vectors = NULL;
dev->d_attrs = NULL;
dev->d_ihead = NULL;
dev->d_ipp = &dev->d_ihead;
dev->d_umax = 0;
*nextbase = dev;
nextbase = &dev->d_next;
if (ht_insert(devbasetab, name, dev))
panic("getdevbase(%s)", name);
}
return (dev);
}
/*
* Look up an attribute.
*/
struct attr *
getattr(name)
const char *name;
{
struct attr *a;
if ((a = ht_lookup(attrtab, name)) == NULL) {
error("undefined attribute `%s'", name);
a = &errattr;
}
return (a);
}
/*
* Set the major device number for a device, so that it can be used
* as a root/swap/dumps "on" device in a configuration.
*/
void
setmajor(d, n)
struct devbase *d;
int n;
{
if (d != &errdev && d->d_major != NODEV)
error("device `%s' is already major %d",
d->d_name, d->d_major);
else
d->d_major = n;
}
#define ABS(x) ((x) < 0 ? -(x) : (x))
static int
exclude(nv, name, what)
struct nvlist *nv;
const char *name, *what;
{
if (nv != NULL) {
error("%s: swap generic must not specify %s", name, what);
return (1);
}
return (0);
}
/*
* Map things like "ra0b" => makedev(major("ra"), 0*8 + 'b'-'a').
* Handle the case where the device number is given but there is no
* corresponding name, and map NULL to the default.
*/
static int
resolve(nvp, name, what, dflt, part)
register struct nvlist **nvp;
const char *name, *what;
struct nvlist *dflt;
register int part;
{
register struct nvlist *nv;
register struct devbase *dev;
register const char *cp;
register int maj, min, l;
int unit;
char buf[NAMESIZE];
if ((u_int)(part -= 'a') >= 7)
panic("resolve");
if ((nv = *nvp) == NULL) {
/*
* Apply default. Easiest to do this by number.
*/
maj = major(dflt->nv_int);
min = (minor(dflt->nv_int) & ~7) | part;
*nvp = nv = newnv(NULL, NULL, NULL, makedev(maj, min));
}
if (nv->nv_int != NODEV) {
/*
* By the numbers. Find the appropriate major number
* to make a name.
*/
maj = major(nv->nv_int);
min = minor(nv->nv_int);
for (dev = allbases; dev != NULL; dev = dev->d_next)
if (dev->d_major == maj)
break;
if (dev == NULL)
(void)sprintf(buf, "<%d/%d>", maj, min);
else
(void)sprintf(buf, "%s%d%c", dev->d_name,
min >> 3, (min & 7) + 'a');
nv->nv_str = intern(buf);
return (0);
}
/*
* The normal case: things like "ra2b". Check for partition
* suffix, remove it if there, and split into name ("ra") and
* unit (2).
*/
l = strlen(nv->nv_str);
cp = &nv->nv_str[l];
if (l > 1 && *--cp >= 'a' && *cp <= 'h' && isdigit(cp[-1])) {
l--;
part = *cp - 'a';
}
cp = nv->nv_str;
if (split(cp, l, buf, sizeof buf, &unit)) {
error("%s: invalid %s device name `%s'", name, what, cp);
return (1);
}
dev = ht_lookup(devbasetab, intern(buf));
if (dev == NULL || dev->d_major == NODEV) {
error("%s: can't make %s device from `%s'",
name, what, nv->nv_str);
return (1);
}
nv->nv_name = dev->d_name;
nv->nv_int = makedev(dev->d_major, unit * 8 + part);
return (0);
}
static int
lresolve(nvp, name, what, dflt, part)
register struct nvlist **nvp;
const char *name, *what;
struct nvlist *dflt;
int part;
{
int err;
while ((err = resolve(nvp, name, what, dflt, part)) == 0 &&
(*nvp)->nv_next != NULL)
nvp = &(*nvp)->nv_next;
return (err);
}
/*
* Add a completed configuration to the list.
*/
void
addconf(cf0)
register struct config *cf0;
{
register struct config *cf;
register struct nvlist *nv;
const char *name;
name = cf0->cf_name;
cf = emalloc(sizeof *cf);
if (ht_insert(cfhashtab, name, cf)) {
error("configuration `%s' already defined", name);
free(cf);
goto bad;
}
*cf = *cf0;
/*
* Look for "swap generic".
*/
for (nv = cf->cf_swap; nv != NULL; nv = nv->nv_next)
if (nv->nv_str == s_generic)
break;
if (nv != NULL) {
/*
* Make sure no root or dump device specified, and no
* other swap devices. Note single | here (check all).
*/
nv = cf->cf_swap;
if (exclude(cf->cf_root, name, "root device") |
exclude(nv->nv_next, name, "additional swap devices") |
exclude(cf->cf_dump, name, "dump device"))
goto bad;
} else {
nv = cf->cf_root;
if (nv == NULL) {
error("%s: no root device specified", name);
goto bad;
}
if (resolve(&cf->cf_root, name, "root", nv, 'a') |
lresolve(&cf->cf_swap, name, "swap", nv, 'b') |
resolve(&cf->cf_dump, name, "dumps", nv, 'b'))
goto bad;
}
*nextcf = cf;
nextcf = &cf->cf_next;
return;
bad:
nvfreel(cf0->cf_root);
nvfreel(cf0->cf_swap);
nvfreel(cf0->cf_dump);
}
void
setconf(npp, what, v)
register struct nvlist **npp;
const char *what;
struct nvlist *v;
{
if (*npp != NULL) {
error("duplicate %s specification", what);
nvfreel(v);
} else
*npp = v;
}
static struct devi *
newdevi(name, unit, d)
const char *name;
int unit;
struct devbase *d;
{
register struct devi *i;
i = emalloc(sizeof *i);
i->i_name = name;
i->i_unit = unit;
i->i_base = d;
i->i_next = NULL;
i->i_bsame = NULL;
i->i_alias = NULL;
i->i_at = NULL;
i->i_atattr = NULL;
i->i_atdev = NULL;
i->i_locs = NULL;
i->i_cfflags = 0;
i->i_lineno = currentline();
if (unit >= d->d_umax)
d->d_umax = unit + 1;
return (i);
}
/*
* Add the named device as attaching to the named attribute (or perhaps
* another device instead) plus unit number.
*/
void
adddev(name, at, loclist, flags)
const char *name, *at;
struct nvlist *loclist;
int flags;
{
register struct devi *i; /* the new instance */
register struct attr *attr; /* attribute that allows attach */
register struct devbase *ib; /* i->i_base */
register struct devbase *ab; /* not NULL => at another dev */
register struct nvlist *nv;
const char *cp;
int atunit;
char atbuf[NAMESIZE];
ab = NULL;
if (at == NULL) {
/* "at root" */
if ((i = getdevi(name)) == NULL)
goto bad;
/*
* Must warn about i_unit > 0 later, after taking care of
* the STAR cases (we could do non-star's here but why
* bother?). Make sure this device can be at root.
*/
ib = i->i_base;
if (!onlist(ib->d_atlist, NULL)) {
error("%s's cannot attach to the root", ib->d_name);
goto bad;
}
attr = &errattr; /* a convenient "empty" attr */
} else {
if (split(at, strlen(at), atbuf, sizeof atbuf, &atunit)) {
error("invalid attachment name `%s'", at);
/* (void)getdevi(name); -- ??? */
goto bad;
}
if ((i = getdevi(name)) == NULL)
goto bad;
ib = i->i_base;
cp = intern(atbuf);
if ((attr = ht_lookup(attrtab, cp)) == NULL) {
/*
* Have to work a bit harder to see whether we have
* something like "tg0 at esp0" (where esp is merely
* not an attribute) or "tg0 at nonesuch0" (where
* nonesuch is not even a device).
*/
if ((ab = ht_lookup(devbasetab, cp)) == NULL) {
error("%s at %s: `%s' unknown",
name, at, atbuf);
goto bad;
}
/*
* See if the named parent carries an attribute
* that allows it to supervise device ib.
*/
for (nv = ab->d_attrs; nv != NULL; nv = nv->nv_next) {
attr = nv->nv_ptr;
if (onlist(attr->a_devs, ib))
goto ok;
}
attr = &errattr;/* now onlist below will fail */
}
if (!onlist(attr->a_devs, ib)) {
error("%s's cannot attach to %s's", ib->d_name, atbuf);
goto bad;
}
}
ok:
if ((i->i_locs = fixloc(name, attr, loclist)) == NULL)
goto bad;
if (i->i_unit == STAR && ib->d_vectors != NULL) {
error("%s's cannot be *'d as they have preset vectors",
ib->d_name);
goto bad;
}
i->i_at = at;
i->i_atattr = attr;
i->i_atdev = ab;
i->i_atunit = atunit;
i->i_cfflags = flags;
selectbase(ib);
/* all done, fall into ... */
bad:
nvfreel(loclist);
return;
}
void
addpseudo(name, number)
const char *name;
int number;
{
register struct devbase *d;
register struct devi *i;
d = ht_lookup(devbasetab, name);
if (d == NULL) {
error("undefined pseudo-device %s", name);
return;
}
if (!d->d_ispseudo) {
error("%s is a real device, not a pseudo-device", name);
return;
}
if (ht_lookup(devitab, name) != NULL) {
error("`%s' already defined", name);
return;
}
i = newdevi(name, number - 1, d); /* foo 16 => "foo0..foo15" */
if (ht_insert(devitab, name, i))
panic("addpseudo(%s)", name);
selectbase(d);
*nextpseudo = i;
nextpseudo = &i->i_next;
npseudo++;
}
/*
* Define a new instance of a specific device.
*/
static struct devi *
getdevi(name)
const char *name;
{
register struct devi *i, *firsti;
register struct devbase *d;
int unit;
char base[NAMESIZE];
if (split(name, strlen(name), base, sizeof base, &unit)) {
error("invalid device name `%s'", name);
return (NULL);
}
d = ht_lookup(devbasetab, intern(base));
if (d == NULL) {
error("%s: unknown device `%s'", name, base);
return (NULL);
}
if (d->d_ispseudo) {
error("%s: %s is a pseudo-device", name, base);
return (NULL);
}
firsti = ht_lookup(devitab, name);
i = newdevi(name, unit, d);
if (firsti == NULL) {
if (ht_insert(devitab, name, i))
panic("getdevi(%s)", name);
*d->d_ipp = i;
d->d_ipp = &i->i_bsame;
} else {
while (firsti->i_alias)
firsti = firsti->i_alias;
firsti->i_alias = i;
}
*nextdevi = i;
nextdevi = &i->i_next;
ndevi++;
return (i);
}
static const char *
concat(name, c)
const char *name;
int c;
{
register int len;
char buf[NAMESIZE];
len = strlen(name);
if (len + 2 > sizeof(buf)) {
error("device name `%s%c' too long", name, c);
len = sizeof(buf) - 2;
}
bcopy(name, buf, len);
buf[len] = c;
buf[len + 1] = 0;
return (intern(buf));
}
const char *
starref(name)
const char *name;
{
return (concat(name, '*'));
}
const char *
wildref(name)
const char *name;
{
return (concat(name, '?'));
}
/*
* Split a name like "foo0" into base name (foo) and unit number (0).
* Return 0 on success. To make this useful for names like "foo0a",
* the length of the "foo0" part is one of the arguments.
*/
static int
split(name, nlen, base, bsize, aunit)
register const char *name;
size_t nlen;
char *base;
size_t bsize;
int *aunit;
{
register const char *cp;
register int c, l;
l = nlen;
if (l < 2 || l >= bsize || isdigit(*name))
return (1);
c = (u_char)name[--l];
if (!isdigit(c)) {
if (c == '*')
*aunit = STAR;
else if (c == '?')
*aunit = WILD;
else
return (1);
} else {
cp = &name[l];
while (isdigit(cp[-1]))
l--, cp--;
*aunit = atoi(cp);
}
bcopy(name, base, l);
base[l] = 0;
return (0);
}
/*
* We have an instance of the base foo, so select it and all its
* attributes for "optional foo".
*/
static void
selectbase(d)
register struct devbase *d;
{
register struct attr *a;
register struct nvlist *nv;
(void)ht_insert(selecttab, d->d_name, (char *)d->d_name);
for (nv = d->d_attrs; nv != NULL; nv = nv->nv_next) {
a = nv->nv_ptr;
(void)ht_insert(selecttab, a->a_name, (char *)a->a_name);
}
}
/*
* Is the given pointer on the given list of pointers?
*/
static int
onlist(nv, ptr)
register struct nvlist *nv;
register void *ptr;
{
for (; nv != NULL; nv = nv->nv_next)
if (nv->nv_ptr == ptr)
return (1);
return (0);
}
static char *
extend(p, name)
register char *p;
const char *name;
{
register int l;
l = strlen(name);
bcopy(name, p, l);
p += l;
*p++ = ',';
*p++ = ' ';
return (p);
}
/*
* Check that we got all required locators, and default any that are
* given as "?" and have defaults. Return 0 on success.
*/
static const char **
fixloc(name, attr, got)
const char *name;
register struct attr *attr;
register struct nvlist *got;
{
register struct nvlist *m, *n;
register int ord;
register const char **lp;
int nmissing, nextra, nnodefault;
char *mp, *ep, *ndp;
char missing[1000], extra[1000], nodefault[1000];
static const char *nullvec[1];
/*
* Look for all required locators, and number the given ones
* according to the required order. While we are numbering,
* set default values for defaulted locators.
*/
if (attr->a_loclen == 0) /* e.g., "at root" */
lp = nullvec;
else
lp = emalloc((attr->a_loclen + 1) * sizeof(const char *));
for (n = got; n != NULL; n = n->nv_next)
n->nv_int = -1;
nmissing = 0;
mp = missing;
/* yes, this is O(mn), but m and n should be small */
for (ord = 0, m = attr->a_locs; m != NULL; m = m->nv_next, ord++) {
for (n = got; n != NULL; n = n->nv_next) {
if (n->nv_name == m->nv_name) {
n->nv_int = ord;
break;
}
}
if (n == NULL && m->nv_int == 0) {
nmissing++;
mp = extend(mp, m->nv_name);
}
lp[ord] = m->nv_str;
}
if (ord != attr->a_loclen)
panic("fixloc");
lp[ord] = NULL;
nextra = 0;
ep = extra;
nnodefault = 0;
ndp = nodefault;
for (n = got; n != NULL; n = n->nv_next) {
if (n->nv_int >= 0) {
if (n->nv_str != NULL)
lp[n->nv_int] = n->nv_str;
else if (lp[n->nv_int] == NULL) {
nnodefault++;
ndp = extend(ndp, n->nv_name);
}
} else {
nextra++;
ep = extend(ep, n->nv_name);
}
}
if (nextra) {
ep[-2] = 0; /* kill ", " */
error("%s: extraneous locator%s: %s",
name, nextra > 1 ? "s" : "", extra);
}
if (nmissing) {
mp[-2] = 0;
error("%s: must specify %s", name, missing);
}
if (nnodefault) {
ndp[-2] = 0;
error("%s: cannot wildcard %s", name, nodefault);
}
if (nmissing || nnodefault) {
free(lp);
lp = NULL;
}
return (lp);
}

61
usr.sbin/config.new/sem.h
View File

@ -1,61 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)sem.h 8.1 (Berkeley) 6/6/93
*/
void enddefs __P((const char *));
void setdefmaxusers __P((int, int, int));
void setmaxusers __P((int));
int defattr __P((const char *, struct nvlist *));
void defdev __P((struct devbase *, int, struct nvlist *,
struct nvlist *, struct nvlist *, struct nvlist *));
struct devbase *getdevbase __P((const char *name));
struct attr *getattr __P((const char *name));
void setmajor __P((struct devbase *d, int n));
void addconf __P((struct config *));
void setconf __P((struct nvlist **, const char *, struct nvlist *));
void adddev __P((const char *, const char *, struct nvlist *, int));
void addpseudo __P((const char *name, int number));
const char *ref __P((const char *name));
const char *starref __P((const char *name));
const char *wildref __P((const char *name));

262
usr.sbin/config.new/util.c
View File

@ -1,262 +0,0 @@
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratories.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 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.
*
* @(#)util.c 8.1 (Berkeley) 6/6/93
*/
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#if __STDC__
#include <stdarg.h>
#else
#include <varargs.h>
#endif
#include "config.h"
static void nomem __P((void));
static void vxerror __P((const char *, int, const char *, va_list));
/*
* Malloc, with abort on error.
*/
void *
emalloc(size)
size_t size;
{
void *p;
if ((p = malloc(size)) == NULL)
nomem();
return (p);
}
/*
* Realloc, with abort on error.
*/
void *
erealloc(p, size)
void *p;
size_t size;
{
if ((p = realloc(p, size)) == NULL)
nomem();
return (p);
}
static void
nomem()
{
(void)fprintf(stderr, "config: out of memory\n");
exit(1);
}
/*
* Prepend the compilation directory to a file name.
*/
char *
path(file)
const char *file;
{
register char *cp;
#define CDIR "../../compile/"
if (file == NULL) {
cp = emalloc(sizeof(CDIR) + strlen(confdirbase));
(void)sprintf(cp, "%s%s", CDIR, confdirbase);
} else {
cp = emalloc(sizeof(CDIR) + strlen(confdirbase) + 1 +
strlen(file));
(void)sprintf(cp, "%s%s/%s", CDIR, confdirbase, file);
}
return (cp);
}
static struct nvlist *nvhead;
struct nvlist *
newnv(name, str, ptr, i)
const char *name, *str;
void *ptr;
int i;
{
register struct nvlist *nv;
if ((nv = nvhead) == NULL)
nv = emalloc(sizeof(*nv));
else
nvhead = nv->nv_next;
nv->nv_next = NULL;
nv->nv_name = name;
if (ptr == NULL)
nv->nv_str = str;
else {
if (str != NULL)
panic("newnv");
nv->nv_ptr = ptr;
}
nv->nv_int = i;
return (nv);
}
/*
* Free an nvlist structure (just one).
*/
void
nvfree(nv)
register struct nvlist *nv;
{
nv->nv_next = nvhead;
nvhead = nv;
}
/*
* Free an nvlist (the whole list).
*/
void
nvfreel(nv)
register struct nvlist *nv;
{
register struct nvlist *next;
for (; nv != NULL; nv = next) {
next = nv->nv_next;
nv->nv_next = nvhead;
nvhead = nv;
}
}
/*
* External (config file) error. Complain, using current file
* and line number.
*/
void
#if __STDC__
error(const char *fmt, ...)
#else
error(fmt, va_alist)
const char *fmt;
va_dcl
#endif
{
va_list ap;
extern const char *yyfile;
#if __STDC__
va_start(ap, fmt);
#else
va_start(ap);
#endif
vxerror(yyfile, currentline(), fmt, ap);
va_end(ap);
}
/*
* Delayed config file error (i.e., something was wrong but we could not
* find out about it until later).
*/
void
#if __STDC__
xerror(const char *file, int line, const char *fmt, ...)
#else
xerror(file, line, fmt, va_alist)
const char *file;
int line;
const char *fmt;
va_dcl
#endif
{
va_list ap;
#if __STDC__
va_start(ap, fmt);
#else
va_start(ap);
#endif
vxerror(file, line, fmt, ap);
va_end(ap);
}
/*
* Internal form of error() and xerror().
*/
static void
vxerror(file, line, fmt, ap)
const char *file;
int line;
const char *fmt;
va_list ap;
{
(void)fprintf(stderr, "%s:%d: ", file, line);
(void)vfprintf(stderr, fmt, ap);
(void)putc('\n', stderr);
errors++;
}
/*
* Internal error, abort.
*/
__dead void
#if __STDC__
panic(const char *fmt, ...)
#else
panic(fmt, va_alist)
const char *fmt;
va_dcl
#endif
{
va_list ap;
#if __STDC__
va_start(ap, fmt);
#else
va_start(ap);
#endif
(void)fprintf(stderr, "config: panic: ");
(void)vfprintf(stderr, fmt, ap);
(void)putc('\n', stderr);
va_end(ap);
exit(2);
}