BaseType.h

//========================================================================================
// 
// $File$
// 
// Owner: ?
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
// 
// ABSTRACT:
// This file defines a set of base types for use by all PageMaker applications.
// See the comments below for the different types.
// 
//========================================================================================

#ifndef __BASETYPE__
#define __BASETYPE__

#ifndef __AnsiBasedTypes__
#include "AnsiBasedTypes.h"
#endif

#include "K2TypeTraits.h" // For base_type

#if defined MACINTOSH || defined WINDOWS
#include <limits.h>
#else
#include <climits>
#endif

typedef uchar *PString; // pascal string headed with count
typedef const uchar *ConstPString; // pascal string headed with count

typedef char *CString; // null terminated "C" string
typedef const char *ConstCString; // null terminated "C" string

typedef uchar16 *WString; // null terminated "Unicode" string
typedef const uchar16 *ConstWString; // null terminated "Unicode" string


// there is a bug in the current (3.3) version of the gcc headers where __SCHAR_MAX__ is
// not defined.
#ifndef __SCHAR_MAX__
#define __SCHAR_MAX__ 127
#endif

const int8 kMinInt8 = (int8)SCHAR_MIN; // from limits.h
const int8 kMaxInt8 = (int8)SCHAR_MAX;
const int16 kMinInt16 = (int16)SHRT_MIN;
const int16 kMaxInt16 = (int16)SHRT_MAX;

const uint8 kMaxUInt8 = (uint8)UCHAR_MAX;
const uint16 kMaxUInt16 = (uint16)USHRT_MAX;

#if MACINTOSH && __LP64__
 const int32 kMinInt32 = (int32)INT_MIN;
 const int32 kMaxInt32 = (int32)INT_MAX;

 const uint32 kMaxUInt32 = (uint32)UINT_MAX;
#else
 const int32 kMinInt32 = (int32)LONG_MIN;
 const int32 kMaxInt32 = (int32)LONG_MAX;

 const uint32 kMaxUInt32 = (uint32)ULONG_MAX;
#endif

#if WINDOWS
 const int64 kMinInt64 = (int64)_I64_MIN;
 const int64 kMaxInt64 = (int64)_I64_MAX;

 const uint64 kMaxUInt64 = (uint64)_UI64_MAX;
#else
 const int64 kMinInt64 = (int64)LONG_LONG_MIN;
 const int64 kMaxInt64 = (int64)LONG_LONG_MAX;

 const uint64 kMaxUInt64 = (uint64)ULONG_LONG_MAX;
#endif


//======================================================================
// Other abstract types
//======================================================================

typedef int32 TextIndex;

typedef uchar16 textchar;

typedef uchar16 UTF16TextChar;

class IPMStream;

class UTF32TextChar
{
 public:
 typedef base_type data_type;

 inline UTF32TextChar() : fCharacterValue() {}
 
 inline UTF32TextChar(uint32 c32) : fCharacterValue(c32) {}
 
 inline UTF32TextChar(UTF16TextChar hi, UTF16TextChar low)
 : fCharacterValue((hi - 0xD800) * 0x400 + (low - 0xDC00) + 0x10000) 
 {}
 
 inline UTF32TextChar(const UTF32TextChar &c) : fCharacterValue(c.fCharacterValue) {}

 inline uint32 GetValue() const { return fCharacterValue; }
 
 inline UTF16TextChar CalcHighSurrogate() const { return (fCharacterValue > 0xFFFF ? static_cast<UTF16TextChar>((fCharacterValue - 0x10000) / 0x400 + 0xd800) : static_cast<UTF16TextChar>(fCharacterValue)); }
 
 inline UTF16TextChar CalcLowSurrogate() const { return (fCharacterValue > 0xFFFF ? static_cast<UTF16TextChar>((fCharacterValue - 0x10000) % 0x400 + 0xdc00) : static_cast<UTF16TextChar>(fCharacterValue)); }
 
 inline void ToUTF16(UTF16TextChar * buf, int32 * len) const
 {
 buf[0] = CalcHighSurrogate();
 if (fCharacterValue > 0xFFFF && *len >= 2)
 {
 *len = 2;
 buf[1] = CalcLowSurrogate();
 }
 else
 *len = 1;
 }
 
 inline bool16 operator == (UTF32TextChar c32) const { return c32.fCharacterValue == fCharacterValue;}

 inline bool16 operator != (UTF32TextChar c32) const { return c32.fCharacterValue != fCharacterValue;}
 
 inline bool16 operator >= (UTF32TextChar i) const { return fCharacterValue >= i.fCharacterValue; }
 
 inline bool16 operator <= (UTF32TextChar i) const { return fCharacterValue <= i.fCharacterValue; }
 
 inline bool16 operator > (UTF32TextChar i) const { return fCharacterValue > i.fCharacterValue; }

 inline bool16 operator < (UTF32TextChar i) const { return fCharacterValue < i.fCharacterValue; }
 
 inline UTF32TextChar& operator = (const UTF32TextChar& c) { fCharacterValue = c.fCharacterValue; return *this; }

 inline bool16 isExtraWide() const { return GetValue() > 0xffff;}

 void ReadWriteUTF16(IPMStream *s);

 protected:
 uint32 fCharacterValue;
};

 
 template <>
 struct CONVERSION_TO_THREADLOCALSTORAGE<UTF32TextChar> {
 static uint32 CONVERT(UTF32TextChar arg) {return arg.GetValue();}
 };

const TextIndex kInvalidTextIndex = -1;


typedef int32 ErrorCode;

enum { 
 kSuccess = 0, 
 kFailure = 1, 
 kCancel = 2 
};


#if 0
 #if defined(MACINTOSH) && !defined(__POWERPC__)
 #define RESOURCE_ENDIAN_SWAPPING 1
 #else
 #define RESOURCE_ENDIAN_SWAPPING 0
#endif
#else
#define RESOURCE_ENDIAN_SWAPPING 0
#endif

template<typename T>
class ResourceEndianWrapper32
{
 uint32 fContent;

 uint32 EE (uint32 value) const
 {
 #if RESOURCE_ENDIAN_SWAPPING
 return ((value >> 24) & 0x000000ff) |
 ((value >> 8) & 0x0000ff00) |
 ((value << 8) & 0x00ff0000) |
 ((value << 24) & 0xff000000);
 #else
 return value;
 #endif
 }

public:
 
 void Set (T value)
 {
 fContent = EE ((uint32) value);
 }
 
 T Get () const
 {
 return T (EE (fContent));
 }
 
 ResourceEndianWrapper32 (T value)
 {
 Set (value);
 }
 
 operator T () const
 {
 return Get ();
 }
};
 
template<typename T>
class ResourceEndianWrapper16
{
 uint16 fContent;

 uint16 EE (uint16 value) const
 {
 #if RESOURCE_ENDIAN_SWAPPING
 return ((value >> 8) & 0x00ff) |
 ((value << 8) & 0xff00);
 #else
 return value;
 #endif
 }

public:
 
 void Set (T value)
 {
 fContent = EE ((uint16) value);
 }
 
 T Get () const
 {
 return T (EE (fContent));
 }
 
 ResourceEndianWrapper16 (T value)
 {
 Set (value);
 }
 
 operator T () const
 {
 return Get ();
 }
};

#if defined(MACINTOSH) && defined(__POWERPC__)
#define IS_BIG_ENDIAN_ARCH 1
#define IS_LITTLE_ENDIAN_ARCH 0
#else
#define IS_BIG_ENDIAN_ARCH 0
#define IS_LITTLE_ENDIAN_ARCH 1
#endif

namespace K2
{
 // 11/13/98 Roey
 // Introduced this namespace to avoid possible conflicts
 // with third party libraries.
 // As we are adding more to this namespace it might become necessary
 // to create a dedicated file for it.

 typedef enum {
 kSuppressUI, 
 kMinimalUI, 
 kFullUI 
 } UIFlags;
}

using namespace K2;

#endif // __BASETYPE__