Initial commit
This commit is contained in:
571
common/fs.cpp
Normal file
571
common/fs.cpp
Normal file
@@ -0,0 +1,571 @@
|
||||
/* ScummVM - Graphic Adventure Engine
|
||||
*
|
||||
* ScummVM is the legal property of its developers, whose names
|
||||
* are too numerous to list here. Please refer to the COPYRIGHT
|
||||
* file distributed with this source distribution.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "common/system.h"
|
||||
#include "common/debug.h"
|
||||
#include "common/punycode.h"
|
||||
#include "common/textconsole.h"
|
||||
#include "backends/fs/abstract-fs.h"
|
||||
#include "backends/fs/fs-factory.h"
|
||||
|
||||
namespace Common {
|
||||
|
||||
// File-in-directory archive member that captures relative path
|
||||
class FSDirectoryFile : public ArchiveMember {
|
||||
public:
|
||||
FSDirectoryFile(const Common::Path &pathInDirectory, const FSNode &fsNode);
|
||||
|
||||
SeekableReadStream *createReadStream() const override;
|
||||
SeekableReadStream *createReadStreamForAltStream(AltStreamType altStreamType) const override;
|
||||
String getName() const override;
|
||||
Path getPathInArchive() const override;
|
||||
String getFileName() const override;
|
||||
U32String getDisplayName() const override;
|
||||
bool isDirectory() const override;
|
||||
void listChildren(ArchiveMemberList &list, const char *pattern) const override;
|
||||
|
||||
private:
|
||||
Common::Path _pathInDirectory;
|
||||
FSNode _fsNode;
|
||||
};
|
||||
|
||||
FSDirectoryFile::FSDirectoryFile(const Common::Path &pathInDirectory, const FSNode &fsNode)
|
||||
: _pathInDirectory(pathInDirectory), _fsNode(fsNode) {
|
||||
}
|
||||
|
||||
SeekableReadStream *FSDirectoryFile::createReadStream() const {
|
||||
return _fsNode.createReadStream();
|
||||
}
|
||||
|
||||
SeekableReadStream *FSDirectoryFile::createReadStreamForAltStream(AltStreamType altStreamType) const {
|
||||
return _fsNode.createReadStreamForAltStream(altStreamType);
|
||||
}
|
||||
|
||||
String FSDirectoryFile::getName() const {
|
||||
return _fsNode.getName();
|
||||
}
|
||||
|
||||
Path FSDirectoryFile::getPathInArchive() const {
|
||||
return _pathInDirectory;
|
||||
}
|
||||
|
||||
String FSDirectoryFile::getFileName() const {
|
||||
return _fsNode.getName();
|
||||
}
|
||||
|
||||
U32String FSDirectoryFile::getDisplayName() const {
|
||||
return _fsNode.getDisplayName();
|
||||
}
|
||||
|
||||
bool FSDirectoryFile::isDirectory() const {
|
||||
return _fsNode.isDirectory();
|
||||
}
|
||||
|
||||
void FSDirectoryFile::listChildren(ArchiveMemberList &list, const char *pattern) const {
|
||||
// We don't check for includeDirectories in the parent archive to determine the list mode here because it is implicit,
|
||||
// i.e. if includeDirectories was set false, then this file isn't a directory in the first place.
|
||||
|
||||
FSList fsList;
|
||||
if (!_fsNode.getChildren(fsList, FSNode::kListAll))
|
||||
return;
|
||||
|
||||
for (const FSNode &fsNode : fsList) {
|
||||
Common::String fileName = fsNode.getName();
|
||||
|
||||
if (pattern != nullptr && !fileName.matchString(pattern, true))
|
||||
continue;
|
||||
|
||||
Common::Path subPath = _pathInDirectory.appendComponent(fileName);
|
||||
|
||||
list.push_back(ArchiveMemberPtr(new FSDirectoryFile(subPath, fsNode)));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FSNode::FSNode() {
|
||||
}
|
||||
|
||||
FSNode::FSNode(AbstractFSNode *realNode)
|
||||
: _realNode(realNode) {
|
||||
}
|
||||
|
||||
FSNode::~FSNode() {
|
||||
}
|
||||
|
||||
FSNode::FSNode(const Path &p) {
|
||||
assert(g_system);
|
||||
FilesystemFactory *factory = g_system->getFilesystemFactory();
|
||||
AbstractFSNode *tmp = nullptr;
|
||||
|
||||
if (p.empty() || p == Path("."))
|
||||
tmp = factory->makeCurrentDirectoryFileNode();
|
||||
else
|
||||
tmp = factory->makeFileNodePath(p.toString(Common::Path::kNativeSeparator));
|
||||
_realNode = SharedPtr<AbstractFSNode>(tmp);
|
||||
}
|
||||
|
||||
bool FSNode::operator<(const FSNode& node) const {
|
||||
// Directories come before files, i.e., are "lower".
|
||||
if (isDirectory() != node.isDirectory())
|
||||
return isDirectory();
|
||||
|
||||
// If both nodes are of the same type (two files or two dirs),
|
||||
// then sort by name, ignoring case.
|
||||
return getName().compareToIgnoreCase(node.getName()) < 0;
|
||||
}
|
||||
|
||||
bool FSNode::exists() const {
|
||||
return _realNode && _realNode->exists();
|
||||
}
|
||||
|
||||
FSNode FSNode::getChild(const String &n) const {
|
||||
// If this node is invalid or not a directory, return an invalid node
|
||||
if (_realNode == nullptr || !_realNode->isDirectory())
|
||||
return FSNode();
|
||||
|
||||
AbstractFSNode *node = _realNode->getChild(n);
|
||||
return FSNode(node);
|
||||
}
|
||||
|
||||
bool FSNode::getChildren(FSList &fslist, ListMode mode, bool hidden) const {
|
||||
if (!_realNode || !_realNode->isDirectory())
|
||||
return false;
|
||||
|
||||
AbstractFSList nodeList;
|
||||
|
||||
if (!_realNode->getChildren(nodeList, mode, hidden))
|
||||
return false;
|
||||
|
||||
fslist.clear();
|
||||
for (auto &node : nodeList) {
|
||||
fslist.push_back(FSNode(node));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
U32String FSNode::getDisplayName() const {
|
||||
assert(_realNode);
|
||||
return _realNode->getDisplayName();
|
||||
}
|
||||
|
||||
String FSNode::getName() const {
|
||||
assert(_realNode);
|
||||
|
||||
// We transparently decode any punycode-named files
|
||||
String name = _realNode->getName();
|
||||
if (!punycode_hasprefix(name))
|
||||
return name;
|
||||
|
||||
return punycode_decodefilename(name);
|
||||
}
|
||||
|
||||
String FSNode::getFileName() const {
|
||||
return getName();
|
||||
}
|
||||
|
||||
Common::Path FSNode::getPathInArchive() const {
|
||||
return Common::Path(getName(), Common::Path::kNoSeparator);
|
||||
}
|
||||
|
||||
String FSNode::getRealName() const {
|
||||
assert(_realNode);
|
||||
return _realNode->getName();
|
||||
}
|
||||
|
||||
FSNode FSNode::getParent() const {
|
||||
if (_realNode == nullptr)
|
||||
return *this;
|
||||
|
||||
AbstractFSNode *node = _realNode->getParent();
|
||||
if (node == nullptr) {
|
||||
return *this;
|
||||
} else {
|
||||
return FSNode(node);
|
||||
}
|
||||
}
|
||||
|
||||
Path FSNode::getPath() const {
|
||||
assert(_realNode);
|
||||
return Path(_realNode->getPath(), Common::Path::kNativeSeparator);
|
||||
}
|
||||
|
||||
bool FSNode::isDirectory() const {
|
||||
return _realNode && _realNode->isDirectory();
|
||||
}
|
||||
|
||||
void FSNode::listChildren(ArchiveMemberList &childList, const char *pattern) const {
|
||||
Common::FSList fsList;
|
||||
if (!getChildren(fsList, Common::FSNode::kListAll))
|
||||
return;
|
||||
|
||||
for (const Common::FSNode &fsNode : fsList) {
|
||||
if (pattern != nullptr && !fsNode.getName().matchString(pattern))
|
||||
continue;
|
||||
|
||||
childList.push_back(ArchiveMemberPtr(new FSNode(fsNode)));
|
||||
}
|
||||
}
|
||||
|
||||
bool FSNode::isReadable() const {
|
||||
return _realNode && _realNode->isReadable();
|
||||
}
|
||||
|
||||
bool FSNode::isWritable() const {
|
||||
return _realNode && _realNode->isWritable();
|
||||
}
|
||||
|
||||
SeekableReadStream *FSNode::createReadStream() const {
|
||||
if (_realNode == nullptr)
|
||||
return nullptr;
|
||||
|
||||
if (!_realNode->exists()) {
|
||||
warning("FSNode::createReadStream: '%s' does not exist", getName().c_str());
|
||||
return nullptr;
|
||||
} else if (_realNode->isDirectory()) {
|
||||
warning("FSNode::createReadStream: '%s' is a directory", getName().c_str());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return _realNode->createReadStream();
|
||||
}
|
||||
|
||||
SeekableReadStream *FSNode::createReadStreamForAltStream(AltStreamType altStreamType) const {
|
||||
if (_realNode == nullptr)
|
||||
return nullptr;
|
||||
|
||||
if (!_realNode->exists()) {
|
||||
warning("FSNode::createReadStream: '%s' does not exist", getName().c_str());
|
||||
return nullptr;
|
||||
} else if (_realNode->isDirectory()) {
|
||||
warning("FSNode::createReadStream: '%s' is a directory", getName().c_str());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return _realNode->createReadStreamForAltStream(altStreamType);
|
||||
}
|
||||
|
||||
SeekableWriteStream *FSNode::createWriteStream(bool atomic) const {
|
||||
if (_realNode == nullptr)
|
||||
return nullptr;
|
||||
|
||||
if (_realNode->isDirectory()) {
|
||||
warning("FSNode::createWriteStream: '%s' is a directory", getName().c_str());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return _realNode->createWriteStream(atomic);
|
||||
}
|
||||
|
||||
bool FSNode::createDirectory() const {
|
||||
if (_realNode == nullptr)
|
||||
return false;
|
||||
|
||||
if (_realNode->exists()) {
|
||||
if (_realNode->isDirectory()) {
|
||||
warning("FSNode::createDirectory: '%s' already exists", getName().c_str());
|
||||
} else {
|
||||
warning("FSNode::createDirectory: '%s' is a file", getName().c_str());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return _realNode->createDirectory();
|
||||
}
|
||||
|
||||
FSDirectory::FSDirectory(const FSNode &node, int depth, bool flat, bool ignoreClashes, bool includeDirectories)
|
||||
: _node(node), _cached(false), _depth(depth), _flat(flat), _ignoreClashes(ignoreClashes),
|
||||
_includeDirectories(includeDirectories) {
|
||||
}
|
||||
|
||||
FSDirectory::FSDirectory(const Path &prefix, const FSNode &node, int depth, bool flat,
|
||||
bool ignoreClashes, bool includeDirectories)
|
||||
: _node(node), _cached(false), _depth(depth), _flat(flat), _ignoreClashes(ignoreClashes),
|
||||
_includeDirectories(includeDirectories) {
|
||||
|
||||
setPrefix(prefix);
|
||||
}
|
||||
|
||||
FSDirectory::FSDirectory(const Path &name, int depth, bool flat, bool ignoreClashes, bool includeDirectories)
|
||||
: _node(name), _cached(false), _depth(depth), _flat(flat), _ignoreClashes(ignoreClashes),
|
||||
_includeDirectories(includeDirectories) {
|
||||
}
|
||||
|
||||
FSDirectory::FSDirectory(const Path &prefix, const Path &name, int depth, bool flat,
|
||||
bool ignoreClashes, bool includeDirectories)
|
||||
: _node(name), _cached(false), _depth(depth), _flat(flat), _ignoreClashes(ignoreClashes),
|
||||
_includeDirectories(includeDirectories) {
|
||||
|
||||
setPrefix(prefix);
|
||||
}
|
||||
|
||||
FSDirectory::~FSDirectory() {
|
||||
}
|
||||
|
||||
void FSDirectory::setPrefix(const Path &prefix) {
|
||||
_prefix = prefix;
|
||||
}
|
||||
|
||||
FSNode FSDirectory::getFSNode() const {
|
||||
return _node;
|
||||
}
|
||||
|
||||
FSNode *FSDirectory::lookupCache(NodeCache &cache, const Path &name) const {
|
||||
// make caching as lazy as possible
|
||||
if (!name.empty()) {
|
||||
ensureCached();
|
||||
|
||||
if (cache.contains(name))
|
||||
return &cache[name];
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool FSDirectory::hasFile(const Path &path) const {
|
||||
if (path.empty() || !_node.isDirectory())
|
||||
return false;
|
||||
|
||||
FSNode *node = lookupCache(_fileCache, path);
|
||||
return node && node->exists();
|
||||
}
|
||||
|
||||
bool FSDirectory::isPathDirectory(const Path &path) const {
|
||||
if (path.empty() || !_node.isDirectory())
|
||||
return false;
|
||||
|
||||
FSNode *node = lookupCache(_subDirCache, path);
|
||||
return node && node->isDirectory();
|
||||
}
|
||||
|
||||
const ArchiveMemberPtr FSDirectory::getMember(const Path &path) const {
|
||||
if (path.empty() || !_node.isDirectory())
|
||||
return ArchiveMemberPtr();
|
||||
|
||||
FSNode *node = lookupCache(_fileCache, path);
|
||||
|
||||
if (!node || !node->exists()) {
|
||||
warning("FSDirectory::getMember: '%s' does not exist", Common::toPrintable(path.toString(Common::Path::kNativeSeparator)).c_str());
|
||||
return ArchiveMemberPtr();
|
||||
} else if (node->isDirectory()) {
|
||||
warning("FSDirectory::getMember: '%s' is a directory", Common::toPrintable(path.toString(Common::Path::kNativeSeparator)).c_str());
|
||||
return ArchiveMemberPtr();
|
||||
}
|
||||
|
||||
return ArchiveMemberPtr(new FSDirectoryFile(path, *node));
|
||||
}
|
||||
|
||||
SeekableReadStream *FSDirectory::createReadStreamForMember(const Path &path) const {
|
||||
if (path.empty() || !_node.isDirectory())
|
||||
return nullptr;
|
||||
|
||||
FSNode *node = lookupCache(_fileCache, path);
|
||||
if (!node)
|
||||
return nullptr;
|
||||
|
||||
debug(5, "FSDirectory::createReadStreamForMember('%s') -> '%s'", path.toString(Common::Path::kNativeSeparator).c_str(), node->getPath().toString(Common::Path::kNativeSeparator).c_str());
|
||||
|
||||
SeekableReadStream *stream = node->createReadStream();
|
||||
if (!stream)
|
||||
warning("FSDirectory::createReadStreamForMember: Can't create stream for file '%s'", Common::toPrintable(path.toString(Common::Path::kNativeSeparator)).c_str());
|
||||
|
||||
return stream;
|
||||
}
|
||||
|
||||
SeekableReadStream *FSDirectory::createReadStreamForMemberAltStream(const Path &path, AltStreamType altStreamType) const {
|
||||
if (path.empty() || !_node.isDirectory())
|
||||
return nullptr;
|
||||
|
||||
FSNode *node = lookupCache(_fileCache, path);
|
||||
if (!node)
|
||||
return nullptr;
|
||||
|
||||
debug(5, "FSDirectory::createReadStreamForMemberAltStream('%s', %i) -> '%s'", path.toString(Common::Path::kNativeSeparator).c_str(), static_cast<int>(altStreamType), node->getPath().toString(Common::Path::kNativeSeparator).c_str());
|
||||
|
||||
SeekableReadStream *stream = node->createReadStreamForAltStream(altStreamType);
|
||||
if (!stream)
|
||||
debug(5, "FSDirectory::createReadStreamForMemberAltStream: Can't create stream for file '%s' alt stream type %i", Common::toPrintable(path.toString(Common::Path::kNativeSeparator)).c_str(), static_cast<int>(altStreamType));
|
||||
|
||||
return stream;
|
||||
}
|
||||
|
||||
FSDirectory *FSDirectory::getSubDirectory(const Path &name, int depth, bool flat, bool ignoreClashes) {
|
||||
return getSubDirectory(Path(), name, depth, flat, ignoreClashes);
|
||||
}
|
||||
|
||||
FSDirectory *FSDirectory::getSubDirectory(const Path &prefix, const Path &name, int depth,
|
||||
bool flat, bool ignoreClashes) {
|
||||
if (name.empty() || !_node.isDirectory())
|
||||
return nullptr;
|
||||
|
||||
FSNode *node = lookupCache(_subDirCache, name);
|
||||
if (!node)
|
||||
return nullptr;
|
||||
|
||||
return new FSDirectory(prefix, *node, depth, flat, ignoreClashes);
|
||||
}
|
||||
|
||||
void FSDirectory::cacheDirectoryRecursive(FSNode node, int depth, const Path& prefix) const {
|
||||
if (depth <= 0)
|
||||
return;
|
||||
|
||||
FSList list;
|
||||
node.getChildren(list, FSNode::kListAll);
|
||||
|
||||
for (auto &curNode : list) {
|
||||
Path name = prefix.appendComponent(curNode.getRealName());
|
||||
|
||||
// since the hashmap is case insensitive, we need to check for clashes when caching
|
||||
if (curNode.isDirectory()) {
|
||||
if (!_flat && _subDirCache.contains(name)) {
|
||||
// Always warn in this case as it's when there are 2 directories at the same place with different case
|
||||
// That means a problem in user installation as lookups are always done case insensitive
|
||||
warning("FSDirectory::cacheDirectory: name clash when building cache, ignoring sub-directory '%s'",
|
||||
Common::toPrintable(name.toString(Common::Path::kNativeSeparator)).c_str());
|
||||
} else {
|
||||
if (_subDirCache.contains(name)) {
|
||||
if (!_ignoreClashes) {
|
||||
warning("FSDirectory::cacheDirectory: name clash when building subDirCache with subdirectory '%s'",
|
||||
Common::toPrintable(name.toString(Common::Path::kNativeSeparator)).c_str());
|
||||
}
|
||||
}
|
||||
cacheDirectoryRecursive(curNode, depth - 1, _flat ? prefix : name);
|
||||
_subDirCache[name] = curNode;
|
||||
_dirMapCache[prefix].push_back(curNode.getRealName());
|
||||
}
|
||||
} else {
|
||||
if (_fileCache.contains(name)) {
|
||||
if (!_ignoreClashes) {
|
||||
warning("FSDirectory::cacheDirectory: name clash when building cache, ignoring file '%s'",
|
||||
Common::toPrintable(name.toString(Common::Path::kNativeSeparator)).c_str());
|
||||
}
|
||||
} else {
|
||||
_fileCache[name] = curNode;
|
||||
_fileMapCache[prefix].push_back(curNode.getRealName());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void FSDirectory::ensureCached() const {
|
||||
if (_cached)
|
||||
return;
|
||||
cacheDirectoryRecursive(_node, _depth, _prefix);
|
||||
_cached = true;
|
||||
}
|
||||
|
||||
bool FSDirectory::getChildren(const Common::Path &path, Common::Array<Common::String> &list, ListMode mode, bool hidden) const {
|
||||
if (!_node.isDirectory())
|
||||
return 0;
|
||||
|
||||
// Cache dir data
|
||||
ensureCached();
|
||||
|
||||
Common::Path pathNormalized = path.normalize();
|
||||
|
||||
int matches = 0;
|
||||
|
||||
if (mode == kListDirectoriesOnly || mode == kListAll) {
|
||||
for (const auto &dir : _dirMapCache[pathNormalized]) {
|
||||
if (hidden || dir.firstChar() != '.') {
|
||||
list.push_back(dir);
|
||||
matches++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (mode == kListFilesOnly || mode == kListAll) {
|
||||
for (const auto &file : _fileMapCache[pathNormalized]) {
|
||||
if (hidden || file.firstChar() != '.') {
|
||||
list.push_back(file);
|
||||
matches++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return matches;
|
||||
}
|
||||
|
||||
int FSDirectory::listMatchingMembers(ArchiveMemberList &list, const Path &pattern, bool matchPathComponents) const {
|
||||
if (!_node.isDirectory())
|
||||
return 0;
|
||||
|
||||
// Cache dir data
|
||||
ensureCached();
|
||||
|
||||
int matches = 0;
|
||||
const char pathSep = getPathSeparator();
|
||||
const char pathSepStr[] = {pathSep, '\0'};
|
||||
const char *wildCardExclusions = matchPathComponents ? nullptr : pathSepStr;
|
||||
Common::String patternStr;
|
||||
if (matchPathComponents)
|
||||
patternStr = pattern.toString(pathSep);
|
||||
|
||||
auto addMatchingToList = [&](const NodeCache &nodeCache) {
|
||||
for (const auto &it : nodeCache) {
|
||||
bool isMatch;
|
||||
if (matchPathComponents) {
|
||||
Common::String keyStr = it._key.toString(pathSep);
|
||||
isMatch = keyStr.matchString(patternStr, true, wildCardExclusions);
|
||||
} else
|
||||
isMatch = it._key.matchPattern(pattern);
|
||||
|
||||
if (isMatch) {
|
||||
list.push_back(ArchiveMemberPtr(new FSDirectoryFile(it._key, it._value)));
|
||||
++matches;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
addMatchingToList(_fileCache);
|
||||
|
||||
if (_includeDirectories)
|
||||
addMatchingToList(_subDirCache);
|
||||
|
||||
return matches;
|
||||
}
|
||||
|
||||
int FSDirectory::listMembers(ArchiveMemberList &list) const {
|
||||
if (!_node.isDirectory())
|
||||
return 0;
|
||||
|
||||
// Cache dir data
|
||||
ensureCached();
|
||||
|
||||
int files = 0;
|
||||
for (const auto &it : _fileCache) {
|
||||
list.push_back(ArchiveMemberPtr(new FSDirectoryFile(it._key, it._value)));
|
||||
++files;
|
||||
}
|
||||
|
||||
if (_includeDirectories) {
|
||||
for (const auto &it : _subDirCache) {
|
||||
list.push_back(ArchiveMemberPtr(new FSDirectoryFile(it._key, it._value)));
|
||||
++files;
|
||||
}
|
||||
}
|
||||
|
||||
return files;
|
||||
}
|
||||
|
||||
|
||||
} // End of namespace Common
|
||||
Reference in New Issue
Block a user