[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
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	*/
0cec114e RH	5	%locations
0cec114e RH	6
a4da2e3e	7	%{
ed95d745	8	#include <stdio.h>
6f05afcb	9	#include <inttypes.h>
ed95d745	10
a4da2e3e DG	11	#include "dtc.h"
	12	#include "srcpos.h"
	13
ed95d745	14	extern int yylex(void);
658f29a5	15	extern void yyerror(char const *s);
47605971 RH	16	#define ERROR(loc, ...) \
	17	do { \
	18	srcpos_error((loc), "Error", __VA_ARGS__); \
	19	treesource_error = true; \
	20	} while (0)
a4da2e3e	21
0cec114e RH	22	#define YYERROR_CALL(msg) yyerror(msg)
0cec114e RH	23
6f05afcb	24	extern struct dt_info *parser_output;
47605971	25	extern bool treesource_error;
ea3723a5 RH	26
	27	static bool is_ref_relative(const char *ref)
	28	{
	29	return ref[0] != '/' && strchr(&ref[1], '/');
	30	}
	31
a4da2e3e DG	32	%}
	33
	34	%union {
	35	char *propnodename;
a4da2e3e	36	char *labelref;
ed95d745	37	uint8_t byte;
a4da2e3e DG	38	struct data data;
a4da2e3e DG	39
cd296721 SW	40	struct {
	41	struct data data;
	42	int bits;
	43	} array;
	44
a4da2e3e DG	45	struct property *prop;
	46	struct property *proplist;
	47	struct node *node;
	48	struct node *nodelist;
	49	struct reserve_info *re;
cd296721	50	uint64_t integer;
6f05afcb	51	unsigned int flags;
a4da2e3e DG	52	}
	53
	54	%token DT_V1
6f05afcb	55	%token DT_PLUGIN
a4da2e3e	56	%token DT_MEMRESERVE
cd296721 SW	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
50aafd60	61	%token DT_OMIT_NO_REF
a4da2e3e	62	%token <propnodename> DT_PROPNODENAME
47605971 RH	63	%token <integer> DT_LITERAL
47605971 RH	64	%token <integer> DT_CHAR_LITERAL
a4da2e3e DG	65	%token <byte> DT_BYTE
	66	%token <data> DT_STRING
	67	%token <labelref> DT_LABEL
c2e7075c RH	68	%token <labelref> DT_LABEL_REF
c2e7075c RH	69	%token <labelref> DT_PATH_REF
ed95d745	70	%token DT_INCBIN
a4da2e3e DG	71
	72	%type <data> propdata
	73	%type <data> propdataprefix
6f05afcb RH	74	%type <flags> header
6f05afcb RH	75	%type <flags> headers
a4da2e3e DG	76	%type <re> memreserve
a4da2e3e DG	77	%type <re> memreserves
cd296721	78	%type <array> arrayprefix
a4da2e3e DG	79	%type <data> bytestring
	80	%type <prop> propdef
	81	%type <proplist> proplist
c2e7075c	82	%type <labelref> dt_ref
a4da2e3e DG	83
	84	%type <node> devicetree
	85	%type <node> nodedef
	86	%type <node> subnode
	87	%type <nodelist> subnodes
a4da2e3e	88
cd296721 SW	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
a4da2e3e DG	104	%%
	105
	106	sourcefile:
6f05afcb	107	headers memreserves devicetree
a4da2e3e	108	{
6f05afcb RH	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;
a4da2e3e DG	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:
cd296721	147	DT_MEMRESERVE integer_prim integer_prim ';'
a4da2e3e	148	{
658f29a5	149	$$ = build_reserve_entry($2, $3);
a4da2e3e	150	}
658f29a5	151	\| DT_LABEL memreserve
a4da2e3e	152	{
658f29a5 JB	153	add_label(&$2->labels, $1);
658f29a5 JB	154	$$ = $2;
a4da2e3e DG	155	}
	156	;
	157
c2e7075c RH	158	dt_ref: DT_LABEL_REF \| DT_PATH_REF;
c2e7075c RH	159
a4da2e3e DG	160	devicetree:
	161	'/' nodedef
	162	{
658f29a5 JB	163	$$ = name_node($2, "");
	164	}
	165	\| devicetree '/' nodedef
	166	{
	167	$$ = merge_nodes($1, $3);
	168	}
c2e7075c	169	\| dt_ref nodedef
9130ba88 RH	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);
ea3723a5 RH	178	else if (is_ref_relative($1))
ea3723a5 RH	179	ERROR(&@2, "Label-relative reference %s not supported in plugin", $1);
c2e7075c RH	180	$$ = add_orphan_node(
	181	name_node(build_node(NULL, NULL, NULL),
	182	""),
	183	$2, $1);
9130ba88	184	}
c2e7075c	185	\| devicetree DT_LABEL dt_ref nodedef
47605971 RH	186	{
	187	struct node *target = get_node_by_ref($1, $3);
	188
ea3723a5 RH	189	if (($<flags>-1 & DTSF_PLUGIN) && is_ref_relative($3))
	190	ERROR(&@2, "Label-relative reference %s not supported in plugin", $3);
	191
89d12310 RH	192	if (target) {
89d12310 RH	193	add_label(&target->labels, $2);
47605971	194	merge_nodes(target, $4);
89d12310	195	} else
47605971 RH	196	ERROR(&@3, "Label or path %s not found", $3);
	197	$$ = $1;
	198	}
c2e7075c	199	\| devicetree DT_PATH_REF nodedef
658f29a5	200	{
50aafd60 RH	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) {
ea3723a5 RH	207	if (is_ref_relative($2))
ea3723a5 RH	208	ERROR(&@2, "Label-relative reference %s not supported in plugin", $2);
50aafd60	209	add_orphan_node($1, $3, $2);
4201d057	210	} else {
50aafd60 RH	211	struct node *target = get_node_by_ref($1, $2);
	212
	213	if (target)
	214	merge_nodes(target, $3);
4201d057 RH	215	else
	216	ERROR(&@2, "Label or path %s not found", $2);
	217	}
658f29a5	218	$$ = $1;
a4da2e3e	219	}
c2e7075c RH	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 ';'
cd296721 SW	240	{
	241	struct node *target = get_node_by_ref($1, $3);
	242
47605971	243	if (target)
cd296721	244	delete_node(target);
47605971 RH	245	else
	246	ERROR(&@3, "Label or path %s not found", $3);
	247
cd296721	248
50aafd60 RH	249	$$ = $1;
50aafd60 RH	250	}
c2e7075c	251	\| devicetree DT_OMIT_NO_REF dt_ref ';'
50aafd60 RH	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
cd296721 SW	261	$$ = $1;
cd296721 SW	262	}
a4da2e3e DG	263	;
	264
	265	nodedef:
	266	'{' proplist subnodes '}' ';'
	267	{
c2e7075c	268	$$ = build_node($2, $3, &@$);
a4da2e3e DG	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:
658f29a5 JB	284	DT_PROPNODENAME '=' propdata ';'
658f29a5 JB	285	{
c2e7075c	286	$$ = build_property($1, $3, &@$);
12d638f4	287	free($1);
658f29a5 JB	288	}
658f29a5 JB	289	\| DT_PROPNODENAME ';'
a4da2e3e	290	{
c2e7075c	291	$$ = build_property($1, empty_data, &@$);
12d638f4	292	free($1);
a4da2e3e	293	}
cd296721 SW	294	\| DT_DEL_PROP DT_PROPNODENAME ';'
	295	{
	296	$$ = build_property_delete($2);
12d638f4	297	free($2);
cd296721	298	}
658f29a5	299	\| DT_LABEL propdef
a4da2e3e	300	{
658f29a5 JB	301	add_label(&$2->labels, $1);
658f29a5 JB	302	$$ = $2;
a4da2e3e DG	303	}
	304	;
	305
	306	propdata:
	307	propdataprefix DT_STRING
	308	{
	309	$$ = data_merge($1, $2);
	310	}
cd296721	311	\| propdataprefix arrayprefix '>'
a4da2e3e	312	{
cd296721	313	$$ = data_merge($1, $2.data);
a4da2e3e DG	314	}
	315	\| propdataprefix '[' bytestring ']'
	316	{
	317	$$ = data_merge($1, $3);
	318	}
c2e7075c	319	\| propdataprefix dt_ref
a4da2e3e	320	{
f858927f	321	$1 = data_add_marker($1, TYPE_STRING, $2);
a4da2e3e DG	322	$$ = data_add_marker($1, REF_PATH, $2);
a4da2e3e DG	323	}
cd296721	324	\| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
ed95d745	325	{
658f29a5 JB	326	FILE *f = srcfile_relative_open($4.val, NULL);
658f29a5 JB	327	struct data d;
ed95d745 DG	328
ed95d745 DG	329	if ($6 != 0)
658f29a5	330	if (fseek(f, $6, SEEK_SET) != 0)
47605971 RH	331	die("Couldn't seek to offset %llu in \"%s\": %s",
	332	(unsigned long long)$6, $4.val,
	333	strerror(errno));
ed95d745	334
658f29a5	335	d = data_copy_file(f, $8);
ed95d745 DG	336
ed95d745 DG	337	$$ = data_merge($1, d);
658f29a5	338	fclose(f);
ed95d745 DG	339	}
	340	\| propdataprefix DT_INCBIN '(' DT_STRING ')'
	341	{
658f29a5	342	FILE *f = srcfile_relative_open($4.val, NULL);
ed95d745 DG	343	struct data d = empty_data;
ed95d745 DG	344
658f29a5	345	d = data_copy_file(f, -1);
ed95d745 DG	346
ed95d745 DG	347	$$ = data_merge($1, d);
658f29a5	348	fclose(f);
ed95d745	349	}
a4da2e3e DG	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
cd296721 SW	371	arrayprefix:
	372	DT_BITS DT_LITERAL '<'
	373	{
47605971	374	unsigned long long bits;
f858927f	375	enum markertype type = TYPE_UINT32;
47605971 RH	376
	377	bits = $2;
	378
f858927f RH	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:
47605971 RH	385	ERROR(&@2, "Array elements must be"
	386	" 8, 16, 32 or 64-bits");
	387	bits = 32;
cd296721	388	}
47605971	389
f858927f	390	$$.data = data_add_marker(empty_data, type, NULL);
47605971	391	$$.bits = bits;
cd296721 SW	392	}
	393	\| '<'
	394	{
f858927f	395	$$.data = data_add_marker(empty_data, TYPE_UINT32, NULL);
cd296721 SW	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	*/
ec340077 RH	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	}
cd296721 SW	418	}
	419
	420	$$.data = data_append_integer($1.data, $2, $1.bits);
	421	}
c2e7075c	422	\| arrayprefix dt_ref
cd296721 SW	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
47605971	431	ERROR(&@2, "References are only allowed in "
cd296721 SW	432	"arrays with 32-bit elements.");
	433
	434	$$.data = data_append_integer($1.data, val, $1.bits);
	435	}
	436	\| arrayprefix DT_LABEL
a4da2e3e	437	{
cd296721	438	$$.data = data_add_marker($1.data, LABEL, $2);
a4da2e3e	439	}
cd296721 SW	440	;
	441
	442	integer_prim:
	443	DT_LITERAL
cd296721	444	\| DT_CHAR_LITERAL
cd296721	445	\| '(' integer_expr ')'
a4da2e3e	446	{
cd296721	447	$$ = $2;
a4da2e3e DG	448	}
	449	;
	450
cd296721 SW	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:
6e9c9686 RH	500	integer_shift DT_LSHIFT integer_add { $$ = ($3 < 64) ? ($1 << $3) : 0; }
6e9c9686 RH	501	\| integer_shift DT_RSHIFT integer_add { $$ = ($3 < 64) ? ($1 >> $3) : 0; }
cd296721 SW	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; }
91feabc2 RH	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	}
cd296721 SW	531	\| integer_unary
	532	;
	533
	534	integer_unary:
	535	integer_prim
	536	\| '-' integer_unary { $$ = -$2; }
	537	\| '~' integer_unary { $$ = ~$2; }
	538	\| '!' integer_unary { $$ = !$2; }
a4da2e3e DG	539	;
	540
	541	bytestring:
	542	/* empty */
	543	{
f858927f	544	$$ = data_add_marker(empty_data, TYPE_UINT8, NULL);
a4da2e3e DG	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	}
658f29a5	561	\| subnode subnodes
a4da2e3e DG	562	{
	563	$$ = chain_node($1, $2);
	564	}
	565	\| subnode propdef
	566	{
47605971	567	ERROR(&@2, "Properties must precede subnodes");
a4da2e3e DG	568	YYERROR;
	569	}
	570	;
	571
	572	subnode:
658f29a5	573	DT_PROPNODENAME nodedef
a4da2e3e	574	{
658f29a5	575	$$ = name_node($2, $1);
12d638f4	576	free($1);
a4da2e3e	577	}
cd296721 SW	578	\| DT_DEL_NODE DT_PROPNODENAME ';'
cd296721 SW	579	{
c2e7075c	580	$$ = name_node(build_node_delete(&@$), $2);
12d638f4	581	free($2);
cd296721	582	}
50aafd60 RH	583	\| DT_OMIT_NO_REF subnode
	584	{
	585	$$ = omit_node_if_unused($2);
	586	}
658f29a5	587	\| DT_LABEL subnode
a4da2e3e	588	{
658f29a5 JB	589	add_label(&$2->labels, $1);
658f29a5 JB	590	$$ = $2;
a4da2e3e DG	591	}
	592	;
	593
	594	%%
	595
47605971	596	void yyerror(char const *s)
cd296721	597	{
47605971	598	ERROR(&yylloc, "%s", s);
cd296721	599	}