/* 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"); }
void vtkWrap_DeclareVariable( FILE *fp, ValueInfo *val, const char *name, int i, int flags) { unsigned int aType; int j; if (val == NULL) { return; } aType = (val->Type & VTK_PARSE_UNQUALIFIED_TYPE); /* do nothing for void */ if (aType == VTK_PARSE_VOID || (aType & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FUNCTION) { return; } /* add a couple spaces */ fprintf(fp," "); /* for const * return types, prepend with const */ if ((flags & VTK_WRAP_RETURN) != 0) { if ((val->Type & VTK_PARSE_CONST) != 0 && (aType & VTK_PARSE_INDIRECT) != 0) { fprintf(fp,"const "); } } /* do the same for "const char *" with initializer */ else { if ((val->Type & VTK_PARSE_CONST) != 0 && aType == VTK_PARSE_CHAR_PTR && val->Value && strcmp(val->Value, "0") != 0 && strcmp(val->Value, "NULL") != 0) { fprintf(fp,"const "); } } /* print the type name */ fprintf(fp, "%s ", vtkWrap_GetTypeName(val)); /* indirection */ if ((flags & VTK_WRAP_RETURN) != 0) { /* ref and pointer return values are stored as pointers */ if ((aType & VTK_PARSE_INDIRECT) == VTK_PARSE_POINTER || (aType & VTK_PARSE_INDIRECT) == VTK_PARSE_REF) { fprintf(fp, "*"); } } else { /* objects refs and pointers are always handled via pointers, * other refs are passed by value */ if (aType == VTK_PARSE_CHAR_PTR || aType == VTK_PARSE_VOID_PTR || aType == VTK_PARSE_OBJECT_PTR || aType == VTK_PARSE_OBJECT_REF || aType == VTK_PARSE_OBJECT || vtkWrap_IsQtObject(val)) { fprintf(fp, "*"); } /* arrays of unknown size are handled via pointers */ else if (val->CountHint || vtkWrap_IsPODPointer(val)) { fprintf(fp, "*"); } } /* the variable name */ if (i >= 0) { fprintf(fp,"%s%i", name, i); } else { fprintf(fp,"%s", name); } if ((flags & VTK_WRAP_ARG) != 0) { /* print the array decorators */ if (((aType & VTK_PARSE_POINTER_MASK) != 0) && aType != VTK_PARSE_CHAR_PTR && aType != VTK_PARSE_VOID_PTR && aType != VTK_PARSE_OBJECT_PTR && !vtkWrap_IsQtObject(val) && val->CountHint == NULL && !vtkWrap_IsPODPointer(val)) { if (val->NumberOfDimensions == 1 && val->Count > 0) { fprintf(fp, "[%d]", val->Count); } else { for (j = 0; j < val->NumberOfDimensions; j++) { fprintf(fp, "[%s]", val->Dimensions[j]); } } } /* add a default value */ else if (val->Value) { fprintf(fp, " = %s", val->Value); } else if (aType == VTK_PARSE_CHAR_PTR || aType == VTK_PARSE_VOID_PTR || aType == VTK_PARSE_OBJECT_PTR || aType == VTK_PARSE_OBJECT_REF || aType == VTK_PARSE_OBJECT || vtkWrap_IsQtObject(val)) { fprintf(fp, " = NULL"); } else if (val->CountHint || vtkWrap_IsPODPointer(val)) { fprintf(fp, " = NULL"); } else if (aType == VTK_PARSE_BOOL) { fprintf(fp, " = false"); } } /* finish off with a semicolon */ if ((flags & VTK_WRAP_NOSEMI) == 0) { 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; 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"); }
/* Get the size for vtkDataArray Tuple arguments */ static void vtkWrapPython_GetSizesForArrays( FILE *fp, FunctionInfo *theFunc, int is_vtkobject) { int i, j, n; const char *indentation = ""; const char *mtwo; ValueInfo *arg; n = vtkWrap_CountWrappedParameters(theFunc); j = ((is_vtkobject && !theFunc->IsStatic) ? 1 : 0); for (i = 0; i < n; i++) { arg = theFunc->Parameters[i]; if (arg->CountHint || vtkWrap_IsPODPointer(arg)) { if (j == 1) { fprintf(fp, " if (op)\n" " {\n"); indentation = " "; } j += 2; if (arg->CountHint) { fprintf(fp, "%s size%d = op->%s;\n", indentation, i, arg->CountHint); } else { fprintf(fp, "%s size%d = ap.GetArgSize(%d);\n", indentation, i, i); } /* for non-const arrays, alloc twice as much space */ mtwo = ""; if (!vtkWrap_IsConst(arg) && !vtkWrap_IsSetVectorMethod(theFunc)) { mtwo = "2*"; } fprintf(fp, "%s temp%d = small%d;\n" "%s if (size%d > 4)\n" "%s {\n" "%s temp%d = new %s[%ssize%d];\n" "%s }\n", indentation, i, i, indentation, i, indentation, indentation, i, vtkWrap_GetTypeName(arg), mtwo, i, indentation); if (*mtwo) { fprintf(fp, "%s save%d = &temp%d[size%d];\n", indentation, i, i, i); } } } if (j > 1) { if ((j & 1) != 0) { fprintf(fp, " }\n"); } fprintf(fp, "\n"); } }
void vtkWrap_DeclareVariable( FILE *fp, ClassInfo *data, ValueInfo *val, const char *name, int i, int flags) { unsigned int aType; int j; const char *typeName; char *newTypeName = NULL; if (val == NULL) { return; } aType = (val->Type & VTK_PARSE_UNQUALIFIED_TYPE); /* do nothing for void */ if (aType == VTK_PARSE_VOID || (aType & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FUNCTION) { return; } typeName = vtkWrap_GetTypeName(val); if (vtkWrap_IsEnumMember(data, val)) { /* use a typedef to work around compiler issues when someone used the same name for the enum type as for a variable or method */ newTypeName = (char *)malloc(strlen(name) + 16); if (i >= 0) { sprintf(newTypeName, "%s%i_type", name, i); } else { sprintf(newTypeName, "%s_type", name); } fprintf(fp, " typedef %s::%s %s;\n", data->Name, typeName, newTypeName); typeName = newTypeName; } /* add a couple spaces for indentation*/ fprintf(fp," "); /* for const * return types, prepend with const */ if ((flags & VTK_WRAP_RETURN) != 0) { if ((val->Type & VTK_PARSE_CONST) != 0 && (aType & VTK_PARSE_INDIRECT) != 0) { fprintf(fp,"const "); } } /* do the same for "const char *" with initializer */ else { if ((val->Type & VTK_PARSE_CONST) != 0 && aType == VTK_PARSE_CHAR_PTR && val->Value && strcmp(val->Value, "0") != 0 && strcmp(val->Value, "NULL") != 0) { fprintf(fp,"const "); } } /* print the type name */ fprintf(fp, "%s ", typeName); /* indirection */ if ((flags & VTK_WRAP_RETURN) != 0) { /* ref and pointer return values are stored as pointers */ if ((aType & VTK_PARSE_INDIRECT) == VTK_PARSE_POINTER || (aType & VTK_PARSE_INDIRECT) == VTK_PARSE_REF) { fprintf(fp, "*"); } } else { /* objects refs and pointers are always handled via pointers, * other refs are passed by value */ if (aType == VTK_PARSE_CHAR_PTR || aType == VTK_PARSE_VOID_PTR || aType == VTK_PARSE_OBJECT_PTR || aType == VTK_PARSE_OBJECT_REF || aType == VTK_PARSE_OBJECT || vtkWrap_IsQtObject(val)) { fprintf(fp, "*"); } /* arrays of unknown size are handled via pointers */ else if (val->CountHint || vtkWrap_IsPODPointer(val)) { fprintf(fp, "*"); } } /* the variable name */ if (i >= 0) { fprintf(fp,"%s%i", name, i); } else { fprintf(fp,"%s", name); } if ((flags & VTK_WRAP_ARG) != 0) { /* print the array decorators */ if (((aType & VTK_PARSE_POINTER_MASK) != 0) && aType != VTK_PARSE_CHAR_PTR && aType != VTK_PARSE_VOID_PTR && aType != VTK_PARSE_OBJECT_PTR && !vtkWrap_IsQtObject(val) && val->CountHint == NULL && !vtkWrap_IsPODPointer(val)) { if (val->NumberOfDimensions == 1 && val->Count > 0) { fprintf(fp, "[%d]", val->Count); } else { for (j = 0; j < val->NumberOfDimensions; j++) { fprintf(fp, "[%s]", val->Dimensions[j]); } } } /* add a default value */ else if (val->Value) { fprintf(fp, " = %s", val->Value); } else if (aType == VTK_PARSE_CHAR_PTR || aType == VTK_PARSE_VOID_PTR || aType == VTK_PARSE_OBJECT_PTR || aType == VTK_PARSE_OBJECT_REF || aType == VTK_PARSE_OBJECT || vtkWrap_IsQtObject(val)) { fprintf(fp, " = NULL"); } else if (val->CountHint || vtkWrap_IsPODPointer(val)) { fprintf(fp, " = NULL"); } else if (aType == VTK_PARSE_BOOL) { fprintf(fp, " = false"); } } /* finish off with a semicolon */ if ((flags & VTK_WRAP_NOSEMI) == 0) { fprintf(fp, ";\n"); } free(newTypeName); }
void vtkWrapPython_AddPublicConstants( FILE *fp, const char *indent, const char *dictvar, const char *objvar, NamespaceInfo *data) { const char *nextindent = " "; ValueInfo *val; ValueInfo *firstval; const char *scope; int scopeType, scopeValue; unsigned int valtype; const char *typeName; const char *tname; int j = 0; int count, k, i; size_t l, m; /* get the next indent to use */ l = strlen(indent); m = strlen(nextindent); if (m > l + 2) { nextindent += m - l - 2; } /* get the name of the namespace, or NULL if global */ scope = data->Name; if (scope && scope[0] == '\0') { scope = 0; } /* go through the constants, collecting them by type */ while (j < data->NumberOfConstants) { val = data->Constants[j]; if (val->Access != VTK_ACCESS_PUBLIC) { j++; continue; } /* write a single constant if not numerical */ if (j+1 == data->NumberOfConstants || val->Type != data->Constants[j+1]->Type || !vtkWrap_IsScalar(val) || (!val->IsEnum && !vtkWrap_IsNumeric(val))) { vtkWrapPython_AddConstant( fp, indent, dictvar, objvar, scope, val); j++; continue; } /* get important information about the value */ valtype = val->Type; typeName = (val->IsEnum ? val->Class : vtkWrap_GetTypeName(val)); scopeType = (scope && val->IsEnum && strcmp(typeName, "int") != 0); scopeValue = (scope && val->IsEnum); /* count a series of constants of the same type */ firstval = val; count = 0; for (k = j; k < data->NumberOfConstants; k++) { val = data->Constants[k]; if (val->Access == VTK_ACCESS_PUBLIC) { tname = (val->IsEnum ? val->Class : vtkWrap_GetTypeName(val)); if (val->Type != valtype || strcmp(tname, typeName) != 0) { break; } count++; } } /* if no constants to generate, then continue */ if (count == 0) { j = k; continue; } /* check to make sure there won't be a name conflict between an enum type and some other class member, it happens specifically for vtkImplicitBoolean which has a variable and enum type both with the name OperationType */ if (scopeType) { int conflict = 0; for (i = 0; i < data->NumberOfVariables && !conflict; i++) { conflict = (strcmp(data->Variables[i]->Name, typeName) == 0); } if (conflict) { valtype = VTK_PARSE_INT; typeName = "int"; scopeType = 0; } } /* generate the code */ fprintf(fp, "%sfor (int c = 0; c < %d; c++)\n" "%s {\n", indent, count, indent); if (scopeType) { fprintf(fp, "%s typedef %s::%s cxx_enum_type;\n\n", indent, scope, typeName); } fprintf(fp, "%s static const struct { const char *name; %s value; }\n" "%s constants[%d] = {\n", indent, (scopeType ? "cxx_enum_type" : typeName), indent, count); while (j < k) { val = data->Constants[j++]; if (val->Access == VTK_ACCESS_PUBLIC) { fprintf(fp, "%s { \"%s\", %s%s%s },\n", indent, val->Name, (scopeValue ? scope : ""), (scopeValue ? "::" : ""), (val->IsEnum ? val->Name : val->Value)); } } fprintf(fp, "%s };\n" "\n", indent); vtkWrapPython_AddConstantHelper( fp, nextindent, dictvar, objvar, scope, "constants[c].name", "constants[c].value", firstval); fprintf(fp, "%s }\n\n", indent); } }