%RETURN_TYPE %0 = Shiboken::BindingManager::instance().getAllPyObjects().size();
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
unsigned char* %out = reinterpret_cast<unsigned char*>(PyString_AS_STRING(%PYARG_1));
unsigned int %out = static_cast<unsigned int>(PyString_GET_SIZE(%PYARG_1));
%RETURN_TYPE %0 = %1 + %2;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%RETURN_TYPE %0 = %1.x() + %1.y();
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
// The dot in "%1." must be replaced with a "->" by the generator.
double %0 = %1.objectName().size();
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%0 = new %FUNCTION_NAME(atoi(%CONVERTTOCPP[const char*](%PYARG_1)));
static void reparent_layout_items(PyObject* parent, PyObject* layout)
{
const ObjectTypeList& objChildren = %CONVERTTOCPP[ObjectTypeLayout*](layout)->objects();
ObjectTypeList::const_iterator it = objChildren.begin();
for (; it != objChildren.end(); ++it) {
if ((*it)->isLayoutType()) {
ObjectTypeLayout* l = reinterpret_cast<ObjectTypeLayout*>(*it);
reparent_layout_items(parent, %CONVERTTOPYTHON[ObjectTypeLayout*](l));
Shiboken::Object::setParent(layout, %CONVERTTOPYTHON[ObjectTypeLayout*](l));
} else {
Shiboken::Object::setParent(parent, %CONVERTTOPYTHON[ObjectType*](*it));
}
}
}
if (%PYARG_1 != Py_None)
reparent_layout_items(%PYSELF, %PYARG_1);
%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, %2) * 10;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%PYARG_1);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
bool __ok__;
%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%ARGUMENT_NAMES, &__ok__);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
bool __ok__;
%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(&__ok__, %ARGUMENT_NAMES);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
bool __ok__;
%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(&__ok__, %2);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
PyObject* _tuple_ = PyTuple_New(2);
PyTuple_SET_ITEM(_tuple_, 0, %PYARG_0);
PyObject* _item_ = %CONVERTTOPYTHON[bool](__ok__);
PyTuple_SET_ITEM(_tuple_, 1, _item_);
%PYARG_0 = _tuple_;
%PYARG_0 = PyTuple_New(4);
PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG2_TYPE](%2));
PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[%ARG3_TYPE](%3));
PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[%ARG4_TYPE](%4));
%PYARG_0 = PyTuple_New(5);
PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG2_TYPE](%2));
PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[%ARG3_TYPE](%3));
PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[%ARG4_TYPE](%4));
PyTuple_SET_ITEM(%PYARG_0, 4, %CONVERTTOPYTHON[%ARG5_TYPE](%5));
%PYARG_0 = Py_None;
Py_INCREF(Py_None);
%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, true, %3, %4);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
int %out = PySequence_Size(%PYARG_1);
Shiboken::AutoArrayPointer<Point> %out(%1);
for (int i = 0; i < %1; ++i)
%out[i] = %CONVERTTOCPP[Point](PySequence_Fast_GET_ITEM(%PYARG_1, i));
int size = (%2 < 0) ? %1.size() : %2;
%BEGIN_ALLOW_THREADS
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME((const void*) %1.data(), size);
%END_ALLOW_THREADS
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
ObjectType* tmpObject = 0;
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(&tmpObject);
%PYARG_0 = Shiboken::makeTuple(%0, tmpObject);
%RETURN_TYPE %0 = !%CPPSELF.%FUNCTION_NAME(%1);
%PYARG_0 = %CONVERTTOPYTHON[OddBool](%0);
%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, %1+%3, %3);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
PyObject* new_arg0 = PyInt_FromLong(PyInt_AS_LONG(%PYARG_1) - %2);
Py_DECREF(%PYARG_1);
%PYARG_1 = new_arg0;
%0.prepend(Str("Pimped"));
PyObject_Call(%PYTHON_METHOD_OVERRIDE, %PYTHON_ARGUMENTS, NULL);
Shiboken::AutoDecRef _py_ok_(PySequence_GetItem(%PYARG_0, 0));
Shiboken::AutoDecRef _py_ret_(PySequence_GetItem(%PYARG_0, 1));
%RETURN_TYPE %out = %CONVERTTOCPP[%RETURN_TYPE](_py_ok_);
%2 = %CONVERTTOCPP[Str*](_py_ret_);
Str* _str_arg_ = 0;
%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, _str_arg_);
%PYARG_0 = PyTuple_New(2);
PyObject* _item_ = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
PyTuple_SET_ITEM(%PYARG_0, 0, _item_);
_item_ = %CONVERTTOPYTHON[Str*](_str_arg_);
PyTuple_SET_ITEM(%PYARG_0, 1, _item_);
Str* _str_arg_ = 0;
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, _str_arg_);
%PYARG_0 = PyTuple_New(2);
PyObject* _item_ = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
PyTuple_SET_ITEM(%PYARG_0, 0, _item_);
_item_ = %CONVERTTOPYTHON[Str*](_str_arg_);
PyTuple_SET_ITEM(%PYARG_0, 1, _item_);
int a0, a1, a2, a3;
%BEGIN_ALLOW_THREADS
%CPPSELF->::%TYPE::%FUNCTION_NAME(&a0, &a1, &a2, &a3);
%END_ALLOW_THREADS
%PYARG_0 = Shiboken::makeTuple(a0, a1, a2, a3);
PyObject* _obj = %PYARG_0.object();
if (!PySequence_Check(_obj)
|| PySequence_Fast_GET_SIZE(_obj) != 4
|| !SbkNumber_Check(PySequence_Fast_GET_ITEM(_obj, 0))
|| !SbkNumber_Check(PySequence_Fast_GET_ITEM(_obj, 1))
|| !SbkNumber_Check(PySequence_Fast_GET_ITEM(_obj, 2))
|| !SbkNumber_Check(PySequence_Fast_GET_ITEM(_obj, 3))) {
PyErr_SetString(PyExc_TypeError, "Sequence of 4 numbers expected");
} else {
*%1 = %CONVERTTOCPP[int](PySequence_Fast_GET_ITEM(_obj, 0));
*%2 = %CONVERTTOCPP[int](PySequence_Fast_GET_ITEM(_obj, 1));
*%3 = %CONVERTTOCPP[int](PySequence_Fast_GET_ITEM(_obj, 2));
*%4 = %CONVERTTOCPP[int](PySequence_Fast_GET_ITEM(_obj, 3));
}
%BEGIN_ALLOW_THREADS
// It's important for test purposes to use a constructor with parenthesis as argument.
%RETURN_TYPE %0 = %RETURN_TYPE(%CPPSELF.%FUNCTION_NAME(Str(%1)));
%END_ALLOW_THREADS
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%0 = new %TYPE(%PYARG_1);
%PYARG_0 = reinterpret_cast<PyObject*>(%CPPSELF.%FUNCTION_NAME());
if (!%PYARG_0)
%PYARG_0 = Py_None;
Py_INCREF(%PYARG_0);
int* array = NULL;
bool errorOccurred = false;
if (PySequence_Check(%PYARG_1)) {
if((array = Shiboken::sequenceToIntArray(%PYARG_1, true)) == NULL && PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "Should be a sequence of ints");
errorOccurred = true;
}
} else {
PyErr_SetString(PyExc_TypeError, "Should be a sequence of ints");
errorOccurred = true;
}
if (!errorOccurred) {
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(array);
if (array)
delete[] array;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
}
int %out = PySequence_Size(%PYARG_1);
int numItems = PySequence_Size(%PYARG_1);
Shiboken::AutoArrayPointer<int> %out(numItems);
for (int i = 0; i < numItems; ++i)
%out[i] = %CONVERTTOCPP[int](PySequence_Fast_GET_ITEM(%PYARG_1, i));
PyObject* %out = PyList_New(count);
for (int i = 0; i < count; ++i)
PyList_SET_ITEM(%out, i, %CONVERTTOPYTHON[int](%in[i]));
int numItems = PySequence_Size(%PYARG_1);
int *cppItems = new int[numItems];
for (int i = 0; i < numItems; i++)
cppItems[i] = %CONVERTTOCPP[int](PySequence_GetItem(%PYARG_1, i));
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(numItems, cppItems);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
delete[] cppItems;
PyObject* InjectCode_tpstr(PyObject*) { return PyString_FromString("Hi! I'm the inject code dummy class."); }
%PYTHONTYPEOBJECT.tp_str = InjectCode_tpstr;
%1 += 1;
PyObject* tmp = PyString_FromString("end");
PyString_Concat(&%PYARG_0, tmp);
Py_DECREF(tmp);
PyObject* tmp = PyString_FromString("end");
PyString_Concat(&%PYARG_0, tmp);
Py_DECREF(tmp);
int argc;
char** argv;
if (!Shiboken::sequenceToArgcArgv(%PYARG_1, &argc, &argv)) {
PyErr_SetString(PyExc_TypeError, "error");
return 0;
}
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(argc, argv);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
for (int i = 0; i < argc; ++i)
free(argv[i]);
delete[] argv;
int argc;
char** argv;
if (!Shiboken::sequenceToArgcArgv(%PYARG_1, &argc, &argv)) {
PyErr_SetString(PyExc_TypeError, "error");
return 0;
}
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(argc, argv);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
for (int i = 0; i < argc; ++i)
free(argv[i]);
delete[] argv;
return PyString_FromString("PyObject");
return PyString_FromString("PyObject");
unsigned char* %out = 0;
int x1 = (int) %CPPSELF.x();
int x2 = ((int) (%CPPSELF.x() * 100)) - (x1 * 100);
int y1 = (int) %CPPSELF.y();
int y2 = ((int) (%CPPSELF.y() * 100)) - (y1 * 100);
%PYARG_0 = PyString_FromFormat("Point(%d.%d, %d.%d)", x1, x2, y1, y2);
int x1 = (int) %CPPSELF.x();
int x2 = ((int) (%CPPSELF.x() * 10)) - (x1 * 10);
int y1 = (int) %CPPSELF.y();
int y2 = ((int) (%CPPSELF.y() * 10)) - (y1 * 10);
%PYARG_0 = PyString_FromFormat("<Point object at %p: (%d.%d, %d.%d)>", %CPPSELF, x1, x2, y1, y2);
PyObject* type = PyObject_Type(%PYSELF);
PyObject* args = NULL;
args = Py_BuildValue("(dd)", %CPPSELF.x(), %CPPSELF.y());
%PYARG_0 = Py_BuildValue("(OO)", type, args);
Point _midpoint;
// The test consists in *NOT* using the ARGUMENT_NAMES type system variable.
%CPPSELF.%FUNCTION_NAME(%1, &_midpoint);
%PYARG_0 = %CONVERTTOPYTHON[Point](_midpoint);
%PYARG_0 = %PYARG_1;
Py_INCREF(%PYARG_1);
int x1 = (int) %CPPSELF.x();
int x2 = ((int) (%CPPSELF.x() * 100)) - (x1 * 100);
int y1 = (int) %CPPSELF.y();
int y2 = ((int) (%CPPSELF.y() * 100)) - (y1 * 100);
%PYARG_0 = PyString_FromFormat("PointF(%d.%d, %d.%d)", x1, x2, y1, y2);
int x1 = (int) %CPPSELF.x();
int x2 = ((int) (%CPPSELF.x() * 10)) - (x1 * 10);
int y1 = (int) %CPPSELF.y();
int y2 = ((int) (%CPPSELF.y() * 10)) - (y1 * 10);
%PYARG_0 = PyString_FromFormat("<PointF object at %p: (%d.%d, %d.%d)>", %CPPSELF, x1, x2, y1, y2);
PyObject *type = PyObject_Type(%PYSELF);
PyObject *args = NULL;
args = Py_BuildValue("(dd)", %CPPSELF.x(), %CPPSELF.y());
%PYARG_0 = Py_BuildValue("(OO)", type, args);
PointF _midpoint;
// The test consists in using the ARGUMENT_NAMES type system variable.
%CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &_midpoint);
%PYARG_0 = %CONVERTTOPYTHON[PointF](_midpoint);
if (!PyDateTimeAPI)
PyDateTime_IMPORT;
if (PyTime_Check(%1)) {
int pyH = PyDateTime_TIME_GET_HOUR(%1);
int pyM = PyDateTime_TIME_GET_MINUTE(%1);
int pyS = PyDateTime_TIME_GET_SECOND(%1);
if ((pyH == %CPPSELF.hour()) &&l;
(pyM == %CPPSELF.minute()) &&
(pyS == %CPPSELF.second()))
%PYARG_0 = Py_False;
else
%PYARG_0 = Py_True;
}
if (!PyDateTimeAPI)
PyDateTime_IMPORT;
if (PyTime_Check(%1)) {
int pyH = PyDateTime_TIME_GET_HOUR(%1);
int pyM = PyDateTime_TIME_GET_MINUTE(%1);
int pyS = PyDateTime_TIME_GET_SECOND(%1);
if ((pyH == %CPPSELF.hour()) &&l;
(pyM == %CPPSELF.minute()) &&
(pyS == %CPPSELF.second()))
%PYARG_0 = Py_True;
else
%PYARG_0 = Py_False;
}
%0 = new %TYPE();
Shiboken::AutoDecRef result(PyObject_CallMethod(%PYSELF, const_cast<char*>("setHeight"), const_cast<char*>("i"), 2));
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, 2, %3);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
{
Shiboken::AutoDecRef strList(PySequence_Fast(%PYARG_1, "The argument must be a sequence."));
int lineCount = PySequence_Fast_GET_SIZE(strList.object());
for (int line = 0; line < lineCount; ++line) {
if (!PyString_Check(PySequence_Fast_GET_ITEM(strList.object(), line))) {
PyErr_SetString(PyExc_TypeError, "The argument must be a sequence of strings.");
break;
}
}
}
const char** %out = 0;
void* %out = 0;
unsigned char* %out = (unsigned char*) Shiboken::Buffer::getPointer(%PYARG_1);
%BEGIN_ALLOW_THREADS
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(argOut, %2);
%END_ALLOW_THREADS
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%PYARG_0 = PyString_FromString(%CPPSELF.cstring());
return %CPPSELF.size();
if (_i < 0 || _i >= %CPPSELF.size()) {
PyErr_BadArgument();
return 0;
} else {
char res[2];
res[0] = %CPPSELF.get_char(_i);
res[1] = 0;
return PyString_FromString(res);
}
PyObject* args = Py_BuildValue("(iO)", _i, _value);
PyObject* result = Sbk_StrFunc_set_char(self, args);
Py_DECREF(args);
int ok = result == Py_True;
if (result) {
Py_DECREF(result);
}
return !ok ? -1 : 0;
%0 = new %TYPE(PyString_AS_STRING(%PYARG_1), PyString_GET_SIZE(%PYARG_1));
#if PY_VERSION_HEX < 0x03000000
Shiboken::SbkType<ByteArray>()->tp_as_buffer = &SbkByteArrayBufferProc;
Shiboken::SbkType<ByteArray>()->tp_flags |= Py_TPFLAGS_HAVE_GETCHARBUFFER;
#endif
%PYARG_0 = PyString_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size());
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
if (!data.isNull()) {
ByteArray ba(*%CPPSELF);
ba.append(PyString_AS_STRING(data.object()), PyString_GET_SIZE(data.object()));
%PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);
}
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
if (!data.isNull()) {
ByteArray ba(PyString_AS_STRING(data.object()), PyString_GET_SIZE(data.object()));
ba.append(*%CPPSELF);
%PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);
}
ByteArray ba(PyString_AS_STRING(%PYARG_1), PyString_GET_SIZE(%PYARG_1));
ba = ba + *%CPPSELF;
%PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);
ByteArray ba(((PyObject*)%PYSELF)->ob_type->tp_name);
ba += '(';
Shiboken::AutoDecRef contents(PyObject_Repr(PyString_FromStringAndSize(%CPPSELF.data(), %CPPSELF.size())));
ba += PyString_AS_STRING(contents.object());
ba += ")";
%PYARG_0 = PyString_FromStringAndSize(ba.data(), ba.size());
%PYARG_0 = PyString_FromStringAndSize(%CPPSELF.data(), %CPPSELF.size());
return %CPPSELF.size();
if (_i < 0 || _i >= %CPPSELF.size()) {
PyErr_SetString(PyExc_IndexError, "index out of bounds");
return 0;
} else {
char res[2];
res[0] = %CPPSELF.at(_i);
res[1] = 0;
return PyString_FromStringAndSize(res, 1);
}
return %CPPSELF.size();
if (_i < 0 || _i >= static_cast<Py_ssize_t>(%CPPSELF.size())) {
PyErr_BadArgument();
return 0;
} else {
%TYPE::const_iterator it = %CPPSELF.begin();
for (Py_ssize_t i = 1; i <= _i; i++)
++it;
return %CONVERTTOPYTHON[Str](*it);
}
%RETURN_TYPE %0 = %TYPE::%FUNCTION_NAME();
%PYARG_0 = Shiboken::Object::newObject(&SbkObject_Type, %0, false, false);
%PYARG_0 = PyString_FromString(%1);
// This should test if code injections works inside rich comparison operators
Py_INCREF(Py_True);
%PYARG_0 = Py_True;
// Does nothing really, just test the code generation
// of constructors whose arguments where
long %out = PyInt_AS_LONG(%PYARG_1) + 1;
%PYARG_0 = PyString_FromString("");
for (unsigned int i = 0; i < %2; ++i)
PyString_Concat(&%PYARG_0, %PYARG_1);
%RETURN_TYPE %0 = PyTuple_GET_SIZE(%PYARG_2);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%RETURN_TYPE %0 = %CPPSELF.key() != %1;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%RETURN_TYPE %0 = *%CPPSELF & %1;
return %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%RETURN_TYPE %0 = *%CPPSELF & %1;
return %CONVERTTOPYTHON[%RETURN_TYPE](%0);