Ticket #8727: lastPathComponent (3).patch

File lastPathComponent (3).patch, 20.0 KB (added by SF/david_corrales, 17 years ago)

Static lastPathComponent patch

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

     
    101101         * @note By default, this method returns the value of getName().
    102102         */
    103103        virtual String getDisplayName() const { return getName(); }
    104 
     104       
    105105        /**
    106          * Returns a string with an architecture dependent path description.
     106         * Returns the last component of the path pointed by this FilesystemNode.
     107         *
     108         * Examples (POSIX):
     109         *                      /foo/bar.txt would return /bar.txt
     110         *                      /foo/bar/    would return /bar/
     111         * 
     112         * @note This method is very architecture dependent, please check the concrete implementation for more information.
    107113         */
    108114        virtual String getName() const = 0;
    109115       

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

     
    9393        virtual String getPath() const { return _sPath; };
    9494        virtual bool isDirectory() const { return _bIsDirectory; };
    9595        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    96         virtual bool isValid() const { return _bIsValid; };
    9796        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    9897       
    9998        virtual AbstractFilesystemNode *getChild(const String &n) const;
    … …  
    106105        virtual AbstractFSList listVolumes() const;
    107106};
    108107
    109 // TODO: this is ripped of
    110 // AmigaOSFilesystemNode::AmigaOSFilesystemNode(const String &p)
    111 // maybe change it to use this function instead?
    112108/**
    113109 * Returns the last component of a given path.
    114110 *
    … …  
    117113 */
    118114const char *lastPathComponent(const Common::String &str) {
    119115        int offset = str.size();
     116               
     117        if (offset <= 0) {
     118                debug(6, "Bad offset");
     119                return;
     120        }
     121       
    120122        const char *p = str.c_str();
    121123
    122124        while (offset > 0 && (p[offset-1] == '/' || p[offset-1] == ':'))
    … …  
    151153        }
    152154
    153155        _sPath = p;
    154 
    155         // Extract last component from path
    156         const char *str = p.c_str();
    157 
    158         while (offset > 0 && (str[offset-1] == '/' || str[offset-1] == ':'))
    159                 offset--;
    160 
    161         while (offset > 0 && (str[offset-1] != '/' && str[offset-1] != ':')) {
    162                 len++;
    163                 offset--;
    164         }
    165 
    166         _sDisplayName = String(str + offset, len);
     156        _sDisplayName = lastPathComponent(_sPath);
    167157        _pFileLock = 0;
    168158        _bIsDirectory = false;
    169159
    … …  
    352342                                                if (lock) {
    353343                                                        AmigaOSFilesystemNode *entry = new AmigaOSFilesystemNode(lock, (char *)ead->ed_Name);
    354344                                                        if (entry) {
    355                                                                 if (entry->isValid())
     345                                                                //FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
     346                                                                //       specification, the following call had to be changed:
     347                                                                //              if (entry->isValid())
     348                                                                //               Please verify that the logic of the code remains coherent. Also, remember
     349                                                                //               that the isReadable() and isWritable() methods are available.
     350                                                                if (entry->exists())
    356351                                                                    myList.push_back(entry);
    357352                                                                else
    358353                                                                        delete entry;
    … …  
    453448
    454449                                AmigaOSFilesystemNode *entry = new AmigaOSFilesystemNode(volumeLock, buffer);
    455450                                if (entry) {
    456                                         if (entry->isValid())
     451                                        //FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
     452                                        //       specification, the following call had to be changed:
     453                                        //              if (entry->isValid())
     454                                        //               Please verify that the logic of the code remains coherent. Also, remember
     455                                        //               that the isReadable() and isWritable() methods are available.
     456                                        if(entry->exists())
    457457                                                myList.push_back(entry);
    458458                                        else
    459459                                                delete entry;

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

     
    6262        virtual String getPath() const { return _path; }
    6363        virtual bool isDirectory() const { return _isDirectory; }
    6464        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    65         virtual bool isValid() const { return _isValid; }
    6665        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    6766
    6867        virtual AbstractFilesystemNode *getChild(const String &n) const;
    … …  
    8180 * @return Pointer to the first char of the last component inside str.
    8281 */
    8382const char *lastPathComponent(const Common::String &str) {
     83        if(str.empty())
     84                return "";
     85       
    8486        const char *start = str.c_str();
    8587        const char *cur = start + str.size() - 2;
    8688

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

     
    3636ZipFile*        DSFileSystemNode::_zipFile = NULL;
    3737char            currentDir[128];
    3838
     39const char *lastPathComponentDS(const Common::String &str) {
     40        if (str.empty())
     41                return "";
     42       
     43        char disp[128];
     44        char* pathStr = (char *) str.c_str();
     45        int lastSlash = 3;
     46       
     47        for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
     48                if (path[r] == '\\') {
     49                        lastSlash = r;
     50                }
     51        }
     52       
     53        strcpy(disp, pathStr + lastSlash + 1);
     54       
     55        return disp;
     56}
     57
    3958DSFileSystemNode::DSFileSystemNode() {
     59        _path = "ds:/";
    4060        _displayName = "ds:/";
    41         _path = "ds:/";
    4261        _isValid = true;
    4362        _isDirectory = true;
    44         _path = "ds:/";
    4563
    4664/*      if (!_archive) {
    4765                _archive = (GBFS_FILE *) find_first_gbfs_file(scummdata);
    … …  
    5674DSFileSystemNode::DSFileSystemNode(const String& path) {
    5775//      consolePrintf("--%s ",path.c_str());
    5876       
    59         char disp[128];
    60         char* pathStr = (char *) path.c_str();
    61        
    62         int lastSlash = 3;
    63         for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
    64                 if (path[r] == '\\') {
    65                         lastSlash = r;
    66                 }
    67         }
    68        
    69         strcpy(disp, pathStr + lastSlash + 1);
    70        
    71         _displayName = String(disp);
    7277        _path = path;
     78        _displayName = lastPathComponentDS(_path);
    7379//      _isValid = true;
    7480//      _isDirectory = false;
    7581
     82        char* pathStr = (char *) path.c_str();
    7683        if (!strncmp(pathStr, "ds:/", 4)) {
    7784                pathStr += 4;
    7885        }
    … …  
    99106DSFileSystemNode::DSFileSystemNode(const String& path, bool isDir) {
    100107//      consolePrintf("--%s ",path.c_str());
    101108       
    102         char disp[128];
    103         char* pathStr = (char *) path.c_str();
    104         int lastSlash = 3;
    105         for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
    106                 if (path[r] == '\\') {
    107                         lastSlash = r;
    108                 }
    109         }
    110        
    111         strcpy(disp, pathStr + lastSlash + 1);
    112        
    113         _displayName = String(disp);
    114109        _path = path;
     110        _displayName = lastPathComponentDS(_path);
    115111        _isValid = true;
    116112        _isDirectory = isDir;
    117113       
    … …  
    206202// GBAMPFileSystemNode - File system using GBA Movie Player and CF card //
    207203//////////////////////////////////////////////////////////////////////////
    208204
    209 GBAMPFileSystemNode::GBAMPFileSystemNode() {
    210         _displayName = "mp:/";
    211         _path = "mp:/";
    212         _isValid = true;
    213         _isDirectory = true;
    214         _path = "mp:/";
    215 }
    216 
    217 GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path) {
    218 //      consolePrintf("'%s'",path.c_str());
     205const char *lastPathComponentGBAMP(const Common::String &str) {
     206        if (str.empty())
     207                return "";
    219208       
    220209        char disp[128];
    221         char* pathStr = (char *) path.c_str();
     210        char* pathStr = (char *) str.c_str();
    222211        int lastSlash = 3;
     212       
    223213        for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
    224214                if ((path[r] == '\\') || (path[r] == '/')) {
    225215                        lastSlash = r;
    … …  
    227217        }
    228218       
    229219        strcpy(disp, pathStr + lastSlash + 1);
     220       
     221        return disp;
     222}
     223
     224GBAMPFileSystemNode::GBAMPFileSystemNode() {
     225        _path = "mp:/";
     226        _displayName = "mp:/";
     227        _isValid = true;
     228        _isDirectory = true;
     229}
    230230
     231GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path) {
     232//      consolePrintf("'%s'",path.c_str());
     233       
    231234        char check[128];
    232235        int success;
    233236       
    … …  
    243246        }
    244247//      consolePrintf("Path: %s  (%d)\n", check, success);
    245248       
    246         _displayName = String(disp);
    247249        _path = path;
     250        _displayName = lastPathComponentGBAMP(_path);
    248251        _isValid = success == FT_FILE;
    249252        _isDirectory = success == FT_DIR;
    250253}
    … …  
    252255GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path, bool isDirectory) {
    253256//      consolePrintf("'%s'",path.c_str());
    254257       
    255         char disp[128];
    256         char* pathStr = (char *) path.c_str();
    257         int lastSlash = 3;
    258         for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
    259                 if ((path[r] == '\\') || (path[r] == '/')) {
    260                         lastSlash = r;
    261                 }
    262         }
    263        
    264         strcpy(disp, pathStr + lastSlash + 1);
    265 
    266         _displayName = String(disp);
    267258        _path = path;
     259        _displayName = lastPathComponentGBAMP(_path);
    268260        _isValid = true;
    269261        _isDirectory = isDirectory;
    270262}

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

     
    8383        virtual String getPath() const { return _path; }
    8484        virtual bool isDirectory() const { return _isDirectory; }
    8585        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    86         virtual bool isValid() const { return _isValid; }
    8786        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    8887       
    8988        /**
    … …  
    149148        virtual String getPath() const { return _path; }
    150149        virtual bool isDirectory() const { return _isDirectory; }
    151150        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    152         virtual bool isValid() const { return _isValid; }
    153151        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    154152       
    155153        /**

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

     
    6060        // FIXME: isValid should return false if this Node can't be used!
    6161        // so client code can rely on the return value.
    6262        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    63         virtual bool isValid() const { return true; }
    6463        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    6564
    6665        virtual AbstractFilesystemNode *getChild(const String &n) const;
    … …  
    8281 * @return Pointer to the first char of the last component inside str.
    8382 */
    8483const char *lastPathComponent(const Common::String &str) {
     84        if(str.empty())
     85                return "";
     86       
    8587        const char *start = str.c_str();
    8688        const char *cur = start + str.size() - 2;
    8789

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

     
    8080        virtual String getPath() const { return _path; }
    8181        virtual bool isDirectory() const { return _isDirectory; }
    8282        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    83         virtual bool isValid() const { return _isValid; }
    8483        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    8584       
    8685        virtual AbstractFilesystemNode *getChild(const String &name) const;
    … …  
    9392        static AbstractFSList getRootChildren();
    9493};
    9594
     95/**
     96 * Returns the last component of a given path.
     97 *
     98 * @param str String containing the path.
     99 * @return Pointer to the first char of the last component inside str.
     100 */
     101const char *lastPathComponent(const Common::String &str) {
     102        if (str.empty())
     103                return "";
     104       
     105        const char *str = _path.c_str();
     106        while (offset > 0 && (str[offset-1] == '/' || str[offset-1] == ':') )
     107                offset--;
     108        while (offset > 0 && (str[offset-1] != '/' && str[offset-1] != ':')) {
     109                len++;
     110                offset--;
     111        }
     112       
     113        return str + offset;
     114}
     115
    96116ABoxFilesystemNode::ABoxFilesystemNode()
    97117{
     118        _path = "";
    98119        _displayName = "Mounted Volumes";
    99120        _isValid = true;
    100121        _isDirectory = true;
    101         _path = "";
    102122        _lock = NULL;
    103123}
    104124
    … …  
    108128        assert(offset > 0);
    109129
    110130        _path = p;
    111 
    112         // Extract last component from path
    113         const char *str = p.c_str();
    114         while (offset > 0 && (str[offset-1] == '/' || str[offset-1] == ':') )
    115                 offset--;
    116         while (offset > 0 && (str[offset-1] != '/' && str[offset-1] != ':')) {
    117                 len++;
    118                 offset--;
    119         }
    120         _displayName = String(str + offset, len);
     131        _displayName = lastPathComponent(_path);
    121132        _lock = NULL;
    122133        _isDirectory = false;
    123134
    … …  
    212223
    213224ABoxFilesystemNode::ABoxFilesystemNode(const ABoxFilesystemNode& node)
    214225{
     226        _path = node._path;
    215227        _displayName = node._displayName;
    216228        _isValid = node._isValid;
    217229        _isDirectory = node._isDirectory;
    218         _path = node._path;
    219230        _lock = DupLock(node._lock);
    220231}
    221232
    … …  
    299310                                        entry = new ABoxFilesystemNode(lock, fib->fib_FileName);
    300311                                        if (entry)
    301312                                        {
    302                                                 if (entry->isValid())
     313                                                //FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
     314                                                //       specification, the following call had to be changed:
     315                                                //              if (entry->isValid())
     316                                                //               Please verify that the logic of the code remains coherent. Also, remember
     317                                                //               that the isReadable() and isWritable() methods are available.
     318                                                if (entry->exists())
    303319                                                        list.push_back(entry);
    304320                                                else
    305321                                                        delete entry;
    … …  
    378394                                entry = new ABoxFilesystemNode(volume_lock, name);
    379395                                if (entry)
    380396                                {
    381                                         if (entry->isValid())
     397                                        //FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
     398                                        //       specification, the following call had to be changed:
     399                                        //              if (entry->isValid())
     400                                        //               Please verify that the logic of the code remains coherent. Also, remember
     401                                        //               that the isReadable() and isWritable() methods are available.
     402                                        if (entry->exists())
    382403                                                list.push_back(entry);
    383404                                        else
    384405                                                delete entry;

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

     
    6161        virtual String getPath() const { return _path; }
    6262        virtual bool isDirectory() const { return _isDirectory; }
    6363        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    64         virtual bool isValid() const { return _isValid; }
    6564        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    6665
    6766        virtual AbstractFilesystemNode *getChild(const String &n) const;
    … …  
    9291 * @return Pointer to the first char of the last component inside str.
    9392 */
    9493const char *lastPathComponent(const Common::String &str) {
     94        if(str.empty())
     95                return "";
     96       
    9597        const char *start = str.c_str();
    9698        const char *cur = start + str.size() - 2;
    9799
    … …  
    136138
    137139PalmOSFilesystemNode::PalmOSFilesystemNode(const String &p) {
    138140        _path = p;
    139         _displayName = lastPathComponent(p);
     141        _displayName = lastPathComponent(_path);
    140142
    141143        UInt32 attr;
    142144        FileRef handle;

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

     
    9191 * @return Pointer to the first char of the last component inside str.
    9292 */
    9393const char *lastPathComponent(const Common::String &str) {
     94        if(str.empty())
     95                return "";
     96       
    9497        const char *start = str.c_str();
    9598        const char *cur = start + str.size() - 2;
    9699

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

     
    6868        virtual String getPath() const { return _path; }
    6969        virtual bool isDirectory() const { return _isDirectory; }
    7070        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    71         virtual bool isValid() const { return !_isRoot; }
    7271        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    7372
    7473        virtual AbstractFilesystemNode *clone() const { return new Ps2FilesystemNode(this); }
    … …  
    7776        virtual AbstractFilesystemNode *getParent() const;
    7877};
    7978
     79/**
     80 * Returns the last component of a given path.
     81 *
     82 * @param str String containing the path.
     83 * @return Pointer to the first char of the last component inside str.
     84 */
     85const char *lastPathComponent(const Common::String &str) {
     86        //FIXME: implement this method properly.
     87        // This code is probably around the constructors,
     88        // but I couldn't figure it out without having
     89        // doubts on the correctness of my assumptions.
     90        // Therefore, I leave it to the porter to correctly
     91        // implement this method.
     92        assert(false);
     93}
     94
    8095Ps2FilesystemNode::Ps2FilesystemNode() {
    8196        _isDirectory = true;
    8297        _isRoot = true;

  • home/david/Projects/scummvm/backends/fs/psp/psp-fs.cpp

     
    6464        virtual String getPath() const { return _path; }
    6565        virtual bool isDirectory() const { return _isDirectory; }
    6666        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    67         virtual bool isValid() const { return _isValid; }
    6867        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    6968
    7069        virtual AbstractFilesystemNode *getChild(const String &n) const;
    … …  
    8382 * @return Pointer to the first char of the last component inside str.
    8483 */
    8584const char *lastPathComponent(const Common::String &str) {
     85        if(str.empty())
     86                return "";
     87               
    8688        const char *start = str.c_str();
    8789        const char *cur = start + str.size() - 2;
    8890
    … …  
    170172}
    171173
    172174AbstractFilesystemNode *PSPFilesystemNode::getParent() const {
    173         assert(_isValid);
    174        
    175175        if (_path == ROOT_PATH)
    176176                return 0;
    177177       

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

     
    6464        virtual String getPath() const { return _path; }
    6565        virtual bool isDirectory() const { return _isDirectory; }
    6666        virtual bool isReadable() const { return true; }        //FIXME: this is just a stub
    67         virtual bool isValid() const { return _isValid; }
    6867        virtual bool isWritable() const { return true; }        //FIXME: this is just a stub
    6968
    7069        virtual AbstractFilesystemNode *getChild(const String &n) const;
    … …  
    8382 * @return Pointer to the first char of the last component inside str.
    8483 */
    8584const char *lastPathComponent(const Common::String &str) {
     85        if(str.empty())
     86                return "";
     87               
    8688        const char *start = str.c_str();
    8789        const char *cur = start + str.size() - 2;
    8890

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

     
    9292        virtual String getPath() const { return _path; }
    9393        virtual bool isDirectory() const { return _isDirectory; }
    9494        virtual bool isReadable() const { return _access(_path.c_str(), R_OK) == 0; }
    95         virtual bool isValid() const { return _isValid; }
    9695        virtual bool isWritable() const { return _access(_path.c_str(), W_OK) == 0; }
    9796
    9897        virtual AbstractFilesystemNode *getChild(const String &n) const;
    … …  
    139138 * @return Pointer to the first char of the last component inside str.
    140139 */
    141140const char *lastPathComponent(const Common::String &str) {
     141        if(str.empty())
     142                return "";
     143               
    142144        const char *start = str.c_str();
    143145        const char *cur = start + str.size() - 2;
    144146