qglobal.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qglobal.cpp,v 1.2 2003/07/10 02:40:11 llornkcor Exp $
**
** 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>


const char *qVersion()
{
    return QT_VERSION_STR;
}


/*****************************************************************************
  System detection routines
 *****************************************************************************/

static bool si_alreadyDone = FALSE;
static int  si_wordSize;
static bool si_bigEndian;

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(QWS) && defined(Q_OS_MAC)

#include "qt_mac.h"

int qMacVersion()
{
    static int macver = Qt::MV_Unknown;
    static bool first = TRUE;
    if(first) {
        first = FALSE;
        long gestalt_version;
        if(Gestalt(gestaltSystemVersion, &gestalt_version) == noErr) {
            if(gestalt_version >= 0x1020 && gestalt_version < 0x1030)
                macver = Qt::MV_10_DOT_2;
            else if(gestalt_version >= 0x1010 && gestalt_version < 0x1020)
                macver = Qt::MV_10_DOT_1;
        }
    }
    return macver;
}
Qt::MacintoshVersion qt_macver = (Qt::MacintoshVersion)qMacVersion();
#elif 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
 *****************************************************************************/

static QtMsgHandler handler = 0;                // pointer to debug handler
static const int QT_BUFFER_LENGTH = 8196;       // internal buffer length


#ifdef Q_OS_MAC
QString cfstring2qstring(CFStringRef str)
{
    CFIndex length = CFStringGetLength(str); 
    if(const UniChar *chars = CFStringGetCharactersPtr(str)) 
        return QString((QChar *)chars, length);
    UniChar *buffer = (UniChar*)malloc(length * sizeof(UniChar)); 
    CFStringGetCharacters(str, CFRangeMake(0, length), buffer); 
    QString ret((QChar *)buffer, length);
    free(buffer); 
    return ret;
}

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;
}

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
    }
}

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
}

//
// 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 );
}


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;
}

---