Regenerated.

1 files changed, 30 insertions, 26 deletions

diff --git a/NOTES b/NOTES
index 5614f67..b409cb4 100644
--- a/NOTES
+++ b/NOTES
@@ -12,7 +12,7 @@ options.
 
    You should define these macros by using `#define' preprocessor
 directives at the top of your source code files.  These directives
-*must* come before any `#include' of a system header file.  It is best
+_must_ come before any `#include' of a system header file.  It is best
 to make them the very first thing in the file, preceded only by
 comments.  You could also use the `-D' option to GCC, but it's better
 if you make the source files indicate their own meaning in a
@@ -25,10 +25,10 @@ standards require functions with names that smaller ones reserve to the
 user program.  This is not mere pedantry -- it has been a problem in
 practice.  For instance, some non-GNU programs define functions named
 `getline' that have nothing to do with this library's `getline'.  They
-would not be compilable if all features were enabled indescriminantly.
+would not be compilable if all features were enabled indiscriminately.
 
    This should not be used to verify that a program conforms to a
-limited standard.  It is insufficent for this purpose, as it will not
+limited standard.  It is insufficient for this purpose, as it will not
 protect you from including header files outside the standard, or
 relying on semantics undefined within the standard.
 
@@ -125,17 +125,16 @@ relying on semantics undefined within the standard.
      extension (LFS).
 
  - Macro: _LARGEFILE64_SOURCE
-     If you define this macro an additional set of function gets
-     available which enables to use on 32 bit systems to use files of
-     sizes beyond the usual limit of 2GB.  This interface is not
-     available if the system does not support files that large.  On
-     systems where the natural file size limit is greater than 2GB
-     (i.e., on 64 bit systems) the new functions are identical to the
-     replaced functions.
+     If you define this macro an additional set of function is made
+     available which enables 32 bit systems to use files of sizes beyond
+     the usual limit of 2GB.  This interface is not available if the
+     system does not support files that large.  On systems where the
+     natural file size limit is greater than 2GB (i.e., on 64 bit
+     systems) the new functions are identical to the replaced functions.
 
      The new functionality is made available by a new set of types and
-     functions which replace existing.  The names of these new objects
-     contain `64' to indicate the intention, e.g., `off_t' vs.
+     functions which replace the existing ones.  The names of these new
+     objects contain `64' to indicate the intention, e.g., `off_t' vs.
      `off64_t' and `fseeko' vs. `fseeko64'.
 
      This macro was introduced as part of the Large File Support
@@ -143,17 +142,17 @@ relying on semantics undefined within the standard.
      offsets are not generally used (see `_FILE_OFFSET_BITS'.
 
  - Macro: _FILE_OFFSET_BITS
-     This macro lets decide which file system interface shall be used,
+     This macro determines which file system interface shall be used,
      one replacing the other.  While `_LARGEFILE64_SOURCE' makes the
      64 bit interface available as an additional interface
-     `_FILE_OFFSET_BITS' allows to use the 64 bit interface to replace
-     the old interface.
+     `_FILE_OFFSET_BITS' allows the 64 bit interface to replace the old
+     interface.
 
-     If `_FILE_OFFSET_BITS' is undefined or if it is defined to the
-     value `32' nothing changes.  The 32 bit interface is used and
+     If `_FILE_OFFSET_BITS' is undefined, or if it is defined to the
+     value `32', nothing changes.  The 32 bit interface is used and
      types like `off_t' have a size of 32 bits on 32 bit systems.
 
-     If the macro is defined to the value `64' the large file interface
+     If the macro is defined to the value `64', the large file interface
      replaces the old interface.  I.e., the functions are not made
      available under different names as `_LARGEFILE64_SOURCE' does.
      Instead the old function names now reference the new functions,
@@ -167,11 +166,17 @@ relying on semantics undefined within the standard.
      This macro was introduced as part of the Large File Support
      extension (LFS).
 
+ - Macro: _ISOC99_SOURCE
+     Until the revised ISO C standard is widely adopted the new features
+     are not automatically enabled.  The GNU libc nevertheless has a
+     complete implementation of the new standard and to enable the new
+     features the macro `_ISOC99_SOURCE' should be defined.
+
  - Macro: _GNU_SOURCE
-     If you define this macro, everything is included: ISO C, POSIX.1,
-     POSIX.2, BSD, SVID, X/Open, LFS, and GNU extensions.  In the cases
-     where POSIX.1 conflicts with BSD, the POSIX definitions take
-     precedence.
+     If you define this macro, everything is included: ISO C89,
+     ISO C99, POSIX.1, POSIX.2, BSD, SVID, X/Open, LFS, and GNU
+     extensions.  In the cases where POSIX.1 conflicts with BSD, the
+     POSIX definitions take precedence.
 
      If you want to get the full effect of `_GNU_SOURCE' but make the
      BSD definitions take precedence over the POSIX definitions, use
@@ -191,11 +196,10 @@ relying on semantics undefined within the standard.
      If you define one of these macros, reentrant versions of several
      functions get declared.  Some of the functions are specified in
      POSIX.1c but many others are only available on a few other systems
-     or are unique to GNU libc.  The problem is that the
-     standardization of the thread safe C library interface still is
-     behind.
+     or are unique to GNU libc.  The problem is the delay in the
+     standardization of the thread safe C library interface.
 
-     Unlike on some other systems no special version of the C library
+     Unlike on some other systems, no special version of the C library
      must be used for linking.  There is only one version but while
      compiling this it must have been specified to compile as thread
      safe.