/* 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);
}
}
