%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. %RETURN_TYPE %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);

%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);

Shiboken::AutoDecRef _py_ok_(PySequence_GetItem(%PYARG_0, 0)); Shiboken::AutoDecRef _py_ret_(PySequence_GetItem(%PYARG_0, 1)); *%2 = %CONVERTTOCPP[bool](_py_ok_); %RETURN_TYPE %out = %CONVERTTOCPP[%RETURN_TYPE](_py_ret_);

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_);

%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);

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");

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);

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; }

%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;

%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);