- solve problems with padded memory - dont use memcpy

2 files changed, 157 insertions, 123 deletions

diff --git a/library/quuid.cpp b/library/quuid.cpp
index 46fd816..36469a8 100644
--- a/library/quuid.cpp
+++ b/library/quuid.cpp
@@ -48,58 +48,67 @@
 
 /*!
   \fn QUuid::QUuid( const QUuid &orig )
 
   Creates a copy of the QUuid \a orig.
 */
+
 #ifndef QT_NO_QUUID_STRING
+
 /*!
   Creates a QUuid object from the string \a text. Right now, the function
   can only convert the format {12345678-1234-1234-1234-123456789ABC} and
   will create the null UUID when the conversion fails.
 */
 QUuid::QUuid( const QString &text )
 {
     bool ok;
     QString temp = text.upper();
 
     data1 = temp.mid( 1, 8 ).toULong( &ok, 16 );
-    if ( !ok ) {
-	*this = QUuid();
-	return;
+    if ( !ok )
+    {
+        *this = QUuid();
+        return;
     }
 
     data2 = temp.mid( 10, 4 ).toUInt( &ok, 16 );
-    if ( !ok ) {
-	*this = QUuid();
-	return;
+    if ( !ok )
+    {
+        *this = QUuid();
+        return;
     }
     data3 = temp.mid( 15, 4 ).toUInt( &ok, 16 );
-    if ( !ok ) {
-	*this = QUuid();
-	return;
+    if ( !ok )
+    {
+        *this = QUuid();
+        return;
     }
     data4[0] = temp.mid( 20, 2 ).toUInt( &ok, 16 );
-    if ( !ok ) {
-	*this = QUuid();
-	return;
+    if ( !ok )
+    {
+        *this = QUuid();
+        return;
     }
     data4[1] = temp.mid( 22, 2 ).toUInt( &ok, 16 );
-    if ( !ok ) {
-	*this = QUuid();
-	return;
+    if ( !ok )
+    {
+        *this = QUuid();
+        return;
     }
-    for ( int i = 2; i<8; i++ ) {
-	data4[i] = temp.mid( 25 + (i-2)*2, 2 ).toUShort( &ok, 16 );
-	if ( !ok ) {
-	    *this = QUuid();
-	    return;
-	}
+    for ( int i = 2; i<8; i++ )
+    {
+        data4[i] = temp.mid( 25 + (i-2)*2, 2 ).toUShort( &ok, 16 );
+        if ( !ok )
+        {
+            *this = QUuid();
+            return;
+        }
     }
 }
-#endif
+
 /*!
   \fn QUuid QUuid::operator=(const QUuid &uuid )
 
   Assigns the value of \a uuid to this QUuid object.
 */
 
@@ -111,13 +120,13 @@ QUuid::QUuid( const QString &text )
 
 /*!
   \fn bool QUuid::operator!=(const QUuid &other) const
 
   Returns TRUE if this QUuid and the \a other QUuid are different, otherwise returns FALSE.
 */
-#ifndef QT_NO_QUUID_STRING
+
 /*!
   QString QUuid::toString() const
 
   Returns a string in {12345678-1234-1234-1234-123456789ABC} format.
 */
 QString QUuid::toString() const
@@ -127,20 +136,92 @@ QString QUuid::toString() const
     result = "{" + QString::number( data1, 16 ).rightJustify( 8, '0' ) + "-";
     result += QString::number( (int)data2, 16 ).rightJustify( 4, '0' ) + "-";
     result += QString::number( (int)data3, 16 ).rightJustify( 4, '0' ) + "-";
     result += QString::number( (int)data4[0], 16 ).rightJustify( 2, '0' );
     result += QString::number( (int)data4[1], 16 ).rightJustify( 2, '0' ) + "-";
     for ( int i = 2; i < 8; i++ )
-	result += QString::number( (int)data4[i], 16 ).rightJustify( 2, '0' );
+        result += QString::number( (int)data4[i], 16 ).rightJustify( 2, '0' );
 
     return result + "}";
 }
 #endif
+
 /*!
   Returns TRUE if this is the null UUID {00000000-0000-0000-0000-000000000000}, otherwise returns FALSE.
 */
 bool QUuid::isNull() const
 {
     return data4[0] == 0 && data4[1] == 0 && data4[2] == 0 && data4[3] == 0 &&
-	   data4[4] == 0 && data4[5] == 0 && data4[6] == 0 && data4[7] == 0 &&
-	   data1 == 0 && data2 == 0 && data3 == 0;
+           data4[4] == 0 && data4[5] == 0 && data4[6] == 0 && data4[7] == 0 &&
+           data1 == 0 && data2 == 0 && data3 == 0;
+}
+
+
+/*!
+    \fn QUuid::Variant QUuid::variant() const
+
+    Returns the variant of the UUID.
+    The null UUID is considered to be of an unknown variant.
+
+    \sa version()
+*/
+QUuid::Variant QUuid::variant() const
+{
+    if ( isNull() )
+        return VarUnknown;
+    // Check the 3 MSB of data4[0]
+    if ( (data4[0] & 0x80) == 0x00 ) return NCS;
+    else if ( (data4[0] & 0xC0) == 0x80 ) return DCE;
+    else if ( (data4[0] & 0xE0) == 0xC0 ) return Microsoft;
+    else if ( (data4[0] & 0xE0) == 0xE0 ) return Reserved;
+    return VarUnknown;
+}
+
+/*!
+    \fn bool QUuid::operator<(const QUuid &other) const
+
+    Returns TRUE if this QUuid is of the same variant,
+    and lexicographically before the \a other QUuid;
+    otherwise returns FALSE.
+
+    \sa variant()
+*/
+#define ISLESS(f1, f2) if (f1!=f2) return (f1<f2);
+bool QUuid::operator<(const QUuid &other ) const
+{
+    if ( variant() != other.variant() )
+        return FALSE;
+
+    ISLESS( data1, other.data1 );
+    ISLESS( data2, other.data2 );
+    ISLESS( data3, other.data3 );
+    for ( int n = 0; n < 8; n++ )
+    {
+        ISLESS( data4[n], other.data4[n] );
+    }
+    return FALSE;
+}
+
+/*!
+    \fn bool QUuid::operator>(const QUuid &other) const
+
+    Returns TRUE if this QUuid is of the same variant,
+    and lexicographically after the \a other QUuid;
+    otherwise returns FALSE.
+
+    \sa variant()
+*/
+#define ISMORE(f1, f2) if (f1!=f2) return (f1>f2);
+bool QUuid::operator>(const QUuid &other ) const
+{
+    if ( variant() != other.variant() )
+        return FALSE;
+
+    ISMORE( data1, other.data1 );
+    ISMORE( data2, other.data2 );
+    ISMORE( data3, other.data3 );
+    for ( int n = 0; n < 8; n++ )
+    {
+        ISMORE( data4[n], other.data4[n] );
+    }
+    return FALSE;
 }
diff --git a/library/quuid.h b/library/quuid.h
index 841a00f..1575711 100644
--- a/library/quuid.h
+++ b/library/quuid.h
@@ -22,141 +22,94 @@
 #define QUUID_H
 
 #ifndef QT_H
 #include <qstring.h>
 #endif // QT_H
 
-#include <memory.h>
-
-#if defined(Q_OS_WIN32)
-#ifndef GUID_DEFINED
-#define GUID_DEFINED
-typedef struct _GUID
-{
-    ulong   Data1;
-    ushort  Data2;
-    ushort  Data3;
-    uchar   Data4[ 8 ];
-} GUID;
-#endif
-#endif
-
-#if defined( Q_WS_QWS ) && !defined( UUID_H_INCLUDED )
-typedef unsigned char uuid_t[16];
-#endif
-
 struct Q_EXPORT QUuid
 {
+    enum Variant {
+        VarUnknown  =-1,
+        NCS     = 0, // 0 - -
+        DCE     = 2, // 1 0 -
+        Microsoft   = 6, // 1 1 0
+        Reserved    = 7  // 1 1 1
+    };
+
     QUuid()
     {
-	memset( this, 0, sizeof(QUuid) );
+        memset( this, 0, sizeof(QUuid) );
     }
     QUuid( uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8 )
     {
-	data1 = l;
-	data2 = w1;
-	data3 = w2;
-	data4[0] = b1;
-	data4[1] = b2;
-	data4[2] = b3;
-	data4[3] = b4;
-	data4[4] = b5;
-	data4[5] = b6;
-	data4[6] = b7;
-	data4[7] = b8;
+        data1 = l;
+        data2 = w1;
+        data3 = w2;
+        data4[0] = b1;
+        data4[1] = b2;
+        data4[2] = b3;
+        data4[3] = b4;
+        data4[4] = b5;
+        data4[5] = b6;
+        data4[6] = b7;
+        data4[7] = b8;
     }
     QUuid( const QUuid &uuid )
     {
-	memcpy( this, &uuid, sizeof(QUuid) );
+        uint i;
+
+        data1 = uuid.data1;
+        data2 = uuid.data2;
+        data3 = uuid.data3;
+        for( i = 0; i < 8; i++ )
+            data4[ i ] = uuid.data4[ i ];
     }
+
 #ifndef QT_NO_QUUID_STRING
     QUuid( const QString & );
     QString toString() const;
 #endif
     bool isNull() const;
 
     QUuid &operator=(const QUuid &orig )
     {
-	memcpy( this, &orig, sizeof(QUuid) );
-	return *this;
-    }
+        uint i;
 
-    bool operator==(const QUuid &orig ) const
-    {
-	return !memcmp( this, &orig, sizeof(QUuid) );
-    }
+        data1 = orig.data1;
+        data2 = orig.data2;
+        data3 = orig.data3;
+        for( i = 0; i < 8; i++ )
+            data4[ i ] = orig.data4[ i ];
 
-    bool operator!=(const QUuid &orig ) const
-    {
-	return !( *this == orig );
+        return *this;
     }
 
-    inline bool operator<(const QUuid &orig) const
-    {
-	return ( memcmp(this, &orig, sizeof(QUuid)) < 0);
-    }
-    
-    inline bool operator>(const QUuid &orig) const
-    {
-	return ( memcmp(this, &orig, sizeof(QUuid) ) > 0);
-    }
-    
-#if defined(Q_OS_WIN32)
-    // On Windows we have a type GUID that is used by the platform API, so we
-    // provide convenience operators to cast from and to this type.
-    QUuid( const GUID &guid )
+    bool operator==(const QUuid &orig ) const
     {
-	memcpy( this, &guid, sizeof(GUID) );
-    }
+        uint i;
+        if ( data1 != orig.data1 || data2 != orig.data2 ||
+                data3 != orig.data3 )
+            return FALSE;
 
-    QUuid &operator=(const GUID &orig )
-    {
-	memcpy( this, &orig, sizeof(QUuid) );
-	return *this;
-    }
+        for( i = 0; i < 8; i++ )
+            if ( data4[i] != orig.data4[i] )
+                return FALSE;
 
-    operator GUID() const
-    {
-	GUID guid = { data1, data2, data3, { data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7] } };
-	return guid;
+        return TRUE;
     }
 
-    bool operator==( const GUID &guid ) const
+    bool operator!=(const QUuid &orig ) const
     {
-	return !memcmp( this, &guid, sizeof(QUuid) );
+        return !( *this == orig );
     }
 
-    bool operator!=( const GUID &guid ) const
-    {
-	return !( *this == guid );
-    }
-    
-    inline bool operator<(const QUuid &orig) const
-    {
-	return ( memcmp(this, &orig, sizeof(QUuid) ) < 0);
-    }
-    
-    inline bool operator>(const QUuid &orig) const
-    {
-	return ( memcmp(this, &orig, sizeof(QUuid) ) > 0);
-    }
-    
-#endif
-#if defined (Q_WS_QWS)
-    QUuid( uuid_t uuid ) 
-    {
-	memcpy( this, uuid, sizeof(uuid_t) );
-    }
+    bool operator<(const QUuid &other ) const;
+    bool operator>(const QUuid &other ) const;
+
+    QUuid::Variant variant() const;
 
-    QUuid &operator=(const uuid_t &orig )
-    {
-	memcpy( this, &orig, sizeof(uuid_t) );
-	return *this;
-    }
-#endif
-    
     ulong   data1;
     ushort  data2;
     ushort  data3;
     uchar   data4[ 8 ];
 };