1//===-- CommandOptionArgumentTable.h ----------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLDB_INTERPRETER_COMMANDOPTIONARGUMENTTABLE_H
10#define LLDB_INTERPRETER_COMMANDOPTIONARGUMENTTABLE_H
11
12#include "lldb/Interpreter/CommandObject.h"
13
14namespace lldb_private {
15
16static constexpr OptionEnumValueElement g_corefile_save_style[] = {
17 {.value: lldb::eSaveCoreFull, .string_value: "full", .usage: "Create a core file with all memory saved"},
18 {.value: lldb::eSaveCoreDirtyOnly, .string_value: "modified-memory",
19 .usage: "Create a corefile with only modified memory saved"},
20 {.value: lldb::eSaveCoreStackOnly, .string_value: "stack",
21 .usage: "Create a corefile with only stack memory saved"},
22};
23
24static constexpr OptionEnumValueElement g_description_verbosity_type[] = {
25 {
26 .value: eLanguageRuntimeDescriptionDisplayVerbosityCompact,
27 .string_value: "compact",
28 .usage: "Only show the description string",
29 },
30 {
31 .value: eLanguageRuntimeDescriptionDisplayVerbosityFull,
32 .string_value: "full",
33 .usage: "Show the full output, including persistent variable's name and type",
34 },
35};
36
37static constexpr OptionEnumValueElement g_sort_option_enumeration[] = {
38 {
39 .value: eSortOrderNone,
40 .string_value: "none",
41 .usage: "No sorting, use the original symbol table order.",
42 },
43 {
44 .value: eSortOrderByAddress,
45 .string_value: "address",
46 .usage: "Sort output by symbol address.",
47 },
48 {
49 .value: eSortOrderByName,
50 .string_value: "name",
51 .usage: "Sort output by symbol name.",
52 },
53 {
54 .value: eSortOrderBySize,
55 .string_value: "size",
56 .usage: "Sort output by symbol byte size.",
57 },
58};
59
60// Note that the negation in the argument name causes a slightly confusing
61// mapping of the enum values.
62static constexpr OptionEnumValueElement g_dependents_enumeration[] = {
63 {
64 .value: eLoadDependentsDefault,
65 .string_value: "default",
66 .usage: "Only load dependents when the target is an executable.",
67 },
68 {
69 .value: eLoadDependentsNo,
70 .string_value: "true",
71 .usage: "Don't load dependents, even if the target is an executable.",
72 },
73 {
74 .value: eLoadDependentsYes,
75 .string_value: "false",
76 .usage: "Load dependents, even if the target is not an executable.",
77 },
78};
79
80// FIXME: "script-type" needs to have its contents determined dynamically, so
81// somebody can add a new scripting language to lldb and have it pickable here
82// without having to change this enumeration by hand and rebuild lldb proper.
83static constexpr OptionEnumValueElement g_script_option_enumeration[] = {
84 {
85 .value: lldb::eScriptLanguageNone,
86 .string_value: "command",
87 .usage: "Commands are in the lldb command interpreter language",
88 },
89 {
90 .value: lldb::eScriptLanguagePython,
91 .string_value: "python",
92 .usage: "Commands are in the Python language.",
93 },
94 {
95 .value: lldb::eScriptLanguageLua,
96 .string_value: "lua",
97 .usage: "Commands are in the Lua language.",
98 },
99 {
100 .value: lldb::eScriptLanguageNone,
101 .string_value: "default",
102 .usage: "Commands are in the default scripting language.",
103 },
104};
105
106static constexpr OptionEnumValueElement g_log_handler_type[] = {
107 {
108 .value: eLogHandlerDefault,
109 .string_value: "default",
110 .usage: "Use the default (stream) log handler",
111 },
112 {
113 .value: eLogHandlerStream,
114 .string_value: "stream",
115 .usage: "Write log messages to the debugger output stream or to a file if one "
116 "is specified. A buffer size (in bytes) can be specified with -b. If "
117 "no buffer size is specified the output is unbuffered.",
118 },
119 {
120 .value: eLogHandlerCircular,
121 .string_value: "circular",
122 .usage: "Write log messages to a fixed size circular buffer. A buffer size "
123 "(number of messages) must be specified with -b.",
124 },
125 {
126 .value: eLogHandlerSystem,
127 .string_value: "os",
128 .usage: "Write log messages to the operating system log.",
129 },
130};
131
132static constexpr OptionEnumValueElement g_script_synchro_type[] = {
133 {
134 .value: eScriptedCommandSynchronicitySynchronous,
135 .string_value: "synchronous",
136 .usage: "Run synchronous",
137 },
138 {
139 .value: eScriptedCommandSynchronicityAsynchronous,
140 .string_value: "asynchronous",
141 .usage: "Run asynchronous",
142 },
143 {
144 .value: eScriptedCommandSynchronicityCurrentValue,
145 .string_value: "current",
146 .usage: "Do not alter current setting",
147 },
148};
149
150static constexpr OptionEnumValueElement g_running_mode[] = {
151 {.value: lldb::eOnlyThisThread, .string_value: "this-thread", .usage: "Run only this thread"},
152 {.value: lldb::eAllThreads, .string_value: "all-threads", .usage: "Run all threads"},
153 {.value: lldb::eOnlyDuringStepping, .string_value: "while-stepping",
154 .usage: "Run only this thread while stepping"},
155};
156
157static constexpr OptionEnumValueElement g_completion_type[] = {
158 {.value: lldb::eNoCompletion, .string_value: "none", .usage: "No completion."},
159 {.value: lldb::eSourceFileCompletion, .string_value: "source-file", .usage: "Completes to a source file."},
160 {.value: lldb::eDiskFileCompletion, .string_value: "disk-file", .usage: "Completes to a disk file."},
161 {.value: lldb::eDiskDirectoryCompletion, .string_value: "disk-directory",
162 .usage: "Completes to a disk directory."},
163 {.value: lldb::eSymbolCompletion, .string_value: "symbol", .usage: "Completes to a symbol."},
164 {.value: lldb::eModuleCompletion, .string_value: "module", .usage: "Completes to a module."},
165 {.value: lldb::eSettingsNameCompletion, .string_value: "settings-name",
166 .usage: "Completes to a settings name."},
167 {.value: lldb::ePlatformPluginCompletion, .string_value: "platform-plugin",
168 .usage: "Completes to a platform plugin."},
169 {.value: lldb::eArchitectureCompletion, .string_value: "architecture",
170 .usage: "Completes to a architecture."},
171 {.value: lldb::eVariablePathCompletion, .string_value: "variable-path",
172 .usage: "Completes to a variable path."},
173 {.value: lldb::eRegisterCompletion, .string_value: "register", .usage: "Completes to a register."},
174 {.value: lldb::eBreakpointCompletion, .string_value: "breakpoint", .usage: "Completes to a breakpoint."},
175 {.value: lldb::eProcessPluginCompletion, .string_value: "process-plugin",
176 .usage: "Completes to a process plugin."},
177 {.value: lldb::eDisassemblyFlavorCompletion, .string_value: "disassembly-flavor",
178 .usage: "Completes to a disassembly flavor."},
179 {.value: lldb::eTypeLanguageCompletion, .string_value: "type-language",
180 .usage: "Completes to a type language."},
181 {.value: lldb::eFrameIndexCompletion, .string_value: "frame-index", .usage: "Completes to a frame index."},
182 {.value: lldb::eModuleUUIDCompletion, .string_value: "module-uuid", .usage: "Completes to a module uuid."},
183 {.value: lldb::eStopHookIDCompletion, .string_value: "stophook-id", .usage: "Completes to a stophook id."},
184 {.value: lldb::eThreadIndexCompletion, .string_value: "thread-index",
185 .usage: "Completes to a thread index."},
186 {.value: lldb::eWatchpointIDCompletion, .string_value: "watchpoint-id",
187 .usage: "Completes to a watchpoint id."},
188 {.value: lldb::eBreakpointNameCompletion, .string_value: "breakpoint-name",
189 .usage: "Completes to a breakpoint name."},
190 {.value: lldb::eProcessIDCompletion, .string_value: "process-id", .usage: "Completes to a process id."},
191 {.value: lldb::eProcessNameCompletion, .string_value: "process-name",
192 .usage: "Completes to a process name."},
193 {.value: lldb::eRemoteDiskFileCompletion, .string_value: "remote-disk-file",
194 .usage: "Completes to a remote disk file."},
195 {.value: lldb::eRemoteDiskDirectoryCompletion, .string_value: "remote-disk-directory",
196 .usage: "Completes to a remote disk directory."},
197 {.value: lldb::eTypeCategoryNameCompletion, .string_value: "type-category-name",
198 .usage: "Completes to a type category name."},
199 {.value: lldb::eCustomCompletion, .string_value: "custom", .usage: "Custom completion."},
200 {.value: lldb::eThreadIDCompletion, .string_value: "thread-id", .usage: "Completes to a thread ID."},
201};
202
203llvm::StringRef RegisterNameHelpTextCallback();
204llvm::StringRef BreakpointIDHelpTextCallback();
205llvm::StringRef BreakpointIDRangeHelpTextCallback();
206llvm::StringRef BreakpointNameHelpTextCallback();
207llvm::StringRef GDBFormatHelpTextCallback();
208llvm::StringRef FormatHelpTextCallback();
209llvm::StringRef LanguageTypeHelpTextCallback();
210llvm::StringRef SummaryStringHelpTextCallback();
211llvm::StringRef ExprPathHelpTextCallback();
212llvm::StringRef arch_helper();
213
214static constexpr CommandObject::ArgumentTableEntry g_argument_table[] = {
215 // clang-format off
216 { .arg_type: lldb::eArgTypeAddress, .arg_name: "address", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A valid address in the target program's execution space." },
217 { .arg_type: lldb::eArgTypeAddressOrExpression, .arg_name: "address-expression", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "An expression that resolves to an address." },
218 { .arg_type: lldb::eArgTypeAliasName, .arg_name: "alias-name", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of an abbreviation (alias) for a debugger command." },
219 { .arg_type: lldb::eArgTypeAliasOptions, .arg_name: "options-for-aliased-command", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Command options to be used as part of an alias (abbreviation) definition. (See 'help commands alias' for more information.)" },
220 { .arg_type: lldb::eArgTypeArchitecture, .arg_name: "arch", .completion_type: lldb::eArchitectureCompletion, .enum_values: {}, .help_function: { .help_callback: arch_helper, .self_formatting: true }, .help_text: "The architecture name, e.g. i386 or x86_64." },
221 { .arg_type: lldb::eArgTypeBoolean, .arg_name: "boolean", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A Boolean value: 'true' or 'false'" },
222 { .arg_type: lldb::eArgTypeBreakpointID, .arg_name: "breakpt-id", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: BreakpointIDHelpTextCallback, .self_formatting: false }, .help_text: nullptr },
223 { .arg_type: lldb::eArgTypeBreakpointIDRange, .arg_name: "breakpt-id-list", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: BreakpointIDRangeHelpTextCallback, .self_formatting: false }, .help_text: nullptr },
224 { .arg_type: lldb::eArgTypeBreakpointName, .arg_name: "breakpoint-name", .completion_type: lldb::eBreakpointNameCompletion, .enum_values: {}, .help_function: { .help_callback: BreakpointNameHelpTextCallback, .self_formatting: false }, .help_text: nullptr },
225 { .arg_type: lldb::eArgTypeByteSize, .arg_name: "byte-size", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Number of bytes to use." },
226 { .arg_type: lldb::eArgTypeClassName, .arg_name: "class-name", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Then name of a class from the debug information in the program." },
227 { .arg_type: lldb::eArgTypeCommandName, .arg_name: "cmd-name", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A debugger command (may be multiple words), without any options or arguments." },
228 { .arg_type: lldb::eArgTypeCount, .arg_name: "count", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "An unsigned integer." },
229 { .arg_type: lldb::eArgTypeDescriptionVerbosity, .arg_name: "description-verbosity", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_description_verbosity_type, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "How verbose the output of 'po' should be." },
230 { .arg_type: lldb::eArgTypeDirectoryName, .arg_name: "directory", .completion_type: lldb::eDiskDirectoryCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A directory name." },
231 { .arg_type: lldb::eArgTypeDisassemblyFlavor, .arg_name: "disassembly-flavor", .completion_type: lldb::eDisassemblyFlavorCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A disassembly flavor recognized by your disassembly plugin. Currently the only valid options are \"att\" and \"intel\" for Intel targets" },
232 { .arg_type: lldb::eArgTypeEndAddress, .arg_name: "end-address", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
233 { .arg_type: lldb::eArgTypeExpression, .arg_name: "expr", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
234 { .arg_type: lldb::eArgTypeExpressionPath, .arg_name: "expr-path", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: ExprPathHelpTextCallback, .self_formatting: true }, .help_text: nullptr },
235 { .arg_type: lldb::eArgTypeExprFormat, .arg_name: "expression-format", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]" },
236 { .arg_type: lldb::eArgTypeFileLineColumn, .arg_name: "linespec", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A source specifier in the form file:line[:column]" },
237 { .arg_type: lldb::eArgTypeFilename, .arg_name: "filename", .completion_type: lldb::eDiskFileCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a file (can include path)." },
238 { .arg_type: lldb::eArgTypeFormat, .arg_name: "format", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: FormatHelpTextCallback, .self_formatting: true }, .help_text: nullptr },
239 { .arg_type: lldb::eArgTypeFrameIndex, .arg_name: "frame-index", .completion_type: lldb::eFrameIndexCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Index into a thread's list of frames." },
240 { .arg_type: lldb::eArgTypeFullName, .arg_name: "fullname", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
241 { .arg_type: lldb::eArgTypeFunctionName, .arg_name: "function-name", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a function." },
242 { .arg_type: lldb::eArgTypeFunctionOrSymbol, .arg_name: "function-or-symbol", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a function or symbol." },
243 { .arg_type: lldb::eArgTypeGDBFormat, .arg_name: "gdb-format", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: GDBFormatHelpTextCallback, .self_formatting: true }, .help_text: nullptr },
244 { .arg_type: lldb::eArgTypeHelpText, .arg_name: "help-text", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Text to be used as help for some other entity in LLDB" },
245 { .arg_type: lldb::eArgTypeIndex, .arg_name: "index", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "An index into a list." },
246 { .arg_type: lldb::eArgTypeLanguage, .arg_name: "source-language", .completion_type: lldb::eTypeLanguageCompletion, .enum_values: {}, .help_function: { .help_callback: LanguageTypeHelpTextCallback, .self_formatting: true }, .help_text: nullptr },
247 { .arg_type: lldb::eArgTypeLineNum, .arg_name: "linenum", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Line number in a source file." },
248 { .arg_type: lldb::eArgTypeLogCategory, .arg_name: "log-category", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a category within a log channel, e.g. all (try \"log list\" to see a list of all channels and their categories." },
249 { .arg_type: lldb::eArgTypeLogChannel, .arg_name: "log-channel", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a log channel, e.g. process.gdb-remote (try \"log list\" to see a list of all channels and their categories)." },
250 { .arg_type: lldb::eArgTypeMethod, .arg_name: "method", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A C++ method name." },
251 { .arg_type: lldb::eArgTypeName, .arg_name: "name", .completion_type: lldb::eTypeCategoryNameCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a type category." },
252 { .arg_type: lldb::eArgTypeNewPathPrefix, .arg_name: "new-path-prefix", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
253 { .arg_type: lldb::eArgTypeNumLines, .arg_name: "num-lines", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The number of lines to use." },
254 { .arg_type: lldb::eArgTypeNumberPerLine, .arg_name: "number-per-line", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The number of items per line to display." },
255 { .arg_type: lldb::eArgTypeOffset, .arg_name: "offset", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
256 { .arg_type: lldb::eArgTypeOldPathPrefix, .arg_name: "old-path-prefix", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
257 { .arg_type: lldb::eArgTypeOneLiner, .arg_name: "one-line-command", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A command that is entered as a single line of text." },
258 { .arg_type: lldb::eArgTypePath, .arg_name: "path", .completion_type: lldb::eDiskFileCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Path." },
259 { .arg_type: lldb::eArgTypePermissionsNumber, .arg_name: "perms-numeric", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Permissions given as an octal number (e.g. 755)." },
260 { .arg_type: lldb::eArgTypePermissionsString, .arg_name: "perms=string", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Permissions given as a string value (e.g. rw-r-xr--)." },
261 { .arg_type: lldb::eArgTypePid, .arg_name: "pid", .completion_type: lldb::eProcessIDCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The process ID number." },
262 { .arg_type: lldb::eArgTypePlugin, .arg_name: "plugin", .completion_type: lldb::eProcessPluginCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
263 { .arg_type: lldb::eArgTypeProcessName, .arg_name: "process-name", .completion_type: lldb::eProcessNameCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of the process." },
264 { .arg_type: lldb::eArgTypePythonClass, .arg_name: "python-class", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a Python class." },
265 { .arg_type: lldb::eArgTypePythonFunction, .arg_name: "python-function", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a Python function." },
266 { .arg_type: lldb::eArgTypePythonScript, .arg_name: "python-script", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Source code written in Python." },
267 { .arg_type: lldb::eArgTypeQueueName, .arg_name: "queue-name", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of the thread queue." },
268 { .arg_type: lldb::eArgTypeRegisterName, .arg_name: "register-name", .completion_type: lldb::CompletionType::eRegisterCompletion, .enum_values: {}, .help_function: { .help_callback: RegisterNameHelpTextCallback, .self_formatting: true }, .help_text: nullptr },
269 { .arg_type: lldb::eArgTypeRegularExpression, .arg_name: "regular-expression", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A POSIX-compliant extended regular expression." },
270 { .arg_type: lldb::eArgTypeRunArgs, .arg_name: "run-args", .completion_type: lldb::CompletionType::eDiskFileCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Arguments to be passed to the target program when it starts executing." },
271 { .arg_type: lldb::eArgTypeRunMode, .arg_name: "run-mode", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_running_mode, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
272 { .arg_type: lldb::eArgTypeScriptedCommandSynchronicity, .arg_name: "script-cmd-synchronicity", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_script_synchro_type, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The synchronicity to use to run scripted commands with regard to LLDB event system." },
273 { .arg_type: lldb::eArgTypeScriptLang, .arg_name: "script-language", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_script_option_enumeration, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The scripting language to be used for script-based commands. Supported languages are python and lua." },
274 { .arg_type: lldb::eArgTypeSearchWord, .arg_name: "search-word", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Any word of interest for search purposes." },
275 { .arg_type: lldb::eArgTypeSelector, .arg_name: "selector", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "An Objective-C selector name." },
276 { .arg_type: lldb::eArgTypeSettingIndex, .arg_name: "setting-index", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "An index into a settings variable that is an array (try 'settings list' to see all the possible settings variables and their types)." },
277 { .arg_type: lldb::eArgTypeSettingKey, .arg_name: "setting-key", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A key into a settings variables that is a dictionary (try 'settings list' to see all the possible settings variables and their types)." },
278 { .arg_type: lldb::eArgTypeSettingPrefix, .arg_name: "setting-prefix", .completion_type: lldb::CompletionType::eSettingsNameCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a settable internal debugger variable up to a dot ('.'), e.g. 'target.process.'" },
279 { .arg_type: lldb::eArgTypeSettingVariableName, .arg_name: "setting-variable-name", .completion_type: lldb::CompletionType::eSettingsNameCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a settable internal debugger variable. Type 'settings list' to see a complete list of such variables." },
280 { .arg_type: lldb::eArgTypeShlibName, .arg_name: "shlib-name", .completion_type: lldb::CompletionType::eDiskFileCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a shared library." },
281 { .arg_type: lldb::eArgTypeSourceFile, .arg_name: "source-file", .completion_type: lldb::eSourceFileCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a source file.." },
282 { .arg_type: lldb::eArgTypeSortOrder, .arg_name: "sort-order", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_sort_option_enumeration, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Specify a sort order when dumping lists." },
283 { .arg_type: lldb::eArgTypeStartAddress, .arg_name: "start-address", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
284 { .arg_type: lldb::eArgTypeSummaryString, .arg_name: "summary-string", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: SummaryStringHelpTextCallback, .self_formatting: true }, .help_text: nullptr },
285 { .arg_type: lldb::eArgTypeSymbol, .arg_name: "symbol", .completion_type: lldb::eSymbolCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Any symbol name (function name, variable, argument, etc.)" },
286 { .arg_type: lldb::eArgTypeThreadID, .arg_name: "thread-id", .completion_type: lldb::CompletionType::eThreadIndexCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Thread ID number." },
287 { .arg_type: lldb::eArgTypeThreadIndex, .arg_name: "thread-index", .completion_type: lldb::CompletionType::eThreadIndexCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Index into the process' list of threads." },
288 { .arg_type: lldb::eArgTypeThreadName, .arg_name: "thread-name", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The thread's name." },
289 { .arg_type: lldb::eArgTypeTypeName, .arg_name: "type-name", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A type name." },
290 { .arg_type: lldb::eArgTypeUnsignedInteger, .arg_name: "unsigned-integer", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "An unsigned integer." },
291 { .arg_type: lldb::eArgTypeUnixSignal, .arg_name: "unix-signal", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A valid Unix signal name or number (e.g. SIGKILL, KILL or 9)." },
292 { .arg_type: lldb::eArgTypeVarName, .arg_name: "variable-name", .completion_type: lldb::CompletionType::eVariablePathCompletion, .enum_values: {} ,.help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a variable in your program." },
293 { .arg_type: lldb::eArgTypeValue, .arg_name: "value", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_dependents_enumeration, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A value could be anything, depending on where and how it is used." },
294 { .arg_type: lldb::eArgTypeWidth, .arg_name: "width", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Help text goes here." },
295 { .arg_type: lldb::eArgTypeNone, .arg_name: "none", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "No help available for this." },
296 { .arg_type: lldb::eArgTypePlatform, .arg_name: "platform-name", .completion_type: lldb::ePlatformPluginCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of an installed platform plug-in . Type 'platform list' to see a complete list of installed platforms." },
297 { .arg_type: lldb::eArgTypeWatchpointID, .arg_name: "watchpt-id", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Watchpoint IDs are positive integers." },
298 { .arg_type: lldb::eArgTypeWatchpointIDRange, .arg_name: "watchpt-id-list", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "For example, '1-3' or '1 to 3'." },
299 { .arg_type: lldb::eArgTypeWatchType, .arg_name: "watch-type", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Specify the type for a watchpoint." },
300 { .arg_type: lldb::eArgRawInput, .arg_name: "raw-input", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Free-form text passed to a command without prior interpretation, allowing spaces without requiring quotes. To pass arguments and free form text put two dashes ' -- ' between the last argument and any raw input." },
301 { .arg_type: lldb::eArgTypeCommand, .arg_name: "command", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "An LLDB Command line command element." },
302 { .arg_type: lldb::eArgTypeColumnNum, .arg_name: "column", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "Column number in a source file." },
303 { .arg_type: lldb::eArgTypeModuleUUID, .arg_name: "module-uuid", .completion_type: lldb::eModuleUUIDCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A module UUID value." },
304 { .arg_type: lldb::eArgTypeSaveCoreStyle, .arg_name: "corefile-style", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_corefile_save_style, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The type of corefile that lldb will try to create, dependant on this target's capabilities." },
305 { .arg_type: lldb::eArgTypeLogHandler, .arg_name: "log-handler", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_log_handler_type ,.help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The log handle that will be used to write out log messages." },
306 { .arg_type: lldb::eArgTypeSEDStylePair, .arg_name: "substitution-pair", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A sed-style pattern and target pair." },
307 { .arg_type: lldb::eArgTypeRecognizerID, .arg_name: "frame-recognizer-id", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The ID for a stack frame recognizer." },
308 { .arg_type: lldb::eArgTypeConnectURL, .arg_name: "process-connect-url", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A URL-style specification for a remote connection." },
309 { .arg_type: lldb::eArgTypeTargetID, .arg_name: "target-id", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The index ID for an lldb Target." },
310 { .arg_type: lldb::eArgTypeStopHookID, .arg_name: "stop-hook-id", .completion_type: lldb::CompletionType::eStopHookIDCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The ID you receive when you create a stop-hook." },
311 { .arg_type: lldb::eArgTypeCompletionType, .arg_name: "completion-type", .completion_type: lldb::CompletionType::eNoCompletion, .enum_values: g_completion_type, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The completion type to use when adding custom commands. If none is specified, the command won't use auto-completion." },
312 { .arg_type: lldb::eArgTypeRemotePath, .arg_name: "remote-path", .completion_type: lldb::CompletionType::eRemoteDiskFileCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A path on the system managed by the current platform." },
313 { .arg_type: lldb::eArgTypeRemoteFilename, .arg_name: "remote-filename", .completion_type: lldb::CompletionType::eRemoteDiskFileCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "A file on the system managed by the current platform." },
314 { .arg_type: lldb::eArgTypeModule, .arg_name: "module", .completion_type: lldb::CompletionType::eModuleCompletion, .enum_values: {}, .help_function: { .help_callback: nullptr, .self_formatting: false }, .help_text: "The name of a module loaded into the current target." },
315 // clang-format on
316};
317
318static_assert((sizeof(g_argument_table) /
319 sizeof(CommandObject::ArgumentTableEntry)) ==
320 lldb::eArgTypeLastArg,
321 "number of elements in g_argument_table doesn't match "
322 "CommandArgumentType enumeration");
323
324} // namespace lldb_private
325
326#endif // LLDB_INTERPRETER_COMMANDOPTIONARGUMENTTABLE_H
327

source code of lldb/include/lldb/Interpreter/CommandOptionArgumentTable.h