[linux-block.git] / scripts / dtc / dtc-parser.y

/*
 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *                                                                   USA
 */
%{
#include <stdio.h>
#include <inttypes.h>

#include "dtc.h"
#include "srcpos.h"

extern int yylex(void);
extern void yyerror(char const *s);
#define ERROR(loc, ...) \
	do { \
		srcpos_error((loc), "Error", __VA_ARGS__); \
		treesource_error = true; \
	} while (0)

extern struct dt_info *parser_output;
extern bool treesource_error;
%}

%union {
	char *propnodename;
	char *labelref;
	uint8_t byte;
	struct data data;

	struct {
		struct data	data;
		int		bits;
	} array;

	struct property *prop;
	struct property *proplist;
	struct node *node;
	struct node *nodelist;
	struct reserve_info *re;
	uint64_t integer;
	unsigned int flags;
}

%token DT_V1
%token DT_PLUGIN
%token DT_MEMRESERVE
%token DT_LSHIFT DT_RSHIFT DT_LE DT_GE DT_EQ DT_NE DT_AND DT_OR
%token DT_BITS
%token DT_DEL_PROP
%token DT_DEL_NODE
%token DT_OMIT_NO_REF
%token <propnodename> DT_PROPNODENAME
%token <integer> DT_LITERAL
%token <integer> DT_CHAR_LITERAL
%token <byte> DT_BYTE
%token <data> DT_STRING
%token <labelref> DT_LABEL
%token <labelref> DT_REF
%token DT_INCBIN

%type <data> propdata
%type <data> propdataprefix
%type <flags> header
%type <flags> headers
%type <re> memreserve
%type <re> memreserves
%type <array> arrayprefix
%type <data> bytestring
%type <prop> propdef
%type <proplist> proplist

%type <node> devicetree
%type <node> nodedef
%type <node> subnode
%type <nodelist> subnodes

%type <integer> integer_prim
%type <integer> integer_unary
%type <integer> integer_mul
%type <integer> integer_add
%type <integer> integer_shift
%type <integer> integer_rela
%type <integer> integer_eq
%type <integer> integer_bitand
%type <integer> integer_bitxor
%type <integer> integer_bitor
%type <integer> integer_and
%type <integer> integer_or
%type <integer> integer_trinary
%type <integer> integer_expr

%%

sourcefile:
	  headers memreserves devicetree
		{
			parser_output = build_dt_info($1, $2, $3,
			                              guess_boot_cpuid($3));
		}
	;

header:
	  DT_V1 ';'
		{
			$$ = DTSF_V1;
		}
	| DT_V1 ';' DT_PLUGIN ';'
		{
			$$ = DTSF_V1 | DTSF_PLUGIN;
		}
	;

headers:
	  header
	| header headers
		{
			if ($2 != $1)
				ERROR(&@2, "Header flags don't match earlier ones");
			$$ = $1;
		}
	;

memreserves:
	  /* empty */
		{
			$$ = NULL;
		}
	| memreserve memreserves
		{
			$$ = chain_reserve_entry($1, $2);
		}
	;

memreserve:
	  DT_MEMRESERVE integer_prim integer_prim ';'
		{
			$$ = build_reserve_entry($2, $3);
		}
	| DT_LABEL memreserve
		{
			add_label(&$2->labels, $1);
			$$ = $2;
		}
	;

devicetree:
	  '/' nodedef
		{
			$$ = name_node($2, "");
		}
	| devicetree '/' nodedef
		{
			$$ = merge_nodes($1, $3);
		}
	| DT_REF nodedef
		{
			/*
			 * We rely on the rule being always:
			 *   versioninfo plugindecl memreserves devicetree
			 * so $-1 is what we want (plugindecl)
			 */
			if (!($<flags>-1 & DTSF_PLUGIN))
				ERROR(&@2, "Label or path %s not found", $1);
			$$ = add_orphan_node(name_node(build_node(NULL, NULL), ""), $2, $1);
		}
	| devicetree DT_LABEL DT_REF nodedef
		{
			struct node *target = get_node_by_ref($1, $3);

			if (target) {
				add_label(&target->labels, $2);
				merge_nodes(target, $4);
			} else
				ERROR(&@3, "Label or path %s not found", $3);
			$$ = $1;
		}
	| devicetree DT_REF nodedef
		{
			/*
			 * We rely on the rule being always:
			 *   versioninfo plugindecl memreserves devicetree
			 * so $-1 is what we want (plugindecl)
			 */
			if ($<flags>-1 & DTSF_PLUGIN) {
				add_orphan_node($1, $3, $2);
			} else {
				struct node *target = get_node_by_ref($1, $2);

				if (target)
					merge_nodes(target, $3);
				else
					ERROR(&@2, "Label or path %s not found", $2);
			}
			$$ = $1;
		}
	| devicetree DT_DEL_NODE DT_REF ';'
		{
			struct node *target = get_node_by_ref($1, $3);

			if (target)
				delete_node(target);
			else
				ERROR(&@3, "Label or path %s not found", $3);


			$$ = $1;
		}
	| devicetree DT_OMIT_NO_REF DT_REF ';'
		{
			struct node *target = get_node_by_ref($1, $3);

			if (target)
				omit_node_if_unused(target);
			else
				ERROR(&@3, "Label or path %s not found", $3);


			$$ = $1;
		}
	;

nodedef:
	  '{' proplist subnodes '}' ';'
		{
			$$ = build_node($2, $3);
		}
	;

proplist:
	  /* empty */
		{
			$$ = NULL;
		}
	| proplist propdef
		{
			$$ = chain_property($2, $1);
		}
	;

propdef:
	  DT_PROPNODENAME '=' propdata ';'
		{
			$$ = build_property($1, $3);
		}
	| DT_PROPNODENAME ';'
		{
			$$ = build_property($1, empty_data);
		}
	| DT_DEL_PROP DT_PROPNODENAME ';'
		{
			$$ = build_property_delete($2);
		}
	| DT_LABEL propdef
		{
			add_label(&$2->labels, $1);
			$$ = $2;
		}
	;

propdata:
	  propdataprefix DT_STRING
		{
			$$ = data_merge($1, $2);
		}
	| propdataprefix arrayprefix '>'
		{
			$$ = data_merge($1, $2.data);
		}
	| propdataprefix '[' bytestring ']'
		{
			$$ = data_merge($1, $3);
		}
	| propdataprefix DT_REF
		{
			$1 = data_add_marker($1, TYPE_STRING, $2);
			$$ = data_add_marker($1, REF_PATH, $2);
		}
	| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
		{
			FILE *f = srcfile_relative_open($4.val, NULL);
			struct data d;

			if ($6 != 0)
				if (fseek(f, $6, SEEK_SET) != 0)
					die("Couldn't seek to offset %llu in \"%s\": %s",
					    (unsigned long long)$6, $4.val,
					    strerror(errno));

			d = data_copy_file(f, $8);

			$$ = data_merge($1, d);
			fclose(f);
		}
	| propdataprefix DT_INCBIN '(' DT_STRING ')'
		{
			FILE *f = srcfile_relative_open($4.val, NULL);
			struct data d = empty_data;

			d = data_copy_file(f, -1);

			$$ = data_merge($1, d);
			fclose(f);
		}
	| propdata DT_LABEL
		{
			$$ = data_add_marker($1, LABEL, $2);
		}
	;

propdataprefix:
	  /* empty */
		{
			$$ = empty_data;
		}
	| propdata ','
		{
			$$ = $1;
		}
	| propdataprefix DT_LABEL
		{
			$$ = data_add_marker($1, LABEL, $2);
		}
	;

arrayprefix:
	DT_BITS DT_LITERAL '<'
		{
			unsigned long long bits;
			enum markertype type = TYPE_UINT32;

			bits = $2;

			switch (bits) {
			case 8: type = TYPE_UINT8; break;
			case 16: type = TYPE_UINT16; break;
			case 32: type = TYPE_UINT32; break;
			case 64: type = TYPE_UINT64; break;
			default:
				ERROR(&@2, "Array elements must be"
				      " 8, 16, 32 or 64-bits");
				bits = 32;
			}

			$$.data = data_add_marker(empty_data, type, NULL);
			$$.bits = bits;
		}
	| '<'
		{
			$$.data = data_add_marker(empty_data, TYPE_UINT32, NULL);
			$$.bits = 32;
		}
	| arrayprefix integer_prim
		{
			if ($1.bits < 64) {
				uint64_t mask = (1ULL << $1.bits) - 1;
				/*
				 * Bits above mask must either be all zero
				 * (positive within range of mask) or all one
				 * (negative and sign-extended). The second
				 * condition is true if when we set all bits
				 * within the mask to one (i.e. | in the
				 * mask), all bits are one.
				 */
				if (($2 > mask) && (($2 | mask) != -1ULL))
					ERROR(&@2, "Value out of range for"
					      " %d-bit array element", $1.bits);
			}

			$$.data = data_append_integer($1.data, $2, $1.bits);
		}
	| arrayprefix DT_REF
		{
			uint64_t val = ~0ULL >> (64 - $1.bits);

			if ($1.bits == 32)
				$1.data = data_add_marker($1.data,
							  REF_PHANDLE,
							  $2);
			else
				ERROR(&@2, "References are only allowed in "
					    "arrays with 32-bit elements.");

			$$.data = data_append_integer($1.data, val, $1.bits);
		}
	| arrayprefix DT_LABEL
		{
			$$.data = data_add_marker($1.data, LABEL, $2);
		}
	;

integer_prim:
	  DT_LITERAL
	| DT_CHAR_LITERAL
	| '(' integer_expr ')'
		{
			$$ = $2;
		}
	;

integer_expr:
	integer_trinary
	;

integer_trinary:
	  integer_or
	| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
	;

integer_or:
	  integer_and
	| integer_or DT_OR integer_and { $$ = $1 || $3; }
	;

integer_and:
	  integer_bitor
	| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
	;

integer_bitor:
	  integer_bitxor
	| integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
	;

integer_bitxor:
	  integer_bitand
	| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
	;

integer_bitand:
	  integer_eq
	| integer_bitand '&' integer_eq { $$ = $1 & $3; }
	;

integer_eq:
	  integer_rela
	| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
	| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
	;

integer_rela:
	  integer_shift
	| integer_rela '<' integer_shift { $$ = $1 < $3; }
	| integer_rela '>' integer_shift { $$ = $1 > $3; }
	| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
	| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
	;

integer_shift:
	  integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
	| integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
	| integer_add
	;

integer_add:
	  integer_add '+' integer_mul { $$ = $1 + $3; }
	| integer_add '-' integer_mul { $$ = $1 - $3; }
	| integer_mul
	;

integer_mul:
	  integer_mul '*' integer_unary { $$ = $1 * $3; }
	| integer_mul '/' integer_unary
		{
			if ($3 != 0) {
				$$ = $1 / $3;
			} else {
				ERROR(&@$, "Division by zero");
				$$ = 0;
			}
		}
	| integer_mul '%' integer_unary
		{
			if ($3 != 0) {
				$$ = $1 % $3;
			} else {
				ERROR(&@$, "Division by zero");
				$$ = 0;
			}
		}
	| integer_unary
	;

integer_unary:
	  integer_prim
	| '-' integer_unary { $$ = -$2; }
	| '~' integer_unary { $$ = ~$2; }
	| '!' integer_unary { $$ = !$2; }
	;

bytestring:
	  /* empty */
		{
			$$ = data_add_marker(empty_data, TYPE_UINT8, NULL);
		}
	| bytestring DT_BYTE
		{
			$$ = data_append_byte($1, $2);
		}
	| bytestring DT_LABEL
		{
			$$ = data_add_marker($1, LABEL, $2);
		}
	;

subnodes:
	  /* empty */
		{
			$$ = NULL;
		}
	| subnode subnodes
		{
			$$ = chain_node($1, $2);
		}
	| subnode propdef
		{
			ERROR(&@2, "Properties must precede subnodes");
			YYERROR;
		}
	;

subnode:
	  DT_PROPNODENAME nodedef
		{
			$$ = name_node($2, $1);
		}
	| DT_DEL_NODE DT_PROPNODENAME ';'
		{
			$$ = name_node(build_node_delete(), $2);
		}
	| DT_OMIT_NO_REF subnode
		{
			$$ = omit_node_if_unused($2);
		}
	| DT_LABEL subnode
		{
			add_label(&$2->labels, $1);
			$$ = $2;
		}
	;

%%

void yyerror(char const *s)
{
	ERROR(&yylloc, "%s", s);
}
Commit	Line	Data
a4da2e3e DG	1	/*
	2	* (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005.
	3	*
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation; either version 2 of the
	8	* License, or (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	18	* USA
	19	*/
a4da2e3e	20	%{
ed95d745	21	#include <stdio.h>
6f05afcb	22	#include <inttypes.h>
ed95d745	23
a4da2e3e DG	24	#include "dtc.h"
	25	#include "srcpos.h"
	26
ed95d745	27	extern int yylex(void);
658f29a5	28	extern void yyerror(char const *s);
47605971 RH	29	#define ERROR(loc, ...) \
	30	do { \
	31	srcpos_error((loc), "Error", __VA_ARGS__); \
	32	treesource_error = true; \
	33	} while (0)
a4da2e3e	34
6f05afcb	35	extern struct dt_info *parser_output;
47605971	36	extern bool treesource_error;
a4da2e3e DG	37	%}
	38
	39	%union {
	40	char *propnodename;
a4da2e3e	41	char *labelref;
ed95d745	42	uint8_t byte;
a4da2e3e DG	43	struct data data;
a4da2e3e DG	44
cd296721 SW	45	struct {
	46	struct data data;
	47	int bits;
	48	} array;
	49
a4da2e3e DG	50	struct property *prop;
	51	struct property *proplist;
	52	struct node *node;
	53	struct node *nodelist;
	54	struct reserve_info *re;
cd296721	55	uint64_t integer;
6f05afcb	56	unsigned int flags;
a4da2e3e DG	57	}
	58
	59	%token DT_V1
6f05afcb	60	%token DT_PLUGIN
a4da2e3e	61	%token DT_MEMRESERVE
cd296721 SW	62	%token DT_LSHIFT DT_RSHIFT DT_LE DT_GE DT_EQ DT_NE DT_AND DT_OR
	63	%token DT_BITS
	64	%token DT_DEL_PROP
	65	%token DT_DEL_NODE
50aafd60	66	%token DT_OMIT_NO_REF
a4da2e3e	67	%token <propnodename> DT_PROPNODENAME
47605971 RH	68	%token <integer> DT_LITERAL
47605971 RH	69	%token <integer> DT_CHAR_LITERAL
a4da2e3e DG	70	%token <byte> DT_BYTE
	71	%token <data> DT_STRING
	72	%token <labelref> DT_LABEL
	73	%token <labelref> DT_REF
ed95d745	74	%token DT_INCBIN
a4da2e3e DG	75
	76	%type <data> propdata
	77	%type <data> propdataprefix
6f05afcb RH	78	%type <flags> header
6f05afcb RH	79	%type <flags> headers
a4da2e3e DG	80	%type <re> memreserve
a4da2e3e DG	81	%type <re> memreserves
cd296721	82	%type <array> arrayprefix
a4da2e3e DG	83	%type <data> bytestring
	84	%type <prop> propdef
	85	%type <proplist> proplist
	86
	87	%type <node> devicetree
	88	%type <node> nodedef
	89	%type <node> subnode
	90	%type <nodelist> subnodes
a4da2e3e	91
cd296721 SW	92	%type <integer> integer_prim
	93	%type <integer> integer_unary
	94	%type <integer> integer_mul
	95	%type <integer> integer_add
	96	%type <integer> integer_shift
	97	%type <integer> integer_rela
	98	%type <integer> integer_eq
	99	%type <integer> integer_bitand
	100	%type <integer> integer_bitxor
	101	%type <integer> integer_bitor
	102	%type <integer> integer_and
	103	%type <integer> integer_or
	104	%type <integer> integer_trinary
	105	%type <integer> integer_expr
	106
a4da2e3e DG	107	%%
	108
	109	sourcefile:
6f05afcb	110	headers memreserves devicetree
a4da2e3e	111	{
6f05afcb RH	112	parser_output = build_dt_info($1, $2, $3,
	113	guess_boot_cpuid($3));
	114	}
	115	;
	116
	117	header:
	118	DT_V1 ';'
	119	{
	120	$$ = DTSF_V1;
	121	}
	122	\| DT_V1 ';' DT_PLUGIN ';'
	123	{
	124	$$ = DTSF_V1 \| DTSF_PLUGIN;
	125	}
	126	;
	127
	128	headers:
	129	header
	130	\| header headers
	131	{
	132	if ($2 != $1)
	133	ERROR(&@2, "Header flags don't match earlier ones");
	134	$$ = $1;
a4da2e3e DG	135	}
	136	;
	137
	138	memreserves:
	139	/* empty */
	140	{
	141	$$ = NULL;
	142	}
	143	\| memreserve memreserves
	144	{
	145	$$ = chain_reserve_entry($1, $2);
	146	}
	147	;
	148
	149	memreserve:
cd296721	150	DT_MEMRESERVE integer_prim integer_prim ';'
a4da2e3e	151	{
658f29a5	152	$$ = build_reserve_entry($2, $3);
a4da2e3e	153	}
658f29a5	154	\| DT_LABEL memreserve
a4da2e3e	155	{
658f29a5 JB	156	add_label(&$2->labels, $1);
658f29a5 JB	157	$$ = $2;
a4da2e3e DG	158	}
	159	;
	160
a4da2e3e DG	161	devicetree:
	162	'/' nodedef
	163	{
658f29a5 JB	164	$$ = name_node($2, "");
	165	}
	166	\| devicetree '/' nodedef
	167	{
	168	$$ = merge_nodes($1, $3);
	169	}
9130ba88 RH	170	\| DT_REF nodedef
	171	{
	172	/*
	173	* We rely on the rule being always:
	174	* versioninfo plugindecl memreserves devicetree
	175	* so $-1 is what we want (plugindecl)
	176	*/
	177	if (!($<flags>-1 & DTSF_PLUGIN))
	178	ERROR(&@2, "Label or path %s not found", $1);
	179	$$ = add_orphan_node(name_node(build_node(NULL, NULL), ""), $2, $1);
	180	}
47605971 RH	181	\| devicetree DT_LABEL DT_REF nodedef
	182	{
	183	struct node *target = get_node_by_ref($1, $3);
	184
89d12310 RH	185	if (target) {
89d12310 RH	186	add_label(&target->labels, $2);
47605971	187	merge_nodes(target, $4);
89d12310	188	} else
47605971 RH	189	ERROR(&@3, "Label or path %s not found", $3);
	190	$$ = $1;
	191	}
658f29a5 JB	192	\| devicetree DT_REF nodedef
658f29a5 JB	193	{
50aafd60 RH	194	/*
	195	* We rely on the rule being always:
	196	* versioninfo plugindecl memreserves devicetree
	197	* so $-1 is what we want (plugindecl)
	198	*/
	199	if ($<flags>-1 & DTSF_PLUGIN) {
	200	add_orphan_node($1, $3, $2);
4201d057	201	} else {
50aafd60 RH	202	struct node *target = get_node_by_ref($1, $2);
	203
	204	if (target)
	205	merge_nodes(target, $3);
4201d057 RH	206	else
	207	ERROR(&@2, "Label or path %s not found", $2);
	208	}
658f29a5	209	$$ = $1;
a4da2e3e	210	}
cd296721 SW	211	\| devicetree DT_DEL_NODE DT_REF ';'
	212	{
	213	struct node *target = get_node_by_ref($1, $3);
	214
47605971	215	if (target)
cd296721	216	delete_node(target);
47605971 RH	217	else
	218	ERROR(&@3, "Label or path %s not found", $3);
	219
cd296721	220
50aafd60 RH	221	$$ = $1;
	222	}
	223	\| devicetree DT_OMIT_NO_REF DT_REF ';'
	224	{
	225	struct node *target = get_node_by_ref($1, $3);
	226
	227	if (target)
	228	omit_node_if_unused(target);
	229	else
	230	ERROR(&@3, "Label or path %s not found", $3);
	231
	232
cd296721 SW	233	$$ = $1;
cd296721 SW	234	}
a4da2e3e DG	235	;
	236
	237	nodedef:
	238	'{' proplist subnodes '}' ';'
	239	{
	240	$$ = build_node($2, $3);
	241	}
	242	;
	243
	244	proplist:
	245	/* empty */
	246	{
	247	$$ = NULL;
	248	}
	249	\| proplist propdef
	250	{
	251	$$ = chain_property($2, $1);
	252	}
	253	;
	254
	255	propdef:
658f29a5 JB	256	DT_PROPNODENAME '=' propdata ';'
	257	{
	258	$$ = build_property($1, $3);
	259	}
	260	\| DT_PROPNODENAME ';'
a4da2e3e	261	{
658f29a5	262	$$ = build_property($1, empty_data);
a4da2e3e	263	}
cd296721 SW	264	\| DT_DEL_PROP DT_PROPNODENAME ';'
	265	{
	266	$$ = build_property_delete($2);
	267	}
658f29a5	268	\| DT_LABEL propdef
a4da2e3e	269	{
658f29a5 JB	270	add_label(&$2->labels, $1);
658f29a5 JB	271	$$ = $2;
a4da2e3e DG	272	}
	273	;
	274
	275	propdata:
	276	propdataprefix DT_STRING
	277	{
	278	$$ = data_merge($1, $2);
	279	}
cd296721	280	\| propdataprefix arrayprefix '>'
a4da2e3e	281	{
cd296721	282	$$ = data_merge($1, $2.data);
a4da2e3e DG	283	}
	284	\| propdataprefix '[' bytestring ']'
	285	{
	286	$$ = data_merge($1, $3);
	287	}
	288	\| propdataprefix DT_REF
	289	{
f858927f	290	$1 = data_add_marker($1, TYPE_STRING, $2);
a4da2e3e DG	291	$$ = data_add_marker($1, REF_PATH, $2);
a4da2e3e DG	292	}
cd296721	293	\| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
ed95d745	294	{
658f29a5 JB	295	FILE *f = srcfile_relative_open($4.val, NULL);
658f29a5 JB	296	struct data d;
ed95d745 DG	297
ed95d745 DG	298	if ($6 != 0)
658f29a5	299	if (fseek(f, $6, SEEK_SET) != 0)
47605971 RH	300	die("Couldn't seek to offset %llu in \"%s\": %s",
	301	(unsigned long long)$6, $4.val,
	302	strerror(errno));
ed95d745	303
658f29a5	304	d = data_copy_file(f, $8);
ed95d745 DG	305
ed95d745 DG	306	$$ = data_merge($1, d);
658f29a5	307	fclose(f);
ed95d745 DG	308	}
	309	\| propdataprefix DT_INCBIN '(' DT_STRING ')'
	310	{
658f29a5	311	FILE *f = srcfile_relative_open($4.val, NULL);
ed95d745 DG	312	struct data d = empty_data;
ed95d745 DG	313
658f29a5	314	d = data_copy_file(f, -1);
ed95d745 DG	315
ed95d745 DG	316	$$ = data_merge($1, d);
658f29a5	317	fclose(f);
ed95d745	318	}
a4da2e3e DG	319	\| propdata DT_LABEL
	320	{
	321	$$ = data_add_marker($1, LABEL, $2);
	322	}
	323	;
	324
	325	propdataprefix:
	326	/* empty */
	327	{
	328	$$ = empty_data;
	329	}
	330	\| propdata ','
	331	{
	332	$$ = $1;
	333	}
	334	\| propdataprefix DT_LABEL
	335	{
	336	$$ = data_add_marker($1, LABEL, $2);
	337	}
	338	;
	339
cd296721 SW	340	arrayprefix:
	341	DT_BITS DT_LITERAL '<'
	342	{
47605971	343	unsigned long long bits;
f858927f	344	enum markertype type = TYPE_UINT32;
47605971 RH	345
	346	bits = $2;
	347
f858927f RH	348	switch (bits) {
	349	case 8: type = TYPE_UINT8; break;
	350	case 16: type = TYPE_UINT16; break;
	351	case 32: type = TYPE_UINT32; break;
	352	case 64: type = TYPE_UINT64; break;
	353	default:
47605971 RH	354	ERROR(&@2, "Array elements must be"
	355	" 8, 16, 32 or 64-bits");
	356	bits = 32;
cd296721	357	}
47605971	358
f858927f	359	$$.data = data_add_marker(empty_data, type, NULL);
47605971	360	$$.bits = bits;
cd296721 SW	361	}
	362	\| '<'
	363	{
f858927f	364	$$.data = data_add_marker(empty_data, TYPE_UINT32, NULL);
cd296721 SW	365	$$.bits = 32;
	366	}
	367	\| arrayprefix integer_prim
	368	{
	369	if ($1.bits < 64) {
	370	uint64_t mask = (1ULL << $1.bits) - 1;
	371	/*
	372	* Bits above mask must either be all zero
	373	* (positive within range of mask) or all one
	374	* (negative and sign-extended). The second
	375	* condition is true if when we set all bits
	376	* within the mask to one (i.e. \| in the
	377	* mask), all bits are one.
	378	*/
	379	if (($2 > mask) && (($2 \| mask) != -1ULL))
47605971 RH	380	ERROR(&@2, "Value out of range for"
47605971 RH	381	" %d-bit array element", $1.bits);
cd296721 SW	382	}
	383
	384	$$.data = data_append_integer($1.data, $2, $1.bits);
	385	}
	386	\| arrayprefix DT_REF
	387	{
	388	uint64_t val = ~0ULL >> (64 - $1.bits);
	389
	390	if ($1.bits == 32)
	391	$1.data = data_add_marker($1.data,
	392	REF_PHANDLE,
	393	$2);
	394	else
47605971	395	ERROR(&@2, "References are only allowed in "
cd296721 SW	396	"arrays with 32-bit elements.");
	397
	398	$$.data = data_append_integer($1.data, val, $1.bits);
	399	}
	400	\| arrayprefix DT_LABEL
a4da2e3e	401	{
cd296721	402	$$.data = data_add_marker($1.data, LABEL, $2);
a4da2e3e	403	}
cd296721 SW	404	;
	405
	406	integer_prim:
	407	DT_LITERAL
cd296721	408	\| DT_CHAR_LITERAL
cd296721	409	\| '(' integer_expr ')'
a4da2e3e	410	{
cd296721	411	$$ = $2;
a4da2e3e DG	412	}
	413	;
	414
cd296721 SW	415	integer_expr:
	416	integer_trinary
	417	;
	418
	419	integer_trinary:
	420	integer_or
	421	\| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
	422	;
	423
	424	integer_or:
	425	integer_and
	426	\| integer_or DT_OR integer_and { $$ = $1 \|\| $3; }
	427	;
	428
	429	integer_and:
	430	integer_bitor
	431	\| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
	432	;
	433
	434	integer_bitor:
	435	integer_bitxor
	436	\| integer_bitor '\|' integer_bitxor { $$ = $1 \| $3; }
	437	;
	438
	439	integer_bitxor:
	440	integer_bitand
	441	\| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
	442	;
	443
	444	integer_bitand:
	445	integer_eq
	446	\| integer_bitand '&' integer_eq { $$ = $1 & $3; }
	447	;
	448
	449	integer_eq:
	450	integer_rela
	451	\| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
	452	\| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
	453	;
	454
	455	integer_rela:
	456	integer_shift
	457	\| integer_rela '<' integer_shift { $$ = $1 < $3; }
	458	\| integer_rela '>' integer_shift { $$ = $1 > $3; }
	459	\| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
	460	\| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
	461	;
	462
	463	integer_shift:
	464	integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
	465	\| integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
	466	\| integer_add
	467	;
	468
	469	integer_add:
	470	integer_add '+' integer_mul { $$ = $1 + $3; }
	471	\| integer_add '-' integer_mul { $$ = $1 - $3; }
	472	\| integer_mul
	473	;
	474
	475	integer_mul:
	476	integer_mul '' integer_unary { $$ = $1 $3; }
91feabc2 RH	477	\| integer_mul '/' integer_unary
	478	{
	479	if ($3 != 0) {
	480	$$ = $1 / $3;
	481	} else {
	482	ERROR(&@$, "Division by zero");
	483	$$ = 0;
	484	}
	485	}
	486	\| integer_mul '%' integer_unary
	487	{
	488	if ($3 != 0) {
	489	$$ = $1 % $3;
	490	} else {
	491	ERROR(&@$, "Division by zero");
	492	$$ = 0;
	493	}
	494	}
cd296721 SW	495	\| integer_unary
	496	;
	497
	498	integer_unary:
	499	integer_prim
	500	\| '-' integer_unary { $$ = -$2; }
	501	\| '~' integer_unary { $$ = ~$2; }
	502	\| '!' integer_unary { $$ = !$2; }
a4da2e3e DG	503	;
	504
	505	bytestring:
	506	/* empty */
	507	{
f858927f	508	$$ = data_add_marker(empty_data, TYPE_UINT8, NULL);
a4da2e3e DG	509	}
	510	\| bytestring DT_BYTE
	511	{
	512	$$ = data_append_byte($1, $2);
	513	}
	514	\| bytestring DT_LABEL
	515	{
	516	$$ = data_add_marker($1, LABEL, $2);
	517	}
	518	;
	519
	520	subnodes:
	521	/* empty */
	522	{
	523	$$ = NULL;
	524	}
658f29a5	525	\| subnode subnodes
a4da2e3e DG	526	{
	527	$$ = chain_node($1, $2);
	528	}
	529	\| subnode propdef
	530	{
47605971	531	ERROR(&@2, "Properties must precede subnodes");
a4da2e3e DG	532	YYERROR;
	533	}
	534	;
	535
	536	subnode:
658f29a5	537	DT_PROPNODENAME nodedef
a4da2e3e	538	{
658f29a5	539	$$ = name_node($2, $1);
a4da2e3e	540	}
cd296721 SW	541	\| DT_DEL_NODE DT_PROPNODENAME ';'
	542	{
	543	$$ = name_node(build_node_delete(), $2);
	544	}
50aafd60 RH	545	\| DT_OMIT_NO_REF subnode
	546	{
	547	$$ = omit_node_if_unused($2);
	548	}
658f29a5	549	\| DT_LABEL subnode
a4da2e3e	550	{
658f29a5 JB	551	add_label(&$2->labels, $1);
658f29a5 JB	552	$$ = $2;
a4da2e3e DG	553	}
	554	;
	555
	556	%%
	557
47605971	558	void yyerror(char const *s)
cd296721	559	{
47605971	560	ERROR(&yylloc, "%s", s);
cd296721	561	}