summaryrefslogtreecommitdiffstats
path: root/shibokengenerator.h
blob: f9cd564f7d0846052c2c1b8879c999aee170657d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
/*
 * This file is part of the Shiboken Python Binding Generator project.
 *
 * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 *
 * Contact: PySide team <contact@pyside.org>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * 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 St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#ifndef SHIBOKENGENERATOR_H
#define SHIBOKENGENERATOR_H

#include <apiextractor/generator.h>
#include <QtCore/QTextStream>

class DocParser;

/**
 * Abstract generator that contains common methods used in CppGenerator and HeaderGenerator.
 */
class ShibokenGenerator : public Generator
{
public:
    ShibokenGenerator();

    /**
     *   Translate metatypes to C++ format.
     *   \param metaType a pointer to metatype
     *   \param context the current meta class
     *   \param option some extra options
     *   \return the metatype translated to C++ format
     */
    virtual QString translateType(const AbstractMetaType* metaType,
                                  const AbstractMetaClass* context,
                                  int option = NoOption) const;
    /**
     *   Write a function argument in the C++ in the text stream \p s.
     *   This function just call \code s << argumentString(); \endcode
     *   \param s text stream used to write the output.
     *   \param func the current metafunction.
     *   \param argument metaargument information to be parsed.
     *   \param options some extra options.
     */
    void writeArgument(QTextStream &s,
                       const AbstractMetaFunction* func,
                       const AbstractMetaArgument* argument,
                       uint options = 0) const;
    /**
     *   Create a QString in the C++ format to an function argument.
     *   \param func the current metafunction.
     *   \param argument metaargument information to be parsed.
     *   \param options some extra options.
     */
    QString argumentString(const AbstractMetaFunction* func,
                           const AbstractMetaArgument* argument,
                           uint options = 0) const;

    void writeArgumentNames(QTextStream &s,
                            const AbstractMetaFunction* func,
                            uint options = 0) const;

    /**
     *   Function used to write the fucntion arguments on the class buffer.
     *   \param s the class output buffer
     *   \param func the pointer to metafunction information
     *   \param count the number of function arguments
     *   \param options some extra options used during the parser
     */
    void writeFunctionArguments(QTextStream &s,
                                const AbstractMetaFunction* func,
                                uint options = 0) const;
    QString functionReturnType(const AbstractMetaFunction* func, int option = NoOption) const;
    /**
     *   Write a code snip into the buffer \p s.
     *   CodeSnip are codes inside inject-code tags.
     *   \param s    the buffer
     *   \param func the cpp function
     *   \param code_snips   a list of code snips
     *   \param position     the position to insert the code snip
     *   \param language     the kind of code snip
     */
    void writeCodeSnips(QTextStream &s,
                        const CodeSnipList &code_snips,
                        CodeSnip::Position position,
                        TypeSystem::Language language,
                        const AbstractMetaFunction* func = 0);
    /// returns the code snips of a function
    CodeSnipList getCodeSnips(const AbstractMetaFunction* func);
    static bool canCreateWrapperFor(const AbstractMetaClass* metaClass);
    /**
     *   Function witch parse the metafunction information
     *   \param func the function witch will be parserd
     *   \param option some extra options
     *   \param arg_count the number of function arguments
     */
    QString functionSignature(const AbstractMetaFunction* func,
                              QString prepend = "",
                              QString append = "",
                              int option = NoOption,
                              int arg_count = -1) const;

    QString signatureForDefaultVirtualMethod(const AbstractMetaFunction* func,
                                             QString prepend = "",
                                             QString append = "_default",
                                             int option = NoOption,
                                             int arg_count = -1) const;

    virtual QString subDirectoryForClass(const AbstractMetaClass* metaClass) const
    {
        return subDirectoryForPackage(metaClass->package());
    }

    bool hasInjectedCodeOrSignatureModification(const AbstractMetaFunction* func);
    QStringList getBaseClasses(const AbstractMetaClass* metaClass);

    QString writeBaseConversion(QTextStream& s, const AbstractMetaType* type,
                                const AbstractMetaClass* context);
    void writeToPythonConversion(QTextStream& s, const AbstractMetaType* type,
                                 const AbstractMetaClass* context, QString argumentName);
    void writeToCppConversion(QTextStream& s, const AbstractMetaType* type,
                              const AbstractMetaClass* context, QString argumentName);

    static QString wrapperName(const AbstractMetaClass* metaClass);

    static QString pythonPrimitiveTypeName(QString cppTypeName);
    static QString pythonPrimitiveTypeName(const PrimitiveTypeEntry* type);

    static QString pythonOperatorFunctionName(QString cppOpFuncName)
    {
        return QString("__%1__").arg(m_pythonOperators.value(cppOpFuncName));
    }
    static QString pythonOperatorFunctionName(const AbstractMetaFunction* func);
    static QString pythonRichCompareOperatorId(QString cppOpFuncName)
    {
        return QString("Py_%1").arg(m_pythonOperators.value(cppOpFuncName).toUpper());
    }
    static QString pythonRichCompareOperatorId(const AbstractMetaFunction* func)
    {
        return pythonRichCompareOperatorId(func->originalName());
    }

    static QString cpythonOperatorFunctionName(const AbstractMetaFunction* func);

    static bool isNumber(QString cpythonApiName);
    static bool isNumber(const TypeEntry* type);
    static bool isNumber(const AbstractMetaType* type);
    static bool isPyInt(const TypeEntry* type);
    static bool isPyInt(const AbstractMetaType* type);
    static bool isReverseOperator(const AbstractMetaFunction* func);

    QString cpythonBaseName(const TypeEntry* type);
    QString cpythonBaseName(const AbstractMetaType* type);
    QString cpythonTypeName(const TypeEntry* type);
    QString cpythonCheckFunction(const TypeEntry* type, bool genericNumberType = false);
    QString cpythonCheckFunction(const AbstractMetaType* type, bool genericNumberType = false);
    QString cpythonFunctionName(const AbstractMetaFunction* func);
    QString cpythonEnumName(const EnumTypeEntry* enumEntry);
    QString cpythonEnumName(const AbstractMetaEnum* metaEnum)
    {
        return cpythonEnumName(metaEnum->typeEntry());
    }

    QString getFunctionReturnType(const AbstractMetaFunction* func) const;
    QString getFormatUnitString(const AbstractMetaArgumentList arguments) const;

    virtual bool prepareGeneration(const QMap<QString, QString>& args)
    {
        return true;
    }

protected:
    bool m_native_jump_table;
    static QHash<QString, QString> m_pythonPrimitiveTypeName;
    static QHash<QString, QString> m_pythonOperators;
    static QHash<QString, QString> m_formatUnits;

    const char* name() const { return "Shiboken"; }

    /**
     *   Initialize correspondences between primitive and Python types
     */
    static void initPrimitiveTypesCorrespondences();

    static QString retvalVariableName() { return QString("cpp_result"); }

    static FunctionModificationList functionModifications(const AbstractMetaFunction* func);
    AbstractMetaFunctionList queryFunctions(const AbstractMetaClass* metaClass, bool allFunction = false);
    void writeFunctionCall(QTextStream& s,
                           const AbstractMetaFunction* metaFunc,
                           uint options = 0) const;

    AbstractMetaFunctionList filterFunctions(const AbstractMetaClass* metaClass);
    AbstractMetaFunctionList queryGlobalOperators(const AbstractMetaClass* metaClass);
    AbstractMetaFunctionList sortContructor(AbstractMetaFunctionList list);
};


#endif // SHIBOKENGENERATOR_H