/* Save a copy of each non-const array arg, so that we can check * if they were changed by the method call */ void vtkWrapPython_SaveArgs(FILE *fp, FunctionInfo *currentFunction) { const char *asterisks = "**********"; ValueInfo *arg; int i, j, n, m; int noneDone = 1; /* do nothing for SetVector macros */ if (vtkWrap_IsSetVectorMethod(currentFunction)) { return; } m = vtkWrap_CountWrappedParameters(currentFunction); /* save arrays for args that are non-const */ for (i = 0; i < m; i++) { arg = currentFunction->Parameters[i]; n = arg->NumberOfDimensions; if (n < 1 && (vtkWrap_IsArray(arg) || vtkWrap_IsPODPointer(arg) || vtkWrap_IsCharPointer(arg))) { n = 1; } if ((vtkWrap_IsArray(arg) || vtkWrap_IsNArray(arg) || vtkWrap_IsPODPointer(arg) || vtkWrap_IsCharPointer(arg)) && (arg->Type & VTK_PARSE_CONST) == 0 && !vtkWrap_IsRef(arg)) { noneDone = 0; fprintf(fp, " ap.Save(%.*stemp%d, %.*ssave%d, ", (n-1), asterisks, i, (n-1), asterisks, i); if (vtkWrap_IsNArray(arg)) { for (j = 0; j < arg->NumberOfDimensions; j++) { fprintf(fp, "%ssize%d[%d]", (j == 0 ? "" : "*"), i, j); } } else { fprintf(fp, "size%d", i); } fprintf(fp, ");\n"); } } if (!noneDone) { 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"); }
/* 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"); }
/* 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 = nullptr;\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) || (vtkWrap_IsCharPointer(arg) && !vtkWrap_IsConst(arg))) { /* for non-const arrays, alloc twice as much space */ const char *mtwo = ""; if (!vtkWrap_IsConst(arg) && !vtkWrap_IsSetVectorMethod(theFunc)) { mtwo = "2*"; } if (vtkWrap_IsCharPointer(arg)) { /* prepare for "char *" arg for non-const char pointer */ fprintf(fp, " size_t size%d = ap.GetStringSize(%d);\n" " vtkPythonArgs::Array<char> store%d(%ssize%d + 1);\n" " char *temp%d = store%d.Data();\n", i, i, i, mtwo, i, i, i); if (!vtkWrap_IsRef(arg)) { fprintf(fp, " char *save%d = temp%d + size%d + 1;\n", i, i, i); } } else if (arg->CountHint || vtkWrap_IsPODPointer(arg)) { /* prepare for "T *" arg, where T is a plain type */ fprintf(fp, " size_t 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) && !vtkWrap_IsRef(arg)) { fprintf(fp, " %s *save%d = (size%d == 0 ? nullptr : temp%d + size%d);\n", vtkWrap_GetTypeName(arg), i, i, i, i); } } else if (vtkWrap_IsArray(arg) && arg->Value) { /* prepare for "T a[n] = nullptr" arg (array with default of NULL) */ fprintf(fp, " size_t size%d = 0;\n" " %s store%d[%s%d];\n" " %s *temp%d = nullptr;\n", i, vtkWrap_GetTypeName(arg), i, mtwo, arg->Count, vtkWrap_GetTypeName(arg), i); if (!vtkWrap_IsConst(arg)) { fprintf(fp, " %s *save%d = nullptr;\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 if (vtkWrap_IsStdVector(arg)) { fprintf(fp, " %s temp%d(ap.GetArgSize(%d));\n", arg->Class, i, i); } 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) || vtkWrap_IsZeroCopyPointer(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 = nullptr;\n", i); } } if (theFunc->ReturnValue) { /* the size for a one-dimensional array */ if (vtkWrap_IsArray(theFunc->ReturnValue) && !theFunc->ReturnValue->CountHint) { fprintf(fp, " size_t sizer = %d;\n", theFunc->ReturnValue->Count); } } /* temp variable for the Python return value */ fprintf(fp, " PyObject *result = nullptr;\n" "\n"); }
/* Write the code to convert the arguments with vtkPythonArgs */ static void vtkWrapPython_GetAllParameters( FILE *fp, ClassInfo *data, FunctionInfo *currentFunction) { ValueInfo *arg; int requiredArgs, totalArgs; int i; totalArgs = vtkWrap_CountWrappedParameters(currentFunction); requiredArgs = vtkWrap_CountRequiredArguments(currentFunction); if (requiredArgs == totalArgs) { fprintf(fp, "ap.CheckArgCount(%d)", totalArgs); } else { fprintf(fp, "ap.CheckArgCount(%d, %d)", requiredArgs, totalArgs); } for (i = 0; i < totalArgs; i++) { arg = currentFunction->Parameters[i]; fprintf(fp, " &&\n" " "); if (i >= requiredArgs) { fprintf(fp, "(ap.NoArgsLeft() || "); } vtkWrapPython_GetSingleArgument(fp, data, i, arg, 0); if (i >= requiredArgs) { fprintf(fp, ")"); } if (vtkWrap_IsFunction(arg)) { break; } } /* loop again, check sizes against any size hints */ for (i = 0; i < totalArgs; i++) { arg = currentFunction->Parameters[i]; if (arg->CountHint && !vtkWrap_IsRef(arg)) { fprintf(fp, " &&\n" " ap.CheckSizeHint(%d, size%d, ", i, i); /* write out the code that gives the size */ vtkWrapPython_SubstituteCode(fp, data, currentFunction, arg->CountHint); fprintf(fp, ")"); } if (vtkWrap_IsFunction(arg)) { break; } } }