Remove more HTML entities

3836425+corob-msft@users.noreply.github.com · 3836425+corob-msft@users.noreply.github.com · commit 233c954e1b2d · 2021-11-10T18:01:43.000-08:00
diff --git a/docs/c-language/c-operators.md b/docs/c-language/c-operators.md
@@ -16,7 +16,7 @@ C includes the following unary operators:
 |Symbol|Name|
 |------------|----------|
 |**-** **~** **!**|Negation and complement operators|
-|**&#42;** **&**|Indirection and address-of operators|
+|**`*`** **`&`**|Indirection and address-of operators|
 |**`sizeof`**|Size operator|
 |**+**|Unary plus operator|
 |**++** **--**|Unary increment and decrement operators|
@@ -25,7 +25,7 @@ Binary operators associate from left to right. C provides the following binary o
 
 |Symbol|Name|
 |------------|----------|
-|**&#42;** **/** **%**|Multiplicative operators|
+|**`*`** **`/`** **`%`**|Multiplicative operators|
 |**+** **-**|Additive operators|
 |**\<\<** **>>**|Shift operators|
 |**\<** **>** **\<=** **>=** **==** **!=**|Relational operators|
diff --git a/docs/c-language/indirection-and-address-of-operators.md b/docs/c-language/indirection-and-address-of-operators.md
@@ -7,7 +7,7 @@ ms.assetid: 10d62b00-12ba-4ea9-a2d5-09ac29ca2232
 ---
 # Indirection and Address-of Operators
 
-The unary indirection operator (__&#42;__) accesses a value indirectly, through a pointer. The operand must be a pointer type. The result of the operation is the value addressed by the operand; that is, the value at the address to which its operand points. The type of the result is the type that the operand addresses.
+The unary indirection operator (**`*`**) accesses a value indirectly, through a pointer. The operand must be a pointer type. The result of the operation is the value addressed by the operand; that is, the value at the address to which its operand points. The type of the result is the type that the operand addresses.
 
 The result of the indirection operator is *type* if the operand is of type *pointer to type*. If the operand points to a function, the result is a function designator. If it points to an object, the result is an lvalue that designates the object.
 
@@ -21,9 +21,9 @@ If the pointer value is not valid, the result of the indirection operator is und
 
 - The pointer specifies an address not used by the executing program.
 
-The unary address-of operator (**&**) gives the address of its operand. The operand must be either an lvalue that designates an object that is not declared __register__ and is not a bit-field, or the result of a unary __&#42;__ operator or an array dereference (__&#91;&#93;__) operator, or a function designator. The result is of type *pointer to type* for an operand of type *type*.
+The unary address-of operator (**&**) gives the address of its operand. The operand must be either an lvalue that designates an object that is not declared __register__ and is not a bit-field, or the result of a unary **`*`** operator or an array dereference (__&#91;&#93;__) operator, or a function designator. The result is of type *pointer to type* for an operand of type *type*.
 
-If the operand is the result of a unary __&#42;__ operator, neither operator is evaluated and the result is as if both were omitted. The result is not an lvalue, and the constraints on the operators still apply. If the operand is the result of a __&#91;&#93;__ operator, neither the __&__ operator nor the unary __&#42;__ implied by the __&#91;&#93;__ operator is evaluated. The result has the same effect as removing the __&__ operator and changing the __&#91;&#93;__ operator to a __+__ operator. Otherwise, the result is a pointer to the object or function designated by the operand.
+If the operand is the result of a unary **`*`** operator, neither operator is evaluated and the result is as if both were omitted. The result is not an lvalue, and the constraints on the operators still apply. If the operand is the result of a __&#91;&#93;__ operator, neither the __&__ operator nor the unary **`*`** implied by the __&#91;&#93;__ operator is evaluated. The result has the same effect as removing the __&__ operator and changing the __&#91;&#93;__ operator to a __+__ operator. Otherwise, the result is a pointer to the object or function designated by the operand.
 
 ## Examples
 
@@ -41,7 +41,7 @@ This statement uses the address-of operator (**&**) to take the address of the s
 pa = &a[5];
 ```
 
-The indirection operator (__&#42;__) is used in this example to access the **`int`** value at the address stored in `pa`. The value is assigned to the integer variable `x`:
+The indirection operator (**`*`**) is used in this example to access the **`int`** value at the address stored in `pa`. The value is assigned to the integer variable `x`:
 
 ```C
 x = *pa;
@@ -67,5 +67,5 @@ Once the function `roundup` is declared, two pointers to `roundup` are declared
 
 ## See also
 
-[Indirection Operator: &#42;](../cpp/indirection-operator-star.md)<br/>
+[Indirection Operator: `*`](../cpp/indirection-operator-star.md)<br/>
 [Address-of Operator: &](../cpp/address-of-operator-amp.md)
diff --git a/docs/c-runtime-library/reference/fdopen-wfdopen.md b/docs/c-runtime-library/reference/fdopen-wfdopen.md
@@ -45,7 +45,7 @@ For more information about these and other error codes, see [_doserrno, errno, _
 
 The **_fdopen** function associates an I/O stream with the file that is identified by *fd*, and thus allows a file that is opened for low-level I/O to be buffered and formatted. **_wfdopen** is a wide-character version of **_fdopen**; the *mode* argument to **_wfdopen** is a wide-character string. **_wfdopen** and **_fdopen** otherwise behave identically.
 
-File descriptors passed into **_fdopen** are owned by the returned **FILE &#42;** stream. If **_fdopen** is successful, do not call [\_close](close.md) on the file descriptor. Calling [fclose](fclose-fcloseall.md) on the returned **FILE &#42;** also closes the file descriptor.
+File descriptors passed into **_fdopen** are owned by the returned `FILE *` stream. If **_fdopen** is successful, do not call [\_close](close.md) on the file descriptor. Calling [fclose](fclose-fcloseall.md) on the returned `FILE *` also closes the file descriptor.
 
 By default, this function's global state is scoped to the application. To change this, see [Global state in the CRT](../global-state.md).
 
diff --git a/docs/c-runtime-library/reference/mbsrtowcs-s.md b/docs/c-runtime-library/reference/mbsrtowcs-s.md
@@ -82,13 +82,13 @@ The destination string *wcstr* is always null-terminated, even in the case of an
 
 If *count* is the special value [_TRUNCATE](../../c-runtime-library/truncate.md), **mbsrtowcs_s** converts as much of the string as will fit into the destination buffer, while still leaving room for a null terminator.
 
-If **mbsrtowcs_s** successfully converts the source string, it puts the size in wide characters of the converted string and the null terminator into *&#42;pReturnValue*, provided *pReturnValue* is not a null pointer. This occurs even if the *wcstr* argument is a null pointer and lets you determine the required buffer size. Note that if *wcstr* is a null pointer, *count* is ignored.
+If **mbsrtowcs_s** successfully converts the source string, it puts the size in wide characters of the converted string and the null terminator into `*pReturnValue`, provided *pReturnValue* is not a null pointer. This occurs even if the *wcstr* argument is a null pointer and lets you determine the required buffer size. Note that if *wcstr* is a null pointer, *count* is ignored.
 
 If *wcstr* is not a null pointer, the pointer object pointed to by *mbstr* is assigned a null pointer if conversion stopped because a terminating null character was reached. Otherwise, it is assigned the address just past the last multibyte character converted, if any. This allows a subsequent function call to restart conversion where this call stopped.
 
 If *mbstate* is a null pointer, the library internal **mbstate_t** conversion state static object is used. Because this internal static object is not thread-safe, we recommend that you pass your own *mbstate* value.
 
-If **mbsrtowcs_s** encounters a multibyte character that is not valid in the current locale, it puts -1 in *&#42;pReturnValue*, sets the destination buffer *wcstr* to an empty string, sets **errno** to **EILSEQ**, and returns **EILSEQ**.
+If **mbsrtowcs_s** encounters a multibyte character that is not valid in the current locale, it puts -1 in `*pReturnValue`, sets the destination buffer *wcstr* to an empty string, sets **errno** to **EILSEQ**, and returns **EILSEQ**.
 
 If the sequences pointed to by *mbstr* and *wcstr* overlap, the behavior of **mbsrtowcs_s** is undefined. **mbsrtowcs_s** is affected by the LC_TYPE category of the current locale.
 
diff --git a/docs/c-runtime-library/reference/mbstowcs-s-mbstowcs-s-l.md b/docs/c-runtime-library/reference/mbstowcs-s-mbstowcs-s-l.md
@@ -96,9 +96,9 @@ The destination string is always null-terminated (even in the case of an error).
 
 If *`count`* is the special value [`_TRUNCATE`](../../c-runtime-library/truncate.md), then **`mbstowcs_s`** converts as much of the string as will fit into the destination buffer, while still leaving room for a null terminator.
 
-If **`mbstowcs_s`** successfully converts the source string, it puts the size in wide characters of the converted string, including the null terminator, into *&#42;pReturnValue* (provided *`pReturnValue`* is not **`NULL`**). This occurs even if the *`wcstr`* argument is **`NULL`** and provides a way to determine the required buffer size. Note that if *`wcstr`* is **`NULL`**, *count* is ignored, and *`sizeInWords`* must be 0.
+If **`mbstowcs_s`** successfully converts the source string, it puts the size in wide characters of the converted string, including the null terminator, into `*pReturnValue` (provided *`pReturnValue`* is not **`NULL`**). This occurs even if the *`wcstr`* argument is **`NULL`** and provides a way to determine the required buffer size. Note that if *`wcstr`* is **`NULL`**, *count* is ignored, and *`sizeInWords`* must be 0.
 
-If **`mbstowcs_s`** encounters an invalid multibyte character, it puts 0 in *&#42;pReturnValue*, sets the destination buffer to an empty string, sets **`errno`** to **`EILSEQ`**, and returns **`EILSEQ`**.
+If **`mbstowcs_s`** encounters an invalid multibyte character, it puts 0 in `*pReturnValue`, sets the destination buffer to an empty string, sets **`errno`** to **`EILSEQ`**, and returns **`EILSEQ`**.
 
 If the sequences pointed to by *`mbstr`* and *`wcstr`* overlap, the behavior of **`mbstowcs_s`** is undefined.
 
diff --git a/docs/c-runtime-library/using-tchar-h-data-types-with-mbcs.md b/docs/c-runtime-library/using-tchar-h-data-types-with-mbcs.md
@@ -12,9 +12,9 @@ ms.assetid: 48f471e7-9d2b-4a39-b841-16a0e15c0a18
 
 As the table of generic-text routine mappings indicates (see [Generic-Text Mappings](../c-runtime-library/generic-text-mappings.md)), when the manifest constant **_MBCS** is defined, a given generic-text routine maps to one of the following kinds of routines:
 
-- An SBCS routine that handles multibyte bytes, characters, and strings appropriately. In this case, the string arguments are expected to be of type **char&#42;**. For example, **_tprintf** maps to **printf**; the string arguments to **printf** are of type **char&#42;**. If you use the **_TCHAR** generic-text data type for your string types, the formal and actual parameter types for **printf** match because **_TCHAR&#42;** maps to **char&#42;**.
+- An SBCS routine that handles multibyte bytes, characters, and strings appropriately. In this case, the string arguments are expected to be of type `char*`. For example, **_tprintf** maps to **printf**; the string arguments to **printf** are of type `char*`. If you use the **_TCHAR** generic-text data type for your string types, the formal and actual parameter types for **printf** match because `_TCHAR*` maps to `char*`.
 
-- An MBCS-specific routine. In this case, the string arguments are expected to be of type __unsigned char&#42;__. For example, **_tcsrev** maps to **_mbsrev**, which expects and returns a string of type __unsigned char&#42;__. Again, if you use the **_TCHAR** generic-text data type for your string types, there's a potential type conflict because **_TCHAR** maps to type **`char`**.
+- An MBCS-specific routine. In this case, the string arguments are expected to be of type `unsigned char*`. For example, **_tcsrev** maps to **_mbsrev**, which expects and returns a string of type `unsigned char*`. Again, if you use the **_TCHAR** generic-text data type for your string types, there's a potential type conflict because **_TCHAR** maps to type **`char`**.
 
 Following are three solutions for preventing this type conflict (and the C compiler warnings or C++ compiler errors that would result):
 
@@ -24,7 +24,7 @@ Following are three solutions for preventing this type conflict (and the C compi
    char *_tcsrev(char *);
    ```
 
-   In the default case, the prototype for **_tcsrev** maps to **_mbsrev** through a thunk in LIBC.LIB. This changes the types of the **_mbsrev** incoming parameters and outgoing return value from **_TCHAR &#42;** (such as **char &#42;**) to **unsigned char &#42;**. This method ensures type matching when you're using **_TCHAR**, but it's relatively slow because of the function call overhead.
+   In the default case, the prototype for **_tcsrev** maps to **_mbsrev** through a thunk in LIBC.LIB. This changes the types of the **_mbsrev** incoming parameters and outgoing return value from `_TCHAR*` (such as `char*`) to `unsigned char*`. This method ensures type matching when you're using **_TCHAR**, but it's relatively slow because of the function call overhead.
 
 - Use function inlining by incorporating the following preprocessor statement in your code.
 
diff --git a/docs/extensions/consuming-generics-cpp-cli.md b/docs/extensions/consuming-generics-cpp-cli.md
@@ -10,7 +10,7 @@ ms.assetid: e6330ef5-e907-432e-b527-7a22f5899639
 
 Generics authored in one .NET (or UWP) language may be used in other languages. Unlike templates, a generic in a compiled assembly still remains generic. Thus, one may instantiate the generic type in a different assembly and even in a different language than the assembly in which the generic type was defined.
 
-## Example: Generic class defined in C&#35;
+## Example: Generic class defined in C\#
 
 This example shows a generic class defined in C#.
 
@@ -70,7 +70,7 @@ public class CircularList<ItemType> {
 }
 ```
 
-## Example: Consume assembly authored in C&#35;
+## Example: Consume assembly authored in C\#
 
 This example consumes the assembly authored in C#.
 
diff --git a/docs/mfc/managing-the-state-data-of-mfc-modules.md b/docs/mfc/managing-the-state-data-of-mfc-modules.md
@@ -14,7 +14,7 @@ This article discusses the state data of MFC modules and how this state is updat
 
 As shown in the following figure, MFC has state data for each module used in an application. Examples of this data include Windows instance handles (used for loading resources), pointers to the current `CWinApp` and `CWinThread` objects of an application, OLE module reference counts, and a variety of maps that maintain the connections between Windows object handles and corresponding instances of MFC objects. However, when an application uses multiple modules, the state data of each module is not application wide. Rather, each module has its own private copy of the MFC's state data.
 
-![State data of a single module &#40;application&#41;.](../mfc/media/vc387n1.gif "State data of a single module &#40;application&#41;") <br/>
+![Diagram showing the state data of a single module.](../mfc/media/vc387n1.gif) <br/>
 State Data of a Single Module (Application)
 
 A module's state data is contained in a structure and is always available via a pointer to that structure. When the flow of execution enters a particular module, as shown in the following figure, that module's state must be the "current" or "effective" state. Therefore, each thread object has a pointer to the effective state structure of that application. Keeping this pointer updated at all times is vital to managing the application's global state and maintaining the integrity of each module's state. Incorrect management of the global state can lead to unpredictable application behavior.
diff --git a/docs/mfc/reference/cwnd-class.md b/docs/mfc/reference/cwnd-class.md
@@ -4863,10 +4863,10 @@ The following shows the various system icons that can be used in a message box:
 
 |Icon|Macro|
 |-|-|
-|![Stop &#40;x&#41; icon.](../../mfc/reference/media/vc364f1.gif "Stop &#40;x&#41; icon")|`MB_ICONHAND`, `MB_ICONSTOP`, and `MB_ICONERROR`|
-|![Help &#40;?&#41; icon.](../../mfc/reference/media/vc364f2.gif "Help &#40;?&#41; icon")|MB_ICONQUESTION|
-|![Important &#40;&#33;&#41; icon.](../../mfc/reference/media/vc364f3.gif "Important &#40;&#33;&#41; icon")|MB_ICONEXCLAMATION and MB_ICONWARNING|
-|![Information &#40;i&#41; icon.](../../mfc/reference/media/vc364f4.gif "Information &#40;i&#41; icon")|MB_ICONASTERISK and MB_ICONINFORMATION|
+|![Stop or X icon.](../../mfc/reference/media/vc364f1.gif)|`MB_ICONHAND`, `MB_ICONSTOP`, and `MB_ICONERROR`|
+|![Help or question mark icon.](../../mfc/reference/media/vc364f2.gif)|MB_ICONQUESTION|
+|![Important or exclamation point icon.](../../mfc/reference/media/vc364f3.gif)|MB_ICONEXCLAMATION and MB_ICONWARNING|
+|![Information or letter I icon.](../../mfc/reference/media/vc364f4.gif)|MB_ICONASTERISK and MB_ICONINFORMATION|
 
 ### Example
 
