| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Copyright (C) 2016 Intel Corporation. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the qmake application of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:GPL-EXCEPT$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $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> |
| #include <limits.h> |
| #if defined(_MSC_VER) && _MSC_VER >= 1400 |
| #include <share.h> |
| #endif |
| |
| QT_BEGIN_NAMESPACE |
| |
| // FIXME: a line ending in CRLF gets counted as two lines. |
| #if 1 |
| #define qmake_endOfLine(c) (c == '\r' || c == '\n') |
| #else |
| inline bool qmake_endOfLine(const char &c) { return (c == '\r' || c == '\n'); } |
| #endif |
| |
| 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::normalizePath(real_name); |
| return local_name; |
| } |
| |
| struct SourceDependChildren; |
| struct SourceFile { |
| SourceFile() : deps(nullptr), 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(nullptr), num_nodes(0), used_nodes(0) { } |
| ~SourceDependChildren() { if (children) free(children); children = nullptr; } |
| 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 = nullptr, bool own = true); |
| |
| struct SourceFileNode { |
| SourceFileNode() : key(nullptr), next(nullptr), file(nullptr), 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] = nullptr; |
| } |
| |
| 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 nullptr; |
| } |
| |
| void SourceFiles::addFile(SourceFile *p, const char *k, bool own_file) |
| { |
| const QByteArray ba = p->file.local().toLatin1(); |
| if(!k) |
| k = ba.constData(); |
| 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 QVector<QMakeLocalFileName> &l) |
| { |
| // Ensure that depdirs does not contain the same paths several times, to minimize the stats |
| QVector<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 = nullptr; |
| files_changed = false; |
| |
| //buffer |
| spare_buffer = nullptr; |
| spare_buffer_size = 0; |
| } |
| |
| QMakeSourceFileInfo::~QMakeSourceFileInfo() |
| { |
| //buffer |
| if(spare_buffer) { |
| free(spare_buffer); |
| spare_buffer = nullptr; |
| spare_buffer_size = 0; |
| } |
| |
| //quick project lookup |
| delete files; |
| delete includes; |
| } |
| |
| void QMakeSourceFileInfo::addSourceFiles(const ProStringList &l, uchar seek, |
| QMakeSourceFileInfo::SourceFileType type) |
| { |
| for(int i=0; i<l.size(); ++i) |
| addSourceFile(l.at(i).toQString(), 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; |
| } |
| |
| bool QMakeSourceFileInfo::isSystemInclude(const QString &name) |
| { |
| if (QDir::isRelativePath(name)) { |
| // if we got a relative path here, it's either an -I flag with a relative path |
| // or an include file we couldn't locate. Either way, conclude it's not |
| // a system include. |
| return false; |
| } |
| |
| for (int i = 0; i < systemIncludes.size(); ++i) { |
| // check if name is located inside the system include dir: |
| QDir systemDir(systemIncludes.at(i)); |
| QString relativePath = systemDir.relativeFilePath(name); |
| |
| // the relative path might be absolute if we're crossing drives on Windows |
| if (QDir::isAbsolutePath(relativePath) || relativePath.startsWith("../")) |
| continue; |
| debug_msg(5, "File/dir %s is in system dir %s, skipping", |
| qPrintable(name), qPrintable(systemIncludes.at(i))); |
| return true; |
| } |
| 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()); |
| } |
| |
| static int skipEscapedLineEnds(const char *buffer, int buffer_len, int offset, int *lines) |
| { |
| // Join physical lines to make logical lines, as in the C preprocessor |
| while (offset + 1 < buffer_len |
| && buffer[offset] == '\\' |
| && qmake_endOfLine(buffer[offset + 1])) { |
| offset += 2; |
| ++*lines; |
| if (offset < buffer_len |
| && buffer[offset - 1] == '\r' |
| && buffer[offset] == '\n') // CRLF |
| offset++; |
| } |
| return offset; |
| } |
| |
| static bool matchWhileUnsplitting(const char *buffer, int buffer_len, int start, |
| const char *needle, int needle_len, |
| int *matchlen, int *lines) |
| { |
| int x = start; |
| for (int n = 0; n < needle_len; |
| n++, x = skipEscapedLineEnds(buffer, buffer_len, x + 1, lines)) { |
| if (x >= buffer_len || buffer[x] != needle[n]) |
| return false; |
| } |
| // That also skipped any remaining BSNLs immediately after the match. |
| |
| // Tell caller how long the match was: |
| *matchlen = x - start; |
| |
| return true; |
| } |
| |
| /* Advance from an opening quote at buffer[offset] to the matching close quote. */ |
| static int scanPastString(char *buffer, int buffer_len, int offset, int *lines) |
| { |
| // http://en.cppreference.com/w/cpp/language/string_literal |
| // It might be a C++11 raw string. |
| bool israw = false; |
| if (buffer[offset] == '"' && offset > 0) { |
| int explore = offset - 1; |
| bool prefix = false; // One of L, U, u or u8 may appear before R |
| bool saw8 = false; // Partial scan of u8 |
| while (explore >= 0) { |
| // Cope with backslash-newline interruptions of the prefix: |
| if (explore > 0 |
| && qmake_endOfLine(buffer[explore]) |
| && buffer[explore - 1] == '\\') { |
| explore -= 2; |
| } else if (explore > 1 |
| && buffer[explore] == '\n' |
| && buffer[explore - 1] == '\r' |
| && buffer[explore - 2] == '\\') { |
| explore -= 3; |
| // Remaining cases can only decrement explore by one at a time: |
| } else if (saw8 && buffer[explore] == 'u') { |
| explore--; |
| saw8 = false; |
| prefix = true; |
| } else if (saw8 || prefix) { |
| break; |
| } else if (explore > 1 && buffer[explore] == '8') { |
| explore--; |
| saw8 = true; |
| } else if (buffer[explore] == 'L' |
| || buffer[explore] == 'U' |
| || buffer[explore] == 'u') { |
| explore--; |
| prefix = true; |
| } else if (buffer[explore] == 'R') { |
| if (israw) |
| break; |
| explore--; |
| israw = true; |
| } else { |
| break; |
| } |
| } |
| // Check the R (with possible prefix) isn't just part of an identifier: |
| if (israw && explore >= 0 |
| && (isalnum(buffer[explore]) || buffer[explore] == '_')) { |
| israw = false; |
| } |
| } |
| |
| if (israw) { |
| #define SKIP_BSNL(pos) skipEscapedLineEnds(buffer, buffer_len, (pos), lines) |
| |
| offset = SKIP_BSNL(offset + 1); |
| const char *const delim = buffer + offset; |
| int clean = offset; |
| while (offset < buffer_len && buffer[offset] != '(') { |
| if (clean < offset) |
| buffer[clean++] = buffer[offset]; |
| else |
| clean++; |
| |
| offset = SKIP_BSNL(offset + 1); |
| } |
| /* |
| Not checking correctness (trust real compiler to do that): |
| - no controls, spaces, '(', ')', '\\' or (presumably) '"' in delim; |
| - at most 16 bytes in delim |
| |
| Raw strings are surely defined after phase 2, when BSNLs are resolved; |
| so the delimiter's exclusion of '\\' and space (including newlines) |
| applies too late to save us the need to cope with BSNLs in it. |
| */ |
| |
| const int delimlen = buffer + clean - delim; |
| int matchlen = delimlen, extralines = 0; |
| while ((offset = SKIP_BSNL(offset + 1)) < buffer_len |
| && (buffer[offset] != ')' |
| || (delimlen > 0 && |
| !matchWhileUnsplitting(buffer, buffer_len, |
| offset + 1, delim, delimlen, |
| &matchlen, &extralines)) |
| || buffer[offset + 1 + matchlen] != '"')) { |
| // skip, but keep track of lines |
| if (qmake_endOfLine(buffer[offset])) |
| ++*lines; |
| extralines = 0; |
| } |
| *lines += extralines; // from the match |
| // buffer[offset] is ')' |
| offset += 1 + matchlen; // 1 for ')', then delim |
| // buffer[offset] is '"' |
| |
| #undef SKIP_BSNL |
| } else { // Traditional string or char literal: |
| const char term = buffer[offset]; |
| while (++offset < buffer_len && buffer[offset] != term) { |
| if (buffer[offset] == '\\') |
| ++offset; |
| else if (qmake_endOfLine(buffer[offset])) |
| ++*lines; |
| } |
| } |
| |
| return offset; |
| } |
| |
| bool QMakeSourceFileInfo::findDeps(SourceFile *file) |
| { |
| if(file->dep_checked || file->type == TYPE_UNKNOWN) |
| return true; |
| files_changed = true; |
| file->dep_checked = true; |
| |
| const QMakeLocalFileName sourceFile = fixPathForFile(file->file, true); |
| |
| struct stat fst; |
| char *buffer = nullptr; |
| int buffer_len = 0; |
| { |
| int fd; |
| #if defined(_MSC_VER) && _MSC_VER >= 1400 |
| if (_sopen_s(&fd, sourceFile.local().toLatin1().constData(), |
| _O_RDONLY, _SH_DENYNO, _S_IREAD) != 0) |
| fd = -1; |
| #else |
| fd = open(sourceFile.local().toLatin1().constData(), O_RDONLY); |
| #endif |
| if (fd == -1 || fstat(fd, &fst) || S_ISDIR(fst.st_mode)) { |
| if (fd != -1) |
| QT_CLOSE(fd); |
| 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; |
| enum { |
| /* |
| States of C preprocessing (for TYPE_C only), after backslash-newline |
| elimination and skipping comments and spaces (i.e. in ANSI X3.159-1989 |
| section 2.1.1.2's phase 4). We're about to study buffer[x] to decide |
| on which transition to do. |
| */ |
| AtStart, // start of logical line; a # may start a preprocessor directive |
| HadHash, // saw a # at start, looking for preprocessor keyword |
| WantName, // saw #include or #import, waiting for name |
| InCode // after directive, parsing non-#include directive or in actual code |
| } cpp_state = AtStart; |
| |
| int x = 0; |
| if (buffer_len >= 3) { |
| const unsigned char *p = (unsigned char *)buffer; |
| // skip UTF-8 BOM, if present |
| if (p[0] == 0xEF && p[1] == 0xBB && p[2] == 0xBF) |
| x += 3; |
| } |
| for (; x < buffer_len; ++x) { |
| bool try_local = true; |
| char *inc = nullptr; |
| 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; x < buffer_len && buffer[x] != '>'; ++x) {} // skip |
| int inc_len = 0; |
| for (++x; x + inc_len < buffer_len && buffer[x + inc_len] != '<'; ++inc_len) {} // skip |
| if (x + inc_len < buffer_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; x < buffer_len && buffer[x] != '>'; ++x) {} // skip up to > |
| while(x < buffer_len) { |
| while (++x < buffer_len && buffer[x] != '<') {} // skip up to < |
| x++; |
| if(buffer_len >= x + 7 && !strncmp(buffer+x, "header", 6) && |
| (buffer[x + 6] == ' ' || buffer[x + 6] == '>')) { |
| for (x += 7; x < buffer_len && buffer[x] != '>'; ++x) {} // skip up to > |
| int inc_len = 0; |
| for (++x; x + inc_len < buffer_len && buffer[x + inc_len] != '<'; |
| ++inc_len) {} // skip |
| if (x + inc_len < buffer_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; x < buffer_len && buffer[x] != '>'; ++x) { |
| if (buffer_len >= x + 9 && buffer[x] == 'i' && |
| !strncmp(buffer + x, "impldecl", 8)) { |
| for (x += 8; x < buffer_len && buffer[x] != '='; ++x) {} // skip |
| while (++x < buffer_len && (buffer[x] == '\t' || buffer[x] == ' ')) {} // skip |
| char quote = 0; |
| if (x < buffer_len && (buffer[x] == '\'' || buffer[x] == '"')) { |
| quote = buffer[x]; |
| ++x; |
| } |
| int val_len; |
| for (val_len = 0; x + val_len < buffer_len; ++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]; |
| if (x + val_len < buffer_len) { |
| buffer[x + val_len] = '\0'; |
| if (!strcmp(buffer + x, "in implementation")) { |
| //### do this |
| } |
| } |
| } |
| } |
| int inc_len = 0; |
| for (++x; x + inc_len < buffer_len && buffer[x + inc_len] != '<'; |
| ++inc_len) {} // skip |
| |
| if (x + inc_len < buffer_len) { |
| buffer[x + inc_len] = '\0'; |
| inc = buffer + x; |
| } |
| } |
| } |
| //read past new line now.. |
| for (; x < buffer_len && !qmake_endOfLine(buffer[x]); ++x) {} // skip |
| ++line_count; |
| } else if(file->type == QMakeSourceFileInfo::TYPE_QRC) { |
| } else if(file->type == QMakeSourceFileInfo::TYPE_C) { |
| // We've studied all buffer[i] for i < x |
| for (; x < buffer_len; ++x) { |
| // How to handle backslash-newline (BSNL) pairs: |
| #define SKIP_BSNL(pos) skipEscapedLineEnds(buffer, buffer_len, (pos), &line_count) |
| |
| // Seek code or directive, skipping comments and space: |
| for (; (x = SKIP_BSNL(x)) < buffer_len; ++x) { |
| if (buffer[x] == ' ' || buffer[x] == '\t') { |
| // keep going |
| } else if (buffer[x] == '/') { |
| int extralines = 0; |
| int y = skipEscapedLineEnds(buffer, buffer_len, x + 1, &extralines); |
| if (y >= buffer_len) { |
| x = y; |
| break; |
| } else if (buffer[y] == '/') { // C++-style comment |
| line_count += extralines; |
| x = SKIP_BSNL(y + 1); |
| while (x < buffer_len && !qmake_endOfLine(buffer[x])) |
| x = SKIP_BSNL(x + 1); // skip |
| |
| cpp_state = AtStart; |
| ++line_count; |
| } else if (buffer[y] == '*') { // C-style comment |
| line_count += extralines; |
| x = y; |
| while ((x = SKIP_BSNL(++x)) < buffer_len) { |
| if (buffer[x] == '*') { |
| extralines = 0; |
| y = skipEscapedLineEnds(buffer, buffer_len, |
| x + 1, &extralines); |
| if (y < buffer_len && buffer[y] == '/') { |
| line_count += extralines; |
| x = y; // for loop shall step past this |
| break; |
| } |
| } else if (qmake_endOfLine(buffer[x])) { |
| ++line_count; |
| } |
| } |
| } else { |
| // buffer[x] is the division operator |
| break; |
| } |
| } else if (qmake_endOfLine(buffer[x])) { |
| ++line_count; |
| cpp_state = AtStart; |
| } else { |
| /* Drop out of phases 1, 2, 3, into phase 4 */ |
| break; |
| } |
| } |
| // Phase 4 study of buffer[x]: |
| |
| if(x >= buffer_len) |
| break; |
| |
| switch (cpp_state) { |
| case HadHash: |
| { |
| // Read keyword; buffer[x] starts first preprocessing token after # |
| const char *const keyword = buffer + x; |
| int clean = x; |
| while (x < buffer_len && buffer[x] >= 'a' && buffer[x] <= 'z') { |
| // skip over keyword, consolidating it if it contains BSNLs |
| // (see WantName's similar code consolidating inc, below) |
| if (clean < x) |
| buffer[clean++] = buffer[x]; |
| else |
| clean++; |
| |
| x = SKIP_BSNL(x + 1); |
| } |
| const int keyword_len = buffer + clean - keyword; |
| x--; // Still need to study buffer[x] next time round for loop. |
| |
| cpp_state = |
| ((keyword_len == 7 && !strncmp(keyword, "include", 7)) // C & Obj-C |
| || (keyword_len == 6 && !strncmp(keyword, "import", 6))) // Obj-C |
| ? WantName : InCode; |
| break; |
| } |
| |
| case WantName: |
| { |
| char term = buffer[x]; |
| if (term == '<') { |
| try_local = false; |
| term = '>'; |
| } else if (term != '"') { |
| /* |
| Possibly malformed, but this may be something like: |
| #include IDENTIFIER |
| which does work, if #define IDENTIFIER "filename" is |
| in effect. This is beyond this noddy preprocessor's |
| powers of tracking. So give up and resume searching |
| for a directive. We haven't made sense of buffer[x], |
| so back up to ensure we do study it (now as code) next |
| time round the loop. |
| */ |
| x--; |
| cpp_state = InCode; |
| continue; |
| } |
| |
| x = SKIP_BSNL(x + 1); |
| inc = buffer + x; |
| int clean = x; // offset if we need to clear \-newlines |
| for (; x < buffer_len && buffer[x] != term; x = SKIP_BSNL(x + 1)) { |
| if (qmake_endOfLine(buffer[x])) { // malformed |
| cpp_state = AtStart; |
| ++line_count; |
| break; |
| } |
| |
| /* |
| If we do skip any BSNLs, we need to consolidate the |
| surviving text by copying to lower indices. For that |
| to be possible, we also have to keep 'clean' advanced |
| in step with x even when we've yet to see any BSNLs. |
| */ |
| if (clean < x) |
| buffer[clean++] = buffer[x]; |
| else |
| clean++; |
| } |
| if (cpp_state == WantName) |
| buffer[clean] = '\0'; |
| else // i.e. malformed |
| inc = nullptr; |
| |
| cpp_state = InCode; // hereafter |
| break; |
| } |
| |
| case AtStart: |
| // Preprocessor directive? |
| if (buffer[x] == '#') { |
| cpp_state = HadHash; |
| break; |
| } |
| cpp_state = InCode; |
| Q_FALLTHROUGH(); // to handle buffer[x] as such. |
| case InCode: |
| // matching quotes (string literals and character literals) |
| if (buffer[x] == '\'' || buffer[x] == '"') { |
| x = scanPastString(buffer, buffer_len, x, &line_count); |
| // for loop's ++x shall step over the closing quote. |
| } |
| // else: buffer[x] is just some code; move on. |
| break; |
| } |
| |
| if (inc) // We were in WantName and found a name. |
| break; |
| #undef SKIP_BSNL |
| } |
| if(x >= buffer_len) |
| break; |
| } |
| |
| if(inc) { |
| if(!includes) |
| includes = new SourceFiles; |
| /* QTBUG-72383: Local includes "foo.h" must first be resolved relative to the |
| * sourceDir, only global includes <bar.h> are unique. */ |
| SourceFile *dep = try_local ? nullptr : includes->lookupFile(inc); |
| if(!dep) { |
| bool exists = false; |
| QMakeLocalFileName lfn(inc); |
| if(QDir::isRelativePath(lfn.real())) { |
| if(try_local) { |
| QDir sourceDir = findFileInfo(sourceFile).dir(); |
| QMakeLocalFileName f(sourceDir.absoluteFilePath(lfn.local())); |
| if(findFileInfo(f).exists()) { |
| lfn = fixPathForFile(f); |
| exists = true; |
| } |
| } |
| if(!exists) { //path lookup |
| for (const QMakeLocalFileName &depdir : qAsConst(depdirs)) { |
| QMakeLocalFileName f(depdir.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() && !isSystemInclude(lfn.real())) { |
| dep = files->lookupFile(lfn); |
| if(!dep) { |
| dep = new SourceFile; |
| dep->file = lfn; |
| dep->type = QMakeSourceFileInfo::TYPE_C; |
| files->addFile(dep); |
| /* QTBUG-72383: Local includes "foo.h" are keyed by the resolved |
| * path (stored in dep itself), only global includes <bar.h> are |
| * unique keys immediately. */ |
| const char *key = try_local ? nullptr : inc; |
| includes->addFile(dep, key, 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; |
| } |
| |
| static bool isCWordChar(char c) { |
| return c == '_' |
| || (c >= 'a' && c <= 'z') |
| || (c >= 'A' && c <= 'Z') |
| || (c >= '0' && c <= '9'); |
| } |
| |
| bool QMakeSourceFileInfo::findMocs(SourceFile *file) |
| { |
| if(file->moc_checked) |
| return true; |
| files_changed = true; |
| file->moc_checked = true; |
| |
| int buffer_len = 0; |
| char *buffer = nullptr; |
| { |
| 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_DENYNO, _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)) { |
| if (fd != -1) |
| QT_CLOSE(fd); |
| return false; //shouldn't happen |
| } |
| buffer = getBuffer(fst.st_size); |
| while (int 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; |
| // [0] for Q_OBJECT, [1] for Q_GADGET, [2] for Q_NAMESPACE, [3] for Q_NAMESPACE_EXPORT |
| bool ignore[4] = { false, false, false, false }; |
| /* qmake ignore Q_GADGET */ |
| /* qmake ignore Q_OBJECT */ |
| /* qmake ignore Q_NAMESPACE */ |
| /* qmake ignore Q_NAMESPACE_EXPORT */ |
| for(int x = 0; x < buffer_len; x++) { |
| #define SKIP_BSNL(pos) skipEscapedLineEnds(buffer, buffer_len, (pos), &line_count) |
| x = SKIP_BSNL(x); |
| if (buffer[x] == '/') { |
| int extralines = 0; |
| int y = skipEscapedLineEnds(buffer, buffer_len, x + 1, &extralines); |
| if (buffer_len > y) { |
| // If comment, advance to the character that ends it: |
| if (buffer[y] == '/') { // C++-style comment |
| line_count += extralines; |
| x = y; |
| do { |
| x = SKIP_BSNL(x + 1); |
| } while (x < buffer_len && !qmake_endOfLine(buffer[x])); |
| |
| } else if (buffer[y] == '*') { // C-style comment |
| line_count += extralines; |
| x = SKIP_BSNL(y + 1); |
| for (; x < buffer_len; x = SKIP_BSNL(x + 1)) { |
| 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[0] = 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[1] = true; |
| } else if (buffer_len >= (x + 23) && |
| !strncmp(buffer + x + 1, "make ignore Q_NAMESPACE", 23)) { |
| debug_msg(2, "Mocgen: %s:%d Found \"qmake ignore Q_NAMESPACE\"", |
| file->file.real().toLatin1().constData(), line_count); |
| x += 23; |
| ignore[2] = true; |
| } else if (buffer_len >= (x + 30) && |
| !strncmp(buffer + x + 1, "make ignore Q_NAMESPACE_EXPORT", 30)) { |
| debug_msg(2, "Mocgen: %s:%d Found \"qmake ignore Q_NAMESPACE_EXPORT\"", |
| file->file.real().toLatin1().constData(), line_count); |
| x += 30; |
| ignore[3] = true; |
| } |
| } else if (buffer[x] == '*') { |
| extralines = 0; |
| y = skipEscapedLineEnds(buffer, buffer_len, x + 1, &extralines); |
| if (buffer_len > y && buffer[y] == '/') { |
| line_count += extralines; |
| x = y; |
| break; |
| } |
| } else if (Option::debug_level && qmake_endOfLine(buffer[x])) { |
| ++line_count; |
| } |
| } |
| } |
| // else: don't update x, buffer[x] is just the division operator. |
| } |
| } else if (buffer[x] == '\'' || buffer[x] == '"') { |
| x = scanPastString(buffer, buffer_len, x, &line_count); |
| // Leaves us on closing quote; for loop's x++ steps us past it. |
| } |
| |
| if (x < buffer_len && Option::debug_level && qmake_endOfLine(buffer[x])) |
| ++line_count; |
| if (buffer_len > x + 8 && !isCWordChar(buffer[x])) { |
| int morelines = 0; |
| int y = skipEscapedLineEnds(buffer, buffer_len, x + 1, &morelines); |
| if (buffer[y] == 'Q') { |
| static const char interesting[][19] = { "Q_OBJECT", "Q_GADGET", "Q_NAMESPACE", "Q_NAMESPACE_EXPORT" }; |
| for (int interest = 0; interest < 4; ++interest) { |
| if (ignore[interest]) |
| continue; |
| |
| int matchlen = 0, extralines = 0; |
| size_t needle_len = strlen(interesting[interest]); |
| Q_ASSERT(needle_len <= INT_MAX); |
| if (matchWhileUnsplitting(buffer, buffer_len, y, |
| interesting[interest], |
| static_cast<int>(needle_len), |
| &matchlen, &extralines) |
| && y + matchlen < buffer_len |
| && !isCWordChar(buffer[y + matchlen])) { |
| if (Option::debug_level) { |
| buffer[y + matchlen] = '\0'; |
| debug_msg(2, "Mocgen: %s:%d Found MOC symbol %s", |
| file->file.real().toLatin1().constData(), |
| line_count + morelines, buffer + y); |
| } |
| file->mocable = true; |
| return true; |
| } |
| } |
| } |
| } |
| #undef SKIP_BSNL |
| } |
| return true; |
| } |
| |
| QT_END_NAMESPACE |
