feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
6d17da175f66a24143f676fc5b51a5b69b2b5cf4
qt-creator/tests/auto/debugger/tst_namedemangler.cpp

541 lines
32 KiB
C++
Raw Normal View History

Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
**
Contact -> qt-project.org Change-Id: I7134d7de30bcf9f9dcfad42520dd45ee083a852d Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@nokia.com>
2012-07-19 12:26:56 +02:00
** Contact: http://www.qt-project.org/
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
**
**
** GNU Lesser General Public License Usage
**
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this file.
** Please review the following information to ensure the GNU Lesser General
** Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** Other Usage
**
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**************************************************************************/
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
#include <namedemangler/namedemangler.h>
#include <namedemangler/parsetreenodes.h>
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
#include <QObject>
#include <QTest>
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
#define TEST_CORRECTLY_MANGLED_NAME(mangled, expectedDemangled) \
do { \
QVERIFY2(demangler.demangle(mangled), qPrintable(demangler.errorString())); \
QCOMPARE(demangler.demangledName(), QLatin1String(expectedDemangled)); \
} while (0)
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
const char *toString(char c) { return (QByteArray("'") + c + "'").constData(); }
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
using namespace Debugger::Internal;
class NameDemanglerAutoTest : public QObject
{
Q_OBJECT
private slots:
void testUnmangledName();
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
void testDisjunctFirstSets();
Debugger: Refactor name demangler. Now all the parsing logic as well as the stringification is in the tree nodes. Change-Id: Ie8222729c14c0102d94045026fc61a75cd31cc63 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 16:14:07 +02:00
void testCorrectlyMangledNames();
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
void testIncorrectlyMangledNames();
private:
void testIncorrectlyMangledName(const QString &mangledName);
NameDemangler demangler;
};
void NameDemanglerAutoTest::testUnmangledName()
{
QVERIFY(demangler.demangle("f") && demangler.demangledName() == "f");
}
Debugger: Refactor name demangler. Now all the parsing logic as well as the stringification is in the tree nodes. Change-Id: Ie8222729c14c0102d94045026fc61a75cd31cc63 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 16:14:07 +02:00
void NameDemanglerAutoTest::testCorrectlyMangledNames()
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
{
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z1fv", "f()");
TEST_CORRECTLY_MANGLED_NAME("_Z1fi", "f(int)");
TEST_CORRECTLY_MANGLED_NAME("_Z3foo3bar", "foo(bar)");
TEST_CORRECTLY_MANGLED_NAME("_Zrm1XS_", "operator%(X, X)");
TEST_CORRECTLY_MANGLED_NAME("_ZplR1XS0_", "operator+(X &, X &)");
TEST_CORRECTLY_MANGLED_NAME("_ZlsRK1XS1_", "operator<<(X const &, X const &)");
TEST_CORRECTLY_MANGLED_NAME("_ZN3FooIA4_iE3barE", "Foo<int[4]>::bar");
TEST_CORRECTLY_MANGLED_NAME("_Z5firstI3DuoEvS0_", "void first<Duo>(Duo)");
TEST_CORRECTLY_MANGLED_NAME("_Z5firstI3DuoEvT_", "void first<Duo>(Duo)");
TEST_CORRECTLY_MANGLED_NAME("_Z3fooIiPFidEiEvv",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"void foo<int, int (*)(double), int>()");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN1N1fE", "N::f");
TEST_CORRECTLY_MANGLED_NAME("_ZN6System5Sound4beepEv",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"System::Sound::beep()");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN5Arena5levelE", "Arena::level");
TEST_CORRECTLY_MANGLED_NAME("_ZN5StackIiiE5levelE", "Stack<int, int>::level");
TEST_CORRECTLY_MANGLED_NAME("_Z1fI1XEvPVN1AIT_E1TE",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"void f<X>(A<X>::T volatile *)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZngILi42EEvN1AIXplT_Li2EEE1TE",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"void operator-<42>(A<42 + 2>::T)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z4makeI7FactoryiET_IT0_Ev",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"Factory<int> make<Factory, int>()");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z3foo5Hello5WorldS0_S_",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"foo(Hello, World, World, Hello)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z3fooPM2ABi", "foo(int AB::**)");
TEST_CORRECTLY_MANGLED_NAME("_ZlsRSoRKSs",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"operator<<(std::basic_ostream<char, std::char_traits<char> > &, "
"std::basic_string<char, std::char_traits<char>, "
"std::allocator<char> > const &)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZTI7a_class", "typeid(a_class)");
TEST_CORRECTLY_MANGLED_NAME("_ZZN1A3fooEiE1B", "A::foo(int)::B");
TEST_CORRECTLY_MANGLED_NAME("_ZZ3foovEN1C1DE", "foo()::C::D");
TEST_CORRECTLY_MANGLED_NAME("_ZZZ3foovEN1C3barEvEN1E3bazEv",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"foo()::C::bar()::E::baz()");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZZN1N1fEiE1p", "N::f(int)::p");
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZZN1N1fEiEs", "N::f(int)::{string literal}");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z41__static_initialization_and_destruction_0ii",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"__static_initialization_and_destruction_0(int, int)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN20NameDemanglerPrivate3eoiE",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"NameDemanglerPrivate::eoi");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZZN20NameDemanglerPrivate15parseIdentifierEiE8__func__",
"NameDemanglerPrivate::parseIdentifier(int)::__func__");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN4QSetI5QCharED1Ev", "QSet<QChar>::~QSet()");
TEST_CORRECTLY_MANGLED_NAME("_Zne5QCharS_", "operator!=(QChar, QChar)");
TEST_CORRECTLY_MANGLED_NAME("_ZN20NameDemanglerPrivate17parseFunctionTypeEv",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"NameDemanglerPrivate::parseFunctionType()");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZNK20NameDemanglerPrivate16ArrayNewOperator8makeExprERK11QStringList",
"NameDemanglerPrivate::ArrayNewOperator::makeExpr(QStringList const &) const");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN13QLatin1StringC1EPKc",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"QLatin1String::QLatin1String(char const *)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZN15QtSharedPointer16ExternalRefCountIN20NameDemanglerPrivate8OperatorEE12internalCopyIS2_EEvRKNS0_IT_EE",
"void QtSharedPointer::ExternalRefCount<NameDemanglerPrivate::Operator>::internalCopy<NameDemanglerPrivate::Operator>(QtSharedPointer::ExternalRefCount<NameDemanglerPrivate::Operator> const &)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZN15QtSharedPointer16ExternalRefCountIN20NameDemanglerPrivate8OperatorEE11internalSetEPNS_20ExternalRefCountDataEPS2_",
"QtSharedPointer::ExternalRefCount<NameDemanglerPrivate::Operator>::internalSet(QtSharedPointer::ExternalRefCountData *, NameDemanglerPrivate::Operator *)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN20NameDemanglerPrivate17parseUnscopedNameEv",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"NameDemanglerPrivate::parseUnscopedName()");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZNK7QString3argExiiRK5QChar",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"QString::arg(long long, int, int, QChar const &) const");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZN20NameDemanglerPrivate8OperatorC2ERK7QStringS3_",
"NameDemanglerPrivate::Operator::Operator(QString const &, QString const &)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZN15QtSharedPointer16ExternalRefCountIN20NameDemanglerPrivate8OperatorEEC2EN2Qt14InitializationE",
"QtSharedPointer::ExternalRefCount<NameDemanglerPrivate::Operator>::ExternalRefCount(Qt::Initialization)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN7QString5clearEv", "QString::clear()");
TEST_CORRECTLY_MANGLED_NAME("_ZNK5QListI7QStringE2atEi",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"QList<QString>::at(int) const");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZNK7QString10startsWithERKS_N2Qt15CaseSensitivityE",
"QString::startsWith(QString const &, Qt::CaseSensitivity) const");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZNK4QSetI5QCharE8constEndEv",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"QSet<QChar>::constEnd() const");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z11qt_assert_xPKcS0_S0_i",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"qt_assert_x(char const *, char const *, char const *, int)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN9QHashData8willGrowEv",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"QHashData::willGrow()");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZNK5QHashI5QChar15QHashDummyValueE14const_iteratorneERKS3_",
"QHash<QChar, QHashDummyValue>::const_iterator::operator!=(QHash<QChar, QHashDummyValue>::const_iterator const &) const");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZNK13NameDemangler11errorStringEv",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"NameDemangler::errorString() const");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN7QString7replaceERK7QRegExpRKS_",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"QString::replace(QRegExp const &, QString const &)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN7QString4freeEPNS_4DataE",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"QString::free(QString::Data *)");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME(
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"_ZTSN20NameDemanglerPrivate19ArrayAccessOperatorE",
"typeid(NameDemanglerPrivate::ArrayAccessOperator).name()");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN3ns11fERKPFPKiS1_RKhE",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"ns1::f(int const * (* const &)(int const *, unsigned char const &))");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z9test_funcMN3ns11cImEEKFPKvPiRlmE",
"test_func(void const * (ns1::c<unsigned long>::*)(int *, long &, unsigned long) const)");
TEST_CORRECTLY_MANGLED_NAME("_ZN3ns11fEPKPFPKiS1_RKhE",
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
"ns1::f(int const * (* const *)(int const *, unsigned char const &))");
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZNK1CcviEv", "C::operator int() const");
TEST_CORRECTLY_MANGLED_NAME("_ZN1CppEv", "C::operator++()");
TEST_CORRECTLY_MANGLED_NAME("_ZN1CmmEv", "C::operator--()");
TEST_CORRECTLY_MANGLED_NAME("_ZN1CppEi", "C::operator++(int)");
TEST_CORRECTLY_MANGLED_NAME("_ZN1CmmEi", "C::operator--(int)");
TEST_CORRECTLY_MANGLED_NAME("_ZNK1CcvT_IPKcEEv", "C::operator char const *<char const *>() const");
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z9weirdfuncIiEvT_KPFS0_S0_E", "void weirdfunc<int>(int, int (* const)(int))");
TEST_CORRECTLY_MANGLED_NAME("_Z9weirdfuncIiEvT_PFS0_DtfL1p_EE", "void weirdfunc<int>(int, int (*)(decltype({param#1})))");
TEST_CORRECTLY_MANGLED_NAME("_Z9weirdfuncIiEvT_S0_", "void weirdfunc<int>(int, int)");
TEST_CORRECTLY_MANGLED_NAME("_Z9weirdfuncIiEvT_DtfL0p_E", "void weirdfunc<int>(int, decltype({param#1}))");
TEST_CORRECTLY_MANGLED_NAME("_Z9weirdfuncIiEvT_S0_S0_", "void weirdfunc<int>(int, int, int)");
TEST_CORRECTLY_MANGLED_NAME("_Z9weirdfuncIiEvT_S0_DtfL0p0_E", "void weirdfunc<int>(int, int, decltype({param#2}))");
Name demangler: Fix some substitution bugs. Also try to collapse references as much as it is possible with the current design. Change-Id: I1de55eac2d681a36f8b77d77968c4a06d19b6fac Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-25 11:43:21 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z8toStringIiESsT_",
"std::basic_string<char, std::char_traits<char>, std::allocator<char> > toString<int>(int)");
Name demangler: Fix reference collapsing. Change-Id: I7bcf1ace346ffcb5e05242f6cedfc5439c97fff9 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-08-10 16:46:38 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z4funcIRA5_iEvOT_", "void func<int (&)[5]>(int (&)[5])");
Name demangler: Fix some substitution bugs. Also try to collapse references as much as it is possible with the current design. Change-Id: I1de55eac2d681a36f8b77d77968c4a06d19b6fac Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-25 11:43:21 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZSt9make_pairIiRA5_KcESt4pairINSt17__decay_and_stripIT_E6__typeENS4_IT0_E6__typeEEOS5_OS8_",
Name demangler: Fix reference collapsing. Change-Id: I7bcf1ace346ffcb5e05242f6cedfc5439c97fff9 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-08-10 16:46:38 +02:00
"std::pair<std::__decay_and_strip<int>::__type, std::__decay_and_strip<char const (&)[5]>::__type> std::make_pair<int, char const (&)[5]>(int &&, char const (&)[5])");
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
// All examples from the ABI spec.
TEST_CORRECTLY_MANGLED_NAME("_ZN1S1xE", "S::x");
TEST_CORRECTLY_MANGLED_NAME("_Z1fM1AKFvvE", "f(void (A::*)() const)");
TEST_CORRECTLY_MANGLED_NAME("_Z1fIiEvT_", "void f<int>(int)");
TEST_CORRECTLY_MANGLED_NAME("_Z3fooc", "foo(char)");
TEST_CORRECTLY_MANGLED_NAME("_Z2CBIL_Z3foocEE", "CB<foo(char)>");
TEST_CORRECTLY_MANGLED_NAME("_Z2CBIL_Z7IsEmptyEE", "CB<IsEmpty>");
TEST_CORRECTLY_MANGLED_NAME("_ZZ1giEN1S1fE_2i", "g(int)::S::f(int)");
TEST_CORRECTLY_MANGLED_NAME("_ZZ1gvEN1SC1Ev", "g()::S::S()");
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZZZ1gvEN1SC1EvEs", "g()::S::S()::{string literal}");
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZZ1gvE5str4a", "g()::str4a");
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZZ1gvEs_1", "g()::{string literal}");
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZZ1gvE5str4b", "g()::str4b");
TEST_CORRECTLY_MANGLED_NAME("_Z1fPFvvEM1SFvvE", "f(void (*)(), void (S::*)())");
TEST_CORRECTLY_MANGLED_NAME("_ZN1N1TIiiE2mfES0_IddE", "N::T<int, int>::mf(N::T<double, double>)");
TEST_CORRECTLY_MANGLED_NAME("_ZSt5state", "std::state");
TEST_CORRECTLY_MANGLED_NAME("_ZNSt3_In4wardE", "std::_In::ward");
TEST_CORRECTLY_MANGLED_NAME("_Z1fN1SUt_E", "f(S::{unnamed type#1})");
TEST_CORRECTLY_MANGLED_NAME("_ZZZ1giEN1S1fE_2iEUt1_", "g(int)::S::f(int)::{unnamed type#3}");
TEST_CORRECTLY_MANGLED_NAME("_ZZZ1giEN1S1fE_2iENUt1_2fxEv", "g(int)::S::f(int)::{unnamed type#3}::fx()");
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
TEST_CORRECTLY_MANGLED_NAME("_Z1AIcfE", "A<char, float>");
TEST_CORRECTLY_MANGLED_NAME("_Z1fIiEvT_PDtfL0pK_E", "void f<int>(int, decltype({param#1 const}) *)");
TEST_CORRECTLY_MANGLED_NAME("_Z1AILln42EE", "A<-42L>");
TEST_CORRECTLY_MANGLED_NAME("_Z2f1I1QEDTpldtfp_1xdtL_Z1qE1xET_", "decltype({param#1}.x + q.x) f1<Q>(Q)");
TEST_CORRECTLY_MANGLED_NAME("_Z2f2I1QEDTpldtfp_1xsrS0_1xET_", "decltype({param#1}.x + Q::x) f2<Q>(Q)");
TEST_CORRECTLY_MANGLED_NAME("_Z2f3IiEDTplfp_dtL_Z1dEsr1B1XIT_EE1xES1_", "decltype({param#1} + d.B::X<int>::x) f3<int>(int)");
TEST_CORRECTLY_MANGLED_NAME("_Z3fooILi2EEvRAplT_Li1E_i", "void foo<2>(int (&)[2 + 1])");
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZZ1giENKUlvE_clEv", "g(int)::{lambda()#1}::operator()() const");
TEST_CORRECTLY_MANGLED_NAME("_ZZ1giENKUlvE0_clEv", "g(int)::{lambda()#2}::operator()() const");
TEST_CORRECTLY_MANGLED_NAME("_ZNK1SIiE1xMUlvE_clEv", "S<int>::x::{lambda()#1}::operator()() const");
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
TEST_CORRECTLY_MANGLED_NAME("_ZN1S4funcEii", "S::func(int, int)");
// Note: c++filt from binutils 2.22 demangles these wrong (counts default arguments from first instead of from last)
TEST_CORRECTLY_MANGLED_NAME("_ZZN1S1fEiiEd0_NKUlvE_clEv", "S::f(int, int)::{default arg#1}::{lambda()#1}::operator()() const");
TEST_CORRECTLY_MANGLED_NAME("_ZZN1S1fEiiEd0_NKUlvE0_clEv", "S::f(int, int)::{default arg#1}::{lambda()#2}::operator()() const");
TEST_CORRECTLY_MANGLED_NAME("_ZZN1S1fEiiEd_NKUlvE_clEv", "S::f(int, int)::{default arg#2}::{lambda()#1}::operator()() const");
// Note: gcc 4.6.3 encodes this as "_Z2f4I7OpClassEDTadsrT_miES1_".
TEST_CORRECTLY_MANGLED_NAME("_Z2f4I7OpClassEDTadsrT_onmiES0_", "decltype(&OpClass::operator-) f4<OpClass>(OpClass)");
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
}
void NameDemanglerAutoTest::testIncorrectlyMangledNames()
{
}
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
void NameDemanglerAutoTest::testDisjunctFirstSets()
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
{
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
for (char c = 0x20; c < 0x7e; ++c) {
// <encoding>
QVERIFY(!NameNode::mangledRepresentationStartsWith(c)
|| !SpecialNameNode::mangledRepresentationStartsWith(c));
// <name>
QVERIFY(!NestedNameNode::mangledRepresentationStartsWith(c)
|| !UnscopedNameNode::mangledRepresentationStartsWith(c));
QVERIFY(!NestedNameNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
QVERIFY(!NestedNameNode::mangledRepresentationStartsWith(c)
|| !LocalNameNode::mangledRepresentationStartsWith(c));
QVERIFY(!UnscopedNameNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c) || c == 'S');
QVERIFY(!UnscopedNameNode::mangledRepresentationStartsWith(c)
|| !LocalNameNode::mangledRepresentationStartsWith(c));
QVERIFY(!SubstitutionNode::mangledRepresentationStartsWith(c)
|| !LocalNameNode::mangledRepresentationStartsWith(c));
// <nested-name>
QVERIFY(!CvQualifiersNode::mangledRepresentationStartsWith(c)
|| !PrefixNode::mangledRepresentationStartsWith(c) || c == 'r');
// <prefix>
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
QVERIFY(!TemplateArgsNode::mangledRepresentationStartsWith(c)
Name demangler: Fix reference collapsing. Change-Id: I7bcf1ace346ffcb5e05242f6cedfc5439c97fff9 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-08-10 16:46:38 +02:00
|| !UnqualifiedNameNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
Name demangler: Fix reference collapsing. Change-Id: I7bcf1ace346ffcb5e05242f6cedfc5439c97fff9 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-08-10 16:46:38 +02:00
|| !UnqualifiedNameNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!SubstitutionNode::mangledRepresentationStartsWith(c)
Name demangler: Fix reference collapsing. Change-Id: I7bcf1ace346ffcb5e05242f6cedfc5439c97fff9 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-08-10 16:46:38 +02:00
|| !UnqualifiedNameNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
// <template-arg>
QVERIFY(!TypeNode::mangledRepresentationStartsWith(c)
|| !ExprPrimaryNode::mangledRepresentationStartsWith(c));
// <expression>
QVERIFY(!OperatorNameNode::mangledRepresentationStartsWith(c)
|| !TemplateParamNode::mangledRepresentationStartsWith(c));
QVERIFY(!OperatorNameNode::mangledRepresentationStartsWith(c)
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
|| !FunctionParamNode::mangledRepresentationStartsWith(c));
QVERIFY2(!OperatorNameNode::mangledRepresentationStartsWith(c)
|| !UnresolvedNameNode::mangledRepresentationStartsWith(c)
|| c == 'd' || c == 'g' || c == 'o' || c == 's', toString(c));
QVERIFY(!OperatorNameNode::mangledRepresentationStartsWith(c)
|| !ExprPrimaryNode::mangledRepresentationStartsWith(c));
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
|| !FunctionParamNode::mangledRepresentationStartsWith(c));
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
|| !ExprPrimaryNode::mangledRepresentationStartsWith(c));
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
|| !FunctionParamNode::mangledRepresentationStartsWith(c));
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
|| !UnresolvedNameNode::mangledRepresentationStartsWith(c));
QVERIFY(!FunctionParamNode::mangledRepresentationStartsWith(c)
|| !UnresolvedNameNode::mangledRepresentationStartsWith(c));
QVERIFY(!FunctionParamNode::mangledRepresentationStartsWith(c)
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
|| !ExprPrimaryNode::mangledRepresentationStartsWith(c));
// <expr-primary>
QVERIFY(!TypeNode::mangledRepresentationStartsWith(c)
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
|| !MangledNameRule::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
// <type>
QVERIFY(!BuiltinTypeNode::mangledRepresentationStartsWith(c)
|| !FunctionTypeNode::mangledRepresentationStartsWith(c));
QVERIFY2(!BuiltinTypeNode::mangledRepresentationStartsWith(c)
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
|| !ClassEnumTypeRule::mangledRepresentationStartsWith(c) || c == 'D', toString(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!BuiltinTypeNode::mangledRepresentationStartsWith(c)
|| !ArrayTypeNode::mangledRepresentationStartsWith(c));
QVERIFY(!BuiltinTypeNode::mangledRepresentationStartsWith(c)
|| !PointerToMemberTypeNode::mangledRepresentationStartsWith(c));
QVERIFY(!BuiltinTypeNode::mangledRepresentationStartsWith(c)
|| !TemplateParamNode::mangledRepresentationStartsWith(c));
QVERIFY(!BuiltinTypeNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
QVERIFY(!BuiltinTypeNode::mangledRepresentationStartsWith(c)
|| !CvQualifiersNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!BuiltinTypeNode::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c) || c == 'D');
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!FunctionTypeNode::mangledRepresentationStartsWith(c)
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
|| !ClassEnumTypeRule::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!FunctionTypeNode::mangledRepresentationStartsWith(c)
|| !ArrayTypeNode::mangledRepresentationStartsWith(c));
QVERIFY(!FunctionTypeNode::mangledRepresentationStartsWith(c)
|| !PointerToMemberTypeNode::mangledRepresentationStartsWith(c));
QVERIFY(!FunctionTypeNode::mangledRepresentationStartsWith(c)
|| !TemplateParamNode::mangledRepresentationStartsWith(c));
QVERIFY(!FunctionTypeNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
QVERIFY(!FunctionTypeNode::mangledRepresentationStartsWith(c)
|| !CvQualifiersNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!FunctionTypeNode::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c));
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
QVERIFY(!ClassEnumTypeRule::mangledRepresentationStartsWith(c)
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
|| !ArrayTypeNode::mangledRepresentationStartsWith(c));
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
QVERIFY(!ClassEnumTypeRule::mangledRepresentationStartsWith(c)
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
|| !PointerToMemberTypeNode::mangledRepresentationStartsWith(c));
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
QVERIFY(!ClassEnumTypeRule::mangledRepresentationStartsWith(c)
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
|| !TemplateParamNode::mangledRepresentationStartsWith(c));
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
QVERIFY(!ClassEnumTypeRule::mangledRepresentationStartsWith(c)
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
QVERIFY(!ClassEnumTypeRule::mangledRepresentationStartsWith(c)
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
|| !CvQualifiersNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!ClassEnumTypeRule::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c) || c == 'D');
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!ArrayTypeNode::mangledRepresentationStartsWith(c)
|| !PointerToMemberTypeNode::mangledRepresentationStartsWith(c));
QVERIFY(!ArrayTypeNode::mangledRepresentationStartsWith(c)
|| !TemplateParamNode::mangledRepresentationStartsWith(c));
QVERIFY(!ArrayTypeNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
QVERIFY(!ArrayTypeNode::mangledRepresentationStartsWith(c)
|| !CvQualifiersNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!ArrayTypeNode::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!PointerToMemberTypeNode::mangledRepresentationStartsWith(c)
|| !TemplateParamNode::mangledRepresentationStartsWith(c));
QVERIFY(!PointerToMemberTypeNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
QVERIFY(!PointerToMemberTypeNode::mangledRepresentationStartsWith(c)
|| !CvQualifiersNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!PointerToMemberTypeNode::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
|| !CvQualifiersNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!SubstitutionNode::mangledRepresentationStartsWith(c)
|| !CvQualifiersNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!SubstitutionNode::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c));
QVERIFY(!CvQualifiersNode::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
// <unqualified-name>
QVERIFY(!OperatorNameNode::mangledRepresentationStartsWith(c)
|| !CtorDtorNameNode::mangledRepresentationStartsWith(c));
QVERIFY(!OperatorNameNode::mangledRepresentationStartsWith(c)
|| !SourceNameNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!OperatorNameNode::mangledRepresentationStartsWith(c)
|| !UnnamedTypeNameNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!CtorDtorNameNode::mangledRepresentationStartsWith(c)
|| !SourceNameNode::mangledRepresentationStartsWith(c));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!CtorDtorNameNode::mangledRepresentationStartsWith(c)
|| !UnnamedTypeNameNode::mangledRepresentationStartsWith(c));
QVERIFY(!SourceNameNode::mangledRepresentationStartsWith(c)
|| !UnnamedTypeNameNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
// <array-type>
Debugger: Refactor name demangler. Now all the parsing logic as well as the stringification is in the tree nodes. Change-Id: Ie8222729c14c0102d94045026fc61a75cd31cc63 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 16:14:07 +02:00
QVERIFY(!NonNegativeNumberNode<10>::mangledRepresentationStartsWith(c)
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
|| !ExpressionNode::mangledRepresentationStartsWith(c) || std::isdigit(c));
// <unresolved-type>
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
|| !DeclTypeNode::mangledRepresentationStartsWith(c));
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
QVERIFY(!DeclTypeNode::mangledRepresentationStartsWith(c)
|| !SubstitutionNode::mangledRepresentationStartsWith(c));
// <desctructor-name>
QVERIFY(!UnresolvedTypeRule::mangledRepresentationStartsWith(c)
|| !SimpleIdNode::mangledRepresentationStartsWith(c));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
}
// <template-args>, <template-arg>
QVERIFY(!TemplateArgNode::mangledRepresentationStartsWith('E'));
// <template-arg>
QVERIFY(!TypeNode::mangledRepresentationStartsWith('X')
&& !TypeNode::mangledRepresentationStartsWith('J')
/* && !TypeNode::mangledRepresentationStartsWith('s') */);
QVERIFY(!ExprPrimaryNode::mangledRepresentationStartsWith('X')
&& !ExprPrimaryNode::mangledRepresentationStartsWith('J')
&& !ExprPrimaryNode::mangledRepresentationStartsWith('s'));
// <expression>
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith('c')
&& !TemplateParamNode::mangledRepresentationStartsWith('s')
&& !TemplateParamNode::mangledRepresentationStartsWith('a'));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!FunctionParamNode::mangledRepresentationStartsWith('c')
&& !FunctionParamNode::mangledRepresentationStartsWith('c')
&& !FunctionParamNode::mangledRepresentationStartsWith('c'));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!ExprPrimaryNode::mangledRepresentationStartsWith('c')
&& !ExprPrimaryNode::mangledRepresentationStartsWith('s')
&& !ExprPrimaryNode::mangledRepresentationStartsWith('a'));
QVERIFY(!ExpressionNode::mangledRepresentationStartsWith('E'));
QVERIFY(!ExpressionNode::mangledRepresentationStartsWith('_'));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!InitializerNode::mangledRepresentationStartsWith('E'));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
// <type>
QVERIFY(!BuiltinTypeNode::mangledRepresentationStartsWith('P')
&& !BuiltinTypeNode::mangledRepresentationStartsWith('R')
&& !BuiltinTypeNode::mangledRepresentationStartsWith('O')
&& !BuiltinTypeNode::mangledRepresentationStartsWith('C')
&& !BuiltinTypeNode::mangledRepresentationStartsWith('G')
&& !BuiltinTypeNode::mangledRepresentationStartsWith('U'));
QVERIFY(!FunctionTypeNode::mangledRepresentationStartsWith('P')
&& !FunctionTypeNode::mangledRepresentationStartsWith('R')
&& !FunctionTypeNode::mangledRepresentationStartsWith('O')
&& !FunctionTypeNode::mangledRepresentationStartsWith('C')
&& !FunctionTypeNode::mangledRepresentationStartsWith('G')
&& !FunctionTypeNode::mangledRepresentationStartsWith('U')
&& !FunctionTypeNode::mangledRepresentationStartsWith('D'));
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
QVERIFY(!ClassEnumTypeRule::mangledRepresentationStartsWith('P')
&& !ClassEnumTypeRule::mangledRepresentationStartsWith('R')
&& !ClassEnumTypeRule::mangledRepresentationStartsWith('O')
&& !ClassEnumTypeRule::mangledRepresentationStartsWith('C')
&& !ClassEnumTypeRule::mangledRepresentationStartsWith('G')
&& !ClassEnumTypeRule::mangledRepresentationStartsWith('U')
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
/* && !firstSetClassEnumType.contains('D') */);
QVERIFY(!ArrayTypeNode::mangledRepresentationStartsWith('P')
&& !ArrayTypeNode::mangledRepresentationStartsWith('R')
&& !ArrayTypeNode::mangledRepresentationStartsWith('O')
&& !ArrayTypeNode::mangledRepresentationStartsWith('C')
&& !ArrayTypeNode::mangledRepresentationStartsWith('G')
&& !ArrayTypeNode::mangledRepresentationStartsWith('U')
&& !ArrayTypeNode::mangledRepresentationStartsWith('D'));
QVERIFY(!PointerToMemberTypeNode::mangledRepresentationStartsWith('P')
&& !PointerToMemberTypeNode::mangledRepresentationStartsWith('R')
&& !PointerToMemberTypeNode::mangledRepresentationStartsWith('O')
&& !PointerToMemberTypeNode::mangledRepresentationStartsWith('C')
&& !PointerToMemberTypeNode::mangledRepresentationStartsWith('G')
&& !PointerToMemberTypeNode::mangledRepresentationStartsWith('U')
&& !PointerToMemberTypeNode::mangledRepresentationStartsWith('D'));
QVERIFY(!TemplateParamNode::mangledRepresentationStartsWith('P')
&& !TemplateParamNode::mangledRepresentationStartsWith('R')
&& !TemplateParamNode::mangledRepresentationStartsWith('O')
&& !TemplateParamNode::mangledRepresentationStartsWith('C')
&& !TemplateParamNode::mangledRepresentationStartsWith('G')
&& !TemplateParamNode::mangledRepresentationStartsWith('U')
&& !TemplateParamNode::mangledRepresentationStartsWith('D'));
QVERIFY(!SubstitutionNode::mangledRepresentationStartsWith('P')
&& !SubstitutionNode::mangledRepresentationStartsWith('R')
&& !SubstitutionNode::mangledRepresentationStartsWith('O')
&& !SubstitutionNode::mangledRepresentationStartsWith('C')
&& !SubstitutionNode::mangledRepresentationStartsWith('G')
&& !SubstitutionNode::mangledRepresentationStartsWith('U')
&& !SubstitutionNode::mangledRepresentationStartsWith('D'));
QVERIFY(!CvQualifiersNode::mangledRepresentationStartsWith('P')
&& !CvQualifiersNode::mangledRepresentationStartsWith('R')
&& !CvQualifiersNode::mangledRepresentationStartsWith('O')
&& !CvQualifiersNode::mangledRepresentationStartsWith('C')
&& !CvQualifiersNode::mangledRepresentationStartsWith('G')
&& !CvQualifiersNode::mangledRepresentationStartsWith('U')
&& !CvQualifiersNode::mangledRepresentationStartsWith('D'));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!DeclTypeNode::mangledRepresentationStartsWith('P')
&& !DeclTypeNode::mangledRepresentationStartsWith('R')
&& !DeclTypeNode::mangledRepresentationStartsWith('O')
&& !DeclTypeNode::mangledRepresentationStartsWith('C')
&& !DeclTypeNode::mangledRepresentationStartsWith('G')
&& !DeclTypeNode::mangledRepresentationStartsWith('U'));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
// <array-type>
Debugger: Refactor name demangler. Now all the parsing logic as well as the stringification is in the tree nodes. Change-Id: Ie8222729c14c0102d94045026fc61a75cd31cc63 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 16:14:07 +02:00
QVERIFY(!NonNegativeNumberNode<10>::mangledRepresentationStartsWith('_'));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
QVERIFY(!ExpressionNode::mangledRepresentationStartsWith('_'));
// <substitution>
Debugger: Refactor name demangler. Now all the parsing logic as well as the stringification is in the tree nodes. Change-Id: Ie8222729c14c0102d94045026fc61a75cd31cc63 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 16:14:07 +02:00
QVERIFY(!NonNegativeNumberNode<36>::mangledRepresentationStartsWith('_')
&& !NonNegativeNumberNode<36>::mangledRepresentationStartsWith('t')
&& !NonNegativeNumberNode<36>::mangledRepresentationStartsWith('a')
&& !NonNegativeNumberNode<36>::mangledRepresentationStartsWith('b')
&& !NonNegativeNumberNode<36>::mangledRepresentationStartsWith('s')
&& !NonNegativeNumberNode<36>::mangledRepresentationStartsWith('i')
&& !NonNegativeNumberNode<36>::mangledRepresentationStartsWith('o')
&& !NonNegativeNumberNode<36>::mangledRepresentationStartsWith('d'));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
// <special-name>
Debugger: Name demangler improvements. - Fix assertion macro. - Make parse tree smaller by getting rid of nodes that serve no purpose. - Add all examples from the ABI spec to the auto test. Change-Id: Id63d8330e6380bfb7d56acd1d445f7b70a1f6e70 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2012-07-06 20:03:58 +02:00
QVERIFY(!CallOffsetRule::mangledRepresentationStartsWith('V')
&& !CallOffsetRule::mangledRepresentationStartsWith('T')
&& !CallOffsetRule::mangledRepresentationStartsWith('I')
&& !CallOffsetRule::mangledRepresentationStartsWith('S')
&& !CallOffsetRule::mangledRepresentationStartsWith('c'));
Debugger: Refactor name demangler. So far, we converted the mangled to the demangled representation on the fly while parsing. Because some demangled strings look different depending on higher-level context, awkward string manipulations were then necessary at some later point. The new solution is much more easily maintainable, creating a tree with a node for every rule in the grammar first and converting the complete tree to the demangled string later. Change-Id: I59088df259611d7cd78af47b81b6a21d628a787f Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-06 09:29:39 +02:00
// <unscoped-name>
QVERIFY(!UnqualifiedNameNode::mangledRepresentationStartsWith('S'));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
Name demangler: Fix reference collapsing. Change-Id: I7bcf1ace346ffcb5e05242f6cedfc5439c97fff9 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-08-10 16:46:38 +02:00
// <prefix>
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
QVERIFY(!TemplateArgsNode::mangledRepresentationStartsWith('M'));
Name demangler: Fix reference collapsing. Change-Id: I7bcf1ace346ffcb5e05242f6cedfc5439c97fff9 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-08-10 16:46:38 +02:00
QVERIFY(!UnqualifiedNameNode::mangledRepresentationStartsWith('M'));
Debugger:Sync name demangler with specification. The new stuff is mostly C++11 features (closures etc.). Also fix a number of bugs uncovered along the way. All tests succeed now, including the examples from the specification. Change-Id: I9b224b0dd82ad8f5b17d5f5d1809d1dea1a7a803 Reviewed-by: Christian Kandeler <christian.kandeler@nokia.com>
2012-07-09 16:23:02 +02:00
// <base-unresolved-name>
QVERIFY(!SimpleIdNode::mangledRepresentationStartsWith('o'));
QVERIFY(!SimpleIdNode::mangledRepresentationStartsWith('d'));
// <initializer>
QVERIFY(!ExpressionNode::mangledRepresentationStartsWith('E'));
// <unresolved-name-node>
QVERIFY(!BaseUnresolvedNameNode::mangledRepresentationStartsWith('g'));
QVERIFY(!BaseUnresolvedNameNode::mangledRepresentationStartsWith('s'));
QVERIFY(!UnresolvedTypeRule::mangledRepresentationStartsWith('N'));
QVERIFY(!UnresolvedQualifierLevelRule::mangledRepresentationStartsWith('N'));
QVERIFY(!UnresolvedQualifierLevelRule::mangledRepresentationStartsWith('E'));
Debugger: Add auto tests for name demangler. Change-Id: I79c0d25dbddb201e10079afa9fb76b3c737ba135 Reviewed-by: hjk <qthjk@ovi.com>
2012-05-09 12:08:22 +02:00
}
void NameDemanglerAutoTest::testIncorrectlyMangledName(
const QString &mangledName)
{
QVERIFY(!demangler.demangle(mangledName));
}
QTEST_MAIN(NameDemanglerAutoTest)
#include "tst_namedemangler.moc"
Copy Permalink