| /* |
| * (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 bool 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 = true; |
| } |
| |
| 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; |
| } |