/* Declare all local variables used by the wrapper method */
void vtkWrapPython_DeclareVariables(
FILE *fp, ClassInfo *data, FunctionInfo *theFunc)
{
ValueInfo *arg;
int i, n;
n = vtkWrap_CountWrappedParameters(theFunc);
/* temp variables for arg values */
for (i = 0; i < n; i++)
{
arg = theFunc->Parameters[i];
/* a callable python object for function args */
if (vtkWrap_IsFunction(arg))
{
fprintf(fp,
" PyObject *temp%d = NULL;\n",
i);
/* ignore further arguments */
break;
}
/* a PyObject argument will simply be passed through */
if (vtkWrap_IsPythonObject(arg))
{
fprintf(fp,
" PyObject *temp%d;\n",
i);
continue;
}
/* temps for arrays */
if (vtkWrap_IsArray(arg) || vtkWrap_IsNArray(arg) ||
vtkWrap_IsPODPointer(arg))
{
/* for non-const arrays, alloc twice as much space */
const char *mtwo = "";
if (!vtkWrap_IsConst(arg) && !vtkWrap_IsSetVectorMethod(theFunc))
{
mtwo = "2*";
}
if (arg->CountHint || vtkWrap_IsPODPointer(arg))
{
/* prepare for "T *" arg, where T is a plain type */
fprintf(fp,
" int size%d = ap.GetArgSize(%d);\n"
" vtkPythonArgs::Array<%s> store%d(%ssize%d);\n"
" %s *temp%d = store%d.Data();\n",
i, i,
vtkWrap_GetTypeName(arg), i, mtwo, i,
vtkWrap_GetTypeName(arg), i, i);
if (!vtkWrap_IsConst(arg))
{
fprintf(fp,
" %s *save%d = (size%d == 0 ? NULL : temp%d + size%d);\n",
vtkWrap_GetTypeName(arg), i, i, i, i);
}
}
else if (vtkWrap_IsArray(arg) && arg->Value)
{
/* prepare for "T a[n] = NULL" arg (array whose default is NULL) */
fprintf(fp,
" int size%d = 0;\n"
" %s store%d[%s%d];\n"
" %s *temp%d = NULL;\n",
i,
vtkWrap_GetTypeName(arg), i, mtwo, arg->Count,
vtkWrap_GetTypeName(arg), i);
if (!vtkWrap_IsConst(arg))
{
fprintf(fp,
" %s *save%d = NULL;\n",
vtkWrap_GetTypeName(arg), i);
}
fprintf(fp,
" if (ap.GetArgSize(%d) > 0)\n"
" {\n"
" size%d = %d;\n"
" temp%d = store%d;\n",
i,
i, arg->Count,
i, i);
if (!vtkWrap_IsConst(arg))
{
fprintf(fp,
" save%d = store%d + %d;\n",
i, i, arg->Count);
}
fprintf(fp,
" }\n");
}
else
{
/* prepare for "T a[n]" or "T a[n][m]" array arg */
vtkWrap_DeclareVariableSize(fp, arg, "size", i);
vtkWrap_DeclareVariable(fp, data, arg, "temp", i, VTK_WRAP_ARG);
if (!vtkWrap_IsConst(arg) &&
!vtkWrap_IsSetVectorMethod(theFunc))
{
/* for saving a copy of the array */
vtkWrap_DeclareVariable(fp, data, arg, "save", i, VTK_WRAP_ARG);
}
}
}
else
{
/* make a "temp" variable for any other kind of argument */
vtkWrap_DeclareVariable(fp, data, arg, "temp", i, VTK_WRAP_ARG);
}
/* temps for buffer objects */
if (vtkWrap_IsVoidPointer(arg))
{
fprintf(fp,
" Py_buffer pbuf%d = VTK_PYBUFFER_INITIALIZER;\n",
i);
}
/* temps for conversion constructed objects, which only occur
* for special objects */
if (vtkWrap_IsSpecialObject(arg) &&
!vtkWrap_IsNonConstRef(arg))
{
fprintf(fp,
" PyObject *pobj%d = NULL;\n",
i);
}
}
if (theFunc->ReturnValue)
{
/* the size for a one-dimensional array */
if (vtkWrap_IsArray(theFunc->ReturnValue) &&
!theFunc->ReturnValue->CountHint)
{
fprintf(fp,
" int sizer = %d;\n",
theFunc->ReturnValue->Count);
}
}
/* temp variable for the Python return value */
fprintf(fp,
" PyObject *result = NULL;\n"
"\n");
}
/* generate the code that calls the C++ method */
static void vtkWrapPython_GenerateMethodCall(
FILE *fp, FunctionInfo *currentFunction, ClassInfo *data,
HierarchyInfo *hinfo, int is_vtkobject)
{
char methodname[256];
ValueInfo *arg;
int totalArgs;
int is_constructor;
int i, k, n;
totalArgs = vtkWrap_CountWrappedParameters(currentFunction);
is_constructor = vtkWrap_IsConstructor(data, currentFunction);
/* for vtkobjects, do a bound call and an unbound call */
n = 1;
if (is_vtkobject &&
!currentFunction->IsStatic &&
!currentFunction->IsPureVirtual &&
!is_constructor)
{
n = 2;
}
if (!is_constructor &&
!vtkWrap_IsVoid(currentFunction->ReturnValue))
{
/* temp variable for C++-type return value */
fprintf(fp, " ");
vtkWrap_DeclareVariable(fp, data, currentFunction->ReturnValue,
"tempr", -1, VTK_WRAP_RETURN | VTK_WRAP_NOSEMI);
fprintf(fp, " =");
}
/* handle both bound and unbound calls */
if (n == 2)
{
if (!is_constructor &&
!vtkWrap_IsVoid(currentFunction->ReturnValue))
{
fprintf(fp, " (ap.IsBound() ?\n"
" ");
}
else
{
fprintf(fp,
" if (ap.IsBound())\n"
" {\n"
" ");
}
}
/* print the code that calls the method */
for (k = 0; k < n; k++)
{
if (k == 1)
{
/* unbound method call */
sprintf(methodname, "op->%s::%s",
data->Name, currentFunction->Name);
}
else if (currentFunction->IsStatic)
{
/* static method call */
sprintf(methodname, "%s::%s",
data->Name, currentFunction->Name);
}
else if (is_constructor)
{
/* constructor call */
sprintf(methodname, "new %s", currentFunction->Name);
}
else
{
/* standard bound method call */
sprintf(methodname, "op->%s", currentFunction->Name);
}
if (is_constructor)
{
fprintf(fp,
" %s *op = new %s(",
data->Name, data->Name);
}
else if (vtkWrap_IsVoid(currentFunction->ReturnValue))
{
fprintf(fp,
" %s(",
methodname);
}
else if (vtkWrap_IsRef(currentFunction->ReturnValue))
{
fprintf(fp,
" &%s(",
methodname);
}
else
{
fprintf(fp,
" %s(",
methodname);
}
/* print all the arguments in the call */
for (i = 0; i < totalArgs; i++)
{
arg = currentFunction->Parameters[i];
if (vtkWrap_IsFunction(arg))
{
fprintf(fp,"\n"
" (temp%d == Py_None ? NULL : vtkPythonVoidFunc),\n"
" (temp%d == Py_None ? NULL : temp%d));\n",
i, i, i);
fprintf(fp,
" if (temp%d != Py_None)\n"
" {\n"
" Py_INCREF(temp%d);\n"
" }\n"
" %sArgDelete(\n"
" (temp%d == Py_None ? NULL : vtkPythonVoidFuncArgDelete)",
i, i, methodname, i);
break;
}
if (i)
{
fprintf(fp,", ");
}
if ((vtkWrap_IsSpecialObject(arg) ||
vtkWrap_IsQtObject(arg)) &&
!vtkWrap_IsPointer(arg))
{
fprintf(fp, "*temp%i", i);
}
else
{
fprintf(fp, "temp%i", i);
}
}
fprintf(fp, ")");
/* handle ternary operator for ap.IsBound() */
if (n == 2)
{
if (!is_constructor &&
!vtkWrap_IsVoid(currentFunction->ReturnValue))
{
fprintf(fp, (k == 0 ? " :\n " : ");\n"));
}
else if (k == 0)
{
fprintf(fp, ";\n"
" }\n"
" else\n"
" {\n"
" ");
}
else
{
fprintf(fp, ";\n"
" }\n");
}
}
else
{
fprintf(fp, ";\n");
}
}
if (is_constructor)
{
/* initialize tuples created with default constructor */
if (currentFunction->NumberOfParameters == 0 && hinfo)
{
n = vtkWrap_GetTupleSize(data, hinfo);
for (i = 0; i < n; i++)
{
fprintf(fp,
" (*op)[%d] = 0;\n",
i);
}
}
}
fprintf(fp,
"\n");
}
/* Declare all local variables used by the wrapper method */
void vtkWrapPython_DeclareVariables(
FILE *fp, ClassInfo *data, FunctionInfo *theFunc)
{
ValueInfo *arg;
int i, n;
int storageSize;
n = vtkWrap_CountWrappedParameters(theFunc);
/* temp variables for arg values */
for (i = 0; i < n; i++)
{
arg = theFunc->Parameters[i];
if (vtkWrap_IsPythonObject(arg) ||
/* a callable python object for function args */
vtkWrap_IsFunction(arg))
{
fprintf(fp,
" PyObject *temp%d = NULL;\n",
i);
break;
}
/* make a "temp" variable for the argument */
vtkWrap_DeclareVariable(fp, data, arg, "temp", i, VTK_WRAP_ARG);
/* temps for buffer objects */
if (vtkWrap_IsVoidPointer(arg))
{
fprintf(fp,
" Py_buffer pbuf%d = VTK_PYBUFFER_INITIALIZER;\n",
i);
}
/* temps for conversion constructed objects, which only occur
* for special objects */
if (vtkWrap_IsSpecialObject(arg) &&
!vtkWrap_IsNonConstRef(arg))
{
fprintf(fp,
" PyObject *pobj%d = NULL;\n",
i);
}
/* temps for arrays */
if (vtkWrap_IsArray(arg) || vtkWrap_IsNArray(arg) ||
vtkWrap_IsPODPointer(arg))
{
storageSize = 4;
if (!vtkWrap_IsConst(arg) &&
!vtkWrap_IsSetVectorMethod(theFunc))
{
/* for saving a copy of the array */
vtkWrap_DeclareVariable(fp, data, arg, "save", i, VTK_WRAP_ARG);
storageSize *= 2;
}
if (arg->CountHint || vtkWrap_IsPODPointer(arg))
{
fprintf(fp,
" %s small%d[%d];\n",
vtkWrap_GetTypeName(arg), i, storageSize);
}
/* write an int array containing the dimensions */
vtkWrap_DeclareVariableSize(fp, arg, "size", i);
}
}
if (theFunc->ReturnValue)
{
/* the size for a one-dimensional array */
if (vtkWrap_IsArray(theFunc->ReturnValue) &&
!theFunc->ReturnValue->CountHint)
{
fprintf(fp,
" int sizer = %d;\n",
theFunc->ReturnValue->Count);
}
}
/* temp variable for the Python return value */
fprintf(fp,
" PyObject *result = NULL;\n"
"\n");
}
