int vtkWrap_IsVoidPointer(ValueInfo *val)
{
unsigned int t = (val->Type & VTK_PARSE_BASE_TYPE);
return (t == VTK_PARSE_VOID && vtkWrap_IsPointer(val));
}
/* This sets the CountHint for vtkDataArray methods where the
* tuple size is equal to GetNumberOfComponents. */
void vtkWrap_FindCountHints(
ClassInfo *data, FileInfo *finfo, HierarchyInfo *hinfo)
{
int i;
int count;
const char *countMethod;
FunctionInfo *theFunc;
/* add hints for vtkInformation get methods */
if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkInformation"))
{
countMethod = "Length(temp0)";
for (i = 0; i < data->NumberOfFunctions; i++)
{
theFunc = data->Functions[i];
if (strcmp(theFunc->Name, "Get") == 0 &&
theFunc->NumberOfParameters >= 1 &&
theFunc->Parameters[0]->Type == VTK_PARSE_OBJECT_PTR &&
(strcmp(theFunc->Parameters[0]->Class,
"vtkInformationIntegerVectorKey") == 0 ||
strcmp(theFunc->Parameters[0]->Class,
"vtkInformationDoubleVectorKey") == 0))
{
if (theFunc->ReturnValue && theFunc->ReturnValue->Count == 0 &&
theFunc->NumberOfParameters == 1)
{
theFunc->ReturnValue->CountHint = countMethod;
}
}
}
}
/* add hints for array GetTuple methods */
if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkDataArray"))
{
countMethod = "GetNumberOfComponents()";
for (i = 0; i < data->NumberOfFunctions; i++)
{
theFunc = data->Functions[i];
if ((strcmp(theFunc->Name, "GetTuple") == 0 ||
strcmp(theFunc->Name, "GetTupleValue") == 0) &&
theFunc->ReturnValue && theFunc->ReturnValue->Count == 0 &&
theFunc->NumberOfParameters == 1 &&
theFunc->Parameters[0]->Type == VTK_PARSE_ID_TYPE)
{
theFunc->ReturnValue->CountHint = countMethod;
}
else if ((strcmp(theFunc->Name, "SetTuple") == 0 ||
strcmp(theFunc->Name, "SetTupleValue") == 0 ||
strcmp(theFunc->Name, "GetTuple") == 0 ||
strcmp(theFunc->Name, "GetTupleValue") == 0 ||
strcmp(theFunc->Name, "InsertTuple") == 0 ||
strcmp(theFunc->Name, "InsertTupleValue") == 0) &&
theFunc->NumberOfParameters == 2 &&
theFunc->Parameters[0]->Type == VTK_PARSE_ID_TYPE &&
theFunc->Parameters[1]->Count == 0)
{
theFunc->Parameters[1]->CountHint = countMethod;
}
else if ((strcmp(theFunc->Name, "InsertNextTuple") == 0 ||
strcmp(theFunc->Name, "InsertNextTupleValue") == 0) &&
theFunc->NumberOfParameters == 1 &&
theFunc->Parameters[0]->Count == 0)
{
theFunc->Parameters[0]->CountHint = countMethod;
}
}
}
/* add hints for interpolator Interpolate methods */
if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkAbstractImageInterpolator"))
{
countMethod = "GetNumberOfComponents()";
for (i = 0; i < data->NumberOfFunctions; i++)
{
theFunc = data->Functions[i];
if (strcmp(theFunc->Name, "Interpolate") == 0 &&
theFunc->NumberOfParameters == 2 &&
theFunc->Parameters[0]->Type == (VTK_PARSE_DOUBLE_PTR|VTK_PARSE_CONST) &&
theFunc->Parameters[0]->Count == 3 &&
theFunc->Parameters[1]->Type == VTK_PARSE_DOUBLE_PTR &&
theFunc->Parameters[1]->Count == 0)
{
theFunc->Parameters[1]->CountHint = countMethod;
}
}
}
for (i = 0; i < data->NumberOfFunctions; i++)
{
theFunc = data->Functions[i];
/* hints for constructors that take arrays */
if (vtkWrap_IsConstructor(data, theFunc) &&
theFunc->NumberOfParameters == 1 &&
vtkWrap_IsPointer(theFunc->Parameters[0]) &&
vtkWrap_IsNumeric(theFunc->Parameters[0]) &&
theFunc->Parameters[0]->Count == 0 &&
hinfo)
{
count = vtkWrap_GetTupleSize(data, hinfo);
if (count)
{
char counttext[24];
sprintf(counttext, "%d", count);
theFunc->Parameters[0]->Count = count;
vtkParse_AddStringToArray(
&theFunc->Parameters[0]->Dimensions,
&theFunc->Parameters[0]->NumberOfDimensions,
vtkParse_CacheString(finfo->Strings, counttext, strlen(counttext)));
}
}
/* hints for operator[] index range */
if (theFunc->IsOperator && theFunc->Name &&
strcmp(theFunc->Name, "operator[]") == 0)
{
if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkTuple"))
{
theFunc->SizeHint = "GetSize()";
}
else if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArrayCoordinates") ||
vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArrayExtents") ||
vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArraySort"))
{
theFunc->SizeHint = "GetDimensions()";
}
else if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArrayExtentsList") ||
vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArrayWeights"))
{
theFunc->SizeHint = "GetCount()";
}
}
}
}
/* 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");
}
/* Convert values into python object and return them within python */
void vtkWrapPython_ReturnValue(
FILE *fp, ClassInfo *data, ValueInfo *val, int static_call)
{
char pythonname[1024];
const char *deref = "";
const char *prefix = "ap.";
if (static_call)
{
prefix = "vtkPythonArgs::";
fprintf(fp,
" if (PyErr_Occurred() == NULL)\n"
" {\n");
}
else
{
fprintf(fp,
" if (!ap.ErrorOccurred())\n"
" {\n");
}
if (val && vtkWrap_IsRef(val))
{
deref = "*";
}
if (vtkWrap_IsVoid(val))
{
fprintf(fp,
" result = %sBuildNone();\n",
prefix);
}
else if (vtkWrap_IsEnumMember(data, val))
{
fprintf(fp,
" result = Py%s_%s_FromEnum(tempr);\n",
data->Name, val->Class);
}
else if (vtkWrap_IsPythonObject(val))
{
fprintf(fp,
" result = tempr;\n");
}
else if (vtkWrap_IsVTKObject(val))
{
fprintf(fp,
" result = %sBuildVTKObject(tempr);\n",
prefix);
if (vtkWrap_IsNewInstance(val))
{
fprintf(fp,
" if (result && PyVTKObject_Check(result))\n"
" {\n"
" PyVTKObject_GetObject(result)->UnRegister(0);\n"
" PyVTKObject_SetFlag(result, VTK_PYTHON_IGNORE_UNREGISTER, 1);\n"
" }\n");
}
}
else if (vtkWrap_IsSpecialObject(val) &&
vtkWrap_IsRef(val))
{
vtkWrapText_PythonName(val->Class, pythonname);
fprintf(fp,
" result = %sBuildSpecialObject(tempr, \"%s\");\n",
prefix, pythonname);
}
else if (vtkWrap_IsSpecialObject(val) &&
!vtkWrap_IsRef(val))
{
vtkWrapText_PythonName(val->Class, pythonname);
fprintf(fp,
" result = %sBuildSpecialObject(&tempr, \"%s\");\n",
prefix, pythonname);
}
else if (vtkWrap_IsQtObject(val) &&
(vtkWrap_IsRef(val) || vtkWrap_IsPointer(val)))
{
fprintf(fp,
" result = %sBuildSIPObject(tempr, \"%s\", false);\n",
prefix, val->Class);
}
else if (vtkWrap_IsQtObject(val) &&
!vtkWrap_IsRef(val) && !vtkWrap_IsPointer(val))
{
fprintf(fp,
" result = %sBuildSIPObject(new %s(tempr), \"%s\", false);\n",
prefix, val->Class, val->Class);
}
else if (vtkWrap_IsQtEnum(val))
{
fprintf(fp,
" result = %sBuildSIPEnumValue(tempr, \"%s\");\n",
prefix, val->Class);
}
else if (vtkWrap_IsCharPointer(val))
{
fprintf(fp,
" result = %sBuildValue(tempr);\n",
prefix);
}
else if (vtkWrap_IsVoidPointer(val))
{
fprintf(fp,
" result = %sBuildValue(tempr);\n",
prefix);
}
else if (vtkWrap_IsChar(val) && vtkWrap_IsArray(val))
{
fprintf(fp,
" result = %sBuildBytes(tempr, sizer);\n",
prefix);
}
else if (vtkWrap_IsArray(val))
{
fprintf(fp,
" result = %sBuildTuple(tempr, sizer);\n",
prefix);
}
else
{
fprintf(fp,
" result = %sBuildValue(%stempr);\n",
prefix, deref);
}
fprintf(fp,
" }\n");
}
int vtkWrap_IsCharPointer(ValueInfo *val)
{
unsigned int t = (val->Type & VTK_PARSE_BASE_TYPE);
return (t == VTK_PARSE_CHAR && vtkWrap_IsPointer(val));
}
int vtkWrap_IsPODPointer(ValueInfo *val)
{
unsigned int t = (val->Type & VTK_PARSE_BASE_TYPE);
return (t != VTK_PARSE_CHAR && vtkWrap_IsNumeric(val) &&
vtkWrap_IsPointer(val));
}
/* Write code for execution after the method parameters are evaluated */
static void vtkWrapPython_SubstituteCode(
FILE *fp, ClassInfo *data, FunctionInfo *func, const char *code)
{
StringTokenizer t;
int qualified = 0;
int matched;
int j;
/* tokenize the code according to C/C++ rules */
vtkParse_InitTokenizer(&t, code, WS_DEFAULT);
do
{
/* check whether we have found an unqualified identifier */
matched = 0;
if ((t.tok == TOK_ID || t.tok == '#') && !qualified)
{
/* check for "this" */
if (t.len == 4 && strncmp(t.text, "this", 4) == 0)
{
fprintf(fp, "op");
matched = 1;
}
if (!matched) /* check for parameters */
{
ValueInfo *arg = NULL;
/* check for positional parameter "#n" */
if (t.tok == '#' && vtkParse_NextToken(&t) && t.tok == TOK_NUMBER)
{
j = (int)atol(t.text);
arg = func->Parameters[j];
}
else
{
for (j = 0; j < func->NumberOfParameters; j++)
{
const char *name;
arg = func->Parameters[j];
name = arg->Name;
if (name && strlen(name) == t.len &&
strncmp(name, t.text, t.len) == 0)
{
break;
}
arg = NULL;
}
}
if (arg)
{
matched = 1;
if (vtkWrap_IsSpecialObject(arg) && !vtkWrap_IsPointer(arg))
{
fprintf(fp, "(*temp%d)", j);
}
else
{
fprintf(fp, "temp%d", j);
}
}
}
if (!matched) /* check for class members */
{
for (j = 0; j < data->NumberOfItems; j++)
{
ItemInfo *item = &data->Items[j];
const char *name = NULL;
int is_static = 0;
if (item->Type == VTK_FUNCTION_INFO)
{
/* methods */
name = data->Functions[item->Index]->Name;
is_static = data->Functions[item->Index]->IsStatic;
}
else if (item->Type == VTK_VARIABLE_INFO)
{
/* member variables */
name = data->Variables[item->Index]->Name;
is_static = data->Variables[item->Index]->IsStatic;
}
else if (item->Type == VTK_CONSTANT_INFO)
{
/* enum values and other constants */
name = data->Constants[item->Index]->Name;
is_static = 1;
}
if (name && strlen(name) == t.len &&
strncmp(name, t.text, t.len) == 0)
{
if (is_static)
{
fprintf(fp, "%s::%s", data->Name, name);
}
else
{
fprintf(fp, "op->%s", name);
}
matched = 1;
break;
}
}
}
}
if (!matched)
{
fprintf(fp, "%*.*s", (int)t.len, (int)t.len, t.text);
}
/* if next character is whitespace, add a space */
if (vtkParse_CharType(t.text[t.len], CPRE_WHITE))
{
fprintf(fp, " ");
}
/* check whether the next identifier is qualified */
qualified = (t.tok == TOK_SCOPE ||
t.tok == TOK_ARROW ||
t.tok == '.');
}
while (vtkParse_NextToken(&t));
}