package.nls.json

{
    "c_cpp.debuggers.pipeTransport.description": "When present, this tells the debugger to connect to a remote computer using another executable as a pipe that will relay standard input/output between VS Code and the MI-enabled debugger backend executable (such as gdb).",
    "c_cpp.debuggers.pipeTransport.default.pipeProgram": "enter the fully qualified path for the pipe program name, for example '/usr/bin/ssh'.",
    "c_cpp.debuggers.pipeTransport.default.debuggerPath": "The full path to the debugger on the target machine, for example /usr/bin/gdb.",
    "c_cpp.debuggers.pipeTransport.debuggerPath.description": "The full path to the debugger on the target machine, for example /usr/bin/gdb.",
    "c_cpp.debuggers.pipeTransport.pipeCwd.description": "The fully qualified path to the working directory for the pipe program.",
    "c_cpp.debuggers.pipeTransport.pipeProgram.description": "The fully qualified pipe command to execute.",
    "c_cpp.debuggers.pipeTransport.pipeArgs.description": "Command line arguments passed to the pipe program to configure the connection.",
    "c_cpp.debuggers.pipeTransport.pipeEnv.description": "Environment variables passed to the pipe program.",
    "c_cpp.debuggers.pipeTransport.quoteArgs.description": "If the pipeProgram's individual arguments contain characters (such as spaces or tabs), should it be quoted? If 'false', the debugger command will no longer be automatically quoted. Default is 'true'.",
    "c_cpp.debuggers.logging.description": "Optional flags to determine what types of messages should be logged to the Debug Console.",
    "c_cpp.debuggers.logging.exceptions.description": "Optional flag to determine whether exception messages should be logged to the Debug Console. Defaults to true.",
    "c_cpp.debuggers.logging.moduleLoad.description": "Optional flag to determine whether module load events should be logged to the Debug Console. Defaults to true.",
    "c_cpp.debuggers.logging.programOutput.description": "Optional flag to determine whether program output should be logged to the Debug Console. Defaults to true.",
    "c_cpp.debuggers.logging.engineLogging.description": "Optional flag to determine whether diagnostic debug engine messages should be logged to the Debug Console. Defaults to false.",
    "c_cpp.debuggers.logging.trace.description": "Optional flag to determine whether diagnostic adapter command tracing should be logged to the Debug Console. Defaults to false.",
    "c_cpp.debuggers.logging.traceResponse.description": "Optional flag to determine whether diagnostic adapter command and response tracing should be logged to the Debug Console. Defaults to false.",
    "c_cpp.debuggers.cppvsdbg.logging.threadExit.description": "Optional flag to determine whether thread exit messages should be logged to the Debug Console. Default: false.",
    "c_cpp.debuggers.cppvsdbg.logging.processExit.description": "Optional flag to determine whether target process exit messages should be logged to the Debug Console. Default: true.",
    "c_cpp.debuggers.text.description": "The debugger command to execute.",
    "c_cpp.debuggers.description.description": "Optional description for the command.",
    "c_cpp.debuggers.ignoreFailures.description": "If true, failures from the command should be ignored. Default value is false.",
    "c_cpp.debuggers.program.description": "Full path to program executable.",
    "c_cpp.debuggers.args.description": "Command line arguments passed to the program.",
    "c_cpp.debuggers.cppdbg.type.description": "The type of the engine. Must be \"cppdbg\".",
    "c_cpp.debuggers.cppvsdbg.type.description": "The type of the engine. Must be \"cppvsdbg\".",
    "c_cpp.debuggers.targetArchitecture.description": "The architecture of the debuggee. This will automatically be detected unless this parameter is set. Allowed values are x86, arm, arm64, mips, x64, amd64, x86_64.",
    "c_cpp.debuggers.cwd.description": "The working directory of the target.",
    "c_cpp.debuggers.setupCommands.description": "One or more GDB/LLDB commands to execute in order to setup the underlying debugger. Example: \"setupCommands\": [ { \"text\": \"-enable-pretty-printing\", \"description\": \"Enable GDB pretty printing\", \"ignoreFailures\": true }].",
    "c_cpp.debuggers.postRemoteConnectCommands.description": "One or more commands that execute after remote connection to a debug server.",
    "c_cpp.debuggers.customLaunchSetupCommands.description": "If provided, this replaces the default commands used to launch a target with some other commands. For example, this can be \"-target-attach\" in order to attach to a target process. An empty command list replaces the launch commands with nothing, which can be useful if the debugger is being provided launch options as command line options. Example: \"customLaunchSetupCommands\": [ { \"text\": \"target-run\", \"description\": \"run target\", \"ignoreFailures\": false }].",
    "c_cpp.debuggers.launchCompleteCommand.description": "The command to execute after the debugger is fully setup in order to cause the target process to run. Allowed values are \"exec-run\", \"exec-continue\", \"None\". The default value is \"exec-run\".",
    "c_cpp.debuggers.cppdbg.visualizerFile.description": ".natvis file to be used when debugging this process. This option is not compatible with GDB pretty printing. Please also see \"showDisplayString\" if using this setting.",
    "c_cpp.debuggers.cppdbg.svdPath.description": "The full path to an embedded device's SVD file.",
    "c_cpp.debuggers.cppvsdbg.visualizerFile.description": ".natvis file to be used when debugging this process.",
    "c_cpp.debuggers.showDisplayString.description": "When a visualizerFile is specified, showDisplayString will enable the display string. Turning this option on can cause slower performance during debugging.",
    "c_cpp.debuggers.environment.description": "Environment variables to add to the environment for the program. Example: [ { \"name\": \"config\", \"value\": \"Debug\" } ], not [ { \"config\": \"Debug\" } ].",
    "c_cpp.debuggers.envFile.description": "Absolute path to a file containing environment variable definitions. This file has key value pairs separated by an equals sign per line. E.g. KEY=VALUE.",
    "c_cpp.debuggers.additionalSOLibSearchPath.description": "Semicolon separated list of directories to use to search for .so files. Example: \"c:\\dir1;c:\\dir2\".",
    "c_cpp.debuggers.MIMode.description": "Indicates the console debugger that the MIDebugEngine will connect to. Allowed values are \"gdb\" \"lldb\".",
    "c_cpp.debuggers.miDebuggerPath.description": "The path to the MI debugger (such as gdb). When unspecified, it will search path first for the debugger.",
    "c_cpp.debuggers.miDebuggerArgs.description": "Additional arguments for the MI debugger (such as gdb).",
    "c_cpp.debuggers.miDebuggerServerAddress.description": "Network address of the MI Debugger Server to connect to (example: localhost:1234).",
    "c_cpp.debuggers.useExtendedRemote.description": "Connect to the MI Debugger Server with target extended-remote mode.",
    "c_cpp.debuggers.stopAtEntry.description": "Optional parameter. If true, the debugger should stop at the entrypoint of the target. If processId is passed, has no effect.",
    "c_cpp.debuggers.debugServerPath.description": "Optional full path to the debug server to launch. Defaults to null. It is used in conjunction with either \"miDebugServerAddress\" or your own server with a \"customSetupCommand\" that runs \"-target-select remote <server:port>\".",
    "c_cpp.debuggers.debugServerArgs.description": "Optional debug server args. Defaults to null.",
    "c_cpp.debuggers.serverStarted.description": "Optional server-started pattern to look for in the debug server output. Defaults to null.",
    "c_cpp.debuggers.filterStdout.description": "Search stdout stream for server-started pattern and log stdout to debug output. Defaults to true.",
    "c_cpp.debuggers.filterStderr.description": "Search stderr stream for server-started pattern and log stderr to debug output. Defaults to false.",
    "c_cpp.debuggers.serverLaunchTimeout.description": "Optional time, in milliseconds, for the debugger to wait for the debugServer to start up. Default is 10000.",
    "c_cpp.debuggers.coreDumpPath.description": "Optional full path to a core dump file for the specified program. Defaults to null.",
    "c_cpp.debuggers.cppdbg.externalConsole.description": "If true, a console is launched for the debuggee. If false, on Linux and Windows, it will appear in the Integrated Console.",
    "c_cpp.debuggers.cppvsdbg.externalConsole.description": "[Deprecated by 'console'] If true, a console is launched for the debuggee. If false, no console is launched.",
    "c_cpp.debuggers.cppvsdbg.console.description": "Where to launch the debug target. Defaults to 'internalConsole' if not defined.",
    "c_cpp.debuggers.cppvsdbg.console.internalConsole.description": "Output to the VS Code Debug Console. This doesn't support reading console input (ex:'std::cin' or 'scanf').",
    "c_cpp.debuggers.cppvsdbg.console.integratedTerminal.description": "VS Code's integrated terminal.",
    "c_cpp.debuggers.cppvsdbg.console.externalTerminal.description": "Console applications will be launched in an external terminal window. The window will be reused in relaunch scenarios and will not automatically disappear when the application exits.",
    "c_cpp.debuggers.cppvsdbg.console.newExternalWindow.description": "Console applications will be launched in their own external console window which will end when the application stops. Non-console applications will run without a terminal, and stdout/stderr will be ignored.",
    "c_cpp.debuggers.avoidWindowsConsoleRedirection.description": "If true, disables debuggee console redirection that is required for Integrated Terminal support.",
    "c_cpp.debuggers.sourceFileMap.description": "Optional source file mappings passed to the debug engine. Example: '{ \"/original/source/path\":\"/current/source/path\" }'.",
    "c_cpp.debuggers.processId.anyOf.description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
    "c_cpp.debuggers.symbolSearchPath.description": "Semicolon separated list of directories to use to search for symbol (that is, pdb) files. Example: \"c:\\dir1;c:\\dir2\".",
    "c_cpp.debuggers.dumpPath.description": "Optional full path to a dump file for the specified program. Example: \"c:\\temp\\app.dmp\". Defaults to null.",
    "c_cpp.debuggers.enableDebugHeap.description": "If false, the process will be launched with debug heap disabled. This sets the environment variable '_NO_DEBUG_HEAP' to '1'.",
    "c_cpp.debuggers.symbolLoadInfo.description": "Explicit control of symbol loading.",
    "c_cpp.debuggers.symbolLoadInfo.loadAll.description": "If true, symbols for all libs will be loaded, otherwise no solib symbols will be loaded. Default value is true.",
    "c_cpp.debuggers.symbolLoadInfo.exceptionList.description": "List of filenames (wildcards allowed) separated by semicolons ';'. Modifies behavior of LoadAll. If LoadAll is true then don't load symbols for libs that match any name in the list. Otherwise only load symbols for libs that match. Example: \"foo.so;bar.so\".",
    "c_cpp.debuggers.requireExactSource.description": "Optional flag to require current source code to match the pdb.",
    "c_cpp.debuggers.stopAtConnect.description": "If true, the debugger should stop after connecting to the target. If false, the debugger will continue after connecting. Defaults to false.",
    "c_cpp.debuggers.hardwareBreakpoints.description": "Explicit control of hardware breakpoint behavior for remote targets.",
    "c_cpp.debuggers.hardwareBreakpoints.require.description": "If true, always use hardware breakpoints. Defaults to false.",
    "c_cpp.debuggers.hardwareBreakpoints.limit.description": "Optional limit on the number of available hardware breakpoints to use. Only enforced when \"require\" is true and \"limit\" is greater than 0. Defaults to 0.",
    "c_cpp.debuggers.variables.description": "Variables for recursive substitution in this launch configuration. Each variable may refer to others.",
    "c_cpp.debuggers.variables.properties.description": "Variable for recursive substitution in this launch configuration. The value may refer to other variables.",
    "c_cpp.debuggers.host.description": "Host information.",
    "c_cpp.debuggers.host.user.description": "User logging into the host.",
    "c_cpp.debuggers.host.hostName.description": "Host name.",
    "c_cpp.debuggers.host.port.description": "SSH port on the host. Default is 22.",
    "c_cpp.debuggers.host.jumpHost.description": "Connect to the target host by first making a connection to the jump hosts.",
    "c_cpp.debuggers.host.localForward.description": "Forward connections to the given TCP port or Unix socket on the local (client) host to the given host and port, or Unix socket, on the remote side",
    "c_cpp.debuggers.host.localForward.bindAddress.description": "Local address",
    "c_cpp.debuggers.host.localForward.port.description": "Local port",
    "c_cpp.debuggers.host.localForward.host.description": "Host name",
    "c_cpp.debuggers.host.localForward.hostPort.description": "Host port",
    "c_cpp.debuggers.host.localForward.localSocket.description": "Local socket",
    "c_cpp.debuggers.host.localForward.remoteSocket.description": "Remote socket",
    "c_cpp.debuggers.deploySteps.description": "Steps needed to deploy the application. Order matters.",
    "c_cpp.debuggers.deploySteps.copyFile.description": "Copy files using SCP or rsync.",
    "c_cpp.debuggers.deploySteps.copyFile.files.description": "Files to be copied. Supports path pattern.",
    "c_cpp.debuggers.deploySteps.copyFile.targetDir.description": "Target directory.",
    "c_cpp.debuggers.deploySteps.copyFile.recursive.description": "If true, copies folders recursively.",
    "c_cpp.debuggers.deploySteps.copyFile.scpPath.description": "Optional full path to SCP. Assumes SCP is on PATH if not specified",
    "c_cpp.debuggers.deploySteps.copyFile.rsyncPath.description": "Optional full path to rsync. Assumes rsync is on PATH if not specified",
    "c_cpp.debuggers.deploySteps.debug": "If true, skip when starting without debugging. If false, skip when starting debugging. If undefined, never skip.",
    "c_cpp.debuggers.deploySteps.ssh.description": "SSH command step.",
    "c_cpp.debuggers.deploySteps.ssh.command.description": "Command to be executed via SSH. The command after '-c' in SSH command.",
    "c_cpp.debuggers.deploySteps.ssh.sshPath.description": "Optional full path to SSH. Assumes SSH is on PATH if not specified",
    "c_cpp.debuggers.deploySteps.continueOn.description": "An optional finish pattern in output. When this pattern is seen in the output, continue the deploy procedures regardless of whether this step returns.",
    "c_cpp.debuggers.deploySteps.shell.description": "Shell command step.",
    "c_cpp.debuggers.deploySteps.shell.command.description": "Shell command to be executed.",
    "c_cpp.debuggers.vsCodeCommand.description": "VS Code command to be invoked. Can be a command in VS Code or an active extension.",
    "c_cpp.debuggers.vsCodeCommand.command.description": "VS Code command to be invoked.",
    "c_cpp.debuggers.vsCodeCommand.args.description": "Arguments to the VS Code command.",
    "c_cpp.debuggers.sourceFileMap.sourceFileMapEntry.description": "Current and compile-time paths to the same source trees. Files found under the EditorPath are mapped to the CompileTimePath path for breakpoint matching and mapped from CompileTimePath to EditorPath when displaying stacktrace locations.",
    "c_cpp.debuggers.sourceFileMap.sourceFileMapEntry.editorPath.description": "The path to the source tree the editor will use.",
    "c_cpp.debuggers.sourceFileMap.sourceFileMapEntry.useForBreakpoints.description": "False if this entry is only used for stack frame location mapping. True if this entry should also be used when specifying breakpoint locations.",
    "c_cpp.debuggers.symbolOptions.description": "Options to control how symbols (.pdb files) are found and loaded.",
    "c_cpp.debuggers.unknownBreakpointHandling.description": "Controls how breakpoints set externally (usually via raw GDB commands) are handled when hit.\nAllowed values are \"throw\", which acts as if an exception was thrown by the application, and \"stop\", which only pauses the debug session. The default value is \"throw\".",
    "c_cpp.debuggers.VSSymbolOptions.description": "Provides configuration for locating and loading symbols to the debug adapter.",
    "c_cpp.debuggers.VSSymbolOptions.searchPaths.description": "Array of symbol server URLs (example: http\u200b://MyExampleSymbolServer) or directories (example: /build/symbols) to search for .pdb files. These directories will be searched in addition to the default locations -- next to the module and the path where the pdb was originally dropped to.",
    "c_cpp.debuggers.VSSymbolOptions.searchMicrosoftSymbolServer.description": "If 'true' the Microsoft Symbol server (https\u200b://msdl.microsoft.com\u200b/download/symbols) is added to the symbols search path. If unspecified, this option defaults to 'false'.",
    "c_cpp.debuggers.VSSymbolOptions.cachePath.description": "Directory where symbols downloaded from symbol servers should be cached. If unspecified, on Windows the debugger will default to %TEMP%\\SymbolCache.",
    "c_cpp.debuggers.VSSymbolOptions.moduleFilter.description": "Provides options to control which modules (.dll files) the debugger will attempt to load symbols (.pdb files) for.",
    "c_cpp.debuggers.VSSymbolOptionsModuleFilter.description": "Provides configuration for loading symbols to the debug adapter.",
    "c_cpp.debuggers.VSSymbolOptionsModuleFilter.mode.description": "Controls which of the two basic operating modes the module filter operates in.",
    "c_cpp.debuggers.VSSymbolOptionsModuleFilter.mode.loadAllButExcluded.enumDescriptions": "Load symbols for all modules unless the module is in the 'excludedModules' array.",
    "c_cpp.debuggers.VSSymbolOptionsModuleFilter.mode.loadOnlyIncluded.enumDescriptions": "Do not attempt to load symbols for ANY module unless it is in the 'includedModules' array, or it is included through the 'includeSymbolsNextToModules' setting.",
    "c_cpp.debuggers.VSSymbolOptionsModuleFilter.excludedModules.description": "Array of modules that the debugger should NOT load symbols for. Wildcards (example: MyCompany.*.dll) are supported.\n\nThis property is ignored unless 'mode' is set to 'loadAllButExcluded'.",
    "c_cpp.debuggers.VSSymbolOptionsModuleFilter.includedModules.description": "Array of modules that the debugger should load symbols for. Wildcards (example: MyCompany.*.dll) are supported.\n\nThis property is ignored unless 'mode' is set to 'loadOnlyIncluded'.",
    "c_cpp.debuggers.VSSymbolOptionsModuleFilter.includeSymbolsNextToModules.description": "If true, for any module NOT in the 'includedModules' array, the debugger will still check next to the module itself and the launching executable, but it will not check paths on the symbol search list. This option defaults to 'true'.\n\nThis property is ignored unless 'mode' is set to 'loadOnlyIncluded'.",
    "c_cpp.debuggers.logging.natvisDiagnostics.description": "Optional flag to determine whether diagnostic natvis messages should be logged to the Debug Console. Defaults to None.",
    "c_cpp.debuggers.logging.category.verbose.description": "Logs that are used for interactive investigation during development. These logs should primarily contain information useful for debugging and have no long-term value.",
    "c_cpp.debuggers.logging.category.warning.description": "Logs that highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.",
    "c_cpp.debuggers.logging.category.error.description": "Logs that highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.",
    "c_cpp.debuggers.logging.category.none.description": "Not used for writing log messages. Specifies that a logging category should not write any messages.",
    "refresh.process.list.tooltip": "Refresh process list",
    "attach.to.process": "Attach to process",
    "select.process.attach": "Select the process to attach to",
    "process.not.selected": "Process not selected.",
    "debugger.path.and.server.address.required": "{0} in debug configuration requires {1} and {2}",
    "no.pipetransport.useextendedremote": "Chosen debug configuration does not contain {0} or {1}",
    "pipe.failed": "Pipe transport failed to get OS and processes.",
    "no.process.list": "Transport attach could not obtain processes list.",
    "failed.to.make.gdb.connection": "Failed to make GDB connection: '{0}'.",
    "failed.to.parse.processes": "Failed to parse processes: '{0}'.",
    "os.not.supported": "Operating system '{0}' not supported.",
    "timeout.processList.spawn": "'{0}' timed out after {1} seconds.",
    "cancel.processList.spawn": "'{0}' canceled.",
    "error.processList.spawn": "'{0}' exited with code: '{1}'.",
    "failed.processList.spawn": "Failed to spawn '{0}'.",
    "process.exited": "Process exited with code {0}",
    "process.succeeded": "Process executed successfully.",
    "ignoring.lines.in.envfile": "Ignoring non-parsable lines in {0} {1}: ",
    "cppdebug.autoLoadPrettyPrinters.description": "Automatically load GDB pretty printers when debugging with GDB. This enables better visualization of complex C++ types like Qt containers and STL types.",
    "cppdebug.enablePrettyPrinting.description": "Enable GDB pretty printing for the debugging session."
}