Release-1.2.2-20001015

1 files changed, 1917 insertions, 0 deletions

diff --git a/qtools/qcstring.cpp b/qtools/qcstring.cpp
new file mode 100644
index 0000000..77dc386
--- /dev/null
+++ b/qtools/qcstring.cpp
@@ -0,0 +1,1917 @@
+/****************************************************************************
+** 
+**
+** 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"
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <ctype.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 == s1 ? 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
+{
+    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;
+    }
+}
+
+/*!
+  \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);
+}
+
+
+/*****************************************************************************
+  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() );
+}
+
+/*!
+  \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;
+}
+
+#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 )
+{
+    if ( size > 0 ) {
+	*data() = '\0';				// set terminator
+	*(data()+(size-1)) = '\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 )
+{
+    duplicate( str, qstrlen(str) + 1 );
+}
+
+
+/*!
+  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 )
+{
+    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';
+    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, ... )
+{
+    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;
+}
+
+
+/*!
+  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 )
+{
+    detach();
+    if ( len < 0 )
+	len = length();
+    if ( !QByteArray::fill(c,len+1) )
+	return FALSE;
+    *(data()+len) = '\0';
+    return TRUE;
+}
+
+
+/*!
+  \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( c );
+	while ( *d && tolower(*d) != c )
+	    d++;
+	if ( !*d && c )				// not found
+	    d = 0;
+    }
+    return d ? (int)(d - 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;
+    }
+    return d ? (int)(d - 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
+{
+    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( c );
+	while ( d >= b && tolower(*d) != c )
+	    d--;
+    }
+    return d >= b ? (int)(d - b) : -1;
+}
+
+/*!
+  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 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;
+    }
+    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.
+*/
+
+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( c );
+	while ( *d ) {
+	    if ( tolower(*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 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 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
+{
+    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;
+    }
+}
+
+/*!
+  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
+{
+    if ( isEmpty() ) {
+	QCString empty;
+	return empty;
+    } else {
+	uint l = length();
+	if ( len > l )
+	    len = l;
+	char *p = data() + (l - len);
+	return QCString( p );
+    }
+}
+
+/*!
+  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;
+    }
+}
+
+/*!
+  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 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;
+}
+
+/*!
+  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 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;
+}
+
+/*!
+  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(*p);
+	    p++;
+	}
+    }
+    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(*p);
+	    p++;
+	}
+    }
+    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
+{
+    if ( isEmpty() )				// nothing to do
+	return copy();
+
+    register char *s = data();
+    QCString result = s;
+    int reslen = result.length();
+    if ( !isspace(s[0]) && !isspace(s[reslen-1]) )
+	return result;				// returns a copy
+
+    s = result.data();
+    int start = 0;
+    int end = reslen - 1;
+    while ( isspace(s[start]) )			// skip white space from start
+	start++;
+    if ( s[start] == '\0' ) {			// only white space
+	result.resize( 1 );
+	return result;
+    }
+    while ( end && isspace(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
+
+  \sa stripWhiteSpace()
+*/
+
+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(*from) )
+	    from++;
+	while ( *from && !isspace(*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.
+
+  \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 &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 );
+    }
+    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
+{
+    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 )
+{
+    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;
+}
+
+/*!
+  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
+{
+    QString d = QString::fromLatin1( data() );
+    return d.find( rx, index );
+}
+
+/*!
+  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
+{
+    QString d = QString::fromLatin1( data() );
+    return d.findRev( rx, index );
+}
+
+/*!
+  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
+{
+    QString d = QString::fromLatin1( data() );
+    return d.contains( rx );
+}
+
+
+/*!
+  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;
+}
+
+/*!
+  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
+{
+    char *p = data();
+    long val=0;
+    const long max_mult = 214748364;
+    bool is_ok = FALSE;
+    int neg = 0;
+    if ( !p )
+	goto bye;
+    while ( isspace(*p) )			// skip leading space
+	p++;
+    if ( *p == '-' ) {
+	p++;
+	neg = 1;
+    } else if ( *p == '+' ) {
+	p++;
+    }
+    if ( !isdigit(*p) )
+	goto bye;
+    while ( isdigit(*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(*p) )			// skip trailing space
+	p++;
+    if ( *p == '\0' )
+	is_ok = TRUE;
+bye:
+    if ( ok )
+	*ok = is_ok;
+    return is_ok ? val : 0;
+}
+
+/*!
+  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(*p) )			// skip leading space
+	p++;
+    if ( *p == '+' )
+	p++;
+    if ( !isdigit(*p) )
+	goto bye;
+    while ( isdigit(*p) ) {
+	if ( val > max_mult || (val == max_mult && (*p-'0') > 5) )
+	    goto bye;
+	val = 10*val + (*p++ - '0');
+    }
+    while ( isspace(*p) )			// skip trailing space
+	p++;
+    if ( *p == '\0' )
+	is_ok = TRUE;
+bye:
+    if ( ok )
+	*ok = is_ok;
+    return is_ok ? val : 0;
+}
+
+/*!
+  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
+{
+    long v = toLong( ok );
+    if ( ok && *ok && (v < -32768 || v > 32767) )
+	*ok = FALSE;
+    return (short)v;
+}
+
+/*!
+  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;
+}
+
+
+/*!
+  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 );
+}
+
+/*!
+  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 );
+}
+
+/*!
+  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
+{
+    char *end;
+    double val = strtod( data() ? data() : "", &end );
+    if ( ok )
+	*ok = ( data() && *data() && ( end == 0 || *end == '\0' ) );
+    return val;
+}
+
+/*!
+  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
+{
+    return (float)toDouble( ok );
+}
+
+
+/*!
+  Makes a deep copy of \e str.
+  Returns a reference to the string.
+*/
+
+QCString &QCString::setStr( const char *str )
+{
+    detach();
+    if ( str )					// valid string
+	store( str, qstrlen(str)+1 );
+    else					// empty
+	resize( 0 );
+    return *this;
+}
+
+/*!
+  Sets the string to the printed value of \e n and returns a
+  reference to the string.
+*/
+
+QCString &QCString::setNum( long n )
+{
+    detach();
+    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 = '-';
+    store( p, qstrlen(p)+1 );
+    return *this;
+}
+
+/*!
+  Sets the string to the printed unsigned value of \e n and
+  returns a reference to the string.
+*/
+
+QCString &QCString::setNum( ulong n )
+{
+    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;
+}
+
+/*!
+  \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 )
+{
+#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 );
+}
+
+/*!
+  \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.
+*/
+
+bool QCString::setExpand( uint index, char c )
+{
+    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
+    }
+    *(data() + index) = c;
+    return TRUE;
+}
+
+
+/*!
+  \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 )
+{
+    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;
+}
+
+/*!
+  Appends \e c to the string and returns a reference to the string.
+*/
+
+QCString &QCString::operator+=( char c )
+{
+    detach();
+    uint len = length();
+    if ( !QByteArray::resize( len + 2 ) )
+	return *this;				// no memory
+    *(data() + len) = c;
+    *(data() + len+1) = '\0';
+    return *this;
+}
+
+
+/*****************************************************************************
+  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 defined(CHECK_NULL)
+	qWarning( "QDataStream: Not enough memory to read QCString" );
+#endif
+	len = 0;
+    }
+    if ( len > 0 )				// not null array
+	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>.
+*/
+
+/*!
+  \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.
+
+  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 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.
+*/