more uniform wording

TylerMSFT · TylerMSFT · commit c67cfc80a978 · 2025-10-07T14:25:20.000-07:00
diff --git a/docs/c-runtime-library/reference/ctime-ctime32-ctime64-wctime-wctime32-wctime64.md b/docs/c-runtime-library/reference/ctime-ctime32-ctime64-wctime-wctime32-wctime64.md
@@ -62,8 +62,8 @@ These functions validate their parameters. If *`sourceTime`* is a null pointer,
 
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
-> [!Note]
-> Starting with Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are now declared as `inline` (external linkage).\
+>> [!Note]
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
 > To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
 > This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following functions: `ctime`, `_wctime`
diff --git a/docs/c-runtime-library/reference/ctime-s-ctime32-s-ctime64-s-wctime-s-wctime32-s-wctime64-s.md b/docs/c-runtime-library/reference/ctime-s-ctime32-s-ctime64-s-wctime-s-wctime32-s-wctime64-s.md
@@ -125,7 +125,7 @@ The debug library versions of these functions first fill the buffer with 0xFE. T
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting with Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are now declared as `inline` (external linkage).\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
 > To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
 > This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following functions: `ctime_s`, `_wctime_s`
diff --git a/docs/c-runtime-library/reference/difftime-difftime32-difftime64.md b/docs/c-runtime-library/reference/difftime-difftime32-difftime64.md
@@ -46,10 +46,9 @@ These functions validate their parameters. If either of the parameters is zero o
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> If you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `difftime`
 
 ## Requirements
diff --git a/docs/c-runtime-library/reference/futime-futime32-futime64.md b/docs/c-runtime-library/reference/futime-futime32-futime64.md
@@ -52,7 +52,7 @@ The **`_futime`** routine sets the modification date and the access time on the
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting with Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are now declared as `inline` (external linkage).\
+> If you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
 > To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
 > This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `_futime`
diff --git a/docs/c-runtime-library/reference/gmtime-gmtime32-gmtime64.md b/docs/c-runtime-library/reference/gmtime-gmtime32-gmtime64.md
@@ -57,10 +57,9 @@ The **`_gmtime32`** function breaks down the *`sourceTime`* value and stores it
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `gmtime`
 
 ## Requirements
diff --git a/docs/c-runtime-library/reference/gmtime-s-gmtime32-s-gmtime64-s.md b/docs/c-runtime-library/reference/gmtime-s-gmtime32-s-gmtime64-s.md
@@ -77,10 +77,9 @@ Each of the structure fields is of type **`int`**, as shown in the following tab
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `gmtime_s`
 
 ## Requirements
diff --git a/docs/c-runtime-library/reference/localtime-localtime32-localtime64.md b/docs/c-runtime-library/reference/localtime-localtime32-localtime64.md
@@ -73,10 +73,9 @@ These functions validate their parameters. If *`sourceTime`* is a null pointer,
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `localtime`
 
 ## Requirements
diff --git a/docs/c-runtime-library/reference/localtime-s-localtime32-s-localtime64-s.md b/docs/c-runtime-library/reference/localtime-s-localtime32-s-localtime64-s.md
@@ -85,10 +85,9 @@ If the **`TZ`** environment variable is set, the C run-time library assumes rule
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `localtime_s`
 
 ## Requirements
diff --git a/docs/c-runtime-library/reference/mkgmtime-mkgmtime32-mkgmtime64.md b/docs/c-runtime-library/reference/mkgmtime-mkgmtime32-mkgmtime64.md
@@ -49,11 +49,9 @@ The range of the **`_mkgmtime32`** function is from midnight, January 1, 1970, U
 Both **`gmtime`** and **`localtime`** use a common static buffer for the conversion. If you supply this buffer to **`_mkgmtime`**, the previous contents are destroyed.
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
-> This applies to the following function: `_mkgmtime`
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\> This applies to the following function: `_mkgmtime`
 
 ## Examples
 
diff --git a/docs/c-runtime-library/reference/mktime-mktime32-mktime64.md b/docs/c-runtime-library/reference/mktime-mktime32-mktime64.md
@@ -63,10 +63,9 @@ These functions validate their parameter. If *`timeptr`* is a null pointer, the
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `mktime`
 
 ## Requirements
diff --git a/docs/c-runtime-library/reference/strnlen-strnlen-s.md b/docs/c-runtime-library/reference/strnlen-strnlen-s.md
@@ -89,9 +89,9 @@ Each of these functions returns the number of characters in *`str`*, not includi
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting with Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are now declared as `inline` (external linkage).\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
 > To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
-> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\> This applies to the following functions: `strnlen_s`, `wcsnlen_s`
 > This applies to the following functions: `strnlen_s`, `wcsnlen_s`
 
 ### Generic-text routine mappings
diff --git a/docs/c-runtime-library/reference/time-time32-time64.md b/docs/c-runtime-library/reference/time-time32-time64.md
@@ -38,10 +38,9 @@ The **`time`** function returns the number of seconds elapsed since midnight (00
 **`time`** is a wrapper for **`_time64`** and **`time_t`** is, by default, equivalent to **`__time64_t`**. If you need to force the compiler to interpret **`time_t`** as the old 32-bit **`time_t`**, you can define `_USE_32BIT_TIME_T`. We don't recommend `_USE_32BIT_TIME_T`, because your application may fail after January 18, 2038; the use of this macro isn't allowed on 64-bit platforms.
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `time`
 
 ## Requirements
diff --git a/docs/c-runtime-library/reference/timespec-get-timespec32-get-timespec64-get1.md b/docs/c-runtime-library/reference/timespec-get-timespec32-get-timespec64-get1.md
@@ -56,10 +56,9 @@ These functions support only `TIME_UTC` as the *`base`* value. `TIME_UTC` sets t
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following function: `timespec_get`
 
 ## Requirements
diff --git a/docs/c-runtime-library/reference/utime-utime32-utime64-wutime-wutime32-wutime64.md b/docs/c-runtime-library/reference/utime-utime32-utime64-wutime-wutime32-wutime64.md
@@ -86,10 +86,9 @@ Specific versions of the `_utimbuf` structure (`__utimbuf32` and `__utimbuf64`)
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
 > [!Note]
-> Starting in Visual Studio 2025 and the Windows SDK 26000, this function changes from declaring the function (or functions for multi-function pages) with `static inline` to `inline`.\
-> You can opt-out of the change for your project by defining `_STATIC_INLINE_UCRT_FUNCTIONS=1`.\
-> You can adopt the change early by defining `_STATIC_INLINE_UCRT_FUNCTIONS=0`.\
-> This change improves conformance and helps avoid One Definition Rule (ODR) violations, especially when using modules.\
+> When you use Windows SDK version 10.0.xxxxx.xxxx and Visual Studio 2026 or later together, the following functions are no longer declared as `static inline` (internal linkage). Instead, they are declared as `inline` (external linkage).\
+> To return to the previous behavior, `#define _STATIC_INLINE_UCRT_FUNCTIONS=1` before including any CRT headers. By default, `_STATIC_INLINE_UCRT_FUNCTIONS` is set to 0.\
+> This change increases UCRT conformance with the C++ standard, while also improving compatibility with C++ modules.\
 > This applies to the following functions: `_utime`, `_wutime`
 
 ### Generic-text routine mappings
