%{

/*	$OpenBSD: gram.y,v 1.24 2015/01/16 06:40:16 deraadt Exp $	*/

/*	$NetBSD: gram.y,v 1.14 1997/02/02 21:12:32 thorpej 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/param.h>	/* NODEV */

#include <sys/types.h>

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

#include <string.h>

#include <errno.h>

#include "config.h"

#include "sem.h"

#define	FORMAT(n) ((n) > -10 && (n) < 10 ? "%d" : "0x%x")

#define	stop(s)	error(s), exit(1)

int	include(const char *, int);

void	yyerror(const char *);

int	yylex(void);

static	struct	config conf;	/* at most one active at a time */

/* the following is used to recover nvlist space after errors */

static	struct	nvlist *alloc[1000];

static	int	adepth;

#define	new0(n,s,p,i,x)	(alloc[adepth++] = 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	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)

static	void	cleanup(void);

static	void	setmachine(const char *, const char *);

static	void	check_maxpart(void);

%}

%union {

	struct	attr *attr;

	struct	devbase *devb;

	struct	deva *deva;

	struct	nvlist *list;

	const char *str;

	int	val;

}

%token	AND AT ATTACH BUILD COMPILE_WITH CONFIG DEFINE DEFOPT

%token	DEVICE DISABLE

%token	DUMPS ENDFILE XFILE XOBJECT FLAGS INCLUDE XMACHINE MAJOR MAKEOPTIONS

%token	MAXUSERS MAXPARTITIONS MINOR ON OPTIONS PSEUDO_DEVICE ROOT SOURCE SWAP

%token	WITH NEEDS_COUNT NEEDS_FLAG RMOPTIONS ENABLE

%token	<val> NUMBER

%token	<str> PATHNAME WORD EMPTY

%left '|'

%left '&'

%type	<list>	pathnames

%type	<list>	fopts fexpr fatom

%type	<val>	fflgs fflag oflgs oflag

%type	<str>	rule

%type	<attr>	attr

%type	<devb>	devbase

%type	<deva>	devattach_opt

%type	<val>	disable

%type	<list>	atlist interface_opt

%type	<str>	atname

%type	<list>	loclist_opt loclist locdef

%type	<str>	locdefault

%type	<list>	attrs_opt attrs

%type	<list>	locators locator

%type	<list>	swapdev_list dev_spec

%type	<str>	device_instance

%type	<str>	attachment

%type	<str>	value

%type	<val>	major_minor signed_number npseudo

%type	<val>	flags_opt

%%

/*

 * A configuration consists of a machine type, followed by the machine

 * definition files (via the include() mechanism), followed by the

 * configuration specification(s) proper.  In effect, this is two

 * separate grammars, with some shared terminals and nonterminals.

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

 */

Configuration:

	topthings			/* dirspecs, include "std.arch" */

	machine_spec			/* "machine foo" from machine descr. */

	dev_defs dev_eof		/* sys/conf/files */

	dev_defs dev_eof		/* sys/arch/${MACHINE_ARCH}/... */

	dev_defs dev_eof		/* sys/arch/${MACHINE}/... */

					{ check_maxpart(); }

	specs;				/* rest of machine description */

topthings:

	topthings topthing |

	/* empty */;

topthing:

	SOURCE PATHNAME '\n'		{ if (!srcdir) srcdir = $2; } |

	BUILD  PATHNAME '\n'		{ if (!builddir) builddir = $2; } |

	include '\n' |

	'\n';

machine_spec:

	XMACHINE WORD '\n'		{ setmachine($2,NULL); } |

	XMACHINE WORD WORD '\n'		{ setmachine($2,$3); } |

	error { stop("cannot proceed without machine specifier"); };

dev_eof:

	ENDFILE				{ enddefs(); checkfiles(); };

pathnames:

	PATHNAME			{ $$ = new_nsi($1, NULL, 0); } |

	pathnames '|' PATHNAME		{ ($$ = $1)->nv_next = new_nsi($3, NULL, 0); };

/*

 * Various nonterminals shared between the grammars.

 */

file:

	XFILE pathnames fopts fflgs rule { addfile($2, $3, $4, $5); };

object:

	XOBJECT PATHNAME fopts oflgs	{ addobject($2, $3, $4); };

/* order of options is important, must use right recursion */

fopts:

	fexpr				{ $$ = $1; } |

	/* empty */			{ $$ = NULL; };

fexpr:

	fatom				{ $$ = $1; } |

	'!' fatom			{ $$ = fx_not($2); } |

	fexpr '&' fexpr			{ $$ = fx_and($1, $3); } |

	fexpr '|' fexpr			{ $$ = fx_or($1, $3); } |

	'(' fexpr ')'			{ $$ = $2; };

fatom:

	WORD				{ $$ = fx_atom($1); };

fflgs:

	fflgs fflag			{ $$ = $1 | $2; } |

	/* empty */			{ $$ = 0; };

fflag:

	NEEDS_COUNT			{ $$ = FI_NEEDSCOUNT; } |

	NEEDS_FLAG			{ $$ = FI_NEEDSFLAG; };

oflgs:

	oflgs oflag			{ $$ = $1 | $2; } |

	/* empty */			{ $$ = 0; };

oflag:

	NEEDS_FLAG			{ $$ = OI_NEEDSFLAG; };

rule:

	COMPILE_WITH WORD		{ $$ = $2; } |

	/* empty */			{ $$ = NULL; };

include:

	INCLUDE WORD			{ include($2, 0); };

/*

 * The machine definitions grammar.

 */

dev_defs:

	dev_defs dev_def |

	/* empty */;

dev_def:

	one_def '\n'			{ adepth = 0; } |

	'\n' |

	error '\n'			{ cleanup(); };

one_def:

	file |

	object |

	include |

	DEFINE WORD interface_opt	{ (void)defattr($2, $3); } |

	DEFOPT WORD			{ defoption($2); } |

	DEVICE devbase interface_opt attrs_opt

					{ defdev($2, 0, $3, $4); } |

	ATTACH devbase AT atlist devattach_opt attrs_opt

					{ defdevattach($5, $2, $4, $6); } |

	MAXUSERS NUMBER NUMBER NUMBER	{ setdefmaxusers($2, $3, $4); } |

	MAXPARTITIONS NUMBER		{ maxpartitions = $2; } |

	PSEUDO_DEVICE devbase attrs_opt { defdev($2,1,NULL,$3); } |

	MAJOR '{' majorlist '}';

disable:

	DISABLE				{ $$ = 1; } |

	/* empty */			{ $$ = 0; };

atlist:

	atlist ',' atname		{ $$ = new_nx($3, $1); } |

	atname				{ $$ = new_n($1); };

atname:

	WORD				{ $$ = $1; } |

	ROOT				{ $$ = NULL; };

devbase:

	WORD				{ $$ = getdevbase((char *)$1); };

devattach_opt:

	WITH WORD			{ $$ = getdevattach($2); } |

	/* empty */			{ $$ = NULL; };

interface_opt:

	'{' loclist_opt '}'		{ $$ = new_nx("", $2); } |

	/* empty */			{ $$ = NULL; };

loclist_opt:

	loclist				{ $$ = $1; } |

	/* empty */			{ $$ = NULL; };

/* loclist order matters, must use right recursion */

loclist:

	locdef ',' loclist		{ ($$ = $1)->nv_next = $3; } |

	locdef				{ $$ = $1; };

/* "[ WORD locdefault ]" syntax may be unnecessary... */

locdef:

	WORD locdefault			{ $$ = new_nsi($1, $2, 0); } |

	WORD				{ $$ = new_nsi($1, NULL, 0); } |

	'[' WORD locdefault ']'		{ $$ = new_nsi($2, $3, 1); };

locdefault:

	'=' value			{ $$ = $2; };

value:

	WORD				{ $$ = $1; } |

	EMPTY				{ $$ = $1; } |

	signed_number			{

						char bf[40];

						(void)snprintf(bf, sizeof bf,

						    FORMAT($1), $1);

						$$ = intern(bf);

					};

signed_number:

	NUMBER				{ $$ = $1; } |

	'-' NUMBER			{ $$ = -$2; };

attrs_opt:

	':' attrs			{ $$ = $2; } |

	/* empty */			{ $$ = NULL; };

attrs:

	attrs ',' attr			{ $$ = new_px($3, $1); } |

	attr				{ $$ = new_p($1); };

attr:

	WORD				{ $$ = getattr($1); };

majorlist:

	majorlist ',' majordef |

	majordef;

majordef:

	devbase '=' NUMBER		{ setmajor($1, $3); };

/*

 * The configuration grammar.

 */

specs:

	specs spec |

	/* empty */;

spec:

	config_spec '\n'		{ adepth = 0; } |

	'\n' |

	error '\n'			{ cleanup(); };

config_spec:

	file |

	object |

	include |

	OPTIONS opt_list |

	RMOPTIONS ropt_list |

	MAKEOPTIONS mkopt_list |

	MAXUSERS NUMBER			{ setmaxusers($2); } |

	CONFIG conf sysparam_list	{ addconf(&conf); } |

	PSEUDO_DEVICE WORD npseudo disable { addpseudo($2, $3, $4); } |

	device_instance AT attachment ENABLE { enabledev($1, $3); } |

	device_instance AT attachment disable locators flags_opt

					{ adddev($1, $3, $5, $6, $4); };

mkopt_list:

	mkopt_list ',' mkoption |

	mkoption;

mkoption:

	WORD '=' value			{ addmkoption($1, $3); }

opt_list:

	opt_list ',' option |

	option;

ropt_list:

	ropt_list ',' WORD { removeoption($3); } |

	WORD { removeoption($1); };

option:

	WORD				{ addoption($1, NULL); } |

	WORD '=' value			{ addoption($1, $3); };

conf:

	WORD				{ conf.cf_name = $1;

					    conf.cf_lineno = currentline();

					    conf.cf_root = NULL;

					    conf.cf_swap = NULL;

					    conf.cf_dump = NULL; };

sysparam_list:

	sysparam_list sysparam |

	sysparam;

sysparam:

	ROOT on_opt dev_spec	 { setconf(&conf.cf_root, "root", $3); } |

	SWAP on_opt swapdev_list { setconf(&conf.cf_swap, "swap", $3); } |

	DUMPS on_opt dev_spec	 { setconf(&conf.cf_dump, "dumps", $3); };

swapdev_list:

	dev_spec AND swapdev_list	{ ($$ = $1)->nv_next = $3; } |

	dev_spec			{ $$ = $1; };

dev_spec:

	WORD				{ $$ = new_si($1, NODEV); } |

	major_minor			{ $$ = new_si(NULL, $1); };

major_minor:

	MAJOR NUMBER MINOR NUMBER	{ $$ = makedev($2, $4); };

on_opt:

	ON | /* empty */;

npseudo:

	NUMBER				{ $$ = $1; } |

	/* empty */			{ $$ = 1; };

device_instance:

	WORD '*'			{ $$ = starref($1); } |

	WORD				{ $$ = $1; };

attachment:

	ROOT				{ $$ = NULL; } |

	WORD '?'			{ $$ = wildref($1); } |

	WORD				{ $$ = $1; };

locators:

	locators locator		{ ($$ = $2)->nv_next = $1; } |

	/* empty */			{ $$ = NULL; };

locator:

	WORD value			{ $$ = new_ns($1, $2); } |

	WORD '?'			{ $$ = new_ns($1, NULL); };

flags_opt:

	FLAGS NUMBER			{ $$ = $2; } |

	/* empty */			{ $$ = 0; };

%%

void

yyerror(const char *s)

{

}

/*

 * Cleanup procedure after syntax error: release any nvlists

 * allocated during parsing the current line.

 */

static void

cleanup(void)

{

	struct nvlist **np;

	int i;

}

static void

setmachine(const char *mch, const char *mcharch)

{

		    machinearch, machinearch);

	else

}

static void

check_maxpart(void)

{

	}

}