StdFile.cpp

Go to the documentation of this file.

/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 1998-2000, Matthes Bender
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2009-2016, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
 
/* Lots of file helpers */
 
#include "C4Include.h"
#include "platform/StdFile.h"
 
#ifdef HAVE_IO_H
#include <io.h>
#endif
#ifdef _WIN32
#include "platform/C4windowswrapper.h"
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <zlib.h>
 
/* Path & Filename */
#ifdef _WIN32
static const char *DirectorySeparators = R"(/\)";
#else
static const char *DirectorySeparators = "/";
#endif
 
// Return pointer to position after last backslash.
 
char *GetFilename(char *szPath)
{
    if (!szPath) return nullptr;
    char *pPos,*pFilename=szPath;
    for (pPos=szPath; *pPos; pPos++) if (*pPos==DirectorySeparator || *pPos=='/') pFilename = pPos+1;
    return pFilename;
}
const char *GetFilename(const char *szPath)
{
    if (!szPath) return nullptr;
    const char *pPos,*pFilename=szPath;
    for (pPos=szPath; *pPos; pPos++) if (*pPos==DirectorySeparator || *pPos=='/') pFilename = pPos+1;
    return pFilename;
}
 
const char* GetFilenameOnly(const char *strFilename)
{
    // Get filename to static buffer
    static char strBuffer[_MAX_PATH_LEN];
    SCopy(GetFilename(strFilename), strBuffer);
    // Truncate extension
    RemoveExtension(strBuffer);
    // Return buffer
    return strBuffer;
}
 
const char *GetC4Filename(const char *szPath)
{
    // returns path to file starting at first .c4*-directory.
    if (!szPath) return nullptr;
    const char *pPos,*pFilename=szPath;
    for (pPos=szPath; *pPos; pPos++)
    {
        if (*pPos==DirectorySeparator || *pPos=='/')
        {
            if (pPos >= szPath+4 && SEqual2NoCase(pPos-4, ".oc")) return pFilename;
            pFilename = pPos+1;
        }
    }
    return pFilename;
}
 
int GetTrailingNumber(const char *strString)
{
    // Default
    int iNumber = 0;
    // Start from end
    const char *cpPos = strString + SLen(strString);
    // Walk back while number
    while ((cpPos > strString) && Inside(*(cpPos - 1), '0', '9')) cpPos--;
    // Scan number
    sscanf(cpPos, "%d", &iNumber);
    // Return result
    return iNumber;
}
 
// Like GetFilename, but searches for a slash instead of a backslash
// (unix-style paths)
 
char *GetFilenameWeb(char *szPath)
{
    if (!szPath) return nullptr;
    char *pPos, *pFilename=szPath;
    for (pPos=szPath; *pPos; pPos++) if (*pPos == '/') pFilename = pPos+1;
    return pFilename;
}
const char *GetFilenameWeb(const char *szPath)
{
    if (!szPath) return nullptr;
    const char *pPos, *pFilename=szPath;
    for (pPos=szPath; *pPos; pPos++) if (*pPos == '/') pFilename = pPos+1;
    return pFilename;
}
 
// Return pointer to last file extension.
 
char *GetExtension(char *szFilename)
{
    int pos, end;
    for (end=0; szFilename[end]; end++) {}
    pos = end;
    while ((pos > 0) && (szFilename[pos-1] != '.') && (szFilename[pos-1] != DirectorySeparator)) --pos;
    if ((pos > 0) && szFilename[pos-1] == '.') return szFilename + pos;
    return szFilename + end;
}
const char *GetExtension(const char *szFilename)
{
    int pos, end;
    for (end=0; szFilename[end]; end++) {}
    pos = end;
    while ((pos>0) && (szFilename[pos-1] != '.') && (szFilename[pos-1] != DirectorySeparator)) pos--;
    if ((pos > 0) && szFilename[pos-1] == '.') return szFilename+pos;
    return szFilename+end;
}
 
 
void RealPath(const char *szFilename, char *pFullFilename)
{
#ifdef _WIN32
    wchar_t *wpath = _wfullpath(nullptr, GetWideChar(szFilename), 0);
    StdStrBuf path(wpath);
    // I'm pretty sure pFullFilename will always have at least a size of _MAX_PATH, but ughh
    // This should return a StdStrBuf
    SCopy(path.getData(), pFullFilename, _MAX_PATH);
    free(wpath);
#else
    char *pSuffix = nullptr;
    char szCopy[_MAX_PATH_LEN];
    for (;;)
    {
        // Try to convert to full filename. Note this might fail if the given file doesn't exist
        if (realpath(szFilename, pFullFilename))
            break;
        // ... which is undesired behaviour here. Try to reduce the filename until it works.
        if (!pSuffix)
        {
            SCopy(szFilename, szCopy, _MAX_PATH);
            szFilename = szCopy;
            pSuffix = szCopy + SLen(szCopy);
        }
        else
            *pSuffix = '/';
        while (pSuffix > szCopy)
            if (*--pSuffix == '/')
                break;
        if (pSuffix <= szCopy)
        {
            // Give up: Just copy whatever we got
            SCopy(szFilename, pFullFilename, _MAX_PATH);
            return;
        }
        *pSuffix = 0;
    }
    // Append suffix
    if (pSuffix)
    {
        *pSuffix = '/';
        SAppend(pSuffix, pFullFilename, _MAX_PATH);
    }
#endif
}
 
// Copy (extended) parent path (without backslash) to target buffer.
 
bool GetParentPath(const char *szFilename, char *szBuffer)
{
    // Prepare filename
    SCopy(szFilename,szBuffer,_MAX_PATH);
    // Extend relative single filenames
#ifdef _WIN32
    if (!SCharCount(DirectorySeparator,szFilename)) _fullpath(szBuffer,szFilename,_MAX_PATH);
#else
    if (!SCharCount(DirectorySeparator,szFilename)) RealPath(szFilename,szBuffer);
#endif
    // Truncate path
    return TruncatePath(szBuffer);
}
 
bool GetParentPath(const char *szFilename, StdStrBuf *outBuf)
{
    char buf[_MAX_PATH_LEN]; *buf='\0';
    if (!GetParentPath(szFilename, buf)) return false;
    outBuf->Copy(buf);
    return true;
}
 
const char *GetRelativePathS(const char *strPath, const char *strRelativeTo)
{
    // Specified path is relative to base path
#ifdef _WIN32
    if (SEqual2NoCase(strPath, strRelativeTo))
#else
    if (SEqual2(strPath, strRelativeTo))
#endif
    {
        // return relative section
        return strPath + SLen(strRelativeTo) + ((strPath[SLen(strRelativeTo)] == DirectorySeparator) ? +1 : 0);
    }
    // Not relative: return full path
    return strPath;
}
 
bool IsGlobalPath(const char *szPath)
{
#ifdef _WIN32
    // C:\...
    if (*szPath && szPath[1] == ':') return true;
#endif
    // /usr/bin, \Temp\, ...
    if (*szPath == DirectorySeparator) return true;
    return false;
}
 
// Truncate string before last backslash.
 
bool TruncatePath(char *szPath)
{
    if (!szPath) return false;
    int iBSPos;
    iBSPos=SCharLastPos(DirectorySeparator,szPath);
#ifndef _WIN32
    int iBSPos2;
    iBSPos2=SCharLastPos('\\',szPath);
    if (iBSPos2 > iBSPos) fprintf(stderr, "Warning: TruncatePath with a \\ (%s)\n", szPath);
#endif
    if (iBSPos<0) return false;
    szPath[iBSPos]=0;
    return true;
}
 
// Append terminating backslash if not present.
 
void AppendBackslash(char *szFilename)
{
    int i=SLen(szFilename);
    if (i>0) if (szFilename[i-1]==DirectorySeparator) return;
    SAppendChar(DirectorySeparator,szFilename);
}
 
// Remove terminating backslash if present.
 
void TruncateBackslash(char *szFilename)
{
    int i=SLen(szFilename);
    if (i>0) if (szFilename[i-1]==DirectorySeparator) szFilename[i-1]=0;
}
 
// Append extension if no extension.
 
void DefaultExtension(char *szFilename, const char *szExtension)
{
    if (!(*GetExtension(szFilename)))
        { SAppend(".",szFilename); SAppend(szExtension,szFilename); }
}
 
void DefaultExtension(StdStrBuf *sFilename, const char *szExtension)
{
    assert(sFilename);
    if (!(*GetExtension(sFilename->getData())))
        { sFilename->AppendChar('.'); sFilename->Append(szExtension); }
}
 
// Append or overwrite extension.
 
void EnforceExtension(char *szFilename, const char *szExtension)
{
    char *ext = GetExtension(szFilename);
    if (ext[0]) { SCopy(szExtension,ext); }
    else { SAppend(".",szFilename); SAppend(szExtension,szFilename); }
}
 
void EnforceExtension(StdStrBuf *sFilename, const char *szExtension)
{
    assert(sFilename);
    const char *ext = GetExtension(sFilename->getData());
    if (ext[0]) { sFilename->ReplaceEnd(ext - sFilename->getData(), szExtension); }
    else { sFilename->AppendChar('.'); sFilename->Append(szExtension); }
}
 
// remove extension
 
void RemoveExtension(char *szFilename)
{
    char *ext = GetExtension(szFilename);
    if (ext[0]) ext[-1]=0;
}
 
void RemoveExtension(StdStrBuf *psFileName)
{
    if (psFileName && *psFileName)
    {
        RemoveExtension(psFileName->getMData());
        psFileName->SetLength(strlen(psFileName->getData()));
    }
}
 
// Enforce indexed extension until item does not exist.
 
void MakeTempFilename(char *szFilename)
{
    DefaultExtension(szFilename,"tmp");
    char *fn_ext=GetExtension(szFilename);
    int cnum=-1;
    do
    {
        cnum++;
        osprintf(fn_ext,"%03d",cnum);
    }
    while (FileExists(szFilename) && (cnum<999));
}
 
void MakeTempFilename(StdStrBuf *sFilename)
{
    assert(sFilename);
    if (!sFilename->getLength()) sFilename->Copy("temp.tmp");
    EnforceExtension(sFilename, "tmp");
    char *fn_ext=GetExtension(sFilename->getMData());
    int cnum=-1;
    do
    {
        cnum++;
        osprintf(fn_ext,"%03d",cnum);
    }
    while (FileExists(sFilename->getData()) && (cnum<999));
}
 
bool WildcardListMatch(const char *szWildcardList, const char *szString)
{
    // safety
    if (!szString || !szWildcardList) return false;
    // match any item in list
    StdStrBuf sWildcard, sWildcardList(szWildcardList);
    int32_t i=0;
    while (sWildcardList.GetSection(i++, &sWildcard, '|'))
    {
        if (WildcardMatch(sWildcard.getData(), szString)) return true;
    }
    // none matched
    return false;
}
 
bool IsWildcardString(const char *szString)
{
    // safety
    if (!szString) return false;
    // known wildcard characters: *?[
    return (SCharCount('?', szString)>0) || (SCharCount('*', szString)>0) || (SCharCount('[', szString)>0);
}
 
// Parses a character class, skips over it and returns whether it matches the given character.
static bool WildcardMatchCharacterClass(const char **charclass, char matchchar)
{
    const char *cc = *charclass;
    if (*cc++ != '[') return false;
    bool match = false;
    // ] is allowed as first character, e.g. []]
    do
    {
        // range, e.g. [a-z]
        if (cc[1] == '-' && cc[2] != ']')
        {
            if (matchchar >= cc[0] && matchchar <= cc[2])
                match = true;
            cc += 2;
        }
        // single character
        else if (*cc == matchchar)
            match = true;
    }
    while (*++cc && *cc != ']');
    *charclass = cc;
    return match;
}
 
bool WildcardMatch(const char *szWildcard, const char *szString)
{
    // safety
    if (!szString || !szWildcard) return false;
    // match char-wise
    const char *pWild = szWildcard, *pPos = szString;
    const char *pLWild = nullptr, *pLPos = nullptr; // backtracking
    while (*pWild || pLWild)
        // string wildcard?
        if (*pWild == '*')
            { pLWild = ++pWild; pLPos = pPos; }
    // nothing left to match?
        else if (!*pPos)
            break;
    // character class, equal or one-character-wildcard? proceed
        else if ((*pWild == '[' && WildcardMatchCharacterClass(&pWild, *pPos))
                || *pWild == '?'
                || tolower(*pWild) == tolower(*pPos))
            { pWild++; pPos++; }
    // backtrack possible?
        else if (pLPos)
            { pWild = pLWild; pPos = ++pLPos; }
    // match failed
        else
            return false;
    // match complete if both strings are fully matched
    return !*pWild && !*pPos;
}
 
// create a valid file name from some title
void MakeFilenameFromTitle(char *szTitle)
{
    // copy all chars but those to be stripped
    char *szFilename=szTitle, *szTitle2=szTitle;
    while (*szTitle2)
    {
        bool fStrip;
        if (IsWhiteSpace(*szTitle2))
            fStrip = (szFilename==szTitle);
        else if (static_cast<unsigned int>(*szTitle2) > 127)
            fStrip = true;
        else
            fStrip = (SCharPos(*szTitle2, R"(!"'%&/=?+*#:;<>\.)") >= 0);
        if (!fStrip) *szFilename++ = *szTitle2;
        ++szTitle2;
    }
    // truncate spaces from end
    while (IsWhiteSpace(*--szFilename)) if (szFilename==szTitle) { --szFilename; break; }
    // terminate
    *++szFilename=0;
    // no name? (only invalid chars)
    if (!*szTitle) SCopy("unnamed", szTitle, 50);
    // done
}
 
/* Files */
 
bool FileExists(const char *szFilename)
{
#ifdef _WIN32
    return GetFileAttributes(GetWideChar(szFilename)) != INVALID_FILE_ATTRIBUTES;
#else
    return (!access(szFilename,F_OK));
#endif
}
 
size_t FileSize(const char *szFilename)
{
#if defined(_WIN32) || defined(_WIN64)
    auto attributes = WIN32_FILE_ATTRIBUTE_DATA();
    if (GetFileAttributesEx(GetWideChar(szFilename), GetFileExInfoStandard, &attributes) == 0)
        return 0;
#ifdef _WIN64
    return (static_cast<size_t>(attributes.nFileSizeHigh) << (sizeof(attributes.nFileSizeLow) * 8)) | attributes.nFileSizeLow;
#else
    return attributes.nFileSizeLow;
#endif
#else
    struct stat stStats;
    if (stat(szFilename,&stStats)) return 0;
    return stStats.st_size;
#endif
}
 
// operates on a filedescriptor from open or fileno
size_t FileSize(int fdes)
{
#ifdef _WIN32
    return _filelength(fdes);
#else
    struct stat stStats;
    if (fstat(fdes,&stStats)) return 0;
    return stStats.st_size;
#endif
}
 
int FileTime(const char *szFilename)
{
#ifdef _WIN32
    auto attributes = WIN32_FILE_ATTRIBUTE_DATA();
    if (GetFileAttributesEx(GetWideChar(szFilename), GetFileExInfoStandard, &attributes) == 0)
        return 0;
    int64_t ft = (static_cast<int64_t>(attributes.ftLastWriteTime.dwHighDateTime) << (sizeof(attributes.ftLastWriteTime.dwLowDateTime) * 8)) | attributes.ftLastWriteTime.dwLowDateTime;
    ft -= 116444736000000000;
    ft /= 10000000;
    return ft;
#else
    struct stat stStats;
    if (stat(szFilename,&stStats)!=0) return 0;
    return stStats.st_mtime;
#endif
}
 
bool EraseFile(const char *szFilename)
{
#ifdef _WIN32
    SetFileAttributesW(GetWideChar(szFilename), FILE_ATTRIBUTE_NORMAL);
    if (DeleteFileW(GetWideChar(szFilename)) == 0)
    {
        switch (GetLastError())
        {
        case ERROR_PATH_NOT_FOUND:
        case ERROR_FILE_NOT_FOUND:
            // While deleting it didn't work, the file doesn't exist (anymore).
            // Pretend everything is fine.
            return true;
        default:
            // Some other error left us unable to delete the file.
            return false;
        }
    }
    return true;
#else
    // either unlink or remove could be used. Well, stick to ANSI C where possible.
    if (remove(szFilename))
    {
        if (errno == ENOENT)
        {
            // Hah, here the wrapper actually makes sense:
            // The engine only cares about the file not being there after this call.
            return true;
        }
        return false;
    }
    return true;
#endif
}
 
#ifndef _WIN32
bool CopyFile(const char *szSource, const char *szTarget, bool FailIfExists)
{
    int fds = open (szSource, O_RDONLY | O_CLOEXEC);
    if (!fds) return false;
    struct stat info; fstat(fds, &info);
    int fdt = open (szTarget, O_CLOEXEC | O_WRONLY | O_CREAT | (FailIfExists? O_EXCL : O_TRUNC), info.st_mode);
    if (!fdt)
    {
        close (fds);
        return false;
    }
    char buffer[1024]; ssize_t l;
    while ((l = read(fds, buffer, sizeof(buffer))) > 0)
        if (write(fdt, buffer, l) < l)
        {
            l = -1;
            break;
        }
    close (fds);
    close (fdt);
    // On error, return false
    return l != -1;
}
 
bool RenameFile(const char *szFilename, const char *szNewFilename)
{
    if (rename(szFilename,szNewFilename) < 0)
    {
        if (errno != EXDEV) return false;
        if (CopyFile(szFilename, szNewFilename, false))
        {
            return EraseFile(szFilename);
        }
        return false;
    }
    return true;
}
#else
 
#undef CopyFile
bool CopyFile(const char *szSource, const char *szTarget, bool FailIfExists)
{
    return !!CopyFileW(GetWideChar(szSource), GetWideChar(szTarget), FailIfExists);
}
 
bool RenameFile(const char *szFilename, const char *szNewFilename)
{
    return !!MoveFileExW(GetWideChar(szFilename), GetWideChar(szNewFilename), MOVEFILE_COPY_ALLOWED);
}
 
#endif
 
bool MakeOriginalFilename(char *szFilename)
{
    // safety
    if (!szFilename) return false;
#ifdef _WIN32
    // root-directory?
    if (Inside(SLen(szFilename), 2u, 3u)) if (szFilename[1]==':')
        {
            szFilename[2]='\\'; szFilename[3]=0;
            if (GetDriveTypeW(GetWideChar(szFilename)) == DRIVE_NO_ROOT_DIR) return false;
            return true;
        }
    struct _wfinddata_t fdt; intptr_t shnd;
    if ((shnd=_wfindfirst(GetWideChar(szFilename),&fdt))<0) return false;
    _findclose(shnd);
    StdStrBuf name(fdt.name);
    SCopy(GetFilename(name.getData()),GetFilename(szFilename),_MAX_FNAME);
#else
    if (SCharPos('*', szFilename) != -1)
    {
        fputs ("Warning: MakeOriginalFilename with \"", stderr);
        fputs (szFilename, stderr);
        fputs ("\"!\n", stderr);
    }
#endif
    return true;
}
 
/* Directories */
 
const char *GetWorkingDirectory()
{
#ifdef _WIN32
    static StdStrBuf buffer;
    wchar_t *widebuf = nullptr;
    DWORD widebufsz = GetCurrentDirectoryW(0, nullptr);
    widebuf = new wchar_t[widebufsz];
    if (GetCurrentDirectoryW(widebufsz, widebuf) == 0) {
        delete[] widebuf;
        return nullptr;
    }
    buffer.Take(StdStrBuf(widebuf));
    delete[] widebuf;
    return buffer.getData();
#else
    static char buf[_MAX_PATH_LEN];
    return getcwd(buf,_MAX_PATH);
#endif
}
 
bool SetWorkingDirectory(const char *path)
{
#ifdef _WIN32
    return SetCurrentDirectoryW(GetWideChar(path)) != 0;
#else
    return (chdir(path)==0);
#endif
}
 
bool CreatePath(const std::string &path)
{
    assert(!path.empty());
#ifdef _WIN32
    if (CreateDirectoryW(GetWideChar(path.c_str()), nullptr))
    {
        return true;
    }
    else
    {
        DWORD err = GetLastError();
        switch (err)
        {
        case ERROR_PATH_NOT_FOUND:
            break;
        case ERROR_ALREADY_EXISTS:
            return true;
        default:
            // Something major has happened: Log
        {
            wchar_t * str;
            if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
                              nullptr, err, 0, (LPWSTR)&str, 0, nullptr))
            {
                LogF("CreateDirectory failed: %s", StdStrBuf(str).getData());
                LocalFree(str);
            }
            return false;
        }
        }
    }
#else
    if (!mkdir(path.c_str(), S_IREAD | S_IWRITE | S_IEXEC))
        return true;
    switch (errno)
    {
    case ENOENT:
        break;
    case EEXIST:
        // FIXME: Check whether the path is blocked by a non-directory
        return true;
    default:
        return false;
    }
#endif
    // Recursively create parent path
    std::string::size_type slash = path.find_last_of(DirectorySeparators);
    if (slash == 0 || slash == std::string::npos)
        return false;
    return CreatePath(path.substr(0, slash)) && CreatePath(path);
}
 
bool DirectoryExists(const char *szFilename)
{
    // Ignore trailing slash or backslash, except when we are probing the
    // root directory '/'.
    char bufFilename[_MAX_PATH_LEN];
    if (szFilename && szFilename[0])
    {
        unsigned int len = SLen(szFilename);
        if (len > 1 && ((szFilename[len - 1] == '\\') || (szFilename[len - 1] == '/')))
        {
            SCopy(szFilename, bufFilename, _MAX_PATH);
            bufFilename[SLen(bufFilename) - 1] = 0;
            szFilename = bufFilename;
        }
    }
    // Check file attributes
#ifdef _WIN32
    struct _wfinddata_t fdt; intptr_t shnd;
    if ((shnd=_wfindfirst(GetWideChar(szFilename),&fdt))<0) return false;
    _findclose(shnd);
    if (fdt.attrib & _A_SUBDIR) return true;
#else
    struct stat stStats;
    if (stat(szFilename,&stStats)!=0) return 0;
    return (S_ISDIR(stStats.st_mode));
#endif
    return false;
}
 
bool CopyDirectory(const char *szSource, const char *szTarget, bool fResetAttributes)
{
    // Source check
    if (!szSource || !szTarget) return false;
    if (!DirectoryExists(szSource)) return false;
    // Do not process system navigation directories
    if (SEqual(GetFilename(szSource),".")
        || SEqual(GetFilename(szSource),".."))
        return true;
    // Overwrite target
    if (!EraseItem(szTarget)) return false;
    // Create target directory
    bool status=true;
#ifdef _WIN32
    if (_wmkdir(GetWideChar(szTarget))!=0) return false;
    // Copy contents to target directory
    char contents[_MAX_PATH_LEN];
    SCopy(szSource,contents); AppendBackslash(contents);
    SAppend("*",contents);
    _wfinddata_t fdt; intptr_t hfdt;
    if ( (hfdt=_wfindfirst(GetWideChar(contents),&fdt)) > -1 )
    {
        do
        {
            char itemsource[_MAX_PATH_LEN],itemtarget[_MAX_PATH_LEN];
            SCopy(szSource,itemsource); AppendBackslash(itemsource); SAppend(StdStrBuf(fdt.name).getData(),itemsource);
            SCopy(szTarget,itemtarget); AppendBackslash(itemtarget); SAppend(StdStrBuf(fdt.name).getData(),itemtarget);
            if (!CopyItem(itemsource,itemtarget, fResetAttributes)) status=false;
        }
        while (_wfindnext(hfdt,&fdt)==0);
        _findclose(hfdt);
    }
#else
    if (mkdir(szTarget,0777)!=0) return false;
    DIR * d = opendir(szSource);
    dirent * ent;
    char itemsource[_MAX_PATH_LEN],itemtarget[_MAX_PATH_LEN];
    while ((ent = readdir(d)))
    {
        SCopy(szSource,itemsource); AppendBackslash(itemsource); SAppend(ent->d_name,itemsource);
        SCopy(szTarget,itemtarget); AppendBackslash(itemtarget); SAppend(ent->d_name,itemtarget);
        if (!CopyItem(itemsource,itemtarget, fResetAttributes)) status=false;
    }
    closedir(d);
#endif
    return status;
}
 
bool EraseDirectory(const char *szDirName)
{
    // Do not process system navigation directories
    if (SEqual(GetFilename(szDirName),".")
        || SEqual(GetFilename(szDirName),".."))
        return true;
    char path[_MAX_PATH_LEN];
#ifdef _WIN32
    // Get path to directory contents
    SCopy(szDirName,path); SAppend(R"(\*.*)",path);
    // Erase subdirectories and files
    ForEachFile(path,&EraseItem);
#else
    DIR * d = opendir(szDirName);
    dirent * ent;
    while ((ent = readdir(d)))
    {
        SCopy(szDirName,path); AppendBackslash(path); SAppend(ent->d_name,path);
        if (!EraseItem(path)) return false;
    }
    closedir(d);
#endif
    // Check working directory
    if (SEqual(szDirName,GetWorkingDirectory()))
    {
        // Will work only if szDirName is full path and correct case!
        SCopy(GetWorkingDirectory(),path);
        int lbacks = SCharLastPos(DirectorySeparator,path);
        if (lbacks > -1)
        {
            path[lbacks]=0; SetWorkingDirectory(path);
        }
    }
    // Remove directory
#ifdef _WIN32
    return !!RemoveDirectoryW(GetWideChar(szDirName));
#else
    return (rmdir(szDirName)==0 || errno == ENOENT);
#endif
}
 
/* Items */
bool RenameItem(const char *szItemName, const char *szNewItemName)
{
    // FIXME: What if the directory would have to be copied?
    return RenameFile(szItemName,szNewItemName);
}
 
bool EraseItem(const char *szItemName)
{
    if (!EraseFile(szItemName)) return EraseDirectory(szItemName);
    else return true;
}
 
bool CreateItem(const char *szItemname)
{
    // Overwrite any old item
    EraseItem(szItemname);
    // Create dummy item
    FILE *fhnd;
#ifdef _WIN32
    if (!(fhnd=_wfopen(GetWideChar(szItemname), L"wb"))) return false;
#else
    if (!(fhnd=fopen(szItemname,"wb"))) return false;
#endif
    fclose(fhnd);
    // Success
    return true;
}
 
bool CopyItem(const char *szSource, const char *szTarget, bool fResetAttributes)
{
    // Check for identical source and target
    if (ItemIdentical(szSource,szTarget)) return true;
    // Copy directory
    if (DirectoryExists(szSource))
        return CopyDirectory(szSource,szTarget,fResetAttributes);
    // Copy file
    if (!CopyFile(szSource,szTarget,false)) return false;
    // Reset any attributes if desired
#ifdef _WIN32
    if (fResetAttributes) if (!SetFileAttributesW(GetWideChar(szTarget), FILE_ATTRIBUTE_NORMAL)) return false;
#else
    if (fResetAttributes) if (chmod(szTarget, S_IRWXU)) return false;
#endif
    return true;
}
 
bool MoveItem(const char *szSource, const char *szTarget)
{
    if (ItemIdentical(szSource,szTarget)) return true;
    return RenameFile(szSource, szTarget);
}
 
bool ItemIdentical(const char *szFilename1, const char *szFilename2)
{
    char szFullFile1[_MAX_PATH_LEN],szFullFile2[_MAX_PATH_LEN];
    RealPath(szFilename1, szFullFile1); RealPath(szFilename2, szFullFile2);
#ifdef _WIN32
    if (SEqualNoCase(szFullFile1,szFullFile2)) return true;
#else
    if (SEqual(szFullFile1,szFullFile2)) return true;
#endif
    return false;
}
 
//------------------------- Multi File Processing --------------------------------------------------------------------------------------------------------
 
struct DirectoryIteratorP
{
    DirectoryIteratorP() = default;
    DirectoryIterator::FileList files;
    std::string directory;
    int ref{1};
};
 
DirectoryIterator::DirectoryIterator()
        : p(new DirectoryIteratorP), iter(p->files.end())
{}
DirectoryIterator::DirectoryIterator(const DirectoryIterator &other)
        : p(other.p), iter(other.iter)
{
    ++p->ref;
}
 
DirectoryIterator & DirectoryIterator::operator = (const DirectoryIterator & other)
{
    p = other.p; iter = other.iter;
    ++p->ref;
    return *this;
}
 
DirectoryIterator::~DirectoryIterator()
{
    if (--p->ref == 0)
        delete p;
}
 
void DirectoryIterator::Clear()
{
    // clear cache
    if (p->ref > 1)
    {
        // Detach from shared memory
        --p->ref;
        p = new DirectoryIteratorP;
    }
    p->directory.clear();
    p->files.clear();
    iter = p->files.end();
}
 
void DirectoryIterator::Reset ()
{
    iter = p->files.begin();
}
 
void DirectoryIterator::Reset (const char * dirname, bool force_reread)
{
    if (p->directory == dirname && !force_reread)
    {
        // Skip reinitialisation and just reset the iterator
        iter = p->files.begin();
        return;
    }
    if (p->ref > 1)
    {
        // Detach from shared memory
        --p->ref;
        p = new DirectoryIteratorP;
    }
    p->files.clear();
    iter = p->files.end();
    Read(dirname);
}
 
DirectoryIterator::DirectoryIterator (const char * dirname)
        : p(new DirectoryIteratorP), iter(p->files.end())
{
    Read(dirname);
}
 
void DirectoryIterator::Read(const char *dirname)
{
    assert(dirname && *dirname);
    assert(p->files.empty());
    std::string search_path(dirname);
    if (!search_path.empty() && search_path.back() != DirectorySeparator)
        search_path.push_back(DirectorySeparator);
#ifdef WIN32
    auto file = WIN32_FIND_DATAW();
    HANDLE fh = FindFirstFileW(GetWideChar((search_path + '*').c_str()), &file);
    if (fh == INVALID_HANDLE_VALUE)
    {
        switch (GetLastError())
        {
        case ERROR_PATH_NOT_FOUND:
        case ERROR_FILE_NOT_FOUND:
            // This is okay, either the directory doesn't exist or there are no files
            return;
        default:
            // Something else broke
            Log("DirectoryIterator::Read(const char*): Unable to read file system");
            return;
        }
    }
    // Insert files into list
    do
    {
        // ...unless they're . or ..
        if (file.cFileName[0] == '.' && (file.cFileName[1] == '\0' || (file.cFileName[1] == '.' && file.cFileName[2] == '\0')))
            continue;
 
        size_t size = (file.nFileSizeHigh * (size_t(MAXDWORD) + 1)) + file.nFileSizeLow;
 
        p->files.emplace_back(StdStrBuf(file.cFileName).getData(), size);
    }
    while (FindNextFileW(fh, &file));
    FindClose(fh);
#else
    DIR *fh = opendir(dirname);
    if (fh == nullptr)
    {
        switch (errno)
        {
        case ENOENT:
        case ENOTDIR:
            // Okay, so there's no files here.
            return;
        default:
            // Something else broke
            LogF("DirectoryIterator::Read(\"%s\"): %s", dirname, strerror(errno));
            return;
        }
    }
    dirent *file;
    // Insert files into list
    while ((file = readdir(fh)) != nullptr)
    {
        // ...unless they're . or ..
        if (file->d_name[0] == '.' && (file->d_name[1] == '\0' || (file->d_name[1] == '.' && file->d_name[2] == '\0')))
            continue;
        p->files.emplace_back(file->d_name, 0);
    }
    closedir(fh);
#endif
    // Sort list
    std::sort(p->files.begin(), p->files.end());
    for (auto & file : p->files)
        file.first.insert(0, search_path); // prepend path to all file entries
    iter = p->files.begin();
    p->directory = dirname;
}
 
DirectoryIterator& DirectoryIterator::operator++()
{
    if (iter != p->files.end())
        ++iter;
    return *this;
}
 
const char * DirectoryIterator::operator*() const
{
    if (iter == p->files.end())
        return nullptr;
    return iter->first.c_str();
}
DirectoryIterator DirectoryIterator::operator++(int)
{
    DirectoryIterator tmp(*this);
    ++*this;
    return tmp;
}
 
size_t DirectoryIterator::GetFileSize() const
{
#ifdef _WIN32
    return iter->second;
#else
    return FileSize(iter->first.c_str());
#endif
}
 
int ForEachFile(const char *szDirName, bool (*fnCallback)(const char *))
{
    if (!szDirName || !fnCallback)
        return 0;
    char szFilename[_MAX_PATH_LEN];
    SCopy(szDirName,szFilename);
    bool fHasWildcard = (SCharPos('*', szFilename)>=0);
    if (!fHasWildcard) // parameter without wildcard: Append "/*.*" or "\*.*"
        AppendBackslash(szFilename);
    int iFileCount = 0;
#ifdef _WIN32
    struct _wfinddata_t fdt; intptr_t fdthnd;
    if (!fHasWildcard) // parameter without wildcard: Append "/*.*" or "\*.*"
        SAppend("*",szFilename,_MAX_PATH);
    if ((fdthnd = _wfindfirst (GetWideChar(szFilename), &fdt)) < 0)
        return 0;
    do
    {
        if (!wcscmp(fdt.name, L".") || !wcscmp(fdt.name, L"..")) continue;
        StdStrBuf name(fdt.name);
        SCopy(name.getData(),GetFilename(szFilename));
        if ((*fnCallback)(szFilename))
            iFileCount++;
    }
    while (_wfindnext(fdthnd,&fdt)==0);
    _findclose(fdthnd);
#else
    if (fHasWildcard) fprintf(stderr, "Warning: ForEachFile with * (%s)\n", szDirName);
    DIR * d = opendir(szDirName);
    if (!d) return 0;
    dirent * ent;
    while ((ent = readdir(d)))
    {
        SCopy(ent->d_name,GetFilename(szFilename));
        if ((*fnCallback)(szFilename))
            iFileCount++;
    }
    closedir(d);
#endif
    return iFileCount;
}