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

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
 */
%{
#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_LABEL_REF
%token <labelref> DT_PATH_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 <labelref> dt_ref

%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;
		}
	;

dt_ref: DT_LABEL_REF | DT_PATH_REF;

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, 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_PATH_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_LABEL_REF nodedef
		{
			struct node *target = get_node_by_ref($1, $2);

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