Various bug fixes to application of wording.

N3624 - format U1 and U2 with code font

N3638 - add missing \pnum

N3649 - decl-specifierss -> decl-specifiers

N3652 - strike "of literal type" as directed by N3652.

Bugfix - remove spurious line break in [basic.start.init]/2.

Bugfix - remove excess whitespace in [expr.prim.lambda]

Bug fix - [expr.prim.lambda] format operator()(a) in code font.

Bug fix - in [expr.const] format constexpr in comment as code.

N3638 - remove spurious comma.

[temp.explicit] add missing comma.

N3652 - fix section names for C++11 compatibility sections.

N3638 - add missing paragraph

Author: Stefanus Du Toit

source/basic.tex

@@ -2510,7 +2510,6 @@
 constant expression, except that it may also invoke \tcode{constexpr} constructors
 for \tcode{o} and its subobjects even if those objects are of non-literal class
 types \enternote such a class may have a non-trivial destructor \exitnote.
-
 \indextext{initialization!constant}%
 \term{Constant initialization} is performed:
 

source/compatibility.tex

@@ -800,15 +800,15 @@
 Programs and headers that reference \mname{STDC} are
 quite common.
 
-\rSec1[diff.cpp03]{\Cpp and ISO \CppIII}
+\rSec1[diff.cpp11]{\Cpp and ISO \CppIII}
 
 \pnum
 \indextext{summary!compatibility~with ISO \CppIII}%
 This subclause lists the differences between \Cpp and
 ISO \CppIII (ISO/IEC 14882:2003, \doccite{Programming Languages --- \Cpp}),
 by the chapters of this document.
 
-\rSec2[diff.cpp03.lex]{Clause \ref{lex}: lexical conventions}
+\rSec2[diff.cpp11.lex]{Clause \ref{lex}: lexical conventions}
 
 \ref{lex.pptoken}
 \change New kinds of string literals

source/declarations.tex

@@ -1511,7 +1511,7 @@
 
 \pnum
 If the \tcode{auto} \grammarterm{type-specifier} appears as one of the
-\grammarterm{decl-specifiers}{s} in the \grammarterm{decl-specifier-seq} of a
+\grammarterm{decl-specifier}{s} in the \grammarterm{decl-specifier-seq} of a
 \grammarterm{parameter-declaration} of a \grammarterm{lambda-expression}, the
 \indextext{generic lambda!definition of}%
 lambda is a \term{generic lambda}~(\ref{expr.prim.lambda}). \enterexample
@@ -1647,6 +1647,12 @@
 \exitexample%
 \indextext{specifier|)}
 
+\pnum
+If a function with a declared return type that contains a placeholder type has
+multiple \tcode{return} statements, the return type is deduced for each
+\tcode{return} statement. If the type deduced is not the same in each
+deduction, the program is ill-formed.
+
 \pnum
 If a function with a declared return type that uses a placeholder type has no
 \tcode{return} statements, the return type is deduced as though from a
@@ -1685,7 +1691,7 @@
 body contains a \tcode{return} statement with a non-type-dependent operand.
 \enternote Therefore, any use of a specialization of the function template will
 cause an implicit instantiation. Any errors that arise from this instantiation
-are not in the immediate context of the function type, and can result in the
+are not in the immediate context of the function type and can result in the
 program being ill-formed. \exitnote
 \enterexample
 \begin{codeblock}
@@ -1697,6 +1703,7 @@
 \end{codeblock}
 \exitexample
 
+\pnum
 Redeclarations or specializations of a function or function template with a
 declared return type that uses a placeholder type shall also use that
 placeholder, not a deduced type.

source/expressions.tex

@@ -283,8 +283,8 @@
 respectively;
 
 \item
-if \tcode{T1} is ``pointer to member of \tcode{C1} of type \cvqual{cv1} U1'' and \tcode{T2} is
-``pointer to member of \tcode{C2} of type \cvqual{cv2} U2'' where \tcode{C1} is
+if \tcode{T1} is ``pointer to member of \tcode{C1} of type \cvqual{cv1} \tcode{U1}'' and \tcode{T2} is
+``pointer to member of \tcode{C2} of type \cvqual{cv2} \tcode{U2}'' where \tcode{C1} is
 reference-related to \tcode{C2} or \tcode{C2} is reference-related to
 \tcode{C1}~(\ref{dcl.init.ref}), the cv-combined type of \tcode{T2} and \tcode{T1} or the cv-combined type
 of \tcode{T1} and \tcode{T2}, respectively;
@@ -699,7 +699,7 @@
 invented \grammarterm{template-parameter}.
 \enterexample
 \begin{codeblock}
-  auto glambda  = [](auto a, auto&& b) { return a < b; };
+  auto glambda = [](auto a, auto&& b) { return a < b; };
   bool b = glambda(3, 3.14);                                  // OK
   auto vglambda = [](auto printer) {
      return [=](auto&& ... ts) {                              // OK: \tcode{ts} is a function parameter pack
@@ -760,7 +760,7 @@
 struct Closure {
   template<class T> auto operator()(T t) const { ... }
   template<class T> static auto lambda_call_operator_invoker(T a) {
-    // forwards execution to operator()(a) and therefore has
+    // forwards execution to \tcode{operator()(a)} and therefore has
     // the same return type deduced
     ...
   }
@@ -4484,7 +4484,7 @@
   objects. \exitnote, or
 
   \item
-  a non-volatile glvalue of literal type that refers to a non-volatile object
+  a non-volatile glvalue that refers to a non-volatile object
   defined with \tcode{constexpr}, or that refers to a non-mutable sub-object
   of such an object, or
 
@@ -4570,7 +4570,7 @@
 }
 constexpr int f2(int k) {
   int x = k;                        // OK: not required to be a constant expression
-                                    // because \tcode{x} is not constexpr
+                                    // because \tcode{x} is not \tcode{constexpr}
   return x;
 }
 

source/templates.tex

@@ -4662,7 +4662,7 @@
 
 \pnum
 \indextext{instantiation!explicit}%
-A class, function, variable or member template specialization can be explicitly
+A class, function, variable, or member template specialization can be explicitly
 instantiated from its template.
 A member function, member class or static data member of a class template can
 be explicitly instantiated from the member definition associated with its class