/*
* Generate the API for an argument.
*/
static int apiArgument(sipSpec *pt, argDef *ad, int out, int need_comma,
int names, int defaults, int in_str, FILE *fp)
{
const char *tname;
classDef *tscope;
if (isArraySize(ad))
return need_comma;
if ((tname = pyType(pt, ad, &tscope)) == NULL)
return need_comma;
if (need_comma)
fprintf(fp, ", ");
prScopedPythonName(fp, tscope, tname);
/*
* Handle the default value is required, but ignore it if it is an output
* only argument.
*/
if (defaults && ad->defval && !out)
{
if (names && ad->name != NULL)
fprintf(fp, " %s", ad->name->text);
fprintf(fp, "=");
prDefaultValue(ad, in_str, fp);
}
return TRUE;
}
/*
* Generate the XML for a type.
*/
static void xmlType(sipSpec *pt, argDef *ad, int sec, FILE *fp)
{
const char *type_type = NULL, *type_name;
classDef *type_scope;
fprintf(fp, " typename=\"");
switch (ad->atype)
{
case class_type:
type_type = (isOpaque(ad->u.cd) ? "opaque" : "class");
break;
case enum_type:
if (ad->u.ed->pyname != NULL)
type_type = "enum";
break;
case rxcon_type:
case rxdis_type:
if (!sec)
type_type = "class";
break;
case qobject_type:
type_type = "class";
break;
case slotcon_type:
case slotdis_type:
{
int a;
prcode(fp, "SLOT(");
for (a = 0; a < ad->u.sa->nrArgs; ++a)
{
if (a > 0)
prcode(fp, ", ");
prcode(fp, "%M%B%M", &ad->u.sa->args[a]);
}
prcode(fp, ")");
}
break;
case mapped_type:
type_type = "mappedtype";
break;
}
if ((type_name = pyType(pt, ad, sec, &type_scope)) != NULL)
prScopedPythonName(fp, type_scope, type_name);
fprintf(fp, "\"");
if (type_type != NULL)
fprintf(fp, " typetype=\"%s\"", type_type);
if (ad->name != NULL)
fprintf(fp, " name=\"%s\"", ad->name->text);
}
/*
* Generate the XML for a type.
*/
static void xmlType(sipSpec *pt, moduleDef *mod, argDef *ad, int out,
KwArgs kwargs, FILE *fp)
{
const char *type_name;
classDef *type_scope;
typeHintDef *thd;
fprintf(fp, " typename=\"");
/* Handle the argument name. */
if (!out && ad->name != NULL)
{
if (kwargs == AllKwArgs || (kwargs == OptionalKwArgs && ad->defval != NULL))
fprintf(fp, "%s: ", ad->name->text);
}
/* Use any explicit type hint unless the argument is constrained. */
thd = (out ? ad->typehint_out : (isConstrained(ad) ? NULL : ad->typehint_in));
if (thd != NULL)
{
pyiTypeHint(pt, thd, mod, out, NULL, FALSE, TRUE, fp);
}
else
{
switch (ad->atype)
{
case class_type:
restPyClass(ad->u.cd, fp);
break;
case enum_type:
if (ad->u.ed->pyname != NULL)
restPyEnum(ad->u.ed, fp);
else
fprintf(fp, "int");
break;
case qobject_type:
restPyClass(pt->qobject_cd, fp);
break;
case mapped_type:
/* There would normally be a type hint. */
fprintf(fp, "unknown-type");
break;
default:
if ((type_name = pyType(pt, ad, &type_scope)) != NULL)
prScopedPythonName(fp, type_scope, type_name);
}
}
if (!out && ad->name != NULL && ad->defval != NULL)
{
fprintf(fp, " = ");
/*
* Try and convert the value to a reST reference. We don't try very
* hard but will get most cases.
*/
if (!restValue(pt, ad->defval, fp))
prDefaultValue(ad, FALSE, fp);
}
fprintf(fp, "\"");
}
