1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the qmake application of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #ifndef CACHEKEYS_H

    43 #define CACHEKEYS_H

    44 

    45 #include "project.h"

    46 #include <qstring.h>

    47 #include <qstringlist.h>

    48 #include <qfile.h>

    49 #include <qfileinfo.h>

    50 #include <qhash.h>

    51 

    52 QT_BEGIN_NAMESPACE

    53 

    54 // -------------------------------------------------------------------------------------------------

    55 struct FixStringCacheKey

    56 {

    57     mutable uint hash;

    58     QString string, pwd;

    59     uchar flags;

    60     FixStringCacheKey(const QString &s, uchar f)

    61     {

    62         hash = 0;

    63         pwd = qmake_getpwd();

    64         string = s;

    65         flags = f;

    66     }

    67     bool operator==(const FixStringCacheKey &f) const

    68     {

    69         return (hashCode() == f.hashCode() &&

    70                 f.flags == flags &&

    71                 f.string == string &&

    72                 f.pwd == pwd);

    73     }

    74     inline uint hashCode() const {

    75         if(!hash)

    76             hash = qHash(string) | qHash(flags) /*| qHash(pwd)*/;

    77         return hash;

    78     }

    79 };

    80 inline uint qHash(const FixStringCacheKey &f) { return f.hashCode(); }

    81 

    82 // -------------------------------------------------------------------------------------------------

    83 struct FileInfoCacheKey

    84 {

    85     mutable uint hash;

    86     QString file, pwd;

    87     FileInfoCacheKey(const QString &f)

    88     {

    89         hash = 0;

    90         if(isRelativePath(f))

    91             pwd = qmake_getpwd();

    92         file = f;

    93     }

    94     bool operator==(const FileInfoCacheKey &f) const

    95     {

    96         return (hashCode() == f.hashCode() && f.file == file &&

    97                 f.pwd == pwd);

    98     }

    99     inline uint hashCode() const {

   100         if(!hash)

   101             hash = qHash(file) /*| qHash(pwd)*/;

   102         return hash;

   103     }

   104     inline bool isRelativePath(const QString &file) {

   105         int length = file.length();

   106         if (!length)

   107             return true;

   108 

   109         const QChar c0 = file.at(0);

   110         const QChar c1 = length >= 2 ? file.at(1) : QChar(0);

   111         return !(c0 == QLatin1Char('/')

   112                 || c0 == QLatin1Char('\\')

   113                 || (c0.isLetter() && c1 == QLatin1Char(':'))

   114                 || (c0 == QLatin1Char('/') && c1 == QLatin1Char('/'))

   115                 || (c0 == QLatin1Char('\\') && c1 == QLatin1Char('\\')));

   116     }

   117 };

   118 inline uint qHash(const FileInfoCacheKey &f) { return f.hashCode(); }

   119 

   120 // -------------------------------------------------------------------------------------------------

   121 struct FileFixifyCacheKey

   122 {

   123     mutable uint hash;

   124     QString in_d, out_d;

   125     QString file, pwd;

   126     uint fixType;

   127     bool canonicalize;

   128     FileFixifyCacheKey(const QString &f, const QString &od, const QString &id,

   129                        uint ft, bool c)

   130     {

   131         hash = 0;

   132         pwd = qmake_getpwd();

   133         file = f;

   134         if(od.isNull())

   135             out_d = Option::output_dir;

   136         else

   137             out_d = od;

   138         if(id.isNull())

   139             in_d = qmake_getpwd();

   140         else

   141             in_d = id;

   142         fixType = ft;

   143         canonicalize = c;

   144     }

   145     QString toString() const {

   146         return file + "--" + in_d + "--" + out_d + "--" + pwd + "--" +

   147             QString::number(fixType) + "--" + QString::number((int)canonicalize);

   148     }

   149     bool operator==(const FileFixifyCacheKey &f) const

   150     {

   151         return (f.canonicalize == canonicalize &&

   152                 f.fixType == fixType &&

   153                 f.file == file &&

   154                 f.in_d == in_d &&

   155                 f.out_d == out_d &&

   156                 f.pwd == pwd);

   157     }

   158     inline uint hashCode() const {

   159         if(!hash)

   160             hash = uint(canonicalize) | uint(fixType) |

   161                    qHash(file) | qHash(in_d) | qHash(out_d) /*|qHash(pwd)*/;

   162         return hash;

   163     }

   164 };

   165 

   166 inline uint qHash(const FileFixifyCacheKey &f) { return f.hashCode(); }

   167 // -------------------------------------------------------------------------------------------------

   168 

   169 // As MSVC 6.0 can't handle template functions that well, we need a separate function for each type

   170 inline void qmakeDeleteCacheClear_QMapStringInt(void *i) { delete reinterpret_cast<QMap<QString,int> *>(i); }

   171 inline void qmakeDeleteCacheClear_QStringList(void *i) { delete reinterpret_cast<QStringList *>(i); }

   172 inline void qmakeDeleteCacheClear_QHashFixStringCacheKeyQString(void *i) { delete reinterpret_cast<QHash<FixStringCacheKey, QString> *>(i); }

   173 inline void qmakeDeleteCacheClear_QHashFileInfoCacheKeyQFileInfo(void *i) { delete reinterpret_cast<QHash<FileInfoCacheKey, QFileInfo> *>(i); }

   174 inline void qmakeDeleteCacheClear_QHashFileFixifyCacheKeyQString(void *i) { delete reinterpret_cast<QHash<FileFixifyCacheKey, QString> *>(i); }

   175 inline void qmakeFreeCacheClear(void *i) { free(i); }

   176 

   177 typedef void (*qmakeCacheClearFunc)(void *);

   178 void qmakeAddCacheClear(qmakeCacheClearFunc func, void **);

   179 void qmakeClearCaches();

   180 

   181 QT_END_NAMESPACE

   182 

   183 #endif // CACHEKEYS_H