forked from Mirrors/openclonk
1109 lines
27 KiB
C++
1109 lines
27 KiB
C++
/*
|
|
* 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 + 1];
|
|
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 + 1];
|
|
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+1]; *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+1];
|
|
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 + 1];
|
|
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+1];
|
|
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+1],itemtarget[_MAX_PATH+1];
|
|
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+1],itemtarget[_MAX_PATH+1];
|
|
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+1];
|
|
#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+1],szFullFile2[_MAX_PATH+1];
|
|
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+1];
|
|
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;
|
|
}
|