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

**

** 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 Linguist of the Qt Toolkit.

**

** $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 "lupdate.h"

#include <translator.h>

#include <QtCore/QBitArray>

#include <QtCore/QDebug>

#include <QtCore/QFileInfo>

#include <QtCore/QStack>

#include <QtCore/QString>

#include <QtCore/QTextCodec>

#include <QtCore/QTextStream>

#include <ctype.h>              // for isXXX()

QT_BEGIN_NAMESPACE

/* qmake ignore Q_OBJECT */

static QString MagicComment(QLatin1String("TRANSLATOR"));

#define STRING(s) static QString str##s(QLatin1String(#s))

//#define DIAGNOSE_RETRANSLATABILITY // FIXME: should make a runtime option of this

class HashString {

public:

    HashString() : m_hash(0x80000000) {}

    explicit HashString(const QString &str) : m_str(str), m_hash(0x80000000) {}

    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;

    friend uint qHash(const HashString &str);

};

uint qHash(const HashString &str)

{

    if (str.m_hash & 0x80000000)

        str.m_hash = qHash(str.m_str);

    return str.m_hash;

}

class HashStringList {

public:

    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;

    friend uint qHash(const HashStringList &list);

};

uint qHash(const HashStringList &list)

{

    if (list.m_hash & 0x80000000) {

        uint hash = 0;

        foreach (const HashString &qs, list.m_list) {

            hash ^= qHash(qs) ^ 0x0ad9f526;

            hash = ((hash << 13) & 0x0fffffff) | (hash >> 15);

        }

        list.m_hash = hash;

    }

    return list.m_hash;

}

typedef QList<HashString> NamespaceList;

struct Namespace {

    Namespace() :

            classDef(this),

            hasTrFunctions(false), complained(false)

    {}

    ~Namespace()

    {

        qDeleteAll(children);

    }

    QHash<HashString, Namespace *> children;

    QHash<HashString, NamespaceList> aliases;

    QList<HashStringList> usings;

    // Class declarations set no flags and create no namespaces, so they are ignored.

    // 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;

    bool complained; // ... that tr functions are missing.

};

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;

};

struct ParseResults {

    int fileId;

    Namespace rootNamespace;

    QSet<const ParseResults *> includes;

};

typedef QHash<QString, const ParseResults *> ParseResultHash;

typedef QHash<QString, const Translator *> TranslatorHash;

class CppFiles {

public:

    static const ParseResults *getResults(const QString &cleanFile);

    static void setResults(const QString &cleanFile, const ParseResults *results);

    static const Translator *getTranslator(const QString &cleanFile);

    static void setTranslator(const QString &cleanFile, const Translator *results);

    static bool isBlacklisted(const QString &cleanFile);

    static void setBlacklisted(const QString &cleanFile);

private:

    static ParseResultHash &parsedFiles();

    static TranslatorHash &translatedFiles();

    static QSet<QString> &blacklistedFiles();

};

class CppParser {

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(const QString &initialContext, ConversionData &cd, QSet<QString> &inclusions);

    void parseInternal(ConversionData &cd, QSet<QString> &inclusions);

    const ParseResults *recordResults(bool isHeader);

    void deleteResults() { delete results; }

    struct SavedState {

        NamespaceList namespaces;

        QStack<int> namespaceDepths;

        NamespaceList functionContext;

        QString functionContextUnresolved;

        QString pendingContext;

    };

private:

    struct IfdefState {

        IfdefState() {}

        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;

    };

    uint getChar();

    uint getToken();

    bool getMacroArgs();

    bool match(uint t);

    bool matchString(QString *s);

    bool matchEncoding(bool *utf8);

    bool matchStringOrNull(QString *s);

    bool matchExpression();

    QString transcode(const QString &str, bool utf8);

    void recordMessage(

        int line, const QString &context, const QString &text, const QString &comment,

        const QString &extracomment, const QString &msgid, const TranslatorMessage::ExtraData &extra,

        bool utf8, bool plural);

    void processInclude(const QString &file, ConversionData &cd,

                        QSet<QString> &inclusions);

    void saveState(SavedState *state);

    void loadState(const SavedState *state);

    static QString stringifyNamespace(const NamespaceList &namespaces);

    static QStringList stringListifyNamespace(const NamespaceList &namespaces);

    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;

    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, QSet<HashStringList> *visitedUsings) const;

    bool qualifyOne(const NamespaceList &namespaces, int nsCnt, const HashString &segment,

                    NamespaceList *resolved) const;

    bool fullyQualify(const NamespaceList &namespaces, int nsCnt,

                      const QList<HashString> &segments, bool isDeclaration,

                      NamespaceList *resolved, QStringList *unresolved) const;

    bool fullyQualify(const NamespaceList &namespaces,

                      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 haveLast = true);

    enum {

        Tok_Eof, Tok_class, Tok_friend, Tok_namespace, Tok_using, Tok_return,

        Tok_tr, Tok_trUtf8, Tok_translate, Tok_translateUtf8, Tok_trid,

        Tok_Q_OBJECT, Tok_Q_DECLARE_TR_FUNCTIONS,

        Tok_Ident, Tok_Comment, Tok_String, Tok_Arrow, Tok_Colon, Tok_ColonColon,

        Tok_Equals, Tok_LeftBracket, Tok_RightBracket,

        Tok_LeftBrace, Tok_RightBrace, Tok_LeftParen, Tok_RightParen, Tok_Comma, Tok_Semicolon,

        Tok_Null, Tok_Integer,

        Tok_QuotedInclude, Tok_AngledInclude,

        Tok_Other

    };

    // Tokenizer state

    QString yyFileName;

    int yyCh;

    bool yyAtNewline;

    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;

    QString yyInStr;

    const ushort *yyInPtr;

    // Parser state

    uint yyTok;

    NamespaceList namespaces;

    QStack<int> namespaceDepths;

    NamespaceList functionContext;

    QString functionContextUnresolved;

    QString prospectiveContext;

    QString pendingContext;

    ParseResults *results;

    Translator *tor;

    bool directInclude;

    SavedState 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;

}

void CppParser::setInput(const QString &in)

{

    yyInStr = in;

    yyFileName = QString();

    yySourceCodec = 0;

    yyForceUtf8 = true;

}

void CppParser::setInput(QTextStream &ts, const QString &fileName)

{

    yyInStr = ts.readAll();

    yyFileName = fileName;

    yySourceCodec = ts.codec();

    yyForceUtf8 = false;

}

/*

  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.

*/

uint 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 c;

    }

}

// This ignores commas, parens and comments.

// IOW, it understands only a single, simple argument.

bool CppParser::getMacroArgs()

{

    // Failing this assertion would mean losing the preallocated buffer.

    Q_ASSERT(yyWord.isDetached());

    yyWord.resize(0);

    while (isspace(yyCh))

        yyCh = getChar();

    if (yyCh != '(')

        return false;

    do {

        yyCh = getChar();

    } while (isspace(yyCh));

    ushort *ptr = (ushort *)yyWord.unicode();

    while (yyCh != ')') {

        if (yyCh == EOF)

            return false;

        *ptr++ = yyCh;

        yyCh = getChar();

    }

    yyCh = getChar();

    for (; ptr != (ushort *)yyWord.unicode() && isspace(*(ptr - 1)); --ptr) ;

    yyWord.resize(ptr - (ushort *)yyWord.unicode());

    return true;

}

STRING(Q_OBJECT);

STRING(Q_DECLARE_TR_FUNCTIONS);

STRING(QT_TR_NOOP);

STRING(QT_TRID_NOOP);

STRING(QT_TRANSLATE_NOOP);

STRING(QT_TRANSLATE_NOOP3);

STRING(QT_TR_NOOP_UTF8);

STRING(QT_TRANSLATE_NOOP_UTF8);

STRING(QT_TRANSLATE_NOOP3_UTF8);

STRING(class);

// QTranslator::findMessage() has the same parameters as QApplication::translate()

STRING(findMessage);

STRING(friend);

STRING(namespace);

STRING(qtTrId);

STRING(return);

STRING(struct);

STRING(TR);

STRING(Tr);

STRING(tr);

STRING(trUtf8);

STRING(translate);

STRING(using);

uint CppParser::getToken()

{

  restart:

    // Failing this assertion would mean losing the preallocated buffer.

    Q_ASSERT(yyWord.isDetached());

    yyWord.resize(0);

    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.