1463 lines
32 KiB
Plaintext
1463 lines
32 KiB
Plaintext
%{
|
|
/* $NetBSD: gram.y,v 1.54 2016/08/07 10:37:24 christos 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: @(#)gram.y 8.1 (Berkeley) 6/6/93
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__RCSID("$NetBSD: gram.y,v 1.54 2016/08/07 10:37:24 christos Exp $");
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include "defs.h"
|
|
#include "sem.h"
|
|
|
|
#define FORMAT(n) (((n).fmt == 8 && (n).val != 0) ? "0%llo" : \
|
|
((n).fmt == 16) ? "0x%llx" : "%lld")
|
|
|
|
#define stop(s) cfgerror(s), exit(1)
|
|
|
|
static struct config conf; /* at most one active at a time */
|
|
static int nowarn; /* if warning suppression is on */
|
|
|
|
|
|
/*
|
|
* Allocation wrapper functions
|
|
*/
|
|
static void wrap_alloc(void *ptr, unsigned code);
|
|
static void wrap_continue(void);
|
|
static void wrap_cleanup(void);
|
|
|
|
/*
|
|
* Allocation wrapper type codes
|
|
*/
|
|
#define WRAP_CODE_nvlist 1
|
|
#define WRAP_CODE_defoptlist 2
|
|
#define WRAP_CODE_loclist 3
|
|
#define WRAP_CODE_attrlist 4
|
|
#define WRAP_CODE_condexpr 5
|
|
|
|
/*
|
|
* The allocation wrappers themselves
|
|
*/
|
|
#define DECL_ALLOCWRAP(t) static struct t *wrap_mk_##t(struct t *arg)
|
|
|
|
DECL_ALLOCWRAP(nvlist);
|
|
DECL_ALLOCWRAP(defoptlist);
|
|
DECL_ALLOCWRAP(loclist);
|
|
DECL_ALLOCWRAP(attrlist);
|
|
DECL_ALLOCWRAP(condexpr);
|
|
|
|
/* allow shorter names */
|
|
#define wrap_mk_loc(p) wrap_mk_loclist(p)
|
|
#define wrap_mk_cx(p) wrap_mk_condexpr(p)
|
|
|
|
/*
|
|
* Macros for allocating new objects
|
|
*/
|
|
|
|
/* old-style for struct nvlist */
|
|
#define new0(n,s,p,i,x) wrap_mk_nvlist(newnv(n, s, p, i, x))
|
|
#define new_n(n) new0(n, NULL, NULL, 0, NULL)
|
|
#define new_nx(n, x) new0(n, NULL, NULL, 0, x)
|
|
#define new_ns(n, s) new0(n, s, NULL, 0, NULL)
|
|
#define new_si(s, i) new0(NULL, s, NULL, i, NULL)
|
|
#define new_spi(s, p, i) new0(NULL, s, p, i, NULL)
|
|
#define new_nsi(n,s,i) new0(n, s, NULL, i, NULL)
|
|
#define new_np(n, p) new0(n, NULL, p, 0, NULL)
|
|
#define new_s(s) new0(NULL, s, NULL, 0, NULL)
|
|
#define new_p(p) new0(NULL, NULL, p, 0, NULL)
|
|
#define new_px(p, x) new0(NULL, NULL, p, 0, x)
|
|
#define new_sx(s, x) new0(NULL, s, NULL, 0, x)
|
|
#define new_nsx(n,s,x) new0(n, s, NULL, 0, x)
|
|
#define new_i(i) new0(NULL, NULL, NULL, i, NULL)
|
|
|
|
/* new style, type-polymorphic; ordinary and for types with multiple flavors */
|
|
#define MK0(t) wrap_mk_##t(mk_##t())
|
|
#define MK1(t, a0) wrap_mk_##t(mk_##t(a0))
|
|
#define MK2(t, a0, a1) wrap_mk_##t(mk_##t(a0, a1))
|
|
#define MK3(t, a0, a1, a2) wrap_mk_##t(mk_##t(a0, a1, a2))
|
|
|
|
#define MKF0(t, f) wrap_mk_##t(mk_##t##_##f())
|
|
#define MKF1(t, f, a0) wrap_mk_##t(mk_##t##_##f(a0))
|
|
#define MKF2(t, f, a0, a1) wrap_mk_##t(mk_##t##_##f(a0, a1))
|
|
|
|
/*
|
|
* Data constructors
|
|
*/
|
|
|
|
static struct defoptlist *mk_defoptlist(const char *, const char *,
|
|
const char *);
|
|
static struct loclist *mk_loc(const char *, const char *, long long);
|
|
static struct loclist *mk_loc_val(const char *, struct loclist *);
|
|
static struct attrlist *mk_attrlist(struct attrlist *, struct attr *);
|
|
static struct condexpr *mk_cx_atom(const char *);
|
|
static struct condexpr *mk_cx_not(struct condexpr *);
|
|
static struct condexpr *mk_cx_and(struct condexpr *, struct condexpr *);
|
|
static struct condexpr *mk_cx_or(struct condexpr *, struct condexpr *);
|
|
|
|
/*
|
|
* Other private functions
|
|
*/
|
|
|
|
static void setmachine(const char *, const char *, struct nvlist *, int);
|
|
static void check_maxpart(void);
|
|
|
|
static struct loclist *present_loclist(struct loclist *ll);
|
|
static void app(struct loclist *, struct loclist *);
|
|
static struct loclist *locarray(const char *, int, struct loclist *, int);
|
|
static struct loclist *namelocvals(const char *, struct loclist *);
|
|
|
|
%}
|
|
|
|
%union {
|
|
struct attr *attr;
|
|
struct devbase *devb;
|
|
struct deva *deva;
|
|
struct nvlist *list;
|
|
struct defoptlist *defoptlist;
|
|
struct loclist *loclist;
|
|
struct attrlist *attrlist;
|
|
struct condexpr *condexpr;
|
|
const char *str;
|
|
struct numconst num;
|
|
int64_t val;
|
|
u_char flag;
|
|
devmajor_t devmajor;
|
|
int32_t i32;
|
|
}
|
|
|
|
%token AND AT ATTACH
|
|
%token BLOCK BUILD
|
|
%token CHAR COLONEQ COMPILE_WITH CONFIG
|
|
%token DEFFS DEFINE DEFOPT DEFPARAM DEFFLAG DEFPSEUDO DEFPSEUDODEV
|
|
%token DEVICE DEVCLASS DUMPS DEVICE_MAJOR
|
|
%token ENDFILE
|
|
%token XFILE FILE_SYSTEM FLAGS
|
|
%token IDENT IOCONF
|
|
%token LINKZERO
|
|
%token XMACHINE MAJOR MAKEOPTIONS MAXUSERS MAXPARTITIONS MINOR
|
|
%token NEEDS_COUNT NEEDS_FLAG NO CNO
|
|
%token XOBJECT OBSOLETE ON OPTIONS
|
|
%token PACKAGE PLUSEQ PREFIX BUILDPREFIX PSEUDO_DEVICE PSEUDO_ROOT
|
|
%token ROOT
|
|
%token SELECT SINGLE SOURCE
|
|
%token TYPE
|
|
%token VECTOR VERSION
|
|
%token WITH
|
|
%token <num> NUMBER
|
|
%token <str> PATHNAME QSTRING WORD EMPTYSTRING
|
|
%token ENDDEFS
|
|
|
|
%type <condexpr> fopts condexpr condatom
|
|
%type <condexpr> cond_or_expr cond_and_expr cond_prefix_expr
|
|
%type <condexpr> cond_base_expr
|
|
%type <str> fs_spec
|
|
%type <flag> fflags fflag oflags oflag
|
|
%type <str> rule
|
|
%type <attr> depend
|
|
%type <devb> devbase
|
|
%type <deva> devattach_opt
|
|
%type <list> atlist
|
|
%type <loclist> interface_opt
|
|
%type <str> atname
|
|
%type <loclist> loclist locdef
|
|
%type <str> locdefault
|
|
%type <loclist> values locdefaults
|
|
%type <attrlist> depend_list depends
|
|
%type <loclist> locators locator
|
|
%type <list> dev_spec
|
|
%type <str> device_instance
|
|
%type <str> attachment
|
|
%type <str> value
|
|
%type <val> major_minor
|
|
%type <num> signed_number
|
|
%type <i32> int32 npseudo device_flags no
|
|
%type <str> deffs
|
|
%type <list> deffses
|
|
%type <defoptlist> defopt
|
|
%type <defoptlist> defopts
|
|
%type <str> optdepend
|
|
%type <list> optdepends
|
|
%type <list> optdepend_list
|
|
%type <str> optfile_opt
|
|
%type <list> subarches
|
|
%type <str> filename stringvalue locname mkvarname
|
|
%type <devmajor> device_major_block device_major_char
|
|
%type <list> devnodes devnodetype devnodeflags devnode_dims
|
|
|
|
%%
|
|
|
|
/*
|
|
* A complete configuration consists of both the selection part (a
|
|
* kernel config such as GENERIC or SKYNET, plus also the various
|
|
* std.* files), which selects the material to be in the kernel, and
|
|
* also the definition part (files, files.*, etc.) that declares what
|
|
* material is available to be placed in kernels.
|
|
*
|
|
* The two parts have almost entirely separate syntaxes. This grammar
|
|
* covers both of them. When config is run on a kernel configuration
|
|
* file, the std.* file for the port is included explicitly. The
|
|
* files.* files are included implicitly when the std.* file declares
|
|
* the machine type.
|
|
*
|
|
* The machine spec, which brings in the definition part, must appear
|
|
* before all configuration material except for the "topthings"; these
|
|
* are the "source" and "build" declarations that tell config where
|
|
* things are. These are not used by default.
|
|
*
|
|
* A previous version of this comment contained the following text:
|
|
*
|
|
* Note that we do not have sufficient keywords to enforce any
|
|
* order between elements of "topthings" without introducing
|
|
* shift/reduce conflicts. Instead, check order requirements in
|
|
* the C code.
|
|
*
|
|
* As of March 2012 this comment makes no sense, as there are only two
|
|
* topthings and no reason for them to be forcibly ordered.
|
|
* Furthermore, the statement about conflicts is false.
|
|
*/
|
|
|
|
/* Complete configuration. */
|
|
configuration:
|
|
topthings machine_spec definition_part selection_part
|
|
;
|
|
|
|
/* Sequence of zero or more topthings. */
|
|
topthings:
|
|
/* empty */
|
|
| topthings topthing
|
|
;
|
|
|
|
/* Directory specification. */
|
|
topthing:
|
|
'\n'
|
|
| SOURCE filename '\n' { if (!srcdir) srcdir = $2; }
|
|
| BUILD filename '\n' { if (!builddir) builddir = $2; }
|
|
;
|
|
|
|
/* "machine foo" from std.whatever */
|
|
machine_spec:
|
|
XMACHINE WORD '\n' { setmachine($2,NULL,NULL,0); }
|
|
| XMACHINE WORD WORD '\n' { setmachine($2,$3,NULL,0); }
|
|
| XMACHINE WORD WORD subarches '\n' { setmachine($2,$3,$4,0); }
|
|
| IOCONF WORD '\n' { setmachine($2,NULL,NULL,1); }
|
|
| error { stop("cannot proceed without machine or ioconf specifier"); }
|
|
;
|
|
|
|
/* One or more sub-arches. */
|
|
subarches:
|
|
WORD { $$ = new_n($1); }
|
|
| subarches WORD { $$ = new_nx($2, $1); }
|
|
;
|
|
|
|
no:
|
|
NO { $$ = 0; }
|
|
| CNO { $$ = 1; }
|
|
;
|
|
|
|
/************************************************************/
|
|
|
|
/*
|
|
* The machine definitions grammar.
|
|
*/
|
|
|
|
/* Complete definition part: the contents of all files.* files. */
|
|
definition_part:
|
|
definitions ENDDEFS { check_maxpart(); check_version(); }
|
|
;
|
|
|
|
/* Zero or more definitions. Trap errors. */
|
|
definitions:
|
|
/* empty */
|
|
| definitions '\n'
|
|
| definitions definition '\n' { wrap_continue(); }
|
|
| definitions error '\n' { wrap_cleanup(); }
|
|
| definitions ENDFILE { enddefs(); checkfiles(); }
|
|
;
|
|
|
|
/* A single definition. */
|
|
definition:
|
|
define_file
|
|
| define_object
|
|
| define_device_major
|
|
| define_prefix
|
|
| define_buildprefix
|
|
| define_devclass
|
|
| define_filesystems
|
|
| define_attribute
|
|
| define_option
|
|
| define_flag
|
|
| define_obsolete_flag
|
|
| define_param
|
|
| define_obsolete_param
|
|
| define_device
|
|
| define_device_attachment
|
|
| define_maxpartitions
|
|
| define_maxusers
|
|
| define_makeoptions
|
|
| define_pseudo
|
|
| define_pseudodev
|
|
| define_major
|
|
| define_version
|
|
;
|
|
|
|
/* source file: file foo/bar.c bar|baz needs-flag compile-with blah */
|
|
define_file:
|
|
XFILE filename fopts fflags rule { addfile($2, $3, $4, $5); }
|
|
;
|
|
|
|
/* object file: object zot.o foo|zot needs-flag */
|
|
define_object:
|
|
XOBJECT filename fopts oflags { addfile($2, $3, $4, NULL); }
|
|
;
|
|
|
|
/* device major declaration */
|
|
define_device_major:
|
|
DEVICE_MAJOR WORD device_major_char device_major_block fopts devnodes
|
|
{
|
|
adddevm($2, $3, $4, $5, $6);
|
|
do_devsw = 1;
|
|
}
|
|
;
|
|
|
|
/* prefix delimiter */
|
|
define_prefix:
|
|
PREFIX filename { prefix_push($2); }
|
|
| PREFIX { prefix_pop(); }
|
|
;
|
|
|
|
define_buildprefix:
|
|
BUILDPREFIX filename { buildprefix_push($2); }
|
|
| BUILDPREFIX WORD { buildprefix_push($2); }
|
|
| BUILDPREFIX { buildprefix_pop(); }
|
|
;
|
|
|
|
define_devclass:
|
|
DEVCLASS WORD { (void)defdevclass($2, NULL, NULL, 1); }
|
|
;
|
|
|
|
define_filesystems:
|
|
DEFFS deffses optdepend_list { deffilesystem($2, $3); }
|
|
;
|
|
|
|
define_attribute:
|
|
DEFINE WORD interface_opt depend_list
|
|
{ (void)defattr0($2, $3, $4, 0); }
|
|
;
|
|
|
|
define_option:
|
|
DEFOPT optfile_opt defopts optdepend_list
|
|
{ defoption($2, $3, $4); }
|
|
;
|
|
|
|
define_flag:
|
|
DEFFLAG optfile_opt defopts optdepend_list
|
|
{ defflag($2, $3, $4, 0); }
|
|
;
|
|
|
|
define_obsolete_flag:
|
|
OBSOLETE DEFFLAG optfile_opt defopts
|
|
{ defflag($3, $4, NULL, 1); }
|
|
;
|
|
|
|
define_param:
|
|
DEFPARAM optfile_opt defopts optdepend_list
|
|
{ defparam($2, $3, $4, 0); }
|
|
;
|
|
|
|
define_obsolete_param:
|
|
OBSOLETE DEFPARAM optfile_opt defopts
|
|
{ defparam($3, $4, NULL, 1); }
|
|
;
|
|
|
|
define_device:
|
|
DEVICE devbase interface_opt depend_list
|
|
{ defdev($2, $3, $4, 0); }
|
|
;
|
|
|
|
define_device_attachment:
|
|
ATTACH devbase AT atlist devattach_opt depend_list
|
|
{ defdevattach($5, $2, $4, $6); }
|
|
;
|
|
|
|
define_maxpartitions:
|
|
MAXPARTITIONS int32 { maxpartitions = $2; }
|
|
;
|
|
|
|
define_maxusers:
|
|
MAXUSERS int32 int32 int32
|
|
{ setdefmaxusers($2, $3, $4); }
|
|
;
|
|
|
|
define_makeoptions:
|
|
MAKEOPTIONS condmkopt_list
|
|
;
|
|
|
|
define_pseudo:
|
|
/* interface_opt in DEFPSEUDO is for backwards compatibility */
|
|
DEFPSEUDO devbase interface_opt depend_list
|
|
{ defdev($2, $3, $4, 1); }
|
|
;
|
|
|
|
define_pseudodev:
|
|
DEFPSEUDODEV devbase interface_opt depend_list
|
|
{ defdev($2, $3, $4, 2); }
|
|
;
|
|
|
|
define_major:
|
|
MAJOR '{' majorlist '}'
|
|
;
|
|
|
|
define_version:
|
|
VERSION int32 { setversion($2); }
|
|
;
|
|
|
|
/* file options: optional expression of conditions */
|
|
fopts:
|
|
/* empty */ { $$ = NULL; }
|
|
| condexpr { $$ = $1; }
|
|
;
|
|
|
|
/* zero or more flags for a file */
|
|
fflags:
|
|
/* empty */ { $$ = 0; }
|
|
| fflags fflag { $$ = $1 | $2; }
|
|
;
|
|
|
|
/* one flag for a file */
|
|
fflag:
|
|
NEEDS_COUNT { $$ = FI_NEEDSCOUNT; }
|
|
| NEEDS_FLAG { $$ = FI_NEEDSFLAG; }
|
|
;
|
|
|
|
/* extra compile directive for a source file */
|
|
rule:
|
|
/* empty */ { $$ = NULL; }
|
|
| COMPILE_WITH stringvalue { $$ = $2; }
|
|
;
|
|
|
|
/* zero or more flags for an object file */
|
|
oflags:
|
|
/* empty */ { $$ = 0; }
|
|
| oflags oflag { $$ = $1 | $2; }
|
|
;
|
|
|
|
/* a single flag for an object file */
|
|
oflag:
|
|
NEEDS_FLAG { $$ = FI_NEEDSFLAG; }
|
|
;
|
|
|
|
/* char 55 */
|
|
device_major_char:
|
|
/* empty */ { $$ = -1; }
|
|
| CHAR int32 { $$ = $2; }
|
|
;
|
|
|
|
/* block 33 */
|
|
device_major_block:
|
|
/* empty */ { $$ = -1; }
|
|
| BLOCK int32 { $$ = $2; }
|
|
;
|
|
|
|
/* device node specification */
|
|
devnodes:
|
|
/* empty */ { $$ = new_s("DEVNODE_DONTBOTHER"); }
|
|
| devnodetype ',' devnodeflags { $$ = nvcat($1, $3); }
|
|
| devnodetype { $$ = $1; }
|
|
;
|
|
|
|
/* device nodes without flags */
|
|
devnodetype:
|
|
SINGLE { $$ = new_s("DEVNODE_SINGLE"); }
|
|
| VECTOR '=' devnode_dims { $$ = nvcat(new_s("DEVNODE_VECTOR"), $3); }
|
|
;
|
|
|
|
/* dimensions (?) */
|
|
devnode_dims:
|
|
NUMBER { $$ = new_i($1.val); }
|
|
| NUMBER ':' NUMBER {
|
|
struct nvlist *__nv1, *__nv2;
|
|
|
|
__nv1 = new_i($1.val);
|
|
__nv2 = new_i($3.val);
|
|
$$ = nvcat(__nv1, __nv2);
|
|
}
|
|
;
|
|
|
|
/* flags for device nodes */
|
|
devnodeflags:
|
|
LINKZERO { $$ = new_s("DEVNODE_FLAG_LINKZERO");}
|
|
;
|
|
|
|
/* one or more file system names */
|
|
deffses:
|
|
deffs { $$ = new_n($1); }
|
|
| deffses deffs { $$ = new_nx($2, $1); }
|
|
;
|
|
|
|
/* a single file system name */
|
|
deffs:
|
|
WORD { $$ = $1; }
|
|
;
|
|
|
|
/* optional locator specification */
|
|
interface_opt:
|
|
/* empty */ { $$ = NULL; }
|
|
| '{' '}' { $$ = present_loclist(NULL); }
|
|
| '{' loclist '}' { $$ = present_loclist($2); }
|
|
;
|
|
|
|
/*
|
|
* loclist order matters, must use right recursion
|
|
* XXX wot?
|
|
*/
|
|
|
|
/* list of locator definitions */
|
|
loclist:
|
|
locdef { $$ = $1; }
|
|
| locdef ',' loclist { $$ = $1; app($1, $3); }
|
|
;
|
|
|
|
/*
|
|
* "[ WORD locdefault ]" syntax may be unnecessary...
|
|
*/
|
|
|
|
/* one locator definition */
|
|
locdef:
|
|
locname locdefault { $$ = MK3(loc, $1, $2, 0); }
|
|
| locname { $$ = MK3(loc, $1, NULL, 0); }
|
|
| '[' locname locdefault ']' { $$ = MK3(loc, $2, $3, 1); }
|
|
| locname '[' int32 ']' { $$ = locarray($1, $3, NULL, 0); }
|
|
| locname '[' int32 ']' locdefaults
|
|
{ $$ = locarray($1, $3, $5, 0); }
|
|
| '[' locname '[' int32 ']' locdefaults ']'
|
|
{ $$ = locarray($2, $4, $6, 1); }
|
|
;
|
|
|
|
/* locator name */
|
|
locname:
|
|
WORD { $$ = $1; }
|
|
| QSTRING { $$ = $1; }
|
|
;
|
|
|
|
/* locator default value */
|
|
locdefault:
|
|
'=' value { $$ = $2; }
|
|
;
|
|
|
|
/* multiple locator default values */
|
|
locdefaults:
|
|
'=' '{' values '}' { $$ = $3; }
|
|
;
|
|
|
|
/* list of depends, may be empty */
|
|
depend_list:
|
|
/* empty */ { $$ = NULL; }
|
|
| ':' depends { $$ = $2; }
|
|
;
|
|
|
|
/* one or more depend items */
|
|
depends:
|
|
depend { $$ = MK2(attrlist, NULL, $1); }
|
|
| depends ',' depend { $$ = MK2(attrlist, $1, $3); }
|
|
;
|
|
|
|
/* one depend item (which is an attribute) */
|
|
depend:
|
|
WORD { $$ = refattr($1); }
|
|
;
|
|
|
|
/* list of option depends, may be empty */
|
|
optdepend_list:
|
|
/* empty */ { $$ = NULL; }
|
|
| ':' optdepends { $$ = $2; }
|
|
;
|
|
|
|
/* a list of option dependencies */
|
|
optdepends:
|
|
optdepend { $$ = new_n($1); }
|
|
| optdepends ',' optdepend { $$ = new_nx($3, $1); }
|
|
;
|
|
|
|
/* one option depend, which is an option name */
|
|
optdepend:
|
|
WORD { $$ = $1; }
|
|
;
|
|
|
|
|
|
/* list of places to attach: attach blah at ... */
|
|
atlist:
|
|
atname { $$ = new_n($1); }
|
|
| atlist ',' atname { $$ = new_nx($3, $1); }
|
|
;
|
|
|
|
/* a place to attach a device */
|
|
atname:
|
|
WORD { $$ = $1; }
|
|
| ROOT { $$ = NULL; }
|
|
;
|
|
|
|
/* one or more defined options */
|
|
defopts:
|
|
defopt { $$ = $1; }
|
|
| defopts defopt { $$ = defoptlist_append($2, $1); }
|
|
;
|
|
|
|
/* one defined option */
|
|
defopt:
|
|
WORD { $$ = MK3(defoptlist, $1, NULL, NULL); }
|
|
| WORD '=' value { $$ = MK3(defoptlist, $1, $3, NULL); }
|
|
| WORD COLONEQ value { $$ = MK3(defoptlist, $1, NULL, $3); }
|
|
| WORD '=' value COLONEQ value { $$ = MK3(defoptlist, $1, $3, $5); }
|
|
;
|
|
|
|
/* list of conditional makeoptions */
|
|
condmkopt_list:
|
|
condmkoption
|
|
| condmkopt_list ',' condmkoption
|
|
;
|
|
|
|
/* one conditional make option */
|
|
condmkoption:
|
|
condexpr mkvarname PLUSEQ value { appendcondmkoption($1, $2, $4); }
|
|
;
|
|
|
|
/* device name */
|
|
devbase:
|
|
WORD { $$ = getdevbase($1); }
|
|
;
|
|
|
|
/* optional attachment: with foo */
|
|
devattach_opt:
|
|
/* empty */ { $$ = NULL; }
|
|
| WITH WORD { $$ = getdevattach($2); }
|
|
;
|
|
|
|
/* list of major numbers */
|
|
/* XXX why is this right-recursive? */
|
|
majorlist:
|
|
majordef
|
|
| majorlist ',' majordef
|
|
;
|
|
|
|
/* one major number */
|
|
majordef:
|
|
devbase '=' int32 { setmajor($1, $3); }
|
|
;
|
|
|
|
int32:
|
|
NUMBER {
|
|
if ($1.val > INT_MAX || $1.val < INT_MIN)
|
|
cfgerror("overflow %" PRId64, $1.val);
|
|
else
|
|
$$ = (int32_t)$1.val;
|
|
}
|
|
;
|
|
|
|
/************************************************************/
|
|
|
|
/*
|
|
* The selection grammar.
|
|
*/
|
|
|
|
/* Complete selection part: all std.* files plus selected config. */
|
|
selection_part:
|
|
selections
|
|
;
|
|
|
|
/* Zero or more config items. Trap errors. */
|
|
selections:
|
|
/* empty */
|
|
| selections '\n'
|
|
| selections selection '\n' { wrap_continue(); }
|
|
| selections error '\n' { wrap_cleanup(); }
|
|
;
|
|
|
|
/* One config item. */
|
|
selection:
|
|
definition
|
|
| select_attr
|
|
| select_no_attr
|
|
| select_no_filesystems
|
|
| select_filesystems
|
|
| select_no_makeoptions
|
|
| select_makeoptions
|
|
| select_no_options
|
|
| select_options
|
|
| select_maxusers
|
|
| select_ident
|
|
| select_no_ident
|
|
| select_config
|
|
| select_no_config
|
|
| select_no_pseudodev
|
|
| select_pseudodev
|
|
| select_pseudoroot
|
|
| select_no_device_instance_attachment
|
|
| select_no_device_attachment
|
|
| select_no_device_instance
|
|
| select_device_instance
|
|
;
|
|
|
|
select_attr:
|
|
SELECT WORD { addattr($2); }
|
|
;
|
|
|
|
select_no_attr:
|
|
no SELECT WORD { delattr($3, $1); }
|
|
;
|
|
|
|
select_no_filesystems:
|
|
no FILE_SYSTEM { nowarn = $1; } no_fs_list { nowarn = 0; }
|
|
;
|
|
|
|
select_filesystems:
|
|
FILE_SYSTEM fs_list
|
|
;
|
|
|
|
select_no_makeoptions:
|
|
no MAKEOPTIONS { nowarn = $1; } no_mkopt_list { nowarn = 0; }
|
|
;
|
|
|
|
select_makeoptions:
|
|
MAKEOPTIONS mkopt_list
|
|
;
|
|
|
|
select_no_options:
|
|
no OPTIONS { nowarn = $1; } no_opt_list { nowarn = 0; }
|
|
;
|
|
|
|
select_options:
|
|
OPTIONS opt_list
|
|
;
|
|
|
|
select_maxusers:
|
|
MAXUSERS int32 { setmaxusers($2); }
|
|
;
|
|
|
|
select_ident:
|
|
IDENT stringvalue { setident($2); }
|
|
;
|
|
|
|
select_no_ident:
|
|
no IDENT { setident(NULL); }
|
|
;
|
|
|
|
select_config:
|
|
CONFIG conf root_spec sysparam_list
|
|
{ addconf(&conf); }
|
|
;
|
|
|
|
select_no_config:
|
|
no CONFIG WORD { delconf($3, $1); }
|
|
;
|
|
|
|
select_no_pseudodev:
|
|
no PSEUDO_DEVICE WORD { delpseudo($3, $1); }
|
|
;
|
|
|
|
select_pseudodev:
|
|
PSEUDO_DEVICE WORD npseudo { addpseudo($2, $3); }
|
|
;
|
|
|
|
select_pseudoroot:
|
|
PSEUDO_ROOT device_instance { addpseudoroot($2); }
|
|
;
|
|
|
|
select_no_device_instance_attachment:
|
|
no device_instance AT attachment
|
|
{ deldevi($2, $4, $1); }
|
|
;
|
|
|
|
select_no_device_attachment:
|
|
no DEVICE AT attachment { deldeva($4, $1); }
|
|
;
|
|
|
|
select_no_device_instance:
|
|
no device_instance { deldev($2, $1); }
|
|
;
|
|
|
|
select_device_instance:
|
|
device_instance AT attachment locators device_flags
|
|
{ adddev($1, $3, $4, $5); }
|
|
;
|
|
|
|
/* list of filesystems */
|
|
fs_list:
|
|
fsoption
|
|
| fs_list ',' fsoption
|
|
;
|
|
|
|
/* one filesystem */
|
|
fsoption:
|
|
WORD { addfsoption($1); }
|
|
;
|
|
|
|
/* list of filesystems that had NO in front */
|
|
no_fs_list:
|
|
no_fsoption
|
|
| no_fs_list ',' no_fsoption
|
|
;
|
|
|
|
/* one filesystem that had NO in front */
|
|
no_fsoption:
|
|
WORD { delfsoption($1, nowarn); }
|
|
;
|
|
|
|
/* list of make options */
|
|
/* XXX why is this right-recursive? */
|
|
mkopt_list:
|
|
mkoption
|
|
| mkopt_list ',' mkoption
|
|
;
|
|
|
|
/* one make option */
|
|
mkoption:
|
|
mkvarname '=' value { addmkoption($1, $3); }
|
|
| mkvarname PLUSEQ value { appendmkoption($1, $3); }
|
|
;
|
|
|
|
/* list of make options that had NO in front */
|
|
no_mkopt_list:
|
|
no_mkoption
|
|
| no_mkopt_list ',' no_mkoption
|
|
;
|
|
|
|
/* one make option that had NO in front */
|
|
/* XXX shouldn't this be mkvarname rather than WORD? */
|
|
no_mkoption:
|
|
WORD { delmkoption($1, nowarn); }
|
|
;
|
|
|
|
/* list of options */
|
|
opt_list:
|
|
option
|
|
| opt_list ',' option
|
|
;
|
|
|
|
/* one option */
|
|
option:
|
|
WORD { addoption($1, NULL); }
|
|
| WORD '=' value { addoption($1, $3); }
|
|
;
|
|
|
|
/* list of options that had NO in front */
|
|
no_opt_list:
|
|
no_option
|
|
| no_opt_list ',' no_option
|
|
;
|
|
|
|
/* one option that had NO in front */
|
|
no_option:
|
|
WORD { deloption($1, nowarn); }
|
|
;
|
|
|
|
/* the name in "config name root on ..." */
|
|
conf:
|
|
WORD {
|
|
conf.cf_name = $1;
|
|
conf.cf_lineno = currentline();
|
|
conf.cf_fstype = NULL;
|
|
conf.cf_root = NULL;
|
|
conf.cf_dump = NULL;
|
|
}
|
|
;
|
|
|
|
/* root fs specification */
|
|
root_spec:
|
|
ROOT on_opt dev_spec { setconf(&conf.cf_root, "root", $3); }
|
|
| ROOT on_opt dev_spec fs_spec { setconf(&conf.cf_root, "root", $3); }
|
|
;
|
|
|
|
/* device for root fs or dump */
|
|
dev_spec:
|
|
'?' { $$ = new_spi(intern("?"),
|
|
NULL,
|
|
(long long)NODEV); }
|
|
| QSTRING { $$ = new_spi($1,
|
|
__UNCONST("spec"),
|
|
(long long)NODEV); }
|
|
| WORD { $$ = new_spi($1,
|
|
NULL,
|
|
(long long)NODEV); }
|
|
| major_minor { $$ = new_si(NULL, $1); }
|
|
;
|
|
|
|
/* major and minor device number */
|
|
major_minor:
|
|
MAJOR NUMBER MINOR NUMBER { $$ = (int64_t)makedev($2.val, $4.val); }
|
|
;
|
|
|
|
/* filesystem type for root fs specification */
|
|
fs_spec:
|
|
TYPE '?' { setfstype(&conf.cf_fstype, intern("?")); }
|
|
| TYPE WORD { setfstype(&conf.cf_fstype, $2); }
|
|
;
|
|
|
|
/* zero or more additional system parameters */
|
|
sysparam_list:
|
|
/* empty */
|
|
| sysparam_list sysparam
|
|
;
|
|
|
|
/* one additional system parameter (there's only one: dumps) */
|
|
sysparam:
|
|
DUMPS on_opt dev_spec { setconf(&conf.cf_dump, "dumps", $3); }
|
|
;
|
|
|
|
/* number of pseudo devices to configure (which is optional) */
|
|
npseudo:
|
|
/* empty */ { $$ = 1; }
|
|
| int32 { $$ = $1; }
|
|
;
|
|
|
|
/* name of a device to configure */
|
|
device_instance:
|
|
WORD { $$ = $1; }
|
|
| WORD '*' { $$ = starref($1); }
|
|
;
|
|
|
|
/* name of a device to configure an attachment to */
|
|
attachment:
|
|
ROOT { $$ = NULL; }
|
|
| WORD { $$ = $1; }
|
|
| WORD '?' { $$ = wildref($1); }
|
|
;
|
|
|
|
/* zero or more locators */
|
|
locators:
|
|
/* empty */ { $$ = NULL; }
|
|
| locators locator { $$ = $2; app($2, $1); }
|
|
;
|
|
|
|
/* one locator */
|
|
locator:
|
|
WORD '?' { $$ = MK3(loc, $1, NULL, 0); }
|
|
| WORD values { $$ = namelocvals($1, $2); }
|
|
;
|
|
|
|
/* optional device flags */
|
|
device_flags:
|
|
/* empty */ { $$ = 0; }
|
|
| FLAGS int32 { $$ = $2; }
|
|
;
|
|
|
|
/************************************************************/
|
|
|
|
/*
|
|
* conditions
|
|
*/
|
|
|
|
|
|
/*
|
|
* order of options is important, must use right recursion
|
|
*
|
|
* dholland 20120310: wut?
|
|
*/
|
|
|
|
/* expression of conditions */
|
|
condexpr:
|
|
cond_or_expr
|
|
;
|
|
|
|
cond_or_expr:
|
|
cond_and_expr
|
|
| cond_or_expr '|' cond_and_expr { $$ = MKF2(cx, or, $1, $3); }
|
|
;
|
|
|
|
cond_and_expr:
|
|
cond_prefix_expr
|
|
| cond_and_expr '&' cond_prefix_expr { $$ = MKF2(cx, and, $1, $3); }
|
|
;
|
|
|
|
cond_prefix_expr:
|
|
cond_base_expr
|
|
/* XXX notyet - need to strengthen downstream first */
|
|
/* | '!' cond_prefix_expr { $$ = MKF1(cx, not, $2); } */
|
|
;
|
|
|
|
cond_base_expr:
|
|
condatom { $$ = $1; }
|
|
| '!' condatom { $$ = MKF1(cx, not, $2); }
|
|
| '(' condexpr ')' { $$ = $2; }
|
|
;
|
|
|
|
/* basic element of config element expression: a config element */
|
|
condatom:
|
|
WORD { $$ = MKF1(cx, atom, $1); }
|
|
;
|
|
|
|
/************************************************************/
|
|
|
|
/*
|
|
* Various nonterminals shared between the grammars.
|
|
*/
|
|
|
|
/* variable name for make option */
|
|
mkvarname:
|
|
QSTRING { $$ = $1; }
|
|
| WORD { $$ = $1; }
|
|
;
|
|
|
|
/* optional file for an option */
|
|
optfile_opt:
|
|
/* empty */ { $$ = NULL; }
|
|
| filename { $$ = $1; }
|
|
;
|
|
|
|
/* filename. */
|
|
filename:
|
|
QSTRING { $$ = $1; }
|
|
| PATHNAME { $$ = $1; }
|
|
;
|
|
|
|
/* constant value */
|
|
value:
|
|
QSTRING { $$ = $1; }
|
|
| WORD { $$ = $1; }
|
|
| EMPTYSTRING { $$ = $1; }
|
|
| signed_number {
|
|
char bf[40];
|
|
|
|
(void)snprintf(bf, sizeof(bf), FORMAT($1), (long long)$1.val);
|
|
$$ = intern(bf);
|
|
}
|
|
;
|
|
|
|
/* constant value that is a string */
|
|
stringvalue:
|
|
QSTRING { $$ = $1; }
|
|
| WORD { $$ = $1; }
|
|
;
|
|
|
|
/* comma-separated list of values */
|
|
/* XXX why right-recursive? */
|
|
values:
|
|
value { $$ = MKF2(loc, val, $1, NULL); }
|
|
| value ',' values { $$ = MKF2(loc, val, $1, $3); }
|
|
;
|
|
|
|
/* possibly negative number */
|
|
signed_number:
|
|
NUMBER { $$ = $1; }
|
|
| '-' NUMBER { $$.fmt = $2.fmt; $$.val = -$2.val; }
|
|
;
|
|
|
|
/* optional ON keyword */
|
|
on_opt:
|
|
/* empty */
|
|
| ON
|
|
;
|
|
|
|
%%
|
|
|
|
void
|
|
yyerror(const char *s)
|
|
{
|
|
|
|
cfgerror("%s", s);
|
|
}
|
|
|
|
/************************************************************/
|
|
|
|
/*
|
|
* Wrap allocations that live on the parser stack so that we can free
|
|
* them again on error instead of leaking.
|
|
*/
|
|
|
|
#define MAX_WRAP 1000
|
|
|
|
struct wrap_entry {
|
|
void *ptr;
|
|
unsigned typecode;
|
|
};
|
|
|
|
static struct wrap_entry wrapstack[MAX_WRAP];
|
|
static unsigned wrap_depth;
|
|
|
|
/*
|
|
* Remember pointer PTR with type-code CODE.
|
|
*/
|
|
static void
|
|
wrap_alloc(void *ptr, unsigned code)
|
|
{
|
|
unsigned pos;
|
|
|
|
if (wrap_depth >= MAX_WRAP) {
|
|
panic("allocation wrapper stack overflow");
|
|
}
|
|
pos = wrap_depth++;
|
|
wrapstack[pos].ptr = ptr;
|
|
wrapstack[pos].typecode = code;
|
|
}
|
|
|
|
/*
|
|
* We succeeded; commit to keeping everything that's been allocated so
|
|
* far and clear the stack.
|
|
*/
|
|
static void
|
|
wrap_continue(void)
|
|
{
|
|
wrap_depth = 0;
|
|
}
|
|
|
|
/*
|
|
* We failed; destroy all the objects allocated.
|
|
*/
|
|
static void
|
|
wrap_cleanup(void)
|
|
{
|
|
unsigned i;
|
|
|
|
/*
|
|
* Destroy each item. Note that because everything allocated
|
|
* is entered on the list separately, lists and trees need to
|
|
* have their links blanked before being destroyed. Also note
|
|
* that strings are interned elsewhere and not handled by this
|
|
* mechanism.
|
|
*/
|
|
|
|
for (i=0; i<wrap_depth; i++) {
|
|
switch (wrapstack[i].typecode) {
|
|
case WRAP_CODE_nvlist:
|
|
nvfree(wrapstack[i].ptr);
|
|
break;
|
|
case WRAP_CODE_defoptlist:
|
|
{
|
|
struct defoptlist *dl = wrapstack[i].ptr;
|
|
|
|
dl->dl_next = NULL;
|
|
defoptlist_destroy(dl);
|
|
}
|
|
break;
|
|
case WRAP_CODE_loclist:
|
|
{
|
|
struct loclist *ll = wrapstack[i].ptr;
|
|
|
|
ll->ll_next = NULL;
|
|
loclist_destroy(ll);
|
|
}
|
|
break;
|
|
case WRAP_CODE_attrlist:
|
|
{
|
|
struct attrlist *al = wrapstack[i].ptr;
|
|
|
|
al->al_next = NULL;
|
|
al->al_this = NULL;
|
|
attrlist_destroy(al);
|
|
}
|
|
break;
|
|
case WRAP_CODE_condexpr:
|
|
{
|
|
struct condexpr *cx = wrapstack[i].ptr;
|
|
|
|
cx->cx_type = CX_ATOM;
|
|
cx->cx_atom = NULL;
|
|
condexpr_destroy(cx);
|
|
}
|
|
break;
|
|
default:
|
|
panic("invalid code %u on allocation wrapper stack",
|
|
wrapstack[i].typecode);
|
|
}
|
|
}
|
|
|
|
wrap_depth = 0;
|
|
}
|
|
|
|
/*
|
|
* Instantiate the wrapper functions.
|
|
*
|
|
* Each one calls wrap_alloc to save the pointer and then returns the
|
|
* pointer again; these need to be generated with the preprocessor in
|
|
* order to be typesafe.
|
|
*/
|
|
#define DEF_ALLOCWRAP(t) \
|
|
static struct t * \
|
|
wrap_mk_##t(struct t *arg) \
|
|
{ \
|
|
wrap_alloc(arg, WRAP_CODE_##t); \
|
|
return arg; \
|
|
}
|
|
|
|
DEF_ALLOCWRAP(nvlist);
|
|
DEF_ALLOCWRAP(defoptlist);
|
|
DEF_ALLOCWRAP(loclist);
|
|
DEF_ALLOCWRAP(attrlist);
|
|
DEF_ALLOCWRAP(condexpr);
|
|
|
|
/************************************************************/
|
|
|
|
/*
|
|
* Data constructors
|
|
*
|
|
* (These are *beneath* the allocation wrappers.)
|
|
*/
|
|
|
|
static struct defoptlist *
|
|
mk_defoptlist(const char *name, const char *val, const char *lintval)
|
|
{
|
|
return defoptlist_create(name, val, lintval);
|
|
}
|
|
|
|
static struct loclist *
|
|
mk_loc(const char *name, const char *str, long long num)
|
|
{
|
|
return loclist_create(name, str, num);
|
|
}
|
|
|
|
static struct loclist *
|
|
mk_loc_val(const char *str, struct loclist *next)
|
|
{
|
|
struct loclist *ll;
|
|
|
|
ll = mk_loc(NULL, str, 0);
|
|
ll->ll_next = next;
|
|
return ll;
|
|
}
|
|
|
|
static struct attrlist *
|
|
mk_attrlist(struct attrlist *next, struct attr *a)
|
|
{
|
|
return attrlist_cons(next, a);
|
|
}
|
|
|
|
static struct condexpr *
|
|
mk_cx_atom(const char *s)
|
|
{
|
|
struct condexpr *cx;
|
|
|
|
cx = condexpr_create(CX_ATOM);
|
|
cx->cx_atom = s;
|
|
return cx;
|
|
}
|
|
|
|
static struct condexpr *
|
|
mk_cx_not(struct condexpr *sub)
|
|
{
|
|
struct condexpr *cx;
|
|
|
|
cx = condexpr_create(CX_NOT);
|
|
cx->cx_not = sub;
|
|
return cx;
|
|
}
|
|
|
|
static struct condexpr *
|
|
mk_cx_and(struct condexpr *left, struct condexpr *right)
|
|
{
|
|
struct condexpr *cx;
|
|
|
|
cx = condexpr_create(CX_AND);
|
|
cx->cx_and.left = left;
|
|
cx->cx_and.right = right;
|
|
return cx;
|
|
}
|
|
|
|
static struct condexpr *
|
|
mk_cx_or(struct condexpr *left, struct condexpr *right)
|
|
{
|
|
struct condexpr *cx;
|
|
|
|
cx = condexpr_create(CX_OR);
|
|
cx->cx_or.left = left;
|
|
cx->cx_or.right = right;
|
|
return cx;
|
|
}
|
|
|
|
/************************************************************/
|
|
|
|
static void
|
|
setmachine(const char *mch, const char *mcharch, struct nvlist *mchsubarches,
|
|
int isioconf)
|
|
{
|
|
char buf[MAXPATHLEN];
|
|
struct nvlist *nv;
|
|
|
|
if (isioconf) {
|
|
if (include(_PATH_DEVNULL, ENDDEFS, 0, 0) != 0)
|
|
exit(1);
|
|
ioconfname = mch;
|
|
return;
|
|
}
|
|
|
|
machine = mch;
|
|
machinearch = mcharch;
|
|
machinesubarches = mchsubarches;
|
|
|
|
/*
|
|
* Define attributes for all the given names
|
|
*/
|
|
if (defattr(machine, NULL, NULL, 0) != 0 ||
|
|
(machinearch != NULL &&
|
|
defattr(machinearch, NULL, NULL, 0) != 0))
|
|
exit(1);
|
|
for (nv = machinesubarches; nv != NULL; nv = nv->nv_next) {
|
|
if (defattr(nv->nv_name, NULL, NULL, 0) != 0)
|
|
exit(1);
|
|
}
|
|
|
|
/*
|
|
* Set up the file inclusion stack. This empty include tells
|
|
* the parser there are no more device definitions coming.
|
|
*/
|
|
if (include(_PATH_DEVNULL, ENDDEFS, 0, 0) != 0)
|
|
exit(1);
|
|
|
|
/* Include arch/${MACHINE}/conf/files.${MACHINE} */
|
|
(void)snprintf(buf, sizeof(buf), "arch/%s/conf/files.%s",
|
|
machine, machine);
|
|
if (include(buf, ENDFILE, 0, 0) != 0)
|
|
exit(1);
|
|
|
|
/* Include any arch/${MACHINE_SUBARCH}/conf/files.${MACHINE_SUBARCH} */
|
|
for (nv = machinesubarches; nv != NULL; nv = nv->nv_next) {
|
|
(void)snprintf(buf, sizeof(buf), "arch/%s/conf/files.%s",
|
|
nv->nv_name, nv->nv_name);
|
|
if (include(buf, ENDFILE, 0, 0) != 0)
|
|
exit(1);
|
|
}
|
|
|
|
/* Include any arch/${MACHINE_ARCH}/conf/files.${MACHINE_ARCH} */
|
|
if (machinearch != NULL)
|
|
(void)snprintf(buf, sizeof(buf), "arch/%s/conf/files.%s",
|
|
machinearch, machinearch);
|
|
else
|
|
strlcpy(buf, _PATH_DEVNULL, sizeof(buf));
|
|
if (include(buf, ENDFILE, 0, 0) != 0)
|
|
exit(1);
|
|
|
|
/*
|
|
* Include the global conf/files. As the last thing
|
|
* pushed on the stack, it will be processed first.
|
|
*/
|
|
if (include("conf/files", ENDFILE, 0, 0) != 0)
|
|
exit(1);
|
|
|
|
oktopackage = 1;
|
|
}
|
|
|
|
static void
|
|
check_maxpart(void)
|
|
{
|
|
|
|
if (maxpartitions <= 0 && ioconfname == NULL) {
|
|
stop("cannot proceed without maxpartitions specifier");
|
|
}
|
|
}
|
|
|
|
static void
|
|
check_version(void)
|
|
{
|
|
/*
|
|
* In essence, version is 0 and is not supported anymore
|
|
*/
|
|
if (version < CONFIG_MINVERSION)
|
|
stop("your sources are out of date -- please update.");
|
|
}
|
|
|
|
/*
|
|
* Prepend a blank entry to the locator definitions so the code in
|
|
* sem.c can distinguish "empty locator list" from "no locator list".
|
|
* XXX gross.
|
|
*/
|
|
static struct loclist *
|
|
present_loclist(struct loclist *ll)
|
|
{
|
|
struct loclist *ret;
|
|
|
|
ret = MK3(loc, "", NULL, 0);
|
|
ret->ll_next = ll;
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
app(struct loclist *p, struct loclist *q)
|
|
{
|
|
while (p->ll_next)
|
|
p = p->ll_next;
|
|
p->ll_next = q;
|
|
}
|
|
|
|
static struct loclist *
|
|
locarray(const char *name, int count, struct loclist *adefs, int opt)
|
|
{
|
|
struct loclist *defs = adefs;
|
|
struct loclist **p;
|
|
char buf[200];
|
|
int i;
|
|
|
|
if (count <= 0) {
|
|
fprintf(stderr, "config: array with <= 0 size: %s\n", name);
|
|
exit(1);
|
|
}
|
|
p = &defs;
|
|
for(i = 0; i < count; i++) {
|
|
if (*p == NULL)
|
|
*p = MK3(loc, NULL, "0", 0);
|
|
snprintf(buf, sizeof(buf), "%s%c%d", name, ARRCHR, i);
|
|
(*p)->ll_name = i == 0 ? name : intern(buf);
|
|
(*p)->ll_num = i > 0 || opt;
|
|
p = &(*p)->ll_next;
|
|
}
|
|
*p = 0;
|
|
return defs;
|
|
}
|
|
|
|
|
|
static struct loclist *
|
|
namelocvals(const char *name, struct loclist *vals)
|
|
{
|
|
struct loclist *p;
|
|
char buf[200];
|
|
int i;
|
|
|
|
for (i = 0, p = vals; p; i++, p = p->ll_next) {
|
|
snprintf(buf, sizeof(buf), "%s%c%d", name, ARRCHR, i);
|
|
p->ll_name = i == 0 ? name : intern(buf);
|
|
}
|
|
return vals;
|
|
}
|
|
|