scripts/dtc/dtc-parser.y

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
print_error
yyerror
eval_literal
eval_char_literal
/*
 * (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;
}
/* [<][>][^][v][top][bottom][index][help] */
root/scripts/dtc/dtc-parser.y

DEFINITIONS
