Ticket #8715: gsoc-fsnode trunk.patch

home/david/Projects/scummvm/backends/factories/abstract-fs-factory.h

@@ +1 @@
+#ifndef ABSTRACT_FILESYSTEM_FACTORY_H
+#define ABSTRACT_FILESYSTEM_FACTORY_H
+
+#include "common/str.h"
+#include "backends/fs/abstract-fs.h"
+
+/**
+ * Creates concrete FilesystemNode objects depending on the current architecture.
+ */
+class AbstractFilesystemFactory {
+public:
+        typedef Common::String String;
+        
+        /**
+         * Destructor.
+         */
+        virtual ~AbstractFilesystemFactory() {}
+        
+        /**
+         * Returns a node representing the "current directory".
+         * If your system does not support this concept, you can either try to
+         * emulate it or simply return some "sensible" default directory node,
+         * e.g. the same value as getRoot() returns.
+         */
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const = 0;
+        
+        /**
+         * Construct a node based on a path; the path is in the same format as it
+         * would be for calls to fopen().
+         *
+         * Furthermore getNodeForPath(oldNode.path()) should create a new node
+         * identical to oldNode. Hence, we can use the "path" value for persistent
+         * storage e.g. in the config file.
+         *
+         * @param path The path string to create a FilesystemNode for.
+         */
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const = 0;
+        
+        /**
+         * Returns a special node representing the filesystem root.
+         * The starting point for any file system browsing.
+         * 
+         * On Unix, this will be simply the node for / (the root directory).
+         * On Windows, it will be a special node which "contains" all drives (C:, D:, E:).
+         */
+        virtual AbstractFilesystemNode *makeRootFileNode() const = 0;
+};
+
+#endif /*ABSTRACT_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/amigaos4/amigaos4-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/amigaos4/amigaos4-fs-factory.h"
+#include "backends/fs/amigaos4/amigaos4-fs.cpp"
+
+DECLARE_SINGLETON(AmigaOSFilesystemFactory);
+
+AbstractFilesystemNode *AmigaOSFilesystemFactory::makeRootFileNode() const {
+        return new AmigaOSFilesystemNode();
+}
+
+AbstractFilesystemNode *AmigaOSFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        return new AmigaOSFilesystemNode();
+}
+
+AbstractFilesystemNode *AmigaOSFilesystemFactory::makeFileNodePath(const String &path) const {
+        return new AmigaOSFilesystemNode(path);
+}

home/david/Projects/scummvm/backends/factories/amigaos4/amigaos4-fs-factory.h

@@ +1 @@
+#ifndef AMIGAOS_FILESYSTEM_FACTORY_H
+#define AMIGAOS_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates AmigaOSFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class AmigaOSFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<AmigaOSFilesystemFactory> { 
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        AmigaOSFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*AMIGAOS_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/dc/ronincd-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/dc/ronincd-fs-factory.h"
+#include "backends/fs/dc/dc-fs.cpp"
+
+DECLARE_SINGLETON(RoninCDFilesystemFactory);
+
+AbstractFilesystemNode *RoninCDFilesystemFactory::makeRootFileNode() const {
+        return new RoninCDFilesystemNode();
+}
+
+AbstractFilesystemNode *RoninCDFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        return new RoninCDFilesystemNode();
+}
+
+AbstractFilesystemNode *RoninCDFilesystemFactory::makeFileNodePath(const String &path) const {
+        return new RoninCDFilesystemNode(path, true);
+}

home/david/Projects/scummvm/backends/factories/dc/ronincd-fs-factory.h

@@ +1 @@
+#ifndef RONINCD_FILESYSTEM_FACTORY_H
+#define RONINCD_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates RoninCDFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class RoninCDFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<RoninCDFilesystemFactory> { 
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        RoninCDFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*RONINCD_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/ds/ds-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/ds/ds-fs-factory.h"
+#include "backends/fs/ds/ds-fs.cpp"
+#include "dsmain.h" //for the isGBAMPAvailable() function
+
+DECLARE_SINGLETON(DSFilesystemFactory);
+
+AbstractFilesystemNode *DSFilesystemFactory::makeRootFileNode() const {
+        if (DS::isGBAMPAvailable()) {
+                return new DS::GBAMPFileSystemNode();
+        } else {
+                return new DS::DSFileSystemNode();
+        }
+}
+
+AbstractFilesystemNode *DSFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        if (DS::isGBAMPAvailable()) {
+                return new DS::GBAMPFileSystemNode();
+        } else {
+                return new DS::DSFileSystemNode();
+        }
+}
+
+AbstractFilesystemNode *DSFilesystemFactory::makeFileNodePath(const String &path) const {
+        if (DS::isGBAMPAvailable()) {
+                return new DS::GBAMPFileSystemNode(path);
+        } else {
+                return new DS::DSFileSystemNode(path);
+        }
+}

home/david/Projects/scummvm/backends/factories/ds/ds-fs-factory.h

@@ +1 @@
+#ifndef DS_FILESYSTEM_FACTORY_H
+#define DS_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates DSFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class DSFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<DSFilesystemFactory> {   
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        DSFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*DS_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/fs-factory-maker.cpp

@@ +1 @@
+#include "backends/factories/abstract-fs-factory.h"
+
+/*
+ * All the following includes choose, at compile time, which specific backend will be used
+ * during the execution of the ScummVM.
+ * 
+ * It has to be done this way because not all the necessary libraries will be available in
+ * all build environments. Additionally, this results in smaller binaries.
+ */
+#if defined(__amigaos4__)
+        #include "backends/factories/amigaos4/amigaos4-fs-factory.cpp"
+#endif
+ 
+#if defined(__DC__)
+        #include "backends/factories/dc/ronincd-fs-factory.cpp"
+#endif
+
+#if defined(__DS__)
+        #include "backends/factories/ds/ds-fs-factory.cpp"
+#endif
+
+#if defined(__GP32__)
+        #include "backends/factories/gp32/gp32-fs-factory.cpp"
+#endif
+
+#if defined(__MORPHOS__)
+        #include "backends/factories/morphos/abox-fs-factory.cpp"
+#endif
+
+#if defined(PALMOS_MODE)
+        #include "backends/factories/palmos/palmos-fs-factory.cpp"
+#endif
+
+#if defined(__PLAYSTATION2__)
+        #include "backends/factories/ps2/ps2-fs-factory.cpp"
+#endif
+
+#if defined(__PSP__)
+        #include "backends/factories/psp/psp-fs-factory.cpp"
+#endif
+
+#if defined(__SYMBIAN32__)
+        #include "backends/factories/symbian/symbian-fs-factory.cpp"
+#endif
+
+#if defined(UNIX)
+        #include "backends/factories/posix/posix-fs-factory.cpp"
+#endif
+
+#if defined(WIN32)
+        #include "backends/factories/windows/windows-fs-factory.cpp"
+#endif
+
+/**
+ * Creates concrete FilesystemFactory and FileFactory objects depending on the current architecture.
+ */
+class FilesystemFactoryMaker {
+public:
+
+        /**
+         * Returns the correct concrete filesystem factory depending on the current build architecture.
+         */
+        static AbstractFilesystemFactory *makeFactory();
+        
+protected:
+        FilesystemFactoryMaker() {}; // avoid instances of this class
+};
+
+AbstractFilesystemFactory *FilesystemFactoryMaker::makeFactory(){
+        #if defined(__amigaos4__)
+                return &AmigaOSFilesystemFactory::instance();
+        #endif
+        
+        #if defined(__DC__)
+                return &RoninCDFilesystemFactory::instance();
+        #endif
+        
+        #if defined(__DS__)
+                return &DSFilesystemFactory::instance();
+        #endif
+        
+        #if defined(__GP32__)
+                return &GP32FilesystemFactory::instance();
+        #endif
+        
+        #if defined(__MORPHOS__)
+                return &ABoxFilesystemFactory::instance();
+        #endif
+        
+        #if defined(PALMOS_MODE)
+                return &PalmOSFilesystemFactory::instance();
+        #endif
+        
+        #if defined(__PLAYSTATION2__)
+                return &Ps2FilesystemFactory::instance();
+        #endif
+        
+        #if defined(__PSP__)
+                return &PSPFilesystemFactory::instance();
+        #endif
+        
+        #if defined(__SYMBIAN32__)
+                return &SymbianFilesystemFactory::instance();
+        #endif
+        
+        #if defined(UNIX)
+                return &POSIXFilesystemFactory::instance();
+        #endif
+        
+        #if defined(WIN32)
+                return &WindowsFilesystemFactory::instance();
+        #endif
+}

home/david/Projects/scummvm/backends/factories/gp32/gp32-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/gp32/gp32-fs-factory.h"
+#include "backends/fs/gp32/gp32-fs.cpp"
+
+DECLARE_SINGLETON(GP32FilesystemFactory);
+
+AbstractFilesystemNode *GP32FilesystemFactory::makeRootFileNode() const {
+        return new GP32FilesystemNode();
+}
+
+AbstractFilesystemNode *GP32FilesystemFactory::makeCurrentDirectoryFileNode() const {
+        return new GP32FilesystemNode();
+}
+
+AbstractFilesystemNode *GP32FilesystemFactory::makeFileNodePath(const String &path) const {
+        return new GP32FilesystemNode(path);
+}

home/david/Projects/scummvm/backends/factories/gp32/gp32-fs-factory.h

@@ +1 @@
+#ifndef GP32_FILESYSTEM_FACTORY_H
+#define GP32_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates GP32FilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class GP32FilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<GP32FilesystemFactory> {       
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        GP32FilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*GP32_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/morphos/abox-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/morphos/abox-fs-factory.h"
+#include "backends/fs/morphos/abox-fs.cpp"
+
+DECLARE_SINGLETON(ABoxFilesystemFactory);
+
+AbstractFilesystemNode *ABoxFilesystemFactory::makeRootFileNode() const {
+        return new ABoxFilesystemNode();
+}
+
+AbstractFilesystemNode *ABoxFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        return new ABoxFilesystemNode();
+}
+
+AbstractFilesystemNode *ABoxFilesystemFactory::makeFileNodePath(const String &path) const {
+        return new ABoxFilesystemNode(path);
+}

home/david/Projects/scummvm/backends/factories/morphos/abox-fs-factory.h

@@ +1 @@
+#ifndef ABOX_FILESYSTEM_FACTORY_H
+#define ABOX_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates ABoxFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class ABoxFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<ABoxFilesystemFactory> {       
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        ABoxFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*ABOX_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/palmos/palmos-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/palmos/palmos-fs-factory.h"
+#include "backends/fs/palmos/palmos-fs.cpp"
+
+DECLARE_SINGLETON(PalmOSFilesystemFactory);
+
+AbstractFilesystemNode *PalmOSFilesystemFactory::makeRootFileNode() const {
+        return new PalmOSFilesystemNode();
+}
+
+AbstractFilesystemNode *PalmOSFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        return new PalmOSFilesystemNode();
+}
+
+AbstractFilesystemNode *PalmOSFilesystemFactory::makeFileNodePath(const String &path) const {
+        return new PalmOSFilesystemNode(path);
+}

home/david/Projects/scummvm/backends/factories/palmos/palmos-fs-factory.h

@@ +1 @@
+#ifndef PALMOS_FILESYSTEM_FACTORY_H
+#define PALMOS_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates PalmOSFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class PalmOSFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<PalmOSFilesystemFactory> {   
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        PalmOSFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*PALMOS_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/posix/posix-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/posix/posix-fs-factory.h"
+#include "backends/fs/posix/posix-fs.cpp"
+
+DECLARE_SINGLETON(POSIXFilesystemFactory);
+
+AbstractFilesystemNode *POSIXFilesystemFactory::makeRootFileNode() const {
+        return new POSIXFilesystemNode();
+}
+
+AbstractFilesystemNode *POSIXFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        char buf[MAXPATHLEN];
+        getcwd(buf, MAXPATHLEN);
+        return new POSIXFilesystemNode(buf, true);
+}
+
+AbstractFilesystemNode *POSIXFilesystemFactory::makeFileNodePath(const String &path) const {
+        return new POSIXFilesystemNode(path, true);
+}

home/david/Projects/scummvm/backends/factories/posix/posix-fs-factory.h

@@ +1 @@
+#ifndef POSIX_FILESYSTEM_FACTORY_H
+#define POSIX_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates POSIXFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class POSIXFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<POSIXFilesystemFactory> {
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        POSIXFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*POSIX_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/ps2/ps2-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/ps2/ps2-fs-factory.h"
+#include "backends/fs/ps2/ps2-fs.cpp"
+
+DECLARE_SINGLETON(Ps2FilesystemFactory);
+
+AbstractFilesystemNode *Ps2FilesystemFactory::makeRootFileNode() const {
+        return new Ps2FilesystemNode();
+}
+
+AbstractFilesystemNode *Ps2FilesystemFactory::makeCurrentDirectoryFileNode() const {
+        return new Ps2FilesystemNode();
+}
+
+AbstractFilesystemNode *Ps2FilesystemFactory::makeFileNodePath(const String &path) const {
+        return new Ps2FilesystemNode(path);
+}

home/david/Projects/scummvm/backends/factories/ps2/ps2-fs-factory.h

@@ +1 @@
+#ifndef PS2_FILESYSTEM_FACTORY_H
+#define PS2_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates PS2FilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class Ps2FilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<Ps2FilesystemFactory> { 
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        Ps2FilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*PS2_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/psp/psp-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/psp/psp-fs-factory.h"
+#include "backends/fs/psp/psp_fs.cpp"
+
+DECLARE_SINGLETON(PSPFilesystemFactory);
+
+AbstractFilesystemNode *PSPFilesystemFactory::makeRootFileNode() const {
+        return new PSPFilesystemNode();
+}
+
+AbstractFilesystemNode *PSPFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        return new PSPFilesystemNode();
+}
+
+AbstractFilesystemNode *PSPFilesystemFactory::makeFileNodePath(const String &path) const {
+        return new PSPFilesystemNode(path, true);
+}

home/david/Projects/scummvm/backends/factories/psp/psp-fs-factory.h

@@ +1 @@
+#ifndef PSP_FILESYSTEM_FACTORY_H
+#define PSP_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates PSPFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class PSPFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<PSPFilesystemFactory> { 
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        PSPFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*PSP_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/symbian/symbian-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/symbian/symbian-fs-factory.h"
+#include "backends/fs/symbian/symbian-fs.cpp"
+
+DECLARE_SINGLETON(SymbianFilesystemFactory);
+
+AbstractFilesystemNode *SymbianFilesystemFactory::makeRootFileNode() const {
+        return new SymbianFilesystemNode(true);
+}
+
+AbstractFilesystemNode *SymbianFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        char path[MAXPATHLEN];
+        getcwd(path, MAXPATHLEN);
+        return new SymbianFilesystemNode(path);
+}
+
+AbstractFilesystemNode *SymbianFilesystemFactory::makeFileNodePath(const String &path) const {
+        return new SymbianFilesystemNode(path);
+}

home/david/Projects/scummvm/backends/factories/symbian/symbian-fs-factory.h

@@ +1 @@
+#ifndef SYMBIAN_FILESYSTEM_FACTORY_H
+#define SYMBIAN_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates SymbianFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class SymbianFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<SymbianFilesystemFactory> { 
+public:
+        typedef Common::String String;
+                
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        SymbianFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*SYMBIAN_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/factories/windows/windows-fs-factory.cpp

@@ +1 @@
+#include "backends/factories/windows/windows-fs-factory.h"
+#include "backends/fs/windows/windows-fs.cpp"
+
+DECLARE_SINGLETON(WindowsFilesystemFactory);
+
+AbstractFilesystemNode *WindowsFilesystemFactory::makeRootFileNode() const {
+        return new WindowsFilesystemNode();
+}
+
+AbstractFilesystemNode *WindowsFilesystemFactory::makeCurrentDirectoryFileNode() const {
+        return new WindowsFilesystemNode("", true);
+}
+
+AbstractFilesystemNode *WindowsFilesystemFactory::makeFileNodePath(const String &path) const {
+        return new WindowsFilesystemNode(path, false);
+}

home/david/Projects/scummvm/backends/factories/windows/windows-fs-factory.h

@@ +1 @@
+#ifndef WINDOWS_FILESYSTEM_FACTORY_H
+#define WINDOWS_FILESYSTEM_FACTORY_H
+
+#include "common/singleton.h"
+#include "backends/factories/abstract-fs-factory.h"
+
+/**
+ * Creates WindowsFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class WindowsFilesystemFactory : public AbstractFilesystemFactory, public Common::Singleton<WindowsFilesystemFactory> { 
+public:
+        typedef Common::String String;
+        
+        virtual AbstractFilesystemNode *makeRootFileNode() const;
+        virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+        virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+        
+protected:
+        WindowsFilesystemFactory() {};
+                
+private:
+        friend class Common::Singleton<SingletonBaseType>;
+};
+
+#endif /*WINDOWS_FILESYSTEM_FACTORY_H*/

home/david/Projects/scummvm/backends/fs/abstract-fs.h

@@ -27 +27 @@
 
 #include "common/array.h"
 #include "common/str.h"
-
 #include "common/fs.h"
 
 class AbstractFilesystemNode;
@@ -47 +46 @@
         friend class FilesystemNode;
         typedef Common::String String;
         typedef FilesystemNode::ListMode ListMode;
-
-        /**
-         * The parent node of this directory.
-         * The parent of the root is the root itself.
-         */
-        virtual AbstractFilesystemNode *parent() const = 0;
-
+        
         /**
-         * The child node with the given name. If no child with this name
+         * 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.
          *
+         * 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.
+         * 
+         * @param name String containing the name of the child to create a new node.
          */
-        virtual AbstractFilesystemNode *child(const String &name) const = 0;
-
+        virtual AbstractFilesystemNode *getChild(const String &name) const = 0;
 
         /**
-         * Returns a special node representing the FS root. The starting point for
-         * any file system browsing.
-         * On Unix, this will be simply the node for / (the root directory).
-         * On Windows, it will be a special node which "contains" all drives (C:, D:, E:).
+         * The parent node of this directory.
+         * The parent of the root is the root itself.
          */
-        static AbstractFilesystemNode *getRoot();
+        virtual AbstractFilesystemNode *getParent() const = 0;
 
+public:
         /**
-         * Returns a node representing the "current directory". If your system does
-         * not support this concept, you can either try to emulate it or
-         * simply return some "sensible" default directory node, e.g. the same
-         * value as getRoot() returns.
+         * Destructor.
+         */
+        virtual ~AbstractFilesystemNode() {}
+        
+        /*
+         * Indicates whether the object refered by this path exists in the filesystem or not.
          */
-        static AbstractFilesystemNode *getCurrentDirectory();
-
+        virtual bool exists() const = 0;
 
         /**
-         * Construct a node based on a path; the path is in the same format as it
-         * would be for calls to fopen().
-         *
-         * Furthermore getNodeForPath(oldNode.path()) should create a new node
-         * identical to oldNode. Hence, we can use the "path" value for persistent
-         * storage e.g. in the config file.
-         *
-         * @todo: This is of course a place where non-portable code easily will sneak
-         *        in, because the format of the path used here is not well-defined.
-         *        So we really should reconsider this API and try to come up with
-         *        something which is more portable but still flexible enough for our
-         *        purposes.
+         * Return a list of child nodes of this directory node. If called on a node
+         * that does not represent a directory, false is returned.
+         * 
+         * @param list List to put the contents of the directory in.
+         * @param mode Mode to use while listing the directory.
+         * @param hidden Whether to include hidden files or not in the results.
+         * 
+         * @return true if succesful, false otherwise (e.g. when the directory does not exist).
          */
-        static AbstractFilesystemNode *getNodeForPath(const String &path);
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const = 0;
 
-
-public:
-        virtual ~AbstractFilesystemNode() {}
+        /**
+         * Returns a human readable path string.
+         * 
+         * @note By default, this method returns the value of getName().
+         */
+        virtual String getDisplayName() const { return getName(); }
 
-        virtual String name() const = 0;
+        /**
+         * Returns a string with an architecture dependent path description.
+         */
+        virtual String getName() const = 0;
         
-        // By default, we use the actual file name as 'display name'.
-        virtual String displayName() const { return name(); }
-
-        virtual bool isValid() const = 0;
-
+        /**
+         * Returns the 'path' of the current node, usable in fopen().
+         */
+        virtual String getPath() const = 0;
+        
+        /**
+         * Indicates whether this path refers to a directory or not.
+         */
         virtual bool isDirectory() const = 0;
         
         /**
-         * Return the 'path' of the current node, usable in fopen(). See also
-         * the static getNodeForPath() method.
+         * Indicates whether this path can be read from or not.
          */
-        virtual String path() const = 0;
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const = 0;
-
+        virtual bool isReadable() const = 0;
+        
+        /**
+         * Indicates whether this path can be written to or not.
+         */
+        virtual bool isWritable() const = 0;
 
         /* TODO:
-        bool exists();
-
-        bool isDirectory();
         bool isFile();
-
-        bool isReadable();
-        bool isWriteable();
         */
 };
 
-
 #endif

home/david/Projects/scummvm/backends/fs/amigaos4/amigaos4-fs.cpp

@@ -38 +38 @@
 #include <common/stdafx.h>
 
 #include "common/util.h"
-
 #include "engines/engine.h"
 #include "backends/fs/abstract-fs.h"
 
@@ -45 +44 @@
 #define ENTER() /* debug(6, "Enter") */
 #define LEAVE() /* debug(6, "Leave") */
 
-
 const uint32 kExAllBufferSize = 40960; // TODO: is this okay for sure?
 
+/**
+ * Implementation of the ScummVM file system API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
+ */
 class AmigaOSFilesystemNode : public AbstractFilesystemNode {
-        protected:
-                BPTR _pFileLock;
-                String _sDisplayName;
-                bool _bIsDirectory;
-                bool _bIsValid;
-                String _sPath;
+protected:
+        BPTR _pFileLock;
+        String _sDisplayName;
+        String _sPath;
+        bool _bIsDirectory;
+        bool _bIsValid;
 
-        public:
-                AmigaOSFilesystemNode();
-                AmigaOSFilesystemNode(BPTR pLock, const char *pDisplayName = 0);
-                AmigaOSFilesystemNode(const String &p);
+public:
+        /**
+         * Creates a AmigaOSFilesystemNode with the root node as path.
+         */
+        AmigaOSFilesystemNode();
+        
+        /**
+         * Creates a AmigaOSFilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         */
+        AmigaOSFilesystemNode(const String &p);
+        
+        /**
+         * FIXME: document this constructor.
+         */
+        AmigaOSFilesystemNode(BPTR pLock, const char *pDisplayName = 0);
 
-            // Note: Copy constructor is needed because it duplicates the file lock
-                AmigaOSFilesystemNode(const AmigaOSFilesystemNode &node);
-                
-                virtual ~AmigaOSFilesystemNode();
+    /**
+     * Copy constructor.
+     * 
+     * @note Needed because it duplicates the file lock
+     */
+        AmigaOSFilesystemNode(const AmigaOSFilesystemNode &node);
+        
+        /**
+         * Destructor.
+         */
+        virtual ~AmigaOSFilesystemNode();
 
-                virtual String displayName() const { return _sDisplayName; };
-                virtual String name() const { return _sDisplayName; };
-                virtual bool isValid() const { return _bIsValid; };
-                virtual bool isDirectory() const { return _bIsDirectory; };
-                virtual String path() const { return _sPath; };
-
-                virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-                virtual AbstractFSList listVolumes() const;
-                virtual AbstractFilesystemNode *parent() const;
-                virtual AbstractFilesystemNode *child(const String &n) const;
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const { return _sDisplayName; };
+        virtual String getName() const { return _sDisplayName; };
+        virtual String getPath() const { return _sPath; };
+        virtual bool isDirectory() const { return _bIsDirectory; };
+        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
+        virtual bool isValid() const { return _bIsValid; };
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
+        
+        virtual AbstractFilesystemNode *getChild(const String &n) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
+        
+        /**
+         * Creates a list with all the volumes present in the root node.
+         */
+        virtual AbstractFSList listVolumes() const;
 };
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-        return new AmigaOSFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String     &path) {
-        return new AmigaOSFilesystemNode(path);
-}
-
 AmigaOSFilesystemNode::AmigaOSFilesystemNode() {
         ENTER();
         _sDisplayName = "Available Disks";
@@ -100 +118 @@
         LEAVE();
 }
 
-
 AmigaOSFilesystemNode::AmigaOSFilesystemNode(const String &p) {
         ENTER();
 
@@ -150 +167 @@
                                 const char c = _sPath.lastChar();
                                 if (c != '/' && c != ':')
                                         _sPath += '/';
-
                         }
                         else {
                                 //_bIsDirectory = false;
@@ -170 +186 @@
         int bufSize = MAXPATHLEN;
         _pFileLock = 0;
 
-        while (1) {
+        while (true) {
                 char *n = new char[bufSize];
                 if (IDOS->NameFromLock(pLock, (STRPTR)n, bufSize) != DOSFALSE) {
                         _sPath = n;
@@ -186 +202 @@
                         delete [] n;
                         return;
                 }
+                
                 bufSize *= 2;
                 delete [] n;
         }
@@ -238 +255 @@
         LEAVE();
 }
 
-bool AmigaOSFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *AmigaOSFilesystemNode::getChild(const String &n) const {
+        if (!_bIsDirectory) {
+                debug(6, "Not a directory");
+                return 0;
+        }
+
+        String newPath(_sPath);
+
+        if (_sPath.lastChar() != '/')
+                newPath += '/';
+
+        newPath += n;
+        BPTR lock = IDOS->Lock(newPath.c_str(), SHARED_LOCK);
+
+        if (!lock) {
+                debug(6, "Bad path");
+                return 0;
+        }
+
+        IDOS->UnLock(lock);
+
+        return new AmigaOSFilesystemNode(newPath);
+}
+
+bool AmigaOSFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
         ENTER();
 
+        //TODO: honor the hidden flag
+
         if (!_bIsValid) {
                 debug(6, "Invalid node");
                 LEAVE();
@@ -308 +351 @@
         }
 
         LEAVE();
+        
         return true;
 }
 
-AbstractFilesystemNode *AmigaOSFilesystemNode::parent() const {
+AbstractFilesystemNode *AmigaOSFilesystemNode::getParent() const {
         ENTER();
 
         if (!_bIsDirectory) {
@@ -337 +381 @@
                 node = new AmigaOSFilesystemNode();
 
         LEAVE();
+        
         return node;
 }
 
-AbstractFilesystemNode *AmigaOSFilesystemNode::child(const String &n) const {
-        
-        if (!_bIsDirectory) {
-                debug(6, "Not a directory");
-                return 0;
-        }
-
-        String newPath(_sPath);
-
-        if (_sPath.lastChar() != '/')
-                newPath += '/';
-
-        newPath += n;
-
-        BPTR lock = IDOS->Lock(newPath.c_str(), SHARED_LOCK);
-
-        if (!lock) {
-                debug(6, "Bad path");
-                return 0;
-        }
-
-        IDOS->UnLock(lock);
-
-        return new AmigaOSFilesystemNode(newPath);
-}
-
 AbstractFSList AmigaOSFilesystemNode::listVolumes()     const {
         ENTER();
 
@@ -431 +450 @@
         IDOS->UnLockDosList(kLockFlags);
 
         LEAVE();
+        
         return myList;
 }
 
-#endif
+#endif //defined(__amigaos4__)

home/david/Projects/scummvm/backends/fs/dc/dc-fs.cpp

@@ -25 +25 @@
 #if defined(__DC__)
 
 #include "common/stdafx.h"
-
 #include "backends/fs/abstract-fs.h"
 
 #include <ronin/cdfs.h>
@@ -32 +31 @@
 #include <stdio.h>
 #include <unistd.h>
 
-/*
- * Implementation of the ScummVM file system API based on ronin.
+/**
+ * Implementation of the ScummVM file system API based on POSIX.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class RoninCDFilesystemNode : public AbstractFilesystemNode {
 protected:
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isValid;
-        String _path;
 
 public:
+        /**
+         * Creates a RoninCDFilesystemNode with the root node as path.
+         */
         RoninCDFilesystemNode();
+        
+        /**
+         * Creates a RoninCDFilesystemNode for a given path.
+         * 
+         * @param path 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.
+         */
         RoninCDFilesystemNode(const String &path, bool verify);
 
-        virtual String displayName() const { return _displayName; }
-        virtual String name() const { return _displayName; }
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const { return _displayName; }
+        virtual String getName() const { return _displayName; }
+        virtual 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 isValid() const { return _isValid; }
-        virtual bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
 
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-        virtual AbstractFilesystemNode *parent() const;
-        virtual AbstractFilesystemNode *child(const String &n) const;
+        virtual AbstractFilesystemNode *getChild(const String &n) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
 };
 
-
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ *                      /foo/bar.txt would return /bar.txt
+ *                      /foo/bar/    would return /bar/
+ *  
+ * @param str String containing the path.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
         const char *start = str.c_str();
         const char *cur = start + str.size() - 2;
@@ -70 +92 @@
         return cur + 1;
 }
 
-
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        // Since there is no way to _set_ the current directory,
-        // it will always be /...
-
-        return getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-        return new RoninCDFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-        return new RoninCDFilesystemNode(path, true);
-}
-
 RoninCDFilesystemNode::RoninCDFilesystemNode() {
         // The root dir.
         _path = "/";
@@ -118 +124 @@
         }
 }
 
-bool RoninCDFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *RoninCDFilesystemNode::getChild(const 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);
+        if (_path.lastChar() != '/')
+                newPath += '/';
+        newPath += n;
+
+        return new RoninCDFilesystemNode(newPath, true);
+}
+
+bool RoninCDFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
         assert(_isDirectory);
+        
+        //TODO: honor the hidden flag
+        
         DIR *dirp = opendir(_path.c_str());
-
         struct dirent *dp;
 
         if (dirp == NULL)
@@ -150 +171 @@
 
                 if (entry._isDirectory)
                         entry._path += "/";
+                        
                 myList.push_back(new RoninCDFilesystemNode(entry));
         }
         closedir(dirp);
+        
         return true;
 }
 
-AbstractFilesystemNode *RoninCDFilesystemNode::parent() const {
+AbstractFilesystemNode *RoninCDFilesystemNode::getParent() const {
         if (_path == "/")
                 return 0;
 
@@ -163 +186 @@
         const char *start = _path.c_str();
         const char *end = lastPathComponent(_path);
 
-        RoninCDFilesystemNode *p = new RoninCDFilesystemNode(String(start, end - start), false);
-
-        return p;
-}
-
-AbstractFilesystemNode *RoninCDFilesystemNode::child(const 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);
-        if (_path.lastChar() != '/')
-                newPath += '/';
-        newPath += n;
-        RoninCDFilesystemNode *p = new RoninCDFilesystemNode(newPath, true);
-
-        return p;
+        return new RoninCDFilesystemNode(String(start, end - start), false);
 }
 
 #endif // defined(__DC__)

home/david/Projects/scummvm/backends/fs/ds/ds-fs.cpp

@@ -20 +20 @@
  *
  */
 
-
 #include "stdafx.h"
 #include "str.h"
-#include "fs.h"
 #include "common/util.h"
 //#include <NDS/ARM9/console.h> //basic print funcionality
 #include "ds-fs.h"
@@ -30 +28 @@
 #include "dsmain.h"
 #include "gba_nds_fat.h"
 
-
 namespace DS {
 
-
-
-
 //////////////////////////////////////////////////////////////
-// DSFileSystemNode - Flash ROM file system using Zip files
+// DSFileSystemNode - Flash ROM file system using Zip files //
 //////////////////////////////////////////////////////////////
 
 ZipFile*        DSFileSystemNode::_zipFile = NULL;
@@ -66 +60 @@
         char disp[128];
         char* pathStr = (char *) path.c_str();
         
-        
         int lastSlash = 3;
         for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
                 if (path[r] == '\\') {
@@ -81 +74 @@
 //      _isValid = true;
 //      _isDirectory = false;
 
-
-
         if (!strncmp(pathStr, "ds:/", 4)) {
                 pathStr += 4;
         }
@@ -87 +78 @@
                 pathStr += 4;
         }
         
-
         if (*pathStr == '\0') {
                 _isValid = true;
                 _isDirectory = true;
@@ -130 +120 @@
 }
 
 DSFileSystemNode::DSFileSystemNode(const DSFileSystemNode* node) {
-
+        //TODO: not implemented?
 }
 
-AbstractFilesystemNode* DSFileSystemNode::parent() const {
-//      consolePrintf("parent\n");
-        DSFileSystemNode *p;
-
-        if (_path != "ds:/") {  
-                char *path = (char *) _path.c_str();
-                int lastSlash = 4;
-                
-                for (int r = 4; r < (int) strlen((char *) path); r++) {
-                        if (path[r] == '\\') {
-                                lastSlash = r;
-                        }
-                }
-
-                p = new DSFileSystemNode(String(path, lastSlash));
-                ((DSFileSystemNode *) (p))->_isDirectory = true;
-        } else {
-                p = new DSFileSystemNode();
-        }
-
-        return p;
-
-}
-
-
-AbstractFilesystemNode *DSFileSystemNode::child(const Common::String& n) const {
+AbstractFilesystemNode *DSFileSystemNode::getChild(const Common::String& n) const {
         if (_path.lastChar() == '\\') {
                 return new DSFileSystemNode(_path + n);
         } else {
@@ -168 +133 @@
         return NULL;
 }
 
-
-bool DSFileSystemNode::listDir(AbstractFSList &dirList, ListMode mode) const {
+bool DSFileSystemNode::getChildren(AbstractFSList &dirList, ListMode mode, bool hidden) const {
 //      consolePrintf("Listdir\n");
-
-        
 //      consolePrintf("Directory\n");
 
-        
+        //TODO: honor the hidden flag
+
         char temp[128];
         strcpy(temp, _path.c_str());
 
@@ -190 +153 @@
 /*                      // This is the root dir, so add the RAM folder
                         DSFileSystemNode* dsfsn = new DSFileSystemNode("ds:/ram");
                         dsfsn->_isDirectory = true;
-                        dirList->push_back(wrap(dsfsn));*/
+                        dirList->push_back(wrap(dsfsn));
+*/
                 }
         } else {
                 _zipFile->changeDirectory(temp);
@@ -196 +160 @@
                 _zipFile->changeDirectory(temp);
         }
         
-        
-        
         if (_zipFile->restartFile()) {
                 do {
                         char n[128];    
@@ -218 +180 @@
         return true;
 }
 
+AbstractFilesystemNode* DSFileSystemNode::getParent() const {
+//      consolePrintf("parent\n");
+        DSFileSystemNode *p;
+
+        if (_path != "ds:/") {  
+                char *path = (char *) _path.c_str();
+                int lastSlash = 4;
+                
+                for (int r = 4; r < (int) strlen((char *) path); r++) {
+                        if (path[r] == '\\') {
+                                lastSlash = r;
+                        }
+                }
 
+                p = new DSFileSystemNode(String(path, lastSlash));
+                ((DSFileSystemNode *) (p))->_isDirectory = true;
+        } else {
+                p = new DSFileSystemNode();
+        }
 
+        return p;
+}
 
-/////////////////////////////////////////////////////////////////////////
-// GBAMPFileSystemNode - File system using GBA Movie Player and CF card
-/////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+// GBAMPFileSystemNode - File system using GBA Movie Player and CF card //
+//////////////////////////////////////////////////////////////////////////
 
 GBAMPFileSystemNode::GBAMPFileSystemNode() {
         _displayName = "mp:/";
@@ -290 +272 @@
 
 
 GBAMPFileSystemNode::GBAMPFileSystemNode(const GBAMPFileSystemNode* node) {
-
+        //TODO: not implemented?
 }
 
-
-AbstractFilesystemNode* GBAMPFileSystemNode::parent() const {
-//      consolePrintf("parent\n");
-        GBAMPFileSystemNode *p;
-
-        if (_path != "mp:/") {  
-                char *path = (char *) _path.c_str();
-                int lastSlash = 4;
-                
-                for (int r = 4; r < (int) strlen((char *) path); r++) {
-                        if (path[r] == '/') {
-                                lastSlash = r;
-                        }
-                }
-
-                p = new GBAMPFileSystemNode(String(path, lastSlash));
-                p->_isDirectory = true;
-        } else {
-                p = new GBAMPFileSystemNode();
-        }
-
-        return p;
-
-}
-
-AbstractFilesystemNode *GBAMPFileSystemNode::child(const Common::String& n) const {
+AbstractFilesystemNode *GBAMPFileSystemNode::getChild(const Common::String& n) const {
         if (_path.lastChar() == '\\') {
                 return new DSFileSystemNode(_path + n);
         } else {
@@ -328 +285 @@
         return NULL;
 }
 
-bool GBAMPFileSystemNode::listDir(AbstractFSList& dirList, ListMode mode) const {
+bool GBAMPFileSystemNode::getChildren(AbstractFSList& dirList, ListMode mode, bool hidden) const {
 //      consolePrintf("Listdir\n");
 
+        //TODO: honor the hidden flag
+
         enum { TYPE_NO_MORE = 0, TYPE_FILE = 1, TYPE_DIR = 2 };
         
         char temp[128], fname[128], *path, *pathTemp;
@@ -346 +305 @@
                 pathTemp++;
         }
 
-
 //      consolePrintf("This dir: %s\n", path);
         FAT_chdir(path);
         
@@ -369 +327 @@
 //                              dsfsn->_isDirectory = entryType == DIR;
                                 dirList.push_back((dsfsn));
                         }
-                
-                
                 } else {
 //                      consolePrintf("Skipping %s\n", fname);
                 }
@@ -385 +341 @@
         return true;
 }
 
+AbstractFilesystemNode* GBAMPFileSystemNode::getParent() const {
+//      consolePrintf("parent\n");
+        GBAMPFileSystemNode *p;
+
+        if (_path != "mp:/") {  
+                char *path = (char *) _path.c_str();
+                int lastSlash = 4;
+                
+                for (int r = 4; r < (int) strlen((char *) path); r++) {
+                        if (path[r] == '/') {
+                                lastSlash = r;
+                        }
+                }
+
+                p = new GBAMPFileSystemNode(String(path, lastSlash));
+                p->_isDirectory = true;
+        } else {
+                p = new GBAMPFileSystemNode();
+        }
+
+        return p;
+}
 
 // Stdio replacements
 #define MAX_FILE_HANDLES 32
@@ -393 +371 @@
 DS::fileHandle handle[MAX_FILE_HANDLES];
 
 FILE* std_fopen(const char* name, const char* mode) {
-
-        
-
         if (!inited) {
                 for (int r = 0; r < MAX_FILE_HANDLES; r++) {
                         handle[r].used = false;
@@ -403 +378 @@
                 inited = true;
                 currentDir[0] = '\0';
         }
-
-
-        
         
         char* realName = (char *) name;
         
@@ -413 +385 @@
         if ((name[0] == 'd') && (name[1] == 's') && (name[2] == ':') && (name[3] == '/')) {
                 realName += 4;
         }
-
+        
         if ((name[0] == 'm') && (name[1] == 'p') && (name[2] == ':') && (name[3] == '/')) {
                 realName += 4;
         }
@@ -421 +393 @@
 //      consolePrintf("Open file:");
 //      consolePrintf("'%s', [%s]", realName, mode);
 
-
         if (DS::isGBAMPAvailable()) {
                 FAT_chdir("/");
                 
@@ -443 +414 @@
                 
                 return (FILE *) result;
         }
-
         
         // Fail to open file for writing.  It's in ROM!
-
+        
         // Allocate a file handle
         int r = 0;
         while (handle[r].used) r++;
@@ -459 +429 @@
                 handle[r].sramFile = (DSSaveFile *) DSSaveFileManager::instance()->openSavefile(realName, false);
         }
 
-        
         if (handle[r].sramFile) {
                 handle[r].used = true;
                 handle[r].pos = 0;
@@ -513 +482 @@
                 return NULL;
         }
 }
+
 void std_fclose(FILE* handle) {
 
         if (DS::isGBAMPAvailable()) {
@@ -528 +498 @@
 }
 
 size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle) {
-
 //      consolePrintf("fread %d,%d %d ", size, numItems, ptr);
-        
-        
 
         if (DS::isGBAMPAvailable()) {
-        
-                
                 int bytes = FAT_fread((void *) ptr, size, numItems, (FAT_FILE *) handle);
                 if (!std_feof(handle)) {
                         return numItems;
@@ -560 +525 @@
                 
                 }
                 
-                return item;*/
-
-
+                return item;
+*/
                 int items = 0;
         
                 //for (int r = 0; r < numItems; r++) {
@@ -567 +531 @@
         
                 //for (int r = 0; r < numItems; r++) {
                         if (!std_feof(handle)) {
-                                
-
-                                
 /*                              for (int t = 0; t < size; t++) {
                                         if (feof(handle)) eof = true;
                                         *(((char *) (ptr)) + r * size + t) = getc(handle);
@@ -576 +537 @@
                                 }*/
                                 int left = size * numItems;
                                 int bytesRead = -1;
+                                
                                 while ((left > 0) && (!FAT_feof((FAT_FILE *) handle))) {
                                         int amount = left > 8192? 8192: left;
 //                                      do {
@@ -580 +542 @@
                                         int amount = left > 8192? 8192: left;
 //                                      do {
                                                 bytesRead = FAT_fread((void *) ptr, 1, amount, (FAT_FILE *) handle);
-        /*                                      if (bytesRead == 0) {
+/*                                              if (bytesRead == 0) {
                                                         consolePrintf("Pos:%d items:%d num:%d amount:%d read:%d\n", ftell(handle), items, numItems, amount, bytesRead);
                                                         left++;
                                                         
@@ -592 +554 @@
                                                         fread(ptr, 1024, 1, handle);
                                                         swiWaitForVBlank();
                                                         //while (true);
-                                                }*/
-                                        //} while (bytesRead == 0);
+                                                }
+
+                                        } while (bytesRead == 0);
+*/
                                         left -= bytesRead;
                                         ptr = ((char *) (ptr)) + bytesRead;                             
                                 }
@@ -599 +563 @@
                                 }
                                 
                                 items = numItems - (left / size);
-                                
-                        
-                
-                                
+
 //                              FAT_fread((void *) ptr, size, 1, ((int) (handle)) - 1);
-        //                      ptr = ((char *) (ptr)) + size;
-                                
+//                              ptr = ((char *) (ptr)) + size;  
                         }
-                //}
+//              }
                 
 //              consolePrintf("...done %d \n", items)
 
@@ -612 +572 @@
 //              consolePrintf("...done %d \n", items)
 
                 return items;
-                
         }
         
         if (handle->sramFile) {
@@ -630 +589 @@
                 return bytes / size;
         }
 
-
         if (handle->pos + size * numItems > handle->size) {
                 numItems = (handle->size - handle->pos) / size;
                 if (numItems < 0) numItems = 0;
@@ -639 +597 @@
 //      consolePrintf("read %d  ", size * numItems);
 
         memcpy((void *) ptr, handle->data + handle->pos, size * numItems);
-
         handle->pos += size * numItems;
 
-        
         return numItems;
 }
 
@@ -657 +613 @@
         //consolePrintf("fwrite size=%d\n", size * numItems);
 
         if (DS::isGBAMPAvailable()) {
-
                 FAT_fwrite(((char *) (ptr)), size, numItems, (FAT_FILE *) handle);
                 return numItems;
                 
@@ -675 +630 @@
                 return numItems;
         }
 
-
         if (handle->sramFile) {
                 handle->sramFile->write(ptr, size);
                 return size;
@@ -704 +658 @@
 }
 
 void std_fflush(FILE* handle) {
+        //FIXME: not implemented?
 //      consolePrintf("fflush ");
 }
 
@@ -711 +666 @@
 //      consolePrintf("fgets file=%d ", file);
         
         if (DS::isGBAMPAvailable()) {
-                
                 char* s = str;
                 while ((*s++ = std_getc(file)) >= 32) {
 //                      consolePrintf("%d ", *s);
@@ -723 +677 @@
                 return str;
         }
         
-        
         if (file->sramFile) {
                 file->pos--;
                 int p = -1;
@@ -743 +696 @@
 }
 
 long int std_ftell(FILE* handle) {
-
         if (DS::isGBAMPAvailable()) {
                 return FAT_ftell((FAT_FILE *) handle);
         }
@@ -758 +710 @@
                 return FAT_fseek((FAT_FILE *) handle, offset, whence);
         }
 
-
         switch (whence) {
-                case SEEK_CUR: {
+                case SEEK_CUR:
                         handle->pos += offset;
                         break;
-                }
-                
-                case SEEK_SET: {
+                case SEEK_SET:
                         handle->pos = offset;
                         break;
-                }
-                
-                case SEEK_END: {
+                case SEEK_END:
                         handle->pos = handle->size + offset;
                         break;
-                }
-                
-                default: {
+                default:
                         handle->pos = offset;
                         break;
-                }
-                
         }
         
         return 0;
@@ -786 +729 @@
 }
 
 void std_clearerr(FILE* handle) {
+        //FIXME: not implemented?
 //      consolePrintf("clearerr ");
 }
 
@@ -790 +734 @@
 }
 
 int std_getc(FILE* handle) {
-
         if (DS::isGBAMPAvailable()) {
                 char c;
                 FAT_fread(&c, 1, 1, (FAT_FILE *) handle);
@@ -852 +795 @@
 }
 
 } // namespace DS
-
-// These functions are added to AbstractFileSystemNode and are therefore outside
-// the DS namespace.
-
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-//      consolePrintf("New node");
-        
-        if (DS::isGBAMPAvailable()) {
-                return new DS::GBAMPFileSystemNode();
-        } else {
-                return new DS::DSFileSystemNode();
-        }
-}
-
-AbstractFilesystemNode* AbstractFilesystemNode::getNodeForPath(const String& path) {
-        if (DS::isGBAMPAvailable()) {
-                return new DS::GBAMPFileSystemNode(path);
-        } else {
-                return new DS::DSFileSystemNode(path);
-        }
-}

home/david/Projects/scummvm/backends/fs/ds/ds-fs.h

@@ -23 +23 @@
 #ifndef _DS_FS_H
 #define _DS_FS_H
 
-
-
 //#include <NDS/ARM9/console.h>
 #include "fs.h"
 #include "zipreader.h"
@@ -32 +30 @@
 #include "scummconsole.h"
 #include "gba_nds_fat.h"
 #include "backends/fs/abstract-fs.h"
-//#include "backends/fs/fs.h"
 
 namespace DS {
 
@@ -37 +34 @@
 namespace DS {
 
 /**
+ * Implementation of the ScummVM file system API.
  * This class is used when a Flash cart is in use.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
 class DSFileSystemNode : public AbstractFilesystemNode {
 protected:
-        static ZipFile* _zipFile;
-
         typedef class Common::String String;
 
+        static ZipFile* _zipFile;
+
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isValid;
-        String _path;
         int _refCountVal;
         
 public:
+        /**
+         * Creates a DSFilesystemNode with the root node as path.
+         */
         DSFileSystemNode();
+        
+        /**
+         * Creates a DSFilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         */
         DSFileSystemNode(const String &path);
-        DSFileSystemNode(const DSFileSystemNode *node);
+        
+        /**
+         * Creates a DSFilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         * @param path true if path is a directory, false otherwise.
+         */
         DSFileSystemNode(const String& path, bool isDir);
         
-        virtual String displayName() const {  return _displayName; }
-        virtual String name() const {  return _displayName; }
-        virtual bool isValid() const { return _isValid; }
+        /**
+         * Copy constructor.
+         */
+        DSFileSystemNode(const DSFileSystemNode *node);
+        
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const {  return _displayName; }
+        virtual String getName() const {  return _displayName; }
+        virtual String getPath() const { return _path; }
         virtual bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
+        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
+        virtual bool isValid() const { return _isValid; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
         
-        virtual bool listDir(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly) const;
-        virtual AbstractFilesystemNode *parent() const;
+        /**
+         * Returns a copy of this node.
+         */
         virtual AbstractFilesystemNode *clone() const { return new DSFileSystemNode(this); }
-        virtual AbstractFilesystemNode *child(const Common::String& name) const;
+        virtual AbstractFilesystemNode *getChild(const Common::String& name) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
+        
+        /**
+         * Returns the zip file this node points to.
+         * TODO: check this documentation.
+         */
         static ZipFile* getZip() { return _zipFile; }
 };
 
-
-/**
+ /**
+ * Implementation of the ScummVM file system API.
  * This class is used when the GBAMP (GBA Movie Player) is used with a CompactFlash card.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
 class GBAMPFileSystemNode : public AbstractFilesystemNode {
 protected:
@@ -79 +112 @@
         typedef class Common::String String;
 
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isValid;
-        String _path;
-        
         int _refCountVal;
         
 public:
+        /**
+         * Creates a GBAMPFilesystemNode with the root node as path.
+         */
         GBAMPFileSystemNode();
+        
+        /**
+         * Creates a GBAMPFilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         */
         GBAMPFileSystemNode(const String &path);
+        
+        /**
+         * Creates a DSFilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         * @param path true if path is a directory, false otherwise.
+         */
         GBAMPFileSystemNode(const String &path, bool isDirectory);
+        
+        /**
+         * Copy constructor.
+         */
         GBAMPFileSystemNode(const GBAMPFileSystemNode *node);
 
-        virtual String displayName() const {  return _displayName; }
-        virtual String name() const {  return _displayName; }
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const {  return _displayName; }
+        virtual String getName() const {  return _displayName; }
+        virtual 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 isValid() const { return _isValid; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
         
-        virtual bool isValid() const { return _isValid; }
-        virtual bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
-        virtual bool listDir(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly) const;
-        virtual AbstractFilesystemNode *parent() const;
+        /**
+         * Returns a copy of this node.
+         */
         virtual AbstractFilesystemNode *clone() const { return new GBAMPFileSystemNode(this); }
-        virtual AbstractFilesystemNode *child(const Common::String& name) const;
-        
+        virtual AbstractFilesystemNode *getChild(const Common::String& name) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
 };
 
-
-
-
 struct fileHandle {
         int pos;
         bool used;
@@ -116 +170 @@
         DSSaveFile* sramFile;
 };
 
-
 #undef stderr
 #undef stdout
 #undef stdin
@@ -140 +193 @@
 void    std_cwd(char* dir);
 void    std_fflush(FILE* handle);
 
-}
+} //namespace DS
 
-#endif
+#endif //_DS_FS_H

home/david/Projects/scummvm/backends/fs/gp32/gp32-fs.cpp

@@ -24 +24 @@
  */
 
 #include "stdafx.h"
+#include "backends/fs/abstract-fs.h"
 
-#include "backends/fs/abstract-fs.h"
+#define MAX_PATH_SIZE 256
 
+/**
+ * Implementation of the ScummVM file system API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
+ */
 class GP32FilesystemNode : public AbstractFilesystemNode {
 protected:
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isRoot;
-        String _path;
 
 public:
+        /**
+         * Creates a GP32FilesystemNode with the root node as path.
+         */
         GP32FilesystemNode();
+        
+        /**
+         * Creates a GP32FilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         */
         GP32FilesystemNode(const String &path);
 
-        virtual String displayName() const { return _displayName; }
-        virtual String name() const { return _displayName; }
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const { return _displayName; }
+        virtual String getName() const { return _displayName; }
+        virtual String getPath() const { return _path; }
+        virtual bool isDirectory() const { return _isDirectory; }
         // FIXME: isValid should return false if this Node can't be used!
-        // client code can rely on the return value.
+        // so client code can rely on the return value.
+        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
         virtual bool isValid() const { return true; }
-        virtual bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
 
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-        virtual AbstractFilesystemNode *parent() const;
-        virtual AbstractFilesystemNode *child(const String &n) const;
+        virtual AbstractFilesystemNode *getChild(const String &n) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
 };
 
-#define MAX_PATH_SIZE 256
-
 const char gpRootPath[] = "gp:\\";
 //char gpCurrentPath[MAX_PATH_SIZE] = "gp:\\";          // must end with '\'
 
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ *                      gp:\foo\bar.txt would return "\bar.txt"
+ *                      gp:\foo\bar\    would return "\bar\"
+ *  
+ * @param str Path to obtain the last component from.
+ * @return Pointer to the first char of the last component inside str.
+ */
+static const char *lastPathComponent(const Common::String &str) {
+        const char *start = str.c_str();
+        const char *cur = start + str.size() - 2;
+
+        while (cur >= start && *cur != '\\') {
+                --cur;
+        }
+
+        return cur + 1;
+}
+
+/**
+ * FIXME: document this function.
+ * 
+ * @param path
+ * @param convPath
+ */
 int gpMakePath(const char *path, char *convPath) {
         // copy root or current directory
         const char *p;
@@ -106 +149 @@
         return 0;
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-        return new GP32FilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-        return new GP32FilesystemNode(path);
-}
-
 GP32FilesystemNode::GP32FilesystemNode() {
         _isDirectory = true;
         _isRoot = true;
@@ -132 +163 @@
         gpMakePath(path.c_str(), convPath);
 
         _path = convPath;
-
         pos = convPath;
+        
         while (*pos)
                 if (*pos++ == '\\')
                         dsplName = pos;
@@ -150 +181 @@
         _isDirectory = true;
 }
 
-bool GP32FilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *GP32FilesystemNode::getChild(const 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);
+        if (_path.lastChar() != '\\')
+                newPath += '\\';
+        newPath += n;
+
+        return new GP32FilesystemNode(newPath);
+}
+
+bool GP32FilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
+        assert(_isDirectory);
+
+        //TODO: honor the hidden flag
 
         GPDIRENTRY dirEntry;
         GPFILEATTR attr;
-
         GP32FilesystemNode entry;
-
         uint32 read;
 
         if (mode == FilesystemNode::kListAll)
@@ -168 +212 @@
         int startIdx = 0; // current file
         String listDir(_path);
         //listDir += "/";
+        
         while (GpDirEnumList(listDir.c_str(), startIdx++, 1, &dirEntry, &read)  == SM_OK) {
                 if (dirEntry.name[0] == '.')
                         continue;
+                        
                 entry._displayName = dirEntry.name;
                 entry._path = _path;
                 entry._path += dirEntry.name;
@@ -194 +240 @@
         return true;
 }
 
-static const char *lastPathComponent(const Common::String &str) {
-        const char *start = str.c_str();
-        const char *cur = start + str.size() - 2;
-
-        while (cur >= start && *cur != '\\') {
-                --cur;
-        }
-
-        return cur + 1;
-}
-
-AbstractFilesystemNode *GP32FilesystemNode::parent() const {
+AbstractFilesystemNode *GP32FilesystemNode::getParent() const {
         if(_isRoot)
                 return 0;
 
@@ -218 +253 @@
 
         return p;
 }
-
-AbstractFilesystemNode *GP32FilesystemNode::child(const 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);
-        if (_path.lastChar() != '\\')
-                newPath += '\\';
-        newPath += n;
-        GP32FilesystemNode *p = new GP32FilesystemNode(newPath);
-
-        return p;
-}

home/david/Projects/scummvm/backends/fs/morphos/abox-fs.cpp

@@ -35 +35 @@
 #include "base/engine.h"
 #include "backends/fs/abstract-fs.h"
 
-/*
+/**
  * Implementation of the ScummVM file system API based on the MorphOS A-Box API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class ABoxFilesystemNode : public AbstractFilesystemNode {
-        protected:
-                BPTR _lock;
-                String _displayName;
-                bool _isDirectory;
-                bool _isValid;
-                String _path;
+protected:
+        BPTR _lock;
+        String _displayName;
+        String _path;
+        bool _isDirectory;
+        bool _isValid;
 
-        public:
-                ABoxFilesystemNode();
-                ABoxFilesystemNode(BPTR lock, CONST_STRPTR display_name = NULL);
-                ABoxFilesystemNode(const String &p);
-                ABoxFilesystemNode(const ABoxFilesystemNode &node);
+public:
+        /**
+         * Creates a ABoxFilesystemNode with the root node as path.
+         */
+        ABoxFilesystemNode();
+        
+        /**
+         * Creates a ABoxFilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         */
+        ABoxFilesystemNode(const String &p);
+        
+        /**
+         * FIXME: document this constructor.
+         */
+        ABoxFilesystemNode(BPTR lock, CONST_STRPTR display_name = NULL);
+        
+        /**
+         * Copy constructor.
+         */
+        ABoxFilesystemNode(const ABoxFilesystemNode &node);
 
-                ~ABoxFilesystemNode();
+        /**
+         * Destructor.
+         */
+        ~ABoxFilesystemNode();
 
-                virtual String displayName() const { return _displayName; }
-                virtual String name() const { return _displayName; };
-                virtual bool isValid() const { return _isValid; }
-                virtual bool isDirectory() const { return _isDirectory; }
-                virtual String path() const { return _path; }
-
-                virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-                static  AbstractFSList listRoot();
-                virtual AbstractFilesystemNode *parent() const;
-                virtual AbstractFilesystemNode *child(const String &name) const;
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const { return _displayName; }
+        virtual String getName() const { return _displayName; };
+        virtual 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 isValid() const { return _isValid; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
+        
+        virtual AbstractFilesystemNode *getChild(const String &name) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
+        
+        /**
+         * Return the list of child nodes for the root node.
+         */
+        static AbstractFSList getRootChildren();
 };
 
-
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String     &path) {
-        return new ABoxFilesystemNode(path);
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot()
-{
-        return new ABoxFilesystemNode();
-}
-
 ABoxFilesystemNode::ABoxFilesystemNode()
 {
         _displayName = "Mounted Volumes";
@@ -90 +104 @@
         _lock = NULL;
 }
 
-ABoxFilesystemNode::ABoxFilesystemNode(BPTR lock, CONST_STRPTR display_name)
-{
-        int bufsize = 256;
-
-        _lock = NULL;
-        for (;;)
-        {
-                char name[bufsize];
-                if (NameFromLock(lock, name, bufsize) != DOSFALSE)
-                {
-                        _path = name;
-                        _displayName = display_name ? display_name : FilePart(name);
-                        break;
-                }
-                if (IoErr() != ERROR_LINE_TOO_LONG)
-                {
-                        _isValid = false;
-                        debug(6, "Error while retrieving path name: %ld", IoErr());
-                        return;
-                }
-                bufsize *= 2;
-        }
-
-        _isDirectory = false;
-        _isValid = false;
-
-        FileInfoBlock *fib = (FileInfoBlock*) AllocDosObject(DOS_FIB, NULL);
-        if (fib == NULL)
-        {
-                debug(6, "Failed to allocate memory for FileInfoBlock");
-                return;
-        }
-
-        if (Examine(lock, fib) != DOSFALSE)
-        {
-                _isDirectory = fib->fib_EntryType > 0;
-                if (_isDirectory)
-                {
-                        if (fib->fib_EntryType != ST_ROOT)
-                                _path += "/";
-                        _lock = DupLock(lock);
-                        _isValid = (_lock != NULL);
-                }
-                else
-                {
-                        _isValid = true;
-                }
-        }
-        FreeDosObject(DOS_FIB, fib);
-}
-
 ABoxFilesystemNode::ABoxFilesystemNode(const String &p) {
         int len = 0, offset = p.size();
 
@@ -168 +131 @@
         }
 
         // Check whether the node exists and if it is a directory
-
         BPTR pLock = Lock((STRPTR)_path.c_str(), SHARED_LOCK);
         if (pLock)
         {
@@ -198 +160 @@
         FreeDosObject(DOS_FIB, fib);
 }
 
+ABoxFilesystemNode::ABoxFilesystemNode(BPTR lock, CONST_STRPTR display_name)
+{
+        int bufsize = 256;
+
+        _lock = NULL;
+        for (;;)
+        {
+                char name[bufsize];
+                if (NameFromLock(lock, name, bufsize) != DOSFALSE)
+                {
+                        _path = name;
+                        _displayName = display_name ? display_name : FilePart(name);
+                        break;
+                }
+                if (IoErr() != ERROR_LINE_TOO_LONG)
+                {
+                        _isValid = false;
+                        debug(6, "Error while retrieving path name: %ld", IoErr());
+                        return;
+                }
+                bufsize *= 2;
+        }
+
+        _isDirectory = false;
+        _isValid = false;
+
+        FileInfoBlock *fib = (FileInfoBlock*) AllocDosObject(DOS_FIB, NULL);
+        if (fib == NULL)
+        {
+                debug(6, "Failed to allocate memory for FileInfoBlock");
+                return;
+        }
+
+        if (Examine(lock, fib) != DOSFALSE)
+        {
+                _isDirectory = fib->fib_EntryType > 0;
+                if (_isDirectory)
+                {
+                        if (fib->fib_EntryType != ST_ROOT)
+                                _path += "/";
+                        _lock = DupLock(lock);
+                        _isValid = (_lock != NULL);
+                }
+                else
+                {
+                        _isValid = true;
+                }
+        }
+        
+        FreeDosObject(DOS_FIB, fib);
+}
+
 ABoxFilesystemNode::ABoxFilesystemNode(const ABoxFilesystemNode& node)
 {
         _displayName = node._displayName;
@@ -216 +230 @@
         }
 }
 
-bool ABoxFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
+AbstractFilesystemNode *ABoxFilesystemNode::getChild(const String &name) const {
+        assert(_isDirectory);
+        String newPath(_path);
+
+        if (_path.lastChar() != '/')
+                newPath += '/';
+        newPath += name;
+
+        BPTR lock = Lock(newPath.c_str(), SHARED_LOCK);
+
+        if (!lock)
+        {
+                return 0;
+    }
+
+        UnLock(lock);
+
+        return new ABoxFilesystemNode(newPath);
+}
+
+bool ABoxFilesystemNode::getChildren(AbstractFSList &list, ListMode mode, bool hidden) const
 {
+        //TODO: honor the hidden flag
+        
         if (!_isValid)
         {
                 debug(6, "listDir() called on invalid node");
@@ -232 +268 @@
         if (_lock == NULL)
         {
                 /* This is the root node */
-                myList = listRoot();
+                list = getRootChildren();
                 return true;
         }
 
@@ -266 +302 @@
                                         if (entry)
                                         {
                                                 if (entry->isValid())
-                                                        myList.push_back(entry);
+                                                        list.push_back(entry);
                                                 else
                                                         delete entry;
                                         }
@@ -284 +320 @@
         return true;
 }
 
-AbstractFilesystemNode *ABoxFilesystemNode::parent() const
+AbstractFilesystemNode *ABoxFilesystemNode::getParent() const
 {
         AbstractFilesystemNode *node = NULL;
 
@@ -309 +345 @@
         return node;
 }
 
-AbstractFilesystemNode *ABoxFilesystemNode::child(const String &name) const {
-        assert(_isDirectory);
-        String newPath(_path);
-
-        if (_path.lastChar() != '/')
-                newPath += '/';
-        newPath += name;
-
-        BPTR lock = Lock(newPath.c_str(), SHARED_LOCK);
-
-        if (!lock)
-        {
-                return 0;
-    }
-
-        UnLock(lock);
-
-        return new ABoxFilesystemNode(newPath);
-}
-
-AbstractFSList ABoxFilesystemNode::listRoot()
+AbstractFSList ABoxFilesystemNode::getRootChildren()
 {
-        AbstractFSList myList;
+        AbstractFSList list;
         DosList *dosList;
         CONST ULONG lockDosListFlags = LDF_READ | LDF_VOLUMES;
         char name[256];
@@ -339 +355 @@
         dosList = LockDosList(lockDosListFlags);
         if (dosList == NULL)
         {
-                return myList;
+                return list;
         }
 
         dosList = NextDosEntry(dosList, LDF_VOLUMES);
@@ -345 +361 @@
         dosList = NextDosEntry(dosList, LDF_VOLUMES);
         while (dosList)
         {
-                if (dosList->dol_Type == DLT_VOLUME &&  // Should always be true, but ...
-                         dosList->dol_Name &&                                   // Same here
-                         dosList->dol_Task                                              // Will be NULL if volume is removed from drive but still in use by some program
+                if (dosList->dol_Type == DLT_VOLUME &&  // Should always be true, but ...
+                         dosList->dol_Name &&                           // Same here
+                         dosList->dol_Task                                      // Will be NULL if volume is removed from drive but still in use by some program
                         )
                 {
                         ABoxFilesystemNode *entry;
@@ -365 +381 @@
                                 if (entry)
                                 {
                                         if (entry->isValid())
-                                                myList.push_back(entry);
+                                                list.push_back(entry);
                                         else
                                                 delete entry;
                                 }
@@ -377 +393 @@
 
         UnLockDosList(lockDosListFlags);
 
-        return myList;
+        return list;
 }
 
 #endif // defined(__MORPHOS__)
-
-

home/david/Projects/scummvm/backends/fs/palmos/palmos-fs.cpp

@@ -30 +30 @@
 #include "common/stdafx.h"
 #include "backends/fs/abstract-fs.h"
 
-/*
+/**
  * Implementation of the ScummVM file system API based on PalmOS VFS API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class PalmOSFilesystemNode : public AbstractFilesystemNode {
 protected:
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isValid;
         bool _isPseudoRoot;
-        String _path;
         
 public:
+        /**
+         * Creates a PalmOSFilesystemNode with the root node as path.
+         */
         PalmOSFilesystemNode();
+        
+        /**
+         * Creates a POSIXFilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         */
         PalmOSFilesystemNode(const String &p);
 
-        virtual String displayName() const { return _displayName; }
-        virtual String name() const { return _displayName; }
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const { return _displayName; }
+        virtual String getName() const { return _displayName; }
+        virtual 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 isValid() const { return _isValid; }
-        virtual bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
 
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-        virtual AbstractFilesystemNode *parent() const;
-        virtual AbstractFilesystemNode *child(const String &n) const;
+        virtual AbstractFilesystemNode *getChild(const String &n) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
 
 private:
-        static void addFile (AbstractFSList &list, ListMode mode, const Char *base, FileInfoType* find_data);
+        /**
+         * Adds a single WindowsFilesystemNode to a given list.
+         * This method is used by getChildren() to populate the directory entries list. 
+         * 
+         * @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 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);
 };
 
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ *                      /foo/bar.txt would return /bar.txt
+ *                      /foo/bar/    would return /bar/
+ *  
+ * @param str String containing the path.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
         const char *start = str.c_str();
         const char *cur = start + str.size() - 2;
@@ -95 +127 @@
         list.push_back(new PalmOSFilesystemNode(entry));
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-        return new PalmOSFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-        return new PalmOSFilesystemNode(path);
-}
-
-
 PalmOSFilesystemNode::PalmOSFilesystemNode() {
         _isDirectory = true;
         _displayName = "Root";
@@ -122 +141 @@
 
         UInt32 attr;
         FileRef handle;
-        Err e = VFSFileOpen(gVars->VFS.volRefNum, _path.c_str(), vfsModeRead, &handle);
-        if (!e) {
-                e = VFSFileGetAttributes(handle, &attr);
+        Err error = VFSFileOpen(gVars->VFS.volRefNum, _path.c_str(), vfsModeRead, &handle);
+        if (!error) {
+                error = VFSFileGetAttributes(handle, &attr);
                 VFSFileClose(handle);
         }
 
-        if (e) {
+        if (error) {
                 _isValid = false;
                 _isDirectory = false;
 
@@ -139 +158 @@
         _isPseudoRoot = false;
 }
 
-bool PalmOSFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
-        Err e;
+AbstractFilesystemNode *PalmOSFilesystemNode::getChild(const String &n) const {
+        assert(_isDirectory);
+        
+        String newPath(_path);
+        if (_path.lastChar() != '/')
+                newPath += '/';
+        newPath += n;
+
+        FileRef handle;
+        UInt32 attr;
+        Err error = VFSFileOpen(gVars->VFS.volRefNum, newPath.c_str(), vfsModeRead, &handle);
+        if (error)
+                return 0;
+        
+        error = VFSFileGetAttributes(handle, &attr);
+        VFSFileClose(handle);
+
+        if (error || !(attr & vfsFileAttrDirectory))
+                return 0;
+
+        return new PalmOSFilesystemNode(newPath);
+}
+
+bool PalmOSFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
+        //TODO: honor the hidden flag
+        
+        Err error;
         Char nameP[256];
         FileInfoType desc;
         FileRef handle;
@@ -148 +192 @@
 
         desc.nameP = nameP;
         desc.nameBufLen = 256;
-        e = VFSFileOpen(gVars->VFS.volRefNum, _path.c_str(), vfsModeRead, &handle);
+        error = VFSFileOpen(gVars->VFS.volRefNum, _path.c_str(), vfsModeRead, &handle);
 
-        if (e)
+        if (error)
                 return false;
         
         while(dirIterator != expIteratorStop) {
-                e = VFSDirEntryEnumerate(handle, &dirIterator, &desc);
-                if (!e) {
+                error = VFSDirEntryEnumerate(handle, &dirIterator, &desc);
+                if (!error) {
                         addFile(myList, mode, _path.c_str(), &desc);
                 }
         }
@@ -165 +209 @@
         return true;
 }
 
-
-AbstractFilesystemNode *PalmOSFilesystemNode::parent() const {
+AbstractFilesystemNode *PalmOSFilesystemNode::getParent() const {
         PalmOSFilesystemNode *p = 0;
         
         if (!_isPseudoRoot) {
@@ -180 +223 @@
                 p->_displayName = lastPathComponent(p->_path);
                 p->_isPseudoRoot =(p->_path == "/");
         }
-        return p;
-}
-
-
-AbstractFilesystemNode *PalmOSFilesystemNode::child(const String &n) const {
-        assert(_isDirectory);
-        String newPath(_path);
-
-        if (_path.lastChar() != '/')
-                newPath += '/';
-        newPath += n;
-
-        FileRef handle;
-        UInt32 attr;
-        Err e = VFSFileOpen(gVars->VFS.volRefNum, newPath.c_str(), vfsModeRead, &handle);
-        if (e)
-                return 0;
         
-        e = VFSFileGetAttributes(handle, &attr);
-        VFSFileClose(handle);
-
-        if (e || !(attr & vfsFileAttrDirectory))
-                return 0;
-
-        PalmOSFilesystemNode *p = new PalmOSFilesystemNode(newPath);
         return p;
 }
 

home/david/Projects/scummvm/backends/fs/posix/posix-fs.cpp

@@ -25 +25 @@
 #if defined(UNIX)
 
 #include "common/stdafx.h"
-
 #include "backends/fs/abstract-fs.h"
 
 #ifdef MACOSX
@@ -37 +36 @@
 #include <stdio.h>
 #include <unistd.h>
 
-/*
+/**
  * Implementation of the ScummVM file system API based on POSIX.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class POSIXFilesystemNode : public AbstractFilesystemNode {
 protected:
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isValid;
-        String _path;
 
 public:
+        /**
+         * Creates a POSIXFilesystemNode with the root node as path.
+         */
         POSIXFilesystemNode();
+        
+        /**
+         * Creates a POSIXFilesystemNode for a given path.
+         * 
+         * @param path 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.
+         */
         POSIXFilesystemNode(const String &path, bool verify);
-
-        virtual String displayName() const { return _displayName; }
-        virtual String name() const { return _displayName; }
-        virtual bool isValid() const { return _isValid; }
+        
+        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 bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
-
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-        virtual AbstractFilesystemNode *parent() const;
-        virtual AbstractFilesystemNode *child(const String &n) const;
+        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 bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
+        
+private:
+        /**
+         * Tests and sets the _isValid and _isDirectory flags, using the stat() function.
+         */
+        virtual void setFlags();
 };
 
-
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ *                      /foo/bar.txt would return /bar.txt
+ *                      /foo/bar/    would return /bar/
+ *  
+ * @param str String containing the path.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
         const char *start = str.c_str();
         const char *cur = start + str.size() - 2;
@@ -75 +102 @@
         return cur + 1;
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        char buf[MAXPATHLEN];
-        getcwd(buf, MAXPATHLEN);
-        return new POSIXFilesystemNode(buf, true);
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-        return new POSIXFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-        return new POSIXFilesystemNode(path, true);
+void POSIXFilesystemNode::setFlags() {
+        struct stat st;
+        
+        _isValid = (0 == stat(_path.c_str(), &st));
+        _isDirectory = _isValid ? S_ISDIR(st.st_mode) : false;
 }
 
 POSIXFilesystemNode::POSIXFilesystemNode() {
@@ -123 +143 @@
 
         _path = p;
         _displayName = lastPathComponent(_path);
-        _isValid = true;
-        _isDirectory = true;
 
         if (verify) {
-                struct stat st;
-                _isValid = (0 == stat(_path.c_str(), &st));
-                _isDirectory = _isValid ? S_ISDIR(st.st_mode) : false;
+                setFlags();
         }
 }
 
-bool POSIXFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *POSIXFilesystemNode::getChild(const 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);
+        if (_path.lastChar() != '/')
+                newPath += '/';
+        newPath += n;
+        
+        return new POSIXFilesystemNode(newPath, true);
+}
+
+bool POSIXFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
         assert(_isDirectory);
+        
         DIR *dirp = opendir(_path.c_str());
-
         struct dirent *dp;
 
         if (dirp == NULL)
@@ -142 +171 @@
         if (dirp == NULL)
                 return false;
 
-        // ... loop over dir entries using readdir
+        // loop over dir entries using readdir
         while ((dp = readdir(dirp)) != NULL) {
-                // Skip 'invisible' files
-                if (dp->d_name[0] == '.')
+                // Skip 'invisible' files if necessary
+                if (dp->d_name[0] == '.' && !hidden) {
                         continue;
+                }
+                // Skip '.' and '..' to avoid cycles
+                if((dp->d_name[0] == '.' && dp->d_name[1] == 0) || (dp->d_name[0] == '.' && dp->d_name[1] == '.')) {
+                        continue;
+                }
 
                 String newPath(_path);
                 if (newPath.lastChar() != '/')
@@ -156 +190 @@
                 POSIXFilesystemNode entry(newPath, false);
 
 #if defined(SYSTEM_NOT_SUPPORTING_D_TYPE)
-                // TODO: d_type is not part of POSIX, so it might not be supported
-                // on some of our targets. For those systems where it isn't supported,
-                // add this #elif case, which tries to use stat() instead.
-                struct stat st;
-                entry._isValid = (0 == stat(entry._path.c_str(), &st));
-                entry._isDirectory = entry._isValid ? S_ISDIR(st.st_mode) : false;
+                /* TODO: d_type is not part of POSIX, so it might not be supported
+                 * on some of our targets. For those systems where it isn't supported,
+                 * add this #elif case, which tries to use stat() instead.
+                 * 
+                 * The d_type method is used to avoid costly recurrent stat() calls in big
+                 * directories.
+                 */
+                entry.setFlags();
 #else
                 if (dp->d_type == DT_UNKNOWN) {
                         // Fall back to stat()
-                        struct stat st;
-                        entry._isValid = (0 == stat(entry._path.c_str(), &st));
-                        entry._isDirectory = entry._isValid ? S_ISDIR(st.st_mode) : false;
+                        entry.setFlags();
                 } else {
                         entry._isValid = (dp->d_type == DT_DIR) || (dp->d_type == DT_REG) || (dp->d_type == DT_LNK);
                         if (dp->d_type == DT_LNK) {
@@ -194 +228 @@
 
                 if (entry._isDirectory)
                         entry._path += "/";
+                        
                 myList.push_back(new POSIXFilesystemNode(entry));
         }
         closedir(dirp);
+        
         return true;
 }
 
-AbstractFilesystemNode *POSIXFilesystemNode::parent() const {
+AbstractFilesystemNode *POSIXFilesystemNode::getParent() const {
         if (_path == "/")
                 return 0;
 
@@ -207 +243 @@
         const char *start = _path.c_str();
         const char *end = lastPathComponent(_path);
 
-        POSIXFilesystemNode *p = new POSIXFilesystemNode(String(start, end - start), false);
-
-        return p;
-}
-
-AbstractFilesystemNode *POSIXFilesystemNode::child(const 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);
-        if (_path.lastChar() != '/')
-                newPath += '/';
-        newPath += n;
-        POSIXFilesystemNode *p = new POSIXFilesystemNode(newPath, true);
-
-        return p;
+        return new POSIXFilesystemNode(String(start, end - start), true);
 }
 
-#endif // defined(UNIX)
+#endif //#if defined(UNIX)

home/david/Projects/scummvm/backends/fs/ps2/ps2-fs.cpp

@@ -32 +32 @@
 extern AsyncFio fio;
 extern OSystem_PS2 *g_systemPs2;
 
+/**
+ * Implementation of the ScummVM file system API based on the Ps2SDK.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
+ */
 class Ps2FilesystemNode : public AbstractFilesystemNode {
 protected:
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isRoot;
-        String _path;
 
 public:
-        Ps2FilesystemNode(void);
+        /**
+         * Creates a PS2FilesystemNode with the root node as path.
+         */
+        Ps2FilesystemNode();
+        
+        /**
+         * Creates a PS2FilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         */
+        Ps2FilesystemNode(const String &path);
+        
+        /**
+         * Copy constructor.
+         */
         Ps2FilesystemNode(const Ps2FilesystemNode *node);
-        Ps2FilesystemNode(const String &path);
 
-        virtual String displayName() const { return _displayName; }
-        virtual String name() const { return _displayName; }
-        virtual bool isValid() const { return !_isRoot; }
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const { return _displayName; }
+        virtual String getName() const { return _displayName; }
+        virtual String getPath() const { return _path; }
         virtual bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
+        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
+        virtual bool isValid() const { return !_isRoot; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
 
-        //virtual FSList listDir(ListMode) const;
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-        virtual AbstractFilesystemNode *parent() const;
         virtual AbstractFilesystemNode *clone() const { return new Ps2FilesystemNode(this); }
-        virtual AbstractFilesystemNode *child(const String &n) const;
+        virtual AbstractFilesystemNode *getChild(const String &n) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
 };
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot(void) {
-        return new Ps2FilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-        return new Ps2FilesystemNode(path);
-}
-
-Ps2FilesystemNode::Ps2FilesystemNode(void) {
+Ps2FilesystemNode::Ps2FilesystemNode() {
         _isDirectory = true;
         _isRoot = true;
         _displayName = "PlayStation 2";
@@ -108 +116 @@
         _isRoot = node->_isRoot;
 }
 
-bool Ps2FilesystemNode::listDir(AbstractFSList &list, ListMode mode) const {
+AbstractFilesystemNode *Ps2FilesystemNode::getChild(const String &n) const {
+        if (!_isDirectory)
+                return NULL;
+
+        char listDir[256];
+        sprintf(listDir, "%s/", _path.c_str());
+        int fd = fio.dopen(listDir);
+        
+        if (fd >= 0) {
+                iox_dirent_t dirent;
+                
+                while (fio.dread(fd, &dirent) > 0) {
+                        if (strcmp(n.c_str(), dirent.name) == 0) {
+                                Ps2FilesystemNode *dirEntry = new Ps2FilesystemNode();
+
+                                dirEntry->_isDirectory = (bool)(dirent.stat.mode & FIO_S_IFDIR);
+                                dirEntry->_isRoot = false;
+
+                                dirEntry->_path = _path;
+                                dirEntry->_path += "/";
+                                dirEntry->_path += dirent.name;
+
+                                dirEntry->_displayName = dirent.name;
+
+                                fio.dclose(fd);
+                                return dirEntry;
+                        }
+                }
+                fio.dclose(fd);
+        }
+        
+        return NULL;
+}
+
+bool Ps2FilesystemNode::getChildren(AbstractFSList &list, ListMode mode, bool hidden) const {
+        //TODO: honor the hidden flag
+        
         if (!_isDirectory)
                 return false;
 
@@ -135 +179 @@
         } else {
                 char listDir[256];
                 int fd;
+                
                 if (_path.lastChar() == '/')
                         fd = fio.dopen(_path.c_str());
                 else {
@@ -173 +218 @@
         }
 }
 
-AbstractFilesystemNode *Ps2FilesystemNode::parent() const {
+AbstractFilesystemNode *Ps2FilesystemNode::getParent() const {
         if (_isRoot)
                 return new Ps2FilesystemNode(this);
 
@@ -191 +236 @@
         else
                 return new Ps2FilesystemNode();
 }
-
-AbstractFilesystemNode *Ps2FilesystemNode::child(const String &n) const {
-        if (!_isDirectory)
-                return NULL;
-
-        char listDir[256];
-        sprintf(listDir, "%s/", _path.c_str());
-        int fd = fio.dopen(listDir);
-        
-        if (fd >= 0) {
-                iox_dirent_t dirent;
-
-                while (fio.dread(fd, &dirent) > 0) {
-                        if (strcmp(n.c_str(), dirent.name) == 0) {
-                                Ps2FilesystemNode *dirEntry = new Ps2FilesystemNode();
-
-                                dirEntry->_isDirectory = (bool)(dirent.stat.mode & FIO_S_IFDIR);
-                                dirEntry->_isRoot = false;
-
-                                dirEntry->_path = _path;
-                                dirEntry->_path += "/";
-                                dirEntry->_path += dirent.name;
-
-                                dirEntry->_displayName = dirent.name;
-
-                                fio.dclose(fd);
-                                return dirEntry;
-                        }
-                }
-                fio.dclose(fd);
-        }
-        return NULL;
-}

home/david/Projects/scummvm/backends/fs/psp/psp_fs.cpp

@@ -23 +23 @@
  */
 
 #ifdef __PSP__
+
 #include "engines/engine.h"
-
 #include "backends/fs/abstract-fs.h"
 
 #include <sys/stat.h>
@@ -32 +32 @@
 
 #define ROOT_PATH       "ms0:/"
 
-
-/*
+/**
  * Implementation of the ScummVM file system API based on PSPSDK API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class PSPFilesystemNode : public AbstractFilesystemNode {
 protected:
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isValid;
-        String _path;
         
 public:
+        /**
+         * Creates a PSPFilesystemNode with the root node as path.
+         */
         PSPFilesystemNode();
+        
+        /**
+         * Creates a PSPFilesystemNode for a given path.
+         * 
+         * @param path 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 String displayName() const { return _displayName; }
-        virtual String name() const { return _displayName; }
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const { return _displayName; }
+        virtual String getName() const { return _displayName; }
+        virtual 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 isValid() const { return _isValid; }
-        virtual bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
 
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-        virtual AbstractFilesystemNode *parent() const;
-        virtual AbstractFilesystemNode *child(const String &n) const;
+        virtual AbstractFilesystemNode *getChild(const String &n) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
 };
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        return AbstractFilesystemNode::getRoot();
-}
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ *                      /foo/bar.txt would return /bar.txt
+ *                      /foo/bar/    would return /bar/
+ *  
+ * @param str String containing the path.
+ * @return Pointer to the first char of the last component inside str.
+ */
+static const char *lastPathComponent(const Common::String &str) {
+        const char *start = str.c_str();
+        const char *cur = start + str.size() - 2;
 
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-        return new PSPFilesystemNode();
+        while (cur >= start && *cur != '/') {
+                --cur;
+        }
+
+        return cur + 1;
 }
 
 PSPFilesystemNode::PSPFilesystemNode() {
@@ -89 +115 @@
         }       
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-        return new PSPFilesystemNode(path, true);
+AbstractFilesystemNode *PSPFilesystemNode::getChild(const 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);
+        if (_path.lastChar() != '/')
+                newPath += '/';
+        newPath += n;
+
+        return new PSPFilesystemNode(newPath, true);
 }
 
+bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
+        assert(_isDirectory);
 
-bool PSPFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
-        assert(_isDirectory);
+        //TODO: honor the hidden flag
 
         int dfd  = sceIoDopen(_path.c_str());
         if (dfd > 0) {
@@ -133 +169 @@
         }
 }
 
-static const char *lastPathComponent(const Common::String &str) {
-        const char *start = str.c_str();
-        const char *cur = start + str.size() - 2;
-
-        while (cur >= start && *cur != '/') {
-                --cur;
-        }
-
-        return cur + 1;
-}
-
-AbstractFilesystemNode *PSPFilesystemNode::parent() const {
+AbstractFilesystemNode *PSPFilesystemNode::getParent() const {
         assert(_isValid);
         
         if (_path == ROOT_PATH)
@@ -153 +178 @@
         const char *start = _path.c_str();
         const char *end = lastPathComponent(_path);
         
-        PSPFilesystemNode *p = new PSPFilesystemNode(String(start, end - start), false);
-        
-        return p;
+        return new PSPFilesystemNode(String(start, end - start), false);
 }
 
-AbstractFilesystemNode *PSPFilesystemNode::child(const 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);
-        if (_path.lastChar() != '/')
-                newPath += '/';
-        newPath += n;
-        PSPFilesystemNode *p = new PSPFilesystemNode(newPath, true);
-
-        return p;
-}
-
-#endif // PSP
+#endif //#ifdef __PSP__

home/david/Projects/scummvm/backends/fs/symbian/symbian-fs.cpp

@@ -31 +31 @@
 #include <f32file.h>
 #include <bautils.h>
 
-/*
+/**
  * Implementation of the ScummVM file system API based on POSIX.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class SymbianFilesystemNode : public AbstractFilesystemNode {
 protected:
         String _displayName;
+        String _path;
         bool _isDirectory;
         bool _isValid;
-        String _path;
         bool _isPseudoRoot;
 
 public:
+        /**
+         * Creates a SymbianFilesystemNode with the root node as path.
+         * 
+         * @param aIsRoot true if the node will be a pseudo root, false otherwise.
+         */
         SymbianFilesystemNode(bool aIsRoot);
+        
+        /**
+         * Creates a SymbianFilesystemNode for a given path.
+         * 
+         * @param path String with the path the new node should point to.
+         */
         SymbianFilesystemNode(const String &path);
-        virtual String displayName() const { return _displayName; }
-        virtual String name() const { return _displayName; }
+        
+        virtual bool exists() const { return true; }            //FIXME: this is just a stub
+        virtual String getDisplayName() const { return _displayName; }
+        virtual String getName() const { return _displayName; }
+        virtual 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 isValid() const { return _isValid; }
-        virtual bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
+        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
 
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-        virtual AbstractFilesystemNode *parent() const;
-        virtual AbstractFilesystemNode *child(const String &n) const;
+        virtual AbstractFilesystemNode *getChild(const String &n) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
 };
 
-
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ *                      c:\foo\bar.txt would return "\bar.txt"
+ *                      c:\foo\bar\    would return "\bar\"
+ *  
+ * @param str Path to obtain the last component from.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
         const char *start = str.c_str();
         const char *cur = start + str.size() - 2;
@@ -69 +94 @@
         return cur + 1;
 }
 
+/**
+ * Fixes the path by changing all slashes to backslashes.
+ * 
+ * @param path String with the path to be fixed.
+ */
 static void fixFilePath(Common::String& path) {
         TInt len = path.size();
         
@@ -79 +109 @@
         }
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        char path[MAXPATHLEN];
-        getcwd(path, MAXPATHLEN);
-        return new SymbianFilesystemNode(path);
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-        return new SymbianFilesystemNode(true);
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-        return new SymbianFilesystemNode(path);
-}
-
 SymbianFilesystemNode::SymbianFilesystemNode(bool aIsRoot) {
         _path = "";
         _isValid = true;
@@ -128 +144 @@
         }
 }
 
-bool SymbianFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *SymbianFilesystemNode::getChild(const String &n) const {
         assert(_isDirectory);
+        String newPath(_path);
+
+        if (_path.lastChar() != '\\')
+                newPath += '\\';
+        newPath += n;
+
+        TPtrC8 ptr((const unsigned char*) newPath.c_str(), newPath.size());
+        TFileName fname;
+        fname.Copy(ptr);
+        TBool isFolder = EFalse;
+        BaflUtils::IsFolder(CEikonEnv::Static()->FsSession(), fname, isFolder);
+        if(!isFolder)
+                return 0;
+
+        return new SymbianFilesystemNode(newPath);
+}
+
+bool SymbianFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
+        assert(_isDirectory);
+
+        //TODO: honor the hidden flag
 
         if (_isPseudoRoot) {
                 // Drives enumeration
@@ -199 +236 @@
                         }
                         CleanupStack::PopAndDestroy(dirPtr);
                 }
-
         }
+        
         return true;
 }
 
-AbstractFilesystemNode *SymbianFilesystemNode::parent() const {
+AbstractFilesystemNode *SymbianFilesystemNode::getParent() const {
         SymbianFilesystemNode *p =NULL;
 
         // Root node is its own parent. Still we can't just return this
@@ -210 +247 @@
         // Root node is its own parent. Still we can't just return this
         // as the GUI code will call delete on the old node.
         if (!_isPseudoRoot && _path.size() > 3) {
-                p=new SymbianFilesystemNode(false);
+                p = new SymbianFilesystemNode(false);
                 const char *start = _path.c_str();
                 const char *end = lastPathComponent(_path);
 
@@ -221 +258 @@
         }
         else
         {
-                p=new SymbianFilesystemNode(true);
+                p = new SymbianFilesystemNode(true);
         }
-        return p;
-}
-
-AbstractFilesystemNode *SymbianFilesystemNode::child(const String &n) const {
-        assert(_isDirectory);
-        String newPath(_path);
-
-        if (_path.lastChar() != '\\')
-                newPath += '\\';
-        newPath += n;
-
-        TPtrC8 ptr((const unsigned char*) newPath.c_str(), newPath.size());
-        TFileName fname;
-        fname.Copy(ptr);
-        TBool isFolder = EFalse;
-        BaflUtils::IsFolder(CEikonEnv::Static()->FsSession(), fname, isFolder);
-        if(!isFolder)
-                return 0;
-
-        SymbianFilesystemNode *p = new SymbianFilesystemNode(newPath);
+        
         return p;
 }
 
-#endif // defined(__SYMBIAN32__)
+#endif //#if defined (__SYMBIAN32__)

home/david/Projects/scummvm/backends/fs/windows/windows-fs.cpp

@@ -29 +29 @@
 #endif
 #include "common/stdafx.h"
 #include "backends/fs/abstract-fs.h"
+#include <io.h>
 #include <stdio.h>
 #include <stdlib.h>
 #ifndef _WIN32_WCE
@@ -36 +37 @@
 #endif
 #include <tchar.h>
 
-/*
+/**
  * Implementation of the ScummVM file system API based on Windows API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class WindowsFilesystemNode : public AbstractFilesystemNode {
 protected:
         String _displayName;
+        String _path;
         bool _isDirectory;
-        bool _isValid;
         bool _isPseudoRoot;
-        String _path;
+        bool _isValid;
 
 public:
+        /**
+         * Creates a WindowsFilesystemNode with the root node as path.
+         * 
+         * In regular windows systems, a virtual root path is used "".
+         * In windows CE, the "\" root is used instead.
+         */
         WindowsFilesystemNode();
-        WindowsFilesystemNode(const String &path);
-
-        virtual String displayName() const { return _displayName; }
-        virtual String name() const { return _displayName; }
-        virtual bool isValid() const { return _isValid; }
+        
+        /**
+         * Creates a WindowsFilesystemNode for a given path.
+         * 
+         * Examples:
+         *                      path=c:\foo\bar.txt, currentDir=false -> c:\foo\bar.txt
+         *                      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 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);
+        
+        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 bool isDirectory() const { return _isDirectory; }
-        virtual String path() const { return _path; }
+        virtual bool isReadable() const { return _access(_path.c_str(), R_OK) == 0; }
+        virtual bool isValid() const { return _isValid; }
+        virtual bool isWritable() const { return _access(_path.c_str(), W_OK) == 0; }
 
-        virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-        virtual AbstractFilesystemNode *parent() const;
-        virtual AbstractFilesystemNode *child(const String &n) const;
+        virtual AbstractFilesystemNode *getChild(const String &n) const;
+        virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
+        virtual AbstractFilesystemNode *getParent() const;
 
 private:
-        static char *toAscii(TCHAR *x);
-        static const TCHAR* toUnicode(const char *x);
-        static void addFile (AbstractFSList &list, ListMode mode, const char *base, WIN32_FIND_DATA* find_data);
+        /**
+         * Adds a single WindowsFilesystemNode to a given list.
+         * This method is used by getChildren() to populate the directory entries list. 
+         * 
+         * @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 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);
+        
+        /**
+         * Converts a Unicode string to Ascii format.
+         * 
+         * @param str String to convert from Unicode to Ascii.
+         * @return str in Ascii format.
+         */
+        static char *toAscii(TCHAR *str);
+        
+        /**
+         * Converts an Ascii string to Unicode format.
+         * 
+         * @param str String to convert from Ascii to Unicode.
+         * @return str in Unicode format.
+         */
+        static const TCHAR* toUnicode(const char *str);
 };
 
-
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ *                      c:\foo\bar.txt would return "\bar.txt"
+ *                      c:\foo\bar\    would return "\bar\"
+ *  
+ * @param str Path to obtain the last component from.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
         const char *start = str.c_str();
         const char *cur = start + str.size() - 2;
@@ -80 +135 @@
         return cur + 1;
 }
 
-char* WindowsFilesystemNode::toAscii(TCHAR *x) {
-
-#ifndef UNICODE
-        return (char*)x;
-#else
-        static char asciiString[MAX_PATH];
-        WideCharToMultiByte(CP_ACP, 0, x, _tcslen(x) + 1, asciiString, sizeof(asciiString), NULL, NULL);
-        return asciiString;
-#endif
-}
-
-const TCHAR* WindowsFilesystemNode::toUnicode(const char *x) {
-#ifndef UNICODE
-        return (const TCHAR *)x;
-#else
-        static TCHAR unicodeString[MAX_PATH];
-        MultiByteToWideChar(CP_ACP, 0, x, strlen(x) + 1, unicodeString, sizeof(unicodeString) / sizeof(TCHAR));
-        return unicodeString;
-#endif
-}
-
 void WindowsFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const char *base, WIN32_FIND_DATA* find_data) {
         WindowsFilesystemNode entry;
         char *asciiName = toAscii(find_data->cFileName);
@@ -128 +162 @@
         list.push_back(new WindowsFilesystemNode(entry));
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-        char path[MAX_PATH];
-        GetCurrentDirectory(MAX_PATH, path);
-
-        // Add a trailing slash, if necessary.
-        if (path[0] != 0) {
-                if (path[strlen(path) - 1] != '\\')
-                        strcat(path, "\\");
-        }
-
-        return new WindowsFilesystemNode(path);
+char* WindowsFilesystemNode::toAscii(TCHAR *str) {
+#ifndef UNICODE
+        return (char*)str;
+#else
+        static char asciiString[MAX_PATH];
+        WideCharToMultiByte(CP_ACP, 0, str, _tcslen(str) + 1, asciiString, sizeof(asciiString), NULL, NULL);
+        return asciiString;
+#endif
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-        return new WindowsFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-        return new WindowsFilesystemNode(path);
+const TCHAR* WindowsFilesystemNode::toUnicode(const char *str) {
+#ifndef UNICODE
+        return (const TCHAR *)str;
+#else
+        static TCHAR unicodeString[MAX_PATH];
+        MultiByteToWideChar(CP_ACP, 0, str, strlen(str) + 1, unicodeString, sizeof(unicodeString) / sizeof(TCHAR));
+        return unicodeString;
+#endif
 }
 
 WindowsFilesystemNode::WindowsFilesystemNode() {
@@ -165 +198 @@
 #endif
 }
 
-WindowsFilesystemNode::WindowsFilesystemNode(const String &p) {
-        assert(p.size() > 0);
+WindowsFilesystemNode::WindowsFilesystemNode(const String &p, const bool currentDir) {
+        if (currentDir) {
+                char path[MAX_PATH];
+                GetCurrentDirectory(MAX_PATH, path);
 
-        _path = p;
+                // Add a trailing slash, if necessary.
+                if (path[0] != 0) {
+                        if (path[strlen(path) - 1] != '\\')
+                                strcat(path, "\\");
+                }
+                _path = path;
+        }
+        else {
+                assert(p.size() > 0);
+                _path = p;
+        }
+        
         _displayName = lastPathComponent(_path);
 
         // Check whether it is a directory, and whether the file actually exists
@@ -175 +221 @@
         DWORD fileAttribs = GetFileAttributes(toUnicode(_path.c_str()));
 
         if (fileAttribs == INVALID_FILE_ATTRIBUTES) {
+                _isDirectory = false;
                 _isValid = false;
-                _isDirectory = false;
         } else {
+                _isDirectory = ((fileAttribs & FILE_ATTRIBUTE_DIRECTORY) != 0);
                 _isValid = true;
-                _isDirectory = ((fileAttribs & FILE_ATTRIBUTE_DIRECTORY) != 0);
         }
         _isPseudoRoot = false;
 }
@@ -184 +230 @@
         _isPseudoRoot = false;
 }
 
-bool WindowsFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *WindowsFilesystemNode::getChild(const String &n) const {
+        assert(_isDirectory);
+        
+        String newPath(_path);
+        if (_path.lastChar() != '\\')
+                newPath += '\\';
+        newPath += n;
+
+        // Check whether the directory actually exists
+        DWORD fileAttribs = GetFileAttributes(toUnicode(newPath.c_str()));
+        if (fileAttribs == INVALID_FILE_ATTRIBUTES)
+                return 0;
+
+        return new WindowsFilesystemNode(newPath, false);
+}
+
+bool WindowsFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
         assert(_isDirectory);
 
+        //TODO: honor the hidden flag
+
         if (_isPseudoRoot) {
 #ifndef _WIN32_WCE
                 // Drives enumeration
@@ -218 +282 @@
                 sprintf(searchPath, "%s*", _path.c_str());
 
                 handle = FindFirstFile(toUnicode(searchPath), &desc);
+                
                 if (handle == INVALID_HANDLE_VALUE)
                         return false;
+                        
                 addFile(myList, mode, _path.c_str(), &desc);
+                
                 while (FindNextFile(handle, &desc))
                         addFile(myList, mode, _path.c_str(), &desc);
 
@@ -230 +297 @@
         return true;
 }
 
-AbstractFilesystemNode *WindowsFilesystemNode::parent() const {
+AbstractFilesystemNode *WindowsFilesystemNode::getParent() const {
         assert(_isValid || _isPseudoRoot);
+        
         if (_isPseudoRoot)
                 return 0;
+                
         WindowsFilesystemNode *p = new WindowsFilesystemNode();
         if (_path.size() > 3) {
                 const char *start = _path.c_str();
@@ -246 +315 @@
                 p->_displayName = lastPathComponent(p->_path);
                 p->_isPseudoRoot = false;
         }
+        
         return p;
 }
 
-AbstractFilesystemNode *WindowsFilesystemNode::child(const String &n) const {
-        assert(_isDirectory);
-        String newPath(_path);
-        if (_path.lastChar() != '\\')
-                newPath += '\\';
-        newPath += n;
-
-        // Check whether the directory actually exists
-        DWORD fileAttribs = GetFileAttributes(toUnicode(newPath.c_str()));
-        if (fileAttribs == INVALID_FILE_ATTRIBUTES)
-                return 0;
-
-        WindowsFilesystemNode *p = new WindowsFilesystemNode(newPath);
-        return p;
-}
-
-#endif // WIN32
+#endif //#ifdef WIN32

home/david/Projects/scummvm/backends/plugins/dc/dc-provider.cpp

@@ -114 +114 @@
         // Scan for all plugins in this directory
         FilesystemNode dir(PLUGIN_DIRECTORY);
         FSList files;
-        if (!dir.listDir(files, FilesystemNode::kListFilesOnly)) {
+        if (!dir.getChildren(files, FilesystemNode::kListFilesOnly)) {
                 error("Couldn't open plugin directory '%s'", PLUGIN_DIRECTORY);
         }
 
@@ -119 +119 @@
         }
 
         for (FSList::const_iterator i = files.begin(); i != files.end(); ++i) {
-                Common::String name(i->name());
+                Common::String name(i->getName());
                 if (name.hasPrefix(PLUGIN_PREFIX) && name.hasSuffix(PLUGIN_SUFFIX)) {
-                        pl.push_back(new DCPlugin(i->path()));
+                        pl.push_back(new DCPlugin(i->getPath()));
                 }
         }
         

home/david/Projects/scummvm/backends/plugins/posix/posix-provider.cpp

@@ -107 +107 @@
         // Scan for all plugins in this directory
         FilesystemNode dir(PLUGIN_DIRECTORY);
         FSList files;
-        if (!dir.listDir(files, FilesystemNode::kListFilesOnly)) {
+        if (!dir.getChildren(files, FilesystemNode::kListFilesOnly)) {
                 error("Couldn't open plugin directory '%s'", PLUGIN_DIRECTORY);
         }
 
@@ -112 +112 @@
         }
 
         for (FSList::const_iterator i = files.begin(); i != files.end(); ++i) {
-                Common::String name(i->name());
+                Common::String name(i->getName());
                 if (name.hasPrefix(PLUGIN_PREFIX) && name.hasSuffix(PLUGIN_SUFFIX)) {
-                        pl.push_back(new POSIXPlugin(i->path()));
+                        pl.push_back(new POSIXPlugin(i->getPath()));
                 }
         }
         

home/david/Projects/scummvm/backends/plugins/sdl/sdl-provider.cpp

@@ -107 +107 @@
         // Scan for all plugins in this directory
         FilesystemNode dir(PLUGIN_DIRECTORY);
         FSList files;
-        if (!dir.listDir(files, FilesystemNode::kListFilesOnly)) {
+        if (!dir.getChildren(files, FilesystemNode::kListFilesOnly)) {
                 error("Couldn't open plugin directory '%s'", PLUGIN_DIRECTORY);
         }
 
@@ -112 +112 @@
         }
 
         for (FSList::const_iterator i = files.begin(); i != files.end(); ++i) {
-                Common::String name(i->name());
+                Common::String name(i->getName());
                 if (name.hasPrefix(PLUGIN_PREFIX) && name.hasSuffix(PLUGIN_SUFFIX)) {
-                        pl.push_back(new SDLPlugin(i->path()));
+                        pl.push_back(new SDLPlugin(i->getPath()));
                 }
         }
         

home/david/Projects/scummvm/backends/plugins/win32/win32-provider.cpp

@@ -110 +110 @@
         // Scan for all plugins in this directory
         FilesystemNode dir(PLUGIN_DIRECTORY);
         FSList files;
-        if (!dir.listDir(files, FilesystemNode::kListFilesOnly)) {
+        if (!dir.getChildren(files, FilesystemNode::kListFilesOnly)) {
                 error("Couldn't open plugin directory '%s'", PLUGIN_DIRECTORY);
         }
 
@@ -115 +115 @@
         }
 
         for (FSList::const_iterator i = files.begin(); i != files.end(); ++i) {
-                Common::String name(i->name());
+                Common::String name(i->getName());
                 if (name.hasPrefix(PLUGIN_PREFIX) && name.hasSuffix(PLUGIN_SUFFIX)) {
-                        pl.push_back(new Win32Plugin(i->path()));
+                        pl.push_back(new Win32Plugin(i->getPath()));
                 }
         }
         

home/david/Projects/scummvm/backends/saves/default/default-saves.cpp

@@ -28 +28 @@
 #include "common/stdafx.h"
 #include "common/savefile.h"
 #include "common/util.h"
+#include "common/fs.h"
+#include "common/file.h"
 #include "backends/saves/default/default-saves.h"
 #include "backends/saves/compressed/compressed-saves.h"
 
@@ -119 +121 @@
         // Ensure that the savepath exists and is writeable. If not, generate
         // an appropriate error
         const char *savePath = getSavePath();
+        
 #if defined(UNIX) || defined(__SYMBIAN32__)
         struct stat sb;
+        clearError();
         
         // Check whether the dir exists
         if (stat(savePath, &sb) == -1) {
@@ -126 +130 @@
         if (stat(savePath, &sb) == -1) {
                 // The dir does not exist, or stat failed for some other reason.
                 // If the problem was that the path pointed to nothing, try
-                // to create the dir.
-                if (errno == ENOENT) {
+                // to create the dir (ENOENT case).
+                switch (errno) {
+                case EACCES:
+                        setError(SFM_DIR_ACCESS, Common::String("Search or write permission denied"));
+                        break;
+                case ELOOP:
+                        setError(SFM_DIR_LOOP, Common::String("Too many symbolic links encountered while traversing the path"));
+                        break;
+                case ENAMETOOLONG:
+                        setError(SFM_DIR_NAMETOOLONG, Common::String("The path name is too long"));
+                        break;
+                case ENOENT:
                         if (mkdir(savePath, 0755) != 0) {
                                 // mkdir could fail for various reasons: The parent dir doesn't exist,
                                 // or is not writeable, the path could be completly bogus, etc.
@@ -133 +147 @@
                                 // or is not writeable, the path could be completly bogus, etc.
                                 warning("mkdir for '%s' failed!", savePath);
                                 perror("mkdir");
-                                // TODO: Specify an error code here so that callers can 
-                                // determine what exactly went wrong.
+                                
+                                switch (errno) {
+                                case EACCES:
+                                        setError(SFM_DIR_ACCESS, Common::String("Search or write permission denied"));
+                                        break;
+                                case EMLINK:
+                                        setError(SFM_DIR_LINKMAX, Common::String("The link count of the parent directory would exceed {LINK_MAX}"));
+                                        break;
+                                case ELOOP:
+                                        setError(SFM_DIR_LOOP, Common::String("Too many symbolic links encountered while traversing the path"));
+                                        break;
+                                case ENAMETOOLONG:
+                                        setError(SFM_DIR_NAMETOOLONG, Common::String("The path name is too long"));
+                                        break;
+                                case ENOENT:
+                                        setError(SFM_DIR_NOENT, Common::String("A component of the path path does not exist, or the path is an empty string"));
+                                        break;
+                                case ENOTDIR:
+                                        setError(SFM_DIR_NOTDIR, Common::String("A component of the path prefix is not a directory"));
+                                        break;
+                                case EROFS:
+                                        setError(SFM_DIR_ROFS, Common::String("The parent directory resides on a read-only file system"));
+                                        break;
+                                }
+                                
                                 return 0;
                         }
-                } else {
-                        // Unknown error, abort.
-                        // TODO: Specify an error code here so that callers can 
-                        // determine what exactly went wrong.
-                        return 0;
-                }
+                        break;
+                case ENOTDIR:
+                        setError(SFM_DIR_NOTDIR, Common::String("A component of the path prefix is not a directory"));
+                        break;
+                } 
         } else {
-                // So stat() succeeded. But is the path actually pointing to a
-                // directory?
+                // So stat() succeeded. But is the path actually pointing to a directory?
                 if (!S_ISDIR(sb.st_mode)) {
-                        // TODO: Specify an error code here so that callers can 
-                        // determine what exactly went wrong.
+                        setError(SFM_DIR_NOTDIR, Common::String("The given savepath is not a directory"));
+                        
                         return 0;
                 }
         }
@@ -163 +198 @@
                 delete sf;
                 sf = 0;
         }
+        
         return wrapOutSaveFile(sf);
 }
 
@@ -179 +215 @@
         return wrapInSaveFile(sf);
 }
 
-void DefaultSaveFileManager::listSavefiles(const char * /* prefix */, bool *marks, int num) {
-        // TODO: Implement this properly, at least on systems that support
-        // opendir/readdir.
-        // Even better, replace this with a better design...
-        memset(marks, true, num * sizeof(bool));
+bool DefaultSaveFileManager::removeSavefile(const char *filename) {
+        Common::File file;
+        FilesystemNode savePath(filename);
+        return file.remove(savePath);
+}
+
+Common::StringList DefaultSaveFileManager::listSavefiles(const char *regex) {
+        FilesystemNode savePath(getSavePath());
+        FSList savefiles;
+        Common::StringList results;
+        Common::String search(regex);
+        
+        if(savePath.lookupFile(savefiles, savePath, search, false, true)) {
+                for(FSList::const_iterator file = savefiles.begin(); file != savefiles.end(); file++) {
+                        results.push_back(file->getPath());
+                }
+        }
+                                
+        return results;
 }
 
 #endif // !defined(DISABLE_DEFAULT_SAVEFILEMANAGER)

home/david/Projects/scummvm/backends/saves/default/default-saves.h

@@ -28 +28 @@
 
 #include "common/stdafx.h"
 #include "common/savefile.h"
+#include "common/str.h"
 
 class DefaultSaveFileManager : public Common::SaveFileManager {
 public:
@@ -33 +34 @@
 public:
         virtual Common::OutSaveFile *openForSaving(const char *filename);
         virtual Common::InSaveFile *openForLoading(const char *filename);
-        virtual void listSavefiles(const char * /* prefix */, bool *marks, int num);
+        virtual bool removeSavefile(const char *filename);
+        virtual Common::StringList listSavefiles(const char *regex);
 };
 
 #endif

home/david/Projects/scummvm/base/commandLine.cpp

@@ -32 +32 @@
 
 #include "common/config-manager.h"
 #include "common/system.h"
+#include "common/fs.h"
 
 #include "sound/mididrv.h"
 #include "sound/mixer.h"
@@ -48 +49 @@
 
 #define DETECTOR_TESTING_HACK
 
-#ifdef DETECTOR_TESTING_HACK
-#include "common/fs.h"
-#endif
-
 namespace Base {
 
 static const char USAGE_STRING[] =
@@ -313 +310 @@
         for (int i = 1; i < argc; ++i) {
                 s = argv[i];
                 s2 = (i < argc-1) ? argv[i+1] : 0;
-
+                
                 if (s[0] != '-') {
                         // The argument doesn't start with a dash, so it's not an option.
                         // Hence it must be the target name. We currently enforce that
@@ -390 +387 @@
                         END_OPTION
 
                         DO_OPTION('p', "path")
-                                // TODO: Verify whether the path is valid
+                                FilesystemNode path(option);
+                                if(!path.exists()) {
+                                        usage("Non-existent game path '%s'", option);
+                                } else if(!path.isReadable()) {
+                                        usage("Non-readable game path '%s'", option);
+                                }
                         END_OPTION
 
                         DO_OPTION('q', "language")
@@ -428 +430 @@
                         END_OPTION
 
                         DO_LONG_OPTION("soundfont")
-                                // TODO: Verify whether the path is valid
+                                FilesystemNode path(option);
+                                if(!path.exists()) {
+                                        usage("Non-existent soundfont path '%s'", option);
+                                } else if(!path.isReadable()) {
+                                        usage("Non-readable soundfont path '%s'", option);
+                                }
                         END_OPTION
 
                         DO_LONG_OPTION_BOOL("disable-sdl-parachute")
@@ -453 +460 @@
                         END_OPTION
 
                         DO_LONG_OPTION("savepath")
-                                // TODO: Verify whether the path is valid
+                                FilesystemNode path(option);
+                                if(!path.exists()) {
+                                        usage("Non-existent savegames path '%s'", option);
+                                } else if(!path.isWritable()) {
+                                        usage("Non-writable savegames path '%s'", option);
+                                }
                         END_OPTION
 
                         DO_LONG_OPTION_INT("talkspeed")
@@ -466 +478 @@
                         END_OPTION
 
                         DO_LONG_OPTION("themepath")
-                                // TODO: Verify whether the path is valid
+                                FilesystemNode path(option);
+                                if(!path.exists()) {
+                                        usage("Non-existent theme path '%s'", option);
+                                } else if(!path.isReadable()) {
+                                        usage("Non-readable theme path '%s'", option);
+                                }
                         END_OPTION
 
                         DO_LONG_OPTION("target-md5")
@@ -562 +579 @@
                 
                 FilesystemNode dir(path);
                 FSList files;
-                if (!dir.listDir(files, FilesystemNode::kListAll)) {
+                if (!dir.getChildren(files, FilesystemNode::kListAll)) {
                         printf(" ... invalid path, skipping\n");
                         continue;
                 }
@@ -673 +690 @@
         if (!settings.contains("savepath")) {
                 const char *dir = getenv("SCUMMVM_SAVEPATH");
                 if (dir && *dir && strlen(dir) < MAXPATHLEN) {
-                        // TODO: Verify whether the path is valid
-                        settings["savepath"] = dir;
+                        FilesystemNode saveDir(dir);
+                        if(!saveDir.exists()) {
+                                warning("Non-existent SCUMMVM_SAVEPATH save path. It will be ignored.");
+                        } else if(!saveDir.isWritable()) {
+                                warning("Non-writable SCUMMVM_SAVEPATH save path. It will be ignored.");
+                        } else {
+                                settings["savepath"] = dir;
+                        }
                 }
         }
 #endif
@@ -679 +702 @@
         }
 #endif
 
-
         // Finally, store the command line settings into the config manager.
         for (Common::StringMap::const_iterator x = settings.begin(); x != settings.end(); ++x) {
                 Common::String key(x->_key);

home/david/Projects/scummvm/common/advancedDetector.cpp

@@ -276 +276 @@
 
         FSList fslist;
         FilesystemNode dir(ConfMan.get("path"));
-        if (!dir.listDir(fslist, FilesystemNode::kListFilesOnly)) {
+        if (!dir.getChildren(fslist, FilesystemNode::kListFilesOnly)) {
                 return kInvalidPathError;
         }
 
@@ -345 +345 @@
                 // Get the information of the existing files
                 for (FSList::const_iterator file = fslist->begin(); file != fslist->end(); ++file) {
                         if (file->isDirectory()) continue;
-                        tstr = file->name();
+                        tstr = file->getName();
                         tstr.toLowercase();
 
                         // Strip any trailing dot
@@ -364 +364 @@
 
                         debug(3, "> %s: %s", tstr.c_str(), md5str);
 
-                        if (testFile.open(file->path())) {
+                        if (testFile.open(file->getPath())) {
                                 filesSize[tstr] = (int32)testFile.size();
                                 testFile.close();
                         }

home/david/Projects/scummvm/common/file.cpp

@@ -28 +28 @@
 #include "common/hashmap.h"
 #include "common/util.h"
 #include "common/hash-str.h"
+#include <errno.h>
 
 #ifdef MACOSX
 #include "CoreFoundation/CoreFoundation.h"
@@ -226 +227 @@
                 return;
 
         FSList fslist;
-        if (!dir.listDir(fslist, FilesystemNode::kListAll)) {
+        if (!dir.getChildren(fslist, FilesystemNode::kListAll)) {
                 // Failed listing the contents of this node, so it is either not a 
                 // directory, or just doesn't exist at all.
                 return;
@@ -237 +238 @@
 
         // Do not add directories multiple times, unless this time they are added
         // with a bigger depth.
-        const String &directory(dir.path());
+        const String &directory(dir.getPath());
         if (_defaultDirectories->contains(directory) && (*_defaultDirectories)[directory] >= level)
                 return;
         (*_defaultDirectories)[directory] = level;
@@ -247 +248 @@
 
         for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
                 if (file->isDirectory()) {
-                        addDefaultDirectoryRecursive(file->path(), level - 1, prefix + file->name() + "/");
+                        addDefaultDirectoryRecursive(file->getPath(), level - 1, prefix + file->getName() + "/");
                 } else {
                         String lfn(prefix);
-                        lfn += file->name();
+                        lfn += file->getName();
                         lfn.toLowercase();
                         if (!_filesMap->contains(lfn)) {
-                                (*_filesMap)[lfn] = file->path();
+                                (*_filesMap)[lfn] = file->getPath();
                         }
                 }
         }
@@ -364 +365 @@
 bool File::open(const FilesystemNode &node, AccessMode mode) {
         assert(mode == kFileReadMode || mode == kFileWriteMode);
 
-        if (!node.isValid()) {
-                warning("File::open: Trying to open an invalid FilesystemNode object");
+        if (!node.exists()) {
+                warning("File::open: Trying to open a FilesystemNode which does not exist");
                 return false;
         } else if (node.isDirectory()) {
                 warning("File::open: Trying to open a FilesystemNode which is a directory");
@@ -370 +371 @@
         } else if (node.isDirectory()) {
                 warning("File::open: Trying to open a FilesystemNode which is a directory");
                 return false;
-        }
+        } /*else if (!node.isReadable() && mode == kFileReadMode) {
+                warning("File::open: Trying to open an unreadable FilesystemNode object for reading");
+                return false;
+        } else if (!node.isWritable() && mode == kFileWriteMode) {
+                warning("File::open: Trying to open an unwritable FilesystemNode object for writing");
+                return false;
+        }*/
 
-        String filename(node.name());
+        String filename(node.getName());
 
         if (_handle) {
                 error("File::open: This file object already is opened (%s), won't open '%s'", _name.c_str(), filename.c_str());
@@ -383 +390 @@
 
         const char *modeStr = (mode == kFileReadMode) ? "rb" : "wb";
 
-        _handle = fopen(node.path().c_str(), modeStr);
+        _handle = fopen(node.getPath().c_str(), modeStr);
 
         if (_handle == NULL) {
                 if (mode == kFileReadMode)
@@ -402 +409 @@
         return true;
 }
 
+bool File::remove(const String &filename){
+        if (remove(filename.c_str()) != 0) {
+                if(errno == EACCES)
+                        ;//TODO: read-only file
+                if(errno == ENOENT)
+                        ;//TODO: non-existent file
+                
+                return false;
+        } else {
+                return true;
+        }
+}
+
+bool File::remove(const FilesystemNode &node){
+        if (remove(node.getPath()) != 0) {
+                if(errno == EACCES)
+                        ;//TODO: read-only file
+                if(errno == ENOENT)
+                        ;//TODO: non-existent file
+                                
+                return false;
+        } else {
+                return true;
+        }
+}
+
 bool File::exists(const String &filename) {
         // First try to find the file it via a FilesystemNode (in case an absolute
         // path was passed). But we only use this to filter out directories.
@@ -406 +439 @@
         // First try to find the file it via a FilesystemNode (in case an absolute
         // path was passed). But we only use this to filter out directories.
         FilesystemNode file(filename);
-        // FIXME: can't use isValid() here since at the time of writing
-        // FilesystemNode is to be unable to find for example files
-        // added in extrapath
-        if (file.isDirectory())
-                return false;
-
+        
+        return (!file.isDirectory() && file.exists());
+        
+        //***DEPRECATED COMMENTS BELOW, LEFT FOR DISCUSSION***
         // Next, try to locate the file by *opening* it in read mode. This has
         // multiple effects:
         // 1) It takes _filesMap and _defaultDirectories into consideration -> good

home/david/Projects/scummvm/common/file.h

@@ -52 +52 @@
         // code that accidentally copied File objects tended to break in strange
         // ways.
         File(const File &f);
-        File &operator  =(const File &f);
+        File &operator =(const File &f);
 
 public:
         enum AccessMode {
@@ -86 +86 @@
 
         virtual void close();
 
+        virtual bool remove(const String &filename);
+        virtual bool remove(const FilesystemNode &node);
+        
         /**
          * Checks if the object opened a file successfully.
          *

home/david/Projects/scummvm/common/fs.cpp

@@ -23 +23 @@
  */
 
 #include "common/stdafx.h"
-
-#include "backends/fs/abstract-fs.h"
 #include "common/util.h"
+#include "backends/fs/abstract-fs.h"
+#include "backends/factories/fs-factory-maker.cpp"
 
+/*
+ * Simple DOS-style pattern matching function (understands * and ? like used in DOS).
+ * Taken from exult/files/listfiles.cc
+ */
+static bool matchString(const char *str, const char *pat) {
+        const char *p = 0;
+        const char *q = 0;
+        
+        for (;;) {
+                switch (*pat) {
+                case '*':
+                        p = ++pat;
+                        q = str;
+                        break;
 
-FilesystemNode::FilesystemNode(AbstractFilesystemNode *realNode) {
-        _realNode = realNode;
-        _refCount = new int(1);
+                default:
+                        if (*pat != *str) {
+                                if (p) {
+                                        pat = p;
+                                        str = ++q;
+                                        if(!*str)
+                                                return !*pat;
+                                        break;
+                                }
+                                else
+                                        return false;
+                        }
+                        // fallthrough
+                case '?':
+                        if(!*str)
+                                return !*pat;
+                        pat++;
+                        str++;
+                }
+        }
 }
 
 FilesystemNode::FilesystemNode() {
@@ -38 +69 @@
         _refCount = 0;
 }
 
+FilesystemNode::FilesystemNode(AbstractFilesystemNode *realNode) {
+        _realNode = realNode;
+        _refCount = new int(1);
+}
+
 FilesystemNode::FilesystemNode(const FilesystemNode &node) {
         _realNode = node._realNode;
         _refCount = node._refCount;
@@ -46 +82 @@
 }
 
 FilesystemNode::FilesystemNode(const Common::String &p) {
+        AbstractFilesystemFactory *factory = FilesystemFactoryMaker::makeFactory();
+        
         if (p.empty() || p == ".")
-                _realNode = AbstractFilesystemNode::getCurrentDirectory();
+                _realNode = factory->makeCurrentDirectoryFileNode();
         else
-                _realNode = AbstractFilesystemNode::getNodeForPath(p);
+                _realNode = factory->makeFileNodePath(p);
         _refCount = new int(1);
 }
 
@@ -57 +95 @@
         decRefCount();
 }
 
-void FilesystemNode::decRefCount() {
-        if (_refCount) {
-                assert(*_refCount > 0);
-                --(*_refCount);
-                if (*_refCount == 0) {
-                        delete _refCount;
-                        delete _realNode;
-                }
-        }
-}
-
-FilesystemNode &FilesystemNode::operator  =(const FilesystemNode &node) {
+FilesystemNode &FilesystemNode::operator= (const FilesystemNode &node) {
         if (node._refCount)
                 ++(*node._refCount);
 
@@ -80 +107 @@
         return *this;
 }
 
-bool FilesystemNode::isValid() const {
-        if (_realNode == 0)
+bool FilesystemNode::operator< (const FilesystemNode& node) const
+{
+        if (isDirectory() && !node.isDirectory())
+                return true;
+        if (!isDirectory() && node.isDirectory())
                 return false;
-        return _realNode->isValid();
+        return scumm_stricmp(getDisplayName().c_str(), node.getDisplayName().c_str()) < 0;
 }
 
-FilesystemNode FilesystemNode::getParent() const {
-        if (_realNode == 0)
-                return *this;
+void FilesystemNode::decRefCount() {
+        if (_refCount) {
+                assert(*_refCount > 0);
+                --(*_refCount);
+                if (*_refCount == 0) {
+                        delete _refCount;
+                        delete _realNode;
+                }
+        }
+}
 
-        AbstractFilesystemNode *node = _realNode->parent();
-        if (node == 0) {
-                return *this;
-        } else {
-                return FilesystemNode(node);
-        }
+bool FilesystemNode::exists() const {
+        if (_realNode == 0)
+                return false;
+        return _realNode->exists();
 }
 
 FilesystemNode FilesystemNode::getChild(const Common::String &n) const {
@@ -103 +138 @@
                 return *this;
 
         assert(_realNode->isDirectory());
-        AbstractFilesystemNode *node = _realNode->child(n);
+        AbstractFilesystemNode *node = _realNode->getChild(n);
         return FilesystemNode(node);
 }
 
-bool FilesystemNode::listDir(FSList &fslist, ListMode mode) const {
+bool FilesystemNode::getChildren(FSList &fslist, ListMode mode, bool hidden) const {
         if (!_realNode || !_realNode->isDirectory())
                 return false;
 
@@ -113 +148 @@
 
         AbstractFSList tmp;
         
-        if (!_realNode->listDir(tmp, mode))
+        if (!_realNode->getChildren(tmp, mode, hidden))
                 return false;
         
         fslist.clear();
@@ -124 +159 @@
         return true;
 }
 
+Common::String FilesystemNode::getDisplayName() const {
+        assert(_realNode);
+        return _realNode->getDisplayName();
+}
+
+Common::String FilesystemNode::getName() const {
+        assert(_realNode);
+        return _realNode->getName();
+}
+
+FilesystemNode FilesystemNode::getParent() const {
+        if (_realNode == 0)
+                return *this;
+
+        AbstractFilesystemNode *node = _realNode->getParent();
+        if (node == 0) {
+                return *this;
+        } else {
+                return FilesystemNode(node);
+        }
+}
+
+Common::String FilesystemNode::getPath() const {
+        assert(_realNode);
+        return _realNode->getPath();
+}
+
 bool FilesystemNode::isDirectory() const {
         if (_realNode == 0)
                 return false;
@@ -130 +192 @@
         return _realNode->isDirectory();
 }
 
-Common::String FilesystemNode::displayName() const {
-        assert(_realNode);
-        return _realNode->displayName();
+bool FilesystemNode::isReadable() const {
+        if (_realNode == 0)
+                return false;
+        return _realNode->isReadable();
 }
 
-Common::String FilesystemNode::name() const {
-        assert(_realNode);
-        return _realNode->name();
+bool FilesystemNode::isWritable() const {
+        if (_realNode == 0)
+                return false;
+        return _realNode->isWritable();
 }
 
-Common::String FilesystemNode::path() const {
-        assert(_realNode);
-        return _realNode->path();
+bool FilesystemNode::lookupFile(FSList &results, FSList &fslist, Common::String &filename, bool hidden, bool exhaustive) const
+{
+        for(FSList::iterator entry = fslist.begin(); entry != fslist.end(); ++entry)
+        {
+                if(entry->isDirectory()) {
+                        lookupFileRec(results, *entry, filename, hidden, exhaustive);
+                }
+        }
+        
+        //TODO: we would return true even if no matches were found, if the initial results list isn't empty
+        return ((results.size() > 0) ? true : false);
 }
 
+bool FilesystemNode::lookupFile(FSList &results, FilesystemNode &dir, Common::String &filename, bool hidden, bool exhaustive) const
+{
+        lookupFileRec(results, dir, filename, hidden, exhaustive);
+        
+        //TODO: we would return true even if no matches were found, if the initial results list isn't empty
+        return ((results.size() > 0) ? true : false);
+}
 
-bool FilesystemNode::operator< (const FilesystemNode& node) const
+void FilesystemNode::lookupFileRec(FSList &results, FilesystemNode &dir, Common::String &filename, bool hidden, bool exhaustive) const
 {
-        if (isDirectory() && !node.isDirectory())
-                return true;
-        if (!isDirectory() && node.isDirectory())
-                return false;
-        return scumm_stricmp(displayName().c_str(), node.displayName().c_str()) < 0;
+        FSList entries;
+        dir.getChildren(entries, FilesystemNode::kListAll, hidden);
+        
+        for(FSList::iterator entry = entries.begin(); entry != entries.end(); ++entry)
+        {
+                if(entry->isDirectory()) {
+                        lookupFileRec(results, *entry, filename, hidden, exhaustive);
+                } else {
+                        //TODO: here we assume all backends implement the lastPathComponent method. It is currently static,
+                        //              so it might be a good idea to include it inside the backend class. This would enforce its
+                        //              implementation by all ports.
+                        if(matchString(lastPathComponent(entry->getPath()), filename.c_str())) {
+                                results.push_back(*entry);
+                                
+                                if(!exhaustive) {
+                                        break;
+                                }
+                        }
+                }
+        }
 }

home/david/Projects/scummvm/common/fs.h

@@ -33 +33 @@
 class FilesystemNode;
 class AbstractFilesystemNode;
 
-
 /**
  * List of multiple file system nodes. E.g. the contents of a given directory.
  * This is subclass instead of just a typedef so that we can use forward
@@ -41 +40 @@
  */
 class FSList : public Common::Array<FilesystemNode> {};
 
-
 /**
- * FilesystemNode provides an abstraction for file pathes, allowing for portable
+ * FilesystemNode provides an abstraction for file paths, allowing for portable
  * file system browsing. To this ends, multiple or single roots have to be supported
  * (compare Unix with a single root, Windows with multiple roots C:, D:, ...).
  *
@@ -67 +65 @@
  */
 class FilesystemNode {
 private:
+        int *_refCount;
         AbstractFilesystemNode *_realNode;
-        int *_refCount;
-
         FilesystemNode(AbstractFilesystemNode *realNode);
 
 public:
@@ -113 +110 @@
         /**
          * Copy operator.
          */
-        FilesystemNode &operator  =(const FilesystemNode &node);
-
+        FilesystemNode &operator= (const FilesystemNode &node);
+        
         /**
-         * Checks if the FilesystemNode is valid for any usage
+         * Compare the name of this node to the name of another. Directories
+         * go before normal files.
          */
-        bool isValid() const;
+        bool operator< (const FilesystemNode& node) const;
 
-        /**
-         * Get the parent node of this node. If this node has no parent node,
-         * then it returns a duplicate of this node.
+        /*
+         * Indicates whether the object refered by this path exists in the filesystem or not.
          */
-        FilesystemNode getParent() const;
+        virtual bool exists() const;
 
         /**
          * Fetch a child node of this node, with the given name. Only valid for
-         * directory nodes (an assertion is triggered otherwise). If no no child
-         * node with the given name exists, an invalid node is returned.
+         * directory nodes (an assertion is triggered otherwise).
+         * If no child node with the given name exists, an invalid node is returned.
          */
         FilesystemNode getChild(const Common::String &name) const;
-
+        
         /**
          * Return a list of child nodes of this directory node. If called on a node
          * that does not represent a directory, false is returned.
+         * 
          * @return true if succesful, false otherwise (e.g. when the directory does not exist).
-         * @todo Rename this to listChildren or getChildren.
-         */
-        virtual bool listDir(FSList &fslist, ListMode mode = kListDirectoriesOnly) const;
-
-        /**
-         * Is this node pointing to a directory?
-         * @todo Currently we assume that a valid node that is not a directory
-         * automatically is a file (ignoring things like symlinks). That might
-         * actually be OK... but we could still add an isFile method. Or even replace
-         * isValid and isDirectory by a getType() method that can return values like
-         * kDirNodeType, kFileNodeType, kInvalidNodeType.
          */
-        virtual bool isDirectory() const;
+        virtual bool getChildren(FSList &fslist, ListMode mode = kListDirectoriesOnly, bool hidden = false) const;      
 
         /**
          * Return a human readable string for this node, usable for display (e.g.
@@ -155 +142 @@
          * Return a human readable string for this node, usable for display (e.g.
          * in the GUI code). Do *not* rely on it being usable for anything else,
          * like constructing paths!
+         * 
          * @return the display name
          */
-        virtual Common::String displayName() const;
+        virtual Common::String getDisplayName() const;
 
         /**
          * Return a string representation of the name of the file. This is can be
@@ -167 +155 @@
          *
          * @return the file name
          */
-        virtual Common::String name() const;
+        virtual Common::String getName() const;
 
         /**
          * Return a string representation of the file which can be passed to fopen(),
@@ -180 +168 @@
          *
          * @return the 'path' represented by this filesystem node
          */
-        virtual Common::String path() const;
+        virtual Common::String getPath() const;
+        
+        /**
+         * Get the parent node of this node. If this node has no parent node,
+         * then it returns a duplicate of this node.
+         */
+        FilesystemNode getParent() const;
 
         /**
-         * Compare the name of this node to the name of another. Directories
-         * go before normal files.
+         * Indicates whether this path refers to a directory or not.
+         * 
+         * @todo Currently we assume that a valid node that is not a directory
+         * automatically is a file (ignoring things like symlinks). That might
+         * actually be OK... but we could still add an isFile method. Or even replace
+         * isValid and isDirectory by a getType() method that can return values like
+         * kDirNodeType, kFileNodeType, kInvalidNodeType.
          */
-        bool operator< (const FilesystemNode& node) const;
+        virtual bool isDirectory() const;
+        
+        /**
+         * Indicates whether this path can be read from or not.
+         */
+        virtual bool isReadable() const;
+        
+        /**
+         * Indicates whether this path can be written to or not.
+         */
+        virtual bool isWritable() const;
+        
+        /**
+         * Searches recursively for a filename inside the given directories.
+         * 
+         * @param results List to put the matches in.
+         * @param fslist List of directories to search within.
+         * @param filename Name of the file to look for.
+         * @param hidden Whether to search hidden files or not. Default: false
+         * @param exhaustive Whether to continue searching after one match has been found. Default: false
+         * 
+         * @return true if matches could be found, false otherwise.
+         */
+        virtual bool lookupFile(FSList &results, FSList &fslist, Common::String &filename, bool hidden, bool exhaustive) const;
+        
+        /**
+         * Searches recursively for a filename inside the given directory.
+         * 
+         * @param results List to put the matches in.
+         * @param FilesystemNode Directory to search within.
+         * @param filename Name of the file to look for.
+         * @param hidden Whether to search hidden files or not. Default: false
+         * @param exhaustive Whether to continue searching after one match has been found. Default: false
+         * 
+         * @return true if matches could be found, false otherwise.
+         */
+        virtual bool lookupFile(FSList &results, FilesystemNode &dir, Common::String &filename, bool hidden, bool exhaustive) const;
 
 protected:
+        /**
+         * Decreases the reference count to the FilesystemNode, and if necessary,
+         * deletes the corresponding underlying references.
+         */
         void decRefCount();
+        
+        /**
+         * Searches recursively for a filename inside the given directory.
+         * 
+         * @param results List to put the matches in.
+         * @param FilesystemNode Directory to search within.
+         * @param filename Name of the file to look for.
+         * @param hidden Whether to search hidden files or not.
+         * @param exhaustive Whether to continue searching after one match has been found.
+         */
+        void lookupFileRec(FSList &results, FilesystemNode &dir, Common::String &filename, bool hidden, bool exhaustive) const;
 };
 
 //} // End of namespace Common
@@ -194 +244 @@
 
 //} // End of namespace Common
 
-#endif
+#endif //COMMON_FS_H

home/david/Projects/scummvm/common/md5.cpp

@@ -246 +246 @@
 }
 
 bool md5_file(const FilesystemNode &file, uint8 digest[16], uint32 length) {
-        if (!file.isValid()) {
-                warning("md5_file: using an invalid FilesystemNode");
+        if(!file.exists()) {
+                warning("md5_file: using an inexistent FilesystemNode");
+                return false;
+        } else if (!file.isReadable()) {
+                warning("md5_file: using an unreadable FilesystemNode");
                 return false;
         } else if (file.isDirectory()) {
-                warning("md5_file: using a diretory FilesystemNode");
+                warning("md5_file: using a directory FilesystemNode");
                 return false;
         }
 
-        return md5_file(file.path().c_str(), digest, length);
+        return md5_file(file.getPath().c_str(), digest, length);
 }
 
 bool md5_file(const char *name, uint8 digest[16], uint32 length) {

home/david/Projects/scummvm/common/savefile.h

@@ -30 +30 @@
 #include "common/noncopyable.h"
 #include "common/scummsys.h"
 #include "common/stream.h"
+#include "common/str.h"
 
 namespace Common {
 
@@ -77 +78 @@
 class SaveFileManager : NonCopyable {
 
 public:
+        enum SFMError {
+                SFM_NO_ERROR,                   //Default state, indicates no error has been recorded
+                SFM_DIR_ACCESS,                 //stat(), mkdir()::EACCES: Search or write permission denied
+                SFM_DIR_LINKMAX,                //mkdir()::EMLINK: The link count of the parent directory would exceed {LINK_MAX}
+                SFM_DIR_LOOP,                   //stat(), mkdir()::ELOOP: Too many symbolic links encountered while traversing the path
+                SFM_DIR_NAMETOOLONG,    //stat(), mkdir()::ENAMETOOLONG: The path name is too long
+                SFM_DIR_NOENT,                  //stat(), mkdir()::ENOENT: A component of the path path does not exist, or the path is an empty string
+                SFM_DIR_NOTDIR,                 //stat(), mkdir()::ENOTDIR: A component of the path prefix is not a directory
+                SFM_DIR_ROFS                    //mkdir()::EROFS: The parent directory resides on a read-only file system
+        };
+        
+protected:
+        SFMError _error;
+        String _errorDesc;
+        
+public:
         virtual ~SaveFileManager() {}
-
+        
+        /**
+         * Clears the last set error code and string.
+         */
+        virtual void clearError() { _error = SFM_NO_ERROR; _errorDesc = ""; }
+        
+        /**
+         * Returns the last ocurred error code. If none ocurred, returns SFM_NO_ERROR.
+         * 
+         * @return A SFMError indicating the type of the last error.
+         */
+        virtual SFMError getError() { return _error; }
+        
+        /**
+         * Returns the last ocurred error description. If none ocurred, returns 0.
+         * 
+         * @return A string describing the last error.
+         */
+        virtual String getErrorDesc() { return _errorDesc; }
+        
+        /**
+         * Sets the last ocurred error.
+         * @param error Code identifying the last error.
+         * @param errorDesc String describing the last error.
+         */
+        virtual void setError(SFMError error, String errorDesc) { _error = error; _errorDesc = errorDesc; }
+        
         /**
          * Open the file with name filename in the given directory for saving.
          * @param filename      the filename
@@ -94 +137 @@
         virtual InSaveFile *openForLoading(const char *filename) = 0;
 
         /**
-         * Request a list of available savegames with a given prefix.
-         * TODO: Document this better!
-         * TODO: Or even replace it with a better API. For example, one that
-         * returns a list of strings for all present file names. 
+         * Removes the given savefile from the filesystem.
+         * @param filename Filename path pointing to the savefile.
+         * @return true if no error ocurred. false otherwise.
          */
-        virtual void listSavefiles(const char * /* prefix */, bool *marks, int num) = 0;
+        virtual bool removeSavefile(const char *filename) = 0;
+        
+        /**
+         * Request a list of available savegames with a given regex.
+         * @param regex Regular expression to match. Wildcards like * or ? are available.
+         * returns a list of strings for all present file names.
+         */
+        virtual Common::StringList listSavefiles(const char *regex) = 0;
 
         /**
          * Get the path to the save game directory.

home/david/Projects/scummvm/engines/agi/agi_v3.cpp

@@ -52 +52 @@
         FSList fslist;
         FilesystemNode dir(ConfMan.get("path"));
 
-        if (!dir.listDir(fslist, FilesystemNode::kListFilesOnly)) {
-                warning("AgiEngine: invalid game path '%s'", dir.path().c_str());
+        if (!dir.getChildren(fslist, FilesystemNode::kListFilesOnly)) {
+                warning("AgiEngine: invalid game path '%s'", dir.getPath().c_str());
                 return errInvalidAGIFile;
         }
 
@@ -59 +59 @@
 
         for (FSList::const_iterator file = fslist.begin();
             file != fslist.end() && !found; ++file) {
-                Common::String f = file->name();
+                Common::String f = file->getName();
                 f.toLowercase();
 
                 if (f.hasSuffix("vol.0")) {

home/david/Projects/scummvm/engines/agi/detection.cpp

@@ -1883 +1883 @@
         // 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) {
                 if (file->isDirectory()) continue;
-                Common::String filename = file->name();
+                Common::String filename = file->getName();
                 filename.toLowercase();
                 allFiles[filename] = true; // Save the filename in a hash table
                 
@@ -1889 +1889 @@
                 
                 if (filename.hasSuffix(".wag")) {
                         // Save latest found *.wag file's path (Can be used to open the file, the name can't)
-                        wagFilePath = file->path();
+                        wagFilePath = file->getPath();
                         wagFileCount++; // Count found *.wag files
                 }
         }

home/david/Projects/scummvm/engines/agos/saveload.cpp

@@ -38 +38 @@
 
 int AGOSEngine::countSaveGames() {
         Common::InSaveFile *f;
+        Common::StringList filenames;
         uint i = 1;
+        char slot[3];
+        int slotNum;
         bool marks[256];
 
         char *prefix = genSaveName(998);
-        prefix[strlen(prefix)-3] = '\0';
-        _saveFileMan->listSavefiles(prefix, marks, 256);
+        prefix[strlen(prefix)-3] = '*';
+        prefix[strlen(prefix)-2] = '\0';
+        memset(marks, false, 256 * sizeof(bool));       //assume no savegames for this title
+        filenames = _saveFileMan->listSavefiles(prefix);
 
+        for(Common::StringList::const_iterator file = filenames.begin(); file != filenames.end(); file++){
+                //Obtain the last 3 digits of the filename, since they correspond to the save slot
+                slot[0] = file->c_str()[file->size()-3];
+                slot[1] = file->c_str()[file->size()-2];
+                slot[2] = file->c_str()[file->size()-1];
+                
+                slotNum = atoi(slot);
+                if(slotNum >= 0 && slotNum < 256)
+                        marks[slotNum] = true;  //mark this slot as valid
+        }
+        
         while (i < 256) {
                 if (marks[i] &&
                     (f = _saveFileMan->openForLoading(genSaveName(i)))) {
@@ -53 +69 @@
                 } else
                         break;
         }
+        
         return i;
 }
 

home/david/Projects/scummvm/engines/kyra/resource.cpp

@@ -82 +82 @@
         FSList fslist;
         FilesystemNode dir(ConfMan.get("path"));
 
-        if (!dir.listDir(fslist, FilesystemNode::kListFilesOnly))
-                error("invalid game path '%s'", dir.path().c_str());
+        if (!dir.getChildren(fslist, FilesystemNode::kListFilesOnly))
+                error("invalid game path '%s'", dir.getPath().c_str());
 
         if (_vm->game() == GI_KYRA1 && _vm->gameFlags().isTalkie) {
                 static const char *list[] = {
@@ -96 +96 @@
                 Common::for_each(_pakfiles.begin(), _pakfiles.end(), Common::bind2nd(Common::mem_fun(&ResourceFile::protect), true));
         } else {
                 for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
-                        Common::String filename = file->name();
+                        Common::String filename = file->getName();
                         filename.toUppercase();
 
                         // No real PAK file!
@@ -104 +104 @@
                                 continue;
 
                         if (filename.hasSuffix("PAK") || filename.hasSuffix("APK")) {
-                                if (!loadPakFile(file->name()))
-                                        error("couldn't open pakfile '%s'", file->name().c_str());
+                                if (!loadPakFile(file->getName()))
+                                        error("couldn't open pakfile '%s'", file->getName().c_str());
                         }
                 }
 

home/david/Projects/scummvm/engines/queen/queen.cpp

@@ -73 +73 @@
                 if (file->isDirectory()) {
                         continue;
                 }
-                if (file->name().equalsIgnoreCase("queen.1") || file->name().equalsIgnoreCase("queen.1c")) {
+                if (file->getName().equalsIgnoreCase("queen.1") || file->getName().equalsIgnoreCase("queen.1c")) {
                         Common::File dataFile;
                         if (!dataFile.open(*file)) {
                                 continue;
@@ -317 +317 @@
 }
 
 void QueenEngine::findGameStateDescriptions(char descriptions[100][32]) {
-        char filename[20];
-        makeGameStateName(0, filename);
-        filename[strlen(filename) - 2] = 0;
+        char prefix[20];
+        makeGameStateName(0, prefix);
+        prefix[strlen(prefix) - 2] = '*';
+        prefix[strlen(prefix) - 1] = 0;
         bool marks[SAVESTATE_MAX_NUM];
-        _saveFileMan->listSavefiles(filename, marks, SAVESTATE_MAX_NUM);
+        char slot[2];
+        int slotNum;
+        Common::StringList filenames;
+
+        memset(marks, false, SAVESTATE_MAX_NUM * sizeof(bool)); //assume no savegames for this title
+        filenames = _saveFileMan->listSavefiles(prefix);
+        
+        for(Common::StringList::const_iterator file = filenames.begin(); file != filenames.end(); file++){
+                //Obtain the last 2 digits of the filename, since they correspond to the save slot
+                slot[0] = file->c_str()[file->size()-2];
+                slot[1] = file->c_str()[file->size()-1];
+                
+                slotNum = atoi(slot);
+                if(slotNum >= 0 && slotNum < SAVESTATE_MAX_NUM)
+                        marks[slotNum] = true;  //mark this slot as valid
+        }
+        
         for (int i = 0; i < SAVESTATE_MAX_NUM; ++i) {
                 if (marks[i]) {
                         GameStateHeader header;

home/david/Projects/scummvm/engines/saga/saveload.cpp

@@ -112 +112 @@
 }
 
 void SagaEngine::fillSaveList() {
+        assert(_saveMarks);
+        
         int i;
         Common::InSaveFile *in;
+        Common::StringList filenames;
+        char slot[2];
+        int slotNum;
         char *name;
 
         name = calcSaveFileName(MAX_SAVES);
-        name[strlen(name) - 2] = 0;
-        _saveFileMan->listSavefiles(name, _saveMarks, MAX_SAVES);
-
+        name[strlen(name) - 2] = '*';
+        name[strlen(name) - 1] = 0;
+        
+        memset(_saveMarks, false, MAX_SAVES * sizeof(bool));    //assume no savegames for this title
+        filenames = _saveFileMan->listSavefiles(name);
+        
+        for(Common::StringList::iterator file = filenames.begin(); file != filenames.end(); file++){
+                //Obtain the last 2 digits of the filename, since they correspond to the save slot
+                slot[0] = file->c_str()[file->size()-2];
+                slot[1] = file->c_str()[file->size()-1];
+                
+                slotNum = atoi(slot);
+                if(slotNum >= 0 && slotNum < MAX_SAVES)
+                        _saveMarks[slotNum] = true;     //mark this slot as valid
+        }
+        
         _saveFilesMaxCount = 0;
         for (i = 0; i < MAX_SAVES; i++) {
                 if (_saveMarks[i]) {

home/david/Projects/scummvm/engines/scumm/detection.cpp

@@ -18 +18 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
- * $URL$
- * $Id$
+ * $URL:https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/branches/gsoc2007-fsnode/engines/scumm/detection.cpp $
+ * $Id:detection.cpp 26949 2007-05-26 20:23:24Z david_corrales $
  *
  */
 
@@ -194 +194 @@
 // 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) {
-                if (!scumm_stricmp(file->name().c_str(), name.c_str())) {
+                if (!scumm_stricmp(file->getName().c_str(), name.c_str())) {
                         result = *file;
                         return true;
                 }
@@ -220 +220 @@
                 FSList tmpList;
                 if (searchFSNode(fslist, "RESOURCE", resDir)
                         && resDir.isDirectory()
-                        && resDir.listDir(tmpList, FilesystemNode::kListFilesOnly)
+                        && resDir.getChildren(tmpList, FilesystemNode::kListFilesOnly)
                         && searchFSNode(tmpList, filename, langFile)) {
                         tmp.open(langFile);
                 }
@@ -324 +324 @@
                         DetectorDesc d;
                         d.node = *file;
                         d.md5Entry = 0;
-                        fileMD5Map[file->name()] = d;
+                        fileMD5Map[file->getName()] = d;
                 }
         }
 
@@ -451 +451 @@
 
         Common::File tmp;
         if (!tmp.open(d.node)) {
-                warning("SCUMM detectGames: failed to open '%s' for read access", d.node.path().c_str());
+                warning("SCUMM detectGames: failed to open '%s' for read access", d.node.getPath().c_str());
                 return false;
         }
         
@@ -755 +755 @@
         // Fetch the list of files in the current directory
         FSList fslist;
         FilesystemNode dir(ConfMan.get("path"));
-        if (!dir.listDir(fslist, FilesystemNode::kListFilesOnly)) {
+        if (!dir.getChildren(fslist, FilesystemNode::kListFilesOnly)) {
                 return kInvalidPathError;
         }
 

home/david/Projects/scummvm/engines/scumm/dialogs.cpp

@@ -427 +427 @@
 #pragma mark -
 
 Common::StringList generateSavegameList(ScummEngine *scumm, bool saveMode) {
-        // Get savegame names
-        Common::StringList l;
+        // Get savegame descriptions
+        Common::StringList descriptions;
         char name[32];
-        uint i = saveMode ? 1 : 0;
+        uint i = saveMode ? 1 : 0;              //the autosave is on slot #0
         bool avail_saves[81];
 
         scumm->listSavegames(avail_saves, ARRAYSIZE(avail_saves));
@@ -439 +439 @@
                         scumm->getSavegameName(i, name);
                 else
                         name[0] = 0;
-                l.push_back(name);
+                descriptions.push_back(name);
         }
-
-        return l;
+        
+        return descriptions;
 }
 
 MainMenuDialog::MainMenuDialog(ScummEngine *scumm)

home/david/Projects/scummvm/engines/scumm/saveload.cpp

@@ -384 +384 @@
 }
 
 void ScummEngine::listSavegames(bool *marks, int num) {
+        assert(marks);
+        
         char prefix[256];
+        char slot[2];
+        int slotNum;
+        Common::StringList filenames;
+        
         makeSavegameName(prefix, 99, false);
-        prefix[strlen(prefix)-2] = 0;
-        _saveFileMan->listSavefiles(prefix, marks, num);
+        prefix[strlen(prefix)-2] = '*';
+        prefix[strlen(prefix)-1] = 0;
+        memset(marks, false, num * sizeof(bool));       //assume no savegames for this title
+        filenames = _saveFileMan->listSavefiles(prefix);
+        
+        for(Common::StringList::const_iterator file = filenames.begin(); file != filenames.end(); file++){
+                //Obtain the last 2 digits of the filename, since they correspond to the save slot
+                slot[0] = file->c_str()[file->size()-2];
+                slot[1] = file->c_str()[file->size()-1];
+                
+                slotNum = atoi(slot);
+                if(slotNum >= 0 && slotNum < num)
+                        marks[slotNum] = true;  //mark this slot as valid
+        }
 }
 
 bool ScummEngine::getSavegameName(int slot, char *desc) {

home/david/Projects/scummvm/engines/sky/sky.cpp

@@ -124 +124 @@
         // Iterate over all files in the given directory
         for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
                 if (!file->isDirectory()) {
-                        const char *fileName = file->name().c_str();
+                        const char *fileName = file->getName().c_str();
 
                         if (0 == scumm_stricmp("sky.dsk", fileName)) {
                                 Common::File dataDisk;
-                                if (dataDisk.open(file->path())) {
+                                if (dataDisk.open(file->getPath())) {
                                         hasSkyDsk = true;
                                         dataDiskSize = dataDisk.size();
                                 }
@@ -136 +136 @@
 
                         if (0 == scumm_stricmp("sky.dnr", fileName)) {
                                 Common::File dinner;
-                                if (dinner.open(file->path())) {
+                                if (dinner.open(file->getPath())) {
                                         hasSkyDnr = true;
                                         dinnerTableEntries = dinner.readUint32LE();
                                 }

home/david/Projects/scummvm/engines/sword1/sword1.cpp

@@ -107 +107 @@
 void Sword1CheckDirectory(const FSList &fslist, bool *filesFound) {
         for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
                 if (!file->isDirectory()) {
-                        const char *fileName = file->name().c_str();
+                        const char *fileName = file->getName().c_str();
                         for (int cnt = 0; cnt < NUM_FILES_TO_CHECK; cnt++)
                                 if (scumm_stricmp(fileName, g_filesToCheck[cnt]) == 0)
                                         filesFound[cnt] = true;
@@ -113 +113 @@
                                         filesFound[cnt] = true;
                 } else {
                         for (int cnt = 0; cnt < ARRAYSIZE(g_dirNames); cnt++)
-                                if (scumm_stricmp(file->name().c_str(), g_dirNames[cnt]) == 0) {
+                                if (scumm_stricmp(file->getName().c_str(), g_dirNames[cnt]) == 0) {
                                         FSList fslist2;
-                                        if (file->listDir(fslist2, FilesystemNode::kListFilesOnly))
+                                        if (file->getChildren(fslist2, FilesystemNode::kListFilesOnly))
                                                 Sword1CheckDirectory(fslist2, filesFound);
                                 }
                 }

home/david/Projects/scummvm/engines/sword2/sword2.cpp

@@ -101 +101 @@
                 // Iterate over all files in the given directory
                 for (file = fslist.begin(); file != fslist.end(); ++file) {
                         if (!file->isDirectory()) {
-                                const char *fileName = file->name().c_str();
+                                const char *fileName = file->getName().c_str();
 
                                 if (0 == scumm_stricmp(g->detectname, fileName)) {
                                         // Match found, add to list of candidates, then abort inner loop.
@@ -118 +118 @@
                 // present e.g. if the user copied the data straight from CD.
                 for (file = fslist.begin(); file != fslist.end(); ++file) {
                         if (file->isDirectory()) {
-                                const char *fileName = file->name().c_str();
+                                const char *fileName = file->getName().c_str();
 
                                 if (0 == scumm_stricmp("clusters", fileName)) {
                                         FSList recList;
-                                        if (file->listDir(recList, FilesystemNode::kListAll)) {
+                                        if (file->getChildren(recList, FilesystemNode::kListAll)) {
                                                 GameList recGames(Engine_SWORD2_detectGames(recList));
                                                 if (!recGames.empty()) {
                                                         detectedGames.push_back(recGames);
@@ -144 +144 @@
 
         FSList fslist;
         FilesystemNode dir(ConfMan.get("path"));
-        if (!dir.listDir(fslist, FilesystemNode::kListAll)) {
+        if (!dir.getChildren(fslist, FilesystemNode::kListAll)) {
                 return kInvalidPathError;
         }
 

home/david/Projects/scummvm/engines/touche/saveload.cpp

@@ -400 +400 @@
 
 void ToucheEngine::generateGameStateFileName(int num, char *dst, int len, bool prefixOnly) const {
         if (prefixOnly) {
-                snprintf(dst, len, "%s.", _targetName.c_str());
+                snprintf(dst, len, "%s.*", _targetName.c_str());
         } else {
                 snprintf(dst, len, "%s.%d", _targetName.c_str(), num);
         }

home/david/Projects/scummvm/engines/touche/ui.cpp

@@ -370 +370 @@
                                 setupMenu(menuData.mode, &menuData);
                                 curMode = menuData.mode;
                                 if (menuData.mode == kMenuLoadStateMode || menuData.mode == kMenuSaveStateMode) {
+                                        assert(menuData.saveLoadMarks);
+                                        
                                         char gameStateFileName[16];
                                         generateGameStateFileName(999, gameStateFileName, 15, true);
-                                        _saveFileMan->listSavefiles(gameStateFileName, menuData.saveLoadMarks, 100);
+                                        char slot[2];
+                                        int slotNum;
+                                        Common::StringList filenames;
+                                        
+                                        memset(menuData.saveLoadMarks, false, 100 * sizeof(bool));      //assume no savegames for this title    
+                                        filenames = _saveFileMan->listSavefiles(gameStateFileName);
+                                        
+                                        for(Common::StringList::const_iterator file = filenames.begin(); file != filenames.end(); file++){
+                                                //Obtain the last 1 or 2 digits of the filename, since they correspond to the save slot
+                                                //This engine can save games either with one or two digits, hence the additional if statement
+                                                slot[0] = file->c_str()[file->size()-2];
+                                                slot[1] = file->c_str()[file->size()-1];
+                                                
+                                                if(!atoi(&slot[0])){
+                                                        slotNum = atoi(&slot[1]);
+                                                } else {
+                                                        slotNum = atoi(slot);
+                                                }
+                                                
+                                                if(slotNum >= 0 && slotNum < 100)
+                                                        menuData.saveLoadMarks[slotNum] = true; //mark this slot as valid
+                                        }
+                                        
                                         for (int i = 0; i < 100; ++i) {
                                                 menuData.saveLoadDescriptionsTable[i][0] = 0;
                                                 if (menuData.saveLoadMarks[i]) {

home/david/Projects/scummvm/gui/browser.cpp

@@ -28 +28 @@
 #include "gui/ListWidget.h"
 
 #include "common/config-manager.h"
-#include "common/fs.h"
 #include "common/system.h"
 #include "common/algorithm.h"
 
@@ -223 +222 @@
 
 void BrowserDialog::updateListing() {
         // Update the path display
-        _currentPath->setLabel(_node.path());
+        _currentPath->setLabel(_node.getPath());
 
         // We memorize the last visited path.
-        ConfMan.set("browser_lastpath", _node.path());
+        ConfMan.set("browser_lastpath", _node.getPath());
 
         // Read in the data from the file system
         FilesystemNode::ListMode listMode = _isDirBrowser ? FilesystemNode::kListDirectoriesOnly
@@ -231 +230 @@
         // Read in the data from the file system
         FilesystemNode::ListMode listMode = _isDirBrowser ? FilesystemNode::kListDirectoriesOnly
                                                           : FilesystemNode::kListAll;
-        if (!_node.listDir(_nodeContent, listMode)) {
+        if (!_node.getChildren(_nodeContent, listMode)) {
                 _nodeContent.clear();
         } else {
                 Common::sort(_nodeContent.begin(), _nodeContent.end());
@@ -241 +240 @@
         Common::StringList list;
         for (FSList::iterator i = _nodeContent.begin(); i != _nodeContent.end(); ++i) {
                 if (!_isDirBrowser && i->isDirectory())
-                        list.push_back(i->displayName() + "/");
+                        list.push_back(i->getDisplayName() + "/");
                 else
-                        list.push_back(i->displayName());
+                        list.push_back(i->getDisplayName());
         }
         _fileList->setList(list);
         _fileList->scrollTo(0);

home/david/Projects/scummvm/gui/launcher.cpp

@@ -394 +394 @@
                 if (browser.runModal() > 0) {
                         // User made this choice...
                         FilesystemNode file(browser.getResult());
-                        _soundFont->setLabel(file.path());
+                        _soundFont->setLabel(file.getPath());
 
-                        if (!file.path().empty() && (file.path() != "None"))
+                        if (!file.getPath().empty() && (file.getPath() != "None"))
                                 _soundFontClearButton->setEnabled(true);
                         else
                                 _soundFontClearButton->setEnabled(false);
@@ -417 +417 @@
                         // done with optional specific gameid to pluginmgr detectgames?
                         // FSList files = dir.listDir(FilesystemNode::kListFilesOnly);
 
-                        _gamePathWidget->setLabel(dir.path());
+                        _gamePathWidget->setLabel(dir.getPath());
                         draw();
                 }
                 draw();
@@ -430 +430 @@
                 if (browser.runModal() > 0) {
                         // User made his choice...
                         FilesystemNode dir(browser.getResult());
-                        _extraPathWidget->setLabel(dir.path());
+                        _extraPathWidget->setLabel(dir.getPath());
                         draw();
                 }
                 draw();
@@ -442 +442 @@
                 if (browser.runModal() > 0) {
                         // User made his choice...
                         FilesystemNode dir(browser.getResult());
-                        _savePathWidget->setLabel(dir.path());
+                        _savePathWidget->setLabel(dir.getPath());
                         draw();
                 }
                 draw();
@@ -654 +654 @@
                 // User made his choice...
                 FilesystemNode dir(_browser->getResult());
                 FSList files;
-                if (!dir.listDir(files, FilesystemNode::kListAll)) {
+                if (!dir.getChildren(files, FilesystemNode::kListAll)) {
                         error("browser returned a node that is not a directory: '%s'",
-                                        dir.path().c_str());
+                                        dir.getPath().c_str());
                 }
 
                 // ...so let's determine a list of candidates, games that
@@ -686 +686 @@
                         GameDescriptor result = candidates[idx];
 
                         // TODO: Change the detectors to set "path" !
-                        result["path"] = dir.path();
+                        result["path"] = dir.getPath();
 
                         Common::String domain = addGameToConf(result);
 

home/david/Projects/scummvm/gui/massadd.cpp

@@ -128 +128 @@
                 FilesystemNode dir = _scanStack.pop();
         
                 FSList files;
-                if (!dir.listDir(files, FilesystemNode::kListAll)) {
+                if (!dir.getChildren(files, FilesystemNode::kListAll)) {
                         error("browser returned a node that is not a directory: '%s'",
-                                        dir.path().c_str());
+                                        dir.getPath().c_str());
                 }
         
                 // Run the detector on the dir
@@ -142 +142 @@
                         // e.g. ask the user which one to pick (make sure to display the 
                         // path, too).
                         GameDescriptor result = candidates[0];
-                        result["path"] = dir.path();
+                        result["path"] = dir.getPath();
                         
                         _games.push_back(result);
                 }

home/david/Projects/scummvm/gui/options.cpp

@@ -27 +27 @@
 #include "gui/themebrowser.h"
 #include "gui/chooser.h"
 #include "gui/eval.h"
+#include "gui/message.h"
 #include "gui/newgui.h"
 #include "gui/options.h"
 #include "gui/PopUpWidget.h"
@@ -813 +814 @@
                 if (browser.runModal() > 0) {
                         // User made his choice...
                         FilesystemNode dir(browser.getResult());
-                        _savePath->setLabel(dir.path());
+                        if(dir.isWritable())
+                        {
+                                _savePath->setLabel(dir.getPath());
+                        } else {
+                                MessageDialog error("The chosen directory cannot be written to. Please select another one.");
+                                error.runModal();
+                                return;
+                        }       
                         draw();
-                        // TODO - we should check if the directory is writeable before accepting it
                 }
                 break;
         }
@@ -824 +831 @@
                 if (browser.runModal() > 0) {
                         // User made his choice...
                         FilesystemNode dir(browser.getResult());
-                        _themePath->setLabel(dir.path());
+                        _themePath->setLabel(dir.getPath());
                         draw();
                 }
                 break;
@@ -834 +841 @@
                 if (browser.runModal() > 0) {
                         // User made his choice...
                         FilesystemNode dir(browser.getResult());
-                        _extraPath->setLabel(dir.path());
+                        _extraPath->setLabel(dir.getPath());
                         draw();
                 }
                 break;
@@ -844 +851 @@
                 if (browser.runModal() > 0) {
                         // User made his choice...
                         FilesystemNode file(browser.getResult());
-                        _soundFont->setLabel(file.path());
+                        _soundFont->setLabel(file.getPath());
 
-                        if (!file.path().empty() && (file.path() != "None"))
+                        if (!file.getPath().empty() && (file.getPath() != "None"))
                                 _soundFontClearButton->setEnabled(true);
                         else
                                 _soundFontClearButton->setEnabled(false);

home/david/Projects/scummvm/gui/themebrowser.cpp

@@ -27 +27 @@
 #include "gui/ListWidget.h"
 #include "gui/widget.h"
 #include "gui/theme.h"
-#include "common/fs.h"
 
 #ifdef MACOSX
 #include "CoreFoundation/CoreFoundation.h"
@@ -145 +144 @@
 
         FilesystemNode node(dir);
 
-        if (!node.isValid())
+        if (!node.exists() || !node.isReadable())
                 return;
 
         FSList fslist;
-        if (!node.listDir(fslist, FilesystemNode::kListAll))
+        if (!node.getChildren(fslist, FilesystemNode::kListAll))
                 return;
 
         for (FSList::const_iterator i = fslist.begin(); i != fslist.end(); ++i) {
@@ -154 +153 @@
 
         for (FSList::const_iterator i = fslist.begin(); i != fslist.end(); ++i) {
                 if (i->isDirectory()) {
-                        addDir(list, i->path(), level-1);
+                        addDir(list, i->getPath(), level-1);
                 } else {
                         Entry th;
                         if (isTheme(*i, th)) {
@@ -177 +176 @@
         Common::ConfigFile cfg;
         Common::String type;
 
-        out.file = node.name();
+        out.file = node.getName();
         for (int i = out.file.size()-1; out.file[i] != '.' && i > 0; --i) {
                 out.file.deleteLastChar();
         }