return PyLong_FromSize_t(%in);
%out = %OUTTYPE(PyLong_AsSsize_t(%in));
static bool Check2TupleOfNumbers(PyObject* pyIn) {
if (!PySequence_Check(pyIn) || !(PySequence_Size(pyIn) == 2))
return false;
Shiboken::AutoDecRef pyReal(PySequence_GetItem(pyIn, 0));
if (!SbkNumber_Check(pyReal))
return false;
Shiboken::AutoDecRef pyImag(PySequence_GetItem(pyIn, 1));
if (!SbkNumber_Check(pyImag))
return false;
return true;
}
return PyComplex_FromDoubles(%in.real(), %in.imag());
double real = PyComplex_RealAsDouble(%in);
double imag = PyComplex_ImagAsDouble(%in);
%out = %OUTTYPE(real, imag);
Shiboken::AutoDecRef pyReal(PySequence_GetItem(%in, 0));
Shiboken::AutoDecRef pyImag(PySequence_GetItem(%in, 1));
double real = %CONVERTTOCPP[double](pyReal);
double imag = %CONVERTTOCPP[double](pyImag);
%out = %OUTTYPE(real, imag);
SBK_UNUSED(%in);
Py_RETURN_NONE;
%out = %OUTTYPE(%in == 0);
if (!%in)
Py_RETURN_NONE;
#ifdef IS_PY3K
return PyCapsule_New(%in, 0, 0);
#else
return PyCObject_FromVoidPtr(%in, 0);
#endif
%out = 0;
void* ptr;
#ifdef IS_PY3K
ptr = PyCapsule_GetPointer(%in, 0);
#else
ptr = PyCObject_AsVoidPtr(%in);
#endif
%out = (%OUTTYPE)ptr;
static bool checkPyCapsuleOrPyCObject(PyObject* pyObj)
{
#ifdef IS_PY3K
return PyCapsule_CheckExact(pyObj);
#else
return PyCObject_Check(pyObj);
#endif
}
#ifdef IS_PY3K
return PyCapsule_New(&%in, 0, 0);
#else
return PyCObject_FromVoidPtr(&%in, 0);
#endif
void* ptr;
#ifdef IS_PY3K
ptr = PyCapsule_GetPointer(%in, 0);
#else
ptr = PyCObject_AsVoidPtr(%in);
#endif
%out = *((%OUTTYPE*)ptr);
return PyBool_FromLong(%in.value());
// Tests CONVERTTOCPP macro with C++ primitive type.
bool b = %CONVERTTOCPP[bool](%in);
%out = %OUTTYPE(b);
// Tests CONVERTTOCPP macro with user's primitive type.
Complex cpx = %CONVERTTOCPP[Complex](%in);
%out = %OUTTYPE(cpx.real() != 0.0 || cpx.imag() != 0.0);
return Shiboken::String::fromCString(%in.cstring(), %in.size());
const char* str = %CONVERTTOCPP[const char*](%in);
%out = %OUTTYPE(str);
%out = %OUTTYPE();
%FUNCTION_NAME(&%1, %2);
%PYARG_0 = %CONVERTTOPYTHON[PStr](%1);
%FUNCTION_NAME(&%1);
%PYARG_0 = %CONVERTTOPYTHON[PStr](%1);
PyObject* %out = PyList_New((int) %in.size());
PStrList::const_iterator it = %in.begin();
for (int idx = 0; it != %in.end(); ++it, ++idx) {
PStr cppItem(*it);
PyList_SET_ITEM(%out, idx, %CONVERTTOPYTHON[PStr](cppItem));
}
return %out;
%OUTTYPE& list = %out;
Shiboken::AutoDecRef seq(PySequence_Fast(%in, 0));
for (int i = 0; i < PySequence_Fast_GET_SIZE(seq.object()); i++) {
PyObject* pyItem = PySequence_Fast_GET_ITEM(seq.object(), i);
PStr cppItem = %CONVERTTOCPP[PStr](pyItem);
list.push_back(cppItem);
}
PStrList %0;
%0.push_back(%1);
%0.push_back(%2);
%PYARG_0 = %CONVERTTOPYTHON[PStrList](%0);
std::list<PStr> %0;
%0.push_back(%1);
%0.push_back(%2);
%PYARG_0 = %CONVERTTOPYTHON[std::list<PStr>](%0);
%PYARG_0 = (PyObject*) Shiboken::Conversions::getPythonTypeObject(%1);
if (!%PYARG_0)
%PYARG_0 = Py_None;
Py_INCREF(%PYARG_0);
SbkConverter* converter = Shiboken::Conversions::getConverter(%1);
if (converter) {
if (Shiboken::Conversions::pythonTypeIs$TYPEType(converter))
%PYARG_0 = Py_True;
else
%PYARG_0 = Py_False;
Py_INCREF(%PYARG_0);
} else {
PyErr_Format(PyExc_ValueError, "Type '%s' has no converter associated to it", %1);
}
Shiboken::Conversions::SpecificConverter converter(%1);
const char* %0 = 0;
switch (converter.conversionType()) {
case Shiboken::Conversions::SpecificConverter::CopyConversion:
%0 = "Copy conversion";
break;
case Shiboken::Conversions::SpecificConverter::PointerConversion:
%0 = "Pointer conversion";
break;
case Shiboken::Conversions::SpecificConverter::ReferenceConversion:
%0 = "Reference conversion";
break;
default:
%0 = "Invalid conversion";
}
%PYARG_0 = %CONVERTTOPYTHON[const char*](%0);
static PyObject* __convertCppValuesToPython(const char** typeName, void** values, int size)
{
PyObject* result = PyTuple_New(size);
for (int i = 0; i < size; ++i) {
Shiboken::Conversions::SpecificConverter converter(typeName[i]);
PyTuple_SET_ITEM(result, i, converter.toPython(values[i]));
}
return result;
}
const char* typeNames[] = { "Point", "Point*", "Point&" };
void* values[] = { &%1, &%2, &(%3) };
%PYARG_0 = __convertCppValuesToPython(typeNames, values, 3);
const char* typeNames[] = { "ObjectType*", "ObjectType&" };
void* values[] = { &%1, &(%2) };
%PYARG_0 = __convertCppValuesToPython(typeNames, values, 2);
const char* typeNames[] = { "std::list<int>" };
void* values[] = { &%1 };
%PYARG_0 = __convertCppValuesToPython(typeNames, values, 1);
const char* typeNames[] = { "int", "int" };
void* values[] = { &%1, &%2 };
%PYARG_0 = __convertCppValuesToPython(typeNames, values, 2);
PyObject* %out = PyTuple_New(2);
PyTuple_SET_ITEM(%out, 0, %CONVERTTOPYTHON[%INTYPE_0](%in.first));
PyTuple_SET_ITEM(%out, 1, %CONVERTTOPYTHON[%INTYPE_1](%in.second));
return %out;
%out.first = %CONVERTTOCPP[%OUTTYPE_0](PySequence_Fast_GET_ITEM(%in, 0));
%out.second = %CONVERTTOCPP[%OUTTYPE_1](PySequence_Fast_GET_ITEM(%in, 1));
PyObject* %out = PyList_New((int) %in.size());
%INTYPE::const_iterator it = %in.begin();
for (int idx = 0; it != %in.end(); ++it, ++idx) {
%INTYPE_0 cppItem(*it);
PyList_SET_ITEM(%out, idx, %CONVERTTOPYTHON[%INTYPE_0](cppItem));
}
return %out;
Shiboken::AutoDecRef seq(PySequence_Fast(%in, 0));
for (int i = 0; i < PySequence_Fast_GET_SIZE(seq.object()); i++) {
PyObject* pyItem = PySequence_Fast_GET_ITEM(seq.object(), i);
%OUTTYPE_0 cppItem = %CONVERTTOCPP[%OUTTYPE_0](pyItem);
%out.push_back(cppItem);
}
PyObject* %out = PyDict_New();
%INTYPE::const_iterator it = %in.begin();
for (; it != %in.end(); ++it) {
%INTYPE_0 key = it->first;
%INTYPE_1 value = it->second;
PyDict_SetItem(%out,
%CONVERTTOPYTHON[%INTYPE_0](key),
%CONVERTTOPYTHON[%INTYPE_1](value));
}
return %out;
PyObject* key;
PyObject* value;
Py_ssize_t pos = 0;
while (PyDict_Next(%in, &pos, &key, &value)) {
%OUTTYPE_0 cppKey = %CONVERTTOCPP[%OUTTYPE_0](key);
%OUTTYPE_1 cppValue = %CONVERTTOCPP[%OUTTYPE_1](value);
%out.insert(%OUTTYPE::value_type(cppKey, cppValue));
}
%RETURN_TYPE %0 = Shiboken::BindingManager::instance().getAllPyObjects().size();
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
const unsigned char* %out = reinterpret_cast<const unsigned char*>(Shiboken::String::toCString(%PYARG_1));
unsigned int %out = static_cast<unsigned int>(Shiboken::String::len(%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);
const char* tmpArg = %CONVERTTOCPP[const char*](%PYARG_1);
%0 = new %FUNCTION_NAME(atoi(tmpArg));
static void reparent_layout_items(PyObject* parent, PyObject* layout)
{
// CHECKTYPE and ISCONVERTIBLE are used here for test purposes, don't change them.
if (!%CHECKTYPE[ObjectTypeLayout*](layout) && !%ISCONVERTIBLE[ObjectTypeLayout*](layout))
return;
// %CHECKTYPE[ObjectTypeLayout*](layout)
// %ISCONVERTIBLE[ObjectTypeLayout*](layout)
ObjectTypeLayout* var;
var = %CONVERTTOCPP[ObjectTypeLayout*](layout);
// TODO-CONVERTER: erase this
/*
ObjectTypeLayout* var2 = %CONVERTTOCPP[ObjectTypeLayout*](layout);
*/
const ObjectTypeList& objChildren = var->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);
bool _status;
bool* %2 = &_status;
%PYARG_0 = PyTuple_New(2);
PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[bool](*%2));
PyTuple_SET_ITEM(%PYARG_0, 1, %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;
%BEGIN_ALLOW_THREADS
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(&tmpObject);
%END_ALLOW_THREADS
%PYARG_0 = PyTuple_New(2);
PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[ObjectType*](tmpObject));
%RETURN_TYPE %0 = !%CPPSELF.%FUNCTION_NAME(%1);
%PYARG_0 = %CONVERTTOPYTHON[OddBool](%0);
cppSelf->notifyGetAttroCalled();
cppSelf->notifySetAttroCalled();
%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 = PyTuple_New(4);
PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](a0));
PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](a1));
PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](a2));
PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[int](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);
bool ok_;
%RETURN_TYPE retval_ =
%FUNCTION_NAME(%1, %2, %3, %4, %5, %6, %7, %8, %9, %10, &ok_);
if (!ok_)
%PYARG_0 = Py_None;
else
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval_);
typedef std::list<int> Inner;
typedef std::list<Inner> Outer;
int result = 0;
Outer::const_iterator oiter, oend = %1.end();
for (oiter = %1.begin(); oiter != oend; ++oiter) {
const Inner& inner = *oiter;
Inner::const_iterator iiter, iend = inner.end();
for (iiter = inner.begin(); iiter != iend; ++iiter)
result += *iiter;
}
%PYARG_0 = %CONVERTTOPYTHON[int](result);
typedef std::pair<int, int> Pair;
typedef std::list<Pair> List;
int result = 0;
List::const_iterator iter, end = %1.end();
for (iter = %1.begin(); iter != end; ++iter)
result += iter->first * iter->second;
%PYARG_0 = %CONVERTTOPYTHON[int](result);
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) {
if (%CHECKTYPE[int](PySequence_Fast_GET_ITEM(%PYARG_1, i)))
%out[i] = %CONVERTTOCPP[int](PySequence_Fast_GET_ITEM(%PYARG_1, i));
else if (%ISCONVERTIBLE[int](PySequence_Fast_GET_ITEM(%PYARG_1, i)))
%out[i] = -1;
else
%out[i] = -2;
}
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 Shiboken::String::fromCString("Hi! I'm the inject code dummy class."); }
%PYTHONTYPEOBJECT.tp_str = InjectCode_tpstr;
%1 += 1;
PyObject* tmp = Shiboken::String::fromCString("end");
Shiboken::String::concat(&%PYARG_0, tmp);
Py_DECREF(tmp);
PyObject* tmp = Shiboken::String::fromCString("end");
Shiboken::String::concat(&%PYARG_0, tmp);
Py_DECREF(tmp);
int argc;
char** argv;
if (!Shiboken::listToArgcArgv(%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::listToArgcArgv(%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 Shiboken::String::fromCString("PyObject");
return Shiboken::String::fromCString("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 = Shiboken::String::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 = Shiboken::String::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 = Shiboken::String::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 = Shiboken::String::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()) &&
(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()) &&
(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 (!Shiboken::String::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 = Shiboken::String::fromCString(%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 Shiboken::String::fromCString(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;
%out = %OUTTYPE();
Py_ssize_t len;
const char* str = Shiboken::String::toCString(%in, &len);
%out = %OUTTYPE(str, len);
PyObject* data = 0;
if (PyUnicode_CheckExact(%PYARG_1)) {
data = PyUnicode_AsASCIIString(%PYARG_1);
} else {
data = %PYARG_1;
Py_INCREF(data);
}
%0 = new %TYPE(PyBytes_AsString(data), PyBytes_GET_SIZE(data));
Py_DECREF(data);
#if PY_VERSION_HEX < 0x03000000
Shiboken::SbkType<ByteArray>()->tp_as_buffer = &SbkByteArrayBufferProc;
Shiboken::SbkType<ByteArray>()->tp_flags |= Py_TPFLAGS_HAVE_GETCHARBUFFER;
#endif
%PYARG_0 = PyBytes_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size());
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
if (!data.isNull()) {
ByteArray ba(*%CPPSELF);
ba.append(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
%PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);
}
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
if (!data.isNull()) {
ByteArray ba(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
ba.append(*%CPPSELF);
%PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);
}
ByteArray ba(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1));
ba = ba + *%CPPSELF;
%PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);
ByteArray ba(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1));
ba.append(*%CPPSELF);
%PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);
ByteArray b(Py_TYPE(%PYSELF)->tp_name);
PyObject* aux = Shiboken::String::fromStringAndSize(%CPPSELF.data(), %CPPSELF.size());
if (PyUnicode_CheckExact(aux)) {
PyObject* tmp = PyUnicode_AsASCIIString(aux);
Py_DECREF(aux);
aux = tmp;
}
b += "('";
b += ByteArray(PyBytes_AS_STRING(aux), PyBytes_GET_SIZE(aux));
b += "')";
%PYARG_0 = Shiboken::String::fromStringAndSize(b.data(), b.size());
%PYARG_0 = Shiboken::String::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 PyBytes_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);
}
%PYARG_0 = Shiboken::String::fromCString(%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 = Shiboken::String::fromCString("");
for (unsigned int i = 0; i < %2; ++i)
Shiboken::String::concat(&%PYARG_0, %PYARG_1);
%RETURN_TYPE %0 = PyTuple_GET_SIZE(%PYARG_2);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
static bool PyDate_ImportAndCheck(PyObject* pyIn) {
if (!PyDateTimeAPI)
PyDateTime_IMPORT;
return PyDate_Check(pyIn);
}
int day = PyDateTime_GET_DAY(%in);
int month = PyDateTime_GET_MONTH(%in);
int year = PyDateTime_GET_YEAR(%in);
%out = %OUTTYPE(day, month, year);
if (!PyDateTimeAPI)
PyDateTime_IMPORT;
%PYARG_0 = PyDate_FromDate(%CPPSELF.day(), %CPPSELF.month(), %CPPSELF.year());
%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);