xref: /aosp_15_r20/external/dng_sdk/source/dng_string.cpp (revision fd1fabb72dbdf09ea7034f531e6f8e9f57334c8d)

/*****************************************************************************/
// Copyright 2006-2007 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.
/*****************************************************************************/

/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_string.cpp#2 $ */
/* $DateTime: 2012/07/31 22:04:34 $ */
/* $Change: 840853 $ */
/* $Author: tknoll $ */

/*****************************************************************************/

#include "dng_string.h"

#include "dng_assertions.h"
#include "dng_exceptions.h"
#include "dng_flags.h"
#include "dng_mutex.h"
#include "dng_utils.h"
#include "dng_safe_arithmetic.h"

#if qMacOS
#include <TargetConditionals.h>
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
#include <MobileCoreServices/MobileCoreServices.h>
#else
#include <CoreServices/CoreServices.h>
#endif  // TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
#endif  // qMacOS

#if qWinOS
#include <windows.h>
#endif

#if qiPhone || qAndroid || qLinux
#include <ctype.h> // for isdigit
#endif

/*****************************************************************************/

const uint32 kREPLACEMENT_CHARACTER	= 0x0000FFFD;

/*****************************************************************************/

// Returns the length of the zero-terminated string 's'. Throws a dng_exception
// if the length of 's' is too large to be represented as a uint32_t.
static uint32 strlenAsUint32(const char *s)
	{

	uint32 lengthAsUint32 = 0;
	ConvertUnsigned(strlen(s), &lengthAsUint32);

	return lengthAsUint32;

	}

// Checks whether there is enough space left in the buffer pointed to by
// 'currentPos' to write at least 'space' elements of type T (to positions
// currentPos[0] through currentPos[space - 1]. Throws a dng_exception if there
// is not enough space left in the buffer.
// 'bufferEnd' should point one element beyond the end of the buffer. For
// example, if the buffer is "T buffer[3];", then bufferEnd should point to
// T + 3.
template <class T>
static void CheckSpaceLeftInBuffer(const T *currentPos,
								   const T *bufferEnd,
								   size_t space)
	{

	if (bufferEnd < currentPos || static_cast<size_t>(bufferEnd - currentPos) < space)
		{
		ThrowMemoryFull ("Buffer overrun");
		}

	}

/*****************************************************************************/

// Throws an exception to notify the user of code that has not been security
// hardened and prevent execution of that code.
//
// Though the DNG SDK in general has been security-hardened, this does not apply
// to the following Mac-OS- and Windows-specific functions. Calls to
// ThrowNotHardened() have been added to these functions to alert callers of
// this fact.
//
// If you're trying to use a function that calls ThrowNotHardened(), you need to
// fix the security issues noted in the comment next to the ThrowNotHardened()
// call. Once you have fixed these issues, obtain a security review for the
// fixes. This may require fuzzing of the modified code on the target platform.
static void ThrowNotHardened()
	{
	ThrowProgramError ("This function has not been security-hardened");
	}

#if qMacOS
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR

static uint32 Extract_SystemEncoding (const dng_string &dngString,
							   		  dng_memory_data &buffer)
	{
		// TODO: Needs implementation.
		ThrowProgramError ("Extract_SystemEncoding() not implemented on iOS");
		return 0;
	}

static void Assign_SystemEncoding (dng_string &dngString,
							       const char *otherString)
	{
		// TODO: Needs implementation.
		ThrowProgramError ("Assign_SystemEncoding() not implemented on iOS");

	}

static void Assign_JIS_X208_1990 (dng_string &dngString,
							      const char *otherString)
	{
		// TODO: Needs implementation.
		ThrowProgramError ("Assign_JIS_X208_1990() not implemented on iOS");
	}

#else

static void Assign_Multibyte (dng_string &dngString,
							  const char *otherString,
							  TextEncoding encoding)
	{

	// This function contains security-vulnerable code. Do not use.
	// The particular vulnerabilities are:
	// - Casting the result of strlen() to a uint32 may case truncation. (Use
	//   strlenAsUint32() instead.)
	// - The computation of aBufSize and the subsequent addition of 1 in the
	//   call to the dng_memory_data constructor may wrap around.
	ThrowNotHardened();

	uint32 aSize = (uint32) strlen (otherString);

	if (aSize > 0)
		{

		uint32 aBufSize = aSize * 6 + 256;

		dng_memory_data aBuf (aBufSize + 1);

		UnicodeMapping aMapping;

		aMapping.unicodeEncoding = ::CreateTextEncoding (kTextEncodingUnicodeV3_0,
														 kUnicodeNoSubset,
														 kUnicodeUTF8Format);

		aMapping.otherEncoding   = encoding;
		aMapping.mappingVersion  = kUnicodeUseLatestMapping;

		TextToUnicodeInfo aInfo = NULL;

		if (::CreateTextToUnicodeInfo (&aMapping, &aInfo) == noErr)
			{

			ByteCount aInput  = 0;
			ByteCount aOutput = 0;

			::ConvertFromTextToUnicode (aInfo,
										aSize,
									    otherString,
									    kUnicodeUseFallbacksMask |
									    kUnicodeLooseMappingsMask,
									    0,
									    NULL,
									    NULL,
									    NULL,
									    aBufSize,
									    &aInput,
									    &aOutput,
									    (UniChar *) aBuf.Buffer ());

			::DisposeTextToUnicodeInfo (&aInfo);

			if (aOutput > 0 && aOutput <= aBufSize)
				{

				char *aBufChar = aBuf.Buffer_char ();

				aBufChar [aOutput] = 0;

				dngString.Set (aBufChar);

				return;

				}

			}

		}

	dngString.Clear ();

	}

static uint32 Extract_Multibyte (const dng_string &dngString,
							     dng_memory_data &buffer,
							     TextEncoding encoding)
	{

	// This function contains security-vulnerable code. Do not use.
	// The particular vulnerabilities are:
	// - The computation of aBufSize may wrap around.
	// - The computation of the argument to buffer.Allocate() may overflow; the
	//   conversion to uint32 is also problematic.
	// - The signed-to-unsigned conversion in the return statement "
	//   return (uint32) aOutput;" may be problematic.
	ThrowNotHardened();

	uint32 aSize = dngString.Length ();

	if (aSize > 0)
		{

		uint32 aBufSize = (aSize * 2) + 256;

		dng_memory_data tempBuffer (aBufSize);

		UnicodeMapping aMapping;

		aMapping.unicodeEncoding = ::CreateTextEncoding (kTextEncodingUnicodeV3_0,
														 kUnicodeNoSubset,
														 kUnicodeUTF8Format);

		aMapping.otherEncoding   = encoding;
		aMapping.mappingVersion  = kUnicodeUseLatestMapping;

		UnicodeToTextInfo aInfo = NULL;

		if (::CreateUnicodeToTextInfo (&aMapping, &aInfo) == noErr)
			{

			ByteCount aInput  = 0;
			ByteCount aOutput = 0;

			::ConvertFromUnicodeToText (aInfo,
										aSize,
										(const UniChar *) dngString.Get (),
									    kUnicodeUseFallbacksMask  |
									    kUnicodeLooseMappingsMask |
									    kUnicodeDefaultDirectionMask,
									    0,
									    NULL,
									    NULL,
									    NULL,
									    aBufSize,
									    &aInput,
									    &aOutput,
									    tempBuffer.Buffer_char ());

			::DisposeUnicodeToTextInfo (&aInfo);

			if (aOutput > 0)
				{

				buffer.Allocate ((uint32) (aOutput + 1));

				memcpy (buffer.Buffer (),
						tempBuffer.Buffer (),
						aOutput);

				buffer.Buffer_char () [aOutput] = 0;

				return (uint32) aOutput;

				}

			}

		}

	buffer.Allocate (1);

	buffer.Buffer_char () [0] = 0;

	return 0;

	}

static void Assign_SystemEncoding (dng_string &dngString,
							       const char *otherString)
	{

	TextEncoding aEncoding;

	::UpgradeScriptInfoToTextEncoding (smSystemScript,
									   kTextLanguageDontCare,
									   kTextRegionDontCare,
									   NULL,
									   &aEncoding);

	Assign_Multibyte (dngString,
					  otherString,
					  aEncoding);

	}

static uint32 Extract_SystemEncoding (const dng_string &dngString,
							   		  dng_memory_data &buffer)
	{

	TextEncoding aEncoding;

	::UpgradeScriptInfoToTextEncoding (smSystemScript,
									   kTextLanguageDontCare,
									   kTextRegionDontCare,
									   NULL,
									   &aEncoding);

	return Extract_Multibyte (dngString,
					   		  buffer,
					   		  aEncoding);

	}

static void Assign_JIS_X208_1990 (dng_string &dngString,
							      const char *otherString)
	{

	Assign_Multibyte (dngString,
					  otherString,
					  kTextEncodingJIS_X0208_90);

	}

#endif  // TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
#endif  // qMacOS

/*****************************************************************************/

#if qWinOS

static void Assign_Multibyte (dng_string &dngString,
							  const char *otherString,
							  UINT encoding)
	{

	// This function contains security-vulnerable code. Do not use.
	// The particular vulnerabilities are:
	// - Converting the return value of strlen() to int may cause overflow.
	// - The computation of aBufChars and of the argument to the dng_memory_data
	//   constructor may overflow. Additionally, there is an implicit
	//   signed-to-unsigned conversion in the call to the dng_memory_data
	//   constructor.
	ThrowNotHardened();

	DNG_ASSERT (sizeof (WCHAR) == 2, "WCHAR must be 2 bytes");

	int aSize = (int) strlen (otherString);

	if (aSize > 0)
		{

		int aBufChars = aSize * 3 + 128;

		dng_memory_data aBuf ((aBufChars + 1) << 1);

		int aResult = ::MultiByteToWideChar (encoding,
											 0,
											 otherString,
											 aSize,
											 (WCHAR *) aBuf.Buffer (),
											 aBufChars);

		if (aResult > 0 && aResult <= aBufChars)
			{

			uint16 * aUTF16 = aBuf.Buffer_uint16 ();

			aUTF16 [aResult] = 0;

			dngString.Set_UTF16 (aUTF16);

			return;

			}

		}

	dngString.Clear ();

	}

static uint32 Extract_Multibyte (const dng_string &dngString,
							     dng_memory_data &buffer,
							     UINT encoding)
	{

	// This function contains security-vulnerable code. Do not use.
	// The particular vulnerabilities are:
	// - Converting the return value of dngString.Get_UTF16() may cause
	//   overflow.
	// - The computation of dBufSize may overflow.
	// - The calls to the dng_memory_data constructor and to buffer.Allocate()
	//   trigger implicit conversions of int to uint32 that may be problematic.
	// - The memcpy() call triggers an implicit conversion of aResult to a
	//   size_t, which may be problematic.
	// - The conversion of aResult to a uint32 in the return statement may be
	//   problematic.
	ThrowNotHardened();

	DNG_ASSERT (sizeof (WCHAR) == 2, "WCHAR must be 2 bytes");

	dng_memory_data sBuffer;

	int aCount = dngString.Get_UTF16 (sBuffer);

	int dBufSize = aCount * 2 + 256;

	dng_memory_data dBuffer (dBufSize);

	int aResult = ::WideCharToMultiByte (encoding,
										 0,
										 (WCHAR *) sBuffer.Buffer (),
										 aCount,
										 dBuffer.Buffer_char (),
										 dBufSize,
										 NULL,
										 NULL);

	if (aResult < 0)
		aResult = 0;

	buffer.Allocate (aResult + 1);

	memcpy (buffer.Buffer (),
			dBuffer.Buffer (),
			aResult);

	buffer.Buffer_char () [aResult] = 0;

	return (uint32) aResult;

	}

static void Assign_SystemEncoding (dng_string &dngString,
							       const char *otherString)
	{

	Assign_Multibyte (dngString,
					  otherString,
					  ::GetACP ());

	}

static uint32 Extract_SystemEncoding (const dng_string &dngString,
							   		  dng_memory_data &buffer)
	{

	return Extract_Multibyte (dngString,
					   		  buffer,
					   		  ::GetACP ());

	}

static void Assign_JIS_X208_1990 (dng_string &dngString,
							      const char *otherString)
	{

	// From MSDN documentation: 20932 = JIS X 0208-1990 & 0121-1990

	const UINT kJIS = 20932;

	Assign_Multibyte (dngString,
					  otherString,
					  kJIS);

	}

#endif

/*****************************************************************************/

static bool IsASCII (const char *s)
	{

	if (!s)
		{

		return true;

		}

	while (true)
		{

		uint8 c = (uint8) *(s++);

		if (c == 0)
			{

			break;

			}

		if (c & 0x80)
			{

			return false;

			}

		}

	return true;

	}

/*****************************************************************************/

dng_string::dng_string ()

	:	fData ()

	{

	}

/*****************************************************************************/

dng_string::dng_string (const dng_string &s)

	:	fData ()

	{

	Set (s.Get ());

	}

/*****************************************************************************/

dng_string & dng_string::operator= (const dng_string &s)
	{

	if (this != &s)
		{

		Set (s.Get ());

		}

	return *this;

	}

/*****************************************************************************/

dng_string::~dng_string ()
	{

	}

/*****************************************************************************/

const char * dng_string::Get () const
	{

	if (fData.Buffer ())
		{

		return fData.Buffer_char ();

		}

	return "";

	}

/*****************************************************************************/

bool dng_string::IsASCII () const
	{

	return ::IsASCII (Get ());

	}

/*****************************************************************************/

void dng_string::Set (const char *s)
	{

	// Measure the new length.

	uint32 newLen = (s != NULL ? strlenAsUint32 (s) : 0);

	// If it is a NULL string, then clear the buffer.

	if (newLen == 0)
		{

		fData.Clear ();

		}

	// Else we need to copy the bytes.

	else
		{

		uint32 oldLen = Length ();

		// We might be setting this string to a sub-string of itself,
		// so don't reallocate the data unless the string is getting
		// longer.

		if (newLen > oldLen)
			{

			fData.Clear ();

			fData.Allocate (SafeUint32Add (newLen, 1));

			}

		char *d = fData.Buffer_char ();

		for (uint32 k = 0; k <= newLen; k++)
			{

			d [k] = s [k];

			}

		}

	}

/*****************************************************************************/

void dng_string::Set_ASCII (const char *s)
	{

	if (::IsASCII (s))
		{

		Set (s);

		}

	else
		{

		Set_SystemEncoding (s);

		}

	}

/*****************************************************************************/

void dng_string::Set_UTF8 (const char *s)
	{

	uint32 len = strlenAsUint32 (s);

	const char *sEnd = s + len;

	// Worst case expansion is 1-byte characters expanding to
	// replacement character, which requires 3 bytes.

	const uint32 destBufferLength = SafeUint32Add (SafeUint32Mult (len, 3), 1);
	dng_memory_data buffer (destBufferLength);

	uint8 *d = buffer.Buffer_uint8 ();
	uint8 * const destEnd = d + destBufferLength;

	while (s < sEnd)
		{

		uint32 aChar = DecodeUTF8 (s, (uint32) (sEnd - s));

		if (aChar > 0x7FFFFFFF)
			{
			aChar = kREPLACEMENT_CHARACTER;
			}

		#if qDNGValidate

		if (aChar == kREPLACEMENT_CHARACTER)
			{
			ReportWarning ("Expected UTF-8 value is not valid UTF-8 (or contains a kREPLACEMENT_CHARACTER)");
			}

		#endif

		if (aChar < 0x00000080)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 1);
			*(d++) = (uint8) aChar;
			}

		else if (aChar < 0x00000800)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 2);
			*(d++) = (uint8) ((aChar >> 6) | 0x000000C0);
			*(d++) = (uint8) ((aChar & 0x0000003F) | 0x00000080);
			}

		else if (aChar < 0x00010000)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 3);
			*(d++) = (uint8) ( (aChar >> 12) | 0x000000E0);
			*(d++) = (uint8) (((aChar >>  6) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080);
			}

		else if (aChar < 0x00200000)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 4);
			*(d++) = (uint8) ( (aChar >> 18) | 0x000000F0);
			*(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >>  6) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080);
			}

		else if (aChar < 0x04000000)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 5);
			*(d++) = (uint8) ( (aChar >> 24) | 0x000000F8);
			*(d++) = (uint8) (((aChar >> 18) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >>  6) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080);
			}

		else
			{
			CheckSpaceLeftInBuffer (d, destEnd, 6);
			*(d++) = (uint8) ( (aChar >> 30) | 0x000000FC);
			*(d++) = (uint8) (((aChar >> 24) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >> 18) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >>  6) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080);
			}

		}

	CheckSpaceLeftInBuffer (d, destEnd, 1);
	*d = 0;

	Set (buffer.Buffer_char ());

	}

/*****************************************************************************/

uint32 dng_string::Get_SystemEncoding (dng_memory_data &buffer) const
	{

	if (IsASCII ())
		{

		uint32 len = Length ();

		const uint32 destBufferLength = SafeUint32Add (len, 1);
		buffer.Allocate (destBufferLength);

		memcpy (buffer.Buffer (), Get (), destBufferLength);

		return len;

		}

	else
		{

		#if qMacOS || qWinOS

		return Extract_SystemEncoding (*this, buffer);

		#else

		// Fallback logic to force the string to ASCII.

		dng_string temp (*this);

		temp.ForceASCII ();

		return temp.Get_SystemEncoding (buffer);

		#endif

		}

	}

/*****************************************************************************/

void dng_string::Set_SystemEncoding (const char *s)
	{

	if (::IsASCII (s))
		{

		Set (s);

		}

	else
		{

		#if qMacOS || qWinOS

		Assign_SystemEncoding (*this, s);

		#else

		// Fallback logic that just grabs the ASCII characters and
		// ignores the non-ASCII characters.

		uint32 len = strlenAsUint32 (s);

		const uint32 destBufferLength = SafeUint32Add (len, 1);
		dng_memory_data buffer (destBufferLength);

		uint8 *d = buffer.Buffer_uint8 ();
		uint8 * const destEnd = d + destBufferLength;

		while (*s)
			{

			uint8 c = (uint8) *(s++);

			if ((c & 0x80) == 0)
				{

				CheckSpaceLeftInBuffer (d, destEnd, 1);
				*(d++) = c;

				}

			}

		CheckSpaceLeftInBuffer (d, destEnd, 1);
		*d = 0;

		Set (buffer.Buffer_char ());

		#endif

		}

	}

/*****************************************************************************/

bool dng_string::ValidSystemEncoding () const
	{

	if (IsASCII ())
		{

		return true;

		}

	dng_memory_data buffer;

	Get_SystemEncoding (buffer);

	dng_string temp;

	temp.Set_SystemEncoding (buffer.Buffer_char ());

	return (*this == temp);

	}

/*****************************************************************************/

void dng_string::Set_JIS_X208_1990 (const char *s)
	{

	if (::IsASCII (s))
		{

		Set (s);

		}

	else
		{

		#if qMacOS || qWinOS

		Assign_JIS_X208_1990 (*this, s);

		#else

		// Fallback to the ASCII extraction logic.

		Set_SystemEncoding (s);

		#endif

		}

	}

/*****************************************************************************/

uint32 dng_string::DecodeUTF8 (const char *&s,
							   uint32 maxBytes,
							   bool *isValid)
	{

	static const uint8 gUTF8Bytes [256] =
		{
		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
		3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0
		};

	if (isValid)
		{
		*isValid = true;
		}

	const uint8 *nBuf = (const uint8 *) s;

	uint32 aChar = nBuf [0];

	uint32 aSize = gUTF8Bytes [aChar];

	if (aSize > maxBytes)
		{

		s += maxBytes;

		if (isValid)
			{
			*isValid = false;
			}

		return kREPLACEMENT_CHARACTER;

		}

	s += aSize;

	for (uint32 extra = 1; extra < aSize; extra++)
		{

		if ((nBuf [extra] & 0xC0) != 0x80)
			{

			if (isValid)
				{
				*isValid = false;
				}

			return kREPLACEMENT_CHARACTER;

			}

		}

	switch (aSize)
		{

		case 0:
			{

			s++;		// Don't get stuck in infinite loop

			if (isValid)
				{
				*isValid = false;
				}

			return kREPLACEMENT_CHARACTER;

			}

		case 1:
			{

			return aChar;

			}

		case 2:
			{

			aChar = ((aChar << 6) + nBuf [1]) - (uint32) 0x00003080UL;

			break;

			}

		case 3:
			{

			aChar =  ((((aChar << 6) + nBuf [1])
							   << 6) + nBuf [2]) - (uint32) 0x000E2080UL;

			break;

			}

		case 4:
			{

			aChar = ((((((aChar << 6) + nBuf [1])
							    << 6) + nBuf [2])
								<< 6) + nBuf [3]) - (uint32) 0x03C82080UL;

			break;

			}
		}

	if (aChar < 0x7F || aChar > 0x0010FFFF)
		{

		if (isValid)
			{
			*isValid = false;
			}

		return kREPLACEMENT_CHARACTER;

		}

	return aChar;

	}

/*****************************************************************************/

bool dng_string::IsUTF8 (const char *s)
	{

	uint32 len = strlenAsUint32 (s);

	const char *sEnd = s + len;

	while (s < sEnd)
		{

		bool isValid = true;

		(void) DecodeUTF8 (s, (uint32) (sEnd - s), &isValid);

		if (!isValid)
			{
			return false;
			}

		}

	return true;

	}

/*****************************************************************************/

void dng_string::Set_UTF8_or_System (const char *s)
	{

	if (::IsASCII (s))
		{

		Set (s);

		}

	else if (IsUTF8 (s))
		{

		Set_UTF8 (s);

		}

	else
		{

		Set_SystemEncoding (s);

		}

	}

/*****************************************************************************/

uint32 dng_string::Get_UTF16 (dng_memory_data &buffer) const
	{

	uint32 count = 0;

	const char *sPtr = Get ();

	while (*sPtr)
		{

		uint32 x = DecodeUTF8 (sPtr);

		if (x <= 0x0000FFFF ||
			x >  0x0010FFFF)
			{

			count = SafeUint32Add (count, 1);

			}

		else
			{

			count = SafeUint32Add (count, 2);

			}

		}

	const uint32 destBufferLength = SafeUint32Add (count, 1);
	buffer.Allocate (destBufferLength, sizeof (uint16));

	uint16 *dPtr = buffer.Buffer_uint16 ();
	uint16 * const destEnd = dPtr + destBufferLength;

	sPtr = Get ();

	while (*sPtr)
		{

		uint32 x = DecodeUTF8 (sPtr);

		if (x <= 0x0000FFFF)
			{

			CheckSpaceLeftInBuffer (dPtr, destEnd, 1);
			*(dPtr++) = (uint16) x;

			}

		else if (x > 0x0010FFFF)
			{

			CheckSpaceLeftInBuffer (dPtr, destEnd, 1);
			*(dPtr++) = (uint16) kREPLACEMENT_CHARACTER;

			}

		else
			{

			x -= 0x00010000;

			CheckSpaceLeftInBuffer (dPtr, destEnd, 2);
			*(dPtr++) = (uint16) ((x >> 10       ) + 0x0000D800);
			*(dPtr++) = (uint16) ((x & 0x000003FF) + 0x0000DC00);

			}

		}

	CheckSpaceLeftInBuffer (dPtr, destEnd, 1);
	*dPtr = 0;

	return count;

	}

/*****************************************************************************/

void dng_string::Set_UTF16 (const uint16 *s)
	{

	if (!s)
		{
		Clear ();
		return;
		}

	bool swap = false;

	if (s [0] == 0xFFFE)		// Swapped byte order marker
		{
		swap = true;
		s++;
		}

	else if (s [0] == 0xFEFF)	// Non-swapped byte order marker
		{
		s++;
		}

	uint32 length16 = 0;

	while (s [length16] != 0)
		{
		length16 = SafeUint32Add (length16, 1);
		}

	const uint16 *sEnd = s + length16;

	const uint32 destBufferSize =
		SafeUint32Add (SafeUint32Mult (length16, 6), 1);
	dng_memory_data buffer (destBufferSize);

	uint8 *d = buffer.Buffer_uint8 ();
	uint8 * const destEnd = d + destBufferSize;

	while (s < sEnd)
		{

		uint32 aChar = *s++;

		if (swap)
			{
			aChar = ((aChar << 8) | (aChar >> 8)) & 0x0000FFFF;
			}

		if ((aChar >= 0x0000D800) && (aChar <= 0x0000DBFF) && (s < sEnd))
			{

			uint32 aLow = *s;

			if (swap)
				{
				aLow = ((aLow << 8) | (aLow >> 8)) & 0x0000FFFF;
				}

			if ((aLow >= 0x0000DC00) && (aLow <= 0x0000DFFF))
				{

				aChar = ((aChar - 0x0000D800) << 10) +
					    (aLow - 0x0000DC00) +
					    0x00010000;

				s++;

				}

			}

		if (aChar > 0x7FFFFFFF)
			{
			aChar = kREPLACEMENT_CHARACTER;
			}

		if (aChar < 0x00000080)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 1);
			*(d++) = (uint8) aChar;
			}

		else if (aChar < 0x00000800)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 2);
			*(d++) = (uint8) ((aChar >> 6) | 0x000000C0);
			*(d++) = (uint8) ((aChar & 0x0000003F) | 0x00000080);
			}

		else if (aChar < 0x00010000)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 3);
			*(d++) = (uint8) ( (aChar >> 12) | 0x000000E0);
			*(d++) = (uint8) (((aChar >>  6) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080);
			}

		else if (aChar < 0x00200000)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 4);
			*(d++) = (uint8) ( (aChar >> 18) | 0x000000F0);
			*(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >>  6) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080);
			}

		else if (aChar < 0x04000000)
			{
			CheckSpaceLeftInBuffer (d, destEnd, 5);
			*(d++) = (uint8) ( (aChar >> 24) | 0x000000F8);
			*(d++) = (uint8) (((aChar >> 18) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >>  6) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080);
			}

		else
			{
			CheckSpaceLeftInBuffer (d, destEnd, 6);
			*(d++) = (uint8) ( (aChar >> 30) | 0x000000FC);
			*(d++) = (uint8) (((aChar >> 24) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >> 18) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >> 12) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) (((aChar >>  6) & 0x0000003F) | 0x00000080);
			*(d++) = (uint8) ( (aChar & 0x0000003F) | 0x00000080);
			}

		}

	CheckSpaceLeftInBuffer (d, destEnd, 1);
	*d = 0;

	Set (buffer.Buffer_char ());

	}

/*****************************************************************************/

void dng_string::Clear ()
	{

	Set (NULL);

	}

/*****************************************************************************/

void dng_string::Truncate (uint32 maxBytes)
	{

	uint32 len = Length ();

	if (len > maxBytes)
		{

		uint8 *s = fData.Buffer_uint8 ();

		// Don't truncate on an extension character.  Extensions characters
		// in UTF-8 have the 0x80 bit set and the 0x40 bit clear.

		while (maxBytes > 0 && ((s [maxBytes]) & 0xC0) == 0x80)
			{

			maxBytes--;

			}

		s [maxBytes] = 0;

		}

	}

/*****************************************************************************/

bool dng_string::TrimTrailingBlanks ()
	{

	bool didTrim = false;

	if (fData.Buffer ())
		{

		char *s = fData.Buffer_char ();

		uint32 len = strlenAsUint32 (s);

		while (len > 0 && s [len - 1] == ' ')
			{
			len--;
			didTrim = true;
			}

		s [len] = 0;

		}

	return didTrim;

	}

/*****************************************************************************/

bool dng_string::TrimLeadingBlanks ()
	{

	bool didTrim = false;

	const char *s = Get ();

	while (*s == ' ')
		{
		s++;
		didTrim = true;
		}

	if (didTrim)
		{
		Set (s);
		}

	return didTrim;

	}

/*****************************************************************************/

bool dng_string::IsEmpty () const
	{

	const char *s = Get ();

	return *s == 0;

	}

/*****************************************************************************/

uint32 dng_string::Length () const
	{

	const char *s = Get ();

	return strlenAsUint32 (s);

	}

/*****************************************************************************/

bool dng_string::operator== (const dng_string &s) const
	{

	const char *s1 =   Get ();
	const char *s2 = s.Get ();

	return strcmp (s1, s2) == 0;

	}

/*****************************************************************************/

bool dng_string::Matches (const char *t,
						  const char *s,
						  bool case_sensitive)
	{

	while (*s != 0)
		{

		char c1 = *(s++);
		char c2 = *(t++);

		if (!case_sensitive)
			{
			c1 = ForceUppercase (c1);
			c2 = ForceUppercase (c2);
			}

		if (c1 != c2)
			{
			return false;
			}

		}

	return (*t == 0);

	}

/*****************************************************************************/

bool dng_string::Matches (const char *s,
						  bool case_sensitive) const
	{

	return dng_string::Matches (Get (), s, case_sensitive);

	}

/*****************************************************************************/

bool dng_string::StartsWith (const char *s,
						     bool case_sensitive) const
	{

	const char *t = Get ();

	while (*s != 0)
		{

		char c1 = *(s++);
		char c2 = *(t++);

		if (!case_sensitive)
			{
			c1 = ForceUppercase (c1);
			c2 = ForceUppercase (c2);
			}

		if (c1 != c2)
			{
			return false;
			}

		}

	return true;

	}

/*****************************************************************************/

bool dng_string::EndsWith (const char *s,
						   bool case_sensitive) const
	{

	uint32 len1 = Length ();

	uint32 len2 = strlenAsUint32 (s);

	if (len1 < len2)
		{
		return false;
		}

	const char *t = Get () + (len1 - len2);

	while (*s != 0)
		{

		char c1 = *(s++);
		char c2 = *(t++);

		if (!case_sensitive)
			{
			c1 = ForceUppercase (c1);
			c2 = ForceUppercase (c2);
			}

		if (c1 != c2)
			{
			return false;
			}

		}

	return true;

	}

/*****************************************************************************/

bool dng_string::Contains (const char *s,
						   bool case_sensitive,
						   int32 *match_offset) const
	{

	if (match_offset)
		{
		*match_offset = -1;
		}

	uint32 len1 = Length ();

	uint32 len2 = strlenAsUint32 (s);

	if (len1 < len2)
		{
		return false;
		}

	uint32 offsets = len1 - len2;

	for (uint32 offset = 0; offset <= offsets; offset++)
		{

		const char *ss = s;
		const char *tt = Get () + offset;

		while (*ss != 0)
			{

			char c1 = *(ss++);
			char c2 = *(tt++);

			if (!case_sensitive)
				{
				c1 = ForceUppercase (c1);
				c2 = ForceUppercase (c2);
				}

			if (c1 != c2)
				{
				goto tryNextOffset;
				}

			}

		if (match_offset)
			{
			*match_offset = offset;
			}

		return true;

		tryNextOffset:	;

		}

	return false;

	}

/*****************************************************************************/

bool dng_string::Replace (const char *old_string,
						  const char *new_string,
						  bool case_sensitive)
	{

	int32 match_offset = -1;

	if (Contains (old_string,
				  case_sensitive,
				  &match_offset))
		{

		uint32 len1 = Length ();

		uint32 len2 = strlenAsUint32 (old_string);
		uint32 len3 = strlenAsUint32 (new_string);

		if (len2 == len3)
			{

			strncpy (fData.Buffer_char () + match_offset,
					 new_string,
					 len3);

			}

		else if (len2 > len3)
			{

			strncpy (fData.Buffer_char () + match_offset,
					 new_string,
					 len3);

			const char *s = fData.Buffer_char () + match_offset + len2;
				  char *d = fData.Buffer_char () + match_offset + len3;

			uint32 extra = len1 - match_offset - len2 + 1;	// + 1 for NULL termination

			for (uint32 j = 0; j < extra; j++)
				{
				*(d++) = *(s++);
				}

			}

		else
			{

			// "len1 - len2" cannot wrap around because we know that if this
			// string contains old_string, len1 >= len2 must hold.
			dng_memory_data tempBuffer (
				SafeUint32Add (SafeUint32Add (len1 - len2, len3), 1));

			if (match_offset)
				{

				strncpy (tempBuffer.Buffer_char (),
						 fData     .Buffer_char (),
						 match_offset);

				}

			if (len3)
				{

				strncpy (tempBuffer.Buffer_char () + match_offset,
						 new_string,
						 len3);

				}

			uint32 extra = len1 - match_offset - len2 + 1;	// + 1 for NULL termination

			strncpy (tempBuffer.Buffer_char () + match_offset + len3,
					 fData     .Buffer_char () + match_offset + len2,
					 extra);

			Set (tempBuffer.Buffer_char ());

			}

		return true;

		}

	return false;

	}

/*****************************************************************************/

bool dng_string::TrimLeading (const char *s,
						      bool case_sensitive)
	{

	if (StartsWith (s, case_sensitive))
		{

		Set (Get () + strlenAsUint32 (s));

		return true;

		}

	return false;

	}

/*****************************************************************************/

void dng_string::Append (const char *s)
	{

	uint32 len2 = strlenAsUint32 (s);

	if (len2)
		{

		uint32 len1 = Length ();

		dng_memory_data temp (SafeUint32Add (SafeUint32Add (len1, len2), 1));

		char *buffer = temp.Buffer_char ();

		if (len1)
			{
			memcpy (buffer, Get (), len1);
			}

		memcpy (buffer + len1, s, len2 + 1);

		Set (buffer);

		}

	}

/*****************************************************************************/

void dng_string::SetUppercase ()
	{

	if (fData.Buffer ())
		{

		uint32 len = Length ();

		char *dPtr = fData.Buffer_char ();

		for (uint32 j = 0; j < len; j++)
			{

			char c = dPtr [j];

			if (c >= 'a' && c <= 'z')
				{

				dPtr [j] = c - 'a' + 'A';

				}

			}

		}

	}

/*****************************************************************************/

void dng_string::SetLowercase ()
	{

	if (fData.Buffer ())
		{

		uint32 len = Length ();

		char *dPtr = fData.Buffer_char ();

		for (uint32 j = 0; j < len; j++)
			{

			char c = dPtr [j];

			if (c >= 'A' && c <= 'Z')
				{

				dPtr [j] = c - 'A' + 'a';

				}

			}

		}

	}

/*****************************************************************************/

void dng_string::SetLineEndings (char ending)
	{

	if (fData.Buffer ())
		{

		const char *sPtr = fData.Buffer_char ();
		      char *dPtr = fData.Buffer_char ();

		while (*sPtr)
			{

			char c = *(sPtr++);

			char nc = sPtr [0];

			if ((c == '\r' && nc == '\n') ||
				(c == '\n' && nc == '\r'))
				{

				sPtr++;

				if (ending)
					{
					*(dPtr++) = ending;
					}

				}

			else if (c == '\n' ||
					 c == '\r')
				{

				if (ending)
					{
					*(dPtr++) = ending;
					}

				}

			else
				{

				*(dPtr++) = c;

				}

			}

		*dPtr = 0;

		}

	}

/*****************************************************************************/

void dng_string::StripLowASCII ()
	{

	if (fData.Buffer ())
		{

		const char *sPtr = fData.Buffer_char ();
		      char *dPtr = fData.Buffer_char ();

		while (*sPtr)
			{

			char c = *(sPtr++);

			if (c == '\r' || c == '\n' || (uint8) c >= ' ')
				{

				*(dPtr++) = c;

				}

			}

		*dPtr = 0;

		}

	}

/*****************************************************************************/

void dng_string::NormalizeAsCommaSeparatedNumbers ()
	{

	if (fData.Buffer ())
		{

		const char *sPtr = fData.Buffer_char ();
			  char *dPtr = fData.Buffer_char ();

		bool commaInserted = false;

		while (*sPtr)
			{

			uint32 c = DecodeUTF8 (sPtr);

			// Support number formats such as "3", "+3.0", "-3.1416", "314.16e-2",
			// "0.31416E1", but no hex/octal number representations.

			if (isdigit ((int) c) || c == '.' || c == '-' || c == '+' || c == 'e' || c == 'E')
				{

				*(dPtr++) = (char) c;

				if (commaInserted)
					{

					commaInserted = false;

					}

				}

			else if (!commaInserted)
				{

				*(dPtr++) = ',';

				commaInserted = true;

				}

			}

		*dPtr = 0;

		}

	}

/******************************************************************************/

// Unicode to low-ASCII strings table.

struct UnicodeToLowASCIIEntry
	{
	uint32 unicode;
	const char *ascii;
	};

static const UnicodeToLowASCIIEntry kUnicodeToLowASCII [] =
	{
	{	0x00A0, " "		},
	{	0x00A1, "!"		},
	{	0x00A9, "(C)"	},
	{	0x00AA, "a"		},
	{	0x00AB, "<<"	},
	{	0x00AC, "!"		},
	{	0x00AE, "(R)"	},
	{	0x00B0, "dg"	},
	{	0x00B1, "+-"	},
	{	0x00B7, "."		},
	{	0x00BA, "o"		},
	{	0x00BB, ">>"	},
	{	0x00BF, "?"		},
	{	0x00C0, "A"		},
	{	0x00C1, "A"		},
	{	0x00C2, "A"		},
	{	0x00C3, "A"		},
	{	0x00C4, "A"		},
	{	0x00C5, "A"		},
	{	0x00C6, "AE"	},
	{	0x00C7, "C"		},
	{	0x00C8, "E"		},
	{	0x00C9, "E"		},
	{	0x00CA, "E"		},
	{	0x00CB, "E"		},
	{	0x00CC, "I"		},
	{	0x00CD, "I"		},
	{	0x00CE, "I"		},
	{	0x00CF, "I"		},
	{	0x00D1, "N"		},
	{	0x00D2, "O"		},
	{	0x00D3, "O"		},
	{	0x00D4, "O"		},
	{	0x00D5, "O"		},
	{	0x00D6, "O"		},
	{	0x00D8, "O"		},
	{	0x00D9, "U"		},
	{	0x00DA, "U"		},
	{	0x00DB, "U"		},
	{	0x00DC, "U"		},
	{	0x00DD, "Y"		},
	{	0x00E0, "a"		},
	{	0x00E1, "a"		},
	{	0x00E2, "a"		},
	{	0x00E3, "a"		},
	{	0x00E4, "a"		},
	{	0x00E5, "a"		},
	{	0x00E6, "ae"	},
	{	0x00E7, "c"		},
	{	0x00E8, "e"		},
	{	0x00E9, "e"		},
	{	0x00EA, "e"		},
	{	0x00EB, "e"		},
	{	0x00EC, "i"		},
	{	0x00ED, "i"		},
	{	0x00EE, "i"		},
	{	0x00EF, "i"		},
	{	0x00F1, "n"		},
	{	0x00F2, "o"		},
	{	0x00F3, "o"		},
	{	0x00F4, "o"		},
	{	0x00F5, "o"		},
	{	0x00F6, "o"		},
	{	0x00F7, "/"		},
	{	0x00F8, "o"		},
	{	0x00F9, "u"		},
	{	0x00FA, "u"		},
	{	0x00FB, "u"		},
	{	0x00FC, "u"		},
	{	0x00FD, "y"		},
	{	0x00FF, "y"		},
	{	0x0131, "i"		},
	{	0x0152, "OE"	},
	{	0x0153, "oe"	},
	{	0x0178, "Y"		},
	{	0x2013, "-"		},
	{	0x2014, "-"		},
	{	0x2018, "'"		},
	{	0x2019, "'"		},
	{	0x201A, ","		},
	{	0x201C, "\""	},
	{	0x201D, "\""	},
	{	0x201E, ",,"	},
	{	0x2022, "."		},
	{	0x2026, "..."	},
	{	0x2039, "<"		},
	{	0x203A, ">"		},
	{	0x2044, "/"		},
	{	0x2122, "TM"	},
	{	0x2206, "d"		},
	{	0x2211, "S"		},
	{	0x2260, "!="	},
	{	0x2264, "<="	},
	{	0x2265, ">="	},
	{	0x2318, "#"		},
	{	0xFB01, "fi"	},
	{	0xFB02, "fl"	}
	};

/******************************************************************************/

void dng_string::ForceASCII ()
	{

	if (!IsASCII ())
		{

		uint32 tempBufferSize =
			SafeUint32Add (SafeUint32Mult(Length(), 3), 1);
		dng_memory_data tempBuffer (tempBufferSize);

		char *dPtr = tempBuffer.Buffer_char ();
		char * const destEnd = dPtr + tempBufferSize;

		const char *sPtr = Get ();

		while (*sPtr)
			{

			uint32 x = DecodeUTF8 (sPtr);

			if (x <= 0x007F)
				{

				CheckSpaceLeftInBuffer (dPtr, destEnd, 1);
				*(dPtr++) = (char) x;

				}

			else
				{

				const char *ascii = NULL;

				const uint32 kTableEntrys = sizeof (kUnicodeToLowASCII    ) /
									        sizeof (kUnicodeToLowASCII [0]);

				for (uint32 entry = 0; entry < kTableEntrys; entry++)
					{

					if (kUnicodeToLowASCII [entry] . unicode == x)
						{

						ascii = kUnicodeToLowASCII [entry] . ascii;

						break;

						}

					}

				if (ascii)
					{

					while (*ascii)
						{

						CheckSpaceLeftInBuffer (dPtr, destEnd, 1);
						*(dPtr++) = *(ascii++);

						}

					}

				else
					{

					CheckSpaceLeftInBuffer (dPtr, destEnd, 1);
					*(dPtr++) ='?';

					}

				}

			}

		CheckSpaceLeftInBuffer (dPtr, destEnd, 1);
		*dPtr = 0;

		Set (tempBuffer.Buffer_char ());

		}

	}

/******************************************************************************/

static dng_mutex gProtectUCCalls ("gProtectUCCalls");

/******************************************************************************/

int32 dng_string::Compare (const dng_string &s) const
	{

	#if qMacOS
	#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR

		// TODO: Needs implementation.
		ThrowProgramError ("Compare() not implemented on iOS");
		return 0;

	#else

		{

		dng_memory_data aStrA;
		dng_memory_data aStrB;

		uint32 aLenA = this->Get_UTF16 (aStrA);
		uint32 aLenB = s    .Get_UTF16 (aStrB);

		if (aLenA > 0)
			{

			if (aLenB > 0)
				{

				// For some Mac OS versions anyway, UCCompareTextDefault is not
				// thread safe.

				dng_lock_mutex lockMutex (&gProtectUCCalls);

				UCCollateOptions aOptions = kUCCollateStandardOptions |
											kUCCollatePunctuationSignificantMask;

				SInt32 aOrder = -1;

				Boolean aEqual = false;

				OSStatus searchStatus = ::UCCompareTextDefault (aOptions,
																aStrA.Buffer_uint16 (),
																aLenA,
																aStrB.Buffer_uint16 (),
																aLenB,
																&aEqual,
																&aOrder);

				if (searchStatus == noErr)
					{

					if (aEqual || (aOrder == 0))
						{
						return 0;
						}

					else
						{
						return (aOrder > 0) ? 1 : -1;
						}

					}

				else
					{

					DNG_REPORT ("UCCompareTextDefault failed");

					return -1;

					}

				}

			else
				{
				return 1;
				}

			}

		else
			{

			if (aLenB > 0)
				{
				return -1;
				}

			else
				{
				return 0;
				}

			}

		}

	#endif  // TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR

	#elif qWinOS

		{

		dng_memory_data aStrA;
		dng_memory_data aStrB;

		uint32 aLenA = this->Get_UTF16 (aStrA);
		uint32 aLenB = s    .Get_UTF16 (aStrB);

		if (aLenA > 0)
			{

			if (aLenB > 0)
				{

				LCID locale = LOCALE_SYSTEM_DEFAULT;

				DWORD aFlags = NORM_IGNOREWIDTH;

				int aOrder = ::CompareStringW (locale,
											   aFlags,
											   (const WCHAR *) aStrA.Buffer_uint16 (),
											   aLenA,
											   (const WCHAR *) aStrB.Buffer_uint16 (),
											   aLenB);

				if (aOrder == CSTR_EQUAL)
					{
					return 0;
					}

				else if (aOrder == CSTR_GREATER_THAN)
					{
					return 1;
					}

				else
					{
					return -1;
					}

				}

			else
				{
				return 1;
				}

			}

		else
			{

			if (aLenB > 0)
				{
				return -1;
				}
			else
				{
				return 0;
				}

			}

		}

	#else

	// Fallback to a pure Unicode sort order.

		{

		for (uint32 pass = 0; pass < 2; pass++)
			{

			const char *aPtr =   Get ();
			const char *bPtr = s.Get ();

			while (*aPtr || *bPtr)
				{

				if (!bPtr)
					{
					return 1;
					}

				else if (!aPtr)
					{
					return -1;
					}

				uint32 a = DecodeUTF8 (aPtr);
				uint32 b = DecodeUTF8 (bPtr);

				// Ignore case on first compare pass.

				if (pass == 0)
					{

					if (a >= (uint32) 'a' && a <= (uint32) 'z')
						{
						a = a - (uint32) 'a' + (uint32) 'A';
						}

					if (b >= (uint32) 'a' && b <= (uint32) 'z')
						{
						b = b - (uint32) 'a' + (uint32) 'A';
						}

					}

				if (b > a)
					{
					return 1;
					}

				else if (a < b)
					{
					return -1;
					}

				}

			}

		}

	#endif

	return 0;

	}

/*****************************************************************************/