aboutsummaryrefslogtreecommitdiff
path: root/gcc/d/expr.cc
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/d/expr.cc')
-rw-r--r--gcc/d/expr.cc64
1 files changed, 32 insertions, 32 deletions
diff --git a/gcc/d/expr.cc b/gcc/d/expr.cc
index d1e71f9..461124f 100644
--- a/gcc/d/expr.cc
+++ b/gcc/d/expr.cc
@@ -1642,7 +1642,7 @@ public:
{
StructDeclaration *sd = ((TypeStruct *) tnext)->sym;
- for (size_t i = 0; i < sd->fields.dim; i++)
+ for (size_t i = 0; i < sd->fields.length; i++)
{
VarDeclaration *field = sd->fields[i];
@@ -2439,7 +2439,7 @@ public:
{
/* If we have a user supplied initializer, then set-up with a
struct literal. */
- if (e->arguments != NULL && sd->fields.dim != 0)
+ if (e->arguments != NULL && sd->fields.length != 0)
{
StructLiteralExp *se = StructLiteralExp::create (e->loc, sd,
e->arguments,
@@ -2464,9 +2464,9 @@ public:
TypeDArray *tarray = (TypeDArray *) tb;
gcc_assert (!e->allocator);
- gcc_assert (e->arguments && e->arguments->dim >= 1);
+ gcc_assert (e->arguments && e->arguments->length >= 1);
- if (e->arguments->dim == 1)
+ if (e->arguments->length == 1)
{
/* Single dimension array allocations. */
Expression *arg = (*e->arguments)[0];
@@ -2488,14 +2488,14 @@ public:
else
{
/* Multidimensional array allocations. */
- tree tarray = make_array_type (Type::tsize_t, e->arguments->dim);
+ tree tarray = make_array_type (Type::tsize_t, e->arguments->length);
tree var = build_local_temp (tarray);
vec<constructor_elt, va_gc> *elms = NULL;
/* Get the base element type for the array, generating the
initializer for the dims parameter along the way. */
Type *telem = e->newtype->toBasetype ();
- for (size_t i = 0; i < e->arguments->dim; i++)
+ for (size_t i = 0; i < e->arguments->length; i++)
{
Expression *arg = (*e->arguments)[i];
CONSTRUCTOR_APPEND_ELT (elms, size_int (i), build_expr (arg));
@@ -2516,7 +2516,7 @@ public:
tree tinfo = build_typeinfo (e->loc, e->type);
tree dims = d_array_value (build_ctype (Type::tsize_t->arrayOf ()),
- size_int (e->arguments->dim),
+ size_int (e->arguments->length),
build_address (var));
result = build_libcall (libcall, tb, 2, tinfo, dims);
@@ -2544,7 +2544,7 @@ public:
tree arg = build_typeinfo (e->loc, e->newtype);
result = build_libcall (libcall, tb, 1, arg);
- if (e->arguments && e->arguments->dim == 1)
+ if (e->arguments && e->arguments->length == 1)
{
result = d_save_expr (result);
tree init = modify_expr (build_deref (result),
@@ -2661,7 +2661,7 @@ public:
if (e->e0)
result = build_expr (e->e0);
- for (size_t i = 0; i < e->exps->dim; ++i)
+ for (size_t i = 0; i < e->exps->length; ++i)
{
Expression *exp = (*e->exps)[i];
result = compound_expr (result, build_expr (exp));
@@ -2688,7 +2688,7 @@ public:
gcc_assert (tb->ty == Tarray || tb->ty == Tsarray || tb->ty == Tpointer);
/* Handle empty array literals. */
- if (e->elements->dim == 0)
+ if (e->elements->length == 0)
{
if (tb->ty == Tarray)
this->result_ = d_array_value (build_ctype (e->type),
@@ -2703,14 +2703,14 @@ public:
/* Build an expression that assigns the expressions in ELEMENTS to
a constructor. */
vec<constructor_elt, va_gc> *elms = NULL;
- vec_safe_reserve (elms, e->elements->dim);
+ vec_safe_reserve (elms, e->elements->length);
bool constant_p = true;
tree saved_elems = NULL_TREE;
Type *etype = tb->nextOf ();
- tree satype = make_array_type (etype, e->elements->dim);
+ tree satype = make_array_type (etype, e->elements->length);
- for (size_t i = 0; i < e->elements->dim; i++)
+ for (size_t i = 0; i < e->elements->length; i++)
{
Expression *expr = e->getElement (i);
tree value = build_expr (expr, this->constp_);
@@ -2749,7 +2749,7 @@ public:
tree decl = build_artificial_decl (TREE_TYPE (ctor), ctor, "A");
ctor = build_address (decl);
if (tb->ty == Tarray)
- ctor = d_array_value (type, size_int (e->elements->dim), ctor);
+ ctor = d_array_value (type, size_int (e->elements->length), ctor);
d_pushdecl (decl);
rest_of_decl_compilation (decl, 1, 0);
@@ -2769,12 +2769,12 @@ public:
tree mem = build_libcall (LIBCALL_ARRAYLITERALTX,
etype->pointerTo (), 2,
build_typeinfo (e->loc, etype->arrayOf ()),
- size_int (e->elements->dim));
+ size_int (e->elements->length));
mem = d_save_expr (mem);
/* Now copy the constructor into memory. */
tree tmemcpy = builtin_decl_explicit (BUILT_IN_MEMCPY);
- tree size = size_mult_expr (size_int (e->elements->dim),
+ tree size = size_mult_expr (size_int (e->elements->length),
size_int (tb->nextOf ()->size ()));
tree result = build_call_expr (tmemcpy, 3, mem,
@@ -2784,7 +2784,7 @@ public:
result = compound_expr (result, mem);
if (tb->ty == Tarray)
- result = d_array_value (type, size_int (e->elements->dim), result);
+ result = d_array_value (type, size_int (e->elements->length), result);
this->result_ = compound_expr (saved_elems, result);
}
@@ -2802,7 +2802,7 @@ public:
/* Handle empty assoc array literals. */
TypeAArray *ta = (TypeAArray *) tb;
- if (e->keys->dim == 0)
+ if (e->keys->length == 0)
{
this->result_ = build_constructor (build_ctype (ta), NULL);
return;
@@ -2811,35 +2811,35 @@ public:
/* Build an expression that assigns all expressions in KEYS
to a constructor. */
vec<constructor_elt, va_gc> *kelts = NULL;
- vec_safe_reserve (kelts, e->keys->dim);
- for (size_t i = 0; i < e->keys->dim; i++)
+ vec_safe_reserve (kelts, e->keys->length);
+ for (size_t i = 0; i < e->keys->length; i++)
{
Expression *key = (*e->keys)[i];
tree t = build_expr (key);
CONSTRUCTOR_APPEND_ELT (kelts, size_int (i),
convert_expr (t, key->type, ta->index));
}
- tree tkeys = make_array_type (ta->index, e->keys->dim);
+ tree tkeys = make_array_type (ta->index, e->keys->length);
tree akeys = build_constructor (tkeys, kelts);
/* Do the same with all expressions in VALUES. */
vec<constructor_elt, va_gc> *velts = NULL;
- vec_safe_reserve (velts, e->values->dim);
- for (size_t i = 0; i < e->values->dim; i++)
+ vec_safe_reserve (velts, e->values->length);
+ for (size_t i = 0; i < e->values->length; i++)
{
Expression *value = (*e->values)[i];
tree t = build_expr (value);
CONSTRUCTOR_APPEND_ELT (velts, size_int (i),
convert_expr (t, value->type, ta->next));
}
- tree tvals = make_array_type (ta->next, e->values->dim);
+ tree tvals = make_array_type (ta->next, e->values->length);
tree avals = build_constructor (tvals, velts);
/* Generate: _d_assocarrayliteralTX (ti, keys, vals); */
tree keys = d_array_value (build_ctype (ta->index->arrayOf ()),
- size_int (e->keys->dim), build_address (akeys));
+ size_int (e->keys->length), build_address (akeys));
tree vals = d_array_value (build_ctype (ta->next->arrayOf ()),
- size_int (e->values->dim),
+ size_int (e->values->length),
build_address (avals));
tree mem = build_libcall (LIBCALL_ASSOCARRAYLITERALTX, Type::tvoidptr, 3,
@@ -2859,7 +2859,7 @@ public:
void visit (StructLiteralExp *e)
{
/* Handle empty struct literals. */
- if (e->elements == NULL || e->sd->fields.dim == 0)
+ if (e->elements == NULL || e->sd->fields.length == 0)
{
this->result_ = build_constructor (build_ctype (e->type), NULL);
return;
@@ -2879,12 +2879,12 @@ public:
tree saved_elems = NULL_TREE;
/* CTFE may fill the hidden pointer by NullExp. */
- gcc_assert (e->elements->dim <= e->sd->fields.dim);
+ gcc_assert (e->elements->length <= e->sd->fields.length);
Type *tb = e->type->toBasetype ();
gcc_assert (tb->ty == Tstruct);
- for (size_t i = 0; i < e->elements->dim; i++)
+ for (size_t i = 0; i < e->elements->length; i++)
{
Expression *exp = (*e->elements)[i];
if (!exp)
@@ -2921,7 +2921,7 @@ public:
}
/* Maybe setup hidden pointer to outer scope context. */
- if (e->sd->isNested () && e->elements->dim != e->sd->fields.dim
+ if (e->sd->isNested () && e->elements->length != e->sd->fields.length
&& this->constp_ == false)
{
tree field = get_symbol_decl (e->sd->vthis);
@@ -2989,8 +2989,8 @@ public:
vec<constructor_elt, va_gc> *elms = NULL;
bool constant_p = true;
- vec_safe_reserve (elms, ale->elements->dim);
- for (size_t i = 0; i < ale->elements->dim; i++)
+ vec_safe_reserve (elms, ale->elements->length);
+ for (size_t i = 0; i < ale->elements->length; i++)
{
Expression *expr = ale->getElement (i);
tree value = d_convert (etype, build_expr (expr, this->constp_));
generated by cgit v1.1 at 2025-05-22 03:01:41 +0000