Bug Summary

File:tools/lldb/source/Interpreter/CommandInterpreter.cpp
Warning:line 1734, column 9
Value stored to 'num_command_matches' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CommandInterpreter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lldb/source/Interpreter -I /build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lldb/source/Interpreter -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp -faddrsig
1//===-- CommandInterpreter.cpp ----------------------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include <stdlib.h>
11#include <string>
12#include <vector>
13
14#include "CommandObjectScript.h"
15#include "lldb/Interpreter/CommandObjectRegexCommand.h"
16
17#include "Commands/CommandObjectApropos.h"
18#include "Commands/CommandObjectBreakpoint.h"
19#include "Commands/CommandObjectBugreport.h"
20#include "Commands/CommandObjectCommands.h"
21#include "Commands/CommandObjectDisassemble.h"
22#include "Commands/CommandObjectExpression.h"
23#include "Commands/CommandObjectFrame.h"
24#include "Commands/CommandObjectGUI.h"
25#include "Commands/CommandObjectHelp.h"
26#include "Commands/CommandObjectLanguage.h"
27#include "Commands/CommandObjectLog.h"
28#include "Commands/CommandObjectMemory.h"
29#include "Commands/CommandObjectPlatform.h"
30#include "Commands/CommandObjectPlugin.h"
31#include "Commands/CommandObjectProcess.h"
32#include "Commands/CommandObjectQuit.h"
33#include "Commands/CommandObjectRegister.h"
34#include "Commands/CommandObjectSettings.h"
35#include "Commands/CommandObjectSource.h"
36#include "Commands/CommandObjectStats.h"
37#include "Commands/CommandObjectTarget.h"
38#include "Commands/CommandObjectThread.h"
39#include "Commands/CommandObjectType.h"
40#include "Commands/CommandObjectVersion.h"
41#include "Commands/CommandObjectWatchpoint.h"
42
43#include "lldb/Core/Debugger.h"
44#include "lldb/Core/PluginManager.h"
45#include "lldb/Core/State.h"
46#include "lldb/Core/StreamFile.h"
47#include "lldb/Utility/Log.h"
48#include "lldb/Utility/Stream.h"
49#include "lldb/Utility/Timer.h"
50
51#ifndef LLDB_DISABLE_LIBEDIT
52#include "lldb/Host/Editline.h"
53#endif
54#include "lldb/Host/Host.h"
55#include "lldb/Host/HostInfo.h"
56
57#include "lldb/Interpreter/CommandCompletions.h"
58#include "lldb/Interpreter/CommandInterpreter.h"
59#include "lldb/Interpreter/CommandReturnObject.h"
60#include "lldb/Interpreter/OptionValueProperties.h"
61#include "lldb/Interpreter/Options.h"
62#include "lldb/Interpreter/Property.h"
63#include "lldb/Utility/Args.h"
64
65#include "lldb/Target/Process.h"
66#include "lldb/Target/TargetList.h"
67#include "lldb/Target/Thread.h"
68
69#include "llvm/ADT/STLExtras.h"
70#include "llvm/ADT/SmallString.h"
71#include "llvm/Support/Path.h"
72#include "llvm/Support/PrettyStackTrace.h"
73
74using namespace lldb;
75using namespace lldb_private;
76
77static const char *k_white_space = " \t\v";
78
79static PropertyDefinition g_properties[] = {
80 {"expand-regex-aliases", OptionValue::eTypeBoolean, true, false, nullptr,
81 nullptr, "If true, regular expression alias commands will show the "
82 "expanded command that will be executed. This can be used to "
83 "debug new regular expression alias commands."},
84 {"prompt-on-quit", OptionValue::eTypeBoolean, true, true, nullptr, nullptr,
85 "If true, LLDB will prompt you before quitting if there are any live "
86 "processes being debugged. If false, LLDB will quit without asking in any "
87 "case."},
88 {"stop-command-source-on-error", OptionValue::eTypeBoolean, true, true,
89 nullptr, nullptr, "If true, LLDB will stop running a 'command source' "
90 "script upon encountering an error."},
91 {"space-repl-prompts", OptionValue::eTypeBoolean, true, false, nullptr,
92 nullptr,
93 "If true, blank lines will be printed between between REPL submissions."},
94 {nullptr, OptionValue::eTypeInvalid, true, 0, nullptr, nullptr, nullptr}};
95
96enum {
97 ePropertyExpandRegexAliases = 0,
98 ePropertyPromptOnQuit = 1,
99 ePropertyStopCmdSourceOnError = 2,
100 eSpaceReplPrompts = 3
101};
102
103ConstString &CommandInterpreter::GetStaticBroadcasterClass() {
104 static ConstString class_name("lldb.commandInterpreter");
105 return class_name;
106}
107
108CommandInterpreter::CommandInterpreter(Debugger &debugger,
109 ScriptLanguage script_language,
110 bool synchronous_execution)
111 : Broadcaster(debugger.GetBroadcasterManager(),
112 CommandInterpreter::GetStaticBroadcasterClass().AsCString()),
113 Properties(OptionValuePropertiesSP(
114 new OptionValueProperties(ConstString("interpreter")))),
115 IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand),
116 m_debugger(debugger), m_synchronous_execution(synchronous_execution),
117 m_skip_lldbinit_files(false), m_skip_app_init_files(false),
118 m_script_interpreter_sp(), m_command_io_handler_sp(), m_comment_char('#'),
119 m_batch_command_mode(false), m_truncation_warning(eNoTruncation),
120 m_command_source_depth(0), m_num_errors(0), m_quit_requested(false),
121 m_stopped_for_crash(false) {
122 debugger.SetScriptLanguage(script_language);
123 SetEventName(eBroadcastBitThreadShouldExit, "thread-should-exit");
124 SetEventName(eBroadcastBitResetPrompt, "reset-prompt");
125 SetEventName(eBroadcastBitQuitCommandReceived, "quit");
126 CheckInWithManager();
127 m_collection_sp->Initialize(g_properties);
128}
129
130bool CommandInterpreter::GetExpandRegexAliases() const {
131 const uint32_t idx = ePropertyExpandRegexAliases;
132 return m_collection_sp->GetPropertyAtIndexAsBoolean(
133 nullptr, idx, g_properties[idx].default_uint_value != 0);
134}
135
136bool CommandInterpreter::GetPromptOnQuit() const {
137 const uint32_t idx = ePropertyPromptOnQuit;
138 return m_collection_sp->GetPropertyAtIndexAsBoolean(
139 nullptr, idx, g_properties[idx].default_uint_value != 0);
140}
141
142void CommandInterpreter::SetPromptOnQuit(bool b) {
143 const uint32_t idx = ePropertyPromptOnQuit;
144 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
145}
146
147void CommandInterpreter::AllowExitCodeOnQuit(bool allow) {
148 m_allow_exit_code = allow;
149 if (!allow)
150 m_quit_exit_code.reset();
151}
152
153bool CommandInterpreter::SetQuitExitCode(int exit_code) {
154 if (!m_allow_exit_code)
155 return false;
156 m_quit_exit_code = exit_code;
157 return true;
158}
159
160int CommandInterpreter::GetQuitExitCode(bool &exited) const {
161 exited = m_quit_exit_code.hasValue();
162 if (exited)
163 return *m_quit_exit_code;
164 return 0;
165}
166
167void CommandInterpreter::ResolveCommand(const char *command_line,
168 CommandReturnObject &result) {
169 std::string command = command_line;
170 if (ResolveCommandImpl(command, result) != nullptr) {
171 result.AppendMessageWithFormat("%s", command.c_str());
172 result.SetStatus(eReturnStatusSuccessFinishResult);
173 }
174}
175
176bool CommandInterpreter::GetStopCmdSourceOnError() const {
177 const uint32_t idx = ePropertyStopCmdSourceOnError;
178 return m_collection_sp->GetPropertyAtIndexAsBoolean(
179 nullptr, idx, g_properties[idx].default_uint_value != 0);
180}
181
182bool CommandInterpreter::GetSpaceReplPrompts() const {
183 const uint32_t idx = eSpaceReplPrompts;
184 return m_collection_sp->GetPropertyAtIndexAsBoolean(
185 nullptr, idx, g_properties[idx].default_uint_value != 0);
186}
187
188void CommandInterpreter::Initialize() {
189 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
190 Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
191
192 CommandReturnObject result;
193
194 LoadCommandDictionary();
195
196 // An alias arguments vector to reuse - reset it before use...
197 OptionArgVectorSP alias_arguments_vector_sp(new OptionArgVector);
198
199 // Set up some initial aliases.
200 CommandObjectSP cmd_obj_sp = GetCommandSPExact("quit", false);
201 if (cmd_obj_sp) {
202 AddAlias("q", cmd_obj_sp);
203 AddAlias("exit", cmd_obj_sp);
204 }
205
206 cmd_obj_sp = GetCommandSPExact("_regexp-attach", false);
207 if (cmd_obj_sp)
208 AddAlias("attach", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
209
210 cmd_obj_sp = GetCommandSPExact("process detach", false);
211 if (cmd_obj_sp) {
212 AddAlias("detach", cmd_obj_sp);
213 }
214
215 cmd_obj_sp = GetCommandSPExact("process continue", false);
216 if (cmd_obj_sp) {
217 AddAlias("c", cmd_obj_sp);
218 AddAlias("continue", cmd_obj_sp);
219 }
220
221 cmd_obj_sp = GetCommandSPExact("_regexp-break", false);
222 if (cmd_obj_sp)
223 AddAlias("b", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
224
225 cmd_obj_sp = GetCommandSPExact("_regexp-tbreak", false);
226 if (cmd_obj_sp)
227 AddAlias("tbreak", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
228
229 cmd_obj_sp = GetCommandSPExact("thread step-inst", false);
230 if (cmd_obj_sp) {
231 AddAlias("stepi", cmd_obj_sp);
232 AddAlias("si", cmd_obj_sp);
233 }
234
235 cmd_obj_sp = GetCommandSPExact("thread step-inst-over", false);
236 if (cmd_obj_sp) {
237 AddAlias("nexti", cmd_obj_sp);
238 AddAlias("ni", cmd_obj_sp);
239 }
240
241 cmd_obj_sp = GetCommandSPExact("thread step-in", false);
242 if (cmd_obj_sp) {
243 AddAlias("s", cmd_obj_sp);
244 AddAlias("step", cmd_obj_sp);
245 CommandAlias *sif_alias = AddAlias(
246 "sif", cmd_obj_sp, "--end-linenumber block --step-in-target %1");
247 if (sif_alias) {
248 sif_alias->SetHelp("Step through the current block, stopping if you step "
249 "directly into a function whose name matches the "
250 "TargetFunctionName.");
251 sif_alias->SetSyntax("sif <TargetFunctionName>");
252 }
253 }
254
255 cmd_obj_sp = GetCommandSPExact("thread step-over", false);
256 if (cmd_obj_sp) {
257 AddAlias("n", cmd_obj_sp);
258 AddAlias("next", cmd_obj_sp);
259 }
260
261 cmd_obj_sp = GetCommandSPExact("thread step-out", false);
262 if (cmd_obj_sp) {
263 AddAlias("finish", cmd_obj_sp);
264 }
265
266 cmd_obj_sp = GetCommandSPExact("frame select", false);
267 if (cmd_obj_sp) {
268 AddAlias("f", cmd_obj_sp);
269 }
270
271 cmd_obj_sp = GetCommandSPExact("thread select", false);
272 if (cmd_obj_sp) {
273 AddAlias("t", cmd_obj_sp);
274 }
275
276 cmd_obj_sp = GetCommandSPExact("_regexp-jump", false);
277 if (cmd_obj_sp) {
278 AddAlias("j", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
279 AddAlias("jump", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
280 }
281
282 cmd_obj_sp = GetCommandSPExact("_regexp-list", false);
283 if (cmd_obj_sp) {
284 AddAlias("l", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
285 AddAlias("list", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
286 }
287
288 cmd_obj_sp = GetCommandSPExact("_regexp-env", false);
289 if (cmd_obj_sp)
290 AddAlias("env", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
291
292 cmd_obj_sp = GetCommandSPExact("memory read", false);
293 if (cmd_obj_sp)
294 AddAlias("x", cmd_obj_sp);
295
296 cmd_obj_sp = GetCommandSPExact("_regexp-up", false);
297 if (cmd_obj_sp)
298 AddAlias("up", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
299
300 cmd_obj_sp = GetCommandSPExact("_regexp-down", false);
301 if (cmd_obj_sp)
302 AddAlias("down", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
303
304 cmd_obj_sp = GetCommandSPExact("_regexp-display", false);
305 if (cmd_obj_sp)
306 AddAlias("display", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
307
308 cmd_obj_sp = GetCommandSPExact("disassemble", false);
309 if (cmd_obj_sp)
310 AddAlias("dis", cmd_obj_sp);
311
312 cmd_obj_sp = GetCommandSPExact("disassemble", false);
313 if (cmd_obj_sp)
314 AddAlias("di", cmd_obj_sp);
315
316 cmd_obj_sp = GetCommandSPExact("_regexp-undisplay", false);
317 if (cmd_obj_sp)
318 AddAlias("undisplay", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
319
320 cmd_obj_sp = GetCommandSPExact("_regexp-bt", false);
321 if (cmd_obj_sp)
322 AddAlias("bt", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
323
324 cmd_obj_sp = GetCommandSPExact("target create", false);
325 if (cmd_obj_sp)
326 AddAlias("file", cmd_obj_sp);
327
328 cmd_obj_sp = GetCommandSPExact("target modules", false);
329 if (cmd_obj_sp)
330 AddAlias("image", cmd_obj_sp);
331
332 alias_arguments_vector_sp.reset(new OptionArgVector);
333
334 cmd_obj_sp = GetCommandSPExact("expression", false);
335 if (cmd_obj_sp) {
336 AddAlias("p", cmd_obj_sp, "--")->SetHelpLong("");
337 AddAlias("print", cmd_obj_sp, "--")->SetHelpLong("");
338 AddAlias("call", cmd_obj_sp, "--")->SetHelpLong("");
339 if (auto po = AddAlias("po", cmd_obj_sp, "-O --")) {
340 po->SetHelp("Evaluate an expression on the current thread. Displays any "
341 "returned value with formatting "
342 "controlled by the type's author.");
343 po->SetHelpLong("");
344 }
345 AddAlias("parray", cmd_obj_sp, "--element-count %1 --")->SetHelpLong("");
346 AddAlias("poarray", cmd_obj_sp,
347 "--object-description --element-count %1 --")
348 ->SetHelpLong("");
349 }
350
351 cmd_obj_sp = GetCommandSPExact("process kill", false);
352 if (cmd_obj_sp) {
353 AddAlias("kill", cmd_obj_sp);
354 }
355
356 cmd_obj_sp = GetCommandSPExact("process launch", false);
357 if (cmd_obj_sp) {
358 alias_arguments_vector_sp.reset(new OptionArgVector);
359#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
360 AddAlias("r", cmd_obj_sp, "--");
361 AddAlias("run", cmd_obj_sp, "--");
362#else
363#if defined(__APPLE__)
364 std::string shell_option;
365 shell_option.append("--shell-expand-args");
366 shell_option.append(" true");
367 shell_option.append(" --");
368 AddAlias("r", cmd_obj_sp, "--shell-expand-args true --");
369 AddAlias("run", cmd_obj_sp, "--shell-expand-args true --");
370#else
371 StreamString defaultshell;
372 defaultshell.Printf("--shell=%s --",
373 HostInfo::GetDefaultShell().GetPath().c_str());
374 AddAlias("r", cmd_obj_sp, defaultshell.GetString());
375 AddAlias("run", cmd_obj_sp, defaultshell.GetString());
376#endif
377#endif
378 }
379
380 cmd_obj_sp = GetCommandSPExact("target symbols add", false);
381 if (cmd_obj_sp) {
382 AddAlias("add-dsym", cmd_obj_sp);
383 }
384
385 cmd_obj_sp = GetCommandSPExact("breakpoint set", false);
386 if (cmd_obj_sp) {
387 AddAlias("rbreak", cmd_obj_sp, "--func-regex %1");
388 }
389}
390
391void CommandInterpreter::Clear() {
392 m_command_io_handler_sp.reset();
393
394 if (m_script_interpreter_sp)
395 m_script_interpreter_sp->Clear();
396}
397
398const char *CommandInterpreter::ProcessEmbeddedScriptCommands(const char *arg) {
399 // This function has not yet been implemented.
400
401 // Look for any embedded script command
402 // If found,
403 // get interpreter object from the command dictionary,
404 // call execute_one_command on it,
405 // get the results as a string,
406 // substitute that string for current stuff.
407
408 return arg;
409}
410
411void CommandInterpreter::LoadCommandDictionary() {
412 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
413 Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
414
415 lldb::ScriptLanguage script_language = m_debugger.GetScriptLanguage();
416
417 m_command_dict["apropos"] = CommandObjectSP(new CommandObjectApropos(*this));
418 m_command_dict["breakpoint"] =
419 CommandObjectSP(new CommandObjectMultiwordBreakpoint(*this));
420 m_command_dict["bugreport"] =
421 CommandObjectSP(new CommandObjectMultiwordBugreport(*this));
422 m_command_dict["command"] =
423 CommandObjectSP(new CommandObjectMultiwordCommands(*this));
424 m_command_dict["disassemble"] =
425 CommandObjectSP(new CommandObjectDisassemble(*this));
426 m_command_dict["expression"] =
427 CommandObjectSP(new CommandObjectExpression(*this));
428 m_command_dict["frame"] =
429 CommandObjectSP(new CommandObjectMultiwordFrame(*this));
430 m_command_dict["gui"] = CommandObjectSP(new CommandObjectGUI(*this));
431 m_command_dict["help"] = CommandObjectSP(new CommandObjectHelp(*this));
432 m_command_dict["log"] = CommandObjectSP(new CommandObjectLog(*this));
433 m_command_dict["memory"] = CommandObjectSP(new CommandObjectMemory(*this));
434 m_command_dict["platform"] =
435 CommandObjectSP(new CommandObjectPlatform(*this));
436 m_command_dict["plugin"] = CommandObjectSP(new CommandObjectPlugin(*this));
437 m_command_dict["process"] =
438 CommandObjectSP(new CommandObjectMultiwordProcess(*this));
439 m_command_dict["quit"] = CommandObjectSP(new CommandObjectQuit(*this));
440 m_command_dict["register"] =
441 CommandObjectSP(new CommandObjectRegister(*this));
442 m_command_dict["script"] =
443 CommandObjectSP(new CommandObjectScript(*this, script_language));
444 m_command_dict["settings"] =
445 CommandObjectSP(new CommandObjectMultiwordSettings(*this));
446 m_command_dict["source"] =
447 CommandObjectSP(new CommandObjectMultiwordSource(*this));
448 m_command_dict["statistics"] = CommandObjectSP(new CommandObjectStats(*this));
449 m_command_dict["target"] =
450 CommandObjectSP(new CommandObjectMultiwordTarget(*this));
451 m_command_dict["thread"] =
452 CommandObjectSP(new CommandObjectMultiwordThread(*this));
453 m_command_dict["type"] = CommandObjectSP(new CommandObjectType(*this));
454 m_command_dict["version"] = CommandObjectSP(new CommandObjectVersion(*this));
455 m_command_dict["watchpoint"] =
456 CommandObjectSP(new CommandObjectMultiwordWatchpoint(*this));
457 m_command_dict["language"] =
458 CommandObjectSP(new CommandObjectLanguage(*this));
459
460 const char *break_regexes[][2] = {
461 {"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$",
462 "breakpoint set --file '%1' --line %2"},
463 {"^/([^/]+)/$", "breakpoint set --source-pattern-regexp '%1'"},
464 {"^([[:digit:]]+)[[:space:]]*$", "breakpoint set --line %1"},
465 {"^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "breakpoint set --address %1"},
466 {"^[\"']?([-+]?\\[.*\\])[\"']?[[:space:]]*$",
467 "breakpoint set --name '%1'"},
468 {"^(-.*)$", "breakpoint set %1"},
469 {"^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$",
470 "breakpoint set --name '%2' --shlib '%1'"},
471 {"^\\&(.*[^[:space:]])[[:space:]]*$",
472 "breakpoint set --name '%1' --skip-prologue=0"},
473 {"^[\"']?(.*[^[:space:]\"'])[\"']?[[:space:]]*$",
474 "breakpoint set --name '%1'"}};
475
476 size_t num_regexes = llvm::array_lengthof(break_regexes);
477
478 std::unique_ptr<CommandObjectRegexCommand> break_regex_cmd_ap(
479 new CommandObjectRegexCommand(
480 *this, "_regexp-break",
481 "Set a breakpoint using one of several shorthand formats.\n",
482 "\n"
483 "_regexp-break <filename>:<linenum>\n"
484 " main.c:12 // Break at line 12 of "
485 "main.c\n\n"
486 "_regexp-break <linenum>\n"
487 " 12 // Break at line 12 of current "
488 "file\n\n"
489 "_regexp-break 0x<address>\n"
490 " 0x1234000 // Break at address "
491 "0x1234000\n\n"
492 "_regexp-break <name>\n"
493 " main // Break in 'main' after the "
494 "prologue\n\n"
495 "_regexp-break &<name>\n"
496 " &main // Break at first instruction "
497 "in 'main'\n\n"
498 "_regexp-break <module>`<name>\n"
499 " libc.so`malloc // Break in 'malloc' from "
500 "'libc.so'\n\n"
501 "_regexp-break /<source-regex>/\n"
502 " /break here/ // Break on source lines in "
503 "current file\n"
504 " // containing text 'break "
505 "here'.\n",
506 2, CommandCompletions::eSymbolCompletion |
507 CommandCompletions::eSourceFileCompletion,
508 false));
509
510 if (break_regex_cmd_ap.get()) {
511 bool success = true;
512 for (size_t i = 0; i < num_regexes; i++) {
513 success = break_regex_cmd_ap->AddRegexCommand(break_regexes[i][0],
514 break_regexes[i][1]);
515 if (!success)
516 break;
517 }
518 success =
519 break_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full");
520
521 if (success) {
522 CommandObjectSP break_regex_cmd_sp(break_regex_cmd_ap.release());
523 m_command_dict[break_regex_cmd_sp->GetCommandName()] = break_regex_cmd_sp;
524 }
525 }
526
527 std::unique_ptr<CommandObjectRegexCommand> tbreak_regex_cmd_ap(
528 new CommandObjectRegexCommand(
529 *this, "_regexp-tbreak",
530 "Set a one-shot breakpoint using one of several shorthand formats.\n",
531 "\n"
532 "_regexp-break <filename>:<linenum>\n"
533 " main.c:12 // Break at line 12 of "
534 "main.c\n\n"
535 "_regexp-break <linenum>\n"
536 " 12 // Break at line 12 of current "
537 "file\n\n"
538 "_regexp-break 0x<address>\n"
539 " 0x1234000 // Break at address "
540 "0x1234000\n\n"
541 "_regexp-break <name>\n"
542 " main // Break in 'main' after the "
543 "prologue\n\n"
544 "_regexp-break &<name>\n"
545 " &main // Break at first instruction "
546 "in 'main'\n\n"
547 "_regexp-break <module>`<name>\n"
548 " libc.so`malloc // Break in 'malloc' from "
549 "'libc.so'\n\n"
550 "_regexp-break /<source-regex>/\n"
551 " /break here/ // Break on source lines in "
552 "current file\n"
553 " // containing text 'break "
554 "here'.\n",
555 2, CommandCompletions::eSymbolCompletion |
556 CommandCompletions::eSourceFileCompletion,
557 false));
558
559 if (tbreak_regex_cmd_ap.get()) {
560 bool success = true;
561 for (size_t i = 0; i < num_regexes; i++) {
562 // If you add a resultant command string longer than 1024 characters be
563 // sure to increase the size of this buffer.
564 char buffer[1024];
565 int num_printed =
566 snprintf(buffer, 1024, "%s %s", break_regexes[i][1], "-o 1");
567 lldbassert(num_printed < 1024)lldb_private::lldb_assert(num_printed < 1024, "num_printed < 1024"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 567)
;
568 UNUSED_IF_ASSERT_DISABLED(num_printed)((void)(num_printed));
569 success =
570 tbreak_regex_cmd_ap->AddRegexCommand(break_regexes[i][0], buffer);
571 if (!success)
572 break;
573 }
574 success =
575 tbreak_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full");
576
577 if (success) {
578 CommandObjectSP tbreak_regex_cmd_sp(tbreak_regex_cmd_ap.release());
579 m_command_dict[tbreak_regex_cmd_sp->GetCommandName()] =
580 tbreak_regex_cmd_sp;
581 }
582 }
583
584 std::unique_ptr<CommandObjectRegexCommand> attach_regex_cmd_ap(
585 new CommandObjectRegexCommand(
586 *this, "_regexp-attach", "Attach to process by ID or name.",
587 "_regexp-attach <pid> | <process-name>", 2, 0, false));
588 if (attach_regex_cmd_ap.get()) {
589 if (attach_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$",
590 "process attach --pid %1") &&
591 attach_regex_cmd_ap->AddRegexCommand(
592 "^(-.*|.* -.*)$", "process attach %1") && // Any options that are
593 // specified get passed to
594 // 'process attach'
595 attach_regex_cmd_ap->AddRegexCommand("^(.+)$",
596 "process attach --name '%1'") &&
597 attach_regex_cmd_ap->AddRegexCommand("^$", "process attach")) {
598 CommandObjectSP attach_regex_cmd_sp(attach_regex_cmd_ap.release());
599 m_command_dict[attach_regex_cmd_sp->GetCommandName()] =
600 attach_regex_cmd_sp;
601 }
602 }
603
604 std::unique_ptr<CommandObjectRegexCommand> down_regex_cmd_ap(
605 new CommandObjectRegexCommand(*this, "_regexp-down",
606 "Select a newer stack frame. Defaults to "
607 "moving one frame, a numeric argument can "
608 "specify an arbitrary number.",
609 "_regexp-down [<count>]", 2, 0, false));
610 if (down_regex_cmd_ap.get()) {
611 if (down_regex_cmd_ap->AddRegexCommand("^$", "frame select -r -1") &&
612 down_regex_cmd_ap->AddRegexCommand("^([0-9]+)$",
613 "frame select -r -%1")) {
614 CommandObjectSP down_regex_cmd_sp(down_regex_cmd_ap.release());
615 m_command_dict[down_regex_cmd_sp->GetCommandName()] = down_regex_cmd_sp;
616 }
617 }
618
619 std::unique_ptr<CommandObjectRegexCommand> up_regex_cmd_ap(
620 new CommandObjectRegexCommand(
621 *this, "_regexp-up",
622 "Select an older stack frame. Defaults to moving one "
623 "frame, a numeric argument can specify an arbitrary number.",
624 "_regexp-up [<count>]", 2, 0, false));
625 if (up_regex_cmd_ap.get()) {
626 if (up_regex_cmd_ap->AddRegexCommand("^$", "frame select -r 1") &&
627 up_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r %1")) {
628 CommandObjectSP up_regex_cmd_sp(up_regex_cmd_ap.release());
629 m_command_dict[up_regex_cmd_sp->GetCommandName()] = up_regex_cmd_sp;
630 }
631 }
632
633 std::unique_ptr<CommandObjectRegexCommand> display_regex_cmd_ap(
634 new CommandObjectRegexCommand(
635 *this, "_regexp-display",
636 "Evaluate an expression at every stop (see 'help target stop-hook'.)",
637 "_regexp-display expression", 2, 0, false));
638 if (display_regex_cmd_ap.get()) {
639 if (display_regex_cmd_ap->AddRegexCommand(
640 "^(.+)$", "target stop-hook add -o \"expr -- %1\"")) {
641 CommandObjectSP display_regex_cmd_sp(display_regex_cmd_ap.release());
642 m_command_dict[display_regex_cmd_sp->GetCommandName()] =
643 display_regex_cmd_sp;
644 }
645 }
646
647 std::unique_ptr<CommandObjectRegexCommand> undisplay_regex_cmd_ap(
648 new CommandObjectRegexCommand(
649 *this, "_regexp-undisplay", "Stop displaying expression at every "
650 "stop (specified by stop-hook index.)",
651 "_regexp-undisplay stop-hook-number", 2, 0, false));
652 if (undisplay_regex_cmd_ap.get()) {
653 if (undisplay_regex_cmd_ap->AddRegexCommand("^([0-9]+)$",
654 "target stop-hook delete %1")) {
655 CommandObjectSP undisplay_regex_cmd_sp(undisplay_regex_cmd_ap.release());
656 m_command_dict[undisplay_regex_cmd_sp->GetCommandName()] =
657 undisplay_regex_cmd_sp;
658 }
659 }
660
661 std::unique_ptr<CommandObjectRegexCommand> connect_gdb_remote_cmd_ap(
662 new CommandObjectRegexCommand(
663 *this, "gdb-remote", "Connect to a process via remote GDB server. "
664 "If no host is specifed, localhost is assumed.",
665 "gdb-remote [<hostname>:]<portnum>", 2, 0, false));
666 if (connect_gdb_remote_cmd_ap.get()) {
667 if (connect_gdb_remote_cmd_ap->AddRegexCommand(
668 "^([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)$",
669 "process connect --plugin gdb-remote connect://%1:%2") &&
670 connect_gdb_remote_cmd_ap->AddRegexCommand(
671 "^([[:digit:]]+)$",
672 "process connect --plugin gdb-remote connect://localhost:%1")) {
673 CommandObjectSP command_sp(connect_gdb_remote_cmd_ap.release());
674 m_command_dict[command_sp->GetCommandName()] = command_sp;
675 }
676 }
677
678 std::unique_ptr<CommandObjectRegexCommand> connect_kdp_remote_cmd_ap(
679 new CommandObjectRegexCommand(
680 *this, "kdp-remote", "Connect to a process via remote KDP server. "
681 "If no UDP port is specified, port 41139 is "
682 "assumed.",
683 "kdp-remote <hostname>[:<portnum>]", 2, 0, false));
684 if (connect_kdp_remote_cmd_ap.get()) {
685 if (connect_kdp_remote_cmd_ap->AddRegexCommand(
686 "^([^:]+:[[:digit:]]+)$",
687 "process connect --plugin kdp-remote udp://%1") &&
688 connect_kdp_remote_cmd_ap->AddRegexCommand(
689 "^(.+)$", "process connect --plugin kdp-remote udp://%1:41139")) {
690 CommandObjectSP command_sp(connect_kdp_remote_cmd_ap.release());
691 m_command_dict[command_sp->GetCommandName()] = command_sp;
692 }
693 }
694
695 std::unique_ptr<CommandObjectRegexCommand> bt_regex_cmd_ap(
696 new CommandObjectRegexCommand(
697 *this, "_regexp-bt",
698 "Show the current thread's call stack. Any numeric argument "
699 "displays at most that many "
700 "frames. The argument 'all' displays all threads.",
701 "bt [<digit> | all]", 2, 0, false));
702 if (bt_regex_cmd_ap.get()) {
703 // accept but don't document "bt -c <number>" -- before bt was a regex
704 // command if you wanted to backtrace three frames you would do "bt -c 3"
705 // but the intention is to have this emulate the gdb "bt" command and so
706 // now "bt 3" is the preferred form, in line with gdb.
707 if (bt_regex_cmd_ap->AddRegexCommand("^([[:digit:]]+)$",
708 "thread backtrace -c %1") &&
709 bt_regex_cmd_ap->AddRegexCommand("^-c ([[:digit:]]+)$",
710 "thread backtrace -c %1") &&
711 bt_regex_cmd_ap->AddRegexCommand("^all$", "thread backtrace all") &&
712 bt_regex_cmd_ap->AddRegexCommand("^$", "thread backtrace")) {
713 CommandObjectSP command_sp(bt_regex_cmd_ap.release());
714 m_command_dict[command_sp->GetCommandName()] = command_sp;
715 }
716 }
717
718 std::unique_ptr<CommandObjectRegexCommand> list_regex_cmd_ap(
719 new CommandObjectRegexCommand(
720 *this, "_regexp-list",
721 "List relevant source code using one of several shorthand formats.",
722 "\n"
723 "_regexp-list <file>:<line> // List around specific file/line\n"
724 "_regexp-list <line> // List current file around specified "
725 "line\n"
726 "_regexp-list <function-name> // List specified function\n"
727 "_regexp-list 0x<address> // List around specified address\n"
728 "_regexp-list -[<count>] // List previous <count> lines\n"
729 "_regexp-list // List subsequent lines",
730 2, CommandCompletions::eSourceFileCompletion, false));
731 if (list_regex_cmd_ap.get()) {
732 if (list_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$",
733 "source list --line %1") &&
734 list_regex_cmd_ap->AddRegexCommand(
735 "^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]"
736 "]*$",
737 "source list --file '%1' --line %2") &&
738 list_regex_cmd_ap->AddRegexCommand(
739 "^\\*?(0x[[:xdigit:]]+)[[:space:]]*$",
740 "source list --address %1") &&
741 list_regex_cmd_ap->AddRegexCommand("^-[[:space:]]*$",
742 "source list --reverse") &&
743 list_regex_cmd_ap->AddRegexCommand(
744 "^-([[:digit:]]+)[[:space:]]*$",
745 "source list --reverse --count %1") &&
746 list_regex_cmd_ap->AddRegexCommand("^(.+)$",
747 "source list --name \"%1\"") &&
748 list_regex_cmd_ap->AddRegexCommand("^$", "source list")) {
749 CommandObjectSP list_regex_cmd_sp(list_regex_cmd_ap.release());
750 m_command_dict[list_regex_cmd_sp->GetCommandName()] = list_regex_cmd_sp;
751 }
752 }
753
754 std::unique_ptr<CommandObjectRegexCommand> env_regex_cmd_ap(
755 new CommandObjectRegexCommand(
756 *this, "_regexp-env",
757 "Shorthand for viewing and setting environment variables.",
758 "\n"
759 "_regexp-env // Show enrivonment\n"
760 "_regexp-env <name>=<value> // Set an environment variable",
761 2, 0, false));
762 if (env_regex_cmd_ap.get()) {
763 if (env_regex_cmd_ap->AddRegexCommand("^$",
764 "settings show target.env-vars") &&
765 env_regex_cmd_ap->AddRegexCommand("^([A-Za-z_][A-Za-z_0-9]*=.*)$",
766 "settings set target.env-vars %1")) {
767 CommandObjectSP env_regex_cmd_sp(env_regex_cmd_ap.release());
768 m_command_dict[env_regex_cmd_sp->GetCommandName()] = env_regex_cmd_sp;
769 }
770 }
771
772 std::unique_ptr<CommandObjectRegexCommand> jump_regex_cmd_ap(
773 new CommandObjectRegexCommand(
774 *this, "_regexp-jump", "Set the program counter to a new address.",
775 "\n"
776 "_regexp-jump <line>\n"
777 "_regexp-jump +<line-offset> | -<line-offset>\n"
778 "_regexp-jump <file>:<line>\n"
779 "_regexp-jump *<addr>\n",
780 2, 0, false));
781 if (jump_regex_cmd_ap.get()) {
782 if (jump_regex_cmd_ap->AddRegexCommand("^\\*(.*)$",
783 "thread jump --addr %1") &&
784 jump_regex_cmd_ap->AddRegexCommand("^([0-9]+)$",
785 "thread jump --line %1") &&
786 jump_regex_cmd_ap->AddRegexCommand("^([^:]+):([0-9]+)$",
787 "thread jump --file %1 --line %2") &&
788 jump_regex_cmd_ap->AddRegexCommand("^([+\\-][0-9]+)$",
789 "thread jump --by %1")) {
790 CommandObjectSP jump_regex_cmd_sp(jump_regex_cmd_ap.release());
791 m_command_dict[jump_regex_cmd_sp->GetCommandName()] = jump_regex_cmd_sp;
792 }
793 }
794}
795
796int CommandInterpreter::GetCommandNamesMatchingPartialString(
797 const char *cmd_str, bool include_aliases, StringList &matches) {
798 AddNamesMatchingPartialString(m_command_dict, cmd_str, matches);
799
800 if (include_aliases) {
801 AddNamesMatchingPartialString(m_alias_dict, cmd_str, matches);
802 }
803
804 return matches.GetSize();
805}
806
807CommandObjectSP CommandInterpreter::GetCommandSP(llvm::StringRef cmd_str,
808 bool include_aliases,
809 bool exact,
810 StringList *matches) const {
811 CommandObjectSP command_sp;
812
813 std::string cmd = cmd_str;
814
815 if (HasCommands()) {
816 auto pos = m_command_dict.find(cmd);
817 if (pos != m_command_dict.end())
818 command_sp = pos->second;
819 }
820
821 if (include_aliases && HasAliases()) {
822 auto alias_pos = m_alias_dict.find(cmd);
823 if (alias_pos != m_alias_dict.end())
824 command_sp = alias_pos->second;
825 }
826
827 if (HasUserCommands()) {
828 auto pos = m_user_dict.find(cmd);
829 if (pos != m_user_dict.end())
830 command_sp = pos->second;
831 }
832
833 if (!exact && !command_sp) {
834 // We will only get into here if we didn't find any exact matches.
835
836 CommandObjectSP user_match_sp, alias_match_sp, real_match_sp;
837
838 StringList local_matches;
839 if (matches == nullptr)
840 matches = &local_matches;
841
842 unsigned int num_cmd_matches = 0;
843 unsigned int num_alias_matches = 0;
844 unsigned int num_user_matches = 0;
845
846 // Look through the command dictionaries one by one, and if we get only one
847 // match from any of them in toto, then return that, otherwise return an
848 // empty CommandObjectSP and the list of matches.
849
850 if (HasCommands()) {
851 num_cmd_matches =
852 AddNamesMatchingPartialString(m_command_dict, cmd_str, *matches);
853 }
854
855 if (num_cmd_matches == 1) {
856 cmd.assign(matches->GetStringAtIndex(0));
857 auto pos = m_command_dict.find(cmd);
858 if (pos != m_command_dict.end())
859 real_match_sp = pos->second;
860 }
861
862 if (include_aliases && HasAliases()) {
863 num_alias_matches =
864 AddNamesMatchingPartialString(m_alias_dict, cmd_str, *matches);
865 }
866
867 if (num_alias_matches == 1) {
868 cmd.assign(matches->GetStringAtIndex(num_cmd_matches));
869 auto alias_pos = m_alias_dict.find(cmd);
870 if (alias_pos != m_alias_dict.end())
871 alias_match_sp = alias_pos->second;
872 }
873
874 if (HasUserCommands()) {
875 num_user_matches =
876 AddNamesMatchingPartialString(m_user_dict, cmd_str, *matches);
877 }
878
879 if (num_user_matches == 1) {
880 cmd.assign(
881 matches->GetStringAtIndex(num_cmd_matches + num_alias_matches));
882
883 auto pos = m_user_dict.find(cmd);
884 if (pos != m_user_dict.end())
885 user_match_sp = pos->second;
886 }
887
888 // If we got exactly one match, return that, otherwise return the match
889 // list.
890
891 if (num_user_matches + num_cmd_matches + num_alias_matches == 1) {
892 if (num_cmd_matches)
893 return real_match_sp;
894 else if (num_alias_matches)
895 return alias_match_sp;
896 else
897 return user_match_sp;
898 }
899 } else if (matches && command_sp) {
900 matches->AppendString(cmd_str);
901 }
902
903 return command_sp;
904}
905
906bool CommandInterpreter::AddCommand(llvm::StringRef name,
907 const lldb::CommandObjectSP &cmd_sp,
908 bool can_replace) {
909 if (cmd_sp.get())
910 lldbassert((this == &cmd_sp->GetCommandInterpreter()) &&lldb_private::lldb_assert((this == &cmd_sp->GetCommandInterpreter
()) && "tried to add a CommandObject from a different interpreter"
, "(this == &cmd_sp->GetCommandInterpreter()) && \"tried to add a CommandObject from a different interpreter\""
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 911)
911 "tried to add a CommandObject from a different interpreter")lldb_private::lldb_assert((this == &cmd_sp->GetCommandInterpreter
()) && "tried to add a CommandObject from a different interpreter"
, "(this == &cmd_sp->GetCommandInterpreter()) && \"tried to add a CommandObject from a different interpreter\""
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 911)
;
912
913 if (name.empty())
914 return false;
915
916 std::string name_sstr(name);
917 auto name_iter = m_command_dict.find(name_sstr);
918 if (name_iter != m_command_dict.end()) {
919 if (!can_replace || !name_iter->second->IsRemovable())
920 return false;
921 name_iter->second = cmd_sp;
922 } else {
923 m_command_dict[name_sstr] = cmd_sp;
924 }
925 return true;
926}
927
928bool CommandInterpreter::AddUserCommand(llvm::StringRef name,
929 const lldb::CommandObjectSP &cmd_sp,
930 bool can_replace) {
931 if (cmd_sp.get())
932 lldbassert((this == &cmd_sp->GetCommandInterpreter()) &&lldb_private::lldb_assert((this == &cmd_sp->GetCommandInterpreter
()) && "tried to add a CommandObject from a different interpreter"
, "(this == &cmd_sp->GetCommandInterpreter()) && \"tried to add a CommandObject from a different interpreter\""
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 933)
933 "tried to add a CommandObject from a different interpreter")lldb_private::lldb_assert((this == &cmd_sp->GetCommandInterpreter
()) && "tried to add a CommandObject from a different interpreter"
, "(this == &cmd_sp->GetCommandInterpreter()) && \"tried to add a CommandObject from a different interpreter\""
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 933)
;
934
935 if (!name.empty()) {
936 // do not allow replacement of internal commands
937 if (CommandExists(name)) {
938 if (can_replace == false)
939 return false;
940 if (m_command_dict[name]->IsRemovable() == false)
941 return false;
942 }
943
944 if (UserCommandExists(name)) {
945 if (can_replace == false)
946 return false;
947 if (m_user_dict[name]->IsRemovable() == false)
948 return false;
949 }
950
951 m_user_dict[name] = cmd_sp;
952 return true;
953 }
954 return false;
955}
956
957CommandObjectSP CommandInterpreter::GetCommandSPExact(llvm::StringRef cmd_str,
958 bool include_aliases) const {
959 Args cmd_words(cmd_str); // Break up the command string into words, in case
960 // it's a multi-word command.
961 CommandObjectSP ret_val; // Possibly empty return value.
962
963 if (cmd_str.empty())
964 return ret_val;
965
966 if (cmd_words.GetArgumentCount() == 1)
967 return GetCommandSP(cmd_str, include_aliases, true, nullptr);
968 else {
969 // We have a multi-word command (seemingly), so we need to do more work.
970 // First, get the cmd_obj_sp for the first word in the command.
971 CommandObjectSP cmd_obj_sp = GetCommandSP(llvm::StringRef(cmd_words.GetArgumentAtIndex(0)),
972 include_aliases, true, nullptr);
973 if (cmd_obj_sp.get() != nullptr) {
974 // Loop through the rest of the words in the command (everything passed
975 // in was supposed to be part of a command name), and find the
976 // appropriate sub-command SP for each command word....
977 size_t end = cmd_words.GetArgumentCount();
978 for (size_t j = 1; j < end; ++j) {
979 if (cmd_obj_sp->IsMultiwordObject()) {
980 cmd_obj_sp =
981 cmd_obj_sp->GetSubcommandSP(cmd_words.GetArgumentAtIndex(j));
982 if (cmd_obj_sp.get() == nullptr)
983 // The sub-command name was invalid. Fail and return the empty
984 // 'ret_val'.
985 return ret_val;
986 } else
987 // We have more words in the command name, but we don't have a
988 // multiword object. Fail and return empty 'ret_val'.
989 return ret_val;
990 }
991 // We successfully looped through all the command words and got valid
992 // command objects for them. Assign the last object retrieved to
993 // 'ret_val'.
994 ret_val = cmd_obj_sp;
995 }
996 }
997 return ret_val;
998}
999
1000CommandObject *CommandInterpreter::GetCommandObject(llvm::StringRef cmd_str,
1001 StringList *matches) const {
1002 CommandObject *command_obj =
1003 GetCommandSP(cmd_str, false, true, matches).get();
1004
1005 // If we didn't find an exact match to the command string in the commands,
1006 // look in the aliases.
1007
1008 if (command_obj)
1009 return command_obj;
1010
1011 command_obj = GetCommandSP(cmd_str, true, true, matches).get();
1012
1013 if (command_obj)
1014 return command_obj;
1015
1016 // If there wasn't an exact match then look for an inexact one in just the
1017 // commands
1018 command_obj = GetCommandSP(cmd_str, false, false, nullptr).get();
1019
1020 // Finally, if there wasn't an inexact match among the commands, look for an
1021 // inexact match in both the commands and aliases.
1022
1023 if (command_obj) {
1024 if (matches)
1025 matches->AppendString(command_obj->GetCommandName());
1026 return command_obj;
1027 }
1028
1029 return GetCommandSP(cmd_str, true, false, matches).get();
1030}
1031
1032bool CommandInterpreter::CommandExists(llvm::StringRef cmd) const {
1033 return m_command_dict.find(cmd) != m_command_dict.end();
1034}
1035
1036bool CommandInterpreter::GetAliasFullName(llvm::StringRef cmd,
1037 std::string &full_name) const {
1038 bool exact_match = (m_alias_dict.find(cmd) != m_alias_dict.end());
1039 if (exact_match) {
1040 full_name.assign(cmd);
1041 return exact_match;
1042 } else {
1043 StringList matches;
1044 size_t num_alias_matches;
1045 num_alias_matches =
1046 AddNamesMatchingPartialString(m_alias_dict, cmd, matches);
1047 if (num_alias_matches == 1) {
1048 // Make sure this isn't shadowing a command in the regular command space:
1049 StringList regular_matches;
1050 const bool include_aliases = false;
1051 const bool exact = false;
1052 CommandObjectSP cmd_obj_sp(
1053 GetCommandSP(cmd, include_aliases, exact, &regular_matches));
1054 if (cmd_obj_sp || regular_matches.GetSize() > 0)
1055 return false;
1056 else {
1057 full_name.assign(matches.GetStringAtIndex(0));
1058 return true;
1059 }
1060 } else
1061 return false;
1062 }
1063}
1064
1065bool CommandInterpreter::AliasExists(llvm::StringRef cmd) const {
1066 return m_alias_dict.find(cmd) != m_alias_dict.end();
1067}
1068
1069bool CommandInterpreter::UserCommandExists(llvm::StringRef cmd) const {
1070 return m_user_dict.find(cmd) != m_user_dict.end();
1071}
1072
1073CommandAlias *
1074CommandInterpreter::AddAlias(llvm::StringRef alias_name,
1075 lldb::CommandObjectSP &command_obj_sp,
1076 llvm::StringRef args_string) {
1077 if (command_obj_sp.get())
1078 lldbassert((this == &command_obj_sp->GetCommandInterpreter()) &&lldb_private::lldb_assert((this == &command_obj_sp->GetCommandInterpreter
()) && "tried to add a CommandObject from a different interpreter"
, "(this == &command_obj_sp->GetCommandInterpreter()) && \"tried to add a CommandObject from a different interpreter\""
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 1079)
1079 "tried to add a CommandObject from a different interpreter")lldb_private::lldb_assert((this == &command_obj_sp->GetCommandInterpreter
()) && "tried to add a CommandObject from a different interpreter"
, "(this == &command_obj_sp->GetCommandInterpreter()) && \"tried to add a CommandObject from a different interpreter\""
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 1079)
;
1080
1081 std::unique_ptr<CommandAlias> command_alias_up(
1082 new CommandAlias(*this, command_obj_sp, args_string, alias_name));
1083
1084 if (command_alias_up && command_alias_up->IsValid()) {
1085 m_alias_dict[alias_name] = CommandObjectSP(command_alias_up.get());
1086 return command_alias_up.release();
1087 }
1088
1089 return nullptr;
1090}
1091
1092bool CommandInterpreter::RemoveAlias(llvm::StringRef alias_name) {
1093 auto pos = m_alias_dict.find(alias_name);
1094 if (pos != m_alias_dict.end()) {
1095 m_alias_dict.erase(pos);
1096 return true;
1097 }
1098 return false;
1099}
1100
1101bool CommandInterpreter::RemoveCommand(llvm::StringRef cmd) {
1102 auto pos = m_command_dict.find(cmd);
1103 if (pos != m_command_dict.end()) {
1104 if (pos->second->IsRemovable()) {
1105 // Only regular expression objects or python commands are removable
1106 m_command_dict.erase(pos);
1107 return true;
1108 }
1109 }
1110 return false;
1111}
1112bool CommandInterpreter::RemoveUser(llvm::StringRef alias_name) {
1113 CommandObject::CommandMap::iterator pos = m_user_dict.find(alias_name);
1114 if (pos != m_user_dict.end()) {
1115 m_user_dict.erase(pos);
1116 return true;
1117 }
1118 return false;
1119}
1120
1121void CommandInterpreter::GetHelp(CommandReturnObject &result,
1122 uint32_t cmd_types) {
1123 llvm::StringRef help_prologue(GetDebugger().GetIOHandlerHelpPrologue());
1124 if (!help_prologue.empty()) {
1125 OutputFormattedHelpText(result.GetOutputStream(), llvm::StringRef(),
1126 help_prologue);
1127 }
1128
1129 CommandObject::CommandMap::const_iterator pos;
1130 size_t max_len = FindLongestCommandWord(m_command_dict);
1131
1132 if ((cmd_types & eCommandTypesBuiltin) == eCommandTypesBuiltin) {
1133 result.AppendMessage("Debugger commands:");
1134 result.AppendMessage("");
1135
1136 for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos) {
1137 if (!(cmd_types & eCommandTypesHidden) &&
1138 (pos->first.compare(0, 1, "_") == 0))
1139 continue;
1140
1141 OutputFormattedHelpText(result.GetOutputStream(), pos->first, "--",
1142 pos->second->GetHelp(), max_len);
1143 }
1144 result.AppendMessage("");
1145 }
1146
1147 if (!m_alias_dict.empty() &&
1148 ((cmd_types & eCommandTypesAliases) == eCommandTypesAliases)) {
1149 result.AppendMessageWithFormat(
1150 "Current command abbreviations "
1151 "(type '%shelp command alias' for more info):\n",
1152 GetCommandPrefix());
1153 result.AppendMessage("");
1154 max_len = FindLongestCommandWord(m_alias_dict);
1155
1156 for (auto alias_pos = m_alias_dict.begin(); alias_pos != m_alias_dict.end();
1157 ++alias_pos) {
1158 OutputFormattedHelpText(result.GetOutputStream(), alias_pos->first, "--",
1159 alias_pos->second->GetHelp(), max_len);
1160 }
1161 result.AppendMessage("");
1162 }
1163
1164 if (!m_user_dict.empty() &&
1165 ((cmd_types & eCommandTypesUserDef) == eCommandTypesUserDef)) {
1166 result.AppendMessage("Current user-defined commands:");
1167 result.AppendMessage("");
1168 max_len = FindLongestCommandWord(m_user_dict);
1169 for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos) {
1170 OutputFormattedHelpText(result.GetOutputStream(), pos->first, "--",
1171 pos->second->GetHelp(), max_len);
1172 }
1173 result.AppendMessage("");
1174 }
1175
1176 result.AppendMessageWithFormat(
1177 "For more information on any command, type '%shelp <command-name>'.\n",
1178 GetCommandPrefix());
1179}
1180
1181CommandObject *CommandInterpreter::GetCommandObjectForCommand(
1182 llvm::StringRef &command_string) {
1183 // This function finds the final, lowest-level, alias-resolved command object
1184 // whose 'Execute' function will eventually be invoked by the given command
1185 // line.
1186
1187 CommandObject *cmd_obj = nullptr;
1188 size_t start = command_string.find_first_not_of(k_white_space);
1189 size_t end = 0;
1190 bool done = false;
1191 while (!done) {
1192 if (start != std::string::npos) {
1193 // Get the next word from command_string.
1194 end = command_string.find_first_of(k_white_space, start);
1195 if (end == std::string::npos)
1196 end = command_string.size();
1197 std::string cmd_word = command_string.substr(start, end - start);
1198
1199 if (cmd_obj == nullptr)
1200 // Since cmd_obj is NULL we are on our first time through this loop.
1201 // Check to see if cmd_word is a valid command or alias.
1202 cmd_obj = GetCommandObject(cmd_word);
1203 else if (cmd_obj->IsMultiwordObject()) {
1204 // Our current object is a multi-word object; see if the cmd_word is a
1205 // valid sub-command for our object.
1206 CommandObject *sub_cmd_obj =
1207 cmd_obj->GetSubcommandObject(cmd_word.c_str());
1208 if (sub_cmd_obj)
1209 cmd_obj = sub_cmd_obj;
1210 else // cmd_word was not a valid sub-command word, so we are done
1211 done = true;
1212 } else
1213 // We have a cmd_obj and it is not a multi-word object, so we are done.
1214 done = true;
1215
1216 // If we didn't find a valid command object, or our command object is not
1217 // a multi-word object, or we are at the end of the command_string, then
1218 // we are done. Otherwise, find the start of the next word.
1219
1220 if (!cmd_obj || !cmd_obj->IsMultiwordObject() ||
1221 end >= command_string.size())
1222 done = true;
1223 else
1224 start = command_string.find_first_not_of(k_white_space, end);
1225 } else
1226 // Unable to find any more words.
1227 done = true;
1228 }
1229
1230 command_string = command_string.substr(end);
1231 return cmd_obj;
1232}
1233
1234static const char *k_valid_command_chars =
1235 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
1236static void StripLeadingSpaces(std::string &s) {
1237 if (!s.empty()) {
1238 size_t pos = s.find_first_not_of(k_white_space);
1239 if (pos == std::string::npos)
1240 s.clear();
1241 else if (pos == 0)
1242 return;
1243 s.erase(0, pos);
1244 }
1245}
1246
1247static size_t FindArgumentTerminator(const std::string &s) {
1248 const size_t s_len = s.size();
1249 size_t offset = 0;
1250 while (offset < s_len) {
1251 size_t pos = s.find("--", offset);
1252 if (pos == std::string::npos)
1253 break;
1254 if (pos > 0) {
1255 if (isspace(s[pos - 1])) {
1256 // Check if the string ends "\s--" (where \s is a space character) or
1257 // if we have "\s--\s".
1258 if ((pos + 2 >= s_len) || isspace(s[pos + 2])) {
1259 return pos;
1260 }
1261 }
1262 }
1263 offset = pos + 2;
1264 }
1265 return std::string::npos;
1266}
1267
1268static bool ExtractCommand(std::string &command_string, std::string &command,
1269 std::string &suffix, char &quote_char) {
1270 command.clear();
1271 suffix.clear();
1272 StripLeadingSpaces(command_string);
1273
1274 bool result = false;
1275 quote_char = '\0';
1276
1277 if (!command_string.empty()) {
1278 const char first_char = command_string[0];
1279 if (first_char == '\'' || first_char == '"') {
1280 quote_char = first_char;
1281 const size_t end_quote_pos = command_string.find(quote_char, 1);
1282 if (end_quote_pos == std::string::npos) {
1283 command.swap(command_string);
1284 command_string.erase();
1285 } else {
1286 command.assign(command_string, 1, end_quote_pos - 1);
1287 if (end_quote_pos + 1 < command_string.size())
1288 command_string.erase(0, command_string.find_first_not_of(
1289 k_white_space, end_quote_pos + 1));
1290 else
1291 command_string.erase();
1292 }
1293 } else {
1294 const size_t first_space_pos =
1295 command_string.find_first_of(k_white_space);
1296 if (first_space_pos == std::string::npos) {
1297 command.swap(command_string);
1298 command_string.erase();
1299 } else {
1300 command.assign(command_string, 0, first_space_pos);
1301 command_string.erase(0, command_string.find_first_not_of(
1302 k_white_space, first_space_pos));
1303 }
1304 }
1305 result = true;
1306 }
1307
1308 if (!command.empty()) {
1309 // actual commands can't start with '-' or '_'
1310 if (command[0] != '-' && command[0] != '_') {
1311 size_t pos = command.find_first_not_of(k_valid_command_chars);
1312 if (pos > 0 && pos != std::string::npos) {
1313 suffix.assign(command.begin() + pos, command.end());
1314 command.erase(pos);
1315 }
1316 }
1317 }
1318
1319 return result;
1320}
1321
1322CommandObject *CommandInterpreter::BuildAliasResult(
1323 llvm::StringRef alias_name, std::string &raw_input_string,
1324 std::string &alias_result, CommandReturnObject &result) {
1325 CommandObject *alias_cmd_obj = nullptr;
1326 Args cmd_args(raw_input_string);
1327 alias_cmd_obj = GetCommandObject(alias_name);
1328 StreamString result_str;
1329
1330 if (!alias_cmd_obj || !alias_cmd_obj->IsAlias()) {
1331 alias_result.clear();
1332 return alias_cmd_obj;
1333 }
1334 std::pair<CommandObjectSP, OptionArgVectorSP> desugared =
1335 ((CommandAlias *)alias_cmd_obj)->Desugar();
1336 OptionArgVectorSP option_arg_vector_sp = desugared.second;
1337 alias_cmd_obj = desugared.first.get();
1338 std::string alias_name_str = alias_name;
1339 if ((cmd_args.GetArgumentCount() == 0) ||
1340 (alias_name_str.compare(cmd_args.GetArgumentAtIndex(0)) != 0))
1341 cmd_args.Unshift(alias_name_str);
1342
1343 result_str.Printf("%s", alias_cmd_obj->GetCommandName().str().c_str());
1344
1345 if (!option_arg_vector_sp.get()) {
1346 alias_result = result_str.GetString();
1347 return alias_cmd_obj;
1348 }
1349 OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
1350
1351 int value_type;
1352 std::string option;
1353 std::string value;
1354 for (const auto &entry : *option_arg_vector) {
1355 std::tie(option, value_type, value) = entry;
1356 if (option == "<argument>") {
1357 result_str.Printf(" %s", value.c_str());
1358 continue;
1359 }
1360
1361 result_str.Printf(" %s", option.c_str());
1362 if (value_type == OptionParser::eNoArgument)
1363 continue;
1364
1365 if (value_type != OptionParser::eOptionalArgument)
1366 result_str.Printf(" ");
1367 int index = GetOptionArgumentPosition(value.c_str());
1368 if (index == 0)
1369 result_str.Printf("%s", value.c_str());
1370 else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount()) {
1371
1372 result.AppendErrorWithFormat("Not enough arguments provided; you "
1373 "need at least %d arguments to use "
1374 "this alias.\n",
1375 index);
1376 result.SetStatus(eReturnStatusFailed);
1377 return nullptr;
1378 } else {
1379 size_t strpos = raw_input_string.find(cmd_args.GetArgumentAtIndex(index));
1380 if (strpos != std::string::npos)
1381 raw_input_string = raw_input_string.erase(
1382 strpos, strlen(cmd_args.GetArgumentAtIndex(index)));
1383 result_str.Printf("%s", cmd_args.GetArgumentAtIndex(index));
1384 }
1385 }
1386
1387 alias_result = result_str.GetString();
1388 return alias_cmd_obj;
1389}
1390
1391Status CommandInterpreter::PreprocessCommand(std::string &command) {
1392 // The command preprocessor needs to do things to the command line before any
1393 // parsing of arguments or anything else is done. The only current stuff that
1394 // gets preprocessed is anything enclosed in backtick ('`') characters is
1395 // evaluated as an expression and the result of the expression must be a
1396 // scalar that can be substituted into the command. An example would be:
1397 // (lldb) memory read `$rsp + 20`
1398 Status error; // Status for any expressions that might not evaluate
1399 size_t start_backtick;
1400 size_t pos = 0;
1401 while ((start_backtick = command.find('`', pos)) != std::string::npos) {
1402 if (start_backtick > 0 && command[start_backtick - 1] == '\\') {
1403 // The backtick was preceded by a '\' character, remove the slash and
1404 // don't treat the backtick as the start of an expression
1405 command.erase(start_backtick - 1, 1);
1406 // No need to add one to start_backtick since we just deleted a char
1407 pos = start_backtick;
1408 } else {
1409 const size_t expr_content_start = start_backtick + 1;
1410 const size_t end_backtick = command.find('`', expr_content_start);
1411 if (end_backtick == std::string::npos)
1412 return error;
1413 else if (end_backtick == expr_content_start) {
1414 // Empty expression (two backticks in a row)
1415 command.erase(start_backtick, 2);
1416 } else {
1417 std::string expr_str(command, expr_content_start,
1418 end_backtick - expr_content_start);
1419
1420 ExecutionContext exe_ctx(GetExecutionContext());
1421 Target *target = exe_ctx.GetTargetPtr();
1422 // Get a dummy target to allow for calculator mode while processing
1423 // backticks. This also helps break the infinite loop caused when
1424 // target is null.
1425 if (!target)
1426 target = m_debugger.GetDummyTarget();
1427 if (target) {
1428 ValueObjectSP expr_result_valobj_sp;
1429
1430 EvaluateExpressionOptions options;
1431 options.SetCoerceToId(false);
1432 options.SetUnwindOnError(true);
1433 options.SetIgnoreBreakpoints(true);
1434 options.SetKeepInMemory(false);
1435 options.SetTryAllThreads(true);
1436 options.SetTimeout(llvm::None);
1437
1438 ExpressionResults expr_result = target->EvaluateExpression(
1439 expr_str.c_str(), exe_ctx.GetFramePtr(), expr_result_valobj_sp,
1440 options);
1441
1442 if (expr_result == eExpressionCompleted) {
1443 Scalar scalar;
1444 if (expr_result_valobj_sp)
1445 expr_result_valobj_sp =
1446 expr_result_valobj_sp->GetQualifiedRepresentationIfAvailable(
1447 expr_result_valobj_sp->GetDynamicValueType(), true);
1448 if (expr_result_valobj_sp->ResolveValue(scalar)) {
1449 command.erase(start_backtick, end_backtick - start_backtick + 1);
1450 StreamString value_strm;
1451 const bool show_type = false;
1452 scalar.GetValue(&value_strm, show_type);
1453 size_t value_string_size = value_strm.GetSize();
1454 if (value_string_size) {
1455 command.insert(start_backtick, value_strm.GetString());
1456 pos = start_backtick + value_string_size;
1457 continue;
1458 } else {
1459 error.SetErrorStringWithFormat("expression value didn't result "
1460 "in a scalar value for the "
1461 "expression '%s'",
1462 expr_str.c_str());
1463 }
1464 } else {
1465 error.SetErrorStringWithFormat("expression value didn't result "
1466 "in a scalar value for the "
1467 "expression '%s'",
1468 expr_str.c_str());
1469 }
1470 } else {
1471 if (expr_result_valobj_sp)
1472 error = expr_result_valobj_sp->GetError();
1473 if (error.Success()) {
1474
1475 switch (expr_result) {
1476 case eExpressionSetupError:
1477 error.SetErrorStringWithFormat(
1478 "expression setup error for the expression '%s'",
1479 expr_str.c_str());
1480 break;
1481 case eExpressionParseError:
1482 error.SetErrorStringWithFormat(
1483 "expression parse error for the expression '%s'",
1484 expr_str.c_str());
1485 break;
1486 case eExpressionResultUnavailable:
1487 error.SetErrorStringWithFormat(
1488 "expression error fetching result for the expression '%s'",
1489 expr_str.c_str());
1490 break;
1491 case eExpressionCompleted:
1492 break;
1493 case eExpressionDiscarded:
1494 error.SetErrorStringWithFormat(
1495 "expression discarded for the expression '%s'",
1496 expr_str.c_str());
1497 break;
1498 case eExpressionInterrupted:
1499 error.SetErrorStringWithFormat(
1500 "expression interrupted for the expression '%s'",
1501 expr_str.c_str());
1502 break;
1503 case eExpressionHitBreakpoint:
1504 error.SetErrorStringWithFormat(
1505 "expression hit breakpoint for the expression '%s'",
1506 expr_str.c_str());
1507 break;
1508 case eExpressionTimedOut:
1509 error.SetErrorStringWithFormat(
1510 "expression timed out for the expression '%s'",
1511 expr_str.c_str());
1512 break;
1513 case eExpressionStoppedForDebug:
1514 error.SetErrorStringWithFormat("expression stop at entry point "
1515 "for debugging for the "
1516 "expression '%s'",
1517 expr_str.c_str());
1518 break;
1519 }
1520 }
1521 }
1522 }
1523 }
1524 if (error.Fail())
1525 break;
1526 }
1527 }
1528 return error;
1529}
1530
1531bool CommandInterpreter::HandleCommand(const char *command_line,
1532 LazyBool lazy_add_to_history,
1533 CommandReturnObject &result,
1534 ExecutionContext *override_context,
1535 bool repeat_on_empty_command,
1536 bool no_context_switching)
1537
1538{
1539
1540 std::string command_string(command_line);
1541 std::string original_command_string(command_line);
1542
1543 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_COMMANDS(1U << 18)));
1544 llvm::PrettyStackTraceFormat stack_trace("HandleCommand(command = \"%s\")",
1545 command_line);
1546
1547 if (log)
1548 log->Printf("Processing command: %s", command_line);
1549
1550 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
1551 Timer scoped_timer(func_cat, "Handling command: %s.", command_line);
1552
1553 if (!no_context_switching)
1554 UpdateExecutionContext(override_context);
1555
1556 if (WasInterrupted()) {
1557 result.AppendError("interrupted");
1558 result.SetStatus(eReturnStatusFailed);
1559 return false;
1560 }
1561
1562 bool add_to_history;
1563 if (lazy_add_to_history == eLazyBoolCalculate)
1564 add_to_history = (m_command_source_depth == 0);
1565 else
1566 add_to_history = (lazy_add_to_history == eLazyBoolYes);
1567
1568 bool empty_command = false;
1569 bool comment_command = false;
1570 if (command_string.empty())
1571 empty_command = true;
1572 else {
1573 const char *k_space_characters = "\t\n\v\f\r ";
1574
1575 size_t non_space = command_string.find_first_not_of(k_space_characters);
1576 // Check for empty line or comment line (lines whose first non-space
1577 // character is the comment character for this interpreter)
1578 if (non_space == std::string::npos)
1579 empty_command = true;
1580 else if (command_string[non_space] == m_comment_char)
1581 comment_command = true;
1582 else if (command_string[non_space] == CommandHistory::g_repeat_char) {
1583 llvm::StringRef search_str(command_string);
1584 search_str = search_str.drop_front(non_space);
1585 if (auto hist_str = m_command_history.FindString(search_str)) {
1586 add_to_history = false;
1587 command_string = *hist_str;
1588 original_command_string = *hist_str;
1589 } else {
1590 result.AppendErrorWithFormat("Could not find entry: %s in history",
1591 command_string.c_str());
1592 result.SetStatus(eReturnStatusFailed);
1593 return false;
1594 }
1595 }
1596 }
1597
1598 if (empty_command) {
1599 if (repeat_on_empty_command) {
1600 if (m_command_history.IsEmpty()) {
1601 result.AppendError("empty command");
1602 result.SetStatus(eReturnStatusFailed);
1603 return false;
1604 } else {
1605 command_line = m_repeat_command.c_str();
1606 command_string = command_line;
1607 original_command_string = command_line;
1608 if (m_repeat_command.empty()) {
1609 result.AppendErrorWithFormat("No auto repeat.\n");
1610 result.SetStatus(eReturnStatusFailed);
1611 return false;
1612 }
1613 }
1614 add_to_history = false;
1615 } else {
1616 result.SetStatus(eReturnStatusSuccessFinishNoResult);
1617 return true;
1618 }
1619 } else if (comment_command) {
1620 result.SetStatus(eReturnStatusSuccessFinishNoResult);
1621 return true;
1622 }
1623
1624 Status error(PreprocessCommand(command_string));
1625
1626 if (error.Fail()) {
1627 result.AppendError(error.AsCString());
1628 result.SetStatus(eReturnStatusFailed);
1629 return false;
1630 }
1631
1632 // Phase 1.
1633
1634 // Before we do ANY kind of argument processing, we need to figure out what
1635 // the real/final command object is for the specified command. This gets
1636 // complicated by the fact that the user could have specified an alias, and,
1637 // in translating the alias, there may also be command options and/or even
1638 // data (including raw text strings) that need to be found and inserted into
1639 // the command line as part of the translation. So this first step is plain
1640 // look-up and replacement, resulting in:
1641 // 1. the command object whose Execute method will actually be called
1642 // 2. a revised command string, with all substitutions and replacements
1643 // taken care of
1644 // From 1 above, we can determine whether the Execute function wants raw
1645 // input or not.
1646
1647 CommandObject *cmd_obj = ResolveCommandImpl(command_string, result);
1648
1649 // Although the user may have abbreviated the command, the command_string now
1650 // has the command expanded to the full name. For example, if the input was
1651 // "br s -n main", command_string is now "breakpoint set -n main".
1652 if (log) {
1653 llvm::StringRef command_name = cmd_obj ? cmd_obj->GetCommandName() : "<not found>";
1654 log->Printf("HandleCommand, cmd_obj : '%s'", command_name.str().c_str());
1655 log->Printf("HandleCommand, (revised) command_string: '%s'",
1656 command_string.c_str());
1657 const bool wants_raw_input =
1658 (cmd_obj != NULL__null) ? cmd_obj->WantsRawCommandString() : false;
1659 log->Printf("HandleCommand, wants_raw_input:'%s'",
1660 wants_raw_input ? "True" : "False");
1661 }
1662
1663 // Phase 2.
1664 // Take care of things like setting up the history command & calling the
1665 // appropriate Execute method on the CommandObject, with the appropriate
1666 // arguments.
1667
1668 if (cmd_obj != nullptr) {
1669 if (add_to_history) {
1670 Args command_args(command_string);
1671 const char *repeat_command = cmd_obj->GetRepeatCommand(command_args, 0);
1672 if (repeat_command != nullptr)
1673 m_repeat_command.assign(repeat_command);
1674 else
1675 m_repeat_command.assign(original_command_string);
1676
1677 m_command_history.AppendString(original_command_string);
1678 }
1679
1680 std::string remainder;
1681 const std::size_t actual_cmd_name_len = cmd_obj->GetCommandName().size();
1682 if (actual_cmd_name_len < command_string.length())
1683 remainder = command_string.substr(actual_cmd_name_len);
1684
1685 // Remove any initial spaces
1686 size_t pos = remainder.find_first_not_of(k_white_space);
1687 if (pos != 0 && pos != std::string::npos)
1688 remainder.erase(0, pos);
1689
1690 if (log)
1691 log->Printf(
1692 "HandleCommand, command line after removing command name(s): '%s'",
1693 remainder.c_str());
1694
1695 cmd_obj->Execute(remainder.c_str(), result);
1696 }
1697
1698 if (log)
1699 log->Printf("HandleCommand, command %s",
1700 (result.Succeeded() ? "succeeded" : "did not succeed"));
1701
1702 return result.Succeeded();
1703}
1704
1705int CommandInterpreter::HandleCompletionMatches(CompletionRequest &request) {
1706 int num_command_matches = 0;
1707 bool look_for_subcommand = false;
1708
1709 // For any of the command completions a unique match will be a complete word.
1710 request.SetWordComplete(true);
1711
1712 if (request.GetCursorIndex() == -1) {
1713 // We got nothing on the command line, so return the list of commands
1714 bool include_aliases = true;
1715 StringList new_matches;
1716 num_command_matches =
1717 GetCommandNamesMatchingPartialString("", include_aliases, new_matches);
1718 request.AddCompletions(new_matches);
1719 } else if (request.GetCursorIndex() == 0) {
1720 // The cursor is in the first argument, so just do a lookup in the
1721 // dictionary.
1722 StringList new_matches;
1723 CommandObject *cmd_obj = GetCommandObject(
1724 request.GetParsedLine().GetArgumentAtIndex(0), &new_matches);
1725
1726 if (num_command_matches == 1 && cmd_obj && cmd_obj->IsMultiwordObject() &&
1727 new_matches.GetStringAtIndex(0) != nullptr &&
1728 strcmp(request.GetParsedLine().GetArgumentAtIndex(0),
1729 new_matches.GetStringAtIndex(0)) == 0) {
1730 if (request.GetParsedLine().GetArgumentCount() == 1) {
1731 request.SetWordComplete(true);
1732 } else {
1733 look_for_subcommand = true;
1734 num_command_matches = 0;
Value stored to 'num_command_matches' is never read
1735 new_matches.DeleteStringAtIndex(0);
1736 request.GetParsedLine().AppendArgument(llvm::StringRef());
1737 request.SetCursorIndex(request.GetCursorIndex() + 1);
1738 request.SetCursorCharPosition(0);
1739 }
1740 }
1741 request.AddCompletions(new_matches);
1742 num_command_matches = request.GetNumberOfMatches();
1743 }
1744
1745 if (request.GetCursorIndex() > 0 || look_for_subcommand) {
1746 // We are completing further on into a commands arguments, so find the
1747 // command and tell it to complete the command. First see if there is a
1748 // matching initial command:
1749 CommandObject *command_object =
1750 GetCommandObject(request.GetParsedLine().GetArgumentAtIndex(0));
1751 if (command_object == nullptr) {
1752 return 0;
1753 } else {
1754 request.GetParsedLine().Shift();
1755 request.SetCursorIndex(request.GetCursorIndex() - 1);
1756 num_command_matches = command_object->HandleCompletion(request);
1757 }
1758 }
1759
1760 return num_command_matches;
1761}
1762
1763int CommandInterpreter::HandleCompletion(
1764 const char *current_line, const char *cursor, const char *last_char,
1765 int match_start_point, int max_return_elements, StringList &matches) {
1766
1767 llvm::StringRef command_line(current_line, last_char - current_line);
1768 CompletionRequest request(command_line, cursor - current_line,
1769 match_start_point, max_return_elements, matches);
1770
1771 // Don't complete comments, and if the line we are completing is just the
1772 // history repeat character, substitute the appropriate history line.
1773 const char *first_arg = request.GetParsedLine().GetArgumentAtIndex(0);
1774 if (first_arg) {
1775 if (first_arg[0] == m_comment_char)
1776 return 0;
1777 else if (first_arg[0] == CommandHistory::g_repeat_char) {
1778 if (auto hist_str = m_command_history.FindString(first_arg)) {
1779 matches.InsertStringAtIndex(0, *hist_str);
1780 return -2;
1781 } else
1782 return 0;
1783 }
1784 }
1785
1786 // Only max_return_elements == -1 is supported at present:
1787 lldbassert(max_return_elements == -1)lldb_private::lldb_assert(max_return_elements == -1, "max_return_elements == -1"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 1787)
;
1788
1789 int num_command_matches = HandleCompletionMatches(request);
1790
1791 if (num_command_matches <= 0)
1792 return num_command_matches;
1793
1794 if (request.GetParsedLine().GetArgumentCount() == 0) {
1795 // If we got an empty string, insert nothing.
1796 matches.InsertStringAtIndex(0, "");
1797 } else {
1798 // Now figure out if there is a common substring, and if so put that in
1799 // element 0, otherwise put an empty string in element 0.
1800 std::string command_partial_str = request.GetCursorArgumentPrefix().str();
1801
1802 std::string common_prefix;
1803 matches.LongestCommonPrefix(common_prefix);
1804 const size_t partial_name_len = command_partial_str.size();
1805 common_prefix.erase(0, partial_name_len);
1806
1807 // If we matched a unique single command, add a space... Only do this if
1808 // the completer told us this was a complete word, however...
1809 if (num_command_matches == 1 && request.GetWordComplete()) {
1810 char quote_char = request.GetParsedLine()[request.GetCursorIndex()].quote;
1811 common_prefix =
1812 Args::EscapeLLDBCommandArgument(common_prefix, quote_char);
1813 if (quote_char != '\0')
1814 common_prefix.push_back(quote_char);
1815 common_prefix.push_back(' ');
1816 }
1817 matches.InsertStringAtIndex(0, common_prefix.c_str());
1818 }
1819 return num_command_matches;
1820}
1821
1822CommandInterpreter::~CommandInterpreter() {}
1823
1824void CommandInterpreter::UpdatePrompt(llvm::StringRef new_prompt) {
1825 EventSP prompt_change_event_sp(
1826 new Event(eBroadcastBitResetPrompt, new EventDataBytes(new_prompt)));
1827 ;
1828 BroadcastEvent(prompt_change_event_sp);
1829 if (m_command_io_handler_sp)
1830 m_command_io_handler_sp->SetPrompt(new_prompt);
1831}
1832
1833bool CommandInterpreter::Confirm(llvm::StringRef message, bool default_answer) {
1834 // Check AutoConfirm first:
1835 if (m_debugger.GetAutoConfirm())
1836 return default_answer;
1837
1838 IOHandlerConfirm *confirm =
1839 new IOHandlerConfirm(m_debugger, message, default_answer);
1840 IOHandlerSP io_handler_sp(confirm);
1841 m_debugger.RunIOHandler(io_handler_sp);
1842 return confirm->GetResponse();
1843}
1844
1845const CommandAlias *
1846CommandInterpreter::GetAlias(llvm::StringRef alias_name) const {
1847 OptionArgVectorSP ret_val;
1848
1849 auto pos = m_alias_dict.find(alias_name);
1850 if (pos != m_alias_dict.end())
1851 return (CommandAlias *)pos->second.get();
1852
1853 return nullptr;
1854}
1855
1856bool CommandInterpreter::HasCommands() const { return (!m_command_dict.empty()); }
1857
1858bool CommandInterpreter::HasAliases() const { return (!m_alias_dict.empty()); }
1859
1860bool CommandInterpreter::HasUserCommands() const { return (!m_user_dict.empty()); }
1861
1862bool CommandInterpreter::HasAliasOptions() const { return HasAliases(); }
1863
1864void CommandInterpreter::BuildAliasCommandArgs(CommandObject *alias_cmd_obj,
1865 const char *alias_name,
1866 Args &cmd_args,
1867 std::string &raw_input_string,
1868 CommandReturnObject &result) {
1869 OptionArgVectorSP option_arg_vector_sp =
1870 GetAlias(alias_name)->GetOptionArguments();
1871
1872 bool wants_raw_input = alias_cmd_obj->WantsRawCommandString();
1873
1874 // Make sure that the alias name is the 0th element in cmd_args
1875 std::string alias_name_str = alias_name;
1876 if (alias_name_str.compare(cmd_args.GetArgumentAtIndex(0)) != 0)
1877 cmd_args.Unshift(alias_name_str);
1878
1879 Args new_args(alias_cmd_obj->GetCommandName());
1880 if (new_args.GetArgumentCount() == 2)
1881 new_args.Shift();
1882
1883 if (option_arg_vector_sp.get()) {
1884 if (wants_raw_input) {
1885 // We have a command that both has command options and takes raw input.
1886 // Make *sure* it has a " -- " in the right place in the
1887 // raw_input_string.
1888 size_t pos = raw_input_string.find(" -- ");
1889 if (pos == std::string::npos) {
1890 // None found; assume it goes at the beginning of the raw input string
1891 raw_input_string.insert(0, " -- ");
1892 }
1893 }
1894
1895 OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
1896 const size_t old_size = cmd_args.GetArgumentCount();
1897 std::vector<bool> used(old_size + 1, false);
1898
1899 used[0] = true;
1900
1901 int value_type;
1902 std::string option;
1903 std::string value;
1904 for (const auto &option_entry : *option_arg_vector) {
1905 std::tie(option, value_type, value) = option_entry;
1906 if (option == "<argument>") {
1907 if (!wants_raw_input || (value != "--")) {
1908 // Since we inserted this above, make sure we don't insert it twice
1909 new_args.AppendArgument(value);
1910 }
1911 continue;
1912 }
1913
1914 if (value_type != OptionParser::eOptionalArgument)
1915 new_args.AppendArgument(option);
1916
1917 if (value == "<no-argument>")
1918 continue;
1919
1920 int index = GetOptionArgumentPosition(value.c_str());
1921 if (index == 0) {
1922 // value was NOT a positional argument; must be a real value
1923 if (value_type != OptionParser::eOptionalArgument)
1924 new_args.AppendArgument(value);
1925 else {
1926 char buffer[255];
1927 ::snprintf(buffer, sizeof(buffer), "%s%s", option.c_str(),
1928 value.c_str());
1929 new_args.AppendArgument(llvm::StringRef(buffer));
1930 }
1931
1932 } else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount()) {
1933 result.AppendErrorWithFormat("Not enough arguments provided; you "
1934 "need at least %d arguments to use "
1935 "this alias.\n",
1936 index);
1937 result.SetStatus(eReturnStatusFailed);
1938 return;
1939 } else {
1940 // Find and remove cmd_args.GetArgumentAtIndex(i) from raw_input_string
1941 size_t strpos =
1942 raw_input_string.find(cmd_args.GetArgumentAtIndex(index));
1943 if (strpos != std::string::npos) {
1944 raw_input_string = raw_input_string.erase(
1945 strpos, strlen(cmd_args.GetArgumentAtIndex(index)));
1946 }
1947
1948 if (value_type != OptionParser::eOptionalArgument)
1949 new_args.AppendArgument(cmd_args.GetArgumentAtIndex(index));
1950 else {
1951 char buffer[255];
1952 ::snprintf(buffer, sizeof(buffer), "%s%s", option.c_str(),
1953 cmd_args.GetArgumentAtIndex(index));
1954 new_args.AppendArgument(buffer);
1955 }
1956 used[index] = true;
1957 }
1958 }
1959
1960 for (auto entry : llvm::enumerate(cmd_args.entries())) {
1961 if (!used[entry.index()] && !wants_raw_input)
1962 new_args.AppendArgument(entry.value().ref);
1963 }
1964
1965 cmd_args.Clear();
1966 cmd_args.SetArguments(new_args.GetArgumentCount(),
1967 new_args.GetConstArgumentVector());
1968 } else {
1969 result.SetStatus(eReturnStatusSuccessFinishNoResult);
1970 // This alias was not created with any options; nothing further needs to be
1971 // done, unless it is a command that wants raw input, in which case we need
1972 // to clear the rest of the data from cmd_args, since its in the raw input
1973 // string.
1974 if (wants_raw_input) {
1975 cmd_args.Clear();
1976 cmd_args.SetArguments(new_args.GetArgumentCount(),
1977 new_args.GetConstArgumentVector());
1978 }
1979 return;
1980 }
1981
1982 result.SetStatus(eReturnStatusSuccessFinishNoResult);
1983 return;
1984}
1985
1986int CommandInterpreter::GetOptionArgumentPosition(const char *in_string) {
1987 int position = 0; // Any string that isn't an argument position, i.e. '%'
1988 // followed by an integer, gets a position
1989 // of zero.
1990
1991 const char *cptr = in_string;
1992
1993 // Does it start with '%'
1994 if (cptr[0] == '%') {
1995 ++cptr;
1996
1997 // Is the rest of it entirely digits?
1998 if (isdigit(cptr[0])) {
1999 const char *start = cptr;
2000 while (isdigit(cptr[0]))
2001 ++cptr;
2002
2003 // We've gotten to the end of the digits; are we at the end of the
2004 // string?
2005 if (cptr[0] == '\0')
2006 position = atoi(start);
2007 }
2008 }
2009
2010 return position;
2011}
2012
2013void CommandInterpreter::SourceInitFile(bool in_cwd,
2014 CommandReturnObject &result) {
2015 FileSpec init_file;
2016 if (in_cwd) {
2017 ExecutionContext exe_ctx(GetExecutionContext());
2018 Target *target = exe_ctx.GetTargetPtr();
2019 if (target) {
2020 // In the current working directory we don't load any program specific
2021 // .lldbinit files, we only look for a ".lldbinit" file.
2022 if (m_skip_lldbinit_files)
2023 return;
2024
2025 LoadCWDlldbinitFile should_load =
2026 target->TargetProperties::GetLoadCWDlldbinitFile();
2027 if (should_load == eLoadCWDlldbinitWarn) {
2028 FileSpec dot_lldb(".lldbinit", true);
2029 llvm::SmallString<64> home_dir_path;
2030 llvm::sys::path::home_directory(home_dir_path);
2031 FileSpec homedir_dot_lldb(home_dir_path.c_str(), false);
2032 homedir_dot_lldb.AppendPathComponent(".lldbinit");
2033 homedir_dot_lldb.ResolvePath();
2034 if (dot_lldb.Exists() &&
2035 dot_lldb.GetDirectory() != homedir_dot_lldb.GetDirectory()) {
2036 result.AppendErrorWithFormat(
2037 "There is a .lldbinit file in the current directory which is not "
2038 "being read.\n"
2039 "To silence this warning without sourcing in the local "
2040 ".lldbinit,\n"
2041 "add the following to the lldbinit file in your home directory:\n"
2042 " settings set target.load-cwd-lldbinit false\n"
2043 "To allow lldb to source .lldbinit files in the current working "
2044 "directory,\n"
2045 "set the value of this variable to true. Only do so if you "
2046 "understand and\n"
2047 "accept the security risk.");
2048 result.SetStatus(eReturnStatusFailed);
2049 return;
2050 }
2051 } else if (should_load == eLoadCWDlldbinitTrue) {
2052 init_file.SetFile("./.lldbinit", true, FileSpec::Style::native);
2053 }
2054 }
2055 } else {
2056 // If we aren't looking in the current working directory we are looking in
2057 // the home directory. We will first see if there is an application
2058 // specific ".lldbinit" file whose name is "~/.lldbinit" followed by a "-"
2059 // and the name of the program. If this file doesn't exist, we fall back to
2060 // just the "~/.lldbinit" file. We also obey any requests to not load the
2061 // init files.
2062 llvm::SmallString<64> home_dir_path;
2063 llvm::sys::path::home_directory(home_dir_path);
2064 FileSpec profilePath(home_dir_path.c_str(), false);
2065 profilePath.AppendPathComponent(".lldbinit");
2066 std::string init_file_path = profilePath.GetPath();
2067
2068 if (m_skip_app_init_files == false) {
2069 FileSpec program_file_spec(HostInfo::GetProgramFileSpec());
2070 const char *program_name = program_file_spec.GetFilename().AsCString();
2071
2072 if (program_name) {
2073 char program_init_file_name[PATH_MAX4096];
2074 ::snprintf(program_init_file_name, sizeof(program_init_file_name),
2075 "%s-%s", init_file_path.c_str(), program_name);
2076 init_file.SetFile(program_init_file_name, true,
2077 FileSpec::Style::native);
2078 if (!init_file.Exists())
2079 init_file.Clear();
2080 }
2081 }
2082
2083 if (!init_file && !m_skip_lldbinit_files)
2084 init_file.SetFile(init_file_path, false, FileSpec::Style::native);
2085 }
2086
2087 // If the file exists, tell HandleCommand to 'source' it; this will do the
2088 // actual broadcasting of the commands back to any appropriate listener (see
2089 // CommandObjectSource::Execute for more details).
2090
2091 if (init_file.Exists()) {
2092 const bool saved_batch = SetBatchCommandMode(true);
2093 CommandInterpreterRunOptions options;
2094 options.SetSilent(true);
2095 options.SetStopOnError(false);
2096 options.SetStopOnContinue(true);
2097
2098 HandleCommandsFromFile(init_file,
2099 nullptr, // Execution context
2100 options, result);
2101 SetBatchCommandMode(saved_batch);
2102 } else {
2103 // nothing to be done if the file doesn't exist
2104 result.SetStatus(eReturnStatusSuccessFinishNoResult);
2105 }
2106}
2107
2108const char *CommandInterpreter::GetCommandPrefix() {
2109 const char *prefix = GetDebugger().GetIOHandlerCommandPrefix();
2110 return prefix == NULL__null ? "" : prefix;
2111}
2112
2113PlatformSP CommandInterpreter::GetPlatform(bool prefer_target_platform) {
2114 PlatformSP platform_sp;
2115 if (prefer_target_platform) {
2116 ExecutionContext exe_ctx(GetExecutionContext());
2117 Target *target = exe_ctx.GetTargetPtr();
2118 if (target)
2119 platform_sp = target->GetPlatform();
2120 }
2121
2122 if (!platform_sp)
2123 platform_sp = m_debugger.GetPlatformList().GetSelectedPlatform();
2124 return platform_sp;
2125}
2126
2127void CommandInterpreter::HandleCommands(const StringList &commands,
2128 ExecutionContext *override_context,
2129 CommandInterpreterRunOptions &options,
2130 CommandReturnObject &result) {
2131 size_t num_lines = commands.GetSize();
2132
2133 // If we are going to continue past a "continue" then we need to run the
2134 // commands synchronously. Make sure you reset this value anywhere you return
2135 // from the function.
2136
2137 bool old_async_execution = m_debugger.GetAsyncExecution();
2138
2139 // If we've been given an execution context, set it at the start, but don't
2140 // keep resetting it or we will cause series of commands that change the
2141 // context, then do an operation that relies on that context to fail.
2142
2143 if (override_context != nullptr)
2144 UpdateExecutionContext(override_context);
2145
2146 if (!options.GetStopOnContinue()) {
2147 m_debugger.SetAsyncExecution(false);
2148 }
2149
2150 for (size_t idx = 0; idx < num_lines && !WasInterrupted(); idx++) {
2151 const char *cmd = commands.GetStringAtIndex(idx);
2152 if (cmd[0] == '\0')
2153 continue;
2154
2155 if (options.GetEchoCommands()) {
2156 // TODO: Add Stream support.
2157 result.AppendMessageWithFormat("%s %s\n",
2158 m_debugger.GetPrompt().str().c_str(), cmd);
2159 }
2160
2161 CommandReturnObject tmp_result;
2162 // If override_context is not NULL, pass no_context_switching = true for
2163 // HandleCommand() since we updated our context already.
2164
2165 // We might call into a regex or alias command, in which case the
2166 // add_to_history will get lost. This m_command_source_depth dingus is the
2167 // way we turn off adding to the history in that case, so set it up here.
2168 if (!options.GetAddToHistory())
2169 m_command_source_depth++;
2170 bool success =
2171 HandleCommand(cmd, options.m_add_to_history, tmp_result,
2172 nullptr, /* override_context */
2173 true, /* repeat_on_empty_command */
2174 override_context != nullptr /* no_context_switching */);
2175 if (!options.GetAddToHistory())
2176 m_command_source_depth--;
2177
2178 if (options.GetPrintResults()) {
2179 if (tmp_result.Succeeded())
2180 result.AppendMessage(tmp_result.GetOutputData());
2181 }
2182
2183 if (!success || !tmp_result.Succeeded()) {
2184 llvm::StringRef error_msg = tmp_result.GetErrorData();
2185 if (error_msg.empty())
2186 error_msg = "<unknown error>.\n";
2187 if (options.GetStopOnError()) {
2188 result.AppendErrorWithFormat(
2189 "Aborting reading of commands after command #%" PRIu64"l" "u"
2190 ": '%s' failed with %s",
2191 (uint64_t)idx, cmd, error_msg.str().c_str());
2192 result.SetStatus(eReturnStatusFailed);
2193 m_debugger.SetAsyncExecution(old_async_execution);
2194 return;
2195 } else if (options.GetPrintResults()) {
2196 result.AppendMessageWithFormat(
2197 "Command #%" PRIu64"l" "u" " '%s' failed with %s", (uint64_t)idx + 1, cmd,
2198 error_msg.str().c_str());
2199 }
2200 }
2201
2202 if (result.GetImmediateOutputStream())
2203 result.GetImmediateOutputStream()->Flush();
2204
2205 if (result.GetImmediateErrorStream())
2206 result.GetImmediateErrorStream()->Flush();
2207
2208 // N.B. Can't depend on DidChangeProcessState, because the state coming
2209 // into the command execution could be running (for instance in Breakpoint
2210 // Commands. So we check the return value to see if it is has running in
2211 // it.
2212 if ((tmp_result.GetStatus() == eReturnStatusSuccessContinuingNoResult) ||
2213 (tmp_result.GetStatus() == eReturnStatusSuccessContinuingResult)) {
2214 if (options.GetStopOnContinue()) {
2215 // If we caused the target to proceed, and we're going to stop in that
2216 // case, set the status in our real result before returning. This is
2217 // an error if the continue was not the last command in the set of
2218 // commands to be run.
2219 if (idx != num_lines - 1)
2220 result.AppendErrorWithFormat(
2221 "Aborting reading of commands after command #%" PRIu64"l" "u"
2222 ": '%s' continued the target.\n",
2223 (uint64_t)idx + 1, cmd);
2224 else
2225 result.AppendMessageWithFormat("Command #%" PRIu64"l" "u"
2226 " '%s' continued the target.\n",
2227 (uint64_t)idx + 1, cmd);
2228
2229 result.SetStatus(tmp_result.GetStatus());
2230 m_debugger.SetAsyncExecution(old_async_execution);
2231
2232 return;
2233 }
2234 }
2235
2236 // Also check for "stop on crash here:
2237 bool should_stop = false;
2238 if (tmp_result.GetDidChangeProcessState() && options.GetStopOnCrash()) {
2239 TargetSP target_sp(m_debugger.GetTargetList().GetSelectedTarget());
2240 if (target_sp) {
2241 ProcessSP process_sp(target_sp->GetProcessSP());
2242 if (process_sp) {
2243 for (ThreadSP thread_sp : process_sp->GetThreadList().Threads()) {
2244 StopReason reason = thread_sp->GetStopReason();
2245 if (reason == eStopReasonSignal || reason == eStopReasonException ||
2246 reason == eStopReasonInstrumentation) {
2247 should_stop = true;
2248 break;
2249 }
2250 }
2251 }
2252 }
2253 if (should_stop) {
2254 if (idx != num_lines - 1)
2255 result.AppendErrorWithFormat(
2256 "Aborting reading of commands after command #%" PRIu64"l" "u"
2257 ": '%s' stopped with a signal or exception.\n",
2258 (uint64_t)idx + 1, cmd);
2259 else
2260 result.AppendMessageWithFormat(
2261 "Command #%" PRIu64"l" "u" " '%s' stopped with a signal or exception.\n",
2262 (uint64_t)idx + 1, cmd);
2263
2264 result.SetStatus(tmp_result.GetStatus());
2265 m_debugger.SetAsyncExecution(old_async_execution);
2266
2267 return;
2268 }
2269 }
2270 }
2271
2272 result.SetStatus(eReturnStatusSuccessFinishResult);
2273 m_debugger.SetAsyncExecution(old_async_execution);
2274
2275 return;
2276}
2277
2278// Make flags that we can pass into the IOHandler so our delegates can do the
2279// right thing
2280enum {
2281 eHandleCommandFlagStopOnContinue = (1u << 0),
2282 eHandleCommandFlagStopOnError = (1u << 1),
2283 eHandleCommandFlagEchoCommand = (1u << 2),
2284 eHandleCommandFlagPrintResult = (1u << 3),
2285 eHandleCommandFlagStopOnCrash = (1u << 4)
2286};
2287
2288void CommandInterpreter::HandleCommandsFromFile(
2289 FileSpec &cmd_file, ExecutionContext *context,
2290 CommandInterpreterRunOptions &options, CommandReturnObject &result) {
2291 if (cmd_file.Exists()) {
2292 StreamFileSP input_file_sp(new StreamFile());
2293
2294 std::string cmd_file_path = cmd_file.GetPath();
2295 Status error = input_file_sp->GetFile().Open(cmd_file_path.c_str(),
2296 File::eOpenOptionRead);
2297
2298 if (error.Success()) {
2299 Debugger &debugger = GetDebugger();
2300
2301 uint32_t flags = 0;
2302
2303 if (options.m_stop_on_continue == eLazyBoolCalculate) {
2304 if (m_command_source_flags.empty()) {
2305 // Stop on continue by default
2306 flags |= eHandleCommandFlagStopOnContinue;
2307 } else if (m_command_source_flags.back() &
2308 eHandleCommandFlagStopOnContinue) {
2309 flags |= eHandleCommandFlagStopOnContinue;
2310 }
2311 } else if (options.m_stop_on_continue == eLazyBoolYes) {
2312 flags |= eHandleCommandFlagStopOnContinue;
2313 }
2314
2315 if (options.m_stop_on_error == eLazyBoolCalculate) {
2316 if (m_command_source_flags.empty()) {
2317 if (GetStopCmdSourceOnError())
2318 flags |= eHandleCommandFlagStopOnError;
2319 } else if (m_command_source_flags.back() &
2320 eHandleCommandFlagStopOnError) {
2321 flags |= eHandleCommandFlagStopOnError;
2322 }
2323 } else if (options.m_stop_on_error == eLazyBoolYes) {
2324 flags |= eHandleCommandFlagStopOnError;
2325 }
2326
2327 if (options.GetStopOnCrash()) {
2328 if (m_command_source_flags.empty()) {
2329 // Echo command by default
2330 flags |= eHandleCommandFlagStopOnCrash;
2331 } else if (m_command_source_flags.back() &
2332 eHandleCommandFlagStopOnCrash) {
2333 flags |= eHandleCommandFlagStopOnCrash;
2334 }
2335 }
2336
2337 if (options.m_echo_commands == eLazyBoolCalculate) {
2338 if (m_command_source_flags.empty()) {
2339 // Echo command by default
2340 flags |= eHandleCommandFlagEchoCommand;
2341 } else if (m_command_source_flags.back() &
2342 eHandleCommandFlagEchoCommand) {
2343 flags |= eHandleCommandFlagEchoCommand;
2344 }
2345 } else if (options.m_echo_commands == eLazyBoolYes) {
2346 flags |= eHandleCommandFlagEchoCommand;
2347 }
2348
2349 if (options.m_print_results == eLazyBoolCalculate) {
2350 if (m_command_source_flags.empty()) {
2351 // Print output by default
2352 flags |= eHandleCommandFlagPrintResult;
2353 } else if (m_command_source_flags.back() &
2354 eHandleCommandFlagPrintResult) {
2355 flags |= eHandleCommandFlagPrintResult;
2356 }
2357 } else if (options.m_print_results == eLazyBoolYes) {
2358 flags |= eHandleCommandFlagPrintResult;
2359 }
2360
2361 if (flags & eHandleCommandFlagPrintResult) {
2362 debugger.GetOutputFile()->Printf("Executing commands in '%s'.\n",
2363 cmd_file_path.c_str());
2364 }
2365
2366 // Used for inheriting the right settings when "command source" might
2367 // have nested "command source" commands
2368 lldb::StreamFileSP empty_stream_sp;
2369 m_command_source_flags.push_back(flags);
2370 IOHandlerSP io_handler_sp(new IOHandlerEditline(
2371 debugger, IOHandler::Type::CommandInterpreter, input_file_sp,
2372 empty_stream_sp, // Pass in an empty stream so we inherit the top
2373 // input reader output stream
2374 empty_stream_sp, // Pass in an empty stream so we inherit the top
2375 // input reader error stream
2376 flags,
2377 nullptr, // Pass in NULL for "editline_name" so no history is saved,
2378 // or written
2379 debugger.GetPrompt(), llvm::StringRef(),
2380 false, // Not multi-line
2381 debugger.GetUseColor(), 0, *this));
2382 const bool old_async_execution = debugger.GetAsyncExecution();
2383
2384 // Set synchronous execution if we are not stopping on continue
2385 if ((flags & eHandleCommandFlagStopOnContinue) == 0)
2386 debugger.SetAsyncExecution(false);
2387
2388 m_command_source_depth++;
2389
2390 debugger.RunIOHandler(io_handler_sp);
2391 if (!m_command_source_flags.empty())
2392 m_command_source_flags.pop_back();
2393 m_command_source_depth--;
2394 result.SetStatus(eReturnStatusSuccessFinishNoResult);
2395 debugger.SetAsyncExecution(old_async_execution);
2396 } else {
2397 result.AppendErrorWithFormat(
2398 "error: an error occurred read file '%s': %s\n",
2399 cmd_file_path.c_str(), error.AsCString());
2400 result.SetStatus(eReturnStatusFailed);
2401 }
2402
2403 } else {
2404 result.AppendErrorWithFormat(
2405 "Error reading commands from file %s - file not found.\n",
2406 cmd_file.GetFilename().AsCString("<Unknown>"));
2407 result.SetStatus(eReturnStatusFailed);
2408 return;
2409 }
2410}
2411
2412ScriptInterpreter *CommandInterpreter::GetScriptInterpreter(bool can_create) {
2413 std::lock_guard<std::recursive_mutex> locker(m_script_interpreter_mutex);
2414 if (!m_script_interpreter_sp) {
2415 if (!can_create)
2416 return nullptr;
2417 lldb::ScriptLanguage script_lang = GetDebugger().GetScriptLanguage();
2418 m_script_interpreter_sp =
2419 PluginManager::GetScriptInterpreterForLanguage(script_lang, *this);
2420 }
2421 return m_script_interpreter_sp.get();
2422}
2423
2424bool CommandInterpreter::GetSynchronous() { return m_synchronous_execution; }
2425
2426void CommandInterpreter::SetSynchronous(bool value) {
2427 m_synchronous_execution = value;
2428}
2429
2430void CommandInterpreter::OutputFormattedHelpText(Stream &strm,
2431 llvm::StringRef prefix,
2432 llvm::StringRef help_text) {
2433 const uint32_t max_columns = m_debugger.GetTerminalWidth();
2434
2435 size_t line_width_max = max_columns - prefix.size();
2436 if (line_width_max < 16)
2437 line_width_max = help_text.size() + prefix.size();
2438
2439 strm.IndentMore(prefix.size());
2440 bool prefixed_yet = false;
2441 while (!help_text.empty()) {
2442 // Prefix the first line, indent subsequent lines to line up
2443 if (!prefixed_yet) {
2444 strm << prefix;
2445 prefixed_yet = true;
2446 } else
2447 strm.Indent();
2448
2449 // Never print more than the maximum on one line.
2450 llvm::StringRef this_line = help_text.substr(0, line_width_max);
2451
2452 // Always break on an explicit newline.
2453 std::size_t first_newline = this_line.find_first_of("\n");
2454
2455 // Don't break on space/tab unless the text is too long to fit on one line.
2456 std::size_t last_space = llvm::StringRef::npos;
2457 if (this_line.size() != help_text.size())
2458 last_space = this_line.find_last_of(" \t");
2459
2460 // Break at whichever condition triggered first.
2461 this_line = this_line.substr(0, std::min(first_newline, last_space));
2462 strm.PutCString(this_line);
2463 strm.EOL();
2464
2465 // Remove whitespace / newlines after breaking.
2466 help_text = help_text.drop_front(this_line.size()).ltrim();
2467 }
2468 strm.IndentLess(prefix.size());
2469}
2470
2471void CommandInterpreter::OutputFormattedHelpText(Stream &strm,
2472 llvm::StringRef word_text,
2473 llvm::StringRef separator,
2474 llvm::StringRef help_text,
2475 size_t max_word_len) {
2476 StreamString prefix_stream;
2477 prefix_stream.Printf(" %-*s %*s ", (int)max_word_len, word_text.data(),
2478 (int)separator.size(), separator.data());
2479 OutputFormattedHelpText(strm, prefix_stream.GetString(), help_text);
2480}
2481
2482void CommandInterpreter::OutputHelpText(Stream &strm, llvm::StringRef word_text,
2483 llvm::StringRef separator,
2484 llvm::StringRef help_text,
2485 uint32_t max_word_len) {
2486 int indent_size = max_word_len + separator.size() + 2;
2487
2488 strm.IndentMore(indent_size);
2489
2490 StreamString text_strm;
2491 text_strm.Printf("%-*s ", (int)max_word_len, word_text.data());
2492 text_strm << separator << " " << help_text;
2493
2494 const uint32_t max_columns = m_debugger.GetTerminalWidth();
2495
2496 llvm::StringRef text = text_strm.GetString();
2497
2498 uint32_t chars_left = max_columns;
2499
2500 auto nextWordLength = [](llvm::StringRef S) {
2501 size_t pos = S.find_first_of(' ');
2502 return pos == llvm::StringRef::npos ? S.size() : pos;
2503 };
2504
2505 while (!text.empty()) {
2506 if (text.front() == '\n' ||
2507 (text.front() == ' ' && nextWordLength(text.ltrim(' ')) > chars_left)) {
2508 strm.EOL();
2509 strm.Indent();
2510 chars_left = max_columns - indent_size;
2511 if (text.front() == '\n')
2512 text = text.drop_front();
2513 else
2514 text = text.ltrim(' ');
2515 } else {
2516 strm.PutChar(text.front());
2517 --chars_left;
2518 text = text.drop_front();
2519 }
2520 }
2521
2522 strm.EOL();
2523 strm.IndentLess(indent_size);
2524}
2525
2526void CommandInterpreter::FindCommandsForApropos(
2527 llvm::StringRef search_word, StringList &commands_found,
2528 StringList &commands_help, CommandObject::CommandMap &command_map) {
2529 CommandObject::CommandMap::const_iterator pos;
2530
2531 for (pos = command_map.begin(); pos != command_map.end(); ++pos) {
2532 llvm::StringRef command_name = pos->first;
2533 CommandObject *cmd_obj = pos->second.get();
2534
2535 const bool search_short_help = true;
2536 const bool search_long_help = false;
2537 const bool search_syntax = false;
2538 const bool search_options = false;
2539 if (command_name.contains_lower(search_word) ||
2540 cmd_obj->HelpTextContainsWord(search_word, search_short_help,
2541 search_long_help, search_syntax,
2542 search_options)) {
2543 commands_found.AppendString(cmd_obj->GetCommandName());
2544 commands_help.AppendString(cmd_obj->GetHelp());
2545 }
2546
2547 if (cmd_obj->IsMultiwordObject()) {
2548 CommandObjectMultiword *cmd_multiword = cmd_obj->GetAsMultiwordCommand();
2549 FindCommandsForApropos(search_word, commands_found, commands_help,
2550 cmd_multiword->GetSubcommandDictionary());
2551 }
2552 }
2553}
2554
2555void CommandInterpreter::FindCommandsForApropos(llvm::StringRef search_word,
2556 StringList &commands_found,
2557 StringList &commands_help,
2558 bool search_builtin_commands,
2559 bool search_user_commands,
2560 bool search_alias_commands) {
2561 CommandObject::CommandMap::const_iterator pos;
2562
2563 if (search_builtin_commands)
2564 FindCommandsForApropos(search_word, commands_found, commands_help,
2565 m_command_dict);
2566
2567 if (search_user_commands)
2568 FindCommandsForApropos(search_word, commands_found, commands_help,
2569 m_user_dict);
2570
2571 if (search_alias_commands)
2572 FindCommandsForApropos(search_word, commands_found, commands_help,
2573 m_alias_dict);
2574}
2575
2576void CommandInterpreter::UpdateExecutionContext(
2577 ExecutionContext *override_context) {
2578 if (override_context != nullptr) {
2579 m_exe_ctx_ref = *override_context;
2580 } else {
2581 const bool adopt_selected = true;
2582 m_exe_ctx_ref.SetTargetPtr(m_debugger.GetSelectedTarget().get(),
2583 adopt_selected);
2584 }
2585}
2586
2587size_t CommandInterpreter::GetProcessOutput() {
2588 // The process has stuff waiting for stderr; get it and write it out to the
2589 // appropriate place.
2590 char stdio_buffer[1024];
2591 size_t len;
2592 size_t total_bytes = 0;
2593 Status error;
2594 TargetSP target_sp(m_debugger.GetTargetList().GetSelectedTarget());
2595 if (target_sp) {
2596 ProcessSP process_sp(target_sp->GetProcessSP());
2597 if (process_sp) {
2598 while ((len = process_sp->GetSTDOUT(stdio_buffer, sizeof(stdio_buffer),
2599 error)) > 0) {
2600 size_t bytes_written = len;
2601 m_debugger.GetOutputFile()->Write(stdio_buffer, bytes_written);
2602 total_bytes += len;
2603 }
2604 while ((len = process_sp->GetSTDERR(stdio_buffer, sizeof(stdio_buffer),
2605 error)) > 0) {
2606 size_t bytes_written = len;
2607 m_debugger.GetErrorFile()->Write(stdio_buffer, bytes_written);
2608 total_bytes += len;
2609 }
2610 }
2611 }
2612 return total_bytes;
2613}
2614
2615void CommandInterpreter::StartHandlingCommand() {
2616 auto idle_state = CommandHandlingState::eIdle;
2617 if (m_command_state.compare_exchange_strong(
2618 idle_state, CommandHandlingState::eInProgress))
2619 lldbassert(m_iohandler_nesting_level == 0)lldb_private::lldb_assert(m_iohandler_nesting_level == 0, "m_iohandler_nesting_level == 0"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 2619)
;
2620 else
2621 lldbassert(m_iohandler_nesting_level > 0)lldb_private::lldb_assert(m_iohandler_nesting_level > 0, "m_iohandler_nesting_level > 0"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 2621)
;
2622 ++m_iohandler_nesting_level;
2623}
2624
2625void CommandInterpreter::FinishHandlingCommand() {
2626 lldbassert(m_iohandler_nesting_level > 0)lldb_private::lldb_assert(m_iohandler_nesting_level > 0, "m_iohandler_nesting_level > 0"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 2626)
;
2627 if (--m_iohandler_nesting_level == 0) {
2628 auto prev_state = m_command_state.exchange(CommandHandlingState::eIdle);
2629 lldbassert(prev_state != CommandHandlingState::eIdle)lldb_private::lldb_assert(prev_state != CommandHandlingState::
eIdle, "prev_state != CommandHandlingState::eIdle", __FUNCTION__
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 2629)
;
2630 }
2631}
2632
2633bool CommandInterpreter::InterruptCommand() {
2634 auto in_progress = CommandHandlingState::eInProgress;
2635 return m_command_state.compare_exchange_strong(
2636 in_progress, CommandHandlingState::eInterrupted);
2637}
2638
2639bool CommandInterpreter::WasInterrupted() const {
2640 bool was_interrupted =
2641 (m_command_state == CommandHandlingState::eInterrupted);
2642 lldbassert(!was_interrupted || m_iohandler_nesting_level > 0)lldb_private::lldb_assert(!was_interrupted || m_iohandler_nesting_level
> 0, "!was_interrupted || m_iohandler_nesting_level > 0"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 2642)
;
2643 return was_interrupted;
2644}
2645
2646void CommandInterpreter::PrintCommandOutput(Stream &stream,
2647 llvm::StringRef str) {
2648 // Split the output into lines and poll for interrupt requests
2649 const char *data = str.data();
2650 size_t size = str.size();
2651 while (size > 0 && !WasInterrupted()) {
2652 size_t chunk_size = 0;
2653 for (; chunk_size < size; ++chunk_size) {
2654 lldbassert(data[chunk_size] != '\0')lldb_private::lldb_assert(data[chunk_size] != '\0', "data[chunk_size] != '\\0'"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 2654)
;
2655 if (data[chunk_size] == '\n') {
2656 ++chunk_size;
2657 break;
2658 }
2659 }
2660 chunk_size = stream.Write(data, chunk_size);
2661 lldbassert(size >= chunk_size)lldb_private::lldb_assert(size >= chunk_size, "size >= chunk_size"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 2661)
;
2662 data += chunk_size;
2663 size -= chunk_size;
2664 }
2665 if (size > 0) {
2666 stream.Printf("\n... Interrupted.\n");
2667 }
2668}
2669
2670void CommandInterpreter::IOHandlerInputComplete(IOHandler &io_handler,
2671 std::string &line) {
2672 // If we were interrupted, bail out...
2673 if (WasInterrupted())
2674 return;
2675
2676 const bool is_interactive = io_handler.GetIsInteractive();
2677 if (is_interactive == false) {
2678 // When we are not interactive, don't execute blank lines. This will happen
2679 // sourcing a commands file. We don't want blank lines to repeat the
2680 // previous command and cause any errors to occur (like redefining an
2681 // alias, get an error and stop parsing the commands file).
2682 if (line.empty())
2683 return;
2684
2685 // When using a non-interactive file handle (like when sourcing commands
2686 // from a file) we need to echo the command out so we don't just see the
2687 // command output and no command...
2688 if (io_handler.GetFlags().Test(eHandleCommandFlagEchoCommand))
2689 io_handler.GetOutputStreamFile()->Printf("%s%s\n", io_handler.GetPrompt(),
2690 line.c_str());
2691 }
2692
2693 StartHandlingCommand();
2694
2695 lldb_private::CommandReturnObject result;
2696 HandleCommand(line.c_str(), eLazyBoolCalculate, result);
2697
2698 // Now emit the command output text from the command we just executed
2699 if (io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) {
2700 // Display any STDOUT/STDERR _prior_ to emitting the command result text
2701 GetProcessOutput();
2702
2703 if (!result.GetImmediateOutputStream()) {
2704 llvm::StringRef output = result.GetOutputData();
2705 PrintCommandOutput(*io_handler.GetOutputStreamFile(), output);
2706 }
2707
2708 // Now emit the command error text from the command we just executed
2709 if (!result.GetImmediateErrorStream()) {
2710 llvm::StringRef error = result.GetErrorData();
2711 PrintCommandOutput(*io_handler.GetErrorStreamFile(), error);
2712 }
2713 }
2714
2715 FinishHandlingCommand();
2716
2717 switch (result.GetStatus()) {
2718 case eReturnStatusInvalid:
2719 case eReturnStatusSuccessFinishNoResult:
2720 case eReturnStatusSuccessFinishResult:
2721 case eReturnStatusStarted:
2722 break;
2723
2724 case eReturnStatusSuccessContinuingNoResult:
2725 case eReturnStatusSuccessContinuingResult:
2726 if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnContinue))
2727 io_handler.SetIsDone(true);
2728 break;
2729
2730 case eReturnStatusFailed:
2731 m_num_errors++;
2732 if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnError))
2733 io_handler.SetIsDone(true);
2734 break;
2735
2736 case eReturnStatusQuit:
2737 m_quit_requested = true;
2738 io_handler.SetIsDone(true);
2739 break;
2740 }
2741
2742 // Finally, if we're going to stop on crash, check that here:
2743 if (!m_quit_requested && result.GetDidChangeProcessState() &&
2744 io_handler.GetFlags().Test(eHandleCommandFlagStopOnCrash)) {
2745 bool should_stop = false;
2746 TargetSP target_sp(m_debugger.GetTargetList().GetSelectedTarget());
2747 if (target_sp) {
2748 ProcessSP process_sp(target_sp->GetProcessSP());
2749 if (process_sp) {
2750 for (ThreadSP thread_sp : process_sp->GetThreadList().Threads()) {
2751 StopReason reason = thread_sp->GetStopReason();
2752 if ((reason == eStopReasonSignal || reason == eStopReasonException ||
2753 reason == eStopReasonInstrumentation) &&
2754 !result.GetAbnormalStopWasExpected()) {
2755 should_stop = true;
2756 break;
2757 }
2758 }
2759 }
2760 }
2761 if (should_stop) {
2762 io_handler.SetIsDone(true);
2763 m_stopped_for_crash = true;
2764 }
2765 }
2766}
2767
2768bool CommandInterpreter::IOHandlerInterrupt(IOHandler &io_handler) {
2769 ExecutionContext exe_ctx(GetExecutionContext());
2770 Process *process = exe_ctx.GetProcessPtr();
2771
2772 if (InterruptCommand())
2773 return true;
2774
2775 if (process) {
2776 StateType state = process->GetState();
2777 if (StateIsRunningState(state)) {
2778 process->Halt();
2779 return true; // Don't do any updating when we are running
2780 }
2781 }
2782
2783 ScriptInterpreter *script_interpreter = GetScriptInterpreter(false);
2784 if (script_interpreter) {
2785 if (script_interpreter->Interrupt())
2786 return true;
2787 }
2788 return false;
2789}
2790
2791void CommandInterpreter::GetLLDBCommandsFromIOHandler(
2792 const char *prompt, IOHandlerDelegate &delegate, bool asynchronously,
2793 void *baton) {
2794 Debugger &debugger = GetDebugger();
2795 IOHandlerSP io_handler_sp(
2796 new IOHandlerEditline(debugger, IOHandler::Type::CommandList,
2797 "lldb", // Name of input reader for history
2798 llvm::StringRef::withNullAsEmpty(prompt), // Prompt
2799 llvm::StringRef(), // Continuation prompt
2800 true, // Get multiple lines
2801 debugger.GetUseColor(),
2802 0, // Don't show line numbers
2803 delegate)); // IOHandlerDelegate
2804
2805 if (io_handler_sp) {
2806 io_handler_sp->SetUserData(baton);
2807 if (asynchronously)
2808 debugger.PushIOHandler(io_handler_sp);
2809 else
2810 debugger.RunIOHandler(io_handler_sp);
2811 }
2812}
2813
2814void CommandInterpreter::GetPythonCommandsFromIOHandler(
2815 const char *prompt, IOHandlerDelegate &delegate, bool asynchronously,
2816 void *baton) {
2817 Debugger &debugger = GetDebugger();
2818 IOHandlerSP io_handler_sp(
2819 new IOHandlerEditline(debugger, IOHandler::Type::PythonCode,
2820 "lldb-python", // Name of input reader for history
2821 llvm::StringRef::withNullAsEmpty(prompt), // Prompt
2822 llvm::StringRef(), // Continuation prompt
2823 true, // Get multiple lines
2824 debugger.GetUseColor(),
2825 0, // Don't show line numbers
2826 delegate)); // IOHandlerDelegate
2827
2828 if (io_handler_sp) {
2829 io_handler_sp->SetUserData(baton);
2830 if (asynchronously)
2831 debugger.PushIOHandler(io_handler_sp);
2832 else
2833 debugger.RunIOHandler(io_handler_sp);
2834 }
2835}
2836
2837bool CommandInterpreter::IsActive() {
2838 return m_debugger.IsTopIOHandler(m_command_io_handler_sp);
2839}
2840
2841lldb::IOHandlerSP
2842CommandInterpreter::GetIOHandler(bool force_create,
2843 CommandInterpreterRunOptions *options) {
2844 // Always re-create the IOHandlerEditline in case the input changed. The old
2845 // instance might have had a non-interactive input and now it does or vice
2846 // versa.
2847 if (force_create || !m_command_io_handler_sp) {
2848 // Always re-create the IOHandlerEditline in case the input changed. The
2849 // old instance might have had a non-interactive input and now it does or
2850 // vice versa.
2851 uint32_t flags = 0;
2852
2853 if (options) {
2854 if (options->m_stop_on_continue == eLazyBoolYes)
2855 flags |= eHandleCommandFlagStopOnContinue;
2856 if (options->m_stop_on_error == eLazyBoolYes)
2857 flags |= eHandleCommandFlagStopOnError;
2858 if (options->m_stop_on_crash == eLazyBoolYes)
2859 flags |= eHandleCommandFlagStopOnCrash;
2860 if (options->m_echo_commands != eLazyBoolNo)
2861 flags |= eHandleCommandFlagEchoCommand;
2862 if (options->m_print_results != eLazyBoolNo)
2863 flags |= eHandleCommandFlagPrintResult;
2864 } else {
2865 flags = eHandleCommandFlagEchoCommand | eHandleCommandFlagPrintResult;
2866 }
2867
2868 m_command_io_handler_sp.reset(new IOHandlerEditline(
2869 m_debugger, IOHandler::Type::CommandInterpreter,
2870 m_debugger.GetInputFile(), m_debugger.GetOutputFile(),
2871 m_debugger.GetErrorFile(), flags, "lldb", m_debugger.GetPrompt(),
2872 llvm::StringRef(), // Continuation prompt
2873 false, // Don't enable multiple line input, just single line commands
2874 m_debugger.GetUseColor(),
2875 0, // Don't show line numbers
2876 *this));
2877 }
2878 return m_command_io_handler_sp;
2879}
2880
2881void CommandInterpreter::RunCommandInterpreter(
2882 bool auto_handle_events, bool spawn_thread,
2883 CommandInterpreterRunOptions &options) {
2884 // Always re-create the command interpreter when we run it in case any file
2885 // handles have changed.
2886 bool force_create = true;
2887 m_debugger.PushIOHandler(GetIOHandler(force_create, &options));
2888 m_stopped_for_crash = false;
2889
2890 if (auto_handle_events)
2891 m_debugger.StartEventHandlerThread();
2892
2893 if (spawn_thread) {
2894 m_debugger.StartIOHandlerThread();
2895 } else {
2896 m_debugger.ExecuteIOHandlers();
2897
2898 if (auto_handle_events)
2899 m_debugger.StopEventHandlerThread();
2900 }
2901}
2902
2903CommandObject *
2904CommandInterpreter::ResolveCommandImpl(std::string &command_line,
2905 CommandReturnObject &result) {
2906 std::string scratch_command(command_line); // working copy so we don't modify
2907 // command_line unless we succeed
2908 CommandObject *cmd_obj = nullptr;
2909 StreamString revised_command_line;
2910 bool wants_raw_input = false;
2911 size_t actual_cmd_name_len = 0;
2912 std::string next_word;
2913 StringList matches;
2914 bool done = false;
2915 while (!done) {
2916 char quote_char = '\0';
2917 std::string suffix;
2918 ExtractCommand(scratch_command, next_word, suffix, quote_char);
2919 if (cmd_obj == nullptr) {
2920 std::string full_name;
2921 bool is_alias = GetAliasFullName(next_word, full_name);
2922 cmd_obj = GetCommandObject(next_word, &matches);
2923 bool is_real_command =
2924 (is_alias == false) ||
2925 (cmd_obj != nullptr && cmd_obj->IsAlias() == false);
2926 if (!is_real_command) {
2927 matches.Clear();
2928 std::string alias_result;
2929 cmd_obj =
2930 BuildAliasResult(full_name, scratch_command, alias_result, result);
2931 revised_command_line.Printf("%s", alias_result.c_str());
2932 if (cmd_obj) {
2933 wants_raw_input = cmd_obj->WantsRawCommandString();
2934 actual_cmd_name_len = cmd_obj->GetCommandName().size();
2935 }
2936 } else {
2937 if (cmd_obj) {
2938 llvm::StringRef cmd_name = cmd_obj->GetCommandName();
2939 actual_cmd_name_len += cmd_name.size();
2940 revised_command_line.Printf("%s", cmd_name.str().c_str());
2941 wants_raw_input = cmd_obj->WantsRawCommandString();
2942 } else {
2943 revised_command_line.Printf("%s", next_word.c_str());
2944 }
2945 }
2946 } else {
2947 if (cmd_obj->IsMultiwordObject()) {
2948 CommandObject *sub_cmd_obj =
2949 cmd_obj->GetSubcommandObject(next_word.c_str());
2950 if (sub_cmd_obj) {
2951 // The subcommand's name includes the parent command's name, so
2952 // restart rather than append to the revised_command_line.
2953 llvm::StringRef sub_cmd_name = sub_cmd_obj->GetCommandName();
2954 actual_cmd_name_len = sub_cmd_name.size() + 1;
2955 revised_command_line.Clear();
2956 revised_command_line.Printf("%s", sub_cmd_name.str().c_str());
2957 cmd_obj = sub_cmd_obj;
2958 wants_raw_input = cmd_obj->WantsRawCommandString();
2959 } else {
2960 if (quote_char)
2961 revised_command_line.Printf(" %c%s%s%c", quote_char,
2962 next_word.c_str(), suffix.c_str(),
2963 quote_char);
2964 else
2965 revised_command_line.Printf(" %s%s", next_word.c_str(),
2966 suffix.c_str());
2967 done = true;
2968 }
2969 } else {
2970 if (quote_char)
2971 revised_command_line.Printf(" %c%s%s%c", quote_char,
2972 next_word.c_str(), suffix.c_str(),
2973 quote_char);
2974 else
2975 revised_command_line.Printf(" %s%s", next_word.c_str(),
2976 suffix.c_str());
2977 done = true;
2978 }
2979 }
2980
2981 if (cmd_obj == nullptr) {
2982 const size_t num_matches = matches.GetSize();
2983 if (matches.GetSize() > 1) {
2984 StreamString error_msg;
2985 error_msg.Printf("Ambiguous command '%s'. Possible matches:\n",
2986 next_word.c_str());
2987
2988 for (uint32_t i = 0; i < num_matches; ++i) {
2989 error_msg.Printf("\t%s\n", matches.GetStringAtIndex(i));
2990 }
2991 result.AppendRawError(error_msg.GetString());
2992 } else {
2993 // We didn't have only one match, otherwise we wouldn't get here.
2994 lldbassert(num_matches == 0)lldb_private::lldb_assert(num_matches == 0, "num_matches == 0"
, __FUNCTION__, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Interpreter/CommandInterpreter.cpp"
, 2994)
;
2995 result.AppendErrorWithFormat("'%s' is not a valid command.\n",
2996 next_word.c_str());
2997 }
2998 result.SetStatus(eReturnStatusFailed);
2999 return nullptr;
3000 }
3001
3002 if (cmd_obj->IsMultiwordObject()) {
3003 if (!suffix.empty()) {
3004 result.AppendErrorWithFormat(
3005 "command '%s' did not recognize '%s%s%s' as valid (subcommand "
3006 "might be invalid).\n",
3007 cmd_obj->GetCommandName().str().c_str(),
3008 next_word.empty() ? "" : next_word.c_str(),
3009 next_word.empty() ? " -- " : " ", suffix.c_str());
3010 result.SetStatus(eReturnStatusFailed);
3011 return nullptr;
3012 }
3013 } else {
3014 // If we found a normal command, we are done
3015 done = true;
3016 if (!suffix.empty()) {
3017 switch (suffix[0]) {
3018 case '/':
3019 // GDB format suffixes
3020 {
3021 Options *command_options = cmd_obj->GetOptions();
3022 if (command_options &&
3023 command_options->SupportsLongOption("gdb-format")) {
3024 std::string gdb_format_option("--gdb-format=");
3025 gdb_format_option += (suffix.c_str() + 1);
3026
3027 std::string cmd = revised_command_line.GetString();
3028 size_t arg_terminator_idx = FindArgumentTerminator(cmd);
3029 if (arg_terminator_idx != std::string::npos) {
3030 // Insert the gdb format option before the "--" that terminates
3031 // options
3032 gdb_format_option.append(1, ' ');
3033 cmd.insert(arg_terminator_idx, gdb_format_option);
3034 revised_command_line.Clear();
3035 revised_command_line.PutCString(cmd);
3036 } else
3037 revised_command_line.Printf(" %s", gdb_format_option.c_str());
3038
3039 if (wants_raw_input &&
3040 FindArgumentTerminator(cmd) == std::string::npos)
3041 revised_command_line.PutCString(" --");
3042 } else {
3043 result.AppendErrorWithFormat(
3044 "the '%s' command doesn't support the --gdb-format option\n",
3045 cmd_obj->GetCommandName().str().c_str());
3046 result.SetStatus(eReturnStatusFailed);
3047 return nullptr;
3048 }
3049 }
3050 break;
3051
3052 default:
3053 result.AppendErrorWithFormat(
3054 "unknown command shorthand suffix: '%s'\n", suffix.c_str());
3055 result.SetStatus(eReturnStatusFailed);
3056 return nullptr;
3057 }
3058 }
3059 }
3060 if (scratch_command.empty())
3061 done = true;
3062 }
3063
3064 if (!scratch_command.empty())
3065 revised_command_line.Printf(" %s", scratch_command.c_str());
3066
3067 if (cmd_obj != NULL__null)
3068 command_line = revised_command_line.GetString();
3069
3070 return cmd_obj;
3071}