Remove trailing whitespace in LaTeX sources. (#1468)

Author: jensmaurer

source/algorithms.tex

@@ -1335,7 +1335,7 @@
 unsequenced with respect to one another within each thread of execution.
 These threads of execution are either the invoking thread of execution or threads of
 execution implicitly created by the library; the latter will provide weakly parallel
-forward progress guarantees. 
+forward progress guarantees.
 \begin{note}
 This means that multiple function object invocations may be interleaved on a
 single thread of execution, which overrides the usual guarantee from \ref{intro.execution}
@@ -2075,7 +2075,7 @@
 \returns If \tcode{last1 - first1 != last2 - first2}, return \tcode{false}.
 Otherwise return \tcode{true} if there exists a permutation of the elements in the
 range \range{first2}{first2 + (last1 - first1)}, beginning with \tcode{ForwardIterator2
-begin}, such that \tcode{equal(first1, last1, begin)} returns \tcode{true} or 
+begin}, such that \tcode{equal(first1, last1, begin)} returns \tcode{true} or
 \tcode{equal(first1, last1, begin, pred)} returns \tcode{true}; otherwise, returns
 \tcode{false}.
 
@@ -2287,7 +2287,7 @@
 
 \begin{itemdescr}
 \pnum
-\effects For each non-negative integer 
+\effects For each non-negative integer
 $i < n$, performs \tcode{*(result + i) = *(first + i)}.
 
 \pnum
@@ -4648,7 +4648,7 @@
 If \range{first1}{last1} contains $m$ elements that are equivalent to each other and
 \range{first2}{last2} contains $n$ elements that are equivalent to them, then
 $|m - n|$ of those elements shall be copied to the output range: the last
-$m - n$ of these elements from \range{first1}{last1} if $m > n$, and the last 
+$m - n$ of these elements from \range{first1}{last1} if $m > n$, and the last
 $n - m$ of these elements from \range{first2}{last2} if $m < n$.
 \end{itemdescr}
 

source/atomics.tex

@@ -78,7 +78,7 @@
   bool atomic_compare_exchange_weak(@\placeholder{atomic-type}@*@\itcorr[-1]@, T*, T) noexcept;
   bool atomic_compare_exchange_strong(volatile @\placeholder{atomic-type}@*@\itcorr[-1]@, T*, T) noexcept;
   bool atomic_compare_exchange_strong(@\placeholder{atomic-type}@*@\itcorr[-1]@, T*, T) noexcept;
-  bool atomic_compare_exchange_weak_explicit(volatile @\placeholder{atomic-type}@*@\itcorr[-1]@, T*, T, 
+  bool atomic_compare_exchange_weak_explicit(volatile @\placeholder{atomic-type}@*@\itcorr[-1]@, T*, T,
     memory_order, memory_order) noexcept;
   bool atomic_compare_exchange_weak_explicit(@\placeholder{atomic-type}@*@\itcorr[-1]@, T*, T,
     memory_order, memory_order) noexcept;
@@ -198,7 +198,7 @@
 \begin{codeblock}
 namespace std {
   enum memory_order {
-    memory_order_relaxed, memory_order_consume, memory_order_acquire, 
+    memory_order_relaxed, memory_order_consume, memory_order_acquire,
     memory_order_release, memory_order_acq_rel, memory_order_seq_cst
   };
 }
@@ -805,7 +805,7 @@
 \pnum
 There are only a few kinds of operations on atomic types, though there are many
 instances on those kinds. This section specifies each general kind. The specific
-instances are defined in 
+instances are defined in
 \ref{atomics.types.generic}, \ref{atomics.types.operations.general},
 \ref{atomics.types.operations.arith}, and \ref{atomics.types.operations.pointer}.
 

source/basic.tex

@@ -474,7 +474,7 @@
 were present in the definition of \tcode{D}; that is, the default
 argument is subject to the requirements described in this paragraph (and, if
 the default argument has subexpressions with default arguments, this
-requirement applies recursively).\footnote{\ref{dcl.fct.default} 
+requirement applies recursively).\footnote{\ref{dcl.fct.default}
 describes how default argument names are looked up.}
 
 \item if \tcode{D} is a class with an implicitly-declared
@@ -764,7 +764,7 @@
 \pnum
 \indextext{parameter!scope of}%
 The potential scope of a function parameter name
-(including one appearing in a 
+(including one appearing in a
 \grammarterm{lambda-declarator})
 or of a function-local predefined variable
 in a function
@@ -3854,7 +3854,7 @@
 \indextext{floating-point type!implementation-defined}%
 \begin{note}
 This International Standard imposes no requirements on the accuracy of
-floating-point operations; see also~\ref{support.limits}. 
+floating-point operations; see also~\ref{support.limits}.
 \end{note}
 Integral and floating types are collectively
 called \defnx{arithmetic}{type!arithmetic} types.
@@ -4061,9 +4061,9 @@
 \defn{volatile-qualified} version, and a
 \defn{const-volatile-qualified} version. The
 type of an object~(\ref{intro.object}) includes the \grammarterm{cv-qualifier}{s}
-specified in the \grammarterm{decl-specifier-seq}~(\ref{dcl.spec}), 
+specified in the \grammarterm{decl-specifier-seq}~(\ref{dcl.spec}),
 \grammarterm{declarator} (Clause~\ref{dcl.decl}),
-\grammarterm{type-id}~(\ref{dcl.name}), or 
+\grammarterm{type-id}~(\ref{dcl.name}), or
 \grammarterm{new-type-id}~(\ref{expr.new}) when the object is created.
 \begin{itemize}
 \item A \defnx{const object}{object!const} is an object of type \tcode{const T} or a

source/classes.tex

@@ -250,7 +250,7 @@
 
 struct T {          // trivial but not standard-layout
   int i;
-private: 
+private:
   int j;
 };
 

source/compatibility.tex

@@ -146,7 +146,7 @@
 names are referred to outside the \tcode{struct}.
 The latter is probably rare.
 
-\ref{basic.link} [also \ref{dcl.type}] 
+\ref{basic.link} [also \ref{dcl.type}]
 \change A name of file scope that is explicitly declared \tcode{const}, and not explicitly
 declared \tcode{extern}, has internal linkage, while in C it would have external linkage.
 \rationale
@@ -915,7 +915,7 @@
 \ref{expr.log.and}
 \change \tcode{\&\&} is valid in a \grammarterm{type-name}.
 \rationale Required for new features.
-\effect 
+\effect
 Valid \CppIII code may fail to compile or produce different results in
 this International Standard, as the following example illustrates:
 
@@ -1577,7 +1577,7 @@
 struct derived;
 struct base {
   friend struct derived;
-private: 
+private:
   base();
 };
 struct derived : base {};
@@ -1711,7 +1711,7 @@
 \begin{codeblock}
 #include <set>
 
-struct compare 
+struct compare
 {
   bool operator()(int a, int b)
   {

source/containers.tex

@@ -277,7 +277,7 @@
 \begin{note}
 The algorithm \tcode{equal()} is defined in Clause~\ref{algorithms}.
 \end{note}
- 
+
 \pnum
 The member function \tcode{size()} returns the number of elements in the container.
 The number of elements is defined by the rules of
@@ -547,7 +547,7 @@
 \end{codeblock}
 where \tcode{p} is the address of the uninitialized storage for the element
 allocated within \tcode{X}.
-	
+
 \item
 \tcode{T} is \defnx{\tcode{MoveInsertable} into \tcode{X}}
 {MoveInsertable into X@\tcode{MoveInsertable} into \tcode{X}}
@@ -4155,7 +4155,7 @@
 \begin{itemdescr}
 \pnum
 \effects If \tcode{sz < distance(begin(), end())}, erases the last \tcode{distance(begin(),
-end()) - sz} elements from the list. Otherwise, inserts \tcode{sz - distance(begin(), end())}  
+end()) - sz} elements from the list. Otherwise, inserts \tcode{sz - distance(begin(), end())}
 copies of \tcode{c} at the end of the list.
 
 \pnum
@@ -5412,7 +5412,7 @@
 \begin{note} The request is non-binding to allow latitude for
 implementation-specific optimizations. \end{note}
 It does not increase \tcode{capacity()}, but may reduce \tcode{capacity()}
-by causing reallocation. 
+by causing reallocation.
 If an exception is thrown other than by the move constructor
 of a non-\tcode{CopyInsertable} \tcode{T} there are no effects.
 
@@ -6269,7 +6269,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-The first form is equivalent to 
+The first form is equivalent to
 \tcode{return emplace(std::forward<P>(x))}. The second form is
 equivalent to \tcode{return emplace_hint(position, std::forward<P>(x))}.
 
@@ -6733,7 +6733,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-The first form is equivalent to 
+The first form is equivalent to
 \tcode{return emplace(std::forward<P>(x))}. The second form is
 equivalent to \tcode{return emplace_hint(position, std::forward<P>(x))}.
 
@@ -8035,12 +8035,12 @@
       unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
     template <class InputIterator>
-      unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf, 
+      unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                          const allocator_type& a)
         : unordered_multimap(f, l, n, hf, key_equal(), a) { }
     unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_multimap(il, n, hasher(), key_equal(), a) { }
-    unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf, 
+    unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
                        const allocator_type& a)
       : unordered_multimap(il, n, hf, key_equal(), a) { }
     ~unordered_multimap();
@@ -8195,7 +8195,7 @@
 provided, the number of buckets is \impldef{default number of buckets in
 \tcode{unordered_multimap}}. Then
 inserts elements from the range \range{f}{l}
-for the first form, or from the range 
+for the first form, or from the range
 \range{il.begin()}{il.end()} for the second form.
 \tcode{max_load_factor()} returns \tcode{1.0}.
 
@@ -8490,7 +8490,7 @@
 provided, the number of buckets is \impldef{default number of buckets in
 \tcode{unordered_set}}. Then
 inserts elements from the range \range{f}{l}
-for the first form, or from the range 
+for the first form, or from the range
 \range{il.begin()}{il.end()} for the second form.
 \tcode{max_load_factor()} returns \tcode{1.0}.
 
@@ -8600,12 +8600,12 @@
       unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
     template <class InputIterator>
-      unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf, 
+      unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                          const allocator_type& a)
       : unordered_multiset(f, l, n, hf, key_equal(), a) { }
     unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_multiset(il, n, hasher(), key_equal(), a) { }
-    unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf, 
+    unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf,
                        const allocator_type& a)
       : unordered_multiset(il, n, hf, key_equal(), a) { }
     ~unordered_multiset();