&& !vec_safe_is_empty (user_args))
{
/* Create a CONSTRUCTOR from ARGS, e.g. {1, 2} from <1, 2>. */
- tree list = build_tree_list_vec (user_args);
- tree ctor = build_constructor_from_list (init_list_type_node, list);
+ tree ctor = build_constructor_from_vec (init_list_type_node,
+ user_args);
CONSTRUCTOR_IS_DIRECT_INIT (ctor) = true;
CONSTRUCTOR_IS_PAREN_INIT (ctor) = true;
if (is_dummy_object (instance))
else if (array_p)
{
tree vecinit = NULL_TREE;
- if (vec_safe_length (*init) == 1
- && DIRECT_LIST_INIT_P ((**init)[0]))
+ const size_t len = vec_safe_length (*init);
+ if (len == 1 && DIRECT_LIST_INIT_P ((**init)[0]))
{
vecinit = (**init)[0];
if (CONSTRUCTOR_NELTS (vecinit) == 0)
vecinit = digest_init (arraytype, vecinit, complain);
}
}
+ /* This handles code like new char[]{"foo"}. */
+ else if (len == 1
+ && char_type_p (TYPE_MAIN_VARIANT (type))
+ && TREE_CODE (tree_strip_any_location_wrapper ((**init)[0]))
+ == STRING_CST)
+ {
+ vecinit = (**init)[0];
+ STRIP_ANY_LOCATION_WRAPPER (vecinit);
+ }
else if (*init)
{
if (complain & tf_error)
&& AGGREGATE_TYPE_P (type)
&& (*init)->length () > 1)
{
- ie = build_tree_list_vec (*init);
- ie = build_constructor_from_list (init_list_type_node, ie);
+ ie = build_constructor_from_vec (init_list_type_node, *init);
CONSTRUCTOR_IS_DIRECT_INIT (ie) = true;
CONSTRUCTOR_IS_PAREN_INIT (ie) = true;
ie = digest_init (type, ie, complain);
return error_mark_node;
}
+ /* P1009: Array size deduction in new-expressions. */
+ if (TREE_CODE (type) == ARRAY_TYPE
+ && !TYPE_DOMAIN (type)
+ && *init)
+ {
+ /* This means we have 'new T[]()'. */
+ if ((*init)->is_empty ())
+ {
+ tree ctor = build_constructor (init_list_type_node, NULL);
+ CONSTRUCTOR_IS_DIRECT_INIT (ctor) = true;
+ vec_safe_push (*init, ctor);
+ }
+ tree &elt = (**init)[0];
+ /* The C++20 'new T[](e_0, ..., e_k)' case allowed by P0960. */
+ if (!DIRECT_LIST_INIT_P (elt) && cxx_dialect >= cxx20)
+ {
+ /* Handle new char[]("foo"). */
+ if (vec_safe_length (*init) == 1
+ && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
+ && TREE_CODE (tree_strip_any_location_wrapper (elt))
+ == STRING_CST)
+ /* Leave it alone: the string should not be wrapped in {}. */;
+ else
+ {
+ tree ctor = build_constructor_from_vec (init_list_type_node, *init);
+ CONSTRUCTOR_IS_DIRECT_INIT (ctor) = true;
+ CONSTRUCTOR_IS_PAREN_INIT (ctor) = true;
+ elt = ctor;
+ /* We've squashed all the vector elements into the first one;
+ truncate the rest. */
+ (*init)->truncate (1);
+ }
+ }
+ /* Otherwise we should have 'new T[]{e_0, ..., e_k}'. */
+ if (BRACE_ENCLOSED_INITIALIZER_P (elt))
+ elt = reshape_init (type, elt, complain);
+ cp_complete_array_type (&type, elt, /*do_default*/false);
+ }
+
/* The type allocated must be complete. If the new-type-id was
"T[N]" then we are just checking that "T" is complete here, but
that is equivalent, since the value of "N" doesn't matter. */
if (*nelts == error_mark_node)
*nelts = integer_one_node;
- if (outer_declarator)
+ if (*nelts == NULL_TREE)
+ /* Leave [] in the declarator. */;
+ else if (outer_declarator)
outer_declarator->declarator = declarator->declarator;
else
new_declarator = NULL;
cp_parser_direct_new_declarator (cp_parser* parser)
{
cp_declarator *declarator = NULL;
+ bool first_p = true;
while (true)
{
cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
token = cp_lexer_peek_token (parser->lexer);
- expression = cp_parser_expression (parser);
+ if (token->type == CPP_CLOSE_SQUARE && first_p)
+ expression = NULL_TREE;
+ else
+ expression = cp_parser_expression (parser);
/* The standard requires that the expression have integral
type. DR 74 adds enumeration types. We believe that the
real intent is that these expressions be handled like the
expression in a `switch' condition, which also allows
classes with a single conversion to integral or
enumeration type. */
- if (!processing_template_decl)
+ if (expression && !processing_template_decl)
{
expression
= build_expr_type_conversion (WANT_INT | WANT_ENUM,
bounds. */
if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
break;
+ first_p = false;
}
return declarator;
return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
|| value_dependent_expression_p
(TREE_OPERAND (TREE_VALUE (type), 1));
+ /* Array type whose dimension has to be deduced. */
+ else if (TREE_CODE (type) == ARRAY_TYPE
+ && TREE_OPERAND (expression, 2) == NULL_TREE)
+ return true;
else
return dependent_type_p (type);
}
static const bool value = sizeof(__test<_Tp, _Args...>(0)) == 1;
};
-static_assert( !is_constructible_mini<int[], int>::value, "");
+// int[](...) will work with P0960 and P1009.
+#if __cpp_aggregate_paren_init
+constexpr bool r = true;
+#else
+constexpr bool r = false;
+#endif
+static_assert( is_constructible_mini<int[], int>::value == r, "");
static_assert( !is_constructible_mini<void, int>::value, "");
--- /dev/null
+// PR c++/93529
+// P1009: Array size deduction in new-expressions
+// { dg-do run { target c++11 } }
+
+// When the array bound is deduced to 0, malloc(0) returns
+// a non-dereferenceable pointer.
+int *p0 = new int[]{};
+int *p1 = new int[]{ 1 };
+int *p2 = new int[]{ 1, 2, 3 };
+char *c1 = new char[]{"foo"};
+#if __cpp_aggregate_paren_init
+int *q0 = new int[]();
+int *q1 = new int[](1);
+int *q2 = new int[](1, 2, 3);
+char *d1 = new char[]("foo");
+char *d2 = new char[4]("foo");
+char *d3 = new char[]((("foo")));
+#endif
+
+struct Aggr { int a; int b; int c; };
+Aggr *a1 = new Aggr[]{};
+Aggr *a2 = new Aggr[]{ 1, 2, 3 };
+Aggr *a3 = new Aggr[]{ 1, 2, 3, 4 };
+Aggr *a4 = new Aggr[]{ { 1, 2, 3 } };
+Aggr *a5 = new Aggr[]{ { 1 }, { 6, 7 } };
+#if __cpp_designated_initializers
+Aggr *a9 = new Aggr[]{ { .a = 1, .b = 2, .c = 3 } };
+#endif
+#if __cpp_aggregate_paren_init
+Aggr *a6 = new Aggr[]();
+Aggr *a7 = new Aggr[]({ 1, 2, 3 });
+Aggr *a8 = new Aggr[]({ 1 }, { 6, 7 });
+#endif
+
+int
+main ()
+{
+ if (p1[0] != 1 || p2[0] != 1 || p2[1] != 2 || p2[2] != 3)
+ __builtin_abort ();
+ if (__builtin_strcmp (c1, "foo"))
+ __builtin_abort ();
+ if (a2->a != 1 || a2->b != 2 || a2->c != 3)
+ __builtin_abort ();
+ if (a3[0].a != 1 || a3[0].b != 2 || a3[0].c != 3
+ || a3[1].a != 4 || a3[1].b != 0 || a3[1].c != 0)
+ __builtin_abort ();
+ if (a4->a != 1 || a4->b != 2 || a4->c != 3)
+ __builtin_abort ();
+ if (a5[0].a != 1 || a5[0].b != 0 || a5[0].c != 0
+ || a5[1].a != 6 || a5[1].b != 7 || a5[1].c != 0)
+ __builtin_abort ();
+#if __cpp_designated_initializers
+ if (a9->a != 1 || a9->b != 2 || a9->c != 3)
+ __builtin_abort ();
+#endif
+#if __cpp_aggregate_paren_init
+ if (q1[0] != 1)
+ __builtin_abort ();
+ if (q2[0] != 1 || q2[1] != 2 || q2[2] != 3)
+ __builtin_abort ();
+ if (__builtin_strcmp (d1, "foo") || __builtin_strcmp (d2, "foo")
+ || __builtin_strcmp (d3, "foo"))
+ __builtin_abort ();
+ if (a7[0].a != 1 || a7[0].b != 2 || a7[0].c != 3)
+ __builtin_abort ();
+ if (a8[0].a != 1 || a8[0].b != 0 || a8[0].c != 0
+ || a8[1].a != 6 || a8[1].b != 7 || a8[1].c != 0)
+ __builtin_abort ();
+#endif
+}
--- /dev/null
+// PR c++/93529
+// P1009: Array size deduction in new-expressions
+// { dg-do compile { target c++11 } }
+
+// Test error cases.
+int *p = new double[] = { 1, 2, 3}; // { dg-error "invalid use of array with unspecified bounds" }
+int *p2 = new double[] = (1, 2, 3); // { dg-error "invalid use of array with unspecified bounds" }
+struct Aggr { int a; int b; int c; };
+Aggr *p3 = new Aggr[]( 1, 2, 3 ); // { dg-error "could not convert|parenthesized initializer" }
+char *p4 = new char[]("foo", "a"); // { dg-error "invalid conversion|parenthesized initializer" }
+
+template<typename... T>
+int *fn(T... t)
+{
+ return new int[]{t...}; // { dg-error "invalid conversion" }
+}
+
+void
+g ()
+{
+ int *p = fn ("a");
+}
--- /dev/null
+// PR c++/93529
+// P1009: Array size deduction in new-expressions
+// { dg-do compile { target c++11 } }
+
+template<typename... T>
+int *fn(T... t)
+{
+ return new int[]{t...};
+}
+
+int
+main ()
+{
+ int *p0 = fn ();
+ int *p1 = fn (1);
+ int *p3 = fn (1, 2, 3);
+}
--- /dev/null
+// PR c++/93529
+// P1009: Array size deduction in new-expressions
+// { dg-do compile { target c++11 } }
+
+void
+fn ()
+{
+ new int[][3]{ { 1, 2, 3 } };
+ new int[][]{ { 1, 2, 3 } }; // { dg-error "expected primary-expression" }
+}
return build_constructor (type, v);
}
+/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
+ are in a vector pointed to by VALS. Note that the TREE_PURPOSE
+ fields in the constructor remain null. */
+
+tree
+build_constructor_from_vec (tree type, const vec<tree, va_gc> *vals)
+{
+ vec<constructor_elt, va_gc> *v = NULL;
+
+ for (tree t : *vals)
+ CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, t);
+
+ return build_constructor (type, v);
+}
+
/* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
of elements, provided as index/value pairs. */
extern tree build_constructor (tree, vec<constructor_elt, va_gc> * CXX_MEM_STAT_INFO);
extern tree build_constructor_single (tree, tree, tree);
extern tree build_constructor_from_list (tree, tree);
+extern tree build_constructor_from_vec (tree, const vec<tree, va_gc> *);
extern tree build_constructor_va (tree, int, ...);
extern tree build_clobber (tree);
extern tree build_real_from_int_cst (tree, const_tree);
projects / gcc.git / commitdiff