N3639 Runtime-sized arrays with automatic storage duration

N3639 [dcl.array] paragraph 1

In [dcl.array]/1, removed bullet points from the last part of the major
bits of added text. The bulleted list was preceded by nothing and appeared
out of nowhere.

Added an index entry for "array of runtime bound" and "runtime bound, array of".

In [support.dynamic], bad_array_length also added to <new> synopsis.

Typeset types in comments to [dcl.array]/1 as code, including two existing
instances not added by the paper.

Improved grammar as follows:
"is invoked ... after the lifetime of the array ended" -> "... has ended"

Rearranged commas in [dcl.fct]/8 for consistent and correct grammar.

Author: Stefanus Du Toit

source/basic.tex

@@ -3551,7 +3551,7 @@
 \begin{itemize}
 \item a scalar type; or
 \item a reference type; or
-\item an array of literal type; or
+\item an array of literal type other than an array of runtime bound; or
 \item a class type (Clause~\ref{class}) that
 has all of the following properties:
 \begin{itemize}

source/classes.tex

@@ -534,10 +534,11 @@
 
 \pnum
 \indextext{class~object!member}%
-Non-\tcode{static}~(\ref{class.static}) data members shall not have
-incomplete types. In particular, a class \tcode{C} shall not contain a
-non-static member of class \tcode{C}, but it can contain a pointer or
-reference to an object of class \tcode{C}.
+A non-\tcode{static}~(\ref{class.static}) data member shall not have
+incomplete type or type ``array of runtime bound''. \enternote In particular,
+a class \tcode{C} shall not contain a non-static member of class \tcode{C}, but
+it can contain a pointer or reference to an object of class \tcode{C}.
+\exitnote
 
 \pnum
 \enternote

source/conversions.tex

@@ -175,10 +175,10 @@
 \pnum
 \indextext{conversion!array-to-pointer}%
 \indextext{decay|see{conversion, array to pointer; conversion, function to pointer}}%
-An lvalue or rvalue of type ``array of \tcode{N} \tcode{T}'' or ``array
-of unknown bound of \tcode{T}'' can be converted to a prvalue of type
-``pointer to \tcode{T}''. The result is a pointer to the first element
-of the array.
+An expression of type ``array of \tcode{N} \tcode{T}'', ``array of runtime
+bound of \tcode{T}'', or ``array of unknown bound of \tcode{T}'' can be
+converted to a prvalue of type ``pointer to \tcode{T}''. The result is a
+pointer to the first element of the array.
 
 \rSec1[conv.func]{Function-to-pointer conversion}
 

source/declarations.tex

@@ -611,6 +611,9 @@
 
 \exitexample
 
+\pnum
+A \grammarterm{typedef-name} shall not name an array of runtime bound.
+
 \pnum
 \indextext{redefinition!\idxcode{typedef}}%
 In a given non-class scope, a \tcode{typedef} specifier can be used to
@@ -1377,9 +1380,11 @@
 \indextext{type~specifier!\idxcode{decltype}}%
 The type denoted by \tcode{decltype(e)} is defined as follows:
 \begin{itemize}
-\item if \tcode{e} is an unparenthesized \grammarterm{id-expression} or
-an unparenthesized
-class
+\item if \tcode{e} has type ``array of runtime bound'', the program is
+ill-formed
+
+\item otherwise, if \tcode{e} is an unparenthesized
+\grammarterm{id-expression} or an unparenthesized class
 member access~(\ref{expr.ref}), \tcode{decltype(e)} is the
 type of the entity named by \tcode{e}. If there is no such entity, or
 if \tcode{e} names a set of overloaded functions, the program is

source/declarators.tex

@@ -120,7 +120,7 @@
 \nontermdef{noptr-declarator}\br
     declarator-id attribute-specifier-seq\opt\br
     noptr-declarator parameters-and-qualifiers\br
-    noptr-declarator \terminal{[} constant-expression\opt \terminal{]} attribute-specifier-seq\opt\br
+    noptr-declarator \terminal{[} expression\opt \terminal{]} attribute-specifier-seq\opt\br
     \terminal{(} ptr-declarator \terminal{)}
 \end{bnf}
 
@@ -599,7 +599,10 @@
 The
 \grammarterm{cv-qualifier}{s}
 apply to the pointer and not to the object pointed to.
-Similarly, the optional \grammarterm{attribute-specifier-seq}~(\ref{dcl.attr.grammar}) appertains to the pointer and not to the object pointed to.
+Similarly, the optional
+\grammarterm{attribute-specifier-seq}~(\ref{dcl.attr.grammar}) appertains to
+the pointer and not to the object pointed to. There shall be no pointers to
+arrays of runtime bound.
 
 \pnum
 \enterexample
@@ -821,8 +824,8 @@
 
 \pnum
 \indextext{restriction!reference}%
-There shall be no references to references,
-no arrays of references, and no pointers to references.
+There shall be no references to references, no references to arrays of runtime
+bound, no arrays of references, and no pointers to references.
 \indextext{initialization!reference}%
 The declaration of a reference shall contain an
 \grammarterm{initializer}
@@ -993,7 +996,7 @@
 has the form
 
 \begin{ncsimplebnf}
-\terminal{D1 [} constant-expression\opt \terminal{]} attribute-specifier-seq\opt
+\terminal{D1 [} expression\opt \terminal{]} attribute-specifier-seq\opt
 \end{ncsimplebnf}
 
 and the type of the identifier in the declaration
@@ -1012,41 +1015,57 @@
 \term{element type};
 this type shall not be a reference type, the (possibly cv-qualified) type
 \tcode{void},
-a function type or an abstract class type.
+a function type, an array of unknown or runtime bound, or an abstract class type.
+Except as noted below, if the \grammarterm{expression} is omitted, the type of
+the identifier of \tcode{D} is ``\grammarterm{derived-declarator-type-list}
+array of unknown bound of \tcode{T}''. If the \grammarterm{expression} is
+present, it is implicitly converted to \tcode{std::size_t}. The
+\grammarterm{expression} is erroneous if:
+
+\begin{itemize}
+\item
+its value before converting to \tcode{std::size_t} or, in the case of an
+expression of class type, before application of the second standard
+conversion~(\ref{over.ics.user}) is less than or equal to zero;
+
+\item
+its value is such that the size of the allocated object would exceed the
+implementation-defined limit (Annex~\ref{implimits});
+
+\item
+the initializer of the object is a \grammarterm{braced-init-list} whose number
+of (top-level) \grammarterm{initializer-clause}{s} exceeds the number of
+elements to initialize; or
+
+\item
+the object is initialized with a string literal and there are more initializers
+than there are array elements.
+\end{itemize}
+
+If the \grammarterm{expression}, after converting to \tcode{std::size_t}, is a
+core constant expression and the \grammarterm{expression} is erroneous, the
+program is ill-formed.
+
+If the \grammarterm{expression}, after converting to \tcode{std::size_t}, is a
+core constant expression whose value is \tcode{N}, the type of the identifier
+of \tcode{D} is ``\grammarterm{derived-declarator-type-list} array of
+\tcode{N T}''.
+
+\indextext{array of runtime bound}%
+\indextext{runtime bound!array of|see{array of runtime bound}}%
+Otherwise, the type of the identifier of \tcode{D} is
+``\grammarterm{derived-declarator-type-list} array of runtime bound of
+\tcode{T}'' and the value of the \grammarterm{expression} designates the number
+of elements \tcode{N} in the array. If the \grammarterm{expression} is
+erroneous, an exception of a type that would match a
+handler~(\ref{except.handle}) of type
+\tcode{std::bad_array_length}~(\ref{bad.array.length}) is thrown.
+
 \indextext{declaration!array}%
-If the
-\grammarterm{constant-expression}
-(\ref{expr.const}) is present, it shall be a converted constant
-expression of type \tcode{std\colcol{}size_t} and
-its value shall be greater than zero.
-The constant expression specifies the
-\indextext{array!bound}%
-\indextext{bound,~of~array}%
-\term{bound}
-of (number of elements in) the array.
-If the value of the constant expression is
-\tcode{N},
-the array has
-\tcode{N}
-elements numbered
-\tcode{0}
-to
-\tcode{N-1},
-and the type of the identifier of
-\tcode{D}
-is ``\nonterminal{derived-declarator-type-list} array of
-\tcode{N}
-\tcode{T}''.
 An object of array type contains a contiguously allocated non-empty set of
 \tcode{N}
 subobjects of type
 \tcode{T}.
-Except as noted below, if
-the constant expression is omitted, the type of the identifier of
-\tcode{D}
-is ``\nonterminal{derived-declarator-type-list} array of unknown bound of
-\tcode{T}'',
-an incomplete object type.
 The type ``\nonterminal{derived-declarator-type-list} array of
 \tcode{N}
 \tcode{T}''
@@ -1065,14 +1084,19 @@
 \tcode{T}'',
 and similarly for
 ``array of unknown bound of
-\tcode{T}''.
+\tcode{T}'' and ``array of runtime bound of \tcode{T}''.
 The optional \grammarterm{attribute-specifier-seq} appertains to the array.
 \enterexample
 
 \begin{codeblock}
 typedef int A[5], AA[2][3];
-typedef const A CA;             // type is ``array of 5 const int''
-typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
+typedef const A CA;             // type is ``array of 5 \tcode{const int}''
+typedef const AA CAA;           // type is ``array of 2 array of 3 \tcode{const int}''
+
+void f(unsigned int n) {
+  int a[n];                     // type of \tcode{a} is ``array of runtime bound of \tcode{int}''
+}
+
 \end{codeblock}
 \exitexample
 \enternote
@@ -1095,10 +1119,7 @@
 
 \pnum
 When several ``array of'' specifications are adjacent, a multidimensional
-array is created;
-only the first of
-the constant expressions that specify the bounds
-of the arrays may be omitted.
+array is created.
 In addition to declarations in which an incomplete object type is allowed,
 an array bound may be omitted in some cases in the declaration of a function
 parameter~(\ref{dcl.fct}).
@@ -1122,6 +1143,20 @@
 be the same as in that earlier declaration, and similarly for the definition
 of a static data member of a class.
 
+\pnum
+An array of runtime bound shall only be used as the type of a local object with
+automatic storage duration. If the size of the array exceeds the size of the
+memory available for objects with automatic storage duration, the behavior is
+undefined.\footnote{Implementations that detect this case are encouraged to
+throw an exception that would match a handler~(\ref{except.handle}) of type
+\tcode{std::bad_array_length}~(\ref{bad.array.length}).}
+It is unspecified whether a global allocation
+function~(\ref{basic.stc.dynamic}) is invoked to obtain storage for the array.
+If it is invoked, the corresponding global deallocation function is invoked to
+release the storage after the lifetime of the array has
+ended.\footnote{Alternatively, an implementation could allocate such an array
+on the usual stack or obtain storage via \tcode{malloc}~(\ref{c.malloc}).}
+
 \pnum
 \enterexample
 \indextext{example!subscripting}%
@@ -1536,8 +1571,9 @@
 
 \pnum
 If the type of a parameter includes a type of the form
-``pointer to array of unknown bound of \tcode{T}'' or
-``reference to array of unknown bound of \tcode{T},''
+``array of runtime bound of \tcode{T}'',
+``pointer to array of unknown bound of \tcode{T}'', or
+``reference to array of unknown bound of \tcode{T}'',
 the program is ill-formed.\footnote{This excludes parameters of type
 ``\nonterminal{ptr-arr-seq} \tcode{T2}'' where \tcode{T2} is
 ``pointer to array of unknown bound of \tcode{T}'' and where
@@ -2871,7 +2907,7 @@
 \exitexample
 
 \pnum
-An
+For types other than arrays of runtime bound~(\ref{dcl.array}), an
 \grammarterm{initializer-list}
 is ill-formed if the number of
 \grammarterm{initializer-clause}{s} 
@@ -3185,7 +3221,8 @@
 \exitexample
 
 \pnum
-There shall not be more initializers than there are array elements.
+\enternote There cannot be more initializers than there are array elements;
+see~\ref{dcl.array}.
 \enterexample
 
 \begin{codeblock}
@@ -3194,7 +3231,7 @@
 
 is ill-formed since there is no space for the implied trailing
 \tcode{'\textbackslash 0'}.
-\exitexample
+\exitexample \exitnote
 
 \pnum
 If there are fewer initializers than there are array elements, each element not

source/exceptions.tex

@@ -202,7 +202,8 @@
 functions~(\ref{basic.stc.dynamic.allocation}),
 \tcode{dynamic_cast}~(\ref{expr.dynamic.cast}),
 \tcode{typeid}~(\ref{expr.typeid}),
-\grammarterm{new-expression}~(\ref{expr.new}), and standard library
+\grammarterm{new-expression}~(\ref{expr.new}), array of runtime
+bound~(\ref{dcl.array}), and standard library
 functions~(\ref{structure.specifications}).
 \exitnote
 An object is passed and the type of that object determines which handlers

source/expressions.tex

@@ -842,12 +842,15 @@
 corresponding captured entity if the entity is not a reference to an object, or the
 referenced type otherwise. \enternote If the captured entity is a reference to a
 function, the corresponding data member is also a reference to a function. \exitnote
+An array of runtime bound~(\ref{dcl.array}) shall not be captured by copy.
 
 \pnum
 An entity is \indexdefn{captured!by reference}\term{captured by reference} if it is implicitly or explicitly
 captured but not captured by copy. It is unspecified whether additional unnamed
 non-static data members are declared in the closure type for entities captured by
-reference.
+reference. \enternote Capturing by reference an array of runtime bound also
+implicitly captures the value of the bound to support the range-based for
+statement~(\ref{stmt.ranged}). \exitnote
 
 \pnum
 If a \grammarterm{lambda-expression} \tcode{m2} captures an entity and that entity is
@@ -1674,6 +1677,9 @@
 of the program. Whether or not the destructor is called for the
 \tcode{std::type_info} object at the end of the program is unspecified.
 
+\pnum
+The \tcode{typeid} operator shall not be applied to an array of runtime bound.
+
 \pnum
 When \tcode{typeid} is applied to a glvalue expression whose type is a
 polymorphic class type~(\ref{class.virtual}), the result refers to a
@@ -2335,7 +2341,8 @@
 \indextext{name!address~of cv-qualified}%
 \indextext{expression!pointer~to~member constant}%
 The result of the unary \tcode{\&} operator is a pointer to its operand.
-The operand shall be an lvalue or a \grammarterm{qualified-id}.
+The operand shall be either an lvalue of type other than ``array of runtime bound''
+or a \grammarterm{qualified-id}.
 If the operand is a \grammarterm{qualified-id} naming a non-static member \tcode{m}
 of some class \tcode{C} with type \tcode{T}, the result has type ``pointer to member
 of class \tcode{C} of type \tcode{T}'' and is a prvalue designating \tcode{C::m}.
@@ -2475,8 +2482,9 @@
 \grammarterm{type-id}.
 \indextext{type!incomplete}%
 The \tcode{sizeof} operator shall not be applied to an expression that
-has function or incomplete type, to an enumeration type whose underlying type is not fixed before all
-its enumerators have been declared, to the parenthesized name of such
+has function or incomplete type, to an enumeration type whose underlying type
+is not fixed before all its enumerators have been declared, to an array of
+runtime bound, to the parenthesized name of such
 types, or to a glvalue that designates a bit-field.
 \tcode{sizeof(char)}, \tcode{sizeof(signed char)} and
 \tcode{sizeof(unsigned char)} are \tcode{1}. The result of

source/grammar.tex

@@ -1247,7 +1247,7 @@
 \nontermdef{noptr-declarator}\br
     declarator-id attribute-specifier-seq\opt\br
     noptr-declarator parameters-and-qualifiers\br
-    noptr-declarator \terminal{[} constant-expression\opt \terminal{]} attribute-specifier-seq\opt\br
+    noptr-declarator \terminal{[} expression\opt \terminal{]} attribute-specifier-seq\opt\br
     \terminal{(} ptr-declarator \terminal{)}
 \end{bnf}