/* Declare the exports and imports for a VTK/Python class */ static void vtkWrapPython_ExportVTKClass( FILE *fp, ClassInfo *data, HierarchyInfo *hinfo) { char classname[1024]; const char *supername; /* mangle the classname if necessary */ vtkWrapText_PythonName(data->Name, classname); /* for vtkObjectBase objects: export New method for use by subclasses */ fprintf(fp, "extern \"C\" { %s PyObject *Py%s_ClassNew(); }\n" "\n", "VTK_ABI_EXPORT", classname); /* declare the New methods for all the superclasses */ supername = vtkWrapPython_GetSuperClass(data, hinfo); if (supername) { vtkWrapText_PythonName(supername, classname); fprintf(fp, "#ifndef DECLARED_Py%s_ClassNew\n" "extern \"C\" { PyObject *Py%s_ClassNew(); }\n" "#define DECLARED_Py%s_ClassNew\n" "#endif\n", classname, classname, classname); } }
/* generate the New method for a vtkObjectBase object */ static void vtkWrapPython_GenerateObjectNew( FILE *fp, const char *classname, ClassInfo *data, HierarchyInfo *hinfo, int class_has_new) { char superclassname[1024]; const char *name; int has_constants = 0; int i; if (class_has_new) { fprintf(fp, "static vtkObjectBase *Py%s_StaticNew()\n" "{\n" " return %s::New();\n" "}\n" "\n", classname, data->Name); } fprintf(fp, "PyObject *Py%s_ClassNew()\n" "{\n" " PyVTKClass_Add(\n" " &Py%s_Type, Py%s_Methods,\n", classname, classname, classname); if (strcmp(data->Name, classname) == 0) { fprintf(fp, " \"%s\",\n" " Py%s_Doc(),", classname, classname); } else { /* use of typeid() matches vtkTypeTemplate */ fprintf(fp, " typeid(%s).name(),\n" " Py%s_Doc(),", data->Name, classname); } if (class_has_new) { fprintf(fp, " &Py%s_StaticNew);\n\n", classname); } else { fprintf(fp, " NULL);\n\n"); } fprintf(fp, " PyTypeObject *pytype = &Py%s_Type;\n\n", classname); /* if type is already ready, then return */ fprintf(fp, " if ((pytype->tp_flags & Py_TPFLAGS_READY) != 0)\n" " {\n" " return (PyObject *)pytype;\n" " }\n\n"); /* add any flags specific to this type */ fprintf(fp, "#if !defined(VTK_PY3K) && PY_VERSION_HEX >= 0x02060000\n" " pytype->tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;\n" "#endif\n\n"); /* find the first superclass that is a VTK class, create it first */ name = vtkWrapPython_GetSuperClass(data, hinfo); if (name) { vtkWrapText_PythonName(name, superclassname); fprintf(fp, " pytype->tp_base = (PyTypeObject *)Py%s_ClassNew();\n\n", superclassname); } /* check if any constants need to be added to the class dict */ for (i = 0; i < data->NumberOfConstants; i++) { if (data->Constants[i]->Access == VTK_ACCESS_PUBLIC) { has_constants = 1; break; } } if (has_constants) { fprintf(fp, " PyObject *d = pytype->tp_dict;\n" " PyObject *o;\n" "\n"); /* add any enum types defined in the class to its dict */ vtkWrapPython_AddPublicEnumTypes(fp, " ", "d", "o", data); /* add any constants defined in the class to its dict */ vtkWrapPython_AddPublicConstants(fp, " ", "d", "o", data); } fprintf(fp, " PyType_Ready(pytype);\n" " return (PyObject *)pytype;\n" "}\n\n"); }
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); } }
/* 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); } }
/* Wrap a templated class */ int vtkWrapPython_WrapTemplatedClass( FILE *fp, ClassInfo *data, FileInfo *file_info, HierarchyInfo *hinfo) { char classname[1024]; const char *instantiations[1024]; int ninstantiations = 0; int i, j, k, nargs; ClassInfo *sdata; ValueInfo *tdef; HierarchyEntry *entry; const char *name; char *cp; const char **args; const char **defaults; const char *modulename; const char *name_with_args; int is_vtkobject = 0; const char **types; /* do not directly wrap vtkTypeTemplate */ if (strcmp(data->Name, "vtkTypeTemplate") == 0) { return 0; } if (hinfo == 0) { return 0; } entry = vtkParseHierarchy_FindEntry(hinfo, data->Name); if (entry == 0) { return 0; } modulename = entry->Module; defaults = entry->TemplateDefaults; /* find all instantiations from derived classes */ for (j = 0; j < hinfo->NumberOfEntries; j++) { entry = &hinfo->Entries[j]; classname[0] = '\0'; /* skip enum entries */ if (entry->IsEnum) { continue; } /* look for typedefs of template instantiations */ if (entry->IsTypedef) { tdef = entry->Typedef; if ((tdef->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_OBJECT && entry->NumberOfTemplateParameters == 0) { if (tdef->Class && tdef->Class[0] != '\0' && tdef->Class[strlen(tdef->Class) - 1] == '>') { strcpy(classname, tdef->Class); entry = vtkParseHierarchy_FindEntry(hinfo, classname); } } if (!entry || entry->IsTypedef || entry->IsEnum) { continue; } } nargs = entry->NumberOfTemplateParameters; args = entry->TemplateParameters; if (strcmp(entry->Module, modulename) == 0 && (entry->NumberOfSuperClasses == 1 || strcmp(entry->Name, data->Name) == 0)) { types = NULL; /* only do these classes directly */ if (strcmp(entry->Name, "vtkDenseArray") == 0 || strcmp(entry->Name, "vtkSparseArray") == 0) { types = vtkParse_GetArrayTypes(); } else if (strcmp(entry->Name, "vtkTuple") == 0) { static const char *tuple_types[13] = { "unsigned char, 2", "unsigned char, 3", "unsigned char, 4", "int, 2", "int, 3", "int, 4", "float, 2", "float, 3", "float, 4", "double, 2", "double, 3", "double, 4", NULL }; types = tuple_types; } /* do all other templated classes indirectly */ else if (nargs > 0) { continue; } for (i = 0; i == 0 || (types && types[i] != NULL); i++) { /* make the classname, with template args if present */ if (classname[0] == '\0') { if (nargs == 0) { sprintf(classname, "%s", entry->Name); } else { sprintf(classname, "%s<%s>", entry->Name, types[i]); } } name_with_args = NULL; if (strcmp(data->Name, entry->Name) == 0) { /* entry is the same as data */ cp = (char *)malloc(strlen(classname) + 1); strcpy(cp, classname); name_with_args = cp; } else { /* entry is not data, see if it is a subclass, and if so, * what template args of 'data' it corresponds to */ vtkParseHierarchy_IsTypeOfTemplated( hinfo, entry, classname, data->Name, &name_with_args); } if (name_with_args) { /* append to the list of instantiations if not present yet */ for (k = 0; k < ninstantiations; k++) { if (strcmp(name_with_args, instantiations[k]) == 0) { break; } } if (k == ninstantiations) { instantiations[ninstantiations++] = name_with_args; } else { free((char *)name_with_args); } } classname[0] = '\0'; } } } if (ninstantiations) { for (k = 0; k < ninstantiations; k++) { entry = vtkParseHierarchy_FindEntry(hinfo, instantiations[k]); is_vtkobject = vtkParseHierarchy_IsTypeOfTemplated( hinfo, entry, instantiations[k], "vtkObjectBase", NULL); nargs = data->Template->NumberOfParameters; vtkParse_DecomposeTemplatedType(instantiations[k], &name, nargs, &args, defaults); sdata = (ClassInfo *)malloc(sizeof(ClassInfo)); vtkParse_CopyClass(sdata, data); vtkParse_InstantiateClassTemplate(sdata, file_info->Strings, nargs, args); vtkWrapText_PythonName(instantiations[k], classname); vtkWrapPython_WrapOneClass( fp, modulename, classname, sdata, file_info, hinfo, is_vtkobject); vtkParse_FreeClass(sdata); vtkParse_FreeTemplateDecomposition(name, nargs, args); } /* the docstring for the templated class */ fprintf(fp, "static const char *Py%s_Doc[] = {\n", data->Name); vtkWrapPython_ClassDoc(fp, file_info, data, hinfo, is_vtkobject); fprintf(fp, " \"\\nProvided Types:\\n\\n\",\n"); for (k = 0; k < ninstantiations; k++) { vtkWrapPython_PyTemplateName(instantiations[k], classname); fprintf(fp, " \" %s => %s\\n\",\n", classname, instantiations[k]); } fprintf(fp, " NULL\n" "};\n" "\n"); fprintf(fp, "PyObject *Py%s_TemplateNew()\n" "{\n" " PyObject *o;\n" "\n" " PyObject *temp = PyVTKTemplate_New(\"%sPython.%s\",\n" " Py%s_Doc);\n" "\n", data->Name, modulename, data->Name, data->Name); for (k = 0; k < ninstantiations; k++) { vtkWrapText_PythonName(instantiations[k], classname); entry = vtkParseHierarchy_FindEntry(hinfo, instantiations[k]); if (vtkParseHierarchy_IsTypeOfTemplated( hinfo, entry, instantiations[k], "vtkObjectBase", NULL)) { fprintf(fp, " o = Py%s_ClassNew();\n", classname); } else { fprintf(fp, " o = Py%s_TypeNew();\n", classname); } fprintf(fp, " if (o && PyVTKTemplate_AddItem(temp, o) != 0)\n" " {\n" " Py_DECREF(o);\n" " }\n" "\n"); free((char *)instantiations[k]); } fprintf(fp, " return temp;\n" "}\n" "\n"); return 1; } return 0; }