Removed unnecessary and/or TDE-unrelated code.r14.0.7

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
Signed-off-by: Slávek Banko <slavek.banko@axis.cz>

1 files changed, 0 insertions, 695 deletions

diff --git a/tqtinterface/qt4/src/tools/tqmutex_unix.cpp b/tqtinterface/qt4/src/tools/tqmutex_unix.cpp
deleted file mode 100644
index 540a128..0000000
--- a/tqtinterface/qt4/src/tools/tqmutex_unix.cpp
+++ /dev/null
@@ -1,695 +0,0 @@
-/****************************************************************************
-**
-** TQMutex class for Unix
-**
-** Created : 20010725
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the tools module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** This file may be used under the terms of the Q Public License as
-** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** Commercial License Agreement provided with the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-#if defined(TQT_THREAD_SUPPORT)
-
-#include "tqplatformdefs.h"
-
-typedef pthread_mutex_t     TQ_MUTEX_T;
-
-// POSIX threads mutex types
-#if ((defined(PTHREAD_MUTEX_RECURSIVE) && defined(PTHREAD_MUTEX_DEFAULT)) || \
-     defined(TQ_OS_FREEBSD)) && !defined(TQ_OS_UNIXWARE) && !defined(TQ_OS_SOLARIS) && \
-    !defined(TQ_OS_MAC)
-// POSIX 1003.1c-1995 - We love this OS
-#  define TQ_MUTEX_SET_TYPE(a, b) pthread_mutexattr_settype((a), (b))
-#  if defined(TQT_CHECK_RANGE)
-#    define TQ_NORMAL_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK
-#  else
-#    define TQ_NORMAL_MUTEX_TYPE PTHREAD_MUTEX_DEFAULT
-#  endif
-#  define TQ_RECURSIVE_MUTEX_TYPE PTHREAD_MUTEX_RECURSIVE
-#elif defined(MUTEX_NONRECURSIVE_NP) && defined(MUTEX_RECURSIVE_NP)
-// POSIX 1003.4a pthreads draft extensions
-#  define TQ_MUTEX_SET_TYPE(a, b) pthread_mutexattr_setkind_np((a), (b));
-#  define TQ_NORMAL_MUTEX_TYPE MUTEX_NONRECURSIVE_NP
-#  define TQ_RECURSIVE_MUTEX_TYPE MUTEX_RECURSIVE_NP
-#else
-// Unknown mutex types - skip them
-#  define TQ_MUTEX_SET_TYPE(a, b)
-#  undef  TQ_NORMAL_MUTEX_TYPE
-#  undef  TQ_RECURSIVE_MUTEX_TYPE
-#endif
-
-#include "tqmutex.h"
-#include "tqmutex_p.h"
-
-#include <errno.h>
-#include <string.h>
-
-
-// Private class declarations
-
-class TQRealMutexPrivate : public TQMutexPrivate {
-public:
-    TQRealMutexPrivate(bool = FALSE);
-
-    void lock();
-    void unlock();
-    bool locked();
-    bool trylock();
-    int type() const;
-
-    bool recursive;
-};
-
-#ifndef    TQ_RECURSIVE_MUTEX_TYPE
-class TQRecursiveMutexPrivate : public TQMutexPrivate
-{
-public:
-    TQRecursiveMutexPrivate();
-    ~TQRecursiveMutexPrivate();
-
-    void lock();
-    void unlock();
-    bool locked();
-    bool trylock();
-    int type() const;
-
-    int count;
-    unsigned long owner;
-    pthread_mutex_t handle2;
-};
-#endif // !TQ_RECURSIVE_MUTEX_TYPE
-
-
-// Private class implementation
-
-// base destructor
-TQMutexPrivate::~TQMutexPrivate()
-{
-    int ret = pthread_mutex_destroy(&handle);
-
-#ifdef TQT_CHECK_RANGE
-    if ( ret )
-	qWarning( "Mutex destroy failure: %s", strerror( ret ) );
-#endif
-}
-
-// real mutex class
-TQRealMutexPrivate::TQRealMutexPrivate(bool recurs)
-    : recursive(recurs)
-{
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    TQ_MUTEX_SET_TYPE(&attr, recursive ? TQ_RECURSIVE_MUTEX_TYPE : TQ_NORMAL_MUTEX_TYPE);
-    TQ_UNUSED(recursive);
-    int ret = pthread_mutex_init(&handle, &attr);
-    pthread_mutexattr_destroy(&attr);
-
-#ifdef TQT_CHECK_RANGE
-    if( ret )
-	qWarning( "Mutex init failure: %s", strerror( ret ) );
-#endif // TQT_CHECK_RANGE
-}
-
-void TQRealMutexPrivate::lock()
-{
-    int ret = pthread_mutex_lock(&handle);
-
-#ifdef TQT_CHECK_RANGE
-    if (ret)
-	qWarning("Mutex lock failure: %s", strerror(ret));
-#endif
-}
-
-void TQRealMutexPrivate::unlock()
-{
-    int ret = pthread_mutex_unlock(&handle);
-
-#ifdef TQT_CHECK_RANGE
-    if (ret)
-	qWarning("Mutex unlock failure: %s", strerror(ret));
-#endif
-}
-
-bool TQRealMutexPrivate::locked()
-{
-    int ret = pthread_mutex_trylock(&handle);
-
-    if (ret == EBUSY) {
-	return TRUE;
-    } else if (ret) {
-#ifdef TQT_CHECK_RANGE
-	qWarning("Mutex locktest failure: %s", strerror(ret));
-#endif
-    } else
-	pthread_mutex_unlock(&handle);
-
-    return FALSE;
-}
-
-bool TQRealMutexPrivate::trylock()
-{
-    int ret = pthread_mutex_trylock(&handle);
-
-    if (ret == EBUSY) {
-	return FALSE;
-    } else if (ret) {
-#ifdef TQT_CHECK_RANGE
-	qWarning("Mutex trylock failure: %s", strerror(ret));
-#endif
-	return FALSE;
-    }
-
-    return TRUE;
-}
-
-int TQRealMutexPrivate::type() const
-{
-    return recursive ? TQ_MUTEX_RECURSIVE : TQ_MUTEX_NORMAL;
-}
-
-
-#ifndef    TQ_RECURSIVE_MUTEX_TYPE
-TQRecursiveMutexPrivate::TQRecursiveMutexPrivate()
-    : count(0), owner(0)
-{
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    TQ_MUTEX_SET_TYPE(&attr, TQ_NORMAL_MUTEX_TYPE);
-    int ret = pthread_mutex_init(&handle, &attr);
-    pthread_mutexattr_destroy(&attr);
-
-#  ifdef TQT_CHECK_RANGE
-    if (ret)
-	qWarning( "Mutex init failure: %s", strerror(ret) );
-#  endif
-
-    pthread_mutexattr_init(&attr);
-    ret = pthread_mutex_init( &handle2, &attr );
-    pthread_mutexattr_destroy(&attr);
-
-#  ifdef TQT_CHECK_RANGE
-    if (ret)
-	qWarning( "Mutex init failure: %s", strerror(ret) );
-#  endif
-}
-
-TQRecursiveMutexPrivate::~TQRecursiveMutexPrivate()
-{
-    int ret = pthread_mutex_destroy(&handle2);
-
-#  ifdef TQT_CHECK_RANGE
-    if (ret)
-	qWarning( "Mutex destroy failure: %s", strerror(ret) );
-#  endif
-}
-
-void TQRecursiveMutexPrivate::lock()
-{
-    pthread_mutex_lock(&handle2);
-
-    if (count > 0 && owner == (unsigned long) pthread_self()) {
-	count++;
-    } else {
-	pthread_mutex_unlock(&handle2);
-	pthread_mutex_lock(&handle);
-	pthread_mutex_lock(&handle2);
-	count = 1;
-	owner = (unsigned long) pthread_self();
-    }
-
-    pthread_mutex_unlock(&handle2);
-}
-
-void TQRecursiveMutexPrivate::unlock()
-{
-    pthread_mutex_lock(&handle2);
-
-    if (owner == (unsigned long) pthread_self()) {
-	// do nothing if the count is already 0... to reflect the behaviour described
-	// in the docs
-	if (count && (--count) < 1) {
-	    count = 0;
-	    pthread_mutex_unlock(&handle);
-	}
-    } else {
-#ifdef TQT_CHECK_RANGE
-	qWarning("TQMutex::unlock: unlock from different thread than locker");
-	qWarning("                was locked by %d, unlock attempt from %d",
-		 (int)owner, (int)pthread_self());
-#endif
-    }
-
-    pthread_mutex_unlock(&handle2);
-}
-
-bool TQRecursiveMutexPrivate::locked()
-{
-    pthread_mutex_lock(&handle2);
-
-    bool ret;
-    int code = pthread_mutex_trylock(&handle);
-
-    if (code == EBUSY) {
-	ret = TRUE;
-    } else {
-#ifdef TQT_CHECK_RANGE
-	if (code)
-	    qWarning("Mutex trylock failure: %s", strerror(code));
-#endif
-
-	pthread_mutex_unlock(&handle);
-	ret = FALSE;
-    }
-
-    pthread_mutex_unlock(&handle2);
-
-    return ret;
-}
-
-bool TQRecursiveMutexPrivate::trylock()
-{
-    bool ret = TRUE;
-
-    pthread_mutex_lock(&handle2);
-
-    if ( count > 0 && owner == (unsigned long) pthread_self() ) {
-	count++;
-    } else {
-        int code = pthread_mutex_trylock(&handle);
-
-	if (code == EBUSY) {
-	    ret = FALSE;
-	} else if (code) {
-#ifdef TQT_CHECK_RANGE
-	    qWarning("Mutex trylock failure: %s", strerror(code));
-#endif
-	    ret = FALSE;
-	} else {
-	    count = 1;
-	    owner = (unsigned long) pthread_self();
-	}
-    }
-
-    pthread_mutex_unlock(&handle2);
-
-    return ret;
-}
-
-int TQRecursiveMutexPrivate::type() const
-{
-    return TQ_MUTEX_RECURSIVE;
-}
-
-#endif // !TQ_RECURSIVE_MUTEX_TYPE
-
-
-/*!
-    \class TQMutex tqmutex.h
-    \threadsafe
-    \brief The TQMutex class provides access serialization between threads.
-
-    \ingroup thread
-    \ingroup environment
-
-    The purpose of a TQMutex is to protect an object, data structure or
-    section of code so that only one thread can access it at a time
-    (This is similar to the Java \c synchronized keyword). For
-    example, say there is a method which prints a message to the user
-    on two lines:
-
-    \code
-    int number = 6;
-
-    void method1()
-    {
-	number *= 5;
-	number /= 4;
-    }
-
-    void method2()
-    {
-	number *= 3;
-	number /= 2;
-    }
-    \endcode
-
-    If these two methods are called in succession, the following happens:
-
-    \code
-    // method1()
-    number *= 5;	// number is now 30
-    number /= 4;	// number is now 7
-
-    // method2()
-    number *= 3;	// nubmer is now 21
-    number /= 2;	// number is now 10
-    \endcode
-
-    If these two methods are called simultaneously from two threads then the
-    following sequence could result:
-
-    \code
-    // Thread 1 calls method1()
-    number *= 5;	// number is now 30
-
-    // Thread 2 calls method2().
-    //
-    // Most likely Thread 1 has been put to sleep by the operating
-    // system to allow Thread 2 to run.
-    number *= 3;	// number is now 90
-    number /= 2;	// number is now 45
-
-    // Thread 1 finishes executing.
-    number /= 4;	// number is now 11, instead of 10
-    \endcode
-
-    If we add a mutex, we should get the result we want:
-
-    \code
-    TQMutex mutex;
-    int number = 6;
-
-    void method1()
-    {
-	mutex.lock();
-	number *= 5;
-	number /= 4;
-	mutex.unlock();
-    }
-
-    void method2()
-    {
-	mutex.lock();
-	number *= 3;
-	number /= 2;
-	mutex.unlock();
-    }
-    \endcode
-
-    Then only one thread can modify \c number at any given time and
-    the result is correct. This is a trivial example, of course, but
-    applies to any other case where things need to happen in a
-    particular sequence.
-
-    When you call lock() in a thread, other threads that try to call
-    lock() in the same place will block until the thread that got the
-    lock calls unlock(). A non-blocking alternative to lock() is
-    tryLock().
-*/
-
-/*!
-    Constructs a new mutex. The mutex is created in an unlocked state.
-    A recursive mutex is created if \a recursive is TRUE; a normal
-    mutex is created if \a recursive is FALSE (the default). With a
-    recursive mutex, a thread can lock the same mutex multiple times
-    and it will not be unlocked until a corresponding number of
-    unlock() calls have been made.
-*/
-TQMutex::TQMutex(bool recursive)
-{
-#ifndef    TQ_RECURSIVE_MUTEX_TYPE
-    if ( recursive )
-	d = new TQRecursiveMutexPrivate();
-    else
-#endif // !TQ_RECURSIVE_MUTEX_TYPE
-	d = new TQRealMutexPrivate(recursive);
-}
-
-/*!
-    Destroys the mutex.
-
-    \warning If you destroy a mutex that still holds a lock the
-    resultant behavior is undefined.
-*/
-TQMutex::~TQMutex()
-{
-    delete d;
-}
-
-/*!
-    Attempt to lock the mutex. If another thread has locked the mutex
-    then this call will \e block until that thread has unlocked it.
-
-    \sa unlock(), locked()
-*/
-void TQMutex::lock()
-{
-    d->lock();
-}
-
-/*!
-    Unlocks the mutex. Attempting to unlock a mutex in a different
-    thread to the one that locked it results in an error. Unlocking a
-    mutex that is not locked results in undefined behaviour (varies
-    between different Operating Systems' thread implementations).
-
-    \sa lock(), locked()
-*/
-void TQMutex::unlock()
-{
-    d->unlock();
-}
-
-/*!
-    Returns TRUE if the mutex is locked by another thread; otherwise
-    returns FALSE.
-
-    \warning Due to differing implementations of recursive mutexes on
-    various platforms, calling this function from the same thread that
-    previously locked the mutex will return undefined results.
-
-    \sa lock(), unlock()
-*/
-bool TQMutex::locked()
-{
-    return d->locked();
-}
-
-/*!
-    Attempt to lock the mutex. If the lock was obtained, this function
-    returns TRUE. If another thread has locked the mutex, this
-    function returns FALSE, instead of waiting for the mutex to become
-    available, i.e. it does not block.
-
-    If the lock was obtained, the mutex must be unlocked with unlock()
-    before another thread can successfully lock it.
-
-    \sa lock(), unlock(), locked()
-*/
-bool TQMutex::tryLock()
-{
-    return d->trylock();
-}
-
-/*!
-    \class TQMutexLocker tqmutex.h
-    \brief The TQMutexLocker class simplifies locking and unlocking TQMutexes.
-
-    \threadsafe
-
-    \ingroup thread
-    \ingroup environment
-
-    The purpose of TQMutexLocker is to simplify TQMutex locking and
-    unlocking. Locking and unlocking a TQMutex in complex functions and
-    statements or in exception handling code is error prone and
-    difficult to debug. TQMutexLocker should be used in such situations
-    to ensure that the state of the mutex is well defined and always
-    locked and unlocked properly.
-
-    TQMutexLocker should be created within a function where a TQMutex
-    needs to be locked. The mutex is locked when TQMutexLocker is
-    created, and unlocked when TQMutexLocker is destroyed.
-
-    For example, this complex function locks a TQMutex upon entering
-    the function and unlocks the mutex at all the exit points:
-
-    \code
-    int complexFunction( int flag )
-    {
-	mutex.lock();
-
-	int return_value = 0;
-
-	switch ( flag ) {
-	case 0:
-	case 1:
-	    {
-		mutex.unlock();
-		return moreComplexFunction( flag );
-	    }
-
-	case 2:
-	    {
-		int status = anotherFunction();
-		if ( status < 0 ) {
-		    mutex.unlock();
-		    return -2;
-		}
-		return_value = status + flag;
-		break;
-	    }
-
-	default:
-	    {
-		if ( flag > 10 ) {
-		    mutex.unlock();
-		    return -1;
-		}
-		break;
-	    }
-	}
-
-	mutex.unlock();
-	return return_value;
-    }
-    \endcode
-
-    This example function will get more complicated as it is
-    developed, which increases the likelihood that errors will occur.
-
-    Using TQMutexLocker greatly simplifies the code, and makes it more
-    readable:
-
-    \code
-    int complexFunction( int flag )
-    {
-	TQMutexLocker locker( &mutex );
-
-	int return_value = 0;
-
-	switch ( flag ) {
-	case 0:
-	case 1:
-	    {
-		return moreComplexFunction( flag );
-	    }
-
-	case 2:
-	    {
-		int status = anotherFunction();
-		if ( status < 0 )
-		    return -2;
-		return_value = status + flag;
-		break;
-	    }
-
-	default:
-	    {
-		if ( flag > 10 )
-		    return -1;
-		break;
-	    }
-	}
-
-	return return_value;
-    }
-    \endcode
-
-    Now, the mutex will always be unlocked when the TQMutexLocker
-    object is destroyed (when the function returns since \c locker is
-    an auto variable). Note that the mutex will be unlocked after
-    the call to moreComplexFunction() in this example, avoiding
-    possible bugs caused by unlocking the mutex too early, as in
-    the first example.
-
-    The same principle applies to code that throws and catches
-    exceptions. An exception that is not caught in the function that
-    has locked the mutex has no way of unlocking the mutex before the
-    exception is passed up the stack to the calling function.
-
-    TQMutexLocker also provides a mutex() member function that returns
-    the mutex on which the TQMutexLocker is operating. This is useful
-    for code that needs access to the mutex, such as
-    TQWaitCondition::wait(). For example:
-
-    \code
-    class SignalWaiter
-    {
-    private:
-	TQMutexLocker locker;
-
-    public:
-	SignalWaiter( TQMutex *mutex )
-	    : locker( mutex )
-	{
-	}
-
-	void waitForSignal()
-	{
-	    ...
-	    ...
-	    ...
-
-	    while ( ! signalled )
-		waitcondition.wait( locker.mutex() );
-
-	    ...
-	    ...
-	    ...
-	}
-    };
-    \endcode
-
-    \sa TQMutex, TQWaitCondition
-*/
-
-/*!
-    \fn TQMutexLocker::TQMutexLocker( TQMutex *mutex )
-
-    Constructs a TQMutexLocker and locks \a mutex. The mutex will be
-    unlocked when the TQMutexLocker is destroyed. If \a mutex is zero,
-    TQMutexLocker does nothing.
-
-    \sa TQMutex::lock()
-*/
-
-/*!
-    \fn TQMutexLocker::~TQMutexLocker()
-
-    Destroys the TQMutexLocker and unlocks the mutex which was locked
-    in the constructor.
-
-    \sa TQMutexLocker::TQMutexLocker(), TQMutex::unlock()
-*/
-
-/*!
-    \fn TQMutex *TQMutexLocker::mutex() const
-
-    Returns a pointer to the mutex which was locked in the
-    constructor.
-
-    \sa TQMutexLocker::TQMutexLocker()
-*/
-
-#endif // TQT_THREAD_SUPPORT