/* 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"); }
int main(int argc, char *argv[]) { ClassInfo *wrappedClasses[MAX_WRAPPED_CLASSES]; unsigned char wrapAsVTKObject[MAX_WRAPPED_CLASSES]; ClassInfo *data = NULL; NamespaceInfo *contents; OptionInfo *options; HierarchyInfo *hinfo = NULL; FileInfo *file_info; FILE *fp; const char *module = "vtkCommonCore"; const char *name; char *name_from_file = NULL; int numberOfWrappedClasses = 0; int numberOfWrappedNamespaces = 0; int wrapped_anything = 0; int i, j; size_t k, m; int is_vtkobject; /* pre-define a macro to identify the language */ vtkParse_DefineMacro("__VTK_WRAP_PYTHON__", 0); /* get command-line args and parse the header file */ file_info = vtkParse_Main(argc, argv); /* get the command-line options */ options = vtkParse_GetCommandLineOptions(); /* get the output file */ fp = fopen(options->OutputFileName, "w"); if (!fp) { fprintf(stderr, "Error opening output file %s\n", options->OutputFileName); exit(1); } /* get the hierarchy info for accurate typing */ if (options->HierarchyFileNames) { hinfo = vtkParseHierarchy_ReadFiles( options->NumberOfHierarchyFileNames, options->HierarchyFileNames); } /* get the filename without the extension */ name = file_info->FileName; m = strlen(name); for (k = m; k > 0; k--) { if (name[k] == '.') { break; } } if (k > 0) { m = k; } for (k = m; k > 0; k--) { if (!((name[k-1] >= 'a' && name[k-1] <= 'z') || (name[k-1] >= 'A' && name[k-1] <= 'Z') || (name[k-1] >= '0' && name[k-1] <= '9') || name[k-1] == '_')) { break; } } name_from_file = (char *)malloc(m - k + 1); strncpy(name_from_file, &name[k], m - k); name_from_file[m-k] = '\0'; name = name_from_file; /* get the global namespace */ contents = file_info->Contents; /* use the hierarchy file to expand typedefs */ if (hinfo) { for (i = 0; i < contents->NumberOfClasses; i++) { vtkWrap_ApplyUsingDeclarations(contents->Classes[i], file_info, hinfo); } for (i = 0; i < contents->NumberOfClasses; i++) { vtkWrap_ExpandTypedefs(contents->Classes[i], file_info, hinfo); } } /* the VTK_WRAPPING_CXX tells header files where they're included from */ fprintf(fp, "// python wrapper for %s\n//\n" "#define VTK_WRAPPING_CXX\n", name); /* unless this is vtkObjectBase.h, define VTK_STREAMS_FWD_ONLY */ if (strcmp("vtkObjectBase", name) != 0) { /* Block inclusion of full streams. */ fprintf(fp, "#define VTK_STREAMS_FWD_ONLY\n"); } /* lots of important utility functions are defined in vtkPythonArgs.h */ fprintf(fp, "#include \"vtkPythonArgs.h\"\n" "#include \"vtkPythonOverload.h\"\n" "#include \"vtkConfigure.h\"\n" "#include <cstddef>\n" "#include <sstream>\n"); /* vtkPythonCommand is needed to wrap vtkObject.h */ if (strcmp("vtkObject", name) == 0) { fprintf(fp, "#include \"vtkPythonCommand.h\"\n"); } /* generate includes for any special types that are used */ vtkWrapPython_GenerateSpecialHeaders(fp, file_info, hinfo); /* the header file for the wrapped class */ fprintf(fp, "#include \"%s.h\"\n\n", name); /* do the export of the main entry point */ fprintf(fp, "extern \"C\" { %s void PyVTKAddFile_%s(PyObject *); }\n", "VTK_ABI_EXPORT", name); /* get the module that is being wrapped */ data = file_info->MainClass; if (!data && file_info->Contents->NumberOfClasses > 0) { data = file_info->Contents->Classes[0]; } if (data && hinfo) { module = vtkWrapPython_ClassModule(hinfo, data->Name); } /* Identify all enum types that are used by methods */ vtkWrapPython_MarkAllEnums(file_info->Contents, hinfo); /* Wrap any enum types defined in the global namespace */ for (i = 0; i < contents->NumberOfEnums; i++) { vtkWrapPython_GenerateEnumType(fp, module, NULL, contents->Enums[i]); } /* Wrap any namespaces */ for (i = 0; i < contents->NumberOfNamespaces; i++) { if (contents->Namespaces[i]->NumberOfConstants > 0) { vtkWrapPython_WrapNamespace(fp, module, contents->Namespaces[i]); numberOfWrappedNamespaces++; } } /* Check for all special classes before any classes are wrapped */ for (i = 0; i < contents->NumberOfClasses; i++) { data = contents->Classes[i]; /* guess whether type is a vtkobject */ is_vtkobject = (data == file_info->MainClass ? 1 : 0); if (hinfo) { is_vtkobject = vtkWrap_IsTypeOf(hinfo, data->Name, "vtkObjectBase"); } if (!is_vtkobject) { /* mark class as abstract only if it has pure virtual methods */ /* (does not check for inherited pure virtual methods) */ data->IsAbstract = 0; for (j = 0; j < data->NumberOfFunctions; j++) { FunctionInfo *func = data->Functions[j]; if (func && func->IsPureVirtual) { data->IsAbstract = 1; break; } } } wrapAsVTKObject[i] = (is_vtkobject ? 1 : 0); } /* Wrap all of the classes in the file */ for (i = 0; i < contents->NumberOfClasses; i++) { data = contents->Classes[i]; is_vtkobject = wrapAsVTKObject[i]; /* if "hinfo" is present, wrap everything, else just the main class */ if (hinfo || data == file_info->MainClass) { if (vtkWrapPython_WrapOneClass( fp, module, data->Name, data, file_info, hinfo, is_vtkobject)) { /* re-index wrapAsVTKObject for wrapped classes */ wrapAsVTKObject[numberOfWrappedClasses] = (is_vtkobject ? 1 : 0); wrappedClasses[numberOfWrappedClasses++] = data; } } } /* The function for adding everything to the module dict */ wrapped_anything = (numberOfWrappedClasses || numberOfWrappedNamespaces || contents->NumberOfConstants); fprintf(fp, "void PyVTKAddFile_%s(\n" " PyObject *%s)\n" "{\n" "%s", name, (wrapped_anything ? "dict" : ""), (wrapped_anything ? " PyObject *o;\n" : "")); /* Add all of the namespaces */ for (j = 0; j < contents->NumberOfNamespaces; j++) { if (contents->Namespaces[j]->NumberOfConstants > 0) { fprintf(fp, " o = PyVTKNamespace_%s();\n" " if (o && PyDict_SetItemString(dict, \"%s\", o) != 0)\n" " {\n" " Py_DECREF(o);\n" " }\n" "\n", contents->Namespaces[j]->Name, contents->Namespaces[j]->Name); } } /* Add all of the classes that have been wrapped */ for (i = 0; i < numberOfWrappedClasses; i++) { data = wrappedClasses[i]; is_vtkobject = wrapAsVTKObject[i]; if (data->Template) { /* Template generator */ fprintf(fp, " o = Py%s_TemplateNew();\n" "\n", data->Name); /* Add template specializations to dict */ fprintf(fp, " if (o)\n" " {\n" " PyObject *l = PyObject_CallMethod(o, (char *)\"values\", 0);\n" " Py_ssize_t n = PyList_GET_SIZE(l);\n" " for (Py_ssize_t i = 0; i < n; i++)\n" " {\n" " PyObject *ot = PyList_GET_ITEM(l, i);\n" " const char *nt = NULL;\n" " if (PyType_Check(ot))\n" " {\n" " nt = ((PyTypeObject *)ot)->tp_name;\n" " }\n" " else if (PyCFunction_Check(ot))\n" " {\n" " nt = ((PyCFunctionObject *)ot)->m_ml->ml_name;\n" " }\n" " if (nt)\n" " {\n" " PyDict_SetItemString(dict, nt, ot);\n" " }\n" " }\n" " Py_DECREF(l);\n" " }\n" "\n"); } else if (is_vtkobject) { /* Class is derived from vtkObjectBase */ fprintf(fp, " o = Py%s_ClassNew();\n" "\n", data->Name); } else { /* Classes that are not derived from vtkObjectBase */ fprintf(fp, " o = Py%s_TypeNew();\n" "\n", data->Name); } fprintf(fp, " if (o && PyDict_SetItemString(dict, \"%s\", o) != 0)\n" " {\n" " Py_DECREF(o);\n" " }\n" "\n", data->Name); } /* add any enum types defined in the file */ vtkWrapPython_AddPublicEnumTypes(fp, " ", "dict", "o", contents); /* add any constants defined in the file */ vtkWrapPython_AddPublicConstants(fp, " ", "dict", "o", contents); /* close the AddFile function */ fprintf(fp, "}\n\n"); free(name_from_file); vtkParse_Free(file_info); return 0; }