Merge branch 'master' of git@scm.dev.nokia.troll.no:creator/mainline

src/libs/cplusplus/PreprocessorEnvironment.cpp

@@ -117,6 +117,13 @@ Macro *Environment::bind(const Macro &__macro)
     return m;
 }
 
+void Environment::addMacros(const QList<Macro> &macros)
+{
+    foreach (const Macro &macro, macros) {
+        bind(macro);
+    }
+}
+
 Macro *Environment::remove(const QByteArray &name)
 {
     Macro macro;
@@ -127,6 +134,23 @@ Macro *Environment::remove(const QByteArray &name)
     return bind(macro);
 }
 
+void Environment::reset()
+{
+    if (_macros) {
+        qDeleteAll(firstMacro(), lastMacro());
+        free(_macros);
+    }
+
+    if (_hash)
+        free(_hash);
+
+    _macros = 0;
+    _allocated_macros = 0;
+    _macro_count = -1;
+    _hash = 0;
+    _hash_count = 401;
+}
+
 bool Environment::isBuiltinMacro(const QByteArray &s) const
 {
     if (s.length() != 8)

src/libs/cplusplus/PreprocessorEnvironment.h

@@ -56,6 +56,7 @@
 #include "CPlusPlusForwardDeclarations.h"
 
 #include <QVector>
+#include <QList>
 #include <QByteArray>
 
 namespace CPlusPlus {
@@ -89,6 +90,9 @@ public:
     Macro **lastMacro()
     { return _macros + _macro_count + 1; }
 
+    void reset();
+    void addMacros(const QList<Macro> &macros);
+
 private:
     static unsigned hashCode(const QByteArray &s);
     void rehash();

src/libs/cplusplus/SimpleLexer.cpp

@@ -54,6 +54,11 @@ bool SimpleToken::isKeyword() const
     return _kind >= T_FIRST_KEYWORD && _kind < T_FIRST_QT_KEYWORD;
 }
 
+bool SimpleToken::isComment() const
+{
+    return _kind == T_COMMENT || _kind == T_DOXY_COMMENT;
+}
+
 SimpleLexer::SimpleLexer()
     : _lastState(0),
       _skipComments(false),

src/libs/cplusplus/SimpleLexer.h

@@ -69,6 +69,7 @@ public:
     bool isLiteral() const;
     bool isOperator() const;
     bool isKeyword() const;
+    bool isComment() const;
 
 public:
     int _kind;

src/libs/cplusplus/TokenUnderCursor.cpp

@@ -49,6 +49,9 @@ TokenUnderCursor::~TokenUnderCursor()
 SimpleToken TokenUnderCursor::operator()(const QTextCursor &cursor) const
 {
     SimpleLexer tokenize;
+    tokenize.setObjCEnabled(true);
+    tokenize.setSkipComments(false);
+
     QTextBlock block = cursor.block();
     int column = cursor.columnNumber();
 

src/plugins/cppeditor/CppEditor.mimetypes.xml

@@ -43,6 +43,7 @@
         <glob pattern="*.c++"/>
         <glob pattern="*.C"/>
         <glob pattern="*.inl"/>
+        <glob pattern="*.qdoc"/>
     </mime-type>
 
     <mime-type type="text/x-objcsrc">

src/plugins/cppeditor/cppeditor.cpp

@@ -740,7 +740,9 @@ void CPPEditor::setFontSettings(const TextEditor::FontSettings &fs)
                    << QLatin1String(TextEditor::Constants::C_OPERATOR)
                    << QLatin1String(TextEditor::Constants::C_PREPROCESSOR)
                    << QLatin1String(TextEditor::Constants::C_LABEL)
-                   << QLatin1String(TextEditor::Constants::C_COMMENT);
+                   << QLatin1String(TextEditor::Constants::C_COMMENT)
+                   << QLatin1String(TextEditor::Constants::C_DOXYGEN_COMMENT)
+                   << QLatin1String(TextEditor::Constants::C_DOXYGEN_TAG);
     }
 
     const QVector<QTextCharFormat> formats = fs.toTextCharFormats(categories);

src/plugins/cppeditor/cppeditor.pro

@@ -16,6 +16,7 @@ HEADERS += cppplugin.h \
     cppeditorenums.h \
     cppeditor_global.h \
     cppclasswizard.h
+
 SOURCES += cppplugin.cpp \
     cppeditoractionhandler.cpp \
     cppeditor.cpp \
@@ -23,4 +24,5 @@ SOURCES += cppplugin.cpp \
     cpphoverhandler.cpp \
     cppfilewizard.cpp \
     cppclasswizard.cpp
+
 RESOURCES += cppeditor.qrc

src/plugins/cppeditor/cppeditorenums.h

@@ -51,6 +51,8 @@ enum CppFormats {
     CppPreprocessorFormat,
     CppLabelFormat,
     CppCommentFormat,
+    CppDoxygenCommentFormat,
+    CppDoxygenTagFormat,
     NumCppFormats
 };
 

src/plugins/cppeditor/cpphighlighter.cpp

@@ -32,6 +32,7 @@
 ***************************************************************************/
 
 #include "cpphighlighter.h"
+#include <cpptools/cppdoxygen.h>
 
 #include <Token.h>
 #include <cplusplus/SimpleLexer.h>
@@ -115,23 +116,35 @@ void CppHighlighter::highlightBlock(const QString &text)
         }
 
         bool highlightCurrentWordAsPreprocessor = highlightAsPreprocessor;
+
         if (highlightAsPreprocessor)
             highlightAsPreprocessor = false;
 
         if (i == 0 && tk.is(T_POUND)) {
             setFormat(tk.position(), tk.length(), m_formats[CppPreprocessorFormat]);
             highlightAsPreprocessor = true;
+
         } else if (highlightCurrentWordAsPreprocessor &&
                    (tk.isKeyword() || tk.is(T_IDENTIFIER)) && isPPKeyword(tk.text()))
             setFormat(tk.position(), tk.length(), m_formats[CppPreprocessorFormat]);
+
         else if (tk.is(T_INT_LITERAL) || tk.is(T_FLOAT_LITERAL))
             setFormat(tk.position(), tk.length(), m_formats[CppNumberFormat]);
+
         else if (tk.is(T_STRING_LITERAL) || tk.is(T_CHAR_LITERAL) || tk.is(T_ANGLE_STRING_LITERAL))
             setFormat(tk.position(), tk.length(), m_formats[CppStringFormat]);
+
         else if (tk.is(T_WIDE_STRING_LITERAL) || tk.is(T_WIDE_CHAR_LITERAL))
             setFormat(tk.position(), tk.length(), m_formats[CppStringFormat]);
-        else if (tk.is(T_COMMENT)) {
-            setFormat(tk.position(), tk.length(), m_formats[CppCommentFormat]);
+
+        else if (tk.isComment()) {
+
+            if (tk.is(T_COMMENT))
+                setFormat(tk.position(), tk.length(), m_formats[CppCommentFormat]);
+
+            else // a doxygen comment
+                highlightDoxygenComment(text, tk.position(), tk.length());
+
             // we need to insert a close comment parenthesis, if
             //  - the line starts in a C Comment (initalState != 0)
             //  - the first token of the line is a T_COMMENT (i == 0 && tk.is(T_COMMENT))
@@ -145,12 +158,16 @@ void CppHighlighter::highlightBlock(const QString &text)
                 // clear the initial state.
                 initialState = 0;
             }
+
         } else if (tk.isKeyword() || isQtKeyword(tk.text()))
             setFormat(tk.position(), tk.length(), m_formats[CppKeywordFormat]);
+
         else if (tk.isOperator())
             setFormat(tk.position(), tk.length(), m_formats[CppOperatorFormat]);
+
         else if (i == 0 && tokens.size() > 1 && tk.is(T_IDENTIFIER) && tokens.at(1).is(T_COLON))
             setFormat(tk.position(), tk.length(), m_formats[CppLabelFormat]);
+
         else if (tk.is(T_IDENTIFIER))
             highlightWord(tk.text(), tk.position(), tk.length());
     }
@@ -304,3 +321,36 @@ void CppHighlighter::highlightWord(QStringRef word, int position, int length)
         setFormat(position, length, m_formats[CppTypeFormat]);
     }
 }
+
+void CppHighlighter::highlightDoxygenComment(const QString &text, int position, int)
+{
+    int initial = position;
+
+    const QChar *uc = text.unicode();
+    const QChar *it = uc + position;
+
+    const QTextCharFormat &format = m_formats[CppDoxygenCommentFormat];
+    const QTextCharFormat &kwFormat = m_formats[CppDoxygenTagFormat];
+
+    while (! it->isNull()) {
+        if (it->unicode() == QLatin1Char('\\') ||
+            it->unicode() == QLatin1Char('@')) {
+            ++it;
+
+            const QChar *start = it;
+            while (it->isLetterOrNumber() || it->unicode() == '_')
+                ++it;
+
+            int k = CppTools::classifyDoxygenTag(start, it - start);
+            if (k != CppTools::T_DOXY_IDENTIFIER) {
+                setFormat(initial, start - uc - initial, format);
+                setFormat(start - uc - 1, it - start + 1, kwFormat);
+                initial = it - uc;
+            }
+        } else
+            ++it;
+    }
+
+    setFormat(initial, it - uc - initial, format);
+}
+

src/plugins/cppeditor/cpphighlighter.h

@@ -61,6 +61,10 @@ public:
 
 private:
     void highlightWord(QStringRef word, int position, int length);
+
+    void highlightDoxygenComment(const QString &text, int position,
+                                 int length);
+
     bool isPPKeyword(const QStringRef &text) const;
     bool isQtKeyword(const QStringRef &text) const;
 

src/plugins/cpptools/cppcodecompletion.cpp

@@ -32,8 +32,8 @@
 ***************************************************************************/
 
 #include "cppcodecompletion.h"
-
 #include "cppmodelmanager.h"
+#include "cppdoxygen.h"
 
 #include <Control.h>
 #include <AST.h>
@@ -371,46 +371,54 @@ static int startOfOperator(TextEditor::ITextEditable *editor,
     const QChar ch3 = pos >  1 ? editor->characterAt(pos - 3) : QChar();
 
     int start = pos;
+    int k = T_EOF_SYMBOL;
 
     if        (ch2 != QLatin1Char('.') && ch == QLatin1Char('.')) {
-        if (kind)
-            *kind = T_DOT;
+        k = T_DOT;
         --start;
     } else if (wantFunctionCall        && ch == QLatin1Char('(')) {
-        if (kind)
-            *kind = T_LPAREN;
+        k = T_LPAREN;
         --start;
     } else if (ch2 == QLatin1Char(':') && ch == QLatin1Char(':')) {
-        if (kind)
-            *kind = T_COLON_COLON;
+        k = T_COLON_COLON;
         start -= 2;
     } else if (ch2 == QLatin1Char('-') && ch == QLatin1Char('>')) {
-        if (kind)
-            *kind = T_ARROW;
+        k = T_ARROW;
         start -= 2;
     } else if (ch2 == QLatin1Char('.') && ch == QLatin1Char('*')) {
-        if (kind)
-            *kind = T_DOT_STAR;
+        k = T_DOT_STAR;
         start -= 2;
     } else if (ch3 == QLatin1Char('-') && ch2 == QLatin1Char('>') && ch == QLatin1Char('*')) {
-        if (kind)
-            *kind = T_ARROW_STAR;
+        k = T_ARROW_STAR;
         start -= 3;
+    } else if (ch == QLatin1Char('@') || ch == QLatin1Char('\\')) {
+        k = T_DOXY_COMMENT;
+        --start;
     }
 
-    if (start != pos) {
-        TextEditor::BaseTextEditor *edit = qobject_cast<TextEditor::BaseTextEditor *>(editor->widget());
-        QTextCursor tc(edit->textCursor());
-        tc.setPosition(pos);
-        static CPlusPlus::TokenUnderCursor tokenUnderCursor;
-        const SimpleToken tk = tokenUnderCursor(tc);
-        if (tk.is(T_COMMENT) || tk.isLiteral()) {
-            if (kind)
-                *kind = T_EOF_SYMBOL;
-            return pos;
-        }
+    if (start == pos)
+        return start;
+
+    TextEditor::BaseTextEditor *edit = qobject_cast<TextEditor::BaseTextEditor *>(editor->widget());
+    QTextCursor tc(edit->textCursor());
+    tc.setPosition(pos);
+
+    static CPlusPlus::TokenUnderCursor tokenUnderCursor;
+    const SimpleToken tk = tokenUnderCursor(tc);
+
+    if (k == T_DOXY_COMMENT && tk.isNot(T_DOXY_COMMENT)) {
+        k = T_EOF_SYMBOL;
+        start = pos;
     }
 
+    else if (tk.is(T_COMMENT) || tk.isLiteral()) {
+        k = T_EOF_SYMBOL;
+        start = pos;
+    }
+
+    if (kind)
+        *kind = k;
+
     return start;
 }
 
@@ -457,15 +465,32 @@ int CppCodeCompletion::startCompletion(TextEditor::ITextEditable *editor)
     ExpressionUnderCursor expressionUnderCursor;
     QString expression;
 
+
+    if (m_completionOperator == T_DOXY_COMMENT) {
+        for (int i = 1; i < T_DOXY_LAST_TAG; ++i) {
+            TextEditor::CompletionItem item(this);
+            item.m_text.append(QString::fromLatin1(doxygenTagSpell(i)));
+            item.m_icon = m_icons.keywordIcon();
+            m_completions.append(item);
+        }
+
+        return m_startPosition;
+    }
+
+
     if (m_completionOperator) {
         QTextCursor tc(edit->document());
         tc.setPosition(endOfExpression);
+
         expression = expressionUnderCursor(tc);
+
         if (m_completionOperator == T_LPAREN) {
             if (expression.endsWith(QLatin1String("SIGNAL")))
                 m_completionOperator = T_SIGNAL;
+
             else if (expression.endsWith(QLatin1String("SLOT")))
                 m_completionOperator = T_SLOT;
+
             else if (editor->position() != endOfOperator) {
                 // We don't want a function completion when the cursor isn't at the opening brace
                 expression.clear();

src/plugins/cpptools/cppdoxygen.h

+/***************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact:  Qt Software Information (qt-info@nokia.com)
+**
+**
+** Non-Open Source Usage
+**
+** Licensees may use this file in accordance with the Qt Beta Version
+** License Agreement, Agreement version 2.2 provided with the Software or,
+** alternatively, in accordance with the terms contained in a written
+** agreement between you and Nokia.
+**
+** GNU General Public License Usage
+**
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the packaging
+** of this file.  Please review the following information to ensure GNU
+** General Public Licensing requirements will be met:
+**
+** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt GPL Exception
+** version 1.3, included in the file GPL_EXCEPTION.txt in this package.
+**
+***************************************************************************/
+
+#include "cpptools_global.h"
+
+namespace CppTools {
+
+enum DoxygenReservedWord {
+    T_DOXY_IDENTIFIER,
+    T_DOXY_ARG,
+    T_DOXY_ATTENTION,
+    T_DOXY_AUTHOR,
+    T_DOXY_CALLGRAPH,
+    T_DOXY_CODE,
+    T_DOXY_DOT,
+    T_DOXY_ELSE,
+    T_DOXY_ENDCODE,
+    T_DOXY_ENDCOND,
+    T_DOXY_ENDDOT,
+    T_DOXY_ENDHTMLONLY,
+    T_DOXY_ENDIF,
+    T_DOXY_ENDLATEXONLY,
+    T_DOXY_ENDLINK,
+    T_DOXY_ENDMANONLY,
+    T_DOXY_ENDVERBATIM,
+    T_DOXY_ENDXMLONLY,
+    T_DOXY_HIDEINITIALIZER,
+    T_DOXY_HTMLONLY,
+    T_DOXY_INTERFACE,
+    T_DOXY_INTERNAL,
+    T_DOXY_INVARIANT,
+    T_DOXY_LATEXONLY,
+    T_DOXY_LI,
+    T_DOXY_MANONLY,
+    T_DOXY_N,
+    T_DOXY_NOSUBGROUPING,
+    T_DOXY_NOTE,
+    T_DOXY_ONLY,
+    T_DOXY_POST,
+    T_DOXY_PRE,
+    T_DOXY_REMARKS,
+    T_DOXY_RETURN,
+    T_DOXY_RETURNS,
+    T_DOXY_SA,
+    T_DOXY_SEE,
+    T_DOXY_SHOWINITIALIZER,
+    T_DOXY_SINCE,
+    T_DOXY_TEST,
+    T_DOXY_TODO,
+    T_DOXY_VERBATIM,
+    T_DOXY_WARNING,
+    T_DOXY_XMLONLY,
+    T_DOXY_A,
+    T_DOXY_ADDTOGROUP,
+    T_DOXY_ANCHOR,
+    T_DOXY_B,
+    T_DOXY_C,
+    T_DOXY_CLASS,
+    T_DOXY_COND,
+    T_DOXY_COPYDOC,
+    T_DOXY_DEF,
+    T_DOXY_DONTINCLUDE,
+    T_DOXY_DOTFILE,
+    T_DOXY_E,
+    T_DOXY_ELSEIF,
+    T_DOXY_EM,
+    T_DOXY_ENUM,
+    T_DOXY_EXAMPLE,
+    T_DOXY_EXCEPTION,
+    T_DOXY_EXCEPTIONS,
+    T_DOXY_FILE,
+    T_DOXY_HTMLINCLUDE,
+    T_DOXY_IF,
+    T_DOXY_IFNOT,
+    T_DOXY_INCLUDE,
+    T_DOXY_LINK,
+    T_DOXY_NAMESPACE,
+    T_DOXY_P,
+    T_DOXY_PACKAGE,
+    T_DOXY_REF,
+    T_DOXY_RELATES,
+    T_DOXY_RELATESALSO,
+    T_DOXY_RETVAL,
+    T_DOXY_THROW,
+    T_DOXY_THROWS,
+    T_DOXY_VERBINCLUDE,
+    T_DOXY_VERSION,
+    T_DOXY_XREFITEM,
+    T_DOXY_PARAM,
+    T_DOXY_IMAGE,
+    T_DOXY_DEFGROUP,
+    T_DOXY_PAGE,
+    T_DOXY_PARAGRAPH,
+    T_DOXY_SECTION,
+    T_DOXY_STRUCT,
+    T_DOXY_SUBSECTION,
+    T_DOXY_SUBSUBSECTION,
+    T_DOXY_UNION,
+    T_DOXY_WEAKGROUP,
+    T_DOXY_ADDINDEX,
+    T_DOXY_BRIEF,
+    T_DOXY_BUG,
+    T_DOXY_DATE,
+    T_DOXY_DEPRECATED,
+    T_DOXY_FN,
+    T_DOXY_INGROUP,
+    T_DOXY_LINE,
+    T_DOXY_MAINPAGE,
+    T_DOXY_NAME,
+    T_DOXY_OVERLOAD,
+    T_DOXY_PAR,
+    T_DOXY_SHORT,
+    T_DOXY_SKIP,
+    T_DOXY_SKIPLINE,
+    T_DOXY_TYPEDEF,
+    T_DOXY_UNTIL,
+    T_DOXY_VAR,
+
+    T_FIRST_QDOC_TAG,
+
+    T_DOXY_ABSTRACT = T_FIRST_QDOC_TAG,
+    T_DOXY_BADCODE,
+    T_DOXY_BASENAME,
+    T_DOXY_BOLD,
+    T_DOXY_CAPTION,
+    T_DOXY_CHAPTER,
+    T_DOXY_CODELINE,
+    T_DOXY_DOTS,
+    T_DOXY_ENDABSTRACT,
+    T_DOXY_ENDCHAPTER,
+    T_DOXY_ENDFOOTNOTE,
+    T_DOXY_ENDLEGALESE,
+    T_DOXY_ENDLIST,
+    T_DOXY_ENDOMIT,
+    T_DOXY_ENDPART,
+    T_DOXY_ENDQUOTATION,
+    T_DOXY_ENDRAW,
+    T_DOXY_ENDSECTION1,
+    T_DOXY_ENDSECTION2,
+    T_DOXY_ENDSECTION3,
+    T_DOXY_ENDSECTION4,
+    T_DOXY_ENDSIDEBAR,
+    T_DOXY_ENDTABLE,
+    T_DOXY_EXPIRE,
+    T_DOXY_FOOTNOTE,
+    T_DOXY_GENERATELIST,
+    T_DOXY_GRANULARITY,
+    T_DOXY_HEADER,
+    T_DOXY_I,
+    T_DOXY_INDEX,
+    T_DOXY_INLINEIMAGE,
+    T_DOXY_KEYWORD,
+    T_DOXY_L,
+    T_DOXY_LEGALESE,
+    T_DOXY_LIST,
+    T_DOXY_META,
+    T_DOXY_NEWCODE,
+    T_DOXY_O,
+    T_DOXY_OLDCODE,
+    T_DOXY_OMIT,
+    T_DOXY_OMITVALUE,
+    T_DOXY_PART,
+    T_DOXY_PRINTLINE,
+    T_DOXY_PRINTTO,
+    T_DOXY_PRINTUNTIL,
+    T_DOXY_QUOTATION,
+    T_DOXY_QUOTEFILE,
+    T_DOXY_QUOTEFROMFILE,
+    T_DOXY_QUOTEFUNCTION,
+    T_DOXY_RAW,
+    T_DOXY_ROW,
+    T_DOXY_SECTION1,
+    T_DOXY_SECTION2,
+    T_DOXY_SECTION3,
+    T_DOXY_SECTION4,
+    T_DOXY_SIDEBAR,
+    T_DOXY_SKIPTO,
+    T_DOXY_SKIPUNTIL,
+    T_DOXY_SNIPPET,
+    T_DOXY_SUB,
+    T_DOXY_SUP,
+    T_DOXY_TABLE,
+    T_DOXY_TABLEOFCONTENTS,
+    T_DOXY_TARGET,
+    T_DOXY_TT,
+    T_DOXY_UNDERLINE,
+    T_DOXY_UNICODE,
+    T_DOXY_VALUE,
+    T_DOXY_CONTENTSPAGE,
+    T_DOXY_EXTERNALPAGE,
+    T_DOXY_GROUP,
+    T_DOXY_HEADERFILE,
+    T_DOXY_INDEXPAGE,
+    T_DOXY_INHEADERFILE,
+    T_DOXY_MACRO,
+    T_DOXY_MODULE,
+    T_DOXY_NEXTPAGE,
+    T_DOXY_PREVIOUSPAGE,
+    T_DOXY_PROPERTY,
+    T_DOXY_REIMP,
+    T_DOXY_SERVICE,
+    T_DOXY_STARTPAGE,
+    T_DOXY_VARIABLE,