/*

 *

 *  Copyright (C) 2001-2026, OFFIS e.V.

 *  All rights reserved.  See COPYRIGHT file for details.

 *

 *  This software and supporting documentation were developed by

 *

 *    OFFIS e.V.

 *    R&D Division Health

 *    Escherweg 2

 *    D-26121 Oldenburg, Germany

 *

 *

 *  As an exception of the above notice, the code for OFStandard::strlcpy

 *  and OFStandard::strlcat in this file have been derived from the BSD

 *  implementation which carries the following copyright notice:

 *

 *  Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>

 *  All rights reserved.  See COPYRIGHT file for details.

 *

 *  Redistribution and use in source and binary forms, with or without

 *  modification, are permitted provided that the following conditions

 *  are met:

 *  1. Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *  2. Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *  3. The name of the author may not be used to endorse or promote products

 *     derived from this software without specific prior written permission.

 *

 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,

 *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY

 *  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL

 *  THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

 *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 *  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *

 *  The code for OFStandard::atof that is used when DCMTK is compiled

 *  with the macro ENABLE_OLD_OFSTD_ATOF_IMPLEMENTATION has been derived

 *  from an implementation that carries the following copyright notice:

 *

 *  Copyright 1988 Regents of the University of California

 *  Permission to use, copy, modify, and distribute this software and

 *  its documentation for any purpose and without fee is hereby granted,

 *  provided that the above copyright notice appear in all copies.  The

 *  University of California makes no representations about the

 *  suitability of this software for any purpose.  It is provided "as

 *  is" without express or implied warranty.

 *

 *

 *  The code for OFStandard::ftoa that is used when DCMTK is compiled

 *  with the macro ENABLE_OLD_OFSTD_FTOA_IMPLEMENTATION has been derived

 *  from an implementation that carries the following copyright notice:

 *

 *  Copyright (c) 1988 Regents of the University of California.

 *  All rights reserved.  See COPYRIGHT file for details.

 *

 *  Redistribution and use in source and binary forms are permitted

 *  provided that the above copyright notice and this paragraph are

 *  duplicated in all such forms and that any documentation,

 *  advertising materials, and other materials related to such

 *  distribution and use acknowledge that the software was developed

 *  by the University of California, Berkeley.  The name of the

 *  University may not be used to endorse or promote products derived

 *  from this software without specific prior written permission.

 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR

 *  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

 *  WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 *

 *

 *  The "Base64" encoder/decoder has been derived from an implementation

 *  with the following copyright notice:

 *

 *  Copyright (c) 1999, Bob Withers - bwit@pobox.com

 *

 *  This code may be freely used for any purpose, either personal or

 *  commercial, provided the authors copyright notice remains intact.

 *

 *

 *  Module: ofstd

 *

 *  Author: Joerg Riesmeier, Marco Eichelberg

 *

 *  Purpose: Class for various helper functions

 *

 */

#include "dcmtk/config/osconfig.h"    /* make sure OS specific configuration is included first */

#ifdef __SUNPRO_CC

BEGIN_EXTERN_C

// SunPro declares vsnprintf() only in <stdio.h>, not in <cstdio>.

#include <stdio.h>

END_EXTERN_C

#else

#include <cstdio>

#endif

#include "dcmtk/ofstd/ofstd.h"

#include "dcmtk/ofstd/ofcond.h"

#include "dcmtk/ofstd/offile.h"

#include "dcmtk/ofstd/ofstream.h"

#include "dcmtk/ofstd/oftuple.h"

#include "dcmtk/ofstd/ofmath.h"

#include "dcmtk/ofstd/ofsockad.h"

#include "dcmtk/ofstd/ofvector.h"

#include "dcmtk/ofstd/ofdiag.h"

#include "dcmtk/ofstd/oftimer.h"

#include <cmath>

#include <clocale>

#include <cstring>       /* for memset() */

#include <sstream>

BEGIN_EXTERN_C

#include <sys/stat.h>    /* for stat() */

#ifdef HAVE_IO_H

#include <io.h>          /* for access() on Win32 */

#endif

#include <sys/types.h>   /* for opendir() and closedir() */

#ifdef HAVE_DIRENT_H

#include <dirent.h>      /* for opendir() and closedir() */

#else

#define dirent direct

#ifdef HAVE_SYS_DIR_H

#include <sys/dir.h>

#endif

#endif

#ifdef HAVE_FNMATCH_H

#include <fnmatch.h>     /* for fnmatch() */

#endif

#ifdef HAVE_IEEEFP_H

#include <ieeefp.h>      /* for finite() on Solaris 2.5.1 */

#endif

#ifdef HAVE_SYS_UTSNAME_H

#include <sys/utsname.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#ifdef HAVE_NETDB_H

#include <netdb.h>

#endif

END_EXTERN_C

#ifdef HAVE_WINDOWS_H

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>

#include <windows.h>     /* for GetFileAttributes() */

#include <direct.h>      /* for _mkdir() */

#include <lm.h>          /* for NetWkstaUserGetInfo */

#include <ws2tcpip.h>    /* for struct sockaddr_in6 */

#ifndef R_OK /* Windows defines access() but not the constants */

#define W_OK 02 /* Write permission */

#define R_OK 04 /* Read permission */

#define F_OK 00 /* Existence only */

#endif /* !R_OK */

#elif defined(HAVE_WINSOCK_H)

#include <winsock.h>  /* include winsock.h directly i.e. on MacOS */

#endif /* HAVE_WINDOWS_H */

#ifdef _WIN32

#include <process.h>     /* needed for declaration of getpid() */

#endif

#include "dcmtk/ofstd/ofgrp.h"

#include "dcmtk/ofstd/ofpwd.h"

#include "dcmtk/ofstd/ofoption.h"

// check mutually exclusive feature macros for the implementations of OFStandard::atof() and OFStandard::ftoa()

#if defined (ENABLE_IOSTREAM_BASED_ATOF_IMPLEMENTATION) && defined (ENABLE_CSTDIO_BASED_ATOF_IMPLEMENTATION)

#error The macros ENABLE_IOSTREAM_BASED_ATOF_IMPLEMENTATION and ENABLE_CSTDIO_BASED_ATOF_IMPLEMENTATION must not both be defined

#endif

#if defined (ENABLE_OLD_OFSTD_ATOF_IMPLEMENTATION) && defined (ENABLE_IOSTREAM_BASED_ATOF_IMPLEMENTATION)

#error The macros ENABLE_OLD_OFSTD_ATOF_IMPLEMENTATION and ENABLE_IOSTREAM_BASED_ATOF_IMPLEMENTATION must not both be defined

#endif

#if defined (ENABLE_OLD_OFSTD_ATOF_IMPLEMENTATION) && defined (ENABLE_CSTDIO_BASED_ATOF_IMPLEMENTATION)

#error The macros ENABLE_OLD_OFSTD_ATOF_IMPLEMENTATION and ENABLE_CSTDIO_BASED_ATOF_IMPLEMENTATION must not both be defined

#endif

#if defined (ENABLE_IOSTREAM_BASED_FTOA_IMPLEMENTATION) && defined (ENABLE_CSTDIO_BASED_FTOA_IMPLEMENTATION)

#error The macros ENABLE_IOSTREAM_BASED_FTOA_IMPLEMENTATION and ENABLE_CSTDIO_BASED_FTOA_IMPLEMENTATION must not both be defined

#endif

#if defined (ENABLE_OLD_OFSTD_FTOA_IMPLEMENTATION) && defined (ENABLE_IOSTREAM_BASED_FTOA_IMPLEMENTATION)

#error The macros ENABLE_OLD_OFSTD_FTOA_IMPLEMENTATION and ENABLE_IOSTREAM_BASED_FTOA_IMPLEMENTATION must not both be defined

#endif

#if defined (ENABLE_OLD_OFSTD_FTOA_IMPLEMENTATION) && defined (ENABLE_CSTDIO_BASED_FTOA_IMPLEMENTATION)

#error The macros ENABLE_OLD_OFSTD_FTOA_IMPLEMENTATION and ENABLE_CSTDIO_BASED_FTOA_IMPLEMENTATION must not both be defined

#endif

// define defaults for OFStandard::atof() and OFStandard::ftoa()

#if !defined(ENABLE_OLD_OFSTD_ATOF_IMPLEMENTATION) && !defined(ENABLE_IOSTREAM_BASED_ATOF_IMPLEMENTATION) && !defined(ENABLE_CSTDIO_BASED_ATOF_IMPLEMENTATION)

#ifdef _WIN32

// on Windows, the iostream-based implementation of atof is extremely slow,

// and we do have a locale independent version of sscanf. Use this version.

#define ENABLE_CSTDIO_BASED_ATOF_IMPLEMENTATION

#else

// on other platforms, we assume that the iobased-implementation, being the

// cleanest one, is appropriate. This is known to be the case for gcc and clang with glibc.

#define ENABLE_IOSTREAM_BASED_ATOF_IMPLEMENTATION

#endif

#endif

#if !defined(ENABLE_OLD_OFSTD_FTOA_IMPLEMENTATION) && !defined(ENABLE_IOSTREAM_BASED_FTOA_IMPLEMENTATION) && !defined(ENABLE_CSTDIO_BASED_FTOA_IMPLEMENTATION)

#ifdef _WIN32

// on Windows, the iostream-based implementation of atof is extremely slow,

// and we do have a locale independent version of sprintf, called _snprintf_s_l.

// Use this version.

#define ENABLE_CSTDIO_BASED_FTOA_IMPLEMENTATION

#else

// on other platforms, we assume that the iobased-implementation, being the

// cleanest one, is appropriate. This is known to be the case for gcc and clang with glibc.

#define ENABLE_IOSTREAM_BASED_FTOA_IMPLEMENTATION

#endif

#endif

// maximum number of repetitions for EAI_AGAIN

#define DCMTK_MAX_EAI_AGAIN_REPETITIONS 5

// --- ftoa() processing flags ---

const unsigned int OFStandard::ftoa_format_e  = 0x01;

const unsigned int OFStandard::ftoa_format_f  = 0x02;

const unsigned int OFStandard::ftoa_uppercase = 0x04;

const unsigned int OFStandard::ftoa_alternate = 0x08;

const unsigned int OFStandard::ftoa_leftadj   = 0x10;

const unsigned int OFStandard::ftoa_zeropad   = 0x20;

// --- string functions ---

#ifndef HAVE_STRLCPY

/*

 * Copy src to string dst of size siz.  At most siz-1 characters

 * will be copied.  Always NUL terminates (unless siz == 0).

 * Returns strlen(src); if retval >= siz, truncation occurred.

 */

size_t OFStandard::my_strlcpy(char *dst, const char *src, size_t siz)

{

  char *d = dst;

  const char *s = src;

  size_t n = siz;

  /* Copy as many bytes as will fit */

  if (n != 0 && --n != 0)

  {

    do

    {

      if ((*d++ = *s++) == 0)

         break;

    } while (--n != 0);

  }

  /* Not enough room in dst, add NUL and traverse rest of src */

  if (n == 0)

  {

     if (siz != 0)

        *d = '\0'; /* NUL-terminate dst */

     while (*s++) /* do nothing */ ;

  }

  return(s - src - 1);    /* count does not include NUL */

}

#endif /* HAVE_STRLCPY */

#ifndef HAVE_STRLCAT

/*

 * Appends src to string dst of size siz (unlike strncat, siz is the

 * full size of dst, not space left).  At most siz-1 characters

 * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).

 * Returns strlen(src) + MIN(siz, strlen(initial dst)).

 * If retval >= siz, truncation occurred.

 */

size_t OFStandard::my_strlcat(char *dst, const char *src, size_t siz)

{

  char *d = dst;

  const char *s = src;

  size_t n = siz;

  size_t dlen;

  /* Find the end of dst and adjust bytes left but don't go past end */

  while (n-- != 0 && *d != '\0') d++;

  dlen = d - dst;

  n = siz - dlen;

  if (n == 0) return(dlen + strlen(s));

  while (*s != '\0')

  {

    if (n != 1)

    {

      *d++ = *s;

      n--;

    }

    s++;

  }

  *d = '\0';

  return(dlen + (s - src));       /* count does not include NUL */

}

#endif /* HAVE_STRLCAT */

int OFStandard::snprintf(char *str, size_t size, const char *format, ...)

{

    // we emulate snprintf() via vsnprintf().

    int count;

    va_list ap;

    va_start(ap, format);

    count = OFStandard::vsnprintf(str, size, format, ap);

    va_end(ap);

    return count;

}

int OFStandard::vsnprintf(char *str, size_t size, const char *format, va_list ap)

{

#ifdef _MSC_VER

#if _MSC_VER < 1900

    // Visual Studio versions 2005 to 2013 do not have a C99 compliant

    // vsnprintf(), but they have _snprintf(), which can be used to emulate it.

    int count = -1;

    if (size != 0)

        count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);

    if (count == -1)

        count = _vscprintf(format, ap);

    return count;

#else /* _MSC_VER < 1900 */

    // Visual Studio 2015 and newer has a C99 compliant vsnprintf().

    return ::vsnprintf(str, size, format, ap);

#endif /* _MSC_VER < 1900 */

#else /* _MSC_VER */

    return ::vsnprintf(str, size, format, ap);

#endif /* _MSC_VER */

}

#ifdef HAVE_PROTOTYPE_STRERROR_R

/*

 * convert a given error code to a string. This function wraps the various

 * approaches found on different systems. Internally, the standard function

 * strerror() or strerror_r() is used.

 */

const char *OFStandard::strerror(const int errnum,

                                 char *buf,

                                 const size_t buflen)

{

    const char *result = "";

    if ((buf != NULL) && (buflen > 0))

    {

        // be paranoid and initialize the buffer to empty string

        buf[0] = 0;

        // two incompatible interfaces for strerror_r with different return types exist

#ifdef HAVE_CHARP_STRERROR_R

        // we're using the GNU specific version that returns the result, which may

        // or may not be a pointer to buf

        result = strerror_r(errnum, buf, buflen);

#else

        // we're using the X/OPEN version that always stores the result in buf

        (void) strerror_r(errnum, buf, buflen);

        result = buf;

#endif

    }

    return result;

}

#else

const char *OFStandard::strerror(const int errnum,

                                 char * /*buf*/,

                                 const size_t /*buflen*/)

{

    // we only have strerror() which is thread unsafe on Posix platforms, but thread safe on Windows

    return :: strerror(errnum);

}

#endif

OFString &OFStandard::toUpper(OFString &result,

                              const OFString &value)

{

    result = value;

    return OFStandard::toUpper(result);

}

OFString &OFStandard::toUpper(OFString &value)

{

    const size_t length = value.length();

    unsigned char c;

    for (size_t i = 0; i < length; i++)

    {

        c = value.at(i);

        value.at(i) = OFstatic_cast(char, toupper(c));

    }

    return value;

}

OFString &OFStandard::toLower(OFString &result,

                              const OFString &value)

{

    result = value;

    return OFStandard::toLower(result);

}

OFString &OFStandard::toLower(OFString &value)

{

    const size_t length = value.length();

    unsigned char c;

    for (size_t i = 0; i < length; i++)

    {

        c = value.at(i);

        value.at(i) = OFstatic_cast(char, tolower(c));

    }

    return value;

}

// --- file system functions ---

OFBool OFStandard::pathExists(const OFFilename &pathName)

{

    OFBool result = OFFalse;

    /* check for valid path name (avoid NULL or empty string) */

    if (!pathName.isEmpty())

    {

        /* check existence with "access()" */

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

        /* check whether to use the wide-char version of the API function */

        if (pathName.usesWideChars())

            result = (_waccess(pathName.getWideCharPointer(), F_OK) == 0);

        else

#endif

            result = (access(pathName.getCharPointer(), F_OK) == 0);

    }

    return result;

}

OFBool OFStandard::fileExists(const OFFilename &fileName)

{

    OFBool result = OFFalse;

    /* check for valid file name (avoid NULL or empty string) */

    if (!fileName.isEmpty())

    {

#ifdef HAVE_WINDOWS_H

        /* get file attributes */

        DWORD fileAttr;

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

        /* check whether to use the wide-char version of the API function */

        if (fileName.usesWideChars())

            fileAttr = GetFileAttributesW(fileName.getWideCharPointer());

        else

#endif

            fileAttr = GetFileAttributesA(fileName.getCharPointer());

        if (fileAttr != 0xffffffff)

        {

            /* check file type (not a directory?) */

            result = ((fileAttr & FILE_ATTRIBUTE_DIRECTORY) == 0);

        }

#else /* HAVE_WINDOWS_H */

        /* check whether path exists (but does not point to a directory) */

        result = pathExists(fileName.getCharPointer()) && !dirExists(fileName.getCharPointer());

#endif /* HAVE_WINDOWS_H */

    }

    return result;

}

OFBool OFStandard::dirExists(const OFFilename &dirName)

{

    OFBool result = OFFalse;

    /* check for valid directory name (avoid NULL or empty string) */

    if (!dirName.isEmpty())

    {

#ifdef HAVE_WINDOWS_H

        /* get file attributes of the directory */

        DWORD fileAttr;

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

        /* check whether to use the wide-char version of the API function */

        if (dirName.usesWideChars())

            fileAttr = GetFileAttributesW(dirName.getWideCharPointer());

        else

#endif

            fileAttr = GetFileAttributesA(dirName.getCharPointer());

        if (fileAttr != 0xffffffff)

        {

            /* check file type (is a directory?) */

            result = ((fileAttr & FILE_ATTRIBUTE_DIRECTORY) != 0);

        }

#else /* HAVE_WINDOWS_H */

        /* try to open the given directory */

        DIR *dirPtr = opendir(dirName.getCharPointer());

        if (dirPtr != NULL)

        {

            result = OFTrue;

            closedir(dirPtr);

        }

#endif /* HAVE_WINDOWS_H */

    }

    return result;

}

OFBool OFStandard::isReadable(const OFFilename &pathName)

{

    OFBool result = OFFalse;

    /* check for valid path name (avoid NULL or empty string) */

    if (!pathName.isEmpty())

    {

        /* check whether the path is readable using "access()" */

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

        /* check whether to use the wide-char version of the API function */

        if (pathName.usesWideChars())

            result = (_waccess(pathName.getWideCharPointer(), R_OK) == 0);

        else

#endif

            result = (access(pathName.getCharPointer(), R_OK) == 0);

}

    return result;

}

OFBool OFStandard::isWriteable(const OFFilename &pathName)

{

    OFBool result = OFFalse;

    /* check for valid path name (avoid NULL or empty string) */

    if (!pathName.isEmpty())

    {

        /* check whether the path is writable using "access()" */

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

        /* check whether to use the wide-char version of the API function */

        if (pathName.usesWideChars())

            result = (_waccess(pathName.getWideCharPointer(), W_OK) == 0);

        else

#endif

            result = (access(pathName.getCharPointer(), W_OK) == 0);

    }

    return result;

}

OFString &OFStandard::getDirNameFromPath(OFString &result,

                                         const OFString &pathName,

                                         const OFBool assumeDirName)

{

    OFFilename resultFilename;

    /* call the real function */

    getDirNameFromPath(resultFilename, pathName, assumeDirName);

    /* convert result into a string object */

    result = OFSTRING_GUARD(resultFilename.getCharPointer());

    return result;

}

OFFilename &OFStandard::getDirNameFromPath(OFFilename &result,

                                           const OFFilename &pathName,

                                           const OFBool assumeDirName)

{

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

    /* check whether to use the wide-char version of the API function */

    if (pathName.usesWideChars())

    {

        const wchar_t *strValue = pathName.getWideCharPointer();

        const wchar_t *strPos = wcsrchr(strValue, L'\\' /* WIDE_PATH_SEPARATOR */);

        // Windows accepts both backslash and forward slash as path separators.

        const wchar_t *strPos2 = wcsrchr(strValue, L'/');

        // if strPos2 points to a character closer to the end of the string, use this instead of strPos

        if ((strPos == NULL) || ((strPos2 != NULL) && (strPos2 > strPos))) strPos = strPos2;

        /* path separator found? */

        if (strPos == NULL)

        {

            if (assumeDirName)

                result = pathName;

            else

                result.clear();

        } else {

            wchar_t *tmpString = new wchar_t[strPos - strValue + 1];

            wcsncpy(tmpString, strValue, strPos - strValue);

            tmpString[strPos - strValue] = L'\0';

            result.set(tmpString, OFTrue /*convert*/);

            delete[] tmpString;

        }

    } else

#endif

    /* otherwise, use the conventional 8-bit characters version */

    {

        const char *strValue = pathName.getCharPointer();

        const char *strPos = strrchr(strValue, PATH_SEPARATOR);

#ifdef _WIN32

        // Windows accepts both backslash and forward slash as path separators.

        const char *strPos2 = strrchr(strValue, '/');

        // if strPos2 points to a character closer to the end of the string, use this instead of strPos

        if ((strPos == NULL) || ((strPos2 != NULL) && (strPos2 > strPos))) strPos = strPos2;

#endif

        /* path separator found? */

        if (strPos == NULL)

        {

            if (assumeDirName)

                result = pathName;

            else

                result.clear();

        } else

            result.set(OFString(strValue, strPos - strValue));

    }

    return result;

}

OFString &OFStandard::getFilenameFromPath(OFString &result,

                                          const OFString &pathName,

                                          const OFBool assumeFilename)

{

    OFFilename resultFilename;

    /* call the real function */

    getFilenameFromPath(resultFilename, pathName, assumeFilename);

    /* convert result into a string object */

    result = OFSTRING_GUARD(resultFilename.getCharPointer());

    return result;

}

OFFilename &OFStandard::getFilenameFromPath(OFFilename &result,

                                            const OFFilename &pathName,

                                            const OFBool assumeFilename)

{

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

    /* check whether to use the wide-char version of the API function */

    if (pathName.usesWideChars())

    {

        const wchar_t *strValue = pathName.getWideCharPointer();

        const wchar_t *strPos = wcsrchr(strValue, L'\\' /* WIDE_PATH_SEPARATOR */);

        // Windows accepts both backslash and forward slash as path separators.

        const wchar_t *strPos2 = wcsrchr(strValue, L'/');

        // if strPos2 points to a character closer to the end of the string, use this instead of strPos

        if ((strPos == NULL) || ((strPos2 != NULL) && (strPos2 > strPos))) strPos = strPos2;

        /* path separator found? */

        if (strPos == NULL)

        {

            if (assumeFilename)

                result = pathName;

            else

                result.clear();

        } else {

            wchar_t *tmpString = new wchar_t[wcslen(strPos)];

            wcscpy(tmpString, strPos + 1);

            result.set(tmpString, OFTrue /*convert*/);

            delete[] tmpString;

        }

    } else

#endif

    /* otherwise, use the conventional 8-bit characters version */

    {

        const char *strValue = pathName.getCharPointer();

        const char *strPos = strrchr(strValue, PATH_SEPARATOR);

#ifdef _WIN32

        // Windows accepts both backslash and forward slash as path separators.

        const char *strPos2 = strrchr(strValue, '/');

        // if strPos2 points to a character closer to the end of the string, use this instead of strPos

        if ((strPos == NULL) || ((strPos2 != NULL) && (strPos2 > strPos))) strPos = strPos2;

#endif

        /* path separator found? */

        if (strPos == NULL)

        {

            if (assumeFilename)

                result = pathName;

            else

                result.clear();

        } else

            result.set(OFString(strPos + 1));

    }

    return result;

}

OFString &OFStandard::normalizeDirName(OFString &result,

                                       const OFString &dirName,

                                       const OFBool allowEmptyDirName)

{

    OFFilename resultFilename;

    /* call the real function */

    normalizeDirName(resultFilename, dirName, allowEmptyDirName);

    /* convert result into a string object */

    result = OFSTRING_GUARD(resultFilename.getCharPointer());

    return result;

}

OFFilename &OFStandard::normalizeDirName(OFFilename &result,

                                         const OFFilename &dirName,

                                         const OFBool allowEmptyDirName)

{

    /* remove trailing path separators (keep it if appearing at the beginning of the string) */

    /* TODO: do we need to check for absolute path containing Windows drive name, e.g. "c:\"? */

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

    /* check whether to use the wide-char version of the API function */

    if (dirName.usesWideChars())

    {

        const wchar_t *strValue = dirName.getWideCharPointer();

        size_t strLength = (strValue == NULL) ? 0 : wcslen(strValue);

        // Windows accepts both backslash and forward slash as path separators.

        while ((strLength > 1) && ((strValue[strLength - 1] == L'\\' /* WIDE_PATH_SEPARATOR */) ||

              (strValue[strLength - 1] == L'/' )))

            --strLength;

        /* avoid "." as a directory name, use empty string instead */

        if (allowEmptyDirName && ((strLength == 0) || ((strLength == 1) && (strValue[0] == L'.'))))

            result.clear();

        /* avoid empty directory name (use "." instead) */

        else if (!allowEmptyDirName && (strLength == 0))

            result.set(L".", OFTrue /*convert*/);

        /* copy resulting string (omit trailing backslashes) */

        else {

            wchar_t *tmpString = new wchar_t[strLength + 1];

            wcsncpy(tmpString, strValue, strLength);

            tmpString[strLength] = L'\0';

            result.set(tmpString, OFTrue /*convert*/);

            delete[] tmpString;

        }

    } else

#endif

    /* otherwise, use the conventional 8-bit characters version */

    {

        const char *strValue = dirName.getCharPointer();

        size_t strLength = (strValue == NULL) ? 0 : strlen(strValue);

#ifdef _WIN32

        // Windows accepts both backslash and forward slash as path separators.

        while ((strLength > 1) && ((strValue[strLength - 1] == PATH_SEPARATOR) ||

              (strValue[strLength - 1] == '/' )))

            --strLength;

#else

        while ((strLength > 1) && (strValue[strLength - 1] == PATH_SEPARATOR))

            --strLength;

#endif

        /* avoid "." as a directory name, use empty string instead */

        if (allowEmptyDirName && ((strLength == 0) || ((strLength == 1) && (strValue[0] == '.'))))

            result.clear();

        /* avoid empty directory name (use "." instead) */

        else if (!allowEmptyDirName && (strLength == 0))

            result.set(".");

        /* copy resulting string (omit trailing backslashes) */

        else

            result.set(OFString(strValue, strLength));

    }

    return result;

}

OFString &OFStandard::combineDirAndFilename(OFString &result,

                                            const OFString &dirName,

                                            const OFString &fileName,

                                            const OFBool allowEmptyDirName)

{

    OFFilename resultFilename;

    /* call the real function */

    combineDirAndFilename(resultFilename, dirName, fileName, allowEmptyDirName);

    /* convert result into a string object */

    result = OFSTRING_GUARD(resultFilename.getCharPointer());

    return result;

}

OFFilename &OFStandard::combineDirAndFilename(OFFilename &result,

                                              const OFFilename &dirName,

                                              const OFFilename &fileName,

                                              const OFBool allowEmptyDirName)

{

    // # might use system function realpath() in the future to resolve paths including ".."

    // # or combinations of absolute paths in both 'dirName' and 'fileName'

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

    /* check whether to use the wide-char version of the API function */

    if (dirName.usesWideChars() || fileName.usesWideChars())

    {

        const wchar_t *strValue = fileName.getWideCharPointer();

        size_t strLength = (strValue == NULL) ? 0 : wcslen(strValue);

        /* check whether 'fileName' contains absolute path */

        /* (this check also covers UNC syntax, e.g. "\\server\...") */

        // Windows accepts both backslash and forward slash as path separators.

        if ((strLength > 0) && ((strValue[0] == L'\\' /* WIDE_PATH_SEPARATOR */) || (strValue[0] == L'/')))

        {

            result.set(strValue, OFTrue /*convert*/);

            return result;

        }

#ifdef HAVE_WINDOWS_H

        else if (strLength >= 3)

        {

            /* check for absolute path containing Windows drive name, e.g. "c:\..." */

            const wchar_t c = strValue[0];

            if (((c >= L'A') && (c <= L'Z')) || ((c >= L'a') && (c <= L'z')))

            {

                // Windows accepts both backslash and forward slash as path separators.

                if ((strValue[1] == L':') && ((strValue[2] == L'\\' /* WIDE_PATH_SEPARATOR */))||(strValue[2] == L'/'))

                {

                    result.set(strValue, OFTrue /*convert*/);

                    return result;

                }

            }

        }

#endif

        /* we only get here, if we don't have an absolute directory in "fileName" */

        /* now normalize the directory name */

        normalizeDirName(result, dirName, allowEmptyDirName);

        /* do some extra checks on a special case */

        if (!result.isEmpty() && !result.usesWideChars())

        {

            /* make sure that wide-char version exists */

            OFFilename tmpDirName(result);

            result.set(tmpDirName.getCharPointer(), OFTrue /*convert*/);

        }

        /* check file name (ignore empty string and ".") */

        if ((strLength > 1) || ((strLength == 1) && (strValue[0] != L'.')))

        {

            if (result.isEmpty())

                result.set(strValue, OFTrue /*convert*/);

            else {

                const wchar_t *resValue = result.getWideCharPointer();

                const size_t resLength = wcslen(resValue); /* should never be 0 */

                wchar_t *tmpString = new wchar_t[strLength + resLength + 1 + 1];

                wcscpy(tmpString, resValue);

                /* add path separator (if required) ... */

                // Windows accepts both backslash and forward slash as path separators.

                if ((resValue[resLength - 1] != L'\\' /* WIDE_PATH_SEPARATOR */) && (resValue[resLength - 1] != L'/'))

                {

                    tmpString[resLength] = L'\\' /* WIDE_PATH_SEPARATOR */;

                    tmpString[resLength + 1] = L'\0';

                }

                /* ...and file name */

                wcscat(tmpString, strValue);

                result.set(tmpString, OFTrue /*convert*/);

                delete[] tmpString;

            }

        }

    } else

#endif

    /* otherwise, use the conventional 8-bit characters version */

    {

        const char *strValue = fileName.getCharPointer();

        size_t strLength = (strValue == NULL) ? 0 : strlen(strValue);

        /* check whether 'fileName' contains absolute path */

        /* (this check also covers UNC syntax, e.g. "\\server\...") */

#ifdef _WIN32

        // Windows accepts both backslash and forward slash as path separators.

        if ((strLength > 0) && ((strValue[0] == PATH_SEPARATOR) || (strValue[0] == '/')))

#else

        if ((strLength > 0) && (strValue[0] == PATH_SEPARATOR))

#endif

        {

            result.set(strValue);

            return result;

        }

#ifdef HAVE_WINDOWS_H

        else if (strLength >= 3)

        {

            /* check for absolute path containing Windows drive name, e.g. "c:\..." */

            const char c = strValue[0];

            if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')))

            {

                if ((strValue[1] == ':') && ((strValue[2] == '\\') || (strValue[2] == '/')))

                {

                    result.set(strValue);

                    return result;

                }

            }

        }

#endif

        /* we only get here, if we don't have an absolute directory in "fileName" */

        /* now normalize the directory name */

        normalizeDirName(result, dirName, allowEmptyDirName);

        /* check file name (ignore empty string and ".") */

        if ((strLength > 1) || ((strLength == 1) && (strValue[0] != '.')))

        {

            if (result.isEmpty())

                result.set(strValue);

            else {

                const char *resValue = result.getCharPointer();

                const size_t resLength = strlen(resValue); /* should never be 0 */

                const size_t buflen = strLength + resLength + 1 + 1;

                char *tmpString = new char[buflen];

                OFStandard::strlcpy(tmpString, resValue, buflen);

                /* add path separator (if required) ... */

#ifdef _WIN32

                // Windows accepts both backslash and forward slash as path separators.

                if ((resValue[resLength - 1] != PATH_SEPARATOR) && (resValue[resLength - 1] != '/'))

#else

                if (resValue[resLength - 1] != PATH_SEPARATOR)

#endif

                {

                    tmpString[resLength] = PATH_SEPARATOR;

                    tmpString[resLength + 1] = '\0';

                }

                /* ...and file name */

                OFStandard::strlcat(tmpString, strValue, buflen);

                result.set(tmpString);

                delete[] tmpString;

            }

        }

    }

    return result;

}

OFCondition OFStandard::removeRootDirFromPathname(OFFilename &result,

                                                  const OFFilename &rootDir,

                                                  const OFFilename &pathName,

                                                  const OFBool allowLeadingPathSeparator)

{

    OFCondition status = EC_IllegalParameter;

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)

    /* check whether to use the wide-char version of the API function */

    if (rootDir.usesWideChars() || pathName.usesWideChars())

    {

        const wchar_t *rootValue = rootDir.getWideCharPointer();

        const wchar_t *pathValue = pathName.getWideCharPointer();

        const size_t rootLength = (rootValue == NULL) ? 0 : wcslen(rootValue);

        const size_t pathLength = (pathValue == NULL) ? 0 : wcslen(pathValue);

        /* check for empty strings */

        if ((rootLength == 0) && (pathLength == 0))

        {

            result.set("", OFTrue /*convert*/);

            status = EC_Normal;

        }

        /* check for empty root dir */

        else if (rootLength == 0)

        {

            result.set(pathValue, OFTrue /*convert*/);

            status = EC_Normal;

        }

        /* check for "compatible" length */

        else if (rootLength <= pathLength)

        {

            /* check for same prefix */

            if (wcsncmp(rootValue, pathValue, rootLength) == 0)

            {

                /* create temporary buffer for destination string */

                wchar_t *tmpString = new wchar_t[pathLength - rootLength + 1];

                /* remove root dir prefix from path name */

                wcscpy(tmpString, pathValue + rootLength);

                /* remove leading path separator (if present) */

                if (!allowLeadingPathSeparator && ((tmpString[0] == PATH_SEPARATOR) || (tmpString[0] == '/')))

                    result.set(tmpString + 1, OFTrue /*convert*/);

                else

                    result.set(tmpString, OFTrue /*convert*/);

                delete[] tmpString;

                status = EC_Normal;

            }

        }

    } else

#endif

    /* otherwise, use the conventional 8-bit characters version */

    {

        const char *rootValue = rootDir.getCharPointer();

        const char *pathValue = pathName.getCharPointer();

        const size_t rootLength = (rootValue == NULL) ? 0 : strlen(rootValue);

        const size_t pathLength = (pathValue == NULL) ? 0 : strlen(pathValue);

        /* check for empty strings */

        if ((rootLength == 0) && (pathLength == 0))

        {

            result.set("");

            status = EC_Normal;

        }

        /* check for empty root dir */

        else if (rootLength == 0)

        {

            result.set(pathValue);

            status = EC_Normal;

        }

        /* check for "compatible" length */

        else if (rootLength <= pathLength)

        {

            /* check for same prefix */

            if (strncmp(rootValue, pathValue, rootLength) == 0)

            {

                /* create temporary buffer for destination string */

                size_t buflen = pathLength - rootLength + 1;

                char *tmpString = new char[buflen];

                /* remove root dir prefix from path name */

                OFStandard::strlcpy(tmpString, pathValue + rootLength, buflen);

                /* remove leading path separator (if present) */

#ifdef _WIN32

                // Windows accepts both backslash and forward slash as path separators.

                if (!allowLeadingPathSeparator && ((tmpString[0] == PATH_SEPARATOR) || (tmpString[0] == '/')))

#else

                if (!allowLeadingPathSeparator && (tmpString[0] == PATH_SEPARATOR))

#endif

                    result.set(tmpString + 1);

                else

                    result.set(tmpString);

                delete[] tmpString;

                status = EC_Normal;

            }

        }

    }

    /* return empty string in case of error */

    if (status.bad())

        result.clear();

    return status;

}

OFFilename &OFStandard::appendFilenameExtension(OFFilename &result,

                                                const OFFilename &fileName,

                                                const OFFilename &fileExtension)

{

#if defined(WIDE_CHAR_FILE_IO_FUNCTIONS) && defined(_WIN32)