diff options
Diffstat (limited to 'sources/shiboken6/generator')
13 files changed, 196 insertions, 199 deletions
diff --git a/sources/shiboken6/generator/generator.cpp b/sources/shiboken6/generator/generator.cpp index 5975e54e6..b1accb74b 100644 --- a/sources/shiboken6/generator/generator.cpp +++ b/sources/shiboken6/generator/generator.cpp @@ -177,7 +177,7 @@ void Generator::setOutputDirectory(const QString &outDir) bool Generator::generateFileForContext(const GeneratorContext &context) { const AbstractMetaClass *cls = context.metaClass(); - auto *typeEntry = cls->typeEntry(); + auto typeEntry = cls->typeEntry(); if (!shouldGenerate(typeEntry)) return true; @@ -233,14 +233,14 @@ bool Generator::generate() for (auto cls : m_d->api.classes()) { if (!generateFileForContext(contextForClass(cls))) return false; - auto *te = cls->typeEntry(); + auto te = cls->typeEntry(); if (shouldGenerate(te) && te->isPrivate()) m_d->m_hasPrivateClasses = true; } for (const auto &smp: m_d->api.instantiatedSmartPointers()) { const AbstractMetaClass *pointeeClass = nullptr; - const auto *instantiatedType = smp.type.instantiations().constFirst().typeEntry(); + const auto instantiatedType = smp.type.instantiations().constFirst().typeEntry(); if (instantiatedType->isComplex()) // not a C++ primitive pointeeClass = AbstractMetaClass::findClass(m_d->api.classes(), instantiatedType); if (!generateFileForContext(contextForSmartPointer(smp.specialized, smp.type, @@ -251,7 +251,7 @@ bool Generator::generate() return finishGeneration(); } -bool Generator::shouldGenerate(const TypeEntry *typeEntry) const +bool Generator::shouldGenerate(const TypeEntryCPtr &typeEntry) const { return typeEntry->shouldGenerate(); } @@ -276,11 +276,11 @@ bool Generator::avoidProtectedHack() const return m_d->m_avoidProtectedHack; } -QString Generator::getFullTypeName(const TypeEntry *type) +QString Generator::getFullTypeName(TypeEntryCPtr type) { QString result = type->qualifiedCppName(); if (type->isArray()) - type = static_cast<const ArrayTypeEntry *>(type)->nestedTypeEntry(); + type = qSharedPointerCast<const ArrayTypeEntry>(type)->nestedTypeEntry(); if (!isCppPrimitive(type)) result.prepend(u"::"_s); return result; @@ -365,7 +365,7 @@ std::optional<DefaultValue> return minimalConstructor(api, type.typeEntry()); if (type.typeEntry()->isComplex()) { - auto cType = static_cast<const ComplexTypeEntry *>(type.typeEntry()); + auto cType = qSharedPointerCast<const ComplexTypeEntry>(type.typeEntry()); if (cType->hasDefaultConstructor()) return DefaultValue(DefaultValue::Custom, cType->defaultConstructor()); auto klass = AbstractMetaClass::findClass(api.classes(), cType); @@ -390,7 +390,7 @@ std::optional<DefaultValue> std::optional<DefaultValue> Generator::minimalConstructor(const ApiExtractorResult &api, - const TypeEntry *type, + const TypeEntryCPtr &type, QString *errorString) { if (!type) @@ -404,8 +404,8 @@ std::optional<DefaultValue> } if (type->isEnum()) { - const auto enumEntry = static_cast<const EnumTypeEntry *>(type); - if (const auto *nullValue = enumEntry->nullValue()) + const auto enumEntry = qSharedPointerCast<const EnumTypeEntry>(type); + if (const auto nullValue = enumEntry->nullValue(); !nullValue.isNull()) return DefaultValue(DefaultValue::Enum, nullValue->name()); return DefaultValue(DefaultValue::Custom, u"static_cast< ::"_s + type->qualifiedCppName() @@ -418,7 +418,7 @@ std::optional<DefaultValue> } if (type->isPrimitive()) { - QString ctor = static_cast<const PrimitiveTypeEntry *>(type)->defaultConstructor(); + QString ctor = qSharedPointerCast<const PrimitiveTypeEntry>(type)->defaultConstructor(); // If a non-C++ (i.e. defined by the user) primitive type does not have // a default constructor defined by the user, the empty constructor is // heuristically returned. If this is wrong the build of the generated @@ -461,7 +461,7 @@ std::optional<DefaultValue> if (!metaClass) return {}; - auto cType = static_cast<const ComplexTypeEntry *>(metaClass->typeEntry()); + auto cType = qSharedPointerCast<const ComplexTypeEntry>(metaClass->typeEntry()); if (cType->hasDefaultConstructor()) return DefaultValue(DefaultValue::Custom, cType->defaultConstructor()); @@ -489,7 +489,7 @@ std::optional<DefaultValue> for (qsizetype i = 0, size = arguments.size(); suitable && i < size && !arguments.at(i).hasOriginalDefaultValueExpression(); ++i) { const AbstractMetaArgument &arg = arguments.at(i); - const TypeEntry *aType = arg.type().typeEntry(); + TypeEntryCPtr aType = arg.type().typeEntry(); suitable &= aType != cType; simple &= isCppPrimitive(aType) || aType->isEnum() || arg.type().isPointer(); } diff --git a/sources/shiboken6/generator/generator.h b/sources/shiboken6/generator/generator.h index 34ab84a37..8bfbb49ad 100644 --- a/sources/shiboken6/generator/generator.h +++ b/sources/shiboken6/generator/generator.h @@ -130,7 +130,7 @@ protected: static QString getFileNameBaseForSmartPointer(const AbstractMetaType &smartPointerType); /// Returns true if the generator should generate any code for the AbstractMetaClass. - virtual bool shouldGenerate(const TypeEntry *t) const; + virtual bool shouldGenerate(const TypeEntryCPtr &t) const; /** * Translate metatypes to binding source format. @@ -151,7 +151,7 @@ protected: static QString packageName(); // Returns the full name of the type. - static QString getFullTypeName(const TypeEntry *type); + static QString getFullTypeName(TypeEntryCPtr type); static QString getFullTypeName(const AbstractMetaType &type); static QString getFullTypeName(const AbstractMetaClass *metaClass); @@ -168,7 +168,7 @@ protected: * Returns a null string if it fails. */ static std::optional<DefaultValue> - minimalConstructor(const ApiExtractorResult &api, const TypeEntry *type, + minimalConstructor(const ApiExtractorResult &api, const TypeEntryCPtr &type, QString *errorString = nullptr); static std::optional<DefaultValue> minimalConstructor(const ApiExtractorResult &api, const AbstractMetaType &type, diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp index 61f736e74..dee776cd4 100644 --- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp +++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp @@ -85,7 +85,7 @@ static bool functionSort(const AbstractMetaFunctionCPtr &func1, const AbstractMe return func1->name() < func2->name(); } -static inline QVersionNumber versionOf(const TypeEntry *te) +static inline QVersionNumber versionOf(const TypeEntryCPtr &te) { if (te) { const auto version = te->version(); @@ -108,7 +108,7 @@ QString QtDocGenerator::fileNameSuffix() return u".rst"_s; } -bool QtDocGenerator::shouldGenerate(const TypeEntry *te) const +bool QtDocGenerator::shouldGenerate(const TypeEntryCPtr &te) const { return Generator::shouldGenerate(te) && te->type() != TypeEntry::SmartPointerType; diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h index 08a359322..1c82610a2 100644 --- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h +++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h @@ -44,7 +44,7 @@ public: QtXmlToSphinxLink resolveLink(const QtXmlToSphinxLink &) const override; protected: - bool shouldGenerate(const TypeEntry *) const override; + bool shouldGenerate(const TypeEntryCPtr &) const override; static QString fileNameSuffix(); QString fileNameForContext(const GeneratorContext &context) const override; void generateClass(TextStream &ts, const GeneratorContext &classContext) override; diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp index fbe7f183e..47fb271f9 100644 --- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp +++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp @@ -186,9 +186,9 @@ const ProtocolEntries &sequenceProtocols() // Return name of function to create PyObject wrapping a container static QString opaqueContainerCreationFunc(const AbstractMetaType &type) { - const auto *containerTypeEntry = - static_cast<const ContainerTypeEntry *>(type.typeEntry()); - const auto *instantiationTypeEntry = + const auto containerTypeEntry = + qSharedPointerCast<const ContainerTypeEntry>(type.typeEntry()); + const auto instantiationTypeEntry = type.instantiations().constFirst().typeEntry(); QString result = u"create"_s; if (type.isConstant()) @@ -284,9 +284,9 @@ QList<AbstractMetaFunctionCList> CppGenerator::BoolCastFunctionOptional CppGenerator::boolCast(const AbstractMetaClass *metaClass) const { - const auto *te = metaClass->typeEntry(); + const auto te = metaClass->typeEntry(); if (te->isSmartPointer()) { - auto *ste = static_cast<const SmartPointerTypeEntry *>(te); + auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(te); auto valueCheckMethod = ste->valueCheckMethod(); if (!valueCheckMethod.isEmpty()) { @@ -324,8 +324,8 @@ CppGenerator::BoolCastFunctionOptional } std::optional<AbstractMetaType> - CppGenerator::findSmartPointerInstantiation(const SmartPointerTypeEntry *pointer, - const TypeEntry *pointee) const + CppGenerator::findSmartPointerInstantiation(const SmartPointerTypeEntryCPtr &pointer, + const TypeEntryCPtr &pointee) const { for (const auto &smp : api().instantiatedSmartPointers()) { const auto &i = smp.type; @@ -472,7 +472,7 @@ static bool _shouldInheritInt(const AbstractMetaEnum &cppEnum) static QString BuildEnumFlagInfo(const AbstractMetaEnum &cppEnum) { - auto *enumType = cppEnum.typeEntry(); + auto enumType = cppEnum.typeEntry(); QString result = _plainName(enumType->name()); auto flags = enumType->flags(); auto decision = enumType->pythonEnumType(); @@ -503,7 +503,7 @@ static bool generateRichComparison(const GeneratorContext &c) { auto *metaClass = c.metaClass(); if (c.forSmartPointer()) { - auto *te = static_cast<const SmartPointerTypeEntry *>(metaClass->typeEntry()); + auto te = qSharedPointerCast<const SmartPointerTypeEntry>(metaClass->typeEntry()); return te->smartPointerType() == TypeSystem::SmartPointerType::Shared; } @@ -622,7 +622,7 @@ static bool needsTypeDiscoveryFunction(const AbstractMetaClass *c) && (c->isPolymorphic() || !c->typeEntry()->polymorphicIdValue().isEmpty()); } -static void writeAddedTypeSignatures(TextStream &s, const ComplexTypeEntry *te) +static void writeAddedTypeSignatures(TextStream &s, const ComplexTypeEntryCPtr &te) { for (const auto &e : te->addedPyMethodDefEntrys()) { if (auto count = e.signatures.size()) { @@ -647,11 +647,11 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon s.setLanguage(TextStream::Language::Cpp); const AbstractMetaClass *metaClass = classContext.metaClass(); - const auto *typeEntry = metaClass->typeEntry(); + const auto typeEntry = metaClass->typeEntry(); auto innerClasses = metaClass->innerClasses(); for (auto it = innerClasses.begin(); it != innerClasses.end(); ) { - auto *innerTypeEntry = (*it)->typeEntry(); + auto innerTypeEntry = (*it)->typeEntry(); if (shouldGenerate(innerTypeEntry) && !innerTypeEntry->isSmartPointer()) ++it; else @@ -674,7 +674,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon const AbstractMetaClass *context = metaClass->enclosingClass(); while (context) { if (context->isNamespace() && !context->enclosingClass() - && static_cast<const NamespaceTypeEntry *>(context->typeEntry())->generateUsing()) { + && qSharedPointerCast<const NamespaceTypeEntry>(context->typeEntry())->generateUsing()) { s << "\nusing namespace " << context->qualifiedCppName() << ";\n"; break; } @@ -694,7 +694,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon // python conversion rules if (typeEntry->isValue()) { - auto *vte = static_cast<const ValueTypeEntry *>(typeEntry); + auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry); if (vte->hasTargetConversionRule()) { s << "// Python Conversion\n"; s << vte->targetConversionRule() << '\n'; @@ -959,7 +959,7 @@ void CppGenerator::generateSmartPointerClass(TextStream &s, const GeneratorConte { s.setLanguage(TextStream::Language::Cpp); const AbstractMetaClass *metaClass = classContext.metaClass(); - const auto *typeEntry = static_cast<const SmartPointerTypeEntry *>(metaClass->typeEntry()); + const auto typeEntry = qSharedPointerCast<const SmartPointerTypeEntry>(metaClass->typeEntry()); const bool hasPointeeClass = classContext.pointeeClass() != nullptr; const auto smartPointerType = typeEntry->smartPointerType(); const bool isValueHandle = smartPointerType ==TypeSystem::SmartPointerType::ValueHandle; @@ -1157,7 +1157,7 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio // SbkType would return null when the type is a container. auto typeEntry = func->type().typeEntry(); if (typeEntry->isContainer()) { - const auto *cte = static_cast<const ContainerTypeEntry *>(typeEntry); + const auto cte = qSharedPointerCast<const ContainerTypeEntry>(typeEntry); switch (cte->containerKind()) { case ContainerTypeEntry::ListContainer: break; @@ -1197,7 +1197,7 @@ void CppGenerator::writeVirtualMethodCppCall(TextStream &s, const QString &funcName, const CodeSnipList &snips, const AbstractMetaArgument *lastArg, - const TypeEntry *retType, + const TypeEntryCPtr &retType, const QString &returnStatement, bool hasGil) const { if (!snips.isEmpty()) { @@ -1292,10 +1292,10 @@ QPair<QString, QChar> CppGenerator::virtualMethodNativeArg(const AbstractMetaFun return {arg.name() + CONV_RULE_OUT_VAR_SUFFIX, u'N'}; const auto &type = arg.type(); - auto *argTypeEntry = type.typeEntry(); + auto argTypeEntry = type.typeEntry(); // Check for primitive types convertible by Py_BuildValue() if (argTypeEntry->isPrimitive() && !type.isCString()) { - const auto *pte = basicReferencedTypeEntry(argTypeEntry->asPrimitive()); + const auto pte = basicReferencedTypeEntry(argTypeEntry); auto it = formatUnits().constFind(pte->name()); if (it != formatUnits().constEnd()) return {arg.name(), it.value()}; @@ -1385,7 +1385,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s, const AbstractMetaFunctionCPtr &func, int cacheIndex) const { - const TypeEntry *retType = func->type().typeEntry(); + TypeEntryCPtr retType = func->type().typeEntry(); const QString funcName = func->isOperatorOverload() ? pythonOperatorFunctionName(func) : func->definitionNames().constFirst(); @@ -1725,7 +1725,7 @@ void CppGenerator::writeMetaCast(TextStream &s, } void CppGenerator::writeFlagsConverterFunctions(TextStream &s, - const FlagsTypeEntry *flagsType, + const FlagsTypeEntryCPtr &flagsType, const QString &enumTypeName, const QString &flagsCppTypeName, const QString &enumTypeCheck) const @@ -1781,7 +1781,7 @@ static void generateDeprecatedValueWarnings(TextStream &c, const AbstractMetaEnum &metaEnum, bool useSurrogateName) { - const EnumTypeEntry *enumType = metaEnum.typeEntry(); + EnumTypeEntryCPtr enumType = metaEnum.typeEntry(); const QString prefix = enumType->qualifiedCppName() + u"::"_s; c << "switch (value) {\n"; const auto &deprecatedValues = metaEnum.deprecatedValues(); @@ -1803,7 +1803,7 @@ void CppGenerator::writeEnumConverterFunctions(TextStream &s, const AbstractMeta { if (metaEnum.isPrivate() || metaEnum.isAnonymous()) return; - EnumTypeEntry *enumType = metaEnum.typeEntry(); + EnumTypeEntryPtr enumType = metaEnum.typeEntry(); Q_ASSERT(enumType); QString typeName = fixedCppTypeName(enumType); QString enumPythonType = cpythonTypeNameExt(enumType); @@ -1838,7 +1838,7 @@ void CppGenerator::writeEnumConverterFunctions(TextStream &s, const AbstractMeta s << '\n'; // QFlags part. - if (auto *flags = enumType->flags()) { + if (auto flags = enumType->flags(); !flags.isNull()) { const QString flagsCppTypeName = useSurrogateName ? cppTypeName : getFullTypeName(flags).trimmed(); writeFlagsConverterFunctions(s, flags, typeName, flagsCppTypeName, pyTypeCheck); @@ -1851,7 +1851,7 @@ void CppGenerator::writeConverterFunctions(TextStream &s, const AbstractMetaClas s << "// Type conversion functions.\n\n"; AbstractMetaEnumList classEnums = metaClass->enums(); - auto *typeEntry = metaClass->typeEntry(); + auto typeEntry = metaClass->typeEntry(); metaClass->getEnumsFromInvisibleNamespacesToBeGenerated(&classEnums); if (!classEnums.isEmpty()) s << "// Python to C++ enum conversion.\n"; @@ -1961,7 +1961,7 @@ return result;)"; c << '*' << outPtr << " = *" << cpythonWrapperCPtr(typeEntry, pyInVariable) << ';'; } else { - auto *ste = static_cast<const SmartPointerTypeEntry *>(typeEntry); + auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(typeEntry); const QString resetMethod = ste->resetMethod(); c << "auto *ptr = " << outPtr << ";\n"; c << "if (" << pyInVariable << " == Py_None)\n" << indent; @@ -2052,7 +2052,7 @@ return result;)"; } if (typeEntry->isValue()) { - auto *vte = static_cast<const ValueTypeEntry *>(typeEntry); + auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry); writeCustomConverterFunctions(s, vte->customConversion()); } } @@ -2065,7 +2065,7 @@ void CppGenerator::writeCustomConverterFunctions(TextStream &s, const TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions(); if (toCppConversions.isEmpty()) return; - auto *ownerType = customConversion->ownerType(); + auto ownerType = customConversion->ownerType(); s << "// Python to C++ conversions for type '" << ownerType->qualifiedCppName() << "'.\n"; for (const auto &toNative : toCppConversions) writePythonToCppConversionFunctions(s, toNative, ownerType); @@ -2075,7 +2075,7 @@ void CppGenerator::writeCustomConverterFunctions(TextStream &s, void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass *metaClass, const GeneratorContext &classContext) const { - const auto *typeEntry = metaClass->typeEntry(); + const auto typeEntry = metaClass->typeEntry(); if (typeEntry->isNamespace()) return; s << "// Register Converter\n" @@ -2185,7 +2185,7 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass } if (typeEntry->isValue()) { - auto *vte = static_cast<const ValueTypeEntry *>(typeEntry); + auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry); writeCustomConverterRegister(s, vte->customConversion(), u"converter"_s); } } @@ -2220,7 +2220,7 @@ static AbstractMetaClassCList findSmartPointeeBaseClasses(const ApiExtractorResu const AbstractMetaType &smartPointerType) { AbstractMetaClassCList result; - auto *instantiationsTe = smartPointerType.instantiations().at(0).typeEntry(); + auto instantiationsTe = smartPointerType.instantiations().at(0).typeEntry(); auto targetClass = AbstractMetaClass::findClass(api.classes(), instantiationsTe); if (targetClass != nullptr) result = targetClass->allTypeSystemAncestors(); @@ -2234,14 +2234,14 @@ void CppGenerator::writeSmartPointerConverterFunctions(TextStream &s, if (baseClasses.isEmpty()) return; - auto *smartPointerTypeEntry = - static_cast<const SmartPointerTypeEntry *>(smartPointerType.typeEntry()); + auto smartPointerTypeEntry = + qSharedPointerCast<const SmartPointerTypeEntry>(smartPointerType.typeEntry()); // TODO: Missing conversion to smart pointer pointer type: s << "// Register smartpointer conversion for all derived classes\n"; for (auto *base : baseClasses) { - auto *baseTe = base->typeEntry(); + auto baseTe = base->typeEntry(); if (smartPointerTypeEntry->matchesInstantiation(baseTe)) { if (auto opt = findSmartPointerInstantiation(smartPointerTypeEntry, baseTe)) { const auto smartTargetType = opt.value(); @@ -2889,7 +2889,7 @@ void CppGenerator::writeTypeCheck(TextStream &s, const QSharedPointer<OverloadDataNode> &overloadData, const QString &argumentName) { - QSet<const TypeEntry *> numericTypes; + QSet<TypeEntryCPtr> numericTypes; const OverloadDataList &siblings = overloadData->parent()->children(); for (const auto &sibling : siblings) { for (const auto &func : sibling->overloads()) { @@ -2997,7 +2997,7 @@ qsizetype CppGenerator::writePythonToCppTypeConversion(TextStream &s, const AbstractMetaClass *context, const QString &defaultValue) const { - const TypeEntry *typeEntry = type.typeEntry(); + TypeEntryCPtr typeEntry = type.typeEntry(); if (typeEntry->isCustom() || typeEntry->isVarargs()) return 0; @@ -3286,7 +3286,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s, if (func->isConstructor() && func->arguments().size() == 1) { const AbstractMetaClass *ownerClass = func->ownerClass(); - const ComplexTypeEntry *baseContainerType = ownerClass->typeEntry()->baseContainerType(); + ComplexTypeEntryCPtr baseContainerType = ownerClass->typeEntry()->baseContainerType(); if (baseContainerType && baseContainerType == func->arguments().constFirst().type().typeEntry() && ownerClass->isCopyable()) { tck << '!' << cpythonCheckFunction(ownerClass->typeEntry()) @@ -3472,7 +3472,7 @@ QString CppGenerator::pythonToCppFunctionName(const AbstractMetaType &sourceType return pythonToCppFunctionName(fixedCppTypeName(sourceType), fixedCppTypeName(targetType)); } QString CppGenerator::pythonToCppFunctionName(const TargetToNativeConversion &toNative, - const TypeEntry *targetType) + const TypeEntryCPtr &targetType) { return pythonToCppFunctionName(fixedCppTypeName(toNative), fixedCppTypeName(targetType)); } @@ -3487,7 +3487,7 @@ QString CppGenerator::convertibleToCppFunctionName(const AbstractMetaType &sourc return convertibleToCppFunctionName(fixedCppTypeName(sourceType), fixedCppTypeName(targetType)); } QString CppGenerator::convertibleToCppFunctionName(const TargetToNativeConversion &toNative, - const TypeEntry *targetType) + const TypeEntryCPtr &targetType) { return convertibleToCppFunctionName(fixedCppTypeName(toNative), fixedCppTypeName(targetType)); } @@ -3532,7 +3532,7 @@ void CppGenerator::writeCppToPythonFunction(TextStream &s, const CustomConversionPtr &customConversion) const { QString code = customConversion->nativeToTargetConversion(); - auto *ownerType = customConversion->ownerType(); + auto ownerType = customConversion->ownerType(); const bool constRef = !ownerType->isPrimitive(); // PyCapsule needs a non-const ref replaceCppToPythonVariables(code, getFullTypeName(ownerType), constRef); writeCppToPythonFunction(s, code, fixedCppTypeName(customConversion->ownerType())); @@ -3540,7 +3540,7 @@ void CppGenerator::writeCppToPythonFunction(TextStream &s, void CppGenerator::writeCppToPythonFunction(TextStream &s, const AbstractMetaType &containerType) const { Q_ASSERT(containerType.typeEntry()->isContainer()); - auto *cte = static_cast<const ContainerTypeEntry *>(containerType.typeEntry()); + auto cte = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry()); if (!cte->hasCustomConversion()) { QString m; QTextStream(&m) << "Can't write the C++ to Python conversion function for container type '" @@ -3631,7 +3631,7 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, const TargetToNativeConversion &toNative, - const TypeEntry *targetType) const + const TypeEntryCPtr &targetType) const { // Python to C++ conversion function. QString code = toNative.conversion(); @@ -3679,7 +3679,7 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, const AbstractMetaType &containerType) const { Q_ASSERT(containerType.typeEntry()->isContainer()); - auto *cte = static_cast<const ContainerTypeEntry *>(containerType.typeEntry()); + auto cte = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry()); if (!cte->hasCustomConversion()) { //qFatal return; @@ -3882,7 +3882,7 @@ CppGenerator::argumentClassFromIndex(const ApiExtractorResult &api, type = type.instantiations().constFirst(); } - auto *te = type.typeEntry(); + auto te = type.typeEntry(); if (type.isVoid() || !te->isComplex()) throw Exception(msgInvalidArgumentModification(func, argIndex)); auto *result = AbstractMetaClass::findClass(api.classes(), te); @@ -4411,7 +4411,7 @@ void CppGenerator::writeSpecialCastFunction(TextStream &s, const AbstractMetaCla void CppGenerator::writePrimitiveConverterInitialization(TextStream &s, const CustomConversionPtr &customConversion) { - const TypeEntry *type = customConversion->ownerType(); + TypeEntryCPtr type = customConversion->ownerType(); QString converter = converterObject(type); s << "// Register converter for type '" << type->qualifiedTargetLangName() << "'.\n" << converter << " = Shiboken::Conversions::createConverter("; @@ -4441,7 +4441,8 @@ static void registerEnumConverterScopes(TextStream &s, QString signature) } } -void CppGenerator::writeFlagsConverterInitialization(TextStream &s, const FlagsTypeEntry *flags) +void CppGenerator::writeFlagsConverterInitialization(TextStream &s, + const FlagsTypeEntryCPtr &flags) { static const char enumPythonVar[] = "FType"; @@ -4493,7 +4494,7 @@ void CppGenerator::writeEnumConverterInitialization(TextStream &s, const Abstrac { if (metaEnum.isPrivate() || metaEnum.isAnonymous()) return; - const EnumTypeEntry *enumType = metaEnum.typeEntry(); + EnumTypeEntryCPtr enumType = metaEnum.typeEntry(); Q_ASSERT(enumType); static const char enumPythonVar[] = "EType"; @@ -4516,7 +4517,7 @@ void CppGenerator::writeEnumConverterInitialization(TextStream &s, const Abstrac s << outdent << "}\n"; - if (auto *flags = enumType->flags()) + if (auto flags = enumType->flags(); !flags.isNull()) writeFlagsConverterInitialization(s, flags); } @@ -4565,13 +4566,13 @@ void CppGenerator::writeSmartPointerConverterInitialization(TextStream &s, const if (classes.isEmpty()) return; - auto *smartPointerTypeEntry = static_cast<const SmartPointerTypeEntry *>(type.typeEntry()); + auto smartPointerTypeEntry = qSharedPointerCast<const SmartPointerTypeEntry>(type.typeEntry()); s << "// Register SmartPointer converter for type '" << cppSignature << "'." << '\n' << "///////////////////////////////////////////////////////////////////////////////////////\n\n"; for (auto *base : classes) { - auto *baseTe = base->typeEntry(); + auto baseTe = base->typeEntry(); if (auto opt = findSmartPointerInstantiation(smartPointerTypeEntry, baseTe)) { const auto smartTargetType = opt.value(); s << "// Convert to SmartPointer derived class: [" @@ -4587,7 +4588,8 @@ void CppGenerator::writeSmartPointerConverterInitialization(TextStream &s, const s << "///////////////////////////////////////////////////////////////////////////////////////" << '\n' << '\n'; } -void CppGenerator::writeExtendedConverterInitialization(TextStream &s, const TypeEntry *externalType, +void CppGenerator::writeExtendedConverterInitialization(TextStream &s, + const TypeEntryCPtr &externalType, const AbstractMetaClassCList &conversions) { s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() @@ -4634,7 +4636,7 @@ bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass *metaClass) return true; } - const ComplexTypeEntry *baseType = metaClass->typeEntry()->baseContainerType(); + ComplexTypeEntryCPtr baseType = metaClass->typeEntry()->baseContainerType(); return baseType && baseType->isContainer(); } @@ -5392,7 +5394,7 @@ using ComparisonOperatorList = QList<AbstractMetaFunction::ComparisonOperatorTyp static ComparisonOperatorList smartPointeeComparisons(const GeneratorContext &context) { Q_ASSERT(context.forSmartPointer()); - auto *te = context.preciseType().instantiations().constFirst().typeEntry(); + auto te = context.preciseType().instantiations().constFirst().typeEntry(); if (isExtendedCppPrimitive(te)) { // Primitive pointee types have all return {AbstractMetaFunction::OperatorEqual, AbstractMetaFunction::OperatorNotEqual, @@ -5433,9 +5435,9 @@ void CppGenerator::writeSmartPointerRichCompareFunction(TextStream &s, writeArgumentConversion(s, context.preciseType(), CPP_ARG0, PYTHON_ARG, ErrorReturn::Default, metaClass); - const auto *te = context.preciseType().typeEntry(); + const auto te = context.preciseType().typeEntry(); Q_ASSERT(te->isSmartPointer()); - const auto *ste = static_cast<const SmartPointerTypeEntry *>(te); + const auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(te); s << "const auto *" << selfPointeeVar << " = " << CPP_SELF_VAR << '.' << ste->getter() << "();\n"; @@ -5665,7 +5667,7 @@ void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum const AbstractMetaClass *enclosingClass = cppEnum.targetLangEnclosingClass(); bool hasUpperEnclosingClass = enclosingClass && enclosingClass->targetLangEnclosingClass() != nullptr; - const EnumTypeEntry *enumTypeEntry = cppEnum.typeEntry(); + EnumTypeEntryCPtr enumTypeEntry = cppEnum.typeEntry(); QString enclosingObjectVariable; if (enclosingClass) enclosingObjectVariable = cpythonTypeName(enclosingClass); @@ -5681,8 +5683,8 @@ void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum QString enumVarTypeObj = cpythonTypeNameExt(enumTypeEntry); if (!cppEnum.isAnonymous()) { int packageLevel = packageName().count(u'.') + 1; - FlagsTypeEntry *flags = enumTypeEntry->flags(); - if (flags) { + FlagsTypeEntryPtr flags = enumTypeEntry->flags(); + if (!flags.isNull()) { // The following could probably be made nicer: // We need 'flags->flagsName()' with the full module/class path. QString fullPath = getClassTargetFullName(cppEnum); @@ -5805,7 +5807,7 @@ void CppGenerator::writeSignalInitialization(TextStream &s, const AbstractMetaCl void CppGenerator::writeFlagsToLong(TextStream &s, const AbstractMetaEnum &cppEnum) { - FlagsTypeEntry *flagsEntry = cppEnum.typeEntry()->flags(); + FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags(); if (!flagsEntry) return; s << "static PyObject *" << cpythonEnumName(cppEnum) << "_long(PyObject *self)\n" @@ -5819,8 +5821,8 @@ void CppGenerator::writeFlagsToLong(TextStream &s, const AbstractMetaEnum &cppEn void CppGenerator::writeFlagsNonZero(TextStream &s, const AbstractMetaEnum &cppEnum) { - FlagsTypeEntry *flagsEntry = cppEnum.typeEntry()->flags(); - if (!flagsEntry) + FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags(); + if (flagsEntry.isNull()) return; s << "static int " << cpythonEnumName(cppEnum) << "__nonzero(PyObject *self)\n"; s << "{\n" << indent << "int val;\n"; @@ -5874,8 +5876,8 @@ void CppGenerator::writeFlagsNumberMethodsDefinitions(TextStream &s, void CppGenerator::writeFlagsBinaryOperator(TextStream &s, const AbstractMetaEnum &cppEnum, const QString &pyOpName, const QString &cppOpName) { - FlagsTypeEntry *flagsEntry = cppEnum.typeEntry()->flags(); - Q_ASSERT(flagsEntry); + FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags(); + Q_ASSERT(!flagsEntry.isNull()); s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject *self, PyObject *" << PYTHON_ARG << ")\n{\n" << indent; @@ -5903,7 +5905,7 @@ void CppGenerator::writeFlagsUnaryOperator(TextStream &s, const AbstractMetaEnum const QString &pyOpName, const QString &cppOpName, bool boolResult) { - FlagsTypeEntry *flagsEntry = cppEnum.typeEntry()->flags(); + FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags(); Q_ASSERT(flagsEntry); s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName @@ -5993,7 +5995,7 @@ void CppGenerator::writeClassRegister(TextStream &s, const GeneratorContext &classContext, const QString &signatures) const { - const ComplexTypeEntry *classTypeEntry = metaClass->typeEntry(); + ComplexTypeEntryCPtr classTypeEntry = metaClass->typeEntry(); const AbstractMetaClass *enc = metaClass->targetLangEnclosingClass(); QString enclosingObjectVariable = enc ? u"enclosingClass"_s : u"module"_s; @@ -6571,7 +6573,7 @@ void CppGenerator::writeNbBoolFunction(const GeneratorContext &context, // function. void CppGenerator::writeInitFunc(TextStream &declStr, TextStream &callStr, const QString &initFunctionName, - const TypeEntry *enclosingEntry) + const TypeEntryCPtr &enclosingEntry) { const bool hasParent = enclosingEntry && enclosingEntry->type() != TypeEntry::TypeSystemType; @@ -6619,7 +6621,7 @@ bool CppGenerator::finishGeneration() AbstractMetaClassCList classesWithStaticFields; for (auto cls : api().classes()){ - auto *te = cls->typeEntry(); + auto te = cls->typeEntry(); if (shouldGenerate(te)) { writeInitFunc(s_classInitDecl, s_classPythonDefines, getSimpleClassInitFunctionName(cls), @@ -6636,7 +6638,7 @@ bool CppGenerator::finishGeneration() for (const auto &smp : api().instantiatedSmartPointers()) { GeneratorContext context = contextForSmartPointer(smp.specialized, smp.type); auto *enclosingClass = context.metaClass()->enclosingClass(); - auto *enclosingTypeEntry = enclosingClass != nullptr + auto enclosingTypeEntry = enclosingClass != nullptr ? enclosingClass->typeEntry() : targetLangEnclosingEntry(smp.type.typeEntry()); writeInitFunc(s_classInitDecl, s_classPythonDefines, @@ -6652,7 +6654,7 @@ bool CppGenerator::finishGeneration() const ExtendedConverterData extendedConverters = getExtendedConverters(); for (auto it = extendedConverters.cbegin(), end = extendedConverters.cend(); it != end; ++it) { - const TypeEntry *te = it.key(); + TypeEntryCPtr te = it.key(); includes << te->include(); for (const auto &metaClass : it.value()) includes << metaClass->typeEntry()->include(); @@ -6660,7 +6662,7 @@ bool CppGenerator::finishGeneration() const QList<CustomConversionPtr> &typeConversions = getPrimitiveCustomConversions(); for (const auto &c : typeConversions) { - if (auto *te = c->ownerType()) + if (auto te = c->ownerType(); !te.isNull()) includes << te->include(); } @@ -6707,8 +6709,8 @@ bool CppGenerator::finishGeneration() } TypeDatabase *typeDb = TypeDatabase::instance(); - const TypeSystemTypeEntry *moduleEntry = typeDb->defaultTypeSystemType(); - Q_ASSERT(moduleEntry); + TypeSystemTypeEntryCPtr moduleEntry = typeDb->defaultTypeSystemType(); + Q_ASSERT(!moduleEntry.isNull()); s << '\n'; // Extra includes @@ -6791,7 +6793,7 @@ bool CppGenerator::finishGeneration() if (!extendedConverters.isEmpty()) { s << '\n' << "// Extended Converters.\n\n"; for (ExtendedConverterData::const_iterator it = extendedConverters.cbegin(), end = extendedConverters.cend(); it != end; ++it) { - const TypeEntry *externalType = it.key(); + TypeEntryCPtr externalType = it.key(); s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << '\n'; for (const AbstractMetaClass *sourceClass : it.value()) { @@ -6945,12 +6947,12 @@ bool CppGenerator::finishGeneration() s << "// Register primitive types converters.\n"; const PrimitiveTypeEntryCList &primitiveTypeList = primitiveTypes(); - for (const PrimitiveTypeEntry *pte : primitiveTypeList) { + for (const auto &pte : primitiveTypeList) { if (!pte->generateCode() || !isCppPrimitive(pte)) continue; if (!pte->referencesType()) continue; - const auto *referencedType = basicReferencedTypeEntry(pte); + TypeEntryCPtr referencedType = basicReferencedTypeEntry(pte); QString converter = converterObject(referencedType); QStringList cppSignature = pte->qualifiedCppName().split(u"::"_s, Qt::SkipEmptyParts); while (!cppSignature.isEmpty()) { @@ -7027,10 +7029,10 @@ static bool useParentHeuristics(const ApiExtractorResult &api, auto *owner = func->ownerClass(); if (owner == nullptr) return false; - auto *ownerEntry = owner->parentManagementEntry(); - if (ownerEntry == nullptr) + auto ownerEntry = owner->parentManagementEntry(); + if (ownerEntry.isNull()) return false; - auto *argTypeEntry = argType.typeEntry(); + auto argTypeEntry = argType.typeEntry(); if (!argTypeEntry->isComplex()) return false; auto *argClass = AbstractMetaClass::findClass(api.classes(), argTypeEntry); diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.h b/sources/shiboken6/generator/shiboken/cppgenerator.h index 99ad16722..b2e99b7bb 100644 --- a/sources/shiboken6/generator/shiboken/cppgenerator.h +++ b/sources/shiboken6/generator/shiboken/cppgenerator.h @@ -63,7 +63,7 @@ private: const AbstractMetaClassCList &innerClasses = {}) const; static void writeInitFunc(TextStream &declStr, TextStream &callStr, const QString &initFunctionName, - const TypeEntry *enclosingEntry = nullptr); + const TypeEntryCPtr &enclosingEntry = {}); static void writeCacheResetNative(TextStream &s, const GeneratorContext &classContext); void writeConstructorNative(TextStream &s, const GeneratorContext &classContext, const AbstractMetaFunctionCPtr &func) const; @@ -85,7 +85,7 @@ private: int cacheIndex) const; void writeVirtualMethodCppCall(TextStream &s, const AbstractMetaFunctionCPtr &func, const QString &funcName, const QList<CodeSnip> &snips, - const AbstractMetaArgument *lastArg, const TypeEntry *retType, + const AbstractMetaArgument *lastArg, const TypeEntryCPtr &retType, const QString &returnStatement, bool hasGil) const; static QString virtualMethodReturn(TextStream &s, const ApiExtractorResult &api, const AbstractMetaFunctionCPtr &func, @@ -93,7 +93,7 @@ private: void writeMetaObjectMethod(TextStream &s, const GeneratorContext &classContext) const; static void writeMetaCast(TextStream &s, const GeneratorContext &classContext); - void writeFlagsConverterFunctions(TextStream &s, const FlagsTypeEntry *flagsType, + void writeFlagsConverterFunctions(TextStream &s, const FlagsTypeEntryCPtr &flagsType, const QString &enumTypeName, const QString &flagsCppTypeName, const QString &enumTypeCheck) const; @@ -292,13 +292,13 @@ private: static QString pythonToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName); static QString pythonToCppFunctionName(const AbstractMetaType &sourceType, const AbstractMetaType &targetType); static QString pythonToCppFunctionName(const TargetToNativeConversion &toNative, - const TypeEntry *targetType); + const TypeEntryCPtr &targetType); /// Returns the name of a Python to C++ convertible check function. static QString convertibleToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName); static QString convertibleToCppFunctionName(const AbstractMetaType &sourceType, const AbstractMetaType &targetType); static QString convertibleToCppFunctionName(const TargetToNativeConversion &toNative, - const TypeEntry *targetType); + const TypeEntryCPtr &targetType); /// Writes a C++ to Python conversion function. void writeCppToPythonFunction(TextStream &s, const QString &code, const QString &sourceTypeName, @@ -328,7 +328,7 @@ private: /// Writes a pair of Python to C++ conversion and check functions for implicit conversions. void writePythonToCppConversionFunctions(TextStream &s, const TargetToNativeConversion &toNative, - const TypeEntry *targetType) const; + const TypeEntryCPtr &targetType) const; /// Writes a pair of Python to C++ conversion and check functions for instantiated container types. void writePythonToCppConversionFunctions(TextStream &s, @@ -461,11 +461,12 @@ private: static void writePrimitiveConverterInitialization(TextStream &s, const CustomConversionPtr &customConversion); - static void writeFlagsConverterInitialization(TextStream &s, const FlagsTypeEntry *enumType); + static void writeFlagsConverterInitialization(TextStream &s, const FlagsTypeEntryCPtr &enumType); static void writeEnumConverterInitialization(TextStream &s, const AbstractMetaEnum &metaEnum); QString writeContainerConverterInitialization(TextStream &s, const AbstractMetaType &type) const; void writeSmartPointerConverterInitialization(TextStream &s, const AbstractMetaType &ype) const; - static void writeExtendedConverterInitialization(TextStream &s, const TypeEntry *externalType, + static void writeExtendedConverterInitialization(TextStream &s, + const TypeEntryCPtr &externalType, const AbstractMetaClassCList &conversions); void writeParentChildManagement(TextStream &s, const AbstractMetaFunctionCPtr &func, @@ -517,8 +518,8 @@ private: { return boolCast(metaClass).has_value(); } std::optional<AbstractMetaType> - findSmartPointerInstantiation(const SmartPointerTypeEntry *pointer, - const TypeEntry *pointee) const; + findSmartPointerInstantiation(const SmartPointerTypeEntryCPtr &pointer, + const TypeEntryCPtr &pointee) const; void clearTpFuncs(); QHash<QString, QString> m_tpFuncs; diff --git a/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp b/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp index 91c56b284..8073e0c97 100644 --- a/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp +++ b/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp @@ -85,7 +85,7 @@ CppGenerator::OpaqueContainerData { OpaqueContainerData result; const auto &valueType = containerType.instantiations().constFirst(); - const auto *containerTypeEntry = static_cast<const ContainerTypeEntry *>(containerType.typeEntry()); + const auto containerTypeEntry = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry()); result.name = containerTypeEntry->opaqueContainerName(valueType.typeEntry()->name()); const auto cppSignature = containerType.cppSignature(); diff --git a/sources/shiboken6/generator/shiboken/generatorargument.cpp b/sources/shiboken6/generator/shiboken/generatorargument.cpp index 5c8f12458..e81ad0797 100644 --- a/sources/shiboken6/generator/shiboken/generatorargument.cpp +++ b/sources/shiboken6/generator/shiboken/generatorargument.cpp @@ -19,7 +19,7 @@ GeneratorArgument GeneratorArgument::fromMetaType(const AbstractMetaType &type) { GeneratorArgument result; - const TypeEntry *typeEntry = type.typeEntry(); + const auto typeEntry = type.typeEntry(); if (typeEntry->isCustom() || typeEntry->isVarargs()) return result; diff --git a/sources/shiboken6/generator/shiboken/headergenerator.cpp b/sources/shiboken6/generator/shiboken/headergenerator.cpp index d24a3b12b..9ed192097 100644 --- a/sources/shiboken6/generator/shiboken/headergenerator.cpp +++ b/sources/shiboken6/generator/shiboken/headergenerator.cpp @@ -245,12 +245,12 @@ void HeaderGenerator::writeMemberFunctionWrapper(TextStream &s, s << ", "; const AbstractMetaArgument &arg = arguments.at(i); const auto &type = arg.type(); - const TypeEntry *enumTypeEntry = nullptr; + TypeEntryCPtr enumTypeEntry; if (type.isFlags()) - enumTypeEntry = static_cast<const FlagsTypeEntry *>(type.typeEntry())->originator(); + enumTypeEntry = qSharedPointerCast<const FlagsTypeEntry>(type.typeEntry())->originator(); else if (type.isEnum()) enumTypeEntry = type.typeEntry(); - if (enumTypeEntry) { + if (!enumTypeEntry.isNull()) { s << type.cppSignature() << '(' << arg.name() << ')'; } else if (type.passByValue() && type.isUniquePointer()) { s << stdMove(arg.name()); @@ -339,7 +339,7 @@ static const AbstractMetaClass * } void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorResult &api, - const TypeEntry *typeEntry) + const TypeEntryCPtr &typeEntry) { if (!typeEntry || !typeEntry->generateCode()) return; @@ -350,7 +350,7 @@ void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorR // For a typedef "using Foo=QList<int>", write a type index // SBK_QLIST_INT besides SBK_FOO which is then matched by function // argument. Check against duplicate typedefs for the same types. - const auto *cType = static_cast<const ComplexTypeEntry *>(typeEntry); + const auto cType = qSharedPointerCast<const ComplexTypeEntry>(typeEntry); if (cType->baseContainerType()) { auto metaClass = AbstractMetaClass::findClass(api.classes(), cType); Q_ASSERT(metaClass != nullptr); @@ -366,7 +366,7 @@ void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorR } } if (typeEntry->isEnum()) { - auto ete = static_cast<const EnumTypeEntry *>(typeEntry); + auto ete = qSharedPointerCast<const EnumTypeEntry>(typeEntry); if (ete->flags()) writeTypeIndexValueLine(s, api, ete->flags()); } @@ -390,7 +390,7 @@ void HeaderGenerator::writeTypeIndexValueLines(TextStream &s, const ApiExtractor // Format the typedefs for the typedef entries to be generated static void formatTypeDefEntries(TextStream &s) { - QList<const TypedefEntry *> entries; + QList<TypedefEntryCPtr> entries; const auto typeDbEntries = TypeDatabase::instance()->typedefEntries(); for (auto it = typeDbEntries.cbegin(), end = typeDbEntries.cend(); it != end; ++it) { if (it.value()->generateCode() != 0) @@ -399,7 +399,7 @@ static void formatTypeDefEntries(TextStream &s) if (entries.isEmpty()) return; s << "\n// typedef entries\n"; - for (const auto e : entries) { + for (const auto &e : entries) { const QString name = e->qualifiedCppName(); // Fixme: simplify by using nested namespaces in C++ 17. const auto components = QStringView{name}.split(u"::"); @@ -586,7 +586,7 @@ bool HeaderGenerator::finishGeneration() macrosStream << "// Converter indices\nenum : int {\n"; const auto &primitives = primitiveTypes(); int pCount = 0; - for (const PrimitiveTypeEntry *ptype : primitives) { + for (const auto &ptype : primitives) { /* Note: do not generate indices for typedef'd primitive types * as they'll use the primitive type converters instead, so we * don't need to create any other. @@ -631,7 +631,7 @@ bool HeaderGenerator::finishGeneration() StringStream protEnumsSurrogates(TextStream::Language::Cpp); for (auto metaClass : classList) { - const TypeEntry *classType = metaClass->typeEntry(); + const auto classType = metaClass->typeEntry(); if (!shouldGenerate(classType)) continue; @@ -649,8 +649,7 @@ bool HeaderGenerator::finishGeneration() for (const AbstractMetaEnum &cppEnum : metaClass->enums()) { if (cppEnum.isAnonymous() || cppEnum.isPrivate()) continue; - EnumTypeEntry *enumType = cppEnum.typeEntry(); - includeList << enumType->include(); + includeList << cppEnum.typeEntry()->include(); writeProtectedEnumSurrogate(protEnumsSurrogates, cppEnum); writeSbkTypeFunction(typeFunctionsStr, cppEnum); } @@ -660,8 +659,7 @@ bool HeaderGenerator::finishGeneration() } for (const auto &smp : api().instantiatedSmartPointers()) { - const TypeEntry *classType = smp.type.typeEntry(); - includes << classType->include(); + includes << smp.type.typeEntry()->include(); writeSbkTypeFunction(typeFunctions, smp.type); } if (usePySideExtensions()) @@ -708,7 +706,7 @@ bool HeaderGenerator::finishGeneration() if (!primitiveTypes().isEmpty()) { s << "// Conversion Includes - Primitive Types\n"; const auto &primitiveTypeList = primitiveTypes(); - for (const PrimitiveTypeEntry *ptype : primitiveTypeList) + for (const auto &ptype : primitiveTypeList) s << ptype->include(); s<< '\n'; } @@ -716,7 +714,7 @@ bool HeaderGenerator::finishGeneration() if (!containerTypes().isEmpty()) { s << "// Conversion Includes - Container Types\n"; const ContainerTypeEntryCList &containerTypeList = containerTypes(); - for (const ContainerTypeEntry *ctype : containerTypeList) + for (const auto &ctype : containerTypeList) s << ctype->include(); s<< '\n'; } @@ -802,8 +800,8 @@ void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum s << "template<> inline PyTypeObject *SbkType< ::" << enumName << " >() "; s << "{ return " << cpythonTypeNameExt(cppEnum.typeEntry()) << "; }\n"; - FlagsTypeEntry *flag = cppEnum.typeEntry()->flags(); - if (flag) { + const auto flag = cppEnum.typeEntry()->flags(); + if (!flag.isNull()) { s << "template<> inline PyTypeObject *SbkType< ::" << flag->name() << " >() " << "{ return " << cpythonTypeNameExt(flag) << "; }\n"; } diff --git a/sources/shiboken6/generator/shiboken/headergenerator.h b/sources/shiboken6/generator/shiboken/headergenerator.h index 4f988c349..af81f0316 100644 --- a/sources/shiboken6/generator/shiboken/headergenerator.h +++ b/sources/shiboken6/generator/shiboken/headergenerator.h @@ -36,7 +36,7 @@ private: static void writeSbkTypeFunction(TextStream &s, const AbstractMetaClass *cppClass) ; static void writeSbkTypeFunction(TextStream &s, const AbstractMetaType &metaType) ; void writeTypeIndexValueLine(TextStream &s, const ApiExtractorResult &api, - const TypeEntry *typeEntry); + const TypeEntryCPtr &typeEntry); void writeTypeIndexValueLines(TextStream &s, const ApiExtractorResult &api, const AbstractMetaClass *metaClass); void writeProtectedEnumSurrogate(TextStream &s, const AbstractMetaEnum &cppEnum) const; diff --git a/sources/shiboken6/generator/shiboken/overloaddata.cpp b/sources/shiboken6/generator/shiboken/overloaddata.cpp index e42e52990..a5594791e 100644 --- a/sources/shiboken6/generator/shiboken/overloaddata.cpp +++ b/sources/shiboken6/generator/shiboken/overloaddata.cpp @@ -31,16 +31,16 @@ using namespace Qt::StringLiterals; static QString getTypeName(const AbstractMetaType &type) { - const TypeEntry *typeEntry = type.typeEntry(); + TypeEntryCPtr typeEntry = type.typeEntry(); if (typeEntry->isPrimitive()) - typeEntry = basicReferencedTypeEntry(typeEntry->asPrimitive()); + typeEntry = basicReferencedTypeEntry(typeEntry); QString typeName = typeEntry->name(); if (typeEntry->isContainer()) { QStringList types; for (const auto &cType : type.instantiations()) { - const TypeEntry *typeEntry = cType.typeEntry(); + TypeEntryCPtr typeEntry = cType.typeEntry(); if (typeEntry->isPrimitive()) - typeEntry = basicReferencedTypeEntry(typeEntry->asPrimitive()); + typeEntry = basicReferencedTypeEntry(typeEntry); types << typeEntry->name(); } typeName += u'<' + types.join(u',') + u" >"_s; @@ -241,7 +241,7 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api) // Process inheritance relationships if (targetType.isValue() || targetType.isObject()) { - auto *te = targetType.typeEntry(); + const auto te = targetType.typeEntry(); auto metaClass = AbstractMetaClass::findClass(api.classes(), te); if (!metaClass) throw Exception(msgArgumentClassNotFound(m_overloads.constFirst(), te)); diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp index a39fe1f5e..1810235b7 100644 --- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp +++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp @@ -255,11 +255,11 @@ ShibokenGenerator::FunctionGeneration return result; } -AbstractMetaFunctionCList ShibokenGenerator::implicitConversions(const TypeEntry *t) const +AbstractMetaFunctionCList ShibokenGenerator::implicitConversions(const TypeEntryCPtr &t) const { if (!generateImplicitConversions() || !t->isValue()) return {}; - auto *vte = static_cast<const ValueTypeEntry *>(t); + auto vte = qSharedPointerCast<const ValueTypeEntry>(t); auto customConversion = vte->customConversion(); if (!customConversion.isNull() && customConversion->replaceOriginalTargetToNativeConversions()) return {}; @@ -417,7 +417,7 @@ static QString cpythonEnumFlagsName(const QString &moduleName, return result; } -QString ShibokenGenerator::cpythonEnumName(const EnumTypeEntry *enumEntry) +QString ShibokenGenerator::cpythonEnumName(const EnumTypeEntryCPtr &enumEntry) { QString p = enumEntry->targetLangPackage(); p.replace(u'.', u'_'); @@ -429,7 +429,7 @@ QString ShibokenGenerator::cpythonEnumName(const AbstractMetaEnum &metaEnum) return cpythonEnumName(metaEnum.typeEntry()); } -QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntry *flagsEntry) +QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntryCPtr &flagsEntry) { QString p = flagsEntry->targetLangPackage(); p.replace(u'.', u'_'); @@ -438,10 +438,8 @@ QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntry *flagsEntry) QString ShibokenGenerator::cpythonFlagsName(const AbstractMetaEnum *metaEnum) { - const FlagsTypeEntry *flags = metaEnum->typeEntry()->flags(); - if (!flags) - return QString(); - return cpythonFlagsName(flags); + const auto flags = metaEnum->typeEntry()->flags(); + return flags.isNull() ? QString{} : cpythonFlagsName(flags); } QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass) @@ -465,7 +463,7 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaType &metaType, + u", reinterpret_cast<SbkObject *>("_s + argName + u")))"_s; } -QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry *type, +QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntryCPtr &type, const QString &argName) { if (!type->isWrapperType()) @@ -532,21 +530,21 @@ QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClass *metaClass) return cpythonBaseName(metaClass->typeEntry()); } -QString ShibokenGenerator::cpythonBaseName(const TypeEntry *type) +QString ShibokenGenerator::cpythonBaseName(const TypeEntryCPtr &type) { QString baseName; if (type->isWrapperType() || type->isNamespace()) { // && type->referenceType() == NoReference) { baseName = u"Sbk_"_s + type->name(); } else if (type->isPrimitive()) { - const auto *ptype = basicReferencedTypeEntry(type->asPrimitive()); + const auto ptype = basicReferencedTypeEntry(type); baseName = ptype->hasTargetLangApiType() ? ptype->targetLangApiName() : pythonPrimitiveTypeName(ptype->name()); } else if (type->isEnum()) { - baseName = cpythonEnumName(static_cast<const EnumTypeEntry *>(type)); + baseName = cpythonEnumName(qSharedPointerCast<const EnumTypeEntry>(type)); } else if (type->isFlags()) { - baseName = cpythonFlagsName(static_cast<const FlagsTypeEntry *>(type)); + baseName = cpythonFlagsName(qSharedPointerCast<const FlagsTypeEntry>(type)); } else if (type->isContainer()) { - const auto *ctype = static_cast<const ContainerTypeEntry *>(type); + const auto ctype = qSharedPointerCast<const ContainerTypeEntry>(type); switch (ctype->containerKind()) { case ContainerTypeEntry::ListContainer: //baseName = "PyList"; @@ -576,12 +574,12 @@ QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass *metaClass) return cpythonTypeName(metaClass->typeEntry()); } -QString ShibokenGenerator::cpythonTypeName(const TypeEntry *type) +QString ShibokenGenerator::cpythonTypeName(const TypeEntryCPtr &type) { return cpythonBaseName(type) + u"_TypeF()"_s; } -QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntry *type) +QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntryCPtr &type) { return cppApiVariableName(type->targetLangPackage()) + u'[' + getTypeIndexVariableName(type) + u']'; @@ -609,7 +607,7 @@ QString ShibokenGenerator::converterObject(const AbstractMetaType &type) return converterObject(typeEntry); } -QString ShibokenGenerator::converterObject(const TypeEntry *type) +QString ShibokenGenerator::converterObject(const TypeEntryCPtr &type) { if (isExtendedCppPrimitive(type)) return QString::fromLatin1("Shiboken::Conversions::PrimitiveTypeConverter<%1>()") @@ -630,8 +628,8 @@ QString ShibokenGenerator::converterObject(const TypeEntry *type) } /* the typedef'd primitive types case */ - const auto *pte = dynamic_cast<const PrimitiveTypeEntry *>(type); - if (!pte) { + auto pte = qSharedPointerDynamicCast<const PrimitiveTypeEntry>(type); + if (pte.isNull()) { qDebug() << "Warning: the Qt5 primitive type is unknown" << type->qualifiedCppName(); return QString(); } @@ -676,7 +674,7 @@ static QString _fixedCppTypeName(QString typeName) typeName.replace(u"&"_s, u"REF"_s); return typeName; } -QString ShibokenGenerator::fixedCppTypeName(const TypeEntry *type, QString typeName) +QString ShibokenGenerator::fixedCppTypeName(const TypeEntryCPtr &type, QString typeName) { if (typeName.isEmpty()) typeName = type->qualifiedCppName(); @@ -723,21 +721,21 @@ bool ShibokenGenerator::isNumber(const QString &cpythonApiName) } static std::optional<TypeSystem::CPythonType> - targetLangApiCPythonType(const PrimitiveTypeEntry *t) + targetLangApiCPythonType(const PrimitiveTypeEntryCPtr &t) { if (!t->hasTargetLangApiType()) return {}; - const auto *cte = t->targetLangApiType(); + const auto cte = t->targetLangApiType(); if (cte->type() != TypeEntry::PythonType) return {}; - return static_cast<const PythonTypeEntry *>(cte)->cPythonType(); + return qSharedPointerCast<const PythonTypeEntry>(cte)->cPythonType(); } -bool ShibokenGenerator::isNumber(const TypeEntry *type) +bool ShibokenGenerator::isNumber(const TypeEntryCPtr &type) { if (!type->isPrimitive()) return false; - const auto *pte = basicReferencedTypeEntry(type->asPrimitive()); + const auto pte = basicReferencedTypeEntry(type); const auto cPythonTypeOpt = targetLangApiCPythonType(pte); // FIXME PYSIDE-1660: Return false here after making primitive types built-in? if (!cPythonTypeOpt.has_value()) { @@ -756,11 +754,11 @@ bool ShibokenGenerator::isNumber(const AbstractMetaType &type) return isNumber(type.typeEntry()); } -bool ShibokenGenerator::isPyInt(const TypeEntry *type) +bool ShibokenGenerator::isPyInt(const TypeEntryCPtr &type) { if (!type->isPrimitive()) return false; - const auto *pte = basicReferencedTypeEntry(type->asPrimitive()); + const auto pte = basicReferencedTypeEntry(type); const auto cPythonTypeOpt = targetLangApiCPythonType(pte); // FIXME PYSIDE-1660: Return false here after making primitive types built-in? if (!cPythonTypeOpt.has_value()) { @@ -784,9 +782,9 @@ bool ShibokenGenerator::isNullPtr(const QString &value) QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType) { - const auto *typeEntry = metaType.typeEntry(); + const auto typeEntry = metaType.typeEntry(); if (typeEntry->isCustom()) { - const auto *cte = static_cast<const CustomTypeEntry *>(typeEntry); + const auto cte = qSharedPointerCast<const CustomTypeEntry>(typeEntry); if (cte->hasCheckFunction()) return cte->checkFunction(); throw Exception(msgUnknownCheckFunction(typeEntry)); @@ -803,7 +801,7 @@ QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType) if (typeEntry->isContainer()) { QString typeCheck = u"Shiboken::Conversions::"_s; ContainerTypeEntry::ContainerKind type = - static_cast<const ContainerTypeEntry *>(typeEntry)->containerKind(); + qSharedPointerCast<const ContainerTypeEntry>(typeEntry)->containerKind(); if (type == ContainerTypeEntry::ListContainer || type == ContainerTypeEntry::SetContainer) { const QString containerType = type == ContainerTypeEntry::SetContainer @@ -851,10 +849,10 @@ QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType) return cpythonCheckFunction(typeEntry); } -QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry *type) +QString ShibokenGenerator::cpythonCheckFunction(TypeEntryCPtr type) { if (type->isCustom()) { - const auto *cte = static_cast<const CustomTypeEntry *>(type); + const auto cte = qSharedPointerCast<const CustomTypeEntry>(type); if (cte->hasCheckFunction()) return cte->checkFunction(); throw Exception(msgUnknownCheckFunction(type)); @@ -864,28 +862,26 @@ QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry *type) return u"SbkObject_TypeCheck("_s + cpythonTypeNameExt(type) + u", "_s; if (type->isPrimitive()) - type = basicReferencedTypeEntry(type->asPrimitive()); + type = basicReferencedTypeEntry(type); - if (auto *tla = type->targetLangApiType()) { + if (auto tla = type->targetLangApiType()) { if (tla->hasCheckFunction()) return tla->checkFunction(); } - if (isExtendedCppPrimitive(type)) { - const auto *pte = type->asPrimitive(); - return pythonPrimitiveTypeName(pte->name()) + u"_Check"_s; - } + if (isExtendedCppPrimitive(type)) + return pythonPrimitiveTypeName(type->name()) + u"_Check"_s; return cpythonIsConvertibleFunction(type); } -QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry *type) +QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntryCPtr &type) { if (type->isWrapperType()) { QString result = u"Shiboken::Conversions::"_s; bool isValue = false; if (type->isValue()) { - const auto *cte = static_cast<const ComplexTypeEntry *>(type); + const auto cte = qSharedPointerCast<const ComplexTypeEntry>(type); isValue = !cte->isValueTypeWithCopyConstructorOnly(); } result += isValue ? u"isPythonToCppValueConvertible"_s @@ -899,9 +895,9 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry *type) QString ShibokenGenerator::cpythonIsConvertibleFunction(AbstractMetaType metaType) { - const auto *typeEntry = metaType.typeEntry(); + const auto typeEntry = metaType.typeEntry(); if (typeEntry->isCustom()) { - const auto *cte = static_cast<const CustomTypeEntry *>(typeEntry); + const auto cte = qSharedPointerCast<const CustomTypeEntry>(typeEntry); if (cte->hasCheckFunction()) return cte->checkFunction(); throw Exception(msgUnknownCheckFunction(typeEntry)); @@ -990,7 +986,7 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaC return cpythonToPythonConversionFunction(metaClass->typeEntry()); } -QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry *type) +QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntryCPtr &type) { if (type->isWrapperType()) { const QString conversion = type->isValue() ? u"copy"_s : u"pointer"_s; @@ -1163,7 +1159,7 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter for (const auto &convOp : overloads) { // Get only the conversion operators that return a type from another module, // that are value-types and were not removed in the type system. - const TypeEntry *convType = convOp->type().typeEntry(); + const auto convType = convOp->type().typeEntry(); if (convType->generateCode() || !convType->isValue() || convOp->isModifiedRemoved()) continue; @@ -1177,7 +1173,7 @@ QList<CustomConversionPtr> ShibokenGenerator::getPrimitiveCustomConversions() { QList<CustomConversionPtr> conversions; const auto &primitiveTypeList = primitiveTypes(); - for (const PrimitiveTypeEntry *type : primitiveTypeList) { + for (const auto &type : primitiveTypeList) { if (type->shouldGenerate() && isUserPrimitive(type) && type->hasCustomConversion()) conversions << type->customConversion(); } @@ -1852,7 +1848,7 @@ QString ShibokenGenerator::getPrivateModuleHeaderFileName(const QString &moduleN IncludeGroupList ShibokenGenerator::classIncludes(const AbstractMetaClass *metaClass) const { IncludeGroupList result; - auto *typeEntry = metaClass->typeEntry(); + const auto typeEntry = metaClass->typeEntry(); //Extra includes result.append(IncludeGroup{u"Extra includes"_s, typeEntry->extraIncludes()}); @@ -2214,10 +2210,10 @@ QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass *met { return getTypeIndexVariableName(metaClass->typeEntry()); } -QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry *type) +QString ShibokenGenerator::getTypeIndexVariableName(TypeEntryCPtr type) { if (isCppPrimitive(type)) - type = basicReferencedTypeEntry(type->asPrimitive()); + type = basicReferencedTypeEntry(type); QString result = u"SBK_"_s; // Disambiguate namespaces per module to allow for extending them. if (type->isNamespace()) { @@ -2271,7 +2267,7 @@ QString ShibokenGenerator::minimalConstructorExpression(const ApiExtractorResult } QString ShibokenGenerator::minimalConstructorExpression(const ApiExtractorResult &api, - const TypeEntry *type) + const TypeEntryCPtr &type) { if (isExtendedCppPrimitive(type)) return {}; diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.h b/sources/shiboken6/generator/shiboken/shibokengenerator.h index 1b7168e31..d0b1158c6 100644 --- a/sources/shiboken6/generator/shiboken/shibokengenerator.h +++ b/sources/shiboken6/generator/shiboken/shibokengenerator.h @@ -78,7 +78,7 @@ public: static QString minimalConstructorExpression(const ApiExtractorResult &api, const AbstractMetaType &type); static QString minimalConstructorExpression(const ApiExtractorResult &api, - const TypeEntry *type); + const TypeEntryCPtr &type); protected: bool doSetup() override; @@ -181,7 +181,7 @@ protected: FunctionGeneration functionGeneration(const AbstractMetaFunctionCPtr &func) const; // Return a list of implicit conversions if generation is enabled. - AbstractMetaFunctionCList implicitConversions(const TypeEntry *t) const; + AbstractMetaFunctionCList implicitConversions(const TypeEntryCPtr &t) const; QString wrapperName(const AbstractMetaClass *metaClass) const; @@ -198,29 +198,29 @@ protected: static QString fixedCppTypeName(const TargetToNativeConversion &toNative); static QString fixedCppTypeName(const AbstractMetaType &type); - static QString fixedCppTypeName(const TypeEntry *type, QString typeName = QString()); + static QString fixedCppTypeName(const TypeEntryCPtr &type, QString typeName = {}); static bool isNumber(const QString &cpythonApiName); - static bool isNumber(const TypeEntry *type); + static bool isNumber(const TypeEntryCPtr &type); static bool isNumber(const AbstractMetaType &type); - static bool isPyInt(const TypeEntry *type); + static bool isPyInt(const TypeEntryCPtr &type); static bool isPyInt(const AbstractMetaType &type); static bool isNullPtr(const QString &value); static QString converterObject(const AbstractMetaType &type) ; - static QString converterObject(const TypeEntry *type); + static QString converterObject(const TypeEntryCPtr &type); static QString cpythonBaseName(const AbstractMetaClass *metaClass); - static QString cpythonBaseName(const TypeEntry *type); + static QString cpythonBaseName(const TypeEntryCPtr &type); static QString cpythonBaseName(const AbstractMetaType &type); static QString cpythonTypeName(const AbstractMetaClass *metaClass); - static QString cpythonTypeName(const TypeEntry *type); - static QString cpythonTypeNameExt(const TypeEntry *type); + static QString cpythonTypeName(const TypeEntryCPtr &type); + static QString cpythonTypeNameExt(const TypeEntryCPtr &type); static QString cpythonTypeNameExt(const AbstractMetaType &type) ; - static QString cpythonCheckFunction(const TypeEntry *type); + static QString cpythonCheckFunction(TypeEntryCPtr type); static QString cpythonCheckFunction(AbstractMetaType metaType); - static QString cpythonIsConvertibleFunction(const TypeEntry *type); + static QString cpythonIsConvertibleFunction(const TypeEntryCPtr &type); static QString cpythonIsConvertibleFunction(AbstractMetaType metaType); static QString cpythonIsConvertibleFunction(const AbstractMetaArgument &metaArg); @@ -230,7 +230,7 @@ protected: static QString cpythonToPythonConversionFunction(const AbstractMetaType &type, const AbstractMetaClass *context = nullptr); static QString cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass); - static QString cpythonToPythonConversionFunction(const TypeEntry *type); + static QString cpythonToPythonConversionFunction(const TypeEntryCPtr &type); static QString cpythonFunctionName(const AbstractMetaFunctionCPtr &func) ; static QString cpythonMethodDefinitionName(const AbstractMetaFunctionCPtr &func); @@ -247,12 +247,12 @@ protected: const QString &argName = QStringLiteral("self")); static QString cpythonWrapperCPtr(const AbstractMetaType &metaType, const QString &argName); - static QString cpythonWrapperCPtr(const TypeEntry *type, const QString &argName); + static QString cpythonWrapperCPtr(const TypeEntryCPtr &type, const QString &argName); - static QString cpythonEnumName(const EnumTypeEntry *enumEntry); + static QString cpythonEnumName(const EnumTypeEntryCPtr &enumEntry); static QString cpythonEnumName(const AbstractMetaEnum &metaEnum); - static QString cpythonFlagsName(const FlagsTypeEntry *flagsEntry); + static QString cpythonFlagsName(const FlagsTypeEntryCPtr &flagsEntry); static QString cpythonFlagsName(const AbstractMetaEnum *metaEnum); /// Returns the special cast function name, the function used to proper cast class with multiple inheritance. static QString cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass); @@ -287,7 +287,7 @@ protected: /// Returns the type index variable name for a given typedef for a template /// class instantiation made of the template class and the instantiation values static QString getTypeAlternateTemplateIndexVariableName(const AbstractMetaClass *metaClass); - static QString getTypeIndexVariableName(const TypeEntry *type); + static QString getTypeIndexVariableName(TypeEntryCPtr type); static QString getTypeIndexVariableName(const AbstractMetaType &type) ; /// Returns true if the user don't want verbose error messages on the generated bindings. @@ -301,7 +301,7 @@ protected: // All data about extended converters: the type entries of the target type, and a // list of AbstractMetaClasses accepted as argument for the conversion. - using ExtendedConverterData = QHash<const TypeEntry *, AbstractMetaClassCList>; + using ExtendedConverterData = QHash<TypeEntryCPtr, AbstractMetaClassCList>; /// Returns all extended conversions for the current module. ExtendedConverterData getExtendedConverters() const; |