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
|
/*
* 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 CPPGENERATOR_H
#define CPPGENERATOR_H
#include "shibokengenerator.h"
#include "overloaddata.h"
/**
* The CppGenerator generate the implementations of C++ bindings classes.
*/
class CppGenerator : public ShibokenGenerator
{
public:
CppGenerator();
protected:
QString fileNameForClass(const AbstractMetaClass* metaClass) const;
QList<AbstractMetaFunctionList> filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
uint query);
void generateClass(QTextStream& s, const AbstractMetaClass* metaClass);
void finishGeneration();
private:
void writeConstructorNative(QTextStream& s, const AbstractMetaFunction* func);
void writeDestructorNative(QTextStream& s, const AbstractMetaClass* metaClass);
void writeVirtualMethodNative(QTextStream& s, const AbstractMetaFunction* func);
void writeConstructorWrapper(QTextStream &s, const AbstractMetaFunctionList overloads);
void writeDestructorWrapper(QTextStream& s, const AbstractMetaClass* metaClass);
void writeMinimalConstructorCallArguments(QTextStream& s, const AbstractMetaClass* metaClass);
void writeMinimalConstructorCallArguments(QTextStream& s, const AbstractMetaType* type);
void writeMethodWrapper(QTextStream &s, const AbstractMetaFunctionList overloads);
void writeArgumentsInitializer(QTextStream& s, OverloadData& overloadData);
void writeErrorSection(QTextStream& s, OverloadData& overloadData);
/// Writes the check section for the validity of wrapped C++ objects.
void writeInvalidCppObjectCheck(QTextStream& s);
void writeTypeCheck(QTextStream& s, const OverloadData* overloadData, QString argumentName);
void writeTypeConverterImpl(QTextStream& s, const TypeEntry* type);
/**
* Writes Python to C++ conversions for arguments on Python wrappers.
* If implicit conversions, and thus new object allocation, are needed,
* code to deallocate a possible new instance is also generated.
* \param s text stream to write
* \param metatype a pointer to the argument type to be converted
* \param context the current meta class
* \param argName C++ argument name
* \param argName Python argument name
*/
void writeArgumentConversion(QTextStream& s, const AbstractMetaType* argType,
QString argName, QString pyArgName,
const AbstractMetaClass* context = 0);
/// Convenience method to call writeArgumentConversion with an AbstractMetaArgument
/// instead of an AbstractMetaType.
void writeArgumentConversion(QTextStream& s, const AbstractMetaArgument* arg,
QString argName, QString pyArgName,
const AbstractMetaClass* context = 0)
{
writeArgumentConversion(s, arg->type(), argName, pyArgName, context);
}
void writeOverloadedMethodDecisor(QTextStream& s, OverloadData* parentOverloadData);
void writeMethodCall(QTextStream& s, const AbstractMetaFunction* func, int maxArgs = 0);
void writeClassRegister(QTextStream& s, const AbstractMetaClass* metaClass);
void writeClassDefinition(QTextStream& s, const AbstractMetaClass* metaClass);
void writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList overloads);
/// Writes the implementation of all methods part of python sequence protocol
void writeSequenceMethods(QTextStream& s, const AbstractMetaClass* metaClass);
/// Writes the struct PySequenceMethods for types thats supports the python sequence protocol
void writeTypeAsSequenceDefinition(QTextStream& s, const AbstractMetaClass* metaClass);
void writeTypeAsNumberDefinition(QTextStream& s, const AbstractMetaClass* metaClass);
void writeRichCompareFunction(QTextStream& s, const AbstractMetaClass* metaClass);
void writeFlagsNewMethod(QTextStream& s, const FlagsTypeEntry* cppFlags);
void writeEnumDefinition(QTextStream& s, const AbstractMetaEnum* metaEnum);
void writeEnumInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum);
void writeFlagsDefinition(QTextStream& s, const AbstractMetaEnum* cppEnum);
void writeFlagsMethods(QTextStream& s, const AbstractMetaEnum* cppEnum);
void writeFlagsNumberMethodsDefinition(QTextStream& s, const AbstractMetaEnum* cppEnum);
void writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
QString pyOpName, QString cppOpName);
void writeFlagsInplaceOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
QString pyOpName, QString cppOpName);
void writeFlagsUnaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
QString pyOpName, QString cppOpName, bool boolResult = false);
/// Writes the function that registers the multiple inheritance information for the classes that need it.
void writeMultipleInheritanceInitializerFunction(QTextStream& s, const AbstractMetaClass* metaClass);
/**
* Returns the multiple inheritance initializer function for the given class.
* \param metaClass the class for whom the function name must be generated.
* \return name of the multiple inheritance information initializer function or
* an empty string if there is no multiple inheritance in its ancestry.
*/
QString multipleInheritanceInitializerFunctionName(const AbstractMetaClass* metaClass);
/// Returns true if the given class supports the python sequence protocol
bool supportsSequenceProtocol(const AbstractMetaClass* metaClass);
// Maps special function names to function parameters and return types
// used by CPython API in the sequence protocol.
QHash<QString, QPair<QString, QString> > m_sequenceProtocol;
};
#endif // CPPGENERATOR_H
|
