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

**

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

#include "outputrevision.h"

#include "utils.h"

#include <QtCore/qmetatype.h>

#include <stdio.h>

#include <private/qmetaobject_p.h> //for the flags.

QT_BEGIN_NAMESPACE

uint qvariant_nameToType(const char* name)

{

    if (!name)

        return 0;

    if (strcmp(name, "QVariant") == 0)

        return 0xffffffff;

    if (strcmp(name, "QCString") == 0)

        return QMetaType::QByteArray;

    if (strcmp(name, "Q_LLONG") == 0)

        return QMetaType::LongLong;

    if (strcmp(name, "Q_ULLONG") == 0)

        return QMetaType::ULongLong;

    if (strcmp(name, "QIconSet") == 0)

        return QMetaType::QIcon;

    uint tp = QMetaType::type(name);

    return tp < QMetaType::User ? tp : 0;

}

/*

  Returns true if the type is a QVariant types.

*/

bool isVariantType(const char* type)

{

    return qvariant_nameToType(type) != 0;

}

/*!

  Returns true if the type is qreal.

*/

static bool isQRealType(const char *type)

{

    return strcmp(type, "qreal") == 0;

}

Generator::Generator(ClassDef *classDef, const QList<QByteArray> &metaTypes, FILE *outfile)

    : out(outfile), cdef(classDef), metaTypes(metaTypes)

{

    if (cdef->superclassList.size())

        purestSuperClass = cdef->superclassList.first().first;

}

static inline int lengthOfEscapeSequence(const QByteArray &s, int i)

{

    if (s.at(i) != '\\' || i >= s.length() - 1)

        return 1;

    const int startPos = i;

    ++i;

    char ch = s.at(i);

    if (ch == 'x') {

        ++i;

        while (i < s.length() && is_hex_char(s.at(i)))

            ++i;

    } else if (is_octal_char(ch)) {

        while (i < startPos + 4

               && i < s.length()

               && is_octal_char(s.at(i))) {

            ++i;

        }

    } else { // single character escape sequence

        i = qMin(i + 1, s.length());

    }

    return i - startPos;

}

int Generator::strreg(const char *s)

{

    int idx = 0;

    if (!s)

        s = "";

    for (int i = 0; i < strings.size(); ++i) {

        const QByteArray &str = strings.at(i);

        if (str == s)

            return idx;

        idx += str.length() + 1;

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

            if (str.at(i) == '\\') {

                int cnt = lengthOfEscapeSequence(str, i) - 1;

                idx -= cnt;

                i += cnt;

            }

        }

    }

    strings.append(s);

    return idx;

}

void Generator::generateCode()

{

    bool isQt = (cdef->classname == "Qt");

    bool isQObject = (cdef->classname == "QObject");

    bool isConstructible = !cdef->constructorList.isEmpty();

//

// build the data array

//

    int i = 0;

    // filter out undeclared enumerators and sets

    {

        QList<EnumDef> enumList;

        for (i = 0; i < cdef->enumList.count(); ++i) {

            EnumDef def = cdef->enumList.at(i);

            if (cdef->enumDeclarations.contains(def.name)) {

                enumList += def;

            }

            QByteArray alias = cdef->flagAliases.value(def.name);

            if (cdef->enumDeclarations.contains(alias)) {

                def.name = alias;

                enumList += def;

            }

        }

        cdef->enumList = enumList;

    }

    QByteArray qualifiedClassNameIdentifier = cdef->qualified;

    qualifiedClassNameIdentifier.replace(':', '_');

    int index = 14;

    fprintf(out, "static const uint qt_meta_data_%s[] = {\n", qualifiedClassNameIdentifier.constData());

    fprintf(out, "\n // content:\n");

    fprintf(out, "    %4d,       // revision\n", 4);

    fprintf(out, "    %4d,       // classname\n", strreg(cdef->qualified));

    fprintf(out, "    %4d, %4d, // classinfo\n", cdef->classInfoList.count(), cdef->classInfoList.count() ? index : 0);

    index += cdef->classInfoList.count() * 2;

    int methodCount = cdef->signalList.count() + cdef->slotList.count() + cdef->methodList.count();

    fprintf(out, "    %4d, %4d, // methods\n", methodCount, methodCount ? index : 0);

    index += methodCount * 5;

    fprintf(out, "    %4d, %4d, // properties\n", cdef->propertyList.count(), cdef->propertyList.count() ? index : 0);

    index += cdef->propertyList.count() * 3;

    if(cdef->notifyableProperties)

        index += cdef->propertyList.count();

    fprintf(out, "    %4d, %4d, // enums/sets\n", cdef->enumList.count(), cdef->enumList.count() ? index : 0);

    int enumsIndex = index;

    for (i = 0; i < cdef->enumList.count(); ++i)

        index += 4 + (cdef->enumList.at(i).values.count() * 2);

    fprintf(out, "    %4d, %4d, // constructors\n", isConstructible ? cdef->constructorList.count() : 0,

            isConstructible ? index : 0);

    fprintf(out, "    %4d,       // flags\n", 0);

    fprintf(out, "    %4d,       // signalCount\n", cdef->signalList.count());

//

// Build classinfo array

//

    generateClassInfos();

//

// Build signals array first, otherwise the signal indices would be wrong

//

    generateFunctions(cdef->signalList, "signal", MethodSignal);

//

// Build slots array

//

    generateFunctions(cdef->slotList, "slot", MethodSlot);

//

// Build method array

//

    generateFunctions(cdef->methodList, "method", MethodMethod);

//

// Build property array

//

    generateProperties();

//

// Build enums array

//

    generateEnums(enumsIndex);

//

// Build constructors array

//

    if (isConstructible)

        generateFunctions(cdef->constructorList, "constructor", MethodConstructor);

//

// Terminate data array

//

    fprintf(out, "\n       0        // eod\n};\n\n");

//

// Build stringdata array

//

    fprintf(out, "static const char qt_meta_stringdata_%s[] = {\n", qualifiedClassNameIdentifier.constData());

    fprintf(out, "    \"");

    int col = 0;

    int len = 0;

    for (i = 0; i < strings.size(); ++i) {

        QByteArray s = strings.at(i);

        len = s.length();

        if (col && col + len >= 72) {

            fprintf(out, "\"\n    \"");

            col = 0;

        } else if (len && s.at(0) >= '0' && s.at(0) <= '9') {

            fprintf(out, "\"\"");

            len += 2;

        }

        int idx = 0;

        while (idx < s.length()) {

            if (idx > 0) {

                col = 0;

                fprintf(out, "\"\n    \"");

            }

            int spanLen = qMin(70, s.length() - idx);

            // don't cut escape sequences at the end of a line

            int backSlashPos = s.lastIndexOf('\\', idx + spanLen - 1);

            if (backSlashPos >= idx) {

                int escapeLen = lengthOfEscapeSequence(s, backSlashPos);

                spanLen = qBound(spanLen, backSlashPos + escapeLen - idx, s.length() - idx);

            }

            fwrite(s.constData() + idx, 1, spanLen, out);

            idx += spanLen;

            col += spanLen;

        }

        fputs("\\0", out);

        col += len + 2;

    }

    fprintf(out, "\"\n};\n\n");

//

// Generate internal qt_static_metacall() function

//

    if (isConstructible)

        generateStaticMetacall(qualifiedClassNameIdentifier);

//

// Build extra array

//

    QList<QByteArray> extraList;

    for (int i = 0; i < cdef->propertyList.count(); ++i) {

        const PropertyDef &p = cdef->propertyList.at(i);

        if (!isVariantType(p.type) && !metaTypes.contains(p.type) && !p.type.contains('*') &&

                !p.type.contains('<') && !p.type.contains('>')) {

            int s = p.type.lastIndexOf("::");

            if (s > 0) {

                QByteArray scope = p.type.left(s);

                if (scope != "Qt" && scope != cdef->classname && !extraList.contains(scope))

                    extraList += scope;

            }

        }

    }

    if (!extraList.isEmpty()) {

        fprintf(out, "#ifdef Q_NO_DATA_RELOCATION\n");

        fprintf(out, "static const QMetaObjectAccessor qt_meta_extradata_%s[] = {\n    ", qualifiedClassNameIdentifier.constData());

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

            fprintf(out, "    %s::getStaticMetaObject,\n", extraList.at(i).constData());

        }

        fprintf(out, "#else\n");

        fprintf(out, "static const QMetaObject *qt_meta_extradata_%s[] = {\n    ", qualifiedClassNameIdentifier.constData());

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

            fprintf(out, "    &%s::staticMetaObject,\n", extraList.at(i).constData());

        }

        fprintf(out, "#endif //Q_NO_DATA_RELOCATION\n");

        fprintf(out, "    0\n};\n\n");

    }

    if (isConstructible || !extraList.isEmpty()) {

        fprintf(out, "static const QMetaObjectExtraData qt_meta_extradata2_%s = {\n    ",

                qualifiedClassNameIdentifier.constData());

        if (extraList.isEmpty())

            fprintf(out, "0, ");

        else

            fprintf(out, "qt_meta_extradata_%s, ", qualifiedClassNameIdentifier.constData());

        if (!isConstructible)

            fprintf(out, "0");

        else

            fprintf(out, "%s_qt_static_metacall", qualifiedClassNameIdentifier.constData());

        fprintf(out, " \n};\n\n");

    }

//

// Finally create and initialize the static meta object

//

    if (isQt)

        fprintf(out, "const QMetaObject QObject::staticQtMetaObject = {\n");

    else

        fprintf(out, "const QMetaObject %s::staticMetaObject = {\n", cdef->qualified.constData());

    if (isQObject)

        fprintf(out, "    { 0, ");

    else if (cdef->superclassList.size())

        fprintf(out, "    { &%s::staticMetaObject, ", purestSuperClass.constData());

    else

        fprintf(out, "    { 0, ");

    fprintf(out, "qt_meta_stringdata_%s,\n      qt_meta_data_%s, ",

             qualifiedClassNameIdentifier.constData(), qualifiedClassNameIdentifier.constData());

    if (!isConstructible && extraList.isEmpty())

        fprintf(out, "0 }\n");

    else

        fprintf(out, "&qt_meta_extradata2_%s }\n", qualifiedClassNameIdentifier.constData());

    fprintf(out, "};\n");

    if(isQt)

        return;

//

// Generate static meta object accessor (needed for symbian, because DLLs do not support data imports.

//

    fprintf(out, "\n#ifdef Q_NO_DATA_RELOCATION\n");

    fprintf(out, "const QMetaObject &%s::getStaticMetaObject() { return staticMetaObject; }\n", cdef->qualified.constData());

    fprintf(out, "#endif //Q_NO_DATA_RELOCATION\n");

    if (!cdef->hasQObject)

        return;

    fprintf(out, "\nconst QMetaObject *%s::metaObject() const\n{\n    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;\n}\n",

            cdef->qualified.constData());

//

// Generate smart cast function

//

    fprintf(out, "\nvoid *%s::qt_metacast(const char *_clname)\n{\n", cdef->qualified.constData());

    fprintf(out, "    if (!_clname) return 0;\n");

    fprintf(out, "    if (!strcmp(_clname, qt_meta_stringdata_%s))\n"

                  "        return static_cast<void*>(const_cast< %s*>(this));\n",

            qualifiedClassNameIdentifier.constData(), cdef->classname.constData());

    for (int i = 1; i < cdef->superclassList.size(); ++i) { // for all superclasses but the first one

        if (cdef->superclassList.at(i).second == FunctionDef::Private)

            continue;

        const char *cname = cdef->superclassList.at(i).first;

        fprintf(out, "    if (!strcmp(_clname, \"%s\"))\n        return static_cast< %s*>(const_cast< %s*>(this));\n",

                cname, cname, cdef->classname.constData());

    }

    for (int i = 0; i < cdef->interfaceList.size(); ++i) {

        const QList<ClassDef::Interface> &iface = cdef->interfaceList.at(i);

        for (int j = 0; j < iface.size(); ++j) {

            fprintf(out, "    if (!strcmp(_clname, %s))\n        return ", iface.at(j).interfaceId.constData());

            for (int k = j; k >= 0; --k)

                fprintf(out, "static_cast< %s*>(", iface.at(k).className.constData());

            fprintf(out, "const_cast< %s*>(this)%s;\n",

                    cdef->classname.constData(), QByteArray(j+1, ')').constData());

        }

    }

    if (!purestSuperClass.isEmpty() && !isQObject) {

        QByteArray superClass = purestSuperClass;

        // workaround for VC6

        if (superClass.contains("::")) {

            fprintf(out, "    typedef %s QMocSuperClass;\n", superClass.constData());

            superClass = "QMocSuperClass";

        }

        fprintf(out, "    return %s::qt_metacast(_clname);\n", superClass.constData());

    } else {

        fprintf(out, "    return 0;\n");

    }

    fprintf(out, "}\n");

//

// Generate internal qt_metacall()  function

//

    generateMetacall();

//

// Generate internal signal functions

//

    for (int signalindex = 0; signalindex < cdef->signalList.size(); ++signalindex)

        generateSignal(&cdef->signalList[signalindex], signalindex);

}

void Generator::generateClassInfos()

{

    if (cdef->classInfoList.isEmpty())

        return;

    fprintf(out, "\n // classinfo: key, value\n");

    for (int i = 0; i < cdef->classInfoList.size(); ++i) {

        const ClassInfoDef &c = cdef->classInfoList.at(i);

        fprintf(out, "    %4d, %4d,\n", strreg(c.name), strreg(c.value));

    }

}

void Generator::generateFunctions(QList<FunctionDef>& list, const char *functype, int type)

{

    if (list.isEmpty())

        return;

    fprintf(out, "\n // %ss: signature, parameters, type, tag, flags\n", functype);

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

        const FunctionDef &f = list.at(i);

        QByteArray sig = f.name + '(';

        QByteArray arguments;

        for (int j = 0; j < f.arguments.count(); ++j) {

            const ArgumentDef &a = f.arguments.at(j);

            if (j) {

                sig += ",";

                arguments += ",";

            }

            sig += a.normalizedType;

            arguments += a.name;

        }

        sig += ')';

        char flags = type;

        if (f.access == FunctionDef::Private)

            flags |= AccessPrivate;

        else if (f.access == FunctionDef::Public)

            flags |= AccessPublic;

        else if (f.access == FunctionDef::Protected)

            flags |= AccessProtected;

        if (f.access == FunctionDef::Private)

            flags |= AccessPrivate;

        else if (f.access == FunctionDef::Public)

            flags |= AccessPublic;

        else if (f.access == FunctionDef::Protected)

            flags |= AccessProtected;

        if (f.isCompat)

            flags |= MethodCompatibility;

        if (f.wasCloned)

            flags |= MethodCloned;

        if (f.isScriptable)

            flags |= MethodScriptable;

        fprintf(out, "    %4d, %4d, %4d, %4d, 0x%02x,\n", strreg(sig),

                strreg(arguments), strreg(f.normalizedType), strreg(f.tag), flags);

    }

}

void Generator::generateProperties()

{

    //

    // specify get function, for compatibiliy we accept functions

    // returning pointers, or const char * for QByteArray.

    //

    for (int i = 0; i < cdef->propertyList.count(); ++i) {

        PropertyDef &p = cdef->propertyList[i];

        if (p.read.isEmpty())

            continue;

        for (int j = 0; j < cdef->publicList.count(); ++j) {

            const FunctionDef &f = cdef->publicList.at(j);

            if (f.name != p.read)

                continue;

            if (!f.isConst) // get  functions must be const

                continue;

            if (f.arguments.size()) // and must not take any arguments

                continue;

            PropertyDef::Specification spec = PropertyDef::ValueSpec;

            QByteArray tmp = f.normalizedType;

            if (p.type == "QByteArray" && tmp == "const char *")

                    tmp = "QByteArray";

            if (tmp.left(6) == "const ")

                tmp = tmp.mid(6);

            if (p.type != tmp && tmp.endsWith('*')) {

                tmp.chop(1);

                spec = PropertyDef::PointerSpec;

            } else if (f.type.name.endsWith('&')) { // raw type, not normalized type

                spec = PropertyDef::ReferenceSpec;

            }

            if (p.type != tmp)

                continue;

            p.gspec = spec;

            break;

        }

        if(!p.notify.isEmpty()) {

            int notifyId = -1;

            for (int j = 0; j < cdef->signalList.count(); ++j) {

                const FunctionDef &f = cdef->signalList.at(j);

                if(f.name != p.notify) {

                    continue;

                } else {

                    notifyId = j /* Signal indexes start from 0 */;

                    break;

                }

            }