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

**

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

#include <QtCore/QDebug>

#include <QtCore/QIODevice>

#include <QtCore/QHash>

#include <QtCore/QString>

#include <QtCore/QTextStream>

#include <ctype.h>

#define MAGIC_OBSOLETE_REFERENCE "Obsolete_PO_entries"

// Uncomment if you wish to hard wrap long lines in .po files. Note that this

// affects only msg strings, not comments.

//#define HARD_WRAP_LONG_WORDS

QT_BEGIN_NAMESPACE

static const int MAX_LEN = 79;

static QString poEscapedString(const QString &prefix, const QString &keyword,

                               bool noWrap, const QString &ba)

{

    QStringList lines;

    int off = 0;

    QString res;

    while (off < ba.length()) {

        ushort c = ba[off++].unicode();

        switch (c) {

        case '\n':

            res += QLatin1String("\\n");

            lines.append(res);

            res.clear();

            break;

        case '\r':

            res += QLatin1String("\\r");

            break;

        case '\t':

            res += QLatin1String("\\t");

            break;

        case '\v':

            res += QLatin1String("\\v");

            break;

        case '\a':

            res += QLatin1String("\\a");

            break;

        case '\b':

            res += QLatin1String("\\b");

            break;

        case '\f':

            res += QLatin1String("\\f");

            break;

        case '"':

            res += QLatin1String("\\\"");

            break;

        case '\\':

            res += QLatin1String("\\\\");

            break;

        default:

            if (c < 32) {

                res += QLatin1String("\\x");

                res += QString::number(c, 16);

                if (off < ba.length() && isxdigit(ba[off].unicode()))

                    res += QLatin1String("\"\"");

            } else {

                res += QChar(c);

            }

            break;

        }

    }

    if (!res.isEmpty())

        lines.append(res);

    if (!lines.isEmpty()) {

        if (!noWrap) {

            if (lines.count() != 1 ||

                lines.first().length() > MAX_LEN - keyword.length() - prefix.length() - 3)

            {

                QStringList olines = lines;

                lines = QStringList(QString());

                const int maxlen = MAX_LEN - prefix.length() - 2;

                foreach (const QString &line, olines) {

                    int off = 0;

                    while (off + maxlen < line.length()) {

                        int idx = line.lastIndexOf(QLatin1Char(' '), off + maxlen - 1) + 1;

                        if (idx == off) {

#ifdef HARD_WRAP_LONG_WORDS

                            // This doesn't seem too nice, but who knows ...

                            idx = off + maxlen;

#else

                            idx = line.indexOf(QLatin1Char(' '), off + maxlen) + 1;

                            if (!idx)

                                break;

#endif

                        }

                        lines.append(line.mid(off, idx - off));

                        off = idx;

                    }

                    lines.append(line.mid(off));

                }

            }

        } else if (lines.count() > 1) {

            lines.prepend(QString());

        }

    }

    return prefix + keyword + QLatin1String(" \"") +

           lines.join(QLatin1String("\"\n") + prefix + QLatin1Char('"')) +

           QLatin1String("\"\n");

}

static QString poEscapedLines(const QString &prefix, bool addSpace, const QStringList &lines)

{

    QString out;

    foreach (const QString &line, lines) {

        out += prefix;

        if (addSpace && !line.isEmpty())

            out += QLatin1Char(' ' );

        out += line;

        out += QLatin1Char('\n');

    }

    return out;

}

static QString poEscapedLines(const QString &prefix, bool addSpace, const QString &in0)

{

    QString in = in0;

    if (in.endsWith(QLatin1Char('\n')))

        in.chop(1);

    return poEscapedLines(prefix, addSpace, in.split(QLatin1Char('\n')));

}

static QString poWrappedEscapedLines(const QString &prefix, bool addSpace, const QString &line)

{

    const int maxlen = MAX_LEN - prefix.length();

    QStringList lines;

    int off = 0;

    while (off + maxlen < line.length()) {

        int idx = line.lastIndexOf(QLatin1Char(' '), off + maxlen - 1);

        if (idx < off) {

#if 0 //def HARD_WRAP_LONG_WORDS

            // This cannot work without messing up semantics, so do not even try.

#else

            idx = line.indexOf(QLatin1Char(' '), off + maxlen);

            if (idx < 0)

                break;

#endif

        }

        lines.append(line.mid(off, idx - off));

        off = idx + 1;

    }

    lines.append(line.mid(off));

    return poEscapedLines(prefix, addSpace, lines);

}

struct PoItem

{

public:

    PoItem()

      : isPlural(false), isFuzzy(false)

    {}

public:

    bool isPlural;

    bool isFuzzy;

    QHash<QString, QString> extra;

};

{

}

{

    int stoff;

    for (; l < lines.size(); ++l) {

        if (line.isEmpty() || !line.startsWith(prefix))

            break;

            offset++;

            break;

        offset++;

        forever {

            if (offset == line.length())

                goto premature_eol;

            if (c == '"') {

                if (offset == line.length())

                    break;

                    offset++;

                    cd.appendError(QString::fromLatin1(

                            "PO parsing error: extra characters on line %1.")

                            .arg(l + 1));

                    break;

                }

                continue;

            }

            if (c == '\\') {

                if (offset == line.length())

                    goto premature_eol;

                switch (c) {

                case 'r':

                    break;

                case 'n':

                    break;

                case 't':

                    break;

                case 'v':

                    break;

                case 'a':

                    break;

                case 'b':

                    break;

                case 'f':

                    break;

                case '"':

                    break;

                case '\\':

                    break;

                case '0':

                case '1':

                case '2':

                case '3':

                case '4':

                case '5':

                case '6':

                case '7':

                    stoff = offset - 1;

                        if (++offset == line.length())

                            goto premature_eol;

                    break;

                case 'x':

                    stoff = offset;

                        if (++offset == line.length())

                            goto premature_eol;

                    break;

                default:

                    cd.appendError(QString::fromLatin1(

                            "PO parsing error: invalid escape '\\%1' (line %2).")

                    break;

                }

            } else {

            }

        }

        offset = prefix.size();

    }

    --l;

    return msg;

premature_eol:

    cd.appendError(QString::fromLatin1(

            "PO parsing error: premature end of line %1.").arg(l + 1));

}

{

    for (int i = 1; ; i++) {

            prefix.truncate(i);

            break;

        }

    }

    for (; l < lines.size(); ++l) {

        if (line.startsWith(prefix))

            msg += line.mid(prefix.size());

            break;

    }

    --l;

}

bool loadPO(Translator &translator, QIODevice &dev, ConversionData &cd)

{

    bool error = false;

    // format of a .po file entry:

    // white-space

    // #  translator-comments

    // #. automatic-comments

    // #: reference...

    // #, flag...

    // #~ msgctxt, msgid*, msgstr - used for obsoleted messages

    // #| msgctxt, msgid* previous untranslated-string - for fuzzy message

    // msgctx string-context

    // msgid untranslated-string

    // -- For singular:

    // msgstr translated-string

    // -- For plural:

    // msgid_plural untranslated-string-plural

    // msgstr[0] translated-string

    // ...

    // we need line based lookahead below.

    PoItem item;

    for (; l != lines.size(); ++l) {

        if (line.isEmpty())

           continue;

        if (isTranslationLine(line)) {

            while (true) {

                item.msgStr.append(str);

                if (l + 1 >= lines.size() || !isTranslationLine(lines.at(l + 1)))

                    break;

                ++l;

                line = lines.at(l);

            }

            if (item.msgId.isEmpty()) {

                }

                }