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