Merge pull request #5647 from MicrosoftDocs/FromPublicMasterBranch

Confirm merge from FromPublicMasterBranch to main to sync with https://github.com/MicrosoftDocs/cpp-docs (branch main)

Author: Albertyang0

docs/c-runtime-library/reference/mbbtype-mbbtype-l.md

@@ -50,9 +50,9 @@ The locale to use.
 |---|---|---|---|
 | Any value except 1 | Valid single byte or lead byte | `_MBC_SINGLE` (0) | Single byte (0x20 - 0x7E, 0xA1 - 0xDF) |
 | Any value except 1 | Valid single byte or lead byte | `_MBC_LEAD` (1) | Lead byte of multibyte character (0x81 - 0x9F, 0xE0 - 0xFC) |
-| Any value except 1 | Valid single-byte or lead byte | `_MBC_ILLEGAL`<br /><br /> (-1) | Invalid character (any value except 0x20 - 0x7E, 0xA1 - 0xDF, 0x81 - 0x9F, 0xE0 - 0xFC |
+| Any value except 1 | Valid single-byte or lead byte | `_MBC_ILLEGAL` (-1) | Invalid character: not single or lead (0x00 - 0x1F, 0x7F, 0x80, 0xA0, 0xFD, 0xFE, 0xFF) |
 | 1 | Valid trail byte | `_MBC_TRAIL` (2) | Trailing byte of multibyte character (0x40 - 0x7E, 0x80 - 0xFC) |
-| 1 | Valid trail byte | `_MBC_ILLEGAL`<br /><br /> (-1) | Invalid character (any value except 0x20 - 0x7E, 0xA1 - 0xDF, 0x81 - 0x9F, 0xE0 - 0xFC |
+| 1 | Valid trail byte | `_MBC_ILLEGAL` (-1) | Invalid character: not trailing (0x00 - 0x3F, 0x7F, 0xFD, 0xFE, 0xFF) |
 
 ## Remarks
 

docs/cpp/writing-an-exception-filter.md

@@ -16,33 +16,37 @@ For example, the following code uses a function call in the *filter* expression:
 ```cpp
 // exceptions_Writing_an_Exception_Filter.cpp
 #include <windows.h>
+int Eval_Exception(int);
 int main() {
-   int Eval_Exception( int );
-
-   __try {}
-
-   __except ( Eval_Exception( GetExceptionCode( ))) {
-      ;
-   }
-
+    __try {
+        ;
+    }
+    __except (Eval_Exception(GetExceptionCode())) {
+        ;
+    }
+}
+void HandleOverflow() {
+    // Gracefully recover
 }
-void ResetVars( int ) {}
-int Eval_Exception ( int n_except ) {
-   if ( n_except != STATUS_INTEGER_OVERFLOW &&
-      n_except != STATUS_FLOAT_OVERFLOW )   // Pass on most exceptions
-   return EXCEPTION_CONTINUE_SEARCH;
-
-   // Execute some code to clean up problem
-   ResetVars( 0 );   // initializes data to 0
-   return EXCEPTION_CONTINUE_EXECUTION;
+int Eval_Exception(int n_except) {
+    if (
+        n_except != STATUS_INTEGER_OVERFLOW &&
+        n_except != STATUS_FLOAT_OVERFLOW
+    ) {
+        // Pass on most exceptions
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
+    // Execute some code to clean up problem
+    HandleOverflow();
+    return EXCEPTION_CONTINUE_EXECUTION;
 }
 ```
 
 It's a good idea to use a function call in the *filter* expression whenever *filter* needs to do anything complex. Evaluating the expression causes execution of the function, in this case, `Eval_Exception`.
 
 Note the use of [`GetExceptionCode`](/windows/win32/Debug/getexceptioncode) to determine the exception. This function must be called inside the filter expression of the **`__except`** statement. `Eval_Exception` can't call `GetExceptionCode`, but it must have the exception code passed to it.
 
-This handler passes control to another handler unless the exception is an integer or floating-point overflow. If it is, the handler calls a function (`ResetVars` is only an example, not an API function) to reset some global variables. The **`__except`** statement block, which in this example is empty, can never be executed because `Eval_Exception` never returns `EXCEPTION_EXECUTE_HANDLER` (1).
+This handler passes control to another handler unless the exception is an integer or floating-point overflow. If it is, the handler calls a function (`HandleOverflow` is only an example, not an API function) to appropriately try to recover from the exception. The **`__except`** statement block, which in this example is empty, can never be executed because `Eval_Exception` never returns `EXCEPTION_EXECUTE_HANDLER` (1).
 
 Using a function call is a good general-purpose technique for dealing with complex filter expressions. Two other C language features that are useful are:
 
@@ -53,21 +57,21 @@ Using a function call is a good general-purpose technique for dealing with compl
 The conditional operator is frequently useful here. It can be used to check for a specific return code and then return one of two different values. For example, the filter in the following code recognizes the exception only if the exception is `STATUS_INTEGER_OVERFLOW`:
 
 ```cpp
-__except( GetExceptionCode() == STATUS_INTEGER_OVERFLOW ? 1 : 0 ) {
+__except (GetExceptionCode() == STATUS_INTEGER_OVERFLOW ? 1 : 0)
 ```
 
 The purpose of the conditional operator in this case is mainly to provide clarity, because the following code produces the same results:
 
 ```cpp
-__except( GetExceptionCode() == STATUS_INTEGER_OVERFLOW ) {
+__except (GetExceptionCode() == STATUS_INTEGER_OVERFLOW)
 ```
 
 The conditional operator is more useful in situations where you might want the filter to evaluate to -1, `EXCEPTION_CONTINUE_EXECUTION`.
 
 The comma operator lets you execute multiple expressions in sequence. It then returns the value of the last expression. For example, the following code stores the exception code in a variable and then tests it:
 
 ```cpp
-__except( nCode = GetExceptionCode(), nCode == STATUS_INTEGER_OVERFLOW )
+__except (nCode = GetExceptionCode(), nCode == STATUS_INTEGER_OVERFLOW)
 ```
 
 ## See also