From 6f3533fb1d742620328b4fcc79410d3e09d6eb8d Mon Sep 17 00:00:00 2001 From: Enrico Granata Date: Fri, 29 Jul 2011 19:53:35 +0000 Subject: Public API changes: - Completely new implementation of SBType - Various enhancements in several other classes Python synthetic children providers for std::vector, std::list and std::map: - these return the actual elements into the container as the children of the container - basic template name parsing that works (hopefully) on both Clang and GCC - find them in examples/synthetic and in the test suite in functionalities/data-formatter/data-formatter-python-synth New summary string token ${svar : - the syntax is just the same as in ${var but this new token lets you read the values coming from the synthetic children provider instead of the actual children - Python providers above provide a synthetic child len that returns the number of elements into the container Full bug fix for the issue in which getting byte size for a non-complete type would crash LLDB Several other fixes, including: - inverted the order of arguments in the ClangASTType constructor - EvaluationPoint now only returns SharedPointer's to Target and Process - the help text for several type subcommands now correctly indicates argument-less options as such llvm-svn: 136504 --- lldb/source/Core/Module.cpp | 37 ++++++++++++++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) (limited to 'lldb/source/Core/Module.cpp') diff --git a/lldb/source/Core/Module.cpp b/lldb/source/Core/Module.cpp index 8b07a76eead..28780f4f99a 100644 --- a/lldb/source/Core/Module.cpp +++ b/lldb/source/Core/Module.cpp @@ -422,7 +422,7 @@ Module::FindFunctions (const RegularExpression& regex, } uint32_t -Module::FindTypes (const SymbolContext& sc, const ConstString &name, bool append, uint32_t max_matches, TypeList& types) +Module::FindTypes_Impl (const SymbolContext& sc, const ConstString &name, bool append, uint32_t max_matches, TypeList& types) { Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); if (sc.module_sp.get() == NULL || sc.module_sp.get() == this) @@ -434,6 +434,41 @@ Module::FindTypes (const SymbolContext& sc, const ConstString &name, bool append return 0; } +// depending on implementation details, type lookup might fail because of +// embedded spurious namespace:: prefixes. this call strips them, paying +// attention to the fact that a type might have namespace'd type names as +// arguments to templates, and those must not be stripped off +static const char* +StripTypeName(const char* name_cstr) +{ + const char* skip_namespace = strstr(name_cstr, "::"); + const char* template_arg_char = strchr(name_cstr, '<'); + while (skip_namespace != NULL) + { + if (template_arg_char != NULL && + skip_namespace > template_arg_char) // but namespace'd template arguments are still good to go + break; + name_cstr = skip_namespace+2; + skip_namespace = strstr(name_cstr, "::"); + } + return name_cstr; +} + +uint32_t +Module::FindTypes (const SymbolContext& sc, const ConstString &name, bool append, uint32_t max_matches, TypeList& types) +{ + uint32_t retval = FindTypes_Impl(sc, name, append, max_matches, types); + + if (retval == 0) + { + const char *stripped = StripTypeName(name.GetCString()); + return FindTypes_Impl(sc, ConstString(stripped), append, max_matches, types); + } + else + return retval; + +} + //uint32_t //Module::FindTypes(const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding encoding, const char *udt_name, TypeList& types) //{ -- cgit v1.2.3