OpenBSD-4.6/usr.sbin/config/files.c
/* $OpenBSD: files.c,v 1.16 2008/03/22 22:35:15 deraadt Exp $ */
/* $NetBSD: files.c,v 1.6 1996/03/17 13:18:17 cgd 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
*/
#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;
static struct objects **nextobject;
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();
nextfile = &allfiles;
unchecked = &allfiles;
nextobject = &allobjects;
}
void
addfile(struct nvlist *nvpath, struct nvlist *optx, int flags, const char *rule,
const char *lintrule)
{
struct files *fi;
const char *dotp, *dotp1, *tail, *path, *tail1 = NULL;
struct nvlist *nv;
size_t baselen;
int needc, needf;
char base[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 (optx == NULL && (needc || needf)) {
error("nothing to %s for %s", needc ? "count" : "flag", path);
goto bad;
}
for (nv = nvpath; nv; nv = nv->nv_next) {
path = nv->nv_name;
/* 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)) {
error("invalid pathname `%s'", path);
goto bad;
}
/*
* Ensure all tailnames are identical, because .o
* filenames must be identical too.
*/
if (tail1 &&
(dotp - tail != dotp1 - tail1 ||
strncmp(tail1, tail, dotp - tail)))
error("different production from %s %s",
nvpath->nv_name, tail);
tail1 = tail;
dotp1 = dotp;
}
/*
* Commit this file to memory. We will decide later whether it
* will be used after all.
*/
fi = emalloc(sizeof *fi);
if (ht_insert(pathtab, path, fi)) {
free(fi);
if ((fi = ht_lookup(pathtab, path)) == NULL)
panic("addfile: ht_lookup(%s)", path);
error("duplicate file %s", path);
xerror(fi->fi_srcfile, fi->fi_srcline,
"here is the original definition");
}
memcpy(base, tail, baselen);
base[baselen] = 0;
fi->fi_next = NULL;
fi->fi_srcfile = yyfile;
fi->fi_srcline = currentline();
fi->fi_flags = flags;
fi->fi_nvpath = nvpath;
fi->fi_base = intern(base);
fi->fi_optx = optx;
fi->fi_optf = NULL;
fi->fi_mkrule[0] = rule;
fi->fi_mkrule[1] = lintrule;
*nextfile = fi;
nextfile = &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 = emalloc(sizeof *oi);
if (ht_insert(pathtab, path, oi)) {
free(oi);
if ((oi = ht_lookup(pathtab, path)) == NULL)
panic("addfile: ht_lookup(%s)", path);
error("duplicate file %s", path);
xerror(oi->oi_srcfile, oi->oi_srcline,
"here is the original definition");
}
oi->oi_next = NULL;
oi->oi_srcfile = yyfile;
oi->oi_srcline = currentline();
oi->oi_flags = flags;
oi->oi_path = path;
oi->oi_optx = optx;
oi->oi_optf = NULL;
*nextobject = oi;
nextobject = &oi->oi_next;
}
/*
* 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 = fi->fi_next)
if ((fi->fi_flags & FI_NEEDSCOUNT) != 0)
(void)expr_eval(fi->fi_optx, checkaux, fi);
if (last != NULL)
unchecked = &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) {
xerror(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;
for (fi = allfiles; fi != NULL; fi = fi->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_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_nvpath != ofi->fi_nvpath) {
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 {
xerror(fi->fi_srcfile, fi->fi_srcline,
"object file collision on %s.o, from %s",
fi->fi_base, fi->fi_nvpath->nv_name);
xerror(ofi->fi_srcfile, ofi->fi_srcline,
"here is the previous file: %s",
ofi->fi_nvpath->nv_name);
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;
for (oi = allobjects; oi != NULL; oi = oi->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);
}
/*
* 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
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);
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