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