Adding qmake in preperation for new build system

1 files changed, 544 insertions, 0 deletions

diff --git a/qmake/tools/qgpluginmanager.cpp b/qmake/tools/qgpluginmanager.cpp
new file mode 100644
index 0000000..46c85f5
--- a/dev/null
+++ b/qmake/tools/qgpluginmanager.cpp
@@ -0,0 +1,544 @@
+/****************************************************************************
+** $Id$
+**
+** Implementation of QGPluginManager class
+**
+** Copyright (C) 2000-2001 Trolltech AS.  All rights reserved.
+**
+** This file is part of the tools module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include "qgpluginmanager_p.h"
+#ifndef QT_NO_COMPONENT
+#include "qcomlibrary_p.h"
+#include "qmap.h"
+#include "qdir.h"
+
+/*
+  The following co-occurrence code is borrowed from Qt Linguist.
+
+  How similar are two texts? The approach used here relies on
+  co-occurrence matrices and is very efficient.
+
+  Let's see with an example: how similar are "here" and "hither"?  The
+  co-occurrence matrix M for "here" is M[h,e] = 1, M[e,r] = 1,
+  M[r,e] = 1 and 0 elsewhere; the matrix N for "hither" is N[h,i] = 1,
+  N[i,t] = 1, ..., N[h,e] = 1, N[e,r] = 1 and 0 elsewhere.  The union
+  U of both matrices is the matrix U[i,j] = max { M[i,j], N[i,j] },
+  and the intersection V is V[i,j] = min { M[i,j], N[i,j] }. The score
+  for a pair of texts is
+
+      score = (sum of V[i,j] over all i, j) / (sum of U[i,j] over all i, j),
+
+  a formula suggested by Arnt Gulbrandsen. Here we have
+
+      score = 2 / 6,
+
+  or one third.
+
+  The implementation differs from this in a few details.  Most
+  importantly, repetitions are ignored; for input "xxx", M[x,x] equals
+  1, not 2.
+*/
+
+/*
+  Every character is assigned to one of 20 buckets so that the
+  co-occurrence matrix requires only 20 * 20 = 400 bits, not
+  256 * 256 = 65536 bits or even more if we want the whole Unicode.
+  Which character falls in which bucket is arbitrary.
+
+  The second half of the table is a replica of the first half, because of
+  laziness.
+*/
+static const char indexOf[256] = {
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+//      !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /
+    0,  2,  6,  7,  10, 12, 15, 19, 2,  6,  7,  10, 12, 15, 19, 0,
+//  0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?
+    1,  3,  4,  5,  8,  9,  11, 13, 14, 16, 2,  6,  7,  10, 12, 15,
+//  @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
+//  P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _
+    15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0,
+//  `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
+//  p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~
+    15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0,
+
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    0,  2,  6,  7,  10, 12, 15, 19, 2,  6,  7,  10, 12, 15, 19, 0,
+    1,  3,  4,  5,  8,  9,  11, 13, 14, 16, 2,  6,  7,  10, 12, 15,
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
+    15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0,
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  6,  10, 11, 12, 13, 14,
+    15, 12, 16, 17, 18, 19, 2,  10, 15, 7,  19, 2,  6,  7,  10, 0
+};
+
+/*
+  The entry bitCount[i] (for i between 0 and 255) is the number of
+  bits used to represent i in binary.
+*/
+static const char bitCount[256] = {
+    0,  1,  1,  2,  1,  2,  2,  3,  1,  2,  2,  3,  2,  3,  3,  4,
+    1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
+    1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
+    1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
+    2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
+    3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
+    3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
+    4,  5,  5,  6,  5,  6,  6,  7,  5,  6,  6,  7,  6,  7,  7,  8
+};
+
+class QCoMatrix
+{
+public:
+    /*
+      The matrix has 20 * 20 = 400 entries. This requires 50 bytes, or
+      13 words. Some operations are performed on words for more
+      efficiency.
+    */
+    union {
+	Q_UINT8 b[52];
+	Q_UINT32 w[13];
+    };
+
+    QCoMatrix() { memset( b, 0, 52 ); }
+    QCoMatrix( const char *text ) {
+	char c = '\0', d;
+	memset( b, 0, 52 );
+	while ( (d = *text) != '\0' ) {
+	    setCoocc( c, d );
+	    if ( (c = *++text) != '\0' ) {
+		setCoocc( d, c );
+		text++;
+	    }
+	}
+    }
+
+    void setCoocc( char c, char d ) {
+	int k = indexOf[(uchar) c] + 20 * indexOf[(uchar) d];
+	b[k >> 3] |= k & 0x7;
+    }
+
+    int worth() const {
+	int result = 0;
+	for ( int i = 0; i < 50; i++ )
+	    result += bitCount[b[i]];
+	return result;
+    }
+
+    static QCoMatrix reunion( const QCoMatrix& m, const QCoMatrix& n )
+    {
+	QCoMatrix p;
+	for ( int i = 0; i < 13; i++ )
+	    p.w[i] = m.w[i] | n.w[i];
+	return p;
+    }
+    static QCoMatrix intersection( const QCoMatrix& m, const QCoMatrix& n )
+    {
+	QCoMatrix p;
+	for ( int i = 0; i < 13; i++ )
+	    p.w[i] = m.w[i] & n.w[i];
+	return p;
+    }
+};
+
+/*
+  Returns an integer between 0 (dissimilar) and 15 (very similar)
+  depending on  how similar the string is to \a target.
+
+  This function is efficient, but its results might change in future
+  versions of Qt as the algorithm evolves.
+
+  \code
+    QString s( "color" );
+    a = similarity( s, "color" );  // a == 15
+    a = similarity( s, "colour" ); // a == 8
+    a = similarity( s, "flavor" ); // a == 4
+    a = similarity( s, "dahlia" ); // a == 0
+  \endcode
+*/
+static int similarity( const QString& s1, const QString& s2 )
+{
+    QCoMatrix m1( s1 );
+    QCoMatrix m2( s2 );
+    return ( 15 * (QCoMatrix::intersection(m1, m2).worth() + 1) ) /
+	   ( QCoMatrix::reunion(m1, m2).worth() + 1 );
+}
+
+/*!
+  \class QPluginManager qpluginmanager.h
+  \reentrant
+  \brief The QPluginManager class provides basic functions to access a certain kind of functionality in libraries.
+  \ingroup componentmodel
+
+  \internal
+
+  A common usage of components is to extend the existing functionality in an application using plugins. The application
+  defines interfaces that abstract a certain group of functionality, and a plugin provides a specialized implementation
+  of one or more of those interfaces.
+
+  The QPluginManager template has to be instantiated with an interface definition and the IID for this interface.
+
+  \code
+  QPluginManager<MyPluginInterface> *manager = new QPluginManager<MyPluginInterface>( IID_MyPluginInterface );
+  \endcode
+
+  It searches a specified directory for all shared libraries, queries for components that implement the specific interface and
+  reads information about the features the plugin wants to add to the application. The component can provide the set of features
+  provided by implementing either the QFeatureListInterface or the QComponentInformationInterface. The strings returned by the implementations
+  of
+
+  \code
+  QStringList QFeatureListInterface::featureList() const
+  \endcode
+
+  or
+
+  \code
+  QString QComponentInformationInterface::name() const
+  \endcode
+
+  respectively, can then be used to access the component that provides the requested feature:
+
+  \code
+  MyPluginInterface *iface;
+  manager->queryInterface( "feature", &iface );
+  if ( iface )
+      iface->execute( "feature" );
+  \endcode
+
+  The application can use a QPluginManager instance to create parts of the user interface based on the list of features
+  found in plugins:
+
+  \code
+  QPluginManager<MyPluginInterface> *manager = new QPluginManager<MyPluginInterface>( IID_ImageFilterInterface );
+  manager->addLibraryPath(...);
+
+  QStringList features = manager->featureList();
+  for ( QStringList::Iterator it = features.begin(); it != features.end(); ++it ) {
+      MyPluginInterface *iface;
+      manager->queryInterface( *it, &iface );
+
+      // use QAction to provide toolbuttons and menuitems for each feature...
+  }
+  \endcode
+*/
+
+/*!
+  \fn QPluginManager::QPluginManager( const QUuid& id, const QStringList& paths = QString::null, const QString &suffix = QString::null, bool cs = TRUE )
+
+  Creates an QPluginManager for interfaces \a id that will load all shared library files in the \a paths + \a suffix.
+  If \a cs is FALSE the manager will handle feature strings case insensitive.
+
+  \warning
+  Setting the cs flag to FALSE requires that components also convert to lower case when comparing with passed strings, so this has
+  to be handled with care and documented very well.
+
+  \sa QApplication::libraryPaths()
+*/
+
+
+/*!
+  \fn QRESULT QPluginManager::queryInterface(const QString& feature, Type** iface) const
+
+  Sets \a iface to point to the interface providing \a feature.
+
+  \sa featureList(), library()
+*/
+
+
+
+#include <qptrlist.h>
+
+QGPluginManager::QGPluginManager( const QUuid& id, const QStringList& paths, const QString &suffix, bool cs )
+    : interfaceId( id ), plugDict( 17, cs ), casesens( cs ), autounload( TRUE )
+{
+    // Every QLibrary object is destroyed on destruction of the manager
+    libDict.setAutoDelete( TRUE );
+    for ( QStringList::ConstIterator it = paths.begin(); it != paths.end(); ++it ) {
+	QString path = *it;
+	addLibraryPath( path + suffix );
+    }
+}
+
+QGPluginManager::~QGPluginManager()
+{
+    if ( !autounload ) {
+	QDictIterator<QLibrary> it( libDict );
+	while ( it.current() ) {
+	    QLibrary *lib = it.current();
+	    ++it;
+	    lib->setAutoUnload( FALSE );
+	}
+    }
+}
+
+void QGPluginManager::addLibraryPath( const QString& path )
+{
+    if ( !enabled() || !QDir( path ).exists( ".", TRUE ) )
+	return;
+
+#if defined(Q_OS_WIN32)
+    QString filter = "dll";
+#elif defined(Q_OS_MACX)
+    QString filter = "dylib";
+#elif defined(Q_OS_UNIX)
+    QString filter = "so";
+#endif
+
+    QStringList plugins = QDir(path).entryList( "*." + filter );
+    for ( QStringList::Iterator p = plugins.begin(); p != plugins.end(); ++p ) {
+	QString lib = QDir::cleanDirPath( path + "/" + *p );
+	if ( libList.contains( lib ) )
+	    continue;
+	libList.append( lib );
+    }
+}
+
+const QLibrary* QGPluginManager::library( const QString& feature ) const
+{
+    if ( !enabled() || feature.isEmpty() )
+	return 0;
+
+    // We already have a QLibrary object for this feature
+    QLibrary *library = 0;
+    if ( ( library = plugDict[feature] ) )
+	return library;
+
+    // Find the filename that matches the feature request best
+    QMap<int, QStringList> map;
+    QStringList::ConstIterator it = libList.begin();
+    int best = 0;
+    int worst = 15;
+    while ( it != libList.end() ) {
+	if ( (*it).isEmpty() || libDict[*it] ) {
+	    ++it;
+	    continue;
+	}
+	QString basename = QFileInfo(*it).baseName();
+	int s = similarity( feature, basename );
+	if ( s < worst )
+	    worst = s;
+	if ( s > best )
+	    best = s;
+	map[s].append( basename + QChar(0xfffd) + *it );
+	++it;
+    }
+
+    if ( map.isEmpty() )
+	return 0; // no libraries to add
+
+    // Start with the best match to get the library object
+    QGPluginManager *that = (QGPluginManager*)this;
+    for ( int s = best; s >= worst; --s ) {
+	QStringList group = map[s];
+	group.sort(); // sort according to the base name
+	QStringList::ConstIterator git = group.begin();
+	while ( git != group.end() ) {
+	    QString lib = (*git).mid( (*git).find( QChar(0xfffd) ) + 1 );
+	    QString basename = (*git).left( (*git).find( QChar(0xfffd) ) );
+	    ++git;
+
+	    QStringList sameBasename;
+	    while( git != group.end() &&
+		   basename == (*git).left( (*git).find( QChar(0xfffd) ) )  ) {
+		sameBasename << (*git).mid( (*git).find( QChar(0xfffd) ) + 1 );
+		++git;
+	    }
+
+	    if ( sameBasename.isEmpty() ) {
+		that->addLibrary( new QComLibrary( lib ) );
+	    } else {
+		QPtrList<QComLibrary> same;
+		same.setAutoDelete( TRUE );
+		for ( QStringList::ConstIterator bit = sameBasename.begin();
+		      bit != sameBasename.end(); ++bit )
+		    same.append( new QComLibrary( *bit ) );
+		QComLibrary* bestMatch = 0;
+		for ( QComLibrary* candidate = same.first(); candidate; candidate = same.next() )
+		    if ( candidate->qtVersion() && candidate->qtVersion() <= QT_VERSION
+			 && ( !bestMatch || candidate->qtVersion() > bestMatch->qtVersion() ) )
+			bestMatch = candidate;
+		if ( bestMatch ) {
+		    same.find( bestMatch );
+		    that->addLibrary( same.take() );
+		}
+	    }
+
+	    if ( ( library = that->plugDict[feature] ) )
+		return library;
+	}
+    }
+    return 0;
+}
+
+QStringList QGPluginManager::featureList() const
+{
+    QStringList features;
+
+    if ( !enabled() )
+	return features;
+
+    QGPluginManager *that = (QGPluginManager*)this;
+    QStringList theLibs = libList;
+    QStringList phase2Libs;
+    QStringList phase2Deny;
+
+    /* In order to get the feature list we need to add all interesting
+      libraries. If there are libraries with the same base name, we
+      prioritze the one that fits our Qt version number and ignore the
+      others  */
+    QStringList::Iterator it;
+    for ( it = theLibs.begin(); it != theLibs.end(); ++it  ) {
+	if ( (*it).isEmpty() || libDict[*it] )
+	    continue;
+	QComLibrary* library = new QComLibrary( *it );
+	if ( library->qtVersion() == QT_VERSION ) {
+	    that->addLibrary( library );
+	    phase2Deny << QFileInfo( *it ).baseName();
+	} else {
+	    delete library;
+	    phase2Libs << *it;
+	}
+    }
+    for ( it = phase2Libs.begin(); it != phase2Libs.end(); ++it  )
+	if ( !phase2Deny.contains( QFileInfo( *it ).baseName() ) )
+	    that->addLibrary( new QComLibrary( *it ) );
+
+    for ( QDictIterator<QLibrary> pit( plugDict ); pit.current(); ++pit )
+	features << pit.currentKey();
+
+    return features;
+}
+
+bool QGPluginManager::addLibrary( QLibrary* lib )
+{
+    if ( !enabled() || !lib )
+	return FALSE;
+
+    QComLibrary* plugin = (QComLibrary*)lib;
+    bool useful = FALSE;
+
+    QUnknownInterface* iFace = 0;
+    plugin->queryInterface( interfaceId, &iFace );
+    if ( iFace ) {
+	QFeatureListInterface *fliFace = 0;
+	QComponentInformationInterface *cpiFace = 0;
+	iFace->queryInterface( IID_QFeatureList, (QUnknownInterface**)&fliFace );
+	if ( !fliFace )
+	    plugin->queryInterface( IID_QFeatureList, (QUnknownInterface**)&fliFace );
+	if ( !fliFace ) {
+	    iFace->queryInterface( IID_QComponentInformation, (QUnknownInterface**)&cpiFace );
+	    if ( !cpiFace )
+		plugin->queryInterface( IID_QComponentInformation, (QUnknownInterface**)&cpiFace );
+	}
+	QStringList fl;
+	if ( fliFace )
+	    // Map all found features to the library
+	    fl = fliFace->featureList();
+	else if ( cpiFace )
+	    fl << cpiFace->name();
+
+	for ( QStringList::Iterator f = fl.begin(); f != fl.end(); f++ ) {
+	    QLibrary *old = plugDict[*f];
+	    if ( !old ) {
+		useful = TRUE;
+		plugDict.replace( *f, plugin );
+	    } else {
+		// we have old *and* plugin, which one to pick?
+		QComLibrary* first = (QComLibrary*)old;
+		QComLibrary* second = (QComLibrary*)plugin;
+		bool takeFirst = TRUE;
+		if ( first->qtVersion() != QT_VERSION ) {
+		    if ( second->qtVersion() == QT_VERSION )
+			takeFirst = FALSE;
+		    else if ( second->qtVersion() < QT_VERSION &&
+			      first->qtVersion() > QT_VERSION )
+			takeFirst = FALSE;
+		}
+		if ( !takeFirst ) {
+		    useful = TRUE;
+		    plugDict.replace( *f, plugin );
+		    qWarning("%s: Discarding feature %s in %s!",
+			     (const char*) QFile::encodeName( plugin->library()),
+			     (*f).latin1(),
+			     (const char*) QFile::encodeName( old->library() ) );
+		} else {
+		    qWarning("%s: Feature %s already defined in %s!",
+			     (const char*) QFile::encodeName( old->library() ),
+			     (*f).latin1(),
+			     (const char*) QFile::encodeName( plugin->library() ) );
+		}
+	    }
+	}
+	if ( fliFace )
+	    fliFace->release();
+	if ( cpiFace )
+	    cpiFace->release();
+	iFace->release();
+    }
+
+    if ( useful ) {
+	libDict.replace( plugin->library(), plugin );
+	if ( !libList.contains( plugin->library() ) )
+	    libList.append( plugin->library() );
+	return TRUE;
+    }
+    delete plugin;
+    return FALSE;
+}
+
+
+bool QGPluginManager::enabled() const
+{
+#ifdef QT_SHARED
+    return TRUE;
+#else
+    return FALSE;
+#endif
+}
+
+QRESULT QGPluginManager::queryUnknownInterface(const QString& feature, QUnknownInterface** iface) const
+{
+    QComLibrary* plugin = 0;
+    plugin = (QComLibrary*)library( feature );
+    return plugin ? plugin->queryInterface( interfaceId, (QUnknownInterface**)iface ) : QE_NOINTERFACE;
+}
+
+#endif //QT_NO_COMPONENT