/* Check whether the copy constructor is public */
int vtkWrap_HasPublicCopyConstructor(ClassInfo *data)
{
FunctionInfo *func;
int i;
for (i = 0; i < data->NumberOfFunctions; i++)
{
func = data->Functions[i];
if (vtkWrap_IsConstructor(data, func) &&
func->NumberOfParameters == 1 &&
func->Parameters[0]->Class &&
strcmp(func->Parameters[0]->Class, data->Name) == 0 &&
func->Access != VTK_ACCESS_PUBLIC)
{
return 0;
}
}
return 1;
}
/* Create the docstring for a class, and print it to fp */
void vtkWrapPython_ClassDoc(
FILE *fp, FileInfo *file_info, ClassInfo *data, HierarchyInfo *hinfo,
int is_vtkobject)
{
char pythonname[1024];
const char *supername;
char *cp;
const char *ccp = NULL;
size_t i, n;
size_t briefmax = 255;
int j;
char temp[500];
char *comment;
if (data == file_info->MainClass && file_info->NameComment)
{
/* use the old VTK-style class description */
fprintf(fp,
" \"%s\\n\",\n",
vtkWrapText_QuoteString(
vtkWrapText_FormatComment(file_info->NameComment, 70), 500));
}
else if (data->Comment)
{
strncpy(temp, data->Name, briefmax);
temp[briefmax] = '\0';
i = strlen(temp);
temp[i++] = ' ';
temp[i++] = '-';
if (data->Comment[0] != ' ')
{
temp[i++] = ' ';
}
/* extract the brief comment, if present */
ccp = data->Comment;
while (i < briefmax && *ccp != '\0')
{
/* a blank line ends the brief comment */
if (ccp[0] == '\n' && ccp[1] == '\n')
{
break;
}
/* fuzzy: capital letter or a new command on next line ends brief */
if (ccp[0] == '\n' && ccp[1] == ' ' &&
((ccp[2] >= 'A' && ccp[2] <= 'Z') ||
ccp[2] == '@' || ccp[2] == '\\'))
{
break;
}
temp[i] = *ccp;
/* a sentence-ending period ends the brief comment */
if (ccp[0] == '.' && (ccp[1] == ' ' || ccp[1] == '\n'))
{
i++;
ccp++;
while (*ccp == ' ')
{
ccp++;
}
break;
}
ccp++;
i++;
}
/* skip all blank lines */
while (*ccp == '\n')
{
ccp++;
}
if (*ccp == '\0')
{
ccp = NULL;
}
temp[i] = '\0';
fprintf(fp,
" \"%s\\n\",\n",
vtkWrapText_QuoteString(
vtkWrapText_FormatComment(temp, 70), 500));
}
else
{
fprintf(fp,
" \"%s - no description provided.\\n\\n\",\n",
vtkWrapText_QuoteString(data->Name, 500));
}
/* only consider superclasses that are wrapped */
supername = vtkWrapPython_GetSuperClass(data, hinfo);
if (supername)
{
vtkWrapPython_PyTemplateName(supername, pythonname);
fprintf(fp,
" \"Superclass: %s\\n\\n\",\n",
vtkWrapText_QuoteString(pythonname, 500));
}
if (data == file_info->MainClass &&
(file_info->Description ||
file_info->Caveats ||
file_info->SeeAlso))
{
n = 100;
if (file_info->Description)
{
n += strlen(file_info->Description);
}
if (file_info->Caveats)
{
n += strlen(file_info->Caveats);
}
if (file_info->SeeAlso)
{
n += strlen(file_info->SeeAlso);
}
comment = (char *)malloc(n);
cp = comment;
*cp = '\0';
if (file_info->Description)
{
strcpy(cp, file_info->Description);
cp += strlen(cp);
*cp++ = '\n';
*cp++ = '\n';
*cp = '\0';
}
if (file_info->Caveats)
{
sprintf(cp, ".SECTION Caveats\n\n");
cp += strlen(cp);
strcpy(cp, file_info->Caveats);
cp += strlen(cp);
*cp++ = '\n';
*cp++ = '\n';
*cp = '\0';
}
if (file_info->SeeAlso)
{
sprintf(cp, ".SECTION See Also\n\n");
cp += strlen(cp);
strcpy(cp, file_info->SeeAlso);
cp += strlen(cp);
*cp = '\0';
}
ccp = vtkWrapText_FormatComment(comment, 70);
free(comment);
}
else if (ccp)
{
ccp = vtkWrapText_FormatComment(ccp, 70);
}
if (ccp)
{
n = (strlen(ccp) + 400-1)/400;
for (i = 0; i < n; i++)
{
strncpy(temp, &ccp[400*i], 400);
temp[400] = '\0';
if (i < n-1)
{
fprintf(fp,
" \"%s\",\n",
vtkWrapText_QuoteString(temp, 500));
}
else
{ /* just for the last time */
fprintf(fp,
" \"%s\\n\",\n",
vtkWrapText_QuoteString(temp, 500));
}
}
}
/* for special objects, add constructor signatures to the doc */
if (!is_vtkobject && !data->Template && !data->IsAbstract)
{
for (j = 0; j < data->NumberOfFunctions; j++)
{
if (vtkWrapPython_MethodCheck(data, data->Functions[j], hinfo) &&
vtkWrap_IsConstructor(data, data->Functions[j]))
{
fprintf(fp," \"%s\\n\",\n",
vtkWrapText_FormatSignature(
data->Functions[j]->Signature, 70, 2000));
}
}
}
}
/* 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");
}
/* 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()";
}
}
}
}
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");
}
/* Create the docstring for a class, and print it to fp */
void vtkWrapPython_ClassDoc(
FILE *fp, FileInfo *file_info, ClassInfo *data, HierarchyInfo *hinfo,
int is_vtkobject)
{
char pythonname[1024];
const char *supername;
char *cp;
const char *ccp;
size_t i, n;
int j;
char temp[500];
char *comment;
if (file_info->NameComment)
{
fprintf(fp,
" \"%s\\n\",\n",
vtkWrapText_QuoteString(
vtkWrapText_FormatComment(file_info->NameComment, 70), 500));
}
else
{
fprintf(fp,
" \"%s - no description provided.\\n\\n\",\n",
vtkWrapText_QuoteString(data->Name, 500));
}
/* only consider superclasses that are wrapped */
supername = vtkWrapPython_GetSuperClass(data, hinfo);
if (supername)
{
vtkWrapPython_PyTemplateName(supername, pythonname);
fprintf(fp,
" \"Superclass: %s\\n\\n\",\n",
vtkWrapText_QuoteString(pythonname, 500));
}
n = 100;
if (file_info->Description)
{
n += strlen(file_info->Description);
}
if (file_info->Caveats)
{
n += strlen(file_info->Caveats);
}
if (file_info->SeeAlso)
{
n += strlen(file_info->SeeAlso);
}
comment = (char *)malloc(n);
cp = comment;
*cp = '\0';
if (file_info->Description)
{
strcpy(cp, file_info->Description);
cp += strlen(cp);
*cp++ = '\n'; *cp++ = '\n'; *cp = '\0';
}
if (file_info->Caveats)
{
sprintf(cp, ".SECTION Caveats\n\n");
cp += strlen(cp);
strcpy(cp, file_info->Caveats);
cp += strlen(cp);
*cp++ = '\n'; *cp++ = '\n'; *cp = '\0';
}
if (file_info->SeeAlso)
{
sprintf(cp, ".SECTION See Also\n\n");
cp += strlen(cp);
strcpy(cp, file_info->SeeAlso);
cp += strlen(cp);
*cp = '\0';
}
ccp = vtkWrapText_FormatComment(comment, 70);
free(comment);
n = (strlen(ccp) + 400-1)/400;
for (i = 0; i < n; i++)
{
strncpy(temp, &ccp[400*i], 400);
temp[400] = '\0';
if (i < n-1)
{
fprintf(fp,
" \"%s\",\n",
vtkWrapText_QuoteString(temp, 500));
}
else
{ /* just for the last time */
fprintf(fp,
" \"%s\\n\",\n",
vtkWrapText_QuoteString(temp, 500));
}
}
/* for special objects, add constructor signatures to the doc */
if (!is_vtkobject && !data->Template && !data->IsAbstract)
{
for (j = 0; j < data->NumberOfFunctions; j++)
{
if (vtkWrapPython_MethodCheck(data, data->Functions[j], hinfo) &&
vtkWrap_IsConstructor(data, data->Functions[j]))
{
fprintf(fp," \"%s\\n\",\n",
vtkWrapText_FormatSignature(
data->Functions[j]->Signature, 70, 2000));
}
}
}
}
