/* -*- C++ -*-
 *
 * Copyright (C) 2006 Trolltech AS. All rights reserved.
 *    Author: Thiago Macieira <thiago.macieira@trolltech.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <QtCore/qbytearray.h>
#include <QtCore/qdatetime.h>
#include <QtCore/qfile.h>
#include <QtCore/qstring.h>
#include <QtCore/qtextstream.h>
#include <QtCore/qset.h>

#include <dbus/qdbus.h>

#define PROGRAMNAME     "dbusidl2cpp"
#define PROGRAMVERSION  "0.1"
#define PROGRAMCOPYRIGHT "Copyright (C) 2006 Trolltech AS. All rights reserved."

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

static const char cmdlineOptions[] = "a:h:Np:vV";
static const char *proxyFile;
static const char *adaptorFile;
static const char *inputFile;
static bool skipNamespaces;
static bool verbose;
static QStringList wantedInterfaces;

static const char help[] =
    "Usage: " PROGRAMNAME " [options...] [idl-or-xml-file] [interfaces...]\n"
    "Produces the C++ code to implement the interfaces defined in the input file.\n"
    "If no options are given, the code is written to the standard output.\n"
    "\n"
    "Options:\n"
    "  -a <filename>    Write the adaptor code to <filename>\n"
    "  -h               Show this information\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";

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 void parseCmdLine(int argc, char **argv)
{
    int c;
    opterr = true;
    while ((c = getopt(argc, argv, cmdlineOptions)) != -1)
        switch (c)
        {
        case 'a':
            adaptorFile = optarg;
            break;
            
        case 'v':
            verbose = true;
            break;

        case 'N':
            skipNamespaces = true;
            break;
            
        case 'h':
            showHelp();
            break;

        case 'V':
            showVersion();
            break;

        case 'p':
            proxyFile = optarg;
            break;

        case '?':
            exit(1);
        default:
            abort();
        }

    if (optind != argc)
        inputFile = argv[optind++];

    while (optind != argc)
        wantedInterfaces << QString::fromLocal8Bit(argv[optind++]);
}

static QDBusIntrospection::Interfaces readInput()
{
    QFile input(QFile::decodeName(inputFile));
    if (inputFile) 
        input.open(QIODevice::ReadOnly);
    else
        input.open(stdin, 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. Stop.\n");
    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 char *name)
{
    if (!name || (name[0] == '-' && name[1] == '\0'))
        return QString();

    QString retval = QFile::decodeName(name);
    if (!retval.endsWith(".h") && !retval.endsWith(".cpp") && !retval.endsWith(".cc"))
        retval.append(".h");

    return retval;
}

// produce a cpp name from the file name
static QString cpp(const char *name)
{
    if (!name || (name[0] == '-' && name[1] == '\0'))
        return QString();

    QString retval = QFile::decodeName(name);
    if (!retval.endsWith(".h") && !retval.endsWith(".cpp") && !retval.endsWith(".cc"))
        retval.append(".cpp");

    return retval;
}

static QTextStream &writeHeader(QTextStream &ts, bool changesWillBeLost)
{
    ts << "/*" << endl
       << " * This file was generated by " PROGRAMNAME " version " PROGRAMVERSION << endl
       << " * when processing input file " << (inputFile ? inputFile : "<stdin>") << 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;

    ts << " */" << endl
       << endl;

    return ts;
}

enum ClassType { Proxy, Adaptor };
static QString classNameForInterface(const QString &interface, ClassType classType)
{
    QStringList parts = interface.split('.');

    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 += "Interface";
    else
        retval += "Adaptor";

    return retval;
}

static QString templateArg(const QString &arg)
{
    if (!arg.endsWith('>'))
        return arg;

    return arg + ' ';
}

static QString constRefArg(const QString &arg)
{
    if (!arg.startsWith('Q'))
        return arg + ' ';
    else
        return QString("const %1 &").arg(arg);
}

static QString makeQtName(const QString &dbusName)
{
    QString name = dbusName;
    if (name.length() > 3 && name.startsWith("Get"))
        name = name.mid(3);     // strip Get from GetXXXX

    // recapitalize the name
    QChar *p = name.data();
    while (!p->isNull()) {
        // capitalized letter
        // leave it
        if (!p->isNull())
            ++p;

        // lowercase all the next capital letters, except for the last one
        while (!p->isNull() && p->isUpper()) {
            if (!p[1].isNull() && p[1].isUpper())
                *p = p->toLower();
            ++p;
        }

        if (p->isUpper())
            ++p;

        // non capital letters: skip them
        while (!p->isNull() && !p->isUpper())
            ++p;
    }

    name[0] = name[0].toLower(); // lowercase the first one
    return name;
}

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("in%1").arg(i);
        while (retval.contains(name))
            name += "_";
        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("out%1").arg(i);
        while (retval.contains(name))
            name += "_";
        retval << name;
    }
    return retval;
}

static void writeArgList(QTextStream &ts, const QStringList &argNames,
                         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(arg.type.toString(QDBusType::QVariantNames));
        
        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 << arg.type.toString(QDBusType::QVariantNames) << " &" << argNames.at(argPos++);
        first = false;
    }
}

static QString stringify(const QString &data)
{
    QString retval;
    int i;
    for (i = 0; i < data.length(); ++i) {
        retval += '\"';
        for ( ; i < data.length() && data[i] != QChar('\n'); ++i)
            if (data[i] == '\"')
                retval += "\\\"";
            else
                retval += data[i];
        retval += "\"\n";
    }
    return retval;
}

static void writeProxy(const char *proxyFile, const QDBusIntrospection::Interfaces &interfaces)
{
    // open the file
    QString name = header(proxyFile);
    QFile file(name);
    if (!name.isEmpty())
        file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text);
    else
        file.open(stdout, QIODevice::WriteOnly | QIODevice::Text);

    QTextStream ts(&file);

    // write the header:
    writeHeader(ts, true);

    // include guards:
    QString includeGuard;
    if (!name.isEmpty()) {
        includeGuard = name.toUpper().replace(QChar('.'), QChar('_'));
        int pos = includeGuard.lastIndexOf('/');
        if (pos != -1)
            includeGuard = includeGuard.mid(pos + 1);
    } else {
        includeGuard = QString("QDBUSIDL2CPP_PROXY");
    }
    includeGuard = QString("%1_%2%3")
                   .arg(includeGuard)
                   .arg(getpid())
                   .arg(QDateTime::currentDateTime().toTime_t());
    ts << "#ifndef " << includeGuard << endl
       << "#define " << includeGuard << endl
       << endl;

    // include our stuff:
    ts << "#include <QtCore/QObject>" << endl
       << "#include <dbus/qdbus.h>" << endl
       << endl;

    foreach (const QDBusIntrospection::Interface *interface, interfaces) {
        // comment:
        ts << "/*" << endl
           << " * Proxy class for interface " << interface->name << endl
           << " */" << endl;

        // class header:
        QString className = classNameForInterface(interface->name, Proxy);
        ts << "class " << className << ": public QDBusInterface" << endl
           << "{" << endl
           << "public:" << endl
           << "    static inline const char *staticInterfaceName()" << endl
           << "    { return \"" << interface->name << "\"; }" << endl
           << endl
           << "    static inline const char *staticIntrospectionData()" << endl
           << "    { return \"\"" << endl
           << stringify(interface->introspection)
           << "        \"\"; }" << endl
           << endl;

        // constructors/destructors:
        ts << "public:" << endl
           << "    explicit inline " << className << "(const QDBusObject &obj)" << endl
           << "        : QDBusInterface(obj, staticInterfaceName())" << endl
           << "    { }" << endl
           << endl
           << "    inline ~" << className << "()" << endl
           << "    { }" << endl
           << endl;

        // the introspection virtual:
        ts << "    inline virtual QString introspectionData() const" << endl
           << "    { return QString::fromUtf8(staticIntrospectionData()); }" << endl
           << endl;

        // properties:
        ts << "public: // PROPERTIES" << endl;
        foreach (const QDBusIntrospection::Property &property, interface->properties) {
            QString type = property.type.toString(QDBusType::QVariantNames);
            QString templateType = templateArg(type);
            QString constRefType = constRefArg(type);
            QString getter = property.name;
            QString setter = "set" + property.name;
            getter[0] = getter[0].toLower();
            setter[3] = setter[3].toUpper();

            // getter:
            if (property.access != QDBusIntrospection::Property::Write) {
                ts << "    inline QDBusReply<" << templateType << "> " << getter << "() const" << endl
                   << "    {" << endl
                   << "        QDBusReply<QDBusVariant> retval = QDBusPropertiesInterface(object())" << endl
                   << "            .get(QLatin1String(\"" << interface->name << "\"), QLatin1String(\""
                   << property.name << "\"));" << endl
                   << "        return QDBusReply<" << templateType << ">::fromVariant(retval);" << endl
                   << "    }" << endl;
            }

            // setter
            if (property.access != QDBusIntrospection::Property::Read) {
                ts << "    inline QDBusReply<void> " << setter << "(" << constRefType << "value)" << endl
                   << "    {" << endl
                   << "        QDBusVariant v(value, QDBusType(";

                QString sig = property.type.dbusSignature();
                if (sig.length() == 1)
                    ts << "'" << sig.at(0) << "'";
                else
                    ts << "\"" << sig << "\"";

                ts << "));" << endl
                   << "        return QDBusPropertiesInterface(object())" << endl
                   << "            .set(QLatin1String(\"" << interface->name << "\"), QLatin1String(\""
                   << property.name << "\"), v);" << endl
                   << "     }" << endl;
            }

            ts << endl;
        }
        

        // methods:
        ts << "public: // METHODS" << endl;
        foreach (const QDBusIntrospection::Method &method, interface->methods) {
            bool isAsync = method.annotations.value(ANNOTATION_NO_WAIT) == "true";
            if (isAsync && !method.outputArgs.isEmpty()) {
                fprintf(stderr, "warning: method %s in interface %s is marked 'async' but has output arguments.\n",
                        qPrintable(method.name), qPrintable(interface->name));
                continue;
            }
            
            ts << "    inline ";

            QString returnType;

            if (method.annotations.value("org.freedesktop.DBus.Deprecated") == "true")
                ts << "Q_DECL_DEPRECATED ";

            if (isAsync)
                ts << "Q_ASYNC void ";
            else if (method.outputArgs.isEmpty())
                ts << "QDBusReply<void> ";
            else {
                returnType = method.outputArgs.first().type.toString(QDBusType::QVariantNames);
                ts << "QDBusReply<" << templateArg(returnType) << "> ";
            }

            QString name = makeQtName(method.name);
            ts << name << "(";

            QStringList argNames = makeArgNames(method.inputArgs, method.outputArgs);
            writeArgList(ts, argNames, method.inputArgs, method.outputArgs);

            ts << ")" << endl
               << "    {" << endl;

            if (method.outputArgs.count() > 1)
                ts << "        QDBusMessage reply = call(QLatin1String(\"";
            else if (!isAsync)
                ts << "        return call(QLatin1String(\"";
            else
                ts << "        callAsync(QLatin1String(\"";

            QString signature = QChar('.');
            foreach (const QDBusIntrospection::Argument &arg, method.inputArgs)
                signature += arg.type.dbusSignature();
            if (signature.length() == 1)
                signature.clear();
            ts << method.name << signature << "\")";

            int argPos = 0;
            for (int i = 0; i < method.inputArgs.count(); ++i)
                ts << ", " << argNames.at(argPos++);

            // close the QDBusIntrospection::call/callAsync call
            ts << ");" << endl;

            argPos++;
            if (method.outputArgs.count() > 1) {
                ts << "        if (reply.type() == QDBusMessage::ReplyMessage) {" << endl;
                
                // yes, starting from 1
                for (int i = 1; i < method.outputArgs.count(); ++i)
                    ts << "            " << argNames.at(argPos++) << " = qvariant_cast<"
                       << templateArg(method.outputArgs.at(i).type.toString(QDBusType::QVariantNames))
                       << ">(reply.at(" << i << "));" << endl;
                ts << "        }" << endl
                   << "        return reply;" << endl;
            }

            // close the function:
            ts << "    }" << endl
               << endl;
        }

        // close the class:
        ts << "};" << endl
           << endl;
    }

    if (!skipNamespaces) {
        QStringList last;
        QDBusIntrospection::Interfaces::ConstIterator it = interfaces.constBegin();
        do
        {
            QStringList current;
            QString name;
            if (it != interfaces.constEnd()) {
                current = it->constData()->name.split('.');
                name = current.takeLast();
            }
            
            int i = 0;
            while (i < current.count() && i < last.count() && current.at(i) == last.at(i))
                ++i;
        
            // i parts matched
            // close last.count() - i namespaces:
            for (int j = i; j < last.count(); ++j)
                ts << QString((last.count() - j - 1 + i) * 2, ' ') << "}" << endl;

            // open current.count() - i namespaces
            for (int j = i; j < current.count(); ++j)
                ts << QString(j * 2, ' ') << "namespace " << current.at(j) << " {" << endl;

            // add this class:
            if (!name.isEmpty()) {
                ts << QString(current.count() * 2, ' ')
                   << "typedef ::" << classNameForInterface(it->constData()->name, Proxy)
                   << " " << name << ";" << endl;
            }

            if (it == interfaces.constEnd())
                break;
            ++it;
            last = current;
        } while (true);
    }

    // close the include guard
    ts << "#endif" << endl;
}

static void writeAdaptor(const char *adaptorFile, const QDBusIntrospection::Interfaces &interfaces)
{
    // open the file
    QString headerName = header(adaptorFile);
    QFile file(headerName);
    if (!headerName.isEmpty())
        file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text);
    else
        file.open(stdout, QIODevice::WriteOnly | QIODevice::Text);
    QTextStream hs(&file);
    
    QString cppName = cpp(adaptorFile);
    QByteArray cppData;
    QTextStream cs(&cppData);

    // write the headers
    writeHeader(hs, false);

    // include guards:
    QString includeGuard;
    if (!headerName.isEmpty()) {
        includeGuard = headerName.toUpper().replace(QChar('.'), QChar('_'));
        int pos = includeGuard.lastIndexOf('/');
        if (pos != -1)
            includeGuard = includeGuard.mid(pos + 1);
    } else {
        includeGuard = QString("QDBUSIDL2CPP_ADAPTOR");
    }
    includeGuard = QString("%1_%2%3")
                   .arg(includeGuard)
                   .arg(getpid())
                   .arg(QDateTime::currentDateTime().toTime_t());
    hs << "#ifndef " << includeGuard << endl
       << "#define " << includeGuard << endl
       << endl;

    // include our stuff:
    hs << "#include <QtCore/QObject>" << endl;
    if (cppName == headerName)
        hs << "#include <QtCore/QMetaObject>" << endl;
    hs << "#include <dbus/qdbus.h>" << endl
       << endl;

    if (cppName != headerName) {
        writeHeader(cs, false);        
        cs << "#include \"" << headerName << "\"" << endl
           << "#include <QtCore/QMetaObject>" << endl
           << endl;
    }

    foreach (const QDBusIntrospection::Interface *interface, interfaces) {
        QString className = classNameForInterface(interface->name, Adaptor);

        // comment:
        hs << "/*" << endl
           << " * Adaptor class for interface " << interface->name << endl
           << " */" << endl;
        cs << "/*" << endl
           << " * Implementation of adaptor class " << className << endl
           << " */" << endl
           << endl;

        // class header:
        hs << "class " << className << ": public QDBusAbstractAdaptor" << endl
           << "{" << endl
           << "    Q_OBJECT" << endl
           << "    Q_CLASSINFO(\"D-Bus Interface\", \"" << interface->name << "\")" << endl
           << "    Q_CLASSINFO(\"D-Bus Introspection\", \"\"" << endl
           << stringify(interface->introspection)
           << "        \"\")" << endl
           << "public:" << endl
           << "    " << className << "(QObject *parent);" << endl
           << "    virtual ~" << className << "();" << endl
           << endl;

        // constructor/destructor
        cs << className << "::" << className << "(QObject *parent)" << endl
           << "   : QDBusAbstractAdaptor(parent)" << endl
           << "{" << endl
           << "    // constructor" << endl
           << "    setAutoRelaySignals(true);" << endl
           << "}" << endl
           << endl
           << className << "::~" << className << "()" << endl
           << "{" << endl
           << "    // destructor" << endl
           << "}" << endl
           << endl;

        hs << "public: // PROPERTIES" << endl;
        foreach (const QDBusIntrospection::Property &property, interface->properties) {
            QString type = property.type.toString(QDBusType::QVariantNames);
            QString constRefType = constRefArg(type);
            QString getter = property.name;
            QString setter = "set" + property.name;
            getter[0] = getter[0].toLower();
            setter[3] = setter[3].toUpper();
            
            hs << "   Q_PROPERTY(" << type << " " << getter;
            if (property.access != QDBusIntrospection::Property::Write)
                hs << " READ " << getter;
            if (property.access != QDBusIntrospection::Property::Read)
                hs << " WRITE " << setter;
            hs << ")" << endl;

            // getter:
            if (property.access != QDBusIntrospection::Property::Write) {
                hs << "    " << type << " " << getter << "() const;" << endl;
                cs << type << " "
                   << className << "::" << getter << "() const" << endl
                   << "{" << endl
                   << "    // get the value of property " << property.name << endl
                   << "    return qvariant_cast< " << type <<" >(object()->property(\"" << getter << "\"));" << endl
                   << "}" << endl
                   << endl;
            }

            // setter
            if (property.access != QDBusIntrospection::Property::Read) {
                hs << "    void " << setter << "(" << constRefType << "value);" << endl;
                cs << "void " << className << "::" << setter << "(" << constRefType << "value)" << endl
                   << "{" << endl
                   << "    // set the value of property " << property.name << endl
                   << "    object()->setProperty(\"" << getter << "\", value);" << endl
                   << "}" << endl
                   << endl;
            }

            hs << endl;
        }

        hs << "public slots: // METHODS" << endl;
        foreach (const QDBusIntrospection::Method &method, interface->methods) {
            bool isAsync = method.annotations.value(ANNOTATION_NO_WAIT) == "true";
            if (isAsync && !method.outputArgs.isEmpty()) {
                fprintf(stderr, "warning: method %s in interface %s is marked 'async' but has output arguments.\n",
                        qPrintable(method.name), qPrintable(interface->name));
                continue;
            }

            hs << "    ";
            if (method.annotations.value("org.freedesktop.DBus.Deprecated") == "true")
                hs << "Q_DECL_DEPRECATED ";
            
            if (isAsync) {
                hs << "Q_ASYNC void ";
                cs << "Q_ASYNC void ";
            } else if (method.outputArgs.isEmpty()) {
                hs << "void ";
                cs << "void ";
            } else {
                QString type = method.outputArgs.first().type.toString(QDBusType::QVariantNames);
                hs << type << " ";
                cs << type << " ";
            }

            QString name = makeQtName(method.name);
            hs << name << "(";
            cs << className << "::" << name << "(";

            QStringList argNames = makeArgNames(method.inputArgs, method.outputArgs);
            writeArgList(hs, argNames, method.inputArgs, method.outputArgs);
            writeArgList(cs, argNames, method.inputArgs, method.outputArgs);

            hs << ");" << endl; // finished for header
            cs << ")" << endl
               << "{" << endl
               << "    // handle method call " << interface->name << "." << method.name << endl;

            // create the return type
            int j = method.inputArgs.count();
            cs << "    " << method.outputArgs.at(0).type.toString(QDBusType::QVariantNames)
               << " " << argNames.at(j) << ";" << endl;

            // make the call
            if (method.inputArgs.count() <= 10 && method.outputArgs.count() <= 1) {
                // we can use QMetaObject::invokeMethod
                static const char invoke[] = "    QMetaObject::invokeMethod(object(), \"";
                cs << invoke << name << "\"";

                if (!method.outputArgs.isEmpty())
                    cs << ", Q_RETURN_ARG("
                       << method.outputArgs.at(0).type.toString(QDBusType::QVariantNames)
                       << ", "
                       << argNames.at(method.inputArgs.count())
                       << ")";
                
                for (int i = 0; i < method.inputArgs.count(); ++i)
                    cs << ", Q_ARG("
                       << method.inputArgs.at(i).type.toString(QDBusType::QVariantNames)
                       << ", "
                       << argNames.at(i)
                       << ")";
                    
                cs << ");" << endl;
            }

            cs << endl
               << "    // Alternative:" << endl
               << "    //";
            if (!method.outputArgs.isEmpty())
                cs << argNames.at(method.inputArgs.count()) << " = ";
            cs << "static_cast<YourObjectType *>(object())->" << name << "(";
            
            int argPos = 0;
            bool first = true;
            for (int i = 0; i < method.inputArgs.count(); ++i) {
                cs << (first ? "" : ", ") << argNames.at(argPos++);
                first = false;
            }
            ++argPos;           // skip retval, if any
            for (int i = 1; i < method.outputArgs.count(); ++i) {
                cs << (first ? "" : ", ") << argNames.at(argPos++);
                first = false;
            }

            cs << ");" << endl;
            if (!method.outputArgs.isEmpty())
                cs << "    return " << argNames.at(method.inputArgs.count()) << ";" << endl;
            cs << "}" << endl
               << endl;
        }

        hs << "signals: // SIGNALS" << endl;
        foreach (const QDBusIntrospection::Signal &signal, interface->signals_) {
            hs << "    ";
            if (signal.annotations.value("org.freedesktop.DBus.Deprecated") == "true")
                hs << "Q_DECL_DEPRECATED ";
            
            QString name = makeQtName(signal.name);
            hs << "void " << name << "(";

            QStringList argNames = makeArgNames(signal.outputArgs);
            writeArgList(hs, argNames, signal.outputArgs);

            hs << ");" << endl; // finished for header
        }

        // close the class:
        hs << "};" << endl
           << endl;        
    }

    // close the include guard
    hs << "#endif" << endl;
    
    cs.flush();
    hs.flush();
    if (headerName == cppName)
        file.write(cppData);
    else {
        // write to cpp file
        QFile f(cppName);
        f.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text);
        f.write(cppData);
    }
}

int main(int argc, char **argv)
{
    parseCmdLine(argc, argv);

    QDBusIntrospection::Interfaces interfaces = readInput();
    cleanInterfaces(interfaces);

    writeProxy(proxyFile, interfaces);

    if (adaptorFile)
        writeAdaptor(adaptorFile, interfaces);

    return 0;
}
    
/*!
    \page dbusidl2cpp QtDBus IDL compiler (dbusidl2cpp)

    The QtDBus IDL compiler is a tool that can be used to parse interface descriptions and produce
    static code representing those interfaces, which can then be used to make calls to remote
    objects or implement said interfaces.

    \p %dbusidl2dcpp has two modes of operation, that correspond to the two possible outputs it can
    produce: the interface (proxy) class or the adaptor class. The former is similar to the
    \ref StandardInterfaces classes that are part of the QtDBus API and consists of a single .h file,
    which should not be edited. The latter consists of both a C++ header and a source file, which
    are meant to be edited and adapted to your needs.

    The \p %dbusidl2dcpp tool is not meant to be run every time you compile your
    application. Instead, it's meant to be used when developing the code or when the interface
    changes.

    The adaptor classes generated by \p %dbusidl2cpp are just a skeleton that must be completed. It
    generates, by default, calls to slots with the same name on the object the adaptor is attached
    to. However, you may modify those slots or the property accessor functions to suit your needs.
*/