Loading...
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
14extern int yylex(void);
15extern 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
24extern struct dt_info *parser_output;
25extern bool treesource_error;
26
27static 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
106sourcefile:
107 headers memreserves devicetree
108 {
109 parser_output = build_dt_info($1, $2, $3,
110 guess_boot_cpuid($3));
111 }
112 ;
113
114header:
115 DT_V1 ';'
116 {
117 $$ = DTSF_V1;
118 }
119 | DT_V1 ';' DT_PLUGIN ';'
120 {
121 $$ = DTSF_V1 | DTSF_PLUGIN;
122 }
123 ;
124
125headers:
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
135memreserves:
136 /* empty */
137 {
138 $$ = NULL;
139 }
140 | memreserve memreserves
141 {
142 $$ = chain_reserve_entry($1, $2);
143 }
144 ;
145
146memreserve:
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
158dt_ref: DT_LABEL_REF | DT_PATH_REF;
159
160devicetree:
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
265nodedef:
266 '{' proplist subnodes '}' ';'
267 {
268 $$ = build_node($2, $3, &@$);
269 }
270 ;
271
272proplist:
273 /* empty */
274 {
275 $$ = NULL;
276 }
277 | proplist propdef
278 {
279 $$ = chain_property($2, $1);
280 }
281 ;
282
283propdef:
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
306propdata:
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
356propdataprefix:
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
371arrayprefix:
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
442integer_prim:
443 DT_LITERAL
444 | DT_CHAR_LITERAL
445 | '(' integer_expr ')'
446 {
447 $$ = $2;
448 }
449 ;
450
451integer_expr:
452 integer_trinary
453 ;
454
455integer_trinary:
456 integer_or
457 | integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
458 ;
459
460integer_or:
461 integer_and
462 | integer_or DT_OR integer_and { $$ = $1 || $3; }
463 ;
464
465integer_and:
466 integer_bitor
467 | integer_and DT_AND integer_bitor { $$ = $1 && $3; }
468 ;
469
470integer_bitor:
471 integer_bitxor
472 | integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
473 ;
474
475integer_bitxor:
476 integer_bitand
477 | integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
478 ;
479
480integer_bitand:
481 integer_eq
482 | integer_bitand '&' integer_eq { $$ = $1 & $3; }
483 ;
484
485integer_eq:
486 integer_rela
487 | integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
488 | integer_eq DT_NE integer_rela { $$ = $1 != $3; }
489 ;
490
491integer_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
499integer_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
505integer_add:
506 integer_add '+' integer_mul { $$ = $1 + $3; }
507 | integer_add '-' integer_mul { $$ = $1 - $3; }
508 | integer_mul
509 ;
510
511integer_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
534integer_unary:
535 integer_prim
536 | '-' integer_unary { $$ = -$2; }
537 | '~' integer_unary { $$ = ~$2; }
538 | '!' integer_unary { $$ = !$2; }
539 ;
540
541bytestring:
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
556subnodes:
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
572subnode:
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
596void yyerror(char const *s)
597{
598 ERROR(&yylloc, "%s", s);
599}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005.
4 */
5%{
6#include <stdio.h>
7#include <inttypes.h>
8
9#include "dtc.h"
10#include "srcpos.h"
11
12extern int yylex(void);
13extern void yyerror(char const *s);
14#define ERROR(loc, ...) \
15 do { \
16 srcpos_error((loc), "Error", __VA_ARGS__); \
17 treesource_error = true; \
18 } while (0)
19
20extern struct dt_info *parser_output;
21extern bool treesource_error;
22%}
23
24%union {
25 char *propnodename;
26 char *labelref;
27 uint8_t byte;
28 struct data data;
29
30 struct {
31 struct data data;
32 int bits;
33 } array;
34
35 struct property *prop;
36 struct property *proplist;
37 struct node *node;
38 struct node *nodelist;
39 struct reserve_info *re;
40 uint64_t integer;
41 unsigned int flags;
42}
43
44%token DT_V1
45%token DT_PLUGIN
46%token DT_MEMRESERVE
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
51%token DT_OMIT_NO_REF
52%token <propnodename> DT_PROPNODENAME
53%token <integer> DT_LITERAL
54%token <integer> DT_CHAR_LITERAL
55%token <byte> DT_BYTE
56%token <data> DT_STRING
57%token <labelref> DT_LABEL
58%token <labelref> DT_LABEL_REF
59%token <labelref> DT_PATH_REF
60%token DT_INCBIN
61
62%type <data> propdata
63%type <data> propdataprefix
64%type <flags> header
65%type <flags> headers
66%type <re> memreserve
67%type <re> memreserves
68%type <array> arrayprefix
69%type <data> bytestring
70%type <prop> propdef
71%type <proplist> proplist
72%type <labelref> dt_ref
73
74%type <node> devicetree
75%type <node> nodedef
76%type <node> subnode
77%type <nodelist> subnodes
78
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
94%%
95
96sourcefile:
97 headers memreserves devicetree
98 {
99 parser_output = build_dt_info($1, $2, $3,
100 guess_boot_cpuid($3));
101 }
102 ;
103
104header:
105 DT_V1 ';'
106 {
107 $$ = DTSF_V1;
108 }
109 | DT_V1 ';' DT_PLUGIN ';'
110 {
111 $$ = DTSF_V1 | DTSF_PLUGIN;
112 }
113 ;
114
115headers:
116 header
117 | header headers
118 {
119 if ($2 != $1)
120 ERROR(&@2, "Header flags don't match earlier ones");
121 $$ = $1;
122 }
123 ;
124
125memreserves:
126 /* empty */
127 {
128 $$ = NULL;
129 }
130 | memreserve memreserves
131 {
132 $$ = chain_reserve_entry($1, $2);
133 }
134 ;
135
136memreserve:
137 DT_MEMRESERVE integer_prim integer_prim ';'
138 {
139 $$ = build_reserve_entry($2, $3);
140 }
141 | DT_LABEL memreserve
142 {
143 add_label(&$2->labels, $1);
144 $$ = $2;
145 }
146 ;
147
148dt_ref: DT_LABEL_REF | DT_PATH_REF;
149
150devicetree:
151 '/' nodedef
152 {
153 $$ = name_node($2, "");
154 }
155 | devicetree '/' nodedef
156 {
157 $$ = merge_nodes($1, $3);
158 }
159 | dt_ref nodedef
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);
168 $$ = add_orphan_node(
169 name_node(build_node(NULL, NULL, NULL),
170 ""),
171 $2, $1);
172 }
173 | devicetree DT_LABEL dt_ref nodedef
174 {
175 struct node *target = get_node_by_ref($1, $3);
176
177 if (target) {
178 add_label(&target->labels, $2);
179 merge_nodes(target, $4);
180 } else
181 ERROR(&@3, "Label or path %s not found", $3);
182 $$ = $1;
183 }
184 | devicetree DT_PATH_REF nodedef
185 {
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);
193 } else {
194 struct node *target = get_node_by_ref($1, $2);
195
196 if (target)
197 merge_nodes(target, $3);
198 else
199 ERROR(&@2, "Label or path %s not found", $2);
200 }
201 $$ = $1;
202 }
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 ';'
223 {
224 struct node *target = get_node_by_ref($1, $3);
225
226 if (target)
227 delete_node(target);
228 else
229 ERROR(&@3, "Label or path %s not found", $3);
230
231
232 $$ = $1;
233 }
234 | devicetree DT_OMIT_NO_REF dt_ref ';'
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
244 $$ = $1;
245 }
246 ;
247
248nodedef:
249 '{' proplist subnodes '}' ';'
250 {
251 $$ = build_node($2, $3, &@$);
252 }
253 ;
254
255proplist:
256 /* empty */
257 {
258 $$ = NULL;
259 }
260 | proplist propdef
261 {
262 $$ = chain_property($2, $1);
263 }
264 ;
265
266propdef:
267 DT_PROPNODENAME '=' propdata ';'
268 {
269 $$ = build_property($1, $3, &@$);
270 }
271 | DT_PROPNODENAME ';'
272 {
273 $$ = build_property($1, empty_data, &@$);
274 }
275 | DT_DEL_PROP DT_PROPNODENAME ';'
276 {
277 $$ = build_property_delete($2);
278 }
279 | DT_LABEL propdef
280 {
281 add_label(&$2->labels, $1);
282 $$ = $2;
283 }
284 ;
285
286propdata:
287 propdataprefix DT_STRING
288 {
289 $$ = data_merge($1, $2);
290 }
291 | propdataprefix arrayprefix '>'
292 {
293 $$ = data_merge($1, $2.data);
294 }
295 | propdataprefix '[' bytestring ']'
296 {
297 $$ = data_merge($1, $3);
298 }
299 | propdataprefix dt_ref
300 {
301 $1 = data_add_marker($1, TYPE_STRING, $2);
302 $$ = data_add_marker($1, REF_PATH, $2);
303 }
304 | propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
305 {
306 FILE *f = srcfile_relative_open($4.val, NULL);
307 struct data d;
308
309 if ($6 != 0)
310 if (fseek(f, $6, SEEK_SET) != 0)
311 die("Couldn't seek to offset %llu in \"%s\": %s",
312 (unsigned long long)$6, $4.val,
313 strerror(errno));
314
315 d = data_copy_file(f, $8);
316
317 $$ = data_merge($1, d);
318 fclose(f);
319 }
320 | propdataprefix DT_INCBIN '(' DT_STRING ')'
321 {
322 FILE *f = srcfile_relative_open($4.val, NULL);
323 struct data d = empty_data;
324
325 d = data_copy_file(f, -1);
326
327 $$ = data_merge($1, d);
328 fclose(f);
329 }
330 | propdata DT_LABEL
331 {
332 $$ = data_add_marker($1, LABEL, $2);
333 }
334 ;
335
336propdataprefix:
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
351arrayprefix:
352 DT_BITS DT_LITERAL '<'
353 {
354 unsigned long long bits;
355 enum markertype type = TYPE_UINT32;
356
357 bits = $2;
358
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:
365 ERROR(&@2, "Array elements must be"
366 " 8, 16, 32 or 64-bits");
367 bits = 32;
368 }
369
370 $$.data = data_add_marker(empty_data, type, NULL);
371 $$.bits = bits;
372 }
373 | '<'
374 {
375 $$.data = data_add_marker(empty_data, TYPE_UINT32, NULL);
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))
391 ERROR(&@2, "Value out of range for"
392 " %d-bit array element", $1.bits);
393 }
394
395 $$.data = data_append_integer($1.data, $2, $1.bits);
396 }
397 | arrayprefix dt_ref
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
406 ERROR(&@2, "References are only allowed in "
407 "arrays with 32-bit elements.");
408
409 $$.data = data_append_integer($1.data, val, $1.bits);
410 }
411 | arrayprefix DT_LABEL
412 {
413 $$.data = data_add_marker($1.data, LABEL, $2);
414 }
415 ;
416
417integer_prim:
418 DT_LITERAL
419 | DT_CHAR_LITERAL
420 | '(' integer_expr ')'
421 {
422 $$ = $2;
423 }
424 ;
425
426integer_expr:
427 integer_trinary
428 ;
429
430integer_trinary:
431 integer_or
432 | integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
433 ;
434
435integer_or:
436 integer_and
437 | integer_or DT_OR integer_and { $$ = $1 || $3; }
438 ;
439
440integer_and:
441 integer_bitor
442 | integer_and DT_AND integer_bitor { $$ = $1 && $3; }
443 ;
444
445integer_bitor:
446 integer_bitxor
447 | integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
448 ;
449
450integer_bitxor:
451 integer_bitand
452 | integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
453 ;
454
455integer_bitand:
456 integer_eq
457 | integer_bitand '&' integer_eq { $$ = $1 & $3; }
458 ;
459
460integer_eq:
461 integer_rela
462 | integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
463 | integer_eq DT_NE integer_rela { $$ = $1 != $3; }
464 ;
465
466integer_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
474integer_shift:
475 integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
476 | integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
477 | integer_add
478 ;
479
480integer_add:
481 integer_add '+' integer_mul { $$ = $1 + $3; }
482 | integer_add '-' integer_mul { $$ = $1 - $3; }
483 | integer_mul
484 ;
485
486integer_mul:
487 integer_mul '*' integer_unary { $$ = $1 * $3; }
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 }
506 | integer_unary
507 ;
508
509integer_unary:
510 integer_prim
511 | '-' integer_unary { $$ = -$2; }
512 | '~' integer_unary { $$ = ~$2; }
513 | '!' integer_unary { $$ = !$2; }
514 ;
515
516bytestring:
517 /* empty */
518 {
519 $$ = data_add_marker(empty_data, TYPE_UINT8, NULL);
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
531subnodes:
532 /* empty */
533 {
534 $$ = NULL;
535 }
536 | subnode subnodes
537 {
538 $$ = chain_node($1, $2);
539 }
540 | subnode propdef
541 {
542 ERROR(&@2, "Properties must precede subnodes");
543 YYERROR;
544 }
545 ;
546
547subnode:
548 DT_PROPNODENAME nodedef
549 {
550 $$ = name_node($2, $1);
551 }
552 | DT_DEL_NODE DT_PROPNODENAME ';'
553 {
554 $$ = name_node(build_node_delete(&@$), $2);
555 }
556 | DT_OMIT_NO_REF subnode
557 {
558 $$ = omit_node_if_unused($2);
559 }
560 | DT_LABEL subnode
561 {
562 add_label(&$2->labels, $1);
563 $$ = $2;
564 }
565 ;
566
567%%
568
569void yyerror(char const *s)
570{
571 ERROR(&yylloc, "%s", s);
572}