update qmake to 1.05a

1 files changed, 8 insertions, 1 deletions

diff --git a/qmake/tools/qgvector.cpp b/qmake/tools/qgvector.cpp
index 1985f03..3c903ed 100644
--- a/qmake/tools/qgvector.cpp
+++ b/qmake/tools/qgvector.cpp
@@ -1,584 +1,591 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of QGVector class
 **
 ** Created : 930907
 **
 ** Copyright (C) 1992-2000 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 "qglobal.h"
+#if defined(Q_CC_BOR)
+// needed for qsort() because of a std namespace problem on Borland
+#include "qplatformdefs.h"
+#endif
+
 #define	 QGVECTOR_CPP
 #include "qgvector.h"
 #include "qglist.h"
 #include "qstring.h"
 #include "qdatastream.h"
 #include <stdlib.h>
 
 #ifdef QT_THREAD_SUPPORT
 #  include <private/qmutexpool_p.h>
 #endif // QT_THREAD_SUPPORT
 
 #define USE_MALLOC				// comment to use new/delete
 
 #undef NEW
 #undef DELETE
 
 #if defined(USE_MALLOC)
 #define NEW(type,size)	((type*)malloc(size*sizeof(type)))
 #define DELETE(array)	(free((char*)array))
 #else
 #define NEW(type,size)	(new type[size])
 #define DELETE(array)	(delete[] array)
 #define DONT_USE_REALLOC			// comment to use realloc()
 #endif
 
 /*!
   \class QGVector
   \reentrant
   \ingroup collection
 
   \brief The QGVector class is an internal class for implementing Qt
   collection classes.
 
   \internal
 
   QGVector is an internal class that acts as a base class for the
   QPtrVector collection class.
 
   QGVector has some virtual functions that may be reimplemented in
   subclasses to customize behavior.
 
   \list
   \i compareItems() compares two collection/vector items.
   \i read() reads a collection/vector item from a QDataStream.
   \i write() writes a collection/vector item to a QDataStream.
   \endlist
 */
 
 /*****************************************************************************
   Default implementation of virtual functions
  *****************************************************************************/
 
 /*!
   This virtual function compares two list items.
 
   Returns:
   <ul>
   <li> 0 if \a d1 == \a d2
   <li> non-zero if \a d1 != \a d2
   </ul>
 
   This function returns \e int rather than \e bool so that
   reimplementations can return one of three values and use it to sort
   by:
   <ul>
   <li> 0 if \a d1 == \a d2
   <li> \> 0 (positive integer) if \a d1 \> \a d2
   <li> \< 0 (negative integer) if \a d1 \< \a d2
   </ul>
 
   The QPtrVector::sort() and QPtrVector::bsearch() functions require that
   compareItems() is implemented as described here.
 
   This function should not modify the vector because some const
   functions call compareItems().
 */
 
 int QGVector::compareItems( Item d1, Item d2 )
 {
     return d1 != d2;				// compare pointers
 }
 
 #ifndef QT_NO_DATASTREAM
 /*!
   Reads a collection/vector item from the stream \a s and returns a reference
   to the stream.
 
   The default implementation sets \a d to 0.
 
   \sa write()
 */
 
 QDataStream &QGVector::read( QDataStream &s, Item &d )
 {						// read item from stream
     d = 0;
     return s;
 }
 
 /*!
   Writes a collection/vector item to the stream \a s and returns a reference
   to the stream.
 
   The default implementation does nothing.
 
   \sa read()
 */
 
 QDataStream &QGVector::write( QDataStream &s, Item ) const
 {						// write item to stream
     return s;
 }
 #endif // QT_NO_DATASTREAM
 
 /*****************************************************************************
   QGVector member functions
  *****************************************************************************/
 
 QGVector::QGVector()				// create empty vector
 {
     vec = 0;
     len = numItems = 0;
 }
 
 QGVector::QGVector( uint size )			// create vectors with nullptrs
 {
     len = size;
     numItems = 0;
     if ( len == 0 ) {				// zero length
 	vec = 0;
 	return;
     }
     vec = NEW(Item,len);
     Q_CHECK_PTR( vec );
     memset( (void*)vec, 0, len*sizeof(Item) );	// fill with nulls
 }
 
 QGVector::QGVector( const QGVector &a )		// make copy of other vector
     : QPtrCollection( a )
 {
     len = a.len;
     numItems = a.numItems;
     if ( len == 0 ) {
 	vec = 0;
 	return;
     }
     vec = NEW( Item, len );
     Q_CHECK_PTR( vec );
     for ( uint i = 0; i < len; i++ ) {
 	if ( a.vec[i] ) {
 	    vec[i] = newItem( a.vec[i] );
 	    Q_CHECK_PTR( vec[i] );
 	} else {
 	    vec[i] = 0;
 	}
     }
 }
 
 QGVector::~QGVector()
 {
     clear();
 }
 
 QGVector& QGVector::operator=( const QGVector &v )
 {
     if ( &v == this )
 	return *this;
 
     clear();
     len = v.len;
     numItems = v.numItems;
     if ( len == 0 ) {
 	vec = 0;
 	return *this;
     }
     vec = NEW( Item, len );
     Q_CHECK_PTR( vec );
     for ( uint i = 0; i < len; i++ ) {
 	if ( v.vec[i] ) {
 	    vec[i] = newItem( v.vec[i] );
 	    Q_CHECK_PTR( vec[i] );
 	} else {
 	    vec[i] = 0;
 	}
     }
     return *this;
 }
 
 
 bool QGVector::insert( uint index, Item d )	// insert item at index
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= len ) {			// range error
 	qWarning( "QGVector::insert: Index %d out of range", index );
 	return FALSE;
     }
 #endif
     if ( vec[index] ) {				// remove old item
 	deleteItem( vec[index] );
 	numItems--;
     }
     if ( d ) {
 	vec[index] = newItem( d );
 	Q_CHECK_PTR( vec[index] );
 	numItems++;
 	return vec[index] != 0;
     } else {
 	vec[index] = 0;				// reset item
     }
     return TRUE;
 }
 
 bool QGVector::remove( uint index )		// remove item at index
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= len ) {			// range error
 	qWarning( "QGVector::remove: Index %d out of range", index );
 	return FALSE;
     }
 #endif
     if ( vec[index] ) {				// valid item
 	deleteItem( vec[index] );		// delete it
 	vec[index] = 0;				// reset pointer
 	numItems--;
     }
     return TRUE;
 }
 
 QPtrCollection::Item QGVector::take( uint index )		// take out item
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= len ) {			// range error
 	qWarning( "QGVector::take: Index %d out of range", index );
 	return 0;
     }
 #endif
     Item d = vec[index];				// don't delete item
     if ( d )
 	numItems--;
     vec[index] = 0;
     return d;
 }
 
 void QGVector::clear()				// clear vector
 {
     if ( vec ) {
 	for ( uint i=0; i<len; i++ ) {		// delete each item
 	    if ( vec[i] )
 		deleteItem( vec[i] );
 	}
 	DELETE(vec);
 	vec = 0;
 	len = numItems = 0;
     }
 }
 
 bool QGVector::resize( uint newsize )		// resize array
 {
     if ( newsize == len )			// nothing to do
 	return TRUE;
     if ( vec ) {				// existing data
 	if ( newsize < len ) {			// shrink vector
 	    uint i = newsize;
 	    while ( i < len ) {			// delete lost items
 		if ( vec[i] ) {
 		    deleteItem( vec[i] );
 		    numItems--;
 		}
 		i++;
 	    }
 	}
 	if ( newsize == 0 ) {			// vector becomes empty
 	    DELETE(vec);
 	    vec = 0;
 	    len = numItems = 0;
 	    return TRUE;
 	}
 #if defined(DONT_USE_REALLOC)
 	if ( newsize == 0 ) {
 	    DELETE(vec);
 	    vec = 0;
 	    return FALSE;
 	}
 	Item *newvec = NEW(Item,newsize);		// manual realloc
 	memcpy( newvec, vec, (len < newsize ? len : newsize)*sizeof(Item) );
 	DELETE(vec);
 	vec = newvec;
 #else
 	vec = (Item*)realloc( (char *)vec, newsize*sizeof(Item) );
 #endif
     } else {					// create new vector
 	vec = NEW(Item,newsize);
 	len = numItems = 0;
     }
     Q_CHECK_PTR( vec );
     if ( !vec )					// no memory
 	return FALSE;
     if ( newsize > len )			// init extra space added
 	memset( (void*)&vec[len], 0, (newsize-len)*sizeof(Item) );
     len = newsize;
     return TRUE;
 }
 
 
 bool QGVector::fill( Item d, int flen )		// resize and fill vector
 {
     if ( flen < 0 )
 	flen = len;				// default: use vector length
     else if ( !resize( flen ) )
 	return FALSE;
     for ( uint i=0; i<(uint)flen; i++ )		// insert d at every index
 	insert( i, d );
     return TRUE;
 }
 
 
 static QGVector *sort_vec=0;			// current sort vector
 
 
 #if defined(Q_C_CALLBACKS)
 extern "C" {
 #endif
 
 #ifdef Q_OS_TEMP
 static int _cdecl cmp_vec( const void *n1, const void *n2 )
 #else
 static int cmp_vec( const void *n1, const void *n2 )
 #endif
 {
     return sort_vec->compareItems( *((QPtrCollection::Item*)n1), *((QPtrCollection::Item*)n2) );
 }
 
 #if defined(Q_C_CALLBACKS)
 }
 #endif
 
 
 void QGVector::sort()				// sort vector
 {
     if ( count() == 0 )				// no elements
 	return;
     register Item *start = &vec[0];
     register Item *end	= &vec[len-1];
     Item tmp;
     for (;;) {				// put all zero elements behind
 	while ( start < end && *start != 0 )
 	    start++;
 	while ( end > start && *end == 0 )
 	    end--;
 	if ( start < end ) {
 	    tmp = *start;
 	    *start = *end;
 	    *end = tmp;
 	} else {
 	    break;
 	}
     }
 
 #ifdef QT_THREAD_SUPPORT
-    QMutexLocker locker( qt_global_mutexpool->get( &sort_vec ) );
+    QMutexLocker locker( qt_global_mutexpool ?
+			 qt_global_mutexpool->get( &sort_vec ) : 0 );
 #endif // QT_THREAD_SUPPORT
 
     sort_vec = (QGVector*)this;
     qsort( vec, count(), sizeof(Item), cmp_vec );
     sort_vec = 0;
 }
 
 int QGVector::bsearch( Item d ) const		// binary search; when sorted
 {
     if ( !len )
 	return -1;
     if ( !d ) {
 #if defined(QT_CHECK_NULL)
 	qWarning( "QGVector::bsearch: Cannot search for null object" );
 #endif
 	return -1;
     }
     int n1 = 0;
     int n2 = len - 1;
     int mid = 0;
     bool found = FALSE;
     while ( n1 <= n2 ) {
 	int  res;
 	mid = (n1 + n2)/2;
 	if ( vec[mid] == 0 )			// null item greater
 	    res = -1;
 	else
 	    res = ((QGVector*)this)->compareItems( d, vec[mid] );
 	if ( res < 0 )
 	    n2 = mid - 1;
 	else if ( res > 0 )
 	    n1 = mid + 1;
 	else {					// found it
 	    found = TRUE;
 	    break;
 	}
     }
     if ( !found )
 	return -1;
     // search to first of equal items
     while ( (mid - 1 >= 0) && !((QGVector*)this)->compareItems(d, vec[mid-1]) )
 	mid--;
     return mid;
 }
 
 int QGVector::findRef( Item d, uint index) const // find exact item in vector
 {
 #if defined(QT_CHECK_RANGE)
     if ( index > len ) {			// range error
 	qWarning( "QGVector::findRef: Index %d out of range", index );
 	return -1;
     }
 #endif
     for ( uint i=index; i<len; i++ ) {
 	if ( vec[i] == d )
 	    return i;
     }
     return -1;
 }
 
 int QGVector::find( Item d, uint index ) const	// find equal item in vector
 {
 #if defined(QT_CHECK_RANGE)
     if ( index >= len ) {			// range error
 	qWarning( "QGVector::find: Index %d out of range", index );
 	return -1;
     }
 #endif
     for ( uint i=index; i<len; i++ ) {
 	if ( vec[i] == 0 && d == 0 )		// found null item
 	    return i;
 	if ( vec[i] && ((QGVector*)this)->compareItems( vec[i], d ) == 0 )
 	    return i;
     }
     return -1;
 }
 
 uint QGVector::containsRef( Item d ) const	// get number of exact matches
 {
     uint count = 0;
     for ( uint i=0; i<len; i++ ) {
 	if ( vec[i] == d )
 	    count++;
     }
     return count;
 }
 
 uint QGVector::contains( Item d ) const		// get number of equal matches
 {
     uint count = 0;
     for ( uint i=0; i<len; i++ ) {
 	if ( vec[i] == 0 && d == 0 )		// count null items
 	    count++;
 	if ( vec[i] && ((QGVector*)this)->compareItems( vec[i], d ) == 0 )
 	    count++;
     }
     return count;
 }
 
 bool QGVector::insertExpand( uint index, Item d )// insert and grow if necessary
 {
     if ( index >= len ) {
 	if ( !resize( index+1 ) )		// no memory
 	    return FALSE;
     }
     insert( index, d );
     return TRUE;
 }
 
 void QGVector::toList( QGList *list ) const	// store items in list
 {
     list->clear();
     for ( uint i=0; i<len; i++ ) {
 	if ( vec[i] )
 	    list->append( vec[i] );
     }
 }
 
 
 void QGVector::warningIndexRange( uint i )
 {
 #if defined(QT_CHECK_RANGE)
     qWarning( "QGVector::operator[]: Index %d out of range", i );
 #else
     Q_UNUSED( i )
 #endif
 }
 
 
 /*****************************************************************************
   QGVector stream functions
  *****************************************************************************/
 #ifndef QT_NO_DATASTREAM
 QDataStream &operator>>( QDataStream &s, QGVector &vec )
 {						// read vector
     return vec.read( s );
 }
 
 QDataStream &operator<<( QDataStream &s, const QGVector &vec )
 {						// write vector
     return vec.write( s );
 }
 
 QDataStream &QGVector::read( QDataStream &s )	// read vector from stream
 {
     uint num;
     s >> num;					// read number of items
     clear();					// clear vector
     resize( num );
     for (uint i=0; i<num; i++) {		// read all items
 	Item d;
 	read( s, d );
 	Q_CHECK_PTR( d );
 	if ( !d )				// no memory
 	    break;
 	vec[i] = d;
     }
     return s;
 }
 
 QDataStream &QGVector::write( QDataStream &s ) const
 {						// write vector to stream
     uint num = count();
     s << num;					// number of items to write
     num = size();
     for (uint i=0; i<num; i++) {		// write non-null items
 	if ( vec[i] )
 	    write( s, vec[i] );
     }
     return s;
 }
 
 /* Returns whether v equals this vector or not */
 
 bool QGVector::operator==( const QGVector &v ) const
 {
     if ( size() != v.size() )
 	return FALSE;
     if ( count() != v.count() )
 	return FALSE;
     for ( int i = 0; i < (int)size(); ++i ) {
 	if ( ( (QGVector*)this )->compareItems( at( i ), v.at( i ) ) != 0 )
 	    return FALSE;
     }
     return TRUE;
 }
 
 #endif // QT_NO_DATASTREAM