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