/* Save a copy of each non-const array arg, so that we can check
* if they were changed by the method call */
void vtkWrapPython_SaveArgs(FILE *fp, FunctionInfo *currentFunction)
{
const char *asterisks = "**********";
ValueInfo *arg;
int i, j, n, m;
int noneDone = 1;
/* do nothing for SetVector macros */
if (vtkWrap_IsSetVectorMethod(currentFunction))
{
return;
}
m = vtkWrap_CountWrappedParameters(currentFunction);
/* save arrays for args that are non-const */
for (i = 0; i < m; i++)
{
arg = currentFunction->Parameters[i];
n = arg->NumberOfDimensions;
if (n < 1 && (vtkWrap_IsArray(arg) || vtkWrap_IsPODPointer(arg) ||
vtkWrap_IsCharPointer(arg)))
{
n = 1;
}
if ((vtkWrap_IsArray(arg) || vtkWrap_IsNArray(arg) ||
vtkWrap_IsPODPointer(arg) || vtkWrap_IsCharPointer(arg)) &&
(arg->Type & VTK_PARSE_CONST) == 0 &&
!vtkWrap_IsRef(arg))
{
noneDone = 0;
fprintf(fp,
" ap.Save(%.*stemp%d, %.*ssave%d, ",
(n-1), asterisks, i, (n-1), asterisks, i);
if (vtkWrap_IsNArray(arg))
{
for (j = 0; j < arg->NumberOfDimensions; j++)
{
fprintf(fp, "%ssize%d[%d]", (j == 0 ? "" : "*"), i, j);
}
}
else
{
fprintf(fp, "size%d", i);
}
fprintf(fp, ");\n");
}
}
if (!noneDone)
{
fprintf(fp,
"\n");
}
}
static char *vtkWrapPython_FormatString(FunctionInfo *currentFunction)
{
static char result[2048]; /* max literal string length */
size_t currPos = 0;
ValueInfo *arg;
unsigned int argtype;
int i;
int totalArgs, requiredArgs;
totalArgs = vtkWrap_CountWrappedParameters(currentFunction);
requiredArgs = vtkWrap_CountRequiredArguments(currentFunction);
for (i = 0; i < totalArgs; i++)
{
arg = currentFunction->Parameters[i];
argtype = (arg->Type & VTK_PARSE_UNQUALIFIED_TYPE);
if (i == requiredArgs)
{
/* make all following arguments optional */
result[currPos++] = '|';
}
/* add the format char to the string */
result[currPos++] = vtkWrapPython_FormatChar(argtype);
if (((argtype & VTK_PARSE_INDIRECT) == VTK_PARSE_POINTER ||
(argtype & VTK_PARSE_INDIRECT) == VTK_PARSE_ARRAY) &&
argtype != VTK_PARSE_OBJECT_PTR &&
argtype != VTK_PARSE_QOBJECT_PTR)
{
/* back up and replace the char */
--currPos;
if (argtype == VTK_PARSE_CHAR_PTR)
{
/* string with "None" equivalent to "NULL" */
result[currPos++] = 'z';
}
else if (argtype == VTK_PARSE_VOID_PTR)
{
/* buffer type, None not allowed to avoid passing NULL pointer */
result[currPos++] = 's';
result[currPos++] = '#';
}
else
{
result[currPos++] = 'O';
}
}
}
result[currPos++] = '\0';
return result;
}
/* Free any temporaries that were needed for the C++ method call*/
static void vtkWrapPython_FreeTemporaries(
FILE *fp, FunctionInfo *currentFunction)
{
ValueInfo *arg;
int i, j, n;
n = vtkWrap_CountWrappedParameters(currentFunction);
/* check array value change for args that are non-const */
j = 0;
for (i = 0; i < n; i++)
{
arg = currentFunction->Parameters[i];
if (vtkWrap_IsVoidPointer(arg))
{
/* release Py_buffer objects */
fprintf(fp,
"#if PY_VERSION_HEX >= 0x02060000\n"
" if (pbuf%d.obj != 0)\n"
" {\n"
" PyBuffer_Release(&pbuf%d);\n"
" }\n"
"#endif\n",
i, i);
}
else if (vtkWrap_IsSpecialObject(arg) &&
!vtkWrap_IsNonConstRef(arg))
{
/* decref any PyObjects created via conversion constructors */
fprintf(fp,
" Py_XDECREF(pobj%d);\n",
i);
j = 1;
}
else if (arg->CountHint || vtkWrap_IsPODPointer(arg))
{
/* free any temporary arrays */
fprintf(fp,
" if (temp%d != small%d)\n"
" {\n"
" delete [] temp%d;\n"
" }\n",
i, i, i);
j = 1;
}
}
if (j)
{
fprintf(fp,
"\n");
}
}
/* Write the code to convert the arguments with vtkPythonArgs */
static void vtkWrapPython_GetAllParameters(
FILE *fp, ClassInfo *data, FunctionInfo *currentFunction)
{
ValueInfo *arg;
int requiredArgs, totalArgs;
int i;
totalArgs = vtkWrap_CountWrappedParameters(currentFunction);
requiredArgs = vtkWrap_CountRequiredArguments(currentFunction);
if (requiredArgs == totalArgs)
{
fprintf(fp,
"ap.CheckArgCount(%d)",
totalArgs);
}
else
{
fprintf(fp,
"ap.CheckArgCount(%d, %d)",
requiredArgs, totalArgs);
}
for (i = 0; i < totalArgs; i++)
{
arg = currentFunction->Parameters[i];
fprintf(fp, " &&\n"
" ");
if (i >= requiredArgs)
{
fprintf(fp, "(ap.NoArgsLeft() || ");
}
vtkWrapPython_GetSingleArgument(fp, data, i, arg, 0);
if (i >= requiredArgs)
{
fprintf(fp, ")");
}
if (vtkWrap_IsFunction(arg))
{
break;
}
}
}
int vtkWrap_CountRequiredArguments(FunctionInfo *f)
{
int requiredArgs = 0;
int totalArgs;
int i;
totalArgs = vtkWrap_CountWrappedParameters(f);
for (i = 0; i < totalArgs; i++)
{
if (f->Parameters[i]->Value == NULL ||
vtkWrap_IsArray(f->Parameters[i]) ||
vtkWrap_IsNArray(f->Parameters[i]))
{
requiredArgs = i+1;
}
}
return requiredArgs;
}
const char *vtkWrapText_PythonSignature(
FunctionInfo *currentFunction)
{
/* string is intentionally not freed until the program exits */
static struct vtkWPString staticString = { NULL, 0, 0 };
struct vtkWPString *result;
ValueInfo *arg, *ret;
const char *parens[2] = { "(", ")" };
const char *braces[2] = { "[", "]" };
const char **delims;
int i, n;
n = vtkWrap_CountWrappedParameters(currentFunction);
result = &staticString;
result->len = 0;
/* print out the name of the method */
vtkWPString_Append(result, "V.");
vtkWPString_Append(result, currentFunction->Name);
/* print the arg list */
vtkWPString_Append(result, "(");
for (i = 0; i < n; i++)
{
arg = currentFunction->Parameters[i];
if (i != 0)
{
vtkWPString_Append(result, ", ");
}
delims = parens;
if (!vtkWrap_IsConst(arg) &&
!vtkWrap_IsSetVectorMethod(currentFunction))
{
delims = braces;
}
vtkWrapText_PythonTypeSignature(result, delims, arg);
}
vtkWPString_Append(result, ")");
/* if this is a void method, we are finished */
/* otherwise, print "->" and the return type */
ret = currentFunction->ReturnValue;
if (ret && (ret->Type & VTK_PARSE_UNQUALIFIED_TYPE) != VTK_PARSE_VOID)
{
vtkWPString_Append(result, " -> ");
vtkWrapText_PythonTypeSignature(result, parens, ret);
}
if (currentFunction->Signature)
{
vtkWPString_Append(result, "\nC++: ");
vtkWPString_Append(result, currentFunction->Signature);
}
return result->str;
}
/* Write back to all the reference arguments and array arguments that
* were passed, but only write to arrays if the array has changed and
* the array arg was non-const */
static void vtkWrapPython_WriteBackToArgs(
FILE *fp, FunctionInfo *currentFunction)
{
const char *asterisks = "**********";
ValueInfo *arg;
int i, j, n, m;
/* do nothing for SetVector macros */
if (vtkWrap_IsSetVectorMethod(currentFunction))
{
return;
}
m = vtkWrap_CountWrappedParameters(currentFunction);
/* check array value change for args that are non-const */
for (i = 0; i < m; i++)
{
arg = currentFunction->Parameters[i];
n = arg->NumberOfDimensions;
if (n < 1 && (vtkWrap_IsArray(arg) || vtkWrap_IsPODPointer(arg)))
{
n = 1;
}
if (vtkWrap_IsNonConstRef(arg) &&
!vtkWrap_IsObject(arg))
{
fprintf(fp,
" if (!ap.ErrorOccurred())\n"
" {\n"
" ap.SetArgValue(%d, temp%d);\n"
" }\n",
i, i);
}
else if ((vtkWrap_IsArray(arg) || vtkWrap_IsNArray(arg) ||
vtkWrap_IsPODPointer(arg)) &&
!vtkWrap_IsConst(arg) &&
!vtkWrap_IsSetVectorMethod(currentFunction))
{
fprintf(fp,
" if (ap.ArrayHasChanged(%.*stemp%d, %.*ssave%d, ",
(n-1), asterisks, i, (n-1), asterisks, i);
if (vtkWrap_IsNArray(arg))
{
for (j = 0; j < arg->NumberOfDimensions; j++)
{
fprintf(fp, "%ssize%d[%d]", (j == 0 ? "" : "*"), i, j);
}
}
else
{
fprintf(fp, "size%d", i);
}
fprintf(fp, ") &&\n"
" !ap.ErrorOccurred())\n"
" {\n");
if (vtkWrap_IsNArray(arg))
{
fprintf(fp,
" ap.SetNArray(%d, %.*stemp%d, %d, size%d);\n",
i, (n-1), asterisks, i, n, i);
}
else
{
fprintf(fp,
" ap.SetArray(%d, temp%d, size%d);\n",
i, i, i);
}
fprintf(fp,
" }\n"
"\n");
}
}
}
/* generate the code that calls the C++ method */
static void vtkWrapPython_GenerateMethodCall(
FILE *fp, FunctionInfo *currentFunction, ClassInfo *data,
HierarchyInfo *hinfo, int is_vtkobject)
{
char methodname[256];
ValueInfo *arg;
int totalArgs;
int is_constructor;
int i, k, n;
totalArgs = vtkWrap_CountWrappedParameters(currentFunction);
is_constructor = vtkWrap_IsConstructor(data, currentFunction);
/* for vtkobjects, do a bound call and an unbound call */
n = 1;
if (is_vtkobject &&
!currentFunction->IsStatic &&
!currentFunction->IsPureVirtual &&
!is_constructor)
{
n = 2;
}
if (!is_constructor &&
!vtkWrap_IsVoid(currentFunction->ReturnValue))
{
/* temp variable for C++-type return value */
fprintf(fp, " ");
vtkWrap_DeclareVariable(fp, data, currentFunction->ReturnValue,
"tempr", -1, VTK_WRAP_RETURN | VTK_WRAP_NOSEMI);
fprintf(fp, " =");
}
/* handle both bound and unbound calls */
if (n == 2)
{
if (!is_constructor &&
!vtkWrap_IsVoid(currentFunction->ReturnValue))
{
fprintf(fp, " (ap.IsBound() ?\n"
" ");
}
else
{
fprintf(fp,
" if (ap.IsBound())\n"
" {\n"
" ");
}
}
/* print the code that calls the method */
for (k = 0; k < n; k++)
{
if (k == 1)
{
/* unbound method call */
sprintf(methodname, "op->%s::%s",
data->Name, currentFunction->Name);
}
else if (currentFunction->IsStatic)
{
/* static method call */
sprintf(methodname, "%s::%s",
data->Name, currentFunction->Name);
}
else if (is_constructor)
{
/* constructor call */
sprintf(methodname, "new %s", currentFunction->Name);
}
else
{
/* standard bound method call */
sprintf(methodname, "op->%s", currentFunction->Name);
}
if (is_constructor)
{
fprintf(fp,
" %s *op = new %s(",
data->Name, data->Name);
}
else if (vtkWrap_IsVoid(currentFunction->ReturnValue))
{
fprintf(fp,
" %s(",
methodname);
}
else if (vtkWrap_IsRef(currentFunction->ReturnValue))
{
fprintf(fp,
" &%s(",
methodname);
}
else
{
fprintf(fp,
" %s(",
methodname);
}
/* print all the arguments in the call */
for (i = 0; i < totalArgs; i++)
{
arg = currentFunction->Parameters[i];
if (vtkWrap_IsFunction(arg))
{
fprintf(fp,"\n"
" (temp%d == Py_None ? NULL : vtkPythonVoidFunc),\n"
" (temp%d == Py_None ? NULL : temp%d));\n",
i, i, i);
fprintf(fp,
" if (temp%d != Py_None)\n"
" {\n"
" Py_INCREF(temp%d);\n"
" }\n"
" %sArgDelete(\n"
" (temp%d == Py_None ? NULL : vtkPythonVoidFuncArgDelete)",
i, i, methodname, i);
break;
}
if (i)
{
fprintf(fp,", ");
}
if ((vtkWrap_IsSpecialObject(arg) ||
vtkWrap_IsQtObject(arg)) &&
!vtkWrap_IsPointer(arg))
{
fprintf(fp, "*temp%i", i);
}
else
{
fprintf(fp, "temp%i", i);
}
}
fprintf(fp, ")");
/* handle ternary operator for ap.IsBound() */
if (n == 2)
{
if (!is_constructor &&
!vtkWrap_IsVoid(currentFunction->ReturnValue))
{
fprintf(fp, (k == 0 ? " :\n " : ");\n"));
}
else if (k == 0)
{
fprintf(fp, ";\n"
" }\n"
" else\n"
" {\n"
" ");
}
else
{
fprintf(fp, ";\n"
" }\n");
}
}
else
{
fprintf(fp, ";\n");
}
}
if (is_constructor)
{
/* initialize tuples created with default constructor */
if (currentFunction->NumberOfParameters == 0 && hinfo)
{
n = vtkWrap_GetTupleSize(data, hinfo);
for (i = 0; i < n; i++)
{
fprintf(fp,
" (*op)[%d] = 0;\n",
i);
}
}
}
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;
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");
}
/* 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 vtkWrapPython_OverloadMethodDef(
FILE *fp, const char *classname, ClassInfo *data, int *overloadMap,
FunctionInfo **wrappedFunctions, int numberOfWrappedFunctions,
int fnum, int numberOfOccurrences, int is_vtkobject, int all_legacy)
{
char occSuffix[8];
int occ, occCounter;
FunctionInfo *theOccurrence;
FunctionInfo *theFunc;
int totalArgs, requiredArgs;
int i;
int putInTable;
theFunc = wrappedFunctions[fnum];
if (all_legacy)
{
fprintf(fp,
"#if !defined(VTK_LEGACY_REMOVE)\n");
}
fprintf(fp,
"static PyMethodDef Py%s_%s_Methods[] = {\n",
classname, theFunc->Name);
occCounter = 0;
for (occ = fnum; occ < numberOfWrappedFunctions; occ++)
{
theOccurrence = wrappedFunctions[occ];
if (theOccurrence->Name == 0 ||
strcmp(theOccurrence->Name, theFunc->Name) != 0)
{
continue;
}
occCounter++;
totalArgs = vtkWrap_CountWrappedParameters(theOccurrence);
requiredArgs = vtkWrap_CountRequiredArguments(theOccurrence);
putInTable = 0;
/* all conversion constructors must go into the table */
if (vtkWrap_IsConstructor(data, theOccurrence) &&
requiredArgs <= 1 && totalArgs >= 1 &&
!theOccurrence->IsExplicit)
{
putInTable = 1;
}
/* all methods that overlap with others must go in the table */
for (i = requiredArgs; i <= totalArgs; i++)
{
if (overloadMap[i] == -1)
{
putInTable = 1;
}
}
if (!putInTable)
{
continue;
}
if (theOccurrence->IsLegacy && !all_legacy)
{
fprintf(fp,
"#if !defined(VTK_LEGACY_REMOVE)\n");
}
/* method suffix to distinguish between signatures */
occSuffix[0] = '\0';
if (numberOfOccurrences > 1)
{
sprintf(occSuffix, "_s%d", occCounter);
}
fprintf(fp,
" {NULL, Py%s_%s%s, METH_VARARGS%s,\n"
" (char*)\"%s\"},\n",
classname, wrappedFunctions[occ]->Name,
occSuffix,
theOccurrence->IsStatic ? " | METH_STATIC" : "",
vtkWrapPython_ArgCheckString(
(is_vtkobject && !theOccurrence->IsStatic),
wrappedFunctions[occ]));
if (theOccurrence->IsLegacy && !all_legacy)
{
fprintf(fp,
"#endif\n");
}
}
fprintf(fp,
" {NULL, NULL, 0, NULL}\n"
"};\n");
if (all_legacy)
{
fprintf(fp,
"#endif\n");
}
fprintf(fp,
"\n");
}
int *vtkWrapPython_ArgCountToOverloadMap(
FunctionInfo **wrappedFunctions, int numberOfWrappedFunctions,
int fnum, int is_vtkobject, int *nmax, int *overlap)
{
static int overloadMap[512];
int totalArgs, requiredArgs;
int occ, occCounter;
FunctionInfo *theOccurrence;
FunctionInfo *theFunc;
int mixed_static, any_static;
int i;
*nmax = 0;
*overlap = 0;
theFunc = wrappedFunctions[fnum];
any_static = 0;
mixed_static = 0;
for (i = fnum; i < numberOfWrappedFunctions; i++)
{
if (wrappedFunctions[i]->Name &&
strcmp(wrappedFunctions[i]->Name, theFunc->Name) == 0)
{
if (wrappedFunctions[i]->IsStatic)
{
any_static = 1;
}
else if (any_static)
{
mixed_static = 1;
}
}
}
for (i = 0; i < 100; i++)
{
overloadMap[i] = 0;
}
occCounter = 0;
for (occ = fnum; occ < numberOfWrappedFunctions; occ++)
{
theOccurrence = wrappedFunctions[occ];
if (theOccurrence->Name == 0 ||
strcmp(theOccurrence->Name, theFunc->Name) != 0)
{
continue;
}
occCounter++;
totalArgs = vtkWrap_CountWrappedParameters(theOccurrence);
requiredArgs = vtkWrap_CountRequiredArguments(theOccurrence);
/* vtkobject calls might have an extra "self" arg in front */
if (mixed_static && is_vtkobject &&
!theOccurrence->IsStatic)
{
totalArgs++;
}
if (totalArgs > *nmax)
{
*nmax = totalArgs;
}
for (i = requiredArgs; i <= totalArgs && i < 100; i++)
{
if (overloadMap[i] == 0)
{
overloadMap[i] = occCounter;
}
else
{
overloadMap[i] = -1;
*overlap = 1;
}
}
}
return overloadMap;
}
static char *vtkWrapPython_ArgCheckString(
int isvtkobjmethod, FunctionInfo *currentFunction)
{
static char result[2048]; /* max literal string length */
char pythonname[1024];
size_t currPos = 0;
ValueInfo *arg;
unsigned int argtype;
int i, j, k;
int totalArgs;
totalArgs = vtkWrap_CountWrappedParameters(currentFunction);
if (currentFunction->IsExplicit)
{
result[currPos++] = '-';
}
if (isvtkobjmethod)
{
result[currPos++] = '@';
}
strcpy(&result[currPos], vtkWrapPython_FormatString(currentFunction));
currPos = strlen(result);
for (i = 0; i < totalArgs; i++)
{
arg = currentFunction->Parameters[i];
argtype = (arg->Type & VTK_PARSE_UNQUALIFIED_TYPE);
if ((argtype & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FUNCTION)
{
strcpy(&result[currPos], " func");
currPos += 5;
}
else if (argtype == VTK_PARSE_BOOL ||
argtype == VTK_PARSE_BOOL_REF)
{
strcpy(&result[currPos], " bool");
currPos += 5;
}
else if (argtype == VTK_PARSE_UNICODE_STRING ||
argtype == VTK_PARSE_UNICODE_STRING_REF)
{
strcpy(&result[currPos], " unicode");
currPos += 8;
}
else if (argtype == VTK_PARSE_OBJECT_REF ||
argtype == VTK_PARSE_OBJECT_PTR ||
argtype == VTK_PARSE_OBJECT ||
argtype == VTK_PARSE_UNKNOWN ||
argtype == VTK_PARSE_UNKNOWN_REF ||
argtype == VTK_PARSE_UNKNOWN_PTR ||
argtype == VTK_PARSE_QOBJECT ||
argtype == VTK_PARSE_QOBJECT_REF ||
argtype == VTK_PARSE_QOBJECT_PTR)
{
vtkWrapPython_PythonicName(arg->Class, pythonname);
result[currPos++] = ' ';
if ((argtype == VTK_PARSE_OBJECT_REF ||
argtype == VTK_PARSE_UNKNOWN_REF) &&
(arg->Type & VTK_PARSE_CONST) == 0)
{
result[currPos++] = '&';
}
else if (argtype == VTK_PARSE_QOBJECT_REF)
{
result[currPos++] = '&';
}
else if (argtype == VTK_PARSE_OBJECT_PTR ||
argtype == VTK_PARSE_UNKNOWN_PTR ||
argtype == VTK_PARSE_QOBJECT_PTR)
{
result[currPos++] = '*';
}
strcpy(&result[currPos], pythonname);
currPos += strlen(pythonname);
}
else if (vtkWrap_IsArray(arg) || vtkWrap_IsNArray(arg) ||
vtkWrap_IsPODPointer(arg))
{
result[currPos++] = ' ';
result[currPos++] = '*';
result[currPos++] = vtkWrapPython_FormatChar(argtype);
if (vtkWrap_IsNArray(arg))
{
for (j = 1; j < arg->NumberOfDimensions; j++)
{
result[currPos++] = '[';
for (k = 0; arg->Dimensions[j][k]; k++)
{
result[currPos++] = arg->Dimensions[j][k];
}
result[currPos++] = ']';
}
}
result[currPos] = '\0';
}
}
return result;
}
/* generate includes for any special types that are used */
static void vtkWrapPython_GenerateSpecialHeaders(
FILE *fp, FileInfo *file_info, HierarchyInfo *hinfo)
{
const char **types;
int numTypes = 0;
FunctionInfo *currentFunction;
int i, j, k, n, m, ii, nn;
unsigned int aType;
const char *classname;
const char *ownincfile = "";
ClassInfo *data;
types = (const char **)malloc(1000*sizeof(const char *));
/* always include vtkVariant, it is often used as a template arg
for templated array types, and the file_info doesn't tell us
what types each templated class is instantiated for (that info
might be in the .cxx files, which we cannot access here) */
types[numTypes++] = "vtkVariant";
nn = file_info->Contents->NumberOfClasses;
for (ii = 0; ii < nn; ii++)
{
data = file_info->Contents->Classes[ii];
n = data->NumberOfFunctions;
for (i = 0; i < n; i++)
{
currentFunction = data->Functions[i];
if (currentFunction->Access == VTK_ACCESS_PUBLIC)
{
classname = "void";
aType = VTK_PARSE_VOID;
if (currentFunction->ReturnValue)
{
classname = currentFunction->ReturnValue->Class;
aType = currentFunction->ReturnValue->Type;
}
m = vtkWrap_CountWrappedParameters(currentFunction);
for (j = -1; j < m; j++)
{
if (j >= 0)
{
classname = currentFunction->Parameters[j]->Class;
aType = currentFunction->Parameters[j]->Type;
}
/* we don't require the header file if it is just a pointer */
if ((aType & VTK_PARSE_INDIRECT) != VTK_PARSE_POINTER)
{
if ((aType & VTK_PARSE_BASE_TYPE) == VTK_PARSE_STRING)
{
classname = "vtkStdString";
}
else if ((aType & VTK_PARSE_BASE_TYPE) == VTK_PARSE_UNICODE_STRING)
{
classname = "vtkUnicodeString";
}
else if ((aType & VTK_PARSE_BASE_TYPE) != VTK_PARSE_OBJECT)
{
classname = 0;
}
}
else
{
classname = 0;
}
/* we already include our own header */
if (classname && strcmp(classname, data->Name) != 0)
{
for (k = 0; k < numTypes; k++)
{
/* make a unique list of all classes found */
if (strcmp(classname, types[k]) == 0)
{
break;
}
}
if (k == numTypes)
{
if (numTypes > 0 && (numTypes % 1000) == 0)
{
types = (const char **)realloc((char **)types,
(numTypes + 1000)*sizeof(const char *));
}
types[numTypes++] = classname;
}
}
}
}
}
}
/* get our own include file (returns NULL if hinfo is NULL) */
data = file_info->MainClass;
if (!data && file_info->Contents->NumberOfClasses > 0)
{
data = file_info->Contents->Classes[0];
}
if (data)
{
ownincfile = vtkWrapPython_ClassHeader(hinfo, data->Name);
}
/* for each unique type found in the file */
for (i = 0; i < numTypes; i++)
{
const char *incfile;
incfile = vtkWrapPython_ClassHeader(hinfo, types[i]);
if (incfile)
{
/* make sure it doesn't share our header file */
if (ownincfile == 0 || strcmp(incfile, ownincfile) != 0)
{
fprintf(fp,
"#include \"%s\"\n",
incfile);
}
}
}
free((char **)types);
}
/* Write the code to convert the arguments with vtkPythonArgs */
static void vtkWrapPython_GetAllParameters(
FILE *fp, ClassInfo *data, FunctionInfo *currentFunction)
{
ValueInfo *arg;
int requiredArgs, totalArgs;
int i;
totalArgs = vtkWrap_CountWrappedParameters(currentFunction);
requiredArgs = vtkWrap_CountRequiredArguments(currentFunction);
if (requiredArgs == totalArgs)
{
fprintf(fp,
"ap.CheckArgCount(%d)",
totalArgs);
}
else
{
fprintf(fp,
"ap.CheckArgCount(%d, %d)",
requiredArgs, totalArgs);
}
for (i = 0; i < totalArgs; i++)
{
arg = currentFunction->Parameters[i];
fprintf(fp, " &&\n"
" ");
if (i >= requiredArgs)
{
fprintf(fp, "(ap.NoArgsLeft() || ");
}
vtkWrapPython_GetSingleArgument(fp, data, i, arg, 0);
if (i >= requiredArgs)
{
fprintf(fp, ")");
}
if (vtkWrap_IsFunction(arg))
{
break;
}
}
/* loop again, check sizes against any size hints */
for (i = 0; i < totalArgs; i++)
{
arg = currentFunction->Parameters[i];
if (arg->CountHint && !vtkWrap_IsRef(arg))
{
fprintf(fp, " &&\n"
" ap.CheckSizeHint(%d, size%d, ",
i, i);
/* write out the code that gives the size */
vtkWrapPython_SubstituteCode(fp, data, currentFunction,
arg->CountHint);
fprintf(fp, ")");
}
if (vtkWrap_IsFunction(arg))
{
break;
}
}
}