OK, error, ambiguous consistency of comments in examples.

source/access.tex

@@ -88,8 +88,8 @@
 };
 
 void f() {
- A::BB x; // OK, typedef name \tcode{A::BB} is public
- A::B y; // access error, \tcode{A::B} is private
+ A::BB x; // OK: typedef name \tcode{A::BB} is public
+ A::B y; // access error: \tcode{A::B} is private
 }
 \end{codeblock}
 \end{note}
@@ -187,7 +187,7 @@
 template <class U, class V = typename U::TT>
 class D : public U { };
 
-D <C<B> >* d; // access error, C::TT is protected
+D <C<B> >* d; // access error: C::TT is protected
 \end{codeblock}
 \end{example}
 
@@ -657,7 +657,7 @@
 };
 
 class Y {
- int v[X::a]; // OK, \tcode{Y} is a friend of \tcode{X}
+ int v[X::a]; // OK: \tcode{Y} is a friend of \tcode{X}
 };
 
 class Z {
@@ -842,13 +842,13 @@
  class A {
  friend class X; // OK, but \tcode{X} is a local class, not \tcode{::X}
  friend class Y; // OK
- friend class Z; // OK, introduces local class \tcode{Z}
- friend void a(); // error, \tcode{::a} is not considered
+ friend class Z; // OK: introduces local class \tcode{Z}
+ friend void a(); // error: \tcode{::a} is not considered
  friend void b(); // OK
  friend void c(); // error
  };
  X* px; // OK, but \tcode{::X} is found
- Z* pz; // error, no \tcode{Z} is found
+ Z* pz; // error: no \tcode{Z} is found
 }
 \end{codeblock}
 \end{example}

source/basic.tex

@@ -914,7 +914,7 @@
 class X {
  char v[i]; // error: \tcode{i} refers to \tcode{::i}
  // but when reevaluated is \tcode{X::i}
- int f() { return sizeof(c); } //  OK: \tcode{X::c}
+ int f() { return sizeof(c); } // OK: \tcode{X::c}
  char c;
  enum { i = 2 };
 };
@@ -1753,7 +1753,7 @@
 B::B() { }
 
 B::A ba; // object of type \tcode{A}
-A::A a; // error, \tcode{A::A} is not a type name
+A::A a; // error: \tcode{A::A} is not a type name
 struct A::A a2; // object of type \tcode{A}
 \end{codeblock}
 \end{example}
@@ -1949,8 +1949,8 @@
 namespace C {
  using namespace A;
  using namespace B;
- int i = C::x; // OK, \tcode{A::x} (of type \tcode{int} )
- int j = C::y; // ambiguous, \tcode{A::y} or \tcode{B::y}
+ int i = C::x; // OK: \tcode{A::x} (of type \tcode{int} )
+ int j = C::y; // ambiguous: \tcode{A::y} or \tcode{B::y}
 }
 \end{codeblock}
 \end{example}
@@ -1977,7 +1977,7 @@
  }
  using namespace B;
 }
-void A::f1(int){ } // ill-formed, \tcode{f1} is not a member of \tcode{A}
+void A::f1(int){ } // ill-formed: \tcode{f1} is not a member of \tcode{A}
 \end{codeblock}
 
 \end{example} However, in such namespace member declarations, the
@@ -2000,7 +2000,7 @@
 
 using namespace A;
 using namespace C::D;
-void B::f1(int){ } // OK, defines \tcode{A::B::f1(int)}
+void B::f1(int){ } // OK: defines \tcode{A::B::f1(int)}
 \end{codeblock}
 \end{example}
 \indextext{lookup!qualified~name|)}%
@@ -3325,7 +3325,7 @@
 void B::mutate() {
  new (this) D2; // reuses storage --- ends the lifetime of \tcode{*this}
  f(); // undefined behavior
- ... = this; // OK, \tcode{this} points to valid memory
+ ... = this; // OK: \tcode{this} points to valid memory
 }
 
 void g() {
@@ -3594,7 +3594,7 @@
 
 X x;
 void bar() {
- xp = &x; // OK; type is ``pointer to \tcode{X}''
+ xp = &x; // OK: type is ``pointer to \tcode{X}''
  arrp = &arr; // ill-formed: different types
  xp++; // OK: \tcode{X} is complete
  arrp++; // ill-formed: \tcode{UNKA} can't be completed

source/classes.tex

@@ -316,7 +316,7 @@
 
 \begin{codeblock}
 struct S { int a; };
-struct S { int a; }; // error, double definition
+struct S { int a; }; // error: double definition
 \end{codeblock}
 
 is ill-formed because it defines \tcode{S} twice.
@@ -781,7 +781,7 @@
 union U { T1 t1; T2 t2; };
 int f() {
  U u = { { 1, 2 } }; // active member is \tcode{t1}
- return u.t2.c; // OK, as if \tcode{u.t1.a} were nominated
+ return u.t2.c; // OK: as if \tcode{u.t1.a} were nominated
 }
 \end{codeblock}
 \end{example}
@@ -1635,7 +1635,7 @@
 struct X { const int a; int b; };
 union Y { X x; int k; };
 void g() {
- Y y = { { 1, 2 } }; // OK, \tcode{y.x} is active union member (\ref{class.mem})
+ Y y = { { 1, 2 } }; // OK: \tcode{y.x} is active union member (\ref{class.mem})
  int n = y.x.a;
  y.k = 4; // OK: ends lifetime of \tcode{y.x}, \tcode{y.k} is active member of union
  y.x.b = n; // undefined behavior: \tcode{y.x.b} modified outside its lifetime,

source/compatibility.tex

@@ -1578,12 +1578,12 @@
 struct derived;
 struct base {
  friend struct derived;
-private: 
+private:
  base();
 };
 struct derived : base {};
 
-derived d1{}; // Error. The code was well-formed before.
+derived d1{}; // error: the code was well-formed before.
 derived d2; // still OK
 \end{codeblock}
 

source/conversions.tex

@@ -154,7 +154,7 @@
 }
 auto g = f();
 int m = g(false); // undefined behavior due to access of \tcode{x.n} outside its lifetime
-int n = g(true); // OK, does not access \tcode{y.n}
+int n = g(true); // OK: does not access \tcode{y.n}
 \end{codeblock}
 \end{example}
 The result of the conversion is determined according to the
@@ -231,7 +231,7 @@
 \begin{example}
 \begin{codeblock}
 struct X { int n; };
-int k = X().n; // OK, \tcode{X()} prvalue is converted to xvalue
+int k = X().n; // OK: \tcode{X()} prvalue is converted to xvalue
 \end{codeblock}
 \end{example}
 

source/declarations.tex

@@ -154,7 +154,7 @@
 
 \begin{codeblock}
 enum { }; // ill-formed
-typedef class { }; //  ill-formed
+typedef class { }; // ill-formed
 \end{codeblock}
 \end{example}
 
@@ -1466,7 +1466,7 @@
  -> decltype((h<T>())); // does not force completion of \tcode{A<T>}; \tcode{A<T>::\~{}A()} is
  // not implicitly used within the context of this \grammarterm{decltype-specifier}
 void r() {
- q(42); // Error: deduction against \tcode{q} succeeds, so overload resolution
+ q(42); // error: deduction against \tcode{q} succeeds, so overload resolution
  // selects the specialization ``\tcode{q(T) -> decltype((h<T>())) [with T=int]}''.
  // The return type is \tcode{A<int>}, so a temporary is introduced and its
  // destructor is used, so the program is ill-formed.
@@ -1678,7 +1678,7 @@
 \begin{example}
 \begin{codeblock}
 auto f() { } // OK, return type is \tcode{void}
-auto* g() { } // error, cannot deduce \tcode{auto*} from \tcode{void()}
+auto* g() { } // error: cannot deduce \tcode{auto*} from \tcode{void()}
 \end{codeblock}
 \end{example}
 
@@ -1690,14 +1690,14 @@
 \tcode{return} statements.
 \begin{example}
 \begin{codeblock}
-auto n = n; // error, \tcode{n}'s type is unknown
+auto n = n; // error: \tcode{n}'s type is unknown
 auto f();
-void g() { &f; } // error, \tcode{f}'s return type is unknown
+void g() { &f; } // error: \tcode{f}'s return type is unknown
 auto sum(int i) {
  if (i == 1)
  return i; // \tcode{sum}'s return type is \tcode{int}
  else
- return sum(i-1)+i; // OK, \tcode{sum}'s return type has been deduced
+ return sum(i-1)+i; // OK: \tcode{sum}'s return type has been deduced
 }
 \end{codeblock}
 \end{example}
@@ -1729,19 +1729,19 @@
 auto f();
 auto f() { return 42; } // return type is \tcode{int}
 auto f(); // OK
-int f(); // error, cannot be overloaded with \tcode{auto f()}
-decltype(auto) f(); // error, \tcode{auto} and \tcode{decltype(auto)} don't match
+int f(); // error: cannot be overloaded with \tcode{auto f()}
+decltype(auto) f(); // error: \tcode{auto} and \tcode{decltype(auto)} don't match
 
 template <typename T> auto g(T t) { return t; } // \#1
 template auto g(int); // OK, return type is \tcode{int}
-template char g(char); // error, no matching template
-template<> auto g(double); // OK, forward declaration with unknown return type
+template char g(char); // error: no matching template
+template<> auto g(double); // OK: forward declaration with unknown return type
 
-template <class T> T g(T t) { return t; } // OK, not functionally equivalent to \#1
-template char g(char); // OK, now there is a matching template
+template <class T> T g(T t) { return t; } // OK: not functionally equivalent to \#1
+template char g(char); // OK: now there is a matching template
 template auto g(float); // still matches \#1
 
-void h() { return g(42); } // error, ambiguous
+void h() { return g(42); } // error: ambiguous
 
 template <typename T> struct A {
  friend T frf(T);
@@ -1877,9 +1877,9 @@
 auto x5a = f(); // \tcode{decltype(x5a)} is \tcode{int}
 decltype(auto) x5d = f(); // \tcode{decltype(x5d)} is \tcode{int\&\&}
 auto x6a = { 1, 2 }; // \tcode{decltype(x6a)} is \tcode{std::initializer_list<int>}
-decltype(auto) x6d = { 1, 2 }; // error, \tcode{\{ 1, 2 \}} is not an expression
+decltype(auto) x6d = { 1, 2 }; // error: \tcode{\{ 1, 2 \}} is not an expression
 auto *x7a = &i; // \tcode{decltype(x7a)} is \tcode{int*}
-decltype(auto)*x7d = &i; // error, declared type is not plain \tcode{decltype(auto)}
+decltype(auto)*x7d = &i; // error: declared type is not plain \tcode{decltype(auto)}
 \end{codeblock}
 \end{example}
 
@@ -1915,9 +1915,9 @@
 container(Iter b, Iter e) -> container<typename std::iterator_traits<Iter>::value_type>;
 std::vector<double> v = { /* ... */};
 
-container c(7); // OK, deduces \tcode{int} for \tcode{T}
-auto d = container(v.begin(), v.end()); // OK, deduces \tcode{double} for \tcode{T}
-container e{5, 6}; // error, \tcode{int} is not an iterator
+container c(7); // OK: deduces \tcode{int} for \tcode{T}
+auto d = container(v.begin(), v.end()); // OK: deduces \tcode{double} for \tcode{T}
+container e{5, 6}; // error: \tcode{int} is not an iterator
 \end{codeblock}
 \end{example}
 
@@ -3195,14 +3195,14 @@
  }
  using namespace A::B::C;
  void f1() {
- i = 5; // OK, \tcode{C::i} visible in \tcode{B} and hides \tcode{A::i}
+ i = 5; // OK: \tcode{C::i} visible in \tcode{B} and hides \tcode{A::i}
  }
  }
  namespace D {
  using namespace B;
  using namespace C;
  void f2() {
- i = 5; // ambiguous, \tcode{B::C::i} or \tcode{A::i}?
+ i = 5; // ambiguous: \tcode{B::C::i} or \tcode{A::i}?
  }
  }
  void f3() {
@@ -3349,7 +3349,7 @@
 }
 
 void f() {
- d1++; // error: ambiguous \tcode{::d1} or \tcode{D::d1}?
+ d1++; // error: ambiguous: \tcode{::d1} or \tcode{D::d1}?
  ::d1++; // OK
  D::d1++; // OK
  d2++; // OK: \tcode{D::d2}
@@ -3580,7 +3580,7 @@
 
 namespace B {
  extern "C" int f(); // \tcode{A::f} and \tcode{B::f} refer to the same function
- extern "C" int g() { return 1; } // ill-formed, the function \tcode{g}
+ extern "C" int g() { return 1; } // ill-formed: the function \tcode{g}
  // with C language linkage has two definitions
 }
 
@@ -3851,7 +3851,7 @@
 struct alignas(8) S {};
 struct alignas(1) U {
  S s;
-}; // Error: \tcode{U} specifies an alignment that is less strict than
+}; // error: \tcode{U} specifies an alignment that is less strict than
  // if the \tcode{alignas(1)} were omitted.
 \end{codeblock}
 \end{example}