You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
940 lines
26 KiB
940 lines
26 KiB
/* secqstring.cpp - Secure version of TQString.
|
|
* Copyright (C) 1992-2002 Trolltech AS. All rights reserved.
|
|
* Copyright (C) 2003 g10 Code GmbH
|
|
*
|
|
* The license of the original qstring.cpp file from which this file
|
|
* is derived can be found below. Modified by Marcus Brinkmann
|
|
* <marcus@g10code.de>. All modifications are licensed as follows, so
|
|
* that the intersection of the two licenses is then the GNU General
|
|
* Public License version 2.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <https://www.gnu.org/licenses/>.
|
|
* SPDX-License-Identifier: GPL-2.0
|
|
*/
|
|
|
|
/****************************************************************************
|
|
** $Id$
|
|
**
|
|
** Implementation of the SecTQString class and related Unicode functions
|
|
**
|
|
** Created : 920722
|
|
**
|
|
** Copyright (C) 1992-2002 Trolltech AS. All rights reserved.
|
|
**
|
|
** This file is part of the tools module of the TQt 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.TQPL 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 TQt Enterprise Edition or TQt Professional Edition
|
|
** 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
|
|
** 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 TQt Commercial License Agreements.
|
|
** See http://www.trolltech.com/qpl/ for TQPL 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.
|
|
**
|
|
**********************************************************************/
|
|
|
|
// Don't define it while compiling this module, or USERS of TQt will
|
|
// not be able to link.
|
|
|
|
#include "secqstring.h"
|
|
|
|
static uint computeNewMax( uint len )
|
|
{
|
|
uint newMax = 4;
|
|
while ( newMax < len )
|
|
newMax *= 2;
|
|
// try to save some memory
|
|
if ( newMax >= 1024 * 1024 && len <= newMax - (newMax >> 2) )
|
|
newMax -= newMax >> 2;
|
|
return newMax;
|
|
}
|
|
|
|
// These macros are used for efficient allocation of TQChar strings.
|
|
// IMPORTANT! If you change these, make sure you also change the
|
|
// "delete unicode" statement in ~SecTQStringData() in SecTQString.h correspondingly!
|
|
|
|
#define TQT_ALLOC_SECTQCHAR_VEC(N) (TQChar*) ::secmem_malloc (sizeof(TQChar) * (N))
|
|
#define TQT_DELETE_SECTQCHAR_VEC(P) ::secmem_free (P)
|
|
|
|
|
|
/*****************************************************************************
|
|
SecTQString member functions
|
|
*****************************************************************************/
|
|
|
|
/*!
|
|
\class SecTQString SecTQString.h
|
|
\reentrant
|
|
|
|
\brief The SecTQString class provides an abstraction of Unicode text
|
|
and the classic C '\0'-terminated char array.
|
|
|
|
\ingroup tools
|
|
\ingroup shared
|
|
\ingroup text
|
|
\mainclass
|
|
|
|
SecTQString uses \link shclass.html implicit sharing\endlink, which
|
|
makes it very efficient and easy to use.
|
|
|
|
In all of the SecTQString methods that take \c {const char *}
|
|
parameters, the \c {const char *} is interpreted as a classic
|
|
C-style '\0'-terminated ASCII string. It is legal for the \c
|
|
{const char *} parameter to be 0. If the \c {const char *} is not
|
|
'\0'-terminated, the results are undefined. Functions that copy
|
|
classic C strings into a SecTQString will not copy the terminating
|
|
'\0' character. The TQChar array of the SecTQString (as returned by
|
|
unicode()) is generally not terminated by a '\0'. If you need to
|
|
pass a SecTQString to a function that requires a C '\0'-terminated
|
|
string use latin1().
|
|
|
|
\keyword SecTQString::null
|
|
A SecTQString that has not been assigned to anything is \e null, i.e.
|
|
both the length and data pointer is 0. A SecTQString that references
|
|
the empty string ("", a single '\0' char) is \e empty. Both null
|
|
and empty SecTQStrings are legal parameters to the methods. Assigning
|
|
\c{(const char *) 0} to SecTQString gives a null SecTQString. For
|
|
convenience, \c SecTQString::null is a null SecTQString. When sorting,
|
|
empty strings come first, followed by non-empty strings, followed
|
|
by null strings. We recommend using \c{if ( !str.isNull() )} to
|
|
check for a non-null string rather than \c{if ( !str )}; see \l
|
|
operator!() for an explanation.
|
|
|
|
Note that if you find that you are mixing usage of \l TQCString,
|
|
SecTQString, and \l TQByteArray, this causes lots of unnecessary
|
|
copying and might indicate that the true nature of the data you
|
|
are dealing with is uncertain. If the data is '\0'-terminated 8-bit
|
|
data, use \l TQCString; if it is unterminated (i.e. contains '\0's)
|
|
8-bit data, use \l TQByteArray; if it is text, use SecTQString.
|
|
|
|
Lists of strings are handled by the SecTQStringList class. You can
|
|
split a string into a list of strings using SecTQStringList::split(),
|
|
and join a list of strings into a single string with an optional
|
|
separator using SecTQStringList::join(). You can obtain a list of
|
|
strings from a string list that contain a particular substring or
|
|
that match a particular \link ntqregexp.html regex\endlink using
|
|
SecTQStringList::grep().
|
|
|
|
<b>Note for C programmers</b>
|
|
|
|
Due to C++'s type system and the fact that SecTQString is implicitly
|
|
shared, SecTQStrings may be treated like ints or other simple base
|
|
types. For example:
|
|
|
|
\code
|
|
SecTQString boolToString( bool b )
|
|
{
|
|
SecTQString result;
|
|
if ( b )
|
|
result = "True";
|
|
else
|
|
result = "False";
|
|
return result;
|
|
}
|
|
\endcode
|
|
|
|
The variable, result, is an auto variable allocated on the stack.
|
|
When return is called, because we're returning by value, The copy
|
|
constructor is called and a copy of the string is returned. (No
|
|
actual copying takes place thanks to the implicit sharing, see
|
|
below.)
|
|
|
|
Throughout TQt's source code you will encounter SecTQString usages like
|
|
this:
|
|
\code
|
|
SecTQString func( const SecTQString& input )
|
|
{
|
|
SecTQString output = input;
|
|
// process output
|
|
return output;
|
|
}
|
|
\endcode
|
|
|
|
The 'copying' of input to output is almost as fast as copying a
|
|
pointer because behind the scenes copying is achieved by
|
|
incrementing a reference count. SecTQString (like all TQt's implicitly
|
|
shared classes) operates on a copy-on-write basis, only copying if
|
|
an instance is actually changed.
|
|
|
|
If you wish to create a deep copy of a SecTQString without losing any
|
|
Unicode information then you should use TQDeepCopy.
|
|
|
|
\sa TQChar TQCString TQByteArray SecTQConstString
|
|
*/
|
|
|
|
TQ_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);
|
|
|
|
SecTQStringData* SecTQString::makeSharedNull()
|
|
{
|
|
SecTQString::shared_null = new SecTQStringData;
|
|
#if defined( Q_OS_MAC )
|
|
SecTQString *that = const_cast<SecTQString *>(&SecTQString::null);
|
|
that->d = SecTQString::shared_null;
|
|
#endif
|
|
return SecTQString::shared_null;
|
|
}
|
|
|
|
/*!
|
|
\fn SecTQString::SecTQString()
|
|
|
|
Constructs a null string, i.e. both the length and data pointer
|
|
are 0.
|
|
|
|
\sa isNull()
|
|
*/
|
|
|
|
/*!
|
|
Constructs a string of length one, containing the character \a ch.
|
|
*/
|
|
SecTQString::SecTQString( TQChar ch )
|
|
{
|
|
d = new SecTQStringData( TQT_ALLOC_SECTQCHAR_VEC( 1 ), 1, 1 );
|
|
d->unicode[0] = ch;
|
|
}
|
|
|
|
/*!
|
|
Constructs an implicitly shared copy of \a s. This is very fast
|
|
since it only involves incrementing a reference count.
|
|
*/
|
|
SecTQString::SecTQString( const SecTQString &s ) :
|
|
d(s.d)
|
|
{
|
|
d->ref();
|
|
}
|
|
|
|
|
|
SecTQString::SecTQString( int size, bool /*dummy*/ )
|
|
{
|
|
if ( size ) {
|
|
int l = size;
|
|
TQChar* uc = TQT_ALLOC_SECTQCHAR_VEC( l );
|
|
d = new SecTQStringData( uc, 0, l );
|
|
} else {
|
|
d = shared_null ? shared_null : (shared_null=new SecTQStringData);
|
|
d->ref();
|
|
}
|
|
}
|
|
|
|
|
|
/* Deep copy of STR. */
|
|
SecTQString::SecTQString( const TQString &str )
|
|
{
|
|
const TQChar *unicode = str.unicode ();
|
|
uint length = str.length ();
|
|
|
|
if ( !unicode && !length ) {
|
|
d = shared_null ? shared_null : makeSharedNull();
|
|
d->ref();
|
|
} else {
|
|
TQChar* uc = TQT_ALLOC_SECTQCHAR_VEC( length );
|
|
if ( unicode )
|
|
memcpy(uc, unicode, length*sizeof(TQChar));
|
|
d = new SecTQStringData(uc,unicode ? length : 0,length);
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
Constructs a string that is a deep copy of the first \a length
|
|
characters in the TQChar array.
|
|
|
|
If \a unicode and \a length are 0, then a null string is created.
|
|
|
|
If only \a unicode is 0, the string is empty but has \a length
|
|
characters of space preallocated: SecTQString expands automatically
|
|
anyway, but this may speed up some cases a little. We recommend
|
|
using the plain constructor and setLength() for this purpose since
|
|
it will result in more readable code.
|
|
|
|
\sa isNull() setLength()
|
|
*/
|
|
|
|
SecTQString::SecTQString( const TQChar* unicode, uint length )
|
|
{
|
|
if ( !unicode && !length ) {
|
|
d = shared_null ? shared_null : makeSharedNull();
|
|
d->ref();
|
|
} else {
|
|
TQChar* uc = TQT_ALLOC_SECTQCHAR_VEC( length );
|
|
if ( unicode )
|
|
memcpy(uc, unicode, length*sizeof(TQChar));
|
|
d = new SecTQStringData(uc,unicode ? length : 0,length);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\fn SecTQString::~SecTQString()
|
|
|
|
Destroys the string and frees the string's data if this is the
|
|
last reference to the string.
|
|
*/
|
|
|
|
|
|
/*!
|
|
Deallocates any space reserved solely by this SecTQString.
|
|
|
|
If the string does not share its data with another SecTQString
|
|
instance, nothing happens; otherwise the function creates a new,
|
|
unique copy of this string. This function is called whenever the
|
|
string is modified.
|
|
*/
|
|
|
|
void SecTQString::real_detach()
|
|
{
|
|
setLength( length() );
|
|
}
|
|
|
|
void SecTQString::deref()
|
|
{
|
|
if ( d && d->deref() ) {
|
|
if ( d != shared_null )
|
|
delete d;
|
|
d = 0;
|
|
}
|
|
}
|
|
|
|
void SecTQStringData::deleteSelf()
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
/*!
|
|
\fn SecTQString& SecTQString::operator=( TQChar c )
|
|
|
|
Sets the string to contain just the single character \a c.
|
|
*/
|
|
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Assigns a shallow copy of \a s to this string and returns a
|
|
reference to this string. This is very fast because the string
|
|
isn't actually copied.
|
|
*/
|
|
SecTQString &SecTQString::operator=( const SecTQString &s )
|
|
{
|
|
s.d->ref();
|
|
deref();
|
|
d = s.d;
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
\fn bool SecTQString::isNull() const
|
|
|
|
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
|
|
\endcode
|
|
|
|
\sa isEmpty(), length()
|
|
*/
|
|
|
|
/*!
|
|
\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.
|
|
|
|
\code
|
|
SecTQString a( "" );
|
|
a.isEmpty(); // TRUE
|
|
a.isNull(); // FALSE
|
|
|
|
SecTQString b;
|
|
b.isEmpty(); // TRUE
|
|
b.isNull(); // TRUE
|
|
\endcode
|
|
|
|
\sa isNull(), length()
|
|
*/
|
|
|
|
/*!
|
|
\fn uint SecTQString::length() const
|
|
|
|
Returns the length of the string.
|
|
|
|
Null strings and empty strings have zero length.
|
|
|
|
\sa isNull(), isEmpty()
|
|
*/
|
|
|
|
/*!
|
|
If \a newLen is less than the length of the string, then the
|
|
string is truncated at position \a newLen. Otherwise nothing
|
|
happens.
|
|
|
|
\code
|
|
SecTQString s = "truncate me";
|
|
s.truncate( 5 ); // s == "trunc"
|
|
\endcode
|
|
|
|
\sa setLength()
|
|
*/
|
|
|
|
void SecTQString::truncate( uint newLen )
|
|
{
|
|
if ( newLen < d->len )
|
|
setLength( newLen );
|
|
}
|
|
|
|
/*!
|
|
Ensures that at least \a newLen characters are allocated to the
|
|
string, and sets the length of the string to \a newLen. Any new
|
|
space allocated contains arbitrary data.
|
|
|
|
\sa reserve(), truncate()
|
|
*/
|
|
void SecTQString::setLength( uint newLen )
|
|
{
|
|
if ( d->count != 1 || newLen > d->maxl ||
|
|
( newLen * 4 < d->maxl && d->maxl > 4 ) ) {
|
|
// detach, grow or shrink
|
|
uint newMax = computeNewMax( newLen );
|
|
TQChar* nd = TQT_ALLOC_SECTQCHAR_VEC( newMax );
|
|
if ( nd ) {
|
|
uint len = TQMIN( d->len, newLen );
|
|
memcpy( nd, d->unicode, sizeof(TQChar) * len );
|
|
deref();
|
|
d = new SecTQStringData( nd, newLen, newMax );
|
|
}
|
|
} else {
|
|
d->len = newLen;
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Like setLength, but doesn't shrink the allocated memory.
|
|
*/
|
|
void SecTQString::grow( uint newLen )
|
|
{
|
|
if ( d->count != 1 || newLen > d->maxl ) {
|
|
setLength( newLen );
|
|
} else {
|
|
d->len = newLen;
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns a substring that contains the \a len leftmost characters
|
|
of the string.
|
|
|
|
The whole string is returned if \a len exceeds the length of the
|
|
string.
|
|
|
|
\code
|
|
SecTQString s = "Pineapple";
|
|
SecTQString t = s.left( 4 ); // t == "Pine"
|
|
\endcode
|
|
|
|
\sa right(), mid(), isEmpty()
|
|
*/
|
|
|
|
SecTQString SecTQString::left( uint len ) const
|
|
{
|
|
if ( isEmpty() ) {
|
|
return SecTQString();
|
|
} else if ( len == 0 ) { // ## just for 1.x compat:
|
|
return SecTQString ("");
|
|
} else if ( len >= length() ) {
|
|
return *this;
|
|
} else {
|
|
SecTQString s( len, TRUE );
|
|
memcpy( s.d->unicode, d->unicode, len * sizeof(TQChar) );
|
|
s.d->len = len;
|
|
return s;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns a string that contains the \a len rightmost characters of
|
|
the string.
|
|
|
|
If \a len is greater than the length of the string then the whole
|
|
string is returned.
|
|
|
|
\code
|
|
SecTQString string( "Pineapple" );
|
|
SecTQString t = string.right( 5 ); // t == "apple"
|
|
\endcode
|
|
|
|
\sa left(), mid(), isEmpty()
|
|
*/
|
|
|
|
SecTQString SecTQString::right( uint len ) const
|
|
{
|
|
if ( isEmpty() ) {
|
|
return SecTQString();
|
|
} else if ( len == 0 ) { // ## just for 1.x compat:
|
|
return SecTQString ("");
|
|
} else {
|
|
uint l = length();
|
|
if ( len >= l )
|
|
return *this;
|
|
SecTQString s( len, TRUE );
|
|
memcpy( s.d->unicode, d->unicode+(l-len), len*sizeof(TQChar) );
|
|
s.d->len = len;
|
|
return s;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns a string that contains the \a len characters of this
|
|
string, starting at position \a index.
|
|
|
|
Returns a null string if the string is empty or \a index is out of
|
|
range. Returns the whole string from \a index if \a index + \a len
|
|
exceeds the length of the string.
|
|
|
|
\code
|
|
SecTQString s( "Five pineapples" );
|
|
SecTQString t = s.mid( 5, 4 ); // t == "pine"
|
|
\endcode
|
|
|
|
\sa left(), right()
|
|
*/
|
|
|
|
SecTQString SecTQString::mid( uint index, uint len ) const
|
|
{
|
|
uint slen = length();
|
|
if ( isEmpty() || index >= slen ) {
|
|
return SecTQString();
|
|
} else if ( len == 0 ) { // ## just for 1.x compat:
|
|
return SecTQString ("");
|
|
} else {
|
|
if ( len > slen-index )
|
|
len = slen - index;
|
|
if ( index == 0 && len == slen )
|
|
return *this;
|
|
register const TQChar *p = unicode()+index;
|
|
SecTQString s( len, TRUE );
|
|
memcpy( s.d->unicode, p, len * sizeof(TQChar) );
|
|
s.d->len = len;
|
|
return s;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Inserts \a s into the string at position \a index.
|
|
|
|
If \a index is beyond the end of the string, the string is
|
|
extended with spaces to length \a index and \a s is then appended
|
|
and returns a reference to the string.
|
|
|
|
\code
|
|
SecTQString string( "I like fish" );
|
|
str = string.insert( 2, "don't " );
|
|
// str == "I don't like fish"
|
|
\endcode
|
|
|
|
\sa remove(), replace()
|
|
*/
|
|
|
|
SecTQString &SecTQString::insert( uint index, const SecTQString &s )
|
|
{
|
|
// the sub function takes care of &s == this case.
|
|
return insert( index, s.unicode(), s.length() );
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Inserts the first \a len characters in \a s into the string at
|
|
position \a index and returns a reference to the string.
|
|
*/
|
|
|
|
SecTQString &SecTQString::insert( uint index, const TQChar* s, uint len )
|
|
{
|
|
if ( len == 0 )
|
|
return *this;
|
|
uint olen = length();
|
|
int nlen = olen + len;
|
|
|
|
if ( s >= d->unicode && (uint)(s - d->unicode) < d->maxl ) {
|
|
// Part of me - take a copy.
|
|
TQChar *tmp = TQT_ALLOC_SECTQCHAR_VEC( len );
|
|
memcpy(tmp,s,len*sizeof(TQChar));
|
|
insert(index,tmp,len);
|
|
TQT_DELETE_SECTQCHAR_VEC( tmp );
|
|
return *this;
|
|
}
|
|
|
|
if ( index >= olen ) { // insert after end of string
|
|
grow( len + index );
|
|
int n = index - olen;
|
|
TQChar* uc = d->unicode+olen;
|
|
while (n--)
|
|
*uc++ = ' ';
|
|
memcpy( d->unicode+index, s, sizeof(TQChar)*len );
|
|
} else { // normal insert
|
|
grow( nlen );
|
|
memmove( d->unicode + index + len, unicode() + index,
|
|
sizeof(TQChar) * (olen - index) );
|
|
memcpy( d->unicode + index, s, sizeof(TQChar) * len );
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
Removes \a len characters from the string starting at position \a
|
|
index, and returns a reference to the string.
|
|
|
|
If \a index is beyond the length of the string, nothing happens.
|
|
If \a index is within the string, but \a index + \a len is beyond
|
|
the end of the string, the string is truncated at position \a
|
|
index.
|
|
|
|
\code
|
|
SecTQString string( "Montreal" );
|
|
string.remove( 1, 4 ); // string == "Meal"
|
|
\endcode
|
|
|
|
\sa insert(), replace()
|
|
*/
|
|
|
|
SecTQString &SecTQString::remove( uint index, uint len )
|
|
{
|
|
uint olen = length();
|
|
if ( index >= olen ) {
|
|
// range problems
|
|
} else if ( index + len >= olen ) { // index ok
|
|
setLength( index );
|
|
} else if ( len != 0 ) {
|
|
real_detach();
|
|
memmove( d->unicode+index, d->unicode+index+len,
|
|
sizeof(TQChar)*(olen-index-len) );
|
|
setLength( olen-len );
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Replaces \a len characters with \a slen characters of TQChar data
|
|
from \a s, starting at position \a index, and returns a reference
|
|
to the string.
|
|
|
|
\sa insert(), remove()
|
|
*/
|
|
|
|
SecTQString &SecTQString::replace( uint index, uint len, const TQChar* s, uint slen )
|
|
{
|
|
real_detach();
|
|
if ( len == slen && index + len <= length() ) {
|
|
// Optimized common case: replace without size change
|
|
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 = TQT_ALLOC_SECTQCHAR_VEC( slen );
|
|
memcpy( tmp, s, slen * sizeof(TQChar) );
|
|
replace( index, len, tmp, slen );
|
|
TQT_DELETE_SECTQCHAR_VEC( tmp );
|
|
} else {
|
|
remove( index, len );
|
|
insert( index, s, slen );
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
Replaces \a len characters from the string with \a s, starting at
|
|
position \a index, and returns a reference to the string.
|
|
|
|
If \a index is beyond the length of the string, nothing is deleted
|
|
and \a s is appended at the end of the string. If \a index is
|
|
valid, but \a index + \a len is beyond the end of the string,
|
|
the string is truncated at position \a index, then \a s is
|
|
appended at the end.
|
|
|
|
\code
|
|
TQString string( "Say yes!" );
|
|
string = string.replace( 4, 3, "NO" );
|
|
// string == "Say NO!"
|
|
\endcode
|
|
|
|
\sa insert(), remove()
|
|
*/
|
|
|
|
SecTQString &SecTQString::replace( uint index, uint len, const SecTQString &s )
|
|
{
|
|
return replace( index, len, s.unicode(), s.length() );
|
|
}
|
|
|
|
|
|
/*!
|
|
Appends \a str to the string and returns a reference to the string.
|
|
*/
|
|
SecTQString& SecTQString::operator+=( const SecTQString &str )
|
|
{
|
|
uint len1 = length();
|
|
uint len2 = str.length();
|
|
if ( len2 ) {
|
|
if ( isEmpty() ) {
|
|
operator=( str );
|
|
} else {
|
|
grow( len1+len2 );
|
|
memcpy( d->unicode+len1, str.unicode(), sizeof(TQChar)*len2 );
|
|
}
|
|
} else if ( isNull() && !str.isNull() ) { // ## just for 1.x compat:
|
|
*this = SecTQString ("");
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns the string encoded in UTF-8 format.
|
|
|
|
See TQTextCodec for more diverse coding/decoding of Unicode strings.
|
|
|
|
\sa fromUtf8(), ascii(), latin1(), local8Bit()
|
|
*/
|
|
uchar *SecTQString::utf8() const
|
|
{
|
|
int l = length();
|
|
int rlen = l*3+1;
|
|
uchar* rstr = (uchar*) ::secmem_malloc (rlen);
|
|
uchar* cursor = rstr;
|
|
const TQChar *ch = d->unicode;
|
|
for (int i=0; i < l; i++) {
|
|
uint u = ch->unicode();
|
|
if ( u < 0x80 ) {
|
|
*cursor++ = (uchar)u;
|
|
} else {
|
|
if ( u < 0x0800 ) {
|
|
*cursor++ = 0xc0 | ((uchar) (u >> 6));
|
|
} else {
|
|
if (u >= 0xd800 && u < 0xdc00 && i < l-1) {
|
|
unsigned short low = ch[1].unicode();
|
|
if (low >= 0xdc00 && low < 0xe000) {
|
|
++ch;
|
|
++i;
|
|
u = (u - 0xd800)*0x400 + (low - 0xdc00) + 0x10000;
|
|
}
|
|
}
|
|
if (u > 0xffff) {
|
|
// if people are working in utf8, but strings are encoded in eg. latin1, the resulting
|
|
// name might be invalid utf8. This and the corresponding code in fromUtf8 takes care
|
|
// we can handle this without loosing information. This can happen with latin filenames
|
|
// and a utf8 locale under Unix.
|
|
if (u > 0x10fe00 && u < 0x10ff00) {
|
|
*cursor++ = (u - 0x10fe00);
|
|
++ch;
|
|
continue;
|
|
} else {
|
|
*cursor++ = 0xf0 | ((uchar) (u >> 18));
|
|
*cursor++ = 0x80 | ( ((uchar) (u >> 12)) & 0x3f);
|
|
}
|
|
} else {
|
|
*cursor++ = 0xe0 | ((uchar) (u >> 12));
|
|
}
|
|
*cursor++ = 0x80 | ( ((uchar) (u >> 6)) & 0x3f);
|
|
}
|
|
*cursor++ = 0x80 | ((uchar) (u&0x3f));
|
|
}
|
|
++ch;
|
|
}
|
|
/* FIXME: secmem_realloc doesn't release extra memory. */
|
|
*cursor = '\0';
|
|
return rstr;
|
|
}
|
|
|
|
|
|
/*!
|
|
\fn TQChar SecTQString::at( uint ) const
|
|
|
|
Returns the character at index \a i, or 0 if \a i is beyond the
|
|
length of the string.
|
|
|
|
\code
|
|
const SecTQString string( "abcdefgh" );
|
|
TQChar ch = string.at( 4 );
|
|
// ch == 'e'
|
|
\endcode
|
|
|
|
If the SecTQString is not const (i.e. const SecTQString) or const& (i.e.
|
|
const SecTQString &), then the non-const overload of at() will be used
|
|
instead.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQChar SecTQString::constref(uint i) const
|
|
|
|
Returns the TQChar at index \a i by value.
|
|
|
|
Equivalent to at(\a i).
|
|
|
|
\sa ref()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQChar& SecTQString::ref(uint i)
|
|
|
|
Returns the TQChar at index \a i by reference, expanding the string
|
|
with TQChar::null if necessary. The resulting reference can be
|
|
assigned to, or otherwise used immediately, but becomes invalid
|
|
once furher modifications are made to the string.
|
|
|
|
\code
|
|
SecTQString string("ABCDEF");
|
|
TQChar ch = string.ref( 3 ); // ch == 'D'
|
|
\endcode
|
|
|
|
\sa constref()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQChar SecTQString::operator[]( int ) const
|
|
|
|
Returns the character at index \a i, or TQChar::null if \a i is
|
|
beyond the length of the string.
|
|
|
|
If the SecTQString is not const (i.e., const SecTQString) or const\&
|
|
(i.e., const SecTQString\&), then the non-const overload of operator[]
|
|
will be used instead.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQCharRef SecTQString::operator[]( int )
|
|
|
|
\overload
|
|
|
|
The function returns a reference to the character at index \a i.
|
|
The resulting reference can then be assigned to, or used
|
|
immediately, but it will become invalid once further modifications
|
|
are made to the original string.
|
|
|
|
If \a i is beyond the length of the string then the string is
|
|
expanded with TQChar::nulls, so that the TQCharRef references a
|
|
valid (null) character in the string.
|
|
|
|
The TQCharRef internal class can be used much like a constant
|
|
TQChar, but if you assign to it, you change the original string
|
|
(which will detach itself because of SecTQString's copy-on-write
|
|
semantics). You will get compilation errors if you try to use the
|
|
result as anything but a TQChar.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQCharRef SecTQString::at( uint i )
|
|
|
|
\overload
|
|
|
|
The function returns a reference to the character at index \a i.
|
|
The resulting reference can then be assigned to, or used
|
|
immediately, but it will become invalid once further modifications
|
|
are made to the original string.
|
|
|
|
If \a i is beyond the length of the string then the string is
|
|
expanded with TQChar::null.
|
|
*/
|
|
|
|
/*
|
|
Internal chunk of code to handle the
|
|
uncommon cases of at() above.
|
|
*/
|
|
void SecTQString::subat( uint i )
|
|
{
|
|
uint olen = d->len;
|
|
if ( i >= olen ) {
|
|
setLength( i+1 ); // i is index; i+1 is needed length
|
|
for ( uint j=olen; j<=i; j++ )
|
|
d->unicode[j] = TQChar::null;
|
|
} else {
|
|
// Just be sure to detach
|
|
real_detach();
|
|
}
|
|
}
|
|
|
|
|
|
/*! \internal
|
|
*/
|
|
bool SecTQString::isRightToLeft() const
|
|
{
|
|
int len = length();
|
|
TQChar *p = d->unicode;
|
|
while ( len-- ) {
|
|
switch( (*p).direction () )
|
|
{
|
|
case TQChar::DirL:
|
|
case TQChar::DirLRO:
|
|
case TQChar::DirLRE:
|
|
return FALSE;
|
|
case TQChar::DirR:
|
|
case TQChar::DirAL:
|
|
case TQChar::DirRLO:
|
|
case TQChar::DirRLE:
|
|
return TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
++p;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*!
|
|
\fn const SecTQString operator+( const SecTQString &s1, const SecTQString &s2 )
|
|
|
|
\relates SecTQString
|
|
|
|
Returns a string which is the result of concatenating the string
|
|
\a s1 and the string \a s2.
|
|
|
|
Equivalent to \a {s1}.append(\a s2).
|
|
*/
|
|
|
|
|
|
/*! \fn void SecTQString::detach()
|
|
If the string does not share its data with another SecTQString instance,
|
|
nothing happens; otherwise the function creates a new, unique copy of
|
|
this string. This function is called whenever the string is modified. The
|
|
implicit sharing mechanism is implemented this way.
|
|
*/
|