Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#include "cpp.h"
#include <translator.h>
#include "metastrings.h"
#include "trparser.h"
#include <QtCore/QBitArray>
#include <QtCore/QTextStream>
#include <QtCore/QRegularExpression>
#include <iostream>
#include <optional>
QT_BEGIN_NAMESPACE
/* qmake ignore Q_OBJECT */
using namespace Qt::StringLiterals;
size_t qHash(const HashString &str, size_t seed)
{
if (str.m_hash & 0x80000000)
str.m_hash = qHash(str.m_str, seed) & 0x7fffffff;
return str.m_hash;
}
QDebug operator<<(QDebug debug, const HashString &s)
{
return debug << s.value();
}
size_t qHash(const HashStringList &list, size_t seed)
{
if (list.m_hash & 0x80000000) {
uint hash = 0;
for (const HashString &qs : list.m_list) {
hash ^= qHash(qs, seed) ^ 0x6ad9f526;
hash = ((hash << 13) & 0x7fffffff) | (hash >> 18);
}
list.m_hash = hash;
}
return list.m_hash;
}
QDebug operator<<(QDebug debug, const HashStringList &lst)
{
return debug << lst.m_list;
}
static int nextFileId;
class VisitRecorder {
public:
VisitRecorder()
{
m_ba.resize(nextFileId);
}
bool tryVisit(int fileId)
{
if (m_ba.at(fileId))
return false;
m_ba[fileId] = true;
return true;
}
private:
QBitArray m_ba;
};
class CppParser : private CppParserState {
public:
CppParser(ParseResults *results = 0);
void setInput(const QString &in);
void setInput(QTextStream &ts, const QString &fileName);
void setTranslator(Translator *_tor) { tor = _tor; }
void parse(ConversionData &cd, const QStringList &includeStack, QSet<QString> &inclusions);
bool parseTranslate(QString &prefix);
void parseInternal(ConversionData &cd, const QStringList &includeStack,
QSet<QString> &inclusions);
const ParseResults *recordResults(bool isHeader);
void deleteResults() { delete results; }
private:
struct IfdefState {
IfdefState() {}
IfdefState(int _bracketDepth, int _braceDepth, int _parenDepth) :
bracketDepth(_bracketDepth),
braceDepth(_braceDepth),
parenDepth(_parenDepth),
elseLine(-1)
{}
CppParserState state;
int bracketDepth, bracketDepth1st;
int braceDepth, braceDepth1st;
int parenDepth, parenDepth1st;
int elseLine;
};
enum TokenType {
Tok_Eof,
Tok_class,
Tok_enum,
Tok_friend,
Tok_namespace,
Tok_using,
Tok_return,
Tok_decltype,
Tok_Q_OBJECT,
Tok_Access,
Tok_Cancel,
Tok_Ident,
Tok_String,
Tok_RawString,
Tok_Arrow,
Tok_Colon,
Tok_ColonColon,
Tok_Equals,
Tok_LeftBracket,
Tok_RightBracket,
Tok_Attribute,
Tok_LeftAngleBracket,
Tok_RightAngleBracket,
Tok_LeftShift,
Tok_QuestionMark,
Tok_LeftBrace,
Tok_RightBrace,
Tok_LeftParen,
Tok_RightParen,
Tok_Comma,
Tok_Semicolon,
Tok_Null,
Tok_Integer,
Tok_QuotedInclude,
Tok_AngledInclude
};
std::ostream &yyMsg(int line = 0);
int getChar();
TokenType lookAheadToSemicolonOrLeftBrace();
int lookBackFunctionCallStart(int prefixSize);
int lookAheadFunctionCallEnd(int functionStart);
TokenType getToken();
void processComment();
bool match(TokenType t);
bool matchString(QString *s);
bool matchEncoding();
bool matchStringOrNull(QString *s);
bool skipExpression();
void recordMessage(int line, const QString &context, const QString &text,
const QString &comment, const QString &extracomment, const QString &msgid,
const QString &label, const TranslatorMessage::ExtraData &extra,
bool plural, int startOffset, int endOffset);
void handleTr(QString &prefix, bool plural);
void handleTranslate(int prefixSize, bool plural);
void handleTrId(int prefixSize, bool plural);
void handleDeclareTrFunctions();
void processInclude(const QString &file, ConversionData &cd,
const QStringList &includeStack, QSet<QString> &inclusions);
void saveState(CppParserState *state);
void loadState(const CppParserState &state);
static QString stringifyNamespace(int start, const NamespaceList &namespaces);
static QString stringifyNamespace(const NamespaceList &namespaces)
{ return stringifyNamespace(1, namespaces); }
static QString joinNamespaces(const QString &one, const QString &two);
typedef bool (CppParser::*VisitNamespaceCallback)(const Namespace *ns, void *context) const;
bool visitNamespace(const NamespaceList &namespaces, int nsCount,
VisitNamespaceCallback callback, void *context,
VisitRecorder &vr, const ParseResults *rslt) const;
bool visitNamespace(const NamespaceList &namespaces, int nsCount,
VisitNamespaceCallback callback, void *context) const;
bool qualifyOneCallbackOwn(const Namespace *ns, void *context) const;
bool qualifyOneCallbackUsing(const Namespace *ns, void *context) const;
bool qualifyOne(const NamespaceList &namespaces, int nsCnt, const HashString &segment,
NamespaceList *resolved, Namespace const **resolvedNamespace,
QSet<HashStringList> *visitedUsings, bool *foundViaUsing = nullptr) const;
bool qualifyOne(const NamespaceList &namespaces, int nsCnt, const HashString &segment,
NamespaceList *resolved, Namespace const **resolvedNamespace) const;
bool fullyQualify(const NamespaceList &namespaces, int nsCnt,
const NamespaceList &segments, bool isDeclaration,
NamespaceList *resolved, NamespaceList *unresolved) const;
bool fullyQualify(const NamespaceList &namespaces,
const NamespaceList &segments, bool isDeclaration,
NamespaceList *resolved, NamespaceList *unresolved) const;
bool fullyQualify(const NamespaceList &namespaces,
const QString &segments, bool isDeclaration,
NamespaceList *resolved, NamespaceList *unresolved) const;
bool findNamespaceCallback(const Namespace *ns, void *context) const;
Namespace *findNamespace(const NamespaceList &namespaces, int nsCount = -1) const;
void enterNamespace(NamespaceList *namespaces, const HashString &name);
void truncateNamespaces(NamespaceList *namespaces, int lenght);
Namespace *modifyNamespace(NamespaceList *namespaces, bool haveLast = true);
// Tokenizer state
QString yyFileName;
int yyCh;
bool yyAtNewline;
bool yyTrailingSpace;
QString yyWord;
qsizetype yyWordInitialCapacity = 0;
QStack<IfdefState> yyIfdefStack;
int yyBracketDepth;
int yyBraceDepth;
int yyParenDepth;
int yyLineNo;
int yyCurLineNo;
int yyBracketLineNo;
int yyBraceLineNo;
int yyParenLineNo;
// the string to read from and current position in the string
QStringConverter::Encoding yySourceEncoding = QStringConverter::Utf8;
QString yyInStr;
const ushort *yyInPtr;
// Parser state
TokenType yyTok;
bool metaExpected;
QString context;
MetaStrings m_metaStrings;
QString prospectiveContext;
ParseResults *results;
Translator *tor;
bool directInclude;
CppParserState savedState;
int yyMinBraceDepth;
bool inDefine;
};
CppParser::CppParser(ParseResults *_results)
{
tor = 0;
if (_results) {
results = _results;
directInclude = true;
} else {
results = new ParseResults;
directInclude = false;
}
yyBracketDepth = 0;
yyBraceDepth = 0;
yyParenDepth = 0;
yyCurLineNo = 1;
yyBracketLineNo = 1;
yyBraceLineNo = 1;
yyParenLineNo = 1;
yyAtNewline = true;
yyMinBraceDepth = 0;
inDefine = false;
}
std::ostream &CppParser::yyMsg(int line)
{
return std::cerr << qPrintable(yyFileName) << ':' << (line ? line : yyLineNo) << ": ";
}
void CppParser::setInput(const QString &in)
{
yyInStr = in;
yyFileName = QString();
yySourceEncoding = QStringConverter::Utf8;
}
void CppParser::setInput(QTextStream &ts, const QString &fileName)
{
yyInStr = ts.readAll();
yyFileName = fileName;
yySourceEncoding = ts.encoding();
}
/*
The first part of this source file is the C++ tokenizer. We skip
most of C++; the only tokens that interest us are defined here.
Thus, the code fragment
int main()
{
printf("Hello, world!\n");
return 0;
}
is broken down into the following tokens (Tok_ omitted):
Ident Ident LeftParen RightParen
LeftBrace
Ident LeftParen String RightParen Semicolon
return Semicolon
RightBrace.
The 0 doesn't produce any token.
*/
int CppParser::getChar()
{
const ushort *uc = yyInPtr;
forever {
ushort c = *uc;
if (!c) {
yyInPtr = uc;
return EOF;
}
++uc;
if (c == '\\') {
ushort cc = *uc;
if (cc == '\n') {
++yyCurLineNo;
++uc;
continue;
}
if (cc == '\r') {
++yyCurLineNo;
++uc;
if (*uc == '\n')
++uc;
continue;
}
}
if (c == '\r') {
if (*uc == '\n')
++uc;
c = '\n';
++yyCurLineNo;
yyAtNewline = true;
} else if (c == '\n') {
++yyCurLineNo;
yyAtNewline = true;
} else if (c != ' ' && c != '\t' && c != '#') {
yyAtNewline = false;
}
yyInPtr = uc;
return int(c);
}
}
CppParser::TokenType CppParser::lookAheadToSemicolonOrLeftBrace()
{
if (*yyInPtr == 0)
return Tok_Eof;
const ushort *uc = yyInPtr + 1;
forever {
ushort c = *uc;
if (!c)
return Tok_Eof;
if (c == ';')
return Tok_Semicolon;
if (c == '{')
return Tok_LeftBrace;
++uc;
}
}
static bool isStringLiteralPrefix(const QStringView s)
{
return s == u"L"_s
|| s == u"U"_s
|| s == u"u"_s
|| s == u"u8"_s;
}
static bool isRawStringLiteralPrefix(QStringView s)
{
if (s.endsWith(u'R')) {
s.chop(1);
return s.isEmpty() || isStringLiteralPrefix(s);
}
return false;
}
static const QString strQ_OBJECT = u"Q_OBJECT"_s;
static const QString strclass = u"class"_s;
static const QString strdecltype = u"decltype"_s;
static const QString strenum = u"enum"_s;
static const QString strfinal = u"final"_s;
static const QString strfriend = u"friend"_s;
static const QString strnamespace = u"namespace"_s;
static const QString strnullptr = u"nullptr"_s;
static const QString strQ_NULLPTR = u"Q_NULLPTR"_s;
static const QString strNULL = u"NULL"_s;
static const QString stroperator = u"operator"_s;
static const QString strreturn = u"return"_s;
static const QString strstruct = u"struct"_s;
static const QString strusing = u"using"_s;
static const QString strprivate = u"private"_s;
static const QString strprotected = u"protected"_s;
static const QString strpublic = u"public"_s;
static const QString strslots = u"slots"_s;
static const QString strsignals = u"signals"_s;
static const QString strQ_SLOTS = u"Q_SLOTS"_s;
static const QString strQ_SIGNALS = u"Q_SIGNALS"_s;
CppParser::TokenType CppParser::getToken()
{
restart:
// Failing this assertion would mean losing the preallocated buffer.
Q_ASSERT(yyWord.capacity() == yyWordInitialCapacity);
while (yyCh != EOF) {
yyLineNo = yyCurLineNo;
if (yyCh == '#' && yyAtNewline) {
/*
Early versions of lupdate complained about
unbalanced braces in the following code:
#ifdef ALPHA
while (beta) {
#else
while (gamma) {
#endif
delta;
}
The code contains, indeed, two opening braces for
one closing brace; yet there's no reason to panic.
The solution is to remember yyBraceDepth as it was
when #if, #ifdef or #ifndef was met, and to set
yyBraceDepth to that value when meeting #elif or
#else.
*/
do {
yyCh = getChar();
} while (isspace(yyCh) && yyCh != '\n');
switch (yyCh) {
case 'd': // define
// Skip over the name of the define to avoid it being interpreted as c++ code
do { // Rest of "define"
yyCh = getChar();
if (yyCh == EOF)
return Tok_Eof;
if (yyCh == '\n')
goto restart;
} while (!isspace(yyCh));
do { // Space beween "define" and macro name
yyCh = getChar();
if (yyCh == EOF)
return Tok_Eof;
if (yyCh == '\n')
goto restart;
} while (isspace(yyCh));
do { // Macro name
if (yyCh == '(') {
// Argument list. Follows the name without a space, and no
// paren nesting is possible.
do {
yyCh = getChar();
if (yyCh == EOF)
return Tok_Eof;
if (yyCh == '\n')
goto restart;
} while (yyCh != ')');
break;
}
yyCh = getChar();
if (yyCh == EOF)
return Tok_Eof;
if (yyCh == '\n')
goto restart;
} while (!isspace(yyCh));
do { // Shortcut the immediate newline case if no comments follow.
yyCh = getChar();
if (yyCh == EOF)
return Tok_Eof;
if (yyCh == '\n')
goto restart;
} while (isspace(yyCh));
saveState(&savedState);
yyMinBraceDepth = yyBraceDepth;
inDefine = true;
goto restart;
case 'i':
yyCh = getChar();
if (yyCh == 'f') {
// if, ifdef, ifndef
yyIfdefStack.push(IfdefState(yyBracketDepth, yyBraceDepth, yyParenDepth));
yyCh = getChar();
} else if (yyCh == 'n') {
// include
do {
yyCh = getChar();
} while (yyCh != EOF && !isspace(yyCh) && yyCh != '"' && yyCh != '<' );
while (isspace(yyCh))
yyCh = getChar();
int tChar;
if (yyCh == '"')
tChar = '"';
else if (yyCh == '<')
tChar = '>';
else
break;
ushort *ptr = (ushort *)yyWord.unicode();
forever {
yyCh = getChar();
if (yyCh == EOF || yyCh == '\n')
break;
if (yyCh == tChar) {
yyCh = getChar();
break;
}
*ptr++ = yyCh;
}
yyWord.resize(ptr - (ushort *)yyWord.unicode());
return (tChar == '"') ? Tok_QuotedInclude : Tok_AngledInclude;
}
break;
case 'e':
yyCh = getChar();
if (yyCh == 'l') {
// elif, else
if (!yyIfdefStack.isEmpty()) {
IfdefState &is = yyIfdefStack.top();
if (is.elseLine != -1) {
if (yyBracketDepth != is.bracketDepth1st
|| yyBraceDepth != is.braceDepth1st
|| yyParenDepth != is.parenDepth1st)
yyMsg(is.elseLine)
<< "Parenthesis/bracket/brace mismatch between "
"#if and #else branches; using #if branch\n";
} else {
is.bracketDepth1st = yyBracketDepth;
is.braceDepth1st = yyBraceDepth;
is.parenDepth1st = yyParenDepth;
saveState(&is.state);
}
is.elseLine = yyLineNo;
yyBracketDepth = is.bracketDepth;
yyBraceDepth = is.braceDepth;
yyParenDepth = is.parenDepth;
}
yyCh = getChar();
} else if (yyCh == 'n') {
// endif
if (!yyIfdefStack.isEmpty()) {
IfdefState is = yyIfdefStack.pop();
if (is.elseLine != -1) {
if (yyBracketDepth != is.bracketDepth1st
|| yyBraceDepth != is.braceDepth1st
|| yyParenDepth != is.parenDepth1st)
yyMsg(is.elseLine)
<< "Parenthesis/brace mismatch between "
"#if and #else branches; using #if branch\n";
yyBracketDepth = is.bracketDepth1st;
yyBraceDepth = is.braceDepth1st;
yyParenDepth = is.parenDepth1st;
loadState(is.state);
}
}
yyCh = getChar();
}
break;
}
// Optimization: skip over rest of preprocessor directive
do {
if (yyCh == '/') {
yyCh = getChar();
if (yyCh == '/') {
do {
yyCh = getChar();
} while (yyCh != EOF && yyCh != '\n');
break;
} else if (yyCh == '*') {
bool metAster = false;
forever {
yyCh = getChar();
if (yyCh == EOF) {
yyMsg() << "Unterminated C++ comment\n";
break;
}
if (yyCh == '*') {
metAster = true;
} else if (metAster && yyCh == '/') {
yyCh = getChar();
break;
} else {
metAster = false;
}
}
}
} else {
yyCh = getChar();
}
} while (yyCh != '\n' && yyCh != EOF);
yyCh = getChar();
} else if ((yyCh >= 'A' && yyCh <= 'Z') || (yyCh >= 'a' && yyCh <= 'z') || yyCh == '_') {
ushort *ptr = (ushort *)yyWord.unicode();
do {
*ptr++ = yyCh;
yyCh = getChar();
} while ((yyCh >= 'A' && yyCh <= 'Z') || (yyCh >= 'a' && yyCh <= 'z')
|| (yyCh >= '0' && yyCh <= '9') || yyCh == '_');
yyWord.resize(ptr - (ushort *)yyWord.unicode());
yyTrailingSpace = isspace(yyCh);
//qDebug() << "IDENT: " << yyWord;
if (yyCh == '"' && isStringLiteralPrefix(yyWord)) {
// Handle prefixed string literals as ordinary string literals.
continue;
}
switch (yyWord.unicode()[0].unicode()) {
case 'N':
if (yyWord == strNULL)
return Tok_Null;
break;
case 'Q':
if (yyWord == strQ_NULLPTR)
return Tok_Null;
if (yyWord == strQ_OBJECT)
return Tok_Q_OBJECT;
if (yyWord == strQ_SLOTS || yyWord == strQ_SIGNALS)
return Tok_Access;
break;
case 'c':
if (yyWord == strclass)
return Tok_class;
break;
case 'd':
if (yyWord == strdecltype)
return Tok_decltype;
break;
case 'e':
if (yyWord == strenum)
return Tok_enum;
break;
case 'f':
if (yyWord == strfriend)
return Tok_friend;
break;
case 'n':
if (yyWord == strnamespace)
return Tok_namespace;
if (yyWord == strnullptr)
return Tok_Null;
break;
case 'o':
if (yyWord == stroperator) {
// Operator overload declaration/definition.
// We need to prevent those characters from confusing the followup
// parsing. Actually using them does not add value, so just eat them.
while (isspace(yyCh))
yyCh = getChar();
while (yyCh == '+' || yyCh == '-' || yyCh == '*' || yyCh == '/' || yyCh == '%'
|| yyCh == '=' || yyCh == '<' || yyCh == '>' || yyCh == '!'
|| yyCh == '&' || yyCh == '|' || yyCh == '~' || yyCh == '^'
|| yyCh == '[' || yyCh == ']')
yyCh = getChar();
}
break;
case 'p':
if (yyWord == strpublic || yyWord == strprotected || yyWord == strprivate)
return Tok_Access;
break;
case 'r':
if (yyWord == strreturn)
return Tok_return;
break;
case 's':
if (yyWord == strstruct)
return Tok_class;
if (yyWord == strslots || yyWord == strsignals)
return Tok_Access;
break;
case 'u':
if (yyWord == strusing)
return Tok_using;
break;
}
// a C++11 raw string literal?
if (yyCh == '"' && isRawStringLiteralPrefix(yyWord)) {
ptr = reinterpret_cast<ushort *>(const_cast<QChar *>(yyWord.unicode()));
//get delimiter
QString delimiter;
for (yyCh = getChar(); yyCh != EOF && yyCh != '('; yyCh = getChar())
delimiter += QLatin1Char(yyCh);
if (yyCh != EOF)
yyCh = getChar(); // throw away the opening parentheses
bool is_end = false;
ushort *ptr_past_end = nullptr;
while (yyCh != EOF && !is_end) {
*ptr++ = yyCh;
if (ptr_past_end != nullptr) {
if (delimiter.size() == ptr - ptr_past_end
&& memcmp(delimiter.unicode(), ptr_past_end, (ptr - ptr_past_end) * sizeof (ushort)) == 0
) {
// we've got the delimiter, check if " follows
yyCh = getChar();
if (yyCh == '"')
is_end = true;
else
ptr_past_end = nullptr;
continue;
}
}
if (yyCh == ')') {
ptr_past_end = ptr;
if (delimiter.isEmpty()) {
// no delimiter, check if " follows
yyCh = getChar();
if (yyCh == '"')
is_end = true;
else
ptr_past_end = nullptr;
continue;
}
}
yyCh = getChar();
}
if (is_end)
yyWord.resize(ptr_past_end - 1 - reinterpret_cast<const ushort *>(yyWord.unicode()));
else
yyWord.resize(ptr - reinterpret_cast<const ushort *>(yyWord.unicode()));
if (yyCh != '"')
yyMsg() << "Unterminated/mismatched C++ Raw string\n";
else
yyCh = getChar();
return Tok_RawString;
}
return Tok_Ident;
} else {
switch (yyCh) {
case '\n':
if (inDefine) {
loadState(savedState);
prospectiveContext.clear();
yyBraceDepth = yyMinBraceDepth;
yyMinBraceDepth = 0;
inDefine = false;
metaExpected = true;
yyCh = getChar();
return Tok_Cancel; // Break out of any multi-token constructs
}
yyCh = getChar();
break;
case '/':
yyCh = getChar();
if (yyCh == '/') {
ushort *ptr = (ushort *)yyWord.unicode();
do {
yyCh = getChar();
if (yyCh == EOF)
break;
*ptr++ = yyCh;
} while (yyCh != '\n');
yyWord.resize(ptr - (ushort *)yyWord.unicode());
processComment();
} else if (yyCh == '*') {
bool metAster = false;
ushort *ptr = (ushort *)yyWord.unicode();
forever {
yyCh = getChar();
if (yyCh == EOF) {
yyMsg() << "Unterminated C++ comment\n";
break;
}
*ptr++ = yyCh;
if (yyCh == '*')
metAster = true;
else if (metAster && yyCh == '/')
break;
else
metAster = false;
}
yyWord.resize(ptr - (ushort *)yyWord.unicode() - 2);
processComment();
yyCh = getChar();
}
break;
case '"': {
ushort *ptr = (ushort *)yyWord.unicode();
yyCh = getChar();
while (yyCh != EOF && yyCh != '\n' && yyCh != '"') {
if (yyCh == '\\') {
yyCh = getChar();
if (yyCh == EOF || yyCh == '\n')
break;
*ptr++ = '\\';
}
*ptr++ = yyCh;
yyCh = getChar();
}
yyWord.resize(ptr - (ushort *)yyWord.unicode());
if (yyCh != '"')
yyMsg() << "Unterminated C++ string\n";
else
yyCh = getChar();
return Tok_String;
}
case '-':
yyCh = getChar();
if (yyCh == '>') {
yyCh = getChar();
return Tok_Arrow;
}
break;
case ':':
yyCh = getChar();
if (yyCh == ':') {
yyCh = getChar();
return Tok_ColonColon;
}
return Tok_Colon;
// Incomplete: '<' might be part of '<=' or of template syntax.
// The main intent of not completely ignoring it is to break
// parsing of things like std::cout << QObject::tr() as
// context std::cout::QObject (see Task 161106)
case '=':
yyCh = getChar();
return Tok_Equals;
case '>':
yyCh = getChar();
return Tok_RightAngleBracket;
case '<':
yyCh = getChar();
if (yyCh == '<') {
yyCh = getChar();
return Tok_LeftShift;
}
return Tok_LeftAngleBracket;
case '\'':
yyCh = getChar();
if (yyCh == '\\')
yyCh = getChar();
forever {
if (yyCh == EOF || yyCh == '\n') {
yyMsg() << "Unterminated C++ character\n";
break;
}
yyCh = getChar();
if (yyCh == '\'') {
yyCh = getChar();
break;
}
}
break;
case '{':
if (yyBraceDepth == 0)
yyBraceLineNo = yyCurLineNo;
yyBraceDepth++;
yyCh = getChar();
return Tok_LeftBrace;
case '}':
if (yyBraceDepth == yyMinBraceDepth) {
if (!inDefine)
yyMsg(yyCurLineNo)
<< "Excess closing brace in C++ code"
" (or abuse of the C++ preprocessor)\n";
// Avoid things getting messed up even more
yyCh = getChar();
return Tok_Semicolon;
}
yyBraceDepth--;
yyCh = getChar();
return Tok_RightBrace;
case '(':
if (yyParenDepth == 0)
yyParenLineNo = yyCurLineNo;
yyParenDepth++;
yyCh = getChar();
return Tok_LeftParen;
case ')':
if (yyParenDepth == 0)
yyMsg(yyCurLineNo)
<< "Excess closing parenthesis in C++ code"
" (or abuse of the C++ preprocessor)\n";
else
yyParenDepth--;
yyCh = getChar();
return Tok_RightParen;
case '[':
yyCh = getChar();
if (yyCh == '[') {
// C++11 attribute: [[...]]
yyCh = getChar();
int depth = 2;
bool inString = false;
bool inChar = false;
bool escaped = false;
// Need to handle nested brackets, strings, and character literals
while (depth > 0 && yyCh != EOF) {
if (escaped) {
escaped = false;
} else if (yyCh == '\\') {
escaped = true;
} else if (yyCh == '"' && !inChar) {
inString = !inString;
} else if (yyCh == '\'' && !inString) {
inChar = !inChar;
} else if (!inString && !inChar) {
if (yyCh == '[')
depth++;
else if (yyCh == ']')
depth--;
}
yyCh = getChar();
}
if (yyCh == EOF) {
yyMsg(yyCurLineNo) << "Unterminated C++ attribute (missing ']]')\n";
return Tok_LeftBracket;
}
yyCh = getChar();
return Tok_Attribute;
}
if (yyBracketDepth == 0)
yyBracketLineNo = yyCurLineNo;
yyBracketDepth++;
return Tok_LeftBracket;
case ']':
if (yyBracketDepth == 0)
yyMsg(yyCurLineNo)
<< "Excess closing bracket in C++ code"
" (or abuse of the C++ preprocessor)\n";
else
yyBracketDepth--;
yyCh = getChar();
return Tok_RightBracket;
case ',':
yyCh = getChar();
return Tok_Comma;
case ';':
yyCh = getChar();
return Tok_Semicolon;
case '?':
yyCh = getChar();
return Tok_QuestionMark;
case '0':
yyCh = getChar();
if (yyCh == 'x' || yyCh == 'X') {
do {
yyCh = getChar();
} while ((yyCh >= '0' && yyCh <= '9') || yyCh == '\''
|| (yyCh >= 'a' && yyCh <= 'f') || (yyCh >= 'A' && yyCh <= 'F'));
return Tok_Integer;
}
if (yyCh < '0' || yyCh > '9')
return Tok_Null;
Q_FALLTHROUGH();
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
do {
yyCh = getChar();
} while ((yyCh >= '0' && yyCh <= '9') || yyCh == '\'');
return Tok_Integer;
default:
yyCh = getChar();
break;
}
}
}
return Tok_Eof;
}
/*
The second part of this source file are namespace/class related
utilities for the third part.
*/
void CppParser::saveState(CppParserState *state)
{
*state = *this;
}
void CppParser::loadState(const CppParserState &state)
{
*static_cast<CppParserState *>(this) = state;
}
Namespace *CppParser::modifyNamespace(NamespaceList *namespaces, bool haveLast)
{
Namespace *pns, *ns = &results->rootNamespace;
for (int i = 1; i < namespaces->size(); ++i) {
pns = ns;
if (!(ns = pns->children.value(namespaces->at(i)))) {
do {
ns = new Namespace;
if (haveLast || i < namespaces->size() - 1)
if (const Namespace *ons = findNamespace(*namespaces, i + 1))
ns->classDef = ons->classDef;
pns->children.insert(namespaces->at(i), ns);
ns->parent = pns;
pns = ns;
} while (++i < namespaces->size());
break;
}
}
return ns;
}
QString CppParser::stringifyNamespace(int start, const NamespaceList &namespaces)
{
QString ret;
int l = 0;
for (int j = start; j < namespaces.size(); ++j)
l += namespaces.at(j).value().size();
ret.reserve(l + qMax(0, (namespaces.size() - start - 1)) * 2);
for (int i = start; i < namespaces.size(); ++i) {
if (i > start)
ret += "::"_L1;
ret += namespaces.at(i).value();
}
return ret;
}
QString CppParser::joinNamespaces(const QString &one, const QString &two)
{
return two.isEmpty() ? one : one.isEmpty() ? two : one + QStringLiteral("::") + two;
}
bool CppParser::visitNamespace(const NamespaceList &namespaces, int nsCount,
VisitNamespaceCallback callback, void *context,
VisitRecorder &vr, const ParseResults *rslt) const
{
const Namespace *ns = &rslt->rootNamespace;
for (int i = 1; i < nsCount; ++i)
if (!(ns = ns->children.value(namespaces.at(i))))
goto supers;
if ((this->*callback)(ns, context))
return true;
supers:
for (const ParseResults *sup : rslt->includes)
if (vr.tryVisit(sup->fileId)
&& visitNamespace(namespaces, nsCount, callback, context, vr, sup))
return true;
return false;
}
bool CppParser::visitNamespace(const NamespaceList &namespaces, int nsCount,
VisitNamespaceCallback callback, void *context) const
{
VisitRecorder vr;
return visitNamespace(namespaces, nsCount, callback, context, vr, results);
}
struct QualifyOneData {
QualifyOneData(const NamespaceList &ns, int nsc, const HashString &seg, NamespaceList *rslvd,
QSet<HashStringList> *visited, Namespace const **resolvedNs)
: namespaces(ns),
nsCount(nsc),
segment(seg),
resolved(rslvd),
visitedUsings(visited),
resolvedNamespace(resolvedNs)
{}
const NamespaceList &namespaces;
int nsCount;
const HashString &segment;
NamespaceList *resolved;
QSet<HashStringList> *visitedUsings;
Namespace const **resolvedNamespace;
};
bool CppParser::qualifyOneCallbackOwn(const Namespace *ns, void *context) const
{
QualifyOneData *data = (QualifyOneData *)context;
if (auto rns = ns->children.constFind(data->segment); rns != ns->children.cend()) {
*data->resolved = data->namespaces.mid(0, data->nsCount);
*data->resolved << data->segment;
*data->resolvedNamespace = *rns;
return true;
}
auto nsai = ns->aliases.constFind(data->segment);
if (nsai != ns->aliases.constEnd()) {
const NamespaceList &nsl = *nsai;
if (nsl.last().value().isEmpty()) { // Delayed alias resolution
NamespaceList &nslIn = *const_cast<NamespaceList *>(&nsl);
nslIn.removeLast();
NamespaceList nslOut;
if (!fullyQualify(data->namespaces, data->nsCount, nslIn, false, &nslOut, 0)) {
const_cast<Namespace *>(ns)->aliases.remove(data->segment);
return false;
}
nslIn = nslOut;
}
*data->resolved = nsl;
*data->resolvedNamespace = ns;
return true;
}
return false;
}
bool CppParser::qualifyOneCallbackUsing(const Namespace *ns, void *context) const
{
QualifyOneData *data = (QualifyOneData *)context;
for (const HashStringList &use : ns->usings)
if (!data->visitedUsings->contains(use)) {
data->visitedUsings->insert(use);
if (qualifyOne(use.value(), use.value().size(), data->segment, data->resolved,
data->resolvedNamespace, data->visitedUsings))
return true;
}
return false;
}
bool CppParser::qualifyOne(const NamespaceList &namespaces, int nsCnt, const HashString &segment,
NamespaceList *resolved, Namespace const **resolvedNamespace,
QSet<HashStringList> *visitedUsings, bool *foundViaUsing) const
{
QualifyOneData data(namespaces, nsCnt, segment, resolved, visitedUsings, resolvedNamespace);
if (visitNamespace(namespaces, nsCnt, &CppParser::qualifyOneCallbackOwn, &data)) {
if (foundViaUsing)
*foundViaUsing = false;
return true;
}
if (visitNamespace(namespaces, nsCnt, &CppParser::qualifyOneCallbackUsing, &data)) {
if (foundViaUsing)
*foundViaUsing = true;
return true;
}
return false;
}
bool CppParser::qualifyOne(const NamespaceList &namespaces, int nsCnt, const HashString &segment,
NamespaceList *resolved, Namespace const **resolvedNamespace) const
{
QSet<HashStringList> visitedUsings;
return qualifyOne(namespaces, nsCnt, segment, resolved, resolvedNamespace, &visitedUsings);
}
bool CppParser::fullyQualify(const NamespaceList &namespaces, int nsCnt,
const NamespaceList &segments, bool isDeclaration,
NamespaceList *resolved, NamespaceList *unresolved) const
{
int nsIdx;
int initSegIdx;
if (segments.first().value().isEmpty()) {
// fully qualified
if (segments.size() == 1) {
resolved->clear();
*resolved << HashString(QString());
return true;
}
initSegIdx = 1;
nsIdx = 0;
} else {
initSegIdx = 0;
nsIdx = nsCnt - 1;
}
// Check if the identifier to resolve shares a common suffix
// with the current namespace path. This handles cases like:
// - Current scope: ["", "Outer", "Test"]
// - Trying to resolve: ["Outer", "Test"]
auto matchSeg = segments.crbegin();
auto matchNs = namespaces.crbegin();
if (matchSeg->value() != matchNs->value())
matchSeg++;
int matchingSuffixLength = 0;
while (matchSeg != segments.crend()
&& matchNs != namespaces.crend()
&& matchSeg->value() == matchNs->value()) {
matchSeg++;
matchNs++;
matchingSuffixLength++;
}
// The main loop to resolve the segments in the current namespace.
// There are three possible outcomes:
// 1. resolution of the segments into a class that has tr
// functions (hasTrFunction) if available (trCandidate).
// 2. resolution of the segments into a namespace/class without a
// tr function -> in this case, if we're in a handleTr (or
// similar) function, the caller issues a warning (noTrCandidate).
// 3. the segments cannot be resolved in the current namespace -> in
// this case, we calculate the non-resolved part (unresolvedCandidate)
bool viaUsing = false;
std::optional<NamespaceList> trCandidate;
std::optional<NamespaceList> noTrCandidate;
std::optional<NamespaceList> unresolvedCandidate;
do {
Namespace const *resolvedNs = nullptr;
int segIdx = initSegIdx;
int resolveSize = nsIdx + 1;
*resolved = namespaces;
do {
QSet<HashStringList> visitedUsings;
if (!qualifyOne(*resolved, resolveSize, segments[segIdx], resolved, &resolvedNs,
&visitedUsings, &viaUsing))
break; // could not resolve
segIdx++;
resolveSize = resolved->size();
} while (segIdx < segments.size());
if (segIdx == segments.size()) { // resolved
if (resolvedNs && resolvedNs->classDef && resolvedNs->classDef->hasTrFunctions) {
if (!viaUsing)
return true;
else if (!trCandidate)
trCandidate.emplace(*resolved);
} else if (resolvedNs) {
if (!viaUsing)
noTrCandidate.emplace(*resolved);
else if (!noTrCandidate)
noTrCandidate.emplace(*resolved);
}
} else if (!unresolvedCandidate) { // unresolved
unresolvedCandidate.emplace(segments.mid(segIdx));
}
// For declarations: limit search to suffix-matched depths
// For usages: search all parent levels (standard C++ lookup)
} while ((!isDeclaration || matchingSuffixLength-- > 0) && --nsIdx >= 0);
// Depending on the case, after the loop, we might have only one of the
// outcome candidates, or 2 or 3 (all possbile outcome candidates).
// We prioritize the candidates as follows:
// 1. if a class with tr commands is found (trCandidate), we take it
// as the result.
// 2. otherwise, if any class/namespace without tr commands is
// found (noTrCandidate), take it as the result.
// 3. Finally, if none of the above candidates are found, we return the
// unresolved part (unresolvedCandidate).
if (trCandidate) { // resolved class with tr functions gets priority
*resolved = *trCandidate;
return true;
} else if (noTrCandidate) { // the non-tr resolved namespace/class
*resolved = *noTrCandidate;
return true;
} else if (unresolvedCandidate && unresolved) {
*unresolved = *unresolvedCandidate;
}
resolved->clear();
*resolved << HashString(QString());
if (unresolved)
*unresolved = segments.mid(initSegIdx);
return false;
}
bool CppParser::fullyQualify(const NamespaceList &namespaces,
const NamespaceList &segments, bool isDeclaration,
NamespaceList *resolved, NamespaceList *unresolved) const
{
return fullyQualify(namespaces, namespaces.size(),
segments, isDeclaration, resolved, unresolved);
}
bool CppParser::fullyQualify(const NamespaceList &namespaces,
const QString &quali, bool isDeclaration,
NamespaceList *resolved, NamespaceList *unresolved) const
{
NamespaceList segments;
for (const QString &str : quali.split("::"_L1)) // XXX slow, but needs to be fast(?)
segments << HashString(str);
return fullyQualify(namespaces, segments, isDeclaration, resolved, unresolved);
}
bool CppParser::findNamespaceCallback(const Namespace *ns, void *context) const
{
*((const Namespace **)context) = ns;
return true;
}
Namespace *CppParser::findNamespace(const NamespaceList &namespaces, int nsCount) const
{
Namespace *ns = 0;
if (nsCount == -1)
nsCount = namespaces.size();
visitNamespace(namespaces, nsCount, &CppParser::findNamespaceCallback, &ns);
return ns;
}
void CppParser::enterNamespace(NamespaceList *namespaces, const HashString &name)
{
*namespaces << name;
Namespace *ns;
if (!(ns = findNamespace(*namespaces)))
ns = modifyNamespace(namespaces, false);
const Namespace *cns = &results->rootNamespace;
for (int i = 1; i < namespaces->size(); ++i) {
ns->usings << cns->usings;
if (!(cns = cns->children.value(namespaces->at(i))))
break;
}
}
void CppParser::truncateNamespaces(NamespaceList *namespaces, int length)
{
if (namespaces->size() > length)
namespaces->erase(namespaces->begin() + length, namespaces->end());
}
/*
Functions for processing include files.
*/
size_t qHash(const CppParserState &s, size_t seed)
{
seed = qHash(s.namespaces, seed);
seed = qHash(s.namespaceDepths, seed);
seed = qHash(s.functionContext, seed);
seed = qHash(s.functionContextUnresolved, seed);
seed = qHash(s.pendingContext, seed);
return seed;
}
size_t qHash(const ResultsCacheKey &key, size_t seed)
{
seed = qHash(key.cleanFile, seed);
seed = qHash(key.parserState, seed);
return seed;
}
IncludeCycleHash &CppFiles::includeCycles()
{
static IncludeCycleHash cycles;
return cycles;
}
TranslatorHash &CppFiles::translatedFiles()
{
static TranslatorHash tors;
return tors;
}
QSet<QString> &CppFiles::blacklistedFiles()
{
static QSet<QString> blacklisted;
return blacklisted;
}
QSet<const ParseResults *> CppFiles::getResults(const ResultsCacheKey &key)
{
IncludeCycle * const cycle = includeCycles().value(key);
if (cycle)
return cycle->results;
else
return QSet<const ParseResults *>();
}
void CppFiles::setResults(const ResultsCacheKey &key, const ParseResults *results)
{
IncludeCycle *cycle = includeCycles().value(key);
if (!cycle) {
cycle = new IncludeCycle;
includeCycles().insert(key, cycle);
}
cycle->fileNames.insert(key.cleanFile);
cycle->results.insert(results);
}
const Translator *CppFiles::getTranslator(const QString &cleanFile)
{
return translatedFiles().value(cleanFile);
}
void CppFiles::setTranslator(const QString &cleanFile, const Translator *tor)
{
translatedFiles().insert(cleanFile, tor);
}
bool CppFiles::isBlacklisted(const QString &cleanFile)
{
return blacklistedFiles().contains(cleanFile);
}
void CppFiles::setBlacklisted(const QString &cleanFile)
{
blacklistedFiles().insert(cleanFile);
}
void CppFiles::addIncludeCycle(const QSet<QString> &fileNames, const CppParserState &parserState)
{
IncludeCycle * const cycle = new IncludeCycle;
cycle->fileNames = fileNames;
QSet<IncludeCycle *> intersectingCycles;
for (const QString &fileName : fileNames) {
const ResultsCacheKey key = { fileName, parserState };
IncludeCycle *intersectingCycle = includeCycles().value(key);
if (intersectingCycle && !intersectingCycles.contains(intersectingCycle)) {
intersectingCycles.insert(intersectingCycle);
cycle->fileNames.unite(intersectingCycle->fileNames);
cycle->results.unite(intersectingCycle->results);
}
}
qDeleteAll(intersectingCycles);
for (const QString &fileName : std::as_const(cycle->fileNames))
includeCycles().insert({ fileName, parserState }, cycle);
}
static bool isHeader(const QString &name)
{
QString fileExt = QFileInfo(name).suffix();
return fileExt.isEmpty() || fileExt.startsWith(u'h', Qt::CaseInsensitive);
}
void CppParser::processInclude(const QString &file, ConversionData &cd, const QStringList &includeStack,
QSet<QString> &inclusions)
{
QString cleanFile = QDir::cleanPath(file);
for (const QRegularExpression &rx : std::as_const(cd.m_excludes)) {
if (rx.match(cleanFile).hasMatch())
return;
}
const int index = includeStack.indexOf(cleanFile);
if (index != -1) {
CppFiles::addIncludeCycle(QSet<QString>(includeStack.cbegin() + index, includeStack.cend()),
*this);
return;
}
// If the #include has been blacklisted previously,
// or is not a header file (stdc++ extensionless or *.h*), then really include
// it. Otherwise it is safe to process it stand-alone and re-use the parsed
// namespace data for inclusion into other files.
bool isIndirect = false;
if (!CppFiles::isBlacklisted(cleanFile)
&& isHeader(cleanFile)) {
QSet<const ParseResults *> res = CppFiles::getResults(ResultsCacheKey(cleanFile, *this));
if (!res.isEmpty()) {
results->includes.unite(res);
return;
}
isIndirect = true;
}
QFile f(cleanFile);
if (!f.open(QIODevice::ReadOnly)) {
yyMsg() << qPrintable(
QStringLiteral("Cannot open %1: %2\n").arg(cleanFile, f.errorString()));
return;
}
QTextStream ts(&f);
ts.setEncoding(yySourceEncoding);
ts.setAutoDetectUnicode(true);
inclusions.insert(cleanFile);
if (isIndirect) {
CppParser parser;
for (const QString &projectRoot : std::as_const(cd.m_projectRoots))
if (cleanFile.startsWith(projectRoot)) {
parser.setTranslator(new Translator);
break;
}
parser.setInput(ts, cleanFile);
QStringList stack = includeStack;
stack << cleanFile;
parser.parse(cd, stack, inclusions);
results->includes.insert(parser.recordResults(true));
} else {
CppParser parser(results);
parser.namespaces = namespaces;
parser.functionContext = functionContext;
parser.functionContextUnresolved = functionContextUnresolved;
parser.setInput(ts, cleanFile);
parser.setTranslator(tor);
QStringList stack = includeStack;
stack << cleanFile;
parser.parseInternal(cd, stack, inclusions);
// Avoid that messages obtained by direct scanning are used
CppFiles::setBlacklisted(cleanFile);
}
inclusions.remove(cleanFile);
prospectiveContext.clear();
pendingContext.clear();
}
/*
The third part of this source file is the parser. It accomplishes
a very easy task: It finds all strings inside a tr() or translate()
call, and possibly finds out the context of the call. It supports
three cases: (1) the context is specified, as in
FunnyDialog::tr("Hello") or translate("FunnyDialog", "Hello");
(2) the call appears within an inlined function; (3) the call
appears within a function defined outside the class definition.
*/
bool CppParser::match(TokenType t)
{
bool matches = (yyTok == t);
if (matches)
yyTok = getToken();
return matches;
}
bool CppParser::matchString(QString *s)
{
bool matches = false;
s->clear();
forever {
if (yyTok != Tok_String && yyTok != Tok_RawString)
return matches;
matches = true;
if (yyTok == Tok_String)
*s += transcode(yyWord);
else
*s += yyWord;
s->detach();
yyTok = getToken();
}
}
static const QString strQApplication = u"QApplication"_s;
static const QString strQCoreApplication = u"QCoreApplication"_s;
static const QString strUnicodeUTF8 = u"UnicodeUTF8"_s;
static const QString strDefaultCodec = u"DefaultCodec"_s;
static const QString strCodecForTr = u"CodecForTr"_s;
static const QString strLatin1 = u"Latin1"_s;
bool CppParser::matchEncoding()
{
if (yyTok != Tok_Ident)
return false;
if (yyWord == strQApplication || yyWord == strQCoreApplication) {
yyTok = getToken();
if (yyTok == Tok_ColonColon)
yyTok = getToken();
}
if (yyWord == strUnicodeUTF8) {
yyTok = getToken();
return true;
}
if (yyWord == strLatin1 || yyWord == strDefaultCodec || yyWord == strCodecForTr)
yyMsg() << "Unsupported encoding Latin1/DefaultCodec/CodecForTr\n";
return false;
}
bool CppParser::matchStringOrNull(QString *s)
{
return matchString(s) || match(Tok_Null);
}
/*
* Skip over a C++ expression by consuming tokens until reaching an unmatched
* closing parenthesis. This is used to skip expression arguments in translate
* calls without needing to parse or validate the expression structure.
*
* The function handles any valid C++ expression, including complex ones with
* nested parentheses, operators, casts, templates, and other constructs.
*
* Returns true if the expression was successfully skipped, false if EOF or
* a cancellation token was encountered before finding the end.
*/
bool CppParser::skipExpression()
{
if (match(Tok_Null) || match(Tok_Integer))
return true;
int parenlevel = 0;
while (parenlevel >= 0) {
yyTok = getToken();
if (yyTok == Tok_RightParen)
--parenlevel;
else if (yyTok == Tok_LeftParen)
++parenlevel;
else if (yyTok == Tok_Cancel || yyTok == Tok_Eof)
return false;
}
return true;
}
void CppParser::recordMessage(int line, const QString &context, const QString &text,
const QString &comment, const QString &extracomment,
const QString &msgid, const QString &label,
const TranslatorMessage::ExtraData &extra,
bool plural, int startOffset, int endOffset)
{
TranslatorMessage msg(transcode(context), text, transcode(comment), QString(), yyFileName, line,
QStringList(), TranslatorMessage::Unfinished, plural);
msg.setExtraComment(transcode(extracomment.simplified()));
msg.setId(msgid);
msg.setExtras(extra);
if (!msgid.isEmpty())
msg.setLabel(label);
msg.setStartOffset(startOffset);
msg.setEndOffset(endOffset);
tor->append(msg);
}
void CppParser::handleTr(QString &prefix, bool plural)
{
if (!m_metaStrings.sourcetext().isEmpty())
yyMsg() << "//% cannot be used with tr() / QT_TR_NOOP(). Ignoring\n";
if (!m_metaStrings.label().isEmpty())
yyMsg() << "labels cannot be used with text-based translation. Ignoring\n";
int line = yyLineNo;
const int startOffset = lookBackFunctionCallStart(prefix.size());
yyTok = getToken();
QString text;
if (matchString(&text)) {
QString comment;
if (yyTok == Tok_RightParen) {
// no comment
} else if (match(Tok_Comma) && matchStringOrNull(&comment)) { //comment
if (yyTok == Tok_RightParen) {
// ok,
} else if (match(Tok_Comma)) {
plural = true;
skipExpression();
}
}
if (!pendingContext.isEmpty() && !prefix.startsWith("::"_L1)) {
NamespaceList unresolved;
if (!fullyQualify(namespaces, pendingContext, true, &functionContext, &unresolved)) {
functionContextUnresolved = stringifyNamespace(0, unresolved);
yyMsg() << qPrintable(
QStringLiteral("Qualifying with unknown namespace/class %1::%2\n")
.arg(stringifyNamespace(functionContext)).arg(unresolved.first().value()));
}
pendingContext.clear();
}
if (prefix.isEmpty()) {
if (functionContextUnresolved.isEmpty()) {
int idx = functionContext.size();
if (idx < 2) {
yyMsg() << "tr() cannot be called without context\n";
return;
}
Namespace *fctx;
while (!(fctx = findNamespace(functionContext, idx)->classDef)->hasTrFunctions) {
if (idx == 1) {
context = stringifyNamespace(functionContext);
fctx = findNamespace(functionContext)->classDef;
if (!fctx->complained) {
yyMsg() << qPrintable(
QStringLiteral("Class '%1' lacks Q_OBJECT macro\n").arg(context));
fctx->complained = true;
}
goto gotctx;
}
--idx;
}
if (fctx->trQualification.isEmpty()) {
context.clear();
for (int i = 1;;) {
context += functionContext.at(i).value();
if (++i == idx)
break;
context += "::"_L1;
}
fctx->trQualification = context;
} else {
context = fctx->trQualification;
}
} else {
context = joinNamespaces(stringifyNamespace(functionContext), functionContextUnresolved);
}
} else {
prefix.chop(2);
NamespaceList nsl;
NamespaceList unresolved;
if (fullyQualify(functionContext, prefix, false, &nsl, &unresolved)) {
Namespace *fctx = findNamespace(nsl)->classDef;
if (fctx->trQualification.isEmpty()) {
context = stringifyNamespace(nsl);
fctx->trQualification = context;
} else {
context = fctx->trQualification;
}
if (!fctx->hasTrFunctions && !fctx->complained) {
yyMsg() << qPrintable(QStringLiteral("Class '%1' lacks Q_OBJECT macro\n")
.arg(context));
fctx->complained = true;
}
} else {
context = joinNamespaces(stringifyNamespace(nsl), stringifyNamespace(0, unresolved));
}
prefix.clear();
}
gotctx:
const int endOffset = yyInPtr - (const ushort *)yyInStr.unicode() - 1;
recordMessage(line, context, text, comment, m_metaStrings.extracomment(),
m_metaStrings.msgid(), QString(), m_metaStrings.extra(),
plural, startOffset, endOffset);
}
m_metaStrings.clear();
}
void CppParser::handleTranslate(int prefixSize, bool plural)
{
if (!m_metaStrings.sourcetext().isEmpty())
yyMsg() << "//% cannot be used with translate() / QT_TRANSLATE_NOOP(). Ignoring\n";
if (!m_metaStrings.label().isEmpty())
yyMsg() << "labels cannot be used with text-based translation. Ignoring\n";
const int startOffset = lookBackFunctionCallStart(prefixSize);
int line = yyLineNo;
yyTok = getToken();
QString text;
if (matchString(&context)
&& match(Tok_Comma)
&& matchString(&text) && !text.isEmpty())
{
QString comment;
if (yyTok != Tok_RightParen) {
// look for comment
if (match(Tok_Comma) && matchStringOrNull(&comment)) {
if (yyTok != Tok_RightParen) {
// look for encoding
if (match(Tok_Comma)) {
if (matchEncoding()) {
if (yyTok != Tok_RightParen) {
// look for the plural quantifier,
// this can be a number, an identifier or
// a function call,
// so for simplicity we mark it as plural if
// we know we have a comma instead of an
// right parentheses.
plural |= match(Tok_Comma);
}
} else {
// This can be a QTranslator::translate("context",
// "source", "comment", n) plural translation
if (skipExpression() && yyTok == Tok_RightParen) {
plural = true;
} else {
return;
}
}
} else {
return;
}
}
} else {
return;
}
}
const int endOffset = yyInPtr - (const ushort *)yyInStr.unicode() - 1;
recordMessage(line, context, text, comment, m_metaStrings.extracomment(),
m_metaStrings.msgid(), QString(), m_metaStrings.extra(),
plural, startOffset, endOffset);
}
m_metaStrings.clear();
}
void CppParser::handleTrId(int prefixSize, bool plural)
{
if (!m_metaStrings.msgid().isEmpty())
yyMsg() << "//= cannot be used with qtTrId() / QT_TRID_NOOP(). Ignoring\n";
int line = yyLineNo;
const int startOffset = lookBackFunctionCallStart(prefixSize);
yyTok = getToken();
QString msgid;
if (matchString(&msgid) && !msgid.isEmpty()) {
plural |= match(Tok_Comma);
const int endOffset = yyInPtr - (const ushort *)yyInStr.unicode() - 1;
recordMessage(line, QString(), transcode(m_metaStrings.sourcetext()), QString(),
m_metaStrings.extracomment(), msgid, m_metaStrings.label(),
m_metaStrings.extra(), plural, startOffset, endOffset);
}
m_metaStrings.clear();
}
void CppParser::handleDeclareTrFunctions()
{
QString name;
forever {
yyTok = getToken();
if (yyTok != Tok_Ident)
return;
name += yyWord;
name.detach();
yyTok = getToken();
if (yyTok == Tok_RightParen)
break;
if (yyTok != Tok_ColonColon)
return;
name += "::"_L1;
}
Namespace *ns = modifyNamespace(&namespaces);
ns->hasTrFunctions = true;
ns->trQualification = name;
ns->trQualification.detach();
}
void CppParser::parse(ConversionData &cd, const QStringList &includeStack,
QSet<QString> &inclusions)
{
namespaces << HashString();
functionContext = namespaces;
functionContextUnresolved.clear();
parseInternal(cd, includeStack, inclusions);
}
int CppParser::lookBackFunctionCallStart(int prefixSize)
{
const int funcNameOffset = yyInPtr - (const ushort *)yyInStr.unicode();
QStringView prefix = QStringView(yyInStr).sliced(0, funcNameOffset);
do
prefix.chop(1);
while (prefix.back() != '('_L1);
prefix.chop(prefixSize + yyWord.size() + 1);
auto chopMatch = [](auto& str, const auto& match) {
if (str.endsWith(match)) {
str.chop(match.size());
return true;
}
return false;
};
while (chopMatch(prefix, "."_L1) || chopMatch(prefix, "->"_L1)) {
int pos = prefix.size() - 1;
if (prefix.at(pos) == ')'_L1) {
int count = 1;
pos--;
while (count != 0 && pos >= 0) {
if (QChar c = prefix.at(pos--); c == ')'_L1)
count++;
else if (c == '('_L1)
count--;
else if (c == "\""_L1 || c == "'"_L1) {
const QChar quotation = c;
while (pos >= 0) {
c = prefix[pos--];
if (c == '\\'_L1)
pos--;
else if (c == quotation)
break;
}
}
}
}
while (pos >= 0 && (prefix.at(pos).isLetterOrNumber() || prefix.at(pos) == '_'_L1))
pos--;
prefix.slice(0, pos + 1);
}
return prefix.size();
}
bool CppParser::parseTranslate(QString &prefix)
{
bool forcePlural = false;
switch (trFunctionAliasManager.trFunctionByName(yyWord)) {
case TrFunctionAliasManager::Function_Q_DECLARE_TR_FUNCTIONS:
handleDeclareTrFunctions();
break;
case TrFunctionAliasManager::Function_QT_TR_N_NOOP:
forcePlural = true;
Q_FALLTHROUGH();
case TrFunctionAliasManager::Function_tr:
case TrFunctionAliasManager::Function_trUtf8:
case TrFunctionAliasManager::Function_QT_TR_NOOP:
case TrFunctionAliasManager::Function_QT_TR_NOOP_UTF8:
if (tor)
handleTr(prefix, forcePlural);
break;
case TrFunctionAliasManager::Function_QT_TRANSLATE_N_NOOP:
case TrFunctionAliasManager::Function_QT_TRANSLATE_N_NOOP3:
forcePlural = true;
Q_FALLTHROUGH();
case TrFunctionAliasManager::Function_translate:
case TrFunctionAliasManager::Function_findMessage:
case TrFunctionAliasManager::Function_QT_TRANSLATE_NOOP:
case TrFunctionAliasManager::Function_QT_TRANSLATE_NOOP_UTF8:
case TrFunctionAliasManager::Function_QT_TRANSLATE_NOOP3:
case TrFunctionAliasManager::Function_QT_TRANSLATE_NOOP3_UTF8:
if (tor)
handleTranslate(prefix.size(), forcePlural);
break;
case TrFunctionAliasManager::Function_QT_TRID_N_NOOP:
forcePlural = true;
Q_FALLTHROUGH();
case TrFunctionAliasManager::Function_qtTrId:
case TrFunctionAliasManager::Function_QT_TRID_NOOP:
if (tor)
handleTrId(prefix.size(), forcePlural);
break;
default:
return false;
}
return true;
}
void CppParser::parseInternal(ConversionData &cd, const QStringList &includeStack,
QSet<QString> &inclusions)
{
static constexpr auto strColons("::"_L1);
QString prefix;
bool yyTokColonSeen = false; // Start of c'tor's initializer list
bool yyTokIdentSeen = false; // Start of initializer (member or base class)
bool maybeInTrailingReturnType = false;
const QList<TokenType> allowedTokensInFnTemplate{
Tok_Ident, Tok_decltype, Tok_ColonColon, Tok_Comma,
Tok_Integer, Tok_LeftAngleBracket, Tok_RightAngleBracket
};
metaExpected = true;
prospectiveContext.clear();
pendingContext.clear();
yyWord.reserve(yyInStr.size()); // Rather insane. That's because we do no length checking.
yyWordInitialCapacity = yyWord.capacity();
yyInPtr = (const ushort *)yyInStr.unicode();
yyCh = getChar();
yyTok = getToken();
while (yyTok != Tok_Eof) {
// these are array indexing operations. we ignore them entirely
// so they don't confuse our scoping of static initializers.
// we enter the loop by either reading a left bracket or by an
// #else popping the state.
if (yyBracketDepth && yyBraceDepth == namespaceDepths.size()) {
yyTok = getToken();
continue;
}
//qDebug() << "TOKEN: " << yyTok;
switch (yyTok) {
case Tok_QuotedInclude: {
QString text = QDir(QFileInfo(yyFileName).absolutePath()).absoluteFilePath(yyWord);
text.detach();
if (QFileInfo(text).isFile()) {
processInclude(text, cd, includeStack, inclusions);
yyTok = getToken();
break;
}
}
Q_FALLTHROUGH();
case Tok_AngledInclude: {
const QStringList cSources = cd.m_allCSources.values(yyWord);
if (!cSources.isEmpty()) {
for (const QString &cSource : cSources)
processInclude(cSource, cd, includeStack, inclusions);
goto incOk;
}
for (const QString &incPath : std::as_const(cd.m_includePath)) {
QString text = QDir(incPath).absoluteFilePath(yyWord);
text.detach();
if (QFileInfo(text).isFile()) {
processInclude(text, cd, includeStack, inclusions);
goto incOk;
}
}
incOk:
yyTok = getToken();
break;
}
case Tok_friend:
yyTok = getToken();
// These are forward declarations, so ignore them.
if (yyTok == Tok_class)
yyTok = getToken();
break;
case Tok_class:
/*
Partial support for inlined functions.
*/
case_class:
yyTok = getToken();
if (yyTok == Tok_Equals) { // we're in a template entity
yyTok = getToken();
break;
} else if (yyBraceDepth == namespaceDepths.size() && yyParenDepth == 0) {
NamespaceList quali;
HashString fct;
// Find class name including qualification
forever {
QString text = yyWord;
text.detach();
fct.setValue(text);
yyTok = getToken();
if (yyTok == Tok_ColonColon) {
quali << fct;
yyTok = getToken();
} else if (yyTok == Tok_Ident) {
if (yyWord == strfinal) {
// C++11: final may appear immediately after the name of the class
yyTok = getToken();
break;
}
// Handle impure definitions such as 'class Q_EXPORT QMessageBox', in
// which case 'QMessageBox' is the class name, not 'Q_EXPORT', by
// abandoning any qualification collected so far.
quali.clear();
} else if (yyTok == Tok_Attribute) {
yyTok = getToken();
} else {
break;
}
}
if (yyTok == Tok_Colon || yyTok == Tok_LeftAngleBracket) {
// Skip any token until '{' or ';' since we might do things wrong if we find
// a '::' or ':' token here.
do {
yyTok = getToken();
tokenInTemplate:
if (yyTok == Tok_Eof)
goto goteof;
if (yyTok == Tok_Cancel)
goto case_default;
if (yyTok == Tok_class)
goto case_class;
if (yyTok == Tok_Ident) {
yyTok = getToken();
if (yyTok == Tok_LeftParen)
parseTranslate(prefix);
else
goto tokenInTemplate;
}
} while (yyTok != Tok_LeftBrace && yyTok != Tok_Semicolon);
if (yyTok == Tok_Semicolon)
break;
} else {
if (yyTok != Tok_LeftBrace) {
// Obviously a forward declaration. We skip those, as they
// don't create actually usable namespaces.
break;
}
}
if (!quali.isEmpty()) {
// Forward-declared class definitions can be namespaced.
NamespaceList nsl;
if (!fullyQualify(namespaces, quali, true, &nsl, 0)) {
yyMsg() << "Ignoring definition of undeclared qualified class\n";
break;
}
namespaceDepths.push(namespaces.size());
namespaces = nsl;
} else {
namespaceDepths.push(namespaces.size());
}
enterNamespace(&namespaces, fct);
// Mark this namespace as a class
Namespace *ns = modifyNamespace(&namespaces);
ns->isClass = true;
functionContext = namespaces;
functionContextUnresolved.clear(); // Pointless
prospectiveContext.clear();
pendingContext.clear();
metaExpected = true;
yyTok = getToken();
}
break;
case Tok_namespace:
yyTok = getToken();
// Skip C++11 attributes on namespace
while (yyTok == Tok_Attribute)
yyTok = getToken();
if (yyTok == Tok_Ident) {
QString text = yyWord;
text.detach();
HashString ns = HashString(text);
NamespaceList nestedNamespaces;
forever {
yyTok = getToken();
if (yyTok != Tok_ColonColon)
break;
yyTok = getToken();
if (yyTok != Tok_Ident)
break; // whoops
nestedNamespaces.append(ns);
text = yyWord;
text.detach();
ns = HashString(text);
}
if (yyTok == Tok_LeftBrace) {
namespaceDepths.push(namespaces.size());
for (const auto &nns : nestedNamespaces)
enterNamespace(&namespaces, nns);
enterNamespace(&namespaces, ns);
functionContext = namespaces;
functionContextUnresolved.clear();
prospectiveContext.clear();
pendingContext.clear();
metaExpected = true;
yyTok = getToken();
} else if (yyTok == Tok_Equals) {
// e.g. namespace Is = OuterSpace::InnerSpace;
// Note: 'Is' being qualified is invalid per C++17.
NamespaceList fullName;
yyTok = getToken();
if (yyTok == Tok_ColonColon)
fullName.append(HashString(QString()));
while (yyTok == Tok_ColonColon || yyTok == Tok_Ident) {
if (yyTok == Tok_Ident) {
text = yyWord;
text.detach();
fullName.append(HashString(text));
}
yyTok = getToken();
}
if (fullName.isEmpty())
break;
fullName.append(HashString(QString())); // Mark as unresolved
modifyNamespace(&namespaces)->aliases[ns] = fullName;
}
} else if (yyTok == Tok_LeftBrace) {
// Anonymous namespace
namespaceDepths.push(namespaces.size());
metaExpected = true;
yyTok = getToken();
}
break;
case Tok_using:
yyTok = getToken();
// XXX this should affect only the current scope, not the entire current namespace
if (yyTok == Tok_namespace) {
NamespaceList fullName;
yyTok = getToken();
if (yyTok == Tok_ColonColon)
fullName.append(HashString(QString()));
while (yyTok == Tok_ColonColon || yyTok == Tok_Ident) {
if (yyTok == Tok_Ident) {
QString text = yyWord;
text.detach();
fullName.append(HashString(text));
}
yyTok = getToken();
}
NamespaceList nsl;
if (fullyQualify(namespaces, fullName, false, &nsl, 0))
modifyNamespace(&namespaces)->usings << HashStringList(nsl);
} else {
NamespaceList fullName;
if (yyTok == Tok_ColonColon)
fullName.append(HashString(QString()));
while (yyTok == Tok_ColonColon || yyTok == Tok_Ident) {
if (yyTok == Tok_Ident) {
QString text = yyWord;
text.detach();
fullName.append(HashString(text));
}
yyTok = getToken();
}
if (fullName.isEmpty())
break;
// using-declarations cannot rename classes, so the last element of
// fullName is already the resolved name we actually want.
// As we do no resolution here, we'll collect useless usings of data
// members and methods as well. This is no big deal.
fullName.append(HashString(QString())); // Mark as unresolved
const HashString &ns = *(fullName.constEnd() - 2);
modifyNamespace(&namespaces)->aliases[ns] = fullName;
}
break;
case Tok_Q_OBJECT:
modifyNamespace(&namespaces)->hasTrFunctions = true;
yyTok = getToken();
break;
case Tok_Ident: {
if (yyTokColonSeen &&
yyBraceDepth == namespaceDepths.size() && yyParenDepth == 0) {
// member or base class identifier
yyTokIdentSeen = true;
}
yyTok = getToken();
QString className;
bool methodSpecialization = false;
if (yyTok == Tok_LeftAngleBracket) { // maybe a method specialization
int count = 1;
className = yyWord;
className.detach();
yyTok = getToken();
while (count && allowedTokensInFnTemplate.contains(yyTok)) {
if (yyTok == Tok_LeftAngleBracket)
count++;
else if (yyTok == Tok_RightAngleBracket)
count--;
yyTok = getToken();
}
methodSpecialization = count == 0;
}
if (yyTok == Tok_LeftParen) {
if (parseTranslate(prefix)) {
yyTok = getToken();
break;
} else {
prefix.clear();
}
}
if (yyTok == Tok_ColonColon && !maybeInTrailingReturnType && !yyTrailingSpace) {
prefix += methodSpecialization ? className : yyWord;
prefix.detach();
} else {
// Breaking the :: chain in case of a return/member type
if (!prefix.isEmpty() && yyTok != Tok_LeftParen && yyTok != Tok_RightParen
&& yyTok != Tok_LeftBracket && yyTok != Tok_Equals) {
// We're breaking the chain NOT at a function call or member initialization
// This means prospectiveContext was from a return/member type
prospectiveContext.clear();
}
prefix.clear();
}
metaExpected = false;
break;
}
case Tok_Arrow:
if (yyParenDepth == 0 && yyBraceDepth == namespaceDepths.size())
maybeInTrailingReturnType = true;
yyTok = getToken();
if (yyTok == Tok_Ident) {
yyTok = getToken();
if (yyTok == Tok_LeftParen) {
switch (trFunctionAliasManager.trFunctionByName(yyWord)) {
case TrFunctionAliasManager::Function_tr:
case TrFunctionAliasManager::Function_trUtf8:
yyMsg() << "Cannot invoke tr() like this\n";
break;
}
}
}
break;
case Tok_ColonColon:
if (yyTokIdentSeen || maybeInTrailingReturnType) {
// member or base class identifier
yyTok = getToken();
break;
}
if (yyBraceDepth == namespaceDepths.size() && yyParenDepth == 0 && !yyTokColonSeen)
prospectiveContext = prefix;
if (!prefix.isEmpty())
prefix += strColons;
yyTok = getToken();
break;
case Tok_RightBrace:
if (!yyTokColonSeen) {
if (yyBraceDepth + 1 == namespaceDepths.size()) {
// class or namespace
truncateNamespaces(&namespaces, namespaceDepths.pop());
}
if (yyBraceDepth == namespaceDepths.size()) {
// function, class or namespace
if (!yyBraceDepth && !directInclude)
truncateNamespaces(&functionContext, 1);
else
functionContext = namespaces;
functionContextUnresolved.clear();
pendingContext.clear();
}
}
Q_FALLTHROUGH();
case Tok_Semicolon:
maybeInTrailingReturnType = false;
prospectiveContext.clear();
prefix.clear();
if (m_metaStrings.hasData()) {
yyMsg() << "Discarding unconsumed meta data\n";
m_metaStrings.clear();
}
metaExpected = true;
yyTok = getToken();
break;
case Tok_Access:
// Eat access specifiers, so their colons are not mistaken for c'tor initializer list starts
do {
yyTok = getToken();
} while (yyTok == Tok_Access); // Multiple specifiers are possible, e.g. "public slots"
metaExpected = true;
if (yyTok == Tok_Colon)
goto case_default;
break;
case Tok_Colon:
case Tok_Equals:
if (yyBraceDepth == namespaceDepths.size() && yyParenDepth == 0) {
if (!prospectiveContext.isEmpty()) {
pendingContext = prospectiveContext;
prospectiveContext.clear();
}
//ignore colons for bitfields (are usually followed by a semicolon)
if (yyTok == Tok_Colon) {
if (lookAheadToSemicolonOrLeftBrace() != Tok_Semicolon)
yyTokColonSeen = true;
}
}
metaExpected = true;
yyTok = getToken();
break;
case Tok_LeftBrace:
if (yyBraceDepth == namespaceDepths.size() + 1 && yyParenDepth == 0) {
if (!prospectiveContext.isEmpty()) {
pendingContext = prospectiveContext;
prospectiveContext.clear();
}
if (!yyTokIdentSeen) {
// Function body
yyTokColonSeen = false;
}
}
maybeInTrailingReturnType = false;
yyTokIdentSeen = false;
metaExpected = true;
yyTok = getToken();
break;
case Tok_LeftParen:
if (!yyTokColonSeen && yyBraceDepth == namespaceDepths.size() && yyParenDepth == 1
&& !prospectiveContext.isEmpty()) {
pendingContext = prospectiveContext;
prospectiveContext.clear();
}
yyTokIdentSeen = false;
metaExpected = true;
yyTok = getToken();
break;
case Tok_Comma:
case Tok_QuestionMark:
metaExpected = true;
yyTok = getToken();
break;
case Tok_RightParen:
if (yyParenDepth == 0 && !yyTokColonSeen && !pendingContext.isEmpty()
&& yyBraceDepth == namespaceDepths.size()) {
// Demote the pendingContext to prospectiveContext.
prospectiveContext = pendingContext;
pendingContext.clear();
}
metaExpected = true;
yyTok = getToken();
break;
case Tok_decltype:
{
// Save the parentheses depth outside the 'decltype' specifier.
auto initialParenDepth = yyParenDepth;
// Eat the opening parenthesis that follows 'decltype'.
yyTok = getToken();
// Skip over everything within the parentheses that follow 'decltype'.
while (yyParenDepth != initialParenDepth && yyTok != Tok_Eof)
yyTok = getToken();
}
break;
case Tok_enum:
yyTok = getToken();
// If it is an enum class then ignore
if (yyTok == Tok_class)
yyTok = getToken();
// Allow the parser to flexibly detect and ignore
// colons in front of the typed enums.
yyTok = getToken();
if (yyTok == Tok_Colon) // ignore any colons in front of a typed enum
yyTok = getToken();
break;
default:
if (!yyParenDepth && !maybeInTrailingReturnType)
prospectiveContext.clear();
Q_FALLTHROUGH();
case Tok_RightBracket: // ignoring indexing; for static initializers
case_default:
yyTok = getToken();
break;
}
}
goteof:
if (yyBraceDepth != 0)
yyMsg(yyBraceLineNo)
<< "Unbalanced opening brace in C++ code (or abuse of the C++ preprocessor)\n";
else if (yyParenDepth != 0)
yyMsg(yyParenLineNo)
<< "Unbalanced opening parenthesis in C++ code"
" (or abuse of the C++ preprocessor)\n";
else if (yyBracketDepth != 0)
yyMsg(yyBracketLineNo)
<< "Unbalanced opening bracket in C++ code"
" (or abuse of the C++ preprocessor)\n";
}
void CppParser::processComment()
{
if (!tor || !metaExpected)
return;
if (!m_metaStrings.parse(yyWord)) {
yyMsg() << m_metaStrings.popError().toStdString();
return;
}
if (!m_metaStrings.label().isEmpty()) {
// If pendingContext is set, it may contain aliases that need resolution
NamespaceList contextForLabels = functionContext;
if (!pendingContext.isEmpty())
fullyQualify(namespaces, pendingContext, true, &contextForLabels, nullptr);
QString context = stringifyNamespace(contextForLabels);
QString className;
// Extract class name if the current context is a class
if (const Namespace *ns = findNamespace(contextForLabels); ns && ns->isClass) {
int idx = context.lastIndexOf("::"_L1);
className = idx >= 0 ? context.mid(idx + 2) : context;
}
if (!m_metaStrings.resolveLabel(yyFileName, context, className))
yyMsg() << m_metaStrings.popError().toStdString();
}
if (m_metaStrings.magicComment()) {
auto [context, comment] = *m_metaStrings.magicComment();
TranslatorMessage msg(transcode(context), QString(), transcode(comment), QString(),
yyFileName, yyLineNo, QStringList(), TranslatorMessage::Finished,
false);
msg.setExtraComment(transcode(m_metaStrings.extracomment().simplified()));
tor->append(msg);
tor->setExtras(m_metaStrings.extra());
m_metaStrings.clear();
}
}
const ParseResults *CppParser::recordResults(bool isHeader)
{
if (tor) {
if (tor->messageCount()) {
CppFiles::setTranslator(yyFileName, tor);
} else {
delete tor;
tor = 0;
}
}
if (isHeader) {
const ParseResults *pr;
if (!tor && results->includes.size() == 1
&& results->rootNamespace.children.isEmpty()
&& results->rootNamespace.aliases.isEmpty()
&& results->rootNamespace.usings.isEmpty()) {
// This is a forwarding header. Slash it.
pr = *results->includes.cbegin();
delete results;
} else {
results->fileId = nextFileId++;
pr = results;
}
CppFiles::setResults(ResultsCacheKey(yyFileName, *this), pr);
return pr;
} else {
delete results;
return 0;
}
}
void loadCPP(Translator &translator, const QStringList &filenames, ConversionData &cd)
{
QStringConverter::Encoding e = cd.m_sourceIsUtf16 ? QStringConverter::Utf16 : QStringConverter::Utf8;
for (const QString &filename : filenames) {
if (!CppFiles::getResults(ResultsCacheKey(filename)).isEmpty() || CppFiles::isBlacklisted(filename))
continue;
QFile file(filename);
if (!file.open(QIODevice::ReadOnly)) {
cd.appendError(QStringLiteral("Cannot open %1: %2").arg(filename,
file.errorString()));
continue;
}
CppParser parser;
QTextStream ts(&file);
ts.setEncoding(e);
ts.setAutoDetectUnicode(true);
parser.setInput(ts, filename);
Translator *tor = new Translator;
parser.setTranslator(tor);
QSet<QString> inclusions;
parser.parse(cd, QStringList(), inclusions);
parser.recordResults(isHeader(filename));
}
for (const QString &filename : filenames) {
if (!CppFiles::isBlacklisted(filename)) {
if (const Translator *tor = CppFiles::getTranslator(filename)) {
for (const TranslatorMessage &msg : tor->messages())
translator.extend(msg, cd);
}
}
}
}
QT_END_NAMESPACE