Ticket #8727: lastPathComponent (2).patch

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

Patch to fix the lastPathComponent hack

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

    Property changes on: /home/david/Projects/scummvm
___________________________________________________________________
Name: svn:ignore
   - config.log
scummvm
scummvm-static
config.h
config.mk
.gdb_history
dumps
Credits.rtf
*.mshark

   + .project
     
    6565         * @param name String containing the name of the child to create a new node.
    6666         */
    6767        virtual AbstractFilesystemNode *getChild(const String &name) const = 0;
    68 
     68       
    6969        /**
    7070         * The parent node of this directory.
    7171         * The parent of the root is the root itself.
    … …  
    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

     
    5656        String _sPath;
    5757        bool _bIsDirectory;
    5858        bool _bIsValid;
    59 
     59       
    6060public:
    6161        /**
    6262         * Creates a AmigaOSFilesystemNode with the root node as path.
    … …  
    8989
    9090        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    9191        virtual String getDisplayName() const { return _sDisplayName; };
    92         virtual String getName() const { return _sDisplayName; };
     92        virtual String getName() const;
    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?
    112 /**
    113  * Returns the last component of a given path.
    114  *
    115  * @param str String containing the path.
    116  * @return Pointer to the first char of the last component inside str.
    117  */
    118 const char *lastPathComponent(const Common::String &str) {
    119         int offset = str.size();
    120         const char *p = str.c_str();
    121 
    122         while (offset > 0 && (p[offset-1] == '/' || p[offset-1] == ':'))
    123                 offset--;
    124 
    125         while (offset > 0 && (p[offset-1] != '/' && p[offset-1] != ':'))
    126                 offset--;
    127 
    128         return p + offset;
    129 }
    130 
    131108AmigaOSFilesystemNode::AmigaOSFilesystemNode() {
    132109        ENTER();
    133110        _sDisplayName = "Available Disks";
    … …  
    151128        }
    152129
    153130        _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);
     131        _sDisplayName = getName();
    167132        _pFileLock = 0;
    168133        _bIsDirectory = false;
    169134
    … …  
    352317                                                if (lock) {
    353318                                                        AmigaOSFilesystemNode *entry = new AmigaOSFilesystemNode(lock, (char *)ead->ed_Name);
    354319                                                        if (entry) {
    355                                                                 if (entry->isValid())
     320                                                                //FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
     321                                                                //       specification, the following call had to be changed:
     322                                                                //              if (entry->isValid())
     323                                                                //               Please verify that the logic of the code remains coherent. Also, remember
     324                                                                //               that the isReadable() and isWritable() methods are available.
     325                                                                if (entry->exists())
    356326                                                                    myList.push_back(entry);
    357327                                                                else
    358328                                                                        delete entry;
    … …  
    375345        return true;
    376346}
    377347
     348Common::String AmigaOSFilesystemNode::getName() const {
     349        if (_sPath == "")
     350                        return "";
     351       
     352        int offset = _sPath.size();
     353       
     354        if (offset <= 0) {
     355                debug(6, "Bad offset");
     356                return;
     357        }
     358       
     359        const char *str = _sPath.c_str();
     360
     361        while (offset > 0 && (str[offset-1] == '/' || str[offset-1] == ':'))
     362                offset--;
     363
     364        while (offset > 0 && (str[offset-1] != '/' && str[offset-1] != ':')) {
     365                len++;
     366                offset--;
     367        }
     368
     369        return Common::String(str + offset, len);
     370}
     371
    378372AbstractFilesystemNode *AmigaOSFilesystemNode::getParent() const {
    379373        ENTER();
    380374
    … …  
    453447
    454448                                AmigaOSFilesystemNode *entry = new AmigaOSFilesystemNode(volumeLock, buffer);
    455449                                if (entry) {
    456                                         if (entry->isValid())
     450                                        //FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
     451                                        //       specification, the following call had to be changed:
     452                                        //              if (entry->isValid())
     453                                        //               Please verify that the logic of the code remains coherent. Also, remember
     454                                        //               that the isReadable() and isWritable() methods are available.
     455                                        if(entry->exists())
    457456                                                myList.push_back(entry);
    458457                                        else
    459458                                                delete entry;

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

     
    5858
    5959        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    6060        virtual String getDisplayName() const { return _displayName; }
    61         virtual String getName() const { return _displayName; }
     61        virtual String getName() const;
    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;
    … …  
    7069        virtual AbstractFilesystemNode *getParent() const;
    7170};
    7271
    73 /**
    74  * Returns the last component of a given path.
    75  *
    76  * Examples:
    77  *                      /foo/bar.txt would return /bar.txt
    78  *                      /foo/bar/    would return /bar/
    79  * 
    80  * @param str String containing the path.
    81  * @return Pointer to the first char of the last component inside str.
    82  */
    83 const char *lastPathComponent(const Common::String &str) {
    84         const char *start = str.c_str();
    85         const char *cur = start + str.size() - 2;
    86 
    87         while (cur >= start && *cur != '/') {
    88                 --cur;
    89         }
    90 
    91         return cur + 1;
    92 }
    93 
    9472RoninCDFilesystemNode::RoninCDFilesystemNode() {
    9573        // The root dir.
    9674        _path = "/";
    … …  
    10381        assert(p.size() > 0);
    10482
    10583        _path = p;
    106         _displayName = lastPathComponent(_path);
     84        _displayName = getName();
    10785        _isValid = true;
    10886        _isDirectory = true;
    10987
    … …  
    178156        return true;
    179157}
    180158
     159/**
     160 * Returns the last component of _path.
     161 *
     162 * Examples:
     163 *                      /foo/bar.txt would return /bar.txt
     164 *                      /foo/bar/    would return /bar/
     165 */
     166String RoninCDFilesystemNode::getName() const {
     167        if (_path == "")
     168                        return "";
     169       
     170        const char *start = _path.c_str();
     171        const char *cur = start + _path.size() - 2;
     172
     173        while (cur >= start && *cur != '/') {
     174                --cur;
     175        }
     176
     177        return String(cur + 1);
     178}
     179
    181180AbstractFilesystemNode *RoninCDFilesystemNode::getParent() const {
    182181        if (_path == "/")
    183182                return 0;
    … …  
    183182                return 0;
    184183
    185184        const char *start = _path.c_str();
    186         const char *end = lastPathComponent(_path);
     185        const char *end = getName().c_str();
    187186
    188187        return new RoninCDFilesystemNode(String(start, end - start), false);
    189188}

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

     
    3737char            currentDir[128];
    3838
    3939DSFileSystemNode::DSFileSystemNode() {
     40        _path = "ds:/";
    4041        _displayName = "ds:/";
    41         _path = "ds:/";
    4242        _isValid = true;
    4343        _isDirectory = true;
    44         _path = "ds:/";
    4544
    4645/*      if (!_archive) {
    4746                _archive = (GBFS_FILE *) find_first_gbfs_file(scummdata);
    … …  
    5655DSFileSystemNode::DSFileSystemNode(const String& path) {
    5756//      consolePrintf("--%s ",path.c_str());
    5857       
    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);
    7258        _path = path;
     59        _displayName = getName();
    7360//      _isValid = true;
    7461//      _isDirectory = false;
    7562
     63        char* pathStr = (char *) path.c_str();
    7664        if (!strncmp(pathStr, "ds:/", 4)) {
    7765                pathStr += 4;
    7866        }
    … …  
    9987DSFileSystemNode::DSFileSystemNode(const String& path, bool isDir) {
    10088//      consolePrintf("--%s ",path.c_str());
    10189       
    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);
    11490        _path = path;
     91        _displayName = getName();
    11592        _isValid = true;
    11693        _isDirectory = isDir;
    11794       
    … …  
    179156        return true;
    180157}
    181158
     159String DSFileSystemNode::getName() const {
     160        if (_path == "")
     161                return "";
     162       
     163        char disp[128];
     164        char* pathStr = (char *) _path.c_str();
     165        int lastSlash = 3;
     166       
     167        for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
     168                if (path[r] == '\\') {
     169                        lastSlash = r;
     170                }
     171        }
     172       
     173        strcpy(disp, pathStr + lastSlash + 1);
     174       
     175        return String(disp);
     176}
     177
    182178AbstractFilesystemNode* DSFileSystemNode::getParent() const {
    183179//      consolePrintf("parent\n");
    184180        DSFileSystemNode *p;
    … …  
    207203//////////////////////////////////////////////////////////////////////////
    208204
    209205GBAMPFileSystemNode::GBAMPFileSystemNode() {
     206        _path = "mp:/";
    210207        _displayName = "mp:/";
    211         _path = "mp:/";
    212208        _isValid = true;
    213209        _isDirectory = true;
    214         _path = "mp:/";
    215210}
    216211
    217212GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path) {
    … …  
    217212GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path) {
    218213//      consolePrintf("'%s'",path.c_str());
    219214       
    220         char disp[128];
    221         char* pathStr = (char *) path.c_str();
    222         int lastSlash = 3;
    223         for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
    224                 if ((path[r] == '\\') || (path[r] == '/')) {
    225                         lastSlash = r;
    226                 }
    227         }
    228        
    229         strcpy(disp, pathStr + lastSlash + 1);
    230 
    231215        char check[128];
    232216        int success;
    233217       
    … …  
    243227        }
    244228//      consolePrintf("Path: %s  (%d)\n", check, success);
    245229       
    246         _displayName = String(disp);
    247230        _path = path;
     231        _displayName = getName();
    248232        _isValid = success == FT_FILE;
    249233        _isDirectory = success == FT_DIR;
    250234}
    … …  
    252236GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path, bool isDirectory) {
    253237//      consolePrintf("'%s'",path.c_str());
    254238       
    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);
    267239        _path = path;
     240        _displayName = getName();
    268241        _isValid = true;
    269242        _isDirectory = isDirectory;
    270243}
    … …  
    340313        return true;
    341314}
    342315
     316String GBAMPFileSystemNode::getName() const {
     317        if (_path == "")
     318                return "";
     319       
     320        char disp[128];
     321        char* pathStr = (char *) _path.c_str();
     322        int lastSlash = 3;
     323       
     324        for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
     325                if ((path[r] == '\\') || (path[r] == '/')) {
     326                        lastSlash = r;
     327                }
     328        }
     329       
     330        strcpy(disp, pathStr + lastSlash + 1);
     331       
     332        return String(disp);
     333}
     334
    343335AbstractFilesystemNode* GBAMPFileSystemNode::getParent() const {
    344336//      consolePrintf("parent\n");
    345337        GBAMPFileSystemNode *p;

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

     
    7979       
    8080        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    8181        virtual String getDisplayName() const {  return _displayName; }
    82         virtual String getName() const {  return _displayName; }
     82        virtual String getName() const;
    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        /**
    … …  
    145144
    146145        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    147146        virtual String getDisplayName() const {  return _displayName; }
    148         virtual String getName() const {  return _displayName; }
     147        virtual String getName() const;
    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

     
    5454
    5555        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    5656        virtual String getDisplayName() const { return _displayName; }
    57         virtual String getName() const { return _displayName; }
     57        virtual String getName() const;
    5858        virtual String getPath() const { return _path; }
    5959        virtual bool isDirectory() const { return _isDirectory; }
    6060        // FIXME: isValid should return false if this Node can't be used!
    … …  
    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;
    … …  
    7271//char gpCurrentPath[MAX_PATH_SIZE] = "gp:\\";          // must end with '\'
    7372
    7473/**
    75  * Returns the last component of a given path.
    76  *
    77  * Examples:
    78  *                      gp:\foo\bar.txt would return "\bar.txt"
    79  *                      gp:\foo\bar\    would return "\bar\"
    80  * 
    81  * @param str Path to obtain the last component from.
    82  * @return Pointer to the first char of the last component inside str.
    83  */
    84 const char *lastPathComponent(const Common::String &str) {
    85         const char *start = str.c_str();
    86         const char *cur = start + str.size() - 2;
    87 
    88         while (cur >= start && *cur != '\\') {
    89                 --cur;
    90         }
    91 
    92         return cur + 1;
    93 }
    94 
    95 /**
    9674 * FIXME: document this function.
    9775 *
    9876 * @param path
    … …  
    239217        return true;
    240218}
    241219
     220/**
     221 * Returns the last component of _path.
     222 *
     223 * Examples:
     224 *                      gp:\foo\bar.txt would return "\bar.txt"
     225 *                      gp:\foo\bar\    would return "\bar\"
     226 */
     227String GP32FilesystemNode::getName() const {
     228        if (_path == "")
     229                return "";
     230       
     231        const char *start = _path.c_str();
     232        const char *cur = start + _path.size() - 2;
     233
     234        while (cur >= start && *cur != '\\') {
     235                --cur;
     236        }
     237
     238        return String(cur + 1);
     239}
     240
    242241AbstractFilesystemNode *GP32FilesystemNode::getParent() const {
    243242        if (_isRoot)
    244243                return 0;
    … …  
    244243                return 0;
    245244
    246245        const char *start = _path.c_str();
    247         const char *end = lastPathComponent(_path);
     246        const char *end = getName().c_str();
    248247
    249248        GP32FilesystemNode *p = new GP32FilesystemNode(String(start, end - start));
    250249

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

     
    4545        String _path;
    4646        bool _isDirectory;
    4747        bool _isValid;
    48 
     48       
    4949public:
    5050        /**
    5151         * Creates a ABoxFilesystemNode with the root node as path.
    … …  
    7676
    7777        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    7878        virtual String getDisplayName() const { return _displayName; }
    79         virtual String getName() const { return _displayName; };
     79        virtual String getName() const;
    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;
    … …  
    9594
    9695ABoxFilesystemNode::ABoxFilesystemNode()
    9796{
     97        _path = "";
    9898        _displayName = "Mounted Volumes";
    9999        _isValid = true;
    100100        _isDirectory = true;
    101         _path = "";
    102101        _lock = NULL;
    103102}
    104103
    … …  
    108107        assert(offset > 0);
    109108
    110109        _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);
     110        _displayName = getName();
    121111        _lock = NULL;
    122112        _isDirectory = false;
    123113
    … …  
    127117                debug(6, "FileInfoBlock is NULL");
    128118                return;
    129119        }
    130 
     120       
    131121        // Check whether the node exists and if it is a directory
    132122        BPTR pLock = Lock((STRPTR)_path.c_str(), SHARED_LOCK);
    133123        if (pLock)
    … …  
    212202
    213203ABoxFilesystemNode::ABoxFilesystemNode(const ABoxFilesystemNode& node)
    214204{
     205        _path = node._path;
    215206        _displayName = node._displayName;
    216207        _isValid = node._isValid;
    217208        _isDirectory = node._isDirectory;
    218         _path = node._path;
    219209        _lock = DupLock(node._lock);
    220210}
    221211
    … …  
    299289                                        entry = new ABoxFilesystemNode(lock, fib->fib_FileName);
    300290                                        if (entry)
    301291                                        {
    302                                                 if (entry->isValid())
     292                                                //FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
     293                                                //       specification, the following call had to be changed:
     294                                                //              if (entry->isValid())
     295                                                //               Please verify that the logic of the code remains coherent. Also, remember
     296                                                //               that the isReadable() and isWritable() methods are available.
     297                                                if (entry->exists())
    303298                                                        list.push_back(entry);
    304299                                                else
    305300                                                        delete entry;
    … …  
    318313        return true;
    319314}
    320315
     316String ABoxFilesystemNode::getName() const {
     317        if (_path == "")
     318                return "";
     319       
     320        const char *str = _path.c_str();
     321        while (offset > 0 && (str[offset-1] == '/' || str[offset-1] == ':') )
     322                offset--;
     323        while (offset > 0 && (str[offset-1] != '/' && str[offset-1] != ':')) {
     324                len++;
     325                offset--;
     326        }
     327       
     328        return String(str + offset, len);
     329}
     330
    321331AbstractFilesystemNode *ABoxFilesystemNode::getParent() const
    322332{
    323333        AbstractFilesystemNode *node = NULL;
    … …  
    378388                                entry = new ABoxFilesystemNode(volume_lock, name);
    379389                                if (entry)
    380390                                {
    381                                         if (entry->isValid())
     391                                        //FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
     392                                        //       specification, the following call had to be changed:
     393                                        //              if (entry->isValid())
     394                                        //               Please verify that the logic of the code remains coherent. Also, remember
     395                                        //               that the isReadable() and isWritable() methods are available.
     396                                        if (entry->exists())
    382397                                                list.push_back(entry);
    383398                                        else
    384399                                                delete entry;

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

     
    5757
    5858        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    5959        virtual String getDisplayName() const { return _displayName; }
    60         virtual String getName() const { return _displayName; }
     60        virtual String getName() const;
    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;
    … …  
    8180        static void addFile(AbstractFSList &list, ListMode mode, const Char *base, FileInfoType* find_data);
    8281};
    8382
    84 /**
    85  * Returns the last component of a given path.
    86  *
    87  * Examples:
    88  *                      /foo/bar.txt would return /bar.txt
    89  *                      /foo/bar/    would return /bar/
    90  * 
    91  * @param str String containing the path.
    92  * @return Pointer to the first char of the last component inside str.
    93  */
    94 const char *lastPathComponent(const Common::String &str) {
    95         const char *start = str.c_str();
    96         const char *cur = start + str.size() - 2;
    97 
    98         while (cur >= start && *cur != '/') {
    99                 --cur;
    100         }
    101 
    102         return cur + 1;
    103 }
    104 
    10583void PalmOSFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const char *base, FileInfoType* find_data) {
    10684        PalmOSFilesystemNode entry;
    10785        bool isDir;
    … …  
    136114
    137115PalmOSFilesystemNode::PalmOSFilesystemNode(const String &p) {
    138116        _path = p;
    139         _displayName = lastPathComponent(p);
     117        _displayName = getName();
    140118
    141119        UInt32 attr;
    142120        FileRef handle;
    … …  
    208186        return true;
    209187}
    210188
     189/**
     190 * Returns the last component of _path.
     191 *
     192 * Examples:
     193 *                      /foo/bar.txt would return /bar.txt
     194 *                      /foo/bar/    would return /bar/
     195 */
     196Common::String PalmOSFilesystemNode::getName() const {
     197        if (_path == "")
     198                return "";
     199       
     200        const char *start = _path.c_str();
     201        const char *cur = start + _path.size() - 2;
     202
     203        while (cur >= start && *cur != '/') {
     204                --cur;
     205        }
     206
     207        return Common::String(cur + 1);
     208}
     209
    211210AbstractFilesystemNode *PalmOSFilesystemNode::getParent() const {
    212211        PalmOSFilesystemNode *p = 0;
    213212       
    … …  
    213212       
    214213        if (!_isPseudoRoot) {
    215214                const char *start = _path.c_str();
    216                 const char *end = lastPathComponent(_path);
     215                const char *end = getName().c_str();
    217216       
    218217                p = new PalmOSFilesystemNode();
    219218                p->_path = String(start, end - start);
    … …  
    219218                p->_path = String(start, end - start);
    220219                p->_isValid = true;
    221220                p->_isDirectory = true;
    222                 p->_displayName = lastPathComponent(p->_path);
     221                p->_displayName = p->getName();
    223222                p->_isPseudoRoot =(p->_path == "/");
    224223        }
    225224       

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

     
    4646        String _path;
    4747        bool _isDirectory;
    4848        bool _isValid;
    49 
     49       
    5050public:
    5151        /**
    5252         * Creates a POSIXFilesystemNode with the root node as path.
    … …  
    6363       
    6464        virtual bool exists() const { return access(_path.c_str(), F_OK) == 0; }
    6565        virtual String getDisplayName() const { return _displayName; }
    66         virtual String getName() const { return _displayName; }
     66        virtual String getName() const;
    6767        virtual String getPath() const { return _path; }
    6868        virtual bool isDirectory() const { return _isDirectory; }
    6969        virtual bool isReadable() const { return access(_path.c_str(), R_OK) == 0; }
    … …  
    8080        virtual void setFlags();
    8181};
    8282
    83 /**
    84  * Returns the last component of a given path.
    85  *
    86  * Examples:
    87  *                      /foo/bar.txt would return /bar.txt
    88  *                      /foo/bar/    would return /bar/
    89  * 
    90  * @param str String containing the path.
    91  * @return Pointer to the first char of the last component inside str.
    92  */
    93 const char *lastPathComponent(const Common::String &str) {
    94         const char *start = str.c_str();
    95         const char *cur = start + str.size() - 2;
    96 
    97         while (cur >= start && *cur != '/') {
    98                 --cur;
    99         }
    100 
    101         return cur + 1;
    102 }
    103 
    10483void POSIXFilesystemNode::setFlags() {
    10584        struct stat st;
    10685       
    … …  
    141120        assert(p.size() > 0);
    142121
    143122        _path = p;
    144         _displayName = lastPathComponent(_path);
     123        _displayName = getName();
    145124
    146125        if (verify) {
    147126                setFlags();
    … …  
    235214        return true;
    236215}
    237216
     217/**
     218 * Returns the last component of _path.
     219 *
     220 * Examples:
     221 *                      /foo/bar.txt would return /bar.txt
     222 *                      /foo/bar/    would return /bar/
     223 */
     224Common::String POSIXFilesystemNode::getName() const {
     225        if (_path == "")
     226                return "";
     227       
     228        const char *start = _path.c_str();
     229        const char *cur = start + _path.size() - 2;
     230
     231        while (cur >= start && *cur != '/') {
     232                --cur;
     233        }
     234       
     235        return Common::String(cur + 1);
     236}
     237
    238238AbstractFilesystemNode *POSIXFilesystemNode::getParent() const {
    239239        if (_path == "/")
    240240                return 0;
    … …  
    240240                return 0;
    241241
    242242        const char *start = _path.c_str();
    243         const char *end = lastPathComponent(_path);
     243        const char *end = getName().c_str();
    244244
    245245        return new POSIXFilesystemNode(String(start, end - start), true);
    246246}

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

     
    4343        String _path;
    4444        bool _isDirectory;
    4545        bool _isRoot;
    46 
     46       
    4747public:
    4848        /**
    4949         * Creates a PS2FilesystemNode with the root node as path.
    … …  
    6464
    6565        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    6666        virtual String getDisplayName() const { return _displayName; }
    67         virtual String getName() const { return _displayName; }
     67        virtual String getName() const;
    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); }
    … …  
    218217        }
    219218}
    220219
     220String *Ps2FilesystemNode::getName() const {
     221        //FIXME: implement this method properly
     222        assert(false);
     223}
     224
    221225AbstractFilesystemNode *Ps2FilesystemNode::getParent() const {
    222226        if (_isRoot)
    223227                return new Ps2FilesystemNode(this);

  • 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;
    … …  
    7271        virtual AbstractFilesystemNode *getParent() const;
    7372};
    7473
    75 /**
    76  * Returns the last component of a given path.
    77  *
    78  * Examples:
    79  *                      /foo/bar.txt would return /bar.txt
    80  *                      /foo/bar/    would return /bar/
    81  * 
    82  * @param str String containing the path.
    83  * @return Pointer to the first char of the last component inside str.
    84  */
    85 const char *lastPathComponent(const Common::String &str) {
    86         const char *start = str.c_str();
    87         const char *cur = start + str.size() - 2;
    88 
    89         while (cur >= start && *cur != '/') {
    90                 --cur;
    91         }
    92 
    93         return cur + 1;
    94 }
    95 
    9674PSPFilesystemNode::PSPFilesystemNode() {
    9775        _isDirectory = true;
    9876        _displayName = "Root";
    … …  
    10482        assert(p.size() > 0);
    10583       
    10684        _path = p;
    107         _displayName = lastPathComponent(_path);
     85        _displayName = getName();
    10886        _isValid = true;
    10987        _isDirectory = true;
    11088
    … …  
    169147        }
    170148}
    171149
     150/**
     151 * Returns the last component of _path.
     152 *
     153 * Examples:
     154 *                      /foo/bar.txt would return /bar.txt
     155 *                      /foo/bar/    would return /bar/
     156 */
     157String PSPFilesystemNode::getName() const {
     158        if (_path == "")
     159                return "";
     160       
     161        const char *start = _path.c_str();
     162        const char *cur = start + _path.size() - 2;
     163
     164        while (cur >= start && *cur != '/') {
     165                --cur;
     166        }
     167
     168        return String(cur + 1);
     169}
     170
    172171AbstractFilesystemNode *PSPFilesystemNode::getParent() const {
    173         assert(_isValid);
     172        //assert(_isValid);
    174173       
    175174        if (_path == ROOT_PATH)
    176175                return 0;
    … …  
    176175                return 0;
    177176       
    178177        const char *start = _path.c_str();
    179         const char *end = lastPathComponent(_path);
     178        const char *end = getName().c_str();
    180179       
    181180        return new PSPFilesystemNode(String(start, end - start), false);
    182181}

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

     
    4242        bool _isDirectory;
    4343        bool _isValid;
    4444        bool _isPseudoRoot;
    45 
     45       
    4646public:
    4747        /**
    4848         * Creates a SymbianFilesystemNode with the root node as path.
    … …  
    6060       
    6161        virtual bool exists() const { return true; }            //FIXME: this is just a stub
    6262        virtual String getDisplayName() const { return _displayName; }
    63         virtual String getName() const { return _displayName; }
     63        virtual String getName() const;
    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;
    … …  
    7372};
    7473
    7574/**
    76  * Returns the last component of a given path.
    77  *
    78  * Examples:
    79  *                      c:\foo\bar.txt would return "\bar.txt"
    80  *                      c:\foo\bar\    would return "\bar\"
    81  * 
    82  * @param str Path to obtain the last component from.
    83  * @return Pointer to the first char of the last component inside str.
    84  */
    85 const char *lastPathComponent(const Common::String &str) {
    86         const char *start = str.c_str();
    87         const char *cur = start + str.size() - 2;
    88 
    89         while (cur >= start && *cur != '\\') {
    90                 --cur;
    91         }
    92 
    93         return cur + 1;
    94 }
    95 
    96 /**
    9775 * Fixes the path by changing all slashes to backslashes.
    9876 *
    9977 * @param path String with the path to be fixed.
    … …  
    127105       
    128106        fixFilePath(_path);
    129107
    130         _displayName = lastPathComponent(_path);
     108        _displayName = getName();
    131109
    132110        TEntry fileAttribs;
    133111        TFileName fname;
    … …  
    240218        return true;
    241219}
    242220
     221/**
     222 * Returns the last component of _path.
     223 *
     224 * Examples:
     225 *                      c:\foo\bar.txt would return "\bar.txt"
     226 *                      c:\foo\bar\    would return "\bar\"
     227 */
     228Common::String SymbianFilesystemNode::getName() {
     229        if (_path == "")
     230                return "";
     231       
     232        const char *start = _path.c_str();
     233        const char *cur = start + _path.size() - 2;
     234
     235        while (cur >= start && *cur != '\\') {
     236                --cur;
     237        }
     238
     239        return Common::String(cur + 1);
     240}
     241
    243242AbstractFilesystemNode *SymbianFilesystemNode::getParent() const {
    244243        SymbianFilesystemNode *p =NULL;
    245244
    … …  
    248247        if (!_isPseudoRoot && _path.size() > 3) {
    249248                p = new SymbianFilesystemNode(false);
    250249                const char *start = _path.c_str();
    251                 const char *end = lastPathComponent(_path);
     250                const char *end = getName().c_str();
    252251
    253252                p->_path = String(start, end - start);
    254253                p->_isValid = true;
    … …  
    253252                p->_path = String(start, end - start);
    254253                p->_isValid = true;
    255254                p->_isDirectory = true;
    256                 p->_displayName = lastPathComponent(p->_path);
     255                p->_displayName = p->getName();
    257256        }
    258257        else
    259258        {

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

     
    6363        bool _isDirectory;
    6464        bool _isPseudoRoot;
    6565        bool _isValid;
    66 
     66       
    6767public:
    6868        /**
    6969         * Creates a WindowsFilesystemNode with the root node as path.
    … …  
    8888
    8989        virtual bool exists() const { return _access(_path.c_str(), F_OK) == 0; }
    9090        virtual String getDisplayName() const { return _displayName; }
    91         virtual String getName() const { return _displayName; }
     91        virtual String getName() const;
    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;
    … …  
    128127        static const TCHAR* toUnicode(const char *str);
    129128};
    130129
    131 /**
    132  * Returns the last component of a given path.
    133  *
    134  * Examples:
    135  *                      c:\foo\bar.txt would return "\bar.txt"
    136  *                      c:\foo\bar\    would return "\bar\"
    137  *
    138  * @param str Path to obtain the last component from.
    139  * @return Pointer to the first char of the last component inside str.
    140  */
    141 const char *lastPathComponent(const Common::String &str) {
    142         const char *start = str.c_str();
    143         const char *cur = start + str.size() - 2;
    144 
    145         while (cur >= start && *cur != '\\') {
    146                 --cur;
    147         }
    148 
    149         return cur + 1;
    150 }
    151 
    152130void WindowsFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const char *base, WIN32_FIND_DATA* find_data) {
    153131        WindowsFilesystemNode entry;
    154132        char *asciiName = toAscii(find_data->cFileName);
    … …  
    222200                assert(p.size() > 0);
    223201                _path = p;
    224202        }
    225 
    226         _displayName = lastPathComponent(_path);
     203       
     204        _displayName = getName();
    227205
    228206        // Check whether it is a directory, and whether the file actually exists
    229207        DWORD fileAttribs = GetFileAttributes(toUnicode(_path.c_str()));
    … …  
    309287        return true;
    310288}
    311289
     290/**
     291 * Returns the last component of _path.
     292 *
     293 * Examples:
     294 *                      c:\foo\bar.txt would return "\bar.txt"
     295 *                      c:\foo\bar\    would return "\bar\"
     296 */
     297String WindowsFilesystemNode::getName() const {
     298        if (_path == "")
     299                return "";
     300       
     301        const char *start = _path.c_str();
     302        const char *cur = start + _path.size() - 2;
     303
     304        while (cur >= start && *cur != '\\') {
     305                --cur;
     306        }
     307
     308        return String(cur + 1);
     309}
     310
    312311AbstractFilesystemNode *WindowsFilesystemNode::getParent() const {
    313312        assert(_isValid || _isPseudoRoot);
    314313
    … …  
    318317        WindowsFilesystemNode *p = new WindowsFilesystemNode();
    319318        if (_path.size() > 3) {
    320319                const char *start = _path.c_str();
    321                 const char *end = lastPathComponent(_path);
     320                const char *end = getName().c_str();
    322321
    323322                p = new WindowsFilesystemNode();
    324323                p->_path = String(start, end - start);
    … …  
    324323                p->_path = String(start, end - start);
    325324                p->_isValid = true;
    326325                p->_isDirectory = true;
    327                 p->_displayName = lastPathComponent(p->_path);
     326                p->_displayName = p->getName);
    328327                p->_isPseudoRoot = false;
    329328        }
    330329

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

     
    2626#include "backends/fs/abstract-fs.h"
    2727#include "backends/fs/abstract-fs-factory.h"
    2828
    29 /**
    30  * Simple DOS-style pattern matching function (understands * and ? like used in DOS).
    31  * Taken from exult/files/listfiles.cc
    32  */
    33 static bool matchString(const char *str, const char *pat) {
    34         const char *p = 0;
    35         const char *q = 0;
    36 
    37         for (;;) {
    38                 switch (*pat) {
    39                 case '*':
    40                         p = ++pat;
    41                         q = str;
    42                         break;
    43 
    44                 default:
    45                         if (*pat != *str) {
    46                                 if (p) {
    47                                         pat = p;
    48                                         str = ++q;
    49                                         if (!*str)
    50                                                 return !*pat;
    51                                         break;
    52                                 }
    53                                 else
    54                                         return false;
    55                         }
    56                         // fallthrough
    57                 case '?':
    58                         if (!*str)
    59                                 return !*pat;
    60                         pat++;
    61                         str++;
    62                 }
    63         }
    64 }
    65 
    6629FilesystemNode::FilesystemNode() {
    6730        _realNode = 0;
    6831        _refCount = 0;
    … …  
    233196        return ((matches > 0) ? true : false);
    234197}
    235198
    236 // HACK HACK HACK
    237 extern const char *lastPathComponent(const Common::String &str);
    238 
    239199int FilesystemNode::lookupFileRec(FSList &results, FilesystemNode &dir, Common::String &filename, bool hidden, bool exhaustive) const
    240200{
    241201        FSList entries;
    … …  
    242202        FSList children;
    243203        int matches = 0;
    244204        dir.getChildren(entries, FilesystemNode::kListAll, hidden);
    245 
     205       
    246206        //Breadth search (entries in the same level)
    247207        for (FSList::iterator entry = entries.begin(); entry != entries.end(); ++entry) {
    248208                if (entry->isDirectory()) {
    … …  
    248208                if (entry->isDirectory()) {
    249209                        children.push_back(*entry);
    250210                } else {
    251                         //TODO: here we assume all backends implement the lastPathComponent method. It is currently static,
    252                         //              so it might be a good idea to include it inside the backend class. This would enforce its
    253                         //              implementation by all ports.
    254                         if (matchString(lastPathComponent(entry->getPath()), filename.c_str())) {
     211                        if (Common::matchString(entry->getName().c_str(), filename.c_str())) {
    255212                                results.push_back(*entry);
    256213                                matches++;
    257214

  • home/david/Projects/scummvm/common/util.cpp

     
    6161
    6262namespace Common {
    6363
     64bool matchString(const char *str, const char *pat) {
     65        const char *p = 0;
     66        const char *q = 0;
     67
     68        for (;;) {
     69                switch (*pat) {
     70                case '*':
     71                        p = ++pat;
     72                        q = str;
     73                        break;
     74
     75                default:
     76                        if (*pat != *str) {
     77                                if (p) {
     78                                        pat = p;
     79                                        str = ++q;
     80                                        if (!*str)
     81                                                return !*pat;
     82                                        break;
     83                                }
     84                                else
     85                                        return false;
     86                        }
     87                        // fallthrough
     88                case '?':
     89                        if (!*str)
     90                                return !*pat;
     91                        pat++;
     92                        str++;
     93                }
     94        }
     95}
     96
    6497//
    6598// Print hexdump of the data passed in
    6699//

  • home/david/Projects/scummvm/common/util.h

     
    5353namespace Common {
    5454
    5555/**
     56 * Simple DOS-style pattern matching function (understands * and ? like used in DOS).
     57 * Taken from exult/files/listfiles.cc
     58 *
     59 * Token meaning:
     60 *              "*": any character, any amount of times.
     61 *              "?": any character, only once.
     62 *
     63 * Example strings/patterns:
     64 *              String: monkey.s??       Pattern: monkey.s01    => true
     65 *              String: monkey.s??       Pattern: monkey.s99    => true
     66 *              String: monkey.s??       Pattern: monkey.s101   => false
     67 *              String: monkey.s?1       Pattern: monkey.s01    => true
     68 *              String: monkey.s?1       Pattern: monkey.s99    => false
     69 *              String: monkey.s?1       Pattern: monkey.s101   => false
     70 *              String: monkey.s*        Pattern: monkey.s01    => true
     71 *              String: monkey.s*        Pattern: monkey.s99    => true
     72 *              String: monkey.s*        Pattern: monkey.s101   => true
     73 *              String: monkey.s*1       Pattern: monkey.s01    => true
     74 *              String: monkey.s*1       Pattern: monkey.s99    => false
     75 *              String: monkey.s*1       Pattern: monkey.s101   => true
     76 *
     77 * @param str Text to be matched against the given pattern.
     78 * @param pat Glob pattern.
     79 *
     80 * @return true if str matches the pattern, false otherwise.
     81 */
     82bool matchString(const char *str, const char *pat);
     83
     84/**
    5685 * Print a hexdump of the data passed in. The number of bytes per line is
    5786 * customizable.
    5887 * @param data  the data to be dumped