[intro.defs, definitions, fs.definitions] change notes in Terms and Definitions to say "Note X to entry"

Fixes ISO 3 (C++17 DIS)

Author: tkoeppe

source/intro.tex

@@ -135,9 +135,12 @@
 
 \indexdefn{behavior!conditionally-supported}%
 \definition{conditionally-supported}{defns.cond.supp}
-program construct that an implementation is not required to support\\
-\begin{note} Each implementation documents all conditionally-supported
-constructs that it does not support.\end{note}
+program construct that an implementation is not required to support
+
+\begin{defnote}
+Each implementation documents all conditionally-supported
+constructs that it does not support.
+\end{defnote}
 
 \indexdefn{message!diagnostic}%
 \definition{diagnostic message}{defns.diagnostic}
@@ -147,7 +150,8 @@
 \indexdefn{type!dynamic}%
 \definition{dynamic type}{defns.dynamic.type}
 \defncontext{glvalue} type of the most derived object\iref{intro.object} to which the
-glvalue refers\\
+glvalue refers
+
 \begin{example}
 If a pointer\iref{dcl.ptr} \tcode{p} whose static type is ``pointer to
 class \tcode{B}'' is pointing to an object of class \tcode{D}, derived
@@ -181,10 +185,12 @@
 \indexdefn{character!multibyte}%
 \definition{multibyte character}{defns.multibyte}
 sequence of one or more bytes representing a member of the extended
-character set of either the source or the execution environment\\
-\begin{note} The
-extended character set is a superset of the basic character
-set\iref{lex.charset}.\end{note}
+character set of either the source or the execution environment
+
+\begin{defnote}
+The extended character set is a superset of the basic character
+set\iref{lex.charset}.
+\end{defnote}
 
 \indexdefn{parameter}%
 \indexdefn{parameter!function}%
@@ -214,8 +220,11 @@
 enclosing namespace (if any),
 and
 \grammarterm{requires-clause}\iref{temp.constr.decl} (if any)
-\begin{note} Signatures are used as a basis for
-name mangling and linking.\end{note}
+
+\begin{defnote}
+Signatures are used as a basis for
+name mangling and linking.
+\end{defnote}
 
 \indexdefn{signature}%
 \definition{signature}{defns.signature.templ}
@@ -265,11 +274,13 @@
 \indexdefn{type!static}%
 \definition{static type}{defns.static.type}
 type of an expression\iref{basic.types} resulting from
-analysis of the program without considering execution semantics\\
-\begin{note} The
-static type of an expression depends only on the form of the program in
+analysis of the program without considering execution semantics
+
+\begin{defnote}
+The static type of an expression depends only on the form of the program in
 which the expression appears, and does not change while the program is
-executing. \end{note}
+executing.
+\end{defnote}
 
 \indexdefn{unblock}%
 \definition{unblock}{defns.unblock}
@@ -278,8 +289,10 @@
 \indexdefn{behavior!undefined}%
 \definition{undefined behavior}{defns.undefined}
 behavior for which this International Standard
-imposes no requirements\\
-\begin{note} Undefined behavior may be expected when
+imposes no requirements
+
+\begin{defnote}
+Undefined behavior may be expected when
 this International Standard omits any explicit
 definition of behavior or when a program uses an erroneous construct or erroneous data.
 Permissible undefined behavior ranges
@@ -291,16 +304,18 @@
 not engender undefined behavior; they are required to be diagnosed.
 Evaluation of a constant expression never exhibits behavior explicitly
 specified as undefined\iref{expr.const}.
-\end{note}
+\end{defnote}
 
 \indexdefn{behavior!unspecified}%
 \definition{unspecified behavior}{defns.unspecified}
 behavior, for a well-formed program construct and correct data, that
-depends on the implementation\\
-\begin{note} The implementation is not required to
+depends on the implementation
+
+\begin{defnote}
+The implementation is not required to
 document which behavior occurs. The range of
 possible behaviors is usually delineated by this International Standard.
-\end{note}
+\end{defnote}
 
 \indexdefn{program!well-formed}%
 \definition{well-formed program}{defns.well.formed}

source/lib-intro.tex

@@ -135,16 +135,20 @@
 \definition{arbitrary-positional stream}{defns.arbitrary.stream}
 \indexdefn{stream!arbitrary-positional}%
 stream (described in \ref{input.output}) that can seek to any integral position within
-the length of the stream\\
-\begin{note} Every arbitrary-positional stream is also a repositional stream. \end{note}
+the length of the stream
+
+\begin{defnote}
+Every arbitrary-positional stream is also a repositional stream.
+\end{defnote}
 
 \definition{character}{defns.character}
 \indexdefn{character}%
 \defncontext{\ref{strings}, \ref{localization}, \ref{input.output}, and~\ref{re}}
 object which,
 when treated sequentially,
-can represent text\\
-\begin{note}
+can represent text
+
+\begin{defnote}
 The term does not mean only
 \tcode{char},
 \tcode{char16_t},
@@ -154,17 +158,18 @@
 objects,
 but any value that can be represented by a type
 that provides the definitions specified in these Clauses.
-\end{note}
+\end{defnote}
 
 \definition{character container type}{defns.character.container}
 \indexdefn{type!character container}%
 class or a type used to
-represent a character\\
-\begin{note}
+represent a character
+
+\begin{defnote}
 It is used for one of the template parameters of the string,
 iostream, and regular expression class templates.
 A character container type is a POD\iref{basic.types} type.
-\end{note}
+\end{defnote}
 
 \definition{comparison function}{defns.comparison}
 \indexdefn{function!comparison}%
@@ -174,16 +179,17 @@
 \definition{component}{defns.component}
 \indexdefn{component}%
 group of library entities directly related as members, parameters, or
-return types\\
-\begin{note}
+return types
+
+\begin{defnote}
 For example, the class template
 \tcode{basic_string}
 and the non-member
 function templates
 that operate on
 strings are referred to as the
 \term{string component}.
-\end{note}
+\end{defnote}
 
 \definition{constant subexpression}{defns.const.subexpr}
 \indexdefn{constant subexpression}%
@@ -222,17 +228,19 @@
 \definition{handler function}{defns.handler}
 \indexdefn{function!handler}%
 \term{non-reserved function}
-whose definition may be provided by a \Cpp program\\
-\begin{note}
+whose definition may be provided by a \Cpp program
+
+\begin{defnote}
 A \Cpp program may designate a handler function at various points in its execution by
 supplying a pointer to the function when calling any of the library functions that install
 handler functions\iref{language.support}.
-\end{note}
+\end{defnote}
 
 \definition{iostream class templates}{defns.iostream.templates}
 templates, defined in \ref{input.output},
-that take two template arguments\\
-\begin{note}
+that take two template arguments
+
+\begin{defnote}
 The arguments are named
 \tcode{charT}
 and
@@ -246,7 +254,7 @@
 of the character type represented by
 \tcode{charT}
 necessary to implement the iostream class templates.
-\end{note}
+\end{defnote}
 
 \definition{modifier function}{defns.modifier}
 \indexdefn{function!modifier}%
@@ -274,30 +282,35 @@
 \definition{observer function}{defns.observer}
 \indexdefn{function!observer}%
 class member function\iref{class.mfct} that accesses the state of an object of the class
-but does not alter that state\\
-\begin{note}
+but does not alter that state
+
+\begin{defnote}
 Observer functions are specified as
 \tcode{const}
 member functions\iref{class.this}.
-\end{note}
+\end{defnote}
 
 \definition{referenceable type}{defns.referenceable}
 \indexdefn{type!referenceable}%
 type that is either an
 an object type, a function type that does not have cv-qualifiers or a
 \grammarterm{ref-qualifier}, or a reference type
-\begin{note} The term describes a type to which a reference can be created,
-including reference types. \end{note}
+
+\begin{defnote}
+The term describes a type to which a reference can be created,
+including reference types.
+\end{defnote}
 
 \definition{replacement function}{defns.replacement}
 \indexdefn{function!replacement}%
 non-reserved function
-whose definition is provided by a \Cpp program\\
-\begin{note}
+whose definition is provided by a \Cpp program
+
+\begin{defnote}
 Only one definition for such a function is in effect for the duration of the program's
 execution, as the result of creating the program\iref{lex.phases} and resolving the
 definitions of all translation units\iref{basic.link}.
-\end{note}
+\end{defnote}
 
 \definition{repositional stream}{defns.repositional.stream}
 \indexdefn{stream!repositional}%
@@ -312,28 +325,33 @@
 \term{handler function}
 semantics
 applicable to both the behavior provided by the implementation and
-the behavior of any such function definition in the program\\
-\begin{note}
+the behavior of any such function definition in the program
+
+\begin{defnote}
 If such a function defined in a \Cpp program fails to meet the required
 behavior when it executes, the behavior is undefined.%
 \indextext{undefined}
-\end{note}
+\end{defnote}
 
 \definition{reserved function}{defns.reserved.function}
 \indexdefn{function!reserved}%
 function, specified as part of the \Cpp standard library, that must be defined by the
-implementation\\
-\begin{note}
+implementation
+
+\begin{defnote}
 If a \Cpp program provides a definition for any reserved function, the results are undefined.%
 \indextext{undefined}
-\end{note}
+\end{defnote}
 
 \definition{stable algorithm}{defns.stable}
 \indexdefn{algorithm!stable}%
 \indexdefn{stable algorithm}%
 algorithm that preserves, as appropriate to the particular algorithm, the order
-of elements\\
-\begin{note} Requirements for stable algorithms are given in~\ref{algorithm.stable}. \end{note}
+of elements
+
+\begin{defnote}
+Requirements for stable algorithms are given in \ref{algorithm.stable}.
+\end{defnote}
 
 \definition{traits class}{defns.traits}
 \indexdefn{traits}%
@@ -343,11 +361,14 @@
 \definition{valid but unspecified state}{defns.valid}
 \indexdefn{valid but unspecified state}%
 value of an object that is not specified except that the object's invariants are
-met and operations on the object behave as specified for its type\\
-\begin{example} If an object \tcode{x} of type \tcode{std::vector<int>} is in a
+met and operations on the object behave as specified for its type
+
+\begin{example}
+If an object \tcode{x} of type \tcode{std::vector<int>} is in a
 valid but unspecified state, \tcode{x.empty()} can be called unconditionally,
 and \tcode{x.front()} can be called only if \tcode{x.empty()} returns
-\tcode{false}. \end{example}
+\tcode{false}.
+\end{example}
 
 \rSec1[description]{Method of description (Informative)}
 

source/macros.tex

@@ -531,9 +531,11 @@
 
 %%--------------------------------------------------
 %% Definitions section for "Terms and definitions"
+\newcounter{termnote}
 \newcommand{\nocontentsline}[3]{}
 \newcommand{\definition}[2]{%
 \addxref{#2}%
+\setcounter{termnote}{0}%
 \let\oldcontentsline\addcontentsline%
 \let\addcontentsline\nocontentsline%
 \ifcase\value{SectionDepth}
@@ -547,3 +549,4 @@
 \let\addcontentsline\oldcontentsline%
 }
 \newcommand{\defncontext}[1]{\textlangle#1\textrangle}
+\newenvironment{defnote}{\addtocounter{termnote}{1}\noteintro{Note \thetermnote{} to entry}}{\noteoutro{note}\xspace}