Tools/WinSN5.0Ver.iso/NETSCAP.50/WIN1998.ZIP/ns/cmd/macfe/central/PascalString.h

C/C++ Source or Header | 1998-04-08 | 20.7 KB | 754 lines

//----------------------------------------------------------------------------------------
// PascalString.h
// Copyright ⌐ 1985-1994 by Apple Computer, Inc.  All rights reserved.
//----------------------------------------------------------------------------------------


// Ñ Updated by Jeroen Schalk - DTS
// Ñ Use MABlockMove, not memcpy(), memmove(), strncpy().
// Ñ Changed default constructors to initialize to empty string.
// Ñ Changed number of temporary strings from 4 to 8
// Ñ Make operator[] and unsigned char*() inline
// Ñ Fix bugs in constructors out of const unsigned char* str
// Ñ Optimized constructors to only move required data
// Ñ General cleanup of code for readability

#pragma once

#ifndef __PASCALSTRING__
#define __PASCALSTRING__

#ifndef __MEMORY__
#include <Memory.h>
#endif

#ifndef __TYPES__
#include <Types.h>
#endif

#ifndef __TEXTUTILS__
#include <TextUtils.h>
#endif

#ifndef __OSUTILS__
#include <OSUtils.h>
#endif

#ifndef __STRING__
#include <string.h>
#endif

// Forward declaration for all the CString classes.
struct CString;
struct CStr255;
struct CStr63;
struct CStr32;
struct CStr31;

typedef const CStr255& ConstCStr255Param;
typedef const CStr63& ConstCStr63Param;
typedef const CStr32& ConstCStr32Param;
typedef const CStr31& ConstCStr31Param;

#ifdef Length
#undef Length
#endif
// Some constants defining the length of each of the CString types.

const short kLengthByte = 1;
const short kBaseLen = 2;
const short kStr255Len = 255;
const short kStr63Len = 63;
const short kStr32Len = 32;
const short kStr31Len = 31;

// Number of temporary strings

const short kTempCStrings = 8;

//----------------------------------------------------------------------------------------
// MABlockMove: BlockMoveData() is fastest on PowerPC, memcpy() on 68K
//----------------------------------------------------------------------------------------

#if powerc
    #define MABlockMove(srcPtr, destPtr, byteCount) \
        ::BlockMoveData(Ptr(srcPtr), Ptr(destPtr), Size(byteCount))
#else
    #define MABlockMove(srcPtr, destPtr, byteCount) \
        ::memcpy(destPtr, srcPtr, size_t(byteCount))
#endif

//----------------------------------------------------------------------------------------
// MABlockMoveOverlap: BlockMoveData() is fastest on PowerPC, memmove() on 68K
//----------------------------------------------------------------------------------------

#if powerc
    #define MABlockMoveOverlap(srcPtr, destPtr, byteCount) \
        ::BlockMoveData(Ptr(srcPtr), Ptr(destPtr), Size(byteCount))
#else
    #define MABlockMoveOverlap(srcPtr, destPtr, byteCount) \
        ::memmove(destPtr, srcPtr, size_t(byteCount))
#endif

//----------------------------------------------------------------------------------------
// CString: Superclass of all Pascal string compatible string classes.
//----------------------------------------------------------------------------------------

typedef struct CString *CStringPtr, **CStringHandle;

struct CString
{
public:
    unsigned char fStr[kBaseLen];

protected:
    CString() {}
        // This is here (and protected) to stop people trying to instantiate CString.
        // To do so is very bad,  because it's suicide to make one of these!  There are
        // only 2 bytes of data!
    void InsertHelper(const CString& insStr, short pos, short maxLength);
    void InsertHelper(const char* insStr, short pos, short maxLength);

public:
    // Basic length method, inherited by all derived classes. Define one that returns a
    // reference. Can be used as an lvalue and only can be applied to non-const Strings.

    inline unsigned char& Length()
    {
        return fStr[0];
    }                                            // for non-const CString

    inline unsigned char Length() const
    {
        return fStr[0];
    }                                            // for const CString

    inline Boolean IsEmpty()
    {
        return fStr[0] <= 0;
    }                                            // for non-const CString

    inline Boolean IsEmpty() const
    {
        return fStr[0] <= 0;
    }                                            // for const CString

    // Character selector operator.

    inline unsigned char& operator[](short pos)
    {
        return fStr[pos];
    }                                            // for non-const CString

    inline unsigned char operator[](short pos) const
    {
        return fStr[pos];
    }                                            // for const CString

    //------------------------------------------------------------------------------------
    // CAUTION: There is a subtle difference between the (char*) and (unsigned char*)
    // conversion operators. The first converts a pascal-style string to a c-style
    // string. The second simply converts between two types (CString and Str55) both of
    // which are pascal-style strings.

    // Create a NULL terminated c-style string from a pascal-style CString. Used in
    // debugging to fprintf a CString.

    operator char*() const;

    // Used to create a toolbox type Str255 from our CString. This is simply a type
    // coercion! Both CString and Str255 are expected to be pascal-style strings.

    inline operator unsigned char*()
    {
        return (unsigned char *) this;
    }                                            // for non-const CString

    operator const unsigned char*() const;        // for const CString

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

    // Return an ID represented as a CString to the actual ID (a long).

    operator long() const;

    // Relational operators that are inherited by all the derived CString types. Three of
    // each so that literal C Strings can be conveniently used for one of the operators as
    // well as two of the derive classes as operators. These are declared here but defined
    // below all the CString classes because they use constructors for CStr255 and its class
    // definition has not been encountered yet.

    friend inline Boolean operator==(const CString& s1,
                              const char* s2);
    friend inline Boolean operator==(const char* s1,
                              const CString& s2);
    friend inline Boolean operator==(const CString& s1,
                              const CString& s2);
    friend inline Boolean operator!=(const CString& s1,
                              const char* s2);
    friend inline Boolean operator!=(const char* s1,
                              const CString& s2);
    friend inline Boolean operator!=(const CString& s1,
                              const CString& s2);

    friend inline Boolean operator>(const CString& s1,
                             const char* s2);
    friend inline Boolean operator>(const char* s1,
                             const CString& s2);
    friend inline Boolean operator>(const CString& s1,
                             const CString& s2);

    friend inline Boolean operator<(const CString& s1,
                             const char* s2);
    friend inline Boolean operator<(const char* s1,
                             const CString& s2);
    friend inline Boolean operator<(const CString& s1,
                             const CString& s2);

    friend inline Boolean operator>=(const CString& s1,
                              const char* s2);
    friend inline Boolean operator>=(const char* s1,
                              const CString& s2);
    friend inline Boolean operator>=(const CString& s1,
                              const CString& s2);

    friend inline Boolean operator<=(const CString& s1,
                              const char* s2);
    friend inline Boolean operator<=(const char* s1,
                              const CString& s2);
    friend inline Boolean operator<=(const CString& s1,
                              const CString& s2);

    // Concatenation operator that are inherited by all the derived CString types. Three
    // of each so that literal C Strings can be conveniently used for one of the operators
    // as well as using any two classes derived from CString.

    friend CStr255 operator+(const CString& s1,
                             const char* s2);
    friend CStr255 operator+(const char* s1,
                             const CString& s2);
    friend CStr255 operator+(const CString& s1,
                             const CString& s2);

    // Methods that mimic the Pascal builtin CString functions for Pos, Insert and Delete.
    // Note that insert and copy is implemented in the derived classes.

    unsigned char Pos(const char* subStr, unsigned char startPos = 1);
    unsigned char Pos(const CString& subStr, unsigned char startPos = 1);
    void Delete(short pos, short length);

protected:
    inline long Min(const long a, const long b) const
    {
        return a < b ? a : b;
    }
};


//----------------------------------------------------------------------------------------
// CStr255:
//----------------------------------------------------------------------------------------

struct CStr255 : CString
{
    friend struct CStr63;
    friend struct CStr31;

private:
    unsigned char fData[kStr255Len - 1];

public:
    static const CStr255 sEmptyString;

    CStr255();
    CStr255(const CStr255& str);
    CStr255(const CStr63& str);
    CStr255(const CStr32& str);
    CStr255(const CStr31& str);
    CStr255(const unsigned char* str);
    CStr255(const char* str);
    CStr255(const long id);

    // Insert and Copy roughly equivalent to the Pascal Insert and Copy functions.

    void Insert(const CString& str, short pos);
    void Insert(const char* str, short pos);
    CStr255 Copy(short pos, short length);

    // Concatenation operator

    CStr255& operator +=(const CString& str);
    CStr255& operator +=(const char* str);
    CStr255& operator +=(const char ch);

    // Assignment operator

    CStr255& operator =(const CStr255& str);
    CStr255& operator =(const CStr63& str);
    CStr255& operator =(const CStr32& str);
    CStr255& operator =(const CStr31& str);
    CStr255& operator =(const unsigned char* str);
    CStr255& operator =(const char aChar);
    CStr255& operator =(const char* str);
};


//----------------------------------------------------------------------------------------
// CStr63:
//----------------------------------------------------------------------------------------

struct CStr63 : CString
{
    friend struct CStr255;
    friend struct CStr31;

private:
    unsigned char fData[kStr63Len - 1];

public:
    CStr63();
    CStr63(const CStr255& str);
    CStr63(const CStr63& str);
    CStr63(const CStr32& str);
    CStr63(const CStr31& str);
    CStr63(const unsigned char* str);
    CStr63(const char* str);
    CStr63(const long id);

    // Insert and Copy roughly equivalent to the Pascal Insert and Copy functions.

    void Insert(const CString& str, short pos);
    void Insert(const char* str, short pos);
    CStr63 Copy(short pos, short length);

    // Concatenation operator

    CStr63& operator +=(const CString& str);
    CStr63& operator +=(const char* str);
    CStr63& operator +=(const char ch);
};


//----------------------------------------------------------------------------------------
// CStr32:
//----------------------------------------------------------------------------------------

struct CStr32 : CString
{
    friend struct CStr255;
    friend struct CStr63;

private:
    unsigned char fData[kStr32Len - 1];

public:
    CStr32();
    inline CStr32(unsigned char length)
    {
        fStr[0] = length;
    }

    CStr32(const CStr255& str);
    CStr32(const CStr63& str);
    CStr32(const CStr32& str);
    CStr32(const CStr31& str);
    CStr32(const unsigned char* str);
    CStr32(const char* str);
    CStr32(const long id);

    // Insert and Copy roughly equivalent to the Pascal Insert and Copy functions.

    void Insert(const CString& str, short pos);
    void Insert(const char* str, short pos);
    CStr32 Copy(short pos, short length);

    // Concatenation operator

    CStr32& operator +=(const CString& str);
    CStr32& operator +=(const char* str);
    CStr32& operator +=(const char ch);
};


//----------------------------------------------------------------------------------------
// CStr31:
//----------------------------------------------------------------------------------------

struct CStr31 : CString
{
    friend struct CStr255;
    friend struct CStr63;
    friend struct CStr32;

private:
    unsigned char fData[kStr31Len - 1];

public:
    CStr31();
    inline CStr31(unsigned char length)
    {
        fStr[0] = length;
    }

    CStr31(const CStr255& str);
    CStr31(const CStr63& str);
    CStr31(const CStr32& str);
    CStr31(const CStr31& str);
    CStr31(const unsigned char* str);
    CStr31(const char* str);
    CStr31(const long id);

    void    operator =(const CString& str);
    void    operator =(const unsigned char* str);
    void    operator =(const char* str);

    // Insert and Copy roughly equivalent to the Pascal Insert and Copy functions.

    void Insert(const CString& str, short pos);
    void Insert(const char* str, short pos);
    CStr31 Copy(short pos, short length);

    // Concatenation operator

    CStr31& operator +=(const CString& str);
    CStr31& operator +=(const char* str);
    CStr31& operator +=(const char ch);
};

//----------------------------------------------------------------------------------------
// CStr255 inline function definitions
//----------------------------------------------------------------------------------------

inline CStr255::CStr255()
{
    fStr[0] = 0;
}

inline CStr255::CStr255(const CStr255& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr255::CStr255(const CStr63& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr255::CStr255(const CStr32& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr255::CStr255(const CStr31& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr255::CStr255(const unsigned char* str)
{
    MABlockMove(str, fStr, str[0] + kLengthByte);
}

inline CStr255& CStr255::operator = (const CStr255& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);

    return *this;
}

inline CStr255& CStr255::operator = (const CStr63& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);

    return *this;
}

inline CStr255& CStr255::operator = (const CStr32& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);

    return *this;
}

inline CStr255& CStr255::operator = (const CStr31& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);

    return *this;
}

inline CStr255& CStr255::operator = (const unsigned char* str)
{
    MABlockMove(str, fStr, str[0] + kLengthByte);

    return *this;
}

inline CStr255& CStr255::operator = (const char aChar)
{
    Length() = (aChar) ? 1 : 0;
    fStr[1] = aChar;

    return *this;
}

inline void CStr255::Insert(const CString& str, short pos)
{
    this->InsertHelper(str, pos, kStr255Len);
}

inline void CStr255::Insert(const char* str, short pos)
{
    this->InsertHelper(str, pos, kStr255Len);
}


//----------------------------------------------------------------------------------------
// CStr63 inline function definitions
//----------------------------------------------------------------------------------------

inline CStr63::CStr63()
{
    fStr[0] = 0;
}

inline CStr63::CStr63(const CStr255& str)
{
    // Truncate the CStr255 to 63 bytes if necessary.

    Length() = str.Length() > kStr63Len ? kStr63Len : str.Length();
    MABlockMove(&str.fStr[1], &fStr[1], Length());
}

inline CStr63::CStr63(const CStr63& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr63::CStr63(const CStr32& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr63::CStr63(const CStr31& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr63::CStr63(const unsigned char* str)
{
    MABlockMove(str, fStr, Min(str[0] + kLengthByte, sizeof(CStr63)));
}

inline void CStr63::Insert(const CString& str, short pos)
{
    this->InsertHelper(str, pos, kStr63Len);
}

inline void CStr63::Insert(const char* str, short pos)
{
    this->InsertHelper(str, pos, kStr63Len);
}


//----------------------------------------------------------------------------------------
// CStr32 inline function definitions
//----------------------------------------------------------------------------------------

inline CStr32::CStr32()
{
    fStr[0] = 0;
}

inline CStr32::CStr32(const CStr255& str)
{
    // Truncate the CStr255 to 32 bytes if necessary.

    Length() = str.Length() > kStr32Len ? kStr32Len : str.Length();
    MABlockMove(&str.fStr[1], &fStr[1], Length());
}

inline CStr32::CStr32(const CStr63& str)
{
    // Truncate the CStr63 to 32 bytes if necessary.

    Length() = str.Length() > kStr32Len ? kStr32Len : str.Length();
    MABlockMove(&str.fStr[1], &fStr[1], Length());
}

inline CStr32::CStr32(const CStr32& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr32::CStr32(const CStr31& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr32::CStr32(const unsigned char* str)
{
    MABlockMove(str, fStr, Min(str[0] + kLengthByte, sizeof(CStr32)));
}

inline void CStr32::Insert(const CString& str, short pos)
{
    this->InsertHelper(str, pos, kStr32Len);
}

inline void CStr32::Insert(const char* str, short pos)
{
    this->InsertHelper(str, pos, kStr32Len);
}


//----------------------------------------------------------------------------------------
// CStr31 inline function definitions
//----------------------------------------------------------------------------------------

inline CStr31::CStr31()
{
    fStr[0] = 0;
}

inline CStr31::CStr31(const CStr255& str)
{
    // Truncate the CStr255 to 31 bytes if necessary.

    Length() = str.Length() > kStr31Len ? kStr31Len : str.Length();
    MABlockMove(&str.fStr[1], &fStr[1], Length());
}

inline CStr31::CStr31(const CStr63& str)
{
    // Truncate the CStr63 to 31 bytes if necessary.

    Length() = str.Length() > kStr31Len ? kStr31Len : str.Length();
    MABlockMove(&str.fStr[1], &fStr[1], Length());
}

inline CStr31::CStr31(const CStr32& str)
{
    // Truncate the CStr32 to 31 bytes if necessary.

    Length() = str.Length() > kStr31Len ? kStr31Len : str.Length();
    MABlockMove(&str.fStr[1], &fStr[1], Length());
}

inline CStr31::CStr31(const CStr31& str)
{
    MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
}

inline CStr31::CStr31(const unsigned char* str)
{
    MABlockMove(str, fStr, Min(str[0] + kLengthByte, sizeof(CStr31)));
}

inline void CStr31::Insert(const CString& str, short pos)
{
    this->InsertHelper(str, pos, kStr31Len);
}

inline void CStr31::Insert(const char* str, short pos)
{
    this->InsertHelper(str, pos, kStr31Len);
}


//----------------------------------------------------------------------------------------
// Inline friend function definitions for relational string operators.
//----------------------------------------------------------------------------------------

inline Boolean operator==(const CString& s1, const char* s2)
{
    return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) == 0;
}

inline Boolean operator==(const char* s1, const CString& s2)
{
    return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) == 0;
}

inline Boolean operator==(const CString& s1, const CString& s2)
{
    return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) == 0;
}

inline Boolean operator!=(const CString& s1, const char* s2)
{
    return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) != 0;
}

inline Boolean operator!=(const char* s1, const CString& s2)
{
    return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) != 0;
}

inline Boolean operator!=(const CString& s1, const CString& s2)
{
    return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) != 0;
}

inline Boolean operator>(const CString& s1, const char* s2)
{
    return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) > 0;
}

inline Boolean operator>(const char* s1, const CString& s2)
{
    return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) > 0;
}

inline Boolean operator>(const CString& s1, const CString& s2)
{
    return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) > 0;
}

inline Boolean operator<(const CString& s1, const char* s2)
{
    return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) < 0;
}

inline Boolean operator<(const char* s1, const CString& s2)
{
    return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) < 0;
}

inline Boolean operator<(const CString& s1, const CString& s2)
{
    return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) < 0;
}

inline Boolean operator>=(const CString& s1, const char* s2)
{
    return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) >= 0;
}

inline Boolean operator>=(const char* s1, const CString& s2)
{
    return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) >= 0;
}

inline Boolean operator>=(const CString& s1, const CString& s2)
{
    return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) >= 0;
}

inline Boolean operator<=(const CString& s1, const char* s2)
{
    return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) <= 0;
}

inline Boolean operator<=(const char* s1, const CString& s2)
{
    return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) <= 0;
}

inline Boolean operator<=(const CString& s1, const CString& s2)
{
    return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) <= 0;
}

#endif