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

// 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");

    }

  }

dng_string.cpp:void CheckSpaceLeftInBuffer<unsigned char>(unsigned char const*, unsigned char const*, unsigned long)

Line

Count

Source

71

32.8M

  {

72

73

32.8M

  if (bufferEnd < currentPos || static_cast<size_t>(bufferEnd - currentPos) < space)

74

0

    {

75

0

    ThrowMemoryFull ("Buffer overrun");

76

0

    }

77

78

32.8M

  }

dng_string.cpp:void CheckSpaceLeftInBuffer<unsigned short>(unsigned short const*, unsigned short const*, unsigned long)

Line

Count

Source

71

7.46k

  {

72

73

7.46k

  if (bufferEnd < currentPos || static_cast<size_t>(bufferEnd - currentPos) < space)

74

0

    {

75

0

    ThrowMemoryFull ("Buffer overrun");

76

0

    }

77

78

7.46k

  }

Unexecuted instantiation: dng_string.cpp:void CheckSpaceLeftInBuffer<char>(char const*, char const*, unsigned long)

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

// 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);