Hyphenate 'pointer-to-member' when it is an adjective and define the adjective.

Fixes #1369.

Author: tkoeppe

source/basic.tex

@@ -3594,7 +3594,7 @@
 
 \pnum
 Arithmetic types\iref{basic.fundamental}, enumeration types, pointer
-types, pointer to member types\iref{basic.compound},
+types, pointer-to-member types\iref{basic.compound},
 \tcode{std::nullptr_t},
 and
 cv-qualified\iref{basic.type.qualifier} versions of these
@@ -3884,7 +3884,7 @@
 \pnum
 A value of type \tcode{std::nullptr_t} is a null pointer
 constant\iref{conv.ptr}. Such values participate in the pointer and the
-pointer to member conversions~(\ref{conv.ptr}, \ref{conv.mem}).
+pointer-to-member conversions~(\ref{conv.ptr}, \ref{conv.mem}).
 \tcode{sizeof(std::nullptr_t)} shall be equal to \tcode{sizeof(void*)}.
 
 \pnum
@@ -3938,6 +3938,8 @@
 ordinary pointers to objects or functions.}
 which identify members of a given
 type within objects of a given class, \ref{dcl.mptr}.
+Pointers to data members and pointers to member functions are collectively
+called \term{pointer-to-member} types.
 \end{itemize}
 
 \pnum

source/conversions.tex

@@ -22,7 +22,7 @@
 \item Zero or one conversion from the following set: integral
 promotions, floating-point promotion, integral conversions, floating-point
 conversions, floating-integral conversions, pointer conversions,
-pointer to member conversions, and boolean conversions.
+pointer-to-member conversions, and boolean conversions.
 
 \item Zero or one function pointer conversion.
 
@@ -527,21 +527,22 @@
 object. The null pointer value is converted to the null pointer value of
 the destination type.
 
-\rSec1[conv.mem]{Pointer to member conversions}
+\rSec1[conv.mem]{Pointer-to-member conversions}
 
 \pnum
-\indextext{conversion!pointer to member}%
+\indextext{conversion!pointer-to-member}%
 \indextext{constant!null pointer}%
 \indextext{value!null member pointer}%
-A null pointer constant\iref{conv.ptr} can be converted to a pointer
-to member type; the result is the \term{null member pointer value}
+A null pointer constant\iref{conv.ptr} can be converted to a
+pointer-to-member
+type; the result is the \term{null member pointer value}
 of that type and is distinguishable from any pointer to member not
 created from a null pointer constant.
 Such a conversion is called a \term{null member pointer conversion}.
 Two null member pointer values of
 the same type shall compare equal. The conversion of a null pointer
 constant to a pointer to member of cv-qualified type is a single
-conversion, and not the sequence of a pointer to member conversion
+conversion, and not the sequence of a pointer-to-member conversion
 followed by a qualification conversion\iref{conv.qual}.
 
 \pnum
@@ -571,7 +572,7 @@
 an object pointer or a function pointer
 and the rules for conversions
 of such pointers do not apply to pointers to members.
-\indextext{conversion!pointer to member!\idxcode{void*}}%
+\indextext{conversion!pointer-to-member!\idxcode{void*}}%
 In particular, a pointer to member cannot be converted to a
 \tcode{void*}.}
 
@@ -600,7 +601,7 @@
 
 \pnum
 \indextext{conversion!boolean}%
-A prvalue of arithmetic, unscoped enumeration, pointer, or pointer to member
+A prvalue of arithmetic, unscoped enumeration, pointer, or pointer-to-member
 type can be converted to a prvalue of type \tcode{bool}. A zero value, null
 pointer value, or null member pointer value is converted to \tcode{false}; any
 other value is converted to \tcode{true}. For

source/declarators.tex

@@ -7,7 +7,7 @@
 \indextext{initialization!class object|seealso{constructor}}%
 \indextext{\idxcode{*}|see{declarator, pointer}}
 \indextext{\idxcode{\&}|see{declarator, reference}}%
-\indextext{\idxcode{::*}|see{declarator, pointer to member}}%
+\indextext{\idxcode{::*}|see{declarator, pointer-to-member}}%
 \indextext{\idxcode{[]}|see{declarator, array}}%
 \indextext{\idxcode{()}|see{declarator, function}}%
 
@@ -838,7 +838,7 @@
 \end{note}
 
 \rSec2[dcl.mptr]{Pointers to members}%
-\indextext{declarator!pointer to member}
+\indextext{declarator!pointer-to-member}
 
 \pnum
 In a declaration
@@ -870,7 +870,7 @@
 
 \pnum
 \begin{example}%
-\indextext{example!pointer to member}
+\indextext{example!pointer-to-member}
 
 \begin{codeblock}
 struct X {
@@ -941,7 +941,7 @@
 \begin{note}
 See also~\ref{expr.unary} and~\ref{expr.mptr.oper}.
 The type ``pointer to member'' is distinct from the type ``pointer'',
-that is, a pointer to member is declared only by the pointer to member
+that is, a pointer to member is declared only by the pointer-to-member
 declarator syntax, and never by the pointer declarator syntax.
 There is no ``reference-to-member'' type in \Cpp.
 \end{note}

source/exceptions.tex

@@ -496,8 +496,8 @@
 \tcode{T} is an unambiguous public base class of \tcode{E}, or
 \item%
 the \grammarterm{handler} is of type \cv{}~\tcode{T} or \tcode{const T\&}
-where \tcode{T} is a pointer or pointer to member type and
-\tcode{E} is a pointer or pointer to member type
+where \tcode{T} is a pointer or pointer-to-member type and
+\tcode{E} is a pointer or pointer-to-member type
 that can be converted to \tcode{T} by one or more of
 \begin{itemize}
 
@@ -512,15 +512,15 @@
 \end{itemize}
 
 \item
-the \grammarterm{handler} is of type \cv{}~\tcode{T} or \tcode{const T\&} where \tcode{T} is a pointer or pointer to member type and \tcode{E} is \tcode{std::nullptr_t}.
+the \grammarterm{handler} is of type \cv{}~\tcode{T} or \tcode{const T\&} where \tcode{T} is a pointer or pointer-to-member type and \tcode{E} is \tcode{std::nullptr_t}.
 
 \end{itemize}
 
 \begin{note}
 A
 \grammarterm{throw-expression}
 whose operand is an integer literal with value zero does not match a handler of
-pointer or pointer to member type.
+pointer or pointer-to-member type.
 A handler of reference to array or function type
 is never a match for any exception object\iref{expr.throw}.
 \end{note}

source/expressions.tex

@@ -304,7 +304,7 @@
 The \defn{composite pointer type} of
 two operands \tcode{p1} and
 \tcode{p2} having types \tcode{T1} and \tcode{T2}, respectively, where at least one is a
-pointer or pointer to member type or
+pointer or pointer-to-member type or
 \tcode{std::nullptr_t}, is:
 
 \begin{itemize}
@@ -2279,8 +2279,8 @@
 An argument that has type \cv{}~\tcode{std::nullptr_t} is converted
 to type \tcode{void*}\iref{conv.ptr}.
 After these conversions, if the
-argument does not have arithmetic, enumeration, pointer, pointer to
-member, or class type, the program is ill-formed. Passing a potentially-evaluated
+argument does not have arithmetic, enumeration, pointer, pointer-to-member,
+or class type, the program is ill-formed. Passing a potentially-evaluated
 argument of class type\iref{class} having a non-trivial
 copy constructor, a non-trivial move constructor,
 or a
@@ -2951,7 +2951,7 @@
 class\iref{class.derived} of \tcode{D},
 if \cvqual{cv2} is the same cv-qualification
 as, or greater cv-qualification than, \cvqual{cv1}.\footnote{Function types
-(including those used in pointer to member function
+(including those used in pointer-to-member-function
 types) are never cv-qualified; see~\ref{dcl.fct}.}
 If no valid standard conversion
 from ``pointer to member of \tcode{B} of type \tcode{T}''
@@ -3122,14 +3122,14 @@
 
 \begin{itemize}
 \item converting a prvalue of type ``pointer to member function'' to a
-different pointer to member function type and back to its original type
-yields the original pointer to member value.
+different pointer-to-member-function type and back to its original type
+yields the original pointer-to-member value.
 
 \item converting a prvalue of type ``pointer to data member of \tcode{X}
 of type \tcode{T1}'' to the type ``pointer to data member of \tcode{Y}
 of type \tcode{T2}'' (where the alignment requirements of \tcode{T2} are
 no stricter than those of \tcode{T1}) and back to its original type
-yields the original pointer to member value.
+yields the original pointer-to-member value.
 \end{itemize}
 
 \pnum
@@ -3335,7 +3335,7 @@
 
 \pnum
 \indextext{name!address of cv-qualified}%
-\indextext{expression!pointer to member constant}%
+\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}.
 If the operand is a \grammarterm{qualified-id} naming a non-static or variant member \tcode{m}
@@ -4876,7 +4876,7 @@
 \pnum
 The \tcode{==} (equal to) and the \tcode{!=} (not equal to) operators
 group left-to-right. The operands shall have arithmetic, enumeration, pointer,
-or pointer to member type, or type \tcode{std::nullptr_t}. The operators
+or pointer-to-member type, or type \tcode{std::nullptr_t}. The operators
 \tcode{==} and \tcode{!=} both yield \tcode{true} or \tcode{false}, i.e., a
 result of type \tcode{bool}. In each case below, the operands shall have the
 same type after the specified conversions have been applied.
@@ -4908,7 +4908,7 @@
 \end{itemize}
 
 \pnum
-If at least one of the operands is a pointer to member, pointer to member
+If at least one of the operands is a pointer to member, pointer-to-member
 conversions\iref{conv.mem} and qualification
 conversions\iref{conv.qual} are performed on both operands to bring them to
 their composite pointer type\iref{expr.prop}.
@@ -5249,7 +5249,7 @@
 composite pointer type\iref{expr.prop}. The result is of the composite
 pointer type.
 
-\item One or both of the second and third operands have pointer to member type;
+\item One or both of the second and third operands have pointer-to-member type;
 pointer to member conversions\iref{conv.mem} and qualification
 conversions\iref{conv.qual} are performed to bring them to their composite
 pointer type\iref{expr.prop}. The result is of the composite pointer type.

source/lex.tex

@@ -1712,8 +1712,8 @@
 The pointer literal is the keyword \tcode{nullptr}. It is a prvalue of type
 \tcode{std::nullptr_t}.
 \begin{note}
-\tcode{std::nullptr_t} is a distinct type that is neither a pointer type nor a pointer
-to member type; rather, a prvalue of this type is a null pointer constant and can be
+\tcode{std::nullptr_t} is a distinct type that is neither a pointer type nor a pointer-to-member type;
+rather, a prvalue of this type is a null pointer constant and can be
 converted to a null pointer value or null member pointer value. See~\ref{conv.ptr}
 and~\ref{conv.mem}.
 \end{note}

source/overloading.tex

@@ -2083,7 +2083,7 @@
 Floating-point conversions      &                               &                   &   \ref{conv.double}   \\ \cline{1-1}\cline{4-4}
 Floating-integral conversions   &                               &                   &   \ref{conv.fpint}    \\ \cline{1-1}\cline{4-4}
 Pointer conversions             &   \rb{Conversion}             &   \rb{Conversion} &   \ref{conv.ptr}      \\ \cline{1-1}\cline{4-4}
-Pointer to member conversions   &                               &                   &   \ref{conv.mem}      \\ \cline{1-1}\cline{4-4}
+Pointer-to-member conversions   &                               &                   &   \ref{conv.mem}      \\ \cline{1-1}\cline{4-4}
 Boolean conversions             &                               &                   &   \ref{conv.bool}     \\
 \end{floattable}
 
@@ -2874,7 +2874,7 @@
 match targets of function pointer type or
 reference to function type.
 Non-static member functions match targets of
-pointer to member function type.
+pointer-to-member-function type.
 If a non-static member function is selected, the reference to the overloaded
 function name is required to have the form of a pointer to member as
 described in~\ref{expr.unary.op}.
@@ -3738,7 +3738,7 @@
 
 \pnum
 For every \tcode{\placeholder{T}}, where \tcode{\placeholder{T}}
-is a pointer to member type or \tcode{std::nullptr_t},
+is a pointer-to-member type or \tcode{std::nullptr_t},
 there exist candidate operator functions of the form
 
 \begin{codeblock}
@@ -3805,7 +3805,7 @@
 \cvqual{vq}),
 where
 \tcode{\placeholder{T}}
-is an enumeration or pointer to member type,
+is an enumeration or pointer-to-member type,
 there exist candidate operator functions of the form
 
 \begin{codeblock}

source/templates.tex

@@ -7359,7 +7359,7 @@
 the transformed \tcode{A}.
 \item
 The transformed \tcode{A}
-can be another pointer or pointer to member type that can be converted
+can be another pointer or pointer-to-member type that can be converted
 to the deduced
 \tcode{A}
 via a function pointer conversion\iref{conv.fctptr} and/or
@@ -7407,8 +7407,7 @@
 \pnum
 When
 \tcode{P}
-is a function type, function pointer type, or pointer to member
-function type:
+is a function type, function pointer type, or pointer-to-member-function type:
 \begin{itemize}
 \item
 If the argument is an overload set containing one or more function templates,
@@ -7582,12 +7581,12 @@
 \tcode{A} can be ``pointer to function''
 even if the deduced \tcode{A} is ``pointer to noexcept function''.
 \item
-If the original \tcode{A} is a pointer to member function type,
+If the original \tcode{A} is a pointer-to-member-function type,
 \tcode{A} can be ``pointer to member of type function''
 even if the deduced \tcode{A} is ``pointer to member of type noexcept function''.
 \item
 The deduced \tcode{A}
-can be another pointer or pointer to member type that
+can be another pointer or pointer-to-member type that
 can be converted to \tcode{A} via a qualification conversion.
 \end{itemize}
 
@@ -7600,7 +7599,7 @@
 
 \pnum
 When the deduction process requires a qualification conversion for a
-pointer or pointer to member type as described above, the following
+pointer or pointer-to-member type as described above, the following
 process is used to determine the deduced template argument values:
 
 If
@@ -7902,7 +7901,7 @@
 A function type includes the types of each of the function parameters
 and the return type.
 \item
-A pointer to member type includes the type of the class object pointed to
+A pointer-to-member type includes the type of the class object pointed to
 and the type of the member pointed to.
 \item
 A type that is a specialization of a class template (e.g.,
@@ -8421,8 +8420,8 @@
 \pnum
 A
 \grammarterm{template-argument}
-can be deduced from a function, pointer to function, or pointer to
-member function type.
+can be deduced from a function, pointer to function, or
+pointer-to-member-function type.
 
 \begin{example}
 

source/utilities.tex

@@ -15518,11 +15518,11 @@
 \indexlibrary{\idxcode{is_member_object_pointer}}%
 \tcode{template <class T>}\br
  \tcode{struct is_member_object_pointer;}&
- \tcode{T} is a pointer to non-static data member                              &   \\ \rowsep
+ \tcode{T} is a pointer to data member                              &   \\ \rowsep
 \indexlibrary{\idxcode{is_member_function_pointer}}%
 \tcode{template <class T>}\br
  \tcode{struct is_member_function_pointer;}&
-\tcode{T} is a pointer to non-static member function                           &   \\ \rowsep
+\tcode{T} is a pointer to member function                           &   \\ \rowsep
 \indexlibrary{\idxcode{is_enum}}%
 \tcode{template <class T>}\br
  \tcode{struct is_enum;}            &
@@ -15586,8 +15586,7 @@
 \indexlibrary{\idxcode{is_member_pointer}}%
 \tcode{template <class T>}\br
  \tcode{struct is_member_pointer;}      &
- \tcode{T} is a pointer to non-static data member
- or non-static member function             &   \\
+ \tcode{T} is a pointer-to-member type\iref{basic.compound}               &   \\
 \end{libreqtab3b}
 
 \rSec3[meta.unary.prop]{Type properties}