// 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;

  %}
  
  %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 { $$ = ($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);

  		}

  	| 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);

  }