/* Free any temporaries that were needed for the C++ method call*/ static void vtkWrapPython_FreeTemporaries( FILE *fp, FunctionInfo *currentFunction) { ValueInfo *arg; int i, j, n; n = vtkWrap_CountWrappedParameters(currentFunction); /* check array value change for args that are non-const */ j = 0; for (i = 0; i < n; i++) { arg = currentFunction->Parameters[i]; if (vtkWrap_IsVoidPointer(arg)) { /* release Py_buffer objects */ fprintf(fp, "#if PY_VERSION_HEX >= 0x02060000\n" " if (pbuf%d.obj != 0)\n" " {\n" " PyBuffer_Release(&pbuf%d);\n" " }\n" "#endif\n", i, i); } else if (vtkWrap_IsSpecialObject(arg) && !vtkWrap_IsNonConstRef(arg)) { /* decref any PyObjects created via conversion constructors */ fprintf(fp, " Py_XDECREF(pobj%d);\n", i); j = 1; } else if (arg->CountHint || vtkWrap_IsPODPointer(arg)) { /* free any temporary arrays */ fprintf(fp, " if (temp%d != small%d)\n" " {\n" " delete [] temp%d;\n" " }\n", i, i, i); j = 1; } } if (j) { fprintf(fp, "\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; 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"); }
/* 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"); }
/* Write the code to convert one argument with vtkPythonArgs */ void vtkWrapPython_GetSingleArgument( FILE *fp, ClassInfo *data, int i, ValueInfo *arg, int static_call) { const char *prefix = "ap."; const char *cp; char argname[32]; char pythonname[1024]; size_t l; argname[0] = '\0'; if (static_call) { prefix = "vtkPythonArgs::"; sprintf(argname, "arg%d, ", i); } if (vtkWrap_IsEnumMember(data, arg)) { fprintf(fp, "%sGetEnumValue(%stemp%d, \"%s.%s\")", prefix, argname, i, data->Name, arg->Class); } else if (arg->IsEnum) { cp = arg->Class; for (l = 0; cp[l] != '\0'; l++) { if (cp[l] == ':') { break; } } if (cp[l] == ':' && cp[l+1] == ':') { fprintf(fp, "%sGetEnumValue(%stemp%d, \"%*.*s.%s\")", prefix, argname, i, (int)l, (int)l, cp, &cp[l+2]); } else { fprintf(fp, "%sGetEnumValue(%stemp%d, \"%s\")", prefix, argname, i, cp); } } else if (vtkWrap_IsPythonObject(arg)) { fprintf(fp, "%s%sGetPythonObject(temp%d)", prefix, argname, i); } else if (vtkWrap_IsVTKObject(arg)) { vtkWrapText_PythonName(arg->Class, pythonname); if (strcmp(arg->Class, pythonname) != 0) { /* use typeid() for templated names */ fprintf(fp, "%sGetVTKObject(%stemp%d, typeid(%s).name())", prefix, argname, i, arg->Class); } else { fprintf(fp, "%sGetVTKObject(%stemp%d, \"%s\")", prefix, argname, i, pythonname); } } else if (vtkWrap_IsSpecialObject(arg) && !vtkWrap_IsNonConstRef(arg)) { vtkWrapText_PythonName(arg->Class, pythonname); fprintf(fp, "%sGetSpecialObject(%stemp%d, pobj%d, \"%s\")", prefix, argname, i, i, pythonname); } else if (vtkWrap_IsSpecialObject(arg) && vtkWrap_IsNonConstRef(arg)) { vtkWrapText_PythonName(arg->Class, pythonname); fprintf(fp, "%sGetSpecialObject(%stemp%d, \"%s\")", prefix, argname, i, pythonname); } else if (vtkWrap_IsQtEnum(arg)) { fprintf(fp, "%sGetSIPEnumValue(%stemp%d, \"%s\")", prefix, argname, i, arg->Class); } else if (vtkWrap_IsQtObject(arg)) { fprintf(fp, "%sGetSIPObject(%stemp%d, \"%s\")", prefix, argname, i, arg->Class); } else if (vtkWrap_IsFunction(arg)) { fprintf(fp, "%sGetFunction(%stemp%d)", prefix, argname, i); } else if (vtkWrap_IsVoidPointer(arg)) { fprintf(fp, "%sGetBuffer(%stemp%d, &pbuf%d)", prefix, argname, i, i); } else if (vtkWrap_IsString(arg) || vtkWrap_IsCharPointer(arg)) { fprintf(fp, "%sGetValue(%stemp%d)", prefix, argname, i); } else if (vtkWrap_IsNumeric(arg) && vtkWrap_IsScalar(arg)) { fprintf(fp, "%sGetValue(%stemp%d)", prefix, argname, i); } else if (vtkWrap_IsNArray(arg)) { fprintf(fp, "%sGetNArray(%s%.*stemp%d, %d, size%d)", prefix, argname, (int)(arg->NumberOfDimensions-1), "**********", i, arg->NumberOfDimensions, i); } else if (vtkWrap_IsArray(arg)) { fprintf(fp, "%sGetArray(%stemp%d, size%d)", prefix, argname, i, i); } else if (vtkWrap_IsPODPointer(arg)) { fprintf(fp, "%sGetArray(%stemp%d, size%d)", prefix, argname, i, i); } }
/* 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"); }
/* 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)); }