1 files changed, 835 insertions, 0 deletions

diff --git a/qmake/tools/qglobal.cpp b/qmake/tools/qglobal.cpp
new file mode 100644
index 0000000..47cd6bd
--- a/dev/null
+++ b/qmake/tools/qglobal.cpp
@@ -0,0 +1,835 @@
+/****************************************************************************
+** $Id$
+**
+** Global functions
+**
+** Created : 920604
+**
+** Copyright (C) 1992-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 "qplatformdefs.h"
+
+#include "qasciidict.h"
+#include <limits.h>
+#include <stdio.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+
+/*!
+    \relates QApplication
+
+    Returns the Qt version number as a string, for example, "2.3.0" or
+    "3.0.5".
+
+    The \c QT_VERSION define has the numeric value in the form:
+    0xmmiibb (m = major, i = minor, b = bugfix). For example, Qt
+    3.0.5's \c QT_VERSION is 0x030005.
+*/
+
+const char *qVersion()
+{
+    return QT_VERSION_STR;
+}
+
+
+/*****************************************************************************
+  System detection routines
+ *****************************************************************************/
+
+static bool si_alreadyDone = FALSE;
+static int  si_wordSize;
+static bool si_bigEndian;
+
+/*!
+    \relates QApplication
+
+    Obtains information about the system.
+
+    The system's word size in bits (typically 32) is returned in \a
+    *wordSize. The \a *bigEndian is set to TRUE if this is a big-endian
+    machine, or to FALSE if this is a little-endian machine.
+
+    In debug mode, this function calls qFatal() with a message if the
+    computer is truly weird (i.e. different endianness for 16 bit and
+    32 bit integers); in release mode it returns FALSE.
+*/
+
+bool qSysInfo( int *wordSize, bool *bigEndian )
+{
+#if defined(QT_CHECK_NULL)
+    Q_ASSERT( wordSize != 0 );
+    Q_ASSERT( bigEndian != 0 );
+#endif
+
+            if ( si_alreadyDone ) {             // run it only once
+        *wordSize  = si_wordSize;
+        *bigEndian = si_bigEndian;
+        return TRUE;
+    }
+
+    si_wordSize = 0;
+    Q_ULONG n = (Q_ULONG)(~0);
+            while ( n ) {                       // detect word size
+        si_wordSize++;
+        n /= 2;
+    }
+    *wordSize = si_wordSize;
+
+    if ( *wordSize != 64 &&
+         *wordSize != 32 &&
+                 *wordSize != 16 ) {            // word size: 16, 32 or 64
+#if defined(QT_CHECK_RANGE)
+        qFatal( "qSysInfo: Unsupported system word size %d", *wordSize );
+#endif
+        return FALSE;
+    }
+    if ( sizeof(Q_INT8) != 1 || sizeof(Q_INT16) != 2 || sizeof(Q_INT32) != 4 ||
+         sizeof(Q_ULONG)*8 != si_wordSize || sizeof(float) != 4 || sizeof(double) != 8 ) {
+#if defined(QT_CHECK_RANGE)
+        qFatal( "qSysInfo: Unsupported system data type size" );
+#endif
+        return FALSE;
+    }
+
+            bool  be16, be32;                   // determine byte ordering
+    short ns = 0x1234;
+            int  nl = 0x12345678;
+
+            unsigned char *p = (unsigned char *)(&ns);// 16-bit integer
+    be16 = *p == 0x12;
+
+            p = (unsigned char *)(&nl);                 // 32-bit integer
+    if ( p[0] == 0x12 && p[1] == 0x34 && p[2] == 0x56 && p[3] == 0x78 )
+        be32 = TRUE;
+    else
+    if ( p[0] == 0x78 && p[1] == 0x56 && p[2] == 0x34 && p[3] == 0x12 )
+        be32 = FALSE;
+    else
+        be32 = !be16;
+
+            if ( be16 != be32 ) {               // strange machine!
+#if defined(QT_CHECK_RANGE)
+        qFatal( "qSysInfo: Inconsistent system byte order" );
+#endif
+        return FALSE;
+    }
+
+    *bigEndian = si_bigEndian = be32;
+    si_alreadyDone = TRUE;
+    return TRUE;
+}
+
+#if defined(Q_OS_WIN32) || defined(Q_OS_CYGWIN)
+bool qt_winunicode;
+
+#include "qt_windows.h"
+
+int qWinVersion()
+{
+#ifndef VER_PLATFORM_WIN32s
+        #define VER_PLATFORM_WIN32s    0
+#endif
+#ifndef VER_PLATFORM_WIN32_WINDOWS
+#define VER_PLATFORM_WIN32_WINDOWS  1
+#endif
+#ifndef VER_PLATFORM_WIN32_NT
+        #define VER_PLATFORM_WIN32_NT    2
+#endif
+
+    static int winver = Qt::WV_NT;
+    static int t=0;
+    if ( !t ) {
+        t=1;
+#ifdef Q_OS_TEMP
+        OSVERSIONINFOW osver;
+        osver.dwOSVersionInfoSize = sizeof(osver);
+        GetVersionEx( &osver );
+#else
+        OSVERSIONINFOA osver;
+        osver.dwOSVersionInfoSize = sizeof(osver);
+        GetVersionExA( &osver );
+#endif
+        switch ( osver.dwPlatformId ) {
+        case VER_PLATFORM_WIN32s:
+            winver = Qt::WV_32s;
+            break;
+        case VER_PLATFORM_WIN32_WINDOWS:
+            // We treat Windows Me (minor 90) the same as Windows 98
+            if ( ( osver.dwMinorVersion == 10 ) || ( osver.dwMinorVersion == 90 ) )
+                winver = Qt::WV_98;
+            else
+                winver = Qt::WV_95;
+            break;
+        default: // VER_PLATFORM_WIN32_NT
+            if ( osver.dwMajorVersion < 5 ) {
+                winver = Qt::WV_NT;
+            } else if ( osver.dwMinorVersion == 0 ) {
+                winver = Qt::WV_2000;
+            } else {
+                winver = Qt::WV_XP;
+            }
+        }
+    }
+
+#if defined(UNICODE)
+    if ( winver & Qt::WV_NT_based )
+        qt_winunicode = TRUE;
+    else
+#endif
+        qt_winunicode = FALSE;
+
+    return winver;
+}
+
+Qt::WindowsVersion qt_winver = (Qt::WindowsVersion)qWinVersion();
+#endif
+
+
+/*****************************************************************************
+  Debug output routines
+ *****************************************************************************/
+
+/*!
+    \fn void qDebug( const char *msg, ... )
+
+    \relates QApplication
+
+    Prints a debug message \a msg, or calls the message handler (if it
+    has been installed).
+
+    This function takes a format string and a list of arguments,
+    similar to the C printf() function.
+
+    Example:
+    \code
+        qDebug( "my window handle = %x", myWidget->id() );
+    \endcode
+
+    Under X11, the text is printed to stderr. Under Windows, the text
+    is sent to the debugger.
+
+    \warning The internal buffer is limited to 8196 bytes (including
+    the '\0'-terminator).
+
+    \warning Passing (const char *)0 as argument to qDebug might lead
+    to crashes on certain platforms due to the platforms printf implementation.
+
+    \sa qWarning(), qFatal(), qInstallMsgHandler(),
+        \link debug.html Debugging\endlink
+*/
+
+/*!
+    \fn void qWarning( const char *msg, ... )
+
+    \relates QApplication
+
+    Prints a warning message \a msg, or calls the message handler (if
+    it has been installed).
+
+    This function takes a format string and a list of arguments,
+    similar to the C printf() function.
+
+    Example:
+    \code
+        void f( int c )
+        {
+            if ( c > 200 )
+                qWarning( "f: bad argument, c == %d", c );
+        }
+    \endcode
+
+    Under X11, the text is printed to stderr. Under Windows, the text
+    is sent to the debugger.
+
+    \warning The internal buffer is limited to 8196 bytes (including
+    the '\0'-terminator).
+
+    \warning Passing (const char *)0 as argument to qWarning might lead
+    to crashes on certain platforms due to the platforms printf implementation.
+
+    \sa qDebug(), qFatal(), qInstallMsgHandler(),
+    \link debug.html Debugging\endlink
+*/
+
+/*!
+    \fn void qFatal( const char *msg, ... )
+
+    \relates QApplication
+
+    Prints a fatal error message \a msg and exits, or calls the
+    message handler (if it has been installed).
+
+    This function takes a format string and a list of arguments,
+    similar to the C printf() function.
+
+    Example:
+    \code
+        int divide( int a, int b )
+        {
+                    if ( b == 0 )                       // program error
+                qFatal( "divide: cannot divide by zero" );
+            return a/b;
+        }
+    \endcode
+
+    Under X11, the text is printed to stderr. Under Windows, the text
+    is sent to the debugger.
+
+    \warning The internal buffer is limited to 8196 bytes (including
+    the '\0'-terminator).
+
+    \warning Passing (const char *)0 as argument to qFatal might lead
+    to crashes on certain platforms due to the platforms printf implementation.
+
+    \sa qDebug(), qWarning(), qInstallMsgHandler(),
+    \link debug.html Debugging\endlink
+*/
+
+
+        static QtMsgHandler handler = 0;        // pointer to debug handler
+        static const int QT_BUFFER_LENGTH = 8196;// internal buffer length
+
+
+#ifdef Q_OS_MAC
+const unsigned char * p_str(const char * c, int len=-1)
+{
+    const int maxlen = 255;
+    if(len == -1)
+        len = qstrlen(c);
+    if(len > maxlen) {
+        qWarning( "p_str len must never exceed %d", maxlen );
+        len = maxlen;
+    }
+    unsigned char *ret = (unsigned char*)malloc(len+2);
+    *ret=len;
+    memcpy(((char *)ret)+1,c,len);
+    *(ret+len+1) = '\0';
+    return ret;
+}
+
+const unsigned char * p_str(const QString &s)
+{
+    return p_str(s, s.length());
+}
+
+QCString p2qstring(const unsigned char *c) {
+       char *arr = (char *)malloc(c[0] + 1);
+       memcpy(arr, c+1, c[0]);
+       arr[c[0]] = '\0';
+       QCString ret = arr;
+       delete arr;
+       return ret;
+}
+#endif
+
+
+#ifdef Q_CC_MWERKS
+
+#include "qt_mac.h"
+
+extern bool qt_is_gui_used;
+static void mac_default_handler( const char *msg )
+{
+    if ( qt_is_gui_used ) {
+        const char *p = p_str(msg);
+        DebugStr(p);
+        free(p);
+    } else {
+        fprintf( stderr, msg );
+    }
+}
+
+#endif
+
+
+void qDebug( const char *msg, ... )
+{
+    char buf[QT_BUFFER_LENGTH];
+    va_list ap;
+            va_start( ap, msg );                // use variable arg list
+    if ( handler ) {
+#if defined(QT_VSNPRINTF)
+        QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
+#else
+        vsprintf( buf, msg, ap );
+#endif
+        va_end( ap );
+        (*handler)( QtDebugMsg, buf );
+    } else {
+#if defined(Q_CC_MWERKS)
+                vsprintf( buf, msg, ap );       // ### is there no vsnprintf()?
+        va_end( ap );
+        mac_default_handler(buf);
+#else
+        vfprintf( stderr, msg, ap );
+        va_end( ap );
+                fprintf( stderr, "\n" );        // add newline
+#endif
+    }
+}
+
+// copied... this looks really bad.
+void debug( const char *msg, ... )
+{
+    char buf[QT_BUFFER_LENGTH];
+    va_list ap;
+            va_start( ap, msg );                // use variable arg list
+    if ( handler ) {
+#if defined(QT_VSNPRINTF)
+        QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
+#else
+        vsprintf( buf, msg, ap );
+#endif
+        va_end( ap );
+        (*handler)( QtDebugMsg, buf );
+    } else {
+#ifdef Q_CC_MWERKS
+                vsprintf( buf, msg, ap );       // ### is there no vsnprintf()?
+        va_end( ap );
+        mac_default_handler(buf);
+#else
+        vfprintf( stderr, msg, ap );
+        va_end( ap );
+                fprintf( stderr, "\n" );        // add newline
+#endif
+    }
+}
+
+void qWarning( const char *msg, ... )
+{
+    char buf[QT_BUFFER_LENGTH];
+    va_list ap;
+            va_start( ap, msg );                // use variable arg list
+    if ( handler ) {
+#if defined(QT_VSNPRINTF)
+        QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
+#else
+        vsprintf( buf, msg, ap );
+#endif
+        va_end( ap );
+        (*handler)( QtWarningMsg, buf );
+    } else {
+#ifdef Q_CC_MWERKS
+                vsprintf( buf, msg, ap );       // ### is there no vsnprintf()?
+        va_end( ap );
+        mac_default_handler(buf);
+#else
+        vfprintf( stderr, msg, ap );
+        va_end( ap );
+                fprintf( stderr, "\n" );        // add newline
+#endif
+    }
+}
+
+
+// again, copied
+void warning( const char *msg, ... )
+{
+    char buf[QT_BUFFER_LENGTH];
+    va_list ap;
+            va_start( ap, msg );                // use variable arg list
+    if ( handler ) {
+#if defined(QT_VSNPRINTF)
+        QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
+#else
+        vsprintf( buf, msg, ap );
+#endif
+        va_end( ap );
+        (*handler)( QtWarningMsg, buf );
+    } else {
+#ifdef Q_CC_MWERKS
+                vsprintf( buf, msg, ap );       // ### is there no vsnprintf()?
+        va_end( ap );
+        mac_default_handler(buf);
+#else
+        vfprintf( stderr, msg, ap );
+        va_end( ap );
+                fprintf( stderr, "\n" );        // add newline
+#endif
+    }
+}
+
+void qFatal( const char *msg, ... )
+{
+    char buf[QT_BUFFER_LENGTH];
+    va_list ap;
+            va_start( ap, msg );                // use variable arg list
+    if ( handler ) {
+#if defined(QT_VSNPRINTF)
+        QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
+#else
+        vsprintf( buf, msg, ap );
+#endif
+        va_end( ap );
+        (*handler)( QtFatalMsg, buf );
+    } else {
+#ifdef Q_CC_MWERKS
+                vsprintf( buf, msg, ap );       // ### is there no vsnprintf()?
+        va_end( ap );
+        mac_default_handler(buf);
+#else
+        vfprintf( stderr, msg, ap );
+        va_end( ap );
+                fprintf( stderr, "\n" );        // add newline
+#endif
+#if defined(Q_OS_UNIX) && defined(QT_DEBUG)
+                abort();                        // trap; generates core dump
+#else
+                exit( 1 );                      // goodbye cruel world
+#endif
+    }
+}
+
+// yet again, copied
+void fatal( const char *msg, ... )
+{
+    char buf[QT_BUFFER_LENGTH];
+    va_list ap;
+            va_start( ap, msg );                // use variable arg list
+    if ( handler ) {
+#if defined(QT_VSNPRINTF)
+        QT_VSNPRINTF( buf, QT_BUFFER_LENGTH, msg, ap );
+#else
+        vsprintf( buf, msg, ap );
+#endif
+        va_end( ap );
+        (*handler)( QtFatalMsg, buf );
+    } else {
+#ifdef Q_CC_MWERKS
+                vsprintf( buf, msg, ap );       // ### is there no vsnprintf()?
+        va_end( ap );
+        mac_default_handler(buf);
+#else
+        vfprintf( stderr, msg, ap );
+        va_end( ap );
+                fprintf( stderr, "\n" );        // add newline
+#endif
+#if defined(Q_OS_UNIX) && defined(QT_DEBUG)
+                abort();                        // trap; generates core dump
+#else
+                exit( 1 );                      // goodbye cruel world
+#endif
+    }
+}
+
+/*!
+  \relates QApplication
+
+  Prints the message \a msg and uses \a code to get a system specific
+  error message. When \a code is -1 (the default), the system's last
+  error code will be used if possible. Use this method to handle
+  failures in platform specific API calls.
+
+  This function does nothing when Qt is built with \c QT_NO_DEBUG
+  defined.
+*/
+void qSystemWarning( const char* msg, int code )
+{
+#ifndef QT_NO_DEBUG
+#if defined(Q_OS_WIN32)
+    if ( code == -1 )
+        code = GetLastError();
+
+    if ( !code )
+        return;
+
+#ifdef Q_OS_TEMP
+    unsigned short *string;
+
+    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
+                          NULL,
+                          code,
+                          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                          (LPTSTR)&string,
+                          0,
+                          NULL );
+
+    qWarning( "%s\n\tError code %d - %s (###may need fixing in qglobal.h)", msg, code, (const char *)string );
+#else
+    char* string;
+
+    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
+                          NULL,
+                          code,
+                          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                          (char*)&string,
+                          0,
+                          NULL );
+
+    qWarning( "%s\n\tError code %d - %s", msg, code, (const char*)string );
+#endif
+
+    LocalFree( (HLOCAL)string );
+#else
+    if ( code != -1 )
+        qWarning( "%s\n\tError code %d - %s", msg, code, strerror( code ) );
+    else
+        qWarning( msg );
+#endif
+#endif
+}
+
+/*!
+    \fn void Q_ASSERT( bool test )
+
+    \relates QApplication
+
+    Prints a warning message containing the source code file name and
+    line number if \a test is FALSE.
+
+    This is really a macro defined in \c qglobal.h.
+
+    Q_ASSERT is useful for testing pre- and post-conditions.
+
+    Example:
+    \code
+        //
+        // File: div.cpp
+        //
+
+        #include <qglobal.h>
+
+        int divide( int a, int b )
+        {
+                    Q_ASSERT( b != 0 );                 // this is line 9
+            return a/b;
+        }
+    \endcode
+
+    If \c b is zero, the Q_ASSERT statement will output the following
+    message using the qWarning() function:
+    \code
+        ASSERT: "b == 0" in div.cpp (9)
+    \endcode
+
+    \sa qWarning(), \link debug.html Debugging\endlink
+*/
+
+
+/*!
+    \fn void Q_CHECK_PTR( void *p )
+
+    \relates QApplication
+
+    If \a p is null, a fatal messages says that the program ran out of
+    memory and exits. If \e p is not null, nothing happens.
+
+    This is really a macro defined in \c qglobal.h.
+
+    Example:
+    \code
+        int *a;
+
+        Q_CHECK_PTR( a = new int[80] );  // WRONG!
+
+        a = new int[80];                 // Right
+        Q_CHECK_PTR( a );
+    \endcode
+
+    \sa qFatal(), \link debug.html Debugging\endlink
+*/
+
+
+//
+// The Q_CHECK_PTR macro calls this function to check if an allocation went ok.
+//
+#if (QT_VERSION-0 >= 0x040000)
+#if defined(Q_CC_GNU)
+#warning "Change Q_CHECK_PTR to '{if ((p)==0) qt_check_pointer(__FILE__,__LINE__);}'"
+#warning "No need for qt_check_pointer() to return a value - make it void!"
+#endif
+#endif
+bool qt_check_pointer( bool c, const char *n, int l )
+{
+    if ( c )
+        qWarning( "In file %s, line %d: Out of memory", n, l );
+    return TRUE;
+}
+
+
+static bool firstObsoleteWarning(const char *obj, const char *oldfunc )
+{
+    static QAsciiDict<int> *obsoleteDict = 0;
+            if ( !obsoleteDict ) {              // first time func is called
+        obsoleteDict = new QAsciiDict<int>;
+#if defined(QT_DEBUG)
+        qDebug(
+      "You are using obsolete functions in the Qt library. Call the function\n"
+      "qSuppressObsoleteWarnings() to suppress obsolete warnings.\n"
+             );
+#endif
+    }
+    QCString s( obj );
+    s += "::";
+    s += oldfunc;
+    if ( obsoleteDict->find(s.data()) == 0 ) {
+                obsoleteDict->insert( s.data(), (int*)1 );// anything different from 0
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static bool suppressObsolete = FALSE;
+
+void qSuppressObsoleteWarnings( bool suppress )
+{
+    suppressObsolete = suppress;
+}
+
+        void qObsolete( const char *obj, const char *oldfunc, const char *newfunc )
+{
+    if ( suppressObsolete )
+        return;
+    if ( !firstObsoleteWarning(obj, oldfunc) )
+        return;
+    if ( obj )
+        qDebug( "%s::%s: This function is obsolete, use %s instead.",
+               obj, oldfunc, newfunc );
+    else
+        qDebug( "%s: This function is obsolete, use %s instead.",
+               oldfunc, newfunc );
+}
+
+        void qObsolete( const char *obj, const char *oldfunc )
+{
+    if ( suppressObsolete )
+        return;
+    if ( !firstObsoleteWarning(obj, oldfunc) )
+        return;
+    if ( obj )
+        qDebug( "%s::%s: This function is obsolete.", obj, oldfunc );
+    else
+        qDebug( "%s: This function is obsolete.", oldfunc );
+}
+
+        void qObsolete( const char *message )
+{
+    if ( suppressObsolete )
+        return;
+    if ( !firstObsoleteWarning( "Qt", message) )
+        return;
+    qDebug( "%s", message );
+}
+
+
+/*!
+    \relates QApplication
+
+    Installs a Qt message handler \a h. Returns a pointer to the
+    message handler previously defined.
+
+    The message handler is a function that prints out debug messages,
+    warnings and fatal error messages. The Qt library (debug version)
+    contains hundreds of warning messages that are printed when
+    internal errors (usually invalid function arguments) occur. If you
+    implement your own message handler, you get total control of these
+    messages.
+
+    The default message handler prints the message to the standard
+    output under X11 or to the debugger under Windows. If it is a
+    fatal message, the application aborts immediately.
+
+    Only one message handler can be defined, since this is usually
+    done on an application-wide basis to control debug output.
+
+    To restore the message handler, call \c qInstallMsgHandler(0).
+
+    Example:
+    \code
+        #include <qapplication.h>
+        #include <stdio.h>
+        #include <stdlib.h>
+
+        void myMessageOutput( QtMsgType type, const char *msg )
+        {
+            switch ( type ) {
+                case QtDebugMsg:
+                    fprintf( stderr, "Debug: %s\n", msg );
+                    break;
+                case QtWarningMsg:
+                    fprintf( stderr, "Warning: %s\n", msg );
+                    break;
+                case QtFatalMsg:
+                    fprintf( stderr, "Fatal: %s\n", msg );
+                            abort();            // deliberately core dump
+            }
+        }
+
+        int main( int argc, char **argv )
+        {
+            qInstallMsgHandler( myMessageOutput );
+            QApplication a( argc, argv );
+            ...
+            return a.exec();
+        }
+    \endcode
+
+    \sa qDebug(), qWarning(), qFatal(), \link debug.html Debugging\endlink
+*/
+
+QtMsgHandler qInstallMsgHandler( QtMsgHandler h )
+{
+    QtMsgHandler old = handler;
+    handler = h;
+    return old;
+}
+
+
+/*
+    Dijkstra's bisection algorithm to find the square root as an integer.
+    Deliberately not exported as part of the Qt API, but used in both
+    qsimplerichtext.cpp and qgfxraster_qws.cpp
+*/
+unsigned int qt_int_sqrt( unsigned int n )
+{
+    // n must be in the range 0...UINT_MAX/2-1
+    if ( n >= ( UINT_MAX>>2 ) ) {
+        unsigned int r = 2 * qt_int_sqrt( n / 4 );
+        unsigned int r2 = r + 1;
+        return ( n >= r2 * r2 ) ? r2 : r;
+    }
+    uint h, p= 0, q= 1, r= n;
+    while ( q <= n )
+        q <<= 2;
+    while ( q != 1 ) {
+        q >>= 2;
+        h= p + q;
+        p >>= 1;
+        if ( r >= h ) {
+            p += q;
+            r -= h;
+        }
+    }
+    return p;
+}
+