FCL/sf/mw/qt: comparison tools/linguist/lupdate/cpp.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 // Class definitions may appear multiple times - but only because we are trying to
 // "compile" all sources irrespective of build configuration.
 // Nested classes may be forward-declared inside a definition, and defined in another file.
 // The latter will detach the class' child list, so clones need a backlink to the original
 // definition (either one in case of multiple definitions).
+// Namespaces can have tr() functions as well, so we need to track parent definitions for
+// them as well. The complication is that we may have to deal with a forrest instead of
+// a tree - in that case the parent will be arbitrary. However, it seem likely that
+// Q_DECLARE_TR_FUNCTIONS would be used either in "class-like" namespaces with a central
+// header or only locally in a file.
 Namespace *classDef;
 QString trQualification;
 bool hasTrFunctions;
 static QStringList stringListifySegments(const QList<HashString> &namespaces);
 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) const;
-bool fullyQualify(const NamespaceList &namespaces, const QList<HashString> &segments,
+bool fullyQualify(const NamespaceList &namespaces, int nsCnt,
-bool isDeclaration,
+const QList<HashString> &segments, bool isDeclaration,
 NamespaceList *resolved, QStringList *unresolved) const;
-bool fullyQualify(const NamespaceList &namespaces, const QString &segments,
+bool fullyQualify(const NamespaceList &namespaces,
-bool isDeclaration,
+const QList<HashString> &segments, bool isDeclaration,
+NamespaceList *resolved, QStringList *unresolved) const;
+bool fullyQualify(const NamespaceList &namespaces,
+const QString &segments, bool isDeclaration,
 NamespaceList *resolved, QStringList *unresolved) const;
 bool findNamespaceCallback(const Namespace *ns, void *context) const;
 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 tryOrigin = true);
+Namespace *modifyNamespace(NamespaceList *namespaces, bool haveLast = true);
 enum {
 Tok_Eof, Tok_class, Tok_friend, Tok_namespace, Tok_using, Tok_return,
 Tok_tr = 10, Tok_trUtf8, Tok_translate, Tok_translateUtf8, Tok_trid,
 Tok_Q_OBJECT = 20, Tok_Q_DECLARE_TR_FUNCTIONS,
 int yyBraceLineNo;
 int yyParenLineNo;
 // the string to read from and current position in the string
 QTextCodec *yySourceCodec;
-bool yySourceIsUnicode;
 QString yyInStr;
 const ushort *yyInPtr;
 // Parser state
 uint yyTok;
 void CppParser::setInput(const QString &in)
 {
 yyInStr = in;
 yyFileName = QString();
 yySourceCodec = 0;
-yySourceIsUnicode = true;
 yyForceUtf8 = true;
 }
 void CppParser::setInput(QTextStream &ts, const QString &fileName)
 {
 yyInStr = ts.readAll();
 yyFileName = fileName;
 yySourceCodec = ts.codec();
-yySourceIsUnicode = yySourceCodec->name().startsWith("UTF-");
 yyForceUtf8 = false;
 }
 /*
 The first part of this source file is the C++ tokenizer.  We skip
 forever {
 yyCh = getChar();
 if (yyCh == EOF) {
 qWarning("%s:%d: Unterminated C++ comment\n",
 qPrintable(yyFileName), yyLineNo);
-return Tok_Comment;
+break;
 }
 *ptr++ = yyCh;
 if (yyCh == '*')
 metAster = true;
 functionContext = state->functionContext;
 functionContextUnresolved = state->functionContextUnresolved;
 pendingContext = state->pendingContext;
 }
-Namespace *CppParser::modifyNamespace(NamespaceList *namespaces, bool tryOrigin)
+Namespace *CppParser::modifyNamespace(NamespaceList *namespaces, bool haveLast)
 {
 Namespace *pns, *ns = &results->rootNamespace;
 for (int i = 1; i < namespaces->count(); ++i) {
 pns = ns;
 if (!(ns = pns->children.value(namespaces->at(i)))) {
 do {
 ns = new Namespace;
-if (tryOrigin)
+if (haveLast || i < namespaces->count() - 1)
 if (const Namespace *ons = findNamespace(*namespaces, i + 1))
 ns->classDef = ons->classDef;
 pns->children.insert(namespaces->at(i), ns);
 pns = ns;
 } while (++i < namespaces->count());
 *data->resolved << data->segment;
 return true;
 }
 QHash<HashString, NamespaceList>::ConstIterator nsai = ns->aliases.constFind(data->segment);
 if (nsai != ns->aliases.constEnd()) {
-*data->resolved = *nsai;
+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;
 return true;
 }
 return false;
 }
 return true;
 return visitNamespace(namespaces, nsCnt, &CppParser::qualifyOneCallbackUsing, &data);
 }
-bool CppParser::fullyQualify(const NamespaceList &namespaces, const QList<HashString> &segments,
+bool CppParser::fullyQualify(const NamespaceList &namespaces, int nsCnt,
-bool isDeclaration,
+const QList<HashString> &segments, bool isDeclaration,
 NamespaceList *resolved, QStringList *unresolved) const
 {
 int nsIdx;
 int initSegIdx;
 }
 initSegIdx = 1;
 nsIdx = 0;
 } else {
 initSegIdx = 0;
-nsIdx = namespaces.count() - 1;
+nsIdx = nsCnt - 1;
 }
 do {
 if (qualifyOne(namespaces, nsIdx + 1, segments[initSegIdx], resolved)) {
 int segIdx = initSegIdx;
 if (unresolved)
 *unresolved = stringListifySegments(segments.mid(initSegIdx));
 return false;
 }
-bool CppParser::fullyQualify(const NamespaceList &namespaces, const QString &quali,
+bool CppParser::fullyQualify(const NamespaceList &namespaces,
-bool isDeclaration,
+const QList<HashString> &segments, bool isDeclaration,
+NamespaceList *resolved, QStringList *unresolved) const
+{
+return fullyQualify(namespaces, namespaces.count(),
+segments, isDeclaration, resolved, unresolved);
+}
+bool CppParser::fullyQualify(const NamespaceList &namespaces,
+const QString &quali, bool isDeclaration,
 NamespaceList *resolved, QStringList *unresolved) const
 {
 static QString strColons(QLatin1String("::"));
 QList<HashString> segments;
 QString CppParser::transcode(const QString &str, bool utf8)
 {
 static const char tab[] = "abfnrtv";
 static const char backTab[] = "\a\b\f\n\r\t\v";
-const QString in = (!utf8 || yySourceIsUnicode)
+// This function has to convert back to bytes, as C's \0* sequences work at that level.
-? str : QString::fromUtf8(yySourceCodec->fromUnicode(str).data());
+const QByteArray in = yyForceUtf8 ? str.toUtf8() : tor->codec()->fromUnicode(str);
-QString out;
+QByteArray out;
 out.reserve(in.length());
 for (int i = 0; i < in.length();) {
-ushort c = in[i++].unicode();
+uchar c = in[i++];
 if (c == '\\') {
 if (i >= in.length())
 break;
-c = in[i++].unicode();
+c = in[i++];
 if (c == '\n')
 continue;
 if (c == 'x') {
 QByteArray hex;
-while (i < in.length() && isxdigit((c = in[i].unicode()))) {
+while (i < in.length() && isxdigit((c = in[i]))) {
 hex += c;
 i++;
 }
 out += hex.toUInt(0, 16);
 } else if (c >= '0' && c < '8') {
 QByteArray oct;
 int n = 0;
 oct += c;
-while (n < 2 && i < in.length() && (c = in[i].unicode()) >= '0' && c < '8') {
+while (n < 2 && i < in.length() && (c = in[i]) >= '0' && c < '8') {
 i++;
 n++;
 oct += c;
 }
 out += oct.toUInt(0, 8);
 } else {
 const char *p = strchr(tab, c);
-out += QChar(QLatin1Char(!p ? c : backTab[p - tab]));
+out += !p ? c : backTab[p - tab];
 }
 } else {
 out += c;
 }
 }
-return out;
+return (utf8 || yyForceUtf8) ? QString::fromUtf8(out.constData(), out.length())
+: tor->codec()->toUnicode(out);
 }
 void CppParser::recordMessage(
 int line, const QString &context, const QString &text, const QString &comment,
 const QString &extracomment, const QString &msgid, const TranslatorMessage::ExtraData &extra,
 }
 yyTok = getToken();
 }
 if (fullName.isEmpty())
 break;
-NamespaceList nsl;
+fullName.append(HashString(QString())); // Mark as unresolved
-if (fullyQualify(namespaces, fullName, false, &nsl, 0))
+modifyNamespace(&namespaces)->aliases[ns] = fullName;
-modifyNamespace(&namespaces, false)->aliases[ns] = nsl;
 }
 } else if (yyTok == Tok_LeftBrace) {
 // Anonymous namespace
 namespaceDepths.push(namespaces.count());
 yyTok = getToken();
 }
 yyTok = getToken();
 }
 NamespaceList nsl;
 if (fullyQualify(namespaces, fullName, false, &nsl, 0))
-modifyNamespace(&namespaces, false)->usings << HashStringList(nsl);
+modifyNamespace(&namespaces)->usings << HashStringList(nsl);
 } else {
 QList<HashString> fullName;
 if (yyTok == Tok_ColonColon)
 fullName.append(HashString(QString()));
 while (yyTok == Tok_ColonColon || yyTok == Tok_Ident) {
 }
 yyTok = getToken();
 }
 if (fullName.isEmpty())
 break;
-NamespaceList nsl;
+// using-declarations cannot rename classes, so the last element of
-if (fullyQualify(namespaces, fullName, false, &nsl, 0))
+// fullName is already the resolved name we actually want.
-modifyNamespace(&namespaces, true)->aliases[nsl.last()] = nsl;
+// As we do no resolution here, we'll collect useless usings of data
+// members and methods as well. This is no big deal.
+HashString &ns = fullName.last();
+fullName.append(HashString(QString())); // Mark as unresolved
+modifyNamespace(&namespaces)->aliases[ns] = fullName;
 }
 break;
 case Tok_tr:
 case Tok_trUtf8:
 if (!tor)
 extra.clear();
 break;
 case Tok_trid:
 if (!tor)
 goto case_default;
-if (sourcetext.isEmpty()) {
+if (!msgid.isEmpty())
-yyTok = getToken();
+qWarning("%s:%d: //= cannot be used with qtTrId() / QT_TRID_NOOP(). Ignoring\n",
-} else {
+qPrintable(yyFileName), yyLineNo);
-if (!msgid.isEmpty())
+//utf8 = false; // Maybe use //%% or something like that
-qWarning("%s:%d: //= cannot be used with qtTrId() / QT_TRID_NOOP(). Ignoring\n",
+line = yyLineNo;
-qPrintable(yyFileName), yyLineNo);
+yyTok = getToken();
-//utf8 = false; // Maybe use //%% or something like that
+if (match(Tok_LeftParen) && matchString(&msgid) && !msgid.isEmpty()) {
-line = yyLineNo;
+bool plural = match(Tok_Comma);
-yyTok = getToken();
+recordMessage(line, QString(), sourcetext, QString(), extracomment,
-if (match(Tok_LeftParen) && matchString(&msgid) && !msgid.isEmpty()) {
+msgid, extra, false, plural);
-bool plural = match(Tok_Comma);
+}
-recordMessage(line, QString(), sourcetext, QString(), extracomment,
+sourcetext.clear();
-msgid, extra, false, plural);
-}
-sourcetext.clear();
-}
 extracomment.clear();
 msgid.clear();
 extra.clear();
 break;
 case Tok_Q_DECLARE_TR_FUNCTIONS:
 if (getMacroArgs()) {
-Namespace *ns = modifyNamespace(&namespaces, true);
+Namespace *ns = modifyNamespace(&namespaces);
 ns->hasTrFunctions = true;
 ns->trQualification = yyWord;
 ns->trQualification.detach();
 }
 yyTok = getToken();
 break;
 case Tok_Q_OBJECT:
-modifyNamespace(&namespaces, true)->hasTrFunctions = true;
+modifyNamespace(&namespaces)->hasTrFunctions = true;
 yyTok = getToken();
 break;
 case Tok_Ident:
 prefix += yyWord;
 prefix.detach();
 prefix.clear();
 if (yyTok == Tok_Ident && !yyParenDepth)
 prospectiveContext.clear();
 }
 break;
-case Tok_Comment:
+case Tok_Comment: {
 if (!tor)
 goto case_default;
-if (yyWord.startsWith(QLatin1Char(':'))) {
+const QChar *ptr = yyWord.unicode();
-yyWord.remove(0, 1);
+if (*ptr == QLatin1Char(':') && ptr[1].isSpace()) {
+yyWord.remove(0, 2);
 extracomment += yyWord;
 extracomment.detach();
-} else if (yyWord.startsWith(QLatin1Char('='))) {
+} else if (*ptr == QLatin1Char('=') && ptr[1].isSpace()) {
-yyWord.remove(0, 1);
+yyWord.remove(0, 2);
 msgid = yyWord.simplified();
 msgid.detach();
-} else if (yyWord.startsWith(QLatin1Char('~'))) {
+} else if (*ptr == QLatin1Char('~') && ptr[1].isSpace()) {
-yyWord.remove(0, 1);
+yyWord.remove(0, 2);
 text = yyWord.trimmed();
 int k = text.indexOf(QLatin1Char(' '));
 if (k > -1)
 extra.insert(text.left(k), text.mid(k + 1).trimmed());
 text.clear();
-} else if (yyWord.startsWith(QLatin1Char('%'))) {
+} else if (*ptr == QLatin1Char('%') && ptr[1].isSpace()) {
-sourcetext.reserve(sourcetext.length() + yyWord.length());
+sourcetext.reserve(sourcetext.length() + yyWord.length() - 2);
 ushort *ptr = (ushort *)sourcetext.data() + sourcetext.length();
-int p = 1, c;
+int p = 2, c;
 forever {
 if (p >= yyWord.length())
 break;
 c = yyWord.unicode()[p++].unicode();
 if (isspace(c))
 }
 }
 }
 yyTok = getToken();
 break;
+}
 case Tok_Arrow:
 yyTok = getToken();
 if (yyTok == Tok_tr || yyTok == Tok_trUtf8)
 qWarning("%s:%d: Cannot invoke tr() like this\n",
 qPrintable(yyFileName), yyLineNo);
 CppParser parser;
 QTextStream ts(&file);
 ts.setCodec(codec);
 ts.setAutoDetectUnicode(true);
-if (ts.codec()->name() == "UTF-16")
+parser.setInput(ts, filename);
+if (cd.m_outputCodec.isEmpty() && ts.codec()->name() == "UTF-16")
 translator.setCodecName("System");
-parser.setInput(ts, filename);
 Translator *tor = new Translator;
 tor->setCodecName(translator.codecName());
 parser.setTranslator(tor);
 QSet<QString> inclusions;
 parser.parse(cd.m_defaultContext, cd, inclusions);

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c