/* 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; } } }
static void vtkWrapText_PythonTypeSignature( struct vtkWPString *result, const char *braces[2], ValueInfo *arg) { char text[256]; const char *dimension; const char *classname = ""; if (vtkWrap_IsVoid(arg)) { classname = "void"; } else if (vtkWrap_IsFunction(arg)) { classname = "function"; } else if (vtkWrap_IsString(arg) || vtkWrap_IsCharPointer(arg)) { classname = "string"; if ((arg->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_UNICODE_STRING) { classname = "unicode"; } } else if (vtkWrap_IsChar(arg)) { classname = "char"; } else if (vtkWrap_IsBool(arg)) { classname = "bool"; } else if (vtkWrap_IsRealNumber(arg)) { classname = "float"; } else if (vtkWrap_IsInteger(arg)) { classname = "int"; } else { vtkWrapText_PythonName(arg->Class, text); classname = text; } if ((vtkWrap_IsArray(arg) && arg->CountHint) || vtkWrap_IsPODPointer(arg)) { vtkWPString_Append(result, braces[0]); vtkWPString_Append(result, classname); vtkWPString_Append(result, ", ..."); vtkWPString_Append(result, braces[1]); } else if (vtkWrap_IsArray(arg)) { sprintf(text, "%d", arg->Count); dimension = text; vtkWrapText_PythonArraySignature(result, classname, braces, 1, &dimension); } else if (vtkWrap_IsNArray(arg)) { vtkWrapText_PythonArraySignature(result, classname, braces, arg->NumberOfDimensions, arg->Dimensions); } else { vtkWPString_Append(result, classname); } }
/* 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"); }
/* 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 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; } } }