diff options
Diffstat (limited to 'tools/activeqt/dumpcpp/main.cpp')
| -rw-r--r-- | tools/activeqt/dumpcpp/main.cpp | 1502 |
1 files changed, 1502 insertions, 0 deletions
diff --git a/tools/activeqt/dumpcpp/main.cpp b/tools/activeqt/dumpcpp/main.cpp new file mode 100644 index 0000000..05f1f19 --- /dev/null +++ b/tools/activeqt/dumpcpp/main.cpp @@ -0,0 +1,1502 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the tools applications of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QAxObject> +#include <QFile> +#include <QMetaObject> +#include <QMetaEnum> +#include <QTextStream> +#include <QSettings> +#include <QStringList> +#include <QUuid> +#include <QWidget> +#include <qt_windows.h> +#include <ocidl.h> + +QT_BEGIN_NAMESPACE + +static ITypeInfo *currentTypeInfo = 0; + +enum ObjectCategory +{ + DefaultObject = 0x00, + SubObject = 0x001, + ActiveX = 0x002, + NoMetaObject = 0x004, + NoImplementation = 0x008, + NoDeclaration = 0x010, + NoInlines = 0x020, + OnlyInlines = 0x040, + DoNothing = 0x080, + Licensed = 0x100, + TypeLibID = 0x101 +}; + +// this comes from moc/qmetaobject.cpp +enum ProperyFlags { + Invalid = 0x00000000, + Readable = 0x00000001, + Writable = 0x00000002, + Resetable = 0x00000004, + EnumOrFlag = 0x00000008, + StdCppSet = 0x00000100, + Override = 0x00000200, + Designable = 0x00001000, + ResolveDesignable = 0x00002000, + Scriptable = 0x00004000, + ResolveScriptable = 0x00008000, + Stored = 0x00010000, + ResolveStored = 0x00020000, + Editable = 0x00040000, + ResolveEditable = 0x00080000 +}; + +enum MemberFlags { + AccessPrivate = 0x00, + AccessProtected = 0x01, + AccessPublic = 0x02, + MemberMethod = 0x00, + MemberSignal = 0x04, + MemberSlot = 0x08, + MemberCompatibility = 0x10, + MemberCloned = 0x20, + MemberScriptable = 0x40, +}; + +extern QMetaObject *qax_readEnumInfo(ITypeLib *typeLib, const QMetaObject *parentObject); +extern QMetaObject *qax_readClassInfo(ITypeLib *typeLib, ITypeInfo *typeInfo, const QMetaObject *parentObject); +extern QMetaObject *qax_readInterfaceInfo(ITypeLib *typeLib, ITypeInfo *typeInfo, const QMetaObject *parentObject); +extern QList<QByteArray> qax_qualified_usertypes; +extern QString qax_docuFromName(ITypeInfo *typeInfo, const QString &name); +extern bool qax_dispatchEqualsIDispatch; + +QByteArray nameSpace; +QMap<QByteArray, QByteArray> namespaceForType; + +void writeEnums(QTextStream &out, const QMetaObject *mo) +{ + // enums + for (int ienum = mo->enumeratorOffset(); ienum < mo->enumeratorCount(); ++ienum) { + QMetaEnum metaEnum = mo->enumerator(ienum); + out << " enum " << metaEnum.name() << " {" << endl; + for (int k = 0; k < metaEnum.keyCount(); ++k) { + QByteArray key(metaEnum.key(k)); + out << " " << key.leftJustified(24) << "= " << metaEnum.value(k); + if (k < metaEnum.keyCount() - 1) + out << ","; + out << endl; + } + out << " };" << endl; + out << endl; + } +} + +void writeHeader(QTextStream &out, const QByteArray &nameSpace) +{ + out << "#ifndef QAX_DUMPCPP_" << nameSpace.toUpper() << "_H" << endl; + out << "#define QAX_DUMPCPP_" << nameSpace.toUpper() << "_H" << endl; + out << endl; + out << "// Define this symbol to __declspec(dllexport) or __declspec(dllimport)" << endl; + out << "#ifndef " << nameSpace.toUpper() << "_EXPORT" << endl; + out << "#define " << nameSpace.toUpper() << "_EXPORT" << endl; + out << "#endif" << endl; + out << endl; + out << "#include <qaxobject.h>" << endl; + out << "#include <qaxwidget.h>" << endl; + out << "#include <qdatetime.h>" << endl; + out << "#include <qpixmap.h>" << endl; + out << endl; + out << "struct IDispatch;" << endl; + out << endl; +} + +void generateNameSpace(QTextStream &out, const QMetaObject *mo, const QByteArray &nameSpace) +{ + out << "namespace " << nameSpace << " {" << endl; + out << endl; + writeEnums(out, mo); + + // don't close on purpose +} + +static QByteArray joinParameterNames(const QList<QByteArray> ¶meterNames) +{ + QByteArray slotParameters; + for (int p = 0; p < parameterNames.count(); ++p) { + slotParameters += parameterNames.at(p); + if (p < parameterNames.count() - 1) + slotParameters += ','; + } + + return slotParameters; +} + +QByteArray constRefify(const QByteArray &type) +{ + QByteArray ctype(type); + if (type == "QString" || type == "QPixmap" + || type == "QVariant" || type == "QDateTime" + || type == "QColor" || type == "QFont" + || type == "QByteArray" || type == "QValueList<QVariant>" + || type == "QStringList") + ctype = "const " + ctype + "&"; + + return ctype; +} + +void generateClassDecl(QTextStream &out, const QString &controlID, const QMetaObject *mo, const QByteArray &className, const QByteArray &nameSpace, ObjectCategory category) +{ + QList<QByteArray> functions; + + QByteArray indent; + if (!(category & OnlyInlines)) + indent = " "; + + if (!(category & OnlyInlines)) { + // constructors + out << "class " << nameSpace.toUpper() << "_EXPORT " << className << " : public "; + if (category & ActiveX) + out << "QAxWidget"; + else + out << "QAxObject"; + out << endl; + + out << "{" << endl; + out << "public:" << endl; + out << " " << className << "("; + if (category & Licensed) + out << "const QString &licenseKey = QString(), "; + if (category & ActiveX) + out << "QWidget *parent = 0, Qt::WindowFlags f"; + else if (category & SubObject) + out << "IDispatch *subobject = 0, QAxObject *parent"; + else + out << "QObject *parent"; + out << " = 0)" << endl; + out << " : "; + if (category & ActiveX) + out << "QAxWidget(parent, f"; + else if (category & SubObject) + out << "QAxObject((IUnknown*)subobject, parent"; + else + out << "QAxObject(parent"; + out << ")" << endl; + out << " {" << endl; + if (category & SubObject) + out << " internalRelease();" << endl; + else if (category & Licensed) { + out << " if (licenseKey.isEmpty())" << endl; + out << " setControl(\"" << controlID << "\");" << endl; + out << " else" << endl; + out << " setControl(\"" << controlID << ":\" + licenseKey);" << endl; + } else { + out << " setControl(\"" << controlID << "\");" << endl; + } + out << " }" << endl; + out << endl; + + for (int ci = mo->classInfoOffset(); ci < mo->classInfoCount(); ++ci) { + QMetaClassInfo info = mo->classInfo(ci); + QByteArray iface_name = info.name(); + if (iface_name.startsWith("Event ")) + continue; + + QByteArray iface_class = info.value(); + + out << " " << className << "(" << iface_class << " *iface)" << endl; + + if (category & ActiveX) + out << " : QAxWidget()" << endl; + else + out << " : QAxObject()" << endl; + out << " {" << endl; + out << " initializeFrom(iface);" << endl; + out << " delete iface;" << endl; + out << " }" << endl; + out << endl; + } + } + + functions << className; + + // enums + if (nameSpace.isEmpty() && !(category & OnlyInlines)) { + for (int ienum = mo->enumeratorOffset(); ienum < mo->enumeratorCount(); ++ienum) { + QMetaEnum metaEnum = mo->enumerator(ienum); + out << " enum " << metaEnum.name() << " {" << endl; + for (int k = 0; k < metaEnum.keyCount(); ++k) { + QByteArray key(metaEnum.key(k)); + out << " " << key.leftJustified(24) << "= " << metaEnum.value(k); + if (k < metaEnum.keyCount() - 1) + out << ","; + out << endl; + } + out << " };" << endl; + out << endl; + } + } + // QAxBase public virtual functions. + QList<QByteArray> axBase_vfuncs; + axBase_vfuncs.append("metaObject"); + axBase_vfuncs.append("qObject"); + axBase_vfuncs.append("className"); + axBase_vfuncs.append("propertyWritable"); + axBase_vfuncs.append("setPropertyWritable"); + + // properties + for (int iprop = mo->propertyOffset(); iprop < mo->propertyCount(); ++iprop) { + QMetaProperty property = mo->property(iprop); + if (!property.isReadable()) + continue; + + QByteArray propertyName(property.name()); + if (propertyName == "control" || propertyName == className) + continue; + + if (!(category & OnlyInlines)) { + out << indent << "/*" << endl << indent << "Property " << propertyName << endl; + QString documentation = qax_docuFromName(currentTypeInfo, QString::fromLatin1(propertyName.constData())); + if (!documentation.isEmpty()) { + out << endl; + out << indent << documentation << endl; + } + out << indent << "*/" << endl; + } + + // Check whether the new function conflicts with any of QAxBase public virtual functions. + // If so, prepend the function name with '<classname>_'. Since all internal metaobject magic + // remains the same, we have to use the original name when used with QObject::connect or QMetaObject + QByteArray propertyFunctionName(propertyName); + if (axBase_vfuncs.contains(propertyFunctionName)) { + propertyFunctionName = className + "_" + propertyName; + qWarning("property conflits with QAXBase: %s changed to %s", propertyName.constData(), propertyFunctionName.constData()); + } + + QByteArray propertyType(property.typeName()); + QByteArray castType(propertyType); + + QByteArray simplePropType = propertyType; + simplePropType.replace('*', ""); + + out << indent << "inline "; + bool foreignNamespace = true; + if (!propertyType.contains("::") && + (qax_qualified_usertypes.contains(simplePropType) || qax_qualified_usertypes.contains("enum "+ simplePropType)) + ) { + propertyType = nameSpace + "::" + propertyType; + foreignNamespace = false; + } + + out << propertyType << " "; + + if (category & OnlyInlines) + out << className << "::"; + out << propertyFunctionName << "() const"; + + if (!(category & NoInlines)) { + out << endl << indent << "{" << endl; + if (qax_qualified_usertypes.contains(simplePropType)) { + out << indent << " " << propertyType << " qax_pointer = 0;" << endl; + out << indent << " qRegisterMetaType(\"" << property.typeName() << "\", &qax_pointer);" << endl; + if (foreignNamespace) + out << "#ifdef QAX_DUMPCPP_" << propertyType.left(propertyType.indexOf("::")).toUpper() << "_H" << endl; + out << indent << " qRegisterMetaType(\"" << simplePropType << "\", qax_pointer);" << endl; + if (foreignNamespace) + out << "#endif" << endl; + } + out << indent << " QVariant qax_result = property(\"" << propertyName << "\");" << endl; + if (propertyType.length() && propertyType.at(propertyType.length()-1) == '*') + out << indent << " if (!qax_result.constData()) return 0;" << endl; + out << indent << " Q_ASSERT(qax_result.isValid());" << endl; + if (qax_qualified_usertypes.contains(simplePropType)) { + simplePropType = propertyType; + simplePropType.replace('*', ""); + if (foreignNamespace) + out << "#ifdef QAX_DUMPCPP_" << propertyType.left(propertyType.indexOf("::")).toUpper() << "_H" << endl; + out << indent << " return *(" << propertyType << "*)qax_result.constData();" << endl; + if (foreignNamespace) { + out << "#else" << endl; + out << indent << " return 0; // foreign namespace not included" << endl; + out << "#endif" << endl; + } + + } else { + out << indent << " return *(" << propertyType << "*)qax_result.constData();" << endl; + } + out << indent << "}" << endl; + } else { + out << "; //Returns the value of " << propertyName << endl; + } + + functions << propertyName; + + if (property.isWritable()) { + QByteArray setter(propertyName); + QChar firstChar = QLatin1Char(setter.at(0)); + if (isupper(setter.at(0))) { + setter = "Set" + setter; + } else { + setter[0] = toupper(setter[0]); + setter = "set" + setter; + } + + out << indent << "inline " << "void "; + if (category & OnlyInlines) + out << className << "::"; + out << setter << "(" << constRefify(propertyType) << " value)"; + + if (!(category & NoInlines)) { + if (propertyType.endsWith('*')) { + out << "{" << endl; + out << " int typeId = qRegisterMetaType(\"" << propertyType << "\", &value);" << endl; + out << " setProperty(\"" << propertyName << "\", QVariant(typeId, &value));" << endl; + out << "}" << endl; + } else { + out << "{ setProperty(\"" << propertyName << "\", QVariant(value)); }" << endl; + } + } else { + out << "; //Sets the value of the " << propertyName << " property" << endl; + } + + functions << setter; + } + + out << endl; + } + + // slots - but not property setters + int defaultArguments = 0; + for (int islot = mo->methodOffset(); islot < mo->methodCount(); ++islot) { + const QMetaMethod slot(mo->method(islot)); + if (slot.methodType() != QMetaMethod::Slot) + continue; + +#if 0 + // makes not sense really to respect default arguments... + if (slot.attributes() & Cloned) { + ++defaultArguments; + continue; + } +#endif + + QByteArray slotSignature(slot.signature()); + QByteArray slotName = slotSignature.left(slotSignature.indexOf('(')); + if (functions.contains(slotName)) + continue; + + if (!(category & OnlyInlines)) { + out << indent << "/*" << endl << indent << "Method " << slotName << endl; + QString documentation = qax_docuFromName(currentTypeInfo, QString::fromLatin1(slotName.constData())); + if (!documentation.isEmpty()) { + out << endl; + out << indent << documentation << endl; + } + out << indent << "*/" << endl; + } + + QByteArray slotParameters(joinParameterNames(slot.parameterNames())); + QByteArray slotTag(slot.tag()); + QByteArray slotType(slot.typeName()); + + QByteArray simpleSlotType = slotType; + simpleSlotType.replace('*', ""); + if (!slotType.contains("::") && qax_qualified_usertypes.contains(simpleSlotType)) + slotType = nameSpace + "::" + slotType; + + + QByteArray slotNamedSignature; + if (slotSignature.endsWith("()")) { // no parameters - no names + slotNamedSignature = slotSignature; + } else { + slotNamedSignature = slotSignature.left(slotSignature.indexOf('(') + 1); + QByteArray slotSignatureTruncated(slotSignature.mid(slotNamedSignature.length())); + slotSignatureTruncated.truncate(slotSignatureTruncated.length() - 1); + + QList<QByteArray> signatureSplit = slotSignatureTruncated.split(','); + QList<QByteArray> parameterSplit; + if (slotParameters.isEmpty()) { // generate parameter names + for (int i = 0; i < signatureSplit.count(); ++i) + parameterSplit << QByteArray("p") + QByteArray::number(i); + } else { + parameterSplit = slotParameters.split(','); + } + + for (int i = 0; i < signatureSplit.count(); ++i) { + QByteArray parameterType = signatureSplit.at(i); + if (!parameterType.contains("::") && namespaceForType.contains(parameterType)) + parameterType = namespaceForType.value(parameterType) + "::" + parameterType; + + slotNamedSignature += constRefify(parameterType); + slotNamedSignature += " "; + slotNamedSignature += parameterSplit.at(i); + if (defaultArguments >= signatureSplit.count() - i) { + slotNamedSignature += " = "; + slotNamedSignature += parameterType + "()"; + } + if (i + 1 < signatureSplit.count()) + slotNamedSignature += ", "; + } + slotNamedSignature += ')'; + } + + out << indent << "inline "; + + if (!slotTag.isEmpty()) + out << slotTag << " "; + if (slotType.isEmpty()) + out << "void "; + else + out << slotType << " "; + if (category & OnlyInlines) + out << className << "::"; + + // Update function name in case of conflicts with QAxBase public virtual functions. + int parnIdx = slotNamedSignature.indexOf('('); + QByteArray slotOriginalName = slotNamedSignature.left(parnIdx); + if (axBase_vfuncs.contains(slotOriginalName)) { + QByteArray newSignature = className + "_" + slotOriginalName; + newSignature += slotNamedSignature.mid(parnIdx); + qWarning("function name conflits with QAXBase %s changed to %s", slotNamedSignature.constData(), newSignature.constData()); + slotNamedSignature = newSignature; + } + + out << slotNamedSignature; + + if (category & NoInlines) { + out << ";" << endl; + } else { + out << endl; + out << indent << "{" << endl; + + if (!slotType.isEmpty()) { + out << indent << " " << slotType << " qax_result"; + if (slotType.endsWith('*')) + out << " = 0"; + out << ";" << endl; + if (qax_qualified_usertypes.contains(simpleSlotType)) { + out << indent << " qRegisterMetaType(\"" << simpleSlotType << "*\", &qax_result);" << endl; + bool foreignNamespace = simpleSlotType.contains("::"); + if (foreignNamespace) + out << "#ifdef QAX_DUMPCPP_" << simpleSlotType.left(simpleSlotType.indexOf(':')).toUpper() << "_H" << endl; + out << indent << " qRegisterMetaType(\"" << simpleSlotType << "\", qax_result);" << endl; + if (foreignNamespace) + out << "#endif" << endl; + } + } + out << indent << " void *_a[] = {"; + if (!slotType.isEmpty()) + out << "(void*)&qax_result"; + else + out << "0"; + if (!slotParameters.isEmpty()) { + out << ", (void*)&"; + out << slotParameters.replace(",", ", (void*)&"); + } + out << "};" << endl; + + out << indent << " qt_metacall(QMetaObject::InvokeMetaMethod, " << islot << ", _a);" << endl; + if (!slotType.isEmpty()) + out << indent << " return qax_result;" << endl; + out << indent << "}" << endl; + } + + out << endl; + defaultArguments = 0; + } + + if (!(category & OnlyInlines)) { + if (!(category & NoMetaObject)) { + out << "// meta object functions" << endl; + out << " static const QMetaObject staticMetaObject;" << endl; + out << " virtual const QMetaObject *metaObject() const { return &staticMetaObject; }" << endl; + out << " virtual void *qt_metacast(const char *);" << endl; + } + + out << "};" << endl; + } +} + +#define addString(string, stringData) \ + out << stringDataLength << ", "; \ + stringData += string; \ + stringDataLength += qstrlen(string); \ + stringData += "\\0"; \ + lineLength += qstrlen(string) + 1; \ + if (lineLength > 200) { stringData += "\"\n \""; lineLength = 0; } \ + ++stringDataLength; + +void generateClassImpl(QTextStream &out, const QMetaObject *mo, const QByteArray &className, const QByteArray &nameSpace, ObjectCategory category) +{ + QByteArray qualifiedClassName; + if (!nameSpace.isEmpty()) + qualifiedClassName = nameSpace + "::"; + qualifiedClassName += className; + + QByteArray stringData(qualifiedClassName); + int stringDataLength = stringData.length(); + stringData += "\\0\"\n"; + ++stringDataLength; + int lineLength = 0; + + int classInfoCount = mo->classInfoCount() - mo->classInfoOffset(); + int enumCount = mo->enumeratorCount() - mo->enumeratorOffset(); + int methodCount = mo->methodCount() - mo->methodOffset(); + int propertyCount = mo->propertyCount() - mo->propertyOffset(); + int enumStart = 10; + + out << "static const uint qt_meta_data_" << qualifiedClassName.replace(':', '_') << "[] = {" << endl; + out << endl; + out << " // content:" << endl; + out << " 1, // revision" << endl; + out << " 0, // classname" << endl; + out << " " << classInfoCount << ", " << (classInfoCount ? enumStart : 0) << ", // classinfo" << endl; + enumStart += classInfoCount * 2; + out << " " << methodCount << ", " << (methodCount ? enumStart : 0) << ", // methods" << endl; + enumStart += methodCount * 5; + out << " " << propertyCount << ", " << (propertyCount ? enumStart : 0) << ", // properties" << endl; + enumStart += propertyCount * 3; + out << " " << enumCount << ", " << (enumCount ? enumStart : 0) + << ", // enums/sets" << endl; + out << endl; + + if (classInfoCount) { + out << " // classinfo: key, value" << endl; + stringData += " \""; + for (int i = 0; i < classInfoCount; ++i) { + QMetaClassInfo classInfo = mo->classInfo(i + mo->classInfoOffset()); + out << " "; + addString(classInfo.name(), stringData); + addString(classInfo.value(), stringData); + out << endl; + } + stringData += "\"\n"; + out << endl; + } + if (methodCount) { + out << " // signals: signature, parameters, type, tag, flags" << endl; + stringData += " \""; + for (int i = 0; i < methodCount; ++i) { + const QMetaMethod signal(mo->method(i + mo->methodOffset())); + if (signal.methodType() != QMetaMethod::Signal) + continue; + out << " "; + addString(signal.signature(), stringData); + addString(joinParameterNames(signal.parameterNames()), stringData); + addString(signal.typeName(), stringData); + addString(signal.tag(), stringData); + out << (AccessProtected | signal.attributes() | MemberSignal) << "," << endl; + } + stringData += "\"\n"; + out << endl; + + out << " // slots: signature, parameters, type, tag, flags" << endl; + stringData += " \""; + for (int i = 0; i < methodCount; ++i) { + const QMetaMethod slot(mo->method(i + mo->methodOffset())); + if (slot.methodType() != QMetaMethod::Slot) + continue; + out << " "; + addString(slot.signature(), stringData); + addString(joinParameterNames(slot.parameterNames()), stringData); + addString(slot.typeName(), stringData); + addString(slot.tag(), stringData); + out << (0x01 | slot.attributes() | MemberSlot) << "," << endl; + } + stringData += "\"\n"; + out << endl; + } + if (propertyCount) { + out << " // properties: name, type, flags" << endl; + stringData += " \""; + for (int i = 0; i < propertyCount; ++i) { + QMetaProperty property = mo->property(i + mo->propertyOffset()); + out << " "; + addString(property.name(), stringData); + addString(property.typeName(), stringData); + + uint flags = 0; + uint vartype = property.type(); + if (vartype != QVariant::Invalid && vartype != QVariant::UserType) + flags = vartype << 24; + else if (QByteArray(property.typeName()) == "QVariant") + flags |= 0xff << 24; + + if (property.isReadable()) + flags |= Readable; + if (property.isWritable()) + flags |= Writable; + if (property.isEnumType()) + flags |= EnumOrFlag; + if (property.isDesignable()) + flags |= Designable; + if (property.isScriptable()) + flags |= Scriptable; + if (property.isStored()) + flags |= Stored; + if (property.isEditable()) + flags |= Editable; + + out << "0x" << QString::number(flags, 16).rightJustified(8, '0') << ", \t\t // " << property.typeName() << " " << property.name(); + out << endl; + } + stringData += "\"\n"; + out << endl; + } + + QByteArray enumStringData; + if (enumCount) { + out << " // enums: name, flags, count, data" << endl; + enumStringData += " \""; + enumStart += enumCount * 4; + for (int i = 0; i < enumCount; ++i) { + QMetaEnum enumerator = mo->enumerator(i + mo->enumeratorOffset()); + out << " "; + addString(enumerator.name(), enumStringData); + out << (enumerator.isFlag() ? "0x1" : "0x0") << ", " << enumerator.keyCount() << ", " << enumStart << ", " << endl; + enumStart += enumerator.keyCount() * 2; + } + enumStringData += "\"\n"; + out << endl; + + out << " // enum data: key, value" << endl; + for (int i = 0; i < enumCount; ++i) { + enumStringData += " \""; + QMetaEnum enumerator = mo->enumerator(i + mo->enumeratorOffset()); + for (int j = 0; j < enumerator.keyCount(); ++j) { + out << " "; + addString(enumerator.key(j), enumStringData); + if (nameSpace.isEmpty()) + out << className << "::"; + else + out << nameSpace << "::"; + out << enumerator.key(j) << "," << endl; + } + enumStringData += "\"\n"; + } + out << endl; + } + out << " 0 // eod" << endl; + out << "};" << endl; + out << endl; + + QByteArray stringGenerator; + + if (!nameSpace.isEmpty()) { + static bool firstStringData = true; + if (firstStringData) { // print enums only once + firstStringData = false; + if (!enumStringData.isEmpty()) { + // Maximum string length supported is 64K + int maxStringLength = 65535; + if (enumStringData.size() < maxStringLength) { + out << "static const char qt_meta_enumstringdata_" << nameSpace << "[] = {" << endl; + out << enumStringData << endl; + out << "};" << endl; + out << endl; + } else { + // split the string into fragments of 64k + int fragments = (enumStringData.size() / maxStringLength); + fragments += (enumStringData.size() % maxStringLength) ? 1 : 0; + int i, index; + // define the fragments (qt_meta_enumstringdata_<nameSpace>fragment#) + for (i = 0 , index = 0; i < fragments; i++, index += maxStringLength) { + out << "static const char qt_meta_enumstringdata_" << nameSpace << "fragment"<< QString::number(i) << "[] = {" << endl; + QByteArray fragment = enumStringData.mid(index, maxStringLength); + if (!(fragment[0] == ' ' || fragment[0] == '\n' || fragment[0] == '\"')) + out << "\""; + out << fragment; + int endIx = fragment.size() - 1; + if (!(fragment[endIx] == ' ' || fragment[endIx] == '\n' || fragment[endIx] == '\"' || fragment[endIx] == '\0')) + out << "\"" << endl; + else + out << endl; + out << "};" << endl; + } + // original array definition, size will be the combined size of the arrays defined above + out << "static char qt_meta_enumstringdata_" << nameSpace << "[" << endl; + for (i = 0; i < fragments; i++, index += maxStringLength) { + out << " "; + if (i) + out << "+ "; + out << "sizeof(qt_meta_enumstringdata_" << nameSpace << "fragment"<< QString::number(i) <<")" << endl; + } + out << "] = {0};" << endl << endl; + // this class will initializes the original array in constructor + out << "class qt_meta_enumstringdata_" << nameSpace << "_init " << endl <<"{" <<endl; + out << "public:"<<endl; + out << " qt_meta_enumstringdata_" << nameSpace << "_init() " << endl <<" {" <<endl; + out << " int index = 0;" << endl; + for (i = 0; i < fragments; i++, index += maxStringLength) { + out << " memcpy(qt_meta_enumstringdata_" << nameSpace << " + index, " <<"qt_meta_enumstringdata_" << nameSpace << "fragment"<< QString::number(i); + out << ", sizeof(qt_meta_enumstringdata_" << nameSpace << "fragment"<< QString::number(i) <<") - 1);" << endl; + out << " index += sizeof(qt_meta_enumstringdata_" << nameSpace << "fragment"<< QString::number(i) <<") - 1;" << endl; + } + out << " }" << endl << "};" << endl; + // a global variable of the class + out << "static qt_meta_enumstringdata_" << nameSpace << "_init qt_meta_enumstringdata_" << nameSpace << "_init_instance;" << endl << endl; + } + } + } + stringGenerator = "qt_meta_stringdata_" + qualifiedClassName.replace(':','_') + "()"; + out << "static const char *" << stringGenerator << " {" << endl; + QList<QByteArray> splitStrings; + + // workaround for compilers that can't handle string literals longer than 64k + int splitCount = 0; + do { + int lastNewline = stringData.lastIndexOf('\n', 64000); + QByteArray splitString = stringData.left(lastNewline); + + splitStrings << splitString; + out << " static const char stringdata" << splitCount << "[] = {" << endl; + out << " \"" << splitString << endl; + out << " };" << endl; + stringData = stringData.mid(lastNewline + 1); + if (stringData.startsWith(" \"")) + stringData = stringData.mid(5); + ++splitCount; + } while (!stringData.isEmpty()); + + out << " static char data["; + for (int i = 0; i < splitCount; ++i) { + out << "sizeof(stringdata" << i << ") + "; + } + if (!enumStringData.isEmpty()) { + out << "sizeof(qt_meta_enumstringdata_" << nameSpace << ")"; + } else { + out << "0"; + } + out << "];" << endl; + out << " if (!data[0]) {" << endl; + out << " int index = 0;" << endl; + + int dataIndex = 0; + for (int i = 0; i < splitCount; ++i) { + out << " memcpy(data + index"; + out << ", stringdata" << i << ", sizeof(stringdata" << i << ") - 1);" << endl; + out << " index += sizeof(stringdata" << i << ") - 1;" << endl; + dataIndex += splitStrings.at(i).length(); + } + if (!enumStringData.isEmpty()) { + out << " memcpy(data + index, qt_meta_enumstringdata_" << nameSpace << ", sizeof(qt_meta_enumstringdata_" << nameSpace << "));" << endl; + } + out << " }" << endl; + out << endl; + out << " return data;" << endl; + out << "};" << endl; + out << endl; + } else { + stringData += enumStringData; + stringGenerator = "qt_meta_stringdata_" + qualifiedClassName.replace(':','_'); + out << "static const char qt_meta_stringdata_" << stringGenerator << "[] = {" << endl; + out << " \"" << stringData << endl; + out << "};" << endl; + out << endl; + } + + out << "const QMetaObject " << className << "::staticMetaObject = {" << endl; + if (category & ActiveX) + out << "{ &QWidget::staticMetaObject," << endl; + else + out << "{ &QObject::staticMetaObject," << endl; + out << stringGenerator << "," << endl; + out << "qt_meta_data_" << qualifiedClassName.replace(':','_') << " }" << endl; + out << "};" << endl; + out << endl; + + out << "void *" << className << "::qt_metacast(const char *_clname)" << endl; + out << "{" << endl; + out << " if (!_clname) return 0;" << endl; + out << " if (!strcmp(_clname, " << stringGenerator << "))" << endl; + out << " return static_cast<void*>(const_cast<" << className << "*>(this));" << endl; + if (category & ActiveX) + out << " return QAxWidget::qt_metacast(_clname);" << endl; + else + out << " return QAxObject::qt_metacast(_clname);" << endl; + out << "}" << endl; +} + +bool generateClass(QAxObject *object, const QByteArray &className, const QByteArray &nameSpace, const QByteArray &outname, ObjectCategory category) +{ + IOleControl *control = 0; + object->queryInterface(IID_IOleControl, (void**)&control); + if (control) { + category = ActiveX; + control->Release(); + } + + const QMetaObject *mo = object->metaObject(); + + if (!nameSpace.isEmpty() && !(category & NoDeclaration)) { + QFile outfile(QString::fromLatin1(nameSpace.toLower().constData()) + QLatin1String(".h")); + if (!outfile.open(QIODevice::WriteOnly | QIODevice::Text)) { + qWarning("dumpcpp: Could not open output file '%s'", qPrintable(outfile.fileName())); + return false; + } + QTextStream out(&outfile); + + out << "/****************************************************************************" << endl; + out << "**" << endl; + out << "** Namespace " << nameSpace << " generated by dumpcpp" << endl; + out << "**" << endl; + out << "****************************************************************************/" << endl; + out << endl; + + writeHeader(out, nameSpace); + generateNameSpace(out, mo, nameSpace); + + // close namespace file + out << "};" << endl; + out << endl; + + out << "#endif" << endl; + out << endl; + } + + if (!(category & NoDeclaration)) { + QFile outfile(QString::fromLatin1(outname.constData()) + QLatin1String(".h")); + if (!outfile.open(QIODevice::WriteOnly | QIODevice::Text)) { + qWarning("dumpcpp: Could not open output file '%s'", qPrintable(outfile.fileName())); + return false; + } + QTextStream out(&outfile); + + out << "/****************************************************************************" << endl; + out << "**" << endl; + out << "** Class declaration generated by dumpcpp" << endl; + out << "**" << endl; + out << "****************************************************************************/" << endl; + out << endl; + + out << "#include <qdatetime.h>" << endl; + if (category & ActiveX) + out << "#include <qaxwidget.h>" << endl; + else + out << "#include <qaxobject.h>" << endl; + out << endl; + + out << "struct IDispatch;" << endl, + out << endl; + + if (!nameSpace.isEmpty()) { + out << "#include \"" << nameSpace.toLower() << ".h\"" << endl; + out << endl; + out << "namespace " << nameSpace << " {" << endl; + } + + generateClassDecl(out, object->control(), mo, className, nameSpace, category); + + if (!nameSpace.isEmpty()) { + out << endl; + out << "};" << endl; + } + } + + if (!(category & (NoMetaObject|NoImplementation))) { + QFile outfile(QString::fromLatin1(outname.constData()) + QLatin1String(".cpp")); + if (!outfile.open(QIODevice::WriteOnly | QIODevice::Text)) { + qWarning("dumpcpp: Could not open output file '%s'", qPrintable(outfile.fileName())); + return false; + } + QTextStream out(&outfile); + + out << "#include <qmetaobject.h>" << endl; + out << "#include \"" << outname << ".h\"" << endl; + out << endl; + + if (!nameSpace.isEmpty()) { + out << "using namespace " << nameSpace << ";" << endl; + out << endl; + } + + generateClassImpl(out, mo, className, nameSpace, category); + } + + return true; +} + +bool generateTypeLibrary(const QByteArray &typeLib, const QByteArray &outname, ObjectCategory category) +{ + QString typeLibFile(QString::fromLatin1(typeLib.constData())); + typeLibFile = typeLibFile.replace(QLatin1Char('/'), QLatin1Char('\\')); + QString cppFile(QString::fromLatin1(outname.constData())); + + ITypeLib *typelib; + LoadTypeLibEx(reinterpret_cast<const wchar_t *>(typeLibFile.utf16()), REGKIND_NONE, &typelib); + if (!typelib) { + qWarning("dumpcpp: loading '%s' as a type library failed", qPrintable(typeLibFile)); + return false; + } + + QString libName; + BSTR nameString; + typelib->GetDocumentation(-1, &nameString, 0, 0, 0); + libName = QString::fromUtf16((const ushort *)nameString); + SysFreeString(nameString); + if (!nameSpace.isEmpty()) + libName = QString(nameSpace); + + QString libVersion(QLatin1String("1.0")); + + TLIBATTR *tlibattr = 0; + typelib->GetLibAttr(&tlibattr); + if (tlibattr) { + libVersion = QString::fromLatin1("%1.%2").arg(tlibattr->wMajorVerNum).arg(tlibattr->wMinorVerNum); + typelib->ReleaseTLibAttr(tlibattr); + } + + if (cppFile.isEmpty()) + cppFile = libName.toLower(); + + if (cppFile.isEmpty()) { + qWarning("dumpcpp: no output filename provided, and cannot deduce output filename"); + return false; + } + + QMetaObject *namespaceObject = qax_readEnumInfo(typelib, 0); + + QFile implFile(cppFile + QLatin1String(".cpp")); + QTextStream implOut(&implFile); + if (!(category & (NoMetaObject|NoImplementation))) { + if (!implFile.open(QIODevice::WriteOnly | QIODevice::Text)) { + qWarning("dumpcpp: Could not open output file '%s'", qPrintable(implFile.fileName())); + return false; + } + + implOut << "/****************************************************************************" << endl; + implOut << "**" << endl; + implOut << "** Metadata for " << libName << " generated by dumpcpp from type library" << endl; + implOut << "** " << typeLibFile << endl; + implOut << "**" << endl; + implOut << "****************************************************************************/" << endl; + implOut << endl; + + implOut << "#define QAX_DUMPCPP_" << libName.toUpper() << "_NOINLINES" << endl; + + implOut << "#include \"" << cppFile << ".h\"" << endl; + implOut << endl; + implOut << "using namespace " << libName << ";" << endl; + implOut << endl; + } + + QFile declFile(cppFile + QLatin1String(".h")); + QTextStream declOut(&declFile); + QByteArray classes; + QTextStream classesOut(&classes, QIODevice::WriteOnly); + QByteArray inlines; + QTextStream inlinesOut(&inlines, QIODevice::WriteOnly); + + QMap<QByteArray, QList<QByteArray> > namespaces; + + if(!(category & NoDeclaration)) { + if (!declFile.open(QIODevice::WriteOnly | QIODevice::Text)) { + qWarning("dumpcpp: Could not open output file '%s'", qPrintable(declFile.fileName())); + return false; + } + + declOut << "/****************************************************************************" << endl; + declOut << "**" << endl; + declOut << "** Namespace " << libName << " generated by dumpcpp from type library" << endl; + declOut << "** " << typeLibFile << endl; + declOut << "**" << endl; + declOut << "****************************************************************************/" << endl; + declOut << endl; + + writeHeader(declOut, libName.toLatin1()); + + UINT typeCount = typelib->GetTypeInfoCount(); + if (declFile.isOpen()) { + declOut << endl; + declOut << "// Referenced namespace" << endl; + for (UINT index = 0; index < typeCount; ++index) { + ITypeInfo *typeinfo = 0; + typelib->GetTypeInfo(index, &typeinfo); + if (!typeinfo) + continue; + + TYPEATTR *typeattr; + typeinfo->GetTypeAttr(&typeattr); + if (!typeattr) { + typeinfo->Release(); + continue; + } + + TYPEKIND typekind; + typelib->GetTypeInfoType(index, &typekind); + + QMetaObject *metaObject = 0; + + // trigger meta object to collect references to other type libraries + switch (typekind) { + case TKIND_COCLASS: + if (category & ActiveX) + metaObject = qax_readClassInfo(typelib, typeinfo, &QWidget::staticMetaObject); + else + metaObject = qax_readClassInfo(typelib, typeinfo, &QObject::staticMetaObject); + break; + case TKIND_DISPATCH: + if (category & ActiveX) + metaObject = qax_readInterfaceInfo(typelib, typeinfo, &QWidget::staticMetaObject); + else + metaObject = qax_readInterfaceInfo(typelib, typeinfo, &QObject::staticMetaObject); + break; + case TKIND_RECORD: + case TKIND_ENUM: + case TKIND_INTERFACE: // only for forward declarations + { + QByteArray className; + BSTR bstr; + if (S_OK != typeinfo->GetDocumentation(-1, &bstr, 0, 0, 0)) + break; + className = QString::fromUtf16((const ushort *)bstr).toLatin1(); + SysFreeString(bstr); + switch (typekind) { + case TKIND_RECORD: + className = "struct " + className; + break; + case TKIND_ENUM: + className = "enum " + className; + break; + default: + break; + } + namespaces[libName.toLatin1()].append(className); + if (!qax_qualified_usertypes.contains(className)) + qax_qualified_usertypes << className; + } + break; + default: + break; + } + + delete metaObject; + typeinfo->ReleaseTypeAttr(typeattr); + typeinfo->Release(); + } + + for (int i = 0; i < qax_qualified_usertypes.count(); ++i) { + QByteArray refType = qax_qualified_usertypes.at(i); + QByteArray refTypeLib; + if (refType.contains("::")) { + refTypeLib = refType; + refType = refType.mid(refType.lastIndexOf("::") + 2); + if (refTypeLib.contains(' ')) { + refType = refTypeLib.left(refTypeLib.indexOf(' ')) + ' ' + refType; + } + refTypeLib = refTypeLib.left(refTypeLib.indexOf("::")); + refTypeLib = refTypeLib.mid(refTypeLib.lastIndexOf(' ') + 1); + namespaces[refTypeLib].append(refType); + } else { + namespaces[libName.toLatin1()].append(refType); + } + } + + QList<QByteArray> keys = namespaces.keys(); + for (int n = 0; n < keys.count(); ++n) { + QByteArray nspace = keys.at(n); + if (QString::fromLatin1(nspace.constData()) != libName) { + declOut << "namespace " << nspace << " {" << endl; + QList<QByteArray> classList = namespaces.value(nspace); + for (int c = 0; c < classList.count(); ++c) { + QByteArray className = classList.at(c); + if (className.contains(' ')) { + declOut << " " << className << ";" << endl; + namespaceForType.insert(className.mid(className.indexOf(' ') + 1), nspace); + } else { + declOut << " class " << className << ";" << endl; + namespaceForType.insert(className, nspace); + namespaceForType.insert(className + "*", nspace); + } + } + declOut << "}" << endl << endl; + } + } + + declOut << endl; + } + generateNameSpace(declOut, namespaceObject, libName.toLatin1()); + + QList<QByteArray> classList = namespaces.value(libName.toLatin1()); + if (classList.count()) + declOut << "// forward declarations" << endl; + for (int c = 0; c < classList.count(); ++c) { + QByteArray className = classList.at(c); + if (className.contains(' ')) { + declOut << " " << className << ";" << endl; + namespaceForType.insert(className.mid(className.indexOf(' ') + 1), libName.toLatin1()); + } else { + declOut << " class " << className << ";" << endl; + namespaceForType.insert(className, libName.toLatin1()); + namespaceForType.insert(className + "*", libName.toLatin1()); + } + } + + declOut << endl; + } + + QList<QByteArray> subtypes; + + UINT typeCount = typelib->GetTypeInfoCount(); + for (UINT index = 0; index < typeCount; ++index) { + ITypeInfo *typeinfo = 0; + typelib->GetTypeInfo(index, &typeinfo); + if (!typeinfo) + continue; + + TYPEATTR *typeattr; + typeinfo->GetTypeAttr(&typeattr); + if (!typeattr) { + typeinfo->Release(); + continue; + } + + TYPEKIND typekind; + typelib->GetTypeInfoType(index, &typekind); + + uint object_category = category; + if (!(typeattr->wTypeFlags & TYPEFLAG_FCANCREATE)) + object_category |= SubObject; + else if (typeattr->wTypeFlags & TYPEFLAG_FCONTROL) + object_category |= ActiveX; + + QMetaObject *metaObject = 0; + QUuid guid(typeattr->guid); + + if (!(object_category & ActiveX)) { + QSettings settings(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes\\CLSID\\") + guid.toString(), QSettings::NativeFormat); + if (settings.childGroups().contains(QLatin1String("Control"))) { + object_category |= ActiveX; + object_category &= ~SubObject; + } + } + + switch (typekind) { + case TKIND_COCLASS: + if (object_category & ActiveX) + metaObject = qax_readClassInfo(typelib, typeinfo, &QWidget::staticMetaObject); + else + metaObject = qax_readClassInfo(typelib, typeinfo, &QObject::staticMetaObject); + break; + case TKIND_DISPATCH: + if (object_category & ActiveX) + metaObject = qax_readInterfaceInfo(typelib, typeinfo, &QWidget::staticMetaObject); + else + metaObject = qax_readInterfaceInfo(typelib, typeinfo, &QObject::staticMetaObject); + break; + case TKIND_INTERFACE: // only stub + { + QByteArray className; + BSTR bstr; + if (S_OK != typeinfo->GetDocumentation(-1, &bstr, 0, 0, 0)) + break; + className = QString::fromUtf16((const ushort *)bstr).toLatin1(); + SysFreeString(bstr); + + declOut << "// stub for vtable-only interface" << endl; + declOut << "class " << className << " : public QAxObject {};" << endl << endl; + } + break; + default: + break; + } + + if (metaObject) { + currentTypeInfo = typeinfo; + QByteArray className(metaObject->className()); + if (!(typeattr->wTypeFlags & TYPEFLAG_FDUAL) + && (metaObject->propertyCount() - metaObject->propertyOffset()) == 1 + && className.contains("Events")) { + declOut << "// skipping event interface " << className << endl << endl; + } else { + if (declFile.isOpen()) { + if (typeattr->wTypeFlags & TYPEFLAG_FLICENSED) + object_category |= Licensed; + if (typekind == TKIND_COCLASS) { // write those later... + generateClassDecl(classesOut, guid.toString(), metaObject, className, libName.toLatin1(), (ObjectCategory)(object_category|NoInlines)); + classesOut << endl; + } else { + generateClassDecl(declOut, guid.toString(), metaObject, className, libName.toLatin1(), (ObjectCategory)(object_category|NoInlines)); + declOut << endl; + } + subtypes << className; + generateClassDecl(inlinesOut, guid.toString(), metaObject, className, libName.toLatin1(), (ObjectCategory)(object_category|OnlyInlines)); + inlinesOut << endl; + } + if (implFile.isOpen()) { + generateClassImpl(implOut, metaObject, className, libName.toLatin1(), (ObjectCategory)object_category); + implOut << endl; + } + } + currentTypeInfo = 0; + } + + delete metaObject; + + typeinfo->ReleaseTypeAttr(typeattr); + typeinfo->Release(); + } + + delete namespaceObject; + + classesOut.flush(); + inlinesOut.flush(); + + if (declFile.isOpen()) { + if (classes.size()) { + declOut << "// Actual coclasses" << endl; + declOut << classes; + } + if (inlines.size()) { + declOut << "// member function implementation" << endl; + declOut << "#ifndef QAX_DUMPCPP_" << libName.toUpper() << "_NOINLINES" << endl; + declOut << inlines << endl; + declOut << "#endif" << endl << endl; + } + // close namespace + declOut << "}" << endl; + declOut << endl; + + // partial template specialization for qMetaTypeConstructHelper + for (int t = 0; t < subtypes.count(); ++t) { + QByteArray subType(subtypes.at(t)); + declOut << "template<>" << endl; + declOut << "inline void *qMetaTypeConstructHelper(const " << libName << "::" << subType << " *t)" << endl; + declOut << "{ Q_ASSERT(!t); return new " << libName << "::" << subType << "; }" << endl; + declOut << endl; + } + + declOut << "#endif" << endl; + declOut << endl; + } + + typelib->Release(); + return true; +} + +QT_END_NAMESPACE + +QT_USE_NAMESPACE + +int main(int argc, char **argv) +{ + qax_dispatchEqualsIDispatch = false; + + CoInitialize(0); + + uint category = DefaultObject; + + enum State { + Default = 0, + Output, + NameSpace, + GetTypeLib + } state; + state = Default; + + QByteArray outname; + QByteArray typeLib; + + for (int a = 1; a < argc; ++a) { + QByteArray arg(argv[a]); + const char first = arg[0]; + switch(state) { + case Default: + if (first == '-' || first == '/') { + arg = arg.mid(1); + arg.toLower(); + + if (arg == "o") { + state = Output; + } else if (arg == "n") { + state = NameSpace; + } else if (arg == "v") { + qWarning("dumpcpp: Version 1.0"); + return 0; + } else if (arg == "nometaobject") { + category |= NoMetaObject; + } else if (arg == "impl") { + category |= NoDeclaration; + } else if (arg == "decl") { + category |= NoImplementation; + } else if (arg == "donothing") { + category = DoNothing; + break; + } else if (arg == "compat") { + qax_dispatchEqualsIDispatch = true; + break; + } else if (arg == "getfile") { + state = GetTypeLib; + break; + } else if (arg == "h") { + qWarning("dumpcpp Version1.0\n\n" + "Generate a C++ namespace from a type library.\n\n" + "Usage:\n" + "dumpcpp input [-[-n <namespace>] [-o <filename>]\n\n" + " input: A type library file, type library ID, ProgID or CLSID\n\n" + "Optional parameters:\n" + " namespace: The name of the generated C++ namespace\n" + " filename: The file name (without extension) of the generated files\n" + "\n" + "Other parameters:\n" + " -nometaobject Don't generate meta object information (no .cpp file)\n" + " -impl Only generate the .cpp file\n" + " -decl Only generate the .h file\n" + " -compat Treat all coclass parameters as IDispatch\n" + "\n" + "Examples:\n" + " dumpcpp Outlook.Application -o outlook\n" + " dumpcpp {3B756301-0075-4E40-8BE8-5A81DE2426B7}\n" + "\n"); + return 0; + } + } else { + typeLib = arg; + } + break; + + case Output: + outname = arg; + state = Default; + break; + + case NameSpace: + nameSpace = arg; + state = Default; + break; + + case GetTypeLib: + typeLib = arg; + state = Default; + category = TypeLibID; + break; + default: + break; + } + } + + if (category == TypeLibID) { + QSettings settings(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes\\TypeLib\\") + + QString::fromLatin1(typeLib.constData()), QSettings::NativeFormat); + typeLib = QByteArray(); + QStringList codes = settings.childGroups(); + for (int c = 0; c < codes.count(); ++c) { + typeLib = settings.value(QLatin1String("/") + codes.at(c) + QLatin1String("/0/win32/.")).toByteArray(); + if (QFile::exists(QString::fromLatin1(typeLib))) { + break; + } + } + + if (!typeLib.isEmpty()) + fprintf(stdout, "\"%s\"\n", typeLib.data()); + return 0; + } + + if (category == DoNothing) + return 0; + + if (typeLib.isEmpty()) { + qWarning("dumpcpp: No object class or type library name provided.\n" + " Use -h for help."); + return -1; + } + + // not a file - search registry + if (!QFile::exists(QString::fromLatin1(typeLib.constData()))) { + bool isObject = false; + QSettings settings(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes"), QSettings::NativeFormat); + + // regular string and not a file - must be ProgID + if (typeLib.at(0) != '{') { + CLSID clsid; + if (CLSIDFromProgID(reinterpret_cast<const wchar_t *>(QString(QLatin1String(typeLib)).utf16()), &clsid) != S_OK) { + qWarning("dumpcpp: '%s' is not a type library and not a registered ProgID", typeLib.constData()); + return -2; + } + QUuid uuid(clsid); + typeLib = uuid.toString().toLatin1(); + isObject = true; + } + + // check if CLSID + if (!isObject) { + QVariant test = settings.value(QLatin1String("/CLSID/") + + QString::fromLatin1(typeLib.constData()) + QLatin1String("/.")); + isObject = test.isValid(); + } + + // search typelib ID for CLSID + if (isObject) + typeLib = settings.value(QLatin1String("/CLSID/") + + QString::fromLatin1(typeLib.constData()) + QLatin1String("/Typelib/.")).toByteArray(); + + // interpret input as type library ID + QString key = QLatin1String("/TypeLib/") + QLatin1String(typeLib); + settings.beginGroup(key); + QStringList versions = settings.childGroups(); + QStringList codes; + if (versions.count()) { + settings.beginGroup(QLatin1String("/") + versions.last()); + codes = settings.childGroups(); + key += QLatin1String("/") + versions.last(); + settings.endGroup(); + } + settings.endGroup(); + + for (int c = 0; c < codes.count(); ++c) { + typeLib = settings.value(key + QLatin1String("/") + codes.at(c) + QLatin1String("/win32/.")).toByteArray(); + if (QFile::exists(QString::fromLatin1(typeLib.constData()))) { + break; + } + } + } + + if (!QFile::exists(QString::fromLatin1(typeLib.constData()))) { + qWarning("dumpcpp: type library '%s' not found", typeLib.constData()); + return -2; + } + + if (!generateTypeLibrary(typeLib, outname, (ObjectCategory)category)) { + qWarning("dumpcpp: error processing type library '%s'", typeLib.constData()); + return -1; + } + + return 0; +} |