[GitHub/mt8127/android_kernel_alcatel_ttab.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 "dtc.h"
#include "srcpos.h"

YYLTYPE yylloc;

extern int yylex(void);
extern void print_error(char const *fmt, ...);
extern void yyerror(char const *s);

extern struct boot_info *the_boot_info;
extern int treesource_error;

static unsigned long long eval_literal(const char *s, int base, int bits);
static unsigned char eval_char_literal(const char *s);
%}

%union {
	char *propnodename;
	char *literal;
	char *labelref;
	unsigned int cbase;
	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;
}

%token DT_V1
%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 <propnodename> DT_PROPNODENAME
%token <literal> DT_LITERAL
%token <literal> DT_CHAR_LITERAL
%token <cbase> DT_BASE
%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 <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:
	  DT_V1 ';' memreserves devicetree
		{
			the_boot_info = build_boot_info($3, $4,
							guess_boot_cpuid($4));
		}
	;

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

			if (target)
				merge_nodes(target, $3);
			else
				print_error("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)
				print_error("label or path, '%s', not found", $3);
			else
				delete_node(target);

			$$ = $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
		{
			$$ = 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)
					print_error("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 '<'
		{
			$$.data = empty_data;
			$$.bits = eval_literal($2, 0, 7);

			if (($$.bits !=  8) &&
			    ($$.bits != 16) &&
			    ($$.bits != 32) &&
			    ($$.bits != 64))
			{
				print_error("Only 8, 16, 32 and 64-bit elements"
					    " are currently supported");
				$$.bits = 32;
			}
		}
	| '<'
		{
			$$.data = empty_data;
			$$.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))
					print_error(
						"integer value out of range "
						"%016lx (%d bits)", $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
				print_error("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
		{
			$$ = eval_literal($1, 0, 64);
		}
	| DT_CHAR_LITERAL
		{
			$$ = eval_char_literal($1);
		}
	| '(' 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 { $$ = $1 / $3; }
	| integer_mul '%' integer_unary { $$ = $1 % $3; }
	| integer_unary
	;

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

bytestring:
	  /* empty */
		{
			$$ = empty_data;
		}
	| 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
		{
			print_error("syntax error: 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_LABEL subnode
		{
			add_label(&$2->labels, $1);
			$$ = $2;
		}
	;

%%

void print_error(char const *fmt, ...)
{
	va_list va;

	va_start(va, fmt);
	srcpos_verror(&yylloc, fmt, va);
	va_end(va);

	treesource_error = 1;
}

void yyerror(char const *s) {
	print_error("%s", s);
}

static unsigned long long eval_literal(const char *s, int base, int bits)
{
	unsigned long long val;
	char *e;

	errno = 0;
	val = strtoull(s, &e, base);
	if (*e) {
		size_t uls = strspn(e, "UL");
		if (e[uls])
			print_error("bad characters in literal");
	}
	if ((errno == ERANGE)
		 || ((bits < 64) && (val >= (1ULL << bits))))
		print_error("literal out of range");
	else if (errno != 0)
		print_error("bad literal");
	return val;
}

static unsigned char eval_char_literal(const char *s)
{
	int i = 1;
	char c = s[0];

	if (c == '\0')
	{
		print_error("empty character literal");
		return 0;
	}

	/*
	 * If the first character in the character literal is a \ then process
	 * the remaining characters as an escape encoding. If the first
	 * character is neither an escape or a terminator it should be the only
	 * character in the literal and will be returned.
	 */
	if (c == '\\')
		c = get_escape_char(s, &i);

	if (s[i] != '\0')
		print_error("malformed character literal");

	return c;
}
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	*/
	20
a4da2e3e	21	%{
ed95d745 DG	22	#include <stdio.h>
ed95d745 DG	23
a4da2e3e DG	24	#include "dtc.h"
	25	#include "srcpos.h"
	26
658f29a5 JB	27	YYLTYPE yylloc;
658f29a5 JB	28
ed95d745	29	extern int yylex(void);
658f29a5 JB	30	extern void print_error(char const *fmt, ...);
658f29a5 JB	31	extern void yyerror(char const *s);
a4da2e3e DG	32
a4da2e3e DG	33	extern struct boot_info *the_boot_info;
ed95d745	34	extern int treesource_error;
a4da2e3e	35
ed95d745	36	static unsigned long long eval_literal(const char *s, int base, int bits);
cd296721	37	static unsigned char eval_char_literal(const char *s);
a4da2e3e DG	38	%}
	39
	40	%union {
	41	char *propnodename;
	42	char *literal;
	43	char *labelref;
	44	unsigned int cbase;
ed95d745	45	uint8_t byte;
a4da2e3e DG	46	struct data data;
a4da2e3e DG	47
cd296721 SW	48	struct {
	49	struct data data;
	50	int bits;
	51	} array;
	52
a4da2e3e DG	53	struct property *prop;
	54	struct property *proplist;
	55	struct node *node;
	56	struct node *nodelist;
	57	struct reserve_info *re;
cd296721	58	uint64_t integer;
a4da2e3e DG	59	}
	60
	61	%token DT_V1
	62	%token DT_MEMRESERVE
cd296721 SW	63	%token DT_LSHIFT DT_RSHIFT DT_LE DT_GE DT_EQ DT_NE DT_AND DT_OR
	64	%token DT_BITS
	65	%token DT_DEL_PROP
	66	%token DT_DEL_NODE
a4da2e3e DG	67	%token <propnodename> DT_PROPNODENAME
a4da2e3e DG	68	%token <literal> DT_LITERAL
cd296721	69	%token <literal> DT_CHAR_LITERAL
a4da2e3e DG	70	%token <cbase> DT_BASE
	71	%token <byte> DT_BYTE
	72	%token <data> DT_STRING
	73	%token <labelref> DT_LABEL
	74	%token <labelref> DT_REF
ed95d745	75	%token DT_INCBIN
a4da2e3e DG	76
	77	%type <data> propdata
	78	%type <data> propdataprefix
	79	%type <re> memreserve
	80	%type <re> memreserves
cd296721	81	%type <array> arrayprefix
a4da2e3e DG	82	%type <data> bytestring
	83	%type <prop> propdef
	84	%type <proplist> proplist
	85
	86	%type <node> devicetree
	87	%type <node> nodedef
	88	%type <node> subnode
	89	%type <nodelist> subnodes
a4da2e3e	90
cd296721 SW	91	%type <integer> integer_prim
	92	%type <integer> integer_unary
	93	%type <integer> integer_mul
	94	%type <integer> integer_add
	95	%type <integer> integer_shift
	96	%type <integer> integer_rela
	97	%type <integer> integer_eq
	98	%type <integer> integer_bitand
	99	%type <integer> integer_bitxor
	100	%type <integer> integer_bitor
	101	%type <integer> integer_and
	102	%type <integer> integer_or
	103	%type <integer> integer_trinary
	104	%type <integer> integer_expr
	105
a4da2e3e DG	106	%%
	107
	108	sourcefile:
	109	DT_V1 ';' memreserves devicetree
	110	{
658f29a5 JB	111	the_boot_info = build_boot_info($3, $4,
658f29a5 JB	112	guess_boot_cpuid($4));
a4da2e3e DG	113	}
	114	;
	115
	116	memreserves:
	117	/* empty */
	118	{
	119	$$ = NULL;
	120	}
	121	\| memreserve memreserves
	122	{
	123	$$ = chain_reserve_entry($1, $2);
	124	}
	125	;
	126
	127	memreserve:
cd296721	128	DT_MEMRESERVE integer_prim integer_prim ';'
a4da2e3e	129	{
658f29a5	130	$$ = build_reserve_entry($2, $3);
a4da2e3e	131	}
658f29a5	132	\| DT_LABEL memreserve
a4da2e3e	133	{
658f29a5 JB	134	add_label(&$2->labels, $1);
658f29a5 JB	135	$$ = $2;
a4da2e3e DG	136	}
	137	;
	138
a4da2e3e DG	139	devicetree:
	140	'/' nodedef
	141	{
658f29a5 JB	142	$$ = name_node($2, "");
	143	}
	144	\| devicetree '/' nodedef
	145	{
	146	$$ = merge_nodes($1, $3);
	147	}
	148	\| devicetree DT_REF nodedef
	149	{
	150	struct node *target = get_node_by_ref($1, $2);
	151
	152	if (target)
	153	merge_nodes(target, $3);
	154	else
	155	print_error("label or path, '%s', not found", $2);
	156	$$ = $1;
a4da2e3e	157	}
cd296721 SW	158	\| devicetree DT_DEL_NODE DT_REF ';'
	159	{
	160	struct node *target = get_node_by_ref($1, $3);
	161
	162	if (!target)
	163	print_error("label or path, '%s', not found", $3);
	164	else
	165	delete_node(target);
	166
	167	$$ = $1;
	168	}
a4da2e3e DG	169	;
	170
	171	nodedef:
	172	'{' proplist subnodes '}' ';'
	173	{
	174	$$ = build_node($2, $3);
	175	}
	176	;
	177
	178	proplist:
	179	/* empty */
	180	{
	181	$$ = NULL;
	182	}
	183	\| proplist propdef
	184	{
	185	$$ = chain_property($2, $1);
	186	}
	187	;
	188
	189	propdef:
658f29a5 JB	190	DT_PROPNODENAME '=' propdata ';'
	191	{
	192	$$ = build_property($1, $3);
	193	}
	194	\| DT_PROPNODENAME ';'
a4da2e3e	195	{
658f29a5	196	$$ = build_property($1, empty_data);
a4da2e3e	197	}
cd296721 SW	198	\| DT_DEL_PROP DT_PROPNODENAME ';'
	199	{
	200	$$ = build_property_delete($2);
	201	}
658f29a5	202	\| DT_LABEL propdef
a4da2e3e	203	{
658f29a5 JB	204	add_label(&$2->labels, $1);
658f29a5 JB	205	$$ = $2;
a4da2e3e DG	206	}
	207	;
	208
	209	propdata:
	210	propdataprefix DT_STRING
	211	{
	212	$$ = data_merge($1, $2);
	213	}
cd296721	214	\| propdataprefix arrayprefix '>'
a4da2e3e	215	{
cd296721	216	$$ = data_merge($1, $2.data);
a4da2e3e DG	217	}
	218	\| propdataprefix '[' bytestring ']'
	219	{
	220	$$ = data_merge($1, $3);
	221	}
	222	\| propdataprefix DT_REF
	223	{
	224	$$ = data_add_marker($1, REF_PATH, $2);
	225	}
cd296721	226	\| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
ed95d745	227	{
658f29a5 JB	228	FILE *f = srcfile_relative_open($4.val, NULL);
658f29a5 JB	229	struct data d;
ed95d745 DG	230
ed95d745 DG	231	if ($6 != 0)
658f29a5 JB	232	if (fseek(f, $6, SEEK_SET) != 0)
	233	print_error("Couldn't seek to offset %llu in \"%s\": %s",
	234	(unsigned long long)$6,
	235	$4.val,
	236	strerror(errno));
ed95d745	237
658f29a5	238	d = data_copy_file(f, $8);
ed95d745 DG	239
ed95d745 DG	240	$$ = data_merge($1, d);
658f29a5	241	fclose(f);
ed95d745 DG	242	}
	243	\| propdataprefix DT_INCBIN '(' DT_STRING ')'
	244	{
658f29a5	245	FILE *f = srcfile_relative_open($4.val, NULL);
ed95d745 DG	246	struct data d = empty_data;
ed95d745 DG	247
658f29a5	248	d = data_copy_file(f, -1);
ed95d745 DG	249
ed95d745 DG	250	$$ = data_merge($1, d);
658f29a5	251	fclose(f);
ed95d745	252	}
a4da2e3e DG	253	\| propdata DT_LABEL
	254	{
	255	$$ = data_add_marker($1, LABEL, $2);
	256	}
	257	;
	258
	259	propdataprefix:
	260	/* empty */
	261	{
	262	$$ = empty_data;
	263	}
	264	\| propdata ','
	265	{
	266	$$ = $1;
	267	}
	268	\| propdataprefix DT_LABEL
	269	{
	270	$$ = data_add_marker($1, LABEL, $2);
	271	}
	272	;
	273
cd296721 SW	274	arrayprefix:
	275	DT_BITS DT_LITERAL '<'
	276	{
	277	$$.data = empty_data;
	278	$$.bits = eval_literal($2, 0, 7);
	279
	280	if (($$.bits != 8) &&
	281	($$.bits != 16) &&
	282	($$.bits != 32) &&
	283	($$.bits != 64))
	284	{
	285	print_error("Only 8, 16, 32 and 64-bit elements"
	286	" are currently supported");
	287	$$.bits = 32;
	288	}
	289	}
	290	\| '<'
	291	{
	292	$$.data = empty_data;
	293	$$.bits = 32;
	294	}
	295	\| arrayprefix integer_prim
	296	{
	297	if ($1.bits < 64) {
	298	uint64_t mask = (1ULL << $1.bits) - 1;
	299	/*
	300	* Bits above mask must either be all zero
	301	* (positive within range of mask) or all one
	302	* (negative and sign-extended). The second
	303	* condition is true if when we set all bits
	304	* within the mask to one (i.e. \| in the
	305	* mask), all bits are one.
	306	*/
	307	if (($2 > mask) && (($2 \| mask) != -1ULL))
	308	print_error(
	309	"integer value out of range "
	310	"%016lx (%d bits)", $1.bits);
	311	}
	312
	313	$$.data = data_append_integer($1.data, $2, $1.bits);
	314	}
	315	\| arrayprefix DT_REF
	316	{
	317	uint64_t val = ~0ULL >> (64 - $1.bits);
	318
	319	if ($1.bits == 32)
	320	$1.data = data_add_marker($1.data,
	321	REF_PHANDLE,
	322	$2);
	323	else
	324	print_error("References are only allowed in "
	325	"arrays with 32-bit elements.");
	326
	327	$$.data = data_append_integer($1.data, val, $1.bits);
	328	}
	329	\| arrayprefix DT_LABEL
a4da2e3e	330	{
cd296721	331	$$.data = data_add_marker($1.data, LABEL, $2);
a4da2e3e	332	}
cd296721 SW	333	;
	334
	335	integer_prim:
	336	DT_LITERAL
a4da2e3e	337	{
cd296721	338	$$ = eval_literal($1, 0, 64);
a4da2e3e	339	}
cd296721	340	\| DT_CHAR_LITERAL
a4da2e3e	341	{
cd296721	342	$$ = eval_char_literal($1);
a4da2e3e	343	}
cd296721	344	\| '(' integer_expr ')'
a4da2e3e	345	{
cd296721	346	$$ = $2;
a4da2e3e DG	347	}
	348	;
	349
cd296721 SW	350	integer_expr:
	351	integer_trinary
	352	;
	353
	354	integer_trinary:
	355	integer_or
	356	\| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
	357	;
	358
	359	integer_or:
	360	integer_and
	361	\| integer_or DT_OR integer_and { $$ = $1 \|\| $3; }
	362	;
	363
	364	integer_and:
	365	integer_bitor
	366	\| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
	367	;
	368
	369	integer_bitor:
	370	integer_bitxor
	371	\| integer_bitor '\|' integer_bitxor { $$ = $1 \| $3; }
	372	;
	373
	374	integer_bitxor:
	375	integer_bitand
	376	\| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
	377	;
	378
	379	integer_bitand:
	380	integer_eq
	381	\| integer_bitand '&' integer_eq { $$ = $1 & $3; }
	382	;
	383
	384	integer_eq:
	385	integer_rela
	386	\| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
	387	\| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
	388	;
	389
	390	integer_rela:
	391	integer_shift
	392	\| integer_rela '<' integer_shift { $$ = $1 < $3; }
	393	\| integer_rela '>' integer_shift { $$ = $1 > $3; }
	394	\| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
	395	\| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
	396	;
	397
	398	integer_shift:
	399	integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
	400	\| integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
	401	\| integer_add
	402	;
	403
	404	integer_add:
	405	integer_add '+' integer_mul { $$ = $1 + $3; }
	406	\| integer_add '-' integer_mul { $$ = $1 - $3; }
	407	\| integer_mul
	408	;
	409
	410	integer_mul:
	411	integer_mul '' integer_unary { $$ = $1 $3; }
	412	\| integer_mul '/' integer_unary { $$ = $1 / $3; }
	413	\| integer_mul '%' integer_unary { $$ = $1 % $3; }
414	\| integer_unary
415	;
416
417	integer_unary:
418	integer_prim
419	\| '-' integer_unary { $$ = -$2; }
420	\| '~' integer_unary { $$ = ~$2; }
421	\| '!' integer_unary { $$ = !$2; }
a4da2e3e DG	422	;
	423
	424	bytestring:
	425	/* empty */
	426	{
	427	$$ = empty_data;
	428	}
	429	\| bytestring DT_BYTE
	430	{
	431	$$ = data_append_byte($1, $2);
	432	}
	433	\| bytestring DT_LABEL
	434	{
	435	$$ = data_add_marker($1, LABEL, $2);
	436	}
	437	;
	438
	439	subnodes:
	440	/* empty */
	441	{
	442	$$ = NULL;
	443	}
658f29a5	444	\| subnode subnodes
a4da2e3e DG	445	{
	446	$$ = chain_node($1, $2);
	447	}
	448	\| subnode propdef
	449	{
658f29a5	450	print_error("syntax error: properties must precede subnodes");
a4da2e3e DG	451	YYERROR;
	452	}
	453	;
	454
	455	subnode:
658f29a5	456	DT_PROPNODENAME nodedef
a4da2e3e	457	{
658f29a5	458	$$ = name_node($2, $1);
a4da2e3e	459	}
cd296721 SW	460	\| DT_DEL_NODE DT_PROPNODENAME ';'
	461	{
	462	$$ = name_node(build_node_delete(), $2);
	463	}
658f29a5	464	\| DT_LABEL subnode
a4da2e3e	465	{
658f29a5 JB	466	add_label(&$2->labels, $1);
658f29a5 JB	467	$$ = $2;
a4da2e3e DG	468	}
	469	;
	470
	471	%%
	472
658f29a5	473	void print_error(char const *fmt, ...)
a4da2e3e	474	{
ed95d745	475	va_list va;
a4da2e3e	476
658f29a5 JB	477	va_start(va, fmt);
	478	srcpos_verror(&yylloc, fmt, va);
	479	va_end(va);
ed95d745 DG	480
ed95d745 DG	481	treesource_error = 1;
ed95d745 DG	482	}
ed95d745 DG	483
658f29a5 JB	484	void yyerror(char const *s) {
658f29a5 JB	485	print_error("%s", s);
a4da2e3e DG	486	}
a4da2e3e DG	487
ed95d745	488	static unsigned long long eval_literal(const char *s, int base, int bits)
a4da2e3e DG	489	{
	490	unsigned long long val;
	491	char *e;
	492
	493	errno = 0;
	494	val = strtoull(s, &e, base);
cd296721 SW	495	if (*e) {
	496	size_t uls = strspn(e, "UL");
	497	if (e[uls])
	498	print_error("bad characters in literal");
	499	}
	500	if ((errno == ERANGE)
a4da2e3e	501	\|\| ((bits < 64) && (val >= (1ULL << bits))))
658f29a5	502	print_error("literal out of range");
a4da2e3e	503	else if (errno != 0)
658f29a5	504	print_error("bad literal");
a4da2e3e DG	505	return val;
a4da2e3e DG	506	}
cd296721 SW	507
	508	static unsigned char eval_char_literal(const char *s)
	509	{
	510	int i = 1;
	511	char c = s[0];
	512
	513	if (c == '\0')
	514	{
	515	print_error("empty character literal");
	516	return 0;
	517	}
	518
	519	/*
	520	* If the first character in the character literal is a \ then process
	521	* the remaining characters as an escape encoding. If the first
	522	* character is neither an escape or a terminator it should be the only
	523	* character in the literal and will be returned.
	524	*/
	525	if (c == '\\')
	526	c = get_escape_char(s, &i);
	527
	528	if (s[i] != '\0')
	529	print_error("malformed character literal");
	530
	531	return c;
	532	}