Correct stuff, including alligned_alloc

Colin Robertson · Colin Robertson · commit 105ef6b4e835 · 2019-09-19T04:56:53.000-07:00
diff --git a/docs/standard-library/cstdlib.md b/docs/standard-library/cstdlib.md
@@ -90,7 +90,7 @@ Zero if the registration succeeds, non-zero if it fails.
 
 #### Remarks
 
-The `at_quick_exit()` functions register the function pointed to by *func* to be called without arguments when `quick_exit` is called. It's unspecified whether a call to `at_quick_exit()` that doesn't happen before all calls to `quick_exit` will succeed and the `at_quick_exit()` functions do not introduce a data race. The order of registration may be indeterminate if `at_quick_exit` was called from more than one thread and since `at_quick_exit` registrations are distinct from the `atexit` registrations, applications may need to call both registration functions with the same argument. The implementation shall support the registration of at least 32 functions.
+The `at_quick_exit()` functions register a function *func*, which is called without arguments when `quick_exit` is called. A call to `at_quick_exit()` that doesn't happen before all calls to `quick_exit` may not succeed. The `at_quick_exit()` functions don't introduce a data race. The order of registration may be indeterminate if `at_quick_exit` was called from more than one thread. Since `at_quick_exit` registrations are distinct from the `atexit` registrations, applications may need to call both registration functions using the same argument. MSVC supports the registration of at least 32 functions.
 
 ### <a name="atexit"></a> atexit
 
@@ -101,7 +101,7 @@ int atexit(atexit-handler * func) noexcept;
 
 #### Remarks
 
-The `atexit()` functions register the function pointed to by *func* to be called without arguments at normal program termination. It's unspecified whether a call to `atexit()` that doesn't happen before a call to `exit()` will succeed and the `atexit()` functions do not introduce a data race.The implementation shall support the registration of at least 32 functions.
+The `atexit()` functions register the function pointed to by *func* to be called without arguments at normal program termination. A call to `atexit()` that doesn't happen before a call to `exit()` may not succeed. The `atexit()` functions don't introduce a data race.
 
 #### Return Value
 
@@ -117,11 +117,11 @@ Returns zero if the registration succeeds, nonzero if it fails.
 
 First, objects with thread storage duration and associated with the current thread are destroyed.
 
-Next, objects with static storage duration are destroyed and functions registered by calling `atexit` are called. Automatic objects aren't destroyed as a result of calling `exit()`. If control leaves a registered function called by `exit` because the function doesn't provide a handler for a thrown exception, `std::terminate()` shall be called. A function is called for every time it is registered. Objects with automatic storage duration are all destroyed in a program whose main function contains no automatic objects and executes the call to `exit()`. Control can be transferred directly to such a main function by throwing an exception that's caught in main.
+Next, objects with static storage duration are destroyed and functions registered by calling `atexit` are called. Automatic objects aren't destroyed when `exit()` is called. If control leaves a registered function called by `exit` because the function doesn't provide a handler for a thrown exception, `std::terminate()` is called. A function is called once for every time it's registered. Objects with automatic storage duration are all destroyed in a program whose `main` function contains no automatic objects and executes the call to `exit()`. Control can be transferred directly to such a `main` function by throwing an exception that's caught in `main`.
 
-Next, all open C streams (as mediated by the function signatures declared in <cstdio>) with unwritten buffered data are flushed, all open C streams are closed, and all files created by calling `tmpfile()` are removed.
+Next, all open C streams (as mediated by the function signatures declared in \<cstdio>) with unwritten buffered data are flushed, all open C streams are closed, and all files created by calling `tmpfile()` are removed.
 
-Finally, control is returned to the host environment. If status is zero or EXIT_SUCCESS, an implementation-defined form of the status successful termination is returned. If status is EXIT_FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.
+Finally, control is returned to the host environment. When *status* is zero or EXIT_SUCCESS, an implementation-defined form of the status successful termination is returned. MSVC returns a value of zero. If *status* is EXIT_FAILURE, MSVC returns a value of 3. Otherwise, MSVC returns the *status* parameter value.
 
 ### <a name="getenv"></a> getenv
 
@@ -137,8 +137,7 @@ char* getenv(const char* name);
 
 #### Remarks
 
-Functions registered by calls to `at_quick_exit` are called in the reverse order of their registration, except that a function shall be called after any previously registered functions that had already been called at the time it was registered. Objects shall not be destroyed as a result of calling
-`quick_exit`. If control leaves a registered function called by `quick_exit` because the function doesn't provide a handler for a thrown exception, `std::terminate()` shall be called. A function registered via `at_quick_exit` is invoked by the thread that calls `quick_exit`, which can be a different thread than the one that registered it, so registered functions shouldn't rely on the identity of objects with thread storage duration. After calling registered functions, `quick_exit` shall call `_Exit(status)`. The standard file buffers aren't flushed. The function `quick_exit` is signal-safe when the functions registered with `at_quick_exit` are.
+Generally, functions registered by calls to `at_quick_exit` are called in the reverse order of their registration. This order doesn't apply to functions registered after other registered functions have already been called. No objects are destroyed when `quick_exit` is called. If control leaves a registered function called by `quick_exit` because the function doesn't provide a handler for a thrown exception, `std::terminate()` is called. A function registered via `at_quick_exit` is invoked by the thread that calls `quick_exit`, which can be a different thread than the one that registered it. That means registered functions shouldn't rely on the identity of objects that have thread storage duration. After calling registered functions, `quick_exit` calls `_Exit(status)`. The standard file buffers aren't flushed. The function `quick_exit` is signal-safe when the functions registered with `at_quick_exit` are.
 
 ### <a name="system"></a> system
 
@@ -149,11 +148,20 @@ int system(const char* string);
 ## Memory allocation functions
 
 ```cpp
-void* aligned_alloc(size_t alignment, size_t size);
+// void* aligned_alloc(size_t alignment, size_t size); // Unsupported in MSVC
 void* calloc(size_t nmemb, size_t size);
 void free(void* ptr);
 void* malloc(size_t size);
 void* realloc(void* ptr, size_t size);
+```
+
+### Remarks
+
+These functions have the semantics specified in the C standard library. MSVC doesn't support the `aligned_alloc` function. C11 specified `aligned_alloc()` in a way that's incompatible with the Microsoft implementation of `free()`, namely, that `free()` must be able to handle highly aligned allocations.
+
+## Numeric string conversions
+
+```cpp
 double atof(const char* nptr);
 int atoi(const char* nptr);
 long int atol(const char* nptr);
@@ -167,11 +175,11 @@ unsigned long int strtoul(const char* nptr, char** endptr, int base);
 unsigned long long int strtoull(const char* nptr, char** endptr, int base);
 ```
 
-#### Remarks
+### Remarks
 
 These functions have the semantics specified in the C standard library.
 
-##  Multibyte / wide string and character conversion functions
+## Multibyte / wide string and character conversion functions
 
 ```cpp
 int mblen(const char* s, size_t n);
@@ -220,6 +228,15 @@ double abs(double j);
 long double abs(long double j);
 long int labs(long int j);
 long long int llabs(long long int j);
+```
+
+### Remarks
+
+These functions have the semantics specified in the C standard library.
+
+## Integer division
+
+```cpp
 div_t div(int numer, int denom);
 ldiv_t div(long int numer, long int denom);
 lldiv_t div(long long int numer, long long int denom);
@@ -231,17 +248,6 @@ lldiv_t lldiv(long long int numer, long long int denom);
 
 These functions have the semantics specified in the C standard library.
 
-## Functions
-
-```cpp
-void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
-c-compare-pred * compar);
-void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
-compare-pred * compar);
-void qsort(void* base, size_t nmemb, size_t size, c-compare-pred * compar);
-void qsort(void* base, size_t nmemb, size_t size, compare-pred * compar);
-```
-
 ## See also
 
 [Header Files Reference](../standard-library/cpp-standard-library-header-files.md)\
