NetBSD-5.0.2/usr.bin/config/files.c
/* $NetBSD: files.c,v 1.7 2007/11/30 23:19:18 dsl Exp $ */
/*
* 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. 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.
*
* from: @(#)files.c 8.1 (Berkeley) 6/6/93
*/
#if HAVE_NBTOOL_CONFIG_H
#include "nbtool_config.h"
#endif
#include <sys/param.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <util.h>
#include "defs.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 **unchecked;
static int checkaux(const char *, void *);
static int fixcount(const char *, void *);
static int fixfsel(const char *, void *);
static int fixsel(const char *, void *);
static int expr_eval(struct nvlist *,
int (*)(const char *, void *), void *);
static void expr_free(struct nvlist *);
void
initfiles(void)
{
basetab = ht_new();
pathtab = ht_new();
TAILQ_INIT(&allfiles);
unchecked = &TAILQ_FIRST(&allfiles);
TAILQ_INIT(&allobjects);
}
void
addfile(const char *path, struct nvlist *optx, int flags, const char *rule)
{
struct files *fi;
const char *dotp, *tail;
size_t baselen;
int needc, needf;
char base[200];
/* check various errors */
needc = flags & FI_NEEDSCOUNT;
needf = flags & FI_NEEDSFLAG;
if (needc && needf) {
cfgerror("cannot mix needs-count and needs-flag");
goto bad;
}
if (optx == NULL && (needc || needf)) {
cfgerror("nothing to %s for %s", needc ? "count" : "flag",
path);
goto bad;
}
/* find last part of pathname, and same without trailing suffix */
tail = strrchr(path, '/');
if (tail == NULL)
tail = path;
else
tail++;
dotp = strrchr(tail, '.');
if (dotp == NULL || dotp[1] == 0 ||
(baselen = dotp - tail) >= sizeof(base)) {
cfgerror("invalid pathname `%s'", path);
goto bad;
}
/*
* Commit this file to memory. We will decide later whether it
* will be used after all.
*/
fi = ecalloc(1, sizeof *fi);
if (ht_insert(pathtab, path, fi)) {
free(fi);
if ((fi = ht_lookup(pathtab, path)) == NULL)
panic("addfile: ht_lookup(%s)", path);
/*
* If it's a duplicate entry, it is must specify a make
* rule, and only a make rule, and must come from
* a different source file than the original entry.
* If it does otherwise, it is disallowed. This allows
* machine-dependent files to override the compilation
* options for specific files.
*/
if (rule != NULL && optx == NULL && flags == 0 &&
yyfile != fi->fi_srcfile) {
fi->fi_mkrule = rule;
return;
}
cfgerror("duplicate file %s", path);
cfgxerror(fi->fi_srcfile, fi->fi_srcline,
"here is the original definition");
goto bad;
}
memcpy(base, tail, baselen);
base[baselen] = 0;
fi->fi_srcfile = yyfile;
fi->fi_srcline = currentline();
fi->fi_flags = flags;
fi->fi_path = path;
fi->fi_tail = tail;
fi->fi_base = intern(base);
fi->fi_prefix = SLIST_EMPTY(&prefixes) ? NULL :
SLIST_FIRST(&prefixes)->pf_prefix;
fi->fi_optx = optx;
fi->fi_optf = NULL;
fi->fi_mkrule = rule;
TAILQ_INSERT_TAIL(&allfiles, fi, fi_next);
return;
bad:
expr_free(optx);
}
void
addobject(const char *path, struct nvlist *optx, int flags)
{
struct objects *oi;
/*
* Commit this object to memory. We will decide later whether it
* will be used after all.
*/
oi = ecalloc(1, sizeof *oi);
if (ht_insert(pathtab, path, oi)) {
free(oi);
if ((oi = ht_lookup(pathtab, path)) == NULL)
panic("addfile: ht_lookup(%s)", path);
cfgerror("duplicate file %s", path);
cfgxerror(oi->oi_srcfile, oi->oi_srcline,
"here is the original definition");
}
oi->oi_srcfile = yyfile;
oi->oi_srcline = currentline();
oi->oi_flags = flags;
oi->oi_path = path;
oi->oi_prefix = SLIST_EMPTY(&prefixes) ? NULL :
SLIST_FIRST(&prefixes)->pf_prefix;
oi->oi_optx = optx;
oi->oi_optf = NULL;
TAILQ_INSERT_TAIL(&allobjects, oi, oi_next);
return;
}
/*
* 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(void)
{
struct files *fi, *last;
last = NULL;
for (fi = *unchecked; fi != NULL;
last = fi, fi = TAILQ_NEXT(fi, fi_next)) {
if ((fi->fi_flags & FI_NEEDSCOUNT) != 0)
(void)expr_eval(fi->fi_optx, checkaux, fi);
}
if (last != NULL)
unchecked = &TAILQ_NEXT(last, fi_next);
}
/*
* Auxiliary function for checkfiles, called from expr_eval.
* We are not actually interested in the expression's value.
*/
static int
checkaux(const char *name, void *context)
{
struct files *fi = context;
if (ht_lookup(devbasetab, name) == NULL) {
cfgxerror(fi->fi_srcfile, fi->fi_srcline,
"`%s' is not a countable device",
name);
/* keep fixfiles() from complaining again */
fi->fi_flags |= FI_HIDDEN;
}
return (0);
}
/*
* We have finished reading everything. Tack the files down: calculate
* selection and counts as needed. Check that the object files built
* from the selected sources do not collide.
*/
int
fixfiles(void)
{
struct files *fi, *ofi;
struct nvlist *flathead, **flatp;
int err, sel;
err = 0;
TAILQ_FOREACH(fi, &allfiles, fi_next) {
/* Skip files that generated counted-device complaints. */
if (fi->fi_flags & FI_HIDDEN)
continue;
/* Optional: see if it is to be included. */
if (fi->fi_flags & FIT_FORCESELECT)
{
/* include it */ ;
}
else if (fi->fi_optx != NULL) {
flathead = NULL;
flatp = &flathead;
sel = expr_eval(fi->fi_optx,
fi->fi_flags & FI_NEEDSCOUNT ? fixcount :
fi->fi_flags & FI_NEEDSFLAG ? fixfsel :
fixsel,
&flatp);
fi->fi_optf = flathead;
if (!sel)
continue;
}
/* We like this file. Make sure it generates a unique .o. */
if (ht_insert(basetab, fi->fi_base, fi)) {
if ((ofi = ht_lookup(basetab, fi->fi_base)) == NULL)
panic("fixfiles ht_lookup(%s)", fi->fi_base);
/*
* If the new file comes from a different source,
* allow the new one to override the old one.
*/
if (fi->fi_path != ofi->fi_path) {
if (ht_replace(basetab, fi->fi_base, fi) != 1)
panic("fixfiles ht_replace(%s)",
fi->fi_base);
ofi->fi_flags &= ~FI_SEL;
ofi->fi_flags |= FI_HIDDEN;
} else {
cfgxerror(fi->fi_srcfile, fi->fi_srcline,
"object file collision on %s.o, from %s",
fi->fi_base, fi->fi_path);
cfgxerror(ofi->fi_srcfile, ofi->fi_srcline,
"here is the previous file: %s",
ofi->fi_path);
err = 1;
}
}
fi->fi_flags |= FI_SEL;
}
return (err);
}
/*
* We have finished reading everything. Tack the objects down: calculate
* selection.
*/
int
fixobjects(void)
{
struct objects *oi;
struct nvlist *flathead, **flatp;
int err, sel;
err = 0;
TAILQ_FOREACH(oi, &allobjects, oi_next) {
/* Optional: see if it is to be included. */
if (oi->oi_optx != NULL) {
flathead = NULL;
flatp = &flathead;
sel = expr_eval(oi->oi_optx,
oi->oi_flags & OI_NEEDSFLAG ? fixfsel :
fixsel,
&flatp);
oi->oi_optf = flathead;
if (!sel)
continue;
}
oi->oi_flags |= OI_SEL;
}
return (err);
}
/*
* We have finished reading everything. Tack the devsws down: calculate
* selection.
*/
int
fixdevsw(void)
{
int error;
struct devm *dm, *res;
struct hashtab *fixdevmtab;
char mstr[16];
error = 0;
fixdevmtab = ht_new();
TAILQ_FOREACH(dm, &alldevms, dm_next) {
res = ht_lookup(fixdevmtab, intern(dm->dm_name));
if (res != NULL) {
if (res->dm_cmajor != dm->dm_cmajor ||
res->dm_bmajor != dm->dm_bmajor) {
cfgxerror(res->dm_srcfile, res->dm_srcline,
"device-major '%s' "
"block %d, char %d redefined"
" at %s:%d as block %d, char %d",
res->dm_name,
res->dm_bmajor, res->dm_cmajor,
dm->dm_srcfile, dm->dm_srcline,
dm->dm_bmajor, dm->dm_cmajor);
} else {
cfgxerror(res->dm_srcfile, res->dm_srcline,
"device-major '%s' "
"(block %d, char %d) duplicated"
" at %s:%d",
dm->dm_name, dm->dm_bmajor,
dm->dm_cmajor,
dm->dm_srcfile, dm->dm_srcline);
}
error = 1;
goto out;
}
if (ht_insert(fixdevmtab, intern(dm->dm_name), dm)) {
panic("fixdevsw: %s char %d block %d",
dm->dm_name, dm->dm_cmajor, dm->dm_bmajor);
}
if (dm->dm_opts != NULL &&
!expr_eval(dm->dm_opts, fixsel, NULL))
continue;
if (dm->dm_cmajor != -1) {
if (ht_lookup(cdevmtab, intern(dm->dm_name)) != NULL) {
cfgxerror(dm->dm_srcfile, dm->dm_srcline,
"device-major of character device '%s' "
"is already defined", dm->dm_name);
error = 1;
goto out;
}
(void)snprintf(mstr, sizeof(mstr), "%d", dm->dm_cmajor);
if (ht_lookup(cdevmtab, intern(mstr)) != NULL) {
cfgxerror(dm->dm_srcfile, dm->dm_srcline,
"device-major of character major '%d' "
"is already defined", dm->dm_cmajor);
error = 1;
goto out;
}
if (ht_insert(cdevmtab, intern(dm->dm_name), dm) ||
ht_insert(cdevmtab, intern(mstr), dm)) {
panic("fixdevsw: %s character major %d",
dm->dm_name, dm->dm_cmajor);
}
}
if (dm->dm_bmajor != -1) {
if (ht_lookup(bdevmtab, intern(dm->dm_name)) != NULL) {
cfgxerror(dm->dm_srcfile, dm->dm_srcline,
"device-major of block device '%s' "
"is already defined", dm->dm_name);
error = 1;
goto out;
}
(void)snprintf(mstr, sizeof(mstr), "%d", dm->dm_bmajor);
if (ht_lookup(bdevmtab, intern(mstr)) != NULL) {
cfgxerror(dm->dm_srcfile, dm->dm_srcline,
"device-major of block major '%d' "
"is already defined", dm->dm_bmajor);
error = 1;
goto out;
}
if (ht_insert(bdevmtab, intern(dm->dm_name), dm) ||
ht_insert(bdevmtab, intern(mstr), dm)) {
panic("fixdevsw: %s block major %d",
dm->dm_name, dm->dm_bmajor);
}
}
}
out:
ht_free(fixdevmtab);
return (error);
}
/*
* Called when evaluating a needs-count expression. Make sure the
* atom is a countable device. The expression succeeds iff there
* is at least one of them (note that while `xx*' will not always
* set xx's d_umax > 0, you cannot mix '*' and needs-count). The
* mkheaders() routine wants a flattened, in-order list of the
* atoms for `#define name value' lines, so we build that as we
* are called to eval each atom.
*/
static int
fixcount(const char *name, void *context)
{
struct nvlist ***p = context;
struct devbase *dev;
struct nvlist *nv;
dev = ht_lookup(devbasetab, name);
if (dev == NULL) /* cannot occur here; we checked earlier */
panic("fixcount(%s)", name);
nv = newnv(name, NULL, NULL, dev->d_umax, NULL);
**p = nv;
*p = &nv->nv_next;
(void)ht_insert(needcnttab, name, nv);
return (dev->d_umax != 0);
}
/*
* Called from fixfiles when eval'ing a selection expression for a
* file that will generate a .h with flags. We will need the flat list.
*/
static int
fixfsel(const char *name, void *context)
{
struct nvlist ***p = context;
struct nvlist *nv;
int sel;
sel = ht_lookup(selecttab, name) != NULL;
nv = newnv(name, NULL, NULL, sel, NULL);
**p = nv;
*p = &nv->nv_next;
return (sel);
}
/*
* As for fixfsel above, but we do not need the flat list.
*/
static int
/*ARGSUSED*/
fixsel(const char *name, void *context)
{
return (ht_lookup(selecttab, name) != NULL);
}
/*
* Eval an expression tree. Calls the given function on each node,
* passing it the given context & the name; return value is &/|/! of
* results of evaluating atoms.
*
* No short circuiting ever occurs. fn must return 0 or 1 (otherwise
* our mixing of C's bitwise & boolean here may give surprises).
*/
static int
expr_eval(struct nvlist *expr, int (*fn)(const char *, void *), void *context)
{
int lhs, rhs;
switch (expr->nv_int) {
case FX_ATOM:
return ((*fn)(expr->nv_name, context));
case FX_NOT:
return (!expr_eval(expr->nv_next, fn, context));
case FX_AND:
lhs = expr_eval(expr->nv_ptr, fn, context);
rhs = expr_eval(expr->nv_next, fn, context);
return (lhs & rhs);
case FX_OR:
lhs = expr_eval(expr->nv_ptr, fn, context);
rhs = expr_eval(expr->nv_next, fn, context);
return (lhs | rhs);
}
panic("expr_eval %d", expr->nv_int);
/* NOTREACHED */
return (0);
}
/*
* Free an expression tree.
*/
static void
expr_free(struct nvlist *expr)
{
struct nvlist *rhs;
/* This loop traverses down the RHS of each subexpression. */
for (; expr != NULL; expr = rhs) {
switch (expr->nv_int) {
/* Atoms and !-exprs have no left hand side. */
case FX_ATOM:
case FX_NOT:
break;
/* For AND and OR nodes, free the LHS. */
case FX_AND:
case FX_OR:
expr_free(expr->nv_ptr);
break;
default:
panic("expr_free %d", expr->nv_int);
}
rhs = expr->nv_next;
nvfree(expr);
}
}
#ifdef DEBUG
/*
* Print expression tree.
*/
void
prexpr(struct nvlist *expr)
{
static void pr0();
printf("expr =");
pr0(expr);
printf("\n");
(void)fflush(stdout);
}
static void
pr0(struct nvlist *e)
{
switch (e->nv_int) {
case FX_ATOM:
printf(" %s", e->nv_name);
return;
case FX_NOT:
printf(" (!");
break;
case FX_AND:
printf(" (&");
break;
case FX_OR:
printf(" (|");
break;
default:
printf(" (?%d?", e->nv_int);
break;
}
if (e->nv_ptr)
pr0(e->nv_ptr);
pr0(e->nv_next);
printf(")");
}
#endif