Adding qmake in preperation for new build system

1 files changed, 538 insertions, 0 deletions

diff --git a/qmake/tools/qcomlibrary.cpp b/qmake/tools/qcomlibrary.cpp
new file mode 100644
index 0000000..a7162fc
--- a/dev/null
+++ b/qmake/tools/qcomlibrary.cpp
@@ -0,0 +1,538 @@
+/****************************************************************************
+** $Id$
+**
+** Implementation of QComLibrary class
+**
+** Copyright (C) 2001-2002 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 "qcomlibrary_p.h"
+
+#ifndef QT_NO_COMPONENT
+#include <qapplication.h>
+#include <qsettings.h>
+#include <qfileinfo.h>
+#include <qdatetime.h>
+#include <qcleanuphandler.h>
+#include <errno.h>
+
+#ifdef QT_THREAD_SUPPORT
+#  include "qmutexpool_p.h"
+#endif // QT_THREAD_SUPPORT
+
+#ifndef QT_DEBUG_COMPONENT
+# if defined(QT_DEBUG)
+#  define QT_DEBUG_COMPONENT 1
+# endif
+#endif
+
+
+QComLibrary::QComLibrary( const QString &filename )
+    : QLibrary( filename ), entry( 0 ), libiface( 0 ), qt_version( 0 )
+{
+}
+
+QComLibrary::~QComLibrary()
+{
+    if ( autoUnload() )
+	unload();
+}
+
+bool QComLibrary::unload()
+{
+    if ( libiface ) {
+	libiface->cleanup();
+	if ( !libiface->canUnload() )
+	    return FALSE;
+	libiface->release();
+	libiface = 0;
+    }
+    int refs = entry ? entry->release() : 0;
+    if ( refs )
+	return FALSE;
+
+    entry = 0;
+
+    return QLibrary::unload();
+}
+
+static bool qt_verify( const QString& library, uint version, uint flags,
+		    const QCString &key, bool warn )
+{
+    uint our_flags = 1;
+#if defined(QT_THREAD_SUPPORT)
+    our_flags |= 2;
+#endif
+
+    if ( (flags & 1) == 0 ) {
+	if ( warn )
+	    qWarning( "Conflict in %s:\n"
+		      "  Plugin cannot be queried successfully!",
+		      (const char*) QFile::encodeName(library) );
+    } else if ( ( version > QT_VERSION ) ||
+		( ( QT_VERSION & 0xff0000 ) > ( version & 0xff0000 ) ) ) {
+	if ( warn )
+	    qWarning( "Conflict in %s:\n"
+		      "  Plugin uses incompatible Qt library (%d.%d.%d)!",
+		      (const char*) QFile::encodeName(library),
+		      (version&0xff0000) >> 16, (version&0xff00) >> 8, version&0xff );
+    } else if ( (flags & 2) != (our_flags & 2) ) {
+	if ( warn )
+	    qWarning( "Conflict in %s:\n"
+		      "  Plugin uses %s Qt library!",
+		      (const char*) QFile::encodeName(library),
+		      (flags & 2) ? "multi threaded" : "single threaded" );
+    } else if ( key != QT_BUILD_KEY ) {
+	if ( warn )
+	    qWarning( "Conflict in %s:\n"
+		      "  Plugin uses incompatible Qt library!\n"
+		      "  expected build key \"%s\", got \"%s\".",
+		      (const char*) QFile::encodeName(library),
+		      QT_BUILD_KEY,
+		      key.isEmpty() ? "<null>" : (const char *) key );
+    } else {
+	return TRUE;
+    }
+    return FALSE;
+}
+
+struct qt_token_info
+{
+    qt_token_info( const char *f, const ulong fc )
+	: fields( f ), field_count( fc ), results( fc ), lengths( fc )
+    {
+	results.fill( 0 );
+	lengths.fill( 0 );
+    }
+
+    const char *fields;
+    const ulong field_count;
+
+    QMemArray<const char *> results;
+    QMemArray<ulong> lengths;
+};
+
+/*
+  return values:
+       1 parse ok
+       0 eos
+      -1 parse error
+*/
+static int qt_tokenize( const char *s, ulong s_len, ulong *advance,
+			const qt_token_info &token_info )
+{
+    ulong pos = 0, field = 0, fieldlen = 0;
+    char current;
+    int ret = -1;
+    *advance = 0;
+    for (;;) {
+	current = s[ pos ];
+
+	// next char
+	++pos;
+	++fieldlen;
+	++*advance;
+
+	if ( ! current || pos == s_len + 1 ) {
+	    // save result
+	    token_info.results[ (int)field ] = s;
+	    token_info.lengths[ (int)field ] = fieldlen - 1;
+
+	    // end of string
+	    ret = 0;
+	    break;
+	}
+
+	if ( current == token_info.fields[ field ] ) {
+	    // save result
+	    token_info.results[ (int)field ] = s;
+	    token_info.lengths[ (int)field ] = fieldlen - 1;
+
+	    // end of field
+	    fieldlen = 0;
+	    ++field;
+	    if ( field == token_info.field_count - 1 ) {
+		// parse ok
+		ret = 1;
+	    }
+	    if ( field == token_info.field_count ) {
+		// done parsing
+		break;
+	    }
+
+	    // reset string and its length
+	    s = s + pos;
+	    s_len -= pos;
+	    pos = 0;
+	}
+    }
+
+    return ret;
+}
+
+/*
+  returns TRUE if the string s was correctly parsed, FALSE otherwise.
+*/
+static bool qt_parse_pattern( const char *s, uint *version, uint *flags,
+				   QCString *key )
+{
+    bool ret = TRUE;
+
+    qt_token_info pinfo("=\n", 2);
+    int parse;
+    ulong at = 0, advance, parselen = qstrlen( s );
+    do {
+	parse = qt_tokenize( s + at, parselen, &advance, pinfo );
+	if ( parse == -1 ) {
+	    ret = FALSE;
+	    break;
+	}
+
+	at += advance;
+	parselen -= advance;
+
+	if ( qstrncmp( "version", pinfo.results[ 0 ], pinfo.lengths[ 0 ] ) == 0 ) {
+	    // parse version string
+	    qt_token_info pinfo2("..-", 3);
+	    if ( qt_tokenize( pinfo.results[ 1 ], pinfo.lengths[ 1 ],
+			      &advance, pinfo2 ) != -1 ) {
+		QCString m( pinfo2.results[ 0 ], pinfo2.lengths[ 0 ] + 1 );
+		QCString n( pinfo2.results[ 1 ], pinfo2.lengths[ 1 ] + 1 );
+		QCString p( pinfo2.results[ 2 ], pinfo2.lengths[ 2 ] + 1 );
+		*version  = (m.toUInt() << 16) | (n.toUInt() << 8) | p.toUInt();
+	    } else {
+		ret = FALSE;
+		break;
+	    }
+	} else if ( qstrncmp( "flags", pinfo.results[ 0 ], pinfo.lengths[ 0 ] ) == 0 ) {
+	    // parse flags string
+	    char ch;
+	    *flags = 0;
+	    ulong p = 0, c = 0, bit = 0;
+	    while ( p < pinfo.lengths[ 1 ] ) {
+		ch = pinfo.results[ 1 ][ p ];
+		bit = pinfo.lengths[ 1 ] - p - 1;
+		c = 1 << bit;
+		if ( ch == '1' ) {
+		    *flags |= c;
+		} else if ( ch != '0' ) {
+		    ret = FALSE;
+		    break;
+		}
+		++p;
+	    }
+	} else if ( qstrncmp( "buildkey", pinfo.results[ 0 ],
+			      pinfo.lengths[ 0 ] ) == 0 ){
+	    // save buildkey
+	    *key = QCString( pinfo.results[ 1 ], pinfo.lengths[ 1 ] + 1 );
+	}
+    } while ( parse == 1 && parselen > 0 );
+
+    return ret;
+}
+
+#if defined(Q_OS_UNIX)
+
+#if defined(Q_OS_FREEBSD) || defined(Q_OS_LINUX)
+#  define USE_MMAP
+#  include <sys/types.h>
+#  include <sys/mman.h>
+#endif // Q_OS_FREEBSD || Q_OS_LINUX
+
+static long qt_find_pattern( const char *s, ulong s_len,
+			     const char *pattern, ulong p_len )
+{
+    /*
+      this uses the same algorithm as QString::findRev...
+
+      we search from the end of the file because on the supported
+      systems, the read-only data/text segments are placed at the end
+      of the file.  HOWEVER, when building with debugging enabled, all
+      the debug symbols are placed AFTER the data/text segments.
+
+      what does this mean?  when building in release mode, the search
+      is fast because the data we are looking for is at the end of the
+      file... when building in debug mode, the search is slower
+      because we have to skip over all the debugging symbols first
+    */
+
+    if ( ! s || ! pattern || p_len > s_len ) return -1;
+    ulong i, hs = 0, hp = 0, delta = s_len - p_len;
+
+    for (i = 0; i < p_len; ++i ) {
+	hs += s[delta + i];
+	hp += pattern[i];
+    }
+    i = delta;
+    for (;;) {
+	if ( hs == hp && qstrncmp( s + i, pattern, p_len ) == 0 )
+	    return i;
+	if ( i == 0 )
+	    break;
+	--i;
+	hs -= s[i + p_len];
+	hs += s[i];
+    }
+
+    return -1;
+}
+
+/*
+  This opens the specified library, mmaps it into memory, and searches
+  for the QT_UCM_VERIFICATION_DATA.  The advantage of this approach is that
+  we can get the verification data without have to actually load the library.
+  This lets us detect mismatches more safely.
+
+  Returns FALSE if version/flags/key information is not present, or if the
+                information could not be read.
+  Returns  TRUE if version/flags/key information is present and succesfully read.
+*/
+static bool qt_unix_query( const QString &library, uint *version, uint *flags,
+			   QCString *key )
+{
+    QFile file( library );
+    if (! file.open( IO_ReadOnly ) ) {
+	qWarning( "%s: %s", (const char*) QFile::encodeName(library),
+	    strerror( errno ) );
+	return FALSE;
+    }
+
+    QByteArray data;
+    char *filedata = 0;
+    ulong fdlen = 0;
+
+#ifdef USE_MMAP
+    char *mapaddr = 0;
+    size_t maplen = file.size();
+    mapaddr = (char *) mmap( mapaddr, maplen, PROT_READ, MAP_PRIVATE, file.handle(), 0 );
+    if ( mapaddr != MAP_FAILED ) {
+	// mmap succeeded
+	filedata = mapaddr;
+	fdlen = maplen;
+    } else {
+	// mmap failed
+	qWarning( "mmap: %s", strerror( errno ) );
+#endif // USE_MMAP
+	// try reading the data into memory instead
+	data = file.readAll();
+	filedata = data.data();
+	fdlen = data.size();
+#ifdef USE_MMAP
+    }
+#endif // USE_MMAP
+
+    // verify that the pattern is present in the plugin
+    const char *pattern = "pattern=QT_UCM_VERIFICATION_DATA";
+    const ulong plen = qstrlen( pattern );
+    long pos = qt_find_pattern( filedata, fdlen, pattern, plen );
+
+    bool ret = FALSE;
+    if ( pos >= 0 ) {
+	ret = qt_parse_pattern( filedata + pos, version, flags, key );
+    }
+
+#ifdef USE_MMAP
+    if ( mapaddr != MAP_FAILED && munmap(mapaddr, maplen) != 0 ) {
+	qWarning( "munmap: %s", strerror( errno ) );
+    }
+#endif // USE_MMAP
+
+    file.close();
+    return ret;
+}
+
+#endif // Q_OS_UNIX
+
+
+static QSettings *cache = 0;
+static QSingleCleanupHandler<QSettings> cleanup_cache;
+
+void QComLibrary::createInstanceInternal()
+{
+    if ( library().isEmpty() )
+	return;
+
+    QFileInfo fileinfo( library() );
+    QString lastModified  = fileinfo.lastModified().toString();
+    QString regkey = QString("/Qt Plugins %1.%2/%3")
+		     .arg( ( QT_VERSION & 0xff0000 ) >> 16 )
+		     .arg( ( QT_VERSION & 0xff00 ) >> 8 )
+		     .arg( library() );
+    QStringList reg;
+    uint flags = 0;
+    QCString key;
+    bool query_done = FALSE;
+    bool warn_mismatch = TRUE;
+
+    if ( ! query_done ) {
+
+#ifdef QT_THREAD_SUPPORT
+	QMutexLocker locker( qt_global_mutexpool->get( &cache ) );
+#endif // QT_THREAD_SUPPORT
+
+	if ( ! cache ) {
+	    cache = new QSettings;
+	    cache->insertSearchPath( QSettings::Windows, "/Trolltech" );
+	    cleanup_cache.set( &cache );
+	}
+
+	reg = cache->readListEntry( regkey );
+	if ( reg.count() == 4 ) {
+	    // check timestamp
+	    if ( lastModified == reg[3] ) {
+		qt_version = reg[0].toUInt(0, 16);
+		flags = reg[1].toUInt(0, 16);
+		key = reg[2].latin1();
+
+		query_done = TRUE;
+		warn_mismatch = FALSE;
+	    }
+	}
+    }
+
+#if defined(Q_OS_UNIX)
+    if ( ! query_done ) {
+	// get the query information directly from the plugin without loading
+	if ( qt_unix_query( library(), &qt_version, &flags, &key ) ) {
+ 	    // info read succesfully from library
+ 	    query_done = TRUE;
+	}
+    }
+#else // !Q_OS_UNIX
+    if ( ! query_done ) {
+	// get the query information by loading the plugin
+	if ( !isLoaded() ) {
+	    Q_ASSERT( entry == 0 );
+	    if ( !load() )
+		return;
+	}
+
+#  ifdef Q_CC_BOR
+	typedef const char * __stdcall (*UCMQueryVerificationDataProc)();
+#  else
+	typedef const char * (*UCMQueryVerificationDataProc)();
+#  endif
+	UCMQueryVerificationDataProc ucmQueryVerificationdataProc;
+	ucmQueryVerificationdataProc =
+	    (UCMQueryVerificationDataProc) resolve( "qt_ucm_query_verification_data" );
+
+	if ( !ucmQueryVerificationdataProc ||
+	     !qt_parse_pattern( ucmQueryVerificationdataProc(),
+				&qt_version, &flags, &key ) ) {
+	    qt_version = flags = 0;
+	    key = "unknown";
+	} else {
+	    query_done = TRUE;
+	}
+    }
+#endif // Q_OS_UNIX
+
+    QStringList queried;
+    queried << QString::number( qt_version,16 )
+	    << QString::number( flags, 16 )
+	    <<  key
+	    << lastModified;
+
+    if ( queried != reg ) {
+
+#ifdef QT_THREAD_SUPPORT
+	QMutexLocker locker( qt_global_mutexpool->get( &cache ) );
+#endif // QT_THREAD_SUPPORT
+
+	cache->writeEntry( regkey, queried );
+	// delete the cache, which forces the settings to be written
+	delete cache;
+	cache = 0;
+    }
+
+    if ( ! query_done ) {
+	if ( warn_mismatch ) {
+	    qWarning( "Conflict in %s:\n Plugin cannot be queried successfully!",
+		      (const char*) QFile::encodeName( library() ) );
+	}
+	unload();
+	return;
+    }
+
+    if ( ! qt_verify( library(), qt_version, flags, key, warn_mismatch ) ) {
+	unload();
+	return;
+    } else if ( !isLoaded() ) {
+	Q_ASSERT( entry == 0 );
+	if ( !load() )
+	    return;
+    }
+
+#ifdef Q_CC_BOR
+    typedef QUnknownInterface* __stdcall (*UCMInstanceProc)();
+#else
+    typedef QUnknownInterface* (*UCMInstanceProc)();
+#endif
+    UCMInstanceProc ucmInstanceProc;
+    ucmInstanceProc = (UCMInstanceProc) resolve( "ucm_instantiate" );
+#if defined(QT_DEBUG_COMPONENT)
+    if ( !ucmInstanceProc )
+	qWarning( "%s: Not a UCOM library.", (const char*) QFile::encodeName(library()) );
+#endif
+    entry = ucmInstanceProc ? ucmInstanceProc() : 0;
+
+    if ( entry ) {
+	if ( entry->queryInterface( IID_QLibrary, (QUnknownInterface**)&libiface ) == QS_OK ) {
+	    if ( libiface && !libiface->init() ) {
+		libiface->release();
+		libiface = 0;
+		unload();
+		return;
+	    }
+	}
+    } else {
+#if defined(QT_DEBUG_COMPONENT)
+	qWarning( "%s: No exported component provided.", (const char*) QFile::encodeName(library()) );
+#endif
+	unload();
+    }
+}
+
+QRESULT QComLibrary::queryInterface( const QUuid& request, QUnknownInterface** iface )
+{
+    if ( !entry )
+	createInstanceInternal();
+    return entry ? entry->queryInterface( request, iface ) : QE_NOCOMPONENT;
+}
+
+uint QComLibrary::qtVersion()
+{
+    if ( !entry )
+	createInstanceInternal();
+    return entry ? qt_version : 0;
+}
+
+
+#endif // QT_NO_COMPONENT