diff options
Diffstat (limited to 'debian/pinentry-tqt/pinentry-tqt-1.2.1/tqt/secqstring.cpp')
| -rw-r--r-- | debian/pinentry-tqt/pinentry-tqt-1.2.1/tqt/secqstring.cpp | 939 |
1 files changed, 939 insertions, 0 deletions
diff --git a/debian/pinentry-tqt/pinentry-tqt-1.2.1/tqt/secqstring.cpp b/debian/pinentry-tqt/pinentry-tqt-1.2.1/tqt/secqstring.cpp new file mode 100644 index 00000000..82dd9180 --- /dev/null +++ b/debian/pinentry-tqt/pinentry-tqt-1.2.1/tqt/secqstring.cpp @@ -0,0 +1,939 @@ +/* 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 QT_ALLOC_SECTQCHAR_VEC(N) (TQChar*) ::secmem_malloc (sizeof(TQChar) * (N)) +#define QT_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 +*/ + +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); + +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( QT_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 = QT_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 = QT_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 = QT_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 = QT_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 = QT_ALLOC_SECTQCHAR_VEC( len ); + memcpy(tmp,s,len*sizeof(TQChar)); + insert(index,tmp,len); + QT_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 = QT_ALLOC_SECTQCHAR_VEC( slen ); + memcpy( tmp, s, slen * sizeof(TQChar) ); + replace( index, len, tmp, slen ); + QT_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. +*/ |