Acrolinx fixes

Author: Colin Robertson

docs/build/customize-cmake-settings.md

@@ -125,7 +125,7 @@ usage: ninja [options] [targets...]
 |   -n       | dry run (don't run commands but act like they succeeded)|
 |   -v       | show all command lines while building|
 |   -d MODE  | enable debugging (use -d list to list modes)|
-|   -t TOOL  | run a subtool (use -t list to list subtools). terminates toplevel options; further flags are passed to the tool|
+|   -t TOOL  | run a subtool (use -t list to list subtools). terminates top-level options; further flags are passed to the tool|
 |   -w FLAG  | adjust warnings (use -w list to list warnings)|
 
 ## Inherited environments

docs/build/reference/file-types-created-for-visual-cpp-projects.md

@@ -37,7 +37,7 @@ The following table shows common files in a Visual Studio project, and identifie
 |.atp|Project|Application template project file.|
 |.bmp, .dib, .gif, .jpg, .jpe, .png|Resource|General image files.|
 |.bsc|Compiling|The browser code file.|
-|.cpp; .c|Source|Main source code files for your application.|
+|.cpp, .c|Source|Main source code files for your application.|
 |.cur|Resource|Cursor bitmap graphic file.|
 |.dbp|Project|Database project file.|
 |.disco|Source|The dynamic discovery document file. Handles XML Web service discovery.|

docs/cpp/constexpr-cpp.md

@@ -6,33 +6,31 @@ ms.assetid: c6458ccb-51c6-4a16-aa61-f69e6f4e04f7
 ---
 # constexpr (C++)
 
-The keyword **constexpr** was introduced in C++11 and improved in C++14. It means *constant expression*. Like **const**, it can be applied to variables so that a compiler error will be raised if any code attempts to modify the value. Unlike **const**, **constexpr** can also be applied to functions and class constructors. **constexpr** indicates that the value, or return value, is constant and, if possible, will be computed at compile time.
+The keyword **constexpr** was introduced in C++11 and improved in C++14. It means *constant expression*. Like **const**, it can be applied to variables so that a compiler error is raised if any code attempts to modify the value. Unlike **const**, **constexpr** can also be applied to functions and class constructors. **constexpr** indicates that the value, or return value, is constant and, if possible, is computed at compile time.
 
 A **constexpr** integral value can be used wherever a const integer is required, such as in template arguments and array declarations. And when a value can be computed at compile time instead of run time, it can help your program run faster and use less memory.
 
-To limit the complexity of computing compile time constants, and their potential impacts of compilation time, the C++14 standard requires that the types involved in constant expressions be restricted to [literal types](trivial-standard-layout-and-pod-types.md#literal_types).
+To limit the complexity of compile-time constant computations, and their potential impacts on compilation time, the C++14 standard requires the types in constant expressions to be [literal types](trivial-standard-layout-and-pod-types.md#literal_types).
 
 ## Syntax
 
-```
-constexpr  literal-type  identifier = constant-expression;
-constexpr  literal-type  identifier { constant-expression };
-constexpr literal-type identifier(params );
-constexpr ctor (params);
-```
+> **constexpr** *literal-type* *identifier* **=** *constant-expression* **;**
+> **constexpr** *literal-type* *identifier* **{** *constant-expression* **}** **;**
+> **constexpr** *literal-type* *identifier* **(** *params* **)** **;**
+> **constexpr** *ctor* **(** *params* **)** **;**
 
 ## Parameters
 
 *params*<br/>
-One or more parameters which must be a literal type and must itself be a constant expression.
+One or more parameters, each of which must be a literal type and must itself be a constant expression.
 
 ## Return Value
 
 A constexpr variable or function must return a [literal type](trivial-standard-layout-and-pod-types.md#literal_types).
 
 ## constexpr variables
 
-The primary difference between const and constexpr variables is that the initialization of a const variable can be deferred until run time whereas a constexpr variable must be initialized at compile time.  All constexpr variables are const.
+The primary difference between const and constexpr variables is that the initialization of a const variable can be deferred until run time. A constexpr variable must be initialized at compile time.  All constexpr variables are const.
 
 - A variable can be declared with **constexpr**, if it has a literal type and is initialized. If the initialization is performed by a constructor, the constructor must be declared as **constexpr**.
 
@@ -51,7 +49,7 @@ constexpr int k = j + 1; //Error! j not a constant expression
 
 ## <a name="constexpr_functions"></a> constexpr functions
 
-A **constexpr** function is one whose return value can be computed at compile when consuming code requires it.  When its arguments are **constexpr** values, and consuming code requires the return value at compile time, for example to initialize a **constexpr** variable or provide a non-type template argument, it produces a compile-time constant. When called with non-**constexpr** arguments, or when its value is not required at compile-time, it produces a value at run time like a regular function.  (This dual behavior saves you from having to write **constexpr** and non-**constexpr** versions of the same function.)
+A **constexpr** function is one whose return value can be computed at compile time when consuming code requires it. Consuming code requires the return value at compile time, for example, to initialize a **constexpr** variable or provide a non-type template argument. When its arguments are **constexpr** values, a **constexpr** function produces a compile-time constant. When called with non-**constexpr** arguments, or when its value isn't required at compile-time, it produces a value at run time like a regular function. (This dual behavior saves you from having to write **constexpr** and non-**constexpr** versions of the same function.)
 
 A **constexpr** function or constructor is implicitly **inline**.
 
@@ -61,7 +59,7 @@ The following rules apply to constexpr functions:
 
 - A **constexpr** function can be recursive.
 
-- It cannot be [virtual](../cpp/virtual-cpp.md). A a constructor cannot be defined as constexpr if the enclosing class has any virtual base classes.
+- It cannot be [virtual](../cpp/virtual-cpp.md). A constructor cannot be defined as constexpr if the enclosing class has any virtual base classes.
 
 - The body can be defined as `= default` or `= delete`.
 
@@ -75,7 +73,7 @@ The following rules apply to **constexpr** functions in Visual Studio 2017 and l
 
 - It may contain **if** and **switch** statements, and all looping statements including **for**, range-based for, **while**, and **do-while**.
 
-- It may contain local variable declarations, but the variable must be initialized, must be a literal type, and cannot be static or thread-local. The locally-declared variable is not required to be const and may mutate.
+- It may contain local variable declarations, but the variable must be initialized, must be a literal type, and cannot be static or thread-local. The locally declared variable isn't required to be const and may mutate.
 
 - A constexpr non-static member function is not required to be implicitly const.
 
@@ -89,15 +87,15 @@ constexpr float exp(float x, int n)
 ```
 
 > [!TIP]
-> Note: In the Visual Studio debugger, when debugging a non-optimised Debug build, you can tell whether a **constexpr** function is being evaluated at compile time by putting a breakpoint inside it. If the breakpoint is hit, the function was called at run-time.  If not, then the function was called at compile time.
+> In the Visual Studio debugger, when debugging a non-optimised Debug build, you can tell whether a **constexpr** function is being evaluated at compile time by putting a breakpoint inside it. If the breakpoint is hit, the function was called at run-time.  If not, then the function was called at compile time.
 
 ## extern constexpr
 
 The [/Zc:externConstexpr](../build/reference/zc-externconstexpr.md) compiler option causes the compiler to apply [external linkage](../c-language/external-linkage.md) to variables declared by using **extern constexpr**. In earlier versions of Visual Studio, and by default or if **/Zc:externConstexpr-** is specified, Visual Studio applies internal linkage to **constexpr** variables even if the **extern** keyword is used. The **/Zc:externConstexpr** option is available starting in Visual Studio 2017 Update 15.6. and is off by default. The /permissive- option does not enable /Zc:externConstexpr.
 
 ## Example
 
-The following example shows **constexpr** variables, functions and a user-defined type. Note that in the last statement in main(), the **constexpr** member function GetValue() is a run-time call because the value is not required to be known at compile time.
+The following example shows **constexpr** variables, functions, and a user-defined type. In the last statement in main(), the **constexpr** member function GetValue() is a run-time call because the value isn't required to be known at compile time.
 
 ```cpp
 #include <iostream>
@@ -120,7 +118,7 @@ constexpr float exp2(const float& x, const int& n)
         exp2(x * x, (n - 1) / 2) * x;
 };
 
-// Compile time computation of array length
+// Compile-time computation of array length
 template<typename T, int N>
 constexpr int length(const T(&ary)[N])
 {
@@ -148,19 +146,19 @@ private:
 
 int main()
 {
-    //foo is const:
+    // foo is const:
     constexpr Foo foo(5);
     // foo = Foo(6); //Error!
 
-    //Compile time:
+    // Compile time:
     constexpr float x = exp(5, 3);
     constexpr float y { exp(2, 5) };
     constexpr int val = foo.GetValue();
     constexpr int f5 = fac(5);
     const int nums[] { 1, 2, 3, 4 };
     const int nums2[length(nums) * 2] { 1, 2, 3, 4, 5, 6, 7, 8 };
 
-    //Run time:
+    // Run time:
     cout << "The value of foo is " << foo.GetValue() << endl;
 
 }

docs/cppcx/visual-c-language-reference-c-cx.md

@@ -26,7 +26,7 @@ By using C++/CX, you can create:
 |-|-|
 |[Quick Reference](../cppcx/quick-reference-c-cx.md)|Table of keywords and operators for C++/CX.|
 |[Type System](../cppcx/type-system-c-cx.md)|Describes basic C++/CX types and programming constructs, and how to utilize C++/CX to consume and create Windows Runtime types.|
-|[Building apps and libraries](../cppcx/building-apps-and-libraries-c-cx.md)|Discusses how to use the IDE to build apps and link to static libraries aned DLLs.|
+|[Building apps and libraries](../cppcx/building-apps-and-libraries-c-cx.md)|Discusses how to use the IDE to build apps and link to static libraries and DLLs.|
 |[Interoperating with Other Languages](../cppcx/interoperating-with-other-languages-c-cx.md)|Discusses how components that are written by using C++/CX can be used with components that are written in JavaScript, any managed language, or the Windows Runtime C++ Template Library.|
 |[Threading and Marshaling](../cppcx/threading-and-marshaling-c-cx.md)|Discusses how to specify the threading and marshaling behavior of components that you create.|
 |[Namespaces Reference](../cppcx/namespaces-reference-c-cx.md)|Reference documentation for the default namespace, the Platform namespace, Platform::Collections, and related namespaces.|

docs/data/oledb/irowsetchangeimpl-class.md

@@ -56,7 +56,7 @@ The storage unit for all row handles held by the provider.
 
 |||
 |-|-|
-|[FlushData](#flushdata)|Overidden by provider to commit data to its store.|
+|[FlushData](#flushdata)|Overridden by provider to commit data to its store.|
 
 ## Remarks
 
@@ -127,7 +127,7 @@ See [IRowsetChange::SetData](/previous-versions/windows/desktop/ms721232(v=vs.85
 
 ## <a name="flushdata"></a> IRowsetChangeImpl::FlushData
 
-Overidden by provider to commit data to its store.
+Overridden by provider to commit data to its store.
 
 ### Syntax
 

docs/mfc/reference/cdatabase-class.md

@@ -140,7 +140,7 @@ void Cancel();
 
 ### Remarks
 
-Note that the MFC ODBC classes no longer use asynchronous processing; to perform an asychronous operation, you must directly call the ODBC API function [SQLSetConnectOption](/sql/odbc/reference/syntax/sqlsetconnectoption-function). For more information, see [Asynchronous Execution](/sql/odbc/reference/develop-app/asynchronous-execution).
+Note that the MFC ODBC classes no longer use asynchronous processing; to perform an asynchronous operation, you must directly call the ODBC API function [SQLSetConnectOption](/sql/odbc/reference/syntax/sqlsetconnectoption-function). For more information, see [Asynchronous Execution](/sql/odbc/reference/develop-app/asynchronous-execution).
 
 ##  <a name="cantransact"></a>  CDatabase::CanTransact