Ignore:
Timestamp:
Nov 30, 2009, 6:52:30 PM (16 years ago)
Author:
Dmitry A. Kuminov
Message:

global: Reverted r355, r356, r361, r362 (see #78).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/corelib/io/qfsfileengine_os2.cpp

    r361 r363  
    650650static bool isRelativePath(const QString &path)
    651651{
    652         // On OS/2, "A:bbb.txt" and "/ccc.dat" are relative paths
    653     return !(path.startsWith(QLatin1String("//")) ||
    654              (path.length() >= 2 && path.at(0).isLetter() &&
    655               path.at(1) == QLatin1Char(':') &&
    656               // we treat "D:" as absolute while "D:aaa" as relative
    657               (path.length() == 2 || path.at(2) == QLatin1Char('/'))));
     652    return !(path.startsWith(QLatin1Char('/'))
     653        || (path.length() >= 2
     654        && ((path.at(0).isLetter() && path.at(1) == QLatin1Char(':'))
     655        || (path.at(0) == QLatin1Char('/') && path.at(1) == QLatin1Char('/')))));                // drive, e.g. a:
    658656}
    659657
     
    688686    } else if(file == AbsoluteName || file == AbsolutePathName) {
    689687        QString ret;
    690         if (isRelativePath()) {
    691             if ((d->filePath.size() > 2 && d->filePath.at(1) == QLatin1Char(':') &&
    692                  d->filePath.at(2) != QLatin1Char('/')) ||    // path relative to the current dir of the given drive, so Z:a.txt -> Z:\currentpath\a.txt
    693                 (d->filePath.startsWith(QLatin1Char('/')))) { // path relative to the root of the current drive, so \a.txt -> Z:\a.txt
     688
     689        if (!isRelativePath()) {
     690            if (d->filePath.size() > 2 && d->filePath.at(1) == QLatin1Char(':')
     691                && d->filePath.at(2) != QLatin1Char('/') || // It's a drive-relative path, so Z:a.txt -> Z:\currentpath\a.txt
     692                d->filePath.startsWith(QLatin1Char('/'))    // It's a absolute path to the current drive, so \a.txt -> Z:\a.txt
     693                ) {
    694694                char buf[PATH_MAX+1];
    695695                strcpy(buf, QFile::encodeName(d->filePath).constData());
    696696                _abspath(buf, buf, sizeof(buf));
    697                 ret = QDir::cleanPath(QFile::decodeName(buf));
    698                 if (::isRelativePath(ret)) {
    699                     // still relative, this means we have "Z:aaa" but there is no such drive Z:
    700                     // just assume root is the current dir on Z:
    701                     Q_ASSERT(ret.at(1) == QLatin1Char(':'));
    702                     ret.insert(2, QLatin1Char('/'));
    703                 }
     697                ret = QFile::decodeName(buf);
    704698            } else {
    705                 ret = QDir::cleanPath(QDir::currentPath() + QLatin1Char('/') + d->filePath);
     699                ret = ;
    706700            }
    707701        } else {
    708             ret = d->filePath;
     702            ret = ;
    709703        }
    710704
    711705        // The path should be absolute at this point.
    712         // On OS/2, the absolute path always contains a "X:/" at the begining
    713         // where X is the drive letter, or "//" if it's a network share
    714         if (!ret.startsWith(QLatin1String("//"))) {
     706        // From the docs :
     707        // Absolute paths begin with the directory separator "/"
     708        // (optionally preceded by a drive specification under Windows).
     709        if (ret.at(0) != QLatin1Char('/')) {
    715710            Q_ASSERT(ret.length() >= 2);
    716711            Q_ASSERT(ret.at(0).isLetter());
    717712            Q_ASSERT(ret.at(1) == QLatin1Char(':'));
    718             if (ret.length() == 2) {
    719                 // we are missing the slash in the "drive root dir" case, append it
    720                 ret += QLatin1Char('/');
    721             } else {
    722                 Q_ASSERT(ret.at(2) == QLatin1Char('/'));
    723             }
    724713
    725714            // Force uppercase drive letters.
     
    729718        if (file == AbsolutePathName) {
    730719            int slash = ret.lastIndexOf(QLatin1Char('/'));
    731             if (!ret.startsWith(QLatin1String("//"))) {
    732                 Q_ASSERT(slash >= 2);
    733                 if (slash == 2)
    734                     ret = ret.left(3);  // include the slash if it's "X:/"
    735                 else
    736                     ret = ret.left(slash);
    737             } else {
    738                 Q_ASSERT(slash >= 1);
    739                 if (slash == 1)
    740                     ret = ret.left(3);  // include the slash if it's "//"
    741                 else
    742                     ret = ret.left(slash);
    743             }
     720            if (slash < 0)
     721                return ret;
     722            else if (ret.at(0) != QLatin1Char('/') && slash == 2)
     723                return ret.left(3);      // include the slash
     724            else
     725                return ret.left(slash > 0 ? slash : 1);
    744726        }
    745727        return ret;
     
    751733        if (!ret.isEmpty() && file == CanonicalPathName) {
    752734            int slash = ret.lastIndexOf(QLatin1Char('/'));
    753             if (!ret.startsWith(QLatin1String("//"))) {
    754                 Q_ASSERT(slash >= 2);
    755                 if (slash == 2)
    756                     ret = ret.left(3);  // include the slash if it's "X:/"
    757                 else
    758                     ret = ret.left(slash);
    759             } else {
    760                 Q_ASSERT(slash >= 1);
    761                 if (slash == 1)
    762                     ret = ret.left(3);  // include the slash if it's "//"
    763                 else
    764                     ret = ret.left(slash);
    765             }
     735            if (slash == -1)
     736                ret = QDir::currentPath();
     737            else if (slash == 0)
     738                ret = QLatin1String("/");
     739            ret = ret.left(slash);
    766740        }
    767741        return ret;
     
    774748                QString target = QDir::fromNativeSeparators(QFile::decodeName(QByteArray(buf)));
    775749                QString ret;
    776                 if (::isRelativePath(target)) {
    777                     if ((target.size() > 2 && target.at(1) == QLatin1Char(':') &&
    778                          target.at(2) != QLatin1Char('/')) ||    // path relative to the current dir of the given drive, so Z:a.txt -> Z:\currentpath\a.txt
    779                         (target.startsWith(QLatin1Char('/')))) { // path relative to the root of the current drive, so \a.txt -> Z:\a.txt
     750                if (!::isRelativePath(target)) {
     751                    if (target.size() > 2 && target.at(1) == QLatin1Char(':')
     752                        && target.at(2) != QLatin1Char('/') || // It's a drive-relative path, so Z:a.txt -> Z:\currentpath\a.txt
     753                        target.startsWith(QLatin1Char('/'))    // It's a absolute path to the current drive, so \a.txt -> Z:\a.txt
     754                        ) {
    780755                        char buf[PATH_MAX+1];
    781756                        strcpy(buf, QFile::encodeName(target).constData());
    782757                        _abspath(buf, buf, sizeof(buf));
    783                         ret = QDir::cleanPath(QFile::decodeName(buf));
    784                         if (::isRelativePath(ret)) {
    785                             // still relative, this means we have "Z:aaa" but there is no such drive Z:
    786                             // just assume root is the current dir on Z:
    787                             Q_ASSERT(ret.at(1) == QLatin1Char(':'));
    788                             ret.insert(2, QLatin1Char('/'));
    789                         }
     758                        ret = QFile::decodeName(buf);
    790759                    } else {
    791                         if (S_ISDIR(d->st.st_mode)) {
    792                             QDir parent(d->filePath);
    793                             parent.cdUp();
    794                             ret = parent.path();
    795                             if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
    796                                 ret += QLatin1Char('/');
    797                         }
    798                         ret += target;
    799 
    800                         if (::isRelativePath(ret)) {
    801                             if (!isRelativePath()) {
    802                                 ret.prepend(d->filePath.left(d->filePath.lastIndexOf(QLatin1Char('/')))
    803                                             + QLatin1Char('/'));
    804                             } else {
    805                                 ret.prepend(QDir::currentPath() + QLatin1Char('/'));
    806                             }
    807                         }
    808                         ret = QDir::cleanPath(ret);
    809                         if (ret.size() > 1 && ret.endsWith(QLatin1Char('/')))
    810                             ret.chop(1);
     760                        ret = target;
    811761                    }
    812762                } else {
    813                     ret = target;
     763                    if (S_ISDIR(d->st.st_mode)) {
     764                        QDir parent(d->filePath);
     765                        parent.cdUp();
     766                        ret = parent.path();
     767                        if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
     768                            ret += QLatin1Char('/');
     769                    }
     770                    ret += target;
     771
     772                    if (::isRelativePath(ret)) {
     773                        if (!isRelativePath()) {
     774                            ret.prepend(d->filePath.left(d->filePath.lastIndexOf(QLatin1Char('/')))
     775                                        + QLatin1Char('/'));
     776                        } else {
     777                            ret.prepend(QDir::currentPath() + QLatin1Char('/'));
     778                        }
     779                    }
     780                    ret = QDir::cleanPath(ret);
     781                    if (ret.size() > 1 && ret.endsWith(QLatin1Char('/')))
     782                        ret.chop(1);
    814783                }
    815784
    816 
    817785                // The path should be absolute at this point.
    818                 // On OS/2, the absolute path always contains a "X:/" at the begining
    819                 // where X is the drive letter, or "//" if it's a network share
    820                 if (!ret.startsWith(QLatin1String("//"))) {
     786                // From the docs :
     787                // Absolute paths begin with the directory separator "/"
     788                // (optionally preceded by a drive specification under Windows).
     789                if (ret.at(0) != QLatin1Char('/')) {
    821790                    Q_ASSERT(ret.length() >= 2);
    822791                    Q_ASSERT(ret.at(0).isLetter());
    823792                    Q_ASSERT(ret.at(1) == QLatin1Char(':'));
    824                     if (ret.length() == 2) {
    825                         // we are missing the slash in the "drive root dir" case, append it
    826                         ret += QLatin1Char('/');
    827                     } else {
    828                         Q_ASSERT(ret.at(2) == QLatin1Char('/'));
    829                     }
    830793
    831794                    // Force uppercase drive letters.
Note: See TracChangeset for help on using the changeset viewer.