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

**

** 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 tools applications 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 <QtCore/qbytearray.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdatetime.h>

#include <QtCore/qdebug.h>

#include <QtCore/qfile.h>

#include <QtCore/qstring.h>

#include <QtCore/qstringlist.h>

#include <QtCore/qtextstream.h>

#include <QtCore/qset.h>

#include <QtDBus/QtDBus>

#include "private/qdbusmetaobject_p.h"

#include "private/qdbusintrospection_p.h"

#include <sys/types.h>

#include <stdio.h>

#include <stdlib.h>

#ifdef Q_WS_WIN

#include <process.h>

#endif

#define PROGRAMNAME     "qdbusxml2cpp"

#define PROGRAMVERSION  "0.7"

#define PROGRAMCOPYRIGHT "Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)."

#define ANNOTATION_NO_WAIT      "org.freedesktop.DBus.Method.NoReply"

static QString globalClassName;

static QString parentClassName;

static QString proxyFile;

static QString adaptorFile;

static QString inputFile;

static bool skipNamespaces;

static bool verbose;

static bool includeMocs;

static QString commandLine;

static QStringList includes;

static QStringList wantedInterfaces;

static const char help[] =

    "Usage: " PROGRAMNAME " [options...] [xml-or-xml-file] [interfaces...]\n"

    "Produces the C++ code to implement the interfaces defined in the input file.\n"

    "\n"

    "Options:\n"

    "  -a <filename>    Write the adaptor code to <filename>\n"

    "  -c <classname>   Use <classname> as the class name for the generated classes\n"

    "  -h               Show this information\n"

    "  -i <filename>    Add #include to the output\n"

    "  -l <classname>   When generating an adaptor, use <classname> as the parent class\n"

    "  -m               Generate #include \"filename.moc\" statements in the .cpp files\n"

    "  -N               Don't use namespaces\n"

    "  -p <filename>    Write the proxy code to <filename>\n"

    "  -v               Be verbose.\n"

    "  -V               Show the program version and quit.\n"

    "\n"

    "If the file name given to the options -a and -p does not end in .cpp or .h, the\n"

    "program will automatically append the suffixes and produce both files.\n"

    "You can also use a colon (:) to separate the header name from the source file\n"

    "name, as in '-a filename_p.h:filename.cpp'.\n"

    "\n"

    "If you pass a dash (-) as the argument to either -p or -a, the output is written\n"

    "to the standard output\n";

static const char includeList[] =

    "#include <QtCore/QByteArray>\n"

    "#include <QtCore/QList>\n"

    "#include <QtCore/QMap>\n"

    "#include <QtCore/QString>\n"

    "#include <QtCore/QStringList>\n"

    "#include <QtCore/QVariant>\n";

static const char forwardDeclarations[] =

    "class QByteArray;\n"

    "template<class T> class QList;\n"

    "template<class Key, class Value> class QMap;\n"

    "class QString;\n"

    "class QStringList;\n"

    "class QVariant;\n";

static void showHelp()

{

    printf("%s", help);

    exit(0);

}

static void showVersion()

{

    printf("%s version %s\n", PROGRAMNAME, PROGRAMVERSION);

    printf("D-Bus binding tool for Qt\n");

    exit(0);

}

static QString nextArg(QStringList &args, int i, char opt)

{

    QString arg = args.value(i);

    if (arg.isEmpty()) {

        printf("-%c needs at least one argument\n", opt);

        exit(1);

    }

    return args.takeAt(i);

}

static void parseCmdLine(QStringList args)

{

    args.takeFirst();

    commandLine = QLatin1String(PROGRAMNAME " ");

    commandLine += args.join(QLatin1String(" "));

    int i = 0;

    while (i < args.count()) {

        if (!args.at(i).startsWith(QLatin1Char('-'))) {

            ++i;

            continue;

        }

        QString arg = args.takeAt(i);

        char c = '\0';

        if (arg.length() == 2)

            c = arg.at(1).toLatin1();

        else if (arg == QLatin1String("--help"))

            c = 'h';

        switch (c) {

        case 'a':

            adaptorFile = nextArg(args, i, 'a');

            break;

        case 'c':

            globalClassName = nextArg(args, i, 'c');

            break;

        case 'v':

            verbose = true;

            break;

        case 'i':

            includes << nextArg(args, i, 'i');

            break;

        case 'l':

            parentClassName = nextArg(args, i, 'l');

            break;

        case 'm':

            includeMocs = true;

            break;

        case 'N':

            skipNamespaces = true;

            break;

        case '?':

        case 'h':

            showHelp();

            break;

        case 'V':

            showVersion();

            break;

        case 'p':

            proxyFile = nextArg(args, i, 'p');

            break;

        default:

            printf("unknown option: '%s'\n", qPrintable(arg));

            exit(1);

        }

    }

    if (!args.isEmpty())

        inputFile = args.takeFirst();

    wantedInterfaces << args;

}

static QDBusIntrospection::Interfaces readInput()

{

    QFile input(inputFile);

    if (inputFile.isEmpty() || inputFile == QLatin1String("-"))

        input.open(stdin, QIODevice::ReadOnly);

    else

        input.open(QIODevice::ReadOnly);

    QByteArray data = input.readAll();

    // check if the input is already XML

    data = data.trimmed();

    if (data.startsWith("<!DOCTYPE ") || data.startsWith("<?xml") ||

        data.startsWith("<node") || data.startsWith("<interface"))

        // already XML

        return QDBusIntrospection::parseInterfaces(QString::fromUtf8(data));

    fprintf(stderr, "Cannot process input: '%s'. Stop.\n", qPrintable(inputFile));

    exit(1);

}

static void cleanInterfaces(QDBusIntrospection::Interfaces &interfaces)

{

    if (!wantedInterfaces.isEmpty()) {

        QDBusIntrospection::Interfaces::Iterator it = interfaces.begin();

        while (it != interfaces.end())

            if (!wantedInterfaces.contains(it.key()))

                it = interfaces.erase(it);

            else

                ++it;

    }

}

// produce a header name from the file name

static QString header(const QString &name)

{

    QStringList parts = name.split(QLatin1Char(':'));

    QString retval = parts.first();

    if (retval.isEmpty() || retval == QLatin1String("-"))

        return retval;

    if (!retval.endsWith(QLatin1String(".h")) && !retval.endsWith(QLatin1String(".cpp")) &&

        !retval.endsWith(QLatin1String(".cc")))

        retval.append(QLatin1String(".h"));

    return retval;

}

// produce a cpp name from the file name

static QString cpp(const QString &name)

{

    QStringList parts = name.split(QLatin1Char(':'));

    QString retval = parts.last();

    if (retval.isEmpty() || retval == QLatin1String("-"))

        return retval;

    if (!retval.endsWith(QLatin1String(".h")) && !retval.endsWith(QLatin1String(".cpp")) &&

        !retval.endsWith(QLatin1String(".cc")))

        retval.append(QLatin1String(".cpp"));

    return retval;

}

// produce a moc name from the file name

static QString moc(const QString &name)

{

    QString retval = header(name);

    if (retval.isEmpty())

        return retval;

    retval.truncate(retval.length() - 1); // drop the h in .h

    retval += QLatin1String("moc");

    return retval;

}

static QTextStream &writeHeader(QTextStream &ts, bool changesWillBeLost)

{

    ts << "/*" << endl

       << " * This file was generated by " PROGRAMNAME " version " PROGRAMVERSION << endl

       << " * Command line was: " << commandLine << endl

       << " *" << endl

       << " * " PROGRAMNAME " is " PROGRAMCOPYRIGHT << endl

       << " *" << endl

       << " * This is an auto-generated file." << endl;

    if (changesWillBeLost)

        ts << " * Do not edit! All changes made to it will be lost." << endl;

    else

        ts << " * This file may have been hand-edited. Look for HAND-EDIT comments" << endl

           << " * before re-generating it." << endl;

    ts << " */" << endl

       << endl;

    return ts;

}

enum ClassType { Proxy, Adaptor };

static QString classNameForInterface(const QString &interface, ClassType classType)

{

    if (!globalClassName.isEmpty())

        return globalClassName;

    QStringList parts = interface.split(QLatin1Char('.'));

    QString retval;

    if (classType == Proxy)

        foreach (QString part, parts) {

            part[0] = part[0].toUpper();

            retval += part;

        }

    else {

        retval = parts.last();

        retval[0] = retval[0].toUpper();

    }

    if (classType == Proxy)

        retval += QLatin1String("Interface");

    else

        retval += QLatin1String("Adaptor");

    return retval;

}

static QByteArray qtTypeName(const QString &signature, const QDBusIntrospection::Annotations &annotations, int paramId = -1, const char *direction = "Out")

{

    int type = QDBusMetaType::signatureToType(signature.toLatin1());

    if (type == QVariant::Invalid) {

        QString annotationName = QString::fromLatin1("com.trolltech.QtDBus.QtTypeName");

        if (paramId >= 0)

            annotationName += QString::fromLatin1(".%1%2").arg(QLatin1String(direction)).arg(paramId);

        QString qttype = annotations.value(annotationName);

        if (!qttype.isEmpty())

            return qttype.toLatin1();

        fprintf(stderr, "Got unknown type `%s'\n", qPrintable(signature));

        fprintf(stderr, "You should add <annotation name=\"%s\" value=\"<type>\"/> to the XML description\n",

                qPrintable(annotationName));

        exit(1);

    }

    return QVariant::typeToName(QVariant::Type(type));

}

static QString nonConstRefArg(const QByteArray &arg)

{

    return QLatin1String(arg + " &");

}

static QString templateArg(const QByteArray &arg)

{

    if (!arg.endsWith('>'))

        return QLatin1String(arg);

    return QLatin1String(arg + ' ');

}

static QString constRefArg(const QByteArray &arg)

{

    if (!arg.startsWith('Q'))

        return QLatin1String(arg + ' ');

    else

        return QString( QLatin1String("const %1 &") ).arg( QLatin1String(arg) );

}

static QStringList makeArgNames(const QDBusIntrospection::Arguments &inputArgs,

                                const QDBusIntrospection::Arguments &outputArgs =

                                QDBusIntrospection::Arguments())

{

    QStringList retval;

    for (int i = 0; i < inputArgs.count(); ++i) {

        const QDBusIntrospection::Argument &arg = inputArgs.at(i);

        QString name = arg.name;

        if (name.isEmpty())

            name = QString( QLatin1String("in%1") ).arg(i);

        while (retval.contains(name))

            name += QLatin1String("_");

        retval << name;

    }

    for (int i = 0; i < outputArgs.count(); ++i) {

        const QDBusIntrospection::Argument &arg = outputArgs.at(i);

        QString name = arg.name;

        if (name.isEmpty())

            name = QString( QLatin1String("out%1") ).arg(i);

        while (retval.contains(name))

            name += QLatin1String("_");

        retval << name;

    }

    return retval;

}

static void writeArgList(QTextStream &ts, const QStringList &argNames,

                         const QDBusIntrospection::Annotations &annotations,

                         const QDBusIntrospection::Arguments &inputArgs,

                         const QDBusIntrospection::Arguments &outputArgs = QDBusIntrospection::Arguments())

{

    // input args:

    bool first = true;

    int argPos = 0;

    for (int i = 0; i < inputArgs.count(); ++i) {

        const QDBusIntrospection::Argument &arg = inputArgs.at(i);

        QString type = constRefArg(qtTypeName(arg.type, annotations, i, "In"));

        if (!first)

            ts << ", ";

        ts << type << argNames.at(argPos++);

        first = false;

    }

    argPos++;

    // output args

    // yes, starting from 1

    for (int i = 1; i < outputArgs.count(); ++i) {

        const QDBusIntrospection::Argument &arg = outputArgs.at(i);

        QString name = arg.name;

        if (!first)

            ts << ", ";

        ts << nonConstRefArg(qtTypeName(arg.type, annotations, i, "Out"))

           << argNames.at(argPos++);

        first = false;

    }

}

static QString propertyGetter(const QDBusIntrospection::Property &property)

{

    QString getter = property.annotations.value(QLatin1String("com.trolltech.QtDBus.propertyGetter"));

    if (getter.isEmpty()) {

        getter =  property.name;

        getter[0] = getter[0].toLower();

    }

    return getter;

}

static QString propertySetter(const QDBusIntrospection::Property &property)

{

    QString setter = property.annotations.value(QLatin1String("com.trolltech.QtDBus.propertySetter"));

    if (setter.isEmpty()) {

        setter = QLatin1String("set") + property.name;

        setter[3] = setter[3].toUpper();

    }

    return setter;

}

static QString stringify(const QString &data)

{

    QString retval;

    int i;

    for (i = 0; i < data.length(); ++i) {

        retval += QLatin1Char('\"');

        for ( ; i < data.length() && data[i] != QLatin1Char('\n'); ++i)

            if (data[i] == QLatin1Char('\"'))

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

            else

                retval += data[i];

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

    }

    return retval;

}

static void openFile(const QString &fileName, QFile &file)

{

    if (fileName.isEmpty())

        return;

    bool isOk = false;

    if (fileName == QLatin1String("-")) {

        isOk = file.open(stdout, QIODevice::WriteOnly | QIODevice::Text);

    } else {

        file.setFileName(fileName);

        isOk = file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text);

    }

    if (!isOk)

        fprintf(stderr, "Unable to open '%s': %s\n", qPrintable(fileName),

                qPrintable(file.errorString()));

}

static void writeProxy(const QString &filename, const QDBusIntrospection::Interfaces &interfaces)

{

    // open the file

    QString headerName = header(filename);

    QByteArray headerData;

    QTextStream hs(&headerData);

    QString cppName = cpp(filename);

    QByteArray cppData;

    QTextStream cs(&cppData);

    // write the header:

    writeHeader(hs, true);

    if (cppName != headerName)

        writeHeader(cs, false);

    // include guards:

    QString includeGuard;

    if (!headerName.isEmpty() && headerName != QLatin1String("-")) {

        includeGuard = headerName.toUpper().replace(QLatin1Char('.'), QLatin1Char('_'));

        int pos = includeGuard.lastIndexOf(QLatin1Char('/'));

        if (pos != -1)

            includeGuard = includeGuard.mid(pos + 1);

    } else {

        includeGuard = QLatin1String("QDBUSXML2CPP_PROXY");

    }

    includeGuard = QString(QLatin1String("%1_%2"))