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
214
215
216
217
218
|
/*
* This file is part of the Shiboken Python Bindings 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 <generatorrunner/generator.h>
#include <QtCore/QTextStream>
class DocParser;
/**
* Abstract generator that contains common methods used in CppGenerator and HeaderGenerator.
*/
class ShibokenGenerator : public Generator
{
public:
ShibokenGenerator();
QString translateTypeForWrapperMethod(const AbstractMetaType* cType,
const AbstractMetaClass* context) 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,
Options options = NoOption) 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,
Options options = NoOption) const;
void writeArgumentNames(QTextStream &s,
const AbstractMetaFunction* func,
Options options = NoOption) 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,
Options options = NoOption) const;
QString functionReturnType(const AbstractMetaFunction* func, Options options = 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 a function's code snippets.
* \param func the function from which retrieve the code snippets
* \return a list containing the function code snippets
*/
CodeSnipList getCodeSnips(const AbstractMetaFunction* func);
/**
* Function which 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 = "",
Options options = NoOption,
int arg_count = -1) const;
QString signatureForDefaultVirtualMethod(const AbstractMetaFunction* func,
QString prepend = "",
QString append = "_default",
Options option = NoOption,
int arg_count = -1) const;
bool hasInjectedCodeOrSignatureModification(const AbstractMetaFunction* func);
QStringList getBaseClasses(const AbstractMetaClass* metaClass);
void writeBaseConversion(QTextStream& s, const AbstractMetaType* type,
const AbstractMetaClass* context);
/// Simpler version of writeBaseConversion, uses only the base name of the type.
void writeBaseConversion(QTextStream& s, const TypeEntry* type);
void writeToPythonConversion(QTextStream& s, const AbstractMetaType* type,
const AbstractMetaClass* context, QString argumentName = QString());
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);
static QString pythonOperatorFunctionName(const AbstractMetaFunction* func);
static QString pythonRichCompareOperatorId(QString cppOpFuncName);
static QString pythonRichCompareOperatorId(const AbstractMetaFunction* func);
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);
/// Checks if an argument type should be dereferenced by the Python method wrapper
/// before calling the C++ method.
static bool shouldDereferenceArgumentPointer(const AbstractMetaArgument* arg);
QString cpythonBaseName(const TypeEntry* type);
QString cpythonBaseName(const AbstractMetaType* type);
QString cpythonTypeName(const AbstractMetaClass* metaClass);
QString cpythonTypeName(const TypeEntry* type);
QString cpythonCheckFunction(const TypeEntry* type, bool genericNumberType = false, bool checkExact = false);
QString cpythonCheckFunction(const AbstractMetaType* metaType, bool genericNumberType = false, bool checkExact = false);
QString cpythonIsConvertibleFunction(const TypeEntry* type);
QString cpythonIsConvertibleFunction(const AbstractMetaType* metaType) {
return cpythonIsConvertibleFunction(metaType->typeEntry());
}
QString cpythonFunctionName(const AbstractMetaFunction* func);
QString cpythonWrapperCPtr(const AbstractMetaClass* metaClass, QString argName = "self");
QString cpythonWrapperCPtr(const AbstractMetaType* metaType, QString argName);
QString cpythonWrapperCPtr(const TypeEntry* type, QString argName);
QString cpythonEnumName(const EnumTypeEntry* enumEntry);
QString cpythonEnumName(const AbstractMetaEnum* metaEnum)
{
return cpythonEnumName(metaEnum->typeEntry());
}
QString cpythonFlagsName(const FlagsTypeEntry* flagsEntry);
QString cpythonFlagsName(const AbstractMetaEnum* metaEnum)
{
FlagsTypeEntry* flags = metaEnum->typeEntry()->flags();
if (!flags)
return QString();
return cpythonFlagsName(flags);
}
QString getFunctionReturnType(const AbstractMetaFunction* func, Options options = NoOption) const;
QString getFormatUnitString(const AbstractMetaFunction* func) const;
bool doSetup(const QMap<QString, QString>& args);
protected:
bool m_native_jump_table;
static QHash<QString, QString> m_pythonPrimitiveTypeName;
static QHash<QString, QString> m_pythonOperators;
static QHash<QString, QString> m_formatUnits;
static QHash<QString, QString> m_tpFuncs;
void clearTpFuncs();
const char* name() const { return "Shiboken"; }
/**
* Initialize correspondences between primitive and Python types
*/
static void initPrimitiveTypesCorrespondences();
static QString retvalVariableName() { return QString("py_result"); }
static FunctionModificationList functionModifications(const AbstractMetaFunction* func);
AbstractMetaFunctionList queryFunctions(const AbstractMetaClass* metaClass, bool allFunction = false);
void writeFunctionCall(QTextStream& s,
const AbstractMetaFunction* metaFunc,
Options options = NoOption) const;
AbstractMetaFunctionList filterFunctions(const AbstractMetaClass* metaClass);
AbstractMetaFunctionList queryGlobalOperators(const AbstractMetaClass* metaClass);
};
#endif // SHIBOKENGENERATOR_H
|
