Fix some stray formatting issues.

Author: Colin Robertson

docs/c-runtime-library/reference/atol-atol-l-wtol-wtol-l.md

@@ -50,7 +50,7 @@ Locale to use.
 
 Each function returns the **long** value produced by interpreting the input characters as a number. The return value is 0L for **atol** if the input cannot be converted to a value of that type.
 
-In the case of overflow with large positive integral values, **atol** returns **LONG_MAX**; in the case of overflow with large negative integral values, **LONG_MIN** is returned. In all out-of-range cases, **errno** is set to **ERANGE**. If the parameter passed in is null, the invalid parameter handler is invoked, as described in [Parameter Validation](../../c-runtime-library/parameter-validation.md). If execution is allowed to continue, these functions set **errno** to **EINVAL** and return 0.
+In the case of overflow with large positive integral values, **atol** returns **LONG_MAX**; in the case of overflow with large negative integral values, **LONG_MIN** is returned. In all out-of-range cases, **errno** is set to **ERANGE**. If the parameter passed in is **NULL**, the invalid parameter handler is invoked, as described in [Parameter Validation](../../c-runtime-library/parameter-validation.md). If execution is allowed to continue, these functions set **errno** to **EINVAL** and return 0.
 
 ## Remarks
 

docs/c-runtime-library/security-features-in-the-crt.md

@@ -42,7 +42,7 @@ strcpy(szBuf, "test"); // warning: deprecated
 
 -   `Parameter Validation`. Parameters passed to CRT functions are validated, in both secure functions and in many preexisting versions of functions. These validations include:  
 
-    -   Checking for `**NULL** values passed to the functions.  
+    -   Checking for **NULL** values passed to the functions.  
 
     -   Checking enumerated values for validity.  
 
@@ -54,7 +54,7 @@ strcpy(szBuf, "test"); // warning: deprecated
 
 -   `Sized Buffers`. The secure functions require that the buffer size be passed to any function that writes to a buffer. The secure versions validate that the buffer is large enough before writing to it, helping to avoid dangerous buffer overrun errors that could allow malicious code to execute. These functions usually return an `errno` type of error code and invoke the invalid parameter handler if the size of the buffer is too small. Functions that read from input buffers, such as `gets`, have secure versions that require you to specify a maximum size.  
 
--   `Null termination`. Some functions that left potentially non-terminated strings have secure versions which ensure that strings are properly null terminated.  
+-   `Null termination`. Some functions that left potentially non-terminated strings have secure versions which ensure that strings are properly null-terminated.  
 
 -   `Enhanced error reporting`. The secure functions return error codes with more error information than was available with the preexisting functions. The secure functions and many of the preexisting functions now set `errno` and often return an `errno` code type as well, to provide better error reporting.  
 

docs/c-runtime-library/spawn-wspawn-functions.md

@@ -90,7 +90,7 @@ Each of the `_spawn` functions creates and executes a new process:
   
  You can pass argument pointers as separate arguments (in `_spawnl`, `_spawnle`, `_spawnlp`, and `_spawnlpe`) or as an array of pointers (in `_spawnv`, `_spawnve`, `_spawnvp`, and `_spawnvpe`). You must pass at least one argument, `arg0` or `argv`[0], to the spawned process. By convention, this argument is the name of the program as you would type it on the command line. A different value does not produce an error.  
 
- The `_spawnl`, `_spawnle`, `_spawnlp`, and `_spawnlpe` calls are typically used in cases where the number of arguments is known in advance. The `arg0` argument is usually a pointer to `cmdname`. The arguments `arg1` through `argn` are pointers to the character strings forming the new argument list. Following `argn`, there must be a `**NULL** pointer to mark the end of the argument list.  
+ The `_spawnl`, `_spawnle`, `_spawnlp`, and `_spawnlpe` calls are typically used in cases where the number of arguments is known in advance. The `arg0` argument is usually a pointer to `cmdname`. The arguments `arg1` through `argn` are pointers to the character strings forming the new argument list. Following `argn`, there must be a **NULL** pointer to mark the end of the argument list.  
 
  The `_spawnv`, `_spawnve`, `_spawnvp`, and `_spawnvpe` calls are useful when there is a variable number of arguments to the new process. Pointers to the arguments are passed as an array, `argv`*.* The argument `argv`[0] is usually a pointer to a path in real mode or to the program name in protected mode, and `argv`[1] through `argv`[`n`] are pointers to the character strings forming the new argument list. The argument `argv`[`n` +1] must be a **NULL** pointer to mark the end of the argument list.