Проблема с разделением имени типа

Я создавал класс-шаблон, который преобразует тип в строку, описывающую его, например, typeinfo::name()возвращает строку"int(*)()"(до пробела ). Первоначально у меня было множество особых случаев, чтобы обойти тот факт, что typeid(...).name()удаляет ссылочные квалификаторы и квалификаторы верхнего -уровня cv -, но потом я вспомнил, что передача типа в качестве параметра шаблона сохранит их. Итак, используя заголовок ABI, я получил что-то вроде этого:

#include 
#include 
#include 
#include 

using namespace std;

string demangle(const char* mangledName) {
    int status;
    char* result = abi::__cxa_demangle(mangledName, nullptr, nullptr, &status);
    switch(status) {
    case -1:
        cerr << "Out of memory!" << endl;
        exit(1);
    case -2:
        return mangledName;
    case -3: // Should never happen, but just in case?
        return mangledName;
    }
    string name = result;
    free(result);
    return name;
}

template struct preserve_qualifiers {};

template class typeinfo {
    using wrap = preserve_qualifiers;
public:
    static const string name() {
        string name = demangle(typeid(wrap).name());
        int i = name.find_first_of('<');
        if(i == string::npos) return name;
        int j = name.length() - i - 2;
        return name.substr(i + 1, j);
    }
};

#define TypeOut(...) cout \
    << "Type " #__VA_ARGS__ ": " << endl \
    << "  Mangled: " << typeid(__VA_ARGS__).name() << endl \
    << "  Demangled: " << demangle(typeid(__VA_ARGS__).name()) << endl \
    << "  typeinfo<>: " << typeinfo<__VA_ARGS__>::name() << endl
class A {};
template class F {};
template class G {};
template class T> class H {};
template class T> class I {};
template class J {};
template class K {};
template class... T> class L {};
template class... T> class M {};
template class... T> class N {};
template class...> class... T> class O {};
struct bits {int i : 4, j : 2;};
template struct bits2 {T val : n;};

int main(int argc, char* argv[]) {
    TypeOut(void(*volatile)(void(*const)()));
    TypeOut(int (A::*)());
    TypeOut(int (A::*)()const);
    TypeOut(int (A::*const)());
#ifdef __clang__
    TypeOut(int (A::*)()&);
    TypeOut(int (A::*)()&&);
#endif
    TypeOut(F);
    TypeOut(G<3>);
    TypeOut(H);
    TypeOut(I);
    TypeOut(J);
    TypeOut(K<3>);
    TypeOut(L);
    TypeOut(M);
    TypeOut(N);
    TypeOut(O);
}

Это компилируется и работает (почти )в GCC (4.8 ). Однако GCC не поддерживает квалификаторы ref -для функций-членов, поэтому попробовал его и в Clang (3.2 ), чтобы посмотреть, будет ли он работать. Это не так. Он отлично компилируется и работает без проблем, но большинство имен шаблонов не расшифровываются, как и функции-члены ref -.

Здесь — это вывод GCC из ideone (код был немного изменен, так как версия GCC от ideone не поддерживает объявления nullptr или псевдонимов ). Обратите внимание на отсутствующий квалификатор const в параметре функции. Это единственное, что не сработало, как я надеялся, в GCC. То же самое и в Clang, что, я думаю, не особенно удивительно. (Что удивительно, так это то, что он вообще отсутствует, а не то, что GCC и Clang согласуются с ним.)

К сожалению, при компиляции и запуске с помощью Clang шаблонные классы с переменным числом аргументов не удалось разобрать. Например, J был изменен на 1JIJiEEвместо 1JIIiEE, который выбрал GCC.

Выбранный вывод из clang (показывает только те, которые не работают)

Type int (A::*)()&: 
  Mangled: M1AFivRE
  Demangled: M1AFivRE
  typeinfo<>: 19preserve_qualifiersIM1AFivREE
Type int (A::*)()&&: 
  Mangled: M1AFivOE
  Demangled: M1AFivOE
  typeinfo<>: 19preserve_qualifiersIM1AFivOEE
Type J: 
  Mangled: 1JIJiEE
  Demangled: 1JIJiEE
  typeinfo<>: 19preserve_qualifiersI1JIJiEEE
Type K<3>: 
  Mangled: 1KIJLi3EEE
  Demangled: 1KIJLi3EEE
  typeinfo<>: 19preserve_qualifiersI1KIJLi3EEEE
Type L: 
  Mangled: 1LIJ1FEE
  Demangled: 1LIJ1FEE
  typeinfo<>: 19preserve_qualifiersI1LIJ1FEEE
Type M: 
  Mangled: 1MIJ1GEE
  Demangled: 1MIJ1GEE
  typeinfo<>: 19preserve_qualifiersI1MIJ1GEEE
Type N: 
  Mangled: 1NIJ1FS0_S0_EE
  Demangled: 1NIJ1FS0_S0_EE
  typeinfo<>: 19preserve_qualifiersI1NIJ1FS1_S1_EEE
Type O: 
  Mangled: 1OIJ1NS0_EE
  Demangled: 1OIJ1NS0_EE
  typeinfo<>: 19preserve_qualifiersI1OIJ1NS1_EEE

Кто-нибудь знает, как это можно решить? Это ошибка в clang? (А может, ошибка в GCC?)Моим первым подозрением была несовместимость версий C++ ABI, связанного с моим кодом, и C++ ABI, который использует clang. Тот факт, что проблема возникает только с новыми функциями С++ 11 (, ссылкой на функцию-член -, квалификаторами и шаблонами с переменным числом переменных ), похоже, подтверждает это подозрение... хотя r -ссылается на значение (, например )Нет проблем.

Если это уместно, я использую Mac OSX Lion, а GCC 4.8 и clang 3.2 были установлены с MacPorts. Я использую следующие команды для компиляции:

clang++-mp-3.2 -isystem/usr/local/include/c++/v1 -stdlib=libc++ -std=gnu++11 typeinfo-min.cpp -o typeinfofun-clang
G++-mp-4.8 -std=gnu++11 typeinfo-min.cpp -o typeinfofun-gcc

Флаг isystem кажется необходимым, чтобы позволить clang найти заголовки libc++ (, что было необходимо, когда я использовал для более сложной версии этого ). Без него он даже не может найти .

(В качестве дополнительного примечания, эта проблема влияет и на более сложную версию, поскольку имена классов не были — что, вероятно, неудивительно — среди специализаций для сложных типов, и, таким образом, просто использовался вызов ABI demangle.)

(Кроме того, меня интересует переносимость этого. Я знаю, что в MSVC это не обязательно, так как это возвращает неискаженное имя из typeid(...).name(), но кроме этого...)