diff options
Diffstat (limited to 'qtools/qcstring.cpp')
| -rw-r--r-- | qtools/qcstring.cpp | 2333 |
1 files changed, 605 insertions, 1728 deletions
diff --git a/qtools/qcstring.cpp b/qtools/qcstring.cpp index 44324c2..1bd7c7f 100644 --- a/qtools/qcstring.cpp +++ b/qtools/qcstring.cpp @@ -1,1760 +1,771 @@ -/**************************************************************************** -** -** -** Implementation of extended char array operations, and QByteArray and -** QCString classes -** -** Created : 920722 -** -** Copyright (C) 1992-2000 Trolltech AS. All rights reserved. -** -** This file is part of the tools module of the Qt 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.QPL 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 Qt Enterprise Edition or Qt Professional Edition -** licenses may use this file in accordance with the Qt 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 Qt Commercial License Agreements. -** See http://www.trolltech.com/qpl/ for QPL 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. -** -**********************************************************************/ - -#include "qstring.h" -#include "qregexp.h" -#include "qdatastream.h" +/****************************************************************************** + * + * Copyright (C) 1997-2004 by Dimitri van Heesch. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation under the terms of the GNU General Public License is hereby + * granted. No representations are made about the suitability of this software + * for any purpose. It is provided "as is" without express or implied warranty. + * See the GNU General Public License for more details. + * + * Documents produced by Doxygen are derivative works derived from the + * input used in their production; they are not affected by this license. + * + */ + +#include "qcstring.h" +#include "qgstring.h" + +#include <qstring.h> +#include <stdlib.h> #include <stdio.h> #include <stdarg.h> -#include <stdlib.h> #include <ctype.h> +#include <qregexp.h> +#include <qdatastream.h> -/***************************************************************************** - Safe and portable C string functions; extensions to standard string.h - *****************************************************************************/ - -/*! - \fn void *memmove( void *dst, const void *src, uint len ) - \relates QCString - - This function is normally part of the C library. Qt implements - memmove() for platforms that do not have it. - - memmove() copies \e len bytes from \e src into \e dst. The data is - copied correctly even if \e src and \e dst overlap. -*/ - -void *qmemmove( void *dst, const void *src, uint len ) -{ - register char *d; - register char *s; - if ( dst > src ) { - d = (char *)dst + len - 1; - s = (char *)src + len - 1; - while ( len-- ) - *d-- = *s--; - } else if ( dst < src ) { - d = (char *)dst; - s = (char *)src; - while ( len-- ) - *d++ = *s++; - } - return dst; -} - -/*! - \relates QCString - - Returns a duplicate string. - - Allocates space for a copy of \e str (using \c new), copies it, and returns - a pointer to the copy. - If \e src is null, it immediately returns 0. -*/ - -char *qstrdup( const char *str ) -{ - if ( !str ) - return 0; - char *dst = new char[strlen(str)+1]; - CHECK_PTR( dst ); - return strcpy( dst, str ); -} - -/*! - \relates QCString - - A safe strncpy() function. - - Copies all characters up to \e len bytes from \e str into \e dst and returns - a pointer to \e dst. Guarantees that \e dst is \0-terminated. - If \e src is null, it immediately returns 0. - - \sa qstrcpy() -*/ - -char *qstrncpy( char *dst, const char *src, uint len ) -{ - if ( !src ) - return 0; - strncpy( dst, src, len ); - if ( len > 0 ) - dst[len-1] = '\0'; - return dst; -} - -/*! - \fn int qstrcmp( const char *str1, const char *str2 ) - \relates QCString - - A safe strcmp() function. - - Compares \e str1 and \e str2. Returns a negative value if \e str1 - is less than \e str2, 0 if \e str1 is equal to \e str2 or a positive - value if \e str1 is greater than \e str2. - - Special case I: Returns 0 if \e str1 and \e str2 are both null. - - Special case II: Returns a random nonzero value if \e str1 is null - or \e str2 is null (but not both). - - \sa qstrncmp(), qstricmp(), qstrnicmp() -*/ - -/*! - \fn int qstrncmp( const char *str1, const char *str2, uint len ) - \relates QCString - - A safe strncmp() function. - - Compares \e str1 and \e str2 up to \e len bytes. - - Returns a negative value if \e str1 is less than \e str2, 0 if \e str1 - is equal to \e str2 or a positive value if \e str1 is greater than \e - str2. - - Special case I: Returns 0 if \e str1 and \e str2 are both null. - - Special case II: Returns a random nonzero value if \e str1 is null - or \e str2 is null (but not both). - - \sa qstrcmp(), qstricmp(), qstrnicmp() -*/ - -/*! - \fn int qstricmp( const char *str1, const char *str2 ) - \relates QCString - A safe stricmp() function. - - Compares \e str1 and \e str2 ignoring the case. - - Returns a negative value if \e str1 is less than \e str2, 0 if \e str1 - is equal to \e str2 or a positive value if \e str1 is greater than \e - str2. - - Special case I: Returns 0 if \e str1 and \e str2 are both null. - - Special case II: Returns a random nonzero value if \e str1 is null - or \e str2 is null (but not both). - - \sa qstrcmp(), qstrncmp(), qstrnicmp() -*/ - -int qstricmp( const char *str1, const char *str2 ) -{ - register const uchar *s1 = (const uchar *)str1; - register const uchar *s2 = (const uchar *)str2; - int res; - uchar c; - if ( !s1 || !s2 ) - return s1 == s2 ? 0 : (int)((long)s2 - (long)s1); - for ( ; !(res = (c=tolower(*s1)) - tolower(*s2)); s1++, s2++ ) - if ( !c ) // strings are equal - break; - return res; -} - -/*! - \fn int strnicmp( const char *str1, const char *str2, uint len ) - \relates QCString - - A safe strnicmp() function. - - Compares \e str1 and \e str2 up to \e len bytes ignoring the case. - - Returns a negative value if \e str1 is less than \e str2, 0 if \e str1 - is equal to \e str2 or a positive value if \e str1 is greater than \e - str2. - - Special case I: Returns 0 if \e str1 and \e str2 are both null. - - Special case II: Returns a random nonzero value if \e str1 is null - or \e str2 is null (but not both). - - \sa qstrcmp(), qstrncmp() qstricmp() -*/ - -int qstrnicmp( const char *str1, const char *str2, uint len ) -{ - register const uchar *s1 = (const uchar *)str1; - register const uchar *s2 = (const uchar *)str2; - int res; - uchar c; - if ( !s1 || !s2 ) - return (int)((long)s2 - (long)s1); - for ( ; len--; s1++, s2++ ) { - if ( (res = (c=tolower(*s1)) - tolower(*s2)) ) - return res; - if ( !c ) // strings are equal - break; - } - return 0; -} - - -static Q_UINT16 crc_tbl[16]; -static bool crc_tbl_init = FALSE; - -static void createCRC16Table() // build CRC16 lookup table +QCString::QCString(int size) { - register uint i; - register uint j; - uint v0, v1, v2, v3; - for ( i=0; i<16; i++ ) { - v0 = i & 1; - v1 = (i >> 1) & 1; - v2 = (i >> 2) & 1; - v3 = (i >> 3) & 1; - j = 0; -#undef SET_BIT -#define SET_BIT(x,b,v) x |= v << b - SET_BIT(j, 0,v0); - SET_BIT(j, 7,v0); - SET_BIT(j,12,v0); - SET_BIT(j, 1,v1); - SET_BIT(j, 8,v1); - SET_BIT(j,13,v1); - SET_BIT(j, 2,v2); - SET_BIT(j, 9,v2); - SET_BIT(j,14,v2); - SET_BIT(j, 3,v3); - SET_BIT(j,10,v3); - SET_BIT(j,15,v3); - crc_tbl[i] = j; + if (size>0) + { + m_data = (char *)malloc(size); + if (m_data) + { + if (size>1) memset(m_data,' ',size-1); + m_data[size-1]='\0'; } + } + else + { + m_data=0; + } } -/*! - \relates QByteArray - Returns the CRC-16 checksum of \e len bytes starting at \e data. - - The checksum is independent of the byte order (endianness). -*/ - -Q_UINT16 qChecksum( const char *data, uint len ) -{ - if ( !crc_tbl_init ) { // create lookup table - createCRC16Table(); - crc_tbl_init = TRUE; - } - register Q_UINT16 crc = 0xffff; - uchar c; - uchar *p = (uchar *)data; - while ( len-- ) { - c = *p++; - crc = ((crc >> 4) & 0x0fff) ^ crc_tbl[((crc ^ c) & 15)]; - c >>= 4; - crc = ((crc >> 4) & 0x0fff) ^ crc_tbl[((crc ^ c) & 15)]; - } - return (~crc & 0xffff); +QCString::QCString( const QCString &s ) +{ + duplicate(s); } - -/***************************************************************************** - QByteArray member functions - *****************************************************************************/ - -// NOT REVISED -/*! \class QByteArray qcstring.h - - \brief The QByteArray class provides an array of bytes. - - \inherit QArray - \ingroup tools - \ingroup shared - - QByteArray is defined as QArray\<char\>. -*/ - - -/***************************************************************************** - QByteArray stream functions - *****************************************************************************/ - -/*! - \relates QByteArray - Writes a byte array to a stream and returns a reference to the stream. - - \sa \link datastreamformat.html Format of the QDataStream operators \endlink -*/ -#ifndef QT_NO_DATASTREAM - -QDataStream &operator<<( QDataStream &s, const QByteArray &a ) -{ - return s.writeBytes( a.data(), a.size() ); +QCString::QCString( const char *str ) +{ + duplicate(str); } -/*! - \relates QByteArray - Reads a byte array from a stream and returns a reference to the stream. - - \sa \link datastreamformat.html Format of the QDataStream operators \endlink -*/ - -QDataStream &operator>>( QDataStream &s, QByteArray &a ) -{ - Q_UINT32 len; - s >> len; // read size of array - if ( len == 0 || s.eof() ) { // end of file reached - a.resize( 0 ); - return s; - } - if ( !a.resize( (uint)len ) ) { // resize array -#if defined(CHECK_NULL) - qWarning( "QDataStream: Not enough memory to read QByteArray" ); -#endif - len = 0; - } - if ( len > 0 ) // not null array - s.readRawBytes( a.data(), (uint)len ); - return s; +QCString::QCString( const char *str, uint maxlen ) +{ + uint l; + if (str && ( l = QMIN(qstrlen(str),maxlen) )) + { + m_data=(char *)malloc(l+1); + strncpy(m_data,str,maxlen); + m_data[l]='\0'; + } + else + { + m_data=0; + } } -#endif //QT_NO_DATASTREAM - -/***************************************************************************** - QCString member functions - *****************************************************************************/ - -/*! - \class QCString qcstring.h - - \brief The QCString class provides an abstraction of the classic C - zero-terminated char array (<var>char*</var>). - - \ingroup tools - \ingroup shared - - QCString inherits QByteArray, which is defined as QArray\<char\>. - - Since QCString is a QArray, it uses \e explicit - \link shclass.html sharing\endlink with a reference count. - - You might use QCString for text that is never exposed to the user, - but for text the user sees, you should use QString (which provides - implicit sharing, Unicode and other internationalization support). - - Note that QCString is one of the weaker classes in Qt; its design is - flawed (it tries to behave like a more convenient const char *) and - as a result, algorithms that use QCString heavily all too often - perform badly. For example, append() is O(length()) since it scans - for a null terminator, which makes many algorithms that use QCString - scale even worse. - - Note that for the QCString methods that take a <var>const char *</var> - parameter the results are undefined if the QCString is not - zero-terminated. It is legal for the <var>const char *</var> parameter - to be 0. - - A QCString that has not been assigned to anything is \e null, i.e. both - the length and data pointer is 0. A QCString that references the empty - string ("", a single '\0' char) is \e empty. Both null and empty - QCStrings are legal parameters to the methods. Assigning <var>const char - * 0</var> to QCString gives a null QCString. - - \sa \link shclass.html Shared classes\endlink -*/ - - -/* - Implementation note: The QCString methods for QRegExp searching are - implemented by converting the QCString to a QString and performing - the search on that. This implies a deep copy of the QCString - data. Therefore, if you are giong to perform many QRegExp searches - on one and the same, large QCString, you will get better performance - by converting the QCString to a QString yourself, and do the - searches on that. The results will be of course be identical. -*/ - - - -/*! - \fn QCString::QCString() - Constructs a null string. - \sa isNull() -*/ - -/*! - \fn QCString::QCString( const QCString &s ) - Constructs a shallow copy \e s. - \sa assign() -*/ - -/*! - Constructs a string with room for \e size characters, including the - '\0'-terminator. Makes a null string if \e size == 0. - - If \e size \> 0, then the first and last characters in the string are - initialized to '\0'. All other characters are uninitialized. - - \sa resize(), isNull() -*/ - -QCString::QCString( int size ) - : QByteArray( size ) +QCString::~QCString() { - if ( size > 0 ) { - *data() = '\0'; // set terminator - *(data()+(size-1)) = '\0'; - } + if (m_data) free(m_data); + m_data=0; } -/*! - Constructs a string that is a deep copy of \e str. - - If \a str is 0 a null string is created. - - \sa isNull() -*/ - -QCString::QCString( const char *str ) +QCString &QCString::assign( const char *str ) { - duplicate( str, qstrlen(str) + 1 ); + if (m_data) free(m_data); + duplicate(str); + return *this; } - -/*! - Constructs a string that is a deep copy of \e str, that is no more - than \a maxsize bytes long including the '\0'-terminator. - - Example: - \code - QCString str( "helloworld", 6 ); // Assigns "hello" to str. - \endcode - - If \a str contains a 0 byte within the first \a maxsize bytes, the - resulting QCString will be terminated by the 0. If \a str is 0 a - null string is created. - - \sa isNull() -*/ - -QCString::QCString( const char *str, uint maxsize ) +bool QCString::resize( uint newlen ) { - if ( str == 0 ) - return; - uint len; // index of first '\0' - for ( len = 0; len < maxsize - 1; len++ ) { - if ( str[len] == '\0' ) - break; - } - QByteArray::resize( len + 1 ); - memcpy( data(), str, len ); - data()[len] = 0; -} - -/*! - \fn QCString &QCString::operator=( const QCString &s ) - Assigns a shallow copy of \e s to this string and returns a reference to - this string. -*/ - -/*! - \fn QCString &QCString::operator=( const char *str ) - Assigns a deep copy of \a str to this string and returns a reference to - this string. - - If \a str is 0 a null string is created. - - \sa isNull() -*/ - -/*! - \fn bool QCString::isNull() const - Returns TRUE if the string is null, i.e. if data() == 0. - A null string is also an empty string. - - Example: - \code - QCString a; // a.data() == 0, a.size() == 0, a.length() == 0 - QCString b == ""; // b.data() == "", b.size() == 1, b.length() == 0 - a.isNull(); // TRUE, because a.data() == 0 - a.isEmpty(); // TRUE, because a.length() == 0 - b.isNull(); // FALSE, because b.data() == "" - b.isEmpty(); // TRUE, because b.length() == 0 - \endcode - - \sa isEmpty(), length(), size() -*/ - -/*! - \fn bool QCString::isEmpty() const - - Returns TRUE if the string is empty, i.e. if length() == 0. - An empty string is not always a null string. - - See example in isNull(). - - \sa isNull(), length(), size() -*/ - -/*! - \fn uint QCString::length() const - Returns the length of the string, excluding the '\0'-terminator. - Equivalent to calling \c strlen(data()). - - Null strings and empty strings have zero length. - - \sa size(), isNull(), isEmpty() -*/ - -/*! - \fn bool QCString::truncate( uint pos ) - Truncates the string at position \e pos. - - Equivalent to calling \c resize(pos+1). - - Example: - \code - QCString s = "truncate this string"; - s.truncate( 5 ); // s == "trunc" - \endcode - - \sa resize() -*/ - -/*! - Extends or shrinks the string to \e len bytes, including the - '\0'-terminator. - - A \0-terminator is set at position <code>len - 1</code> unless - <code>len == 0</code>. - - Example: - \code - QCString s = "resize this string"; - s.resize( 7 ); // s == "resize" - \endcode - - \sa truncate() -*/ - -bool QCString::resize( uint len ) -{ - detach(); - if ( !QByteArray::resize(len) ) - return FALSE; - if ( len ) - *(data()+len-1) = '\0'; + if (newlen==0) + { + if (m_data) { free(m_data); m_data=0; } return TRUE; + } + if (m_data==0) // newlen>0 + { + m_data = (char *)malloc(newlen); + } + else + { + m_data = (char *)realloc(m_data,newlen); + } + if (m_data==0) return FALSE; + m_data[newlen-1]='\0'; + return TRUE; } - -/*! - Implemented as a call to the native vsprintf() (see your C-library - manual). - - If your string is shorter than 256 characters, this sprintf() calls - resize(256) to decrease the chance of memory corruption. The string is - resized back to its natural length before sprintf() returns. - - Example: - \code - QCString s; - s.sprintf( "%d - %s", 1, "first" ); // result < 256 chars - - QCString big( 25000 ); // very long string - big.sprintf( "%d - %s", 2, longString ); // result < 25000 chars - \endcode - - \warning All vsprintf() implementations will write past the end of - the target string (*this) if the format specification and arguments - happen to be longer than the target string, and some will also fail - if the target string is longer than some arbitrary implementation - limit. - - Giving user-supplied arguments to sprintf() is begging for trouble. - Sooner or later someone \e will paste a 3000-character line into - your application. -*/ - -QCString &QCString::sprintf( const char *format, ... ) +bool QCString::fill( char c, int len ) { - detach(); - va_list ap; - va_start( ap, format ); - if ( size() < 256 ) - QByteArray::resize( 256 ); // make string big enough - vsprintf( data(), format, ap ); - resize( qstrlen(data()) + 1 ); // truncate - va_end( ap ); - return *this; + uint l=length(); + if (len<0) len=l; + if ((uint)len!=l) + { + if (m_data) free(m_data); + if (len>0) + { + m_data=(char *)malloc(len+1); + if (m_data==0) return FALSE; + m_data[len]='\0'; + } + else + { + m_data=0; + } + } + if (len>0) + { + uint i; + for (i=0;i<(uint)len;i++) m_data[i]=c; + } + return TRUE; } - -/*! - Fills the string with \e len bytes of value \e c, followed by a - '\0'-terminator. - - If \e len is negative, then the current string length is used. - - Returns FALSE is \e len is nonnegative and there is no memory to - resize the string, otherwise TRUE is returned. -*/ - -bool QCString::fill( char c, int len ) +QCString &QCString::sprintf( const char *format, ... ) { - detach(); - if ( len < 0 ) - len = length(); - if ( !QByteArray::fill(c,len+1) ) - return FALSE; - *(data()+len) = '\0'; - return TRUE; + va_list ap; + va_start( ap, format ); + uint l = length(); + const uint minlen=256; + if (l<minlen) + { + if (m_data) + m_data = (char *)realloc(m_data,minlen); + else + m_data = (char *)malloc(minlen); + } + vsprintf( m_data, format, ap ); + resize( qstrlen(m_data) + 1 ); // truncate + va_end( ap ); + return *this; } -/*! - \fn QCString QCString::copy() const - Returns a deep copy of this string. - \sa detach() -*/ - - -/*! - Finds the first occurrence of the character \e c, starting at - position \e index. - - The search is case sensitive if \e cs is TRUE, or case insensitive if \e - cs is FALSE. - - Returns the position of \e c, or -1 if \e c could not be found. -*/ - int QCString::find( char c, int index, bool cs ) const { - if ( (uint)index >= size() ) // index outside string - return -1; - register const char *d; - if ( cs ) { // case sensitive - d = strchr( data()+index, c ); - } else { - d = data()+index; - c = tolower( (uchar) c ); - while ( *d && tolower((uchar) *d) != c ) - d++; - if ( !*d && c ) // not found - d = 0; - } - return d ? (int)(d - data()) : -1; + uint len = length(); + if ( m_data==0 || (uint)index>len ) // index outside string + return -1; + register const char *d; + if ( cs ) // case sensitive + { + d = strchr( m_data+index, c ); + } + else + { + d = m_data+index; + c = tolower( (uchar) c ); + while ( *d && tolower((uchar) *d) != c ) + d++; + if ( !*d && c ) // not found + d = 0; + } + return d ? (int)(d - m_data) : -1; } -/*! - Finds the first occurrence of the string \e str, starting at position - \e index. - - The search is case sensitive if \e cs is TRUE, or case insensitive if \e - cs is FALSE. - - Returns the position of \e str, or -1 if \e str could not be found. -*/ - int QCString::find( const char *str, int index, bool cs ) const { - if ( (uint)index >= size() ) // index outside string - return -1; - if ( !str ) // no search string - return -1; - if ( !*str ) // zero-length search string - return index; - register const char *d; - if ( cs ) { // case sensitive - d = strstr( data()+index, str ); - } else { // case insensitive - d = data()+index; - int len = qstrlen( str ); - while ( *d ) { - if ( qstrnicmp(d, str, len) == 0 ) - break; - d++; - } - if ( !*d ) // not found - d = 0; + uint l = length(); + if ( m_data==0 || (uint)index > l ) // index outside string + return -1; + if ( !str ) // no search string + return -1; + if ( !*str ) // zero-length search string + return index; + register const char *d; + if ( cs ) // case sensitive + { + d = strstr( m_data+index, str ); + } + else // case insensitive + { + d = m_data+index; + int len = qstrlen( str ); + while ( *d ) + { + if ( qstrnicmp(d, str, len) == 0 ) + break; + d++; } - return d ? (int)(d - data()) : -1; + if ( !*d ) // not found + d = 0; + } + return d ? (int)(d - m_data) : -1; } -/*! - Finds the first occurrence of the character \e c, starting at - position \e index and searching backwards. - - The search is case sensitive if \e cs is TRUE, or case insensitive if \e - cs is FALSE. - - Returns the position of \e c, or -1 if \e c could not be found. -*/ - -int QCString::findRev( char c, int index, bool cs ) const +int QCString::find( const QRegExp &rx, int index ) const { - const char *b = data(); - const char *d; - if ( index < 0 ) { // neg index ==> start from end - if ( size() == 0 ) - return -1; - if ( cs ) { - d = strrchr( b, c ); - return d ? (int)(d - b) : -1; - } - index = length(); - } else if ( (uint)index >= size() ) { // bad index - return -1; - } - d = b+index; - if ( cs ) { // case sensitive - while ( d >= b && *d != c ) - d--; - } else { // case insensitive - c = tolower( (uchar) c ); - while ( d >= b && tolower((uchar) *d) != c ) - d--; - } - return d >= b ? (int)(d - b) : -1; + QString d = QString::fromLatin1( m_data ); + return d.find( rx, index ); } -/*! - Finds the first occurrence of the string \e str, starting at - position \e index and searching backwards. - - The search is case sensitive if \e cs is TRUE, or case insensitive if \e - cs is FALSE. - - Returns the position of \e str, or -1 if \e str could not be found. -*/ - -int QCString::findRev( const char *str, int index, bool cs ) const +int QCString::findRev( char c, int index, bool cs) const { - int slen = qstrlen(str); - if ( index < 0 ) // neg index ==> start from end - index = length()-slen; - else if ( (uint)index >= size() ) // bad index - return -1; - else if ( (uint)(index + slen) > length() ) // str would be too long - index = length() - slen; - if ( index < 0 ) - return -1; - - register char *d = data() + index; - if ( cs ) { // case sensitive - for ( int i=index; i>=0; i-- ) - if ( qstrncmp(d--,str,slen)==0 ) - return i; - } else { // case insensitive - for ( int i=index; i>=0; i-- ) - if ( qstrnicmp(d--,str,slen)==0 ) - return i; + const char *b = m_data; + const char *d; + uint len = length(); + if ( b == 0 ) return -1; // empty string + if ( index < 0 ) // neg index ==> start from end + { + if ( len == 0 ) return -1; + if ( cs ) + { + d = strrchr( b, c ); + return d ? (int)(d - b) : -1; } + index = len; + } + else if ( (uint)index > len ) // bad index + { + return -1; + } + d = b+index; + if ( cs ) // case sensitive + { + while ( d >= b && *d != c ) + d--; + } + else // case insensitive + { + c = tolower( (uchar) c ); + while ( d >= b && tolower((uchar) *d) != c ) + d--; + } + return d >= b ? (int)(d - b) : -1; +} + +int QCString::findRev( const char *str, int index, bool cs) const +{ + int slen = qstrlen(str); + uint len = length(); + if ( index < 0 ) // neg index ==> start from end + index = len-slen; + else if ( (uint)index > len ) // bad index + return -1; + else if ( (uint)(index + slen) > len ) // str would be too long + index = len - slen; + if ( index < 0 ) return -1; -} - - -/*! - Returns the number of times the character \e c occurs in the string. - The match is case sensitive if \e cs is TRUE, or case insensitive if \e cs - if FALSE. -*/ + register char *d = m_data + index; + if ( cs ) // case sensitive + { + for ( int i=index; i>=0; i-- ) + if ( qstrncmp(d--,str,slen)==0 ) + return i; + } + else // case insensitive + { + for ( int i=index; i>=0; i-- ) + if ( qstrnicmp(d--,str,slen)==0 ) + return i; + } + return -1; -int QCString::contains( char c, bool cs ) const -{ - int count = 0; - char *d = data(); - if ( !d ) - return 0; - if ( cs ) { // case sensitive - while ( *d ) - if ( *d++ == c ) - count++; - } else { // case insensitive - c = tolower( (uchar) c ); - while ( *d ) { - if ( tolower((uchar) *d) == c ) - count++; - d++; - } - } - return count; } -/*! - Returns the number of times \e str occurs in the string. - - The match is case sensitive if \e cs is TRUE, or case insensitive if \e - cs if FALSE. - - This function counts overlapping substrings, for example, "banana" - contains two occurrences of "ana". - - \sa findRev() -*/ - -int QCString::contains( const char *str, bool cs ) const +int QCString::findRev( const QRegExp &rx, int index ) const { - int count = 0; - char *d = data(); - if ( !d ) - return 0; - int len = qstrlen( str ); - while ( *d ) { // counts overlapping strings - if ( cs ) { - if ( qstrncmp( d, str, len ) == 0 ) - count++; - } else { - if ( qstrnicmp(d, str, len) == 0 ) - count++; - } - d++; - } - return count; + QString d = QString::fromLatin1( m_data ); + return d.findRev( rx, index ); } -/*! - Returns a substring that contains the \e len leftmost characters - of the string. - - The whole string is returned if \e len exceeds the length of the string. - - Example: - \code - QCString s = "Pineapple"; - QCString t = s.left( 4 ); // t == "Pine" - \endcode - - \sa right(), mid() -*/ - -QCString QCString::left( uint len ) const +int QCString::contains( char c, bool cs ) const { - if ( isEmpty() ) { - QCString empty; - return empty; - } else if ( len >= size() ) { - QCString same( data() ); - return same; - } else { - QCString s( len+1 ); - strncpy( s.data(), data(), len ); - *(s.data()+len) = '\0'; - return s; - } + int count = 0; + char *d = m_data; + if ( !d ) + return 0; + if ( cs ) // case sensitive + { + while ( *d ) + if ( *d++ == c ) + count++; + } + else // case insensitive + { + c = tolower( (uchar) c ); + while ( *d ) { + if ( tolower((uchar) *d) == c ) + count++; + d++; + } + } + return count; } -/*! - Returns a substring that contains the \e len rightmost characters - of the string. - - The whole string is returned if \e len exceeds the length of the string. - - Example: - \code - QCString s = "Pineapple"; - QCString t = s.right( 5 ); // t == "apple" - \endcode - - \sa left(), mid() -*/ - -QCString QCString::right( uint len ) const +int QCString::contains( const char *str, bool cs ) const { - if ( isEmpty() ) { - QCString empty; - return empty; - } else { - uint l = length(); - if ( len > l ) - len = l; - char *p = data() + (l - len); - return QCString( p ); - } + int count = 0; + char *d = data(); + if ( !d ) + return 0; + int len = qstrlen( str ); + while ( *d ) // counts overlapping strings + { + if ( cs ) + { + if ( qstrncmp( d, str, len ) == 0 ) + count++; + } + else + { + if ( qstrnicmp(d, str, len) == 0 ) + count++; + } + d++; + } + return count; } -/*! - Returns a substring that contains the \e len characters of this - string, starting at position \e index. - - Returns a null string if the string is empty or \e index is out - of range. Returns the whole string from \e index if \e index+len exceeds - the length of the string. - - Example: - \code - QCString s = "Two pineapples"; - QCString t = s.mid( 4, 4 ); // t == "pine" - \endcode - - \sa left(), right() -*/ - -QCString QCString::mid( uint index, uint len ) const -{ - if ( len == 0xffffffff ) len = length()-index; - uint slen = qstrlen( data() ); - if ( isEmpty() || index >= slen ) { - QCString empty; - return empty; - } else { - register char *p = data()+index; - QCString s( len+1 ); - strncpy( s.data(), p, len ); - *(s.data()+len) = '\0'; - return s; - } +int QCString::contains( const QRegExp &rx ) const +{ + QString d = QString::fromLatin1( m_data ); + return d.contains( rx ); } -/*! - Returns a string of length \e width (plus '\0') that contains this - string and padded by the \e fill character. - - If the length of the string exceeds \e width and \e truncate is FALSE, - then the returned string is a copy of the string. - If the length of the string exceeds \e width and \e truncate is TRUE, - then the returned string is a left(\e width). - - Example: - \code - QCString s("apple"); - QCString t = s.leftJustify(8, '.'); // t == "apple..." - \endcode - - \sa rightJustify() -*/ - -QCString QCString::leftJustify( uint width, char fill, bool truncate ) const +QCString QCString::left( uint len ) const { - QCString result; - int len = qstrlen(data()); - int padlen = width - len; - if ( padlen > 0 ) { - result.QByteArray::resize( len+padlen+1 ); - memcpy( result.data(), data(), len ); - memset( result.data()+len, fill, padlen ); - result[len+padlen] = '\0'; - } else { - if ( truncate ) - result = left( width ); - else - result = copy(); - } - return result; + if ( isEmpty() ) + { + return QCString(); + } + else if ( len >= length() ) + { + return *this; + } + else + { + QCString s( len+1 ); + strncpy( s.data(), m_data, len ); + *(s.data()+len) = '\0'; + return s; + } } -/*! - Returns a string of length \e width (plus '\0') that contains pad - characters followed by the string. - - If the length of the string exceeds \e width and \e truncate is FALSE, - then the returned string is a copy of the string. - If the length of the string exceeds \e width and \e truncate is TRUE, - then the returned string is a left(\e width). - - Example: - \code - QCString s("pie"); - QCString t = s.rightJustify(8, '.'); // t == ".....pie" - \endcode - - \sa leftJustify() -*/ - -QCString QCString::rightJustify( uint width, char fill, bool truncate ) const +QCString QCString::right( uint len ) const { - QCString result; - int len = qstrlen(data()); - int padlen = width - len; - if ( padlen > 0 ) { - result.QByteArray::resize( len+padlen+1 ); - memset( result.data(), fill, padlen ); - memcpy( result.data()+padlen, data(), len ); - result[len+padlen] = '\0'; - } else { - if ( truncate ) - result = left( width ); - else - result = copy(); - } - return result; + if ( isEmpty() ) + { + return QCString(); + } + else + { + uint l = length(); + if ( len > l ) len = l; + char *p = m_data + (l - len); + return QCString( p ); + } +} + +QCString QCString::mid( uint index, uint len) const +{ + uint slen = length(); + if ( len == 0xffffffff ) len = slen-index; + if ( isEmpty() || index >= slen ) + { + return QCString(); + } + else + { + register char *p = data()+index; + QCString s( len+1 ); + strncpy( s.data(), p, len ); + *(s.data()+len) = '\0'; + return s; + } } -/*! - Returns a new string that is the string converted to lower case. - - Presently it only handles 7-bit ASCII, or whatever tolower() - handles (if $LC_CTYPE is set, most UNIX systems do the Right Thing). - - Example: - \code - QCString s("TeX"); - QCString t = s.lower(); // t == "tex" - \endcode - - \sa upper() -*/ - QCString QCString::lower() const { - QCString s( data() ); - register char *p = s.data(); - if ( p ) { - while ( *p ) { - *p = tolower((uchar) *p); - p++; - } + QCString s( m_data ); + register char *p = s.data(); + if ( p ) + { + while ( *p ) + { + *p = tolower((uchar) *p); + p++; } - return s; + } + return s; } -/*! - Returns a new string that is the string converted to upper case. - - Presently it only handles 7-bit ASCII, or whatever toupper() - handles (if $LC_CTYPE is set, most UNIX systems do the Right Thing). - - Example: - \code - QCString s("TeX"); - QCString t = s.upper(); // t == "TEX" - \endcode - - \sa lower() -*/ - QCString QCString::upper() const { - QCString s( data() ); - register char *p = s.data(); - if ( p ) { - while ( *p ) { - *p = toupper((uchar)*p); - p++; - } + QCString s( m_data ); + register char *p = s.data(); + if ( p ) { + while ( *p ) { + *p = toupper((uchar)*p); + p++; } - return s; + } + return s; } - -/*! - Returns a new string that has white space removed from the start and the end. - - White space means any ASCII code 9, 10, 11, 12, 13 or 32. - - Example: - \code - QCString s = " space "; - QCString t = s.stripWhiteSpace(); // t == "space" - \endcode - - \sa simplifyWhiteSpace() -*/ - -QCString QCString::stripWhiteSpace() const +QCString QCString::stripWhiteSpace() const { - if ( isEmpty() ) // nothing to do - return copy(); - - register char *s = data(); - QCString result = s; - int reslen = result.length(); - if ( !isspace((uchar) s[0]) && !isspace((uchar) s[reslen-1]) ) - return result; // returns a copy - - s = result.data(); - int start = 0; - int end = reslen - 1; - while ( isspace((uchar) s[start]) ) // skip white space from start - start++; - if ( s[start] == '\0' ) { // only white space - result.resize( 1 ); - return result; - } - while ( end && isspace((uchar) s[end]) ) // skip white space from end - end--; - end -= start - 1; - memmove( result.data(), &s[start], end ); - result.resize( end + 1 ); - return result; -} - - -/*! - Returns a new string that has white space removed from the start and the end, - plus any sequence of internal white space replaced with a single space - (ASCII 32). - - White space means any ASCII code 9, 10, 11, 12, 13 or 32. - - \code - QCString s = " lots\t of\nwhite space "; - QCString t = s.simplifyWhiteSpace(); // t == "lots of white space" - \endcode + if ( isEmpty() ) // nothing to do + return *this; - \sa stripWhiteSpace() -*/ + register char *s = m_data; + int reslen = length(); + if ( !isspace((uchar) s[0]) && !isspace((uchar) s[reslen-1]) ) + return *this; // returns a copy + + QCString result(s); + s = result.data(); + int start = 0; + int end = reslen - 1; + while ( isspace((uchar) s[start]) ) // skip white space from start + start++; + if ( s[start] == '\0' ) + { // only white space + return QCString(); + } + while ( end && isspace((uchar) s[end]) ) // skip white space from end + end--; + end -= start - 1; + memmove( result.data(), &s[start], end ); + result.resize( end + 1 ); + return result; +} QCString QCString::simplifyWhiteSpace() const { - if ( isEmpty() ) // nothing to do - return copy(); - QCString result( size() ); - char *from = data(); - char *to = result.data(); - char *first = to; - while ( TRUE ) { - while ( *from && isspace((uchar) *from) ) - from++; - while ( *from && !isspace((uchar)*from) ) - *to++ = *from++; - if ( *from ) - *to++ = 0x20; // ' ' - else - break; - } - if ( to > first && *(to-1) == 0x20 ) - to--; - *to = '\0'; - result.resize( (int)((long)to - (long)result.data()) + 1 ); - return result; -} - - -/*! - Insert \e s into the string before position \e index. - - If \e index is beyond the end of the string, the string is extended with - spaces (ASCII 32) to length \e index and \e s is then appended. + if ( isEmpty() ) // nothing to do + return *this; - \code - QCString s = "I like fish"; - s.insert( 2, "don't "); // s == "I don't like fish" - s = "x"; - s.insert( 3, "yz" ); // s == "x yz" - \endcode -*/ + QCString result( length()+1 ); + char *from = data(); + char *to = result.data(); + char *first = to; + while ( TRUE ) + { + while ( *from && isspace((uchar) *from) ) + from++; + while ( *from && !isspace((uchar)*from) ) + *to++ = *from++; + if ( *from ) + *to++ = 0x20; // ' ' + else + break; + } + if ( to > first && *(to-1) == 0x20 ) + to--; + *to = '\0'; + result.resize( (int)((long)to - (long)result.data()) + 1 ); + return result; +} QCString &QCString::insert( uint index, const char *s ) -{ - int len = qstrlen(s); - if ( len == 0 ) - return *this; - uint olen = length(); - int nlen = olen + len; - if ( index >= olen ) { // insert after end of string - detach(); - if ( QByteArray::resize(nlen+index-olen+1) ) { - memset( data()+olen, ' ', index-olen ); - memcpy( data()+index, s, len+1 ); - } - } else if ( QByteArray::resize(nlen+1) ) { // normal insert - detach(); - memmove( data()+index+len, data()+index, olen-index+1 ); - memcpy( data()+index, s, len ); - } +{ + int len = qstrlen(s); + if ( len == 0 ) return *this; + uint olen = length(); + int nlen = olen + len; + if ( index >= olen ) // insert after end of string + { + m_data = (char *)realloc(m_data,nlen+index-olen+1); + if ( m_data ) + { + memset( m_data+olen, ' ', index-olen ); + memcpy( m_data+index, s, len+1 ); + } + } + else if ( (m_data = (char *)realloc(m_data,nlen+1)) ) // normal insert + { + memmove( m_data+index+len, m_data+index, olen-index+1 ); + memcpy( m_data+index, s, len ); + } + return *this; } -/*! - Insert \e c into the string at (before) position \e index and returns - a reference to the string. - - If \e index is beyond the end of the string, the string is extended with - spaces (ASCII 32) to length \e index and \e c is then appended. - - Example: - \code - QCString s = "Yes"; - s.insert( 3, '!'); // s == "Yes!" - \endcode - - \sa remove(), replace() -*/ - -QCString &QCString::insert( uint index, char c ) // insert char +QCString &QCString::insert( uint index, char c ) // insert char { - char buf[2]; - buf[0] = c; - buf[1] = '\0'; - return insert( index, buf ); + char buf[2]; + buf[0] = c; + buf[1] = '\0'; + return insert( index, buf ); } -/*! - \fn QCString &QCString::prepend( const char *s ) - - Prepend \a s to the string. Equivalent to insert(0,s). - - \sa insert() -*/ - -/*! - Removes \e len characters starting at position \e index from the - string and returns a reference to the string. - - If \e index is too big, nothing happens. If \e index is valid, but - \e len is too large, the rest of the string is removed. - - \code - QCString s = "Montreal"; - s.remove( 1, 4 ); - // s == "Meal" - \endcode - - \sa insert(), replace() -*/ - -QCString &QCString::remove( uint index, uint len ) +QCString& QCString::operator+=( const char *str ) { - uint olen = length(); - if ( index + len >= olen ) { // range problems - if ( index < olen ) { // index ok - detach(); - resize( index+1 ); - } - } else if ( len != 0 ) { - detach(); - memmove( data()+index, data()+index+len, olen-index-len+1 ); - QByteArray::resize(olen-len+1); - } - return *this; + if ( !str ) return *this; // nothing to append + uint len1 = length(); + uint len2 = qstrlen(str); + char *newData = (char *)realloc( m_data, len1 + len2 + 1 ); + if (newData) + { + m_data = newData; + memcpy( m_data + len1, str, len2 + 1 ); + } + return *this; } -/*! - Replaces \e len characters starting at position \e index from the - string with \e s, and returns a reference to the string. - - If \e index is too big, nothing is deleted and \e s is inserted at the - end of the string. If \e index is valid, but \e len is too large, \e - str replaces the rest of the string. - - \code - QCString s = "Say yes!"; - s.replace( 4, 3, "NO" ); // s == "Say NO!" - \endcode - - \sa insert(), remove() -*/ - -QCString &QCString::replace( uint index, uint len, const char *s ) -{ - remove( index, len ); - insert( index, s ); - return *this; -} - - -/*! - Finds the first occurrence of the regular expression \e rx, starting at - position \e index. - - Returns the position of the next match, or -1 if \e rx was not found. -*/ - -int QCString::find( const QRegExp &rx, int index ) const +QCString &QCString::operator+=( char c ) { - QString d = QString::fromLatin1( data() ); - return d.find( rx, index ); + uint len = length(); + char *newData = (char *)realloc( m_data, length()+2 ); + if (newData) + { + m_data = newData; + m_data[len] = c; + m_data[len+1] = '\0'; + } + return *this; } -/*! - Finds the first occurrence of the regular expression \e rx, starting at - position \e index and searching backwards. - - The search will start from the end of the string if \e index is negative. - - Returns the position of the next match (backwards), or -1 if \e rx was not - found. -*/ - -int QCString::findRev( const QRegExp &rx, int index ) const +QCString &QCString::remove( uint index, uint len ) { - QString d = QString::fromLatin1( data() ); - return d.findRev( rx, index ); + uint olen = length(); + if ( index + len >= olen ) // range problems + { + if ( index < olen ) // index ok + { + resize( index+1 ); + } + } + else if ( len != 0 ) + { + memmove( m_data+index, m_data+index+len, olen-index-len+1 ); + resize( olen-len+1 ); + } + return *this; } -/*! - Counts the number of overlapping occurrences of \e rx in the string. - - Example: - \code - QString s = "banana and panama"; - QRegExp r = QRegExp("a[nm]a", TRUE, FALSE); - s.contains( r ); // 4 matches - \endcode - - \sa find(), findRev() -*/ - -int QCString::contains( const QRegExp &rx ) const +QCString &QCString::replace( uint index, uint len, const char *s ) { - QString d = QString::fromLatin1( data() ); - return d.contains( rx ); + remove( index, len ); + insert( index, s ); + return *this; } - -/*! - Replaces every occurrence of \e rx in the string with \e str. - Returns a reference to the string. - - Example: - \code - QString s = "banana"; - s.replace( QRegExp("a.*a"), "" ); // becomes "b" - - QString s = "banana"; - s.replace( QRegExp("^[bn]a"), " " ); // becomes " nana" - - QString s = "banana"; - s.replace( QRegExp("^[bn]a"), "" ); // NOTE! becomes "" - \endcode - -*/ - QCString &QCString::replace( const QRegExp &rx, const char *str ) { - QString d = QString::fromLatin1( data() ); - QString r = QString::fromLatin1( str ); - d.replace( rx, r ); - setStr( d.ascii() ); - return *this; + QString d = QString::fromLatin1( m_data ); + QString r = QString::fromLatin1( str ); + d.replace( rx, r ); + operator=( d.ascii() ); + return *this; } -/*! - Returns the string converted to a <code>long</code> value. - - If \e ok is non-null, \e *ok is set to TRUE if there are no - conceivable errors, and FALSE if the string is not a number at all, or if - it has trailing garbage. -*/ - -long QCString::toLong( bool *ok ) const +long QCString::toLong( bool *ok ) const { - char *p = data(); - long val=0; - const long max_mult = 214748364; - bool is_ok = FALSE; - int neg = 0; - if ( !p ) - goto bye; - while ( isspace((uchar)*p) ) // skip leading space - p++; - if ( *p == '-' ) { - p++; - neg = 1; - } else if ( *p == '+' ) { - p++; - } - if ( !isdigit((uchar)*p) ) - goto bye; - while ( isdigit((uchar)*p) ) { - if ( val > max_mult || (val == max_mult && (*p-'0') > 7+neg) ) - goto bye; - val = 10*val + (*p++ - '0'); - } - if ( neg ) - val = -val; - while ( isspace((uchar)*p) ) // skip trailing space - p++; - if ( *p == '\0' ) - is_ok = TRUE; -bye: - if ( ok ) - *ok = is_ok; - return is_ok ? val : 0; + QString s(m_data); + return s.toLong(ok); } -/*! - Returns the string converted to an <code>unsigned long</code> - value. - - If \e ok is non-null, \e *ok is set to TRUE if there are no - conceivable errors, and FALSE if the string is not a number at all, - or if it has trailing garbage. -*/ - ulong QCString::toULong( bool *ok ) const { - char *p = data(); - ulong val=0; - const ulong max_mult = 429496729; - bool is_ok = FALSE; - if ( !p ) - goto bye; - while ( isspace((uchar)*p) ) // skip leading space - p++; - if ( *p == '+' ) - p++; - if ( !isdigit((uchar)*p) ) - goto bye; - while ( isdigit((uchar)*p) ) { - if ( val > max_mult || (val == max_mult && (*p-'0') > 5) ) - goto bye; - val = 10*val + (*p++ - '0'); - } - while ( isspace((uchar)*p) ) // skip trailing space - p++; - if ( *p == '\0' ) - is_ok = TRUE; -bye: - if ( ok ) - *ok = is_ok; - return is_ok ? val : 0; + QString s(m_data); + return s.toULong(ok); } -/*! - Returns the string converted to a <code>short</code> value. - - If \e ok is non-null, \e *ok is set to TRUE if there are no - conceivable errors, and FALSE if the string is not a number at all, or if - it has trailing garbage. -*/ - -short QCString::toShort( bool *ok ) const +short QCString::toShort( bool *ok ) const { - long v = toLong( ok ); - if ( ok && *ok && (v < -32768 || v > 32767) ) - *ok = FALSE; - return (short)v; + QString s(m_data); + return s.toShort(ok); } -/*! - Returns the string converted to an <code>unsigned short</code> value. - - If \e ok is non-null, \e *ok is set to TRUE if there are no - conceivable errors, and FALSE if the string is not a number at all, or if - it has trailing garbage. -*/ - ushort QCString::toUShort( bool *ok ) const { - ulong v = toULong( ok ); - if ( ok && *ok && (v > 65535) ) - *ok = FALSE; - return (ushort)v; + QString s(m_data); + return s.toUShort(ok); } - -/*! - Returns the string converted to a <code>int</code> value. - - If \e ok is non-null, \e *ok is set to TRUE if there are no - conceivable errors, and FALSE if the string is not a number at all, - or if it has trailing garbage. -*/ - int QCString::toInt( bool *ok ) const { - return (int)toLong( ok ); + QString s(m_data); + return s.toInt(ok); } -/*! - Returns the string converted to an <code>unsigned int</code> value. - - If \e ok is non-null, \e *ok is set to TRUE if there are no - conceivable errors, and FALSE if the string is not a number at all, - or if it has trailing garbage. -*/ - uint QCString::toUInt( bool *ok ) const { - return (uint)toULong( ok ); + QString s(m_data); + return s.toUInt(ok); } -/*! - Returns the string converted to a <code>double</code> value. - - If \e ok is non-null, \e *ok is set to TRUE if there are no conceivable - errors, and FALSE if the string is not a number at all, or if it has - trailing garbage. -*/ - -double QCString::toDouble( bool *ok ) const +QCString &QCString::setNum( long n ) { - char *end; - double val = strtod( data() ? data() : "", &end ); - if ( ok ) - *ok = ( data() && *data() && ( end == 0 || *end == '\0' ) ); - return val; + char buf[20]; + register char *p = &buf[19]; + bool neg; + if ( n < 0 ) + { + neg = TRUE; + n = -n; + } + else + { + neg = FALSE; + } + *p = '\0'; + do + { + *--p = ((int)(n%10)) + '0'; + n /= 10; + } while ( n ); + if ( neg ) *--p = '-'; + operator=( p ); + return *this; } -/*! - Returns the string converted to a <code>float</code> value. - - If \e ok is non-null, \e *ok is set to TRUE if there are no - conceivable errors, and FALSE if the string is not a number at all, - or if it has trailing garbage. -*/ - -float QCString::toFloat( bool *ok ) const +QCString &QCString::setNum( ulong n ) { - return (float)toDouble( ok ); + char buf[20]; + register char *p = &buf[19]; + *p = '\0'; + do + { + *--p = ((int)(n%10)) + '0'; + n /= 10; + } while ( n ); + operator=( p ); + return *this; } +void QCString::msg_index( uint index ) +{ +#if defined(CHECK_RANGE) + qWarning( "QCString::at: Absolute index %d out of range", index ); +#else + Q_UNUSED( index ) +#endif +} -/*! - Makes a deep copy of \e str. - Returns a reference to the string. -*/ - -QCString &QCString::setStr( const char *str ) +bool QCString::stripPrefix(const char *prefix) { - detach(); - if ( str ) // valid string - store( str, qstrlen(str)+1 ); - else // empty - resize( 0 ); - return *this; + if (prefix==0) return FALSE; + uint plen = qstrlen(prefix); + if (m_data && qstrncmp(prefix,m_data,plen)==0) // prefix matches + { + uint len = qstrlen(m_data); + uint newlen = len-plen+1; + qmemmove(m_data,m_data+plen,newlen); + resize(newlen); + return TRUE; + } + return FALSE; } -/*! - Sets the string to the printed value of \e n and returns a - reference to the string. -*/ +//--------------------------------------------------------------------------- -QCString &QCString::setNum( long n ) +void *qmemmove( void *dst, const void *src, uint len ) { - detach(); - char buf[20]; - register char *p = &buf[19]; - bool neg; - if ( n < 0 ) { - neg = TRUE; - n = -n; - } else { - neg = FALSE; + register char *d; + register char *s; + if ( dst > src ) { + d = (char *)dst + len - 1; + s = (char *)src + len - 1; + while ( len-- ) + *d-- = *s--; + } else if ( dst < src ) { + d = (char *)dst; + s = (char *)src; + while ( len-- ) + *d++ = *s++; } - *p = '\0'; - do { - *--p = ((int)(n%10)) + '0'; - n /= 10; - } while ( n ); - if ( neg ) - *--p = '-'; - store( p, qstrlen(p)+1 ); - return *this; + return dst; } -/*! - Sets the string to the printed unsigned value of \e n and - returns a reference to the string. -*/ - -QCString &QCString::setNum( ulong n ) +char *qstrdup( const char *str ) { - detach(); - char buf[20]; - register char *p = &buf[19]; - *p = '\0'; - do { - *--p = ((int)(n%10)) + '0'; - n /= 10; - } while ( n ); - store( p, qstrlen(p)+1 ); - return *this; + if ( !str ) + return 0; + char *dst = new char[strlen(str)+1]; + CHECK_PTR( dst ); + return strcpy( dst, str ); } -/*! - \fn QCString &QCString::setNum( int n ) - Sets the string to the printed value of \e n and returns a reference - to the string. -*/ - -/*! - \fn QCString &QCString::setNum( uint n ) - Sets the string to the printed unsigned value of \e n and returns a - reference to the string. -*/ - -/*! - \fn QCString &QCString::setNum( short n ) - Sets the string to the printed value of \e n and returns a reference - to the string. -*/ - -/*! - \fn QCString &QCString::setNum( ushort n ) - Sets the string to the printed unsigned value of \e n and returns a - reference to the string. -*/ - -/*! - Sets the string to the printed value of \e n. - - \arg \e f is the format specifier: 'f', 'F', 'e', 'E', 'g', 'G' (same - as sprintf()). - \arg \e prec is the precision. - - Returns a reference to the string. -*/ - -QCString &QCString::setNum( double n, char f, int prec ) +char *qstrncpy( char *dst, const char *src, uint len ) { -#if defined(CHECK_RANGE) - if ( !(f=='f' || f=='F' || f=='e' || f=='E' || f=='g' || f=='G') ) - qWarning( "QCString::setNum: Invalid format char '%c'", f ); -#endif - char format[20]; - register char *fs = format; // generate format string - *fs++ = '%'; // "%.<prec>l<f>" - if ( prec > 99 ) - prec = 99; - *fs++ = '.'; - if ( prec >= 10 ) { - *fs++ = prec / 10 + '0'; - *fs++ = prec % 10 + '0'; - } else { - *fs++ = prec + '0'; - } - *fs++ = 'l'; - *fs++ = f; - *fs = '\0'; - return sprintf( format, n ); + if ( !src ) + return 0; + strncpy( dst, src, len ); + if ( len > 0 ) + dst[len-1] = '\0'; + return dst; } -/*! - \fn QCString &QCString::setNum( float n, char f, int prec ) - Sets the string to the printed value of \e n. - - \arg \e f is the format specifier: 'f', 'F', 'e', 'E', 'g', 'G' (same - as sprintf()). - \arg \e prec is the precision. - - Returns a reference to the string. -*/ - - -/*! - Sets the character at position \e index to \e c and expands the - string if necessary, filling with spaces. - - Returns FALSE if this \e index was out of range and the string could - not be expanded, otherwise TRUE. -*/ +int qstricmp( const char *str1, const char *str2 ) +{ + register const uchar *s1 = (const uchar *)str1; + register const uchar *s2 = (const uchar *)str2; + int res; + uchar c; + if ( !s1 || !s2 ) + return s1 == s2 ? 0 : (int)((long)s2 - (long)s1); + for ( ; !(res = (c=tolower(*s1)) - tolower(*s2)); s1++, s2++ ) + if ( !c ) // strings are equal + break; + return res; +} -bool QCString::setExpand( uint index, char c ) +int qstrnicmp( const char *str1, const char *str2, uint len ) { - detach(); - uint oldlen = length(); - if ( index >= oldlen ) { - if ( !QByteArray::resize( index+2 ) ) // no memory - return FALSE; - if ( index > oldlen ) - memset( data() + oldlen, ' ', index - oldlen ); - *(data() + index+1) = '\0'; // terminate padded string + register const uchar *s1 = (const uchar *)str1; + register const uchar *s2 = (const uchar *)str2; + int res; + uchar c; + if ( !s1 || !s2 ) + return (int)((long)s2 - (long)s1); + for ( ; len--; s1++, s2++ ) { + if ( (res = (c=tolower(*s1)) - tolower(*s2)) ) + return res; + if ( !c ) // strings are equal + break; } - *(data() + index) = c; - return TRUE; + return 0; } +#ifndef QT_NO_DATASTREAM -/*! - \fn QCString::operator const char *() const - Returns the string data. -*/ - - -/*! - \fn QCString& QCString::append( const char *str ) - Appends \e str to the string and returns a reference to the string. - Equivalent to operator+=(). - */ - -/*! - Appends \e str to the string and returns a reference to the string. -*/ - -QCString& QCString::operator+=( const char *str ) +QDataStream &operator<<( QDataStream &s, const QByteArray &a ) { - if ( !str ) - return *this; // nothing to append - detach(); - uint len1 = length(); - uint len2 = qstrlen(str); - if ( !QByteArray::resize( len1 + len2 + 1 ) ) - return *this; // no memory - memcpy( data() + len1, str, len2 + 1 ); - return *this; + return s.writeBytes( a.data(), a.size() ); } -/*! - Appends \e c to the string and returns a reference to the string. -*/ - -QCString &QCString::operator+=( char c ) +QDataStream &operator>>( QDataStream &s, QByteArray &a ) { - detach(); - uint len = length(); - if ( !QByteArray::resize( len + 2 ) ) - return *this; // no memory - *(data() + len) = c; - *(data() + len+1) = '\0'; - return *this; + Q_UINT32 len; + s >> len; // read size of array + if ( len == 0 || s.eof() ) { // end of file reached + a.resize( 0 ); + return s; + } + if ( !a.resize( (uint)len ) ) { // resize array +#if defined(CHECK_NULL) + qWarning( "QDataStream: Not enough memory to read QByteArray" ); +#endif + len = 0; + } + if ( len > 0 ) // not null array + s.readRawBytes( a.data(), (uint)len ); + return s; } - -/***************************************************************************** - QCString stream functions - *****************************************************************************/ -#ifndef QT_NO_DATASTREAM -/*! - \relates QCString - Writes a string to the stream. - - \sa \link datastreamformat.html Format of the QDataStream operators \endlink -*/ QDataStream &operator<<( QDataStream &s, const QCString &str ) { return s.writeBytes( str.data(), str.size() ); } -/*! - \relates QCString - Reads a string from the stream. - - \sa \link datastreamformat.html Format of the QDataStream operators \endlink -*/ - QDataStream &operator>>( QDataStream &s, QCString &str ) { - str.detach(); Q_UINT32 len; s >> len; // read size of string if ( len == 0 || s.eof() ) { // end of file reached str.resize( 0 ); return s; } - if ( !str.QByteArray::resize( (uint)len )) {// resize string + if ( !str.resize( (uint)len )) {// resize string #if defined(CHECK_NULL) qWarning( "QDataStream: Not enough memory to read QCString" ); #endif @@ -1764,154 +775,20 @@ QDataStream &operator>>( QDataStream &s, QCString &str ) s.readRawBytes( str.data(), (uint)len ); return s; } -#endif //QT_NO_DATASTREAM - -/***************************************************************************** - Documentation for related functions - *****************************************************************************/ -/*! - \fn bool operator==( const QCString &s1, const QCString &s2 ) - \relates QCString - Returns TRUE if the two strings are equal, or FALSE if they are different. - - Equivalent to <code>qstrcmp(s1,s2) == 0</code>. -*/ +#endif //QT_NO_DATASTREAM -/*! - \fn bool operator==( const QCString &s1, const char *s2 ) - \relates QCString - Returns TRUE if the two strings are equal, or FALSE if they are different. +inline QCString operator+( const QCString &s1, const QGString &s2 ) +{ + QCString tmp(s1); + tmp += s2.data(); + return tmp; +} - Equivalent to <code>qstrcmp(s1,s2) == 0</code>. -*/ +inline QCString operator+( const QGString &s1, const QCString &s2 ) +{ + QCString tmp(s1.data()); + tmp += s2; + return tmp; +} -/*! - \fn bool operator==( const char *s1, const QCString &s2 ) - \relates QCString - Returns TRUE if the two strings are equal, or FALSE if they are different. - - Equivalent to <code>qstrcmp(s1,s2) == 0</code>. -*/ - -/*! - \fn bool operator!=( const QCString &s1, const QCString &s2 ) - \relates QCString - Returns TRUE if the two strings are different, or FALSE if they are equal. - - Equivalent to <code>qstrcmp(s1,s2) != 0</code>. -*/ - -/*! - \fn bool operator!=( const QCString &s1, const char *s2 ) - \relates QCString - Returns TRUE if the two strings are different, or FALSE if they are equal. - - Equivalent to <code>qstrcmp(s1,s2) != 0</code>. -*/ - -/*! - \fn bool operator!=( const char *s1, const QCString &s2 ) - \relates QCString - Returns TRUE if the two strings are different, or FALSE if they are equal. - - Equivalent to <code>qstrcmp(s1,s2) != 0</code>. -*/ - -/*! - \fn bool operator<( const QCString &s1, const char *s2 ) - \relates QCString - Returns TRUE if \e s1 is alphabetically less than \e s2, otherwise FALSE. - - Equivalent to <code>qstrcmp(s1,s2) \< 0</code>. -*/ - -/*! - \fn bool operator<( const char *s1, const QCString &s2 ) - \relates QCString - Returns TRUE if \e s1 is alphabetically less than \e s2, otherwise FALSE. - - Equivalent to <code>qstrcmp(s1,s2) \< 0</code>. -*/ - -/*! - \fn bool operator<=( const QCString &s1, const char *s2 ) - \relates QCString - Returns TRUE if \e s1 is alphabetically less than or equal to \e s2, - otherwise FALSE. - - Equivalent to <code>qstrcmp(s1,s2) \<= 0</code>. -*/ - -/*! - \fn bool operator<=( const char *s1, const QCString &s2 ) - \relates QCString - Returns TRUE if \e s1 is alphabetically less than or equal to \e s2, - otherwise FALSE. - - Equivalent to <code>qstrcmp(s1,s2) \<= 0</code>. -*/ - -/*! - \fn bool operator>( const QCString &s1, const char *s2 ) - \relates QCString - Returns TRUE if \e s1 is alphabetically greater than \e s2, otherwise FALSE. - - Equivalent to <code>qstrcmp(s1,s2) \> 0</code>. -*/ - -/*! - \fn bool operator>( const char *s1, const QCString &s2 ) - \relates QCString - Returns TRUE if \e s1 is alphabetically greater than \e s2, otherwise FALSE. - - Equivalent to <code>qstrcmp(s1,s2) \> 0</code>. -*/ - -/*! - \fn bool operator>=( const QCString &s1, const char *s2 ) - \relates QCString - Returns TRUE if \e s1 is alphabetically greater than or equal to \e s2, - otherwise FALSE. - - Equivalent to <code>qstrcmp(s1,s2) \>= 0</code>. -*/ - -/*! - \fn bool operator>=( const char *s1, const QCString &s2 ) - \relates QCString - Returns TRUE if \e s1 is alphabetically greater than or equal to \e s2, - otherwise FALSE. - - Equivalent to <code>qstrcmp(s1,s2) \>= 0</code>. -*/ - -/*! - \fn QCString operator+( const QCString &s1, const QCString &s2 ) - \relates QCString - Returns the concatenated string of s1 and s2. -*/ - -/*! - \fn QCString operator+( const QCString &s1, const char *s2 ) - \relates QCString - Returns the concatenated string of s1 and s2. -*/ - -/*! - \fn QCString operator+( const char *s1, const QCString &s2 ) - \relates QCString - Returns the concatenated string of s1 and s2. -*/ - -/*! - \fn QCString operator+( const QCString &s, char c ) - \relates QCString - Returns the concatenated string of s and c. -*/ - -/*! - \fn QCString operator+( char c, const QCString &s ) - \relates QCString - Returns the concatenated string of c and s. -*/ |