/* * 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 a Python argument. */ static int pyiArgument(sipSpec *pt, moduleDef *mod, argDef *ad, int arg_nr, int out, int need_comma, int sec, int names, int defaults, ifaceFileList *defined, KwArgs kwargs, int pep484, FILE *fp) { int optional, use_optional; if (isArraySize(ad)) return need_comma; if (sec && (ad->atype == slotcon_type || ad->atype == slotdis_type)) return need_comma; if (need_comma) fprintf(fp, ", "); optional = (defaults && ad->defval && !out); /* * We only show names for PEP 484 type hints and when they are part of the * API. */ if (names) names = (pep484 || kwargs == AllKwArgs || (kwargs == OptionalKwArgs && optional)); if (names && ad->atype != ellipsis_type) { if (ad->name != NULL) fprintf(fp, "%s%s: ", ad->name->text, (isPyKeyword(ad->name->text) ? "_" : "")); else fprintf(fp, "a%d: ", arg_nr); } use_optional = FALSE; if (optional && pep484) { /* Assume pointers can be None unless specified otherwise. */ if (isAllowNone(ad) || (!isDisallowNone(ad) && ad->nrderefs > 0)) { fprintf(fp, "typing.Optional["); use_optional = TRUE; } } pyiType(pt, mod, ad, out, sec, defined, pep484, fp); if (names && ad->atype == ellipsis_type) { if (ad->name != NULL) fprintf(fp, "%s%s", ad->name->text, (isPyKeyword(ad->name->text) ? "_" : "")); else fprintf(fp, "a%d", arg_nr); } if (optional) { if (use_optional) fprintf(fp, "]"); fprintf(fp, " = "); if (pep484) fprintf(fp, "..."); else prDefaultValue(ad, TRUE, fp); } return TRUE; }
/* * 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, "\""); }