--- tqt/secqstring.cpp.orig
+++ tqt/secqstring.cpp
@@ -80,8 +80,8 @@ static uint computeNewMax( uint len )
 // IMPORTANT! If you change these, make sure you also change the
 // "delete unicode" statement in ~SecTQStringData() in SecTQString.h correspondingly!
 
-#define QT_ALLOC_SECTQCHAR_VEC(N) (TQChar*) ::secmem_malloc (sizeof(TQChar) * (N))
-#define QT_DELETE_SECTQCHAR_VEC(P) ::secmem_free (P)
+#define TQT_ALLOC_SECTQCHAR_VEC(N) (TQChar*) ::secmem_malloc (sizeof(TQChar) * (N))
+#define TQT_DELETE_SECTQCHAR_VEC(P) ::secmem_free (P)
 
 
 /*****************************************************************************
@@ -188,13 +188,13 @@ static uint computeNewMax( uint len )
     \sa TQChar TQCString TQByteArray SecTQConstString
 */
 
-Q_EXPORT SecTQStringData *SecTQString::shared_null = 0;
-QT_STATIC_CONST_IMPL SecTQString SecTQString::null;
-QT_STATIC_CONST_IMPL TQChar TQChar::null;
-QT_STATIC_CONST_IMPL TQChar TQChar::replacement((ushort)0xfffd);
-QT_STATIC_CONST_IMPL TQChar TQChar::byteOrderMark((ushort)0xfeff);
-QT_STATIC_CONST_IMPL TQChar TQChar::byteOrderSwapped((ushort)0xfffe);
-QT_STATIC_CONST_IMPL TQChar TQChar::nbsp((ushort)0x00a0);
+TQ_EXPORT SecTQStringData *SecTQString::shared_null = 0;
+const SecTQString SecTQString::null;
+const TQChar TQChar::null;
+const TQChar TQChar::replacement((ushort)0xfffd);
+const TQChar TQChar::byteOrderMark((ushort)0xfeff);
+const TQChar TQChar::byteOrderSwapped((ushort)0xfffe);
+const TQChar TQChar::nbsp((ushort)0x00a0);
 
 SecTQStringData* SecTQString::makeSharedNull()
 {
@@ -220,7 +220,7 @@ SecTQString::SecTQString( TQChar ch )
 */
 SecTQString::SecTQString( TQChar ch )
 {
-    d = new SecTQStringData( QT_ALLOC_SECTQCHAR_VEC( 1 ), 1, 1 );
+    d = new SecTQStringData( TQT_ALLOC_SECTQCHAR_VEC( 1 ), 1, 1 );
     d->unicode[0] = ch;
 }
 
@@ -239,7 +239,7 @@ SecTQString::SecTQString( int size, bool /*dummy*/ )
 {
     if ( size ) {
 	int l = size;
-	TQChar* uc = QT_ALLOC_SECTQCHAR_VEC( l );
+	TQChar* uc = TQT_ALLOC_SECTQCHAR_VEC( l );
 	d = new SecTQStringData( uc, 0, l );
     } else {
 	d = shared_null ? shared_null : (shared_null=new SecTQStringData);
@@ -258,7 +258,7 @@ SecTQString::SecTQString( const TQString &str )
 	d = shared_null ? shared_null : makeSharedNull();
 	d->ref();
     } else {
-	TQChar* uc = QT_ALLOC_SECTQCHAR_VEC( length );
+	TQChar* uc = TQT_ALLOC_SECTQCHAR_VEC( length );
 	if ( unicode )
 	    memcpy(uc, unicode, length*sizeof(TQChar));
 	d = new SecTQStringData(uc,unicode ? length : 0,length);
@@ -287,7 +287,7 @@ SecTQString::SecTQString( const TQChar* unicode, uint 
 	d = shared_null ? shared_null : makeSharedNull();
 	d->ref();
     } else {
-	TQChar* uc = QT_ALLOC_SECTQCHAR_VEC( length );
+	TQChar* uc = TQT_ALLOC_SECTQCHAR_VEC( length );
 	if ( unicode )
 	    memcpy(uc, unicode, length*sizeof(TQChar));
 	d = new SecTQStringData(uc,unicode ? length : 0,length);
@@ -356,13 +356,13 @@ SecTQString &SecTQString::operator=( const SecTQString
 /*!
     \fn bool SecTQString::isNull() const
 
-    Returns TRUE if the string is null; otherwise returns FALSE. A
+    Returns true if the string is null; otherwise returns false. A
     null string is always empty.
 
     \code
 	SecTQString a;          // a.unicode() == 0, a.length() == 0
-	a.isNull();         // TRUE, because a.unicode() == 0
-	a.isEmpty();        // TRUE, because a.length() == 0
+	a.isNull();         // true, because a.unicode() == 0
+	a.isEmpty();        // true, because a.length() == 0
     \endcode
 
     \sa isEmpty(), length()
@@ -371,17 +371,17 @@ SecTQString &SecTQString::operator=( const SecTQString
 /*!
     \fn bool SecTQString::isEmpty() const
 
-    Returns TRUE if the string is empty, i.e. if length() == 0;
-    otherwise returns FALSE. Null strings are also empty.
+    Returns true if the string is empty, i.e. if length() == 0;
+    otherwise returns false. Null strings are also empty.
 
     \code
 	SecTQString a( "" );
-	a.isEmpty();        // TRUE
-	a.isNull();         // FALSE
+	a.isEmpty();        // true
+	a.isNull();         // false
 
 	SecTQString b;
-	b.isEmpty();        // TRUE
-	b.isNull();         // TRUE
+	b.isEmpty();        // true
+	b.isNull();         // true
     \endcode
 
     \sa isNull(), length()
@@ -429,7 +429,7 @@ void SecTQString::setLength( uint newLen )
 	 ( newLen * 4 < d->maxl && d->maxl > 4 ) ) {
 	// detach, grow or shrink
 	uint newMax = computeNewMax( newLen );
-	TQChar* nd = QT_ALLOC_SECTQCHAR_VEC( newMax );
+	TQChar* nd = TQT_ALLOC_SECTQCHAR_VEC( newMax );
 	if ( nd ) {
 	    uint len = TQMIN( d->len, newLen );
 	    memcpy( nd, d->unicode, sizeof(TQChar) * len );
@@ -481,7 +481,7 @@ SecTQString SecTQString::left( uint len ) const
     } else if ( len >= length() ) {
 	return *this;
     } else {
-	SecTQString s( len, TRUE );
+	SecTQString s( len, true );
 	memcpy( s.d->unicode, d->unicode, len * sizeof(TQChar) );
 	s.d->len = len;
 	return s;
@@ -513,7 +513,7 @@ SecTQString SecTQString::right( uint len ) const
 	uint l = length();
 	if ( len >= l )
 	    return *this;
-	SecTQString s( len, TRUE );
+	SecTQString s( len, true );
 	memcpy( s.d->unicode, d->unicode+(l-len), len*sizeof(TQChar) );
 	s.d->len = len;
 	return s;
@@ -548,8 +548,8 @@ SecTQString SecTQString::mid( uint index, uint len ) c
 	    len = slen - index;
 	if ( index == 0 && len == slen )
 	    return *this;
-	register const TQChar *p = unicode()+index;
-	SecTQString s( len, TRUE );
+	const TQChar *p = unicode()+index;
+	SecTQString s( len, true );
 	memcpy( s.d->unicode, p, len * sizeof(TQChar) );
 	s.d->len = len;
 	return s;
@@ -594,10 +594,10 @@ SecTQString &SecTQString::insert( uint index, const TQ
 
     if ( s >= d->unicode && (uint)(s - d->unicode) < d->maxl ) {
 	// Part of me - take a copy.
-	TQChar *tmp = QT_ALLOC_SECTQCHAR_VEC( len );
+	TQChar *tmp = TQT_ALLOC_SECTQCHAR_VEC( len );
 	memcpy(tmp,s,len*sizeof(TQChar));
 	insert(index,tmp,len);
-	QT_DELETE_SECTQCHAR_VEC( tmp );
+	TQT_DELETE_SECTQCHAR_VEC( tmp );
 	return *this;
     }
 
@@ -669,10 +669,10 @@ SecTQString &SecTQString::replace( uint index, uint le
 	memcpy( d->unicode+index, s, len * sizeof(TQChar) );
     } else if ( s >= d->unicode && (uint)(s - d->unicode) < d->maxl ) {
 	// Part of me - take a copy.
-	TQChar *tmp = QT_ALLOC_SECTQCHAR_VEC( slen );
+	TQChar *tmp = TQT_ALLOC_SECTQCHAR_VEC( slen );
 	memcpy( tmp, s, slen * sizeof(TQChar) );
 	replace( index, len, tmp, slen );
-	QT_DELETE_SECTQCHAR_VEC( tmp );
+	TQT_DELETE_SECTQCHAR_VEC( tmp );
     } else {
 	remove( index, len );
 	insert( index, s, slen );
@@ -904,18 +904,18 @@ bool SecTQString::isRightToLeft() const
 	case TQChar::DirL:
 	case TQChar::DirLRO:
 	case TQChar::DirLRE:
-	    return FALSE;
+	    return false;
 	case TQChar::DirR:
 	case TQChar::DirAL:
 	case TQChar::DirRLO:
 	case TQChar::DirRLE:
-	    return TRUE;
+	    return true;
 	default:
 	    break;
 	}
 	++p;
     }
-    return FALSE;
+    return false;
 }
 
 
