/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <cplusplus/pp.h>

#include <cplusplus/CppBindings.h>

#include <cplusplus/Overview.h>

#include <cplusplus/CheckUndefinedSymbols.h>

#include "cppmodelmanager.h"

#ifndef ICHECK_BUILD

#  include "cpptoolsconstants.h"

#  include "cpptoolseditorsupport.h"

#  include "cppfindreferences.h"

#endif

#include <functional>

#include <QtConcurrentRun>

#ifndef ICHECK_BUILD

#  include <QFutureSynchronizer>

#  include <qtconcurrent/runextensions.h>

#  include <texteditor/itexteditor.h>

#  include <texteditor/basetexteditor.h>

#  include <projectexplorer/project.h>

#  include <projectexplorer/projectexplorer.h>

#  include <projectexplorer/projectexplorerconstants.h>

#  include <projectexplorer/session.h>

#  include <coreplugin/icore.h>

#  include <coreplugin/uniqueidmanager.h>

#  include <coreplugin/mimedatabase.h>

#  include <coreplugin/editormanager/editormanager.h>

#  include <coreplugin/progressmanager/progressmanager.h>

#  include <extensionsystem/pluginmanager.h>

#else

#  include <QDir>

#endif

#include <utils/qtcassert.h>

#include <TranslationUnit.h>

#include <Semantic.h>

#include <AST.h>

#include <Scope.h>

#include <Literals.h>

#include <Symbols.h>

#include <Names.h>

#include <NameVisitor.h>

#include <TypeVisitor.h>

#include <ASTVisitor.h>

#include <Lexer.h>

#include <Token.h>

#include <cplusplus/LookupContext.h>

#include <QtCore/QCoreApplication>

#include <QtCore/QDebug>

#include <QtCore/QMutexLocker>

#include <QtCore/QTime>

#include <QtCore/QTimer>

#include <QtConcurrentMap>

#include <iostream>

#include <sstream>

using namespace CppTools;

using namespace CppTools::Internal;

using namespace CPlusPlus;

#if defined(QTCREATOR_WITH_DUMP_AST) && defined(Q_CC_GNU)

#include <cxxabi.h>

class DumpAST: protected ASTVisitor

{

public:

    int depth;

    DumpAST(Control *control)

        : ASTVisitor(control), depth(0)

    { }

    void operator()(AST *ast)

    { accept(ast); }

protected:

    virtual bool preVisit(AST *ast)

    {

        std::ostringstream s;

        PrettyPrinter pp(control(), s);

        pp(ast);

        QString code = QString::fromStdString(s.str());

        code.replace('\n', ' ');

        code.replace(QRegExp("\\s+"), " ");

        const char *name = abi::__cxa_demangle(typeid(*ast).name(), 0, 0, 0) + 11;

        QByteArray ind(depth, ' ');

        ind += name;

        printf("%-40s %s\n", ind.constData(), qPrintable(code));

        ++depth;

        return true;

    }

    virtual void postVisit(AST *)

    { --depth; }

};

#endif // QTCREATOR_WITH_DUMP_AST

static const char pp_configuration_file[] = "<configuration>";

static const char pp_configuration[] =

    "# 1 \"<configuration>\"\n"

    "#define __cplusplus 1\n"

    "#define __extension__\n"

    "#define __context__\n"

    "#define __range__\n"

    "#define   restrict\n"

    "#define __restrict\n"

    "#define __restrict__\n"

    "#define __complex__\n"

    "#define __imag__\n"

    "#define __real__\n"

    "#define __builtin_va_arg(a,b) ((b)0)\n"

    // ### add macros for win32

    "#define __cdecl\n"

    "#define __stdcall\n"

    "#define QT_WA(x) x\n"

    "#define API\n"

    "#define WINAPI\n"

    "#define CALLBACK\n"

    "#define STDMETHODCALLTYPE\n"

    "#define __RPC_FAR\n"

    "#define APIENTRY\n"

    "#define __declspec(a)\n"

    "#define STDMETHOD(method) virtual HRESULT STDMETHODCALLTYPE method\n";

#ifndef ICHECK_BUILD

CppPreprocessor::CppPreprocessor(QPointer<CppModelManager> modelManager)

    : snapshot(modelManager->snapshot()),

      m_modelManager(modelManager),

      preprocess(this, &env),

      m_revision(0)

{ }

#else

CppPreprocessor::CppPreprocessor(QPointer<CPlusPlus::ParseManager> modelManager)

    : preprocess(this, &env),

      m_revision(0)

{

}

#endif

CppPreprocessor::~CppPreprocessor()

{ }

void CppPreprocessor::setRevision(unsigned revision)

{ m_revision = revision; }

void CppPreprocessor::setWorkingCopy(const CppTools::CppModelManagerInterface::WorkingCopy &workingCopy)

{ m_workingCopy = workingCopy; }

void CppPreprocessor::setIncludePaths(const QStringList &includePaths)

{ m_includePaths = includePaths; }

void CppPreprocessor::setFrameworkPaths(const QStringList &frameworkPaths)

{ m_frameworkPaths = frameworkPaths; }

void CppPreprocessor::setProjectFiles(const QStringList &files)

{ m_projectFiles = files; }

void CppPreprocessor::setTodo(const QStringList &files)

{ m_todo = QSet<QString>::fromList(files); }

#ifndef ICHECK_BUILD

namespace {

class Process: public std::unary_function<Document::Ptr, void>

{

    QPointer<CppModelManager> _modelManager;

    Snapshot _snapshot;

    CppModelManager::WorkingCopy _workingCopy;

    Document::Ptr _doc;

public:

    Process(QPointer<CppModelManager> modelManager,

            Snapshot snapshot,

            const CppModelManager::WorkingCopy &workingCopy)

        : _modelManager(modelManager),

          _snapshot(snapshot),

          _workingCopy(workingCopy)

    { }

    LookupContext lookupContext(unsigned line, unsigned column) const

    { return lookupContext(_doc->findSymbolAt(line, column)); }

    LookupContext lookupContext(Symbol *symbol) const

    {

        LookupContext context(symbol, Document::create(QLatin1String("<none>")), _doc, _snapshot);

        return context;

    }

    void operator()(Document::Ptr doc)

    {

        _doc = doc;

        Document::CheckMode mode = Document::FastCheck;

        if (_workingCopy.contains(doc->fileName()))

            mode = Document::FullCheck;

        doc->parse();

        doc->check(mode);

        if (mode == Document::FullCheck) {

            // run the binding pass

            NamespaceBindingPtr ns = bind(doc, _snapshot);

            // check for undefined symbols.

            CheckUndefinedSymbols checkUndefinedSymbols(doc);

            checkUndefinedSymbols.setGlobalNamespaceBinding(ns);

            checkUndefinedSymbols(doc->translationUnit()->ast()); // ### FIXME

        }

        doc->releaseTranslationUnit();

        if (_modelManager)

            _modelManager->emitDocumentUpdated(doc); // ### TODO: compress

    }

};

} // end of anonymous namespace

#endif

void CppPreprocessor::run(const QString &fileName)

{

    QString absoluteFilePath = fileName;

    sourceNeeded(absoluteFilePath, IncludeGlobal, /*line = */ 0);

}

void CppPreprocessor::resetEnvironment()

{

    env.reset();

    m_processed.clear();

}

bool CppPreprocessor::includeFile(const QString &absoluteFilePath, QString *result, unsigned *revision)

{

    if (absoluteFilePath.isEmpty() || m_included.contains(absoluteFilePath))

        return true;

    if (m_workingCopy.contains(absoluteFilePath)) {

        m_included.insert(absoluteFilePath);

        const QPair<QString, unsigned> r = m_workingCopy.get(absoluteFilePath);

        *result = r.first;

        *revision = r.second;

        return true;

    }

    QFileInfo fileInfo(absoluteFilePath);

    if (! fileInfo.isFile())

        return false;

    QFile file(absoluteFilePath);

    if (file.open(QFile::ReadOnly)) {

        m_included.insert(absoluteFilePath);

        QTextStream stream(&file);

        const QString contents = stream.readAll();

        *result = contents.toUtf8();

        file.close();

        return true;

    }

    return false;

}

QString CppPreprocessor::tryIncludeFile(QString &fileName, IncludeType type, unsigned *revision)

{

    QFileInfo fileInfo(fileName);

    if (fileName == QLatin1String(pp_configuration_file) || fileInfo.isAbsolute()) {

        QString contents;

        includeFile(fileName, &contents, revision);

        return contents;

    }

    if (type == IncludeLocal && m_currentDoc) {

        QFileInfo currentFileInfo(m_currentDoc->fileName());

        QString path = currentFileInfo.absolutePath();

        path += QLatin1Char('/');

        path += fileName;

        path = QDir::cleanPath(path);

        QString contents;

        if (includeFile(path, &contents, revision)) {

            fileName = path;

            return contents;

        }

    }

    foreach (const QString &includePath, m_includePaths) {

        QString path = includePath;

        path += QLatin1Char('/');

        path += fileName;

        path = QDir::cleanPath(path);

        QString contents;

        if (includeFile(path, &contents, revision)) {

            fileName = path;

            return contents;

        }

    }

    // look in the system include paths

    foreach (const QString &includePath, m_systemIncludePaths) {

        QString path = includePath;

        path += QLatin1Char('/');

        path += fileName;

        path = QDir::cleanPath(path);

        QString contents;

        if (includeFile(path, &contents, revision)) {

            fileName = path;

            return contents;

        }

    }

    int index = fileName.indexOf(QLatin1Char('/'));

    if (index != -1) {

        QString frameworkName = fileName.left(index);

        QString name = fileName.mid(index + 1);

        foreach (const QString &frameworkPath, m_frameworkPaths) {

            QString path = frameworkPath;

            path += QLatin1Char('/');

            path += frameworkName;

            path += QLatin1String(".framework/Headers/");

            path += name;

            path = QDir::cleanPath(path);

            QString contents;

            if (includeFile(path, &contents, revision)) {

                fileName = path;

                return contents;

            }

        }

    }

    QString path = fileName;

    if (path.at(0) != QLatin1Char('/'))

        path.prepend(QLatin1Char('/'));

    foreach (const QString &projectFile, m_projectFiles) {

        if (projectFile.endsWith(path)) {

            fileName = projectFile;

            QString contents;

            includeFile(fileName, &contents, revision);

            return contents;

        }

    }

    //qDebug() << "**** file" << fileName << "not found!";

    return QString();

}

void CppPreprocessor::macroAdded(const Macro &macro)

{

    if (! m_currentDoc)

        return;

    m_currentDoc->appendMacro(macro);

}

void CppPreprocessor::passedMacroDefinitionCheck(unsigned offset, const Macro &macro)

{

    if (! m_currentDoc)

        return;

    m_currentDoc->addMacroUse(macro, offset, macro.name().length(), env.currentLine,

                              QVector<MacroArgumentReference>(), true);

}

void CppPreprocessor::failedMacroDefinitionCheck(unsigned offset, const QByteArray &name)

{

    if (! m_currentDoc)

        return;

    m_currentDoc->addUndefinedMacroUse(name, offset);

}

void CppPreprocessor::startExpandingMacro(unsigned offset,

                                          const Macro &macro,

                                          const QByteArray &originalText,

                                          bool inCondition,

                                          const QVector<MacroArgumentReference> &actuals)

{

    if (! m_currentDoc)

        return;

    //qDebug() << "start expanding:" << macro.name() << "text:" << originalText;

    m_currentDoc->addMacroUse(macro, offset, originalText.length(), env.currentLine,

                              actuals, inCondition);

}

void CppPreprocessor::stopExpandingMacro(unsigned, const Macro &)

{

    if (! m_currentDoc)

        return;

    //qDebug() << "stop expanding:" << macro.name;

}

void CppPreprocessor::mergeEnvironment(Document::Ptr doc)

{

    if (! doc)

        return;

    const QString fn = doc->fileName();

    if (m_processed.contains(fn))

        return;

    m_processed.insert(fn);

    foreach (const Document::Include &incl, doc->includes()) {

        QString includedFile = incl.fileName();

        if (Document::Ptr includedDoc = snapshot.document(includedFile))

            mergeEnvironment(includedDoc);

        else

            run(includedFile);

    }

    env.addMacros(doc->definedMacros());

}

void CppPreprocessor::startSkippingBlocks(unsigned offset)

{

    //qDebug() << "start skipping blocks:" << offset;

    if (m_currentDoc)

        m_currentDoc->startSkippingBlocks(offset);

}

void CppPreprocessor::stopSkippingBlocks(unsigned offset)

{

    //qDebug() << "stop skipping blocks:" << offset;

    if (m_currentDoc)

        m_currentDoc->stopSkippingBlocks(offset);

}

void CppPreprocessor::sourceNeeded(QString &fileName, IncludeType type, unsigned line)

{

    if (fileName.isEmpty())

        return;

    unsigned editorRevision = 0;

    QString contents = tryIncludeFile(fileName, type, &editorRevision);

    fileName = QDir::cleanPath(fileName);

    if (m_currentDoc) {

        m_currentDoc->addIncludeFile(fileName, line);

        if (contents.isEmpty() && ! QFileInfo(fileName).isAbsolute()) {

            QString msg = QCoreApplication::translate(

                    "CppPreprocessor", "%1: No such file or directory").arg(fileName);

            Document::DiagnosticMessage d(Document::DiagnosticMessage::Warning,

                                          m_currentDoc->fileName(),

                                          env.currentLine, /*column = */ 0,

                                          msg);

            m_currentDoc->addDiagnosticMessage(d);

            //qWarning() << "file not found:" << fileName << m_currentDoc->fileName() << env.current_line;

        }

    }

    //qDebug() << "parse file:" << fileName << "contents:" << contents.size();

    Document::Ptr doc = snapshot.document(fileName);

    if (doc) {

        mergeEnvironment(doc);

        return;

    }

    doc = Document::create(fileName);

    doc->setRevision(m_revision);

    doc->setEditorRevision(editorRevision);

    QFileInfo info(fileName);

    if (info.exists())

        doc->setLastModified(info.lastModified());

    Document::Ptr previousDoc = switchDocument(doc);