Prefer // OK: over // OK, ; // error: over // error, ; // error over // Error.

Author: vgvassilev

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 {
@@ -840,15 +840,15 @@
   class Y;
   extern void b();
   class A {
-  friend class X;   // OK, but \tcode{X} is a local class, not \tcode{::X}
+  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
+  X* px;            // OK: but \tcode{::X} is found
+  Z* pz;            // error: no \tcode{Z} is found
 }
 \end{codeblock}
 \end{example}

source/basic.tex

@@ -929,7 +929,7 @@
 
 typedef int I;
 class D {
-  typedef I I;                      // error, even though no reordering involved
+  typedef I I;                      // error: even though no reordering involved
 };
 \end{codeblock}
 \end{example}
@@ -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,7 +1949,7 @@
 namespace C {
   using namespace A;
   using namespace B;
-  int i = C::x;     // OK, \tcode{A::x} (of type \tcode{int} )
+  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}
@@ -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() {

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/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

@@ -906,7 +906,7 @@
 \begin{codeblock}
 constexpr int f(bool b)
   { return b ? throw 0 : 0; }               // OK
-constexpr int f() { return f(true); }       // ill-formed, no diagnostic required
+constexpr int f() { return f(true); }       // ill-formed: no diagnostic required
 
 struct B {
   constexpr B(int x) : i(0) { }             // \tcode{x} is unused
@@ -916,7 +916,7 @@
 int global;
 
 struct D : B {
-  constexpr D() : B(global) { }             // ill-formed, no diagnostic required
+  constexpr D() : B(global) { }             // ill-formed: no diagnostic required
                                             // lvalue-to-rvalue conversion on non-constant \tcode{global}
 };
 \end{codeblock}
@@ -1677,8 +1677,8 @@
 body.
 \begin{example}
 \begin{codeblock}
-auto  f() { } // OK, return type is \tcode{void}
-auto* g() { } // error, cannot deduce \tcode{auto*} from \tcode{void()}
+auto  f() { } // OK: return type is \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 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 <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,7 +3195,7 @@
     }
     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 {
@@ -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
 }
 

source/declarators.tex

@@ -620,7 +620,7 @@
 or allow it to be changed through a cv-unqualified pointer later, for example:
 
 \begin{codeblock}
-*ppc = &ci;         // OK, but would make \tcode{p} point to \tcode{ci} ...
+*ppc = &ci;         // OK: but would make \tcode{p} point to \tcode{ci} ...
                     // ... because of previous error
 *p = 5;             // clobber \tcode{ci}
 \end{codeblock}
@@ -1780,25 +1780,25 @@
 \begin{example}
 
 \begin{codeblock}
-void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
+void g(int = 0, ...);           // OK: ellipsis is not a parameter so it can follow
                                 // a parameter with a default argument
 void f(int, int);
 void f(int, int = 7);
 void h() {
-  f(3);                         // OK, calls \tcode{f(3, 7)}
+  f(3);                         // OK: calls \tcode{f(3, 7)}
   void f(int = 1, int);         // error: does not use default
                                 // from surrounding scope
 }
 void m() {
   void f(int, int);             // has no defaults
   f(4);                         // error: wrong number of arguments
   void f(int, int = 5);         // OK
-  f(4);                         // OK, calls \tcode{f(4, 5);}
+  f(4);                         // OK: calls \tcode{f(4, 5);}
   void f(int, int = 5);         // error: cannot redefine, even to
                                 // same value
 }
 void n() {
-  f(6);                         // OK, calls \tcode{f(6, 7)}
+  f(6);                         // OK: calls \tcode{f(6, 7)}
 }
 \end{codeblock}
 \end{example}
@@ -1929,7 +1929,7 @@
                                     // used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter \tcode{I} found
-int h(int a, int b = sizeof(a));    // OK, unevaluated operand
+int h(int a, int b = sizeof(a));    // OK: unevaluated operand
 \end{codeblock}
 \end{example}
 A non-static member shall not appear in a default argument unless it appears as
@@ -1969,7 +1969,7 @@
 
 void h() {
   int j = f(1);
-  int k = f();                  // OK, means \tcode{f(0)}
+  int k = f();                  // OK: means \tcode{f(0)}
 }
 
 int (*p1)(int) = &f;
@@ -2007,7 +2007,7 @@
 void m() {
   B* pb = new B;
   A* pa = pb;
-  pa->f();          // OK, calls \tcode{pa->B::f(7)}
+  pa->f();          // OK: calls \tcode{pa->B::f(7)}
   pb->f();          // error: wrong number of arguments for \tcode{B::f()}
 }
 \end{codeblock}
@@ -2268,7 +2268,7 @@
 
 \begin{codeblock}
 struct onlydouble {
-  onlydouble() = delete;              // OK, but redundant
+  onlydouble() = delete;              // OK: but redundant
   onlydouble(std::intmax_t) = delete;
   onlydouble(double);
 };
@@ -2285,8 +2285,8 @@
   void* operator new(std::size_t) = delete;
   void* operator new[](std::size_t) = delete;
 };
-sometype* p = new sometype;     // error, deleted class \tcode{operator new}
-sometype* q = new sometype[3];  // error, deleted class \tcode{operator new[]}
+sometype* p = new sometype;     // error: deleted class \tcode{operator new}
+sometype* q = new sometype[3];  // error: deleted class \tcode{operator new[]}
 \end{codeblock}
 \end{example}
 
@@ -2304,7 +2304,7 @@
   ~moveonly() = default;
 };
 moveonly* p;
-moveonly q(*p); // error, deleted copy constructor
+moveonly q(*p); // error: deleted copy constructor
 \end{codeblock}
 \end{example}
 
@@ -2734,7 +2734,7 @@
 \begin{codeblock}
   int f(bool b) {
     unsigned char c;
-    unsigned char d = c; // OK, \tcode{d} has an indeterminate value
+    unsigned char d = c; // OK: \tcode{d} has an indeterminate value
     int e = d;           // undefined behavior
     return b ? d : 0;    // undefined behavior if \tcode{b} is \tcode{true}
   }
@@ -4014,7 +4014,7 @@
 
 struct A {
   std::initializer_list<int> i4;
-  A() : i4{ 1, 2, 3 } {}  // ill-formed, would create a dangling reference
+  A() : i4{ 1, 2, 3 } {}  // ill-formed: would create a dangling reference
 };
 \end{codeblock}
 
@@ -4063,7 +4063,7 @@
 int x = 999;              // x is not a constant expression
 const int y = 999;
 const int z = 99;
-char c1 = x;              // OK, though it might narrow (in this case, it does narrow)
+char c1 = x;              // OK: though it might narrow (in this case, it does narrow)
 char c2{x};               // error: might narrow
 char c3{y};               // error: narrows (assuming \tcode{char} is 8 bits)
 char c4{z};               // OK: no narrowing needed

source/derived.tex

@@ -414,7 +414,7 @@
 struct F: public D, public E { };       // S(x,F) = S(x,E)
 int main() {
   F f;
-  f.x = 0;                              // OK, lookup finds \tcode{E::x}
+  f.x = 0;                              // OK: lookup finds \tcode{E::x}
 }
 \end{codeblock}