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