/* This sets the NewInstance hint for generator methods. */ void vtkWrap_FindNewInstanceMethods( ClassInfo *data, HierarchyInfo *hinfo) { int i; FunctionInfo *theFunc; for (i = 0; i < data->NumberOfFunctions; i++) { theFunc = data->Functions[i]; if (theFunc->Name && theFunc->ReturnValue && vtkWrap_IsVTKObject(theFunc->ReturnValue) && vtkWrap_IsVTKObjectBaseType(hinfo, theFunc->ReturnValue->Class)) { if (strcmp(theFunc->Name, "NewInstance") == 0 || strcmp(theFunc->Name, "CreateInstance") == 0 || (strcmp(theFunc->Name, "CreateImageReader2") == 0 && strcmp(data->Name, "vtkImageReader2Factory") == 0) || (strcmp(theFunc->Name, "CreateDataArray") == 0 && strcmp(data->Name, "vtkDataArray") == 0) || (strcmp(theFunc->Name, "CreateArray") == 0 && strcmp(data->Name, "vtkAbstractArray") == 0) || (strcmp(theFunc->Name, "CreateArray") == 0 && strcmp(data->Name, "vtkArray") == 0) || (strcmp(theFunc->Name, "GetQueryInstance") == 0 && strcmp(data->Name, "vtkSQLDatabase") == 0) || (strcmp(theFunc->Name, "CreateFromURL") == 0 && strcmp(data->Name, "vtkSQLDatabase") == 0) || (strcmp(theFunc->Name, "MakeTransform") == 0 && vtkWrap_IsTypeOf(hinfo, data->Name, "vtkAbstractTransform"))) { theFunc->ReturnValue->Type |= VTK_PARSE_NEWINSTANCE; } } } }
/* This sets the CountHint for vtkDataArray methods where the * tuple size is equal to GetNumberOfComponents. */ void vtkWrap_FindCountHints( ClassInfo *data, HierarchyInfo *hinfo) { int i; const char *countMethod = "GetNumberOfComponents()"; FunctionInfo *theFunc; for (i = 0; i < data->NumberOfFunctions; i++) { theFunc = data->Functions[i]; /* add hints for array GetTuple methods */ if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkDataArray")) { if ((strcmp(theFunc->Name, "GetTuple") == 0 || strcmp(theFunc->Name, "GetTupleValue") == 0) && theFunc->ReturnValue && theFunc->ReturnValue->Count == 0 && theFunc->NumberOfArguments == 1 && theFunc->Arguments[0]->Type == VTK_PARSE_ID_TYPE) { theFunc->ReturnValue->CountHint = countMethod; } else if ((strcmp(theFunc->Name, "SetTuple") == 0 || strcmp(theFunc->Name, "SetTupleValue") == 0 || strcmp(theFunc->Name, "GetTuple") == 0 || strcmp(theFunc->Name, "GetTupleValue") == 0 || strcmp(theFunc->Name, "InsertTuple") == 0 || strcmp(theFunc->Name, "InsertTupleValue") == 0) && theFunc->NumberOfArguments == 2 && theFunc->Arguments[0]->Type == VTK_PARSE_ID_TYPE && theFunc->Arguments[1]->Count == 0) { theFunc->Arguments[1]->CountHint = countMethod; } else if ((strcmp(theFunc->Name, "InsertNextTuple") == 0 || strcmp(theFunc->Name, "InsertNextTupleValue") == 0) && theFunc->NumberOfArguments == 1 && theFunc->Arguments[0]->Count == 0) { theFunc->Arguments[0]->CountHint = countMethod; } } } }
/* This sets the CountHint for vtkDataArray methods where the * tuple size is equal to GetNumberOfComponents. */ void vtkWrap_FindCountHints( ClassInfo *data, FileInfo *finfo, HierarchyInfo *hinfo) { int i; int count; const char *countMethod; FunctionInfo *theFunc; /* add hints for vtkInformation get methods */ if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkInformation")) { countMethod = "Length(temp0)"; for (i = 0; i < data->NumberOfFunctions; i++) { theFunc = data->Functions[i]; if (strcmp(theFunc->Name, "Get") == 0 && theFunc->NumberOfParameters >= 1 && theFunc->Parameters[0]->Type == VTK_PARSE_OBJECT_PTR && (strcmp(theFunc->Parameters[0]->Class, "vtkInformationIntegerVectorKey") == 0 || strcmp(theFunc->Parameters[0]->Class, "vtkInformationDoubleVectorKey") == 0)) { if (theFunc->ReturnValue && theFunc->ReturnValue->Count == 0 && theFunc->NumberOfParameters == 1) { theFunc->ReturnValue->CountHint = countMethod; } } } } /* add hints for array GetTuple methods */ if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkDataArray")) { countMethod = "GetNumberOfComponents()"; for (i = 0; i < data->NumberOfFunctions; i++) { theFunc = data->Functions[i]; if ((strcmp(theFunc->Name, "GetTuple") == 0 || strcmp(theFunc->Name, "GetTupleValue") == 0) && theFunc->ReturnValue && theFunc->ReturnValue->Count == 0 && theFunc->NumberOfParameters == 1 && theFunc->Parameters[0]->Type == VTK_PARSE_ID_TYPE) { theFunc->ReturnValue->CountHint = countMethod; } else if ((strcmp(theFunc->Name, "SetTuple") == 0 || strcmp(theFunc->Name, "SetTupleValue") == 0 || strcmp(theFunc->Name, "GetTuple") == 0 || strcmp(theFunc->Name, "GetTupleValue") == 0 || strcmp(theFunc->Name, "InsertTuple") == 0 || strcmp(theFunc->Name, "InsertTupleValue") == 0) && theFunc->NumberOfParameters == 2 && theFunc->Parameters[0]->Type == VTK_PARSE_ID_TYPE && theFunc->Parameters[1]->Count == 0) { theFunc->Parameters[1]->CountHint = countMethod; } else if ((strcmp(theFunc->Name, "InsertNextTuple") == 0 || strcmp(theFunc->Name, "InsertNextTupleValue") == 0) && theFunc->NumberOfParameters == 1 && theFunc->Parameters[0]->Count == 0) { theFunc->Parameters[0]->CountHint = countMethod; } } } /* add hints for interpolator Interpolate methods */ if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkAbstractImageInterpolator")) { countMethod = "GetNumberOfComponents()"; for (i = 0; i < data->NumberOfFunctions; i++) { theFunc = data->Functions[i]; if (strcmp(theFunc->Name, "Interpolate") == 0 && theFunc->NumberOfParameters == 2 && theFunc->Parameters[0]->Type == (VTK_PARSE_DOUBLE_PTR|VTK_PARSE_CONST) && theFunc->Parameters[0]->Count == 3 && theFunc->Parameters[1]->Type == VTK_PARSE_DOUBLE_PTR && theFunc->Parameters[1]->Count == 0) { theFunc->Parameters[1]->CountHint = countMethod; } } } for (i = 0; i < data->NumberOfFunctions; i++) { theFunc = data->Functions[i]; /* hints for constructors that take arrays */ if (vtkWrap_IsConstructor(data, theFunc) && theFunc->NumberOfParameters == 1 && vtkWrap_IsPointer(theFunc->Parameters[0]) && vtkWrap_IsNumeric(theFunc->Parameters[0]) && theFunc->Parameters[0]->Count == 0 && hinfo) { count = vtkWrap_GetTupleSize(data, hinfo); if (count) { char counttext[24]; sprintf(counttext, "%d", count); theFunc->Parameters[0]->Count = count; vtkParse_AddStringToArray( &theFunc->Parameters[0]->Dimensions, &theFunc->Parameters[0]->NumberOfDimensions, vtkParse_CacheString(finfo->Strings, counttext, strlen(counttext))); } } /* hints for operator[] index range */ if (theFunc->IsOperator && theFunc->Name && strcmp(theFunc->Name, "operator[]") == 0) { if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkTuple")) { theFunc->SizeHint = "GetSize()"; } else if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArrayCoordinates") || vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArrayExtents") || vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArraySort")) { theFunc->SizeHint = "GetDimensions()"; } else if (vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArrayExtentsList") || vtkWrap_IsTypeOf(hinfo, data->Name, "vtkArrayWeights")) { theFunc->SizeHint = "GetCount()"; } } } }
/* print the parsed structures */ int main(int argc, char *argv[]) { OptionInfo *options; FileInfo *file_info; ClassInfo *data; FILE *fp; int i; /* pre-define a macro to identify the language */ vtkParse_DefineMacro("__VTK_WRAP_JAVA__", 0); /* get command-line args and parse the header file */ file_info = vtkParse_Main(argc, argv); /* some utility functions require the string cache */ stringCache = file_info->Strings; /* get the command-line options */ options = vtkParse_GetCommandLineOptions(); /* get the hierarchy info for accurate typing */ if (options->HierarchyFileNames) { hierarchyInfo = vtkParseHierarchy_ReadFiles( options->NumberOfHierarchyFileNames, options->HierarchyFileNames); } /* 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 main class */ data = file_info->MainClass; if (data == NULL || data->IsExcluded) { fclose(fp); exit(0); } if (data->Template) { fclose(fp); exit(0); } for (i = 0; i < data->NumberOfSuperClasses; ++i) { if (strchr(data->SuperClasses[i], '<')) { fclose(fp); exit(0); } } if (hierarchyInfo) { if (!vtkWrap_IsTypeOf(hierarchyInfo, data->Name, "vtkObjectBase")) { fclose(fp); exit(0); } /* resolve using declarations within the header files */ vtkWrap_ApplyUsingDeclarations(data, file_info, hierarchyInfo); /* expand typedefs */ vtkWrap_ExpandTypedefs(data, file_info, hierarchyInfo); } fprintf(fp,"// java wrapper for %s object\n//\n",data->Name); fprintf(fp,"\npackage vtk;\n"); if (strcmp("vtkObjectBase",data->Name)) { fprintf(fp,"import vtk.*;\n"); } fprintf(fp,"\npublic class %s",data->Name); if (strcmp("vtkObjectBase",data->Name)) { if (data->NumberOfSuperClasses) { fprintf(fp," extends %s",data->SuperClasses[0]); } } fprintf(fp,"\n{\n"); /* insert function handling code here */ for (i = 0; i < data->NumberOfFunctions; i++) { currentFunction = data->Functions[i]; outputFunction(fp, data); } HandleDataArray(fp, data); if (!data->NumberOfSuperClasses) { if ( strcmp("vtkObjectBase",data->Name) == 0 ) { fprintf(fp,"\n public static vtk.vtkJavaMemoryManager JAVA_OBJECT_MANAGER = new vtk.vtkJavaMemoryManagerImpl();"); } if (!data->IsAbstract) { fprintf(fp,"\n public %s() {", data->Name); fprintf(fp,"\n this.vtkId = this.VTKInit();"); fprintf(fp,"\n vtkObjectBase.JAVA_OBJECT_MANAGER.registerJavaObject(this.vtkId, this);"); fprintf(fp,"\n}\n"); } else { fprintf(fp,"\n public %s() { super(); }\n",data->Name); } fprintf(fp,"\n public %s(long id) {", data->Name); fprintf(fp,"\n super();"); fprintf(fp,"\n this.vtkId = id;"); fprintf(fp,"\n this.VTKRegister();"); fprintf(fp,"\n vtkObjectBase.JAVA_OBJECT_MANAGER.registerJavaObject(this.vtkId, this);"); fprintf(fp,"\n}\n"); fprintf(fp,"\n protected long vtkId;\n"); fprintf(fp,"\n public long GetVTKId() { return this.vtkId; }"); /* if we are a base class and have a delete method */ if (data->HasDelete) { fprintf(fp,"\n public static native void VTKDeleteReference(long id);"); fprintf(fp,"\n public static native String VTKGetClassNameFromReference(long id);"); fprintf(fp,"\n protected native void VTKDelete();"); fprintf(fp,"\n protected native void VTKRegister();"); fprintf(fp,"\n public void Delete() {"); fprintf(fp,"\n vtkObjectBase.JAVA_OBJECT_MANAGER.unRegisterJavaObject(this.vtkId);"); fprintf(fp,"\n this.vtkId = 0;"); fprintf(fp,"\n }"); } } else { fprintf(fp,"\n public %s() { super(); }\n",data->Name); fprintf(fp,"\n public %s(long id) { super(id); }\n",data->Name); } if (!data->IsAbstract) { fprintf(fp," public native long VTKInit();\n"); } /* fprintf(fp," protected native void VTKCastInit();\n"); */ if (!strcmp("vtkObjectBase",data->Name)) { /* Add the Print method to vtkObjectBase. */ fprintf(fp," public native String Print();\n"); /* Add the default toString from java object */ fprintf(fp," public String toString() { return Print(); }\n"); } if (!strcmp("vtkObject",data->Name)) { fprintf(fp," public native int AddObserver(String id0, Object id1, String id2);\n"); } fprintf(fp,"\n}\n"); fclose(fp); { size_t cc; size_t len; char *dir; char *fname; /*const */char javaDone[] = "VTKJavaWrapped"; FILE* tfp; fname = options->OutputFileName; dir = (char*)malloc(strlen(fname) + strlen(javaDone) + 2); sprintf(dir, "%s", fname); len = strlen(dir); for ( cc = len-1; cc > 0; cc -- ) { if ( dir[cc] == '/' || dir[cc] == '\\' ) { dir[cc+1] = 0; break; } } strcat(dir, javaDone); tfp = fopen(dir, "w"); if ( tfp ) { fprintf(tfp, "File: %s\n", fname); fclose(tfp); } free(dir); } vtkParse_Free(file_info); return 0; }
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; }