xref: /src/usr.bin/config/gram.y

%{
/*	$NetBSD: gram.y,v 1.31 2012/03/11 07:27:02 dholland 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/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 */


/*
 * 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

/*
 * The allocation wrappers themselves
 */
#define DECL_ALLOCWRAP(t)	static struct t *wrap_mk_##t(struct t *arg)

DECL_ALLOCWRAP(nvlist);

/*
 * Macros for allocating new objects
 */

#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_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)

#define	fx_atom(s)	new0(s, NULL, NULL, FX_ATOM, NULL)
#define	fx_not(e)	new0(NULL, NULL, NULL, FX_NOT, e)
#define	fx_and(e1, e2)	new0(NULL, NULL, e1, FX_AND, e2)
#define	fx_or(e1, e2)	new0(NULL, NULL, e1, FX_OR, e2)

/*
 * Other private functions
 */

static	void	setmachine(const char *, const char *, struct nvlist *, int);
static	void	check_maxpart(void);

static	void	app(struct nvlist *, struct nvlist *);

static	struct nvlist *mk_nsis(const char *, int, struct nvlist *, int);
static	struct nvlist *mk_ns(const char *, struct nvlist *);

%}

%union {
	struct	attr *attr;
	struct	devbase *devb;
	struct	deva *deva;
	struct	nvlist *list;
	const char *str;
	struct	numconst num;
	int64_t	val;
}

%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
%token	XOBJECT OBSOLETE ON OPTIONS
%token	PACKAGE PLUSEQ PREFIX PSEUDO_DEVICE PSEUDO_ROOT
%token	ROOT
%token	SINGLE SOURCE
%token	TYPE
%token	VECTOR VERSION
%token	WITH
%token	<num> NUMBER
%token	<str> PATHNAME QSTRING WORD EMPTYSTRING
%token	ENDDEFS

%type	<list>	fopts fexpr fatom
%type	<list>	f_or_expr f_and_expr f_prefix_expr f_base_expr
%type	<str>	fs_spec
%type	<val>	fflgs fflag oflgs oflag
%type	<str>	rule
%type	<attr>	attr
%type	<devb>	devbase
%type	<deva>	devattach_opt
%type	<list>	atlist interface_opt
%type	<str>	atname
%type	<list>	loclist locdef
%type	<str>	locdefault
%type	<list>	values locdefaults
%type	<list>	attrs_opt attrs
%type	<list>	locators locator
%type	<list>	dev_spec
%type	<str>	device_instance
%type	<str>	attachment
%type	<str>	value
%type	<val>	major_minor npseudo
%type	<num>	signed_number
%type	<val>	device_flags
%type	<str>	deffs
%type	<list>	deffses
%type	<list>	defopt
%type	<list>	defopts
%type	<str>	optdep
%type	<list>	optdeps
%type	<list>	defoptdeps
%type	<str>	optfile_opt
%type	<list>	subarches
%type	<str>	filename stringvalue locname mkvarname
%type	<val>	device_major_block device_major_char
%type	<list>	devnodes devnodetype devnodeflags devnode_dims

%%

/*
 * A complete configuration consists of both the configuration 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 configuration_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); }
;

/************************************************************/

/*
 * 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:
	  file
	| object
	| device_major			{ do_devsw = 1; }
	| prefix
	| DEVCLASS WORD			{ (void)defattr($2, NULL, NULL, 1); }
	| DEFFS deffses defoptdeps	{ deffilesystem($2, $3); }
	| DEFINE WORD interface_opt attrs_opt
					{ (void)defattr($2, $3, $4, 0); }
	| DEFOPT optfile_opt defopts defoptdeps
					{ defoption($2, $3, $4); }
	| DEFFLAG optfile_opt defopts defoptdeps
					{ defflag($2, $3, $4, 0); }
	| OBSOLETE DEFFLAG optfile_opt defopts
					{ defflag($3, $4, NULL, 1); }
	| DEFPARAM optfile_opt defopts defoptdeps
					{ defparam($2, $3, $4, 0); }
	| OBSOLETE DEFPARAM optfile_opt defopts
					{ defparam($3, $4, NULL, 1); }
	| DEVICE devbase interface_opt attrs_opt
					{ defdev($2, $3, $4, 0); }
	| ATTACH devbase AT atlist devattach_opt attrs_opt
					{ defdevattach($5, $2, $4, $6); }
	| MAXPARTITIONS NUMBER		{ maxpartitions = $2.val; }
	| MAXUSERS NUMBER NUMBER NUMBER
				    { setdefmaxusers($2.val, $3.val, $4.val); }
	| MAKEOPTIONS condmkopt_list
	/* interface_opt in DEFPSEUDO is for backwards compatibility */
	| DEFPSEUDO devbase interface_opt attrs_opt
					{ defdev($2, $3, $4, 1); }
	| DEFPSEUDODEV devbase interface_opt attrs_opt
					{ defdev($2, $3, $4, 2); }
	| MAJOR '{' majorlist '}'
	| VERSION NUMBER		{ setversion($2.val); }
;

/* source file: file foo/bar.c bar|baz needs-flag compile-with blah */
file:
	XFILE filename fopts fflgs rule	{ addfile($2, $3, $4, $5); }
;

/* file options: optional expression of config elements */
fopts:
	  /* empty */			{ $$ = NULL; }
	| fexpr				{ $$ = $1; }
;

/* zero or more flags for a file */
fflgs:
	  /* empty */			{ $$ = 0; }
	| fflgs 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; }
;

/* object file: object zot.o foo|zot needs-flag */
object:
	XOBJECT filename fopts oflgs	{ addobject($2, $3, $4); }
;

/* zero or more flags for an object file */
oflgs:
	  /* empty */			{ $$ = 0; }
	| oflgs oflag			{ $$ = $1 | $2; }
;

/* a single flag for an object file */
oflag:
	NEEDS_FLAG			{ $$ = OI_NEEDSFLAG; }
;

/* device major declaration */
device_major:
	DEVICE_MAJOR WORD device_major_char device_major_block fopts devnodes
					{ adddevm($2, $3, $4, $5, $6); }
;

/* char 55 */
device_major_char:
	  /* empty */			{ $$ = -1; }
	| CHAR NUMBER			{ $$ = $2.val; }
;

/* block 33 */
device_major_block:
	  /* empty */			{ $$ = -1; }
	| BLOCK NUMBER			{ $$ = $2.val; }
;

/* 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");}
;

/* prefix delimiter */
prefix:
	  PREFIX filename		{ prefix_push($2); }
	| PREFIX			{ prefix_pop(); }
;

/* 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; }
	| '{' '}'			{ $$ = new_nx("", NULL); }
	| '{' loclist '}'		{ $$ = new_nx("", $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 		{ $$ = new_nsi($1, $2, 0); }
	| locname			{ $$ = new_nsi($1, NULL, 0); }
	| '[' locname locdefault ']'	{ $$ = new_nsi($2, $3, 1); }
	| locname '[' NUMBER ']'	{ $$ = mk_nsis($1, $3.val, NULL, 0); }
	| locname '[' NUMBER ']' locdefaults
					{ $$ = mk_nsis($1, $3.val, $5, 0); }
	| '[' locname '[' NUMBER ']' locdefaults ']'
					{ $$ = mk_nsis($2, $4.val, $6, 1); }
;

/* locator name */
locname:
	  WORD				{ $$ = $1; }
	| QSTRING			{ $$ = $1; }
;

/* locator default value */
locdefault:
	'=' value			{ $$ = $2; }
;

/* multiple locator default values */
locdefaults:
	'=' '{' values '}'		{ $$ = $3; }
;

/* optional attributes */
attrs_opt:
	  /* empty */			{ $$ = NULL; }
	| ':' attrs			{ $$ = $2; }
;

/* one or more attributes */
attrs:
	  attr				{ $$ = new_p($1); }
	| attrs ',' attr		{ $$ = new_px($3, $1); }
;

/* one attribute */
attr:
	WORD				{ $$ = getattr($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		{ $$ = nvcat($2, $1); }
;

/* one defined option */
defopt:
	  WORD				{ $$ = new_n($1); }
	| WORD '=' value		{ $$ = new_ns($1, $3); }
	| WORD COLONEQ value		{
		struct nvlist *__nv = new_n($1);

		$$ = new_nsx("", $3, __nv);
	  }
	| WORD '=' value COLONEQ value	{
		struct nvlist *__nv = new_n($1);

		$$ = new_nsx("", $5, __nv);
	  }
;

/* option dependencies (read as "defopt deps") which are optional */
defoptdeps:
	  /* empty */			{ $$ = NULL; }
	| ':' optdeps			{ $$ = $2; }
;

/* a list of option dependencies */
optdeps:
	  optdep			{ $$ = new_n($1); }
	| optdeps ',' optdep		{ $$ = new_nx($3, $1); }
;

/* one option dependence */
optdep:
	WORD				{ $$ = $1; }
;

/* list of conditional makeoptions */
condmkopt_list:
	  condmkoption
	| condmkopt_list ',' condmkoption
;

/* one conditional make option */
condmkoption:
	fexpr 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 '=' NUMBER		{ setmajor($1, $3.val); }
;

/************************************************************/

/*
 * The configuration grammar.
 */

/* Complete configuration part: all std.* files plus selected config. */
configuration_part:
	config_items
;

/* Zero or more config items. Trap errors. */
config_items:
	  /* empty */
	| config_items '\n'
	| config_items config_item '\n'	{ wrap_continue(); }
	| config_items error '\n'	{ wrap_cleanup(); }
;

/* One config item. */
config_item:
	  definition
	| NO FILE_SYSTEM no_fs_list
	| FILE_SYSTEM fs_list
	| NO MAKEOPTIONS no_mkopt_list
	| MAKEOPTIONS mkopt_list
	| NO OPTIONS no_opt_list
	| OPTIONS opt_list
	| MAXUSERS NUMBER		{ setmaxusers($2.val); }
	| IDENT stringvalue		{ setident($2); }
	| CONFIG conf root_spec sysparam_list
					{ addconf(&conf); }
	| NO CONFIG WORD		{ delconf($3); }
	| NO PSEUDO_DEVICE WORD		{ delpseudo($3); }
	| PSEUDO_DEVICE WORD npseudo	{ addpseudo($2, $3); }
	| PSEUDO_ROOT device_instance	{ addpseudoroot($2); }
	| NO device_instance AT attachment
					{ deldevi($2, $4); }
	| NO DEVICE AT attachment	{ deldeva($4); }
	| NO device_instance		{ deldev($2); }
	| 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); }
;

/* 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); }
;

/* 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); }
;

/* 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_si(intern("?"), NODEV); }
	| WORD				{ $$ = new_si($1, NODEV); }
	| major_minor			{ $$ = new_si(NULL, $1); }
;

/* major and minor device number */
major_minor:
	MAJOR NUMBER MINOR NUMBER	{ $$ = 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; }
	| NUMBER			{ $$ = $1.val; }
;

/* 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 '?'			{ $$ = new_ns($1, NULL); }
	| WORD values			{ $$ = mk_ns($1, $2); }
;

/* optional device flags */
device_flags:
	  /* empty */			{ $$ = 0; }
	| FLAGS NUMBER			{ $$ = $2.val; }
;

/************************************************************/

/*
 * dependency logic
 */


/*
 * order of options is important, must use right recursion
 *
 * dholland 20120310: wut?
 */

/* expression of config elements */
fexpr:
	f_or_expr
;

f_or_expr:
	  f_and_expr
	| f_or_expr '|' f_and_expr	{ $$ = fx_or($1, $3); }
;

f_and_expr:
	  f_prefix_expr
	| f_and_expr '&' f_prefix_expr	{ $$ = fx_and($1, $3); }
;

f_prefix_expr:
	  f_base_expr
/* XXX notyet - need to strengthen downstream first */
/*	| '!' f_prefix_expr		{ $$ = fx_not($2); } */
;

f_base_expr:
	  fatom				{ $$ = $1; }
	| '!' fatom			{ $$ = fx_not($2); }
	| '(' fexpr ')'			{ $$ = $2; }
;

/* basic element of config element expression: a config element */
fatom:
	WORD				{ $$ = fx_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				{ $$ = new_s($1); }
	| value ',' values		{ $$ = new_sx($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;

	for (i=0; i<wrap_depth; i++) {
		switch (wrapstack[i].typecode) {
		    case WRAP_CODE_nvlist:
			nvfree(wrapstack[i].ptr);
			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);

/************************************************************/

static void
setmachine(const char *mch, const char *mcharch, struct nvlist *mchsubarches,
	int isioconf)
{
	char buf[MAXPATHLEN];
	struct nvlist *nv;

	if (isioconf) {
		fprintf(stderr, "WARNING: ioconf is an experimental feature\n");
		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.");
}

static void
app(struct nvlist *p, struct nvlist *q)
{
	while (p->nv_next)
		p = p->nv_next;
	p->nv_next = q;
}

static struct nvlist *
mk_nsis(const char *name, int count, struct nvlist *adefs, int opt)
{
	struct nvlist *defs = adefs;
	struct nvlist **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 = new_s("0");
		snprintf(buf, sizeof(buf), "%s%c%d", name, ARRCHR, i);
		(*p)->nv_name = i == 0 ? name : intern(buf);
		(*p)->nv_num = i > 0 || opt;
		p = &(*p)->nv_next;
	}
	*p = 0;
	return defs;
}


static struct nvlist *
mk_ns(const char *name, struct nvlist *vals)
{
	struct nvlist *p;
	char buf[200];
	int i;

	for(i = 0, p = vals; p; i++, p = p->nv_next) {
		snprintf(buf, sizeof(buf), "%s%c%d", name, ARRCHR, i);
		p->nv_name = i == 0 ? name : intern(buf);
	}
	return vals;
}