1 //===-- CommandObject.cpp -------------------------------------------------===//
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 #include "lldb/Interpreter/CommandObject.h"
10
11 #include <map>
12 #include <sstream>
13 #include <string>
14
15 #include <cctype>
16 #include <cstdlib>
17
18 #include "lldb/Core/Address.h"
19 #include "lldb/Interpreter/CommandOptionArgumentTable.h"
20 #include "lldb/Interpreter/Options.h"
21 #include "lldb/Utility/ArchSpec.h"
22 #include "llvm/ADT/ScopeExit.h"
23
24 // These are for the Sourcename completers.
25 // FIXME: Make a separate file for the completers.
26 #include "lldb/DataFormatters/FormatManager.h"
27 #include "lldb/Target/Process.h"
28 #include "lldb/Target/Target.h"
29 #include "lldb/Utility/FileSpec.h"
30 #include "lldb/Utility/FileSpecList.h"
31
32 #include "lldb/Target/Language.h"
33
34 #include "lldb/Interpreter/CommandInterpreter.h"
35 #include "lldb/Interpreter/CommandOptionArgumentTable.h"
36 #include "lldb/Interpreter/CommandReturnObject.h"
37
38 using namespace lldb;
39 using namespace lldb_private;
40
41 // CommandObject
42
CommandObject(CommandInterpreter & interpreter,llvm::StringRef name,llvm::StringRef help,llvm::StringRef syntax,uint32_t flags)43 CommandObject::CommandObject(CommandInterpreter &interpreter,
44 llvm::StringRef name, llvm::StringRef help,
45 llvm::StringRef syntax, uint32_t flags)
46 : m_interpreter(interpreter), m_cmd_name(std::string(name)),
47 m_flags(flags), m_deprecated_command_override_callback(nullptr),
48 m_command_override_callback(nullptr), m_command_override_baton(nullptr) {
49 m_cmd_help_short = std::string(help);
50 m_cmd_syntax = std::string(syntax);
51 }
52
GetDebugger()53 Debugger &CommandObject::GetDebugger() { return m_interpreter.GetDebugger(); }
54
GetHelp()55 llvm::StringRef CommandObject::GetHelp() { return m_cmd_help_short; }
56
GetHelpLong()57 llvm::StringRef CommandObject::GetHelpLong() { return m_cmd_help_long; }
58
GetSyntax()59 llvm::StringRef CommandObject::GetSyntax() {
60 if (!m_cmd_syntax.empty())
61 return m_cmd_syntax;
62
63 StreamString syntax_str;
64 syntax_str.PutCString(GetCommandName());
65
66 if (!IsDashDashCommand() && GetOptions() != nullptr)
67 syntax_str.PutCString(" <cmd-options>");
68
69 if (!m_arguments.empty()) {
70 syntax_str.PutCString(" ");
71
72 if (!IsDashDashCommand() && WantsRawCommandString() && GetOptions() &&
73 GetOptions()->NumCommandOptions())
74 syntax_str.PutCString("-- ");
75 GetFormattedCommandArguments(syntax_str);
76 }
77 m_cmd_syntax = std::string(syntax_str.GetString());
78
79 return m_cmd_syntax;
80 }
81
GetCommandName() const82 llvm::StringRef CommandObject::GetCommandName() const { return m_cmd_name; }
83
SetCommandName(llvm::StringRef name)84 void CommandObject::SetCommandName(llvm::StringRef name) {
85 m_cmd_name = std::string(name);
86 }
87
SetHelp(llvm::StringRef str)88 void CommandObject::SetHelp(llvm::StringRef str) {
89 m_cmd_help_short = std::string(str);
90 }
91
SetHelpLong(llvm::StringRef str)92 void CommandObject::SetHelpLong(llvm::StringRef str) {
93 m_cmd_help_long = std::string(str);
94 }
95
SetSyntax(llvm::StringRef str)96 void CommandObject::SetSyntax(llvm::StringRef str) {
97 m_cmd_syntax = std::string(str);
98 }
99
GetOptions()100 Options *CommandObject::GetOptions() {
101 // By default commands don't have options unless this virtual function is
102 // overridden by base classes.
103 return nullptr;
104 }
105
ParseOptions(Args & args,CommandReturnObject & result)106 bool CommandObject::ParseOptions(Args &args, CommandReturnObject &result) {
107 // See if the subclass has options?
108 Options *options = GetOptions();
109 if (options != nullptr) {
110 Status error;
111
112 auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
113 options->NotifyOptionParsingStarting(&exe_ctx);
114
115 const bool require_validation = true;
116 llvm::Expected<Args> args_or = options->Parse(
117 args, &exe_ctx, GetCommandInterpreter().GetPlatform(true),
118 require_validation);
119
120 if (args_or) {
121 args = std::move(*args_or);
122 error = options->NotifyOptionParsingFinished(&exe_ctx);
123 } else
124 error = args_or.takeError();
125
126 if (error.Success()) {
127 if (options->VerifyOptions(result))
128 return true;
129 } else {
130 const char *error_cstr = error.AsCString();
131 if (error_cstr) {
132 // We got an error string, lets use that
133 result.AppendError(error_cstr);
134 } else {
135 // No error string, output the usage information into result
136 options->GenerateOptionUsage(
137 result.GetErrorStream(), *this,
138 GetCommandInterpreter().GetDebugger().GetTerminalWidth());
139 }
140 }
141 result.SetStatus(eReturnStatusFailed);
142 return false;
143 }
144 return true;
145 }
146
CheckRequirements(CommandReturnObject & result)147 bool CommandObject::CheckRequirements(CommandReturnObject &result) {
148 // Nothing should be stored in m_exe_ctx between running commands as
149 // m_exe_ctx has shared pointers to the target, process, thread and frame and
150 // we don't want any CommandObject instances to keep any of these objects
151 // around longer than for a single command. Every command should call
152 // CommandObject::Cleanup() after it has completed.
153 assert(!m_exe_ctx.GetTargetPtr());
154 assert(!m_exe_ctx.GetProcessPtr());
155 assert(!m_exe_ctx.GetThreadPtr());
156 assert(!m_exe_ctx.GetFramePtr());
157
158 // Lock down the interpreter's execution context prior to running the command
159 // so we guarantee the selected target, process, thread and frame can't go
160 // away during the execution
161 m_exe_ctx = m_interpreter.GetExecutionContext();
162
163 const uint32_t flags = GetFlags().Get();
164 if (flags & (eCommandRequiresTarget | eCommandRequiresProcess |
165 eCommandRequiresThread | eCommandRequiresFrame |
166 eCommandTryTargetAPILock)) {
167
168 if ((flags & eCommandRequiresTarget) && !m_exe_ctx.HasTargetScope()) {
169 result.AppendError(GetInvalidTargetDescription());
170 return false;
171 }
172
173 if ((flags & eCommandRequiresProcess) && !m_exe_ctx.HasProcessScope()) {
174 if (!m_exe_ctx.HasTargetScope())
175 result.AppendError(GetInvalidTargetDescription());
176 else
177 result.AppendError(GetInvalidProcessDescription());
178 return false;
179 }
180
181 if ((flags & eCommandRequiresThread) && !m_exe_ctx.HasThreadScope()) {
182 if (!m_exe_ctx.HasTargetScope())
183 result.AppendError(GetInvalidTargetDescription());
184 else if (!m_exe_ctx.HasProcessScope())
185 result.AppendError(GetInvalidProcessDescription());
186 else
187 result.AppendError(GetInvalidThreadDescription());
188 return false;
189 }
190
191 if ((flags & eCommandRequiresFrame) && !m_exe_ctx.HasFrameScope()) {
192 if (!m_exe_ctx.HasTargetScope())
193 result.AppendError(GetInvalidTargetDescription());
194 else if (!m_exe_ctx.HasProcessScope())
195 result.AppendError(GetInvalidProcessDescription());
196 else if (!m_exe_ctx.HasThreadScope())
197 result.AppendError(GetInvalidThreadDescription());
198 else
199 result.AppendError(GetInvalidFrameDescription());
200 return false;
201 }
202
203 if ((flags & eCommandRequiresRegContext) &&
204 (m_exe_ctx.GetRegisterContext() == nullptr)) {
205 result.AppendError(GetInvalidRegContextDescription());
206 return false;
207 }
208
209 if (flags & eCommandTryTargetAPILock) {
210 Target *target = m_exe_ctx.GetTargetPtr();
211 if (target)
212 m_api_locker =
213 std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());
214 }
215 }
216
217 if (GetFlags().AnySet(eCommandProcessMustBeLaunched |
218 eCommandProcessMustBePaused)) {
219 Process *process = m_interpreter.GetExecutionContext().GetProcessPtr();
220 if (process == nullptr) {
221 // A process that is not running is considered paused.
222 if (GetFlags().Test(eCommandProcessMustBeLaunched)) {
223 result.AppendError("Process must exist.");
224 return false;
225 }
226 } else {
227 StateType state = process->GetState();
228 switch (state) {
229 case eStateInvalid:
230 case eStateSuspended:
231 case eStateCrashed:
232 case eStateStopped:
233 break;
234
235 case eStateConnected:
236 case eStateAttaching:
237 case eStateLaunching:
238 case eStateDetached:
239 case eStateExited:
240 case eStateUnloaded:
241 if (GetFlags().Test(eCommandProcessMustBeLaunched)) {
242 result.AppendError("Process must be launched.");
243 return false;
244 }
245 break;
246
247 case eStateRunning:
248 case eStateStepping:
249 if (GetFlags().Test(eCommandProcessMustBePaused)) {
250 result.AppendError("Process is running. Use 'process interrupt' to "
251 "pause execution.");
252 return false;
253 }
254 }
255 }
256 }
257
258 if (GetFlags().Test(eCommandProcessMustBeTraced)) {
259 Target *target = m_exe_ctx.GetTargetPtr();
260 if (target && !target->GetTrace()) {
261 result.AppendError("Process is not being traced.");
262 return false;
263 }
264 }
265
266 return true;
267 }
268
Cleanup()269 void CommandObject::Cleanup() {
270 m_exe_ctx.Clear();
271 if (m_api_locker.owns_lock())
272 m_api_locker.unlock();
273 }
274
HandleCompletion(CompletionRequest & request)275 void CommandObject::HandleCompletion(CompletionRequest &request) {
276
277 m_exe_ctx = m_interpreter.GetExecutionContext();
278 auto reset_ctx = llvm::make_scope_exit([this]() { Cleanup(); });
279
280 // Default implementation of WantsCompletion() is !WantsRawCommandString().
281 // Subclasses who want raw command string but desire, for example, argument
282 // completion should override WantsCompletion() to return true, instead.
283 if (WantsRawCommandString() && !WantsCompletion()) {
284 // FIXME: Abstract telling the completion to insert the completion
285 // character.
286 return;
287 } else {
288 // Can we do anything generic with the options?
289 Options *cur_options = GetOptions();
290 CommandReturnObject result(m_interpreter.GetDebugger().GetUseColor());
291 OptionElementVector opt_element_vector;
292
293 if (cur_options != nullptr) {
294 opt_element_vector = cur_options->ParseForCompletion(
295 request.GetParsedLine(), request.GetCursorIndex());
296
297 bool handled_by_options = cur_options->HandleOptionCompletion(
298 request, opt_element_vector, GetCommandInterpreter());
299 if (handled_by_options)
300 return;
301 }
302
303 // If we got here, the last word is not an option or an option argument.
304 HandleArgumentCompletion(request, opt_element_vector);
305 }
306 }
307
HandleArgumentCompletion(CompletionRequest & request,OptionElementVector & opt_element_vector)308 void CommandObject::HandleArgumentCompletion(
309 CompletionRequest &request, OptionElementVector &opt_element_vector) {
310 size_t num_arg_entries = GetNumArgumentEntries();
311 if (num_arg_entries != 1)
312 return;
313
314 CommandArgumentEntry *entry_ptr = GetArgumentEntryAtIndex(0);
315 if (!entry_ptr) {
316 assert(entry_ptr && "We said there was one entry, but there wasn't.");
317 return; // Not worth crashing if asserts are off...
318 }
319
320 CommandArgumentEntry &entry = *entry_ptr;
321 // For now, we only handle the simple case of one homogenous argument type.
322 if (entry.size() != 1)
323 return;
324
325 // Look up the completion type, and if it has one, invoke it:
326 const CommandObject::ArgumentTableEntry *arg_entry =
327 FindArgumentDataByType(entry[0].arg_type);
328 const ArgumentRepetitionType repeat = entry[0].arg_repetition;
329
330 if (arg_entry == nullptr || arg_entry->completion_type == lldb::eNoCompletion)
331 return;
332
333 // FIXME: This should be handled higher in the Command Parser.
334 // Check the case where this command only takes one argument, and don't do
335 // the completion if we aren't on the first entry:
336 if (repeat == eArgRepeatPlain && request.GetCursorIndex() != 0)
337 return;
338
339 lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks(
340 GetCommandInterpreter(), arg_entry->completion_type, request, nullptr);
341
342 }
343
344
HelpTextContainsWord(llvm::StringRef search_word,bool search_short_help,bool search_long_help,bool search_syntax,bool search_options)345 bool CommandObject::HelpTextContainsWord(llvm::StringRef search_word,
346 bool search_short_help,
347 bool search_long_help,
348 bool search_syntax,
349 bool search_options) {
350 std::string options_usage_help;
351
352 bool found_word = false;
353
354 llvm::StringRef short_help = GetHelp();
355 llvm::StringRef long_help = GetHelpLong();
356 llvm::StringRef syntax_help = GetSyntax();
357
358 if (search_short_help && short_help.contains_insensitive(search_word))
359 found_word = true;
360 else if (search_long_help && long_help.contains_insensitive(search_word))
361 found_word = true;
362 else if (search_syntax && syntax_help.contains_insensitive(search_word))
363 found_word = true;
364
365 if (!found_word && search_options && GetOptions() != nullptr) {
366 StreamString usage_help;
367 GetOptions()->GenerateOptionUsage(
368 usage_help, *this,
369 GetCommandInterpreter().GetDebugger().GetTerminalWidth());
370 if (!usage_help.Empty()) {
371 llvm::StringRef usage_text = usage_help.GetString();
372 if (usage_text.contains_insensitive(search_word))
373 found_word = true;
374 }
375 }
376
377 return found_word;
378 }
379
ParseOptionsAndNotify(Args & args,CommandReturnObject & result,OptionGroupOptions & group_options,ExecutionContext & exe_ctx)380 bool CommandObject::ParseOptionsAndNotify(Args &args,
381 CommandReturnObject &result,
382 OptionGroupOptions &group_options,
383 ExecutionContext &exe_ctx) {
384 if (!ParseOptions(args, result))
385 return false;
386
387 Status error(group_options.NotifyOptionParsingFinished(&exe_ctx));
388 if (error.Fail()) {
389 result.AppendError(error.AsCString());
390 return false;
391 }
392 return true;
393 }
394
AddSimpleArgumentList(CommandArgumentType arg_type,ArgumentRepetitionType repetition_type)395 void CommandObject::AddSimpleArgumentList(
396 CommandArgumentType arg_type, ArgumentRepetitionType repetition_type) {
397
398 CommandArgumentEntry arg_entry;
399 CommandArgumentData simple_arg;
400
401 // Define the first (and only) variant of this arg.
402 simple_arg.arg_type = arg_type;
403 simple_arg.arg_repetition = repetition_type;
404
405 // There is only one variant this argument could be; put it into the argument
406 // entry.
407 arg_entry.push_back(simple_arg);
408
409 // Push the data for the first argument into the m_arguments vector.
410 m_arguments.push_back(arg_entry);
411 }
412
GetNumArgumentEntries()413 int CommandObject::GetNumArgumentEntries() { return m_arguments.size(); }
414
415 CommandObject::CommandArgumentEntry *
GetArgumentEntryAtIndex(int idx)416 CommandObject::GetArgumentEntryAtIndex(int idx) {
417 if (static_cast<size_t>(idx) < m_arguments.size())
418 return &(m_arguments[idx]);
419
420 return nullptr;
421 }
422
423 const CommandObject::ArgumentTableEntry *
FindArgumentDataByType(CommandArgumentType arg_type)424 CommandObject::FindArgumentDataByType(CommandArgumentType arg_type) {
425 for (int i = 0; i < eArgTypeLastArg; ++i)
426 if (g_argument_table[i].arg_type == arg_type)
427 return &(g_argument_table[i]);
428
429 return nullptr;
430 }
431
GetArgumentHelp(Stream & str,CommandArgumentType arg_type,CommandInterpreter & interpreter)432 void CommandObject::GetArgumentHelp(Stream &str, CommandArgumentType arg_type,
433 CommandInterpreter &interpreter) {
434 const ArgumentTableEntry *entry = &(g_argument_table[arg_type]);
435
436 // The table is *supposed* to be kept in arg_type order, but someone *could*
437 // have messed it up...
438
439 if (entry->arg_type != arg_type)
440 entry = CommandObject::FindArgumentDataByType(arg_type);
441
442 if (!entry)
443 return;
444
445 StreamString name_str;
446 name_str.Printf("<%s>", entry->arg_name);
447
448 if (entry->help_function) {
449 llvm::StringRef help_text = entry->help_function();
450 if (!entry->help_function.self_formatting) {
451 interpreter.OutputFormattedHelpText(str, name_str.GetString(), "--",
452 help_text, name_str.GetSize());
453 } else {
454 interpreter.OutputHelpText(str, name_str.GetString(), "--", help_text,
455 name_str.GetSize());
456 }
457 } else {
458 interpreter.OutputFormattedHelpText(str, name_str.GetString(), "--",
459 entry->help_text, name_str.GetSize());
460
461 // Print enum values and their description if any.
462 OptionEnumValues enum_values = g_argument_table[arg_type].enum_values;
463 if (!enum_values.empty()) {
464 str.EOL();
465 size_t longest = 0;
466 for (const OptionEnumValueElement &element : enum_values)
467 longest =
468 std::max(longest, llvm::StringRef(element.string_value).size());
469 str.IndentMore(5);
470 for (const OptionEnumValueElement &element : enum_values) {
471 str.Indent();
472 interpreter.OutputHelpText(str, element.string_value, ":",
473 element.usage, longest);
474 }
475 str.IndentLess(5);
476 str.EOL();
477 }
478 }
479 }
480
GetArgumentName(CommandArgumentType arg_type)481 const char *CommandObject::GetArgumentName(CommandArgumentType arg_type) {
482 const ArgumentTableEntry *entry = &(g_argument_table[arg_type]);
483
484 // The table is *supposed* to be kept in arg_type order, but someone *could*
485 // have messed it up...
486
487 if (entry->arg_type != arg_type)
488 entry = CommandObject::FindArgumentDataByType(arg_type);
489
490 if (entry)
491 return entry->arg_name;
492
493 return nullptr;
494 }
495
IsPairType(ArgumentRepetitionType arg_repeat_type)496 bool CommandObject::IsPairType(ArgumentRepetitionType arg_repeat_type) {
497 return (arg_repeat_type == eArgRepeatPairPlain) ||
498 (arg_repeat_type == eArgRepeatPairOptional) ||
499 (arg_repeat_type == eArgRepeatPairPlus) ||
500 (arg_repeat_type == eArgRepeatPairStar) ||
501 (arg_repeat_type == eArgRepeatPairRange) ||
502 (arg_repeat_type == eArgRepeatPairRangeOptional);
503 }
504
505 std::optional<ArgumentRepetitionType>
ArgRepetitionFromString(llvm::StringRef string)506 CommandObject::ArgRepetitionFromString(llvm::StringRef string) {
507 return llvm::StringSwitch<ArgumentRepetitionType>(string)
508 .Case("plain", eArgRepeatPlain)
509 .Case("optional", eArgRepeatOptional)
510 .Case("plus", eArgRepeatPlus)
511 .Case("star", eArgRepeatStar)
512 .Case("range", eArgRepeatRange)
513 .Case("pair-plain", eArgRepeatPairPlain)
514 .Case("pair-optional", eArgRepeatPairOptional)
515 .Case("pair-plus", eArgRepeatPairPlus)
516 .Case("pair-star", eArgRepeatPairStar)
517 .Case("pair-range", eArgRepeatPairRange)
518 .Case("pair-range-optional", eArgRepeatPairRangeOptional)
519 .Default({});
520 }
521
522 static CommandObject::CommandArgumentEntry
OptSetFiltered(uint32_t opt_set_mask,CommandObject::CommandArgumentEntry & cmd_arg_entry)523 OptSetFiltered(uint32_t opt_set_mask,
524 CommandObject::CommandArgumentEntry &cmd_arg_entry) {
525 CommandObject::CommandArgumentEntry ret_val;
526 for (unsigned i = 0; i < cmd_arg_entry.size(); ++i)
527 if (opt_set_mask & cmd_arg_entry[i].arg_opt_set_association)
528 ret_val.push_back(cmd_arg_entry[i]);
529 return ret_val;
530 }
531
532 // Default parameter value of opt_set_mask is LLDB_OPT_SET_ALL, which means
533 // take all the argument data into account. On rare cases where some argument
534 // sticks with certain option sets, this function returns the option set
535 // filtered args.
GetFormattedCommandArguments(Stream & str,uint32_t opt_set_mask)536 void CommandObject::GetFormattedCommandArguments(Stream &str,
537 uint32_t opt_set_mask) {
538 int num_args = m_arguments.size();
539 for (int i = 0; i < num_args; ++i) {
540 if (i > 0)
541 str.Printf(" ");
542 CommandArgumentEntry arg_entry =
543 opt_set_mask == LLDB_OPT_SET_ALL
544 ? m_arguments[i]
545 : OptSetFiltered(opt_set_mask, m_arguments[i]);
546 // This argument is not associated with the current option set, so skip it.
547 if (arg_entry.empty())
548 continue;
549 int num_alternatives = arg_entry.size();
550
551 if ((num_alternatives == 2) && IsPairType(arg_entry[0].arg_repetition)) {
552 const char *first_name = GetArgumentName(arg_entry[0].arg_type);
553 const char *second_name = GetArgumentName(arg_entry[1].arg_type);
554 switch (arg_entry[0].arg_repetition) {
555 case eArgRepeatPairPlain:
556 str.Printf("<%s> <%s>", first_name, second_name);
557 break;
558 case eArgRepeatPairOptional:
559 str.Printf("[<%s> <%s>]", first_name, second_name);
560 break;
561 case eArgRepeatPairPlus:
562 str.Printf("<%s> <%s> [<%s> <%s> [...]]", first_name, second_name,
563 first_name, second_name);
564 break;
565 case eArgRepeatPairStar:
566 str.Printf("[<%s> <%s> [<%s> <%s> [...]]]", first_name, second_name,
567 first_name, second_name);
568 break;
569 case eArgRepeatPairRange:
570 str.Printf("<%s_1> <%s_1> ... <%s_n> <%s_n>", first_name, second_name,
571 first_name, second_name);
572 break;
573 case eArgRepeatPairRangeOptional:
574 str.Printf("[<%s_1> <%s_1> ... <%s_n> <%s_n>]", first_name, second_name,
575 first_name, second_name);
576 break;
577 // Explicitly test for all the rest of the cases, so if new types get
578 // added we will notice the missing case statement(s).
579 case eArgRepeatPlain:
580 case eArgRepeatOptional:
581 case eArgRepeatPlus:
582 case eArgRepeatStar:
583 case eArgRepeatRange:
584 // These should not be reached, as they should fail the IsPairType test
585 // above.
586 break;
587 }
588 } else {
589 StreamString names;
590 for (int j = 0; j < num_alternatives; ++j) {
591 if (j > 0)
592 names.Printf(" | ");
593 names.Printf("%s", GetArgumentName(arg_entry[j].arg_type));
594 }
595
596 std::string name_str = std::string(names.GetString());
597 switch (arg_entry[0].arg_repetition) {
598 case eArgRepeatPlain:
599 str.Printf("<%s>", name_str.c_str());
600 break;
601 case eArgRepeatPlus:
602 str.Printf("<%s> [<%s> [...]]", name_str.c_str(), name_str.c_str());
603 break;
604 case eArgRepeatStar:
605 str.Printf("[<%s> [<%s> [...]]]", name_str.c_str(), name_str.c_str());
606 break;
607 case eArgRepeatOptional:
608 str.Printf("[<%s>]", name_str.c_str());
609 break;
610 case eArgRepeatRange:
611 str.Printf("<%s_1> .. <%s_n>", name_str.c_str(), name_str.c_str());
612 break;
613 // Explicitly test for all the rest of the cases, so if new types get
614 // added we will notice the missing case statement(s).
615 case eArgRepeatPairPlain:
616 case eArgRepeatPairOptional:
617 case eArgRepeatPairPlus:
618 case eArgRepeatPairStar:
619 case eArgRepeatPairRange:
620 case eArgRepeatPairRangeOptional:
621 // These should not be hit, as they should pass the IsPairType test
622 // above, and control should have gone into the other branch of the if
623 // statement.
624 break;
625 }
626 }
627 }
628 }
629
630 CommandArgumentType
LookupArgumentName(llvm::StringRef arg_name)631 CommandObject::LookupArgumentName(llvm::StringRef arg_name) {
632 CommandArgumentType return_type = eArgTypeLastArg;
633
634 arg_name = arg_name.ltrim('<').rtrim('>');
635
636 for (int i = 0; i < eArgTypeLastArg; ++i)
637 if (arg_name == g_argument_table[i].arg_name)
638 return_type = g_argument_table[i].arg_type;
639
640 return return_type;
641 }
642
FormatLongHelpText(Stream & output_strm,llvm::StringRef long_help)643 void CommandObject::FormatLongHelpText(Stream &output_strm,
644 llvm::StringRef long_help) {
645 CommandInterpreter &interpreter = GetCommandInterpreter();
646 std::stringstream lineStream{std::string(long_help)};
647 std::string line;
648 while (std::getline(lineStream, line)) {
649 if (line.empty()) {
650 output_strm << "\n";
651 continue;
652 }
653 size_t result = line.find_first_not_of(" \t");
654 if (result == std::string::npos) {
655 result = 0;
656 }
657 std::string whitespace_prefix = line.substr(0, result);
658 std::string remainder = line.substr(result);
659 interpreter.OutputFormattedHelpText(output_strm, whitespace_prefix,
660 remainder);
661 }
662 }
663
GenerateHelpText(CommandReturnObject & result)664 void CommandObject::GenerateHelpText(CommandReturnObject &result) {
665 GenerateHelpText(result.GetOutputStream());
666
667 result.SetStatus(eReturnStatusSuccessFinishNoResult);
668 }
669
GenerateHelpText(Stream & output_strm)670 void CommandObject::GenerateHelpText(Stream &output_strm) {
671 CommandInterpreter &interpreter = GetCommandInterpreter();
672 std::string help_text(GetHelp());
673 if (WantsRawCommandString()) {
674 help_text.append(" Expects 'raw' input (see 'help raw-input'.)");
675 }
676 interpreter.OutputFormattedHelpText(output_strm, "", help_text);
677 output_strm << "\nSyntax: " << GetSyntax() << "\n";
678 Options *options = GetOptions();
679 if (options != nullptr) {
680 options->GenerateOptionUsage(
681 output_strm, *this,
682 GetCommandInterpreter().GetDebugger().GetTerminalWidth());
683 }
684 llvm::StringRef long_help = GetHelpLong();
685 if (!long_help.empty()) {
686 FormatLongHelpText(output_strm, long_help);
687 }
688 if (!IsDashDashCommand() && options && options->NumCommandOptions() > 0) {
689 if (WantsRawCommandString() && !WantsCompletion()) {
690 // Emit the message about using ' -- ' between the end of the command
691 // options and the raw input conditionally, i.e., only if the command
692 // object does not want completion.
693 interpreter.OutputFormattedHelpText(
694 output_strm, "", "",
695 "\nImportant Note: Because this command takes 'raw' input, if you "
696 "use any command options"
697 " you must use ' -- ' between the end of the command options and the "
698 "beginning of the raw input.",
699 1);
700 } else if (GetNumArgumentEntries() > 0) {
701 // Also emit a warning about using "--" in case you are using a command
702 // that takes options and arguments.
703 interpreter.OutputFormattedHelpText(
704 output_strm, "", "",
705 "\nThis command takes options and free-form arguments. If your "
706 "arguments resemble"
707 " option specifiers (i.e., they start with a - or --), you must use "
708 "' -- ' between"
709 " the end of the command options and the beginning of the arguments.",
710 1);
711 }
712 }
713 }
714
AddIDsArgumentData(CommandObject::IDType type)715 void CommandObject::AddIDsArgumentData(CommandObject::IDType type) {
716 CommandArgumentEntry arg;
717 CommandArgumentData id_arg;
718 CommandArgumentData id_range_arg;
719
720 // Create the first variant for the first (and only) argument for this
721 // command.
722 switch (type) {
723 case eBreakpointArgs:
724 id_arg.arg_type = eArgTypeBreakpointID;
725 id_range_arg.arg_type = eArgTypeBreakpointIDRange;
726 break;
727 case eWatchpointArgs:
728 id_arg.arg_type = eArgTypeWatchpointID;
729 id_range_arg.arg_type = eArgTypeWatchpointIDRange;
730 break;
731 }
732 id_arg.arg_repetition = eArgRepeatOptional;
733 id_range_arg.arg_repetition = eArgRepeatOptional;
734
735 // The first (and only) argument for this command could be either an id or an
736 // id_range. Push both variants into the entry for the first argument for
737 // this command.
738 arg.push_back(id_arg);
739 arg.push_back(id_range_arg);
740 m_arguments.push_back(arg);
741 }
742
GetArgumentTypeAsCString(const lldb::CommandArgumentType arg_type)743 const char *CommandObject::GetArgumentTypeAsCString(
744 const lldb::CommandArgumentType arg_type) {
745 assert(arg_type < eArgTypeLastArg &&
746 "Invalid argument type passed to GetArgumentTypeAsCString");
747 return g_argument_table[arg_type].arg_name;
748 }
749
GetArgumentDescriptionAsCString(const lldb::CommandArgumentType arg_type)750 const char *CommandObject::GetArgumentDescriptionAsCString(
751 const lldb::CommandArgumentType arg_type) {
752 assert(arg_type < eArgTypeLastArg &&
753 "Invalid argument type passed to GetArgumentDescriptionAsCString");
754 return g_argument_table[arg_type].help_text;
755 }
756
GetDummyTarget()757 Target &CommandObject::GetDummyTarget() {
758 return m_interpreter.GetDebugger().GetDummyTarget();
759 }
760
GetSelectedOrDummyTarget(bool prefer_dummy)761 Target &CommandObject::GetSelectedOrDummyTarget(bool prefer_dummy) {
762 return m_interpreter.GetDebugger().GetSelectedOrDummyTarget(prefer_dummy);
763 }
764
GetSelectedTarget()765 Target &CommandObject::GetSelectedTarget() {
766 assert(m_flags.AnySet(eCommandRequiresTarget | eCommandProcessMustBePaused |
767 eCommandProcessMustBeLaunched | eCommandRequiresFrame |
768 eCommandRequiresThread | eCommandRequiresProcess |
769 eCommandRequiresRegContext) &&
770 "GetSelectedTarget called from object that may have no target");
771 return *m_interpreter.GetDebugger().GetSelectedTarget();
772 }
773
GetDefaultThread()774 Thread *CommandObject::GetDefaultThread() {
775 Thread *thread_to_use = m_exe_ctx.GetThreadPtr();
776 if (thread_to_use)
777 return thread_to_use;
778
779 Process *process = m_exe_ctx.GetProcessPtr();
780 if (!process) {
781 Target *target = m_exe_ctx.GetTargetPtr();
782 if (!target) {
783 target = m_interpreter.GetDebugger().GetSelectedTarget().get();
784 }
785 if (target)
786 process = target->GetProcessSP().get();
787 }
788
789 if (process)
790 return process->GetThreadList().GetSelectedThread().get();
791 else
792 return nullptr;
793 }
794
Execute(const char * args_string,CommandReturnObject & result)795 void CommandObjectParsed::Execute(const char *args_string,
796 CommandReturnObject &result) {
797 bool handled = false;
798 Args cmd_args(args_string);
799 if (HasOverrideCallback()) {
800 Args full_args(GetCommandName());
801 full_args.AppendArguments(cmd_args);
802 handled =
803 InvokeOverrideCallback(full_args.GetConstArgumentVector(), result);
804 }
805 if (!handled) {
806 for (auto entry : llvm::enumerate(cmd_args.entries())) {
807 const Args::ArgEntry &value = entry.value();
808 if (!value.ref().empty() && value.GetQuoteChar() == '`') {
809 // We have to put the backtick back in place for PreprocessCommand.
810 std::string opt_string = value.c_str();
811 Status error;
812 error = m_interpreter.PreprocessToken(opt_string);
813 if (error.Success())
814 cmd_args.ReplaceArgumentAtIndex(entry.index(), opt_string);
815 }
816 }
817
818 if (CheckRequirements(result)) {
819 if (ParseOptions(cmd_args, result)) {
820 // Call the command-specific version of 'Execute', passing it the
821 // already processed arguments.
822 if (cmd_args.GetArgumentCount() != 0 && m_arguments.empty()) {
823 result.AppendErrorWithFormatv("'{0}' doesn't take any arguments.",
824 GetCommandName());
825 Cleanup();
826 return;
827 }
828 m_interpreter.IncreaseCommandUsage(*this);
829 DoExecute(cmd_args, result);
830 }
831 }
832
833 Cleanup();
834 }
835 }
836
Execute(const char * args_string,CommandReturnObject & result)837 void CommandObjectRaw::Execute(const char *args_string,
838 CommandReturnObject &result) {
839 bool handled = false;
840 if (HasOverrideCallback()) {
841 std::string full_command(GetCommandName());
842 full_command += ' ';
843 full_command += args_string;
844 const char *argv[2] = {nullptr, nullptr};
845 argv[0] = full_command.c_str();
846 handled = InvokeOverrideCallback(argv, result);
847 }
848 if (!handled) {
849 if (CheckRequirements(result))
850 DoExecute(args_string, result);
851
852 Cleanup();
853 }
854 }
855