[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.
 */
%locations

%{
#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)

#define YYERROR_CALL(msg) yyerror(msg)

extern struct dt_info *parser_output;
extern bool treesource_error;

static bool is_ref_relative(const char *ref)
{
	return ref[0] != '/' && strchr(&ref[1], '/');
}

%}

%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);
			else if (is_ref_relative($1))
				ERROR(&@2, "Label-relative reference %s not supported in plugin", $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 (($<flags>-1 & DTSF_PLUGIN) && is_ref_relative($3))
				ERROR(&@2, "Label-relative reference %s not supported in plugin", $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) {
				if (is_ref_relative($2))
					ERROR(&@2, "Label-relative reference %s not supported in plugin", $2);
				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, &@$);
			free($1);
		}
	| DT_PROPNODENAME ';'
		{
			$$ = build_property($1, empty_data, &@$);
			free($1);
		}
	| DT_DEL_PROP DT_PROPNODENAME ';'
		{
			$$ = build_property_delete($2);
			free($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)) {
					char *loc = srcpos_string(&@2);
					fprintf(stderr,
						"WARNING: %s: Value 0x%016" PRIx64
						" truncated to 0x%0*" PRIx64 "\n",
						loc, $2, $1.bits / 4, ($2 & mask));
					free(loc);
				}
			}

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