Moved FilesystemNode / FSList to namespace Common; also got rid of some 'typedef Common::String String;' name aliases

svn-id: r34302

backends/fs/abstract-fs.h

@@ -43,22 +43,21 @@ typedef Common::Array<AbstractFilesystemNode *>	AbstractFSList;
  */
 class AbstractFilesystemNode {
 protected:
-	friend class FilesystemNode;
-	typedef Common::String String;
-	typedef FilesystemNode::ListMode ListMode;
+	friend class Common::FilesystemNode;
+	typedef Common::FilesystemNode::ListMode ListMode;
 
 	/**
-	 * Returns the child node with the given name. If no child with this name
-	 * exists, returns 0. When called on a non-directory node, it should
-	 * handle this gracefully by returning 0.
+	 * Returns the child node with the given name. When called on a non-directory
+	 * node, it should handle this gracefully by returning 0.
+	 * When called with a name not matching any of the files/dirs contained in this
+	 * directory, a valid node shold be returned, which returns 'false' upon calling
+	 * the exists() method. The idea is that this node can then still can be used to
+	 * create a new file via the openForWriting() method.
 	 *
 	 * Example:
 	 *			Calling getChild() for a node with path "/foo/bar" using name="file.txt",
 	 *			would produce a new node with "/foo/bar/file.txt" as path.
 	 *
-	 * @note This function will append a separator char (\ or /) to the end of the
-	 * path if needed.
-	 *
 	 * @note Handling calls on non-dir nodes gracefully makes it possible to
 	 * switch to a lazy type detection scheme in the future.
 	 *

backends/fs/amigaos4/amigaos4-fs.cpp

@@ -52,8 +52,8 @@ const uint32 kExAllBufferSize = 40960; // TODO: is this okay for sure?
 class AmigaOSFilesystemNode : public AbstractFilesystemNode {
 protected:
 	BPTR _pFileLock;
-	String _sDisplayName;
-	String _sPath;
+	Common::String _sDisplayName;
+	Common::String _sPath;
 	bool _bIsDirectory;
 	bool _bIsValid;
 
@@ -74,9 +74,9 @@ public:
 	/**
 	 * Creates a AmigaOSFilesystemNode for a given path.
 	 *
-	 * @param path String with the path the new node should point to.
+	 * @param path Common::String with the path the new node should point to.
 	 */
-	AmigaOSFilesystemNode(const String &p);
+	AmigaOSFilesystemNode(const Common::String &p);
 
 	/**
 	 * FIXME: document this constructor.
@@ -96,14 +96,14 @@ public:
 	virtual ~AmigaOSFilesystemNode();
 
 	virtual bool exists() const;
-	virtual String getDisplayName() const { return _sDisplayName; };
-	virtual String getName() const { return _sDisplayName; };
-	virtual String getPath() const { return _sPath; };
+	virtual Common::String getDisplayName() const { return _sDisplayName; };
+	virtual Common::String getName() const { return _sDisplayName; };
+	virtual Common::String getPath() const { return _sPath; };
 	virtual bool isDirectory() const { return _bIsDirectory; };
 	virtual bool isReadable() const;
 	virtual bool isWritable() const;
 
-	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 
@@ -116,7 +116,7 @@ public:
 /**
  * Returns the last component of a given path.
  *
- * @param str String containing the path.
+ * @param str Common::String containing the path.
  * @return Pointer to the first char of the last component inside str.
  */
 const char *lastPathComponent(const Common::String &str) {
@@ -148,7 +148,7 @@ AmigaOSFilesystemNode::AmigaOSFilesystemNode() {
 	LEAVE();
 }
 
-AmigaOSFilesystemNode::AmigaOSFilesystemNode(const String &p) {
+AmigaOSFilesystemNode::AmigaOSFilesystemNode(const Common::String &p) {
 	ENTER();
 
 	int len = 0, offset = p.size();
@@ -299,14 +299,14 @@ bool AmigaOSFilesystemNode::exists() const {
 	return nodeExists;
 }
 
-AbstractFilesystemNode *AmigaOSFilesystemNode::getChild(const String &n) const {
+AbstractFilesystemNode *AmigaOSFilesystemNode::getChild(const Common::String &n) const {
 	ENTER();
 	if (!_bIsDirectory) {
 		debug(6, "Not a directory");
 		return 0;
 	}
 
-	String newPath(_sPath);
+	Common::String newPath(_sPath);
 
 	if (_sPath.lastChar() != '/')
 		newPath += '/';
@@ -368,10 +368,10 @@ bool AmigaOSFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, b
 
 				struct ExAllData *ead = data;
 				do {
-					if ((mode == FilesystemNode::kListAll) ||
-						(EAD_IS_DRAWER(ead) && (mode == FilesystemNode::kListDirectoriesOnly)) ||
-						(EAD_IS_FILE(ead) && (mode == FilesystemNode::kListFilesOnly))) {
-						String full_path = _sPath;
+					if ((mode == Common::FilesystemNode::kListAll) ||
+						(EAD_IS_DRAWER(ead) && (mode == Common::FilesystemNode::kListDirectoriesOnly)) ||
+						(EAD_IS_FILE(ead) && (mode == Common::FilesystemNode::kListFilesOnly))) {
+						Common::String full_path = _sPath;
 						full_path += (char*)ead->ed_Name;
 
 						BPTR lock = IDOS->Lock((STRPTR)full_path.c_str(), SHARED_LOCK);

backends/fs/ds/ds-fs-factory.cpp

@@ -45,7 +45,7 @@ AbstractFilesystemNode *DSFilesystemFactory::makeCurrentDirectoryFileNode() cons
 	}
 }
 
-AbstractFilesystemNode *DSFilesystemFactory::makeFileNodePath(const String &path) const {
+AbstractFilesystemNode *DSFilesystemFactory::makeFileNodePath(const Common::String &path) const {
 	if (DS::isGBAMPAvailable()) {
 		return new DS::GBAMPFileSystemNode(path);
 	} else {

backends/fs/ds/ds-fs-factory.h

@@ -35,11 +35,9 @@
  */
 class DSFilesystemFactory : public FilesystemFactory, public Common::Singleton<DSFilesystemFactory> {
 public:
-	typedef Common::String String;
-
 	virtual AbstractFilesystemNode *makeRootFileNode() const;
 	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
-	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
 
 protected:
 	DSFilesystemFactory() {};

backends/fs/ds/ds-fs.cpp

@@ -55,7 +55,7 @@ DSFileSystemNode::DSFileSystemNode() {
 	}
 }
 
-DSFileSystemNode::DSFileSystemNode(const String& path) {
+DSFileSystemNode::DSFileSystemNode(const Common::String& path) {
 //	consolePrintf("--%s ",path.c_str());
 
 	char disp[128];
@@ -70,7 +70,7 @@ DSFileSystemNode::DSFileSystemNode(const String& path) {
 
 	strcpy(disp, pathStr + lastSlash + 1);
 
-	_displayName = String(disp);
+	_displayName = Common::String(disp);
 	_path = path;
 //	_isValid = true;
 //	_isDirectory = false;
@@ -98,7 +98,7 @@ DSFileSystemNode::DSFileSystemNode(const String& path) {
 //	consolePrintf("%s - Found: %d, Dir: %d\n", pathStr, _isValid, _isDirectory);
 }
 
-DSFileSystemNode::DSFileSystemNode(const String& path, bool isDir) {
+DSFileSystemNode::DSFileSystemNode(const Common::String& path, bool isDir) {
 //	consolePrintf("--%s ",path.c_str());
 
 	char disp[128];
@@ -112,7 +112,7 @@ DSFileSystemNode::DSFileSystemNode(const String& path, bool isDir) {
 
 	strcpy(disp, pathStr + lastSlash + 1);
 
-	_displayName = String(disp);
+	_displayName = Common::String(disp);
 	_path = path;
 	_isValid = true;
 	_isDirectory = isDir;
@@ -167,10 +167,10 @@ bool DSFileSystemNode::getChildren(AbstractFSList &dirList, ListMode mode, bool
 			_zipFile->getFileName(n);
 
 //			consolePrintf("file: %s\n", n);
-			if ( (_zipFile->isDirectory() && ((mode == FilesystemNode::kListDirectoriesOnly) || (mode == FilesystemNode::kListAll)) )
-				|| (!_zipFile->isDirectory() && ((mode == FilesystemNode::kListFilesOnly) || (mode == FilesystemNode::kListAll)) ) )
+			if ( (_zipFile->isDirectory() && ((mode == Common::FilesystemNode::kListDirectoriesOnly) || (mode == Common::FilesystemNode::kListAll)) )
+				|| (!_zipFile->isDirectory() && ((mode == Common::FilesystemNode::kListFilesOnly) || (mode == Common::FilesystemNode::kListAll)) ) )
 			{
-				DSFileSystemNode* dsfsn = new DSFileSystemNode("ds:/" + String(n), _zipFile->isDirectory());
+				DSFileSystemNode* dsfsn = new DSFileSystemNode("ds:/" + Common::String(n), _zipFile->isDirectory());
 				dsfsn->_isDirectory = _zipFile->isDirectory();
 				dirList.push_back((dsfsn));
 			}
@@ -195,7 +195,7 @@ AbstractFilesystemNode* DSFileSystemNode::getParent() const {
 			}
 		}
 
-		p = new DSFileSystemNode(String(path, lastSlash));
+		p = new DSFileSystemNode(Common::String(path, lastSlash));
 		((DSFileSystemNode *) (p))->_isDirectory = true;
 	} else {
 		p = new DSFileSystemNode();
@@ -216,7 +216,7 @@ GBAMPFileSystemNode::GBAMPFileSystemNode() {
 	_path = "mp:/";
 }
 
-GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path) {
+GBAMPFileSystemNode::GBAMPFileSystemNode(const Common::String& path) {
 //	consolePrintf("'%s'",path.c_str());
 
 	char disp[128];
@@ -245,13 +245,13 @@ GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path) {
 	}
 //	consolePrintf("Path: %s  (%d)\n", check, success);
 
-	_displayName = String(disp);
+	_displayName = Common::String(disp);
 	_path = path;
 	_isValid = success == FT_FILE;
 	_isDirectory = success == FT_DIR;
 }
 
-GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path, bool isDirectory) {
+GBAMPFileSystemNode::GBAMPFileSystemNode(const Common::String& path, bool isDirectory) {
 //	consolePrintf("'%s'",path.c_str());
 
 	char disp[128];
@@ -265,7 +265,7 @@ GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path, bool isDirectory) {
 
 	strcpy(disp, pathStr + lastSlash + 1);
 
-	_displayName = String(disp);
+	_displayName = Common::String(disp);
 	_path = path;
 	_isValid = true;
 	_isDirectory = isDirectory;
@@ -313,8 +313,8 @@ bool GBAMPFileSystemNode::getChildren(AbstractFSList& dirList, ListMode mode, bo
 
 	while (entryType != TYPE_NO_MORE) {
 
-		if ( ((entryType == TYPE_DIR) && ((mode == FilesystemNode::kListDirectoriesOnly) || (mode == FilesystemNode::kListAll)))
-		||   ((entryType == TYPE_FILE) && ((mode == FilesystemNode::kListFilesOnly) || (mode == FilesystemNode::kListAll))) ) {
+		if ( ((entryType == TYPE_DIR) && ((mode == Common::FilesystemNode::kListDirectoriesOnly) || (mode == Common::FilesystemNode::kListAll)))
+		||   ((entryType == TYPE_FILE) && ((mode == Common::FilesystemNode::kListFilesOnly) || (mode == Common::FilesystemNode::kListAll))) ) {
 			GBAMPFileSystemNode* dsfsn;
 
 			consolePrintf("Fname: %s\n", fname);
@@ -322,9 +322,9 @@ bool GBAMPFileSystemNode::getChildren(AbstractFSList& dirList, ListMode mode, bo
 			if (strcmp(fname, ".") && strcmp(fname, "..")) {
 
 				if (!strcmp(path, "/")) {
-					dsfsn = new GBAMPFileSystemNode("mp:" + String(path) + String(fname), entryType == TYPE_DIR);
+					dsfsn = new GBAMPFileSystemNode("mp:" + Common::String(path) + Common::String(fname), entryType == TYPE_DIR);
 				} else {
-					dsfsn = new GBAMPFileSystemNode("mp:" + String(path) + String("/") + String(fname), entryType == TYPE_DIR);
+					dsfsn = new GBAMPFileSystemNode("mp:" + Common::String(path) + Common::String("/") + Common::String(fname), entryType == TYPE_DIR);
 				}
 
 //				dsfsn->_isDirectory = entryType == DIR;
@@ -358,7 +358,7 @@ AbstractFilesystemNode* GBAMPFileSystemNode::getParent() const {
 			}
 		}
 
-		p = new GBAMPFileSystemNode(String(path, lastSlash));
+		p = new GBAMPFileSystemNode(Common::String(path, lastSlash));
 		p->_isDirectory = true;
 	} else {
 		p = new GBAMPFileSystemNode();

backends/fs/ds/ds-fs.h

@@ -41,8 +41,6 @@ namespace DS {
  */
 class DSFileSystemNode : public AbstractFilesystemNode {
 protected:
-	typedef class Common::String String;
-
 	static ZipFile* _zipFile;
 
 	String _displayName;
@@ -89,7 +87,7 @@ public:
 	 */
 	virtual AbstractFilesystemNode *clone() const { return new DSFileSystemNode(this); }
 	virtual AbstractFilesystemNode *getChild(const Common::String& name) const;
-	virtual bool getChildren(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly, bool hidden = false) const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 
 	/**
@@ -107,8 +105,6 @@ public:
  */
 class GBAMPFileSystemNode : public AbstractFilesystemNode {
 protected:
-	typedef class Common::String String;
-
 	String _displayName;
 	String _path;
 	bool _isDirectory;
@@ -153,7 +149,7 @@ public:
 	 */
 	virtual AbstractFilesystemNode *clone() const { return new GBAMPFileSystemNode(this); }
 	virtual AbstractFilesystemNode *getChild(const Common::String& name) const;
-	virtual bool getChildren(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly, bool hidden = false) const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 };
 

backends/fs/palmos/palmos-fs-factory.cpp

@@ -36,7 +36,7 @@ AbstractFilesystemNode *PalmOSFilesystemFactory::makeCurrentDirectoryFileNode()
 	return new PalmOSFilesystemNode();
 }
 
-AbstractFilesystemNode *PalmOSFilesystemFactory::makeFileNodePath(const String &path) const {
+AbstractFilesystemNode *PalmOSFilesystemFactory::makeFileNodePath(const Common::String &path) const {
 	return new PalmOSFilesystemNode(path);
 }
 #endif

backends/fs/palmos/palmos-fs-factory.h

@@ -35,11 +35,9 @@
  */
 class PalmOSFilesystemFactory : public FilesystemFactory, public Common::Singleton<PalmOSFilesystemFactory> {
 public:
-	typedef Common::String String;
-
 	virtual AbstractFilesystemNode *makeRootFileNode() const;
 	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
-	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
 
 protected:
 	PalmOSFilesystemFactory() {};

backends/fs/palmos/palmos-fs.cpp

@@ -36,8 +36,8 @@
  */
 class PalmOSFilesystemNode : public AbstractFilesystemNode {
 protected:
-	String _displayName;
-	String _path;
+	Common::String _displayName;
+	Common::String _path;
 	bool _isDirectory;
 	bool _isValid;
 	bool _isPseudoRoot;
@@ -51,19 +51,19 @@ public:
 	/**
 	 * Creates a POSIXFilesystemNode for a given path.
 	 *
-	 * @param path String with the path the new node should point to.
+	 * @param path Common::String with the path the new node should point to.
 	 */
-	PalmOSFilesystemNode(const String &p);
+	PalmOSFilesystemNode(const Common::String &p);
 
 	virtual bool exists() const { return _isValid; }
-	virtual String getDisplayName() const { return _displayName; }
-	virtual String getName() const { return _displayName; }
-	virtual String getPath() const { return _path; }
+	virtual Common::String getDisplayName() const { return _displayName; }
+	virtual Common::String getName() const { return _displayName; }
+	virtual Common::String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
 	virtual bool isReadable() const { return true; }	//FIXME: this is just a stub
 	virtual bool isWritable() const { return true; }	//FIXME: this is just a stub
 
-	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 
@@ -74,7 +74,7 @@ private:
 	 *
 	 * @param list List to put the file entry node in.
 	 * @param mode Mode to use while adding the file entry to the list.
-	 * @param base String with the directory being listed.
+	 * @param base Common::String with the directory being listed.
 	 * @param find_data Describes a file that the FindFirstFile, FindFirstFileEx, or FindNextFile functions find.
 	 */
 	static void addFile(AbstractFSList &list, ListMode mode, const Char *base, FileInfoType* find_data);
@@ -86,8 +86,8 @@ void PalmOSFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const ch
 
 	isDir = (find_data->attributes & vfsFileAttrDirectory);
 
-	if ((!isDir && mode == FilesystemNode::kListDirectoriesOnly) ||
-		(isDir && mode == FilesystemNode::kListFilesOnly))
+	if ((!isDir && mode == Common::FilesystemNode::kListDirectoriesOnly) ||
+		(isDir && mode == Common::FilesystemNode::kListFilesOnly))
 		return;
 
 	entry._isDirectory = isDir;
@@ -112,7 +112,7 @@ PalmOSFilesystemNode::PalmOSFilesystemNode() {
 	_isPseudoRoot = false;
 }
 
-PalmOSFilesystemNode::PalmOSFilesystemNode(const String &p) {
+PalmOSFilesystemNode::PalmOSFilesystemNode(const Common::String &p) {
 	_path = p;
 	_displayName = lastPathComponent(_path, '/');
 
@@ -135,10 +135,10 @@ PalmOSFilesystemNode::PalmOSFilesystemNode(const String &p) {
 	_isPseudoRoot = false;
 }
 
-AbstractFilesystemNode *PalmOSFilesystemNode::getChild(const String &n) const {
+AbstractFilesystemNode *PalmOSFilesystemNode::getChild(const Common::String &n) const {
 	assert(_isDirectory);
 
-	String newPath(_path);
+	Common::String newPath(_path);
 	if (_path.lastChar() != '/')
 		newPath += '/';
 	newPath += n;
@@ -194,7 +194,7 @@ AbstractFilesystemNode *PalmOSFilesystemNode::getParent() const {
 		const char *end = lastPathComponent(_path, '/');
 
 		p = new PalmOSFilesystemNode();
-		p->_path = String(start, end - start);
+		p->_path = Common::String(start, end - start);
 		p->_isValid = true;
 		p->_isDirectory = true;
 		p->_displayName = lastPathComponent(p->_path, '/');

backends/fs/posix/posix-fs.cpp

@@ -202,8 +202,8 @@ bool POSIXFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, boo
 			continue;
 
 		// Honor the chosen mode
-		if ((mode == FilesystemNode::kListFilesOnly && entry._isDirectory) ||
-			(mode == FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
+		if ((mode == Common::FilesystemNode::kListFilesOnly && entry._isDirectory) ||
+			(mode == Common::FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
 			continue;
 
 		myList.push_back(new POSIXFilesystemNode(entry));

backends/fs/ps2/ps2-fs-factory.cpp

@@ -36,7 +36,7 @@ AbstractFilesystemNode *Ps2FilesystemFactory::makeCurrentDirectoryFileNode() con
 	return new Ps2FilesystemNode();
 }
 
-AbstractFilesystemNode *Ps2FilesystemFactory::makeFileNodePath(const String &path) const {
+AbstractFilesystemNode *Ps2FilesystemFactory::makeFileNodePath(const Common::String &path) const {
 	// return new Ps2FilesystemNode(path);
 
 	Ps2FilesystemNode *nf = new Ps2FilesystemNode(path, true);

backends/fs/ps2/ps2-fs-factory.h

@@ -35,11 +35,9 @@
  */
 class Ps2FilesystemFactory : public FilesystemFactory, public Common::Singleton<Ps2FilesystemFactory> {	
 public:
-	typedef Common::String String;
-		
 	virtual AbstractFilesystemNode *makeRootFileNode() const;
 	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
-	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
 	
 protected:
 	Ps2FilesystemFactory() {};

backends/fs/ps2/ps2-fs.cpp

@@ -47,8 +47,8 @@ class Ps2FilesystemNode : public AbstractFilesystemNode {
 friend class Ps2FilesystemFactory;
 
 protected:
-	String _displayName;
-	String _path;
+	Common::String _displayName;
+	Common::String _path;
 	bool _isDirectory;
 	bool _isRoot;
 
@@ -65,10 +65,10 @@ public:
 	/**
 	 * Creates a PS2FilesystemNode for a given path.
 	 * 
-	 * @param path String with the path the new node should point to.
+	 * @param path Common::String with the path the new node should point to.
 	 */
-	Ps2FilesystemNode(const String &path);
-	Ps2FilesystemNode(const String &path, bool verify);
+	Ps2FilesystemNode(const Common::String &path);
+	Ps2FilesystemNode(const Common::String &path, bool verify);
 	
 	/**
 	 * Copy constructor.
@@ -77,9 +77,9 @@ public:
 
 	virtual bool exists(void) const;
 
-	virtual String getDisplayName() const { return _displayName; }
-	virtual String getName() const { return _displayName; }
-	virtual String getPath() const { return _path; }
+	virtual Common::String getDisplayName() const { return _displayName; }
+	virtual Common::String getName() const { return _displayName; }
+	virtual Common::String getPath() const { return _path; }
 
 	virtual bool isDirectory() const {
 		return _isDirectory;
@@ -95,7 +95,7 @@ public:
 	}
 
 	virtual AbstractFilesystemNode *clone() const { return new Ps2FilesystemNode(this); }
-	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 };
@@ -107,12 +107,12 @@ Ps2FilesystemNode::Ps2FilesystemNode() {
 	_path = "";
 }
 
-Ps2FilesystemNode::Ps2FilesystemNode(const String &path) {
+Ps2FilesystemNode::Ps2FilesystemNode(const Common::String &path) {
 	_path = path;
 	_isDirectory = true;
 	if (strcmp(path.c_str(), "") == 0) {
 		_isRoot = true;
-		_displayName = String("PlayStation 2");
+		_displayName = Common::String("PlayStation 2");
 	} else {
 		_isRoot = false;
 		const char *dsplName = NULL, *pos = path.c_str();
@@ -120,18 +120,18 @@ Ps2FilesystemNode::Ps2FilesystemNode(const String &path) {
 			if (*pos++ == '/')
 				dsplName = pos;
 		if (dsplName)
-			_displayName = String(dsplName);
+			_displayName = Common::String(dsplName);
 		else
 			_displayName = getDeviceDescription(path.c_str());
 	}
 }
 
-Ps2FilesystemNode::Ps2FilesystemNode(const String &path, bool verify) {
+Ps2FilesystemNode::Ps2FilesystemNode(const Common::String &path, bool verify) {
 	_path = path;
 
 	if (strcmp(path.c_str(), "") == 0) {
 		_isRoot = true; /* root is always a dir*/
-		_displayName = String("PlayStation 2");
+		_displayName = Common::String("PlayStation 2");
 		_isDirectory = true;
 	} else {
 		_isRoot = false;
@@ -141,7 +141,7 @@ Ps2FilesystemNode::Ps2FilesystemNode(const String &path, bool verify) {
 				dsplName = pos;
 
 		if (dsplName) {
-			_displayName = String(dsplName);
+			_displayName = Common::String(dsplName);
 			if (verify)
 				_isDirectory = getDirectoryFlag(path.c_str());
 			else
@@ -206,7 +206,7 @@ bool Ps2FilesystemNode::getDirectoryFlag(const char *path) {
 	return false;
 }
 
-AbstractFilesystemNode *Ps2FilesystemNode::getChild(const String &n) const {
+AbstractFilesystemNode *Ps2FilesystemNode::getChild(const Common::String &n) const {
 	if (!_isDirectory)
 		return NULL;
 
@@ -284,9 +284,9 @@ bool Ps2FilesystemNode::getChildren(AbstractFSList &list, ListMode mode, bool hi
 			while ((dreadRes = fio.dread(fd, &dirent)) > 0) {
 				if (dirent.name[0] == '.')
 					continue; // ignore '.' and '..'
-				if (((mode == FilesystemNode::kListDirectoriesOnly) && (dirent.stat.mode & FIO_S_IFDIR)) ||
-					((mode == FilesystemNode::kListFilesOnly) && !(dirent.stat.mode & FIO_S_IFDIR)) ||
-					(mode == FilesystemNode::kListAll)) {
+				if (((mode == Common::FilesystemNode::kListDirectoriesOnly) && (dirent.stat.mode & FIO_S_IFDIR)) ||
+					((mode == Common::FilesystemNode::kListFilesOnly) && !(dirent.stat.mode & FIO_S_IFDIR)) ||
+					(mode == Common::FilesystemNode::kListAll)) {
 
 					dirEntry._isDirectory = (bool)(dirent.stat.mode & FIO_S_IFDIR);
 					dirEntry._isRoot = false;
@@ -322,7 +322,7 @@ AbstractFilesystemNode *Ps2FilesystemNode::getParent() const {
 	}
 
 	if (slash)
-		return new Ps2FilesystemNode(String(_path.c_str(), slash - _path.c_str()));
+		return new Ps2FilesystemNode(Common::String(_path.c_str(), slash - _path.c_str()));
 	else
 		return new Ps2FilesystemNode();
 }

backends/fs/psp/psp-fs-factory.cpp

@@ -36,7 +36,7 @@ AbstractFilesystemNode *PSPFilesystemFactory::makeCurrentDirectoryFileNode() con
 	return new PSPFilesystemNode();
 }
 
-AbstractFilesystemNode *PSPFilesystemFactory::makeFileNodePath(const String &path) const {
+AbstractFilesystemNode *PSPFilesystemFactory::makeFileNodePath(const Common::String &path) const {
 	return new PSPFilesystemNode(path, true);
 }
 #endif

backends/fs/psp/psp-fs-factory.h

@@ -35,11 +35,9 @@
  */
 class PSPFilesystemFactory : public FilesystemFactory, public Common::Singleton<PSPFilesystemFactory> {
 public:
-	typedef Common::String String;
-
 	virtual AbstractFilesystemNode *makeRootFileNode() const;
 	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
-	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
 
 protected:
 	PSPFilesystemFactory() {};

backends/fs/psp/psp-fs.cpp

@@ -39,8 +39,8 @@
  */
 class PSPFilesystemNode : public AbstractFilesystemNode {
 protected:
-	String _displayName;
-	String _path;
+	Common::String _displayName;
+	Common::String _path;
 	bool _isDirectory;
 	bool _isValid;
 
@@ -53,20 +53,20 @@ public:
 	/**
 	 * Creates a PSPFilesystemNode for a given path.
 	 *
-	 * @param path String with the path the new node should point to.
+	 * @param path Common::String with the path the new node should point to.
 	 * @param verify true if the isValid and isDirectory flags should be verified during the construction.
 	 */
 	PSPFilesystemNode(const Common::String &p, bool verify);
 
 	virtual bool exists() const { return access(_path.c_str(), F_OK) == 0; }
-	virtual String getDisplayName() const { return _displayName; }
-	virtual String getName() const { return _displayName; }
-	virtual String getPath() const { return _path; }
+	virtual Common::String getDisplayName() const { return _displayName; }
+	virtual Common::String getName() const { return _displayName; }
+	virtual Common::String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
 	virtual bool isReadable() const { return access(_path.c_str(), R_OK) == 0; }
 	virtual bool isWritable() const { return access(_path.c_str(), W_OK) == 0; }
 
-	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 };
@@ -93,12 +93,12 @@ PSPFilesystemNode::PSPFilesystemNode(const Common::String &p, bool verify) {
 	}
 }
 
-AbstractFilesystemNode *PSPFilesystemNode::getChild(const String &n) const {
+AbstractFilesystemNode *PSPFilesystemNode::getChild(const Common::String &n) const {
 	// FIXME: Pretty lame implementation! We do no error checking to speak
 	// of, do not check if this is a special node, etc.
 	assert(_isDirectory);
 
-	String newPath(_path);
+	Common::String newPath(_path);
 	if (_path.lastChar() != '/')
 		newPath += '/';
 	newPath += n;
@@ -133,8 +133,8 @@ bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
 				entry._path += "/";
 
 			// Honor the chosen mode
-			if ((mode == FilesystemNode::kListFilesOnly && entry._isDirectory) ||
-			   (mode == FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
+			if ((mode == Common::FilesystemNode::kListFilesOnly && entry._isDirectory) ||
+			   (mode == Common::FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
 				continue;
 
 			myList.push_back(new PSPFilesystemNode(entry));
@@ -154,7 +154,7 @@ AbstractFilesystemNode *PSPFilesystemNode::getParent() const {
 	const char *start = _path.c_str();
 	const char *end = lastPathComponent(_path, '/');
 
-	return new PSPFilesystemNode(String(start, end - start), false);
+	return new PSPFilesystemNode(Common::String(start, end - start), false);
 }
 
 #endif //#ifdef __PSP__

backends/fs/symbian/symbian-fs.cpp

@@ -38,8 +38,8 @@
  */
 class SymbianFilesystemNode : public AbstractFilesystemNode {
 protected:
-	String _displayName;
-	String _path;
+	Common::String _displayName;
+	Common::String _path;
 	bool _isDirectory;
 	bool _isValid;
 	bool _isPseudoRoot;
@@ -55,9 +55,9 @@ public:
 	/**
 	 * Creates a SymbianFilesystemNode for a given path.
 	 *
-	 * @param path String with the path the new node should point to.
+	 * @param path Common::String with the path the new node should point to.
 	 */
-	SymbianFilesystemNode(const String &path);
+	SymbianFilesystemNode(const Common::String &path);
 
 	virtual bool exists() const {
 		TFileName fname;
@@ -66,14 +66,14 @@ public:
 		TBool fileExists = BaflUtils::FileExists(static_cast<OSystem_SDL_Symbian*>(g_system)->FsSession(), fname);
 		return fileExists;
 	}
-	virtual String getDisplayName() const { return _displayName; }
-	virtual String getName() const { return _displayName; }
-	virtual String getPath() const { return _path; }
+	virtual Common::String getDisplayName() const { return _displayName; }
+	virtual Common::String getName() const { return _displayName; }
+	virtual Common::String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
 	virtual bool isReadable() const { return access(_path.c_str(), R_OK) == 0; }	//FIXME: this is just a stub
 	virtual bool isWritable() const { return access(_path.c_str(), W_OK) == 0; }	//FIXME: this is just a stub
 
-	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 };
@@ -81,7 +81,7 @@ public:
 /**
  * Fixes the path by changing all slashes to backslashes.
  *
- * @param path String with the path to be fixed.
+ * @param path Common::String with the path to be fixed.
  */
 static void fixFilePath(Common::String& aPath){
 	TInt len = aPath.size();
@@ -102,7 +102,7 @@ SymbianFilesystemNode::SymbianFilesystemNode(bool aIsRoot) {
 
 }
 
-SymbianFilesystemNode::SymbianFilesystemNode(const String &path) {
+SymbianFilesystemNode::SymbianFilesystemNode(const Common::String &path) {
 	if (path.size() == 0)
 		_isPseudoRoot = true;
 	else
@@ -128,9 +128,9 @@ SymbianFilesystemNode::SymbianFilesystemNode(const String &path) {
 	}
 }
 
-AbstractFilesystemNode *SymbianFilesystemNode::getChild(const String &n) const {
+AbstractFilesystemNode *SymbianFilesystemNode::getChild(const Common::String &n) const {
 	assert(_isDirectory);
-	String newPath(_path);
+	Common::String newPath(_path);
 
 	if (_path.lastChar() != '\\')
 		newPath += '\\';
@@ -210,8 +210,8 @@ bool SymbianFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, b
 				entry._isDirectory = fileentry.IsDir();
 
 				// Honor the chosen mode
-				if ((mode == FilesystemNode::kListFilesOnly && entry._isDirectory) ||
-					(mode == FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
+				if ((mode == Common::FilesystemNode::kListFilesOnly && entry._isDirectory) ||
+					(mode == Common::FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
 					continue;
 
 				if (entry._isDirectory)
@@ -235,7 +235,7 @@ AbstractFilesystemNode *SymbianFilesystemNode::getParent() const {
 		const char *start = _path.c_str();
 		const char *end = lastPathComponent(_path, '\\');
 
-		p->_path = String(start, end - start);
+		p->_path = Common::String(start, end - start);
 		p->_isValid = true;
 		p->_isDirectory = true;
 		p->_displayName = lastPathComponent(p->_path, '\\');

backends/fs/wii/wii-fs-factory.cpp

@@ -42,7 +42,7 @@ AbstractFilesystemNode *WiiFilesystemFactory::makeCurrentDirectoryFileNode() con
 		return new WiiFilesystemNode();
 }
 
-AbstractFilesystemNode *WiiFilesystemFactory::makeFileNodePath(const String &path) const {
+AbstractFilesystemNode *WiiFilesystemFactory::makeFileNodePath(const Common::String &path) const {
 	return new WiiFilesystemNode(path, true);
 }
 #endif

backends/fs/wii/wii-fs-factory.h

@@ -33,11 +33,9 @@
  */
 class WiiFilesystemFactory : public FilesystemFactory, public Common::Singleton<WiiFilesystemFactory> {
 public:
-	typedef Common::String String;
-
 	virtual AbstractFilesystemNode *makeRootFileNode() const;
 	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
-	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
 
 protected:
 	WiiFilesystemFactory() {};

backends/fs/wii/wii-fs.cpp

@@ -37,8 +37,8 @@
  */
 class WiiFilesystemNode : public AbstractFilesystemNode {
 protected:
-	String _displayName;
-	String _path;
+	Common::String _displayName;
+	Common::String _path;
 	bool _isDirectory, _isReadable, _isWritable;
 
 public:
@@ -50,20 +50,20 @@ public:
 	/**
 	 * Creates a WiiFilesystemNode for a given path.
 	 *
-	 * @param path String with the path the new node should point to.
+	 * @param path Common::String with the path the new node should point to.
 	 * @param verify true if the isValid and isDirectory flags should be verified during the construction.
 	 */
-	WiiFilesystemNode(const String &path, bool verify);
+	WiiFilesystemNode(const Common::String &path, bool verify);
 
 	virtual bool exists() const;
-	virtual String getDisplayName() const { return _displayName; }
-	virtual String getName() const { return _displayName; }
-	virtual String getPath() const { return _path; }
+	virtual Common::String getDisplayName() const { return _displayName; }
+	virtual Common::String getName() const { return _displayName; }
+	virtual Common::String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
 	virtual bool isReadable() const { return _isReadable; }
 	virtual bool isWritable() const { return _isWritable; }
 
-	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 
@@ -94,7 +94,7 @@ WiiFilesystemNode::WiiFilesystemNode() {
 	setFlags();
 }
 
-WiiFilesystemNode::WiiFilesystemNode(const String &p, bool verify) {
+WiiFilesystemNode::WiiFilesystemNode(const Common::String &p, bool verify) {
 	assert(p.size() > 0);
 
 	_path = p;
@@ -110,10 +110,10 @@ bool WiiFilesystemNode::exists() const {
 	return stat(_path.c_str (), &st) == 0;
 }
 
-AbstractFilesystemNode *WiiFilesystemNode::getChild(const String &n) const {
+AbstractFilesystemNode *WiiFilesystemNode::getChild(const Common::String &n) const {
 	assert(_isDirectory);
 
-	String newPath(_path);
+	Common::String newPath(_path);
 	if (newPath.lastChar() != '/')
 			newPath += '/';
 	newPath += n;
@@ -136,15 +136,15 @@ bool WiiFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
 		if (strcmp(filename, ".") == 0 || strcmp(filename, "..") == 0)
 			continue;
 
-		String newPath(_path);
+		Common::String newPath(_path);
 		if (newPath.lastChar() != '/')
 				newPath += '/';
 		newPath += filename;
 
 		bool isDir = S_ISDIR(st.st_mode);
 
-		if ((mode == FilesystemNode::kListFilesOnly && isDir) ||
-			(mode == FilesystemNode::kListDirectoriesOnly && !isDir))
+		if ((mode == Common::FilesystemNode::kListFilesOnly && isDir) ||
+			(mode == Common::FilesystemNode::kListDirectoriesOnly && !isDir))
 			continue;
 
 		if (isDir)
@@ -165,7 +165,7 @@ AbstractFilesystemNode *WiiFilesystemNode::getParent() const {
 	const char *start = _path.c_str();
 	const char *end = lastPathComponent(_path, '/');
 
-	return new WiiFilesystemNode(String(start, end - start), true);
+	return new WiiFilesystemNode(Common::String(start, end - start), true);
 }
 
 #endif //#if defined(__WII__)

backends/fs/windows/windows-fs.cpp

@@ -58,8 +58,8 @@
  */
 class WindowsFilesystemNode : public AbstractFilesystemNode {
 protected:
-	String _displayName;
-	String _path;
+	Common::String _displayName;
+	Common::String _path;
 	bool _isDirectory;
 	bool _isPseudoRoot;
 	bool _isValid;
@@ -81,20 +81,20 @@ public:
 	 *			path=c:\foo\bar.txt, currentDir=true -> current directory
 	 *			path=NULL, currentDir=true -> current directory
 	 *
-	 * @param path String with the path the new node should point to.
+	 * @param path Common::String with the path the new node should point to.
 	 * @param currentDir if true, the path parameter will be ignored and the resulting node will point to the current directory.
 	 */
-	WindowsFilesystemNode(const String &path, const bool currentDir);
+	WindowsFilesystemNode(const Common::String &path, const bool currentDir);
 
 	virtual bool exists() const { return _access(_path.c_str(), F_OK) == 0; }
-	virtual String getDisplayName() const { return _displayName; }
-	virtual String getName() const { return _displayName; }
-	virtual String getPath() const { return _path; }
+	virtual Common::String getDisplayName() const { return _displayName; }
+	virtual Common::String getName() const { return _displayName; }
+	virtual Common::String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
 	virtual bool isReadable() const { return _access(_path.c_str(), R_OK) == 0; }
 	virtual bool isWritable() const { return _access(_path.c_str(), W_OK) == 0; }
 
-	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 	virtual AbstractFilesystemNode *getParent() const;
 
@@ -105,7 +105,7 @@ private:
 	 *
 	 * @param list List to put the file entry node in.
 	 * @param mode Mode to use while adding the file entry to the list.
-	 * @param base String with the directory being listed.
+	 * @param base Common::String with the directory being listed.
 	 * @param find_data Describes a file that the FindFirstFile, FindFirstFileEx, or FindNextFile functions find.
 	 */
 	static void addFile(AbstractFSList &list, ListMode mode, const char *base, WIN32_FIND_DATA* find_data);
@@ -113,7 +113,7 @@ private:
 	/**
 	 * Converts a Unicode string to Ascii format.
 	 *
-	 * @param str String to convert from Unicode to Ascii.
+	 * @param str Common::String to convert from Unicode to Ascii.
 	 * @return str in Ascii format.
 	 */
 	static char *toAscii(TCHAR *str);
@@ -121,7 +121,7 @@ private:
 	/**
 	 * Converts an Ascii string to Unicode format.
 	 *
-	 * @param str String to convert from Ascii to Unicode.
+	 * @param str Common::String to convert from Ascii to Unicode.
 	 * @return str in Unicode format.
 	 */
 	static const TCHAR* toUnicode(const char *str);
@@ -138,8 +138,8 @@ void WindowsFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const c
 
 	isDirectory = (find_data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ? true : false);
 
-	if ((!isDirectory && mode == FilesystemNode::kListDirectoriesOnly) ||
-		(isDirectory && mode == FilesystemNode::kListFilesOnly))
+	if ((!isDirectory && mode == Common::FilesystemNode::kListDirectoriesOnly) ||
+		(isDirectory && mode == Common::FilesystemNode::kListFilesOnly))
 		return;
 
 	entry._isDirectory = isDirectory;
@@ -190,7 +190,7 @@ WindowsFilesystemNode::WindowsFilesystemNode() {
 #endif
 }
 
-WindowsFilesystemNode::WindowsFilesystemNode(const String &p, const bool currentDir) {
+WindowsFilesystemNode::WindowsFilesystemNode(const Common::String &p, const bool currentDir) {
 	if (currentDir) {
 		char path[MAX_PATH];
 		GetCurrentDirectory(MAX_PATH, path);
@@ -219,10 +219,10 @@ WindowsFilesystemNode::WindowsFilesystemNode(const String &p, const bool current
 	_isPseudoRoot = false;
 }
 
-AbstractFilesystemNode *WindowsFilesystemNode::getChild(const String &n) const {
+AbstractFilesystemNode *WindowsFilesystemNode::getChild(const Common::String &n) const {
 	assert(_isDirectory);
 
-	String newPath(_path);
+	Common::String newPath(_path);
 	if (_path.lastChar() != '\\')
 		newPath += '\\';
 	newPath += n;
@@ -293,7 +293,7 @@ AbstractFilesystemNode *WindowsFilesystemNode::getParent() const {
 		const char *end = lastPathComponent(_path, '\\');
 
 		p = new WindowsFilesystemNode();
-		p->_path = String(start, end - start);
+		p->_path = Common::String(start, end - start);
 		p->_isValid = true;
 		p->_isDirectory = true;
 		p->_displayName = lastPathComponent(p->_path, '\\');

backends/platform/dc/dc-fs.cpp

@@ -36,19 +36,19 @@
  */
 class RoninCDFileNode : public AbstractFilesystemNode {
 protected:
-	String _path;
+	Common::String _path;
 
 public:
-	RoninCDFileNode(const String &path) : _path(path) {};
+	RoninCDFileNode(const Common::String &path) : _path(path) {};
 
 	virtual bool exists() const { return true; }
-	virtual String getName() const { return lastPathComponent(_path, '/'); }
-	virtual String getPath() const { return _path; }
+	virtual Common::String getName() const { return lastPathComponent(_path, '/'); }
+	virtual Common::String getPath() const { return _path; }
 	virtual bool isDirectory() const { return false; }
 	virtual bool isReadable() const { return true; }
 	virtual bool isWritable() const { return false; }
 
-	virtual AbstractFilesystemNode *getChild(const String &n) const { return NULL; }
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const { return NULL; }
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const { return false; }
 	virtual AbstractFilesystemNode *getParent() const;
 
@@ -58,17 +58,17 @@ public:
 /* A directory */
 class RoninCDDirectoryNode : public RoninCDFileNode {
 public:
-	RoninCDDirectoryNode(const String &path) : RoninCDFileNode(path) {};
+	RoninCDDirectoryNode(const Common::String &path) : RoninCDFileNode(path) {};
 
 	virtual bool isDirectory() const { return true; }
-	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
 	virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
 };
 
 /* A file/directory which does not exist */
 class RoninCDNonexistingNode : public RoninCDFileNode {
 public:
-	RoninCDNonexistingNode(const String &path) : RoninCDFileNode(path) {};
+	RoninCDNonexistingNode(const Common::String &path) : RoninCDFileNode(path) {};
 
 	virtual bool exists() const { return false; }
 	virtual bool isReadable() const { return false; }
@@ -90,8 +90,8 @@ AbstractFilesystemNode *RoninCDFileNode::makeFileNodePath(const Common::String &
 	}
 }
 
-AbstractFilesystemNode *RoninCDDirectoryNode::getChild(const String &n) const {
-	String newPath(_path);
+AbstractFilesystemNode *RoninCDDirectoryNode::getChild(const Common::String &n) const {
+	Common::String newPath(_path);
 	if (_path.lastChar() != '/')
 		newPath += '/';
 	newPath += n;
@@ -109,20 +109,20 @@ bool RoninCDDirectoryNode::getChildren(AbstractFSList &myList, ListMode mode, bo
 
 	// ... loop over dir entries using readdir
 	while ((dp = readdir(dirp)) != NULL) {
-		String newPath(_path);
+		Common::String newPath(_path);
 		if (newPath.lastChar() != '/')
 			newPath += '/';
 		newPath += dp->d_name;
 
 		if (dp->d_size < 0) {
 			// Honor the chosen mode
-			if (mode == FilesystemNode::kListFilesOnly)
+			if (mode == Common::FilesystemNode::kListFilesOnly)
 				continue;
 
 			myList.push_back(new RoninCDDirectoryNode(newPath+"/"));
 		} else {
 			// Honor the chosen mode
-			if (mode == FilesystemNode::kListDirectoriesOnly)
+			if (mode == Common::FilesystemNode::kListDirectoriesOnly)
 				continue;
 
 			myList.push_back(new RoninCDFileNode(newPath));
@@ -140,7 +140,7 @@ AbstractFilesystemNode *RoninCDFileNode::getParent() const {
 	const char *start = _path.c_str();
 	const char *end = lastPathComponent(_path, '/');
 
-	return new RoninCDDirectoryNode(String(start, end - start));
+	return new RoninCDDirectoryNode(Common::String(start, end - start));
 }
 
 AbstractFilesystemNode *OSystem_Dreamcast::makeRootFileNode() const {

backends/platform/dc/selector.cpp

@@ -146,12 +146,12 @@ struct Dir
 {
   char name[252];
   char deficon[256];
-  FilesystemNode node;
+  Common::FilesystemNode node;
 };
 
 static Game the_game;
 
-static bool isIcon(const FilesystemNode &entry)
+static bool isIcon(const Common::FilesystemNode &entry)
 {
   int l = entry.getDisplayName().size();
   if (l>4 && !strcasecmp(entry.getDisplayName().c_str()+l-4, ".ICO"))
@@ -198,14 +198,14 @@ static int findGames(Game *games, int max)
 {
   Dir *dirs = new Dir[MAX_DIR];
   int curr_game = 0, curr_dir = 0, num_dirs = 1;
-  dirs[0].node = FilesystemNode("");
+  dirs[0].node = Common::FilesystemNode("");
   while (curr_game < max && curr_dir < num_dirs) {
     strncpy(dirs[curr_dir].name, dirs[curr_dir].node.getPath().c_str(), 252);
     dirs[curr_dir].name[251] = '\0';
     dirs[curr_dir].deficon[0] = '\0';
-    FSList files, fslist;
-    dirs[curr_dir++].node.getChildren(fslist, FilesystemNode::kListAll);
-    for (FSList::const_iterator entry = fslist.begin(); entry != fslist.end();
+    Common::FSList files, fslist;
+    dirs[curr_dir++].node.getChildren(fslist, Common::FilesystemNode::kListAll);
+    for (Common::FSList::const_iterator entry = fslist.begin(); entry != fslist.end();
 	 ++entry) {
       if (entry->isDirectory()) {
 	if (num_dirs < MAX_DIR && strcasecmp(entry->getDisplayName().c_str(),

backends/platform/iphone/osys_iphone.cpp

@@ -1199,11 +1199,11 @@ const char* OSystem_IPHONE::getConfigPath() {
 void OSystem_IPHONE::migrateApp() {
 	// Migrate to the new 1.1.3 directory structure, if needed.
 	
-	FilesystemNode file("/var/mobile");
+	Common::FilesystemNode file("/var/mobile");
 	if (file.exists() && file.isDirectory()) {
 		// We have 1.1.3 or above.
 		s_is113OrHigher = true;
-		file = FilesystemNode(SCUMMVM_ROOT_PATH);
+		file = Common::FilesystemNode(SCUMMVM_ROOT_PATH);
 		if (!file.exists()) {
 			system("mkdir " SCUMMVM_ROOT_PATH);
 			system("mkdir " SCUMMVM_SAVE_PATH);
@@ -1211,7 +1211,7 @@ void OSystem_IPHONE::migrateApp() {
 			// Copy over the prefs file
 			system("cp " SCUMMVM_OLD_PREFS_PATH " " SCUMMVM_PREFS_PATH);
 
-			file = FilesystemNode(SCUMMVM_OLD_SAVE_PATH);
+			file = Common::FilesystemNode(SCUMMVM_OLD_SAVE_PATH);
 			// Copy over old savegames to the new directory.
 			if (file.exists() && file.isDirectory())			
 				system("cp " SCUMMVM_OLD_SAVE_PATH "/* " SCUMMVM_SAVE_PATH "/");

backends/platform/sdl/sdl.cpp

@@ -338,12 +338,12 @@ static Common::String getDefaultConfigFileName() {
 }
 
 Common::SeekableReadStream *OSystem_SDL::openConfigFileForReading() {
-	FilesystemNode file(getDefaultConfigFileName());
+	Common::FilesystemNode file(getDefaultConfigFileName());
 	return file.openForReading();
 }
 
 Common::WriteStream *OSystem_SDL::openConfigFileForWriting() {
-	FilesystemNode file(getDefaultConfigFileName());
+	Common::FilesystemNode file(getDefaultConfigFileName());
 	return file.openForWriting();
 }
 

backends/platform/wince/CELauncherDialog.cpp

@@ -72,10 +72,10 @@ void CELauncherDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 d
 	}
 }
 
-void CELauncherDialog::automaticScanDirectory(const FilesystemNode &node) {
+void CELauncherDialog::automaticScanDirectory(const Common::FilesystemNode &node) {
 	// First check if we have a recognized game in the current directory
-	FSList files;
-	node.getChildren(files, FilesystemNode::kListFilesOnly);
+	Common::FSList files;
+	node.getChildren(files, Common::FilesystemNode::kListFilesOnly);
 	// detect
 	GameList candidates(EngineMan.detectGames(files));
 	// insert
@@ -85,9 +85,9 @@ void CELauncherDialog::automaticScanDirectory(const FilesystemNode &node) {
 		addGameToConf(result);
 	}
 	// Then recurse on the subdirectories
-	FSList dirs;
-	node.getChildren(dirs, FilesystemNode::kListDirectoriesOnly);
-	for (FSList::const_iterator currentDir = dirs.begin(); currentDir != dirs.end(); ++currentDir)
+	Common::FSList dirs;
+	node.getChildren(dirs, Common::FilesystemNode::kListDirectoriesOnly);
+	for (Common::FSList::const_iterator currentDir = dirs.begin(); currentDir != dirs.end(); ++currentDir)
 		automaticScanDirectory(*currentDir);
 
 }

backends/platform/wince/CELauncherDialog.h

@@ -36,7 +36,7 @@ public:
 	virtual void handleCommand(GUI::CommandSender *sender, uint32 cmd, uint32 data);
 protected:
 	void addGame();
-	void automaticScanDirectory(const FilesystemNode &node);
+	void automaticScanDirectory(const Common::FilesystemNode &node);
 };
 
 typedef GUI::LauncherDialog GUILauncherDialog;

backends/saves/default/default-saves.cpp

@@ -78,13 +78,13 @@ DefaultSaveFileManager::DefaultSaveFileManager(const Common::String &defaultSave
 
 
 Common::StringList DefaultSaveFileManager::listSavefiles(const char *pattern) {
-	FilesystemNode savePath(getSavePath());
-	FSList savefiles;
+	Common::FilesystemNode savePath(getSavePath());
+	Common::FSList savefiles;
 	Common::StringList results;
 	Common::String search(pattern);
 
 	if (savePath.lookupFile(savefiles, search, false, true, 0)) {
-		for (FSList::const_iterator file = savefiles.begin(); file != savefiles.end(); ++file) {
+		for (Common::FSList::const_iterator file = savefiles.begin(); file != savefiles.end(); ++file) {
 			results.push_back(file->getName());
 		}
 	}
@@ -92,7 +92,7 @@ Common::StringList DefaultSaveFileManager::listSavefiles(const char *pattern) {
 	return results;
 }
 
-void DefaultSaveFileManager::checkPath(const FilesystemNode &dir) {
+void DefaultSaveFileManager::checkPath(const Common::FilesystemNode &dir) {
 	const Common::String path = dir.getPath();
 	clearError();
 
@@ -173,11 +173,11 @@ void DefaultSaveFileManager::checkPath(const FilesystemNode &dir) {
 
 Common::InSaveFile *DefaultSaveFileManager::openForLoading(const char *filename) {
 	// Ensure that the savepath is valid. If not, generate an appropriate error.
-	FilesystemNode savePath(getSavePath());
+	Common::FilesystemNode savePath(getSavePath());
 	checkPath(savePath);
 
 	if (getError() == SFM_NO_ERROR) {
-		FilesystemNode file = savePath.getChild(filename);
+		Common::FilesystemNode file = savePath.getChild(filename);
 
 		// Open the file for reading
 		Common::SeekableReadStream *sf = file.openForReading();
@@ -190,11 +190,11 @@ Common::InSaveFile *DefaultSaveFileManager::openForLoading(const char *filename)
 
 Common::OutSaveFile *DefaultSaveFileManager::openForSaving(const char *filename) {
 	// Ensure that the savepath is valid. If not, generate an appropriate error.
-	FilesystemNode savePath(getSavePath());
+	Common::FilesystemNode savePath(getSavePath());
 	checkPath(savePath);
 
 	if (getError() == SFM_NO_ERROR) {
-		FilesystemNode file = savePath.getChild(filename);
+		Common::FilesystemNode file = savePath.getChild(filename);
 
 		// Open the file for saving
 		Common::WriteStream *sf = file.openForWriting();
@@ -208,8 +208,8 @@ Common::OutSaveFile *DefaultSaveFileManager::openForSaving(const char *filename)
 bool DefaultSaveFileManager::removeSavefile(const char *filename) {
 	clearError();
 
-	FilesystemNode savePath(getSavePath());
-	FilesystemNode file = savePath.getChild(filename);
+	Common::FilesystemNode savePath(getSavePath());
+	Common::FilesystemNode file = savePath.getChild(filename);
 
 	// TODO: Add new method FilesystemNode::remove()
 	if (remove(file.getPath().c_str()) != 0) {

backends/saves/default/default-saves.h

@@ -55,7 +55,7 @@ protected:
 	 * Checks the given path for read access, existence, etc.
 	 * Sets the internal error and error message accordingly.
 	 */
-	void checkPath(const FilesystemNode &dir);
+	void checkPath(const Common::FilesystemNode &dir);
 };
 
 #endif

base/commandLine.cpp

@@ -365,7 +365,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
 			END_OPTION
 
 			DO_OPTION('p', "path")
-				FilesystemNode path(option);
+				Common::FilesystemNode path(option);
 				if (!path.exists()) {
 					usage("Non-existent game path '%s'", option);
 				} else if (!path.isReadable()) {
@@ -408,7 +408,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
 			END_OPTION
 
 			DO_LONG_OPTION("soundfont")
-				FilesystemNode path(option);
+				Common::FilesystemNode path(option);
 				if (!path.exists()) {
 					usage("Non-existent soundfont path '%s'", option);
 				} else if (!path.isReadable()) {
@@ -438,7 +438,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
 			END_OPTION
 
 			DO_LONG_OPTION("savepath")
-				FilesystemNode path(option);
+				Common::FilesystemNode path(option);
 				if (!path.exists()) {
 					usage("Non-existent savegames path '%s'", option);
 				} else if (!path.isWritable()) {
@@ -447,7 +447,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
 			END_OPTION
 
 			DO_LONG_OPTION("extrapath")
-				FilesystemNode path(option);
+				Common::FilesystemNode path(option);
 				if (!path.exists()) {
 					usage("Non-existent extra path '%s'", option);
 				} else if (!path.isReadable()) {
@@ -465,7 +465,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
 			END_OPTION
 
 			DO_LONG_OPTION("themepath")
-				FilesystemNode path(option);
+				Common::FilesystemNode path(option);
 				if (!path.exists()) {
 					usage("Non-existent theme path '%s'", option);
 				} else if (!path.isReadable()) {
@@ -623,9 +623,9 @@ static void runDetectorTest() {
 			gameid = name;
 		}
 
-		FilesystemNode dir(path);
-		FSList files;
-		if (!dir.getChildren(files, FilesystemNode::kListAll)) {
+		Common::FilesystemNode dir(path);
+		Common::FSList files;
+		if (!dir.getChildren(files, Common::FilesystemNode::kListAll)) {
 			printf(" ... invalid path, skipping\n");
 			continue;
 		}
@@ -736,7 +736,7 @@ bool processSettings(Common::String &command, Common::StringMap &settings) {
 	if (!settings.contains("savepath")) {
 		const char *dir = getenv("SCUMMVM_SAVEPATH");
 		if (dir && *dir && strlen(dir) < MAXPATHLEN) {
-			FilesystemNode saveDir(dir);
+			Common::FilesystemNode saveDir(dir);
 			if (!saveDir.exists()) {
 				warning("Non-existent SCUMMVM_SAVEPATH save path. It will be ignored.");
 			} else if (!saveDir.isWritable()) {

base/plugins.cpp

@@ -29,6 +29,7 @@
 
 #ifdef DYNAMIC_MODULES
 #include "common/config-manager.h"
+#include "common/fs.h"
 #endif
 
 // Plugin versioning
@@ -203,11 +204,11 @@ PluginList FilePluginProvider::getPlugins() {
 	PluginList pl;
 
 	// Prepare the list of directories to search
-	FSList pluginDirs;
+	Common::FSList pluginDirs;
 
 	// Add the default directories
-	pluginDirs.push_back(FilesystemNode("."));
-	pluginDirs.push_back(FilesystemNode("plugins"));
+	pluginDirs.push_back(Common::FilesystemNode("."));
+	pluginDirs.push_back(Common::FilesystemNode("plugins"));
 
 	// Add the provider's custom directories
 	addCustomDirectories(pluginDirs);
@@ -215,21 +216,21 @@ PluginList FilePluginProvider::getPlugins() {
 	// Add the user specified directory
 	Common::String pluginsPath(ConfMan.get("pluginspath"));
 	if (!pluginsPath.empty())
-		pluginDirs.push_back(FilesystemNode(pluginsPath));
+		pluginDirs.push_back(Common::FilesystemNode(pluginsPath));
 
-	FSList::const_iterator dir;
+	Common::FSList::const_iterator dir;
 	for (dir = pluginDirs.begin(); dir != pluginDirs.end(); dir++) {
 		// Load all plugins.
 		// Scan for all plugins in this directory
-		FSList files;
-		if (!dir->getChildren(files, FilesystemNode::kListFilesOnly)) {
+		Common::FSList files;
+		if (!dir->getChildren(files, Common::FilesystemNode::kListFilesOnly)) {
 			debug(1, "Couldn't open plugin directory '%s'", dir->getPath().c_str());
 			continue;
 		} else {
 			debug(1, "Reading plugins from plugin directory '%s'", dir->getPath().c_str());
 		}
 
-		for (FSList::const_iterator i = files.begin(); i != files.end(); ++i) {
+		for (Common::FSList::const_iterator i = files.begin(); i != files.end(); ++i) {
 			if (isPluginFilename(i->getName())) {
 				pl.push_back(createPlugin(i->getPath()));
 			}
@@ -255,9 +256,9 @@ bool FilePluginProvider::isPluginFilename(const Common::String &filename) const
 	return true;
 }
 
-void FilePluginProvider::addCustomDirectories(FSList &dirs) const {
+void FilePluginProvider::addCustomDirectories(Common::FSList &dirs) const {
 #ifdef PLUGIN_DIRECTORY
-	dirs.push_back(FilesystemNode(PLUGIN_DIRECTORY));
+	dirs.push_back(Common::FilesystemNode(PLUGIN_DIRECTORY));
 #endif
 }
 
@@ -379,7 +380,7 @@ GameDescriptor EngineManager::findGame(const Common::String &gameName, const Eng
 	return result;
 }
 
-GameList EngineManager::detectGames(const FSList &fslist) const {
+GameList EngineManager::detectGames(const Common::FSList &fslist) const {
 	GameList candidates;
 
 	const EnginePlugin::List &plugins = getPlugins();

base/plugins.h

@@ -30,9 +30,10 @@
 #include "common/singleton.h"
 #include "common/util.h"
 
-#ifdef DYNAMIC_MODULES
-#include "common/fs.h"
-#endif
+namespace Common {
+	class FSList;
+}
+
 
 /**
  * @page pagePlugins An overview of the ScummVM plugin system
@@ -258,7 +259,7 @@ protected:
 	 * @param dirs	the reference to the list of directories to be used when
 	 * 		searching for plugins.
 	 */
-	virtual void addCustomDirectories(FSList &dirs) const;
+	virtual void addCustomDirectories(Common::FSList &dirs) const;
 };
 
 #endif // DYNAMIC_MODULES

common/file.h

@@ -31,9 +31,10 @@
 #include "common/str.h"
 #include "common/stream.h"
 
+namespace Common {
+
 class FilesystemNode;
 
-namespace Common {
 
 /**
  * TODO: vital to document this core class properly!!! For both users and implementors

common/fs.cpp

@@ -27,7 +27,7 @@
 #include "backends/fs/abstract-fs.h"
 #include "backends/fs/fs-factory.h"
 
-//namespace Common {
+namespace Common {
 
 FilesystemNode::FilesystemNode() {
 }
@@ -200,4 +200,4 @@ Common::WriteStream *FilesystemNode::openForWriting() {
 	return _realNode->openForWriting();
 }
 
-//}	// End of namespace Common
+}	// End of namespace Common

common/fs.h

@@ -32,15 +32,10 @@
 class AbstractFilesystemNode;
 
 namespace Common {
-	class SeekableReadStream;
-	class WriteStream;
-}
-
-//namespace Common {
 
 class FilesystemNode;
-//class SeekableReadStream;
-//class WriteStream;
+class SeekableReadStream;
+class WriteStream;
 
 /**
  * List of multiple file system nodes. E.g. the contents of a given directory.
@@ -246,6 +241,6 @@ public:
 	virtual Common::WriteStream *openForWriting();
 };
 
-//} // End of namespace Common
+} // End of namespace Common
 
 #endif //COMMON_FS_H

common/md5.cpp

@@ -29,6 +29,7 @@
  */
 
 #include "common/file.h"
+#include "common/fs.h"
 #include "common/md5.h"
 #include "common/util.h"
 #include "common/endian.h"

common/md5.h

@@ -26,11 +26,12 @@
 #define COMMON_MD5_H
 
 #include "common/scummsys.h"
-#include "common/fs.h"
-#include "common/stream.h"
 
 namespace Common {
 
+class FilesystemNode;
+class ReadStream;
+
 bool md5_file(const char *name, uint8 digest[16], uint32 length = 0);
 bool md5_file(const FilesystemNode &file, uint8 digest[16], uint32 length = 0);
 bool md5_file(ReadStream &stream, uint8 digest[16], uint32 length = 0);

common/system.cpp

@@ -164,7 +164,7 @@ static Common::String getDefaultConfigFileName() {
 }
 
 Common::SeekableReadStream *OSystem::openConfigFileForReading() {
-	FilesystemNode file(getDefaultConfigFileName());
+	Common::FilesystemNode file(getDefaultConfigFileName());
 	return file.openForReading();
 }
 
@@ -172,7 +172,7 @@ Common::WriteStream *OSystem::openConfigFileForWriting() {
 #ifdef __DC__
 	return 0;
 #else
-	FilesystemNode file(getDefaultConfigFileName());
+	Common::FilesystemNode file(getDefaultConfigFileName());
 	return file.openForWriting();
 #endif
 }

engines/agi/detection.cpp

@@ -2126,7 +2126,7 @@ public:
 	virtual bool createInstance(OSystem *syst, Engine **engine, const Common::ADGameDescription *desc) const;
 	virtual SaveStateList listSaves(const char *target) const;
 	
-	const Common::ADGameDescription *fallbackDetect(const FSList *fslist) const;
+	const Common::ADGameDescription *fallbackDetect(const Common::FSList *fslist) const;
 };
 
 bool AgiMetaEngine::hasFeature(MetaEngineFeature f) const {
@@ -2189,7 +2189,7 @@ SaveStateList AgiMetaEngine::listSaves(const char *target) const {
 	return saveList;
 }
 
-const Common::ADGameDescription *AgiMetaEngine::fallbackDetect(const FSList *fslist) const {
+const Common::ADGameDescription *AgiMetaEngine::fallbackDetect(const Common::FSList *fslist) const {
 	typedef Common::HashMap<Common::String, int32> IntMap;
 	IntMap allFiles;
 	bool matchedUsingFilenames = false;
@@ -2198,7 +2198,7 @@ const Common::ADGameDescription *AgiMetaEngine::fallbackDetect(const FSList *fsl
 	WagFileParser wagFileParser;
 	Common::String wagFilePath;
 	Common::String description;
-	FSList fslistCurrentDir; // Only used if fslist == NULL
+	Common::FSList fslistCurrentDir; // Only used if fslist == NULL
 
 	// // Set the defaults for gameid and extra
 	_gameid = "agi-fanmade";
@@ -2211,8 +2211,8 @@ const Common::ADGameDescription *AgiMetaEngine::fallbackDetect(const FSList *fsl
 		if (path.empty())
 			path = ".";
 
-		FilesystemNode fsCurrentDir(path);
-		fsCurrentDir.getChildren(fslistCurrentDir, FilesystemNode::kListFilesOnly);
+		Common::FilesystemNode fsCurrentDir(path);
+		fsCurrentDir.getChildren(fslistCurrentDir, Common::FilesystemNode::kListFilesOnly);
 		fslist = &fslistCurrentDir;
 	}
 
@@ -2227,7 +2227,7 @@ const Common::ADGameDescription *AgiMetaEngine::fallbackDetect(const FSList *fsl
 	g_fallbackDesc.version = 0x2917;
 
 	// First grab all filenames and at the same time count the number of *.wag files
-	for (FSList::const_iterator file = fslist->begin(); file != fslist->end(); ++file) {
+	for (Common::FSList::const_iterator file = fslist->begin(); file != fslist->end(); ++file) {
 		if (file->isDirectory()) continue;
 		Common::String filename = file->getName();
 		filename.toLowercase();

engines/agi/loader_v3.cpp

@@ -47,15 +47,15 @@ int AgiLoader_v3::detectGame() {
 	int ec = errUnk;
 	bool found = false;
 
-	FSList fslist;
-	FilesystemNode dir(ConfMan.get("path"));
+	Common::FSList fslist;
+	Common::FilesystemNode dir(ConfMan.get("path"));
 
-	if (!dir.getChildren(fslist, FilesystemNode::kListFilesOnly)) {
+	if (!dir.getChildren(fslist, Common::FilesystemNode::kListFilesOnly)) {
 		warning("AgiEngine: invalid game path '%s'", dir.getPath().c_str());
 		return errInvalidAGIFile;
 	}
 
-	for (FSList::const_iterator file = fslist.begin();
+	for (Common::FSList::const_iterator file = fslist.begin();
 	    file != fslist.end() && !found; ++file) {
 		Common::String f = file->getName();
 		f.toLowercase();

engines/agi/sound.cpp

@@ -1107,14 +1107,14 @@ bool IIgsSoundMgr::loadWaveFile(const Common::String &wavePath, const IIgsExeInf
 }
 
 /**
- * A function object (i.e. a functor) for testing if a FilesystemNode
+ * A function object (i.e. a functor) for testing if a Common::FilesystemNode
  * object's name is equal (Ignoring case) to a string or to at least
  * one of the strings in a list of strings. Can be used e.g. with find_if().
  */
-struct fsnodeNameEqualsIgnoreCase : public Common::UnaryFunction<const FilesystemNode&, bool> {
+struct fsnodeNameEqualsIgnoreCase : public Common::UnaryFunction<const Common::FilesystemNode&, bool> {
 	fsnodeNameEqualsIgnoreCase(const Common::StringList &str) : _str(str) {}
 	fsnodeNameEqualsIgnoreCase(const Common::String str) { _str.push_back(str); }
-	bool operator()(const FilesystemNode &param) const {
+	bool operator()(const Common::FilesystemNode &param) const {
 		for (Common::StringList::const_iterator iter = _str.begin(); iter != _str.end(); iter++)
 			if (param.getName().equalsIgnoreCase(*iter))
 				return true;
@@ -1139,9 +1139,9 @@ bool SoundMgr::loadInstruments() {
 	}
 
 	// List files in the game path
-	FSList fslist;
-	FilesystemNode dir(ConfMan.get("path"));
-	if (!dir.getChildren(fslist, FilesystemNode::kListFilesOnly)) {
+	Common::FSList fslist;
+	Common::FilesystemNode dir(ConfMan.get("path"));
+	if (!dir.getChildren(fslist, Common::FilesystemNode::kListFilesOnly)) {
 		warning("Invalid game path (\"%s\"), not loading Apple IIGS instruments", dir.getPath().c_str());
 		return false;
 	}
@@ -1157,7 +1157,7 @@ bool SoundMgr::loadInstruments() {
 	waveNames.push_back("SIERRAST");
 
 	// Search for the executable file and the wave file (i.e. check if any of the filenames match)
-	FSList::const_iterator exeFsnode, waveFsnode;
+	Common::FSList::const_iterator exeFsnode, waveFsnode;
 	exeFsnode  = Common::find_if(fslist.begin(), fslist.end(), fsnodeNameEqualsIgnoreCase(exeNames));
 	waveFsnode = Common::find_if(fslist.begin(), fslist.end(), fsnodeNameEqualsIgnoreCase(waveNames));
 

engines/kyra/resource.cpp

@@ -50,7 +50,7 @@ bool Resource::reset() {
 	clearCompFileList();
 	unloadAllPakFiles();
 
-	FilesystemNode dir(ConfMan.get("path"));
+	Common::FilesystemNode dir(ConfMan.get("path"));
 
 	if (!dir.exists() || !dir.isDirectory())
 		error("invalid game path '%s'", dir.getPath().c_str());
@@ -109,8 +109,8 @@ bool Resource::reset() {
 		return true;
 	}
 
-	FSList fslist;
-	if (!dir.getChildren(fslist, FilesystemNode::kListFilesOnly))
+	Common::FSList fslist;
+	if (!dir.getChildren(fslist, Common::FilesystemNode::kListFilesOnly))
 		error("can't list files inside game path '%s'", dir.getPath().c_str());
 
 	if (_vm->game() == GI_KYRA1 && _vm->gameFlags().isTalkie) {
@@ -128,7 +128,7 @@ bool Resource::reset() {
 				iterator->_value.prot = true;
 		}
 	} else {
-		for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
+		for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
 			Common::String filename = file->getName();
 			filename.toUppercase();
 

engines/made/detection.cpp

@@ -350,7 +350,7 @@ public:
 
 	virtual bool createInstance(OSystem *syst, Engine **engine, const Common::ADGameDescription *desc) const;
 
-	const Common::ADGameDescription *fallbackDetect(const FSList *fslist) const;
+	const Common::ADGameDescription *fallbackDetect(const Common::FSList *fslist) const;
 
 };
 
@@ -362,7 +362,7 @@ bool MadeMetaEngine::createInstance(OSystem *syst, Engine **engine, const Common
 	return gd != 0;
 }
 
-const Common::ADGameDescription *MadeMetaEngine::fallbackDetect(const FSList *fslist) const {
+const Common::ADGameDescription *MadeMetaEngine::fallbackDetect(const Common::FSList *fslist) const {
 	// Set the default values for the fallback descriptor's ADGameDescription part.
 	Made::g_fallbackDesc.desc.language = Common::UNK_LANG;
 	Made::g_fallbackDesc.desc.platform = Common::kPlatformPC;

engines/metaengine.h

@@ -28,7 +28,6 @@
 #include "common/scummsys.h"
 #include "common/str.h"
 #include "common/error.h"
-#include "common/fs.h"
 
 #include "base/game.h"
 #include "base/plugins.h"
@@ -36,6 +35,10 @@
 class Engine;
 class OSystem;
 
+namespace Common {
+	class FSList;
+}
+
 /**
  * A meta engine is essentially a factory for Engine instances with the
  * added ability of listing and detecting supported games.
@@ -62,7 +65,7 @@ public:
 	 * (possibly empty) list of games supported by the engine which it was able
 	 * to detect amongst the given files.
 	 */
-	virtual GameList detectGames(const FSList &fslist) const = 0;
+	virtual GameList detectGames(const Common::FSList &fslist) const = 0;
 
 	/**
 	 * Tries to instantiate an engine instance based on the settings of
@@ -156,7 +159,7 @@ private:
 
 public:
 	GameDescriptor findGame(const Common::String &gameName, const EnginePlugin **plugin = NULL) const;
-	GameList detectGames(const FSList &fslist) const;
+	GameList detectGames(const Common::FSList &fslist) const;
 	const EnginePlugin::List &getPlugins() const;
 };
 

engines/parallaction/disk.h

@@ -211,21 +211,21 @@ protected:
 
 	Parallaction	*_vm;
 
-	FilesystemNode	_baseDir;
-	FilesystemNode	_partDir;
+	Common::FilesystemNode	_baseDir;
+	Common::FilesystemNode	_partDir;
 
-	FilesystemNode	_aniDir;
-	FilesystemNode	_bkgDir;
-	FilesystemNode	_mscDir;
-	FilesystemNode	_mskDir;
-	FilesystemNode	_pthDir;
-	FilesystemNode	_rasDir;
-	FilesystemNode	_scrDir;
-	FilesystemNode	_sfxDir;
-	FilesystemNode	_talDir;
+	Common::FilesystemNode	_aniDir;
+	Common::FilesystemNode	_bkgDir;
+	Common::FilesystemNode	_mscDir;
+	Common::FilesystemNode	_mskDir;
+	Common::FilesystemNode	_pthDir;
+	Common::FilesystemNode	_rasDir;
+	Common::FilesystemNode	_scrDir;
+	Common::FilesystemNode	_sfxDir;
+	Common::FilesystemNode	_talDir;
 
 protected:
-	void errorFileNotFound(const FilesystemNode &dir, const Common::String &filename);
+	void errorFileNotFound(const Common::FilesystemNode &dir, const Common::String &filename);
 	Font *createFont(const char *name, Common::ReadStream &stream);
 	Sprites*	createSprites(Common::ReadStream &stream);
 	void loadBitmap(Common::SeekableReadStream &stream, Graphics::Surface &surf, byte *palette);
@@ -273,14 +273,14 @@ protected:
 	Font *createFont(const char *name, Common::SeekableReadStream &stream);
 	void loadBackground(BackgroundInfo& info, Common::SeekableReadStream &stream);
 
-	FilesystemNode	_baseBkgDir;
-	FilesystemNode	_fntDir;
-	FilesystemNode	_commonAniDir;
-	FilesystemNode	_commonBkgDir;
-	FilesystemNode	_commonMscDir;
-	FilesystemNode	_commonMskDir;
-	FilesystemNode	_commonPthDir;
-	FilesystemNode	_commonTalDir;
+	Common::FilesystemNode	_baseBkgDir;
+	Common::FilesystemNode	_fntDir;
+	Common::FilesystemNode	_commonAniDir;
+	Common::FilesystemNode	_commonBkgDir;
+	Common::FilesystemNode	_commonMscDir;
+	Common::FilesystemNode	_commonMskDir;
+	Common::FilesystemNode	_commonPthDir;
+	Common::FilesystemNode	_commonTalDir;
 
 public:
 	AmigaDisk_br(Parallaction *vm);

engines/parallaction/disk_br.cpp

@@ -91,7 +91,7 @@ struct Sprites : public Frames {
 
 
 
-void DosDisk_br::errorFileNotFound(const FilesystemNode &dir, const Common::String &filename) {
+void DosDisk_br::errorFileNotFound(const Common::FilesystemNode &dir, const Common::String &filename) {
 	error("File '%s' not found in directory '%s'", filename.c_str(), dir.getDisplayName().c_str());
 }
 
@@ -134,7 +134,7 @@ GfxObj* DosDisk_br::loadTalk(const char *name) {
 	debugC(5, kDebugDisk, "DosDisk_br::loadTalk(%s)", name);
 
 	Common::String path(name);
-	FilesystemNode node = _talDir.getChild(path);
+	Common::FilesystemNode node = _talDir.getChild(path);
 	if (!node.exists()) {
 		path += ".tal";
 		node = _talDir.getChild(path);
@@ -160,11 +160,11 @@ Script* DosDisk_br::loadLocation(const char *name) {
 	debugC(5, kDebugDisk, "DosDisk_br::loadLocation");
 
 	Common::String langs[4] = { "it", "fr", "en", "ge" };
-	FilesystemNode locDir = _partDir.getChild(langs[_language]);
+	Common::FilesystemNode locDir = _partDir.getChild(langs[_language]);
 
 	Common::String path(name);
 	path += ".slf";
-	FilesystemNode node = locDir.getChild(path);
+	Common::FilesystemNode node = locDir.getChild(path);
 	if (!node.exists()) {
 		path = Common::String(name) + ".loc";
 		node = locDir.getChild(path);
@@ -183,7 +183,7 @@ Script* DosDisk_br::loadScript(const char* name) {
 
 	Common::String path(name);
 	path += ".scr";
-	FilesystemNode node = _scrDir.getChild(path);
+	Common::FilesystemNode node = _scrDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_scrDir, path);
 	}
@@ -221,7 +221,7 @@ Frames* DosDisk_br::loadPointer(const char *name) {
 
 	Common::String path(name);
 	path += ".ras";
-	FilesystemNode node = _baseDir.getChild(path);
+	Common::FilesystemNode node = _baseDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_baseDir, path);
 	}
@@ -240,7 +240,7 @@ Font* DosDisk_br::loadFont(const char* name) {
 
 	Common::String path(name);
 	path += ".fnt";
-	FilesystemNode node = _baseDir.getChild(path);
+	Common::FilesystemNode node = _baseDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_baseDir, path);
 	}
@@ -255,7 +255,7 @@ GfxObj* DosDisk_br::loadObjects(const char *name) {
 	debugC(5, kDebugDisk, "DosDisk_br::loadObjects");
 
 	Common::String path(name);
-	FilesystemNode node = _partDir.getChild(path);
+	Common::FilesystemNode node = _partDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_partDir, path);
 	}
@@ -274,7 +274,7 @@ GfxObj* DosDisk_br::loadStatic(const char* name) {
 	debugC(5, kDebugDisk, "DosDisk_br::loadStatic");
 
 	Common::String path(name);
-	FilesystemNode node = _rasDir.getChild(path);
+	Common::FilesystemNode node = _rasDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_rasDir, path);
 	}
@@ -312,7 +312,7 @@ Frames* DosDisk_br::loadFrames(const char* name) {
 	debugC(5, kDebugDisk, "DosDisk_br::loadFrames");
 
 	Common::String path(name);
-	FilesystemNode node = _aniDir.getChild(path);
+	Common::FilesystemNode node = _aniDir.getChild(path);
 	if (!node.exists()) {
 		path += ".ani";
 		node = _aniDir.getChild(path);
@@ -336,7 +336,7 @@ void DosDisk_br::loadSlide(BackgroundInfo& info, const char *name) {
 
 	Common::String path(name);
 	path += ".bmp";
-	FilesystemNode node = _baseDir.getChild(path);
+	Common::FilesystemNode node = _baseDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_baseDir, path);
 	}
@@ -363,7 +363,7 @@ void DosDisk_br::loadMask(const char *name, MaskBuffer &buffer) {
 	}
 
 	Common::String filepath;
-	FilesystemNode node;
+	Common::FilesystemNode node;
 	Common::File stream;
 
 	filepath = Common::String(name) + ".msk";
@@ -384,7 +384,7 @@ void DosDisk_br::loadScenery(BackgroundInfo& info, const char *name, const char
 	debugC(5, kDebugDisk, "DosDisk_br::loadScenery");
 
 	Common::String filepath;
-	FilesystemNode node;
+	Common::FilesystemNode node;
 	Common::File stream;
 
 	if (name) {
@@ -447,7 +447,7 @@ Table* DosDisk_br::loadTable(const char* name) {
 
 	Common::String path(name);
 	path += ".tab";
-	FilesystemNode node = _partDir.getChild(path);
+	Common::FilesystemNode node = _partDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_partDir, path);
 	}
@@ -518,7 +518,7 @@ AmigaDisk_br::AmigaDisk_br(Parallaction *vm) : DosDisk_br(vm) {
 
 	_baseBkgDir = _baseDir.getChild("backs");
 
-	FilesystemNode commonDir = _baseDir.getChild("common");
+	Common::FilesystemNode commonDir = _baseDir.getChild("common");
 	_commonAniDir = commonDir.getChild("anims");
 	_commonBkgDir = commonDir.getChild("backs");
 	_commonMscDir = commonDir.getChild("msc");
@@ -566,7 +566,7 @@ void AmigaDisk_br::loadScenery(BackgroundInfo& info, const char* name, const cha
 	debugC(1, kDebugDisk, "AmigaDisk_br::loadScenery '%s', '%s' '%s'", name, mask, path);
 
 	Common::String filepath;
-	FilesystemNode node;
+	Common::FilesystemNode node;
 	Common::File stream;
 
 	if (name) {
@@ -630,7 +630,7 @@ void AmigaDisk_br::loadSlide(BackgroundInfo& info, const char *name) {
 
 	Common::String path(name);
 	path += ".bkg";
-	FilesystemNode node = _baseBkgDir.getChild(path);
+	Common::FilesystemNode node = _baseBkgDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_baseBkgDir, path);
 	}
@@ -644,7 +644,7 @@ GfxObj* AmigaDisk_br::loadStatic(const char* name) {
 	debugC(1, kDebugDisk, "AmigaDisk_br::loadStatic '%s'", name);
 
 	Common::String path(name);
-	FilesystemNode node = _rasDir.getChild(path);
+	Common::FilesystemNode node = _rasDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_rasDir, path);
 	}
@@ -687,7 +687,7 @@ Frames* AmigaDisk_br::loadFrames(const char* name) {
 	debugC(1, kDebugDisk, "AmigaDisk_br::loadFrames '%s'", name);
 
 	Common::String path(name);
-	FilesystemNode node = _aniDir.getChild(path);
+	Common::FilesystemNode node = _aniDir.getChild(path);
 	if (!node.exists()) {
 		path += ".ani";
 		node = _aniDir.getChild(path);
@@ -713,7 +713,7 @@ GfxObj* AmigaDisk_br::loadTalk(const char *name) {
 	debugC(1, kDebugDisk, "AmigaDisk_br::loadTalk '%s'", name);
 
 	Common::String path(name);
-	FilesystemNode node = _talDir.getChild(path);
+	Common::FilesystemNode node = _talDir.getChild(path);
 	if (!node.exists()) {
 		path += ".tal";
 		node = _talDir.getChild(path);
@@ -740,7 +740,7 @@ Font* AmigaDisk_br::loadFont(const char* name) {
 
 	Common::String path(name);
 	path += ".font";
-	FilesystemNode node = _fntDir.getChild(path);
+	Common::FilesystemNode node = _fntDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_fntDir, path);
 	}
@@ -773,7 +773,7 @@ Common::SeekableReadStream* AmigaDisk_br::loadMusic(const char* name) {
 	debugC(5, kDebugDisk, "AmigaDisk_br::loadMusic");
 
 	Common::String path(name);
-	FilesystemNode node = _mscDir.getChild(path);
+	Common::FilesystemNode node = _mscDir.getChild(path);
 	if (!node.exists()) {
 		// TODO (Kirben): error out when music file is not found?
 		return 0;
@@ -789,7 +789,7 @@ Common::ReadStream* AmigaDisk_br::loadSound(const char* name) {
 	debugC(5, kDebugDisk, "AmigaDisk_br::loadSound");
 
 	Common::String path(name);
-	FilesystemNode node = _sfxDir.getChild(path);
+	Common::FilesystemNode node = _sfxDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_sfxDir, path);
 	}
@@ -803,7 +803,7 @@ GfxObj* AmigaDisk_br::loadObjects(const char *name) {
 	debugC(5, kDebugDisk, "AmigaDisk_br::loadObjects");
 
 	Common::String path(name);
-	FilesystemNode node = _partDir.getChild(path);
+	Common::FilesystemNode node = _partDir.getChild(path);
 	if (!node.exists()) {
 		errorFileNotFound(_partDir, path);
 	}

engines/queen/queen.cpp

@@ -63,7 +63,7 @@ public:
 	virtual bool hasFeature(MetaEngineFeature f) const;
 	virtual GameList getSupportedGames() const;
 	virtual GameDescriptor findGame(const char *gameid) const;
-	virtual GameList detectGames(const FSList &fslist) const;
+	virtual GameList detectGames(const Common::FSList &fslist) const;
 	virtual SaveStateList listSaves(const char *target) const;
 
 	virtual PluginError createInstance(OSystem *syst, Engine **engine) const;
@@ -98,11 +98,11 @@ GameDescriptor QueenMetaEngine::findGame(const char *gameid) const {
 	return GameDescriptor();
 }
 
-GameList QueenMetaEngine::detectGames(const FSList &fslist) const {
+GameList QueenMetaEngine::detectGames(const Common::FSList &fslist) const {
 	GameList detectedGames;
 
 	// Iterate over all files in the given directory
-	for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
+	for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
 		if (file->isDirectory()) {
 			continue;
 		}

engines/scumm/detection.cpp

@@ -177,7 +177,7 @@ static Common::String generateFilenameForDetection(const char *pattern, Filename
 }
 
 struct DetectorDesc {
-	FilesystemNode node;
+	Common::FilesystemNode node;
 	Common::String md5;
 	const MD5Table *md5Entry;	// Entry of the md5 table corresponding to this file, if any.
 };
@@ -191,8 +191,8 @@ static bool testGame(const GameSettings *g, const DescMap &fileMD5Map, const Com
 // when performing the matching. The first match is returned, so if you
 // search for "resource" and two nodes "RESOURE and "resource" are present,
 // the first match is used.
-static bool searchFSNode(const FSList &fslist, const Common::String &name, FilesystemNode &result) {
-	for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
+static bool searchFSNode(const Common::FSList &fslist, const Common::String &name, Common::FilesystemNode &result) {
+	for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
 		if (!scumm_stricmp(file->getName().c_str(), name.c_str())) {
 			result = *file;
 			return true;
@@ -202,7 +202,7 @@ static bool searchFSNode(const FSList &fslist, const Common::String &name, Files
 }
 
 // The following function tries to detect the language for COMI and DIG
-static Common::Language detectLanguage(const FSList &fslist, byte id) {
+static Common::Language detectLanguage(const Common::FSList &fslist, byte id) {
 	assert(id == GID_CMI || id == GID_DIG);
 
 	// Check for LANGUAGE.BND (Dig) resp. LANGUAGE.TAB (CMI).
@@ -212,14 +212,14 @@ static Common::Language detectLanguage(const FSList &fslist, byte id) {
 	// switch to MD5 based detection).
 	const char *filename = (id == GID_CMI) ? "LANGUAGE.TAB" : "LANGUAGE.BND";
 	Common::File tmp;
-	FilesystemNode langFile;
+	Common::FilesystemNode langFile;
 	if (!searchFSNode(fslist, filename, langFile) || !tmp.open(langFile)) {
 		// try loading in RESOURCE sub dir...
-		FilesystemNode resDir;
-		FSList tmpList;
+		Common::FilesystemNode resDir;
+		Common::FSList tmpList;
 		if (searchFSNode(fslist, "RESOURCE", resDir)
 			&& resDir.isDirectory()
-			&& resDir.getChildren(tmpList, FilesystemNode::kListFilesOnly)
+			&& resDir.getChildren(tmpList, Common::FilesystemNode::kListFilesOnly)
 			&& searchFSNode(tmpList, filename, langFile)) {
 			tmp.open(langFile);
 		}
@@ -270,7 +270,7 @@ static Common::Language detectLanguage(const FSList &fslist, byte id) {
 }
 
 
-static void computeGameSettingsFromMD5(const FSList &fslist, const GameFilenamePattern *gfp, const MD5Table *md5Entry, DetectorResult &dr) {
+static void computeGameSettingsFromMD5(const Common::FSList &fslist, const GameFilenamePattern *gfp, const MD5Table *md5Entry, DetectorResult &dr) {
 	dr.language = md5Entry->language;
 	dr.extra = md5Entry->extra;
 
@@ -315,12 +315,12 @@ static void computeGameSettingsFromMD5(const FSList &fslist, const GameFilenameP
 	}
 }
 
-static void detectGames(const FSList &fslist, Common::List<DetectorResult> &results, const char *gameid) {
+static void detectGames(const Common::FSList &fslist, Common::List<DetectorResult> &results, const char *gameid) {
 	DescMap fileMD5Map;
 	DetectorResult dr;
 	char md5str[32+1];
 
-	for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
+	for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
 		if (!file->isDirectory()) {
 			DetectorDesc d;
 			d.node = *file;
@@ -677,7 +677,7 @@ public:
 	virtual bool hasFeature(MetaEngineFeature f) const;	
 	virtual GameList getSupportedGames() const;
 	virtual GameDescriptor findGame(const char *gameid) const;
-	virtual GameList detectGames(const FSList &fslist) const;
+	virtual GameList detectGames(const Common::FSList &fslist) const;
 	
 	virtual PluginError createInstance(OSystem *syst, Engine **engine) const;
 
@@ -700,7 +700,7 @@ GameDescriptor ScummMetaEngine::findGame(const char *gameid) const {
 	return Common::AdvancedDetector::findGameID(gameid, gameDescriptions, obsoleteGameIDsTable);
 }
 
-GameList ScummMetaEngine::detectGames(const FSList &fslist) const {
+GameList ScummMetaEngine::detectGames(const Common::FSList &fslist) const {
 	GameList detectedGames;
 	Common::List<DetectorResult> results;
 
@@ -777,9 +777,9 @@ PluginError ScummMetaEngine::createInstance(OSystem *syst, Engine **engine) cons
 	}
 
 	// Fetch the list of files in the current directory
-	FSList fslist;
-	FilesystemNode dir(ConfMan.get("path"));
-	if (!dir.getChildren(fslist, FilesystemNode::kListFilesOnly)) {
+	Common::FSList fslist;
+	Common::FilesystemNode dir(ConfMan.get("path"));
+	if (!dir.getChildren(fslist, Common::FilesystemNode::kListFilesOnly)) {
 		return kInvalidPathError;
 	}
 

engines/sky/sky.cpp

@@ -113,7 +113,7 @@ public:
 	virtual bool hasFeature(MetaEngineFeature f) const;
 	virtual GameList getSupportedGames() const;
 	virtual GameDescriptor findGame(const char *gameid) const;
-	virtual GameList detectGames(const FSList &fslist) const;	
+	virtual GameList detectGames(const Common::FSList &fslist) const;	
 
 	virtual PluginError createInstance(OSystem *syst, Engine **engine) const;
 
@@ -147,7 +147,7 @@ GameDescriptor SkyMetaEngine::findGame(const char *gameid) const {
 	return GameDescriptor();
 }
 
-GameList SkyMetaEngine::detectGames(const FSList &fslist) const {
+GameList SkyMetaEngine::detectGames(const Common::FSList &fslist) const {
 	GameList detectedGames;
 	bool hasSkyDsk = false;
 	bool hasSkyDnr = false;
@@ -155,7 +155,7 @@ GameList SkyMetaEngine::detectGames(const FSList &fslist) const {
 	int dataDiskSize = -1;
 
 	// Iterate over all files in the given directory
-	for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
+	for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
 		if (!file->isDirectory()) {
 			const char *fileName = file->getName().c_str();
 

engines/sword1/sword1.cpp

@@ -98,7 +98,7 @@ public:
 	virtual bool hasFeature(MetaEngineFeature f) const;
 	virtual GameList getSupportedGames() const;
 	virtual GameDescriptor findGame(const char *gameid) const;
-	virtual GameList detectGames(const FSList &fslist) const;
+	virtual GameList detectGames(const Common::FSList &fslist) const;
 	virtual SaveStateList listSaves(const char *target) const;
 
 	virtual PluginError createInstance(OSystem *syst, Engine **engine) const;
@@ -132,8 +132,8 @@ GameDescriptor SwordMetaEngine::findGame(const char *gameid) const {
 	return GameDescriptor();
 }
 
-void Sword1CheckDirectory(const FSList &fslist, bool *filesFound) {
-	for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
+void Sword1CheckDirectory(const Common::FSList &fslist, bool *filesFound) {
+	for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
 		if (!file->isDirectory()) {
 			const char *fileName = file->getName().c_str();
 			for (int cnt = 0; cnt < NUM_FILES_TO_CHECK; cnt++)
@@ -142,15 +142,15 @@ void Sword1CheckDirectory(const FSList &fslist, bool *filesFound) {
 		} else {
 			for (int cnt = 0; cnt < ARRAYSIZE(g_dirNames); cnt++)
 				if (scumm_stricmp(file->getName().c_str(), g_dirNames[cnt]) == 0) {
-					FSList fslist2;
-					if (file->getChildren(fslist2, FilesystemNode::kListFilesOnly))
+					Common::FSList fslist2;
+					if (file->getChildren(fslist2, Common::FilesystemNode::kListFilesOnly))
 						Sword1CheckDirectory(fslist2, filesFound);
 				}
 		}
 	}
 }
 
-GameList SwordMetaEngine::detectGames(const FSList &fslist) const {
+GameList SwordMetaEngine::detectGames(const Common::FSList &fslist) const {
 	int i, j;
 	GameList detectedGames;
 	bool filesFound[NUM_FILES_TO_CHECK];

engines/sword2/sword2.cpp

@@ -83,7 +83,7 @@ public:
 	virtual bool hasFeature(MetaEngineFeature f) const;
 	virtual GameList getSupportedGames() const;
 	virtual GameDescriptor findGame(const char *gameid) const;
-	virtual GameList detectGames(const FSList &fslist) const;
+	virtual GameList detectGames(const Common::FSList &fslist) const;
 	virtual SaveStateList listSaves(const char *target) const;
 
 	virtual PluginError createInstance(OSystem *syst, Engine **engine) const;
@@ -117,10 +117,10 @@ GameDescriptor Sword2MetaEngine::findGame(const char *gameid) const {
 	return GameDescriptor(g->gameid, g->description);
 }
 
-GameList Sword2MetaEngine::detectGames(const FSList &fslist) const {
+GameList Sword2MetaEngine::detectGames(const Common::FSList &fslist) const {
 	GameList detectedGames;
 	const Sword2::GameSettings *g;
-	FSList::const_iterator file;
+	Common::FSList::const_iterator file;
 
 	// TODO: It would be nice if we had code here which distinguishes
 	// between the 'sword2' and 'sword2demo' targets. The current code
@@ -150,8 +150,8 @@ GameList Sword2MetaEngine::detectGames(const FSList &fslist) const {
 				const char *fileName = file->getName().c_str();
 
 				if (0 == scumm_stricmp("clusters", fileName)) {
-					FSList recList;
-					if (file->getChildren(recList, FilesystemNode::kListAll)) {
+					Common::FSList recList;
+					if (file->getChildren(recList, Common::FilesystemNode::kListAll)) {
 						GameList recGames(detectGames(recList));
 						if (!recGames.empty()) {
 							detectedGames.push_back(recGames);
@@ -200,9 +200,9 @@ PluginError Sword2MetaEngine::createInstance(OSystem *syst, Engine **engine) con
 	assert(syst);
 	assert(engine);
 
-	FSList fslist;
-	FilesystemNode dir(ConfMan.get("path"));
-	if (!dir.getChildren(fslist, FilesystemNode::kListAll)) {
+	Common::FSList fslist;
+	Common::FilesystemNode dir(ConfMan.get("path"));
+	if (!dir.getChildren(fslist, Common::FilesystemNode::kListAll)) {
 		return kInvalidPathError;
 	}
 

gui/browser.cpp

@@ -107,7 +107,7 @@ int BrowserDialog::runModal() {
 			err = FSRefMakePath(&ref, (UInt8*)buf, sizeof(buf)-1);
 			assert(err == noErr);
 
-			_choice = FilesystemNode(buf);
+			_choice = Common::FilesystemNode(buf);
 			choiceMade = true;
 		}
 
@@ -160,9 +160,9 @@ BrowserDialog::BrowserDialog(const char *title, bool dirBrowser)
 
 void BrowserDialog::open() {
 	if (ConfMan.hasKey("browser_lastpath"))
-		_node = FilesystemNode(ConfMan.get("browser_lastpath"));
+		_node = Common::FilesystemNode(ConfMan.get("browser_lastpath"));
 	if (!_node.isDirectory())
-		_node = FilesystemNode(".");
+		_node = Common::FilesystemNode(".");
 
 	// Alway refresh file list
 	updateListing();
@@ -227,8 +227,9 @@ void BrowserDialog::updateListing() {
 	ConfMan.set("browser_lastpath", _node.getPath());
 
 	// Read in the data from the file system
-	FilesystemNode::ListMode listMode = _isDirBrowser ? FilesystemNode::kListDirectoriesOnly
-	                                                  : FilesystemNode::kListAll;
+	Common::FilesystemNode::ListMode listMode =
+	         _isDirBrowser ? Common::FilesystemNode::kListDirectoriesOnly
+	                       : Common::FilesystemNode::kListAll;
 	if (!_node.getChildren(_nodeContent, listMode)) {
 		_nodeContent.clear();
 	} else {
@@ -237,7 +238,7 @@ void BrowserDialog::updateListing() {
 
 	// Populate the ListWidget
 	Common::StringList list;
-	for (FSList::iterator i = _nodeContent.begin(); i != _nodeContent.end(); ++i) {
+	for (Common::FSList::iterator i = _nodeContent.begin(); i != _nodeContent.end(); ++i) {
 		if (!_isDirBrowser && i->isDirectory())
 			list.push_back(i->getDisplayName() + "/");
 		else

gui/browser.h

@@ -39,8 +39,6 @@ class ListWidget;
 class StaticTextWidget;
 
 class BrowserDialog : public Dialog {
-	typedef Common::String String;
-	typedef Common::StringList StringList;
 public:
 	BrowserDialog(const char *title, bool dirBrowser);
 
@@ -52,7 +50,7 @@ public:
 	virtual void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
 #endif
 
-	const FilesystemNode	&getResult() { return _choice; }
+	const Common::FilesystemNode	&getResult() { return _choice; }
 
 protected:
 #ifdef MACOSX
@@ -60,10 +58,10 @@ protected:
 #else
 	ListWidget		*_fileList;
 	StaticTextWidget	*_currentPath;
-	FilesystemNode	_node;
-	FSList			_nodeContent;
+	Common::FilesystemNode	_node;
+	Common::FSList			_nodeContent;
 #endif
-	FilesystemNode	_choice;
+	Common::FilesystemNode	_choice;
 	bool			_isDirBrowser;
 
 #ifndef MACOSX

gui/launcher.cpp

@@ -394,7 +394,7 @@ void EditGameDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 dat
 
 		if (browser.runModal() > 0) {
 			// User made this choice...
-			FilesystemNode file(browser.getResult());
+			Common::FilesystemNode file(browser.getResult());
 			_soundFont->setLabel(file.getPath());
 
 			if (!file.getPath().empty() && (file.getPath() != "None"))
@@ -412,7 +412,7 @@ void EditGameDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 dat
 		BrowserDialog browser("Select directory with game data", true);
 		if (browser.runModal() > 0) {
 			// User made his choice...
-			FilesystemNode dir(browser.getResult());
+			Common::FilesystemNode dir(browser.getResult());
 
 			// TODO: Verify the game can be found in the new directory... Best
 			// done with optional specific gameid to pluginmgr detectgames?
@@ -430,7 +430,7 @@ void EditGameDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 dat
 		BrowserDialog browser("Select additional game directory", true);
 		if (browser.runModal() > 0) {
 			// User made his choice...
-			FilesystemNode dir(browser.getResult());
+			Common::FilesystemNode dir(browser.getResult());
 			_extraPathWidget->setLabel(dir.getPath());
 			draw();
 		}
@@ -442,7 +442,7 @@ void EditGameDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 dat
 		BrowserDialog browser("Select directory for saved games", true);
 		if (browser.runModal() > 0) {
 			// User made his choice...
-			FilesystemNode dir(browser.getResult());
+			Common::FilesystemNode dir(browser.getResult());
 			_savePathWidget->setLabel(dir.getPath());
 			draw();
 		}
@@ -798,9 +798,9 @@ void LauncherDialog::addGame() {
 
 	if (_browser->runModal() > 0) {
 		// User made his choice...
-		FilesystemNode dir(_browser->getResult());
-		FSList files;
-		if (!dir.getChildren(files, FilesystemNode::kListAll)) {
+		Common::FilesystemNode dir(_browser->getResult());
+		Common::FSList files;
+		if (!dir.getChildren(files, Common::FilesystemNode::kListAll)) {
 			error("browser returned a node that is not a directory: '%s'",
 					dir.getPath().c_str());
 		}

gui/massadd.cpp

@@ -58,7 +58,7 @@ enum {
 
 
 
-MassAddDialog::MassAddDialog(const FilesystemNode &startDir)
+MassAddDialog::MassAddDialog(const Common::FilesystemNode &startDir)
 	: Dialog("massadddialog"),
 	_dirsScanned(0),
 	_okButton(0),
@@ -156,10 +156,10 @@ void MassAddDialog::handleTickle() {
 
 	// Perform a breadth-first scan of the filesystem.
 	while (!_scanStack.empty() && (g_system->getMillis() - t) < kMaxScanTime) {
-		FilesystemNode dir = _scanStack.pop();
+		Common::FilesystemNode dir = _scanStack.pop();
 
-		FSList files;
-		if (!dir.getChildren(files, FilesystemNode::kListAll)) {
+		Common::FSList files;
+		if (!dir.getChildren(files, Common::FilesystemNode::kListAll)) {
 			error("browser returned a node that is not a directory: '%s'",
 					dir.getPath().c_str());
 		}
@@ -206,7 +206,7 @@ void MassAddDialog::handleTickle() {
 
 
 		// Recurse into all subdirs
-		for (FSList::const_iterator file = files.begin(); file != files.end(); ++file) {
+		for (Common::FSList::const_iterator file = files.begin(); file != files.end(); ++file) {
 			if (file->isDirectory()) {
 				_scanStack.push(*file);
 			}

gui/massadd.h

@@ -38,14 +38,14 @@ class StaticTextWidget;
 
 class MassAddDialog : public Dialog {
 public:
-	MassAddDialog(const FilesystemNode &startDir);
+	MassAddDialog(const Common::FilesystemNode &startDir);
 
 	//void open();
 	void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
 	void handleTickle();
 
 private:
-	Common::Stack<FilesystemNode>  _scanStack;
+	Common::Stack<Common::FilesystemNode>  _scanStack;
 	GameList _games;
 
 	/**

gui/options.cpp

@@ -835,7 +835,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
 		BrowserDialog browser("Select directory for savegames", true);
 		if (browser.runModal() > 0) {
 			// User made his choice...
-			FilesystemNode dir(browser.getResult());
+			Common::FilesystemNode dir(browser.getResult());
 			if (dir.isWritable()) {
 				_savePath->setLabel(dir.getPath());
 			} else {
@@ -851,7 +851,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
 		BrowserDialog browser("Select directory for GUI themes", true);
 		if (browser.runModal() > 0) {
 			// User made his choice...
-			FilesystemNode dir(browser.getResult());
+			Common::FilesystemNode dir(browser.getResult());
 			_themePath->setLabel(dir.getPath());
 			draw();
 		}
@@ -861,7 +861,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
 		BrowserDialog browser("Select directory for extra files", true);
 		if (browser.runModal() > 0) {
 			// User made his choice...
-			FilesystemNode dir(browser.getResult());
+			Common::FilesystemNode dir(browser.getResult());
 			_extraPath->setLabel(dir.getPath());
 			draw();
 		}
@@ -872,7 +872,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
 		BrowserDialog browser("Select directory for plugins", true);
 		if (browser.runModal() > 0) {
 			// User made his choice...
-			FilesystemNode dir(browser.getResult());
+			Common::FilesystemNode dir(browser.getResult());
 			_pluginsPath->setLabel(dir.getPath());
 			draw();
 		}
@@ -883,7 +883,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
 		BrowserDialog browser("Select SoundFont", false);
 		if (browser.runModal() > 0) {
 			// User made his choice...
-			FilesystemNode file(browser.getResult());
+			Common::FilesystemNode file(browser.getResult());
 			_soundFont->setLabel(file.getPath());
 
 			if (!file.getPath().empty() && (file.getPath() != "None"))

gui/themebrowser.cpp

@@ -141,16 +141,16 @@ void ThemeBrowser::addDir(ThList &list, const Common::String &dir, int level) {
 	if (level < 0)
 		return;
 
-	FilesystemNode node(dir);
+	Common::FilesystemNode node(dir);
 
 	if (!node.exists() || !node.isReadable())
 		return;
 
-	FSList fslist;
-	if (!node.getChildren(fslist, FilesystemNode::kListAll))
+	Common::FSList fslist;
+	if (!node.getChildren(fslist, Common::FilesystemNode::kListAll))
 		return;
 
-	for (FSList::const_iterator i = fslist.begin(); i != fslist.end(); ++i) {
+	for (Common::FSList::const_iterator i = fslist.begin(); i != fslist.end(); ++i) {
 		if (i->isDirectory()) {
 			addDir(list, i->getPath(), level-1);
 		} else {
@@ -171,7 +171,7 @@ void ThemeBrowser::addDir(ThList &list, const Common::String &dir, int level) {
 	}
 }
 
-bool ThemeBrowser::isTheme(const FilesystemNode &node, Entry &out) {
+bool ThemeBrowser::isTheme(const Common::FilesystemNode &node, Entry &out) {
 	Common::ConfigFile cfg;
 	Common::String type;
 

gui/themebrowser.h

@@ -58,7 +58,7 @@ private:
 	void updateListing();
 
 	void addDir(ThList &list, const Common::String &dir, int level = 4);
-	bool isTheme(const FilesystemNode &node, Entry &out);
+	bool isTheme(const Common::FilesystemNode &node, Entry &out);
 };
 
 } // end of namespace GUI