1 //===-- Variable.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/Symbol/Variable.h"
11 
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/RegularExpression.h"
14 #include "lldb/Core/Stream.h"
15 #include "lldb/Core/ValueObject.h"
16 #include "lldb/Core/ValueObjectVariable.h"
17 #include "lldb/Symbol/Block.h"
18 #include "lldb/Symbol/CompileUnit.h"
19 #include "lldb/Symbol/CompilerDecl.h"
20 #include "lldb/Symbol/CompilerDeclContext.h"
21 #include "lldb/Symbol/Function.h"
22 #include "lldb/Symbol/SymbolContext.h"
23 #include "lldb/Symbol/SymbolFile.h"
24 #include "lldb/Symbol/Type.h"
25 #include "lldb/Symbol/TypeSystem.h"
26 #include "lldb/Symbol/VariableList.h"
27 #include "lldb/Target/ABI.h"
28 #include "lldb/Target/Process.h"
29 #include "lldb/Target/RegisterContext.h"
30 #include "lldb/Target/StackFrame.h"
31 #include "lldb/Target/Target.h"
32 #include "lldb/Target/Thread.h"
33 
34 #include "llvm/ADT/Twine.h"
35 
36 using namespace lldb;
37 using namespace lldb_private;
38 
39 //----------------------------------------------------------------------
40 // Variable constructor
41 //----------------------------------------------------------------------
42 Variable::Variable(
43     lldb::user_id_t uid, const char *name,
44     const char *mangled, // The mangled or fully qualified name of the variable.
45     const lldb::SymbolFileTypeSP &symfile_type_sp, ValueType scope,
46     SymbolContextScope *context, const RangeList &scope_range,
47     Declaration *decl_ptr, const DWARFExpression &location, bool external,
48     bool artificial, bool static_member)
49     : UserID(uid), m_name(name), m_mangled(ConstString(mangled)),
50       m_symfile_type_sp(symfile_type_sp), m_scope(scope),
51       m_owner_scope(context), m_scope_range(scope_range),
52       m_declaration(decl_ptr), m_location(location), m_external(external),
53       m_artificial(artificial), m_static_member(static_member) {}
54 
55 //----------------------------------------------------------------------
56 // Destructor
57 //----------------------------------------------------------------------
58 Variable::~Variable() {}
59 
60 lldb::LanguageType Variable::GetLanguage() const {
61   SymbolContext variable_sc;
62   m_owner_scope->CalculateSymbolContext(&variable_sc);
63   if (variable_sc.comp_unit)
64     return variable_sc.comp_unit->GetLanguage();
65   return lldb::eLanguageTypeUnknown;
66 }
67 
68 ConstString Variable::GetName() const {
69   ConstString name = m_mangled.GetName(GetLanguage());
70   if (name)
71     return name;
72   return m_name;
73 }
74 
75 ConstString Variable::GetUnqualifiedName() const { return m_name; }
76 
77 bool Variable::NameMatches(const ConstString &name) const {
78   if (m_name == name)
79     return true;
80   SymbolContext variable_sc;
81   m_owner_scope->CalculateSymbolContext(&variable_sc);
82 
83   LanguageType language = eLanguageTypeUnknown;
84   if (variable_sc.comp_unit)
85     language = variable_sc.comp_unit->GetLanguage();
86   return m_mangled.NameMatches(name, language);
87 }
88 bool Variable::NameMatches(const RegularExpression &regex) const {
89   if (regex.Execute(m_name.AsCString()))
90     return true;
91   if (m_mangled)
92     return m_mangled.NameMatches(regex, GetLanguage());
93   return false;
94 }
95 
96 Type *Variable::GetType() {
97   if (m_symfile_type_sp)
98     return m_symfile_type_sp->GetType();
99   return nullptr;
100 }
101 
102 void Variable::Dump(Stream *s, bool show_context) const {
103   s->Printf("%p: ", static_cast<const void *>(this));
104   s->Indent();
105   *s << "Variable" << (const UserID &)*this;
106 
107   if (m_name)
108     *s << ", name = \"" << m_name << "\"";
109 
110   if (m_symfile_type_sp) {
111     Type *type = m_symfile_type_sp->GetType();
112     if (type) {
113       *s << ", type = {" << type->GetID() << "} " << (void *)type << " (";
114       type->DumpTypeName(s);
115       s->PutChar(')');
116     }
117   }
118 
119   if (m_scope != eValueTypeInvalid) {
120     s->PutCString(", scope = ");
121     switch (m_scope) {
122     case eValueTypeVariableGlobal:
123       s->PutCString(m_external ? "global" : "static");
124       break;
125     case eValueTypeVariableArgument:
126       s->PutCString("parameter");
127       break;
128     case eValueTypeVariableLocal:
129       s->PutCString("local");
130       break;
131     case eValueTypeVariableThreadLocal:
132       s->PutCString("thread local");
133       break;
134     default:
135       *s << "??? (" << m_scope << ')';
136     }
137   }
138 
139   if (show_context && m_owner_scope != nullptr) {
140     s->PutCString(", context = ( ");
141     m_owner_scope->DumpSymbolContext(s);
142     s->PutCString(" )");
143   }
144 
145   bool show_fullpaths = false;
146   m_declaration.Dump(s, show_fullpaths);
147 
148   if (m_location.IsValid()) {
149     s->PutCString(", location = ");
150     lldb::addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
151     if (m_location.IsLocationList()) {
152       SymbolContext variable_sc;
153       m_owner_scope->CalculateSymbolContext(&variable_sc);
154       if (variable_sc.function)
155         loclist_base_addr = variable_sc.function->GetAddressRange()
156                                 .GetBaseAddress()
157                                 .GetFileAddress();
158     }
159     ABI *abi = nullptr;
160     if (m_owner_scope) {
161       ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
162       if (module_sp)
163         abi = ABI::FindPlugin(module_sp->GetArchitecture()).get();
164     }
165     m_location.GetDescription(s, lldb::eDescriptionLevelBrief,
166                               loclist_base_addr, abi);
167   }
168 
169   if (m_external)
170     s->PutCString(", external");
171 
172   if (m_artificial)
173     s->PutCString(", artificial");
174 
175   s->EOL();
176 }
177 
178 bool Variable::DumpDeclaration(Stream *s, bool show_fullpaths,
179                                bool show_module) {
180   bool dumped_declaration_info = false;
181   if (m_owner_scope) {
182     SymbolContext sc;
183     m_owner_scope->CalculateSymbolContext(&sc);
184     sc.block = nullptr;
185     sc.line_entry.Clear();
186     bool show_inlined_frames = false;
187     const bool show_function_arguments = true;
188     const bool show_function_name = true;
189 
190     dumped_declaration_info = sc.DumpStopContext(
191         s, nullptr, Address(), show_fullpaths, show_module, show_inlined_frames,
192         show_function_arguments, show_function_name);
193 
194     if (sc.function)
195       s->PutChar(':');
196   }
197   if (m_declaration.DumpStopContext(s, false))
198     dumped_declaration_info = true;
199   return dumped_declaration_info;
200 }
201 
202 size_t Variable::MemorySize() const { return sizeof(Variable); }
203 
204 CompilerDeclContext Variable::GetDeclContext() {
205   Type *type = GetType();
206   if (type)
207     return type->GetSymbolFile()->GetDeclContextContainingUID(GetID());
208   return CompilerDeclContext();
209 }
210 
211 CompilerDecl Variable::GetDecl() {
212   Type *type = GetType();
213   return type ? type->GetSymbolFile()->GetDeclForUID(GetID()) : CompilerDecl();
214 }
215 
216 void Variable::CalculateSymbolContext(SymbolContext *sc) {
217   if (m_owner_scope) {
218     m_owner_scope->CalculateSymbolContext(sc);
219     sc->variable = this;
220   } else
221     sc->Clear(false);
222 }
223 
224 bool Variable::LocationIsValidForFrame(StackFrame *frame) {
225   // Is the variable is described by a single location?
226   if (!m_location.IsLocationList()) {
227     // Yes it is, the location is valid.
228     return true;
229   }
230 
231   if (frame) {
232     Function *function =
233         frame->GetSymbolContext(eSymbolContextFunction).function;
234     if (function) {
235       TargetSP target_sp(frame->CalculateTarget());
236 
237       addr_t loclist_base_load_addr =
238           function->GetAddressRange().GetBaseAddress().GetLoadAddress(
239               target_sp.get());
240       if (loclist_base_load_addr == LLDB_INVALID_ADDRESS)
241         return false;
242       // It is a location list. We just need to tell if the location
243       // list contains the current address when converted to a load
244       // address
245       return m_location.LocationListContainsAddress(
246           loclist_base_load_addr,
247           frame->GetFrameCodeAddress().GetLoadAddress(target_sp.get()));
248     }
249   }
250   return false;
251 }
252 
253 bool Variable::LocationIsValidForAddress(const Address &address) {
254   // Be sure to resolve the address to section offset prior to
255   // calling this function.
256   if (address.IsSectionOffset()) {
257     SymbolContext sc;
258     CalculateSymbolContext(&sc);
259     if (sc.module_sp == address.GetModule()) {
260       // Is the variable is described by a single location?
261       if (!m_location.IsLocationList()) {
262         // Yes it is, the location is valid.
263         return true;
264       }
265 
266       if (sc.function) {
267         addr_t loclist_base_file_addr =
268             sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
269         if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
270           return false;
271         // It is a location list. We just need to tell if the location
272         // list contains the current address when converted to a load
273         // address
274         return m_location.LocationListContainsAddress(loclist_base_file_addr,
275                                                       address.GetFileAddress());
276       }
277     }
278   }
279   return false;
280 }
281 
282 bool Variable::IsInScope(StackFrame *frame) {
283   switch (m_scope) {
284   case eValueTypeRegister:
285   case eValueTypeRegisterSet:
286     return frame != nullptr;
287 
288   case eValueTypeConstResult:
289   case eValueTypeVariableGlobal:
290   case eValueTypeVariableStatic:
291   case eValueTypeVariableThreadLocal:
292     return true;
293 
294   case eValueTypeVariableArgument:
295   case eValueTypeVariableLocal:
296     if (frame) {
297       // We don't have a location list, we just need to see if the block
298       // that this variable was defined in is currently
299       Block *deepest_frame_block =
300           frame->GetSymbolContext(eSymbolContextBlock).block;
301       if (deepest_frame_block) {
302         SymbolContext variable_sc;
303         CalculateSymbolContext(&variable_sc);
304 
305         // Check for static or global variable defined at the compile unit
306         // level that wasn't defined in a block
307         if (variable_sc.block == nullptr)
308           return true;
309 
310         // Check if the variable is valid in the current block
311         if (variable_sc.block != deepest_frame_block &&
312             !variable_sc.block->Contains(deepest_frame_block))
313           return false;
314 
315         // If no scope range is specified then it means that the scope is the
316         // same as the
317         // scope of the enclosing lexical block.
318         if (m_scope_range.IsEmpty())
319           return true;
320 
321         addr_t file_address = frame->GetFrameCodeAddress().GetFileAddress();
322         return m_scope_range.FindEntryThatContains(file_address) != nullptr;
323       }
324     }
325     break;
326 
327   default:
328     break;
329   }
330   return false;
331 }
332 
333 Error Variable::GetValuesForVariableExpressionPath(
334     llvm::StringRef variable_expr_path, ExecutionContextScope *scope,
335     GetVariableCallback callback, void *baton, VariableList &variable_list,
336     ValueObjectList &valobj_list) {
337   Error error;
338   if (!callback || variable_expr_path.empty()) {
339     error.SetErrorString("unknown error");
340     return error;
341   }
342 
343   switch (variable_expr_path.front()) {
344   case '*':
345     error = Variable::GetValuesForVariableExpressionPath(
346         variable_expr_path.drop_front(), scope, callback, baton, variable_list,
347         valobj_list);
348     if (error.Fail()) {
349       error.SetErrorString("unknown error");
350       return error;
351     }
352     for (uint32_t i = 0; i < valobj_list.GetSize();) {
353       Error tmp_error;
354       ValueObjectSP valobj_sp(
355           valobj_list.GetValueObjectAtIndex(i)->Dereference(tmp_error));
356       if (tmp_error.Fail()) {
357         variable_list.RemoveVariableAtIndex(i);
358         valobj_list.RemoveValueObjectAtIndex(i);
359       } else {
360         valobj_list.SetValueObjectAtIndex(i, valobj_sp);
361         ++i;
362       }
363     }
364     return error;
365   case '&': {
366     error = Variable::GetValuesForVariableExpressionPath(
367         variable_expr_path.drop_front(), scope, callback, baton, variable_list,
368         valobj_list);
369     if (error.Success()) {
370       for (uint32_t i = 0; i < valobj_list.GetSize();) {
371         Error tmp_error;
372         ValueObjectSP valobj_sp(
373             valobj_list.GetValueObjectAtIndex(i)->AddressOf(tmp_error));
374         if (tmp_error.Fail()) {
375           variable_list.RemoveVariableAtIndex(i);
376           valobj_list.RemoveValueObjectAtIndex(i);
377         } else {
378           valobj_list.SetValueObjectAtIndex(i, valobj_sp);
379           ++i;
380         }
381       }
382     } else {
383       error.SetErrorString("unknown error");
384     }
385     return error;
386   } break;
387 
388   default: {
389     static RegularExpression g_regex(
390         llvm::StringRef("^([A-Za-z_:][A-Za-z_0-9:]*)(.*)"));
391     RegularExpression::Match regex_match(1);
392     std::string variable_name;
393     variable_list.Clear();
394     if (!g_regex.Execute(variable_expr_path, &regex_match)) {
395       error.SetErrorStringWithFormat(
396           "unable to extract a variable name from '%s'",
397           variable_expr_path.str().c_str());
398       return error;
399     }
400     if (!regex_match.GetMatchAtIndex(variable_expr_path, 1, variable_name)) {
401       error.SetErrorStringWithFormat(
402           "unable to extract a variable name from '%s'",
403           variable_expr_path.str().c_str());
404       return error;
405     }
406     if (!callback(baton, variable_name.c_str(), variable_list)) {
407       error.SetErrorString("unknown error");
408       return error;
409     }
410     uint32_t i = 0;
411     while (i < variable_list.GetSize()) {
412       VariableSP var_sp(variable_list.GetVariableAtIndex(i));
413       ValueObjectSP valobj_sp;
414       if (!var_sp) {
415         variable_list.RemoveVariableAtIndex(i);
416         continue;
417       }
418       ValueObjectSP variable_valobj_sp(
419           ValueObjectVariable::Create(scope, var_sp));
420       if (!variable_valobj_sp) {
421         variable_list.RemoveVariableAtIndex(i);
422         continue;
423       }
424 
425       llvm::StringRef variable_sub_expr_path =
426           variable_expr_path.drop_front(variable_name.size());
427       if (!variable_sub_expr_path.empty()) {
428         ValueObject::ExpressionPathScanEndReason reason_to_stop;
429         ValueObject::ExpressionPathEndResultType final_value_type;
430         ValueObject::GetValueForExpressionPathOptions options;
431         ValueObject::ExpressionPathAftermath final_task_on_target;
432 
433         valobj_sp = variable_valobj_sp->GetValueForExpressionPath(
434             variable_sub_expr_path, &reason_to_stop, &final_value_type, options,
435             &final_task_on_target);
436         if (!valobj_sp) {
437           error.SetErrorStringWithFormat(
438               "invalid expression path '%s' for variable '%s'",
439               variable_sub_expr_path.str().c_str(),
440               var_sp->GetName().GetCString());
441           variable_list.RemoveVariableAtIndex(i);
442           continue;
443         }
444       } else {
445         // Just the name of a variable with no extras
446         valobj_sp = variable_valobj_sp;
447       }
448 
449       valobj_list.Append(valobj_sp);
450       ++i;
451     }
452 
453     if (variable_list.GetSize() > 0) {
454       error.Clear();
455       return error;
456     }
457   } break;
458   }
459   error.SetErrorString("unknown error");
460   return error;
461 }
462 
463 bool Variable::DumpLocationForAddress(Stream *s, const Address &address) {
464   // Be sure to resolve the address to section offset prior to
465   // calling this function.
466   if (address.IsSectionOffset()) {
467     SymbolContext sc;
468     CalculateSymbolContext(&sc);
469     if (sc.module_sp == address.GetModule()) {
470       ABI *abi = nullptr;
471       if (m_owner_scope) {
472         ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
473         if (module_sp)
474           abi = ABI::FindPlugin(module_sp->GetArchitecture()).get();
475       }
476 
477       const addr_t file_addr = address.GetFileAddress();
478       if (sc.function) {
479         if (sc.function->GetAddressRange().ContainsFileAddress(address)) {
480           addr_t loclist_base_file_addr =
481               sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
482           if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
483             return false;
484           return m_location.DumpLocationForAddress(s, eDescriptionLevelBrief,
485                                                    loclist_base_file_addr,
486                                                    file_addr, abi);
487         }
488       }
489       return m_location.DumpLocationForAddress(
490           s, eDescriptionLevelBrief, LLDB_INVALID_ADDRESS, file_addr, abi);
491     }
492   }
493   return false;
494 }
495 
496 static void PrivateAutoComplete(
497     StackFrame *frame, llvm::StringRef partial_path,
498     const llvm::Twine
499         &prefix_path, // Anything that has been resolved already will be in here
500     const CompilerType &compiler_type,
501     StringList &matches, bool &word_complete);
502 
503 static void PrivateAutoCompleteMembers(
504     StackFrame *frame, const std::string &partial_member_name,
505     llvm::StringRef partial_path,
506     const llvm::Twine
507         &prefix_path, // Anything that has been resolved already will be in here
508     const CompilerType &compiler_type,
509     StringList &matches, bool &word_complete);
510 
511 static void PrivateAutoCompleteMembers(
512     StackFrame *frame, const std::string &partial_member_name,
513     llvm::StringRef partial_path,
514     const llvm::Twine
515         &prefix_path, // Anything that has been resolved already will be in here
516     const CompilerType &compiler_type,
517     StringList &matches, bool &word_complete) {
518 
519   // We are in a type parsing child members
520   const uint32_t num_bases = compiler_type.GetNumDirectBaseClasses();
521 
522   if (num_bases > 0) {
523     for (uint32_t i = 0; i < num_bases; ++i) {
524       CompilerType base_class_type =
525           compiler_type.GetDirectBaseClassAtIndex(i, nullptr);
526 
527       PrivateAutoCompleteMembers(
528           frame, partial_member_name, partial_path, prefix_path,
529           base_class_type.GetCanonicalType(), matches, word_complete);
530     }
531   }
532 
533   const uint32_t num_vbases = compiler_type.GetNumVirtualBaseClasses();
534 
535   if (num_vbases > 0) {
536     for (uint32_t i = 0; i < num_vbases; ++i) {
537       CompilerType vbase_class_type =
538           compiler_type.GetVirtualBaseClassAtIndex(i, nullptr);
539 
540       PrivateAutoCompleteMembers(
541           frame, partial_member_name, partial_path, prefix_path,
542           vbase_class_type.GetCanonicalType(), matches, word_complete);
543     }
544   }
545 
546   // We are in a type parsing child members
547   const uint32_t num_fields = compiler_type.GetNumFields();
548 
549   if (num_fields > 0) {
550     for (uint32_t i = 0; i < num_fields; ++i) {
551       std::string member_name;
552 
553       CompilerType member_compiler_type = compiler_type.GetFieldAtIndex(
554           i, member_name, nullptr, nullptr, nullptr);
555 
556       if (partial_member_name.empty() ||
557           member_name.find(partial_member_name) == 0) {
558         if (member_name == partial_member_name) {
559           PrivateAutoComplete(
560               frame, partial_path,
561               prefix_path + member_name, // Anything that has been resolved
562                                          // already will be in here
563               member_compiler_type.GetCanonicalType(), matches, word_complete);
564         } else {
565           matches.AppendString((prefix_path + member_name).str());
566         }
567       }
568     }
569   }
570 }
571 
572 static void PrivateAutoComplete(
573     StackFrame *frame, llvm::StringRef partial_path,
574     const llvm::Twine
575         &prefix_path, // Anything that has been resolved already will be in here
576     const CompilerType &compiler_type,
577     StringList &matches, bool &word_complete) {
578   //    printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path =
579   //    '%s'\n", prefix_path.c_str(), partial_path.c_str());
580   std::string remaining_partial_path;
581 
582   const lldb::TypeClass type_class = compiler_type.GetTypeClass();
583   if (partial_path.empty()) {
584     if (compiler_type.IsValid()) {
585       switch (type_class) {
586       default:
587       case eTypeClassArray:
588       case eTypeClassBlockPointer:
589       case eTypeClassBuiltin:
590       case eTypeClassComplexFloat:
591       case eTypeClassComplexInteger:
592       case eTypeClassEnumeration:
593       case eTypeClassFunction:
594       case eTypeClassMemberPointer:
595       case eTypeClassReference:
596       case eTypeClassTypedef:
597       case eTypeClassVector: {
598         matches.AppendString(prefix_path.str());
599         word_complete = matches.GetSize() == 1;
600       } break;
601 
602       case eTypeClassClass:
603       case eTypeClassStruct:
604       case eTypeClassUnion:
605         if (prefix_path.str().back() != '.')
606           matches.AppendString((prefix_path + ".").str());
607         break;
608 
609       case eTypeClassObjCObject:
610       case eTypeClassObjCInterface:
611         break;
612       case eTypeClassObjCObjectPointer:
613       case eTypeClassPointer: {
614         bool omit_empty_base_classes = true;
615         if (compiler_type.GetNumChildren(omit_empty_base_classes) > 0)
616           matches.AppendString((prefix_path + "->").str());
617         else {
618           matches.AppendString(prefix_path.str());
619           word_complete = true;
620         }
621       } break;
622       }
623     } else {
624       if (frame) {
625         const bool get_file_globals = true;
626 
627         VariableList *variable_list = frame->GetVariableList(get_file_globals);
628 
629         if (variable_list) {
630           const size_t num_variables = variable_list->GetSize();
631           for (size_t i = 0; i < num_variables; ++i) {
632             Variable *variable = variable_list->GetVariableAtIndex(i).get();
633             matches.AppendString(variable->GetName().AsCString());
634           }
635         }
636       }
637     }
638   } else {
639     const char ch = partial_path[0];
640     switch (ch) {
641     case '*':
642       if (prefix_path.str().empty()) {
643         PrivateAutoComplete(frame, partial_path.substr(1), "*", compiler_type,
644                             matches, word_complete);
645       }
646       break;
647 
648     case '&':
649       if (prefix_path.isTriviallyEmpty()) {
650         PrivateAutoComplete(frame, partial_path.substr(1), std::string("&"),
651                             compiler_type, matches, word_complete);
652       }
653       break;
654 
655     case '-':
656       if (partial_path[1] == '>' && !prefix_path.str().empty()) {
657         switch (type_class) {
658         case lldb::eTypeClassPointer: {
659           CompilerType pointee_type(compiler_type.GetPointeeType());
660           if (partial_path[2]) {
661             // If there is more after the "->", then search deeper
662             PrivateAutoComplete(
663                 frame, partial_path.substr(2), prefix_path + "->",
664                 pointee_type.GetCanonicalType(), matches, word_complete);
665           } else {
666             // Nothing after the "->", so list all members
667             PrivateAutoCompleteMembers(
668                 frame, std::string(), std::string(), prefix_path + "->",
669                 pointee_type.GetCanonicalType(), matches, word_complete);
670           }
671         } break;
672         default:
673           break;
674         }
675       }
676       break;
677 
678     case '.':
679       if (compiler_type.IsValid()) {
680         switch (type_class) {
681         case lldb::eTypeClassUnion:
682         case lldb::eTypeClassStruct:
683         case lldb::eTypeClassClass:
684           if (partial_path[1]) {
685             // If there is more after the ".", then search deeper
686             PrivateAutoComplete(frame, partial_path.substr(1),
687                                 prefix_path + ".", compiler_type, matches,
688                                 word_complete);
689 
690           } else {
691             // Nothing after the ".", so list all members
692             PrivateAutoCompleteMembers(frame, std::string(), partial_path,
693                                        prefix_path + ".", compiler_type,
694                                        matches, word_complete);
695           }
696           break;
697         default:
698           break;
699         }
700       }
701       break;
702     default:
703       if (isalpha(ch) || ch == '_' || ch == '$') {
704         const size_t partial_path_len = partial_path.size();
705         size_t pos = 1;
706         while (pos < partial_path_len) {
707           const char curr_ch = partial_path[pos];
708           if (isalnum(curr_ch) || curr_ch == '_' || curr_ch == '$') {
709             ++pos;
710             continue;
711           }
712           break;
713         }
714 
715         std::string token(partial_path, 0, pos);
716         remaining_partial_path = partial_path.substr(pos);
717 
718         if (compiler_type.IsValid()) {
719           PrivateAutoCompleteMembers(frame, token, remaining_partial_path,
720                                      prefix_path, compiler_type, matches,
721                                      word_complete);
722         } else if (frame) {
723           // We haven't found our variable yet
724           const bool get_file_globals = true;
725 
726           VariableList *variable_list =
727               frame->GetVariableList(get_file_globals);
728 
729           if (!variable_list)
730             break;
731 
732           const size_t num_variables = variable_list->GetSize();
733           for (size_t i = 0; i < num_variables; ++i) {
734             Variable *variable = variable_list->GetVariableAtIndex(i).get();
735 
736             if (!variable)
737               continue;
738 
739             const char *variable_name = variable->GetName().AsCString();
740             if (strstr(variable_name, token.c_str()) == variable_name) {
741               if (strcmp(variable_name, token.c_str()) == 0) {
742                 Type *variable_type = variable->GetType();
743                 if (variable_type) {
744                   CompilerType variable_compiler_type(
745                       variable_type->GetForwardCompilerType());
746                   PrivateAutoComplete(
747                       frame, remaining_partial_path,
748                       prefix_path + token, // Anything that has been resolved
749                                            // already will be in here
750                       variable_compiler_type.GetCanonicalType(), matches,
751                       word_complete);
752                 } else {
753                   matches.AppendString((prefix_path + variable_name).str());
754                 }
755               } else if (remaining_partial_path.empty()) {
756                 matches.AppendString((prefix_path + variable_name).str());
757               }
758             }
759           }
760         }
761       }
762       break;
763     }
764   }
765 }
766 
767 size_t Variable::AutoComplete(const ExecutionContext &exe_ctx,
768                               llvm::StringRef partial_path, StringList &matches,
769                               bool &word_complete) {
770   word_complete = false;
771   CompilerType compiler_type;
772 
773   PrivateAutoComplete(exe_ctx.GetFramePtr(), partial_path, "", compiler_type,
774                       matches, word_complete);
775 
776   return matches.GetSize();
777 }
778