luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/qt6' into qt6-mac

This commit is contained in:
Kazunari Sekigawa 2021-12-03 18:01:06 +09:00
parent 5cfc13be71 bc26fd6333
commit 10c6dbf5af
428 changed files with 21628 additions and 3126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
scripts/mkqtdecl.sh
View File

@ -7,13 +7,14 @@
# framework is based on a C++ parser and a configuration file that specifies details
# about the translation.
#
# By default, the script will take the Qt headers from /opt/qt/4.6.3 and /opt/qt/5.5.1
# for Qt4 and Qt5 respectively.
# By default, the script will take the Qt headers from /opt/qt/4.6.3, /opt/qt/5.5.1
# and /opt/qt/6.2.1 for Qt4, Qt5 and Qt6 respectively.
#
# Call it from project level as
#
# ./scripts/mkqtdecl.sh -update # Qt4
# ./scripts/mkqtdecl.sh -update -qt5 # Qt5
# ./scripts/mkqtdecl.sh -update -qt6 # Qt6
#
# For more options see
#
@ -43,14 +44,18 @@ diff=0
reuse=0
qt="/opt/qt/4.6.3/include"
qt5="/opt/qt/5.5.1/include"
qt6="/opt/qt/6.2.1/include"
inst_dir_common=`pwd`/scripts/mkqtdecl_common
inst_dir4=`pwd`/scripts/mkqtdecl4
inst_dir5=`pwd`/scripts/mkqtdecl5
inst_dir6=`pwd`/scripts/mkqtdecl6
src_dir=`pwd`/src
src_name4=gsiqt/qt4
src_name5=gsiqt/qt5
src_name6=gsiqt/qt6
qt_mods4="QtCore QtGui QtDesigner QtNetwork QtSql QtXml QtUiTools"
qt_mods5="QtCore QtGui QtWidgets QtDesigner QtNetwork QtPrintSupport QtSql QtSvg QtXml QtXmlPatterns QtMultimedia QtUiTools"
qt_mods6="QtCore QtGui QtWidgets QtNetwork QtPrintSupport QtSql QtSvg QtXml QtMultimedia QtUiTools QtCore5Compat"
src_name=$src_name4
inst_dir=$inst_dir4
@ -73,6 +78,7 @@ while [ "$1" != "" ]; do
echo " mkqtdecl.sh -diff Show differences - don't produce and don't synchronize"
echo " mkqtdecl.sh -qt path_to_include Use the specified include path"
echo " mkqtdecl.sh -qt5 Use setup for Qt 5.x (use before -qt)"
echo " mkqtdecl.sh -qt6 Use setup for Qt 6.x (use before -qt)"
echo " mkqtdecl.sh -reuse Don't parse C++ container again"
exit 0
;;
@ -102,6 +108,13 @@ while [ "$1" != "" ]; do
qt_mods="$qt_mods5"
src_name="$src_name5"
;;
-qt6)
qt="$qt6"
work_dir="mkqtdecl6.tmp"
inst_dir="$inst_dir6"
qt_mods="$qt_mods6"
src_name="$src_name6"
;;
*)
echo "*** ERROR: unknown command option $a"
exit 1
@ -181,7 +194,7 @@ if [ $update != 0 ]; then
echo "Running gcc preprocessor .."
# By using -D_GCC_LIMITS_H_ we make the gcc not include constants such as ULONG_MAX which will
# remain as such. This way the generated code is more generic.
gcc -std=gnu++98 -I$qt -fPIC -D_GCC_LIMITS_H_ -E -o allofqt.x allofqt.cpp
gcc -std=c++17 -I$qt -fPIC -D_GCC_LIMITS_H_ -E -o allofqt.x allofqt.cpp
echo "Stripping hash lines .."
egrep -v '^#' <allofqt.x >allofqt.e

6
scripts/mkqtdecl4/mkqtdecl.conf
View File

@ -229,7 +229,7 @@ drop_method "QObject", /QObject::userData/ # QObjectUserData not available
drop_method "QChildEvent", /QChildEvent::child/ # provided through a special implementation
drop_method "QFile", /QFile::setDecodingFunction/ # uses callbacks
drop_method "QFile", /QFile::setEncodingFunction/ # uses callbacks
drop_method "QFile", /QFile::open.*IO_FILE/ # uses internal struct
drop_method "QFile", /QFile::open.*FILE/ # uses internal struct
drop_method "QPrinter", /QPrinter::printerSelectionOption/ # not available on WIN
drop_method "QPrinter", /QPrinter::setPrinterSelectionOption/ # not available on WIN
drop_method "QSessionManager", /QSessionManager::handle/ # not available on WIN
@ -263,8 +263,8 @@ drop_method "QFile", /QFile::decodeName\(const\s+QByteArray/ # clashes with cons
drop_method "QTemporaryFile", /QTemporaryFile::open\(int/ # unsupported file descriptor
drop_method "QTextStream", /QTextStream::QTextStream\(QByteArray/ # clashes with QString variant
drop_method "QTextStream", /QTextStream::QTextStream\(const\s*QByteArray/ # clashes with QString variant
drop_method "QTextStream", /QTextStream::QTextStream\(.*_IO_FILE/ # unsupported IO_FILE
drop_method "QTextStream", /QTextStream::QTextStream\(.*_IO_FILE/ # unsupported IO_FILE
drop_method "QTextStream", /QTextStream::QTextStream\(.*FILE/ # unsupported FILE
drop_method "QTextStream", /QTextStream::QTextStream\(.*FILE/ # unsupported FILE
drop_method "", /::operator\s*>>\(QTextStream\s*&/ # implemented through read
drop_method "", /::operator\s*<<\(QTextStream\s*&/ # implemented through put
drop_method "QTextStream", /::operator\s*>>/ # implemented through read

9
scripts/mkqtdecl5/mkqtdecl.conf
View File

@ -30,6 +30,9 @@ drop_method :all_classes, /::qt_check_for_QOBJECT_macro/ # don't include in API!
drop_method :all_classes, /::devType\(/ # not required
drop_method :all_classes, /::data_ptr/ # no private data
drop_method :all_classes, /::x11/ # no X11 stuff
drop_method :all_classes, /\(.*&&.*\)/ # no move semantics
drop_method :all_classes, /.*\s+&&$/ # no move semantics
drop_method :all_classes, /\(.*std::initializer_list.*\)/ # no brace initialization
rename :all_classes, /::create\(/, "qt_create" # clashes with GSI/Ruby
rename :all_classes, /::destroy\(/, "qt_destroy" # clashes with GSI/Ruby
@ -289,7 +292,7 @@ drop_method "QObject", /QObject::setUserData/ # QObjectUserData not available
drop_method "QObject", /QObject::userData/ # QObjectUserData not available
drop_method "QFile", /QFile::setDecodingFunction/ # uses callbacks
drop_method "QFile", /QFile::setEncodingFunction/ # uses callbacks
drop_method "QFile", /QFile::open.*IO_FILE/ # uses internal struct
drop_method "QFile", /QFile::open.*FILE/ # uses internal struct
drop_method "QFileInfo", /QFileInfo::QFileInfo\(QFileInfoPrivate\s+\*/ # uses internal struct
drop_method "QPrinter", /QPrinter::printerSelectionOption/ # not available on WIN
drop_method "QPrinter", /QPrinter::setPrinterSelectionOption/ # not available on WIN
@ -330,8 +333,8 @@ drop_method "QFile", /QFile::decodeName\(const\s+QByteArray/ # clashes with cons
drop_method "QTemporaryFile", /QTemporaryFile::open\(int/ # unsupported file descriptor
drop_method "QTextStream", /QTextStream::QTextStream\(QByteArray/ # clashes with QString variant
drop_method "QTextStream", /QTextStream::QTextStream\(const\s*QByteArray/ # clashes with QString variant
drop_method "QTextStream", /QTextStream::QTextStream\(.*_IO_FILE/ # unsupported IO_FILE
drop_method "QTextStream", /QTextStream::QTextStream\(.*_IO_FILE/ # unsupported IO_FILE
drop_method "QTextStream", /QTextStream::QTextStream\(.*FILE/ # unsupported FILE
drop_method "QTextStream", /QTextStream::QTextStream\(.*FILE/ # unsupported FILE
drop_method "", /::operator\s*>>\(QTextStream\s*&/ # implemented through read
drop_method "", /::operator\s*<<\(QTextStream\s*&/ # implemented through put
drop_method "QTextStream", /::operator\s*>>/ # implemented through read

357
scripts/mkqtdecl6/QtCore/allofqt.cpp Normal file
View File

@ -0,0 +1,357 @@
#include <QtCore/QAbstractAnimation>
#include <QtCore/QAbstractEventDispatcher>
#include <QtCore/QAbstractItemModel>
#include <QtCore/QAbstractListModel>
#include <QtCore/QAbstractNativeEventFilter>
#include <QtCore/QAbstractProxyModel>
#include <QtCore/QAbstractTableModel>
#include <QtCore/QAdoptSharedDataTag>
#include <QtCore/QAnimationDriver>
#include <QtCore/QAnimationGroup>
#include <QtCore/QAnyStringView>
#include <QtCore/QArgument>
#include <QtCore/QArrayData>
#include <QtCore/QArrayDataPointer>
#include <QtCore/QAssociativeConstIterator>
#include <QtCore/QAssociativeIterable>
#include <QtCore/QAssociativeIterator>
#include <QtCore/QAtomicInt>
#include <QtCore/QAtomicInteger>
#include <QtCore/QAtomicPointer>
#include <QtCore/QBaseIterator>
#include <QtCore/QBasicMutex>
#include <QtCore/QBasicTimer>
#include <QtCore/QBasicUtf8StringView>
#include <QtCore/QBEInteger>
#include <QtCore/QBigEndianStorageType>
#include <QtCore/QBindable>
#include <QtCore/QBindingStatus>
#include <QtCore/QBindingStorage>
#include <QtCore/QBitArray>
#include <QtCore/QBitRef>
#include <QtCore/QBuffer>
#include <QtCore/QByteArray>
#include <QtCore/QByteArrayAlgorithms>
#include <QtCore/QByteArrayList>
#include <QtCore/QByteArrayListIterator>
#include <QtCore/QByteArrayMatcher>
#include <QtCore/QByteArrayView>
#include <QtCore/QCache>
#include <QtCore/QCalendar>
#include <QtCore/QCborArray>
#include <QtCore/QCborError>
#include <QtCore/QCborMap>
#include <QtCore/QCborParserError>
#include <QtCore/QCborStreamReader>
#include <QtCore/QCborStreamWriter>
#include <QtCore/QCborValue>
#include <QtCore/QCborValueRef>
#include <QtCore/QChar>
#include <QtCore/QChildEvent>
#include <QtCore/QCollator>
#include <QtCore/QCollatorSortKey>
#include <QtCore/QCommandLineOption>
#include <QtCore/QCommandLineParser>
#include <QtCore/QConcatenateTablesProxyModel>
#include <QtCore/QConstIterator>
#include <QtCore/QConstOverload>
#include <QtCore/QContiguousCache>
#include <QtCore/QContiguousCacheData>
#include <QtCore/QContiguousCacheTypedData>
#include <QtCore/QCoreApplication>
#include <QtCore/QCryptographicHash>
#include <QtCore/QDataStream>
#include <QtCore/QDate>
#include <QtCore/QDateTime>
#include <QtCore/QDeadlineTimer>
#include <QtCore/QDebug>
#include <QtCore/QDebugStateSaver>
#include <QtCore/QDeferredDeleteEvent>
#include <QtCore/QDir>
#include <QtCore/QDirIterator>
#include <QtCore/QDynamicPropertyChangeEvent>
#include <QtCore/QEasingCurve>
#include <QtCore/QElapsedTimer>
#include <QtCore/QEnableSharedFromThis>
#include <QtCore/QEvent>
#include <QtCore/QEventLoop>
#include <QtCore/QEventLoopLocker>
#include <QtCore/QException>
#include <QtCore/QExplicitlySharedDataPointer>
#include <QtCore/QFactoryInterface>
#include <QtCore/QFile>
#include <QtCore/QFileDevice>
#include <QtCore/QFileInfo>
#include <QtCore/QFileInfoList>
#include <QtCore/QFileSelector>
#include <QtCore/QFileSystemWatcher>
#include <QtCore/QFlag>
#include <QtCore/QFlags>
#include <QtCore/QFloat16>
#include <QtCore/QFunctionPointer>
#include <QtCore/QFuture>
#include <QtCore/QFutureInterface>
#include <QtCore/QFutureInterfaceBase>
#include <QtCore/QFutureIterator>
#include <QtCore/QFutureSynchronizer>
#include <QtCore/QFutureWatcher>
#include <QtCore/QFutureWatcherBase>
#include <QtCore/QGenericArgument>
#include <QtCore/QGenericReturnArgument>
#include <QtCore/QGlobalStatic>
#include <QtCore/QHash>
#include <QtCore/QHashDummyValue>
#include <QtCore/QHashFunctions>
#include <QtCore/QHashIterator>
#include <QtCore/QHashSeed>
#include <QtCore/QIdentityProxyModel>
#include <QtCore/QIncompatibleFlag>
#include <QtCore/QIntegerForSize>
#include <QtCore/QInternal>
#include <QtCore/QIODevice>
#include <QtCore/QIODeviceBase>
#include <QtCore/QItemSelection>
#include <QtCore/QItemSelectionModel>
#include <QtCore/QItemSelectionRange>
#include <QtCore/QIterable>
#include <QtCore/QIterator>
#include <QtCore/QJniEnvironment>
#include <QtCore/QJniObject>
#include <QtCore/QJsonArray>
#include <QtCore/QJsonDocument>
#include <QtCore/QJsonObject>
#include <QtCore/QJsonParseError>
#include <QtCore/QJsonValue>
#include <QtCore/QJsonValueRef>
#include <QtCore/QKeyCombination>
#include <QtCore/QKeyValueIterator>
#include <QtCore/QLatin1Char>
#include <QtCore/QLatin1String>
#include <QtCore/QLEInteger>
#include <QtCore/QLibrary>
#include <QtCore/QLibraryInfo>
#include <QtCore/QLine>
#include <QtCore/QLineF>
#include <QtCore/QList>
#include <QtCore/QListIterator>
#include <QtCore/QListSpecialMethodsBase>
#include <QtCore/QLittleEndianStorageType>
#include <QtCore/QLocale>
#include <QtCore/QLockFile>
#include <QtCore/QLoggingCategory>
#include <QtCore/QMap>
#include <QtCore/QMapData>
#include <QtCore/QMapIterator>
#include <QtCore/QMargins>
#include <QtCore/QMarginsF>
#include <QtCore/QMessageAuthenticationCode>
#include <QtCore/QMessageLogContext>
#include <QtCore/QMessageLogger>
#include <QtCore/QMetaAssociation>
#include <QtCore/QMetaClassInfo>
#include <QtCore/QMetaContainer>
#include <QtCore/QMetaEnum>
#include <QtCore/QMetaMethod>
#include <QtCore/QMetaObject>
#include <QtCore/QMetaProperty>
#include <QtCore/QMetaSequence>
#include <QtCore/QMetaType>
#include <QtCore/QMethodRawArguments>
#include <QtCore/QMimeData>
#include <QtCore/QMimeDatabase>
#include <QtCore/QMimeType>
#include <QtCore/QModelIndex>
#include <QtCore/QModelIndexList>
#include <QtCore/QModelRoleData>
#include <QtCore/QModelRoleDataSpan>
#include <QtCore/QMultiHash>
#include <QtCore/QMultiHashIterator>
#include <QtCore/QMultiMap>
#include <QtCore/QMultiMapIterator>
#include <QtCore/QMutableByteArrayListIterator>
#include <QtCore/QMutableFutureIterator>
#include <QtCore/QMutableHashIterator>
#include <QtCore/QMutableListIterator>
#include <QtCore/QMutableMapIterator>
#include <QtCore/QMutableMultiHashIterator>
#include <QtCore/QMutableMultiMapIterator>
#include <QtCore/QMutableSetIterator>
#include <QtCore/QMutex>
#include <QtCore/QMutexLocker>
#include <QtCore/QNoDebug>
#include <QtCore/QNonConstOverload>
#include <QtCore/QObject>
#include <QtCore/QObjectBindableProperty>
#include <QtCore/QObjectCleanupHandler>
#include <QtCore/QObjectData>
#include <QtCore/QObjectList>
#include <QtCore/QOperatingSystemVersion>
#include <QtCore/QPair>
#include <QtCore/QParallelAnimationGroup>
#include <QtCore/QPartialOrdering>
#include <QtCore/QPauseAnimation>
#include <QtCore/QPersistentModelIndex>
#include <QtCore/QPluginLoader>
#include <QtCore/QPluginMetaData>
#include <QtCore/QPoint>
#include <QtCore/QPointer>
#include <QtCore/QPointF>
#include <QtCore/QProcess>
#include <QtCore/QProcessEnvironment>
#include <QtCore/QPromise>
#include <QtCore/QProperty>
#include <QtCore/QPropertyAlias>
#include <QtCore/QPropertyAnimation>
#include <QtCore/QPropertyBinding>
#include <QtCore/QPropertyBindingError>
#include <QtCore/QPropertyBindingPrivatePtr>
#include <QtCore/QPropertyBindingSourceLocation>
#include <QtCore/QPropertyChangeHandler>
#include <QtCore/QPropertyData>
#include <QtCore/QPropertyNotifier>
#include <QtCore/QPropertyObserver>
#include <QtCore/QPropertyObserverBase>
#include <QtCore/QPropertyProxyBindingData>
#include <QtCore/QQueue>
#include <QtCore/QRandomGenerator>
#include <QtCore/QRandomGenerator64>
#include <QtCore/QReadLocker>
#include <QtCore/QReadWriteLock>
#include <QtCore/QRect>
#include <QtCore/QRectF>
#include <QtCore/QRecursiveMutex>
#include <QtCore/QRegularExpression>
#include <QtCore/QRegularExpressionMatch>
#include <QtCore/QRegularExpressionMatchIterator>
#include <QtCore/QResource>
#include <QtCore/QReturnArgument>
#include <QtCore/QRunnable>
#include <QtCore/QSaveFile>
#include <QtCore/QScopedArrayPointer>
#include <QtCore/QScopedPointer>
#include <QtCore/QScopedPointerArrayDeleter>
#include <QtCore/QScopedPointerDeleteLater>
#include <QtCore/QScopedPointerDeleter>
#include <QtCore/QScopedPointerObjectDeleteLater>
#include <QtCore/QScopedPointerPodDeleter>
#include <QtCore/QScopedValueRollback>
#include <QtCore/QScopeGuard>
#include <QtCore/QSemaphore>
#include <QtCore/QSemaphoreReleaser>
#include <QtCore/QSequentialAnimationGroup>
#include <QtCore/QSequentialConstIterator>
#include <QtCore/QSequentialIterable>
#include <QtCore/QSequentialIterator>
#include <QtCore/QSet>
#include <QtCore/QSetIterator>
#include <QtCore/QSettings>
#include <QtCore/QSharedData>
#include <QtCore/QSharedDataPointer>
#include <QtCore/QSharedMemory>
#include <QtCore/QSharedPointer>
#include <QtCore/QSignalBlocker>
#include <QtCore/QSignalMapper>
#include <QtCore/QSize>
#include <QtCore/QSizeF>
#include <QtCore/QSocketDescriptor>
#include <QtCore/QSocketNotifier>
#include <QtCore/QSortFilterProxyModel>
#include <QtCore/QSpecialInteger>
#include <QtCore/QStack>
#include <QtCore/QStandardPaths>
#include <QtCore/QStaticByteArrayMatcherBase>
#include <QtCore/QStaticPlugin>
#include <QtCore/QStorageInfo>
#include <QtCore/QString>
#include <QtCore/QStringAlgorithms>
#include <QtCore/QStringBuilder>
#include <QtCore/QStringConverter>
#include <QtCore/QStringConverterBase>
#include <QtCore/QStringDecoder>
#include <QtCore/QStringEncoder>
#include <QtCore/QStringList>
#include <QtCore/QStringListModel>
#include <QtCore/QStringLiteral>
#include <QtCore/QStringMatcher>
#include <QtCore/QStringTokenizer>
#include <QtCore/QStringTokenizerBase>
#include <QtCore/QStringTokenizerBaseBase>
#include <QtCore/QStringView>
#include <QtCore/QSysInfo>
#include <QtCore/QSystemSemaphore>
#include <QtCore/Qt>
#include <QtCore/QTaggedIterator>
#include <QtCore/QTaggedPointer>
#include <QtCore/QtAlgorithms>
#include <QtCore/QtCborCommon>
#include <QtCore/QtCleanUpFunction>
#include <QtCore/QtCompare>
#include <QtCore/QtConfig>
#include <QtCore/QtContainerFwd>
//#include <QtCore/QtCore>
//#include <QtCore/QtCoreDepends>
#include <QtCore/QtCoreVersion>
#include <QtCore/QtDebug>
#include <QtCore/QTemporaryDir>
#include <QtCore/QTemporaryFile>
#include <QtCore/QtEndian>
#include <QtCore/QTextBoundaryFinder>
#include <QtCore/QTextStream>
#include <QtCore/QTextStreamFunction>
#include <QtCore/QTextStreamManipulator>
#include <QtCore/QtGlobal>
#include <QtCore/QThread>
#include <QtCore/QThreadPool>
#include <QtCore/QThreadStorage>
#include <QtCore/QThreadStorageData>
#include <QtCore/QTime>
#include <QtCore/QTimeLine>
#include <QtCore/QTimer>
#include <QtCore/QTimerEvent>
#include <QtCore/QTimeZone>
#include <QtCore/QtMath>
#include <QtCore/QtMessageHandler>
#include <QtCore/QtNumeric>
#include <QtCore/QtPlugin>
#include <QtCore/QtPluginInstanceFunction>
#include <QtCore/QtPluginMetaDataFunction>
#include <QtCore/QTranslator>
#include <QtCore/QTransposeProxyModel>
#include <QtCore/QTypeInfo>
#include <QtCore/QTypeInfoMerger>
#include <QtCore/QTypeRevision>
#include <QtCore/QUnhandledException>
#include <QtCore/QUntypedBindable>
#include <QtCore/QUntypedPropertyBinding>
#include <QtCore/QUntypedPropertyData>
#include <QtCore/QUrl>
#include <QtCore/QUrlQuery>
#include <QtCore/QUrlTwoFlags>
#include <QtCore/QUtf8StringView>
#include <QtCore/QUuid>
#include <QtCore/QVariant>
#include <QtCore/QVariantAnimation>
#include <QtCore/QVariantConstPointer>
#include <QtCore/QVariantHash>
#include <QtCore/QVariantList>
#include <QtCore/QVariantMap>
#include <QtCore/QVariantPointer>
#include <QtCore/QVariantRef>
#include <QtCore/QVarLengthArray>
#include <QtCore/QVector>
#include <QtCore/QVersionNumber>
#include <QtCore/QWaitCondition>
#include <QtCore/QWeakPointer>
#include <QtCore/QWinEventNotifier>
#include <QtCore/QWriteLocker>
#include <QtCore/QXmlStreamAttribute>
#include <QtCore/QXmlStreamAttributes>
#include <QtCore/QXmlStreamEntityDeclaration>
#include <QtCore/QXmlStreamEntityDeclarations>
#include <QtCore/QXmlStreamEntityResolver>
#include <QtCore/QXmlStreamNamespaceDeclaration>
#include <QtCore/QXmlStreamNamespaceDeclarations>
#include <QtCore/QXmlStreamNotationDeclaration>
#include <QtCore/QXmlStreamNotationDeclarations>
#include <QtCore/QXmlStreamReader>
#include <QtCore/QXmlStreamWriter>

29
scripts/mkqtdecl6/QtCore5Compat/allofqt.cpp Normal file
View File

@ -0,0 +1,29 @@
#include <QtCore5Compat/QBinaryJson>
#include <QtCore5Compat/QConcatenable>
#include <QtCore5Compat/QLinkedList>
#include <QtCore5Compat/QLinkedListData>
#include <QtCore5Compat/QLinkedListIterator>
#include <QtCore5Compat/QLinkedListNode>
#include <QtCore5Compat/QMutableLinkedListIterator>
#include <QtCore5Compat/QRegExp>
#include <QtCore5Compat/QStringRef>
//#include <QtCore5Compat/QtCore5Compat>
//#include <QtCore5Compat/QtCore5CompatDepends>
#include <QtCore5Compat/QtCore5CompatVersion>
#include <QtCore5Compat/QTextCodec>
#include <QtCore5Compat/QTextDecoder>
#include <QtCore5Compat/QTextEncoder>
#include <QtCore5Compat/QXmlAttributes>
#include <QtCore5Compat/QXmlContentHandler>
#include <QtCore5Compat/QXmlDeclHandler>
#include <QtCore5Compat/QXmlDefaultHandler>
#include <QtCore5Compat/QXmlDTDHandler>
#include <QtCore5Compat/QXmlEntityResolver>
#include <QtCore5Compat/QXmlErrorHandler>
#include <QtCore5Compat/QXmlInputSource>
#include <QtCore5Compat/QXmlLexicalHandler>
#include <QtCore5Compat/QXmlLocator>
#include <QtCore5Compat/QXmlNamespaceSupport>
#include <QtCore5Compat/QXmlParseException>
#include <QtCore5Compat/QXmlReader>
#include <QtCore5Compat/QXmlSimpleReader>

44
scripts/mkqtdecl6/QtDesigner/allofqt.cpp Normal file
View File

@ -0,0 +1,44 @@
#include <QtDesigner/QAbstractExtensionFactory>
#include <QtDesigner/QAbstractExtensionManager>
#include <QtDesigner/QAbstractFormBuilder>
#include <QtDesigner/QDesignerActionEditorInterface>
#include <QtDesigner/QDesignerComponents>
#include <QtDesigner/QDesignerContainerExtension>
#include <QtDesigner/QDesignerCustomWidgetCollectionInterface>
#include <QtDesigner/QDesignerCustomWidgetInterface>
#include <QtDesigner/QDesignerDnDItemInterface>
#include <QtDesigner/QDesignerDynamicPropertySheetExtension>
#include <QtDesigner/QDesignerExportWidget>
#include <QtDesigner/QDesignerExtraInfoExtension>
#include <QtDesigner/QDesignerFormEditorInterface>
#include <QtDesigner/QDesignerFormEditorPluginInterface>
#include <QtDesigner/QDesignerFormWindowCursorInterface>
#include <QtDesigner/QDesignerFormWindowInterface>
#include <QtDesigner/QDesignerFormWindowManagerInterface>
#include <QtDesigner/QDesignerFormWindowToolInterface>
#include <QtDesigner/QDesignerIntegration>
#include <QtDesigner/QDesignerIntegrationInterface>
#include <QtDesigner/QDesignerLanguageExtension>
#include <QtDesigner/QDesignerLayoutDecorationExtension>
#include <QtDesigner/QDesignerMemberSheetExtension>
#include <QtDesigner/QDesignerMetaDataBaseInterface>
#include <QtDesigner/QDesignerMetaDataBaseItemInterface>
#include <QtDesigner/QDesignerNewFormWidgetInterface>
#include <QtDesigner/QDesignerObjectInspectorInterface>
#include <QtDesigner/QDesignerOptionsPageInterface>
#include <QtDesigner/QDesignerPromotionInterface>
#include <QtDesigner/QDesignerPropertyEditorInterface>
#include <QtDesigner/QDesignerPropertySheetExtension>
#include <QtDesigner/QDesignerResourceBrowserInterface>
#include <QtDesigner/QDesignerSettingsInterface>
#include <QtDesigner/QDesignerTaskMenuExtension>
#include <QtDesigner/QDesignerWidgetBoxInterface>
#include <QtDesigner/QDesignerWidgetDataBaseInterface>
#include <QtDesigner/QDesignerWidgetDataBaseItemInterface>
#include <QtDesigner/QDesignerWidgetFactoryInterface>
#include <QtDesigner/QExtensionFactory>
#include <QtDesigner/QExtensionManager>
#include <QtDesigner/QFormBuilder>
//#include <QtDesigner/QtDesigner>
//#include <QtDesigner/QtDesignerDepends>
#include <QtDesigner/QtDesignerVersion>

225
scripts/mkqtdecl6/QtGui/allofqt.cpp Normal file
View File

@ -0,0 +1,225 @@
#include <QtGui/QAbstractFileIconProvider>
#include <QtGui/QAbstractTextDocumentLayout>
#include <QtGui/QAbstractUndoItem>
#include <QtGui/QAccessible>
#include <QtGui/QAccessibleActionInterface>
#include <QtGui/QAccessibleApplication>
#include <QtGui/QAccessibleBridge>
#include <QtGui/QAccessibleBridgePlugin>
#include <QtGui/QAccessibleEditableTextInterface>
#include <QtGui/QAccessibleEvent>
#include <QtGui/QAccessibleHyperlinkInterface>
#include <QtGui/QAccessibleImageInterface>
#include <QtGui/QAccessibleInterface>
#include <QtGui/QAccessibleObject>
#include <QtGui/QAccessiblePlugin>
#include <QtGui/QAccessibleStateChangeEvent>
#include <QtGui/QAccessibleTableCellInterface>
#include <QtGui/QAccessibleTableInterface>
#include <QtGui/QAccessibleTableModelChangeEvent>
#include <QtGui/QAccessibleTextCursorEvent>
#include <QtGui/QAccessibleTextInsertEvent>
#include <QtGui/QAccessibleTextInterface>
#include <QtGui/QAccessibleTextRemoveEvent>
#include <QtGui/QAccessibleTextSelectionEvent>
#include <QtGui/QAccessibleTextUpdateEvent>
#include <QtGui/QAccessibleValueChangeEvent>
#include <QtGui/QAccessibleValueInterface>
#include <QtGui/QAction>
#include <QtGui/QActionEvent>
#include <QtGui/QActionGroup>
#include <QtGui/QApplicationStateChangeEvent>
#include <QtGui/QBackingStore>
#include <QtGui/QBitmap>
#include <QtGui/QBrush>
#include <QtGui/QBrushData>
#include <QtGui/QBrushDataPointerDeleter>
#include <QtGui/QClipboard>
#include <QtGui/QCloseEvent>
#include <QtGui/QColor>
#include <QtGui/QColorSpace>
#include <QtGui/QColorTransform>
#include <QtGui/QConicalGradient>
#include <QtGui/QContextMenuEvent>
#include <QtGui/QCursor>
#include <QtGui/QDesktopServices>
#include <QtGui/QDoubleValidator>
#include <QtGui/QDrag>
#include <QtGui/QDragEnterEvent>
#include <QtGui/QDragLeaveEvent>
#include <QtGui/QDragMoveEvent>
#include <QtGui/QDropEvent>
#include <QtGui/QEnterEvent>
#include <QtGui/QEventPoint>
#include <QtGui/QExposeEvent>
#include <QtGui/QFileOpenEvent>
#include <QtGui/QFileSystemModel>
#include <QtGui/QFocusEvent>
#include <QtGui/QFont>
#include <QtGui/QFontDatabase>
#include <QtGui/QFontInfo>
#include <QtGui/QFontMetrics>
#include <QtGui/QFontMetricsF>
#include <QtGui/QGenericMatrix>
#include <QtGui/QGenericPlugin>
#include <QtGui/QGenericPluginFactory>
#include <QtGui/QGlyphRun>
#include <QtGui/QGradient>
#include <QtGui/QGradientStop>
#include <QtGui/QGradientStops>
#include <QtGui/QGuiApplication>
#include <QtGui/QHelpEvent>
#include <QtGui/QHideEvent>
#include <QtGui/QHoverEvent>
#include <QtGui/QIcon>
#include <QtGui/QIconDragEvent>
#include <QtGui/QIconEngine>
#include <QtGui/QIconEnginePlugin>
#include <QtGui/QImage>
#include <QtGui/QImageCleanupFunction>
#include <QtGui/QImageIOHandler>
#include <QtGui/QImageIOPlugin>
#include <QtGui/QImageReader>
#include <QtGui/QImageWriter>
#include <QtGui/QInputDevice>
#include <QtGui/QInputEvent>
#include <QtGui/QInputMethod>
#include <QtGui/QInputMethodEvent>
#include <QtGui/QInputMethodQueryEvent>
#include <QtGui/QIntValidator>
#include <QtGui/QKeyEvent>
#include <QtGui/QKeySequence>
#include <QtGui/QLinearGradient>
#include <QtGui/QMatrix2x2>
#include <QtGui/QMatrix2x3>
#include <QtGui/QMatrix2x4>
#include <QtGui/QMatrix3x2>
#include <QtGui/QMatrix3x3>
#include <QtGui/QMatrix3x4>
#include <QtGui/QMatrix4x2>
#include <QtGui/QMatrix4x3>
#include <QtGui/QMatrix4x4>
#include <QtGui/QMouseEvent>
#include <QtGui/QMoveEvent>
#include <QtGui/QMovie>
#include <QtGui/QNativeGestureEvent>
#include <QtGui/QOffscreenSurface>
#include <QtGui/QOpenGLContext>
#include <QtGui/QOpenGLContextGroup>
#include <QtGui/QOpenGLExtraFunctions>
#include <QtGui/QOpenGLExtraFunctionsPrivate>
#include <QtGui/QOpenGLFunctions>
#include <QtGui/QOpenGLFunctionsPrivate>
#include <QtGui/QPagedPaintDevice>
#include <QtGui/QPageLayout>
#include <QtGui/QPageRanges>
#include <QtGui/QPageSize>
#include <QtGui/QPaintDevice>
#include <QtGui/QPaintDeviceWindow>
#include <QtGui/QPaintEngine>
#include <QtGui/QPaintEngineState>
#include <QtGui/QPainter>
#include <QtGui/QPainterPath>
#include <QtGui/QPainterPathStroker>
#include <QtGui/QPaintEvent>
#include <QtGui/QPalette>
#include <QtGui/QPdfWriter>
#include <QtGui/QPen>
#include <QtGui/QPicture>
#include <QtGui/QPixelFormat>
#include <QtGui/QPixmap>
#include <QtGui/QPixmapCache>
#include <QtGui/QPlatformSurfaceEvent>
#include <QtGui/QPointerEvent>
#include <QtGui/QPointingDevice>
#include <QtGui/QPointingDeviceUniqueId>
#include <QtGui/QPolygon>
#include <QtGui/QPolygonF>
#include <QtGui/QQuaternion>
#include <QtGui/QRadialGradient>
#include <QtGui/QRasterWindow>
#include <QtGui/QRawFont>
#include <QtGui/QRegion>
#include <QtGui/QRegularExpressionValidator>
#include <QtGui/QResizeEvent>
#include <QtGui/QRgb>
#include <QtGui/QRgba64>
#include <QtGui/QRgbaFloat16>
#include <QtGui/QRgbaFloat32>
#include <QtGui/QScreen>
#include <QtGui/QScreenOrientationChangeEvent>
#include <QtGui/QScrollEvent>
#include <QtGui/QScrollPrepareEvent>
#include <QtGui/QSessionManager>
#include <QtGui/QShortcut>
#include <QtGui/QShortcutEvent>
#include <QtGui/QShowEvent>
#include <QtGui/QSinglePointEvent>
#include <QtGui/QStandardItem>
#include <QtGui/QStandardItemModel>
#include <QtGui/QStaticText>
#include <QtGui/QStatusTipEvent>
#include <QtGui/QStyleHints>
#include <QtGui/QSurface>
#include <QtGui/QSurfaceFormat>
#include <QtGui/QSyntaxHighlighter>
#include <QtGui/QTabletEvent>
#include <QtGui/QtEvents>
#include <QtGui/QTextBlock>
#include <QtGui/QTextBlockFormat>
#include <QtGui/QTextBlockGroup>
#include <QtGui/QTextBlockUserData>
#include <QtGui/QTextCharFormat>
#include <QtGui/QTextCursor>
#include <QtGui/QTextDocument>
#include <QtGui/QTextDocumentFragment>
#include <QtGui/QTextDocumentWriter>
#include <QtGui/QTextFormat>
#include <QtGui/QTextFragment>
#include <QtGui/QTextFrame>
#include <QtGui/QTextFrameFormat>
#include <QtGui/QTextFrameLayoutData>
#include <QtGui/QTextImageFormat>
#include <QtGui/QTextInlineObject>
#include <QtGui/QTextItem>
#include <QtGui/QTextLayout>
#include <QtGui/QTextLength>
#include <QtGui/QTextLine>
#include <QtGui/QTextList>
#include <QtGui/QTextListFormat>
#include <QtGui/QTextObject>
#include <QtGui/QTextObjectInterface>
#include <QtGui/QTextOption>
#include <QtGui/QTextTable>
#include <QtGui/QTextTableCell>
#include <QtGui/QTextTableCellFormat>
#include <QtGui/QTextTableFormat>
//#include <QtGui/QtGui>
//#include <QtGui/QtGuiDepends>
#include <QtGui/QtGuiVersion>
#include <QtGui/QToolBarChangeEvent>
#include <QtGui/QTouchEvent>
#include <QtGui/QTransform>
#include <QtGui/QUndoCommand>
#include <QtGui/QUndoGroup>
#include <QtGui/QUndoStack>
#include <QtGui/QValidator>
#include <QtGui/QVector2D>
#include <QtGui/QVector3D>
#include <QtGui/QVector4D>
#include <QtGui/QVulkanDeviceFunctions>
#include <QtGui/QVulkanExtension>
#include <QtGui/QVulkanFunctions>
#include <QtGui/QVulkanInfoVector>
#include <QtGui/QVulkanInstance>
#include <QtGui/QVulkanLayer>
#include <QtGui/QVulkanWindow>
#include <QtGui/QVulkanWindowRenderer>
#include <QtGui/QWhatsThisClickedEvent>
#include <QtGui/QWheelEvent>
#include <QtGui/QWidgetList>
#include <QtGui/QWidgetMapper>
#include <QtGui/QWidgetSet>
#include <QtGui/QWindow>
#include <QtGui/QWindowList>
#include <QtGui/QWindowStateChangeEvent>

29
scripts/mkqtdecl6/QtMultimedia/allofqt.cpp Normal file
View File

@ -0,0 +1,29 @@
#include <QtMultimedia/QAudio>
#include <QtMultimedia/QAudioBuffer>
#include <QtMultimedia/QAudioDecoder>
#include <QtMultimedia/QAudioDevice>
#include <QtMultimedia/QAudioFormat>
#include <QtMultimedia/QAudioFrame>
#include <QtMultimedia/QAudioInput>
#include <QtMultimedia/QAudioOutput>
#include <QtMultimedia/QAudioSink>
#include <QtMultimedia/QAudioSource>
#include <QtMultimedia/QCamera>
#include <QtMultimedia/QCameraDevice>
#include <QtMultimedia/QCameraFormat>
#include <QtMultimedia/QImageCapture>
#include <QtMultimedia/QMediaCaptureSession>
#include <QtMultimedia/QMediaDevices>
#include <QtMultimedia/QMediaFormat>
#include <QtMultimedia/QMediaMetaData>
#include <QtMultimedia/QMediaPlayer>
#include <QtMultimedia/QMediaRecorder>
#include <QtMultimedia/QMediaTimeRange>
#include <QtMultimedia/QSoundEffect>
//#include <QtMultimedia/QtMultimedia>
//#include <QtMultimedia/QtMultimediaDepends>
#include <QtMultimedia/QtMultimediaVersion>
#include <QtMultimedia/QVideoFrame>
#include <QtMultimedia/QVideoFrameFormat>
#include <QtMultimedia/QVideoSink>
#include <QtMultimedia/QWaveDecoder>

56
scripts/mkqtdecl6/QtNetwork/allofqt.cpp Normal file
View File

@ -0,0 +1,56 @@
#include <QtNetwork/QAbstractNetworkCache>
#include <QtNetwork/QAbstractSocket>
#include <QtNetwork/QAuthenticator>
#include <QtNetwork/QDnsDomainNameRecord>
#include <QtNetwork/QDnsHostAddressRecord>
#include <QtNetwork/QDnsLookup>
#include <QtNetwork/QDnsMailExchangeRecord>
#include <QtNetwork/QDnsServiceRecord>
#include <QtNetwork/QDnsTextRecord>
#include <QtNetwork/QDtls>
#include <QtNetwork/QDtlsClientVerifier>
#include <QtNetwork/QHostAddress>
#include <QtNetwork/QHostInfo>
#include <QtNetwork/QHstsPolicy>
#include <QtNetwork/QHttp2Configuration>
#include <QtNetwork/QHttpMultiPart>
#include <QtNetwork/QHttpPart>
#include <QtNetwork/Q_IPV6ADDR>
#include <QtNetwork/QIPv6Address>
#include <QtNetwork/QLocalServer>
#include <QtNetwork/QLocalSocket>
#include <QtNetwork/QNetworkAccessManager>
#include <QtNetwork/QNetworkAddressEntry>
#include <QtNetwork/QNetworkCacheMetaData>
#include <QtNetwork/QNetworkCookie>
#include <QtNetwork/QNetworkCookieJar>
#include <QtNetwork/QNetworkDatagram>
#include <QtNetwork/QNetworkDiskCache>
#include <QtNetwork/QNetworkInformation>
#include <QtNetwork/QNetworkInterface>
#include <QtNetwork/QNetworkProxy>
#include <QtNetwork/QNetworkProxyFactory>
#include <QtNetwork/QNetworkProxyQuery>
#include <QtNetwork/QNetworkReply>
#include <QtNetwork/QNetworkRequest>
#include <QtNetwork/QOcspResponse>
#include <QtNetwork/QPasswordDigestor>
#include <QtNetwork/QSctpServer>
#include <QtNetwork/QSctpSocket>
#include <QtNetwork/QSsl>
#include <QtNetwork/QSslCertificate>
#include <QtNetwork/QSslCertificateExtension>
#include <QtNetwork/QSslCipher>
#include <QtNetwork/QSslConfiguration>
#include <QtNetwork/QSslDiffieHellmanParameters>
#include <QtNetwork/QSslEllipticCurve>
#include <QtNetwork/QSslError>
#include <QtNetwork/QSslKey>
#include <QtNetwork/QSslPreSharedKeyAuthenticator>
#include <QtNetwork/QSslSocket>
#include <QtNetwork/QTcpServer>
#include <QtNetwork/QTcpSocket>
//#include <QtNetwork/QtNetwork>
//#include <QtNetwork/QtNetworkDepends>
#include <QtNetwork/QtNetworkVersion>
#include <QtNetwork/QUdpSocket>

11
scripts/mkqtdecl6/QtPrintSupport/allofqt.cpp Normal file
View File

@ -0,0 +1,11 @@
#include <QtPrintSupport/QAbstractPrintDialog>
#include <QtPrintSupport/QPageSetupDialog>
#include <QtPrintSupport/QPrintDialog>
#include <QtPrintSupport/QPrintEngine>
#include <QtPrintSupport/QPrinter>
#include <QtPrintSupport/QPrinterInfo>
#include <QtPrintSupport/QPrintPreviewDialog>
#include <QtPrintSupport/QPrintPreviewWidget>
//#include <QtPrintSupport/QtPrintSupport>
//#include <QtPrintSupport/QtPrintSupportDepends>
#include <QtPrintSupport/QtPrintSupportVersion>

20
scripts/mkqtdecl6/QtSql/allofqt.cpp Normal file
View File

@ -0,0 +1,20 @@
#include <QtSql/QSql>
#include <QtSql/QSqlDatabase>
#include <QtSql/QSqlDriver>
#include <QtSql/QSqlDriverCreator>
#include <QtSql/QSqlDriverCreatorBase>
#include <QtSql/QSqlDriverPlugin>
#include <QtSql/QSqlError>
#include <QtSql/QSqlField>
#include <QtSql/QSqlIndex>
#include <QtSql/QSqlQuery>
#include <QtSql/QSqlQueryModel>
#include <QtSql/QSqlRecord>
#include <QtSql/QSqlRelation>
#include <QtSql/QSqlRelationalDelegate>
#include <QtSql/QSqlRelationalTableModel>
#include <QtSql/QSqlResult>
#include <QtSql/QSqlTableModel>
//#include <QtSql/QtSql>
//#include <QtSql/QtSqlDepends>
#include <QtSql/QtSqlVersion>

5
scripts/mkqtdecl6/QtSvg/allofqt.cpp Normal file
View File

@ -0,0 +1,5 @@
#include <QtSvg/QSvgGenerator>
#include <QtSvg/QSvgRenderer>
//#include <QtSvg/QtSvg>
//#include <QtSvg/QtSvgDepends>
#include <QtSvg/QtSvgVersion>

4
scripts/mkqtdecl6/QtUiTools/allofqt.cpp Normal file
View File

@ -0,0 +1,4 @@
//#include <QtUiTools/QtUiTools>
//#include <QtUiTools/QtUiToolsDepends>
#include <QtUiTools/QtUiToolsVersion>
#include <QtUiTools/QUiLoader>

196
scripts/mkqtdecl6/QtWidgets/allofqt.cpp Normal file
View File

@ -0,0 +1,196 @@
#include <QtWidgets/QAbstractButton>
#include <QtWidgets/QAbstractGraphicsShapeItem>
#include <QtWidgets/QAbstractItemDelegate>
#include <QtWidgets/QAbstractItemView>
#include <QtWidgets/QAbstractScrollArea>
#include <QtWidgets/QAbstractSlider>
#include <QtWidgets/QAbstractSpinBox>
#include <QtWidgets/QAccessibleWidget>
#include <QtWidgets/QApplication>
#include <QtWidgets/QBoxLayout>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QCalendarWidget>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QColorDialog>
#include <QtWidgets/QColormap>
#include <QtWidgets/QColumnView>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QCommandLinkButton>
#include <QtWidgets/QCommonStyle>
#include <QtWidgets/QCompleter>
#include <QtWidgets/QDataWidgetMapper>
#include <QtWidgets/QDateEdit>
#include <QtWidgets/QDateTimeEdit>
#include <QtWidgets/QDial>
#include <QtWidgets/QDialog>
#include <QtWidgets/QDialogButtonBox>
#include <QtWidgets/QDockWidget>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QErrorMessage>
#include <QtWidgets/QFileDialog>
#include <QtWidgets/QFileIconProvider>
#include <QtWidgets/QFocusFrame>
#include <QtWidgets/QFontComboBox>
#include <QtWidgets/QFontDialog>
#include <QtWidgets/QFormLayout>
#include <QtWidgets/QFrame>
#include <QtWidgets/QGesture>
#include <QtWidgets/QGestureEvent>
#include <QtWidgets/QGestureRecognizer>
#include <QtWidgets/QGraphicsAnchor>
#include <QtWidgets/QGraphicsAnchorLayout>
#include <QtWidgets/QGraphicsBlurEffect>
#include <QtWidgets/QGraphicsColorizeEffect>
#include <QtWidgets/QGraphicsDropShadowEffect>
#include <QtWidgets/QGraphicsEffect>
#include <QtWidgets/QGraphicsEllipseItem>
#include <QtWidgets/QGraphicsGridLayout>
#include <QtWidgets/QGraphicsItem>
#include <QtWidgets/QGraphicsItemAnimation>
#include <QtWidgets/QGraphicsItemGroup>
#include <QtWidgets/QGraphicsLayout>
#include <QtWidgets/QGraphicsLayoutItem>
#include <QtWidgets/QGraphicsLinearLayout>
#include <QtWidgets/QGraphicsLineItem>
#include <QtWidgets/QGraphicsObject>
#include <QtWidgets/QGraphicsOpacityEffect>
#include <QtWidgets/QGraphicsPathItem>
#include <QtWidgets/QGraphicsPixmapItem>
#include <QtWidgets/QGraphicsPolygonItem>
#include <QtWidgets/QGraphicsProxyWidget>
#include <QtWidgets/QGraphicsRectItem>
#include <QtWidgets/QGraphicsRotation>
#include <QtWidgets/QGraphicsScale>
#include <QtWidgets/QGraphicsScene>
#include <QtWidgets/QGraphicsSceneContextMenuEvent>
#include <QtWidgets/QGraphicsSceneDragDropEvent>
#include <QtWidgets/QGraphicsSceneEvent>
#include <QtWidgets/QGraphicsSceneHelpEvent>
#include <QtWidgets/QGraphicsSceneHoverEvent>
#include <QtWidgets/QGraphicsSceneMouseEvent>
#include <QtWidgets/QGraphicsSceneMoveEvent>
#include <QtWidgets/QGraphicsSceneResizeEvent>
#include <QtWidgets/QGraphicsSceneWheelEvent>
#include <QtWidgets/QGraphicsSimpleTextItem>
#include <QtWidgets/QGraphicsTextItem>
#include <QtWidgets/QGraphicsTransform>
#include <QtWidgets/QGraphicsView>
#include <QtWidgets/QGraphicsWidget>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QGroupBox>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QInputDialog>
#include <QtWidgets/QItemDelegate>
#include <QtWidgets/QItemEditorCreator>
#include <QtWidgets/QItemEditorCreatorBase>
#include <QtWidgets/QItemEditorFactory>
#include <QtWidgets/QKeySequenceEdit>
#include <QtWidgets/QLabel>
#include <QtWidgets/QLayout>
#include <QtWidgets/QLayoutItem>
#include <QtWidgets/QLCDNumber>
#include <QtWidgets/QLineEdit>
#include <QtWidgets/QListView>
#include <QtWidgets/QListWidget>
#include <QtWidgets/QListWidgetItem>
#include <QtWidgets/QMainWindow>
#include <QtWidgets/QMdiArea>
#include <QtWidgets/QMdiSubWindow>
#include <QtWidgets/QMenu>
#include <QtWidgets/QMenuBar>
#include <QtWidgets/QMessageBox>
#include <QtWidgets/QPanGesture>
#include <QtWidgets/QPinchGesture>
#include <QtWidgets/QPlainTextDocumentLayout>
#include <QtWidgets/QPlainTextEdit>
#include <QtWidgets/QProgressBar>
#include <QtWidgets/QProgressDialog>
#include <QtWidgets/QProxyStyle>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QRadioButton>
#include <QtWidgets/QRubberBand>
#include <QtWidgets/QScrollArea>
#include <QtWidgets/QScrollBar>
#include <QtWidgets/QScroller>
#include <QtWidgets/QScrollerProperties>
#include <QtWidgets/QSizeGrip>
#include <QtWidgets/QSizePolicy>
#include <QtWidgets/QSlider>
#include <QtWidgets/QSpacerItem>
#include <QtWidgets/QSpinBox>
#include <QtWidgets/QSplashScreen>
#include <QtWidgets/QSplitter>
#include <QtWidgets/QSplitterHandle>
#include <QtWidgets/QStackedLayout>
#include <QtWidgets/QStackedWidget>
#include <QtWidgets/QStandardItemEditorCreator>
#include <QtWidgets/QStatusBar>
#include <QtWidgets/QStyle>
#include <QtWidgets/QStyledItemDelegate>
#include <QtWidgets/QStyleFactory>
#include <QtWidgets/QStyleHintReturn>
#include <QtWidgets/QStyleHintReturnMask>
#include <QtWidgets/QStyleHintReturnVariant>
#include <QtWidgets/QStyleOption>
#include <QtWidgets/QStyleOptionButton>
#include <QtWidgets/QStyleOptionComboBox>
#include <QtWidgets/QStyleOptionComplex>
#include <QtWidgets/QStyleOptionDockWidget>
#include <QtWidgets/QStyleOptionFocusRect>
#include <QtWidgets/QStyleOptionFrame>
#include <QtWidgets/QStyleOptionGraphicsItem>
#include <QtWidgets/QStyleOptionGroupBox>
#include <QtWidgets/QStyleOptionHeader>
#include <QtWidgets/QStyleOptionHeaderV2>
#include <QtWidgets/QStyleOptionMenuItem>
#include <QtWidgets/QStyleOptionProgressBar>
#include <QtWidgets/QStyleOptionRubberBand>
#include <QtWidgets/QStyleOptionSizeGrip>
#include <QtWidgets/QStyleOptionSlider>
#include <QtWidgets/QStyleOptionSpinBox>
#include <QtWidgets/QStyleOptionTab>
#include <QtWidgets/QStyleOptionTabBarBase>
#include <QtWidgets/QStyleOptionTabWidgetFrame>
#include <QtWidgets/QStyleOptionTitleBar>
#include <QtWidgets/QStyleOptionToolBar>
#include <QtWidgets/QStyleOptionToolBox>
#include <QtWidgets/QStyleOptionToolButton>
#include <QtWidgets/QStyleOptionViewItem>
#include <QtWidgets/QStylePainter>
#include <QtWidgets/QStylePlugin>
#include <QtWidgets/QSwipeGesture>
#include <QtWidgets/QSystemTrayIcon>
#include <QtWidgets/QTabBar>
#include <QtWidgets/QTableView>
#include <QtWidgets/QTableWidget>
#include <QtWidgets/QTableWidgetItem>
#include <QtWidgets/QTableWidgetSelectionRange>
#include <QtWidgets/QTabWidget>
#include <QtWidgets/QTapAndHoldGesture>
#include <QtWidgets/QTapGesture>
#include <QtWidgets/QTextBrowser>
#include <QtWidgets/QTextEdit>
#include <QtWidgets/QTileRules>
#include <QtWidgets/QTimeEdit>
#include <QtWidgets/QToolBar>
#include <QtWidgets/QToolBox>
#include <QtWidgets/QToolButton>
#include <QtWidgets/QToolTip>
#include <QtWidgets/QTreeView>
#include <QtWidgets/QTreeWidget>
#include <QtWidgets/QTreeWidgetItem>
#include <QtWidgets/QTreeWidgetItemIterator>
//#include <QtWidgets/QtWidgets>
//#include <QtWidgets/QtWidgetsDepends>
#include <QtWidgets/QtWidgetsVersion>
#include <QtWidgets/QUndoView>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWhatsThis>
#include <QtWidgets/QWidget>
#include <QtWidgets/QWidgetAction>
#include <QtWidgets/QWidgetData>
#include <QtWidgets/QWidgetItem>
#include <QtWidgets/QWidgetItemV2>
#include <QtWidgets/QWizard>
#include <QtWidgets/QWizardPage>

20
scripts/mkqtdecl6/QtXml/allofqt.cpp Normal file
View File

@ -0,0 +1,20 @@
#include <QtXml/QDomAttr>
#include <QtXml/QDomCDATASection>
#include <QtXml/QDomCharacterData>
#include <QtXml/QDomComment>
#include <QtXml/QDomDocument>
#include <QtXml/QDomDocumentFragment>
#include <QtXml/QDomDocumentType>
#include <QtXml/QDomElement>
#include <QtXml/QDomEntity>
#include <QtXml/QDomEntityReference>
#include <QtXml/QDomImplementation>
#include <QtXml/QDomNamedNodeMap>
#include <QtXml/QDomNode>
#include <QtXml/QDomNodeList>
#include <QtXml/QDomNotation>
#include <QtXml/QDomProcessingInstruction>
#include <QtXml/QDomText>
//#include <QtXml/QtXml>
//#include <QtXml/QtXmlDepends>
#include <QtXml/QtXmlVersion>

1486
scripts/mkqtdecl6/mkqtdecl.conf Normal file
View File

File diff suppressed because it is too large Load Diff

1921
scripts/mkqtdecl6/mkqtdecl.events Normal file
View File

File diff suppressed because it is too large Load Diff

15414
scripts/mkqtdecl6/mkqtdecl.properties Normal file
View File

File diff suppressed because it is too large Load Diff

102
scripts/mkqtdecl_common/c++.treetop
View File

@ -49,8 +49,35 @@ grammar CPP
"(" ( s ( "," s )? attribute_value )* s ")" / numeric_const / string_const / id
end
rule ignored_attr
"__attribute__" s attribute_value /
"__asm" s attribute_value /
"constexpr" ![a-zA-Z0-9_] /
"__extension__" /
"__inline" /
"__m64" /
"__m128" /
"__m128d" /
"__m128i" /
"__m256" /
"__m256d" /
"__m256i" /
"__m512" /
"__m512d" /
"__m512i" /
"__mmask8" /
"__mmask16" /
"__v8df" /
"__v8di" /
"__v16sf" /
"__v16si" /
"decltype" s attribute_value /
"alignas" s "(" s block s ")" /
"[[" s block s "]]"
end
rule a
s ( "__attribute__" s attribute_value s / "__asm" s attribute_value s / "__extension__" s / "decltype" s attribute_value s )*
s ( ignored_attr s )*
end
rule unary_op
@ -122,15 +149,15 @@ grammar CPP
end
rule enum_spec
id:id initspec:( s "=" s init:block_wo_comma )? <PEnumSpec>
a id:id a initspec:( s "=" s init:block_wo_comma )? <PEnumSpec>
end
rule enum_body
enum_spec ( s "," s enum_spec )*
enum_spec ( s "," s enum_spec )* ","?
end
rule enum_type
"enum" ![a-zA-Z0-9_] a s id:id? bodyspec:( s "{" s body:enum_body s "}" )? <PEnumType>
"enum" ![a-zA-Z0-9_] a is_class:(s "class" )? s id:id? ( s ":" s type )? bodyspec:( s "{" s body:enum_body s "}" )? <PEnumType>
end
rule virtual_spec
@ -147,13 +174,14 @@ grammar CPP
rule member_declaration_wo_semicolon
template:( d:template_decl s )?
attr:( ( explicit_key / mutable_key / storage_class / inline_spec / virtual_spec / constexpr_key ) s )*
attr:( ( explicit_key / mutable_key / storage_class / inline_spec / virtual_spec / ignored_attr ) s )*
t:type
# type declaration ends with a } .. does not need a semicolon
# (i.e. nested struct or enum)
&{ |seq| seq[-1].text_value_ends_with_curly_brace }
s
( ":" s block_wo_curly_braces s )?
( trailing_return_type )?
a
(
"{" s block s "}" /
@ -163,13 +191,14 @@ grammar CPP
rule member_declaration_w_semicolon
template:( d:template_decl s )?
attr:( ( explicit_key / mutable_key / storage_class / inline_spec / virtual_spec / constexpr_key ) s )*
attr:( ( explicit_key / mutable_key / storage_class / inline_spec / virtual_spec / ignored_attr ) s )*
t:type
# opposite case (member_see declaration_wo_semicolon)
# (i.e. nested struct or enum)
!{ |seq| seq[-1].text_value_ends_with_curly_brace }
s
( ":" s block_wo_curly_braces s )?
( trailing_return_type )?
a
(
"{" s block s "}" /
@ -202,7 +231,7 @@ grammar CPP
# In order to easily distinguish between constructor methods without
# a return type and class or typedef names we assume that all "name("
# constructs are considered constructor names but "name (*func_ptr) ()" is not.
qualified_id s !( "(" !( s "*" ) )
qualified_id s ( "..." s )? !( "(" !( s "*" ) )
end
rule typeof
@ -222,11 +251,11 @@ grammar CPP
end
rule concrete_type
( constexpr_key / class_or_struct_type / enum_type / float_type / char_type / int_type / bool_type / void_type / typeof / class_id )?
( class_or_struct_type / enum_type / float_type / char_type / int_type / bool_type / void_type / typeof / class_id )?
end
rule cv
( constexpr_key / "const" ![a-zA-Z0-9_] / "__const" ![a-zA-Z0-9_] / "volatile" ![a-zA-Z0-9_] / "__volatile" ![a-zA-Z0-9_] ) <PCV>
( "const" ![a-zA-Z0-9_] / "__const" ![a-zA-Z0-9_] / "volatile" ![a-zA-Z0-9_] / "__volatile" ![a-zA-Z0-9_] ) <PCV>
end
rule pointer
@ -256,15 +285,15 @@ grammar CPP
end
rule noexcept_spec
"noexcept" ( s "=" s block / s "(" s block ")" )?
"noexcept" ( s "(" s block s ")" )?
end
rule func_spec
"(" s fa:( a:func_args )? s ")" cvspec:( s cv:cv )? ( s "throw" s "(" s ( type_wo_comma s )? ")" / s noexcept_spec )* ( s override_key )? a <PFuncSpec>
"(" s fa:( a:func_args )? s ")" cvspec:( s cv:cv )? refspec:( s ref:( "&" !"&" / "&&" ) )? ( s "throw" s "(" s ( type_wo_comma s )? ")" / s noexcept_spec / s override_key )* a <PFuncSpec>
end
rule member_pointer
cspec:( qid:qualified_id s "::*" s ) itspec:( it:inner_type )? cvspec:( s cv:cv )? <PMemberPointer>
cspec:( qid:qualified_id s "::*" s ) itspec:( it:inner_type )? cvspec:( s cv:cv )? refspec:( s ref:( "&" !"&" / "&&" ) )? <PMemberPointer>
end
rule inner_type_with_cv
@ -278,21 +307,25 @@ grammar CPP
pointer /
reference /
member_pointer /
( "__restrict" ![a-zA-Z0-9_] s )? qualified_id
( "__restrict" ![a-zA-Z0-9_] s / "..." s )* qualified_id
)
pfx:( s spec:( array_spec / func_spec ) )*
<PInnerType>
end
rule init_spec
block_wo_comma / "default" / "delete" / "0"
end
rule type
cvspec:( cv:cv s )?
a
( "typename" ![a-zA-Z0-9_] s )?
ct:concrete_type
a
il:( s t1:inner_type i1:(s "=" s is1:block_wo_comma)? tt:( s "," s t2:inner_type i2:(s "=" s is2:block_wo_comma)? )* )?
il:( s t1:inner_type i1:(s "=" s is1:init_spec)? tt:( s "," s t2:inner_type i2:(s "=" s is2:init_spec)? )* )?
# alternative initialization if only a concrete type is given:
pi:( s "=" s is:block_wo_comma )?
pi:( s "=" s is:init_spec )?
<PType>
end
@ -301,16 +334,16 @@ grammar CPP
a
( "typename" ![a-zA-Z0-9_] s )?
ct:concrete_type
il:( s t:inner_type i:(s "=" s is:block_wo_comma)? )?
il:( s t:inner_type i:(s "=" s is:init_spec)? )?
# alternative initialization if only a concrete type is given:
pi:( s "=" s is:block_wo_comma )?
pi:( s "=" s is:init_spec )?
<PTypeWoComma>
end
rule type_for_template
cvspec:( cv:cv s )?
a
( "typename" ![a-zA-Z0-9_] s )?
( ( "typename" / "class" ) ![a-zA-Z0-9_] s ( "..." s )? )?
ct:concrete_type
il:( s t:inner_type )?
<PTypeForTemplate>
@ -324,19 +357,15 @@ grammar CPP
"override" ![a-zA-Z0-9_]
end
rule constexpr_key
"constexpr" ![a-zA-Z0-9_]
end
rule inline_spec
"inline" ![a-zA-Z0-9_] <PInline>
end
# parse over blocks as gracefully as possible ...
rule block_atom_wo_gt
"(" s block s ")" / "[" s block s "]" / "<" s block_wo_gt ( s "," s block_wo_gt )* s ">" /
"(" s block s ")" / "[" s block s "]" / "<" !"=" s block_wo_gt ( s "," s block_wo_gt )* s ">" /
numeric_const / hex_const / string_const / char_const /
id / unary_op / bin_op_wo_gt / "?" / "::" / "." / ":" / ";"
id ( s "{" s block s "}" )? / unary_op / bin_op_wo_gt / "?" / "::" / "." / ":" / ";"
end
rule block_wo_gt
@ -347,7 +376,7 @@ grammar CPP
rule block_atom
"(" s block s ")" / "[" s block s "]" / "<" s block_wo_gt ( s "," s block_wo_gt )* s ">" /
numeric_const / hex_const / string_const / char_const /
id / unary_op / bin_op / "?" / "::" / "." / ":"
id ( s "{" s block s "}" )? / unary_op / bin_op / "?" / "::" / "." / ":"
end
rule block
@ -375,25 +404,27 @@ grammar CPP
end
rule template_decl_arg
( "class" / "typename" ) ![a-zA-Z0-9_] s id:id dtspec:( s "=" s dt:type_for_template )? <PClassTemplateArg> /
t:type_for_template initspec:( s "=" s init:block_wo_gt )? <PDirectTemplateArg>
t:type_for_template dtspec:( s "=" s dt:block_wo_gt )? <PClassTemplateArg>
end
rule template_decl
"template" s "<" s ( !">" template_decl_arg s ( "," s template_decl_arg )* )? s ">" <PTemplateDecl>
end
rule trailing_return_type
"->" s ( "decltype" s "(" s block s ")" / type )
end
rule declaration_w_semicolon
template:( d:template_decl s )?
template_member:( d_member:template_decl s )?
attr:( ( storage_class / inline_spec / constexpr_key ) s )*
a
( constexpr_key s )?
attr:( ( storage_class / inline_spec / ignored_attr ) s )*
t:type
# type declaration ends with a } .. does not need a semicolon
# (i.e. nested struct or enum)
!{ |seq| seq[-1].text_value_ends_with_curly_brace }
s ( ":" s block_wo_curly_braces s )?
( trailing_return_type )?
a
(
"{" s block s "}" /
@ -403,14 +434,13 @@ grammar CPP
rule declaration_wo_semicolon
template:( d:template_decl s )?
attr:( ( storage_class / inline_spec / constexpr_key ) s )*
a
( constexpr_key s )?
attr:( ( storage_class / inline_spec / ignored_attr ) s )*
t:type
# opposite case (see declaration_wo_semicolon)
# (i.e. nested struct or enum)
&{ |seq| seq[-1].text_value_ends_with_curly_brace }
s ( ":" s block_wo_curly_braces s )?
( trailing_return_type )?
a
(
"{" s block s "}" /
@ -432,8 +462,12 @@ grammar CPP
a "{" decls:( a ( ";" / typedef / namespace / extern_decl / declaration ) )* s "}" <PExternBlock>
end
rule asm
"asm" s "(" s block s ")"
end
rule module
( a ( ";" / static_assert / using / typedef / namespace / extern_decl / declaration ) )* s <PModule>
( a ( ";" / static_assert / using / typedef / namespace / extern_decl / declaration / asm ) )* s <PModule>
end
end

75
scripts/mkqtdecl_common/common.conf
View File

@ -122,10 +122,17 @@ def add_native_impl_QPersistentQModelIndex
# alternative implementation for QPersistentQModelIndex::operator const QModelIndex &
add_native_impl("QPersistentModelIndex", <<'CODE', <<'DECL')
#if QT_VERSION < 0x60000
static const QModelIndex &castToQModelIndex(const QPersistentModelIndex *m)
{
return m->operator const QModelIndex &();
}
#else
static QModelIndex castToQModelIndex(const QPersistentModelIndex *m)
{
return m->operator QModelIndex();
}
#endif
CODE
gsi::method_ext("castToQModelIndex", &castToQModelIndex, "@brief Binding for \"operator const QModelIndex &\".")
DECL
@ -215,25 +222,25 @@ def add_native_impl_streams
return v;
}
static qt_gsi::Converter<class QChar>::target_type f_QDataStream_read_qchar(QDataStream *s)
static qt_gsi::Converter<QChar>::target_type f_QDataStream_read_qchar(QDataStream *s)
{
QChar v = 0;
QChar v = QChar (0);
*s >> v;
return qt_gsi::Converter<class QChar>::toc (v);
return qt_gsi::Converter<QChar>::toc (v);
}
static qt_gsi::Converter<class QList<int> >::target_type f_QDataStream_read_int_list(QDataStream *s)
static qt_gsi::Converter<QList<int> >::target_type f_QDataStream_read_int_list(QDataStream *s)
{
QList<int> v;
*s >> v;
return qt_gsi::Converter<class QList<int> >::toc (v);
return qt_gsi::Converter<QList<int> >::toc (v);
}
static qt_gsi::Converter<class QVector<int> >::target_type f_QDataStream_read_int_vector(QDataStream *s)
static qt_gsi::Converter<QVector<int> >::target_type f_QDataStream_read_int_vector(QDataStream *s)
{
QVector<int> v;
*s >> v;
return qt_gsi::Converter<class QVector<int> >::toc (v);
return qt_gsi::Converter<QVector<int> >::toc (v);
}
static QString f_QDataStream_read_string(QDataStream *s)
@ -316,21 +323,21 @@ def add_native_impl_streams
return s;
}
static QDataStream *f_QDataStream_put_qchar(QDataStream *s, const qt_gsi::Converter<class QChar>::target_type &v)
static QDataStream *f_QDataStream_put_qchar(QDataStream *s, const qt_gsi::Converter<QChar>::target_type &v)
{
*s << qt_gsi::Converter<class QChar>::toq (v);
*s << qt_gsi::Converter<QChar>::toq (v);
return s;
}
static QDataStream *f_QDataStream_put_int_list(QDataStream *s, const qt_gsi::Converter<class QList<int> >::target_type &v)
static QDataStream *f_QDataStream_put_int_list(QDataStream *s, const qt_gsi::Converter<QList<int> >::target_type &v)
{
*s << qt_gsi::Converter<class QList<int> >::toq (v);
*s << qt_gsi::Converter<QList<int> >::toq (v);
return s;
}
static QDataStream *f_QDataStream_put_int_vector(QDataStream *s, const qt_gsi::Converter<class QVector<int> >::target_type &v)
static QDataStream *f_QDataStream_put_int_vector(QDataStream *s, const qt_gsi::Converter<QVector<int> >::target_type &v)
{
*s << qt_gsi::Converter<class QVector<int> >::toq (v);
*s << qt_gsi::Converter<QVector<int> >::toq (v);
return s;
}
@ -441,7 +448,7 @@ add_native_impl("QTextStream", <<'CODE', <<'DECL')
static qt_gsi::Converter<QChar>::target_type f_QTextStream_read_qchar(QTextStream *s)
{
QChar v = 0;
QChar v = QChar (0);
*s >> v;
return qt_gsi::Converter<QChar>::toc (v);
}
@ -617,52 +624,52 @@ def add_native_impl_polygons
static void f_QPolygon_clear (QPolygon *m)
{
return m->clear();
m->clear();
}
static void f_QPolygon_remove (QPolygon *m, int i)
{
return m->remove (i);
m->remove (i);
}
static void f_QPolygon_insert (QPolygon *m, int i, const QPoint &p)
{
return m->insert (i, p);
m->insert (i, p);
}
static void f_QPolygon_replace (QPolygon *m, int i, const QPoint &p)
{
return m->replace (i, p);
m->replace (i, p);
}
static void f_QPolygon_pop_front (QPolygon *m)
{
return m->pop_front ();
m->pop_front ();
}
static void f_QPolygon_pop_back (QPolygon *m)
{
return m->pop_back ();
m->pop_back ();
}
static void f_QPolygon_push_front (QPolygon *m, const QPoint &p)
{
return m->push_front (p);
m->push_front (p);
}
static void f_QPolygon_push_back (QPolygon *m, const QPoint &p)
{
return m->push_back (p);
m->push_back (p);
}
static void f_QPolygon_reserve (QPolygon *m, int n)
{
return m->reserve (n);
m->reserve (n);
}
static void f_QPolygon_resize (QPolygon *m, int n)
{
return m->resize (n);
m->resize (n);
}
static void f_QPolygon_fill (QPolygon *m, const QPoint &p, int n)
@ -747,52 +754,52 @@ DECL
static void f_QPolygonF_clear (QPolygonF *m)
{
return m->clear();
m->clear();
}
static void f_QPolygonF_remove (QPolygonF *m, int i)
{
return m->remove (i);
m->remove (i);
}
static void f_QPolygonF_insert (QPolygonF *m, int i, const QPointF &p)
{
return m->insert (i, p);
m->insert (i, p);
}
static void f_QPolygonF_replace (QPolygonF *m, int i, const QPointF &p)
{
return m->replace (i, p);
m->replace (i, p);
}
static void f_QPolygonF_pop_front (QPolygonF *m)
{
return m->pop_front ();
m->pop_front ();
}
static void f_QPolygonF_pop_back (QPolygonF *m)
{
return m->pop_back ();
m->pop_back ();
}
static void f_QPolygonF_push_front (QPolygonF *m, const QPointF &p)
{
return m->push_front (p);
m->push_front (p);
}
static void f_QPolygonF_push_back (QPolygonF *m, const QPointF &p)
{
return m->push_back (p);
m->push_back (p);
}
static void f_QPolygonF_reserve (QPolygonF *m, int n)
{
return m->reserve (n);
m->reserve (n);
}
static void f_QPolygonF_resize (QPolygonF *m, int n)
{
return m->resize (n);
m->resize (n);
}
static void f_QPolygonF_fill (QPolygonF *m, const QPointF &p, int n)

39
scripts/mkqtdecl_common/cpp_classes.rb
View File

@ -87,8 +87,8 @@ end
# "cv" is a CPPCV object.
class CPPFunc < CPPOuterType
attr_accessor :inner, :args, :cv
def_initializer :inner, :args, :cv
attr_accessor :inner, :args, :cv, :ref
def_initializer :inner, :args, :cv, :ref
def to_s
a = self.args
@ -96,12 +96,13 @@ class CPPFunc < CPPOuterType
if !a.is_a?(Array)
a = [a]
end
self.inner.to_s + " (" + a.join(", ") + ")" + (self.cv ? " " + self.cv.to_s : "")
self.inner.to_s + " (" + a.join(", ") + ")" + (self.cv ? " " + self.cv.to_s : "") + (self.ref ? " " + self.ref.to_s : "")
end
def dump(i)
i + "CPPFunc\n" + i + " inner:\n" + self.inner.dump(i + " ") + "\n" +
i + " cv: " + self.cv.to_s + "\n" +
i + " ref: " + self.ref.to_s + "\n" +
i + " args:\n" + (self.args || []).collect { |f| f.dump(i + " ") }.join("\n")
end
@ -469,29 +470,19 @@ class CPPFriendDecl < CPPObject
end
# @brief A type template argument (with an optional initializer)
# @attribute id The name of the argument (a string)
# @attribute type The template argument (a type)
# @attribute def_type The default type (nil or a CPPType object)
class CPPClassTemplateArg < CPPObject
attr_accessor :id, :def_type
def_initializer :id, :def_type
attr_accessor :type, :def_type
def_initializer :type, :def_type
def to_s
self.id + (self.def_type ? ("=" + self.def_type.to_s) : "")
end
end
# @brief A value template argument (with an optional initializer)
# @attribute type A CPPType object describing the type
# @attribute def_expr The initializer expression (a string) or nil if no initializer is given
class CPPDirectTemplateArg < CPPObject
attr_accessor :type, :def_expr
def_initializer :type, :def_expr
def to_s
self.type.to_s + (self.def_expr ? ("=" + self.def_expr.to_s) : "")
if self.def_type
self.type.to_s + "=" + self.def_type.to_s
else
self.type.to_s
end
end
end
@ -624,15 +615,15 @@ end
# @attribute specs the enum members (an array of CPPEnumSpec objects)
class CPPEnum < CPPObject
attr_accessor :name, :specs
def_initializer :name, :specs
attr_accessor :name, :specs, :is_class
def_initializer :name, :specs, :is_class
def to_s
"enum " + (self.name || "")
end
def dump(i)
l = i + self.to_s + " {\n"
l = i + self.to_s + (self.is_class ? " class" : "") + " {\n"
l += (self.specs || []).collect { |s| i + " " + s.to_s + "\n" }.join("")
l += i + "}"
end

12
scripts/mkqtdecl_common/cpp_parser_classes.rb
View File

@ -128,7 +128,7 @@ module PEnumType
def cpp
name = id ? id.text_value : nil
specs = bodyspec.nonterminal? ? bodyspec.body.cpp : nil
CPPEnum::new(name, specs)
CPPEnum::new(name, specs, is_class.nonterminal?)
end
end
@ -241,7 +241,7 @@ end
module PFuncSpec
def cpp
CPPFunc::new(nil, (fa.nonterminal? && fa.text_value != "void") ? (fa.a.cpp || []) : [], cvspec.nonterminal? && cvspec.cv.to_symbol)
CPPFunc::new(nil, (fa.nonterminal? && fa.text_value != "void") ? (fa.a.cpp || []) : [], cvspec.nonterminal? && cvspec.cv.to_symbol, refspec.nonterminal? && refspec.ref.text_value)
end
end
@ -404,13 +404,7 @@ end
module PClassTemplateArg
def cpp
CPPClassTemplateArg::new(id.text_value, dtspec.nonterminal? ? dtspec.cpp : nil)
end
end
module PDirectTemplateArg
def cpp
CPPDirectTemplateArg::new(t.cpp, initspec.nonterminal? ? initspec.text_value : nil)
CPPClassTemplateArg::new(t.cpp, dtspec.nonterminal? ? dtspec.cpp : nil)
end
end

2
scripts/mkqtdecl_common/parse.rb
View File

@ -29,7 +29,7 @@ $:.push(File.dirname($0))
require 'oj'
require 'treetop'
Treetop.load "c++"
Treetop.load File.join(File.dirname($0), "c++")
input="all.e"
output="all.db"

313
scripts/mkqtdecl_common/produce.rb
View File

@ -73,6 +73,10 @@ class CPPDeclaration
self.type.func.cv == :const
end
def ref
self.type.func.ref
end
def hash_str
# TODO: this is a hack for making the hash values unique:
@ -83,6 +87,13 @@ class CPPDeclaration
nmax = func.max_args
hk = (self.is_const? ? "c" : "")
if self.ref
if self.ref == "&"
hk += "r"
elsif self.ref == "&&"
hk += "rr"
end
end
if nmax > 0
@ -111,17 +122,28 @@ class CPPDeclaration
nmax = func.max_args
args = nmax.times.collect { |ia| func.args[ia].anonymous_type.to_s }.join(", ")
res = "(" + args + ")"
if self.is_const?
"(" + args + ") const"
else
"(" + args + ")"
res += " const"
end
if self.ref
res += " " + self.ref
end
res
end
def sig(cls)
self.type.name_substituted_type(CPPQualifiedId::new(false, [ cls, self.type.func.func_name ])).to_s
end
def raw_sig(cls)
# backward compatibility for signature computation
s = self.type.name_substituted_type(CPPQualifiedId::new(false, [ cls, self.type.func.func_name ])).to_s
if self.ref
s = s.sub(/\s+&+$/, "")
end
if self.is_const?
s = s.sub(/\s+const$/, "")
end
@ -144,6 +166,19 @@ class CPPNamespace
end
class CPPEnum
def resolve_typedefs(scope)
end
def rescope(prev_scope, other_scope, idpath)
end
def each_qid(&block)
end
end
class CPPStruct
def resolve_typedefs(scope)
@ -426,7 +461,7 @@ class CPPStruct
end
elsif bc_obj
raise("#{bc.class_id.to_s} is not a base class in #{self.id.to_s}")
puts("Warning: #{bc.class_id.to_s} is not a base class in #{self.id.to_s}")
else
puts("Cannot find base class: #{bc.class_id.to_s} of #{self.parent.myself} - declaration ignored")
end
@ -739,7 +774,13 @@ class CPPType
return "#{self.anonymous_type.to_s}(" + expr + ")"
elsif self.is_special(decl_obj)
ta = self.anonymous_type.to_s
if ta =~ /^const (.*) &$/
if ta =~ /^const (.*) &&$/
ta = $1
acc = ".cmove()"
elsif ta =~ /^(.*) &&$/
ta = $1
acc = ".move()"
elsif ta =~ /^const (.*) &$/
ta = $1
acc = ".cref()"
elsif ta =~ /^(.*) &$/
@ -776,6 +817,8 @@ class CPPType
# but can at least read them.
if ta =~ /^const (.*) &$/ || ta =~ /^(.*) &$/
ta = $1
elsif ta =~ /^const (.*) &&$/ || ta =~ /^(.*) &&$/
ta = $1
elsif ta =~ /^const (.*) \*$/ || ta =~ /^(.*) \*$/
ta = $1
acc = "*"
@ -911,6 +954,7 @@ class Configurator
@dropped_methods = {}
@dropped_classes = {}
@dropped_enums = {}
@included_enums = {}
@renamed_methods = {}
@kept_args = {}
@owner_args = {}
@ -1140,6 +1184,7 @@ class Configurator
# static and non-static methods
if bd.storage_class == :static
sig = "static " + sig
sig2 = "static " + sig2
end
if is_dropped?(cls, sig) || is_dropped?(cls2, sig2)
@ -1151,6 +1196,11 @@ class Configurator
# replace assignment operator
if name == "="
# drop assignment if the class does not have a copy ctor ("no copy semantics")
# (required because otherwise operator= is exposed for adaptor classes)
if !has_copy_ctor?(cls)
return nil
end
name = "assign"
end
@ -1225,6 +1275,16 @@ class Configurator
gsub(/\s+/, "")
end
def include_enum(cls, sig)
@included_enums[cls] ||= []
@included_enums[cls] << sig
end
def is_enum_included?(cls, sig)
dm = (@included_enums[:all_classes] || []) + (@included_enums[cls] || [])
dm.find { |d| sig =~ d } != nil
end
def drop_enum(cls, sig)
@dropped_enums[cls] ||= []
@dropped_enums[cls] << sig
@ -1559,7 +1619,6 @@ END
ofile.puts("#include \"gsiQt.h\"")
ofile.puts("#include \"gsi#{modn}Common.h\"")
ofile.puts("#include \"gsiDecl#{modn}TypeTraits.h\"")
end
@ -1633,7 +1692,11 @@ END
next
end
edecl << " gsi::enum_const (\"#{ei_name}\", #{cls}::#{ei}, \"@brief Enum constant #{cls}::#{ei}\")"
if ed.enum.is_class
edecl << " gsi::enum_const (\"#{ei_name}\", #{cls}::#{en}::#{ei}, \"@brief Enum constant #{cls}::#{en}::#{ei}\")"
else
edecl << " gsi::enum_const (\"#{ei_name}\", #{cls}::#{ei}, \"@brief Enum constant #{cls}::#{ei}\")"
end
end
@ -1645,8 +1708,6 @@ END
ofile.puts(" \"@qt\\n@brief This class represents the QFlags<#{cls}::#{en}> flag set\");")
ofile.puts("")
ofile.puts("// Inject the declarations into the parent")
# inject the declarations into the parent namespace or class
pdecl_obj = ed.parent
@ -1662,7 +1723,12 @@ END
pname = pcls + "_Namespace"
end
ofile.puts("static gsi::ClassExt<#{pname}> inject_#{clsn}_#{en}_Enum_in_parent (decl_#{clsn}_#{en}_Enum.defs ());")
if ! ed.enum.is_class
ofile.puts("// Inject the declarations into the parent")
ofile.puts("static gsi::ClassExt<#{pname}> inject_#{clsn}_#{en}_Enum_in_parent (decl_#{clsn}_#{en}_Enum.defs ());")
end
ofile.puts("static gsi::ClassExt<#{pname}> decl_#{clsn}_#{en}_Enum_as_child (decl_#{clsn}_#{en}_Enum, \"#{en}\");")
ofile.puts("static gsi::ClassExt<#{pname}> decl_#{clsn}_#{en}_Enums_as_child (decl_#{clsn}_#{en}_Enums, \"QFlags_#{en}\");")
@ -1786,13 +1852,13 @@ END
bc_methods_by_name = {}
base_classes.each do |bc|
bc_decl_obj = decl_obj.resolve_qid(bc.class_id)
bc_decl_obj && bc_decl_obj.struct.collect_all_methods(bc_methods_by_name, conf)
bc_decl_obj && bc_decl_obj.respond_to?(:struct) && bc_decl_obj.struct.collect_all_methods(bc_methods_by_name, conf)
end
mmap = {}
struct.collect_methods(methods_by_name)
struct.collect_all_methods(all_methods_by_name, conf)
struct.collect_enum_decls(enum_decls_by_name) { |bd| self.is_enum_used?(bd) }
struct.collect_enum_decls(enum_decls_by_name) { |bd| self.is_enum_used?(bd) || conf.is_enum_included?(cls, bd.myself) }
# if one method is abstract, omit ctors for example
is_abstract = all_methods_by_name.values.find do |m|
@ -1832,7 +1898,7 @@ END
# create a default ctor if there is no ctor at all and we can have one
if ctors.empty? && conf.has_default_ctor?(cls)
func = CPPFunc::new(CPPQualifiedId::new(false, [ CPPId::new(decl_obj.myself, nil) ]), [], nil)
func = CPPFunc::new(CPPQualifiedId::new(false, [ CPPId::new(decl_obj.myself, nil) ]), [], nil, nil)
type = CPPType::new(nil, func, nil)
def_ctor = CPPDeclaration::new(type, nil, :public, nil, false, false)
def_ctor.parent = decl_obj
@ -1905,6 +1971,7 @@ END
func = bd.type.func
hk = bd.hash_str
sig = bd.sig(cls)
rsig = bd.raw_sig(cls)
mn = decl_obj.myself # ctor!
mn_name = conf.target_name(cls, bd, mn)
@ -1923,7 +1990,7 @@ END
qt_alist = n_args.times.collect { |ia| func.args[ia].renamed_type(alist[ia]).access_qt_arg(decl_obj) }
ofile.puts("")
ofile.puts("// Constructor #{sig}")
ofile.puts("// Constructor #{rsig}")
ofile.puts("")
ofile.puts("")
@ -1951,7 +2018,7 @@ END
ofile.puts("}")
ofile.puts("")
mdecl_ctors << "new qt_gsi::GenericStaticMethod (\"#{mn_name}\", \"@brief Constructor #{sig}\\nThis method creates an object of class #{cls}.\", &_init_ctor_#{clsn}_#{hk}, &_call_ctor_#{clsn}_#{hk});"
mdecl_ctors << "new qt_gsi::GenericStaticMethod (\"#{mn_name}\", \"@brief Constructor #{rsig}\\nThis method creates an object of class #{cls}.\", &_init_ctor_#{clsn}_#{hk}, &_call_ctor_#{clsn}_#{hk});"
end
@ -1978,6 +2045,7 @@ END
const = bd.is_const?
hk = bd.hash_str
sig = bd.sig(cls)
rsig = bd.raw_sig(cls)
if conf.event_args(cls, sig) && bd.type.return_type.is_void?
# don't produce bindings for signals (which are public in Qt5)
@ -2005,7 +2073,7 @@ END
qt_alist = n_args.times.collect { |ia| func.args[ia].renamed_type(alist[ia]).access_qt_arg(decl_obj) }
ofile.puts("")
ofile.puts("// #{sig}")
ofile.puts("// #{rsig}")
ofile.puts("")
ofile.puts("")
@ -2030,7 +2098,7 @@ END
ofile.puts("}")
ofile.puts("")
mdecl << "new qt_gsi::GenericMethod (\"#{mn_name}\", \"@brief Method #{sig}\\n" + (is_reimp ? "This is a reimplementation of #{is_reimp.parent.myself}::#{mid}" : "") + "\", #{const.to_s}, &_init_f_#{mn}_#{hk}, &_call_f_#{mn}_#{hk});"
mdecl << "new qt_gsi::GenericMethod (\"#{mn_name}\", \"@brief Method #{rsig}\\n" + (is_reimp ? "This is a reimplementation of #{is_reimp.parent.myself}::#{mid}" : "") + "\", #{const.to_s}, &_init_f_#{mn}_#{hk}, &_call_f_#{mn}_#{hk});"
end
@ -2065,6 +2133,7 @@ END
end
sig = bd_short.sig(cls)
rsig = bd_short.raw_sig(cls)
hk = bd_short.hash_str
n_args = func.max_args
@ -2078,7 +2147,7 @@ END
al = ant.collect { |a| a.to_s }.join(", ")
aln = ren_args.collect { |a| a.to_s }.join(", ")
sig_wo_void = sig.sub(/^void /, "")
rsig_wo_void = rsig.sub(/^void /, "")
al_subst = al
SignalSubstitutions.each do |t,s|
@ -2087,9 +2156,9 @@ END
argspecs = argnames.collect { |a| "gsi::arg(\"#{a}\"), " }.join("")
if gsi_args.empty?
mdecl << "gsi::qt_signal (\"#{mid}(#{al_subst})\", \"#{mn_name}\", \"@brief Signal declaration for #{sig_wo_void}\\nYou can bind a procedure to this signal.\");"
mdecl << "gsi::qt_signal (\"#{mid}(#{al_subst})\", \"#{mn_name}\", \"@brief Signal declaration for #{rsig_wo_void}\\nYou can bind a procedure to this signal.\");"
else
mdecl << "gsi::qt_signal<#{event_al} > (\"#{mid}(#{al_subst})\", \"#{mn_name}\", #{argspecs}\"@brief Signal declaration for #{sig_wo_void}\\nYou can bind a procedure to this signal.\");"
mdecl << "gsi::qt_signal<#{event_al} > (\"#{mid}(#{al_subst})\", \"#{mn_name}\", #{argspecs}\"@brief Signal declaration for #{rsig_wo_void}\\nYou can bind a procedure to this signal.\");"
end
end
@ -2114,6 +2183,7 @@ END
const = bd.is_const?
hk = bd.hash_str
sig = bd.sig(cls)
rsig = bd.raw_sig(cls)
mn = conf.mid2str(mid)
mn_name = conf.target_name(cls, bd, mid, all_methods_by_name, bd)
@ -2132,7 +2202,7 @@ END
qt_alist = n_args.times.collect { |ia| func.args[ia].renamed_type(alist[ia]).access_qt_arg(decl_obj) }
ofile.puts("")
ofile.puts("// static #{sig}")
ofile.puts("// static #{rsig}")
ofile.puts("")
ofile.puts("")
@ -2156,7 +2226,7 @@ END
ofile.puts("}")
ofile.puts("")
mdecl << "new qt_gsi::GenericStaticMethod (\"#{mn_name}\", \"@brief Static method #{sig}\\nThis method is static and can be called without an instance.\", &_init_f_#{mn}_#{hk}, &_call_f_#{mn}_#{hk});"
mdecl << "new qt_gsi::GenericStaticMethod (\"#{mn_name}\", \"@brief Static method #{rsig}\\nThis method is static and can be called without an instance.\", &_init_f_#{mn}_#{hk}, &_call_f_#{mn}_#{hk});"
end
@ -2173,6 +2243,7 @@ END
const = bd.is_const?
hk = bd.hash_str
sig = bd.sig("")
rsig = bd.raw_sig("")
# operators may be present twice with the same signature
# (here: same hash key)
@ -2206,7 +2277,7 @@ END
args = rnt.collect { |t| t.gsi_decl_arg(decl_obj) }.join(", ")
ofile.puts("")
ofile.puts("// #{sig}")
ofile.puts("// #{rsig}")
ofile.puts("static #{rt.gsi_decl_return(decl_obj)} op_#{clsn}_#{mn}_#{hk}(#{args}) {")
if !rt.is_void?
@ -2219,7 +2290,7 @@ END
argspecs = argnames[1..-1].collect { |a| "gsi::arg (\"#{a}\"), " }.join("")
mdecl << "gsi::method_ext(\"#{mn_name}\", &::op_#{clsn}_#{mn}_#{hk}, #{argspecs}\"@brief Operator #{sig}\\nThis is the mapping of the global operator to the instance method.\");"
mdecl << "gsi::method_ext(\"#{mn_name}\", &::op_#{clsn}_#{mn}_#{hk}, #{argspecs}\"@brief Operator #{rsig}\\nThis is the mapping of the global operator to the instance method.\");"
end
@ -2335,20 +2406,6 @@ END
# forward decl
@ext_decls << "#{struct.kind.to_s} #{cls};\n\n"
# type traits included ...
tt = "namespace tl { template <> struct type_traits<#{cls}> : public type_traits<void> {\n"
if !conf.has_copy_ctor?(cls) || is_abstract || (eq_op && eq_op.visibility == :private)
tt += " typedef tl::false_tag has_copy_constructor;\n"
end
if !conf.has_default_ctor?(cls) || is_abstract
tt += " typedef tl::false_tag has_default_constructor;\n"
end
if (dtor = struct.get_dtor) && dtor.visibility != :public
tt += " typedef tl::false_tag has_public_destructor;\n"
end
tt += "}; }\n\n"
@ext_decls << tt
# only for top-level classes external declarations are produced currently
@ext_decls << "namespace gsi { GSI_#{modn.upcase}_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} (); }\n\n"
@ -2383,6 +2440,7 @@ END
func = bd.type.func
hk = bd.hash_str
sig = bd.sig(cls)
rsig = bd.raw_sig(cls)
mn = decl_obj.myself # ctor!
mn_name = conf.target_name(cls, bd, mn)
@ -2406,7 +2464,7 @@ END
args = rnt.collect { |t| t.to_s }.join(", ")
ofile.puts("")
ofile.puts(" // [adaptor ctor] #{sig}")
ofile.puts(" // [adaptor ctor] #{rsig}")
ofile.puts(" #{clsn}_Adaptor(#{args}) : #{cls}(#{argnames.join(', ')})")
ofile.puts(" {")
ofile.puts(" qt_gsi::QtObjectBase::init (this);")
@ -2430,6 +2488,7 @@ END
func = bd.type.func
hk = bd.hash_str
sig = bd.sig(cls)
rsig = bd.raw_sig(cls)
const = bd.is_const?
# exclude events
@ -2453,7 +2512,7 @@ END
argexpr = rnt.collect { |t| t.access_qt_arg(decl_obj) }.join(", ")
ofile.puts("")
ofile.puts(" // [expose] #{sig}")
ofile.puts(" // [expose] #{rsig}")
ofile.puts(" " + (bd.storage_class == :static ? "static " : "") + "#{rt.gsi_decl_return(decl_obj)} fp_#{clsn}_#{mn}_#{hk} (#{args}) " + (const ? "const " : "") + "{")
if rt.is_void?
ofile.puts(" #{cls}::#{mid}(#{argexpr});")
@ -2481,6 +2540,7 @@ END
func = bd.type.func
hk = bd.hash_str
sig = bd.sig(cls)
rsig = bd.raw_sig(cls)
const = bd.is_const?
rt = bd.type.return_type
@ -2504,6 +2564,7 @@ END
end
sig = bd_short.sig(cls)
rsig = bd_short.raw_sig(cls)
# for events produce an emitter function
@ -2517,7 +2578,7 @@ END
call_args = argnames.join(", ")
ofile.puts("")
ofile.puts(" // [emitter impl] #{sig}")
ofile.puts(" // [emitter impl] #{rsig}")
ofile.puts(" #{rt.to_s} emitter_#{clsn}_#{mn}_#{hk}(#{raw_args})")
ofile.puts(" {")
if is_private
@ -2560,7 +2621,7 @@ END
call_args = argnames.join(", ")
ofile.puts("")
ofile.puts(" // [adaptor impl] #{sig}")
ofile.puts(" // [adaptor impl] #{rsig}")
ofile.puts(" #{rt.gsi_decl_return(decl_obj)} cbs_#{mn}_#{hk}_#{i_var}(#{args})" + (const ? " const" : ""))
ofile.puts(" {")
if abstract
@ -2625,6 +2686,7 @@ END
func = bd.type.func
hk = bd.hash_str
sig = bd.sig(cls)
rsig = bd.raw_sig(cls)
mn = decl_obj.myself # ctor!
mn_name = conf.target_name(cls, bd, mn)
@ -2642,7 +2704,7 @@ END
qt_alist = n_args.times.collect { |ia| func.args[ia].renamed_type(alist[ia]).access_qt_arg(decl_obj) }
ofile.puts("")
ofile.puts("// Constructor #{sig} (adaptor class)")
ofile.puts("// Constructor #{rsig} (adaptor class)")
ofile.puts("")
ofile.puts("static void _init_ctor_#{clsn}_Adaptor_#{hk} (qt_gsi::GenericStaticMethod *decl)")
ofile.puts("{")
@ -2664,7 +2726,7 @@ END
ofile.puts("}")
ofile.puts("")
mdecl << "new qt_gsi::GenericStaticMethod (\"#{mn_name}\", \"@brief Constructor #{sig}\\nThis method creates an object of class #{cls}.\", &_init_ctor_#{clsn}_Adaptor_#{hk}, &_call_ctor_#{clsn}_Adaptor_#{hk});"
mdecl << "new qt_gsi::GenericStaticMethod (\"#{mn_name}\", \"@brief Constructor #{rsig}\\nThis method creates an object of class #{cls}.\", &_init_ctor_#{clsn}_Adaptor_#{hk}, &_call_ctor_#{clsn}_Adaptor_#{hk});"
end
@ -2677,6 +2739,7 @@ END
func = bd.type.func
hk = bd.hash_str
sig = bd.sig(cls)
rsig = bd.raw_sig(cls)
const = bd.is_const?
rt = bd.type.return_type
@ -2698,6 +2761,7 @@ END
end
sig = bd_short.sig(cls)
rsig = bd_short.raw_sig(cls)
n_args = func.max_args
n_min_args = func.min_args
@ -2707,7 +2771,7 @@ END
ifc_obj = "GenericMethod"
ofile.puts("")
ofile.puts("// emitter #{sig}")
ofile.puts("// emitter #{rsig}")
ofile.puts("")
ofile.puts("static void _init_emitter_#{mn}_#{hk} (qt_gsi::#{ifc_obj} *decl)")
ofile.puts("{")
@ -2728,7 +2792,7 @@ END
if bd_short.storage_class != :static
const_flag = ", " + const.to_s
end
mdecl << "new qt_gsi::#{ifc_obj} (\"emit_#{mn_name}\", \"@brief Emitter for signal #{sig}\\nCall this method to emit this signal.\"#{const_flag}, &_init_emitter_#{mn}_#{hk}, &_call_emitter_#{mn}_#{hk});"
mdecl << "new qt_gsi::#{ifc_obj} (\"emit_#{mn_name}\", \"@brief Emitter for signal #{rsig}\\nCall this method to emit this signal.\"#{const_flag}, &_init_emitter_#{mn}_#{hk}, &_call_emitter_#{mn}_#{hk});"
elsif !bd.virtual && bd.visibility == :protected
@ -2742,7 +2806,7 @@ END
ifc_obj = bd.storage_class == :static ? "GenericStaticMethod" : "GenericMethod"
ofile.puts("")
ofile.puts("// exposed #{sig}")
ofile.puts("// exposed #{rsig}")
ofile.puts("")
ofile.puts("static void _init_fp_#{mn}_#{hk} (qt_gsi::#{ifc_obj} *decl)")
ofile.puts("{")
@ -2781,7 +2845,7 @@ END
if bd.storage_class != :static
const_flag = ", " + const.to_s
end
mdecl << "new qt_gsi::#{ifc_obj} (\"*#{mn_name}\", \"@brief Method #{sig}\\nThis method is protected and can only be called from inside a derived class.\"#{const_flag}, &_init_fp_#{mn}_#{hk}, &_call_fp_#{mn}_#{hk});"
mdecl << "new qt_gsi::#{ifc_obj} (\"*#{mn_name}\", \"@brief Method #{rsig}\\nThis method is protected and can only be called from inside a derived class.\"#{const_flag}, &_init_fp_#{mn}_#{hk}, &_call_fp_#{mn}_#{hk});"
elsif bd.virtual
@ -2798,7 +2862,7 @@ END
alist = n_args.times.collect { |ia| "arg#{ia + 1}" }
ofile.puts("")
ofile.puts("// #{sig}")
ofile.puts("// #{rsig}")
ofile.puts("")
ofile.puts("static void _init_cbs_#{mn}_#{hk}_#{i_var} (qt_gsi::GenericMethod *decl)")
ofile.puts("{")
@ -2834,7 +2898,7 @@ END
ofile.puts("}")
ofile.puts("")
mdecl << "new qt_gsi::GenericMethod (\"#{pp}#{mn_name}\", \"@brief Virtual method #{sig}\\nThis method can be reimplemented in a derived class.\", #{const.to_s}, &_init_cbs_#{mn}_#{hk}_#{i_var}, &_call_cbs_#{mn}_#{hk}_#{i_var});"
mdecl << "new qt_gsi::GenericMethod (\"#{pp}#{mn_name}\", \"@brief Virtual method #{rsig}\\nThis method can be reimplemented in a derived class.\", #{const.to_s}, &_init_cbs_#{mn}_#{hk}_#{i_var}, &_call_cbs_#{mn}_#{hk}_#{i_var});"
mdecl << "new qt_gsi::GenericMethod (\"#{pp}#{mn_name}\", \"@hide\", #{const.to_s}, &_init_cbs_#{mn}_#{hk}_#{i_var}, &_call_cbs_#{mn}_#{hk}_#{i_var}, &_set_callback_cbs_#{mn}_#{hk}_#{i_var});"
end
@ -2900,152 +2964,6 @@ END
end
def produce_ttfile_traits(ttfile, conf, decl_obj)
(cls, clsn) = make_cls_names(decl_obj)
struct = decl_obj.struct
mm = {}
struct.collect_all_methods(mm, conf)
# if one method is abstract, omit ctors for example
is_abstract = mm.values.find do |m|
m.find { |bd| bd.virtual && bd.type.init == "0" } != nil
end
eq_op = (mm["operator="] || [])[0]
# Note: right now, there is no way to specify type traits globally for nested
# classes because there is no forward declaration of inner classes. In that case we
# use the header
if cls =~ /^(.*?)::/
ttfile.puts("#include <#{$1}>")
else
ttfile.puts("#{struct.kind.to_s} #{cls};")
end
ttfile.puts("namespace tl {")
ttfile.puts "template <> struct type_traits<#{cls}> : public type_traits<void> {"
if !conf.has_copy_ctor?(cls) || is_abstract || (eq_op && eq_op.visibility == :private)
ttfile.puts " typedef tl::false_tag has_copy_constructor;"
end
if !conf.has_default_ctor?(cls) || is_abstract
ttfile.puts " typedef tl::false_tag has_default_constructor;"
end
if (dtor = struct.get_dtor) && dtor.visibility != :public
ttfile.puts " typedef tl::false_tag has_public_destructor;"
end
ttfile.puts "};"
ttfile.puts "}"
ttfile.puts ""
if struct.needs_adaptor(conf)
ttfile.puts("class #{clsn}_Adaptor;")
ttfile.puts("namespace tl {")
ttfile.puts "template <> struct type_traits<#{clsn}_Adaptor> : public type_traits<void> {"
if !conf.has_copy_ctor?(cls) || (eq_op && eq_op.visibility == :private)
ttfile.puts " typedef tl::false_tag has_copy_constructor;"
end
if !conf.has_default_ctor?(cls)
ttfile.puts " typedef tl::false_tag has_default_constructor;"
end
ttfile.puts "};"
ttfile.puts "}"
ttfile.puts ""
end
# walk through the subclasses
(struct.body_decl || []).each do |bd|
if bd.is_a?(CPPStructDeclaration) && bd.visibility == :public && bd.struct.body_decl && bd.myself != "" && !conf.is_class_dropped?(cls, bd.myself)
produce_ttfile_traits(ttfile, conf, bd)
end
end
end
def produce_ttfile(conf)
ttfile_name = "gsiDecl#{modn}TypeTraits.h"
ttfile_path = $gen_dir + "/" + ttfile_name
ttfile_path && File.open(ttfile_path, "w") do |ttfile|
ttfile.puts(<<"END");
/*
KLayout Layout Viewer
Copyright (C) 2006-2021 Matthias Koefferlein
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
END
ttfile.puts("/**")
ttfile.puts("* @file #{ttfile_path}")
ttfile.puts("* @brief Type traits for the Qt binding classes")
ttfile.puts("*")
ttfile.puts("* DO NOT EDIT THIS FILE. ")
ttfile.puts("* This file has been created automatically")
ttfile.puts("*/")
ttfile.puts("")
ttfile.puts("#ifndef _HDR_gsiDecl#{modn}TypeTraits")
ttfile.puts("#define _HDR_gsiDecl#{modn}TypeTraits")
ttfile.puts("")
ttfile.puts("#include \"gsiTypes.h\"")
ttfile.puts("")
ttfile.puts("")
prod_list(conf).each do |decl_obj|
if decl_obj.is_a?(CPPStructDeclaration)
decl_obj.myself && produce_ttfile_traits(ttfile, conf, decl_obj)
elsif decl_obj.is_a?(CPPNamespace)
cls = decl_obj.myself
ttfile.puts("class #{cls}_Namespace;")
ttfile.puts("namespace tl {")
ttfile.puts "template <> struct type_traits<#{cls}_Namespace> : public type_traits<void> {"
ttfile.puts " typedef tl::false_tag has_copy_constructor;"
ttfile.puts " typedef tl::false_tag has_default_constructor;"
ttfile.puts "};"
ttfile.puts("}")
ttfile.puts ""
end
end
ttfile.puts("")
ttfile.puts("#endif")
puts("#{ttfile_name} written.")
end
end
def produce_externals
externals_name = "gsiQtExternals.h"
@ -3253,9 +3171,6 @@ end
puts("Producing class list")
bp.produce_class_list
puts("Producing type traits file ..")
bp.produce_ttfile(conf)
puts("Producing main source file ..")
bp.produce_main_source

13
src/db/db/dbBox.h
View File

@ -1423,19 +1423,6 @@ typedef box<db::DCoord> DBox;
namespace tl
{
/**
* @brief The type traits for the box type
*/
template <class C, class R>
struct type_traits <db::box<C, R> > : public type_traits<void>
{
typedef trivial_relocate_required relocate_requirements;
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
template<> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::Box &b);
template<> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::DBox &b);

8
src/db/db/dbBoxTree.h
View File

@ -74,14 +74,14 @@ private:
/// @brief a helper class providing a linear-time iterator difference which is not necessarily
/// the actual difference but monotonous
template <class X>
size_t box_tree_lt_difference (const tl::reuse_vector_const_iterator<X> &a, const tl::reuse_vector_const_iterator<X> &b)
template <class X, bool R>
size_t box_tree_lt_difference (const tl::reuse_vector_const_iterator<X, R> &a, const tl::reuse_vector_const_iterator<X, R> &b)
{
return a.index () - b.index ();
}
template <class X>
size_t box_tree_lt_difference_ptr (const X *a, const tl::reuse_vector_const_iterator<X> &b)
template <class X, bool R>
size_t box_tree_lt_difference_ptr (const X *a, const tl::reuse_vector_const_iterator<X, R> &b)
{
return a - b.unsafe_target_addr ();
}

11
src/db/db/dbCell.h
View File

@ -1143,16 +1143,5 @@ mem_stat (MemStatistics *stat, MemStatistics::purpose_t purpose, int cat, const
} // namespace db
namespace tl
{
/**
* @brief Type traits
*/
template <> struct type_traits <db::Cell> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
#endif

10
src/db/db/dbColdProxy.h
View File

@ -110,16 +110,6 @@ private:
}
namespace tl
{
template <>
struct type_traits<db::ColdProxy> : public type_traits<void>
{
typedef tl::false_tag has_default_constructor;
typedef tl::false_tag has_copy_constructor;
};
}
#endif

13
src/db/db/dbCompoundOperation.h
View File

@ -1620,17 +1620,4 @@ private:
}
namespace tl
{
template <>
struct type_traits<db::CompoundRegionOperationNode>
: public tl::type_traits<void>
{
typedef false_tag has_copy_constructor;
typedef false_tag has_default_constructor;
};
}
#endif

10
src/db/db/dbDeepShapeStore.h
View File

@ -865,15 +865,5 @@ void DeepLayer::commit_shapes (VarCollector &collector, std::map<db::cell_index_
}
namespace tl
{
// disable copying of the deep shape store object
template <> struct type_traits <db::DeepShapeStore> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
};
}
#endif

13
src/db/db/dbEdge.h
View File

@ -1500,19 +1500,6 @@ public:
namespace tl
{
/**
* @brief The type traits for the edge type
*/
template <class C>
struct type_traits <db::edge<C> > : public type_traits<void>
{
typedef trivial_relocate_required relocate_requirements;
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
template<> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::Edge &b);
template<> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::DEdge &b);

13
src/db/db/dbEdgePair.h
View File

@ -622,19 +622,6 @@ typedef edge_pair<db::DCoord> DEdgePair;
namespace tl
{
/**
* @brief The type traits for the edge type
*/
template <class C>
struct type_traits <db::edge_pair<C> > : public type_traits<void>
{
typedef trivial_relocate_required relocate_requirements;
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
template<> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::EdgePair &b);
template<> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::DEdgePair &b);

16
src/db/db/dbEdgePairs.h
View File

@ -613,21 +613,5 @@ private:
}
namespace tl
{
/**
* @brief The type traits for the box type
*/
template <>
struct type_traits <db::EdgePairs> : public type_traits<void>
{
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
}
#endif

16
src/db/db/dbEdges.h
View File

@ -1210,20 +1210,4 @@ private:
} // namespace db
namespace tl
{
/**
* @brief The type traits for the region type
*/
template <>
struct type_traits <db::Edges> : public type_traits<void>
{
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
}
#endif

13
src/db/db/dbHierProcessor.h
View File

@ -532,18 +532,5 @@ private:
}
namespace tl
{
template <class TS, class TI, class TR>
struct type_traits<db::local_processor<TS, TI, TR> > : public tl::type_traits<void>
{
// mark "LocalProcessor" as not having a default ctor and no copy ctor
typedef tl::false_tag has_default_constructor;
typedef tl::false_tag has_copy_constructor;
};
}
#endif

22
src/db/db/dbLayerProperties.h
View File

@ -229,27 +229,5 @@ inline LayerProperties &operator+= (LayerProperties &props, const LayerOffset &o
}
// tl namespace support for db::LayerProperties
namespace tl
{
template <>
struct type_traits <db::LayerProperties> : public type_traits<void>
{
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
template <>
struct type_traits <db::LayerOffset> : public type_traits<void>
{
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
}
#endif

12
src/db/db/dbLayoutToNetlist.h
View File

@ -1002,16 +1002,4 @@ inline void mem_stat (MemStatistics *stat, MemStatistics::purpose_t purpose, int
}
namespace tl
{
template<> struct type_traits<db::LayoutToNetlist> : public tl::type_traits<void>
{
// mark "NetlistDeviceExtractor" as not having a default ctor and no copy ctor
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
#endif

12
src/db/db/dbLayoutVsSchematic.h
View File

@ -172,16 +172,4 @@ private:
}
namespace tl
{
template<> struct type_traits<db::LayoutVsSchematic> : public tl::type_traits<void>
{
// mark "NetlistDeviceExtractor" as not having a default ctor and no copy ctor
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
#endif

10
src/db/db/dbLibrary.h
View File

@ -231,16 +231,6 @@ private:
}
namespace tl
{
/**
* @brief Type traits
*/
template <> struct type_traits <db::Library> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
};
}
#endif

10
src/db/db/dbManager.h
View File

@ -351,15 +351,5 @@ private:
} // namespace db
namespace tl
{
template <>
struct type_traits <db::Manager> : public type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::true_tag has_default_constructor;
};
}
#endif

4
src/db/db/dbMemStatistics.h
View File

@ -41,8 +41,8 @@
namespace tl
{
template <class X> class vector;
template <class X> class reuse_vector;
template <class> class vector;
template <class, bool> class reuse_vector;
class Variant;
}

18
src/db/db/dbNetlistCompare.h
View File

@ -380,22 +380,4 @@ protected:
}
namespace tl
{
template<> struct type_traits<db::NetlistComparer> : public tl::type_traits<void>
{
// mark "NetlistDeviceExtractor" as having a default ctor and no copy ctor
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistCompareLogger> : public tl::type_traits<void>
{
// mark "NetlistDeviceExtractor" as having a default ctor and no copy ctor
typedef tl::false_tag has_copy_constructor;
};
}
#endif

11
src/db/db/dbNetlistCrossReference.h
View File

@ -312,15 +312,4 @@ private:
}
namespace tl
{
template<> struct type_traits<db::NetlistCrossReference> : public tl::type_traits<void>
{
// mark "NetlistDeviceExtractor" as having a default ctor and no copy ctor
typedef tl::false_tag has_copy_constructor;
};
}
#endif

12
src/db/db/dbNetlistDeviceExtractor.h
View File

@ -571,16 +571,4 @@ private:
}
namespace tl
{
template<> struct type_traits<db::NetlistDeviceExtractor> : public tl::type_traits<void>
{
// mark "NetlistDeviceExtractor" as not having a default ctor and no copy ctor
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
#endif

59
src/db/db/dbNetlistDeviceExtractorClasses.h
View File

@ -405,63 +405,4 @@ protected:
}
namespace tl
{
template<> struct type_traits<db::NetlistDeviceExtractorMOS3Transistor> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistDeviceExtractorMOS4Transistor> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistDeviceExtractorCapacitor> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistDeviceExtractorCapacitorWithBulk> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistDeviceExtractorResistor> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistDeviceExtractorResistorWithBulk> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistDeviceExtractorBJT3Transistor> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistDeviceExtractorBJT4Transistor> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template<> struct type_traits<db::NetlistDeviceExtractorDiode> : public tl::type_traits<void>
{
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
#endif

13
src/db/db/dbNetlistReader.h
View File

@ -52,17 +52,4 @@ public:
}
namespace tl
{
template <>
struct type_traits<db::NetlistReader>
: public tl::type_traits<void>
{
typedef tl::false_tag has_default_constructor;
typedef tl::false_tag has_copy_constructor;
};
}
#endif

13
src/db/db/dbNetlistSpiceReader.h
View File

@ -237,17 +237,4 @@ private:
}
namespace tl
{
template <>
struct type_traits<db::NetlistSpiceReader>
: public tl::type_traits<void>
{
typedef tl::false_tag has_default_constructor;
typedef tl::false_tag has_copy_constructor;
};
}
#endif

13
src/db/db/dbNetlistWriter.h
View File

@ -52,17 +52,4 @@ public:
}
namespace tl
{
template <>
struct type_traits<db::NetlistWriter>
: public tl::type_traits<void>
{
typedef tl::false_tag has_default_constructor;
typedef tl::false_tag has_copy_constructor;
};
}
#endif

11
src/db/db/dbPCellDeclaration.h
View File

@ -535,16 +535,5 @@ private:
}
namespace tl
{
/**
* @brief Type traits
*/
template <> struct type_traits <db::PCellDeclaration> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
#endif

15
src/db/db/dbPath.h
View File

@ -224,7 +224,6 @@ public:
typedef typename coord_traits::area_type area_type;
typedef object_tag< path<C> > tag;
typedef tl::vector<point_type> pointlist_type;
typedef typename tl::type_traits<pointlist_type>::relocate_requirements relocate_requirements;
typedef db::path_point_iterator<path <C>, db::unit_trans<C> > iterator;
/**
@ -1132,20 +1131,6 @@ Path round_path_corners (const Path &input, int rad, int npoints);
namespace tl
{
/**
* @brief The type traits for the path type
*/
template <class C>
struct type_traits <db::path<C> > : public type_traits<void>
{
typedef typename db::path<C>::relocate_requirements relocate_requirements;
typedef true_tag has_efficient_swap;
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
/**
* @brief Special extractors for the paths
*/

10
src/db/db/dbPoint.h
View File

@ -750,16 +750,6 @@ inline bool equal (const tl::vector<point<C> > &a, const tl::vector<point<C> > &
namespace tl
{
template <class C>
struct type_traits <db::point<C> > : public type_traits<void>
{
typedef trivial_relocate_required relocate_requirements;
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
template <> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::Point &p);
template <> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::DPoint &p);

47
src/db/db/dbPolygon.h
View File

@ -1045,24 +1045,6 @@ private:
}
namespace tl
{
/**
* @brief The type traits for the contour type
*/
template <class C>
struct type_traits <db::polygon_contour<C> > : public type_traits<void>
{
// the contour just uses one pointer, hence the relocation requirements are simple
typedef typename tl::trivial_relocate_required relocate_requirements;
typedef true_tag has_efficient_swap;
typedef false_tag supports_extractor;
typedef false_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
}
namespace db
{
@ -1437,7 +1419,6 @@ public:
typedef typename coord_traits::area_type area_type;
typedef polygon_contour<C> contour_type;
typedef tl::vector<contour_type> contour_list_type;
typedef typename tl::type_traits<contour_list_type>::relocate_requirements relocate_requirements;
typedef db::polygon_edge_iterator< polygon<C>, db::unit_trans<C> > polygon_edge_iterator;
typedef db::polygon_contour_iterator< contour_type, db::unit_trans<C> > polygon_contour_iterator;
typedef db::object_tag< polygon<C> > tag;
@ -2439,7 +2420,6 @@ public:
typedef typename coord_traits::area_type area_type;
typedef polygon_contour<C> contour_type;
typedef tl::vector<contour_type> contour_list_type;
typedef typename tl::type_traits<contour_type>::relocate_requirements relocate_requirements;
typedef db::polygon_edge_iterator< simple_polygon<C>, db::unit_trans<C> > polygon_edge_iterator;
typedef db::polygon_contour_iterator< contour_type, db::unit_trans<C> > polygon_contour_iterator;
typedef db::object_tag< simple_polygon<C> > tag;
@ -3568,33 +3548,6 @@ void swap (db::simple_polygon<C> &a, db::simple_polygon<C> &b)
namespace tl
{
/**
* @brief The type traits for the polygon type
*/
template <class C>
struct type_traits <db::polygon<C> > : public type_traits<void>
{
typedef typename db::polygon<C>::relocate_requirements relocate_requirements;
typedef true_tag has_efficient_swap;
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
/**
* @brief The type traits for the simple_polygon type
*/
template <class C>
struct type_traits <db::simple_polygon<C> > : public type_traits<void>
{
typedef typename db::simple_polygon<C>::relocate_requirements relocate_requirements;
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
/**
* @brief Special extractors for the polygons
*/

16
src/db/db/dbRegion.h
View File

@ -1821,21 +1821,5 @@ private:
} // namespace db
namespace tl
{
/**
* @brief The type traits for the region type
*/
template <>
struct type_traits <db::Region> : public type_traits<void>
{
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
}
#endif

16
src/db/db/dbShape.h
View File

@ -786,8 +786,8 @@ public:
* we would probably create too much constness. Hence we use const_cast to convert it
* to a non-const one.
*/
template <class Obj>
Shape (const db::Shapes *shapes, const tl::reuse_vector_const_iterator<Obj> &tree_iter)
template <class Obj, bool R>
Shape (const db::Shapes *shapes, const tl::reuse_vector_const_iterator<Obj, R> &tree_iter)
: mp_shapes (const_cast<db::Shapes *> (shapes)), m_with_props (false), m_stable (true)
{
typename Obj::tag tag = typename Obj::tag ();
@ -800,8 +800,8 @@ public:
/**
* @brief Construct as a proxy to a certain object given by an iterator
*/
template <class Obj>
Shape (db::Shapes *shapes, const tl::reuse_vector_const_iterator<Obj> &tree_iter)
template <class Obj, bool R>
Shape (db::Shapes *shapes, const tl::reuse_vector_const_iterator<Obj, R> &tree_iter)
: mp_shapes (shapes), m_with_props (false), m_stable (true)
{
typename Obj::tag tag = typename Obj::tag ();
@ -818,8 +818,8 @@ public:
* we would probably create too much constness. Hence we use const_cast to convert it
* to a non-const one.
*/
template <class Obj, class Trans>
Shape (const db::Shapes *shapes, const tl::reuse_vector_const_iterator<Obj> &tree_iter, const Trans &trans)
template <class Obj, bool R, class Trans>
Shape (const db::Shapes *shapes, const tl::reuse_vector_const_iterator<Obj, R> &tree_iter, const Trans &trans)
: mp_shapes (const_cast<db::Shapes *> (shapes)), m_with_props (false), m_stable (true)
{
typename Obj::tag tag = typename Obj::tag ();
@ -832,8 +832,8 @@ public:
/**
* @brief Construct as a proxy to a certain object given by an iterator
*/
template <class Obj, class Trans>
Shape (db::Shapes *shapes, const tl::reuse_vector_const_iterator<Obj> &tree_iter, const Trans &trans)
template <class Obj, bool R, class Trans>
Shape (db::Shapes *shapes, const tl::reuse_vector_const_iterator<Obj, R> &tree_iter, const Trans &trans)
: mp_shapes (shapes), m_with_props (false), m_stable (true)
{
typename Obj::tag tag = typename Obj::tag ();

12
src/db/db/dbShapeCollection.h
View File

@ -100,16 +100,4 @@ public:
}
namespace tl
{
template<> struct type_traits<db::ShapeCollection> : public tl::type_traits<void>
{
// mark "NetlistDeviceExtractor" as having a default ctor and no copy ctor
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
#endif

11
src/db/db/dbTechnology.h
View File

@ -874,16 +874,5 @@ public:
}
namespace tl
{
/**
* @brief Type traits
*/
template <> struct type_traits <db::TechnologyComponent> : public type_traits<void> {
typedef tl::false_tag has_default_constructor;
typedef tl::false_tag has_copy_constructor;
};
}
#endif

9
src/db/db/dbText.h
View File

@ -1125,15 +1125,6 @@ inline void mem_stat (MemStatistics *stat, MemStatistics::purpose_t purpose, int
namespace tl
{
template <class C>
struct type_traits <db::text<C> > : public type_traits<void>
{
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
template<> void DB_PUBLIC extractor_impl (tl::Extractor &ex, db::Text &p);
template<> void DB_PUBLIC extractor_impl (tl::Extractor &ex, db::DText &p);

16
src/db/db/dbTexts.h
View File

@ -618,21 +618,5 @@ private:
}
namespace tl
{
/**
* @brief The type traits for the box type
*/
template <>
struct type_traits <db::Texts> : public type_traits<void>
{
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
}
#endif

10
src/db/db/dbTilingProcessor.h
View File

@ -703,15 +703,5 @@ private:
}
namespace tl
{
template <>
struct type_traits<db::TilingProcessor> : public type_traits<void>
{
typedef tl::true_tag has_default_constructor;
typedef tl::false_tag has_copy_constructor;
};
}
#endif

13
src/db/db/dbUserObject.h
View File

@ -520,19 +520,6 @@ typedef tl::RegisteredClass<user_object_factory_base<db::DCoord> > DUserObjectDe
} // namespace db
namespace tl
{
/**
* @brief The type traits for the user object type
*/
template <class C>
struct type_traits <db::user_object<C> > : public type_traits<void>
{
typedef trivial_relocate_required relocate_requirements;
typedef true_tag has_efficient_swap;
};
}
// inject a swap specialization into the std namespace:
namespace std
{

9
src/db/db/dbVector.h
View File

@ -713,15 +713,6 @@ struct from_double_vector
namespace tl
{
template <class C>
struct type_traits <db::vector<C> > : public type_traits<void>
{
typedef true_tag supports_extractor;
typedef true_tag supports_to_string;
typedef true_tag has_less_operator;
typedef true_tag has_equal_operator;
};
template <> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::Vector &p);
template <> DB_PUBLIC void extractor_impl (tl::Extractor &ex, db::DVector &p);

18
src/db/db/gsiDeclDbLayoutDiff.cc
View File

@ -369,24 +369,6 @@ private:
int m_layer_index_b;
};
}
namespace tl
{
// Disable copy and default ctor for layout query
template <>
struct type_traits<LayoutDiff>
: public type_traits<void>
{
typedef false_tag has_copy_constructor;
};
}
namespace gsi
{
static unsigned int f_silent () {
return db::layout_diff::f_silent;
}

23
src/db/db/gsiDeclDbLayoutQuery.cc
View File

@ -24,29 +24,6 @@
#include "gsiDecl.h"
#include "dbLayoutQuery.h"
namespace tl
{
// Disable copy and default ctor for layout query
template <>
struct type_traits<db::LayoutQuery>
: public type_traits<void>
{
typedef false_tag has_copy_constructor;
typedef false_tag has_default_constructor;
};
// Disable copy and default ctor for layout query
template <>
struct type_traits<db::LayoutQueryIterator>
: public type_traits<void>
{
typedef false_tag has_copy_constructor;
typedef false_tag has_default_constructor;
};
}
namespace gsi
{

5
src/db/db/gsiDeclDbNetlistCompare.cc
View File

@ -316,11 +316,6 @@ private:
}
namespace tl
{
template<> struct type_traits<GenericNetlistCompareLogger> : public tl::type_traits<db::NetlistCompareLogger> { };
}
namespace gsi
{

23
src/db/db/gsiDeclDbNetlistDeviceExtractor.cc
View File

@ -93,26 +93,6 @@ public:
gsi::Callback cb_extract_devices;
};
}
namespace tl
{
template<> struct type_traits<GenericDeviceExtractor> : public tl::type_traits<void>
{
// mark "NetlistDeviceExtractor" as having a default ctor and no copy ctor
typedef tl::false_tag has_copy_constructor;
typedef tl::true_tag has_default_constructor;
};
}
namespace gsi
{
namespace
{
/**
* @brief A DeviceClassFactory implementation that allows reimplementation of the virtual methods
*/
@ -140,6 +120,9 @@ public:
}
namespace gsi
{
Class<DeviceClassFactoryImpl> decl_dbDeviceClassFactoryBase ("db", "DeviceClassFactory",
gsi::factory_callback ("create_class", &DeviceClassFactoryImpl::create_class, &DeviceClassFactoryImpl::cb_create_class,
"@brief Creates the DeviceClass object\n"

380
src/gsi/gsi/gsiClass.h
View File

@ -44,74 +44,53 @@ namespace gsi
/**
* @brief A helper function to implement equal as efficiently as possible
*/
template<class T, class I>
bool _var_user_equal_impl (const T *a, const T *b, const VariantUserClassImpl *delegate, I);
template<class T, bool> struct _var_user_equal_impl;
template<class T>
bool _var_user_equal_impl (const T *a, const T *b, const VariantUserClassImpl * /*delegate*/, tl::true_tag)
struct _var_user_equal_impl<T, true>
{
return *a == *b;
}
static bool call (const T *a, const T *b, const VariantUserClassImpl * /*delegate*/) { return *a == *b; }
};
template<class T>
bool _var_user_equal_impl (const T *a, const T *b, const VariantUserClassImpl *delegate, tl::false_tag)
struct _var_user_equal_impl<T, false>
{
return delegate->equal_impl ((void *) a, (void *) b);
}
static bool call (const T *a, const T *b, const VariantUserClassImpl *delegate) { return delegate->equal_impl ((void *) a, (void *) b); }
};
/**
* @brief A helper function to implement less as efficiently as possible
* @brief A helper function to implement equal as efficiently as possible
*/
template<class T, class I>
bool _var_user_less_impl (const T *a, const T *b, const VariantUserClassImpl *delegate, I);
template<class T, bool> struct _var_user_less_impl;
template<class T>
bool _var_user_less_impl (const T *a, const T *b, const VariantUserClassImpl * /*delegate*/, tl::true_tag)
struct _var_user_less_impl<T, true>
{
return *a < *b;
}
static bool call (const T *a, const T *b, const VariantUserClassImpl * /*delegate*/) { return *a < *b; }
};
template<class T>
bool _var_user_less_impl (const T *a, const T *b, const VariantUserClassImpl *delegate, tl::false_tag)
struct _var_user_less_impl<T, false>
{
return delegate->less_impl ((void *) a, (void *) b);
}
static bool call (const T *a, const T *b, const VariantUserClassImpl *delegate) { return delegate->less_impl ((void *) a, (void *) b); }
};
/**
* @brief A helper function to implement to_string as efficiently as possible
* @brief A helper function to implement equal as efficiently as possible
*/
template<class T, class I>
std::string _var_user_to_string_impl (const T *a, const VariantUserClassImpl *delegate, I);
template<class T, bool> struct _var_user_to_string_impl;
template<class T>
std::string _var_user_to_string_impl (const T *a, const VariantUserClassImpl * /*delegate*/, tl::true_tag)
struct _var_user_to_string_impl<T, true>
{
return a->to_string ();
}
static std::string call (const T *a, const VariantUserClassImpl * /*delegate*/) { return a->to_string (); }
};
template<class T>
std::string _var_user_to_string_impl (const T *a, const VariantUserClassImpl *delegate, tl::false_tag)
struct _var_user_to_string_impl<T, false>
{
return delegate->to_string_impl ((void *) a);
}
/**
* @brief A helper function to implement read as efficiently as possible
*/
template<class T, class I>
void _var_user_read_impl (T *a, tl::Extractor &ex, I);
template<class T>
void _var_user_read_impl (T *a, tl::Extractor &ex, tl::true_tag)
{
ex.read (*a);
}
template<class T>
void _var_user_read_impl (T * /*a*/, tl::Extractor & /*ex*/, tl::false_tag)
{
tl_assert (false);
}
static std::string call (const T *a, const VariantUserClassImpl *delegate) { return delegate->to_string_impl ((void *) a); }
};
/**
* @brief A VariantUserClassBase specialization that links GSI classes and Variant classes
@ -165,20 +144,17 @@ public:
virtual bool equal (const void *a, const void *b) const
{
typename tl::type_traits<T>::has_equal_operator f;
return gsi::_var_user_equal_impl ((const T *) a, (const T *) b, this, f);
return gsi::_var_user_equal_impl<T, tl::has_equal_operator<T>::value>::call ((const T *) a, (const T *) b, this);
}
virtual bool less (const void *a, const void *b) const
{
typename tl::type_traits<T>::has_less_operator f;
return gsi::_var_user_less_impl ((const T *) a, (const T *) b, this, f);
return gsi::_var_user_less_impl<T, tl::has_less_operator<T>::value>::call ((const T *) a, (const T *) b, this);
}
virtual std::string to_string (const void *a) const
{
typename tl::type_traits<T>::supports_to_string f;
return gsi::_var_user_to_string_impl ((const T *) a, this, f);
return gsi::_var_user_to_string_impl<T, tl::has_to_string<T>::value>::call ((const T *) a, this);
}
void *clone (const void *obj) const
@ -212,8 +188,8 @@ public:
void read (void *a, tl::Extractor &ex) const
{
typename tl::type_traits<T>::supports_extractor f;
gsi::_var_user_read_impl ((T *) a, ex, f);
T *t = (T *) a;
ex.read (*t);
}
const gsi::ClassBase *gsi_cls () const
@ -244,256 +220,21 @@ private:
// -----------------------------------------------------------------------------
// GSI implementation
template <class X>
void *_get_vector_of (SerialArgs & /*from*/, const ArgType & /*a*/, void * /*data*/, void (* /*cb*/) (void * /*data*/, void * /*obj*/), tl::false_tag /*has_copy_ctor*/)
{
tl_assert (false); // cannot copy object of this type
return 0;
}
template <class X, bool> struct _destroy;
template <class X> struct _destroy<X, false> { static void call (X *) { tl_assert (false); } };
template <class X> struct _destroy<X, true> { static void call (X *x) { delete x; } };
template <class X>
void _get_vector_of (SerialArgs &from, const ArgType &a, void *data, void (*cb) (void *data, void *obj), tl::true_tag /*has_copy_ctor*/)
{
std::vector<X> vv;
const std::vector<X> *v = &vv;
if (a.is_cref ()) {
v = &from.template read<const std::vector<X> &> ();
} else if (a.is_cptr ()) {
v = from.template read<const std::vector<X> *> ();
} else if (a.is_ref ()) {
v = &from.template read<std::vector<X> &> ();
} else if (a.is_ptr ()) {
v = from.template read<std::vector<X> *> ();
} else {
vv = from.template read< std::vector<X> > ();
}
for (typename std::vector<X>::const_iterator o = v->begin (); o != v->end (); ++o) {
(*cb) (data, new X (*o));
}
}
template <class X, bool> struct _create;
template <class X> struct _create<X, false> { static void *call () { throw tl::Exception (tl::to_string (tr ("Object cannot be created here"))); } };
template <class X> struct _create<X, true> { static void *call () { return new X (); } };
template <class X>
void _get_cptr_vector_of (SerialArgs &from, const ArgType &a, void *data, void (*cb) (void *data, void *obj))
{
std::vector<const X *> vv;
const std::vector<const X *> *v = &vv;
if (a.is_cref ()) {
v = &from.template read<const std::vector<const X *> &> ();
} else if (a.is_cptr ()) {
v = from.template read<const std::vector<const X *> *> ();
} else if (a.is_ref ()) {
v = &from.template read<std::vector<const X *> &> ();
} else if (a.is_ptr ()) {
v = from.template read<std::vector<const X *> *> ();
} else {
vv = from.template read< std::vector<const X *> > ();
}
for (typename std::vector<const X *>::const_iterator o = v->begin (); o != v->end (); ++o) {
(*cb) (data, (void *) *o);
}
}
template <class X, bool> struct _clone;
template <class X> struct _clone<X, false> { static void *call (const void *) { throw tl::Exception (tl::to_string (tr ("Object cannot be copied here"))); } };
template <class X> struct _clone<X, true> { static void *call (const void *other) { new X (*(const X *)other); } };
template <class X>
void _get_ptr_vector_of (SerialArgs &from, const ArgType &a, void *data, void (*cb) (void *data, void *obj))
{
std::vector<X *> vv;
const std::vector<X *> *v = &vv;
if (a.is_cref ()) {
v = &from.template read<const std::vector<X *> &> ();
} else if (a.is_cptr ()) {
v = from.template read<const std::vector<X *> *> ();
} else if (a.is_ref ()) {
v = &from.template read<std::vector<X *> &> ();
} else if (a.is_ptr ()) {
v = from.template read<std::vector<X *> *> ();
} else {
vv = from.template read< std::vector<X *> > ();
}
for (typename std::vector<X *>::const_iterator o = v->begin (); o != v->end (); ++o) {
(*cb) (data, *o);
}
}
template <class X>
void _destroy (X *, tl::false_tag /*has public dtor*/)
{
tl_assert (false); // cannot delete object of this type
}
template <class X>
void _destroy (X *x, tl::true_tag /*has public dtor*/)
{
delete x;
}
template <class X>
void _push_vector_of (SerialArgs & /*to*/, const ArgType & /*a*/, tl::Heap & /*heap*/, const std::vector<void *> & /*objects*/, tl::false_tag /*has_copy_ctor*/)
{
tl_assert (false); // cannot copy object of this type
}
template <class X>
void _push_vector_of (SerialArgs &to, const ArgType &a, tl::Heap &heap, const std::vector<void *> &objects, tl::true_tag /*has_copy_ctor*/)
{
tl_assert (a.inner () != 0);
std::vector<X> vv;
std::vector<X> *v;
if (a.is_ref () || a.is_cref () || a.is_ptr () || a.is_cptr ()) {
v = new std::vector<X> ();
heap.push (v);
} else {
v = &vv;
}
v->reserve (objects.size ());
for (std::vector<void *>::const_iterator o = objects.begin (); o != objects.end (); ++o) {
v->push_back (*(X *)*o);
}
if (a.is_cref ()) {
to.write<const std::vector<X> &> (*v);
} else if (a.is_cptr ()) {
to.write<const std::vector<X> *> (v);
} else if (a.is_ref ()) {
to.write<std::vector<X> &> (*v);
} else if (a.is_ptr ()) {
to.write<std::vector<X> *> (v);
} else {
to.write<std::vector<X> > (vv);
}
}
template <class X>
void _push_cptr_vector_of (SerialArgs &to, const ArgType &a, tl::Heap &heap, const std::vector<void *> &objects)
{
tl_assert (a.inner () != 0);
std::vector<const X *> vv;
std::vector<const X *> *v;
if (a.is_ref () || a.is_cref () || a.is_ptr () || a.is_cptr ()) {
v = new std::vector<const X *> ();
heap.push (v);
} else {
v = &vv;
}
v->reserve (objects.size ());
for (std::vector<void *>::const_iterator o = objects.begin (); o != objects.end (); ++o) {
v->push_back ((const X *)*o);
}
if (a.is_cref ()) {
to.write<const std::vector<const X *> &> (*v);
} else if (a.is_cptr ()) {
to.write<const std::vector<const X *> *> (v);
} else if (a.is_ref ()) {
to.write<std::vector<const X *> &> (*v);
} else if (a.is_ptr ()) {
to.write<std::vector<const X *> *> (v);
} else {
to.write<std::vector<const X *> > (vv);
}
}
template <class X>
void _push_ptr_vector_of (SerialArgs &to, const ArgType &a, tl::Heap &heap, const std::vector<void *> &objects)
{
tl_assert (a.inner () != 0);
std::vector<X *> vv;
std::vector<X *> *v;
if (a.is_ref () || a.is_cref () || a.is_ptr () || a.is_cptr ()) {
v = new std::vector<X *> ();
heap.push (v);
} else {
v = &vv;
}
v->reserve (objects.size ());
for (std::vector<void *>::const_iterator o = objects.begin (); o != objects.end (); ++o) {
v->push_back ((X *)*o);
}
if (a.is_cref ()) {
to.write<const std::vector<X *> &> (*v);
} else if (a.is_cptr ()) {
to.write<const std::vector<X *> *> (v);
} else if (a.is_ref ()) {
to.write<std::vector<X *> &> (*v);
} else if (a.is_ptr ()) {
to.write<std::vector<X *> *> (v);
} else {
to.write<std::vector<X *> > (vv);
}
}
template <class X>
void *_create (tl::false_tag)
{
throw tl::Exception (tl::to_string (tr ("Object cannot be created here")));
return 0;
}
template <class X>
void *_create (tl::true_tag)
{
return new X ();
}
template <class X>
void *_clone (tl::false_tag, const void * /*other*/)
{
throw tl::Exception (tl::to_string (tr ("Object cannot be copied here")));
return 0;
}
template <class X>
void *_clone (tl::true_tag, const void *other)
{
return new X (*(const X *)other);
}
template <class X>
void _assign (tl::false_tag /*has_copy_ctor*/, void *, const void *)
{
throw tl::Exception (tl::to_string (tr ("Object cannot be copied here")));
}
template <class X>
void _assign (tl::true_tag /*has_copy_ctor*/, void *dest, const void *src)
{
*(X *)dest = *(const X *)src;
}
/**
* @brief A class predicate telling us whether X is polymorphic
*
* The trick was taken from boost - if a class is made polymorphic and it
* has not been before, the size of the object changes since a virtual
* function table will be added.
*/
template <class X>
struct is_polymorphic
{
private:
struct P1 : public X
{
P1 ();
~P1 ();
int something;
};
struct P2 : public X
{
P2 ();
virtual ~P2 ();
int something;
};
public:
typedef typename tl::boolean_value<sizeof (P1) == sizeof (P2)>::value value;
};
template <class X, bool> struct _assign;
template <class X> struct _assign<X, false> { static void call (void *, const void *) { throw tl::Exception (tl::to_string (tr ("Object cannot be copied here"))); } };
template <class X> struct _assign<X, true> { static void call (void *dest, const void *src) { *(X *)dest = *(const X *)src; } };
/**
* @brief A helper class which tests whether a given object can be upcast
@ -513,14 +254,14 @@ public:
* The can_upcast method will return true, if the object (which has at least to
* be of type B) can be upcast to X.
*/
template <class X, class B, class B_IS_POLYMORPHIC>
template <class X, class B, bool B_IS_POLYMORPHIC>
class SubClassTester;
/**
* @brief Specialization for polymorphic types - we can use dynamic_cast to tests whether B object can be cast to X
*/
template <class X, class B>
class SubClassTester<X, B, tl::true_tag>
class SubClassTester<X, B, true>
: public SubClassTesterBase
{
public:
@ -534,7 +275,7 @@ public:
* @brief Specialization for non-polymorphic types
*/
template <class X, class B>
class SubClassTester<X, B, tl::false_tag>
class SubClassTester<X, B, false>
: public SubClassTesterBase
{
public:
@ -556,10 +297,6 @@ class GSI_PUBLIC_TEMPLATE ClassExt
: public ClassBase
{
public:
typedef typename tl::type_traits<X>::has_copy_constructor has_copy_ctor;
typedef typename tl::type_traits<X>::has_default_constructor has_default_ctor;
typedef typename tl::type_traits<X>::has_public_destructor has_public_dtor;
ClassExt (const Methods &mm, const std::string &doc = std::string ())
: ClassBase (doc, mm), mp_declaration (0)
{
@ -713,10 +450,6 @@ class GSI_PUBLIC_TEMPLATE Class
: public ClassBase
{
public:
typedef typename tl::type_traits<X>::has_copy_constructor has_copy_ctor;
typedef typename tl::type_traits<X>::has_default_constructor has_default_ctor;
typedef typename tl::type_traits<X>::has_public_destructor has_public_dtor;
Class (const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string (), bool do_register = true)
: ClassBase (doc, mm, do_register)
{
@ -726,7 +459,7 @@ public:
template <class B>
Class (const Class<B> &base, const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string (), bool do_register = true)
: ClassBase (doc, mm, do_register), m_subclass_tester (new SubClassTester<X, B, typename is_polymorphic<B>::value> ())
: ClassBase (doc, mm, do_register), m_subclass_tester (new SubClassTester<X, B, std::is_polymorphic<B>::value> ())
{
set_module (module);
set_name (name);
@ -742,7 +475,7 @@ public:
template <class B>
Class (const Class<B> &base, const std::string &module, const std::string &name, const std::string &doc = std::string (), bool do_register = true)
: ClassBase (doc, Methods (), do_register), m_subclass_tester (new SubClassTester<X, B, typename is_polymorphic<B>::value> ())
: ClassBase (doc, Methods (), do_register), m_subclass_tester (new SubClassTester<X, B, std::is_polymorphic<B>::value> ())
{
set_module (module);
set_name (name);
@ -785,15 +518,12 @@ public:
virtual void destroy (void *p) const
{
X *x = (X *)p;
has_public_dtor hpd;
_destroy (x, hpd);
_destroy<X, std::is_destructible<X>::value>::call (x);
}
virtual void *create () const
{
has_default_ctor cst;
void *r = _create<X> (cst);
return r;
return _create<X, std::is_default_constructible<X>::value>::call ();
}
virtual void *create_from_adapted (const void *x) const
@ -818,33 +548,27 @@ public:
virtual void *clone (const void *other) const
{
has_copy_ctor cst;
void *r = _clone<X> (cst, other);
return r;
return _clone<X, std::is_copy_constructible<X>::value>::call (other);
}
virtual void assign (void *dest, const void *src) const
{
has_copy_ctor cst;
_assign<X> (cst, dest, src);
_assign<X, std::is_copy_assignable<X>::value>::call (dest, src);
}
virtual bool can_destroy () const
{
has_public_dtor hpd;
return tl::value_of (hpd);
return std::is_destructible<X>::value;
}
virtual bool can_copy () const
{
has_copy_ctor cpt;
return tl::value_of (cpt);
return std::is_copy_constructible<X>::value;
}
virtual bool can_default_create () const
{
has_default_ctor cpt;
return tl::value_of (cpt);
return std::is_default_constructible<X>::value;
}
virtual const ClassBase *subclass_decl (const void *p) const

11
src/gsi/gsi/gsiDeclBasic.cc
View File

@ -26,17 +26,6 @@
#include "gsiDecl.h"
#include "tlTypeTraits.h"
namespace tl
{
template <> struct type_traits<gsi::Interpreter>
: tl::type_traits<void>
{
typedef false_tag has_copy_constructor;
typedef false_tag has_default_constructor;
typedef false_tag has_public_destructor;
};
}
namespace gsi
{

15
src/gsi/gsi/gsiDeclInternal.cc
View File

@ -23,21 +23,6 @@
#include "gsiDecl.h"
namespace tl
{
template <> struct type_traits<gsi::ClassBase> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
template <> struct type_traits<gsi::MethodBase> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
namespace gsi
{

45
src/gsi/gsi/gsiDeclTl.cc
View File

@ -77,18 +77,6 @@ public:
}
};
}
namespace tl {
template <> struct type_traits<gsi::Logger> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
typedef tl::false_tag has_default_constructor;
};
}
namespace gsi
{
Class<Logger> decl_Logger ("tl", "Logger",
gsi::method ("info", &Logger::info, gsi::arg ("msg"),
"@brief Writes the given string to the info channel\n"
@ -464,6 +452,8 @@ private:
std::unique_ptr<tl::Expression> mp_expr;
};
}
static tl::Variant eval_expr (const std::string &e)
{
ExpressionWrapper expr;
@ -488,17 +478,6 @@ static ExpressionWrapper *new_expr2 (const std::string &e, const std::map<std::s
return expr.release ();
}
}
namespace tl {
template <> struct type_traits<ExpressionWrapper> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
typedef tl::true_tag has_default_constructor;
};
}
namespace gsi
{
@ -661,16 +640,6 @@ public:
gsi::Callback cleanup_cb;
};
}
namespace tl
{
template <> struct type_traits<gsi::Executable_Impl> : public type_traits<tl::Executable> { };
}
namespace gsi
{
Class<tl::Executable> decl_Executable ("tl", "ExecutableBase",
gsi::Methods (),
"@hide\n@alias Executable"
@ -719,16 +688,6 @@ public:
gsi::Callback executable_cb;
};
}
namespace tl
{
template <> struct type_traits<gsi::Recipe_Impl> : public type_traits<tl::Recipe> { };
}
namespace gsi
{
static Recipe_Impl *make_recipe (const std::string &name, const std::string &description)
{
return new Recipe_Impl (name, description);

50
src/gsi/gsi/gsiTypes.h
View File

@ -1144,7 +1144,7 @@ public:
/**
* @brief An implementation helper that provides a switch between classes having and having no copy ctor
*/
template <class T, class CC>
template <class T, bool>
class ArgSpecImpl
: public ArgSpecBase
{
@ -1189,7 +1189,7 @@ public:
* @brief A specialization for classes with default and copy ctor
*/
template <class T>
class ArgSpecImpl<T, tl::true_tag>
class ArgSpecImpl<T, true>
: public ArgSpecBase
{
public:
@ -1289,30 +1289,30 @@ private:
*/
template <class T>
class ArgSpec
: public ArgSpecImpl<T, typename tl::type_traits<T>::has_copy_constructor>
: public ArgSpecImpl<T, std::is_copy_constructible<T>::value && std::is_destructible<T>::value>
{
public:
typedef typename tl::type_traits<T>::has_copy_constructor cc_type;
typedef ArgSpecImpl<T, std::is_copy_constructible<T>::value && std::is_destructible<T>::value> Base;
ArgSpec ()
: ArgSpecImpl<T, cc_type> ()
: Base ()
{ }
ArgSpec (const ArgSpec<void> &other)
: ArgSpecImpl<T, cc_type> (other)
: Base (other)
{ }
template <class Q>
ArgSpec (const ArgSpec<Q> &other)
: ArgSpecImpl<T, cc_type> (other)
: Base (other)
{ }
ArgSpec (const std::string &name)
: ArgSpecImpl<T, cc_type> (name)
: Base (name)
{ }
ArgSpec (const std::string &name, const T &init, const std::string &init_doc = std::string ())
: ArgSpecImpl<T, cc_type> (name, init, init_doc)
: Base (name, init, init_doc)
{ }
virtual ArgSpecBase *clone () const
@ -1326,30 +1326,30 @@ public:
*/
template <class T>
class ArgSpec<const T &>
: public ArgSpecImpl<T, typename tl::type_traits<T>::has_copy_constructor>
: public ArgSpecImpl<T, std::is_copy_constructible<T>::value && std::is_destructible<T>::value>
{
public:
typedef typename tl::type_traits<T>::has_copy_constructor cc_type;
typedef ArgSpecImpl<T, std::is_copy_constructible<T>::value && std::is_destructible<T>::value> Base;
ArgSpec ()
: ArgSpecImpl<T, cc_type> ()
ArgSpec ()
: Base ()
{ }
ArgSpec (const ArgSpec<void> &other)
: ArgSpecImpl<T, cc_type> (other)
: Base (other)
{ }
template <class Q>
ArgSpec (const ArgSpec<Q> &other)
: ArgSpecImpl<T, cc_type> (other)
: Base (other)
{ }
ArgSpec (const std::string &name)
: ArgSpecImpl<T, cc_type> (name)
: Base (name)
{ }
ArgSpec (const std::string &name, const T &init, const std::string &init_doc = std::string ())
: ArgSpecImpl<T, cc_type> (name, init, init_doc)
: Base (name, init, init_doc)
{ }
virtual ArgSpecBase *clone () const
@ -1363,37 +1363,37 @@ public:
*/
template <class T>
class ArgSpec<T &>
: public ArgSpecImpl<T, typename tl::type_traits<T>::has_copy_constructor>
: public ArgSpecImpl<T, std::is_copy_constructible<T>::value && std::is_destructible<T>::value>
{
public:
typedef ArgSpecImpl<T, std::is_copy_constructible<T>::value && std::is_destructible<T>::value> Base;
typedef T &init_type;
typedef typename tl::type_traits<T>::has_copy_constructor cc_type;
ArgSpec ()
: ArgSpecImpl<T, cc_type> ()
: Base ()
{ }
ArgSpec (const ArgSpec<void> &other)
: ArgSpecImpl<T, cc_type> (other)
: Base (other)
{ }
template <class Q>
ArgSpec (const ArgSpec<Q> &other)
: ArgSpecImpl<T, cc_type> (other)
: Base (other)
{ }
ArgSpec (const std::string &name)
: ArgSpecImpl<T, cc_type> (name)
: Base (name)
{ }
ArgSpec (const std::string &name, const T &init, const std::string &init_doc = std::string ())
: ArgSpecImpl<T, cc_type> (name, init, init_doc)
: Base (name, init, init_doc)
{ }
T &init () const
{
// this simplifies the implementation, but it's not really clean since the caller may modify the default.
return const_cast<T &> (ArgSpecImpl<T, cc_type>::init ());
return const_cast<T &> (ArgSpecImpl<T, std::is_copy_constructible<T>::value>::init ());
}
virtual ArgSpecBase *clone () const

12
src/gsi/gsi_test/gsiTest.h
View File

@ -1273,17 +1273,5 @@ private:
}
namespace tl
{
template <> struct type_traits<gsi_test::A_NC> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
};
#if defined(HAVE_QT)
template <> struct type_traits<gsi_test::SQ> : public type_traits<void> {
typedef tl::false_tag has_copy_constructor;
};
#endif
}
#endif

15
src/gsiqt/gsiqt.pro
View File

@ -2,11 +2,16 @@
TEMPLATE = subdirs
SUBDIRS = qtbasic
greaterThan(QT_MAJOR_VERSION, 4) {
SUBDIRS += qt5
qt5.depends += qtbasic
greaterThan(QT_MAJOR_VERSION, 5) {
SUBDIRS += qt6
qt6.depends += qtbasic
} else {
SUBDIRS += qt4
qt4.depends += qtbasic
greaterThan(QT_MAJOR_VERSION, 4) {
SUBDIRS += qt5
qt5.depends += qtbasic
} else {
SUBDIRS += qt4
qt4.depends += qtbasic
}
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAbstractAnimation.cc
View File

@ -346,7 +346,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -358,7 +358,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractAnimation::tr (arg1, arg2, arg3));
}
@ -371,7 +371,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -383,7 +383,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractAnimation::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAbstractEventDispatcher.cc
View File

@ -432,7 +432,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -444,7 +444,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractEventDispatcher::tr (arg1, arg2, arg3));
}
@ -457,7 +457,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -469,7 +469,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractEventDispatcher::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAbstractItemModel.cc
View File

@ -1002,7 +1002,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -1014,7 +1014,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractItemModel::tr (arg1, arg2, arg3));
}
@ -1027,7 +1027,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -1039,7 +1039,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractItemModel::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAbstractListModel.cc
View File

@ -182,7 +182,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -194,7 +194,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractListModel::tr (arg1, arg2, arg3));
}
@ -207,7 +207,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -219,7 +219,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractListModel::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAbstractProxyModel.cc
View File

@ -641,7 +641,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -653,7 +653,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractProxyModel::tr (arg1, arg2, arg3));
}
@ -666,7 +666,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -678,7 +678,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractProxyModel::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAbstractState.cc
View File

@ -109,7 +109,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -121,7 +121,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractState::tr (arg1, arg2, arg3));
}
@ -134,7 +134,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -146,7 +146,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractState::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAbstractTableModel.cc
View File

@ -182,7 +182,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -194,7 +194,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractTableModel::tr (arg1, arg2, arg3));
}
@ -207,7 +207,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -219,7 +219,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractTableModel::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAbstractTransition.cc
View File

@ -256,7 +256,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -268,7 +268,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractTransition::tr (arg1, arg2, arg3));
}
@ -281,7 +281,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -293,7 +293,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAbstractTransition::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAnimationDriver.cc
View File

@ -175,7 +175,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -187,7 +187,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAnimationDriver::tr (arg1, arg2, arg3));
}
@ -200,7 +200,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -212,7 +212,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAnimationDriver::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQAnimationGroup.cc
View File

@ -214,7 +214,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -226,7 +226,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAnimationGroup::tr (arg1, arg2, arg3));
}
@ -239,7 +239,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -251,7 +251,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QAnimationGroup::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQBuffer.cc
View File

@ -323,7 +323,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -335,7 +335,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QBuffer::tr (arg1, arg2, arg3));
}
@ -348,7 +348,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -360,7 +360,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QBuffer::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQCoreApplication.cc
View File

@ -824,7 +824,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -836,7 +836,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QCoreApplication::tr (arg1, arg2, arg3));
}
@ -849,7 +849,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -861,7 +861,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QCoreApplication::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQEventLoop.cc
View File

@ -209,7 +209,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -221,7 +221,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QEventLoop::tr (arg1, arg2, arg3));
}
@ -234,7 +234,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -246,7 +246,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QEventLoop::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQEventTransition.cc
View File

@ -136,7 +136,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -148,7 +148,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QEventTransition::tr (arg1, arg2, arg3));
}
@ -161,7 +161,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -173,7 +173,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QEventTransition::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQFile.cc
View File

@ -617,7 +617,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -629,7 +629,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFile::tr (arg1, arg2, arg3));
}
@ -642,7 +642,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -654,7 +654,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFile::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQFileDevice.cc
View File

@ -286,7 +286,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -298,7 +298,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFileDevice::tr (arg1, arg2, arg3));
}
@ -311,7 +311,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -323,7 +323,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFileDevice::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQFileSelector.cc
View File

@ -151,7 +151,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -163,7 +163,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFileSelector::tr (arg1, arg2, arg3));
}
@ -176,7 +176,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -188,7 +188,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFileSelector::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQFileSystemWatcher.cc
View File

@ -168,7 +168,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -180,7 +180,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFileSystemWatcher::tr (arg1, arg2, arg3));
}
@ -193,7 +193,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -205,7 +205,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFileSystemWatcher::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQFinalState.cc
View File

@ -64,7 +64,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -76,7 +76,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFinalState::tr (arg1, arg2, arg3));
}
@ -89,7 +89,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -101,7 +101,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QFinalState::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQHistoryState.cc
View File

@ -135,7 +135,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -147,7 +147,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QHistoryState::tr (arg1, arg2, arg3));
}
@ -160,7 +160,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -172,7 +172,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QHistoryState::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQIODevice.cc
View File

@ -534,7 +534,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -546,7 +546,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QIODevice::tr (arg1, arg2, arg3));
}
@ -559,7 +559,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -571,7 +571,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QIODevice::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQIdentityProxyModel.cc
View File

@ -459,7 +459,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -471,7 +471,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QIdentityProxyModel::tr (arg1, arg2, arg3));
}
@ -484,7 +484,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -496,7 +496,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QIdentityProxyModel::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQItemSelectionModel.cc
View File

@ -453,7 +453,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -465,7 +465,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QItemSelectionModel::tr (arg1, arg2, arg3));
}
@ -478,7 +478,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -490,7 +490,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QItemSelectionModel::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQLibrary.cc
View File

@ -257,7 +257,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -269,7 +269,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QLibrary::tr (arg1, arg2, arg3));
}
@ -282,7 +282,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -294,7 +294,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QLibrary::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQMimeData.cc
View File

@ -425,7 +425,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -437,7 +437,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QMimeData::tr (arg1, arg2, arg3));
}
@ -450,7 +450,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -462,7 +462,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QMimeData::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQObject.cc
View File

@ -724,7 +724,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -736,7 +736,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QObject::tr (arg1, arg2, arg3));
}
@ -749,7 +749,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -761,7 +761,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QObject::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQParallelAnimationGroup.cc
View File

@ -79,7 +79,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -91,7 +91,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QParallelAnimationGroup::tr (arg1, arg2, arg3));
}
@ -104,7 +104,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -116,7 +116,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QParallelAnimationGroup::trUtf8 (arg1, arg2, arg3));
}

8
src/gsiqt/qt5/QtCore/gsiDeclQPauseAnimation.cc
View File

@ -98,7 +98,7 @@ static void _init_f_tr_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -110,7 +110,7 @@ static void _call_f_tr_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QPauseAnimation::tr (arg1, arg2, arg3));
}
@ -123,7 +123,7 @@ static void _init_f_trUtf8_4013 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("c", true, "__null");
static gsi::ArgSpecBase argspec_1 ("c", true, "nullptr");
decl->add_arg<const char * > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("n", true, "-1");
decl->add_arg<int > (argspec_2);
@ -135,7 +135,7 @@ static void _call_f_trUtf8_4013 (const qt_gsi::GenericStaticMethod * /*decl*/, g
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (__null, heap);
const char *arg2 = args ? gsi::arg_reader<const char * >() (args, heap) : gsi::arg_maker<const char * >() (nullptr, heap);
int arg3 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (-1, heap);
ret.write<QString > ((QString)QPauseAnimation::trUtf8 (arg1, arg2, arg3));
}

Some files were not shown because too many files have changed in this diff Show More