Update configure-cmake-debugging-sessions.md

Fix at least a couple of things Acrolinx will hate.

@esweet431 The powers that be hate image files with capitalized extensions. Can you change the name and recommit cmake-targets-add-debug.PNG as cmake-targets-add-debug.png? Thanks!

Author: Colin Robertson

docs/build/configure-cmake-debugging-sessions.md

@@ -22,21 +22,21 @@ You can also start a debug session from Solution Explorer. First, switch to **CM
 
 ![CMake targets view button](media/cmake-targets-view.png  "CMake Targets View menu item")
 
-Then, right-click on any executable and select **Debug**. This automatically starts debugging the selected target based on your active configuration. 
+Then, right-click on an executable and select **Debug**. This command automatically starts debugging the selected target based on your active configuration. 
 
 ## Customize debugger settings
 
-You can customize the debugger settings for any executable CMake target in your project in a configuration file called *launch.vs.json* located in a *.vs* folder in your project root. For most debugging scenarios, creating a launch configuration file is beneficial because it allows you to configure and save debugging setup details. There are three entry points to this file:
+You can customize the debugger settings for any executable CMake target in your project in a configuration file called *launch.vs.json*, located in a *.vs* folder in your project root. A launch configuration file is useful in most debugging scenarios, because you can configure and save your debugging setup details. There are three entry points to this file:
 
 - **Debug Menu:** Select **Debug > Debug and Launch Settings for ${activeDebugTarget}** from the main menu to customize the debug configuration specific to your active debug target. If you don't have a debug target selected, this option will be grayed out.
 
 ![Debug menu entry point](media/cmake-debug-menu.png "Debug menu entry point")
 
 - **Targets View:** Navigate to **Targets View** in Solution Explorer. Then, right-click on a debug target and select **Add Debug Configuration** to customize the debug configuration specific to the selected target. 
 
-![Targets view entry point](media/cmake-targets-add-debug.PNG "Targets view entry point")
+![Targets view entry point](media/cmake-targets-add-debug.png "Targets view entry point")
 
-- **Root CMakeLists.txt:** Right-click on a root CMakeLists.txt and select **Add  Debug Configuration** to open the **Select a Debugger** dialog box. The dialog allows you to add *any* type of debug configuration, but you must manually specify the CMake target to invoke via the `projectTarget` property.
+- **Root CMakeLists.txt:** Right-click on a root *CMakeLists.txt* and select **Add Debug Configuration** to open the **Select a Debugger** dialog box. The dialog allows you to add *any* type of debug configuration, but you must manually specify the CMake target to invoke via the `projectTarget` property.
 
 ![Select a debugger dialog box](media/cmake-select-a-debugger.png "Select a debugger dialog box")
 
@@ -61,6 +61,7 @@ To reference any key in a *CMakeSettings.json* file, preface it with `cmake.` in
   ]
 }
 ```
+
 **Environment variables** defined in CMakeSettings.json can also be used in launch.vs.json using the syntax `${env.VARIABLE_NAME}`. In Visual Studio 2019 version 16.4 and later, debug targets are automatically launched with the environment you specify in CMakeSettings.json. You can unset an environment variable by setting it to **null**. 
 
 ## Launch.vs.json reference
@@ -71,12 +72,12 @@ There are many *launch.vs.json* properties to support all your debugging scenari
 
 - `env`: Additional environment variables to add with the syntax:
 
-```json
+  ```json
   "env": {
         "DEBUG_LOGGING_LEVEL": "trace;info",
         "ENABLE_TRACING": "true"
       }
-```
+  ```
 
 - `args`: Command-line arguments passed to the program to debug.
 
@@ -127,50 +128,66 @@ Use the following options to separate your build machine (defined in CMakeSettin
   - `executable`: Indicates whether the deployed file is an executable.
 
 ### Execute custom gdb commands
+
 Visual Studio supports executing custom gdb commands to interact directly with the underlying debugger. [Learn more](https://github.com/microsoft/MIEngine/wiki/Executing-custom-gdb-lldb-commands)
 
 ### Enable logging
+
 Enable MIEngine logging to see what commands get sent to gdb, what output gdb returns, and how long each command takes. [Learn more](https://github.com/microsoft/MIEngine/wiki/Logging)
 
 ### Configuration type `cppdbg`
 
 The following options can be used when debugging on a remote system or WSL using the `cppdbg` configuration type. In Visual Studio 2019 version 16.6 or later, configuration type `cppgdb` is recommended. 
 
 - `name`: A friendly name to identify the configuration in the **Startup Item** dropdown. 
+
 - `project`: Specifies the relative path to the project file. You shouldn't need to change this when debugging a CMake project. 
+
 - `projectTarget`: Specifies the CMake target to invoke when building the project. Visual Studio autopopulates this property if you enter *launch.vs.json* from the **Debug Menu** or **Targets View**. This value must match the name of an existing debug target listed in the **Startup Item** dropdown.
+
 - `args`: Command-line arguments passed on startup to the program being debugged.
+
 - `processID`: Linux process ID to attach to. Only used when attaching to a remote process. For more information, see [Troubleshoot attaching to processes using GDB](https://github.com/Microsoft/MIEngine/wiki/Troubleshoot-attaching-to-processes-using-GDB).
+
 - `program`: Defaults to `"${debugInfo.fullTargetPath}"`. The Unix path to the application to debug. Only required if different than the target executable in the build or deploy location.
+
 - `remoteMachineName`:  Defaults to `"${debugInfo.remoteMachineName}"`. Name of the remote system that hosts the program to debug. Only required if different than the build system. Must have an existing entry in the [Connection Manager](../linux/connect-to-your-remote-linux-computer.md). Press **Ctrl+Space** to view a list of all existing remote connections.
+
 - `cwd`: Defaults to `"${debugInfo.defaultWorkingDirectory}"`. Full Unix path to the directory on the remote system where `program` is run. The directory must exist.
+
 - `environment`: Additional environment variables passed to the program being debugged. For example,
-```json
-  "environment": [
-      {
-        "name": "ENV1",
-        "value": "envvalue1"
-      },
-      {
-        "name": "ENV2",
-        "value": "envvalue2"
-      }
-    ]
-```
-- `pipeArgs`: An array of command-line arguments passed to the pipe program to configure the connection. The pipe program is used to relay standard input/output between Visual Studio and gdb. Most of this array **does not need to be customized** when debugging CMake projects. The exception is the `${debuggerCommand}`. which launches gdb on the remote system and can be modified to:
-  - Export the value of the environment variable DISPLAY on your Linux system. In the following example, this value is `:1`.
+
   ```json
-  "pipeArgs": [
-      "/s",
-      "${debugInfo.remoteMachineId}",
-      "/p",
-      "${debugInfo.parentProcessId}",
-      "/c",
-      "export DISPLAY=:1;${debuggerCommand}",
-      "--tty=${debugInfo.tty}"
-    ],
+    "environment": [
+        {
+          "name": "ENV1",
+          "value": "envvalue1"
+        },
+        {
+          "name": "ENV2",
+          "value": "envvalue2"
+        }
+      ]
   ```
+  
+- `pipeArgs`: An array of command-line arguments passed to the pipe program to configure the connection. The pipe program is used to relay standard input/output between Visual Studio and gdb. Most of this array **does not need to be customized** when debugging CMake projects. The exception is the `${debuggerCommand}`. which launches gdb on the remote system and can be modified to:
+
+  - Export the value of the environment variable DISPLAY on your Linux system. In the following example, this value is `:1`.
+
+    ```json
+    "pipeArgs": [
+        "/s",
+        "${debugInfo.remoteMachineId}",
+        "/p",
+        "${debugInfo.parentProcessId}",
+        "/c",
+        "export DISPLAY=:1;${debuggerCommand}",
+        "--tty=${debugInfo.tty}"
+      ],
+    ```
+    
   - Run a script before the execution of gdb. Ensure execute permissions are set on your script.
+    
     ```json
     "pipeArgs": [
         "/s",
@@ -182,11 +199,17 @@ The following options can be used when debugging on a remote system or WSL using
         "--tty=${debugInfo.tty}"
       ],
     ```
+    
 - `stopOnEntry`: A boolean that specifies whether to break as soon as the process is launched. The default is false.
+
 - `visualizerFile`: A [.natvis file](/visualstudio/debugger/create-custom-views-of-native-objects) to use when debugging this process. This option is incompatible with gdb pretty printing. Also set `showDisplayString` when you set this property.
+
 - `showDisplayString`: A boolean that enables the display string when a `visualizerFile` is specified. Setting this option to `true` can cause slower performance during debugging.
+
 - `setupCommands`: One or more gdb command(s) to execute, to set up the underlying debugger.
+
 - `miDebuggerPath`: The full path to gdb. When unspecified, Visual Studio searches PATH first for the debugger.
+
 - Finally, all of the deployment options defined for the `cppgdb` configuration type can be used with the `cppdbg` configuration type as well.
 
 ::: moniker-end