1 //===-- CPPLanguageRuntime.cpp -------------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Target/CPPLanguageRuntime.h"
14 #include "lldb/Core/PluginManager.h"
15 #include "lldb/Core/UniqueCStringMap.h"
16 #include "lldb/Target/ExecutionContext.h"
19 using namespace lldb_private;
21 class CPPRuntimeEquivalents
24 CPPRuntimeEquivalents ()
27 m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("basic_string<char>"));
29 // these two (with a prefixed std::) occur when c++stdlib string class occurs as a template argument in some STL container
30 m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("std::basic_string<char>"));
36 Add (ConstString& type_name,
37 ConstString& type_equivalent)
39 m_impl.Insert(type_name.AsCString(), type_equivalent);
43 FindExactMatches (ConstString& type_name,
44 std::vector<ConstString>& equivalents)
49 for (ImplData match = m_impl.FindFirstValueForName(type_name.AsCString());
51 match = m_impl.FindNextValueForName(match))
53 equivalents.push_back(match->value);
60 // partial matches can occur when a name with equivalents is a template argument.
61 // e.g. we may have "class Foo" be a match for "struct Bar". if we have a typename
62 // such as "class Templatized<class Foo, Anything>" we want this to be replaced with
63 // "class Templatized<struct Bar, Anything>". Since partial matching is time consuming
64 // once we get a partial match, we add it to the exact matches list for faster retrieval
66 FindPartialMatches (ConstString& type_name,
67 std::vector<ConstString>& equivalents)
72 const char* type_name_cstr = type_name.AsCString();
74 size_t items_count = m_impl.GetSize();
76 for (size_t item = 0; item < items_count; item++)
78 const char* key_cstr = m_impl.GetCStringAtIndex(item);
79 if ( strstr(type_name_cstr,key_cstr) )
81 count += AppendReplacements(type_name_cstr,
93 std::string& replace (std::string& target,
98 size_t pattern_len = pattern.size();
100 while ( (pos = target.find(pattern)) != std::string::npos )
101 target.replace(pos, pattern_len, with);
107 AppendReplacements (const char* original,
108 const char *matching_key,
109 std::vector<ConstString>& equivalents)
112 std::string matching_key_str(matching_key);
113 ConstString original_const(original);
117 for (ImplData match = m_impl.FindFirstValueForName(matching_key);
119 match = m_impl.FindNextValueForName(match))
121 std::string target(original);
122 std::string equiv_class(match->value.AsCString());
124 replace (target, matching_key_str, equiv_class);
126 ConstString target_const(target.c_str());
128 // you will most probably want to leave this off since it might make this map grow indefinitely
129 #ifdef ENABLE_CPP_EQUIVALENTS_MAP_TO_GROW
130 Add(original_const, target_const);
132 equivalents.push_back(target_const);
140 typedef UniqueCStringMap<ConstString> Impl;
141 typedef const Impl::Entry* ImplData;
145 static CPPRuntimeEquivalents&
148 static CPPRuntimeEquivalents g_equivalents_map;
149 return g_equivalents_map;
152 //----------------------------------------------------------------------
154 //----------------------------------------------------------------------
155 CPPLanguageRuntime::~CPPLanguageRuntime()
159 CPPLanguageRuntime::CPPLanguageRuntime (Process *process) :
160 LanguageRuntime (process)
166 CPPLanguageRuntime::GetObjectDescription (Stream &str, ValueObject &object)
168 // C++ has no generic way to do this.
173 CPPLanguageRuntime::GetObjectDescription (Stream &str, Value &value, ExecutionContextScope *exe_scope)
175 // C++ has no generic way to do this.
180 CPPLanguageRuntime::IsCPPMangledName (const char *name)
182 // FIXME, we should really run through all the known C++ Language plugins and ask each one if
183 // this is a C++ mangled name, but we can put that off till there is actually more than one
186 if (name && name[0] == '_' && name[1] == 'Z')
193 CPPLanguageRuntime::StripNamespacesFromVariableName (const char *name, const char *&base_name_start, const char *&base_name_end)
195 if (base_name_end == NULL)
196 base_name_end = name + strlen (name);
198 const char *last_colon = strrchr (name, ':');
200 if (last_colon == NULL)
202 base_name_start = name;
206 // Can't have a C++ name that begins with a single ':', nor contains an internal single ':'
207 if (last_colon == name)
209 else if (last_colon[-1] != ':')
213 // FIXME: should check if there is
214 base_name_start = last_colon + 1;
220 CPPLanguageRuntime::FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents)
222 uint32_t count = GetEquivalentsMap().FindExactMatches(type_name, equivalents);
224 bool might_have_partials=
225 ( count == 0 ) // if we have a full name match just use it
226 && (strchr(type_name.AsCString(), '<') != NULL // we should only have partial matches when templates are involved, check that we have
227 && strchr(type_name.AsCString(), '>') != NULL); // angle brackets in the type_name before trying to scan for partial matches
229 if ( might_have_partials )
230 count = GetEquivalentsMap().FindPartialMatches(type_name, equivalents);
236 CPPLanguageRuntime::MethodName::Clear()
239 m_basename = llvm::StringRef();
240 m_context = llvm::StringRef();
241 m_arguments = llvm::StringRef();
242 m_qualifiers = llvm::StringRef();
243 m_type = eTypeInvalid;
245 m_parse_error = false;
249 ReverseFindMatchingChars (const llvm::StringRef &s,
250 const llvm::StringRef &left_right_chars,
253 size_t pos = llvm::StringRef::npos)
255 assert (left_right_chars.size() == 2);
256 left_pos = llvm::StringRef::npos;
257 const char left_char = left_right_chars[0];
258 const char right_char = left_right_chars[1];
259 pos = s.find_last_of(left_right_chars, pos);
260 if (pos == llvm::StringRef::npos || s[pos] == left_char)
264 while (pos > 0 && depth > 0)
266 pos = s.find_last_of(left_right_chars, pos);
267 if (pos == llvm::StringRef::npos)
269 if (s[pos] == left_char)
274 return left_pos < right_pos;
277 else if (s[pos] == right_char)
286 CPPLanguageRuntime::MethodName::Parse()
288 if (!m_parsed && m_full)
290 // ConstString mangled;
291 // m_full.GetMangledCounterpart(mangled);
292 // printf ("\n parsing = '%s'\n", m_full.GetCString());
294 // printf (" mangled = '%s'\n", mangled.GetCString());
295 m_parse_error = false;
297 llvm::StringRef full (m_full.GetCString());
299 size_t arg_start, arg_end;
300 llvm::StringRef parens("()", 2);
301 if (ReverseFindMatchingChars (full, parens, arg_start, arg_end))
303 m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
304 if (arg_end + 1 < full.size())
305 m_qualifiers = full.substr(arg_end + 1);
308 size_t basename_end = arg_start;
309 size_t context_end = llvm::StringRef::npos;
310 if (basename_end > 0 && full[basename_end-1] == '>')
312 // TODO: handle template junk...
313 // Templated function
314 size_t template_start, template_end;
315 llvm::StringRef lt_gt("<>", 2);
316 if (ReverseFindMatchingChars (full, lt_gt, template_start, template_end, basename_end))
317 context_end = full.rfind(':', template_start);
319 if (context_end == llvm::StringRef::npos)
320 context_end = full.rfind(':', basename_end);
322 if (context_end == llvm::StringRef::npos)
323 m_basename = full.substr(0, basename_end);
326 m_context = full.substr(0, context_end - 1);
327 const size_t basename_begin = context_end + 1;
328 m_basename = full.substr(basename_begin, basename_end - basename_begin);
330 m_type = eTypeUnknownMethod;
334 m_parse_error = true;
338 // if (!m_context.empty())
339 // printf (" context = '%s'\n", m_context.str().c_str());
341 // printf (" basename = '%s'\n", m_basename.GetCString());
342 // if (!m_arguments.empty())
343 // printf (" arguments = '%s'\n", m_arguments.str().c_str());
344 // if (!m_qualifiers.empty())
345 // printf ("qualifiers = '%s'\n", m_qualifiers.str().c_str());
349 m_parse_error = true;
350 // printf ("error: didn't find matching parens for arguments\n");
356 CPPLanguageRuntime::MethodName::GetBasename ()
364 CPPLanguageRuntime::MethodName::GetContext ()
372 CPPLanguageRuntime::MethodName::GetArguments ()
380 CPPLanguageRuntime::MethodName::GetQualifiers ()