1 //===-- Debugger.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 "lldb/lldb-python.h"
11 
12 #include "lldb/API/SBDebugger.h"
13 
14 #include "lldb/Core/Debugger.h"
15 
16 #include <map>
17 
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/Type.h"
20 
21 #include "lldb/lldb-private.h"
22 #include "lldb/Core/ConnectionFileDescriptor.h"
23 #include "lldb/Core/InputReader.h"
24 #include "lldb/Core/Module.h"
25 #include "lldb/Core/PluginManager.h"
26 #include "lldb/Core/RegisterValue.h"
27 #include "lldb/Core/State.h"
28 #include "lldb/Core/StreamAsynchronousIO.h"
29 #include "lldb/Core/StreamCallback.h"
30 #include "lldb/Core/StreamString.h"
31 #include "lldb/Core/Timer.h"
32 #include "lldb/Core/ValueObject.h"
33 #include "lldb/Core/ValueObjectVariable.h"
34 #include "lldb/DataFormatters/DataVisualization.h"
35 #include "lldb/DataFormatters/FormatManager.h"
36 #include "lldb/Host/DynamicLibrary.h"
37 #include "lldb/Host/Terminal.h"
38 #include "lldb/Interpreter/CommandInterpreter.h"
39 #include "lldb/Interpreter/OptionValueSInt64.h"
40 #include "lldb/Interpreter/OptionValueString.h"
41 #include "lldb/Symbol/ClangASTContext.h"
42 #include "lldb/Symbol/CompileUnit.h"
43 #include "lldb/Symbol/Function.h"
44 #include "lldb/Symbol/Symbol.h"
45 #include "lldb/Symbol/VariableList.h"
46 #include "lldb/Target/TargetList.h"
47 #include "lldb/Target/Process.h"
48 #include "lldb/Target/RegisterContext.h"
49 #include "lldb/Target/StopInfo.h"
50 #include "lldb/Target/Target.h"
51 #include "lldb/Target/Thread.h"
52 #include "lldb/Utility/AnsiTerminal.h"
53 
54 using namespace lldb;
55 using namespace lldb_private;
56 
57 
58 static uint32_t g_shared_debugger_refcount = 0;
59 static lldb::user_id_t g_unique_id = 1;
60 
61 #pragma mark Static Functions
62 
63 static Mutex &
64 GetDebuggerListMutex ()
65 {
66     static Mutex g_mutex(Mutex::eMutexTypeRecursive);
67     return g_mutex;
68 }
69 
70 typedef std::vector<DebuggerSP> DebuggerList;
71 
72 static DebuggerList &
73 GetDebuggerList()
74 {
75     // hide the static debugger list inside a singleton accessor to avoid
76     // global init contructors
77     static DebuggerList g_list;
78     return g_list;
79 }
80 
81 OptionEnumValueElement
82 g_show_disassembly_enum_values[] =
83 {
84     { Debugger::eStopDisassemblyTypeNever,    "never",     "Never show disassembly when displaying a stop context."},
85     { Debugger::eStopDisassemblyTypeNoSource, "no-source", "Show disassembly when there is no source information, or the source file is missing when displaying a stop context."},
86     { Debugger::eStopDisassemblyTypeAlways,   "always",    "Always show disassembly when displaying a stop context."},
87     { 0, NULL, NULL }
88 };
89 
90 OptionEnumValueElement
91 g_language_enumerators[] =
92 {
93     { eScriptLanguageNone,      "none",     "Disable scripting languages."},
94     { eScriptLanguagePython,    "python",   "Select python as the default scripting language."},
95     { eScriptLanguageDefault,   "default",  "Select the lldb default as the default scripting language."},
96     { 0, NULL, NULL }
97 };
98 
99 #define MODULE_WITH_FUNC "{ ${module.file.basename}{`${function.name-with-args}${function.pc-offset}}}"
100 #define FILE_AND_LINE "{ at ${line.file.basename}:${line.number}}"
101 
102 #define DEFAULT_THREAD_FORMAT "thread #${thread.index}: tid = ${thread.id}"\
103     "{, ${frame.pc}}"\
104     MODULE_WITH_FUNC\
105     FILE_AND_LINE\
106     "{, name = '${thread.name}}"\
107     "{, queue = '${thread.queue}}"\
108     "{, stop reason = ${thread.stop-reason}}"\
109     "{\\nReturn value: ${thread.return-value}}"\
110     "\\n"
111 
112 #define DEFAULT_FRAME_FORMAT "frame #${frame.index}: ${frame.pc}"\
113     MODULE_WITH_FUNC\
114     FILE_AND_LINE\
115     "\\n"
116 
117 
118 
119 static PropertyDefinition
120 g_properties[] =
121 {
122 {   "auto-confirm",             OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true all confirmation prompts will receive their default reply." },
123 {   "frame-format",             OptionValue::eTypeString , true, 0    , DEFAULT_FRAME_FORMAT, NULL, "The default frame format string to use when displaying stack frame information for threads." },
124 {   "notify-void",              OptionValue::eTypeBoolean, true, false, NULL, NULL, "Notify the user explicitly if an expression returns void (default: false)." },
125 {   "prompt",                   OptionValue::eTypeString , true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", NULL, "The debugger command line prompt displayed for the user." },
126 {   "script-lang",              OptionValue::eTypeEnum   , true, eScriptLanguagePython, NULL, g_language_enumerators, "The script language to be used for evaluating user-written scripts." },
127 {   "stop-disassembly-count",   OptionValue::eTypeSInt64 , true, 4    , NULL, NULL, "The number of disassembly lines to show when displaying a stopped context." },
128 {   "stop-disassembly-display", OptionValue::eTypeEnum   , true, Debugger::eStopDisassemblyTypeNoSource, NULL, g_show_disassembly_enum_values, "Control when to display disassembly when displaying a stopped context." },
129 {   "stop-line-count-after",    OptionValue::eTypeSInt64 , true, 3    , NULL, NULL, "The number of sources lines to display that come after the current source line when displaying a stopped context." },
130 {   "stop-line-count-before",   OptionValue::eTypeSInt64 , true, 3    , NULL, NULL, "The number of sources lines to display that come before the current source line when displaying a stopped context." },
131 {   "term-width",               OptionValue::eTypeSInt64 , true, 80   , NULL, NULL, "The maximum number of columns to use for displaying text." },
132 {   "thread-format",            OptionValue::eTypeString , true, 0    , DEFAULT_THREAD_FORMAT, NULL, "The default thread format string to use when displaying thread information." },
133 {   "use-external-editor",      OptionValue::eTypeBoolean, true, false, NULL, NULL, "Whether to use an external editor or not." },
134 {   "use-color",                OptionValue::eTypeBoolean, true, true , NULL, NULL, "Whether to use Ansi color codes or not." },
135 
136     {   NULL,                       OptionValue::eTypeInvalid, true, 0    , NULL, NULL, NULL }
137 };
138 
139 enum
140 {
141     ePropertyAutoConfirm = 0,
142     ePropertyFrameFormat,
143     ePropertyNotiftVoid,
144     ePropertyPrompt,
145     ePropertyScriptLanguage,
146     ePropertyStopDisassemblyCount,
147     ePropertyStopDisassemblyDisplay,
148     ePropertyStopLineCountAfter,
149     ePropertyStopLineCountBefore,
150     ePropertyTerminalWidth,
151     ePropertyThreadFormat,
152     ePropertyUseExternalEditor,
153     ePropertyUseColor,
154 };
155 
156 //
157 //const char *
158 //Debugger::GetFrameFormat() const
159 //{
160 //    return m_properties_sp->GetFrameFormat();
161 //}
162 //const char *
163 //Debugger::GetThreadFormat() const
164 //{
165 //    return m_properties_sp->GetThreadFormat();
166 //}
167 //
168 
169 
170 Error
171 Debugger::SetPropertyValue (const ExecutionContext *exe_ctx,
172                             VarSetOperationType op,
173                             const char *property_path,
174                             const char *value)
175 {
176     bool is_load_script = strcmp(property_path,"target.load-script-from-symbol-file") == 0;
177     TargetSP target_sp;
178     LoadScriptFromSymFile load_script_old_value;
179     if (is_load_script && exe_ctx->GetTargetSP())
180     {
181         target_sp = exe_ctx->GetTargetSP();
182         load_script_old_value = target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
183     }
184     Error error (Properties::SetPropertyValue (exe_ctx, op, property_path, value));
185     if (error.Success())
186     {
187         // FIXME it would be nice to have "on-change" callbacks for properties
188         if (strcmp(property_path, g_properties[ePropertyPrompt].name) == 0)
189         {
190             const char *new_prompt = GetPrompt();
191             std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor());
192             if (str.length())
193                 new_prompt = str.c_str();
194             EventSP prompt_change_event_sp (new Event(CommandInterpreter::eBroadcastBitResetPrompt, new EventDataBytes (new_prompt)));
195             GetCommandInterpreter().BroadcastEvent (prompt_change_event_sp);
196         }
197         else if (strcmp(property_path, g_properties[ePropertyUseColor].name) == 0)
198         {
199 			// use-color changed. Ping the prompt so it can reset the ansi terminal codes.
200             SetPrompt (GetPrompt());
201         }
202         else if (is_load_script && target_sp && load_script_old_value == eLoadScriptFromSymFileWarn)
203         {
204             if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() == eLoadScriptFromSymFileTrue)
205             {
206                 std::list<Error> errors;
207                 StreamString feedback_stream;
208                 if (!target_sp->LoadScriptingResources(errors,&feedback_stream))
209                 {
210                     for (auto error : errors)
211                     {
212                         GetErrorStream().Printf("%s\n",error.AsCString());
213                     }
214                     if (feedback_stream.GetSize())
215                         GetErrorStream().Printf("%s",feedback_stream.GetData());
216                 }
217             }
218         }
219     }
220     return error;
221 }
222 
223 bool
224 Debugger::GetAutoConfirm () const
225 {
226     const uint32_t idx = ePropertyAutoConfirm;
227     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
228 }
229 
230 const char *
231 Debugger::GetFrameFormat() const
232 {
233     const uint32_t idx = ePropertyFrameFormat;
234     return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value);
235 }
236 
237 bool
238 Debugger::GetNotifyVoid () const
239 {
240     const uint32_t idx = ePropertyNotiftVoid;
241     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
242 }
243 
244 const char *
245 Debugger::GetPrompt() const
246 {
247     const uint32_t idx = ePropertyPrompt;
248     return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value);
249 }
250 
251 void
252 Debugger::SetPrompt(const char *p)
253 {
254     const uint32_t idx = ePropertyPrompt;
255     m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p);
256     const char *new_prompt = GetPrompt();
257     std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor());
258     if (str.length())
259         new_prompt = str.c_str();
260     EventSP prompt_change_event_sp (new Event(CommandInterpreter::eBroadcastBitResetPrompt, new EventDataBytes (new_prompt)));;
261     GetCommandInterpreter().BroadcastEvent (prompt_change_event_sp);
262 }
263 
264 const char *
265 Debugger::GetThreadFormat() const
266 {
267     const uint32_t idx = ePropertyThreadFormat;
268     return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value);
269 }
270 
271 lldb::ScriptLanguage
272 Debugger::GetScriptLanguage() const
273 {
274     const uint32_t idx = ePropertyScriptLanguage;
275     return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
276 }
277 
278 bool
279 Debugger::SetScriptLanguage (lldb::ScriptLanguage script_lang)
280 {
281     const uint32_t idx = ePropertyScriptLanguage;
282     return m_collection_sp->SetPropertyAtIndexAsEnumeration (NULL, idx, script_lang);
283 }
284 
285 uint32_t
286 Debugger::GetTerminalWidth () const
287 {
288     const uint32_t idx = ePropertyTerminalWidth;
289     return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
290 }
291 
292 bool
293 Debugger::SetTerminalWidth (uint32_t term_width)
294 {
295     const uint32_t idx = ePropertyTerminalWidth;
296     return m_collection_sp->SetPropertyAtIndexAsSInt64 (NULL, idx, term_width);
297 }
298 
299 bool
300 Debugger::GetUseExternalEditor () const
301 {
302     const uint32_t idx = ePropertyUseExternalEditor;
303     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
304 }
305 
306 bool
307 Debugger::SetUseExternalEditor (bool b)
308 {
309     const uint32_t idx = ePropertyUseExternalEditor;
310     return m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
311 }
312 
313 bool
314 Debugger::GetUseColor () const
315 {
316     const uint32_t idx = ePropertyUseColor;
317     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
318 }
319 
320 bool
321 Debugger::SetUseColor (bool b)
322 {
323     const uint32_t idx = ePropertyUseColor;
324     bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
325     SetPrompt (GetPrompt());
326     return ret;
327 }
328 
329 uint32_t
330 Debugger::GetStopSourceLineCount (bool before) const
331 {
332     const uint32_t idx = before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
333     return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
334 }
335 
336 Debugger::StopDisassemblyType
337 Debugger::GetStopDisassemblyDisplay () const
338 {
339     const uint32_t idx = ePropertyStopDisassemblyDisplay;
340     return (Debugger::StopDisassemblyType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
341 }
342 
343 uint32_t
344 Debugger::GetDisassemblyLineCount () const
345 {
346     const uint32_t idx = ePropertyStopDisassemblyCount;
347     return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
348 }
349 
350 #pragma mark Debugger
351 
352 //const DebuggerPropertiesSP &
353 //Debugger::GetSettings() const
354 //{
355 //    return m_properties_sp;
356 //}
357 //
358 
359 int
360 Debugger::TestDebuggerRefCount ()
361 {
362     return g_shared_debugger_refcount;
363 }
364 
365 void
366 Debugger::Initialize ()
367 {
368     if (g_shared_debugger_refcount++ == 0)
369         lldb_private::Initialize();
370 }
371 
372 void
373 Debugger::Terminate ()
374 {
375     if (g_shared_debugger_refcount > 0)
376     {
377         g_shared_debugger_refcount--;
378         if (g_shared_debugger_refcount == 0)
379         {
380             lldb_private::WillTerminate();
381             lldb_private::Terminate();
382 
383             // Clear our master list of debugger objects
384             Mutex::Locker locker (GetDebuggerListMutex ());
385             GetDebuggerList().clear();
386         }
387     }
388 }
389 
390 void
391 Debugger::SettingsInitialize ()
392 {
393     Target::SettingsInitialize ();
394 }
395 
396 void
397 Debugger::SettingsTerminate ()
398 {
399     Target::SettingsTerminate ();
400 }
401 
402 bool
403 Debugger::LoadPlugin (const FileSpec& spec, Error& error)
404 {
405     lldb::DynamicLibrarySP dynlib_sp(new lldb_private::DynamicLibrary(spec));
406     if (!dynlib_sp || dynlib_sp->IsValid() == false)
407     {
408         if (spec.Exists())
409             error.SetErrorString("this file does not represent a loadable dylib");
410         else
411             error.SetErrorString("no such file");
412         return false;
413     }
414     lldb::DebuggerSP debugger_sp(shared_from_this());
415     lldb::SBDebugger debugger_sb(debugger_sp);
416     // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays
417     LLDBCommandPluginInit init_func = dynlib_sp->GetSymbol<LLDBCommandPluginInit>("_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
418     if (!init_func)
419     {
420         error.SetErrorString("cannot find the initialization function lldb::PluginInitialize(lldb::SBDebugger)");
421         return false;
422     }
423     if (init_func(debugger_sb))
424     {
425         m_loaded_plugins.push_back(dynlib_sp);
426         return true;
427     }
428     error.SetErrorString("dylib refused to be loaded");
429     return false;
430 }
431 
432 static FileSpec::EnumerateDirectoryResult
433 LoadPluginCallback
434 (
435  void *baton,
436  FileSpec::FileType file_type,
437  const FileSpec &file_spec
438  )
439 {
440     Error error;
441 
442     static ConstString g_dylibext("dylib");
443 
444     if (!baton)
445         return FileSpec::eEnumerateDirectoryResultQuit;
446 
447     Debugger *debugger = (Debugger*)baton;
448 
449     // If we have a regular file, a symbolic link or unknown file type, try
450     // and process the file. We must handle unknown as sometimes the directory
451     // enumeration might be enumerating a file system that doesn't have correct
452     // file type information.
453     if (file_type == FileSpec::eFileTypeRegular         ||
454         file_type == FileSpec::eFileTypeSymbolicLink    ||
455         file_type == FileSpec::eFileTypeUnknown          )
456     {
457         FileSpec plugin_file_spec (file_spec);
458         plugin_file_spec.ResolvePath ();
459 
460         if (plugin_file_spec.GetFileNameExtension() != g_dylibext)
461             return FileSpec::eEnumerateDirectoryResultNext;
462 
463         Error plugin_load_error;
464         debugger->LoadPlugin (plugin_file_spec, plugin_load_error);
465 
466         return FileSpec::eEnumerateDirectoryResultNext;
467     }
468 
469     else if (file_type == FileSpec::eFileTypeUnknown     ||
470         file_type == FileSpec::eFileTypeDirectory   ||
471         file_type == FileSpec::eFileTypeSymbolicLink )
472     {
473         // Try and recurse into anything that a directory or symbolic link.
474         // We must also do this for unknown as sometimes the directory enumeration
475         // might be enurating a file system that doesn't have correct file type
476         // information.
477         return FileSpec::eEnumerateDirectoryResultEnter;
478     }
479 
480     return FileSpec::eEnumerateDirectoryResultNext;
481 }
482 
483 void
484 Debugger::InstanceInitialize ()
485 {
486     FileSpec dir_spec;
487     const bool find_directories = true;
488     const bool find_files = true;
489     const bool find_other = true;
490     char dir_path[PATH_MAX];
491     if (Host::GetLLDBPath (ePathTypeLLDBSystemPlugins, dir_spec))
492     {
493         if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path)))
494         {
495             FileSpec::EnumerateDirectory (dir_path,
496                                           find_directories,
497                                           find_files,
498                                           find_other,
499                                           LoadPluginCallback,
500                                           this);
501         }
502     }
503 
504     if (Host::GetLLDBPath (ePathTypeLLDBUserPlugins, dir_spec))
505     {
506         if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path)))
507         {
508             FileSpec::EnumerateDirectory (dir_path,
509                                           find_directories,
510                                           find_files,
511                                           find_other,
512                                           LoadPluginCallback,
513                                           this);
514         }
515     }
516 
517     PluginManager::DebuggerInitialize (*this);
518 }
519 
520 DebuggerSP
521 Debugger::CreateInstance (lldb::LogOutputCallback log_callback, void *baton)
522 {
523     DebuggerSP debugger_sp (new Debugger(log_callback, baton));
524     if (g_shared_debugger_refcount > 0)
525     {
526         Mutex::Locker locker (GetDebuggerListMutex ());
527         GetDebuggerList().push_back(debugger_sp);
528     }
529     debugger_sp->InstanceInitialize ();
530     return debugger_sp;
531 }
532 
533 void
534 Debugger::Destroy (DebuggerSP &debugger_sp)
535 {
536     if (debugger_sp.get() == NULL)
537         return;
538 
539     debugger_sp->Clear();
540 
541     if (g_shared_debugger_refcount > 0)
542     {
543         Mutex::Locker locker (GetDebuggerListMutex ());
544         DebuggerList &debugger_list = GetDebuggerList ();
545         DebuggerList::iterator pos, end = debugger_list.end();
546         for (pos = debugger_list.begin (); pos != end; ++pos)
547         {
548             if ((*pos).get() == debugger_sp.get())
549             {
550                 debugger_list.erase (pos);
551                 return;
552             }
553         }
554     }
555 }
556 
557 DebuggerSP
558 Debugger::FindDebuggerWithInstanceName (const ConstString &instance_name)
559 {
560     DebuggerSP debugger_sp;
561     if (g_shared_debugger_refcount > 0)
562     {
563         Mutex::Locker locker (GetDebuggerListMutex ());
564         DebuggerList &debugger_list = GetDebuggerList();
565         DebuggerList::iterator pos, end = debugger_list.end();
566 
567         for (pos = debugger_list.begin(); pos != end; ++pos)
568         {
569             if ((*pos).get()->m_instance_name == instance_name)
570             {
571                 debugger_sp = *pos;
572                 break;
573             }
574         }
575     }
576     return debugger_sp;
577 }
578 
579 TargetSP
580 Debugger::FindTargetWithProcessID (lldb::pid_t pid)
581 {
582     TargetSP target_sp;
583     if (g_shared_debugger_refcount > 0)
584     {
585         Mutex::Locker locker (GetDebuggerListMutex ());
586         DebuggerList &debugger_list = GetDebuggerList();
587         DebuggerList::iterator pos, end = debugger_list.end();
588         for (pos = debugger_list.begin(); pos != end; ++pos)
589         {
590             target_sp = (*pos)->GetTargetList().FindTargetWithProcessID (pid);
591             if (target_sp)
592                 break;
593         }
594     }
595     return target_sp;
596 }
597 
598 TargetSP
599 Debugger::FindTargetWithProcess (Process *process)
600 {
601     TargetSP target_sp;
602     if (g_shared_debugger_refcount > 0)
603     {
604         Mutex::Locker locker (GetDebuggerListMutex ());
605         DebuggerList &debugger_list = GetDebuggerList();
606         DebuggerList::iterator pos, end = debugger_list.end();
607         for (pos = debugger_list.begin(); pos != end; ++pos)
608         {
609             target_sp = (*pos)->GetTargetList().FindTargetWithProcess (process);
610             if (target_sp)
611                 break;
612         }
613     }
614     return target_sp;
615 }
616 
617 Debugger::Debugger (lldb::LogOutputCallback log_callback, void *baton) :
618     UserID (g_unique_id++),
619     Properties(OptionValuePropertiesSP(new OptionValueProperties())),
620     m_input_comm("debugger.input"),
621     m_input_file (),
622     m_output_file (),
623     m_error_file (),
624     m_terminal_state (),
625     m_target_list (*this),
626     m_platform_list (),
627     m_listener ("lldb.Debugger"),
628     m_source_manager_ap(),
629     m_source_file_cache(),
630     m_command_interpreter_ap (new CommandInterpreter (*this, eScriptLanguageDefault, false)),
631     m_input_reader_stack (),
632     m_input_reader_data (),
633     m_instance_name()
634 {
635     char instance_cstr[256];
636     snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID());
637     m_instance_name.SetCString(instance_cstr);
638     if (log_callback)
639         m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton));
640     m_command_interpreter_ap->Initialize ();
641     // Always add our default platform to the platform list
642     PlatformSP default_platform_sp (Platform::GetDefaultPlatform());
643     assert (default_platform_sp.get());
644     m_platform_list.Append (default_platform_sp, true);
645 
646     m_collection_sp->Initialize (g_properties);
647     m_collection_sp->AppendProperty (ConstString("target"),
648                                      ConstString("Settings specify to debugging targets."),
649                                      true,
650                                      Target::GetGlobalProperties()->GetValueProperties());
651     if (m_command_interpreter_ap.get())
652     {
653         m_collection_sp->AppendProperty (ConstString("interpreter"),
654                                          ConstString("Settings specify to the debugger's command interpreter."),
655                                          true,
656                                          m_command_interpreter_ap->GetValueProperties());
657     }
658     OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64 (NULL, ePropertyTerminalWidth);
659     term_width->SetMinimumValue(10);
660     term_width->SetMaximumValue(1024);
661 
662     // Turn off use-color if this is a dumb terminal.
663     const char *term = getenv ("TERM");
664     if (term && !strcmp (term, "dumb"))
665         SetUseColor (false);
666 }
667 
668 Debugger::~Debugger ()
669 {
670     Clear();
671 }
672 
673 void
674 Debugger::Clear()
675 {
676     CleanUpInputReaders();
677     m_listener.Clear();
678     int num_targets = m_target_list.GetNumTargets();
679     for (int i = 0; i < num_targets; i++)
680     {
681         TargetSP target_sp (m_target_list.GetTargetAtIndex (i));
682         if (target_sp)
683         {
684             ProcessSP process_sp (target_sp->GetProcessSP());
685             if (process_sp)
686                 process_sp->Finalize();
687             target_sp->Destroy();
688         }
689     }
690     BroadcasterManager::Clear ();
691 
692     // Close the input file _before_ we close the input read communications class
693     // as it does NOT own the input file, our m_input_file does.
694     m_terminal_state.Clear();
695     GetInputFile().Close ();
696     // Now that we have closed m_input_file, we can now tell our input communication
697     // class to close down. Its read thread should quickly exit after we close
698     // the input file handle above.
699     m_input_comm.Clear ();
700 }
701 
702 bool
703 Debugger::GetCloseInputOnEOF () const
704 {
705     return m_input_comm.GetCloseOnEOF();
706 }
707 
708 void
709 Debugger::SetCloseInputOnEOF (bool b)
710 {
711     m_input_comm.SetCloseOnEOF(b);
712 }
713 
714 bool
715 Debugger::GetAsyncExecution ()
716 {
717     return !m_command_interpreter_ap->GetSynchronous();
718 }
719 
720 void
721 Debugger::SetAsyncExecution (bool async_execution)
722 {
723     m_command_interpreter_ap->SetSynchronous (!async_execution);
724 }
725 
726 
727 void
728 Debugger::SetInputFileHandle (FILE *fh, bool tranfer_ownership)
729 {
730     File &in_file = GetInputFile();
731     in_file.SetStream (fh, tranfer_ownership);
732     if (in_file.IsValid() == false)
733         in_file.SetStream (stdin, true);
734 
735     // Disconnect from any old connection if we had one
736     m_input_comm.Disconnect ();
737     // Pass false as the second argument to ConnectionFileDescriptor below because
738     // our "in_file" above will already take ownership if requested and we don't
739     // want to objects trying to own and close a file descriptor.
740     m_input_comm.SetConnection (new ConnectionFileDescriptor (in_file.GetDescriptor(), false));
741     m_input_comm.SetReadThreadBytesReceivedCallback (Debugger::DispatchInputCallback, this);
742 
743     // Save away the terminal state if that is relevant, so that we can restore it in RestoreInputState.
744     SaveInputTerminalState ();
745 
746     Error error;
747     if (m_input_comm.StartReadThread (&error) == false)
748     {
749         File &err_file = GetErrorFile();
750 
751         err_file.Printf ("error: failed to main input read thread: %s", error.AsCString() ? error.AsCString() : "unkown error");
752         exit(1);
753     }
754 }
755 
756 void
757 Debugger::SetOutputFileHandle (FILE *fh, bool tranfer_ownership)
758 {
759     File &out_file = GetOutputFile();
760     out_file.SetStream (fh, tranfer_ownership);
761     if (out_file.IsValid() == false)
762         out_file.SetStream (stdout, false);
763 
764     // do not create the ScriptInterpreter just for setting the output file handle
765     // as the constructor will know how to do the right thing on its own
766     const bool can_create = false;
767     ScriptInterpreter* script_interpreter = GetCommandInterpreter().GetScriptInterpreter(can_create);
768     if (script_interpreter)
769         script_interpreter->ResetOutputFileHandle (fh);
770 }
771 
772 void
773 Debugger::SetErrorFileHandle (FILE *fh, bool tranfer_ownership)
774 {
775     File &err_file = GetErrorFile();
776     err_file.SetStream (fh, tranfer_ownership);
777     if (err_file.IsValid() == false)
778         err_file.SetStream (stderr, false);
779 }
780 
781 void
782 Debugger::SaveInputTerminalState ()
783 {
784     File &in_file = GetInputFile();
785     if (in_file.GetDescriptor() != File::kInvalidDescriptor)
786         m_terminal_state.Save(in_file.GetDescriptor(), true);
787 }
788 
789 void
790 Debugger::RestoreInputTerminalState ()
791 {
792     m_terminal_state.Restore();
793 }
794 
795 ExecutionContext
796 Debugger::GetSelectedExecutionContext ()
797 {
798     ExecutionContext exe_ctx;
799     TargetSP target_sp(GetSelectedTarget());
800     exe_ctx.SetTargetSP (target_sp);
801 
802     if (target_sp)
803     {
804         ProcessSP process_sp (target_sp->GetProcessSP());
805         exe_ctx.SetProcessSP (process_sp);
806         if (process_sp && process_sp->IsRunning() == false)
807         {
808             ThreadSP thread_sp (process_sp->GetThreadList().GetSelectedThread());
809             if (thread_sp)
810             {
811                 exe_ctx.SetThreadSP (thread_sp);
812                 exe_ctx.SetFrameSP (thread_sp->GetSelectedFrame());
813                 if (exe_ctx.GetFramePtr() == NULL)
814                     exe_ctx.SetFrameSP (thread_sp->GetStackFrameAtIndex (0));
815             }
816         }
817     }
818     return exe_ctx;
819 
820 }
821 
822 InputReaderSP
823 Debugger::GetCurrentInputReader ()
824 {
825     InputReaderSP reader_sp;
826 
827     if (!m_input_reader_stack.IsEmpty())
828     {
829         // Clear any finished readers from the stack
830         while (CheckIfTopInputReaderIsDone()) ;
831 
832         if (!m_input_reader_stack.IsEmpty())
833             reader_sp = m_input_reader_stack.Top();
834     }
835 
836     return reader_sp;
837 }
838 
839 void
840 Debugger::DispatchInputCallback (void *baton, const void *bytes, size_t bytes_len)
841 {
842     if (bytes_len > 0)
843         ((Debugger *)baton)->DispatchInput ((char *)bytes, bytes_len);
844     else
845         ((Debugger *)baton)->DispatchInputEndOfFile ();
846 }
847 
848 
849 void
850 Debugger::DispatchInput (const char *bytes, size_t bytes_len)
851 {
852     if (bytes == NULL || bytes_len == 0)
853         return;
854 
855     WriteToDefaultReader (bytes, bytes_len);
856 }
857 
858 void
859 Debugger::DispatchInputInterrupt ()
860 {
861     m_input_reader_data.clear();
862 
863     InputReaderSP reader_sp (GetCurrentInputReader ());
864     if (reader_sp)
865     {
866         reader_sp->Notify (eInputReaderInterrupt);
867 
868         // If notifying the reader of the interrupt finished the reader, we should pop it off the stack.
869         while (CheckIfTopInputReaderIsDone ()) ;
870     }
871 }
872 
873 void
874 Debugger::DispatchInputEndOfFile ()
875 {
876     m_input_reader_data.clear();
877 
878     InputReaderSP reader_sp (GetCurrentInputReader ());
879     if (reader_sp)
880     {
881         reader_sp->Notify (eInputReaderEndOfFile);
882 
883         // If notifying the reader of the end-of-file finished the reader, we should pop it off the stack.
884         while (CheckIfTopInputReaderIsDone ()) ;
885     }
886 }
887 
888 void
889 Debugger::CleanUpInputReaders ()
890 {
891     m_input_reader_data.clear();
892 
893     // The bottom input reader should be the main debugger input reader.  We do not want to close that one here.
894     while (m_input_reader_stack.GetSize() > 1)
895     {
896         InputReaderSP reader_sp (GetCurrentInputReader ());
897         if (reader_sp)
898         {
899             reader_sp->Notify (eInputReaderEndOfFile);
900             reader_sp->SetIsDone (true);
901         }
902     }
903 }
904 
905 void
906 Debugger::NotifyTopInputReader (InputReaderAction notification)
907 {
908     InputReaderSP reader_sp (GetCurrentInputReader());
909     if (reader_sp)
910 	{
911         reader_sp->Notify (notification);
912 
913         // Flush out any input readers that are done.
914         while (CheckIfTopInputReaderIsDone ())
915             /* Do nothing. */;
916     }
917 }
918 
919 bool
920 Debugger::InputReaderIsTopReader (const InputReaderSP& reader_sp)
921 {
922     InputReaderSP top_reader_sp (GetCurrentInputReader());
923 
924     return (reader_sp.get() == top_reader_sp.get());
925 }
926 
927 
928 void
929 Debugger::WriteToDefaultReader (const char *bytes, size_t bytes_len)
930 {
931     if (bytes && bytes_len)
932         m_input_reader_data.append (bytes, bytes_len);
933 
934     if (m_input_reader_data.empty())
935         return;
936 
937     while (!m_input_reader_stack.IsEmpty() && !m_input_reader_data.empty())
938     {
939         // Get the input reader from the top of the stack
940         InputReaderSP reader_sp (GetCurrentInputReader ());
941         if (!reader_sp)
942             break;
943 
944         size_t bytes_handled = reader_sp->HandleRawBytes (m_input_reader_data.c_str(),
945                                                           m_input_reader_data.size());
946         if (bytes_handled)
947         {
948             m_input_reader_data.erase (0, bytes_handled);
949         }
950         else
951         {
952             // No bytes were handled, we might not have reached our
953             // granularity, just return and wait for more data
954             break;
955         }
956     }
957 
958     // Flush out any input readers that are done.
959     while (CheckIfTopInputReaderIsDone ())
960         /* Do nothing. */;
961 
962 }
963 
964 void
965 Debugger::PushInputReader (const InputReaderSP& reader_sp)
966 {
967     if (!reader_sp)
968         return;
969 
970     // Deactivate the old top reader
971     InputReaderSP top_reader_sp (GetCurrentInputReader ());
972 
973     if (top_reader_sp)
974         top_reader_sp->Notify (eInputReaderDeactivate);
975 
976     m_input_reader_stack.Push (reader_sp);
977     reader_sp->Notify (eInputReaderActivate);
978     ActivateInputReader (reader_sp);
979 }
980 
981 bool
982 Debugger::PopInputReader (const InputReaderSP& pop_reader_sp)
983 {
984     bool result = false;
985 
986     // The reader on the stop of the stack is done, so let the next
987     // read on the stack referesh its prompt and if there is one...
988     if (!m_input_reader_stack.IsEmpty())
989     {
990         // Cannot call GetCurrentInputReader here, as that would cause an infinite loop.
991         InputReaderSP reader_sp(m_input_reader_stack.Top());
992 
993         if (!pop_reader_sp || pop_reader_sp.get() == reader_sp.get())
994         {
995             m_input_reader_stack.Pop ();
996             reader_sp->Notify (eInputReaderDeactivate);
997             reader_sp->Notify (eInputReaderDone);
998             result = true;
999 
1000             if (!m_input_reader_stack.IsEmpty())
1001             {
1002                 reader_sp = m_input_reader_stack.Top();
1003                 if (reader_sp)
1004                 {
1005                     ActivateInputReader (reader_sp);
1006                     reader_sp->Notify (eInputReaderReactivate);
1007                 }
1008             }
1009         }
1010     }
1011     return result;
1012 }
1013 
1014 bool
1015 Debugger::CheckIfTopInputReaderIsDone ()
1016 {
1017     bool result = false;
1018     if (!m_input_reader_stack.IsEmpty())
1019     {
1020         // Cannot call GetCurrentInputReader here, as that would cause an infinite loop.
1021         InputReaderSP reader_sp(m_input_reader_stack.Top());
1022 
1023         if (reader_sp && reader_sp->IsDone())
1024         {
1025             result = true;
1026             PopInputReader (reader_sp);
1027         }
1028     }
1029     return result;
1030 }
1031 
1032 void
1033 Debugger::ActivateInputReader (const InputReaderSP &reader_sp)
1034 {
1035     int input_fd = m_input_file.GetFile().GetDescriptor();
1036 
1037     if (input_fd >= 0)
1038     {
1039         Terminal tty(input_fd);
1040 
1041         tty.SetEcho(reader_sp->GetEcho());
1042 
1043         switch (reader_sp->GetGranularity())
1044         {
1045         case eInputReaderGranularityByte:
1046         case eInputReaderGranularityWord:
1047             tty.SetCanonical (false);
1048             break;
1049 
1050         case eInputReaderGranularityLine:
1051         case eInputReaderGranularityAll:
1052             tty.SetCanonical (true);
1053             break;
1054 
1055         default:
1056             break;
1057         }
1058     }
1059 }
1060 
1061 StreamSP
1062 Debugger::GetAsyncOutputStream ()
1063 {
1064     return StreamSP (new StreamAsynchronousIO (GetCommandInterpreter(),
1065                                                CommandInterpreter::eBroadcastBitAsynchronousOutputData));
1066 }
1067 
1068 StreamSP
1069 Debugger::GetAsyncErrorStream ()
1070 {
1071     return StreamSP (new StreamAsynchronousIO (GetCommandInterpreter(),
1072                                                CommandInterpreter::eBroadcastBitAsynchronousErrorData));
1073 }
1074 
1075 size_t
1076 Debugger::GetNumDebuggers()
1077 {
1078     if (g_shared_debugger_refcount > 0)
1079     {
1080         Mutex::Locker locker (GetDebuggerListMutex ());
1081         return GetDebuggerList().size();
1082     }
1083     return 0;
1084 }
1085 
1086 lldb::DebuggerSP
1087 Debugger::GetDebuggerAtIndex (size_t index)
1088 {
1089     DebuggerSP debugger_sp;
1090 
1091     if (g_shared_debugger_refcount > 0)
1092     {
1093         Mutex::Locker locker (GetDebuggerListMutex ());
1094         DebuggerList &debugger_list = GetDebuggerList();
1095 
1096         if (index < debugger_list.size())
1097             debugger_sp = debugger_list[index];
1098     }
1099 
1100     return debugger_sp;
1101 }
1102 
1103 DebuggerSP
1104 Debugger::FindDebuggerWithID (lldb::user_id_t id)
1105 {
1106     DebuggerSP debugger_sp;
1107 
1108     if (g_shared_debugger_refcount > 0)
1109     {
1110         Mutex::Locker locker (GetDebuggerListMutex ());
1111         DebuggerList &debugger_list = GetDebuggerList();
1112         DebuggerList::iterator pos, end = debugger_list.end();
1113         for (pos = debugger_list.begin(); pos != end; ++pos)
1114         {
1115             if ((*pos).get()->GetID() == id)
1116             {
1117                 debugger_sp = *pos;
1118                 break;
1119             }
1120         }
1121     }
1122     return debugger_sp;
1123 }
1124 
1125 static void
1126 TestPromptFormats (StackFrame *frame)
1127 {
1128     if (frame == NULL)
1129         return;
1130 
1131     StreamString s;
1132     const char *prompt_format =
1133     "{addr = '${addr}'\n}"
1134     "{process.id = '${process.id}'\n}"
1135     "{process.name = '${process.name}'\n}"
1136     "{process.file.basename = '${process.file.basename}'\n}"
1137     "{process.file.fullpath = '${process.file.fullpath}'\n}"
1138     "{thread.id = '${thread.id}'\n}"
1139     "{thread.index = '${thread.index}'\n}"
1140     "{thread.name = '${thread.name}'\n}"
1141     "{thread.queue = '${thread.queue}'\n}"
1142     "{thread.stop-reason = '${thread.stop-reason}'\n}"
1143     "{target.arch = '${target.arch}'\n}"
1144     "{module.file.basename = '${module.file.basename}'\n}"
1145     "{module.file.fullpath = '${module.file.fullpath}'\n}"
1146     "{file.basename = '${file.basename}'\n}"
1147     "{file.fullpath = '${file.fullpath}'\n}"
1148     "{frame.index = '${frame.index}'\n}"
1149     "{frame.pc = '${frame.pc}'\n}"
1150     "{frame.sp = '${frame.sp}'\n}"
1151     "{frame.fp = '${frame.fp}'\n}"
1152     "{frame.flags = '${frame.flags}'\n}"
1153     "{frame.reg.rdi = '${frame.reg.rdi}'\n}"
1154     "{frame.reg.rip = '${frame.reg.rip}'\n}"
1155     "{frame.reg.rsp = '${frame.reg.rsp}'\n}"
1156     "{frame.reg.rbp = '${frame.reg.rbp}'\n}"
1157     "{frame.reg.rflags = '${frame.reg.rflags}'\n}"
1158     "{frame.reg.xmm0 = '${frame.reg.xmm0}'\n}"
1159     "{frame.reg.carp = '${frame.reg.carp}'\n}"
1160     "{function.id = '${function.id}'\n}"
1161     "{function.name = '${function.name}'\n}"
1162     "{function.name-with-args = '${function.name-with-args}'\n}"
1163     "{function.addr-offset = '${function.addr-offset}'\n}"
1164     "{function.line-offset = '${function.line-offset}'\n}"
1165     "{function.pc-offset = '${function.pc-offset}'\n}"
1166     "{line.file.basename = '${line.file.basename}'\n}"
1167     "{line.file.fullpath = '${line.file.fullpath}'\n}"
1168     "{line.number = '${line.number}'\n}"
1169     "{line.start-addr = '${line.start-addr}'\n}"
1170     "{line.end-addr = '${line.end-addr}'\n}"
1171 ;
1172 
1173     SymbolContext sc (frame->GetSymbolContext(eSymbolContextEverything));
1174     ExecutionContext exe_ctx;
1175     frame->CalculateExecutionContext(exe_ctx);
1176     if (Debugger::FormatPrompt (prompt_format, &sc, &exe_ctx, &sc.line_entry.range.GetBaseAddress(), s))
1177     {
1178         printf("%s\n", s.GetData());
1179     }
1180     else
1181     {
1182         printf ("what we got: %s\n", s.GetData());
1183     }
1184 }
1185 
1186 static bool
1187 ScanFormatDescriptor (const char* var_name_begin,
1188                       const char* var_name_end,
1189                       const char** var_name_final,
1190                       const char** percent_position,
1191                       Format* custom_format,
1192                       ValueObject::ValueObjectRepresentationStyle* val_obj_display)
1193 {
1194     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
1195     *percent_position = ::strchr(var_name_begin,'%');
1196     if (!*percent_position || *percent_position > var_name_end)
1197     {
1198         if (log)
1199             log->Printf("[ScanFormatDescriptor] no format descriptor in string, skipping");
1200         *var_name_final = var_name_end;
1201     }
1202     else
1203     {
1204         *var_name_final = *percent_position;
1205         std::string format_name(*var_name_final+1, var_name_end-*var_name_final-1);
1206         if (log)
1207             log->Printf("ScanFormatDescriptor] parsing %s as a format descriptor", format_name.c_str());
1208         if ( !FormatManager::GetFormatFromCString(format_name.c_str(),
1209                                                   true,
1210                                                   *custom_format) )
1211         {
1212             if (log)
1213                 log->Printf("ScanFormatDescriptor] %s is an unknown format", format_name.c_str());
1214 
1215             switch (format_name.front())
1216             {
1217                 case '@':             // if this is an @ sign, print ObjC description
1218                     *val_obj_display = ValueObject::eValueObjectRepresentationStyleLanguageSpecific;
1219                     break;
1220                 case 'V': // if this is a V, print the value using the default format
1221                     *val_obj_display = ValueObject::eValueObjectRepresentationStyleValue;
1222                     break;
1223                 case 'L': // if this is an L, print the location of the value
1224                     *val_obj_display = ValueObject::eValueObjectRepresentationStyleLocation;
1225                     break;
1226                 case 'S': // if this is an S, print the summary after all
1227                     *val_obj_display = ValueObject::eValueObjectRepresentationStyleSummary;
1228                     break;
1229                 case '#': // if this is a '#', print the number of children
1230                     *val_obj_display = ValueObject::eValueObjectRepresentationStyleChildrenCount;
1231                     break;
1232                 case 'T': // if this is a 'T', print the type
1233                     *val_obj_display = ValueObject::eValueObjectRepresentationStyleType;
1234                     break;
1235                 default:
1236                     if (log)
1237                         log->Printf("ScanFormatDescriptor] %s is an error, leaving the previous value alone", format_name.c_str());
1238                     break;
1239             }
1240         }
1241         // a good custom format tells us to print the value using it
1242         else
1243         {
1244             if (log)
1245                 log->Printf("ScanFormatDescriptor] will display value for this VO");
1246             *val_obj_display = ValueObject::eValueObjectRepresentationStyleValue;
1247         }
1248     }
1249     if (log)
1250         log->Printf("ScanFormatDescriptor] final format description outcome: custom_format = %d, val_obj_display = %d",
1251                     *custom_format,
1252                     *val_obj_display);
1253     return true;
1254 }
1255 
1256 static bool
1257 ScanBracketedRange (const char* var_name_begin,
1258                     const char* var_name_end,
1259                     const char* var_name_final,
1260                     const char** open_bracket_position,
1261                     const char** separator_position,
1262                     const char** close_bracket_position,
1263                     const char** var_name_final_if_array_range,
1264                     int64_t* index_lower,
1265                     int64_t* index_higher)
1266 {
1267     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
1268     *open_bracket_position = ::strchr(var_name_begin,'[');
1269     if (*open_bracket_position && *open_bracket_position < var_name_final)
1270     {
1271         *separator_position = ::strchr(*open_bracket_position,'-'); // might be NULL if this is a simple var[N] bitfield
1272         *close_bracket_position = ::strchr(*open_bracket_position,']');
1273         // as usual, we assume that [] will come before %
1274         //printf("trying to expand a []\n");
1275         *var_name_final_if_array_range = *open_bracket_position;
1276         if (*close_bracket_position - *open_bracket_position == 1)
1277         {
1278             if (log)
1279                 log->Printf("[ScanBracketedRange] '[]' detected.. going from 0 to end of data");
1280             *index_lower = 0;
1281         }
1282         else if (*separator_position == NULL || *separator_position > var_name_end)
1283         {
1284             char *end = NULL;
1285             *index_lower = ::strtoul (*open_bracket_position+1, &end, 0);
1286             *index_higher = *index_lower;
1287             if (log)
1288                 log->Printf("[ScanBracketedRange] [%" PRId64 "] detected, high index is same", *index_lower);
1289         }
1290         else if (*close_bracket_position && *close_bracket_position < var_name_end)
1291         {
1292             char *end = NULL;
1293             *index_lower = ::strtoul (*open_bracket_position+1, &end, 0);
1294             *index_higher = ::strtoul (*separator_position+1, &end, 0);
1295             if (log)
1296                 log->Printf("[ScanBracketedRange] [%" PRId64 "-%" PRId64 "] detected", *index_lower, *index_higher);
1297         }
1298         else
1299         {
1300             if (log)
1301                 log->Printf("[ScanBracketedRange] expression is erroneous, cannot extract indices out of it");
1302             return false;
1303         }
1304         if (*index_lower > *index_higher && *index_higher > 0)
1305         {
1306             if (log)
1307                 log->Printf("[ScanBracketedRange] swapping indices");
1308             int64_t temp = *index_lower;
1309             *index_lower = *index_higher;
1310             *index_higher = temp;
1311         }
1312     }
1313     else if (log)
1314             log->Printf("[ScanBracketedRange] no bracketed range, skipping entirely");
1315     return true;
1316 }
1317 
1318 static ValueObjectSP
1319 ExpandIndexedExpression (ValueObject* valobj,
1320                          size_t index,
1321                          StackFrame* frame,
1322                          bool deref_pointer)
1323 {
1324     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
1325     const char* ptr_deref_format = "[%d]";
1326     std::string ptr_deref_buffer(10,0);
1327     ::sprintf(&ptr_deref_buffer[0], ptr_deref_format, index);
1328     if (log)
1329         log->Printf("[ExpandIndexedExpression] name to deref: %s",ptr_deref_buffer.c_str());
1330     const char* first_unparsed;
1331     ValueObject::GetValueForExpressionPathOptions options;
1332     ValueObject::ExpressionPathEndResultType final_value_type;
1333     ValueObject::ExpressionPathScanEndReason reason_to_stop;
1334     ValueObject::ExpressionPathAftermath what_next = (deref_pointer ? ValueObject::eExpressionPathAftermathDereference : ValueObject::eExpressionPathAftermathNothing);
1335     ValueObjectSP item = valobj->GetValueForExpressionPath (ptr_deref_buffer.c_str(),
1336                                                           &first_unparsed,
1337                                                           &reason_to_stop,
1338                                                           &final_value_type,
1339                                                           options,
1340                                                           &what_next);
1341     if (!item)
1342     {
1343         if (log)
1344             log->Printf("[ExpandIndexedExpression] ERROR: unparsed portion = %s, why stopping = %d,"
1345                " final_value_type %d",
1346                first_unparsed, reason_to_stop, final_value_type);
1347     }
1348     else
1349     {
1350         if (log)
1351             log->Printf("[ExpandIndexedExpression] ALL RIGHT: unparsed portion = %s, why stopping = %d,"
1352                " final_value_type %d",
1353                first_unparsed, reason_to_stop, final_value_type);
1354     }
1355     return item;
1356 }
1357 
1358 static bool
1359 FormatPromptRecurse
1360 (
1361     const char *format,
1362     const SymbolContext *sc,
1363     const ExecutionContext *exe_ctx,
1364     const Address *addr,
1365     Stream &s,
1366     const char **end,
1367     ValueObject* valobj
1368 )
1369 {
1370     ValueObject* realvalobj = NULL; // makes it super-easy to parse pointers
1371     bool success = true;
1372     const char *p;
1373     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
1374 
1375     for (p = format; *p != '\0'; ++p)
1376     {
1377         if (realvalobj)
1378         {
1379             valobj = realvalobj;
1380             realvalobj = NULL;
1381         }
1382         size_t non_special_chars = ::strcspn (p, "${}\\");
1383         if (non_special_chars > 0)
1384         {
1385             if (success)
1386                 s.Write (p, non_special_chars);
1387             p += non_special_chars;
1388         }
1389 
1390         if (*p == '\0')
1391         {
1392             break;
1393         }
1394         else if (*p == '{')
1395         {
1396             // Start a new scope that must have everything it needs if it is to
1397             // to make it into the final output stream "s". If you want to make
1398             // a format that only prints out the function or symbol name if there
1399             // is one in the symbol context you can use:
1400             //      "{function =${function.name}}"
1401             // The first '{' starts a new scope that end with the matching '}' at
1402             // the end of the string. The contents "function =${function.name}"
1403             // will then be evaluated and only be output if there is a function
1404             // or symbol with a valid name.
1405             StreamString sub_strm;
1406 
1407             ++p;  // Skip the '{'
1408 
1409             if (FormatPromptRecurse (p, sc, exe_ctx, addr, sub_strm, &p, valobj))
1410             {
1411                 // The stream had all it needed
1412                 s.Write(sub_strm.GetData(), sub_strm.GetSize());
1413             }
1414             if (*p != '}')
1415             {
1416                 success = false;
1417                 break;
1418             }
1419         }
1420         else if (*p == '}')
1421         {
1422             // End of a enclosing scope
1423             break;
1424         }
1425         else if (*p == '$')
1426         {
1427             // We have a prompt variable to print
1428             ++p;
1429             if (*p == '{')
1430             {
1431                 ++p;
1432                 const char *var_name_begin = p;
1433                 const char *var_name_end = ::strchr (p, '}');
1434 
1435                 if (var_name_end && var_name_begin < var_name_end)
1436                 {
1437                     // if we have already failed to parse, skip this variable
1438                     if (success)
1439                     {
1440                         const char *cstr = NULL;
1441                         Address format_addr;
1442                         bool calculate_format_addr_function_offset = false;
1443                         // Set reg_kind and reg_num to invalid values
1444                         RegisterKind reg_kind = kNumRegisterKinds;
1445                         uint32_t reg_num = LLDB_INVALID_REGNUM;
1446                         FileSpec format_file_spec;
1447                         const RegisterInfo *reg_info = NULL;
1448                         RegisterContext *reg_ctx = NULL;
1449                         bool do_deref_pointer = false;
1450                         ValueObject::ExpressionPathScanEndReason reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
1451                         ValueObject::ExpressionPathEndResultType final_value_type = ValueObject::eExpressionPathEndResultTypePlain;
1452 
1453                         // Each variable must set success to true below...
1454                         bool var_success = false;
1455                         switch (var_name_begin[0])
1456                         {
1457                         case '*':
1458                         case 'v':
1459                         case 's':
1460                             {
1461                                 if (!valobj)
1462                                     break;
1463 
1464                                 if (log)
1465                                     log->Printf("[Debugger::FormatPrompt] initial string: %s",var_name_begin);
1466 
1467                                 // check for *var and *svar
1468                                 if (*var_name_begin == '*')
1469                                 {
1470                                     do_deref_pointer = true;
1471                                     var_name_begin++;
1472                                 }
1473 
1474                                 if (log)
1475                                     log->Printf("[Debugger::FormatPrompt] initial string: %s",var_name_begin);
1476 
1477                                 if (*var_name_begin == 's')
1478                                 {
1479                                     if (!valobj->IsSynthetic())
1480                                         valobj = valobj->GetSyntheticValue().get();
1481                                     if (!valobj)
1482                                         break;
1483                                     var_name_begin++;
1484                                 }
1485 
1486                                 if (log)
1487                                     log->Printf("[Debugger::FormatPrompt] initial string: %s",var_name_begin);
1488 
1489                                 // should be a 'v' by now
1490                                 if (*var_name_begin != 'v')
1491                                     break;
1492 
1493                                 if (log)
1494                                     log->Printf("[Debugger::FormatPrompt] initial string: %s",var_name_begin);
1495 
1496                                 ValueObject::ExpressionPathAftermath what_next = (do_deref_pointer ?
1497                                                                                   ValueObject::eExpressionPathAftermathDereference : ValueObject::eExpressionPathAftermathNothing);
1498                                 ValueObject::GetValueForExpressionPathOptions options;
1499                                 options.DontCheckDotVsArrowSyntax().DoAllowBitfieldSyntax().DoAllowFragileIVar().DoAllowSyntheticChildren();
1500                                 ValueObject::ValueObjectRepresentationStyle val_obj_display = ValueObject::eValueObjectRepresentationStyleSummary;
1501                                 ValueObject* target = NULL;
1502                                 Format custom_format = eFormatInvalid;
1503                                 const char* var_name_final = NULL;
1504                                 const char* var_name_final_if_array_range = NULL;
1505                                 const char* close_bracket_position = NULL;
1506                                 int64_t index_lower = -1;
1507                                 int64_t index_higher = -1;
1508                                 bool is_array_range = false;
1509                                 const char* first_unparsed;
1510                                 bool was_plain_var = false;
1511                                 bool was_var_format = false;
1512                                 bool was_var_indexed = false;
1513 
1514                                 if (!valobj) break;
1515                                 // simplest case ${var}, just print valobj's value
1516                                 if (::strncmp (var_name_begin, "var}", strlen("var}")) == 0)
1517                                 {
1518                                     was_plain_var = true;
1519                                     target = valobj;
1520                                     val_obj_display = ValueObject::eValueObjectRepresentationStyleValue;
1521                                 }
1522                                 else if (::strncmp(var_name_begin,"var%",strlen("var%")) == 0)
1523                                 {
1524                                     was_var_format = true;
1525                                     // this is a variable with some custom format applied to it
1526                                     const char* percent_position;
1527                                     target = valobj;
1528                                     val_obj_display = ValueObject::eValueObjectRepresentationStyleValue;
1529                                     ScanFormatDescriptor (var_name_begin,
1530                                                           var_name_end,
1531                                                           &var_name_final,
1532                                                           &percent_position,
1533                                                           &custom_format,
1534                                                           &val_obj_display);
1535                                 }
1536                                     // this is ${var.something} or multiple .something nested
1537                                 else if (::strncmp (var_name_begin, "var", strlen("var")) == 0)
1538                                 {
1539                                     if (::strncmp(var_name_begin, "var[", strlen("var[")) == 0)
1540                                         was_var_indexed = true;
1541                                     const char* percent_position;
1542                                     ScanFormatDescriptor (var_name_begin,
1543                                                           var_name_end,
1544                                                           &var_name_final,
1545                                                           &percent_position,
1546                                                           &custom_format,
1547                                                           &val_obj_display);
1548 
1549                                     const char* open_bracket_position;
1550                                     const char* separator_position;
1551                                     ScanBracketedRange (var_name_begin,
1552                                                         var_name_end,
1553                                                         var_name_final,
1554                                                         &open_bracket_position,
1555                                                         &separator_position,
1556                                                         &close_bracket_position,
1557                                                         &var_name_final_if_array_range,
1558                                                         &index_lower,
1559                                                         &index_higher);
1560 
1561                                     Error error;
1562 
1563                                     std::string expr_path(var_name_final-var_name_begin-1,0);
1564                                     memcpy(&expr_path[0], var_name_begin+3,var_name_final-var_name_begin-3);
1565 
1566                                     if (log)
1567                                         log->Printf("[Debugger::FormatPrompt] symbol to expand: %s",expr_path.c_str());
1568 
1569                                     target = valobj->GetValueForExpressionPath(expr_path.c_str(),
1570                                                                              &first_unparsed,
1571                                                                              &reason_to_stop,
1572                                                                              &final_value_type,
1573                                                                              options,
1574                                                                              &what_next).get();
1575 
1576                                     if (!target)
1577                                     {
1578                                         if (log)
1579                                             log->Printf("[Debugger::FormatPrompt] ERROR: unparsed portion = %s, why stopping = %d,"
1580                                                " final_value_type %d",
1581                                                first_unparsed, reason_to_stop, final_value_type);
1582                                         break;
1583                                     }
1584                                     else
1585                                     {
1586                                         if (log)
1587                                             log->Printf("[Debugger::FormatPrompt] ALL RIGHT: unparsed portion = %s, why stopping = %d,"
1588                                                " final_value_type %d",
1589                                                first_unparsed, reason_to_stop, final_value_type);
1590                                     }
1591                                 }
1592                                 else
1593                                     break;
1594 
1595                                 is_array_range = (final_value_type == ValueObject::eExpressionPathEndResultTypeBoundedRange ||
1596                                                   final_value_type == ValueObject::eExpressionPathEndResultTypeUnboundedRange);
1597 
1598                                 do_deref_pointer = (what_next == ValueObject::eExpressionPathAftermathDereference);
1599 
1600                                 if (do_deref_pointer && !is_array_range)
1601                                 {
1602                                     // I have not deref-ed yet, let's do it
1603                                     // this happens when we are not going through GetValueForVariableExpressionPath
1604                                     // to get to the target ValueObject
1605                                     Error error;
1606                                     target = target->Dereference(error).get();
1607                                     if (error.Fail())
1608                                     {
1609                                         if (log)
1610                                             log->Printf("[Debugger::FormatPrompt] ERROR: %s\n", error.AsCString("unknown")); \
1611                                         break;
1612                                     }
1613                                     do_deref_pointer = false;
1614                                 }
1615 
1616                                 // <rdar://problem/11338654>
1617                                 // we do not want to use the summary for a bitfield of type T:n
1618                                 // if we were originally dealing with just a T - that would get
1619                                 // us into an endless recursion
1620                                 if (target->IsBitfield() && was_var_indexed)
1621                                 {
1622                                     // TODO: check for a (T:n)-specific summary - we should still obey that
1623                                     StreamString bitfield_name;
1624                                     bitfield_name.Printf("%s:%d", target->GetTypeName().AsCString(), target->GetBitfieldBitSize());
1625                                     lldb::TypeNameSpecifierImplSP type_sp(new TypeNameSpecifierImpl(bitfield_name.GetData(),false));
1626                                     if (!DataVisualization::GetSummaryForType(type_sp))
1627                                         val_obj_display = ValueObject::eValueObjectRepresentationStyleValue;
1628                                 }
1629 
1630                                 // TODO use flags for these
1631                                 bool is_array = ClangASTContext::IsArrayType(target->GetClangType(), NULL, NULL, NULL);
1632                                 bool is_pointer = ClangASTContext::IsPointerType(target->GetClangType());
1633                                 bool is_aggregate = ClangASTContext::IsAggregateType(target->GetClangType());
1634 
1635                                 if ((is_array || is_pointer) && (!is_array_range) && val_obj_display == ValueObject::eValueObjectRepresentationStyleValue) // this should be wrong, but there are some exceptions
1636                                 {
1637                                     StreamString str_temp;
1638                                     if (log)
1639                                         log->Printf("[Debugger::FormatPrompt] I am into array || pointer && !range");
1640 
1641                                     if (target->HasSpecialPrintableRepresentation(val_obj_display, custom_format))
1642                                     {
1643                                         // try to use the special cases
1644                                         var_success = target->DumpPrintableRepresentation(str_temp,
1645                                                                                           val_obj_display,
1646                                                                                           custom_format);
1647                                         if (log)
1648                                             log->Printf("[Debugger::FormatPrompt] special cases did%s match", var_success ? "" : "n't");
1649 
1650                                         // should not happen
1651                                         if (var_success)
1652                                             s << str_temp.GetData();
1653                                         var_success = true;
1654                                         break;
1655                                     }
1656                                     else
1657                                     {
1658                                         if (was_plain_var) // if ${var}
1659                                         {
1660                                             s << target->GetTypeName() << " @ " << target->GetLocationAsCString();
1661                                         }
1662                                         else if (is_pointer) // if pointer, value is the address stored
1663                                         {
1664                                             target->DumpPrintableRepresentation (s,
1665                                                                                  val_obj_display,
1666                                                                                  custom_format,
1667                                                                                  ValueObject::ePrintableRepresentationSpecialCasesDisable);
1668                                         }
1669                                         var_success = true;
1670                                         break;
1671                                     }
1672                                 }
1673 
1674                                 // if directly trying to print ${var}, and this is an aggregate, display a nice
1675                                 // type @ location message
1676                                 if (is_aggregate && was_plain_var)
1677                                 {
1678                                     s << target->GetTypeName() << " @ " << target->GetLocationAsCString();
1679                                     var_success = true;
1680                                     break;
1681                                 }
1682 
1683                                 // if directly trying to print ${var%V}, and this is an aggregate, do not let the user do it
1684                                 if (is_aggregate && ((was_var_format && val_obj_display == ValueObject::eValueObjectRepresentationStyleValue)))
1685                                 {
1686                                     s << "<invalid use of aggregate type>";
1687                                     var_success = true;
1688                                     break;
1689                                 }
1690 
1691                                 if (!is_array_range)
1692                                 {
1693                                     if (log)
1694                                         log->Printf("[Debugger::FormatPrompt] dumping ordinary printable output");
1695                                     var_success = target->DumpPrintableRepresentation(s,val_obj_display, custom_format);
1696                                 }
1697                                 else
1698                                 {
1699                                     if (log)
1700                                         log->Printf("[Debugger::FormatPrompt] checking if I can handle as array");
1701                                     if (!is_array && !is_pointer)
1702                                         break;
1703                                     if (log)
1704                                         log->Printf("[Debugger::FormatPrompt] handle as array");
1705                                     const char* special_directions = NULL;
1706                                     StreamString special_directions_writer;
1707                                     if (close_bracket_position && (var_name_end-close_bracket_position > 1))
1708                                     {
1709                                         ConstString additional_data;
1710                                         additional_data.SetCStringWithLength(close_bracket_position+1, var_name_end-close_bracket_position-1);
1711                                         special_directions_writer.Printf("${%svar%s}",
1712                                                                          do_deref_pointer ? "*" : "",
1713                                                                          additional_data.GetCString());
1714                                         special_directions = special_directions_writer.GetData();
1715                                     }
1716 
1717                                     // let us display items index_lower thru index_higher of this array
1718                                     s.PutChar('[');
1719                                     var_success = true;
1720 
1721                                     if (index_higher < 0)
1722                                         index_higher = valobj->GetNumChildren() - 1;
1723 
1724                                     uint32_t max_num_children = target->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
1725 
1726                                     for (;index_lower<=index_higher;index_lower++)
1727                                     {
1728                                         ValueObject* item = ExpandIndexedExpression (target,
1729                                                                                      index_lower,
1730                                                                                      exe_ctx->GetFramePtr(),
1731                                                                                      false).get();
1732 
1733                                         if (!item)
1734                                         {
1735                                             if (log)
1736                                                 log->Printf("[Debugger::FormatPrompt] ERROR in getting child item at index %" PRId64, index_lower);
1737                                         }
1738                                         else
1739                                         {
1740                                             if (log)
1741                                                 log->Printf("[Debugger::FormatPrompt] special_directions for child item: %s",special_directions);
1742                                         }
1743 
1744                                         if (!special_directions)
1745                                             var_success &= item->DumpPrintableRepresentation(s,val_obj_display, custom_format);
1746                                         else
1747                                             var_success &= FormatPromptRecurse(special_directions, sc, exe_ctx, addr, s, NULL, item);
1748 
1749                                         if (--max_num_children == 0)
1750                                         {
1751                                             s.PutCString(", ...");
1752                                             break;
1753                                         }
1754 
1755                                         if (index_lower < index_higher)
1756                                             s.PutChar(',');
1757                                     }
1758                                     s.PutChar(']');
1759                                 }
1760                             }
1761                             break;
1762                         case 'a':
1763                             if (::strncmp (var_name_begin, "addr}", strlen("addr}")) == 0)
1764                             {
1765                                 if (addr && addr->IsValid())
1766                                 {
1767                                     var_success = true;
1768                                     format_addr = *addr;
1769                                 }
1770                             }
1771                             break;
1772 
1773                         case 'p':
1774                             if (::strncmp (var_name_begin, "process.", strlen("process.")) == 0)
1775                             {
1776                                 if (exe_ctx)
1777                                 {
1778                                     Process *process = exe_ctx->GetProcessPtr();
1779                                     if (process)
1780                                     {
1781                                         var_name_begin += ::strlen ("process.");
1782                                         if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0)
1783                                         {
1784                                             s.Printf("%" PRIu64, process->GetID());
1785                                             var_success = true;
1786                                         }
1787                                         else if ((::strncmp (var_name_begin, "name}", strlen("name}")) == 0) ||
1788                                                  (::strncmp (var_name_begin, "file.basename}", strlen("file.basename}")) == 0) ||
1789                                                  (::strncmp (var_name_begin, "file.fullpath}", strlen("file.fullpath}")) == 0))
1790                                         {
1791                                             Module *exe_module = process->GetTarget().GetExecutableModulePointer();
1792                                             if (exe_module)
1793                                             {
1794                                                 if (var_name_begin[0] == 'n' || var_name_begin[5] == 'f')
1795                                                 {
1796                                                     format_file_spec.GetFilename() = exe_module->GetFileSpec().GetFilename();
1797                                                     var_success = format_file_spec;
1798                                                 }
1799                                                 else
1800                                                 {
1801                                                     format_file_spec = exe_module->GetFileSpec();
1802                                                     var_success = format_file_spec;
1803                                                 }
1804                                             }
1805                                         }
1806                                     }
1807                                 }
1808                             }
1809                             break;
1810 
1811                         case 't':
1812                             if (::strncmp (var_name_begin, "thread.", strlen("thread.")) == 0)
1813                             {
1814                                 if (exe_ctx)
1815                                 {
1816                                     Thread *thread = exe_ctx->GetThreadPtr();
1817                                     if (thread)
1818                                     {
1819                                         var_name_begin += ::strlen ("thread.");
1820                                         if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0)
1821                                         {
1822                                             s.Printf("0x%4.4" PRIx64, thread->GetID());
1823                                             var_success = true;
1824                                         }
1825                                         else if (::strncmp (var_name_begin, "protocol_id}", strlen("protocol_id}")) == 0)
1826                                         {
1827                                             s.Printf("0x%4.4" PRIx64, thread->GetProtocolID());
1828                                             var_success = true;
1829                                         }
1830                                         else if (::strncmp (var_name_begin, "index}", strlen("index}")) == 0)
1831                                         {
1832                                             s.Printf("%u", thread->GetIndexID());
1833                                             var_success = true;
1834                                         }
1835                                         else if (::strncmp (var_name_begin, "name}", strlen("name}")) == 0)
1836                                         {
1837                                             cstr = thread->GetName();
1838                                             var_success = cstr && cstr[0];
1839                                             if (var_success)
1840                                                 s.PutCString(cstr);
1841                                         }
1842                                         else if (::strncmp (var_name_begin, "queue}", strlen("queue}")) == 0)
1843                                         {
1844                                             cstr = thread->GetQueueName();
1845                                             var_success = cstr && cstr[0];
1846                                             if (var_success)
1847                                                 s.PutCString(cstr);
1848                                         }
1849                                         else if (::strncmp (var_name_begin, "stop-reason}", strlen("stop-reason}")) == 0)
1850                                         {
1851                                             StopInfoSP stop_info_sp = thread->GetStopInfo ();
1852                                             if (stop_info_sp && stop_info_sp->IsValid())
1853                                             {
1854                                                 cstr = stop_info_sp->GetDescription();
1855                                                 if (cstr && cstr[0])
1856                                                 {
1857                                                     s.PutCString(cstr);
1858                                                     var_success = true;
1859                                                 }
1860                                             }
1861                                         }
1862                                         else if (::strncmp (var_name_begin, "return-value}", strlen("return-value}")) == 0)
1863                                         {
1864                                             StopInfoSP stop_info_sp = thread->GetStopInfo ();
1865                                             if (stop_info_sp && stop_info_sp->IsValid())
1866                                             {
1867                                                 ValueObjectSP return_valobj_sp = StopInfo::GetReturnValueObject (stop_info_sp);
1868                                                 if (return_valobj_sp)
1869                                                 {
1870                                                     ValueObject::DumpValueObject (s, return_valobj_sp.get());
1871                                                     var_success = true;
1872                                                 }
1873                                             }
1874                                         }
1875                                     }
1876                                 }
1877                             }
1878                             else if (::strncmp (var_name_begin, "target.", strlen("target.")) == 0)
1879                             {
1880                                 // TODO: hookup properties
1881 //                                if (!target_properties_sp)
1882 //                                {
1883 //                                    Target *target = Target::GetTargetFromContexts (exe_ctx, sc);
1884 //                                    if (target)
1885 //                                        target_properties_sp = target->GetProperties();
1886 //                                }
1887 //
1888 //                                if (target_properties_sp)
1889 //                                {
1890 //                                    var_name_begin += ::strlen ("target.");
1891 //                                    const char *end_property = strchr(var_name_begin, '}');
1892 //                                    if (end_property)
1893 //                                    {
1894 //                                        ConstString property_name(var_name_begin, end_property - var_name_begin);
1895 //                                        std::string property_value (target_properties_sp->GetPropertyValue(property_name));
1896 //                                        if (!property_value.empty())
1897 //                                        {
1898 //                                            s.PutCString (property_value.c_str());
1899 //                                            var_success = true;
1900 //                                        }
1901 //                                    }
1902 //                                }
1903                                 Target *target = Target::GetTargetFromContexts (exe_ctx, sc);
1904                                 if (target)
1905                                 {
1906                                     var_name_begin += ::strlen ("target.");
1907                                     if (::strncmp (var_name_begin, "arch}", strlen("arch}")) == 0)
1908                                     {
1909                                         ArchSpec arch (target->GetArchitecture ());
1910                                         if (arch.IsValid())
1911                                         {
1912                                             s.PutCString (arch.GetArchitectureName());
1913                                             var_success = true;
1914                                         }
1915                                     }
1916                                 }
1917                             }
1918                             break;
1919 
1920 
1921                         case 'm':
1922                             if (::strncmp (var_name_begin, "module.", strlen("module.")) == 0)
1923                             {
1924                                 if (sc && sc->module_sp.get())
1925                                 {
1926                                     Module *module = sc->module_sp.get();
1927                                     var_name_begin += ::strlen ("module.");
1928 
1929                                     if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0)
1930                                     {
1931                                         if (module->GetFileSpec())
1932                                         {
1933                                             var_name_begin += ::strlen ("file.");
1934 
1935                                             if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0)
1936                                             {
1937                                                 format_file_spec.GetFilename() = module->GetFileSpec().GetFilename();
1938                                                 var_success = format_file_spec;
1939                                             }
1940                                             else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0)
1941                                             {
1942                                                 format_file_spec = module->GetFileSpec();
1943                                                 var_success = format_file_spec;
1944                                             }
1945                                         }
1946                                     }
1947                                 }
1948                             }
1949                             break;
1950 
1951 
1952                         case 'f':
1953                             if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0)
1954                             {
1955                                 if (sc && sc->comp_unit != NULL)
1956                                 {
1957                                     var_name_begin += ::strlen ("file.");
1958 
1959                                     if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0)
1960                                     {
1961                                         format_file_spec.GetFilename() = sc->comp_unit->GetFilename();
1962                                         var_success = format_file_spec;
1963                                     }
1964                                     else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0)
1965                                     {
1966                                         format_file_spec = *sc->comp_unit;
1967                                         var_success = format_file_spec;
1968                                     }
1969                                 }
1970                             }
1971                             else if (::strncmp (var_name_begin, "frame.", strlen("frame.")) == 0)
1972                             {
1973                                 if (exe_ctx)
1974                                 {
1975                                     StackFrame *frame = exe_ctx->GetFramePtr();
1976                                     if (frame)
1977                                     {
1978                                         var_name_begin += ::strlen ("frame.");
1979                                         if (::strncmp (var_name_begin, "index}", strlen("index}")) == 0)
1980                                         {
1981                                             s.Printf("%u", frame->GetFrameIndex());
1982                                             var_success = true;
1983                                         }
1984                                         else if (::strncmp (var_name_begin, "pc}", strlen("pc}")) == 0)
1985                                         {
1986                                             reg_kind = eRegisterKindGeneric;
1987                                             reg_num = LLDB_REGNUM_GENERIC_PC;
1988                                             var_success = true;
1989                                         }
1990                                         else if (::strncmp (var_name_begin, "sp}", strlen("sp}")) == 0)
1991                                         {
1992                                             reg_kind = eRegisterKindGeneric;
1993                                             reg_num = LLDB_REGNUM_GENERIC_SP;
1994                                             var_success = true;
1995                                         }
1996                                         else if (::strncmp (var_name_begin, "fp}", strlen("fp}")) == 0)
1997                                         {
1998                                             reg_kind = eRegisterKindGeneric;
1999                                             reg_num = LLDB_REGNUM_GENERIC_FP;
2000                                             var_success = true;
2001                                         }
2002                                         else if (::strncmp (var_name_begin, "flags}", strlen("flags}")) == 0)
2003                                         {
2004                                             reg_kind = eRegisterKindGeneric;
2005                                             reg_num = LLDB_REGNUM_GENERIC_FLAGS;
2006                                             var_success = true;
2007                                         }
2008                                         else if (::strncmp (var_name_begin, "reg.", strlen ("reg.")) == 0)
2009                                         {
2010                                             reg_ctx = frame->GetRegisterContext().get();
2011                                             if (reg_ctx)
2012                                             {
2013                                                 var_name_begin += ::strlen ("reg.");
2014                                                 if (var_name_begin < var_name_end)
2015                                                 {
2016                                                     std::string reg_name (var_name_begin, var_name_end);
2017                                                     reg_info = reg_ctx->GetRegisterInfoByName (reg_name.c_str());
2018                                                     if (reg_info)
2019                                                         var_success = true;
2020                                                 }
2021                                             }
2022                                         }
2023                                     }
2024                                 }
2025                             }
2026                             else if (::strncmp (var_name_begin, "function.", strlen("function.")) == 0)
2027                             {
2028                                 if (sc && (sc->function != NULL || sc->symbol != NULL))
2029                                 {
2030                                     var_name_begin += ::strlen ("function.");
2031                                     if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0)
2032                                     {
2033                                         if (sc->function)
2034                                             s.Printf("function{0x%8.8" PRIx64 "}", sc->function->GetID());
2035                                         else
2036                                             s.Printf("symbol[%u]", sc->symbol->GetID());
2037 
2038                                         var_success = true;
2039                                     }
2040                                     else if (::strncmp (var_name_begin, "name}", strlen("name}")) == 0)
2041                                     {
2042                                         if (sc->function)
2043                                             cstr = sc->function->GetName().AsCString (NULL);
2044                                         else if (sc->symbol)
2045                                             cstr = sc->symbol->GetName().AsCString (NULL);
2046                                         if (cstr)
2047                                         {
2048                                             s.PutCString(cstr);
2049 
2050                                             if (sc->block)
2051                                             {
2052                                                 Block *inline_block = sc->block->GetContainingInlinedBlock ();
2053                                                 if (inline_block)
2054                                                 {
2055                                                     const InlineFunctionInfo *inline_info = sc->block->GetInlinedFunctionInfo();
2056                                                     if (inline_info)
2057                                                     {
2058                                                         s.PutCString(" [inlined] ");
2059                                                         inline_info->GetName().Dump(&s);
2060                                                     }
2061                                                 }
2062                                             }
2063                                             var_success = true;
2064                                         }
2065                                     }
2066                                     else if (::strncmp (var_name_begin, "name-with-args}", strlen("name-with-args}")) == 0)
2067                                     {
2068                                         // Print the function name with arguments in it
2069 
2070                                         if (sc->function)
2071                                         {
2072                                             var_success = true;
2073                                             ExecutionContextScope *exe_scope = exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL;
2074                                             cstr = sc->function->GetName().AsCString (NULL);
2075                                             if (cstr)
2076                                             {
2077                                                 const InlineFunctionInfo *inline_info = NULL;
2078                                                 VariableListSP variable_list_sp;
2079                                                 bool get_function_vars = true;
2080                                                 if (sc->block)
2081                                                 {
2082                                                     Block *inline_block = sc->block->GetContainingInlinedBlock ();
2083 
2084                                                     if (inline_block)
2085                                                     {
2086                                                         get_function_vars = false;
2087                                                         inline_info = sc->block->GetInlinedFunctionInfo();
2088                                                         if (inline_info)
2089                                                             variable_list_sp = inline_block->GetBlockVariableList (true);
2090                                                     }
2091                                                 }
2092 
2093                                                 if (get_function_vars)
2094                                                 {
2095                                                     variable_list_sp = sc->function->GetBlock(true).GetBlockVariableList (true);
2096                                                 }
2097 
2098                                                 if (inline_info)
2099                                                 {
2100                                                     s.PutCString (cstr);
2101                                                     s.PutCString (" [inlined] ");
2102                                                     cstr = inline_info->GetName().GetCString();
2103                                                 }
2104 
2105                                                 VariableList args;
2106                                                 if (variable_list_sp)
2107                                                     variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument, args);
2108                                                 if (args.GetSize() > 0)
2109                                                 {
2110                                                     const char *open_paren = strchr (cstr, '(');
2111                                                     const char *close_paren = NULL;
2112                                                     if (open_paren)
2113                                                     {
2114                                                         if (strncmp(open_paren, "(anonymous namespace)", strlen("(anonymous namespace)")) == 0)
2115                                                         {
2116                                                             open_paren = strchr (open_paren + strlen("(anonymous namespace)"), '(');
2117                                                             if (open_paren)
2118                                                                 close_paren = strchr (open_paren, ')');
2119                                                         }
2120                                                         else
2121                                                             close_paren = strchr (open_paren, ')');
2122                                                     }
2123 
2124                                                     if (open_paren)
2125                                                         s.Write(cstr, open_paren - cstr + 1);
2126                                                     else
2127                                                     {
2128                                                         s.PutCString (cstr);
2129                                                         s.PutChar ('(');
2130                                                     }
2131                                                     const size_t num_args = args.GetSize();
2132                                                     for (size_t arg_idx = 0; arg_idx < num_args; ++arg_idx)
2133                                                     {
2134                                                         VariableSP var_sp (args.GetVariableAtIndex (arg_idx));
2135                                                         ValueObjectSP var_value_sp (ValueObjectVariable::Create (exe_scope, var_sp));
2136                                                         const char *var_name = var_value_sp->GetName().GetCString();
2137                                                         const char *var_value = var_value_sp->GetValueAsCString();
2138                                                         if (arg_idx > 0)
2139                                                             s.PutCString (", ");
2140                                                         if (var_value_sp->GetError().Success())
2141                                                         {
2142                                                             if (var_value)
2143                                                                 s.Printf ("%s=%s", var_name, var_value);
2144                                                             else
2145                                                                 s.Printf ("%s=%s at %s", var_name, var_value_sp->GetTypeName().GetCString(), var_value_sp->GetLocationAsCString());
2146                                                         }
2147                                                         else
2148                                                             s.Printf ("%s=<unavailable>", var_name);
2149                                                     }
2150 
2151                                                     if (close_paren)
2152                                                         s.PutCString (close_paren);
2153                                                     else
2154                                                         s.PutChar(')');
2155 
2156                                                 }
2157                                                 else
2158                                                 {
2159                                                     s.PutCString(cstr);
2160                                                 }
2161                                             }
2162                                         }
2163                                         else if (sc->symbol)
2164                                         {
2165                                             cstr = sc->symbol->GetName().AsCString (NULL);
2166                                             if (cstr)
2167                                             {
2168                                                 s.PutCString(cstr);
2169                                                 var_success = true;
2170                                             }
2171                                         }
2172                                     }
2173                                     else if (::strncmp (var_name_begin, "addr-offset}", strlen("addr-offset}")) == 0)
2174                                     {
2175                                         var_success = addr != NULL;
2176                                         if (var_success)
2177                                         {
2178                                             format_addr = *addr;
2179                                             calculate_format_addr_function_offset = true;
2180                                         }
2181                                     }
2182                                     else if (::strncmp (var_name_begin, "line-offset}", strlen("line-offset}")) == 0)
2183                                     {
2184                                         var_success = sc->line_entry.range.GetBaseAddress().IsValid();
2185                                         if (var_success)
2186                                         {
2187                                             format_addr = sc->line_entry.range.GetBaseAddress();
2188                                             calculate_format_addr_function_offset = true;
2189                                         }
2190                                     }
2191                                     else if (::strncmp (var_name_begin, "pc-offset}", strlen("pc-offset}")) == 0)
2192                                     {
2193                                         StackFrame *frame = exe_ctx->GetFramePtr();
2194                                         var_success = frame != NULL;
2195                                         if (var_success)
2196                                         {
2197                                             format_addr = frame->GetFrameCodeAddress();
2198                                             calculate_format_addr_function_offset = true;
2199                                         }
2200                                     }
2201                                 }
2202                             }
2203                             break;
2204 
2205                         case 'l':
2206                             if (::strncmp (var_name_begin, "line.", strlen("line.")) == 0)
2207                             {
2208                                 if (sc && sc->line_entry.IsValid())
2209                                 {
2210                                     var_name_begin += ::strlen ("line.");
2211                                     if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0)
2212                                     {
2213                                         var_name_begin += ::strlen ("file.");
2214 
2215                                         if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0)
2216                                         {
2217                                             format_file_spec.GetFilename() = sc->line_entry.file.GetFilename();
2218                                             var_success = format_file_spec;
2219                                         }
2220                                         else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0)
2221                                         {
2222                                             format_file_spec = sc->line_entry.file;
2223                                             var_success = format_file_spec;
2224                                         }
2225                                     }
2226                                     else if (::strncmp (var_name_begin, "number}", strlen("number}")) == 0)
2227                                     {
2228                                         var_success = true;
2229                                         s.Printf("%u", sc->line_entry.line);
2230                                     }
2231                                     else if ((::strncmp (var_name_begin, "start-addr}", strlen("start-addr}")) == 0) ||
2232                                              (::strncmp (var_name_begin, "end-addr}", strlen("end-addr}")) == 0))
2233                                     {
2234                                         var_success = sc && sc->line_entry.range.GetBaseAddress().IsValid();
2235                                         if (var_success)
2236                                         {
2237                                             format_addr = sc->line_entry.range.GetBaseAddress();
2238                                             if (var_name_begin[0] == 'e')
2239                                                 format_addr.Slide (sc->line_entry.range.GetByteSize());
2240                                         }
2241                                     }
2242                                 }
2243                             }
2244                             break;
2245                         }
2246 
2247                         if (var_success)
2248                         {
2249                             // If format addr is valid, then we need to print an address
2250                             if (reg_num != LLDB_INVALID_REGNUM)
2251                             {
2252                                 StackFrame *frame = exe_ctx->GetFramePtr();
2253                                 // We have a register value to display...
2254                                 if (reg_num == LLDB_REGNUM_GENERIC_PC && reg_kind == eRegisterKindGeneric)
2255                                 {
2256                                     format_addr = frame->GetFrameCodeAddress();
2257                                 }
2258                                 else
2259                                 {
2260                                     if (reg_ctx == NULL)
2261                                         reg_ctx = frame->GetRegisterContext().get();
2262 
2263                                     if (reg_ctx)
2264                                     {
2265                                         if (reg_kind != kNumRegisterKinds)
2266                                             reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num);
2267                                         reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_num);
2268                                         var_success = reg_info != NULL;
2269                                     }
2270                                 }
2271                             }
2272 
2273                             if (reg_info != NULL)
2274                             {
2275                                 RegisterValue reg_value;
2276                                 var_success = reg_ctx->ReadRegister (reg_info, reg_value);
2277                                 if (var_success)
2278                                 {
2279                                     reg_value.Dump(&s, reg_info, false, false, eFormatDefault);
2280                                 }
2281                             }
2282 
2283                             if (format_file_spec)
2284                             {
2285                                 s << format_file_spec;
2286                             }
2287 
2288                             // If format addr is valid, then we need to print an address
2289                             if (format_addr.IsValid())
2290                             {
2291                                 var_success = false;
2292 
2293                                 if (calculate_format_addr_function_offset)
2294                                 {
2295                                     Address func_addr;
2296 
2297                                     if (sc)
2298                                     {
2299                                         if (sc->function)
2300                                         {
2301                                             func_addr = sc->function->GetAddressRange().GetBaseAddress();
2302                                             if (sc->block)
2303                                             {
2304                                                 // Check to make sure we aren't in an inline
2305                                                 // function. If we are, use the inline block
2306                                                 // range that contains "format_addr" since
2307                                                 // blocks can be discontiguous.
2308                                                 Block *inline_block = sc->block->GetContainingInlinedBlock ();
2309                                                 AddressRange inline_range;
2310                                                 if (inline_block && inline_block->GetRangeContainingAddress (format_addr, inline_range))
2311                                                     func_addr = inline_range.GetBaseAddress();
2312                                             }
2313                                         }
2314                                         else if (sc->symbol && sc->symbol->ValueIsAddress())
2315                                             func_addr = sc->symbol->GetAddress();
2316                                     }
2317 
2318                                     if (func_addr.IsValid())
2319                                     {
2320                                         if (func_addr.GetSection() == format_addr.GetSection())
2321                                         {
2322                                             addr_t func_file_addr = func_addr.GetFileAddress();
2323                                             addr_t addr_file_addr = format_addr.GetFileAddress();
2324                                             if (addr_file_addr > func_file_addr)
2325                                                 s.Printf(" + %" PRIu64, addr_file_addr - func_file_addr);
2326                                             else if (addr_file_addr < func_file_addr)
2327                                                 s.Printf(" - %" PRIu64, func_file_addr - addr_file_addr);
2328                                             var_success = true;
2329                                         }
2330                                         else
2331                                         {
2332                                             Target *target = Target::GetTargetFromContexts (exe_ctx, sc);
2333                                             if (target)
2334                                             {
2335                                                 addr_t func_load_addr = func_addr.GetLoadAddress (target);
2336                                                 addr_t addr_load_addr = format_addr.GetLoadAddress (target);
2337                                                 if (addr_load_addr > func_load_addr)
2338                                                     s.Printf(" + %" PRIu64, addr_load_addr - func_load_addr);
2339                                                 else if (addr_load_addr < func_load_addr)
2340                                                     s.Printf(" - %" PRIu64, func_load_addr - addr_load_addr);
2341                                                 var_success = true;
2342                                             }
2343                                         }
2344                                     }
2345                                 }
2346                                 else
2347                                 {
2348                                     Target *target = Target::GetTargetFromContexts (exe_ctx, sc);
2349                                     addr_t vaddr = LLDB_INVALID_ADDRESS;
2350                                     if (exe_ctx && !target->GetSectionLoadList().IsEmpty())
2351                                         vaddr = format_addr.GetLoadAddress (target);
2352                                     if (vaddr == LLDB_INVALID_ADDRESS)
2353                                         vaddr = format_addr.GetFileAddress ();
2354 
2355                                     if (vaddr != LLDB_INVALID_ADDRESS)
2356                                     {
2357                                         int addr_width = target->GetArchitecture().GetAddressByteSize() * 2;
2358                                         if (addr_width == 0)
2359                                             addr_width = 16;
2360                                         s.Printf("0x%*.*" PRIx64, addr_width, addr_width, vaddr);
2361                                         var_success = true;
2362                                     }
2363                                 }
2364                             }
2365                         }
2366 
2367                         if (var_success == false)
2368                             success = false;
2369                     }
2370                     p = var_name_end;
2371                 }
2372                 else
2373                     break;
2374             }
2375             else
2376             {
2377                 // We got a dollar sign with no '{' after it, it must just be a dollar sign
2378                 s.PutChar(*p);
2379             }
2380         }
2381         else if (*p == '\\')
2382         {
2383             ++p; // skip the slash
2384             switch (*p)
2385             {
2386             case 'a': s.PutChar ('\a'); break;
2387             case 'b': s.PutChar ('\b'); break;
2388             case 'f': s.PutChar ('\f'); break;
2389             case 'n': s.PutChar ('\n'); break;
2390             case 'r': s.PutChar ('\r'); break;
2391             case 't': s.PutChar ('\t'); break;
2392             case 'v': s.PutChar ('\v'); break;
2393             case '\'': s.PutChar ('\''); break;
2394             case '\\': s.PutChar ('\\'); break;
2395             case '0':
2396                 // 1 to 3 octal chars
2397                 {
2398                     // Make a string that can hold onto the initial zero char,
2399                     // up to 3 octal digits, and a terminating NULL.
2400                     char oct_str[5] = { 0, 0, 0, 0, 0 };
2401 
2402                     int i;
2403                     for (i=0; (p[i] >= '0' && p[i] <= '7') && i<4; ++i)
2404                         oct_str[i] = p[i];
2405 
2406                     // We don't want to consume the last octal character since
2407                     // the main for loop will do this for us, so we advance p by
2408                     // one less than i (even if i is zero)
2409                     p += i - 1;
2410                     unsigned long octal_value = ::strtoul (oct_str, NULL, 8);
2411                     if (octal_value <= UINT8_MAX)
2412                     {
2413                         s.PutChar((char)octal_value);
2414                     }
2415                 }
2416                 break;
2417 
2418             case 'x':
2419                 // hex number in the format
2420                 if (isxdigit(p[1]))
2421                 {
2422                     ++p;    // Skip the 'x'
2423 
2424                     // Make a string that can hold onto two hex chars plus a
2425                     // NULL terminator
2426                     char hex_str[3] = { 0,0,0 };
2427                     hex_str[0] = *p;
2428                     if (isxdigit(p[1]))
2429                     {
2430                         ++p; // Skip the first of the two hex chars
2431                         hex_str[1] = *p;
2432                     }
2433 
2434                     unsigned long hex_value = strtoul (hex_str, NULL, 16);
2435                     if (hex_value <= UINT8_MAX)
2436                         s.PutChar ((char)hex_value);
2437                 }
2438                 else
2439                 {
2440                     s.PutChar('x');
2441                 }
2442                 break;
2443 
2444             default:
2445                 // Just desensitize any other character by just printing what
2446                 // came after the '\'
2447                 s << *p;
2448                 break;
2449 
2450             }
2451 
2452         }
2453     }
2454     if (end)
2455         *end = p;
2456     return success;
2457 }
2458 
2459 bool
2460 Debugger::FormatPrompt
2461 (
2462     const char *format,
2463     const SymbolContext *sc,
2464     const ExecutionContext *exe_ctx,
2465     const Address *addr,
2466     Stream &s,
2467     ValueObject* valobj
2468 )
2469 {
2470     bool use_color = exe_ctx ? exe_ctx->GetTargetRef().GetDebugger().GetUseColor() : true;
2471     std::string format_str = lldb_utility::ansi::FormatAnsiTerminalCodes (format, use_color);
2472     if (format_str.length())
2473         format = format_str.c_str();
2474     return FormatPromptRecurse (format, sc, exe_ctx, addr, s, NULL, valobj);
2475 }
2476 
2477 void
2478 Debugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
2479 {
2480     // For simplicity's sake, I am not going to deal with how to close down any
2481     // open logging streams, I just redirect everything from here on out to the
2482     // callback.
2483     m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton));
2484 }
2485 
2486 bool
2487 Debugger::EnableLog (const char *channel, const char **categories, const char *log_file, uint32_t log_options, Stream &error_stream)
2488 {
2489     Log::Callbacks log_callbacks;
2490 
2491     StreamSP log_stream_sp;
2492     if (m_log_callback_stream_sp)
2493     {
2494         log_stream_sp = m_log_callback_stream_sp;
2495         // For now when using the callback mode you always get thread & timestamp.
2496         log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
2497     }
2498     else if (log_file == NULL || *log_file == '\0')
2499     {
2500         log_stream_sp.reset(new StreamFile(GetOutputFile().GetDescriptor(), false));
2501     }
2502     else
2503     {
2504         LogStreamMap::iterator pos = m_log_streams.find(log_file);
2505         if (pos != m_log_streams.end())
2506             log_stream_sp = pos->second.lock();
2507         if (!log_stream_sp)
2508         {
2509             log_stream_sp.reset (new StreamFile (log_file));
2510             m_log_streams[log_file] = log_stream_sp;
2511         }
2512     }
2513     assert (log_stream_sp.get());
2514 
2515     if (log_options == 0)
2516         log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;
2517 
2518     if (Log::GetLogChannelCallbacks (ConstString(channel), log_callbacks))
2519     {
2520         log_callbacks.enable (log_stream_sp, log_options, categories, &error_stream);
2521         return true;
2522     }
2523     else
2524     {
2525         LogChannelSP log_channel_sp (LogChannel::FindPlugin (channel));
2526         if (log_channel_sp)
2527         {
2528             if (log_channel_sp->Enable (log_stream_sp, log_options, &error_stream, categories))
2529             {
2530                 return true;
2531             }
2532             else
2533             {
2534                 error_stream.Printf ("Invalid log channel '%s'.\n", channel);
2535                 return false;
2536             }
2537         }
2538         else
2539         {
2540             error_stream.Printf ("Invalid log channel '%s'.\n", channel);
2541             return false;
2542         }
2543     }
2544     return false;
2545 }
2546 
2547 SourceManager &
2548 Debugger::GetSourceManager ()
2549 {
2550     if (m_source_manager_ap.get() == NULL)
2551         m_source_manager_ap.reset (new SourceManager (shared_from_this()));
2552     return *m_source_manager_ap;
2553 }
2554 
2555 
2556