[BACK]Return to defs.h CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / usr.bin / config

Annotation of src/usr.bin/config/defs.h, Revision 1.10

1.10    ! cube        1: /*     $NetBSD: defs.h,v 1.9 2005/11/07 03:26:20 erh Exp $     */
1.1       thorpej     2:
                      3: /*
                      4:  * Copyright (c) 1992, 1993
                      5:  *     The Regents of the University of California.  All rights reserved.
                      6:  *
                      7:  * This software was developed by the Computer Systems Engineering group
                      8:  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
                      9:  * contributed to Berkeley.
                     10:  *
                     11:  * All advertising materials mentioning features or use of this software
                     12:  * must display the following acknowledgement:
                     13:  *     This product includes software developed by the University of
                     14:  *     California, Lawrence Berkeley Laboratories.
                     15:  *
                     16:  * Redistribution and use in source and binary forms, with or without
                     17:  * modification, are permitted provided that the following conditions
                     18:  * are met:
                     19:  * 1. Redistributions of source code must retain the above copyright
                     20:  *    notice, this list of conditions and the following disclaimer.
                     21:  * 2. Redistributions in binary form must reproduce the above copyright
                     22:  *    notice, this list of conditions and the following disclaimer in the
                     23:  *    documentation and/or other materials provided with the distribution.
                     24:  * 3. Neither the name of the University nor the names of its contributors
                     25:  *    may be used to endorse or promote products derived from this software
                     26:  *    without specific prior written permission.
                     27:  *
                     28:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     29:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     30:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     31:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     32:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     33:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     34:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     35:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     36:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     37:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     38:  * SUCH DAMAGE.
                     39:  *
                     40:  *     from: @(#)config.h      8.1 (Berkeley) 6/6/93
                     41:  */
                     42:
                     43: /*
                     44:  * defs.h:  Global definitions for "config"
                     45:  */
                     46:
                     47: #if HAVE_NBTOOL_CONFIG_H
                     48: #include "nbtool_config.h"
                     49: #endif
                     50:
                     51: #include <sys/types.h>
                     52: #include <sys/param.h>
                     53: #include <sys/queue.h>
                     54:
                     55: #if !defined(MAKE_BOOTSTRAP) && defined(BSD)
                     56: #include <sys/cdefs.h>
                     57: #include <paths.h>
                     58: #endif
                     59:
                     60: #include <stdio.h>
                     61: #include <stdlib.h>
                     62: #include <unistd.h>
                     63:
                     64: /* These are really for MAKE_BOOTSTRAP but harmless. */
                     65: #ifndef __dead
                     66: #define __dead
                     67: #endif
                     68: #ifndef _PATH_DEVNULL
                     69: #define _PATH_DEVNULL "/dev/null"
                     70: #endif
                     71:
                     72: #ifdef MAKE_BOOTSTRAP
                     73: #undef dev_t
                     74: #undef NODEV
                     75: #undef major
                     76: #undef minor
                     77: #undef makedev
                     78: #define        dev_t           int             /* XXX: assumes int is 32 bits */
                     79: #define        NODEV           ((dev_t)-1)
                     80: #define major(x)        ((int)((((x) & 0x000fff00) >>  8)))
                     81: #define minor(x)        ((int)((((x) & 0xfff00000) >> 12) | \
                     82:                               (((x) & 0x000000ff) >>  0)))
                     83: #define makedev(x,y)    ((dev_t)((((x) <<  8) & 0x000fff00) | \
                     84:                                  (((y) << 12) & 0xfff00000) | \
                     85:                                  (((y) <<  0) & 0x000000ff)))
                     86: #define __attribute__(x)
                     87: #endif /* MAKE_BOOTSTRAP */
                     88:
                     89: #undef setprogname
                     90: #undef getprogname
                     91: extern const char *progname;
                     92: #define        setprogname(s)  ((void)(progname = (s)))
                     93: #define        getprogname()   (progname)
                     94:
                     95: #define ARRCHR '#'
                     96:
                     97: /*
1.8       cube       98:  * The next two lines define the current version of the config(1) binary,
                     99:  * and the minimum version of the configuration files it supports.
                    100:  */
1.10    ! cube      101: #define CONFIG_VERSION         20060525
1.8       cube      102: #define CONFIG_MINVERSION      0
                    103:
                    104: /*
1.1       thorpej   105:  * Name/value lists.  Values can be strings or pointers and/or can carry
                    106:  * integers.  The names can be NULL, resulting in simple value lists.
                    107:  */
                    108: struct nvlist {
                    109:        struct  nvlist *nv_next;
                    110:        const char *nv_name;
                    111:        union {
                    112:                const char *un_str;
                    113:                void *un_ptr;
                    114:        } nv_un;
                    115: #define        nv_str  nv_un.un_str
                    116: #define        nv_ptr  nv_un.un_ptr
                    117:        int     nv_int;
                    118:        int     nv_ifunit;              /* XXX XXX XXX */
                    119:        int     nv_flags;
                    120: #define        NV_DEPENDED     1
1.10    ! cube      121: #define        NV_OBSOLETE     2
1.1       thorpej   122: };
                    123:
                    124: /*
                    125:  * Kernel configurations.
                    126:  */
                    127: struct config {
                    128:        TAILQ_ENTRY(config) cf_next;
                    129:        const char *cf_name;            /* "netbsd" */
                    130:        int     cf_lineno;              /* source line */
                    131:        const char *cf_fstype;          /* file system type */
                    132:        struct  nvlist *cf_root;        /* "root on ra0a" */
                    133:        struct  nvlist *cf_swap;        /* "swap on ra0b and ra1b" */
                    134:        struct  nvlist *cf_dump;        /* "dumps on ra0b" */
                    135: };
                    136:
                    137: /*
                    138:  * Attributes.  These come in three flavors: "plain", "device class,"
                    139:  * and "interface".  Plain attributes (e.g., "ether") simply serve
                    140:  * to pull in files.  Device class attributes are like plain
                    141:  * attributes, but additionally specify a device class (e.g., the
                    142:  * "disk" device class attribute specifies that devices with the
                    143:  * attribute belong to the "DV_DISK" class) and are mutually exclusive.
                    144:  * Interface attributes (e.g., "scsi") carry three lists: locators,
                    145:  * child devices, and references.  The locators are those things
                    146:  * that must be specified in order to configure a device instance
                    147:  * using this attribute (e.g., "tg0 at scsi0").  The a_devs field
                    148:  * lists child devices that can connect here (e.g., "tg"s), while
                    149:  * the a_refs are parents that carry the attribute (e.g., actual
                    150:  * SCSI host adapter drivers such as the SPARC "esp").
                    151:  */
                    152: struct attr {
                    153:        const char *a_name;             /* name of this attribute */
                    154:        int     a_iattr;                /* true => allows children */
                    155:        const char *a_devclass;         /* device class described */
                    156:        struct  nvlist *a_locs;         /* locators required */
                    157:        int     a_loclen;               /* length of above list */
                    158:        struct  nvlist *a_devs;         /* children */
                    159:        struct  nvlist *a_refs;         /* parents */
                    160:        struct  nvlist *a_deps;         /* we depend on these other attrs */
                    161:        int     a_expanding;            /* to detect cycles in attr graph */
                    162: };
                    163:
                    164: /*
                    165:  * Parent specification.  Multiple device instances may share a
                    166:  * given parent spec.  Parent specs are emitted only if there are
                    167:  * device instances which actually reference it.
                    168:  */
                    169: struct pspec {
                    170:        TAILQ_ENTRY(pspec) p_list;      /* link on parent spec list */
                    171:        struct  attr *p_iattr;          /* interface attribute of parent */
                    172:        struct  devbase *p_atdev;       /* optional parent device base */
                    173:        int     p_atunit;               /* optional parent device unit */
                    174:        struct  nvlist *p_devs;         /* children using it */
                    175:        int     p_inst;                 /* parent spec instance */
1.3       cube      176:        int     p_active;               /* parent spec is actively used */
1.1       thorpej   177: };
                    178:
                    179: /*
                    180:  * The "base" part (struct devbase) of a device ("uba", "sd"; but not
                    181:  * "uba2" or "sd0").  It may be found "at" one or more attributes,
                    182:  * including "at root" (this is represented by a NULL attribute), as
                    183:  * specified by the device attachments (struct deva).
                    184:  *
                    185:  * Each device may also export attributes.  If any provide an output
                    186:  * interface (e.g., "esp" provides "scsi"), other devices (e.g.,
                    187:  * "tg"s) can be found at instances of this one (e.g., "esp"s).
                    188:  * Such a connection must provide locators as specified by that
                    189:  * interface attribute (e.g., "target").  The base device can
                    190:  * export both output (aka `interface') attributes, as well as
                    191:  * import input (`plain') attributes.  Device attachments may
                    192:  * only import input attributes; it makes no sense to have a
                    193:  * specific attachment export a new interface to other devices.
                    194:  *
                    195:  * Each base carries a list of instances (via d_ihead).  Note that this
                    196:  * list "skips over" aliases; those must be found through the instances
                    197:  * themselves.  Each base also carries a list of possible attachments,
                    198:  * each of which specify a set of devices that the device can attach
                    199:  * to, as well as the device instances that are actually using that
                    200:  * attachment.
                    201:  */
                    202: struct devbase {
                    203:        const char *d_name;             /* e.g., "sd" */
                    204:        TAILQ_ENTRY(devbase) d_next;
                    205:        int     d_isdef;                /* set once properly defined */
                    206:        int     d_ispseudo;             /* is a pseudo-device */
                    207:        int     d_major;                /* used for "root on sd0", e.g. */
                    208:        struct  nvlist *d_attrs;        /* attributes, if any */
                    209:        int     d_umax;                 /* highest unit number + 1 */
                    210:        struct  devi *d_ihead;          /* first instance, if any */
                    211:        struct  devi **d_ipp;           /* used for tacking on more instances */
                    212:        struct  deva *d_ahead;          /* first attachment, if any */
                    213:        struct  deva **d_app;           /* used for tacking on attachments */
                    214:        struct  attr *d_classattr;      /* device class attribute (if any) */
                    215: };
                    216:
                    217: struct deva {
                    218:        const char *d_name;             /* name of attachment, e.g. "com_isa" */
                    219:        TAILQ_ENTRY(deva) d_next;       /* list of all instances */
                    220:        struct  deva *d_bsame;          /* list on same base */
                    221:        int     d_isdef;                /* set once properly defined */
                    222:        struct  devbase *d_devbase;     /* the base device */
                    223:        struct  nvlist *d_atlist;       /* e.g., "at tg" (attr list) */
                    224:        struct  nvlist *d_attrs;        /* attributes, if any */
                    225:        struct  devi *d_ihead;          /* first instance, if any */
                    226:        struct  devi **d_ipp;           /* used for tacking on more instances */
                    227: };
                    228:
                    229: /*
                    230:  * An "instance" of a device.  The same instance may be listed more
                    231:  * than once, e.g., "xx0 at isa? port FOO" + "xx0 at isa? port BAR".
                    232:  *
                    233:  * After everything has been read in and verified, the devi's are
                    234:  * "packed" to collect all the information needed to generate ioconf.c.
                    235:  * In particular, we try to collapse multiple aliases into a single entry.
                    236:  * We then assign each "primary" (non-collapsed) instance a cfdata index.
                    237:  * Note that there may still be aliases among these.
                    238:  */
                    239: struct devi {
                    240:        /* created while parsing config file */
                    241:        const char *i_name;     /* e.g., "sd0" */
                    242:        int     i_unit;         /* unit from name, e.g., 0 */
                    243:        struct  devbase *i_base;/* e.g., pointer to "sd" base */
                    244:        TAILQ_ENTRY(devi) i_next; /* list of all instances */
                    245:        struct  devi *i_bsame;  /* list on same base */
                    246:        struct  devi *i_asame;  /* list on same base attachment */
                    247:        struct  devi *i_alias;  /* other aliases of this instance */
                    248:        const char *i_at;       /* where this is "at" (NULL if at root) */
                    249:        struct  pspec *i_pspec; /* parent spec (NULL if at root) */
                    250:        struct  deva *i_atdeva;
                    251:        const char **i_locs;    /* locators (as given by pspec's iattr) */
                    252:        int     i_cfflags;      /* flags from config line */
                    253:        int     i_lineno;       /* line # in config, for later errors */
1.5       cube      254:        const char *i_srcfile;  /* file it appears in */
1.7       cube      255:        int     i_level;        /* position between negated instances */
1.4       cube      256:        int     i_active;
                    257: #define        DEVI_ORPHAN     0       /* instance has no active parent */
                    258: #define        DEVI_ACTIVE     1       /* instance has an active parent */
                    259: #define        DEVI_IGNORED    2       /* instance's parent has been removed */
1.6       cube      260: #define DEVI_BROKEN    3       /* instance is broken (syntax error) */
1.1       thorpej   261:
                    262:        /* created during packing or ioconf.c generation */
                    263:        short   i_collapsed;    /* set => this alias no longer needed */
                    264:        short   i_cfindex;      /* our index in cfdata */
                    265:        short   i_locoff;       /* offset in locators.vec */
                    266:
                    267: };
                    268: /* special units */
                    269: #define        STAR    (-1)            /* unit number for, e.g., "sd*" */
                    270: #define        WILD    (-2)            /* unit number for, e.g., "sd?" */
                    271:
                    272: /*
1.9       erh       273:  * Files or objects.  This structure defines the common fields
                    274:  * between the two.
                    275:  */
                    276: struct filetype
                    277: {
                    278:        const char *fit_srcfile;        /* the name of the "files" file that got us */
                    279:        u_short fit_srcline;    /* and the line number */
                    280:        u_char  fit_flags;      /* as below */
                    281:        char    fit_lastc;      /* last char from path */
                    282:        const char *fit_path;   /* full file path */
                    283:        const char *fit_prefix; /* any file prefix */
                    284: };
                    285: /* Anything less than 0x10 is sub-type specific */
                    286: #define FIT_NOPROLOGUE  0x10    /* Don't prepend $S/ */
                    287: #define FIT_FORCESELECT 0x20    /* Always include this file */
                    288:
                    289: /*
1.1       thorpej   290:  * Files.  Each file is either standard (always included) or optional,
                    291:  * depending on whether it has names on which to *be* optional.  The
                    292:  * options field (fi_optx) is actually an expression tree, with nodes
                    293:  * for OR, AND, and NOT, as well as atoms (words) representing some
                    294:  * particular option.  The node type is stored in the nv_int field.
                    295:  * Subexpressions appear in the `next' field; for the binary operators
                    296:  * AND and OR, the left subexpression is first stored in the nv_ptr field.
                    297:  *
                    298:  * For any file marked as needs-count or needs-flag, fixfiles() will
                    299:  * build fi_optf, a `flat list' of the options with nv_int fields that
                    300:  * contain counts or `need' flags; this is used in mkheaders().
                    301:  */
                    302: struct files {
1.9       erh       303:        struct filetype fi_fit;
1.1       thorpej   304:        TAILQ_ENTRY(files) fi_next;
1.9       erh       305:        const  char *fi_tail;   /* name, i.e., strrchr(fi_path, '/') + 1 */
                    306:        const  char *fi_base;   /* tail minus ".c" (or whatever) */
                    307:        struct nvlist *fi_optx; /* options expression */
                    308:        struct nvlist *fi_optf; /* flattened version of above, if needed */
                    309:        const  char *fi_mkrule; /* special make rule, if any */
                    310: };
                    311: #define fi_srcfile fi_fit.fit_srcfile
                    312: #define fi_srcline fi_fit.fit_srcline
                    313: #define fi_flags   fi_fit.fit_flags
                    314: #define fi_lastc   fi_fit.fit_lastc
                    315: #define fi_path    fi_fit.fit_path
                    316: #define fi_prefix  fi_fit.fit_prefix
                    317:
1.1       thorpej   318: /* flags */
                    319: #define        FI_SEL          0x01    /* selected */
                    320: #define        FI_NEEDSCOUNT   0x02    /* needs-count */
                    321: #define        FI_NEEDSFLAG    0x04    /* needs-flag */
                    322: #define        FI_HIDDEN       0x08    /* obscured by other(s), base names overlap */
                    323:
                    324: /*
                    325:  * Objects and libraries.  This allows precompiled object and library
                    326:  * files (e.g. binary-only device drivers) to be linked in.
                    327:  */
                    328: struct objects {
1.9       erh       329:        struct  filetype oi_fit;
1.1       thorpej   330:        TAILQ_ENTRY(objects) oi_next;
                    331:        struct  nvlist *oi_optx;/* options expression */
                    332:        struct  nvlist *oi_optf;/* flattened version of above, if needed */
                    333: };
1.9       erh       334:
                    335: #define oi_srcfile oi_fit.fit_srcfile
                    336: #define oi_srcline oi_fit.fit_srcline
                    337: #define oi_flags   oi_fit.fit_flags
                    338: #define oi_lastc   oi_fit.fit_lastc
                    339: #define oi_path    oi_fit.fit_path
                    340: #define oi_prefix  oi_fit.fit_prefix
                    341:
1.1       thorpej   342: /* flags */
                    343: #define        OI_SEL          0x01    /* selected */
                    344: #define        OI_NEEDSFLAG    0x02    /* needs-flag */
                    345:
                    346: #define        FX_ATOM         0       /* atom (in nv_name) */
                    347: #define        FX_NOT          1       /* NOT expr (subexpression in nv_next) */
                    348: #define        FX_AND          2       /* AND expr (lhs in nv_ptr, rhs in nv_next) */
                    349: #define        FX_OR           3       /* OR expr (lhs in nv_ptr, rhs in nv_next) */
                    350:
                    351: /*
                    352:  * File/object prefixes.  These are arranged in a stack, and affect
                    353:  * the behavior of the source path.
                    354:  */
                    355: struct prefix {
                    356:        SLIST_ENTRY(prefix)     pf_next;        /* next prefix in stack */
                    357:        const char              *pf_prefix;     /* the actual prefix */
                    358: };
                    359:
                    360: /*
                    361:  * Device major informations.
                    362:  */
                    363: struct devm {
                    364:        TAILQ_ENTRY(devm) dm_next;
                    365:        const char      *dm_srcfile;    /* the name of the "majors" file */
                    366:        u_short         dm_srcline;     /* the line number */
                    367:        const char      *dm_name;       /* [bc]devsw name */
                    368:        int             dm_cmajor;      /* character major */
                    369:        int             dm_bmajor;      /* block major */
                    370:        struct nvlist   *dm_opts;       /* options */
                    371: };
                    372:
                    373: /*
                    374:  * Hash tables look up name=value pairs.  The pointer value of the name
                    375:  * is assumed to be constant forever; this can be arranged by interning
                    376:  * the name.  (This is fairly convenient since our lexer does this for
                    377:  * all identifier-like strings---it has to save them anyway, lest yacc's
                    378:  * look-ahead wipe out the current one.)
                    379:  */
                    380: struct hashtab;
                    381:
1.9       erh       382: int lkmmode;
1.1       thorpej   383: const char *conffile;          /* source file, e.g., "GENERIC.sparc" */
                    384: const char *machine;           /* machine type, e.g., "sparc" or "sun3" */
                    385: const char *machinearch;       /* machine arch, e.g., "sparc" or "m68k" */
                    386: struct nvlist *machinesubarches;
                    387:                                /* machine subarches, e.g., "sun68k" or "hpc" */
                    388: const char *srcdir;            /* path to source directory (rel. to build) */
                    389: const char *builddir;          /* path to build directory */
                    390: const char *defbuilddir;       /* default build directory */
                    391: const char *ident;             /* kernel "ident"ification string */
                    392: int    errors;                 /* counts calls to error() */
                    393: int    minmaxusers;            /* minimum "maxusers" parameter */
                    394: int    defmaxusers;            /* default "maxusers" parameter */
                    395: int    maxmaxusers;            /* default "maxusers" parameter */
                    396: int    maxusers;               /* configuration's "maxusers" parameter */
                    397: int    maxpartitions;          /* configuration's "maxpartitions" parameter */
1.8       cube      398: int    version;                /* version of the configuration file */
1.1       thorpej   399: struct nvlist *options;        /* options */
                    400: struct nvlist *fsoptions;      /* filesystems */
                    401: struct nvlist *mkoptions;      /* makeoptions */
                    402: struct nvlist *appmkoptions;   /* appending mkoptions */
                    403: struct hashtab *condmkopttab;  /* conditional makeoption table */
                    404: struct hashtab *devbasetab;    /* devbase lookup */
1.3       cube      405: struct hashtab *devroottab;    /* attach at root lookup */
1.1       thorpej   406: struct hashtab *devatab;       /* devbase attachment lookup */
                    407: struct hashtab *devitab;       /* device instance lookup */
1.4       cube      408: struct hashtab *deaddevitab;   /* removed instances lookup */
1.1       thorpej   409: struct hashtab *selecttab;     /* selects things that are "optional foo" */
                    410: struct hashtab *needcnttab;    /* retains names marked "needs-count" */
                    411: struct hashtab *opttab;        /* table of configured options */
                    412: struct hashtab *fsopttab;      /* table of configured file systems */
                    413: struct hashtab *defopttab;     /* options that have been "defopt"'d */
                    414: struct hashtab *defflagtab;    /* options that have been "defflag"'d */
                    415: struct hashtab *defparamtab;   /* options that have been "defparam"'d */
                    416: struct hashtab *deffstab;      /* defined file systems */
                    417: struct hashtab *optfiletab;    /* "defopt"'d option .h files */
                    418: struct hashtab *attrtab;       /* attributes (locators, etc.) */
                    419: struct hashtab *bdevmtab;      /* block devm lookup */
                    420: struct hashtab *cdevmtab;      /* character devm lookup */
                    421:
                    422: TAILQ_HEAD(, devbase)  allbases;       /* list of all devbase structures */
                    423: TAILQ_HEAD(, deva)     alldevas;       /* list of all devbase attachments */
                    424: TAILQ_HEAD(, config)   allcf;          /* list of configured kernels */
                    425: TAILQ_HEAD(, devi)     alldevi,        /* list of all instances */
                    426:                        allpseudo;      /* list of all pseudo-devices */
                    427: TAILQ_HEAD(, devm)     alldevms;       /* list of all device-majors */
                    428: TAILQ_HEAD(, pspec)    allpspecs;      /* list of all parent specs */
                    429: int    ndevi;                          /* number of devi's (before packing) */
                    430: int    npspecs;                        /* number of parent specs */
                    431: int    maxbdevm;                       /* max number of block major */
                    432: int    maxcdevm;                       /* max number of character major */
                    433: int    do_devsw;                       /* 0 if pre-devsw config */
1.2       martin    434: int    oktopackage;                    /* 0 before setmachine() */
1.7       cube      435: int    devilevel;                      /* used for devi->i_level */
1.1       thorpej   436:
                    437: TAILQ_HEAD(, files)    allfiles;       /* list of all kernel source files */
                    438: TAILQ_HEAD(, objects)  allobjects;     /* list of all kernel object and
                    439:                                           library files */
                    440:
                    441: SLIST_HEAD(, prefix)   prefixes,       /* prefix stack */
                    442:                        allprefixes;    /* all prefixes used (after popped) */
                    443: SLIST_HEAD(, prefix)   curdirs;        /* curdir stack */
                    444:
                    445: struct devi **packed;          /* arrayified table for packed devi's */
                    446: int    npacked;                /* size of packed table, <= ndevi */
                    447:
                    448: struct {                       /* loc[] table for config */
                    449:        const char **vec;
                    450:        int     used;
                    451: } locators;
                    452:
                    453: struct numconst {
                    454:        int64_t val;
                    455:        int fmt;
                    456: };
                    457:
                    458: /* files.c */
                    459: void   initfiles(void);
                    460: void   checkfiles(void);
                    461: int    fixfiles(void);         /* finalize */
                    462: int    fixobjects(void);
                    463: int    fixdevsw(void);
                    464: void   addfile(const char *, struct nvlist *, int, const char *);
                    465: void   addobject(const char *, struct nvlist *, int);
                    466:
                    467: /* hash.c */
                    468: struct hashtab *ht_new(void);
                    469: int    ht_insrep(struct hashtab *, const char *, void *, int);
                    470: #define        ht_insert(ht, nam, val) ht_insrep(ht, nam, val, 0)
                    471: #define        ht_replace(ht, nam, val) ht_insrep(ht, nam, val, 1)
                    472: int    ht_remove(struct hashtab *, const char *);
                    473: void   *ht_lookup(struct hashtab *, const char *);
                    474: void   initintern(void);
                    475: const char *intern(const char *);
                    476: typedef int (*ht_callback)(const char *, void *, void *);
                    477: int    ht_enumerate(struct hashtab *, ht_callback, void *);
                    478:
                    479: /* main.c */
                    480: void   addoption(const char *, const char *);
                    481: void   addfsoption(const char *);
                    482: void   addmkoption(const char *, const char *);
                    483: void   appendmkoption(const char *, const char *);
                    484: void   appendcondmkoption(const char *, const char *, const char *);
                    485: void   deffilesystem(const char *, struct nvlist *);
                    486: void   defoption(const char *, struct nvlist *, struct nvlist *);
1.10    ! cube      487: void   defflag(const char *, struct nvlist *, struct nvlist *, int);
        !           488: void   defparam(const char *, struct nvlist *, struct nvlist *, int);
1.1       thorpej   489: void   deloption(const char *);
                    490: void   delfsoption(const char *);
                    491: void   delmkoption(const char *);
                    492: int    devbase_has_instances(struct devbase *, int);
                    493: struct nvlist * find_declared_option(const char *);
                    494: int    deva_has_instances(struct deva *, int);
                    495: void   setupdirs(void);
                    496:
                    497: /* tests on option types */
                    498: #define OPT_FSOPT(n)   (ht_lookup(deffstab, (n)) != NULL)
                    499: #define OPT_DEFOPT(n)  (ht_lookup(defopttab, (n)) != NULL)
                    500: #define OPT_DEFFLAG(n) (ht_lookup(defflagtab, (n)) != NULL)
                    501: #define OPT_DEFPARAM(n)        (ht_lookup(defparamtab, (n)) != NULL)
1.10    ! cube      502: #define OPT_OBSOLETE(n)        (ht_lookup(obsopttab, (n)) != NULL)
1.1       thorpej   503: #define DEFINED_OPTION(n) (find_declared_option((n)) != NULL)
                    504:
                    505: /* main.c */
                    506: void   logconfig_include(FILE *, const char *);
                    507:
                    508: /* mkdevsw.c */
                    509: int    mkdevsw(void);
                    510:
                    511: /* mkheaders.c */
                    512: int    mkheaders(void);
                    513: int    moveifchanged(const char *, const char *);
                    514:
                    515: /* mkioconf.c */
                    516: int    mkioconf(void);
                    517:
                    518: /* mkmakefile.c */
                    519: int    mkmakefile(void);
                    520:
                    521: /* mkswap.c */
                    522: int    mkswap(void);
                    523:
                    524: /* pack.c */
                    525: void   pack(void);
                    526:
                    527: /* scan.l */
                    528: int    currentline(void);
                    529: int    firstfile(const char *);
                    530: void   package(const char *);
                    531: int    include(const char *, int, int, int);
                    532:
                    533: /* sem.c, other than for yacc actions */
                    534: void   initsem(void);
                    535:
                    536: /* util.c */
                    537: void   *ecalloc(size_t, size_t);
                    538: void   *emalloc(size_t);
                    539: void   *erealloc(void *, size_t);
                    540: char   *estrdup(const char *);
                    541: void   prefix_push(const char *);
                    542: void   prefix_pop(void);
                    543: char   *sourcepath(const char *);
                    544: void   warn(const char *, ...)                         /* immediate warns */
                    545:      __attribute__((__format__(__printf__, 1, 2)));
1.5       cube      546: void   xwarn(const char *, int, const char *, ...)     /* delayed warns */
                    547:      __attribute__((__format__(__printf__, 3, 4)));
1.1       thorpej   548: void   error(const char *, ...)                        /* immediate errs */
                    549:      __attribute__((__format__(__printf__, 1, 2)));
                    550: void   xerror(const char *, int, const char *, ...)    /* delayed errs */
                    551:      __attribute__((__format__(__printf__, 3, 4)));
                    552: __dead void panic(const char *, ...)
                    553:      __attribute__((__format__(__printf__, 1, 2)));
                    554: struct nvlist *newnv(const char *, const char *, void *, int, struct nvlist *);
                    555: void   nvfree(struct nvlist *);
                    556: void   nvfreel(struct nvlist *);
                    557:
                    558: /* liby */
                    559: void   yyerror(const char *);
                    560: int    yylex(void);

CVSweb <webmaster@jp.NetBSD.org>