Both string and bytestring expression values are represented by a
bytestring internally to handle things like "\0abc". So, the only real
distinction is that string expressions must evaluate to a bytestring which
has a \0 in the last bye. For now the only actual "expressions" of these
types are literals, but we'll expand on that later.
Signed-off-by: David Gibson <david@xxxxxxxxxxxxxxxxxxxxx>
---
data.c | 26 ++++++++++++++++--
dtc-parser.y | 58 +++++++++++++++++++++++++++++++---------
dtc.h | 10 +++++++
expression.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
4 files changed, 165 insertions(+), 16 deletions(-)
diff --git a/data.c b/data.c
index 4c50b12..4db1f2f 100644
--- a/data.c
+++ b/data.c
@@ -237,12 +237,17 @@ struct data data_append_align(struct data d, int align)
return data_append_zeroes(d, newlen - d.len);
}
-struct data data_add_marker(struct data d, enum markertype type, char *ref)
+static struct data data_add_marker_at(struct data d, enum markertype type,
+ int offset, char *ref)
{
struct marker *m;
+ m = d.markers;
+ for_each_marker(m)
+ assert(m->offset <= offset);
+
m = xmalloc(sizeof(*m));
- m->offset = d.len;
+ m->offset = offset;
m->type = type;
m->ref = ref;
m->next = NULL;
@@ -250,6 +255,11 @@ struct data data_add_marker(struct data d, enum markertype type, char *ref)
return data_append_markers(d, m);
}
+struct data data_add_marker(struct data d, enum markertype type, char *ref)
+{
+ return data_add_marker_at(d, type, d.len, ref);
+}
+
bool data_is_one_string(struct data d)
{
int i;
@@ -267,3 +277,15 @@ bool data_is_one_string(struct data d)
return true;
}
+
+struct data data_clone(struct data d)
+{
+ struct data clone = data_copy_mem(d.val, d.len);
+ struct marker *m = d.markers;
+
+ for_each_marker(m)
+ clone = data_add_marker_at(clone, m->type,
+ m->offset, strdup(m->ref));
+
+ return clone;
+}
diff --git a/dtc-parser.y b/dtc-parser.y
index fbf5f3c..e4df947 100644
--- a/dtc-parser.y
+++ b/dtc-parser.y
@@ -35,6 +35,8 @@ extern struct boot_info *the_boot_info;
extern bool treesource_error;
static uint64_t expr_int(struct expression *expr);
+static const char *expr_str(struct expression *expr);
+static struct data expr_bytestring(struct expression *expr);
#define UNOP(loc, op, a) (expression_##op(&loc, (a)))
#define BINOP(loc, op, a, b) (expression_##op(&loc, (a), (b)))
@@ -80,7 +82,7 @@ static uint64_t expr_int(struct expression *expr);
%type <re> memreserve
%type <re> memreserves
%type <array> arrayprefix
-%type <data> bytestring
+%type <data> bytestring_literal
%type <prop> propdef
%type <proplist> proplist
@@ -209,32 +211,30 @@ propdef:
;
propdata:
- propdataprefix DT_STRING
+ propdataprefix expr
{
- $$ = data_merge($1, $2);
+ struct data d = expr_bytestring($2);
+ $$ = data_merge($1, d);
}
| 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 ',' expr_prim ',' expr_prim ')'
+ | propdataprefix DT_INCBIN '(' expr_prim ',' expr_prim ',' expr_prim ')'
{
- FILE *f = srcfile_relative_open($4.val, NULL);
+ const char *filename = expr_str($4);
+ FILE *f = srcfile_relative_open(filename, NULL);
off_t offset = expr_int($6);
struct data d;
if (offset != 0)
if (fseek(f, offset, SEEK_SET) != 0)
die("Couldn't seek to offset %llu in \"%s\": %s",
- (unsigned long long)offset, $4.val,
+ (unsigned long long)offset, filename,
strerror(errno));
d = data_copy_file(f, expr_int($8));
@@ -339,6 +339,14 @@ arrayprefix:
expr_prim:
DT_LITERAL { $$ = expression_integer_constant(&yylloc, $1); }
| DT_CHAR_LITERAL { $$ = expression_integer_constant(&yylloc, $1); }
+ | DT_STRING
+ {
+ $$ = expression_string_constant(&yylloc, $1);
+ }
+ | '[' bytestring_literal ']'
+ {
+ $$ = expression_bytestring_constant(&@2, $2);
+ }
| '(' expr ')'
{
$$ = $2;
@@ -422,16 +430,16 @@ expr_unary:
| '!' expr_unary { $$ = UNOP(@$, logic_not, $2); }
;
-bytestring:
+bytestring_literal:
/* empty */
{
$$ = empty_data;
}
- | bytestring DT_BYTE
+ | bytestring_literal DT_BYTE
{
$$ = data_append_byte($1, $2);
}
- | bytestring DT_LABEL
+ | bytestring_literal DT_LABEL
{
$$ = data_add_marker($1, LABEL, $2);
}
@@ -487,3 +495,27 @@ static uint64_t expr_int(struct expression *expr)
assert(v.type == EXPR_INTEGER);
return v.value.integer;
}
+
+static const char *expr_str(struct expression *expr)
+{
+ struct expression_value v = expression_evaluate(expr, EXPR_STRING);
+
+ if (v.type == EXPR_VOID) {
+ treesource_error = true;
+ return "";
+ }
+ assert(v.type == EXPR_STRING);
+ return v.value.d.val;
+}
+
+static struct data expr_bytestring(struct expression *expr)
+{
+ struct expression_value v = expression_evaluate(expr, EXPR_BYTESTRING);
+
+ if (v.type == EXPR_VOID) {
+ treesource_error = true;
+ return empty_data;
+ }
+ assert(v.type == EXPR_BYTESTRING);
+ return v.value.d;
+}
diff --git a/dtc.h b/dtc.h
index 95ed75e..0b644d2 100644
--- a/dtc.h
+++ b/dtc.h
@@ -120,6 +120,8 @@ struct data data_add_marker(struct data d, enum markertype type, char *ref);
bool data_is_one_string(struct data d);
+struct data data_clone(struct data d);
+
/* DT constraints */
#define MAX_PROPNAME_LEN 31
@@ -226,12 +228,15 @@ struct srcpos;
enum expr_type {
EXPR_VOID = 0, /* Missing or unspecified type */
EXPR_INTEGER,
+ EXPR_STRING,
+ EXPR_BYTESTRING,
};
struct expression_value {
enum expr_type type;
union {
uint64_t integer;
+ struct data d;
} value;
};
@@ -252,6 +257,11 @@ struct expression_value expression_evaluate(struct expression *expr,
struct expression *expression_integer_constant(struct srcpos *pos,
uint64_t val);
+struct expression *expression_string_constant(struct srcpos *pos,
+ struct data d);
+struct expression *expression_bytestring_constant(struct srcpos *pos,
+ struct data val);
+
#define DEF_UNARY_OP(nm) \
struct expression *expression_##nm(struct srcpos *, \
struct expression *)
diff --git a/expression.c b/expression.c
index a89eea3..4ecd84a 100644
--- a/expression.c
+++ b/expression.c
@@ -29,11 +29,49 @@ static const char *expression_typename(enum expr_type t)
case EXPR_INTEGER:
return "integer";
+ case EXPR_STRING:
+ return "string";
+
+ case EXPR_BYTESTRING:
+ return "bytestring";
+
default:
assert(0);
}
}
+static struct expression_value value_clone(struct expression_value val)
+{
+ struct expression_value clone = val;
+
+ switch (val.type) {
+ case EXPR_STRING:
+ case EXPR_BYTESTRING:
+ clone.value.d = data_clone(val.value.d);
+ break;
+
+ default:
+ /* nothing more to do */
+ ;
+ }
+
+ return clone;
+}
+
+static void value_free(struct expression_value val)
+{
+ switch (val.type) {
+ case EXPR_STRING:
+ case EXPR_BYTESTRING:
+ data_free(val.value.d);
+ break;
+
+ default:
+ /* nothing to do */
+ ;
+ }
+}
+
struct operator {
const char *name;
unsigned nargs;
@@ -106,6 +144,11 @@ struct expression_value expression_evaluate(struct expression *expr,
{
struct expression_value v = expr->op->evaluate(expr, context);
+ /* Strings can be promoted to bytestrings */
+ if ((v.type == EXPR_STRING)
+ && (context == EXPR_BYTESTRING))
+ v.type = EXPR_BYTESTRING;
+
if ((context != EXPR_VOID) && (context != v.type))
return type_error(expr, "Expected %s expression (found %s)",
expression_typename(context),
@@ -128,15 +171,35 @@ struct expression_value expression_evaluate(struct expression *expr,
(_vi) = (_v).value.integer; \
} while (0)
+#define EVALUATE_STR(_vs, _ex) \
+ do { \
+ struct expression_value _v; \
+ EVALUATE(_v, (_ex), EXPR_STRING); \
+ (_vs) = (_v).value.d; \
+ } while (0)
+
+#define EVALUATE_BS(_vd, _ex) \
+ do { \
+ struct expression_value _v; \
+ EVALUATE(_v, (_ex), EXPR_BYTESTRING); \
+ (_vd) = (_v).value.d; \
+ } while (0)
+
static struct expression_value op_eval_constant(struct expression *expr,
enum expr_type context)
{
assert(expr->nargs == 0);
- return expr->u.constant;
+ return value_clone(expr->u.constant);
+}
+static void op_free_constant(struct expression *expr)
+{
+ value_free(expr->u.constant);
}
+
static struct operator op_constant = {
.name = "constant",
.evaluate = op_eval_constant,
+ .free = op_free_constant,
};
static struct expression *__expression_constant(struct srcpos *loc,
@@ -159,6 +222,28 @@ struct expression *expression_integer_constant(struct srcpos *pos,
return __expression_constant(pos, v);
}
+struct expression *expression_string_constant(struct srcpos *pos,
+ struct data val)
+{
+ struct expression_value v = {
+ .type = EXPR_STRING,
+ .value.d = val,
+ };
+
+ return __expression_constant(pos, v);
+}
+
+struct expression *expression_bytestring_constant(struct srcpos *pos,
+ struct data val)
+{
+ struct expression_value v = {
+ .type = EXPR_BYTESTRING,
+ .value.d = val,
+ };
+
+ return __expression_constant(pos, v);
+}
+
#define INT_UNARY_OP(nm, cop) \
static struct expression_value op_eval_##nm(struct expression *expr, \
enum expr_type context) \
--
1.8.5.3
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
