--- cvsroot/libecb/ecb.pod	2020/01/20 20:40:06	1.78
+++ cvsroot/libecb/ecb.pod	2020/01/20 21:10:16	1.84
@@ -87,7 +87,7 @@
 =item ECB_C
 
 True if the implementation defines the C<__STDC__> macro to a true value,
-while not claiming to be C++.
+while not claiming to be C++, i..e C, but not C++.
 
 =item ECB_C99
 
@@ -112,11 +112,19 @@
 True if the implementation claims to be compliant to C++11/C++14/C++17
 (ISO/IEC 14882:2011, :2014, :2017) or any later version.
 
+Note that many C++20 features will likely have their own feature test
+macros (see e.g. L<http://eel.is/c++draft/cpp.predefined#1.8>).
+
+=item ECB_OPTIMIZE_SIZE
+
+Is C<1> when the compiler optimizes for size, C<0> otherwise. This symbol
+can also be defined before including F<ecb.h>, in which case it will be
+unchanged.
+
 =item ECB_GCC_VERSION (major, minor)
 
-Expands to a true value (suitable for testing in by the preprocessor)
-if the compiler used is GNU C and the version is the given version, or
-higher.
+Expands to a true value (suitable for testing by the preprocessor) if the
+compiler used is GNU C and the version is the given version, or higher.
 
 This macro tries to return false on compilers that claim to be GCC
 compatible but aren't.
@@ -145,7 +153,7 @@
 
 =item ECB_STDFP
 
-If this evaluates to a true value (suitable for testing in by the
+If this evaluates to a true value (suitable for testing by the
 preprocessor), then C<float> and C<double> use IEEE 754 single/binary32
 and double/binary64 representations internally I<and> the endianness of
 both types match the endianness of C<uint32_t> and C<uint64_t>.
@@ -410,12 +418,6 @@
 
 =over 4
 
-=item ECB_OPTIMIZE_SIZE
-
-Is C<1> when the compiler optimizes for size, C<0> otherwise. This symbol
-can also be defined before including F<ecb.h>, in which case it will be
-unchanged.
-
 =item bool ecb_is_constant (expr)
 
 Returns true iff the expression can be deduced to be a compile-time
@@ -758,7 +760,7 @@
 Convert an unsigned 16, 32 or 64 bit value from big or little endian to host byte order.
 
 The naming convention is C<ecb_>(C<be>|C<le>)C<_u>C<16|32|64>C<_to_host>,
-where be and le stand for big endian and little endian, respectively.
+where C<be> and C<le> stand for big endian and little endian, respectively.
 
 =item uint_fast16_t ecb_host_to_be_u16 (uint_fast16_t v)
 
@@ -856,23 +858,23 @@
 
 =over 4
 
-=item T ecb_peek       (const void *ptr)
+=item T ecb_peek<T>      (const void *ptr)
 
-=item T ecb_peek_be    (const void *ptr)
+=item T ecb_peek_be<T>   (const void *ptr)
 
-=item T ecb_peek_le    (const void *ptr)
+=item T ecb_peek_le<T>   (const void *ptr)
 
-=item T ecb_peek_u     (const void *ptr)
+=item T ecb_peek_u<T>    (const void *ptr)
 
-=item T ecb_peek_be_u  (const void *ptr)
+=item T ecb_peek_be_u<T> (const void *ptr)
 
-=item T ecb_peek_le_u  (const void *ptr)
+=item T ecb_peek_le_u<T> (const void *ptr)
 
 Similarly to their C counterparts, these functions load an unsigned 8, 16,
 32 or 64 bit value from memory, with optional conversion from big/little
 endian.
 
-Since the type cannot be deduced, it has top be specified explicitly, e.g.
+Since the type cannot be deduced, it has to be specified explicitly, e.g.
 
    uint_fast16_t v = ecb_peek<uint16_t> (ptr);