Removed unnecessary and/or TDE-unrelated code.

Signed-off-by: Michele Calgaro <[email protected]>
Signed-off-by: Slávek Banko <[email protected]>

1 files changed, 0 insertions, 474 deletions

diff --git a/tqtinterface/qt4/src/kernel/tqthread_unix.cpp b/tqtinterface/qt4/src/kernel/tqthread_unix.cpp
deleted file mode 100644
index 11a1a90..0000000
--- a/tqtinterface/qt4/src/kernel/tqthread_unix.cpp
+++ /dev/null
@@ -1,474 +0,0 @@
-/****************************************************************************
-**
-** TQThread class for Unix
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the kernel 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 [email protected].
-**
-** 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;
-
-#include "tqthread.h"
-#include <private/tqthreadinstance_p.h>
-#include <private/tqmutex_p.h>
-#include <private/tqmutexpool_p.h>
-#include <tqthreadstorage.h>
-
-#include <errno.h>
-#include <sched.h>
-
-
-static TQThreadInstance main_instance = {
-    0, { 0, &main_instance }, 0, 0, 1, 0, PTHREAD_COND_INITIALIZER, 0
-};
-
-
-static TQMutexPool *qt_thread_mutexpool = 0;
-
-
-#if defined(TQ_C_CALLBACKS)
-extern "C" {
-#endif
-
-typedef void*(*TQtThreadCallback)(void*);
-
-static pthread_once_t storage_key_once = PTHREAD_ONCE_INIT;
-static pthread_key_t storage_key;
-static void create_storage_key()
-{
-    pthread_key_create( &storage_key, NULL );
-}
-
-#if defined(TQ_C_CALLBACKS)
-}
-#endif
-
-
-/**************************************************************************
- ** TQThreadInstance
- *************************************************************************/
-
-TQThreadInstance *TQThreadInstance::current()
-{
-    pthread_once( &storage_key_once, create_storage_key );
-    TQThreadInstance *ret = (TQThreadInstance *) pthread_getspecific( storage_key );
-    return ret;
-}
-
-void TQThreadInstance::init(unsigned int stackSize)
-{
-    stacksize = stackSize;
-    args[0] = args[1] = 0;
-    thread_storage = 0;
-    finished = FALSE;
-    running = FALSE;
-    orphan = FALSE;
-
-    pthread_cond_init(&thread_done, NULL);
-    thread_id = 0;
-
-    // threads have not been initialized yet, do it now
-    if (! qt_thread_mutexpool) TQThread::initialize();
-}
-
-void TQThreadInstance::deinit()
-{
-    pthread_cond_destroy(&thread_done);
-}
-
-void *TQThreadInstance::start( void *_arg )
-{
-    void **arg = (void **) _arg;
-
-    pthread_once( &storage_key_once, create_storage_key );
-    pthread_setspecific( storage_key, arg[1] );
-    pthread_cleanup_push( TQThreadInstance::finish, arg[1] );
-    pthread_testcancel();
-
-    ( (TQThread *) arg[0] )->run();
-
-    pthread_cleanup_pop( TRUE );
-    return 0;
-}
-
-void TQThreadInstance::finish( void * )
-{
-    TQThreadInstance *d = current();
-
-    if ( ! d ) {
-#ifdef TQT_CHECK_STATE
-	qWarning( "TQThread: internal error: zero data for running thread." );
-#endif // TQT_CHECK_STATE
-	return;
-    }
-
-    TQMutexLocker locker( d->mutex() );
-    d->running = FALSE;
-    d->finished = TRUE;
-    d->args[0] = d->args[1] = 0;
-
-
-    TQThreadStorageData::finish( d->thread_storage );
-    d->thread_storage = 0;
-
-    d->thread_id = 0;
-    pthread_cond_broadcast(&d->thread_done);
-
-    if (d->orphan) {
-        d->deinit();
-	delete d;
-    }
-}
-
-TQMutex *TQThreadInstance::mutex() const
-{
-    return qt_thread_mutexpool ? qt_thread_mutexpool->get( (void *) this ) : 0;
-}
-
-void TQThreadInstance::terminate()
-{
-    if ( ! thread_id ) return;
-    pthread_cancel( thread_id );
-}
-
-
-/**************************************************************************
- ** TQThread
- *************************************************************************/
-
-/*!
-    This returns the thread handle of the currently executing thread.
-
-    \warning The handle returned by this function is used for internal
-    purposes and should \e not be used in any application code. On
-    Windows, the returned value is a pseudo handle for the current
-    thread, and it cannot be used for numerical comparison.
-*/
-TQt::HANDLE TQThread::currentThread()
-{
-    return (HANDLE) pthread_self();
-}
-
-/*! \internal
-  Initializes the TQThread system.
-*/
-void TQThread::initialize()
-{
-    if ( ! tqt_global_mutexpool )
-	tqt_global_mutexpool = new TQMutexPool( TRUE, 73 );
-    if ( ! qt_thread_mutexpool )
-	qt_thread_mutexpool = new TQMutexPool( FALSE, 127 );
-
-    pthread_once( &storage_key_once, create_storage_key );
-    pthread_setspecific( storage_key, &main_instance );
-}
-
-/*! \internal
-  Cleans up the TQThread system.
-*/
-void TQThread::cleanup()
-{
-    delete tqt_global_mutexpool;
-    delete qt_thread_mutexpool;
-    tqt_global_mutexpool = 0;
-    qt_thread_mutexpool = 0;
-
-    TQThreadInstance::finish(&main_instance);
-
-    pthread_once( &storage_key_once, create_storage_key );
-    pthread_setspecific( storage_key, 0 );
-}
-
-/*!
-    Ends the execution of the calling thread and wakes up any threads
-    waiting for its termination.
-*/
-void TQThread::exit()
-{
-    pthread_exit( 0 );
-}
-
-/*  \internal
-    helper function to do thread sleeps, since usleep()/nanosleep()
-    aren't reliable enough (in terms of behavior and availability)
-*/
-static void thread_sleep( struct timespec *ti )
-{
-    pthread_mutex_t mtx;
-    pthread_cond_t cnd;
-
-    pthread_mutex_init(&mtx, 0);
-    pthread_cond_init(&cnd, 0);
-
-    pthread_mutex_lock( &mtx );
-    (void) pthread_cond_timedwait( &cnd, &mtx, ti );
-    pthread_mutex_unlock( &mtx );
-
-    pthread_cond_destroy( &cnd );
-    pthread_mutex_destroy( &mtx );
-}
-
-/*!
-    System independent sleep. This causes the current thread to sleep
-    for \a secs seconds.
-*/
-void TQThread::sleep( unsigned long secs )
-{
-    struct timeval tv;
-    gettimeofday( &tv, 0 );
-    struct timespec ti;
-    ti.tv_sec = tv.tv_sec + secs;
-    ti.tv_nsec = ( tv.tv_usec * 1000 );
-    thread_sleep( &ti );
-}
-
-/*!
-    System independent sleep. This causes the current thread to sleep
-    for \a msecs milliseconds
-*/
-void TQThread::msleep( unsigned long msecs )
-{
-    struct timeval tv;
-    gettimeofday( &tv, 0 );
-    struct timespec ti;
-
-    ti.tv_nsec = ( tv.tv_usec + ( msecs % 1000 ) * 1000 ) * 1000;
-    ti.tv_sec = tv.tv_sec + ( msecs / 1000 ) + ( ti.tv_nsec / 1000000000 );
-    ti.tv_nsec %= 1000000000;
-    thread_sleep( &ti );
-}
-
-/*!
-    System independent sleep. This causes the current thread to sleep
-    for \a usecs microseconds
-*/
-void TQThread::usleep( unsigned long usecs )
-{
-    struct timeval tv;
-    gettimeofday( &tv, 0 );
-    struct timespec ti;
-
-    ti.tv_nsec = ( tv.tv_usec + ( usecs % 1000000 ) ) * 1000;
-    ti.tv_sec = tv.tv_sec + ( usecs / 1000000 ) + ( ti.tv_nsec / 1000000000 );
-    ti.tv_nsec %= 1000000000;
-    thread_sleep( &ti );
-}
-
-/*!
-    Begins execution of the thread by calling run(), which should be
-    reimplemented in a TQThread subclass to contain your code.  The
-    operating system will schedule the thread according to the \a
-    priority argument.
-
-    If you try to start a thread that is already running, this
-    function will wait until the the thread has finished and then
-    restart the thread.
-
-    \sa Priority
-*/
-void TQThread::start(Priority priority)
-{
-    TQMutexLocker locker( d->mutex() );
-
-    if ( d->running )
-        pthread_cond_wait(&d->thread_done, &locker.mutex()->d->handle);
-    d->running = TRUE;
-    d->finished = FALSE;
-
-    int ret;
-    pthread_attr_t attr;
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-
-#if !defined(TQ_OS_OPENBSD) && defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING-0 >= 0)
-    switch (priority) {
-    case InheritPriority:
-	{
-	    pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
-	    break;
-	}
-
-    default:
-	{
-	    int sched_policy;
-	    if (pthread_attr_getschedpolicy(&attr, &sched_policy) != 0) {
-                // failed to get the scheduling policy, don't bother
-                // setting the priority
-                qWarning("TQThread: cannot determine default scheduler policy");
-                break;
-	    }
-
-	    int prio_min = sched_get_priority_min(sched_policy);
-	    int prio_max = sched_get_priority_max(sched_policy);
-            if (prio_min == -1 || prio_max == -1) {
-                // failed to get the scheduling parameters, don't
-                // bother setting the priority
-                qWarning("TQThread: cannot determine scheduler priority range");
-                break;
-            }
-
-	    int prio;
-	    switch (priority) {
-	    case IdlePriority:
-		prio = prio_min;
-		break;
-
-	    case HighestPriority:
-		prio = prio_max;
-		break;
-
-	    default:
-		// crudely scale our priority enum values to the prio_min/prio_max
-		prio = (((prio_max - prio_min) / TimeCriticalPriority) *
-			priority) + prio_min;
-		prio = TQMAX(prio_min, TQMIN(prio_max, prio));
-		break;
-	    }
-
-	    sched_param sp;
-	    sp.sched_priority = prio;
-
-	    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
-	    pthread_attr_setschedparam(&attr, &sp);
-	    break;
-	}
-    }
-#endif // _POSIX_THREAD_PRIORITY_SCHEDULING
-
-    if ( d->stacksize > 0 ) {
-#if defined(_POSIX_THREAD_ATTR_STACKSIZE) && (_POSIX_THREAD_ATTR_STACKSIZE-0 > 0)
-	ret = pthread_attr_setstacksize( &attr, d->stacksize );
-#else
-	ret = ENOSYS; // stack size not supported, automatically fail
-#endif // _POSIX_THREAD_ATTR_STACKSIZE
-
-	if ( ret ) {
-#ifdef TQT_CHECK_STATE
-	    qWarning( "TQThread::start: thread stack size error: %s", strerror( ret ) ) ;
-#endif // TQT_CHECK_STATE
-
-	    // we failed to set the stacksize, and as the documentation states,
-	    // the thread will fail to run...
-	    d->running = FALSE;
-	    d->finished = FALSE;
-	    return;
-	}
-    }
-
-    d->args[0] = this;
-    d->args[1] = d;
-    ret = pthread_create( &d->thread_id, &attr, (TQtThreadCallback)TQThreadInstance::start, d->args );
-#if defined (TQ_OS_HPUX)
-    if (ret == EPERM) {
-        pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
-	ret = pthread_create(&d->thread_id, &attr, (TQtThreadCallback)TQThreadInstance::start, d->args);
-    }
-#endif
-    pthread_attr_destroy( &attr );
-
-    if ( ret ) {
-#ifdef TQT_CHECK_STATE
-	qWarning( "TQThread::start: thread creation error: %s", strerror( ret ) );
-#endif // TQT_CHECK_STATE
-
-	d->running = FALSE;
-	d->finished = FALSE;
-	d->args[0] = d->args[1] = 0;
-    }
-}
-
-void TQThread::start()
-{
-    start(InheritPriority);
-}
-
-/*!
-    A thread calling this function will block until either of these
-    conditions is met:
-
-    \list
-    \i The thread associated with this TQThread object has finished
-       execution (i.e. when it returns from \l{run()}). This function
-       will return TRUE if the thread has finished. It also returns
-       TRUE if the thread has not been started yet.
-    \i \a time milliseconds has elapsed. If \a time is ULONG_MAX (the
-    	default), then the wait will never timeout (the thread must
-	return from \l{run()}). This function will return FALSE if the
-	wait timed out.
-    \endlist
-
-    This provides similar functionality to the POSIX \c pthread_join() function.
-*/
-bool TQThread::wait( unsigned long time )
-{
-    TQMutexLocker locker( d->mutex() );
-
-    if ( d->thread_id == pthread_self() ) {
-#ifdef TQT_CHECK_STATE
-	qWarning( "TQThread::wait: thread tried to wait on itself" );
-#endif // TQT_CHECK_STATE
-
-	return FALSE;
-    }
-
-    if ( d->finished || ! d->running )
-	return TRUE;
-
-    int ret;
-    if (time != ULONG_MAX) {
-	struct timeval tv;
-	gettimeofday(&tv, 0);
-
-	timespec ti;
-	ti.tv_nsec = (tv.tv_usec + (time % 1000) * 1000) * 1000;
-	ti.tv_sec = tv.tv_sec + (time / 1000) + (ti.tv_nsec / 1000000000);
-	ti.tv_nsec %= 1000000000;
-
-	ret = pthread_cond_timedwait(&d->thread_done, &locker.mutex()->d->handle, &ti);
-    } else
-	ret = pthread_cond_wait(&d->thread_done, &locker.mutex()->d->handle);
-
-#ifdef TQT_CHECK_RANGE
-    if (ret && ret != ETIMEDOUT)
-	qWarning("Wait condition wait failure: %s",strerror(ret));
-#endif
-
-    return (ret == 0);
-}
-
-
-#endif // TQT_THREAD_SUPPORT