diff options
Diffstat (limited to 'qmake/generators/makefiledeps.cpp')
| -rw-r--r-- | qmake/generators/makefiledeps.cpp | 963 |
1 files changed, 963 insertions, 0 deletions
diff --git a/qmake/generators/makefiledeps.cpp b/qmake/generators/makefiledeps.cpp new file mode 100644 index 0000000..852d6a2 --- /dev/null +++ b/qmake/generators/makefiledeps.cpp @@ -0,0 +1,963 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the qmake application of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "makefiledeps.h" +#include "option.h" +#include <qdir.h> +#include <qdatetime.h> +#include <qfileinfo.h> +#include <qbuffer.h> +#include <qplatformdefs.h> +#if defined(Q_OS_UNIX) +# include <unistd.h> +#else +# include <io.h> +#endif +#include <qdebug.h> +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <fcntl.h> +#include <sys/types.h> +#include <sys/stat.h> +#if defined(_MSC_VER) && _MSC_VER >= 1400 +#include <share.h> +#endif + +QT_BEGIN_NAMESPACE + +#if 1 +#define qmake_endOfLine(c) (c == '\r' || c == '\n') +#else +inline bool qmake_endOfLine(const char &c) { return (c == '\r' || c == '\n'); } +#endif + +//#define QMAKE_USE_CACHE + +QMakeLocalFileName::QMakeLocalFileName(const QString &name) : is_null(name.isNull()) +{ + if(!name.isEmpty()) { + if(name.at(0) == QLatin1Char('"') && name.at(name.length()-2) == QLatin1Char('"')) + real_name = name.mid(1, name.length()-2); + else + real_name = name; + } +} +const QString +&QMakeLocalFileName::local() const +{ + if(!is_null && local_name.isNull()) + local_name = Option::fixPathToLocalOS(real_name, true); + return local_name; +} + +struct SourceDependChildren; +struct SourceFile { + SourceFile() : deps(0), type(QMakeSourceFileInfo::TYPE_UNKNOWN), + mocable(0), traversed(0), exists(1), + moc_checked(0), dep_checked(0), included_count(0) { } + ~SourceFile(); + QMakeLocalFileName file; + SourceDependChildren *deps; + QMakeSourceFileInfo::SourceFileType type; + uint mocable : 1, traversed : 1, exists : 1; + uint moc_checked : 1, dep_checked : 1; + uchar included_count; +}; +struct SourceDependChildren { + SourceFile **children; + int num_nodes, used_nodes; + SourceDependChildren() : children(0), num_nodes(0), used_nodes(0) { } + ~SourceDependChildren() { if(children) free(children); children = 0; } + void addChild(SourceFile *s) { + if(num_nodes <= used_nodes) { + num_nodes += 200; + children = (SourceFile**)realloc(children, sizeof(SourceFile*)*(num_nodes)); + } + children[used_nodes++] = s; + } +}; +SourceFile::~SourceFile() { delete deps; } +class SourceFiles { + int hash(const char *); +public: + SourceFiles(); + ~SourceFiles(); + + SourceFile *lookupFile(const char *); + inline SourceFile *lookupFile(const QString &f) { return lookupFile(f.toLatin1().constData()); } + inline SourceFile *lookupFile(const QMakeLocalFileName &f) { return lookupFile(f.local().toLatin1().constData()); } + void addFile(SourceFile *, const char *k=0, bool own=true); + + struct SourceFileNode { + SourceFileNode() : key(0), next(0), file(0), own_file(1) { } + ~SourceFileNode() { + delete [] key; + if(own_file) + delete file; + } + char *key; + SourceFileNode *next; + SourceFile *file; + uint own_file : 1; + } **nodes; + int num_nodes; +}; +SourceFiles::SourceFiles() +{ + nodes = (SourceFileNode**)malloc(sizeof(SourceFileNode*)*(num_nodes=3037)); + for(int n = 0; n < num_nodes; n++) + nodes[n] = 0; +} + +SourceFiles::~SourceFiles() +{ + for(int n = 0; n < num_nodes; n++) { + for(SourceFileNode *next = nodes[n]; next;) { + SourceFileNode *next_next = next->next; + delete next; + next = next_next; + } + } + free(nodes); +} + +int SourceFiles::hash(const char *file) +{ + uint h = 0, g; + while (*file) { + h = (h << 4) + *file; + if ((g = (h & 0xf0000000)) != 0) + h ^= g >> 23; + h &= ~g; + file++; + } + return h; +} + +SourceFile *SourceFiles::lookupFile(const char *file) +{ + int h = hash(file) % num_nodes; + for(SourceFileNode *p = nodes[h]; p; p = p->next) { + if(!strcmp(p->key, file)) + return p->file; + } + return 0; +} + +void SourceFiles::addFile(SourceFile *p, const char *k, bool own_file) +{ + QByteArray ba = p->file.local().toLatin1(); + if(!k) + k = ba; + int h = hash(k) % num_nodes; + SourceFileNode *pn = new SourceFileNode; + pn->own_file = own_file; + pn->key = qstrdup(k); + pn->file = p; + pn->next = nodes[h]; + nodes[h] = pn; +} + +void QMakeSourceFileInfo::dependTreeWalker(SourceFile *node, SourceDependChildren *place) +{ + if(node->traversed || !node->exists) + return; + place->addChild(node); + node->traversed = true; //set flag + if(node->deps) { + for(int i = 0; i < node->deps->used_nodes; i++) + dependTreeWalker(node->deps->children[i], place); + } +} + +void QMakeSourceFileInfo::setDependencyPaths(const QList<QMakeLocalFileName> &l) +{ + // Ensure that depdirs does not contain the same paths several times, to minimize the stats + QList<QMakeLocalFileName> ll; + for (int i = 0; i < l.count(); ++i) { + if (!ll.contains(l.at(i))) + ll.append(l.at(i)); + } + depdirs = ll; +} + +QStringList QMakeSourceFileInfo::dependencies(const QString &file) +{ + QStringList ret; + if(!files) + return ret; + + if(SourceFile *node = files->lookupFile(QMakeLocalFileName(file))) { + if(node->deps) { + /* I stick them into a SourceDependChildren here because it is faster to just + iterate over the list to stick them in the list, and reset the flag, then it is + to loop over the tree (about 50% faster I saw) --Sam */ + SourceDependChildren place; + for(int i = 0; i < node->deps->used_nodes; i++) + dependTreeWalker(node->deps->children[i], &place); + if(place.children) { + for(int i = 0; i < place.used_nodes; i++) { + place.children[i]->traversed = false; //reset flag + ret.append(place.children[i]->file.real()); + } + } + } + } + return ret; +} + +int +QMakeSourceFileInfo::included(const QString &file) +{ + if (!files) + return 0; + + if(SourceFile *node = files->lookupFile(QMakeLocalFileName(file))) + return node->included_count; + return 0; +} + +bool QMakeSourceFileInfo::mocable(const QString &file) +{ + if(SourceFile *node = files->lookupFile(QMakeLocalFileName(file))) + return node->mocable; + return false; +} + +QMakeSourceFileInfo::QMakeSourceFileInfo(const QString &cf) +{ + //dep_mode + dep_mode = Recursive; + + //quick project lookups + includes = files = 0; + files_changed = false; + + //buffer + spare_buffer = 0; + spare_buffer_size = 0; + + //cache + cachefile = cf; + if(!cachefile.isEmpty()) + loadCache(cachefile); +} + +QMakeSourceFileInfo::~QMakeSourceFileInfo() +{ + //cache + if(!cachefile.isEmpty() /*&& files_changed*/) + saveCache(cachefile); + + //buffer + if(spare_buffer) { + free(spare_buffer); + spare_buffer = 0; + spare_buffer_size = 0; + } + + //quick project lookup + delete files; + delete includes; +} + +void QMakeSourceFileInfo::setCacheFile(const QString &cf) +{ + cachefile = cf; + loadCache(cachefile); +} + +void QMakeSourceFileInfo::addSourceFiles(const QStringList &l, uchar seek, + QMakeSourceFileInfo::SourceFileType type) +{ + for(int i=0; i<l.size(); ++i) + addSourceFile(l.at(i), seek, type); +} +void QMakeSourceFileInfo::addSourceFile(const QString &f, uchar seek, + QMakeSourceFileInfo::SourceFileType type) +{ + if(!files) + files = new SourceFiles; + + QMakeLocalFileName fn(f); + SourceFile *file = files->lookupFile(fn); + if(!file) { + file = new SourceFile; + file->file = fn; + files->addFile(file); + } else { + if(file->type != type && file->type != TYPE_UNKNOWN && type != TYPE_UNKNOWN) + warn_msg(WarnLogic, "%s is marked as %d, then %d!", f.toLatin1().constData(), + file->type, type); + } + if(type != TYPE_UNKNOWN) + file->type = type; + + if(seek & SEEK_MOCS && !file->moc_checked) + findMocs(file); + if(seek & SEEK_DEPS && !file->dep_checked) + findDeps(file); +} + +bool QMakeSourceFileInfo::containsSourceFile(const QString &f, SourceFileType type) +{ + if(SourceFile *file = files->lookupFile(QMakeLocalFileName(f))) + return (file->type == type || file->type == TYPE_UNKNOWN || type == TYPE_UNKNOWN); + return false; +} + +char *QMakeSourceFileInfo::getBuffer(int s) { + if(!spare_buffer || spare_buffer_size < s) + spare_buffer = (char *)realloc(spare_buffer, spare_buffer_size=s); + return spare_buffer; +} + +#ifndef S_ISDIR +#define S_ISDIR(x) (x & _S_IFDIR) +#endif + +QMakeLocalFileName QMakeSourceFileInfo::fixPathForFile(const QMakeLocalFileName &f, bool) +{ + return f; +} + +QMakeLocalFileName QMakeSourceFileInfo::findFileForDep(const QMakeLocalFileName &/*dep*/, + const QMakeLocalFileName &/*file*/) +{ + return QMakeLocalFileName(); +} + +QFileInfo QMakeSourceFileInfo::findFileInfo(const QMakeLocalFileName &dep) +{ + return QFileInfo(dep.real()); +} + +bool QMakeSourceFileInfo::findDeps(SourceFile *file) +{ + if(file->dep_checked || file->type == TYPE_UNKNOWN) + return true; + files_changed = true; + file->dep_checked = true; + + struct stat fst; + char *buffer = 0; + int buffer_len = 0; + { + int fd; +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (_sopen_s(&fd, fixPathForFile(file->file, true).local().toLatin1().constData(), + _O_RDONLY, _SH_DENYNO, _S_IREAD) != 0) + fd = -1; +#else + fd = open(fixPathForFile(file->file, true).local().toLatin1().constData(), O_RDONLY); +#endif + if(fd == -1 || fstat(fd, &fst) || S_ISDIR(fst.st_mode)) + return false; + buffer = getBuffer(fst.st_size); + for(int have_read = 0; + (have_read = QT_READ(fd, buffer + buffer_len, fst.st_size - buffer_len)); + buffer_len += have_read); + QT_CLOSE(fd); + } + if(!buffer) + return false; + if(!file->deps) + file->deps = new SourceDependChildren; + + int line_count = 1; + + for(int x = 0; x < buffer_len; ++x) { + bool try_local = true; + char *inc = 0; + if(file->type == QMakeSourceFileInfo::TYPE_UI) { + // skip whitespaces + while(x < buffer_len && (*(buffer+x) == ' ' || *(buffer+x) == '\t')) + ++x; + if(*(buffer + x) == '<') { + ++x; + if(buffer_len >= x + 12 && !strncmp(buffer + x, "includehint", 11) && + (*(buffer + x + 11) == ' ' || *(buffer + x + 11) == '>')) { + for(x += 11; *(buffer + x) != '>'; ++x); + int inc_len = 0; + for(x += 1 ; *(buffer + x + inc_len) != '<'; ++inc_len); + *(buffer + x + inc_len) = '\0'; + inc = buffer + x; + } else if(buffer_len >= x + 13 && !strncmp(buffer + x, "customwidget", 12) && + (*(buffer + x + 12) == ' ' || *(buffer + x + 12) == '>')) { + for(x += 13; *(buffer + x) != '>'; ++x); //skip up to > + while(x < buffer_len) { + for(x++; *(buffer + x) != '<'; ++x); //skip up to < + x++; + if(buffer_len >= x + 7 && !strncmp(buffer+x, "header", 6) && + (*(buffer + x + 6) == ' ' || *(buffer + x + 6) == '>')) { + for(x += 7; *(buffer + x) != '>'; ++x); //skip up to > + int inc_len = 0; + for(x += 1 ; *(buffer + x + inc_len) != '<'; ++inc_len); + *(buffer + x + inc_len) = '\0'; + inc = buffer + x; + break; + } else if(buffer_len >= x + 14 && !strncmp(buffer+x, "/customwidget", 13) && + (*(buffer + x + 13) == ' ' || *(buffer + x + 13) == '>')) { + x += 14; + break; + } + } + } else if(buffer_len >= x + 8 && !strncmp(buffer + x, "include", 7) && + (*(buffer + x + 7) == ' ' || *(buffer + x + 7) == '>')) { + for(x += 8; *(buffer + x) != '>'; ++x) { + if(buffer_len >= x + 9 && *(buffer + x) == 'i' && + !strncmp(buffer + x, "impldecl", 8)) { + for(x += 8; *(buffer + x) != '='; ++x); + if(*(buffer + x) != '=') + continue; + for(++x; *(buffer+x) == '\t' || *(buffer+x) == ' '; ++x); + char quote = 0; + if(*(buffer+x) == '\'' || *(buffer+x) == '"') { + quote = *(buffer + x); + ++x; + } + int val_len; + for(val_len = 0; true; ++val_len) { + if(quote) { + if(*(buffer+x+val_len) == quote) + break; + } else if(*(buffer + x + val_len) == '>' || + *(buffer + x + val_len) == ' ') { + break; + } + } +//? char saved = *(buffer + x + val_len); + *(buffer + x + val_len) = '\0'; + if(!strcmp(buffer+x, "in implementation")) { + //### do this + } + } + } + int inc_len = 0; + for(x += 1 ; *(buffer + x + inc_len) != '<'; ++inc_len); + *(buffer + x + inc_len) = '\0'; + inc = buffer + x; + } + } + //read past new line now.. + for(; x < buffer_len && !qmake_endOfLine(*(buffer + x)); ++x); + ++line_count; + } else if(file->type == QMakeSourceFileInfo::TYPE_QRC) { + } else if(file->type == QMakeSourceFileInfo::TYPE_C) { + for(int beginning=1; x < buffer_len; ++x) { + // whitespace comments and line-endings + for(; x < buffer_len; ++x) { + if(*(buffer+x) == ' ' || *(buffer+x) == '\t') { + // keep going + } else if(*(buffer+x) == '/') { + ++x; + if(buffer_len >= x) { + if(*(buffer+x) == '/') { //c++ style comment + for(; x < buffer_len && !qmake_endOfLine(*(buffer + x)); ++x); + beginning = 1; + } else if(*(buffer+x) == '*') { //c style comment + for(++x; x < buffer_len; ++x) { + if(*(buffer+x) == '*') { + if(x < buffer_len-1 && *(buffer + (x+1)) == '/') { + ++x; + break; + } + } else if(qmake_endOfLine(*(buffer+x))) { + ++line_count; + } + } + } + } + } else if(qmake_endOfLine(*(buffer+x))) { + ++line_count; + beginning = 1; + } else { + break; + } + } + + if(x >= buffer_len) + break; + + // preprocessor directive + if(beginning && *(buffer+x) == '#') + break; + + // quoted strings + if(*(buffer+x) == '\'' || *(buffer+x) == '"') { + const char term = *(buffer+(x++)); + for(; x < buffer_len; ++x) { + if(*(buffer+x) == term) { + ++x; + break; + } else if(*(buffer+x) == '\\') { + ++x; + } else if(qmake_endOfLine(*(buffer+x))) { + ++line_count; + } + } + } + beginning = 0; + } + if(x >= buffer_len) + break; + + //got a preprocessor symbol + ++x; + while(x < buffer_len) { + if(*(buffer+x) != ' ' && *(buffer+x) != '\t') + break; + ++x; + } + + int keyword_len = 0; + const char *keyword = buffer+x; + while(x+keyword_len < buffer_len) { + if(((*(buffer+x+keyword_len) < 'a' || *(buffer+x+keyword_len) > 'z')) && + *(buffer+x+keyword_len) != '_') { + for(x+=keyword_len; //skip spaces after keyword + x < buffer_len && (*(buffer+x) == ' ' || *(buffer+x) == '\t'); + x++); + break; + } else if(qmake_endOfLine(*(buffer+x+keyword_len))) { + x += keyword_len-1; + keyword_len = 0; + break; + } + keyword_len++; + } + + if(keyword_len == 7 && !strncmp(keyword, "include", keyword_len)) { + char term = *(buffer + x); + if(term == '<') { + try_local = false; + term = '>'; + } else if(term != '"') { //wtf? + continue; + } + x++; + + int inc_len; + for(inc_len = 0; *(buffer + x + inc_len) != term && !qmake_endOfLine(*(buffer + x + inc_len)); ++inc_len); + *(buffer + x + inc_len) = '\0'; + inc = buffer + x; + x += inc_len; + } else if(keyword_len == 13 && !strncmp(keyword, "qmake_warning", keyword_len)) { + char term = 0; + if(*(buffer + x) == '"') + term = '"'; + if(*(buffer + x) == '\'') + term = '\''; + if(term) + x++; + + int msg_len; + for(msg_len = 0; (term && *(buffer + x + msg_len) != term) && + !qmake_endOfLine(*(buffer + x + msg_len)); ++msg_len); + *(buffer + x + msg_len) = '\0'; + debug_msg(0, "%s:%d %s -- %s", file->file.local().toLatin1().constData(), line_count, keyword, buffer+x); + x += msg_len; + } else if(*(buffer+x) == '\'' || *(buffer+x) == '"') { + const char term = *(buffer+(x++)); + while(x < buffer_len) { + if(*(buffer+x) == term) + break; + if(*(buffer+x) == '\\') { + x+=2; + } else { + if(qmake_endOfLine(*(buffer+x))) + ++line_count; + ++x; + } + } + } else { + --x; + } + } + + if(inc) { + if(!includes) + includes = new SourceFiles; + SourceFile *dep = includes->lookupFile(inc); + if(!dep) { + bool exists = false; + QMakeLocalFileName lfn(inc); + if(QDir::isRelativePath(lfn.real())) { + if(try_local) { + QString dir = findFileInfo(file->file).path(); + if(QDir::isRelativePath(dir)) + dir.prepend(qmake_getpwd() + "/"); + if(!dir.endsWith("/")) + dir += "/"; + QMakeLocalFileName f(dir + lfn.local()); + if(findFileInfo(f).exists()) { + lfn = fixPathForFile(f); + exists = true; + } + } + if(!exists) { //path lookup + for(QList<QMakeLocalFileName>::Iterator it = depdirs.begin(); it != depdirs.end(); ++it) { + QMakeLocalFileName f((*it).real() + Option::dir_sep + lfn.real()); + QFileInfo fi(findFileInfo(f)); + if(fi.exists() && !fi.isDir()) { + lfn = fixPathForFile(f); + exists = true; + break; + } + } + } + if(!exists) { //heuristic lookup + lfn = findFileForDep(QMakeLocalFileName(inc), file->file); + if((exists = !lfn.isNull())) + lfn = fixPathForFile(lfn); + } + } else { + exists = QFile::exists(lfn.real()); + } + if(!lfn.isNull()) { + dep = files->lookupFile(lfn); + if(!dep) { + dep = new SourceFile; + dep->file = lfn; + dep->type = QMakeSourceFileInfo::TYPE_C; + files->addFile(dep); + includes->addFile(dep, inc, false); + } + dep->exists = exists; + } + } + if(dep && dep->file != file->file) { + dep->included_count++; + if(dep->exists) { + debug_msg(5, "%s:%d Found dependency to %s", file->file.real().toLatin1().constData(), + line_count, dep->file.local().toLatin1().constData()); + file->deps->addChild(dep); + } + } + } + } + if(dependencyMode() == Recursive) { //done last because buffer is shared + for(int i = 0; i < file->deps->used_nodes; i++) { + if(!file->deps->children[i]->deps) + findDeps(file->deps->children[i]); + } + } + return true; +} + +bool QMakeSourceFileInfo::findMocs(SourceFile *file) +{ + if(file->moc_checked) + return true; + files_changed = true; + file->moc_checked = true; + + int buffer_len; + char *buffer = 0; + { + struct stat fst; + int fd; +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (_sopen_s(&fd, fixPathForFile(file->file, true).local().toLocal8Bit().constData(), + _O_RDONLY, _SH_DENYRW, _S_IREAD) != 0) + fd = -1; +#else + fd = open(fixPathForFile(file->file, true).local().toLocal8Bit().constData(), O_RDONLY); +#endif + if(fd == -1 || fstat(fd, &fst) || S_ISDIR(fst.st_mode)) + return false; //shouldn't happen + buffer = getBuffer(fst.st_size); + for(int have_read = buffer_len = 0; + (have_read = QT_READ(fd, buffer + buffer_len, fst.st_size - buffer_len)); + buffer_len += have_read); + QT_CLOSE(fd); + } + + debug_msg(2, "findMocs: %s", file->file.local().toLatin1().constData()); + int line_count = 1; + bool ignore_qobject = false, ignore_qgadget = false; + /* qmake ignore Q_GADGET */ + /* qmake ignore Q_OBJECT */ + for(int x = 0; x < buffer_len; x++) { + if(*(buffer + x) == '/') { + ++x; + if(buffer_len >= x) { + if(*(buffer + x) == '/') { //c++ style comment + for(;x < buffer_len && !qmake_endOfLine(*(buffer + x)); ++x); + } else if(*(buffer + x) == '*') { //c style comment + for(++x; x < buffer_len; ++x) { + if(*(buffer + x) == 't' || *(buffer + x) == 'q') { //ignore + if(buffer_len >= (x + 20) && + !strncmp(buffer + x + 1, "make ignore Q_OBJECT", 20)) { + debug_msg(2, "Mocgen: %s:%d Found \"qmake ignore Q_OBJECT\"", + file->file.real().toLatin1().constData(), line_count); + x += 20; + ignore_qobject = true; + } else if(buffer_len >= (x + 20) && + !strncmp(buffer + x + 1, "make ignore Q_GADGET", 20)) { + debug_msg(2, "Mocgen: %s:%d Found \"qmake ignore Q_GADGET\"", + file->file.real().toLatin1().constData(), line_count); + x += 20; + ignore_qgadget = true; + } + } else if(*(buffer + x) == '*') { + if(buffer_len >= (x+1) && *(buffer + (x+1)) == '/') { + ++x; + break; + } + } else if(Option::debug_level && qmake_endOfLine(*(buffer + x))) { + ++line_count; + } + } + } + } + } else if(*(buffer+x) == '\'' || *(buffer+x) == '"') { + const char term = *(buffer+(x++)); + while(x < buffer_len) { + if(*(buffer+x) == term) + break; + if(*(buffer+x) == '\\') { + x+=2; + } else { + if(qmake_endOfLine(*(buffer+x))) + ++line_count; + ++x; + } + } + } + if(Option::debug_level && qmake_endOfLine(*(buffer+x))) + ++line_count; + if(((buffer_len > x+2 && *(buffer+x+1) == 'Q' && *(buffer+x+2) == '_') + || + (buffer_len > x+4 && *(buffer+x+1) == 'Q' && *(buffer+x+2) == 'O' + && *(buffer+x+3) == 'M' && *(buffer+x+4) == '_')) + && + *(buffer + x) != '_' && + (*(buffer + x) < 'a' || *(buffer + x) > 'z') && + (*(buffer + x) < 'A' || *(buffer + x) > 'Z') && + (*(buffer + x) < '0' || *(buffer + x) > '9')) { + ++x; + int match = 0; + static const char *interesting[] = { "OBJECT", "GADGET", + "M_OBJECT" }; + for(int interest = 0, m1, m2; interest < 3; ++interest) { + if(interest == 0 && ignore_qobject) + continue; + else if(interest == 1 && ignore_qgadget) + continue; + for(m1 = 0, m2 = 0; *(interesting[interest]+m1); ++m1) { + if(*(interesting[interest]+m1) != *(buffer+x+2+m1)) { + m2 = -1; + break; + } + ++m2; + } + if(m1 == m2) { + match = m2 + 2; + break; + } + } + if(match && *(buffer+x+match) != '_' && + (*(buffer+x+match) < 'a' || *(buffer+x+match) > 'z') && + (*(buffer+x+match) < 'A' || *(buffer+x+match) > 'Z') && + (*(buffer+x+match) < '0' || *(buffer+x+match) > '9')) { + if(Option::debug_level) { + *(buffer+x+match) = '\0'; + debug_msg(2, "Mocgen: %s:%d Found MOC symbol %s", file->file.real().toLatin1().constData(), + line_count, buffer+x); + } + file->mocable = true; + return true; + } + } + } + return true; +} + + +void QMakeSourceFileInfo::saveCache(const QString &cf) +{ +#ifdef QMAKE_USE_CACHE + if(cf.isEmpty()) + return; + + QFile file(QMakeLocalFileName(cf).local()); + if(file.open(QIODevice::WriteOnly)) { + QTextStream stream(&file); + stream << qmake_version() << endl << endl; //version + { //cache verification + QMap<QString, QStringList> verify = getCacheVerification(); + stream << verify.count() << endl; + for(QMap<QString, QStringList>::iterator it = verify.begin(); + it != verify.end(); ++it) { + stream << it.key() << endl << it.value().join(";") << endl; + } + stream << endl; + } + if(files->nodes) { + for(int file = 0; file < files->num_nodes; ++file) { + for(SourceFiles::SourceFileNode *node = files->nodes[file]; node; node = node->next) { + stream << node->file->file.local() << endl; //source + stream << node->file->type << endl; //type + + //depends + stream << ";"; + if(node->file->deps) { + for(int depend = 0; depend < node->file->deps->used_nodes; ++depend) { + if(depend) + stream << ";"; + stream << node->file->deps->children[depend]->file.local(); + } + } + stream << endl; + + stream << node->file->mocable << endl; //mocable + stream << endl; //just for human readability + } + } + } + stream.flush(); + file.close(); + } +#else + Q_UNUSED(cf); +#endif +} + +void QMakeSourceFileInfo::loadCache(const QString &cf) +{ + if(cf.isEmpty()) + return; + +#ifdef QMAKE_USE_CACHE + QMakeLocalFileName cache_file(cf); + int fd = open(QMakeLocalFileName(cf).local().toLatin1(), O_RDONLY); + if(fd == -1) + return; + QFileInfo cache_fi = findFileInfo(cache_file); + if(!cache_fi.exists() || cache_fi.isDir()) + return; + + QFile file; + if(!file.open(QIODevice::ReadOnly, fd)) + return; + QTextStream stream(&file); + + if(stream.readLine() == qmake_version()) { //version check + stream.skipWhiteSpace(); + + bool verified = true; + { //cache verification + QMap<QString, QStringList> verify; + int len = stream.readLine().toInt(); + for(int i = 0; i < len; ++i) { + QString var = stream.readLine(); + QString val = stream.readLine(); + verify.insert(var, val.split(';', QString::SkipEmptyParts)); + } + verified = verifyCache(verify); + } + if(verified) { + stream.skipWhiteSpace(); + if(!files) + files = new SourceFiles; + while(!stream.atEnd()) { + QString source = stream.readLine(); + QString type = stream.readLine(); + QString depends = stream.readLine(); + QString mocable = stream.readLine(); + stream.skipWhiteSpace(); + + QMakeLocalFileName fn(source); + QFileInfo fi = findFileInfo(fn); + + SourceFile *file = files->lookupFile(fn); + if(!file) { + file = new SourceFile; + file->file = fn; + files->addFile(file); + file->type = (SourceFileType)type.toInt(); + file->exists = fi.exists(); + } + if(fi.exists() && fi.lastModified() < cache_fi.lastModified()) { + if(!file->dep_checked) { //get depends + if(!file->deps) + file->deps = new SourceDependChildren; + file->dep_checked = true; + QStringList depend_list = depends.split(";", QString::SkipEmptyParts); + for(int depend = 0; depend < depend_list.size(); ++depend) { + QMakeLocalFileName dep_fn(depend_list.at(depend)); + QFileInfo dep_fi(findFileInfo(dep_fn)); + SourceFile *dep = files->lookupFile(dep_fn); + if(!dep) { + dep = new SourceFile; + dep->file = dep_fn; + dep->exists = dep_fi.exists(); + dep->type = QMakeSourceFileInfo::TYPE_UNKNOWN; + files->addFile(dep); + } + dep->included_count++; + file->deps->addChild(dep); + } + } + if(!file->moc_checked) { //get mocs + file->moc_checked = true; + file->mocable = mocable.toInt(); + } + } + } + } + } +#endif +} + +QMap<QString, QStringList> QMakeSourceFileInfo::getCacheVerification() +{ + return QMap<QString, QStringList>(); +} + +bool QMakeSourceFileInfo::verifyCache(const QMap<QString, QStringList> &v) +{ + return v == getCacheVerification(); +} + +QT_END_NAMESPACE |