Release-1.3.9.1-20041206 (71de527e) · Commits · Elphel / doxverilog

qtools/scstring.cpp

0 → 100644

+770 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* 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"
		#ifndef SMALLSTRING
		#include "qcstring.cpp"
		#else

		#include <qstring.h>
		#include <stdlib.h>
		#include <stdio.h>
		#include <stdarg.h>
		#include <ctype.h>
		#include <qregexp.h>
		#include <qdatastream.h>


		SCString::SCString(int size)
		{
		if (size>0)
		{
		m_data = (char *)malloc(size);
		if (m_data)
		{
		m_data[0]='\0';
		m_data[size-1]='\0';
		}
		}
		else
		{
		m_data=0;
		}
		}

		SCString::SCString( const SCString &s )
		{
		duplicate(s);
		}

		SCString::SCString( const char *str )
		{
		duplicate(str);
		}

		SCString::SCString( 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;
		}
		}

		SCString::~SCString()
		{
		if (m_data) free(m_data);
		m_data=0;
		}

		SCString &SCString::assign( const char *str )
		{
		if (m_data) free(m_data);
		duplicate(str);
		return *this;
		}

		bool SCString::resize( uint newlen )
		{
		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;
		}

		bool SCString::fill( char c, int len )
		{
		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;
		}

		SCString &SCString::sprintf( const char *format, ... )
		{
		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;
		}


		int SCString::find( char c, int index, bool cs ) const
		{
		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;
		}

		int SCString::find( const char *str, int index, bool cs ) const
		{
		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++;
		}
		if ( !*d ) // not found
		d = 0;
		}
		return d ? (int)(d - m_data) : -1;
		}

		int SCString::find( const QRegExp &rx, int index ) const
		{
		QString d = QString::fromLatin1( m_data );
		return d.find( rx, index );
		}

		int SCString::findRev( char c, int index, bool cs) const
		{
		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 SCString::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;

		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 SCString::findRev( const QRegExp &rx, int index ) const
		{
		QString d = QString::fromLatin1( m_data );
		return d.findRev( rx, index );
		}

		int SCString::contains( char c, bool cs ) const
		{
		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;
		}

		int SCString::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;
		}

		int SCString::contains( const QRegExp &rx ) const
		{
		QString d = QString::fromLatin1( m_data );
		return d.contains( rx );
		}

		SCString SCString::left( uint len ) const
		{
		if ( isEmpty() )
		{
		return SCString();
		}
		else if ( len >= length() )
		{
		return *this;
		}
		else
		{
		SCString s( len+1 );
		strncpy( s.data(), m_data, len );
		*(s.data()+len) = '\0';
		return s;
		}
		}

		SCString SCString::right( uint len ) const
		{
		if ( isEmpty() )
		{
		return SCString();
		}
		else
		{
		uint l = length();
		if ( len > l ) len = l;
		char *p = m_data + (l - len);
		return SCString( p );
		}
		}

		SCString SCString::mid( uint index, uint len) const
		{
		uint slen = length();
		if ( len == 0xffffffff ) len = slen-index;
		if ( isEmpty() \|\| index >= slen )
		{
		return SCString();
		}
		else
		{
		register char *p = data()+index;
		SCString s( len+1 );
		strncpy( s.data(), p, len );
		*(s.data()+len) = '\0';
		return s;
		}
		}

		SCString SCString::lower() const
		{
		SCString s( m_data );
		register char *p = s.data();
		if ( p )
		{
		while ( *p )
		{
		p = tolower((uchar) p);
		p++;
		}
		}
		return s;
		}

		SCString SCString::upper() const
		{
		SCString s( m_data );
		register char *p = s.data();
		if ( p ) {
		while ( *p ) {
		p = toupper((uchar)p);
		p++;
		}
		}
		return s;
		}

		SCString SCString::stripWhiteSpace() const
		{
		if ( isEmpty() ) // nothing to do
		return *this;

		register char *s = m_data;
		int reslen = length();
		if ( !isspace((uchar) s[0]) && !isspace((uchar) s[reslen-1]) )
		return *this; // returns a copy

		SCString 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 SCString();
		}
		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;
		}

		SCString SCString::simplifyWhiteSpace() const
		{
		if ( isEmpty() ) // nothing to do
		return *this;

		SCString 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;
		}

		SCString &SCString::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
		{
		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;
		}

		SCString &SCString::insert( uint index, char c ) // insert char
		{
		char buf[2];
		buf[0] = c;
		buf[1] = '\0';
		return insert( index, buf );
		}

		SCString& SCString::operator+=( const char *str )
		{
		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;
		}

		SCString &SCString::operator+=( char c )
		{
		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;
		}

		SCString &SCString::remove( uint index, uint len )
		{
		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;
		}

		SCString &SCString::replace( uint index, uint len, const char *s )
		{
		remove( index, len );
		insert( index, s );
		return *this;
		}

		SCString &SCString::replace( const QRegExp &rx, const char *str )
		{
		QString d = QString::fromLatin1( m_data );
		QString r = QString::fromLatin1( str );
		d.replace( rx, r );
		operator=( d.ascii() );
		return *this;
		}

		long SCString::toLong( bool *ok ) const
		{
		QString s(m_data);
		return s.toLong(ok);
		}

		ulong SCString::toULong( bool *ok ) const
		{
		QString s(m_data);
		return s.toULong(ok);
		}

		short SCString::toShort( bool *ok ) const
		{
		QString s(m_data);
		return s.toShort(ok);
		}

		ushort SCString::toUShort( bool *ok ) const
		{
		QString s(m_data);
		return s.toUShort(ok);
		}

		int SCString::toInt( bool *ok ) const
		{
		QString s(m_data);
		return s.toInt(ok);
		}

		uint SCString::toUInt( bool *ok ) const
		{
		QString s(m_data);
		return s.toUInt(ok);
		}

		SCString &SCString::setNum( long n )
		{
		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;
		}

		SCString &SCString::setNum( ulong n )
		{
		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 SCString::msg_index( uint index )
		{
		#if defined(CHECK_RANGE)
		qWarning( "SCString::at: Absolute index %d out of range", index );
		#else
		Q_UNUSED( index )
		#endif
		}

		//---------------------------------------------------------------------------

		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;
		}

		char qstrdup( const char str )
		{
		if ( !str )
		return 0;
		char *dst = new char[strlen(str)+1];
		CHECK_PTR( dst );
		return strcpy( dst, str );
		}

		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;
		}

		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;
		}

		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;
		}

		#ifndef QT_NO_DATASTREAM

		QDataStream &operator<<( QDataStream &s, const QByteArray &a )
		{
		return s.writeBytes( a.data(), a.size() );
		}

		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;
		}

		QDataStream &operator<<( QDataStream &s, const SCString &str )
		{
		return s.writeBytes( str.data(), str.size() );
		}

		QDataStream &operator>>( QDataStream &s, SCString &str )
		{
		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.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



		#endif

qtools/scstring.h

0 → 100644

+152 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* 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.
		*
		*/

		#ifndef SCSTRING_H
		#define SCSTRING_H

		#include <stdlib.h>

		class QRegExp;

		/** This is an alternative implementation of QCString. It provides basically
		* the same functions but uses less memory for administration. This class
		* is just a wrapper around a plain C string requiring only 4 bytes "overhead".
		* QCString features sharing of data and stores the string length, but
		* requires 4 + 12 bytes for this (even for the empty string). As doxygen
		* uses a LOT of string during a run it saves a lot of memory to use a
		* more memory efficient implementation at the cost of relatively low
		* runtime overhead.
		*/
		class SCString
		{
		public:
		SCString() : m_data(0) {} // make null string
		SCString( const SCString &s );
		SCString( int size );
		SCString( const char *str );
		SCString( const char *str, uint maxlen );
		~SCString();

		SCString &operator=( const SCString &s );// deep copy
		SCString &operator=( const char *str ); // deep copy

		bool isNull() const;
		bool isEmpty() const;
		uint length() const;
		uint size() const { return m_data ? length()+1 : 0; }
		char * data() const { return m_data; }
		bool resize( uint newlen );
		bool truncate( uint pos );
		bool fill( char c, int len = -1 );

		SCString copy() const;

		SCString &sprintf( const char *format, ... );

		int find( char c, int index=0, bool cs=TRUE ) const;
		int find( const char *str, int index=0, bool cs=TRUE ) const;
		int find( const QRegExp &, int index=0 ) const;
		int findRev( char c, int index=-1, bool cs=TRUE) const;
		int findRev( const char *str, int index=-1, bool cs=TRUE) const;
		int findRev( const QRegExp &, int index=-1 ) const;
		int contains( char c, bool cs=TRUE ) const;
		int contains( const char *str, bool cs=TRUE ) const;
		int contains( const QRegExp & ) const;

		SCString left( uint len ) const;
		SCString right( uint len ) const;
		SCString mid( uint index, uint len=0xffffffff) const;

		SCString lower() const;
		SCString upper() const;

		SCString stripWhiteSpace() const;
		SCString simplifyWhiteSpace() const;

		SCString &assign( const char *str );
		SCString &insert( uint index, const char * );
		SCString &insert( uint index, char );
		SCString &append( const char *s );
		SCString &prepend( const char *s );
		SCString &remove( uint index, uint len );
		SCString &replace( uint index, uint len, const char * );
		SCString &replace( const QRegExp &, const char * );

		short toShort( bool *ok=0 ) const;
		ushort toUShort( bool *ok=0 ) const;
		int toInt( bool *ok=0 ) const;
		uint toUInt( bool *ok=0 ) const;
		long toLong( bool *ok=0 ) const;
		ulong toULong( bool *ok=0 ) const;

		SCString &setNum( short );
		SCString &setNum( ushort );
		SCString &setNum( int );
		SCString &setNum( uint );
		SCString &setNum( long );
		SCString &setNum( ulong );
		QCString &setNum( float, char f='g', int prec=6 );
		QCString &setNum( double, char f='g', int prec=6 );

		operator const char *() const;
		SCString &operator+=( const char *str );
		SCString &operator+=( char c );
		char &at( uint index ) const;
		char &operator[]( int i ) const { return at(i); }

		private:
		static void msg_index( uint );
		void duplicate( const SCString &s );
		void duplicate( const char *str);
		SCString &duplicate( const char *str, int);

		char * m_data;
		};

		inline char &SCString::at( uint index ) const
		{
		return m_data[index];
		}

		inline void SCString::duplicate( const SCString &s )
		{
		if (!s.isEmpty())
		{
		uint l = strlen(s.data());
		m_data = (char *)malloc(l+1);
		if (m_data) memcpy(m_data,s.data(),l+1);
		}
		else
		m_data=0;
		}
		inline void SCString::duplicate( const char *str)
		{
		if (str && str[0]!='\0')
		{
		uint l = strlen(str);
		m_data = (char *)malloc(l+1);
		if (m_data) memcpy(m_data,str,l+1);
		}
		else
		m_data=0;
		}
		inline SCString &SCString::duplicate( const char *str, int)
		{
		duplicate(str);
		return *this;
		}

		#endif