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