Attachment #419 for bug #860

By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release. View | Details | Raw Unified | Return to bug 860
Collapse All | Expand All

Lines 174-181 Link Here

(-)tdelibs/DEBUG (-2 / +2 lines)
174	do two things:	174	do two things:
175		175
176	1) Disable the TDE crash handler. This can be done either by using the	176	1) Disable the TDE crash handler. This can be done either by using the
177	--nocrashhandler command line option or by setting the KDE_DEBUG environment	177	--nocrashhandler command line option or by setting the TDE_DEBUG environment
178	variable to some value e.g. KDE_DEBUG=true.	178	variable to some value e.g. TDE_DEBUG=true.
179		179
180	2) Enable core dump generation by changing the so called 'ulimits' with the	180	2) Enable core dump generation by changing the so called 'ulimits' with the
181	following command:	181	following command:

Lines 535-541 Link Here

(-)tdelibs/kate/part/test_regression.cpp (-1 / +1 lines)
535	// we're not interested	535	// we're not interested
536	toplevel->statusBar()->hide();	536	toplevel->statusBar()->hide();
537		537
538	if (!getenv("KDE_DEBUG")) {	538	if (!getenv("TDE_DEBUG")) {
539	// set ulimits	539	// set ulimits
540	rlimit vmem_limit = { 25610241024, RLIM_INFINITY }; // 256Mb Memory should suffice	540	rlimit vmem_limit = { 25610241024, RLIM_INFINITY }; // 256Mb Memory should suffice
541	setrlimit(RLIMIT_AS, &vmem_limit);	541	setrlimit(RLIMIT_AS, &vmem_limit);

Lines 578-584 Link Here

(-)tdelibs/khtml/test_regression.cpp (-1 / +1 lines)
578	// we're not interested	578	// we're not interested
579	toplevel->statusBar()->hide();	579	toplevel->statusBar()->hide();
580		580
581	if (!getenv("KDE_DEBUG")) {	581	if (!getenv("TDE_DEBUG")) {
582	// set ulimits	582	// set ulimits
583	rlimit vmem_limit = { 25610241024, RLIM_INFINITY }; // 256Mb Memory should suffice	583	rlimit vmem_limit = { 25610241024, RLIM_INFINITY }; // 256Mb Memory should suffice
584	setrlimit(RLIMIT_AS, &vmem_limit);	584	setrlimit(RLIMIT_AS, &vmem_limit);

Lines 168-174 Link Here

(-)tdelibs/kio/kio/slavebase.cpp (-1 / +1 lines)
168	{	168	{
169	s_protocol = protocol.data();	169	s_protocol = protocol.data();
170	#ifdef Q_OS_UNIX	170	#ifdef Q_OS_UNIX
171	if (!getenv("KDE_DEBUG"))	171	if (!getenv("TDE_DEBUG"))
172	{	172	{
173	KCrash::setCrashHandler( sigsegv_handler );	173	KCrash::setCrashHandler( sigsegv_handler );
174	signal(SIGILL,&sigsegv_handler);	174	signal(SIGILL,&sigsegv_handler);

Lines 1641-1647 Link Here

(-)tdelibs/tdecore/kapplication.cpp (-1 / +1 lines)
1641	}	1641	}
1642	}	1642	}
1643		1643
1644	bool nocrashhandler = (getenv("KDE_DEBUG") != NULL);	1644	bool nocrashhandler = (getenv("TDE_DEBUG") != NULL);
1645	if (!nocrashhandler && args->isSet("crashhandler"))	1645	if (!nocrashhandler && args->isSet("crashhandler"))
1646	{	1646	{
1647	// set default crash handler / set emergency save function to nothing	1647	// set default crash handler / set emergency save function to nothing

Lines 1227-1233 Link Here

(-)tdelibs/kinit/kinit.cpp (-2 / +2 lines)
1227		1227
1228	// support for the old a bit broken way of setting DISPLAY for multihead	1228	// support for the old a bit broken way of setting DISPLAY for multihead
1229	TQCString olddisplay = getenv(DISPLAY);	1229	TQCString olddisplay = getenv(DISPLAY);
1230	TQCString kdedisplay = getenv("KDE_DISPLAY");	1230	TQCString kdedisplay = getenv("TDE_DISPLAY");
1231	bool reset_display = (! olddisplay.isEmpty() &&	1231	bool reset_display = (! olddisplay.isEmpty() &&
1232	! kdedisplay.isEmpty() &&	1232	! kdedisplay.isEmpty() &&
1233	olddisplay != kdedisplay);	1233	olddisplay != kdedisplay);
Lines 1240-1246 Link Here
1240	tty, avoid_loops, startup_id_str );	1240	tty, avoid_loops, startup_id_str );
1241		1241
1242	if (reset_display) {	1242	if (reset_display) {
1243	unsetenv("KDE_DISPLAY");	1243	unsetenv("TDE_DISPLAY");
1244	setenv(DISPLAY, olddisplay, true);	1244	setenv(DISPLAY, olddisplay, true);
1245	}	1245	}

Lines 233-239 Link Here

(-)tdelibs/tdecore/ktempfile.cpp (-1 / +1 lines)
233		233
234	if (mFd >= 0)	234	if (mFd >= 0)
235	{	235	{
236	if( qstrcmp( getenv( "KDE_EXTRA_FSYNC" ), "1" ) == 0 )	236	if( qstrcmp( getenv( "TDE_EXTRA_FSYNC" ), "1" ) == 0 )
237	{	237	{
238	result = FDATASYNC(mFd);	238	result = FDATASYNC(mFd);
239	if (result)	239	if (result)

Lines 390-397 Link Here

(-)tdelibs/kio/kio/slave.cpp (-2 / +2 lines)
390	// for the slave to connect to the application.	390	// for the slave to connect to the application.
391	// In such case we start the slave via KProcess.	391	// In such case we start the slave via KProcess.
392	// It's possible to force this by setting the env. variable	392	// It's possible to force this by setting the env. variable
393	// KDE_FORK_SLAVES, Clearcase seems to require this.	393	// TDE_FORK_SLAVES, Clearcase seems to require this.
394	static bool bForkSlaves = !TQCString(getenv("KDE_FORK_SLAVES")).isEmpty();	394	static bool bForkSlaves = !TQCString(getenv("TDE_FORK_SLAVES")).isEmpty();
395		395
396	if (bForkSlaves \|\| !client->isAttached() \|\| client->isAttachedToForeignServer())	396	if (bForkSlaves \|\| !client->isAttached() \|\| client->isAttachedToForeignServer())
397	{	397	{

Lines 156-162 Link Here

(-)tdelibs/kio/tests/kurifiltertest.cpp (-1 / +1 lines)
156	// Ensure that user configuration doesn't change the results of those tests	156	// Ensure that user configuration doesn't change the results of those tests
157	// TDEHOME needs to be writable though, for a ksycoca database	157	// TDEHOME needs to be writable though, for a ksycoca database
158	setenv( "TDEHOME", TQFile::encodeName( TQDir::homeDirPath() + "/.kde-kurifiltertest" ), true );	158	setenv( "TDEHOME", TQFile::encodeName( TQDir::homeDirPath() + "/.kde-kurifiltertest" ), true );
159	setenv( "KDE_FORK_SLAVES", "yes", true ); // simpler, for the final cleanup	159	setenv( "TDE_FORK_SLAVES", "yes", true ); // simpler, for the final cleanup
160		160
161	KAboutData aboutData(appName, programName, version, description);	161	KAboutData aboutData(appName, programName, version, description);
162	KCmdLineArgs::init(argc, argv, &aboutData);	162	KCmdLineArgs::init(argc, argv, &aboutData);

Lines 838-844 Link Here

(-)tdelibs/kinit/kinit.cpp (-1 / +1 lines)
838		838
839	{	839	{
840	TQCString path = home_dir;	840	TQCString path = home_dir;
841	TQCString readOnly = getenv("KDE_HOME_READONLY");	841	TQCString readOnly = getenv("TDE_HOME_READONLY");
842	if (access(path.data(), R_OK\|W_OK))	842	if (access(path.data(), R_OK\|W_OK))
843	{	843	{
844	if (errno == ENOENT)	844	if (errno == ENOENT)

Lines 919-925 Link Here

(-)tdelibs/tdecore/kapplication.cpp (-1 / +1 lines)
919	// * We use kdialog to warn the user, so we better not generate warnings from	919	// * We use kdialog to warn the user, so we better not generate warnings from
920	// kdialog itself.	920	// kdialog itself.
921	// * Don't warn if we run with a read-only $HOME	921	// * Don't warn if we run with a read-only $HOME
922	TQCString readOnly = getenv("KDE_HOME_READONLY");	922	TQCString readOnly = getenv("TDE_HOME_READONLY");
923	if (readOnly.isEmpty() && (tqstrcmp(name(), "kdialog") != 0))	923	if (readOnly.isEmpty() && (tqstrcmp(name(), "kdialog") != 0))
924	{	924	{
925	KConfigGroupSaver saver(config, "KDE Action Restrictions");	925	KConfigGroupSaver saver(config, "KDE Action Restrictions");

Lines 590-596 Link Here

(-)tdelibs/kinit/kinit.cpp (-2 / +2 lines)
590	exitWithErrorMsg(errorMsg);	590	exitWithErrorMsg(errorMsg);
591	}	591	}
592		592
593	if ( getenv("KDE_IS_PRELINKED") && !execpath.isEmpty() && !launcher)	593	if ( getenv("TDE_IS_PRELINKED") && !execpath.isEmpty() && !launcher)
594	libpath.truncate(0);	594	libpath.truncate(0);
595		595
596	if ( !libpath.isEmpty() )	596	if ( !libpath.isEmpty() )
Lines 1804-1810 Link Here
1804	}	1804	}
1805	}	1805	}
1806	#ifndef __CYGWIN__	1806	#ifndef __CYGWIN__
1807	if (!d.suicide && !getenv("KDE_IS_PRELINKED"))	1807	if (!d.suicide && !getenv("TDE_IS_PRELINKED"))
1808	{	1808	{
1809	TQString konq = locate("lib", "libkonq.la", s_instance);	1809	TQString konq = locate("lib", "libkonq.la", s_instance);
1810	if (!konq.isEmpty())	1810	if (!konq.isEmpty())

Lines 1568-1574 Link Here

(-)tdelibs/tdecore/kstandarddirs.cpp (-1 / +1 lines)
1568		1568
1569	bool readProfiles = true;	1569	bool readProfiles = true;
1570		1570
1571	if (kde_kiosk_admin && !TQCString(getenv("KDE_KIOSK_NO_PROFILES")).isEmpty())	1571	if (kde_kiosk_admin && !TQCString(getenv("TDE_KIOSK_NO_PROFILES")).isEmpty())
1572	readProfiles = false;	1572	readProfiles = false;
1573		1573
1574	TQString userMapFile = config->readEntry("userProfileMapFile");	1574	TQString userMapFile = config->readEntry("userProfileMapFile");

Lines 205-211 Link Here

(-)tdelibs/tdecore/kinstance.cpp (-1 / +1 lines)
205	}	205	}
206		206
207	// Check if we are excempt from kiosk restrictions	207	// Check if we are excempt from kiosk restrictions
208	if (kde_kiosk_admin && !kde_kiosk_exception && !TQCString(getenv("KDE_KIOSK_NO_RESTRICTIONS")).isEmpty())	208	if (kde_kiosk_admin && !kde_kiosk_exception && !TQCString(getenv("TDE_KIOSK_NO_RESTRICTIONS")).isEmpty())
209	{	209	{
210	kde_kiosk_exception = true;	210	kde_kiosk_exception = true;
211	d->sharedConfig = 0;	211	d->sharedConfig = 0;

Lines 1630-1636 Link Here

(-)tdelibs/tdecore/kstandarddirs.cpp (-1 / +1 lines)
1630	}	1630	}
1631		1631
1632	// Process KIOSK restrictions.	1632	// Process KIOSK restrictions.
1633	if (!kde_kiosk_admin \|\| TQCString(getenv("KDE_KIOSK_NO_RESTRICTIONS")).isEmpty())	1633	if (!kde_kiosk_admin \|\| TQCString(getenv("TDE_KIOSK_NO_RESTRICTIONS")).isEmpty())
1634	{	1634	{
1635	config->setGroup("KDE Resource Restrictions");	1635	config->setGroup("KDE Resource Restrictions");
1636	TQMap<TQString, TQString> entries = config->entryMap("KDE Resource Restrictions");	1636	TQMap<TQString, TQString> entries = config->entryMap("KDE Resource Restrictions");

Lines 156-162 Link Here

(-)tdelibs/tdecore/klocale.cpp (-1 / +1 lines)
156	TQStringList languageList;	156	TQStringList languageList;
157	if ( useEnv )	157	if ( useEnv )
158	languageList += TQStringList::split	158	languageList += TQStringList::split
159	(':', TQFile::decodeName( ::getenv("KDE_LANG") ));	159	(':', TQFile::decodeName( ::getenv("TDE_LANG") ));
160	languageList += config->readListEntry("Language", ':');	160	languageList += config->readListEntry("Language", ':');

Lines 130-136 Link Here

(-)tdelibs/tdecore/klocale.h (-1 / +1 lines)
130	* The constructor looks for an entry Locale/Language in the	130	* The constructor looks for an entry Locale/Language in the
131	* configuration file.	131	* configuration file.
132	* If no config file is specified, it will also look for languages	132	* If no config file is specified, it will also look for languages
133	* using the environment variables (KDE_LANG, LC_MESSAGES, LC_ALL, LANG),	133	* using the environment variables (TDE_LANG, LC_MESSAGES, LC_ALL, LANG),
134	* as well as the global configuration file. If KLocale is not able to use	134	* as well as the global configuration file. If KLocale is not able to use
135	* any of the specified languages, the default language (en_US) will be	135	* any of the specified languages, the default language (en_US) will be
136	* used.	136	* used.





OPTION( WITH_ALL_OPTIONS "Enable all optional support" OFF )

OPTION( TDE_MALLOC "Use own malloc implementation" OFF )
OPTION( TDE_MALLOC_DEBUG "Enable debugging in fast malloc" OFF )
OPTION( TDE_MALLOC_FULL "Make alloc as fast as possible" OFF )

OPTION( WITH_ARTS "Build with aRts" ON )
OPTION( WITH_ALSA "Enable ALSA support" ON )


### FIXME fast malloc is also available on x86_64 architecture?
if( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )
  set( TDE_MALLOC_X86 1 )
  message( STATUS "Found x86 architecture" )
else( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )
  if( TDE_MALLOC )
    message( FATAL_ERROR "\nKDE fast malloc is available only on x86 architecture" )
  endif( TDE_MALLOC )
endif( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )






#define KDE_DISTRIBUTION_TEXT "@KDE_DISTRIBUTION_TEXT@"

/* Use own malloc implementation */
#cmakedefine TDE_MALLOC 1

/* Enable debugging in fast malloc */
#cmakedefine TDE_MALLOC_DEBUG 1

/* Make alloc as fast as possible */
#cmakedefine TDE_MALLOC_FULL 1

/* The libc used is glibc */
#undef TDE_MALLOC_GLIBC

/* The platform is x86 */
#cmakedefine TDE_MALLOC_X86 1

/* Define if we shall use KSSL */
#cmakedefine KSSL_HAVE_SSL 1




 There's a new configure switch, --enable-fast-malloc. By default it's turned off, disabling
the system libc one and using this one. Using --enable-fast-malloc=full enables this
malloc unconditionally, aiming for the maximum performance. By using only --enable-fast-malloc,
it's possible to select both malloc implementations at runtime. When $TDE_MALLOC is set to 0,
the system libc malloc is used, otherwise this malloc is used.

 For now, the requirements are :

#define USE_MEMCPY 0
#define MMAP_CLEARS 1
made all functions INLINE
added #ifdef TDE_MALLOC_DEBUG -> #define DEBUG
reordered all functions in order to avoid 'warning: `XYZ' declared inline after being called'
    especially moved the public_* ones at the end of the file
commented out #including malloc.h
added #include <config.h> at the top and enclosed whole file in #ifdef TDE_MALLOC
taken posix_memalign() from glibc
removed public icalloc(),icomalloc(),mtrim(),musable()  (they don't exist everywhere anyway)
enclosed the pthreads part by #if 0 and replaced it with spinlock from glibc CVS (in x86.h)

#define MALLOC_PREACTION   lock( &spinlock )
#define MALLOC_POSTACTION  unlock( &spinlock )
----------
public functions call either functions in this malloc or in libc, depending on $TDE_MALLOC
the kde_malloc_is_used hack






dnl --enable-fast-malloc      - depends on $TDE_MALLOC
dnl --disable-fast-malloc     - disabled
dnl --enable-fast-malloc=full - enabled always
dnl

dnl platforms for which there's a spinlock implementation
    case $target_cpu in
        i?86)
            AC_DEFINE(TDE_MALLOC_X86, 1, [The platform is x86])
            ;;
        *)
            if test "$kde_fast_malloc" = "notgiven"; then

fi

if test "$kde_fast_malloc" = "yes" -o "$kde_fast_malloc" = "notgiven" -o "$kde_fast_malloc" = "debug"; then
dnl $TDE_MALLOC needs glibc (__libc_malloc etc.)
    AC_CACHE_CHECK([if the libc is glibc],kde_cv_libc_glibc,
        [AC_TRY_COMPILE(
            [#include<stdlib.h>],

            [kde_cv_libc_glibc=no])
        ])
    if test "$kde_cv_libc_glibc" = "yes"; then
        AC_DEFINE(TDE_MALLOC_GLIBC, 1, [The libc used is glibc])
    else
        if test "$kde_fast_malloc" = "notgiven"; then
            kde_fast_malloc=notgiven_full

fi

if test "$kde_fast_malloc" != "no"; then
    AC_DEFINE(TDE_MALLOC, 1, [Use own malloc implementation])
fi

if test "$kde_fast_malloc" = "debug" -o "$kde_fast_malloc" = "debug_full"; then
    AC_DEFINE(TDE_MALLOC_DEBUG, 1, [Enable debugging in fast malloc])
fi

if test "$kde_fast_malloc" = "full" -o "$kde_fast_malloc" = "debug_full"; then
    AC_DEFINE(TDE_MALLOC_FULL, 1, [Make alloc as fast as possible])
fi

dnl -finline-limit=<large num> is needed for gcc3 in order to inline large functions




*/
int kde_malloc_is_used = 0;

#ifdef TDE_MALLOC

#ifdef TDE_MALLOC_DEBUG
#define DEBUG
#endif



#else

#ifdef TDE_MALLOC_X86
#include "x86.h"
#else
#error Unknown spinlock implementation


#ifdef USE_PUBLIC_MALLOC_WRAPPERS

#ifndef TDE_MALLOC_FULL

#ifdef TDE_MALLOC_GLIBC
#include "glibc.h"
#else
/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/

static int malloc_type = 0;
static void init_malloc_type(void)
    {
    const char* const env = getenv( "TDE_MALLOC" );
    if( env == NULL )
        malloc_type = 1;
    else if( env[ 0 ] == '0' || env[ 0 ] == 'n' || env[ 0 ] == 'N' )

#endif

Void_t* public_mALLOc(size_t bytes) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  if (MALLOC_POSTACTION != 0) {
  }
  return m;
#ifndef TDE_MALLOC_FULL
    }
  if( malloc_type == 2 )
      return libc_malloc( bytes );

}

void public_fREe(Void_t* m) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  fREe(m);
  if (MALLOC_POSTACTION != 0) {
  }
#ifndef TDE_MALLOC_FULL
  return;
    }
  if( malloc_type == 2 )

}

Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  if (MALLOC_POSTACTION != 0) {
  }
  return m;
#ifndef TDE_MALLOC_FULL
    }
  if( malloc_type == 2 )
      return libc_realloc( m, bytes );

}

Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  if (MALLOC_POSTACTION != 0) {
  }
  return m;
#ifndef TDE_MALLOC_FULL
    }
  if( malloc_type == 2 )
      return libc_memalign( alignment, bytes );

}

Void_t* public_vALLOc(size_t bytes) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  if (MALLOC_POSTACTION != 0) {
  }
  return m;
#ifndef TDE_MALLOC_FULL
    }
  if( malloc_type == 2 )
      return libc_valloc( bytes );

}

Void_t* public_pVALLOc(size_t bytes) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  if (MALLOC_POSTACTION != 0) {
  }
  return m;
#ifndef TDE_MALLOC_FULL
    }
  if( malloc_type == 2 )
      return libc_pvalloc( bytes );

}

Void_t* public_cALLOc(size_t n, size_t elem_size) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  if (MALLOC_POSTACTION != 0) {
  }
  return m;
#ifndef TDE_MALLOC_FULL
    }
  if( malloc_type == 2 )
      return libc_calloc( n, elem_size );

}

void public_cFREe(Void_t* m) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  cFREe(m);
  if (MALLOC_POSTACTION != 0) {
  }
#ifndef TDE_MALLOC_FULL
  return;
    }
  if( malloc_type == 2 )

}

struct mallinfo public_mALLINFo() {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  if (MALLOC_POSTACTION != 0) {
  }
  return m;
#ifndef TDE_MALLOC_FULL
    }
  if( malloc_type == 2 )
      return libc_mallinfo();

}

int public_mALLOPt(int p, int v) {
#ifndef TDE_MALLOC_FULL
  if( malloc_type == 1 )
    {
#endif

  if (MALLOC_POSTACTION != 0) {
  }
  return result;
#ifndef TDE_MALLOC_FULL
    }
  if( malloc_type == 2 )
      return libc_mallopt( p, v );

Lines 147-153 Link Here

(-)tdelibs/tdecore/kextsock.cpp (-1 / +1 lines)
147	(flags & KExtendedSocket::canonName ? KResolver::CanonName : 0) \|	147	(flags & KExtendedSocket::canonName ? KResolver::CanonName : 0) \|
148	(flags & KExtendedSocket::noResolve ? KResolver::NoResolve : 0);	148	(flags & KExtendedSocket::noResolve ? KResolver::NoResolve : 0);
149		149
150	if (getenv("KDE_NO_IPV6"))	150	if (getenv("TDE_NO_IPV6"))
151	familyMask &= ~KResolver::IPv6Family;	151	familyMask &= ~KResolver::IPv6Family;
152		152
153	return true;	153	return true;

Lines 188-194 Link Here

(-)tdelibs/tdecore/netsupp.cpp (-1 / +1 lines)
188	# ifndef AF_INET6	188	# ifndef AF_INET6
189	return 2; // how can we check?	189	return 2; // how can we check?
190	# else	190	# else
191	if (getenv("KDE_NO_IPV6"))	191	if (getenv("TDE_NO_IPV6"))
192	return 2;	192	return 2;
193	int fd = ::socket(AF_INET6, SOCK_STREAM, 0);	193	int fd = ::socket(AF_INET6, SOCK_STREAM, 0);
194	if (fd == -1)	194	if (fd == -1)

Lines 63-69 Link Here

(-)tdelibs/tdecore/network/kresolverstandardworkers.cpp (-1 / +1 lines)
63	#ifndef AF_INET6	63	#ifndef AF_INET6
64	return false;	64	return false;
65	#else	65	#else
66	if (getenv("KDE_NO_IPV6") != 0L)	66	if (getenv("TDE_NO_IPV6") != 0L)
67	return false;	67	return false;
68		68
69	int fd = ::socket(AF_INET6, SOCK_STREAM, 0);	69	int fd = ::socket(AF_INET6, SOCK_STREAM, 0);

Lines 245-251 Link Here

(-)tdelibs/tdecore/network/ksrvresolverworker.cpp (-1 / +1 lines)
245	void initSrvWorker() KDE_NO_EXPORT;	245	void initSrvWorker() KDE_NO_EXPORT;
246	void initSrvWorker()	246	void initSrvWorker()
247	{	247	{
248	if (getenv("KDE_NO_SRV") != NULL)	248	if (getenv("TDE_NO_SRV") != NULL)
249	return;	249	return;
250		250
251	KResolverWorkerFactoryBase::registerNewWorker(new KResolverWorkerFactory<KSrvResolverWorker>);	251	KResolverWorkerFactoryBase::registerNewWorker(new KResolverWorkerFactory<KSrvResolverWorker>);

Lines 306-312 Link Here

(-)tdelibs/tdecore/klibloader.cpp (-1 / +1 lines)
306	d = new KLibLoaderPrivate;	306	d = new KLibLoaderPrivate;
307	lt_dlinit();	307	lt_dlinit();
308	d->unload_mode = KLibLoaderPrivate::UNKNOWN;	308	d->unload_mode = KLibLoaderPrivate::UNKNOWN;
309	if (getenv("KDE_NOUNLOAD") != 0)	309	if (getenv("TDE_NOUNLOAD") != 0)
310	d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD;	310	d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD;
311	else if (getenv("KDE_DOUNLOAD") != 0)	311	else if (getenv("KDE_DOUNLOAD") != 0)
312	d->unload_mode = KLibLoaderPrivate::UNLOAD;	312	d->unload_mode = KLibLoaderPrivate::UNLOAD;




   lastRequest = 0;
   bProcessingQueue = false;

   mSlaveDebug = getenv("TDE_SLAVE_DEBUG_WAIT");
   if (!mSlaveDebug.isEmpty())
   {
      qWarning("Klauncher running in slave-debug mode for slaves of protocol '%s'", mSlaveDebug.data());
   }
   mSlaveValgrind = getenv("TDE_SLAVE_VALGRIND");
   if (!mSlaveValgrind.isEmpty())
   {
      mSlaveValgrindSkin = getenv("TDE_SLAVE_VALGRIND_SKIN");
      qWarning("Klauncher running slaves through valgrind for slaves of protocol '%s'", mSlaveValgrind.data());
   }
   klauncher_header request_header;

Lines 940-946 Link Here

(-)tdelibs/tdecore/network/kresolver.cpp (-1 / +1 lines)
940		940
941	static TQStringList *KResolver_initIdnDomains()	941	static TQStringList *KResolver_initIdnDomains()
942	{	942	{
943	const char *kde_use_idn = getenv("KDE_USE_IDN");	943	const char *kde_use_idn = getenv("TDE_USE_IDN");
944	if (!kde_use_idn)	944	if (!kde_use_idn)
945	kde_use_idn = "ac:at:br:cat:ch:cl:cn:de:dk:fi:gr:hu:info:io:is:jp:kr:li:lt:museum:org:no:se:sh:th:tm:tw:vn";	945	kde_use_idn = "ac:at:br:cat:ch:cl:cn:de:dk:fi:gr:hu:info:io:is:jp:kr:li:lt:museum:org:no:se:sh:th:tm:tw:vn";
946	return new TQStringList(TQStringList::split(':', TQString::fromLatin1(kde_use_idn).lower()));	946	return new TQStringList(TQStringList::split(':', TQString::fromLatin1(kde_use_idn).lower()));

Lines 2074-2080 Link Here

(-)tdelibs/tdecore/klocale.cpp (-1 / +1 lines)
2074	{	2074	{
2075	// If the following environment variable is set, assume all filenames	2075	// If the following environment variable is set, assume all filenames
2076	// are in UTF-8 regardless of the current C locale.	2076	// are in UTF-8 regardless of the current C locale.
2077	d->utf8FileEncoding = getenv("KDE_UTF8_FILENAMES") != 0;	2077	d->utf8FileEncoding = getenv("TDE_UTF8_FILENAMES") != 0;
2078	if (d->utf8FileEncoding)	2078	if (d->utf8FileEncoding)
2079	{	2079	{
2080	TQFile::setEncodingFunction(KLocale::encodeFileNameUTF8);	2080	TQFile::setEncodingFunction(KLocale::encodeFileNameUTF8);




}

#define MAX_PATH 0x1ff
static char win32_mapDir_TDEDIR[MAX_PATH] = "";

// paths name mappings
// when mapping is performed, frees old name at *dir and allocates new path for *dir 

    static const char* WIN32_LIBDIR_TO = "c:/kde/lib/trinity";
    char *e;
//TODO........
    if (!*win32_mapDir_TDEDIR) {
      e = getenv("TDEDIR");
      if (e)
        strncpy( win32_mapDir_TDEDIR, e, MAX_PATH );
    }
    assert(dir && *dir && win32_mapDir_TDEDIR && *win32_mapDir_TDEDIR);
    // /opt/trinity/lib/trinity -> <letter>:/kde/lib/trinity

    if (strcmp(*dir, WIN32_LIBDIR_FROM)==0) {
        free(*dir);
        *dir=strdup(WIN32_LIBDIR_TO);
		if (win32_mapDir_TDEDIR && *win32_mapDir_TDEDIR) {
			(*dir)[0]=win32_mapDir_TDEDIR[0]; //copy drive letter
		}
    }
}

Lines 108-114 Link Here

(-)tdelibs/kded/kbuildsycoca.cpp (-2 / +2 lines)
108	}	108	}
109	else	109	else
110	{	110	{
111	TQCString ksycoca_env = getenv("KDESYCOCA");	111	TQCString ksycoca_env = getenv("TDESYCOCA");
112	if (ksycoca_env.isEmpty())	112	if (ksycoca_env.isEmpty())
113	path = KGlobal::dirs()->saveLocation("cache")+"ksycoca";	113	path = KGlobal::dirs()->saveLocation("cache")+"ksycoca";
114	else	114	else
Lines 120-126 Link Here
120		120
121	static TQString oldSycocaPath()	121	static TQString oldSycocaPath()
122	{	122	{
123	TQCString ksycoca_env = getenv("KDESYCOCA");	123	TQCString ksycoca_env = getenv("TDESYCOCA");
124	if (ksycoca_env.isEmpty())	124	if (ksycoca_env.isEmpty())
125	return KGlobal::dirs()->saveLocation("tmp")+"ksycoca";	125	return KGlobal::dirs()->saveLocation("tmp")+"ksycoca";
126		126

Lines 104-110 Link Here

(-)tdelibs/kded/kded.cpp (-1 / +1 lines)
104	{	104	{
105	_self = this;	105	_self = this;
106	TQCString cPath;	106	TQCString cPath;
107	TQCString ksycoca_env = getenv("KDESYCOCA");	107	TQCString ksycoca_env = getenv("TDESYCOCA");
108	if (ksycoca_env.isEmpty())	108	if (ksycoca_env.isEmpty())
109	cPath = TQFile::encodeName(KGlobal::dirs()->saveLocation("tmp")+"ksycoca");	109	cPath = TQFile::encodeName(KGlobal::dirs()->saveLocation("tmp")+"ksycoca");
110	else	110	else

Lines 112-118 Link Here

(-)tdelibs/tdecore/ksycoca.cpp (-1 / +1 lines)
112	m_str = 0;	112	m_str = 0;
113	m_barray = 0;	113	m_barray = 0;
114	TQString path;	114	TQString path;
115	TQCString ksycoca_env = getenv("KDESYCOCA");	115	TQCString ksycoca_env = getenv("TDESYCOCA");
116	if (ksycoca_env.isEmpty())	116	if (ksycoca_env.isEmpty())
117	path = KGlobal::dirs()->saveLocation("cache") + "ksycoca";	117	path = KGlobal::dirs()->saveLocation("cache") + "ksycoca";
118	else	118	else

Return to bug 860

Lines 720-738 Link Here

(-)tdelibs/config.h.cmake (-5 / +5 lines)
720	#define KDE_DISTRIBUTION_TEXT "@KDE_DISTRIBUTION_TEXT@"	720	#define KDE_DISTRIBUTION_TEXT "@KDE_DISTRIBUTION_TEXT@"
721		721
722	/* Use own malloc implementation */	722	/* Use own malloc implementation */
723	#cmakedefine KDE_MALLOC 1	723	#cmakedefine TDE_MALLOC 1
724		724
725	/* Enable debugging in fast malloc */	725	/* Enable debugging in fast malloc */
726	#cmakedefine KDE_MALLOC_DEBUG 1	726	#cmakedefine TDE_MALLOC_DEBUG 1
727		727
728	/* Make alloc as fast as possible */	728	/* Make alloc as fast as possible */
729	#cmakedefine KDE_MALLOC_FULL 1	729	#cmakedefine TDE_MALLOC_FULL 1
730		730
731	/* The libc used is glibc */	731	/* The libc used is glibc */
732	#undef KDE_MALLOC_GLIBC	732	#undef TDE_MALLOC_GLIBC
733		733
734	/* The platform is x86 */	734	/* The platform is x86 */
735	#cmakedefine KDE_MALLOC_X86 1	735	#cmakedefine TDE_MALLOC_X86 1
736		736
737	/* Define if we shall use KSSL */	737	/* Define if we shall use KSSL */
738	#cmakedefine KSSL_HAVE_SSL 1	738	#cmakedefine KSSL_HAVE_SSL 1

Lines 7-15 Link Here

(-)tdelibs/tdecore/malloc/malloc.c (-26 / +26 lines)
7	*/	7	*/
8	int kde_malloc_is_used = 0;	8	int kde_malloc_is_used = 0;
9		9
10	#ifdef KDE_MALLOC	10	#ifdef TDE_MALLOC
11		11
12	#ifdef KDE_MALLOC_DEBUG	12	#ifdef TDE_MALLOC_DEBUG
13	#define DEBUG	13	#define DEBUG
14	#endif	14	#endif
15		15
Lines 1559-1565 Link Here
1559		1559
1560	#else	1560	#else
1561		1561
1562	#ifdef KDE_MALLOC_X86	1562	#ifdef TDE_MALLOC_X86
1563	#include "x86.h"	1563	#include "x86.h"
1564	#else	1564	#else
1565	#error Unknown spinlock implementation	1565	#error Unknown spinlock implementation
Lines 5475-5483 Link Here
5475		5475
5476	#ifdef USE_PUBLIC_MALLOC_WRAPPERS	5476	#ifdef USE_PUBLIC_MALLOC_WRAPPERS
5477		5477
5478	#ifndef KDE_MALLOC_FULL	5478	#ifndef TDE_MALLOC_FULL
5479		5479
5480	#ifdef KDE_MALLOC_GLIBC	5480	#ifdef TDE_MALLOC_GLIBC
5481	#include "glibc.h"	5481	#include "glibc.h"
5482	#else	5482	#else
5483	/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/	5483	/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/
Lines 5491-5497 Link Here
5491	static int malloc_type = 0;	5491	static int malloc_type = 0;
5492	static void init_malloc_type(void)	5492	static void init_malloc_type(void)
5493	{	5493	{
5494	const char* const env = getenv( "KDE_MALLOC" );	5494	const char* const env = getenv( "TDE_MALLOC" );
5495	if( env == NULL )	5495	if( env == NULL )
5496	malloc_type = 1;	5496	malloc_type = 1;
5497	else if( env[ 0 ] == '0' \|\| env[ 0 ] == 'n' \|\| env[ 0 ] == 'N' )	5497	else if( env[ 0 ] == '0' \|\| env[ 0 ] == 'n' \|\| env[ 0 ] == 'N' )
Lines 5503-5509 Link Here
5503	#endif	5503	#endif
5504		5504
5505	Void_t* public_mALLOc(size_t bytes) {	5505	Void_t* public_mALLOc(size_t bytes) {
5506	#ifndef KDE_MALLOC_FULL	5506	#ifndef TDE_MALLOC_FULL
5507	if( malloc_type == 1 )	5507	if( malloc_type == 1 )
5508	{	5508	{
5509	#endif	5509	#endif
Lines 5515-5521 Link Here
5515	if (MALLOC_POSTACTION != 0) {	5515	if (MALLOC_POSTACTION != 0) {
5516	}	5516	}
5517	return m;	5517	return m;
5518	#ifndef KDE_MALLOC_FULL	5518	#ifndef TDE_MALLOC_FULL
5519	}	5519	}
5520	if( malloc_type == 2 )	5520	if( malloc_type == 2 )
5521	return libc_malloc( bytes );	5521	return libc_malloc( bytes );
Lines 5525-5531 Link Here
5525	}	5525	}
5526		5526
5527	void public_fREe(Void_t* m) {	5527	void public_fREe(Void_t* m) {
5528	#ifndef KDE_MALLOC_FULL	5528	#ifndef TDE_MALLOC_FULL
5529	if( malloc_type == 1 )	5529	if( malloc_type == 1 )
5530	{	5530	{
5531	#endif	5531	#endif
Lines 5535-5541 Link Here
5535	fREe(m);	5535	fREe(m);
5536	if (MALLOC_POSTACTION != 0) {	5536	if (MALLOC_POSTACTION != 0) {
5537	}	5537	}
5538	#ifndef KDE_MALLOC_FULL	5538	#ifndef TDE_MALLOC_FULL
5539	return;	5539	return;
5540	}	5540	}
5541	if( malloc_type == 2 )	5541	if( malloc_type == 2 )
Lines 5549-5555 Link Here
5549	}	5549	}
5550		5550
5551	Void_t* public_rEALLOc(Void_t* m, size_t bytes) {	5551	Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
5552	#ifndef KDE_MALLOC_FULL	5552	#ifndef TDE_MALLOC_FULL
5553	if( malloc_type == 1 )	5553	if( malloc_type == 1 )
5554	{	5554	{
5555	#endif	5555	#endif
Lines 5560-5566 Link Here
5560	if (MALLOC_POSTACTION != 0) {	5560	if (MALLOC_POSTACTION != 0) {
5561	}	5561	}
5562	return m;	5562	return m;
5563	#ifndef KDE_MALLOC_FULL	5563	#ifndef TDE_MALLOC_FULL
5564	}	5564	}
5565	if( malloc_type == 2 )	5565	if( malloc_type == 2 )
5566	return libc_realloc( m, bytes );	5566	return libc_realloc( m, bytes );
Lines 5570-5576 Link Here
5570	}	5570	}
5571		5571
5572	Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {	5572	Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
5573	#ifndef KDE_MALLOC_FULL	5573	#ifndef TDE_MALLOC_FULL
5574	if( malloc_type == 1 )	5574	if( malloc_type == 1 )
5575	{	5575	{
5576	#endif	5576	#endif
Lines 5582-5588 Link Here
5582	if (MALLOC_POSTACTION != 0) {	5582	if (MALLOC_POSTACTION != 0) {
5583	}	5583	}
5584	return m;	5584	return m;
5585	#ifndef KDE_MALLOC_FULL	5585	#ifndef TDE_MALLOC_FULL
5586	}	5586	}
5587	if( malloc_type == 2 )	5587	if( malloc_type == 2 )
5588	return libc_memalign( alignment, bytes );	5588	return libc_memalign( alignment, bytes );
Lines 5592-5598 Link Here
5592	}	5592	}
5593		5593
5594	Void_t* public_vALLOc(size_t bytes) {	5594	Void_t* public_vALLOc(size_t bytes) {
5595	#ifndef KDE_MALLOC_FULL	5595	#ifndef TDE_MALLOC_FULL
5596	if( malloc_type == 1 )	5596	if( malloc_type == 1 )
5597	{	5597	{
5598	#endif	5598	#endif
Lines 5604-5610 Link Here
5604	if (MALLOC_POSTACTION != 0) {	5604	if (MALLOC_POSTACTION != 0) {
5605	}	5605	}
5606	return m;	5606	return m;
5607	#ifndef KDE_MALLOC_FULL	5607	#ifndef TDE_MALLOC_FULL
5608	}	5608	}
5609	if( malloc_type == 2 )	5609	if( malloc_type == 2 )
5610	return libc_valloc( bytes );	5610	return libc_valloc( bytes );
Lines 5614-5620 Link Here
5614	}	5614	}
5615		5615
5616	Void_t* public_pVALLOc(size_t bytes) {	5616	Void_t* public_pVALLOc(size_t bytes) {
5617	#ifndef KDE_MALLOC_FULL	5617	#ifndef TDE_MALLOC_FULL
5618	if( malloc_type == 1 )	5618	if( malloc_type == 1 )
5619	{	5619	{
5620	#endif	5620	#endif
Lines 5626-5632 Link Here
5626	if (MALLOC_POSTACTION != 0) {	5626	if (MALLOC_POSTACTION != 0) {
5627	}	5627	}
5628	return m;	5628	return m;
5629	#ifndef KDE_MALLOC_FULL	5629	#ifndef TDE_MALLOC_FULL
5630	}	5630	}
5631	if( malloc_type == 2 )	5631	if( malloc_type == 2 )
5632	return libc_pvalloc( bytes );	5632	return libc_pvalloc( bytes );
Lines 5636-5642 Link Here
5636	}	5636	}
5637		5637
5638	Void_t* public_cALLOc(size_t n, size_t elem_size) {	5638	Void_t* public_cALLOc(size_t n, size_t elem_size) {
5639	#ifndef KDE_MALLOC_FULL	5639	#ifndef TDE_MALLOC_FULL
5640	if( malloc_type == 1 )	5640	if( malloc_type == 1 )
5641	{	5641	{
5642	#endif	5642	#endif
Lines 5648-5654 Link Here
5648	if (MALLOC_POSTACTION != 0) {	5648	if (MALLOC_POSTACTION != 0) {
5649	}	5649	}
5650	return m;	5650	return m;
5651	#ifndef KDE_MALLOC_FULL	5651	#ifndef TDE_MALLOC_FULL
5652	}	5652	}
5653	if( malloc_type == 2 )	5653	if( malloc_type == 2 )
5654	return libc_calloc( n, elem_size );	5654	return libc_calloc( n, elem_size );
Lines 5658-5664 Link Here
5658	}	5658	}
5659		5659
5660	void public_cFREe(Void_t* m) {	5660	void public_cFREe(Void_t* m) {
5661	#ifndef KDE_MALLOC_FULL	5661	#ifndef TDE_MALLOC_FULL
5662	if( malloc_type == 1 )	5662	if( malloc_type == 1 )
5663	{	5663	{
5664	#endif	5664	#endif
Lines 5668-5674 Link Here
5668	cFREe(m);	5668	cFREe(m);
5669	if (MALLOC_POSTACTION != 0) {	5669	if (MALLOC_POSTACTION != 0) {
5670	}	5670	}
5671	#ifndef KDE_MALLOC_FULL	5671	#ifndef TDE_MALLOC_FULL
5672	return;	5672	return;
5673	}	5673	}
5674	if( malloc_type == 2 )	5674	if( malloc_type == 2 )
Lines 5682-5688 Link Here
5682	}	5682	}
5683		5683
5684	struct mallinfo public_mALLINFo() {	5684	struct mallinfo public_mALLINFo() {
5685	#ifndef KDE_MALLOC_FULL	5685	#ifndef TDE_MALLOC_FULL
5686	if( malloc_type == 1 )	5686	if( malloc_type == 1 )
5687	{	5687	{
5688	#endif	5688	#endif
Lines 5695-5701 Link Here
5695	if (MALLOC_POSTACTION != 0) {	5695	if (MALLOC_POSTACTION != 0) {
5696	}	5696	}
5697	return m;	5697	return m;
5698	#ifndef KDE_MALLOC_FULL	5698	#ifndef TDE_MALLOC_FULL
5699	}	5699	}
5700	if( malloc_type == 2 )	5700	if( malloc_type == 2 )
5701	return libc_mallinfo();	5701	return libc_mallinfo();
Lines 5705-5711 Link Here
5705	}	5705	}
5706		5706
5707	int public_mALLOPt(int p, int v) {	5707	int public_mALLOPt(int p, int v) {
5708	#ifndef KDE_MALLOC_FULL	5708	#ifndef TDE_MALLOC_FULL
5709	if( malloc_type == 1 )	5709	if( malloc_type == 1 )
5710	{	5710	{
5711	#endif	5711	#endif
Lines 5717-5723 Link Here
5717	if (MALLOC_POSTACTION != 0) {	5717	if (MALLOC_POSTACTION != 0) {
5718	}	5718	}
5719	return result;	5719	return result;
5720	#ifndef KDE_MALLOC_FULL	5720	#ifndef TDE_MALLOC_FULL
5721	}	5721	}
5722	if( malloc_type == 2 )	5722	if( malloc_type == 2 )
5723	return libc_mallopt( p, v );	5723	return libc_mallopt( p, v );

Lines 308-314 Link Here

(-)tdelibs/tdecore/klibloader.cpp (-2 / +2 lines)
308	d->unload_mode = KLibLoaderPrivate::UNKNOWN;	308	d->unload_mode = KLibLoaderPrivate::UNKNOWN;
309	if (getenv("KDE_NOUNLOAD") != 0)	309	if (getenv("KDE_NOUNLOAD") != 0)
310	d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD;	310	d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD;
311	else if (getenv("KDE_DOUNLOAD") != 0)	311	else if (getenv("TDE_DOUNLOAD") != 0)
312	d->unload_mode = KLibLoaderPrivate::UNLOAD;	312	d->unload_mode = KLibLoaderPrivate::UNLOAD;
313	d->loaded_stack.setAutoDelete( true );	313	d->loaded_stack.setAutoDelete( true );
314	}	314	}
Lines 525-531 Link Here
525	bool deleted_one = false;	525	bool deleted_one = false;
526	while ((wrap = d->loaded_stack.first())) {	526	while ((wrap = d->loaded_stack.first())) {
527	/* Let's first see, if we want to try to unload this lib.	527	/* Let's first see, if we want to try to unload this lib.
528	If the env. var KDE_DOUNLOAD is set, we try to unload every lib.	528	If the env. var TDE_DOUNLOAD is set, we try to unload every lib.
529	If not, we look at the lib itself, and unload it only, if it exports	529	If not, we look at the lib itself, and unload it only, if it exports
530	the symbol __kde_do_unload. */	530	the symbol __kde_do_unload. */
531	if (d->unload_mode != KLibLoaderPrivate::UNLOAD	531	if (d->unload_mode != KLibLoaderPrivate::UNLOAD

Lines 61-69 Link Here

(-)tdelibs/CMakeLists.txt (-6 / +6 lines)
61		61
62	OPTION( WITH_ALL_OPTIONS "Enable all optional support" OFF )	62	OPTION( WITH_ALL_OPTIONS "Enable all optional support" OFF )
63		63
64	OPTION( KDE_MALLOC "Use own malloc implementation" OFF )	64	OPTION( TDE_MALLOC "Use own malloc implementation" OFF )
65	OPTION( KDE_MALLOC_DEBUG "Enable debugging in fast malloc" OFF )	65	OPTION( TDE_MALLOC_DEBUG "Enable debugging in fast malloc" OFF )
66	OPTION( KDE_MALLOC_FULL "Make alloc as fast as possible" OFF )	66	OPTION( TDE_MALLOC_FULL "Make alloc as fast as possible" OFF )
67		67
68	OPTION( WITH_ARTS "Build with aRts" ON )	68	OPTION( WITH_ARTS "Build with aRts" ON )
69	OPTION( WITH_ALSA "Enable ALSA support" ON )	69	OPTION( WITH_ALSA "Enable ALSA support" ON )
Lines 96-107 Link Here
96		96
97	### FIXME fast malloc is also available on x86_64 architecture?	97	### FIXME fast malloc is also available on x86_64 architecture?
98	if( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )	98	if( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )
99	set( KDE_MALLOC_X86 1 )	99	set( TDE_MALLOC_X86 1 )
100	message( STATUS "Found x86 architecture" )	100	message( STATUS "Found x86 architecture" )
101	else( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )	101	else( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )
102	if( KDE_MALLOC )	102	if( TDE_MALLOC )
103	message( FATAL_ERROR "\nKDE fast malloc is available only on x86 architecture" )	103	message( FATAL_ERROR "\nKDE fast malloc is available only on x86 architecture" )
104	endif( KDE_MALLOC )	104	endif( TDE_MALLOC )
105	endif( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )	105	endif( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i?86" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" )
106		106
107		107

Lines 7-13 Link Here

(-)tdelibs/tdecore/malloc/README (-4 / +4 lines)
7	There's a new configure switch, --enable-fast-malloc. By default it's turned off, disabling	7	There's a new configure switch, --enable-fast-malloc. By default it's turned off, disabling
8	the system libc one and using this one. Using --enable-fast-malloc=full enables this	8	the system libc one and using this one. Using --enable-fast-malloc=full enables this
9	malloc unconditionally, aiming for the maximum performance. By using only --enable-fast-malloc,	9	malloc unconditionally, aiming for the maximum performance. By using only --enable-fast-malloc,
10	it's possible to select both malloc implementations at runtime. When $KDE_MALLOC is set to 0,	10	it's possible to select both malloc implementations at runtime. When $TDE_MALLOC is set to 0,
11	the system libc malloc is used, otherwise this malloc is used.	11	the system libc malloc is used, otherwise this malloc is used.
12		12
13	For now, the requirements are :	13	For now, the requirements are :
Lines 31-41 Link Here
31	#define USE_MEMCPY 0	31	#define USE_MEMCPY 0
32	#define MMAP_CLEARS 1	32	#define MMAP_CLEARS 1
33	made all functions INLINE	33	made all functions INLINE
34	added #ifdef KDE_MALLOC_DEBUG -> #define DEBUG	34	added #ifdef TDE_MALLOC_DEBUG -> #define DEBUG
35	reordered all functions in order to avoid 'warning: `XYZ' declared inline after being called'	35	reordered all functions in order to avoid 'warning: `XYZ' declared inline after being called'
36	especially moved the public_* ones at the end of the file	36	especially moved the public_* ones at the end of the file
37	commented out #including malloc.h	37	commented out #including malloc.h
38	added #include <config.h> at the top and enclosed whole file in #ifdef KDE_MALLOC	38	added #include <config.h> at the top and enclosed whole file in #ifdef TDE_MALLOC
39	taken posix_memalign() from glibc	39	taken posix_memalign() from glibc
40	removed public icalloc(),icomalloc(),mtrim(),musable() (they don't exist everywhere anyway)	40	removed public icalloc(),icomalloc(),mtrim(),musable() (they don't exist everywhere anyway)
41	enclosed the pthreads part by #if 0 and replaced it with spinlock from glibc CVS (in x86.h)	41	enclosed the pthreads part by #if 0 and replaced it with spinlock from glibc CVS (in x86.h)
Lines 45-51 Link Here
45	#define MALLOC_PREACTION lock( &spinlock )	45	#define MALLOC_PREACTION lock( &spinlock )
46	#define MALLOC_POSTACTION unlock( &spinlock )	46	#define MALLOC_POSTACTION unlock( &spinlock )
47	----------	47	----------
48	public functions call either functions in this malloc or in libc, depending on $KDE_MALLOC	48	public functions call either functions in this malloc or in libc, depending on $TDE_MALLOC
49	the kde_malloc_is_used hack	49	the kde_malloc_is_used hack
50		50
51		51

Lines 1-4 Link Here

(-)tdelibs/tdecore/malloc/configure.in.in (-7 / +7 lines)
1	dnl --enable-fast-malloc - depends on $KDE_MALLOC	1	dnl --enable-fast-malloc - depends on $TDE_MALLOC
2	dnl --disable-fast-malloc - disabled	2	dnl --disable-fast-malloc - disabled
3	dnl --enable-fast-malloc=full - enabled always	3	dnl --enable-fast-malloc=full - enabled always
4	dnl	4	dnl
Lines 38-44 Link Here
38	dnl platforms for which there's a spinlock implementation	38	dnl platforms for which there's a spinlock implementation
39	case $target_cpu in	39	case $target_cpu in
40	i?86)	40	i?86)
41	AC_DEFINE(KDE_MALLOC_X86, 1, [The platform is x86])	41	AC_DEFINE(TDE_MALLOC_X86, 1, [The platform is x86])
42	;;	42	;;
43	*)	43	*)
44	if test "$kde_fast_malloc" = "notgiven"; then	44	if test "$kde_fast_malloc" = "notgiven"; then
Lines 63-69 Link Here
63	fi	63	fi
64		64
65	if test "$kde_fast_malloc" = "yes" -o "$kde_fast_malloc" = "notgiven" -o "$kde_fast_malloc" = "debug"; then	65	if test "$kde_fast_malloc" = "yes" -o "$kde_fast_malloc" = "notgiven" -o "$kde_fast_malloc" = "debug"; then
66	dnl $KDE_MALLOC needs glibc (__libc_malloc etc.)	66	dnl $TDE_MALLOC needs glibc (__libc_malloc etc.)
67	AC_CACHE_CHECK([if the libc is glibc],kde_cv_libc_glibc,	67	AC_CACHE_CHECK([if the libc is glibc],kde_cv_libc_glibc,
68	[AC_TRY_COMPILE(	68	[AC_TRY_COMPILE(
69	[#include<stdlib.h>],	69	[#include<stdlib.h>],
Lines 76-82 Link Here
76	[kde_cv_libc_glibc=no])	76	[kde_cv_libc_glibc=no])
77	])	77	])
78	if test "$kde_cv_libc_glibc" = "yes"; then	78	if test "$kde_cv_libc_glibc" = "yes"; then
79	AC_DEFINE(KDE_MALLOC_GLIBC, 1, [The libc used is glibc])	79	AC_DEFINE(TDE_MALLOC_GLIBC, 1, [The libc used is glibc])
80	else	80	else
81	if test "$kde_fast_malloc" = "notgiven"; then	81	if test "$kde_fast_malloc" = "notgiven"; then
82	kde_fast_malloc=notgiven_full	82	kde_fast_malloc=notgiven_full
Lines 116-130 Link Here
116	fi	116	fi
117		117
118	if test "$kde_fast_malloc" != "no"; then	118	if test "$kde_fast_malloc" != "no"; then
119	AC_DEFINE(KDE_MALLOC, 1, [Use own malloc implementation])	119	AC_DEFINE(TDE_MALLOC, 1, [Use own malloc implementation])
120	fi	120	fi
121		121
122	if test "$kde_fast_malloc" = "debug" -o "$kde_fast_malloc" = "debug_full"; then	122	if test "$kde_fast_malloc" = "debug" -o "$kde_fast_malloc" = "debug_full"; then
123	AC_DEFINE(KDE_MALLOC_DEBUG, 1, [Enable debugging in fast malloc])	123	AC_DEFINE(TDE_MALLOC_DEBUG, 1, [Enable debugging in fast malloc])
124	fi	124	fi
125		125
126	if test "$kde_fast_malloc" = "full" -o "$kde_fast_malloc" = "debug_full"; then	126	if test "$kde_fast_malloc" = "full" -o "$kde_fast_malloc" = "debug_full"; then
127	AC_DEFINE(KDE_MALLOC_FULL, 1, [Make alloc as fast as possible])	127	AC_DEFINE(TDE_MALLOC_FULL, 1, [Make alloc as fast as possible])
128	fi	128	fi
129		129
130	dnl -finline-limit=<large num> is needed for gcc3 in order to inline large functions	130	dnl -finline-limit=<large num> is needed for gcc3 in order to inline large functions

Lines 207-221 Link Here

(-)tdelibs/kinit/klauncher.cpp (-3 / +3 lines)
207	lastRequest = 0;	207	lastRequest = 0;
208	bProcessingQueue = false;	208	bProcessingQueue = false;
209		209
210	mSlaveDebug = getenv("KDE_SLAVE_DEBUG_WAIT");	210	mSlaveDebug = getenv("TDE_SLAVE_DEBUG_WAIT");
211	if (!mSlaveDebug.isEmpty())	211	if (!mSlaveDebug.isEmpty())
212	{	212	{
213	qWarning("Klauncher running in slave-debug mode for slaves of protocol '%s'", mSlaveDebug.data());	213	qWarning("Klauncher running in slave-debug mode for slaves of protocol '%s'", mSlaveDebug.data());
214	}	214	}
215	mSlaveValgrind = getenv("KDE_SLAVE_VALGRIND");	215	mSlaveValgrind = getenv("TDE_SLAVE_VALGRIND");
216	if (!mSlaveValgrind.isEmpty())	216	if (!mSlaveValgrind.isEmpty())
217	{	217	{
218	mSlaveValgrindSkin = getenv("KDE_SLAVE_VALGRIND_SKIN");	218	mSlaveValgrindSkin = getenv("TDE_SLAVE_VALGRIND_SKIN");
219	qWarning("Klauncher running slaves through valgrind for slaves of protocol '%s'", mSlaveValgrind.data());	219	qWarning("Klauncher running slaves through valgrind for slaves of protocol '%s'", mSlaveValgrind.data());
220	}	220	}
221	klauncher_header request_header;	221	klauncher_header request_header;

Lines 62-68 Link Here

(-)tdelibs/libltdl/ltdl_win.c (-7 / +7 lines)
62	}	62	}
63		63
64	#define MAX_PATH 0x1ff	64	#define MAX_PATH 0x1ff
65	static char win32_mapDir_KDEDIR[MAX_PATH] = "";	65	static char win32_mapDir_TDEDIR[MAX_PATH] = "";
66		66
67	// paths name mappings	67	// paths name mappings
68	// when mapping is performed, frees old name at dir and allocates new path for dir	68	// when mapping is performed, frees old name at dir and allocates new path for dir
Lines 72-90 Link Here
72	static const char* WIN32_LIBDIR_TO = "c:/kde/lib/trinity";	72	static const char* WIN32_LIBDIR_TO = "c:/kde/lib/trinity";
73	char *e;	73	char *e;
74	//TODO........	74	//TODO........
75	if (!*win32_mapDir_KDEDIR) {	75	if (!*win32_mapDir_TDEDIR) {
76	e = getenv("KDEDIR");	76	e = getenv("TDEDIR");
77	if (e)	77	if (e)
78	strncpy( win32_mapDir_KDEDIR, e, MAX_PATH );	78	strncpy( win32_mapDir_TDEDIR, e, MAX_PATH );
79	}	79	}
80	assert(dir && dir && win32_mapDir_KDEDIR && win32_mapDir_KDEDIR);	80	assert(dir && dir && win32_mapDir_TDEDIR && win32_mapDir_TDEDIR);
81	// /opt/trinity/lib/trinity -> <letter>:/kde/lib/trinity	81	// /opt/trinity/lib/trinity -> <letter>:/kde/lib/trinity
82		82
83	if (strcmp(*dir, WIN32_LIBDIR_FROM)==0) {	83	if (strcmp(*dir, WIN32_LIBDIR_FROM)==0) {
84	free(*dir);	84	free(*dir);
85	*dir=strdup(WIN32_LIBDIR_TO);	85	*dir=strdup(WIN32_LIBDIR_TO);
86	if (win32_mapDir_KDEDIR && *win32_mapDir_KDEDIR) {	86	if (win32_mapDir_TDEDIR && *win32_mapDir_TDEDIR) {
87	(*dir)[0]=win32_mapDir_KDEDIR[0]; //copy drive letter	87	(*dir)[0]=win32_mapDir_TDEDIR[0]; //copy drive letter
88	}	88	}
89	}	89	}
90	}	90	}