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

equal deleted inserted replaced

-:fcece45ef507
+:79de32ba3296
 //#define DIAGNOSE_RETRANSLATABILITY // FIXME: should make a runtime option of this
 class HashString {
 public:
-HashString() : m_hashed(false) {}
+HashString() : m_hash(0x80000000) {}
-explicit HashString(const QString &str) : m_str(str), m_hashed(false) {}
+explicit HashString(const QString &str) : m_str(str), m_hash(0x80000000) {}
-void setValue(const QString &str) { m_str = str; m_hashed = false; }
+void setValue(const QString &str) { m_str = str; m_hash = 0x80000000; }
 const QString &value() const { return m_str; }
 bool operator==(const HashString &other) const { return m_str == other.m_str; }
 private:
 QString m_str;
+// qHash() of a QString is only 28 bits wide, so we can use
+// the highest bit(s) as the "hash valid" flag.
 mutable uint m_hash;
-mutable bool m_hashed;
 friend uint qHash(const HashString &str);
 };
 uint qHash(const HashString &str)
 {
-if (!str.m_hashed) {
+if (str.m_hash & 0x80000000)
-str.m_hashed = true;
 str.m_hash = qHash(str.m_str);
-}
 return str.m_hash;
 }
 class HashStringList {
 public:
-explicit HashStringList(const QList<HashString> &list) : m_list(list), m_hashed(false) {}
+explicit HashStringList(const QList<HashString> &list) : m_list(list), m_hash(0x80000000) {}
 const QList<HashString> &value() const { return m_list; }
 bool operator==(const HashStringList &other) const { return m_list == other.m_list; }
 private:
 QList<HashString> m_list;
 mutable uint m_hash;
-mutable bool m_hashed;
 friend uint qHash(const HashStringList &list);
 };
 uint qHash(const HashStringList &list)
 {
-if (!list.m_hashed) {
+if (list.m_hash & 0x80000000) {
-list.m_hashed = true;
 uint hash = 0;
 foreach (const HashString &qs, list.m_list) {
-hash ^= qHash(qs) ^ 0xa09df22f;
+hash ^= qHash(qs) ^ 0x0ad9f526;
-hash = (hash << 13) | (hash >> 19);
+hash = ((hash << 13) & 0x0fffffff) | (hash >> 15);
 }
 list.m_hash = hash;
 }
 return list.m_hash;
 }
 };
 private:
 struct IfdefState {
 IfdefState() {}
-IfdefState(int _braceDepth, int _parenDepth) :
+IfdefState(int _bracketDepth, int _braceDepth, int _parenDepth) :
+bracketDepth(_bracketDepth),
 braceDepth(_braceDepth),
 parenDepth(_parenDepth),
 elseLine(-1)
 {}
 SavedState state;
+int bracketDepth, bracketDepth1st;
 int braceDepth, braceDepth1st;
 int parenDepth, parenDepth1st;
 int elseLine;
 };
 void truncateNamespaces(NamespaceList *namespaces, int lenght);
 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_tr, Tok_trUtf8, Tok_translate, Tok_translateUtf8, Tok_trid,
-Tok_Q_OBJECT = 20, Tok_Q_DECLARE_TR_FUNCTIONS,
+Tok_Q_OBJECT, Tok_Q_DECLARE_TR_FUNCTIONS,
 Tok_Ident, Tok_Comment, Tok_String, Tok_Arrow, Tok_Colon, Tok_ColonColon,
-Tok_Equals,
+Tok_Equals, Tok_LeftBracket, Tok_RightBracket,
-Tok_LeftBrace = 30, Tok_RightBrace, Tok_LeftParen, Tok_RightParen, Tok_Comma, Tok_Semicolon,
+Tok_LeftBrace, Tok_RightBrace, Tok_LeftParen, Tok_RightParen, Tok_Comma, Tok_Semicolon,
-Tok_Null = 40, Tok_Integer,
+Tok_Null, Tok_Integer,
-Tok_QuotedInclude = 50, Tok_AngledInclude,
+Tok_QuotedInclude, Tok_AngledInclude,
-Tok_Other = 99
+Tok_Other
 };
 // Tokenizer state
 QString yyFileName;
 int yyCh;
 bool yyCodecIsUtf8;
 bool yyForceUtf8;
 QString yyWord;
 qlonglong yyInteger;
 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
 QTextCodec *yySourceCodec;
 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;
 goto restart;
 case 'i':
 yyCh = getChar();
 if (yyCh == 'f') {
 // if, ifdef, ifndef
-yyIfdefStack.push(IfdefState(yyBraceDepth, yyParenDepth));
+yyIfdefStack.push(IfdefState(yyBracketDepth, yyBraceDepth, yyParenDepth));
 yyCh = getChar();
 } else if (yyCh == 'n') {
 // include
 do {
 yyCh = getChar();
 if (yyCh == 'l') {
 // elif, else
 if (!yyIfdefStack.isEmpty()) {
 IfdefState &is = yyIfdefStack.top();
 if (is.elseLine != -1) {
-if (yyBraceDepth != is.braceDepth1st || yyParenDepth != is.parenDepth1st)
+if (yyBracketDepth != is.bracketDepth1st
-qWarning("%s:%d: Parenthesis/brace mismatch between "
+|| yyBraceDepth != is.braceDepth1st
+|| yyParenDepth != is.parenDepth1st)
+qWarning("%s:%d: Parenthesis/bracket/brace mismatch between "
 "#if and #else branches; using #if branch\n",
 qPrintable(yyFileName), is.elseLine);
 } 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 (yyBraceDepth != is.braceDepth1st || yyParenDepth != is.parenDepth1st)
+if (yyBracketDepth != is.bracketDepth1st
+|| yyBraceDepth != is.braceDepth1st
+|| yyParenDepth != is.parenDepth1st)
 qWarning("%s:%d: Parenthesis/brace mismatch between "
 "#if and #else branches; using #if branch\n",
 qPrintable(yyFileName), is.elseLine);
+yyBracketDepth = is.bracketDepth1st;
 yyBraceDepth = is.braceDepth1st;
 yyParenDepth = is.parenDepth1st;
 loadState(&is.state);
 }
 }
 qPrintable(yyFileName), yyCurLineNo);
 else
 yyParenDepth--;
 yyCh = getChar();
 return Tok_RightParen;
+case '[':
+if (yyBracketDepth == 0)
+yyBracketLineNo = yyCurLineNo;
+yyBracketDepth++;
+yyCh = getChar();
+return Tok_LeftBracket;
+case ']':
+if (yyBracketDepth == 0)
+qWarning("%s:%d: Excess closing bracket in C++ code"
+" (or abuse of the C++ preprocessor)\n",
+qPrintable(yyFileName), yyCurLineNo);
+else
+yyBracketDepth--;
+yyCh = getChar();
+return Tok_RightBracket;
 case ',':
 yyCh = getChar();
 return Tok_Comma;
 case ';':
 yyCh = getChar();
 yyWord.reserve(yyInStr.size()); // Rather insane. That's because we do no length checking.
 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.
+while (yyBracketDepth)
+yyTok = getToken();
 //qDebug() << "TOKEN: " << yyTok;
 switch (yyTok) {
 case Tok_QuotedInclude: {
 text = QDir(QFileInfo(yyFileName).absolutePath()).absoluteFilePath(yyWord);
 text.detach();
 if (k == -1) {
 context = comment;
 } else {
 context = comment.left(k);
 comment.remove(0, k + 1);
-recordMessage(yyLineNo, context, QString(), comment, extracomment,
+TranslatorMessage msg(
-QString(), TranslatorMessage::ExtraData(), false, false);
+transcode(context, false), QString(),
+transcode(comment, false), QString(),
+yyFileName, yyLineNo, QStringList(),
+TranslatorMessage::Finished, false);
+msg.setExtraComment(transcode(extracomment.simplified(), false));
 extracomment.clear();
+tor->append(msg);
 tor->setExtras(extra);
 extra.clear();
 }
 }
 }
 yyTok = getToken();
 break;
 default:
 if (!yyParenDepth)
 prospectiveContext.clear();
+// fallthrough
+case Tok_Equals: // for static initializers; other cases make no difference
+case Tok_RightBracket: // ignoring indexing; same reason
 case_default:
 yyTok = getToken();
 break;
 }
 }
 qPrintable(yyFileName), yyBraceLineNo);
 else if (yyParenDepth != 0)
 qWarning("%s:%d: Unbalanced opening parenthesis in C++ code"
 " (or abuse of the C++ preprocessor)\n",
 qPrintable(yyFileName), yyParenLineNo);
+else if (yyBracketDepth != 0)
+qWarning("%s:%d: Unbalanced opening bracket in C++ code"
+" (or abuse of the C++ preprocessor)\n",
+qPrintable(yyFileName), yyBracketLineNo);
 }
 const ParseResults *CppParser::recordResults(bool isHeader)
 {
 if (tor) {

changeset 22	79de32ba3296
parent 19	fcece45ef507
child 33	3e2da88830cd