void FS_Init(const char *argv0) {
int err = PHYSFS_init(argv0);
if (err == 0) {
Con_Errorf(ERR_FATAL, "Error in PHYSFS_init: %s", PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
return;
}
const char *baseDir = PHYSFS_getBaseDir();
fs_basepath = Con_GetVarDefault("fs.basepath", baseDir, CONVAR_STARTUP);
fs_basegame = Con_GetVarDefault("fs.basegame", "base", CONVAR_STARTUP);
fs_game = Con_GetVarDefault("fs.game", DEFAULT_GAME, CONVAR_STARTUP);
bool modLoaded = fs_game->string[0] != '\0';
char **baseFiles, **gameFiles;
// get the file listing for the basegame dir, then immediately unmount
const char *fullBasePath = tempstr("%s/%s", fs_basepath->string, fs_basegame->string);
PHYSFS_mount(fullBasePath, "/", 1);
baseFiles = PHYSFS_enumerateFiles("/");
PHYSFS_removeFromSearchPath(fullBasePath);
// if fs_game is set, do the same thing for the fs_game dir
if (modLoaded) {
const char *fullGamePath = tempstr("%s/%s", fs_basepath->string, fs_game->string);
PHYSFS_mount(fullGamePath, "/", 1);
gameFiles = PHYSFS_enumerateFiles("/");
PHYSFS_removeFromSearchPath(fullGamePath);
// mount the mod dir first, then mount mod PK3s
PHYSFS_mount(tempstr("%s/%s", fs_basepath->string, fs_game->string), "/", 1);
FS_AddPaksFromList(gameFiles, fs_basepath->string, fs_game->string);
PHYSFS_freeList(gameFiles);
}
// then mount the base game dir, then the mount base game PK3s
PHYSFS_mount(tempstr("%s/%s", fs_basepath->string, fs_basegame->string), "/", 1);
FS_AddPaksFromList(baseFiles, fs_basepath->string, fs_basegame->string);
PHYSFS_freeList(baseFiles);
// print all the files we've found in order of priority
Con_Printf("Current filesystem search path:\n");
PHYSFS_getSearchPathCallback(printSearchPath, NULL);
Con_Printf("\n");
// add command handler for dir to view virtual filesystem
Con_AddCommand("dir", Cmd_Dir_f);
}
bool buildMapList(void)
{
char ** filelist, ** file;
size_t len;
if (!loadLevFile("gamedesc.lev", mod_campaign, false))
{
return false;
}
loadLevFile("addon.lev", mod_multiplay, false);
filelist = PHYSFS_enumerateFiles("");
for ( file = filelist; *file != NULL; ++file )
{
len = strlen( *file );
if ( len > 10 // Do not add addon.lev again
&& !strcasecmp( *file+(len-10), ".addon.lev") )
{
loadLevFile(*file, mod_multiplay, true);
}
// add support for X player maps using a new name to prevent conflicts.
if ( len > 13 && !strcasecmp( *file+(len-13), ".xplayers.lev") )
{
loadLevFile(*file, mod_multiplay, true);
}
}
PHYSFS_freeList( filelist );
return true;
}
static PHYSFSX_counted_list file_getdirlist(const char *dir)
{
ntstring<PATH_MAX - 1> path;
auto dlen = path.copy_if(dir);
if ((!dlen && dir[0] != '\0') || !path.copy_if(dlen, "/"))
return nullptr;
++ dlen;
PHYSFSX_counted_list list{PHYSFS_enumerateFiles(dir)};
if (!list)
return nullptr;
const auto predicate = [&](char *i) -> bool {
if (path.copy_if(dlen, i) && PHYSFS_isDirectory(path))
return false;
free(i);
return true;
};
auto j = std::remove_if(list.begin(), list.end(), predicate);
*j = NULL;
auto NumDirs = j.get() - list.get();
qsort(list.get(), NumDirs, sizeof(char *), string_array_sort_func);
if (*dir)
{
// Put the 'go to parent directory' sequence '..' first
++NumDirs;
auto r = reinterpret_cast<char **>(realloc(list.get(), sizeof(char *)*(NumDirs + 1)));
if (!r)
return list;
list.release();
list.reset(r);
std::move_backward(r, r + NumDirs, r + NumDirs + 1);
list[0] = d_strdup("..");
}
list.set_count(NumDirs);
return list;
}
void
ResourceManager::searchAndAddArchives(const std::string &path,
const std::string &ext,
bool append)
{
const char *dirSep = PHYSFS_getDirSeparator();
char **list = PHYSFS_enumerateFiles(path.c_str());
for (char **i = list; *i != NULL; i++)
{
size_t len = strlen(*i);
if (len > ext.length() && !ext.compare((*i)+(len - ext.length())))
{
std::string file, realPath, archive;
file = path + (*i);
realPath = std::string(PHYSFS_getRealDir(file.c_str()));
archive = realPath + dirSep + file;
addToSearchPath(archive, append);
}
}
PHYSFS_freeList(list);
}
static int cmd_enumerate(char *args)
{
char **rc;
if (*args == '\"')
{
args++;
args[strlen(args) - 1] = '\0';
} /* if */
rc = PHYSFS_enumerateFiles(args);
if (rc == NULL)
printf("Failure. reason: %s.\n", PHYSFS_getLastError());
else
{
int file_count;
char **i;
for (i = rc, file_count = 0; *i != NULL; i++, file_count++)
printf("%s\n", *i);
printf("\n total (%d) files.\n", file_count);
PHYSFS_freeList(rc);
} /* else */
return(1);
} /* cmd_enumerate */
Font::Font(GlyphWidth glyph_width_,
const std::string& filename,
int shadowsize_) :
glyph_width(glyph_width_),
glyph_surfaces(),
shadow_surfaces(),
char_height(),
shadowsize(shadowsize_),
glyphs(65536)
{
for(unsigned int i=0; i<65536;i++) glyphs[i].surface_idx = -1;
const std::string fontdir = FileSystem::dirname(filename);
const std::string fontname = FileSystem::basename(filename);
// scan for prefix-filename in addons search path
char **rc = PHYSFS_enumerateFiles(fontdir.c_str());
for (char **i = rc; *i != NULL; i++) {
std::string filename(*i);
if( filename.rfind(fontname) != std::string::npos ) {
loadFontFile(fontdir + filename);
}
}
PHYSFS_freeList(rc);
}
static int l_filesystem_enumerate(lua_State* state) {
int n = lua_gettop(state);
const char * dir = l_tools_toStringOrError(state, 1);
int error = PHYSFS_mount(dir, "/", 1);
if (error != 1)
return printf("%s %s %s \n", "Error: Directory or archive named : ", dir ," does not exist");
char **rc = PHYSFS_enumerateFiles("/");
char **i;
int index = 1;
if( n != 1 )
return luaL_error(state, "Function s a single parameter.");
lua_newtable(state);
for (i = rc; *i != 0; i++)
{
lua_pushinteger(state, index);
lua_pushstring(state, *i);
lua_settable(state, -3);
index++;
}
PHYSFS_freeList(rc);
return 1;
}
/*!
* Tries to mount a list of directories, found in /basedir/subdir/<list>.
* \param basedir Base directory
* \param subdir A subdirectory of basedir
* \param appendToPath Whether to append or prepend
* \param checkList List of directories to check. NULL means any.
*/
void addSubdirs( const char * basedir, const char * subdir, const bool appendToPath, char * checkList[], bool addToModList )
{
char tmpstr[PATH_MAX];
char buf[256];
char ** subdirlist = PHYSFS_enumerateFiles( subdir );
char ** i = subdirlist;
while( *i != NULL )
{
#ifdef DEBUG
debug( LOG_NEVER, "addSubdirs: Examining subdir: [%s]", *i );
#endif // DEBUG
if (*i[0] != '.' && (!checkList || inList(checkList, *i)))
{
snprintf(tmpstr, sizeof(tmpstr), "%s%s%s%s", basedir, subdir, PHYSFS_getDirSeparator(), *i);
#ifdef DEBUG
debug( LOG_NEVER, "addSubdirs: Adding [%s] to search path", tmpstr );
#endif // DEBUG
if (addToModList)
{
addLoadedMod(*i);
snprintf(buf, sizeof(buf), "mod: %s", *i);
addDumpInfo(buf);
}
PHYSFS_addToSearchPath( tmpstr, appendToPath );
}
i++;
}
PHYSFS_freeList( subdirlist );
}
/**Enumerates all files available in a path.
* \param path String pointing to the path
* \return Nonzero on success */
list<string> Filesystem::Enumerate( const string& path, const string &suffix )
{
list<string> files;
char **rc;
rc = PHYSFS_enumerateFiles(path.c_str());
if (rc == NULL){
LogMsg(ERR,"Failure to enumerate %s. reason: %s.\n",
path.c_str(),PHYSFS_getLastError());
}
else
{
int file_count;
char **i;
for (i = rc, file_count = 0; *i != NULL; i++, file_count++)
{
files.push_back( string(*i) );
}
LogMsg(INFO,"\n total (%d) files.\n", file_count);
PHYSFS_freeList(rc);
return 1;
}
return files;
}
void MainMenu::fillLoadMenu( bool save /*= false*/ )
{
const std::string buttonNames[]={"File0","File1","File2","File3","File4","File5"};
char** rc = PHYSFS_enumerateFiles("/");
char* curfile;
CheckButton *button;
for(int i=0;i<6;i++) {
char* recentfile = NULL;
PHYSFS_sint64 t = 0;
std::stringstream filestart;
filestart << i+1 << "_";
if( save ){
button = getCheckButton(*saveGameMenu.get(),buttonNames[i]);
} else {
button = getCheckButton(*loadGameMenu.get(),buttonNames[i]);
}
//make sure Button is connected only once
button->clicked.clear();
if( save )
button->clicked.connect(makeCallback(*this,&MainMenu::selectSaveGameButtonClicked));
else {
button->clicked.connect(makeCallback(*this,&MainMenu::selectLoadGameButtonClicked));
}
for(char** i = rc; *i != 0; i++){
curfile = *i;
if(std::string( curfile ).find( filestart.str() ) == 0 ) {
// && !( curfile->d_type & DT_DIR ) ) is not portable. So
// don't create a directoy named 2_ in a savegame-directory or
// you can no longer load from slot 2.
if (t == 0) {
recentfile = curfile;
t = PHYSFS_getLastModTime(recentfile);
} else {
if (PHYSFS_getLastModTime(curfile) > t) {
/*#ifdef DEBUG
fprintf(stderr," %s is more recent than previous %s\n",
curfile, recentfile);
#endif*/
recentfile = curfile;
t = PHYSFS_getLastModTime(recentfile);
}
}
}
}
#ifdef DEBUG
fprintf(stderr,"Most recent file: %s\n\n",recentfile);
#endif
if(t != 0) {
std::string f= recentfile;
button->setCaptionText(f);
} else {
button->setCaptionText(_("empty"));
}
}
}
WzConfig::WzConfig(const QString &name, WzConfig::warning warning, QObject *parent)
: WzConfigHack(name, (int)warning), m_settings(QString("wz::") + name, QSettings::IniFormat, parent), m_overrides()
{
if (m_settings.status() != QSettings::NoError && (warning != ReadOnly || PHYSFS_exists(name.toUtf8().constData())))
{
debug(LOG_FATAL, "Could not open \"%s\"", name.toUtf8().constData());
}
char **diffList = PHYSFS_enumerateFiles("diffs");
char **i;
int j;
for (i = diffList; *i != NULL; i++)
{
std::string str(std::string("diffs/") + *i + std::string("/") + name.toUtf8().constData());
if (!PHYSFS_exists(str.c_str()))
continue;
QSettings tmp(QString("wz::") + str.c_str(), QSettings::IniFormat);
if (tmp.status() != QSettings::NoError)
{
debug(LOG_FATAL, "Could not read an override for \"%s\"", name.toUtf8().constData());
}
QStringList keys(tmp.allKeys());
for (j = 0; j < keys.length(); j++)
{
m_overrides.insert(keys[j],tmp.value(keys[j]));
}
}
PHYSFS_freeList(diffList);
}
void Game::testAllHelpFiles(){
getGameView()->printStatusMessage( "Testing Help Files...");
std::string filename;
std::string directory = "help/en";
std::string fullname;
char **rc = PHYSFS_enumerateFiles( directory.c_str() );
char **i;
size_t pos;
for (i = rc; *i != NULL; i++) {
fullname = directory;
fullname.append( *i );
filename.assign( *i );
if(PHYSFS_isDirectory(fullname.c_str()))
continue;
pos = filename.rfind( ".xml" );
if( pos != std::string::npos ){
filename.replace( pos, 4 ,"");
std::cerr << "--- Examining " << filename << "\n";
helpWindow->showTopic( filename );
std::cerr << "\n";
}
}
PHYSFS_freeList(rc);
}
std::string
AddonManager::scan_for_info(const std::string& archive_os_path) const
{
std::unique_ptr<char*, decltype(&PHYSFS_freeList)>
rc2(PHYSFS_enumerateFiles("/"),
PHYSFS_freeList);
for(char** j = rc2.get(); *j != 0; ++j)
{
if (has_suffix(*j, ".nfo"))
{
std::string nfo_filename = FileSystem::join("/", *j);
// make sure it's in the current archive_os_path
const char* realdir = PHYSFS_getRealDir(nfo_filename.c_str());
if (!realdir)
{
log_warning << "PHYSFS_getRealDir() failed for " << nfo_filename << ": " << PHYSFS_getLastError() << std::endl;
}
else
{
if (realdir == archive_os_path)
{
return nfo_filename;
}
}
}
}
return std::string();
}
void removeSubdirs( const char * basedir, const char * subdir, char * checkList[] )
{
char tmpstr[PATH_MAX];
char ** subdirlist = PHYSFS_enumerateFiles( subdir );
char ** i = subdirlist;
while( *i != NULL )
{
#ifdef DEBUG
debug( LOG_NEVER, "removeSubdirs: Examining subdir: [%s]", *i );
#endif // DEBUG
if( !checkList || inList( checkList, *i ) )
{
snprintf(tmpstr, sizeof(tmpstr), "%s%s%s%s", basedir, subdir, PHYSFS_getDirSeparator(), *i);
#ifdef DEBUG
debug( LOG_NEVER, "removeSubdirs: Removing [%s] from search path", tmpstr );
#endif // DEBUG
if (!PHYSFS_removeFromSearchPath( tmpstr ))
{
#ifdef DEBUG // spams a ton!
debug(LOG_NEVER, "Couldn't remove %s from search path because %s", tmpstr, PHYSFS_getLastError());
#endif // DEBUG
}
}
i++;
}
PHYSFS_freeList( subdirlist );
}
ReplayMenuState::ReplayMenuState() :
mLeftPlayer(LEFT_PLAYER),
mRightPlayer(RIGHT_PLAYER)
{
IMGUI::getSingleton().resetSelection();
mReplaying = false;
mChecksumError = false;
mReplayMatch = 0;
mReplayRecorder = 0;
mSelectedReplay = 0;
char** filenames = PHYSFS_enumerateFiles("replays");
for (int i = 0; filenames[i] != 0; ++i)
{
std::string tmp(filenames[i]);
if (tmp.find(".bvr") != std::string::npos)
{
mReplayFiles.push_back(std::string(tmp.begin(), tmp.end()-4));
}
}
if (mReplayFiles.size() == 0)
mSelectedReplay = -1;
std::sort(mReplayFiles.rbegin(), mReplayFiles.rend());
mLeftPlayer.loadFromConfig("left");
mRightPlayer.loadFromConfig("right");
}
std::list<UString> FileSystem::enumerateDirectory(const UString &basePath,
const UString &extension) const
{
std::list<UString> result;
bool filterByExtension = !extension.empty();
char **elements = PHYSFS_enumerateFiles(basePath.cStr());
for (char **element = elements; *element != NULL; element++)
{
if (!filterByExtension)
{
result.push_back(*element);
}
else
{
const UString elementString = (*element);
if (elementString.endsWith(extension))
{
result.push_back(elementString);
}
}
}
PHYSFS_freeList(elements);
return result;
}
WzConfig::WzConfig(const QString &name, WzConfig::warning warning, QObject *parent)
{
UDWORD size;
char *data;
QJsonParseError error;
mFilename = name;
mStatus = true;
mWarning = warning;
if (!PHYSFS_exists(name.toUtf8().constData()))
{
if (warning == ReadOnly)
{
mStatus = false;
debug(LOG_ERROR, "IGNORED %s", name.toUtf8().constData());
return;
}
else if (warning == ReadAndWrite)
{
mJson = QJsonDocument();
mObj = mJson.object();
debug(LOG_ERROR, "PREPARED %s", name.toUtf8().constData());
return;
}
}
if (!loadFile(name.toUtf8().constData(), &data, &size))
{
debug(LOG_FATAL, "Could not open \"%s\"", name.toUtf8().constData());
}
mJson = QJsonDocument::fromJson(QByteArray(data, size), &error);
ASSERT(!mJson.isNull(), "JSON document from %s is invalid: %s", name.toUtf8().constData(), error.errorString().toUtf8().constData());
ASSERT(mJson.isObject(), "JSON document from %s is not an object. Read: \n%s", name.toUtf8().constData(), data);
mObj = mJson.object();
#if 0
char **diffList = PHYSFS_enumerateFiles("diffs");
char **i;
int j;
for (i = diffList; *i != NULL; i++)
{
std::string str(std::string("diffs/") + *i + std::string("/") + name.toUtf8().constData());
if (!PHYSFS_exists(str.c_str()))
continue;
QSettings tmp(QString("wz::") + str.c_str(), QSettings::IniFormat);
if (tmp.status() != QSettings::NoError)
{
debug(LOG_FATAL, "Could not read an override for \"%s\"", name.toUtf8().constData());
}
QStringList keys(tmp.allKeys());
for (j = 0; j < keys.length(); j++)
{
m_overrides.insert(keys[j],tmp.value(keys[j]));
}
}
PHYSFS_freeList(diffList);
#endif
}
StringList enumerateFiles(const string& directory) {
StringList files;
char ** listBegin = PHYSFS_enumerateFiles(directory.c_str());
for (char ** file = listBegin; *file != NULL; file++) {
files.push_back(*file);
}
PHYSFS_freeList(listBegin);
return files;
}
StringVector enumerateFiles(const std::string& dir)
{
StringVector list;
char** lst = PHYSFS_enumerateFiles(dir.c_str());
for (char** l = lst; *l != 0; ++l)
list.push_back(*l);
PHYSFS_freeList(lst);
return list;
}
void Cmd_Dir_f() {
const char *path = Con_GetArgsCount() > 1 ? Con_GetArg(1) : "/";
char **rc = PHYSFS_enumerateFiles(path);
char **i;
Con_Printf("Directory listing of %s\n", path);
for (i = rc; *i != NULL; i++)
Con_Printf("%s\n", *i);
PHYSFS_freeList(rc);
}
std::list<std::string> ResourceManager::listDirectoryFiles(const std::string& directoryPath)
{
std::list<std::string> files;
auto rc = PHYSFS_enumerateFiles(resolvePath(directoryPath).c_str());
for(int i = 0; rc[i] != NULL; i++)
files.push_back(rc[i]);
PHYSFS_freeList(rc);
return files;
}
bool deleteAll(const char* filePath, bool deleteRoot)
{
PHYSFS_Stat fileStat;
if (PHYSFS_stat(filePath, &fileStat) == 0)
{
return false;
}
bool ret = false;
if (fileStat.filetype == PHYSFS_FILETYPE_DIRECTORY)
{
auto paths = PHYSFS_enumerateFiles(filePath);
if (paths != nullptr)
{
auto writeDir = PHYSFS_getWriteDir();
if (writeDir != nullptr)
{
for (char** path = paths; *path != nullptr; path++)
{
auto fullPath = std::string(filePath) + '/' + *path;
if (PHYSFS_stat(fullPath.c_str(), &fileStat) == 0)
{
continue;
}
if (fileStat.filetype == PHYSFS_FILETYPE_DIRECTORY)
{
deleteAll(fullPath.c_str(), true);
}
else
{
auto realDir = PHYSFS_getRealDir(fullPath.c_str());
if (realDir != nullptr)
{
if (std::strcmp(writeDir, realDir) == 0)
{
ret = PHYSFS_delete(fullPath.c_str()) != 0;
}
}
}
}
}
PHYSFS_freeList(paths);
}
if (deleteRoot == true)
{
ret = PHYSFS_delete(filePath) != 0;
}
}
else
{
ret = PHYSFS_delete(filePath) != 0;
}
return ret;
}
bool buildMapList()
{
if (!loadLevFile("gamedesc.lev", mod_campaign, false, NULL))
{
return false;
}
loadLevFile("addon.lev", mod_multiplay, false, NULL);
WZ_Maps.clear();
MapFileList realFileNames = listMapFiles();
for (MapFileList::iterator realFileName = realFileNames.begin(); realFileName != realFileNames.end(); ++realFileName)
{
bool mapmod = false;
struct WZmaps CurrentMap;
std::string realFilePathAndName = PHYSFS_getRealDir(realFileName->c_str()) + *realFileName;
PHYSFS_addToSearchPath(realFilePathAndName.c_str(), PHYSFS_APPEND);
char **filelist = PHYSFS_enumerateFiles("");
for (char **file = filelist; *file != NULL; ++file)
{
std::string checkfile = *file;
size_t len = strlen(*file);
if (len > 10 && !strcasecmp(*file + (len - 10), ".addon.lev")) // Do not add addon.lev again
{
loadLevFile(*file, mod_multiplay, true, realFileName->c_str());
}
// add support for X player maps using a new name to prevent conflicts.
if (len > 13 && !strcasecmp(*file + (len - 13), ".xplayers.lev"))
{
loadLevFile(*file, mod_multiplay, true, realFileName->c_str());
}
}
PHYSFS_freeList(filelist);
if (PHYSFS_removeFromSearchPath(realFilePathAndName.c_str()) == 0)
{
debug(LOG_ERROR, "Could not unmount %s, %s", realFilePathAndName.c_str(), PHYSFS_getLastError());
}
mapmod = CheckInMap(realFilePathAndName.c_str(), "WZMap", "WZMap");
if (!mapmod)
{
mapmod = CheckInMap(realFilePathAndName.c_str(), "WZMap", "WZMap/multiplay");
}
CurrentMap.MapName = realFileName->c_str();
CurrentMap.isMapMod = mapmod;
WZ_Maps.push_back(CurrentMap);
}
return true;
}
bool copyDir(const char* dirSrcName, const char* dirDstName)
{
PHYSFS_Stat stat;
if (PHYSFS_stat(dirSrcName, &stat) == 0 ||
stat.filetype != PHYSFS_FILETYPE_DIRECTORY)
{
return false;
}
if (PHYSFS_stat(dirDstName, &stat) != 0 &&
stat.filetype != PHYSFS_FILETYPE_DIRECTORY)
{
return false;
}
createDir(dirDstName);
auto paths = PHYSFS_enumerateFiles(dirSrcName);
if (paths != nullptr)
{
for (char** path = paths; *path != nullptr; path++)
{
auto fullSrcPath = std::string(dirSrcName) + '/' + *path;
auto fullDstPath = std::string(dirDstName) + '/' + *path;
if (PHYSFS_stat(fullSrcPath.c_str(), &stat) == 0)
{
continue;
}
if (stat.filetype == PHYSFS_FILETYPE_DIRECTORY)
{
copyDir(fullSrcPath.c_str(), fullDstPath.c_str());
}
else
{
// copy file (read source file and write destination)
sf::PhysFSStream fileRead(fullSrcPath);
auto fileWrite = PHYSFS_openWrite(fullDstPath.c_str());
if (fileRead.hasError() == false &&
fileWrite != nullptr)
{
std::vector<uint8_t> data((size_t)fileRead.getSize());
fileRead.read(data.data(), fileRead.getSize());
PHYSFS_writeBytes(fileWrite, data.data(), data.size());
PHYSFS_close(fileWrite);
}
}
}
PHYSFS_freeList(paths);
return true;
}
return false;
}
std::vector<std::string>
PhysFSFileSystem::open_directory(const std::string& pathname)
{
std::vector<std::string> files;
char** directory = PHYSFS_enumerateFiles(pathname.c_str());
for(char** i = directory; *i != 0; ++i)
{
files.push_back(*i);
}
PHYSFS_freeList(directory);
return files;
}
void FileManager::EnumerateFiles(const natChar* _path, std::vector<std::string>& _files)
{
natChar **rc = PHYSFS_enumerateFiles(_path);
natChar **i;
for(i = rc; *i != NULL; ++i)
{
std::ostringstream oss;
oss << _path << '/' << *i;
_files.push_back(oss.str());
}
PHYSFS_freeList(rc);
}
static int locateOneElement(char *buf)
{
char *ptr;
char **rc;
char **i;
if (PHYSFS_exists(buf))
return 1; /* quick rejection: exists in current case. */
ptr = strrchr(buf, '/'); /* find entry at end of path. */
if (ptr == NULL)
{
rc = PHYSFS_enumerateFiles("/");
ptr = buf;
} /* if */
else
{
*ptr = '\0';
rc = PHYSFS_enumerateFiles(buf);
*ptr = '/';
ptr++; /* point past dirsep to entry itself. */
} /* else */
for (i = rc; *i != NULL; i++)
{
if (caseInsensitiveStringCompare(*i, ptr) == 0)
{
strcpy(ptr, *i); /* found a match. Overwrite with this case. */
PHYSFS_freeList(rc);
return 1;
} /* if */
} /* for */
/* no match at all... */
PHYSFS_freeList(rc);
return 0;
} /* locateOneElement */
std::vector<std::string> GetDirectoryContent(std::string path) {
std::vector<std::string> ret;
if (!IsLoaded()) {
Logger::begin("Filesystem", Logger::LogLevel_Error) << "FS not loaded" << Logger::end();
assert(false);
return ret;
}
char** list = PHYSFS_enumerateFiles(path.c_str());
char** i;
for (i = list; *i != NULL; i++) {
ret.push_back(*i);
}
PHYSFS_freeList(list);
return ret;
}
static List list_files(const char *path)
{
List list = NULL;
char **files, **file;
if ((files = PHYSFS_enumerateFiles(path)))
{
for (file = files; *file; file++)
list = list_cons(strdup(*file), list);
PHYSFS_freeList(files);
}
return list;
}
void PHYSFSX_listSearchPathContent()
{
char **i, **list;
con_printf(CON_DEBUG, "PHYSFS: Listing contents of Search Path.\n");
list = PHYSFS_getSearchPath();
for (i = list; *i != NULL; i++)
con_printf(CON_DEBUG, "PHYSFS: [%s] is in the Search Path.\n", *i);
PHYSFS_freeList(list);
list = PHYSFS_enumerateFiles("");
for (i = list; *i != NULL; i++)
con_printf(CON_DEBUG, "PHYSFS: * We've got [%s].\n", *i);
PHYSFS_freeList(list);
con_printf(CON_DEBUG, "\n");
}
