You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2857 lines
73 KiB
2857 lines
73 KiB
/*
|
|
* The parse tree transformation module for SIP.
|
|
*
|
|
* Copyright (c) 2007
|
|
* Riverbank Computing Limited <info@riverbankcomputing.co.uk>
|
|
*
|
|
* This file is part of SIP.
|
|
*
|
|
* This copy of SIP is licensed for use under the terms of the SIP License
|
|
* Agreement. See the file LICENSE for more details.
|
|
*
|
|
* SIP is supplied WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "sip.h"
|
|
|
|
|
|
static int samePythonSignature(signatureDef *sd1, signatureDef *sd2);
|
|
static int nextSignificantArg(signatureDef *sd, int a);
|
|
static int sameArgType(argDef *a1, argDef *a2, int strict);
|
|
static int supportedType(classDef *,overDef *,argDef *,int);
|
|
static int sameOverload(overDef *od1,overDef *od2);
|
|
static int sameVirtualHandler(virtHandlerDef *vhd1,virtHandlerDef *vhd2);
|
|
static int isSubClass(classDef *cc,classDef *pc);
|
|
static void setAllImports(sipSpec *pt, moduleDef *mod);
|
|
static void addUniqueModule(moduleDef *mod, moduleDef *imp);
|
|
static void ensureInput(classDef *,overDef *,argDef *);
|
|
static void defaultInput(argDef *);
|
|
static void defaultOutput(classDef *,overDef *,argDef *);
|
|
static void assignClassNrs(sipSpec *,moduleDef *,nodeDef *);
|
|
static void assignEnumNrs(sipSpec *pt);
|
|
static void positionClass(classDef *);
|
|
static void addNodeToParent(nodeDef *,classDef *);
|
|
static void addAutoOverload(sipSpec *,classDef *,overDef *);
|
|
static void ifaceFileIsUsed(sipSpec *, ifaceFileDef *, argDef *);
|
|
static void ifaceFilesAreUsed(sipSpec *, ifaceFileDef *, overDef *);
|
|
static void ifaceFilesAreUsedByMethod(sipSpec *, classDef *, memberDef *);
|
|
static void ifaceFilesAreUsedFromOther(sipSpec *pt, signatureDef *sd);
|
|
static void scopeDefaultValue(sipSpec *,classDef *,argDef *);
|
|
static void setHierarchy(sipSpec *,classDef *,classDef *,classList **);
|
|
static void transformCtors(sipSpec *,classDef *);
|
|
static void transformCasts(sipSpec *,classDef *);
|
|
static void addDefaultCopyCtor(classDef *);
|
|
static void transformOverloads(sipSpec *,classDef *,overDef *);
|
|
static void transformVariableList(sipSpec *);
|
|
static void transformMappedTypes(sipSpec *);
|
|
static void getVisibleMembers(sipSpec *,classDef *);
|
|
static void getVirtuals(sipSpec *pt,classDef *cd);
|
|
static void getClassVirtuals(classDef *,classDef *);
|
|
static void transformTypedefs(sipSpec *pt);
|
|
static void resolveMappedTypeTypes(sipSpec *,mappedTypeDef *);
|
|
static void resolveCtorTypes(sipSpec *,classDef *,ctorDef *);
|
|
static void resolveFuncTypes(sipSpec *,moduleDef *,classDef *,overDef *);
|
|
static void resolvePySigTypes(sipSpec *,moduleDef *,classDef *,overDef *,signatureDef *,int);
|
|
static void resolveVariableType(sipSpec *,varDef *);
|
|
static void fatalNoDefinedType(scopedNameDef *);
|
|
static void getBaseType(sipSpec *,moduleDef *,classDef *,argDef *);
|
|
static void searchScope(sipSpec *,classDef *,scopedNameDef *,argDef *);
|
|
static void searchMappedTypes(sipSpec *,scopedNameDef *,argDef *);
|
|
static void searchTypedefs(sipSpec *,scopedNameDef *,argDef *);
|
|
static void searchEnums(sipSpec *,scopedNameDef *,argDef *);
|
|
static void searchClasses(sipSpec *,moduleDef *mod,scopedNameDef *,argDef *);
|
|
static void appendToMRO(mroDef *,mroDef ***,classDef *);
|
|
static void moveClassCasts(sipSpec *pt, classDef *cd);
|
|
static void moveGlobalSlot(sipSpec *pt, memberDef *gmd);
|
|
static void filterVirtualHandlers(moduleDef *mod);
|
|
static ifaceFileDef *getIfaceFile(argDef *ad);
|
|
static mappedTypeDef *instantiateMappedTypeTemplate(sipSpec *pt, moduleDef *mod, mappedTypeTmplDef *mtt, argDef *type);
|
|
static classDef *getProxy(sipSpec *pt, classDef *cd);
|
|
|
|
|
|
/*
|
|
* Transform the parse tree.
|
|
*/
|
|
|
|
void transform(sipSpec *pt)
|
|
{
|
|
moduleDef *mod;
|
|
moduleListDef *mld;
|
|
classDef *cd, *rev, **tail;
|
|
classList *newl;
|
|
overDef *od;
|
|
mappedTypeDef *mtd;
|
|
virtHandlerDef *vhd;
|
|
int nr;
|
|
|
|
if (pt -> module -> name == NULL)
|
|
fatal("No %%Module has been specified for the module\n");
|
|
|
|
/*
|
|
* The class list has the main module's classes at the front and the
|
|
* ones from the module at the most nested %Import at the end. This
|
|
* affects some of the following algorithms, eg. when assigning class
|
|
* numbers. We have to have consistency whenever a module is used. To
|
|
* achieve this we reverse the order of the classes.
|
|
*/
|
|
rev = NULL;
|
|
cd = pt -> classes;
|
|
|
|
while (cd != NULL)
|
|
{
|
|
classDef *next = cd -> next;
|
|
|
|
cd -> next = rev;
|
|
rev = cd;
|
|
|
|
/*
|
|
* Mark any QObject class. This flag will ripple through all derived
|
|
* classes when we set the hierarchy.
|
|
*/
|
|
if (strcmp(classBaseName(cd), "QObject") == 0)
|
|
setIsQObjectSubClass(cd);
|
|
|
|
cd = next;
|
|
}
|
|
|
|
pt -> classes = rev;
|
|
|
|
/* Build the list of all imports for each module. */
|
|
for (mod = pt->modules; mod != NULL; mod = mod->next)
|
|
setAllImports(pt, mod);
|
|
|
|
/* Check each class has been defined. */
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
if (cd -> iff -> module == NULL)
|
|
{
|
|
fatalScopedName(classFQCName(cd));
|
|
fatal(" has not been defined\n");
|
|
}
|
|
|
|
/*
|
|
* Set the super-class hierarchy for each class and re-order the list
|
|
* of classes so that no class appears before a super class or an
|
|
* enclosing scope class.
|
|
*/
|
|
newl = NULL;
|
|
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
setHierarchy(pt,cd,cd,&newl);
|
|
|
|
/* Replace the old list with the new one. */
|
|
tail = &pt -> classes;
|
|
|
|
while (newl != NULL)
|
|
{
|
|
classList *cl = newl;
|
|
|
|
*tail = cl -> cd;
|
|
tail = &cl -> cd -> next;
|
|
|
|
newl = cl -> next;
|
|
free(cl);
|
|
}
|
|
|
|
*tail = NULL;
|
|
|
|
/* Transform typedefs, variables and global functions. */
|
|
transformTypedefs(pt);
|
|
transformVariableList(pt);
|
|
transformOverloads(pt,NULL,pt -> overs);
|
|
|
|
/* Transform class ctors, functions and casts. */
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
{
|
|
transformCtors(pt,cd);
|
|
|
|
if (!pt -> genc)
|
|
{
|
|
transformOverloads(pt,cd,cd -> overs);
|
|
transformCasts(pt, cd);
|
|
}
|
|
}
|
|
|
|
/* Transform mapped types based on templates. */
|
|
transformMappedTypes(pt);
|
|
|
|
/* Handle default ctors now that the argument types are resolved. */
|
|
if (!pt -> genc)
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
if (!noDefaultCtors(cd) && !isOpaque(cd) && cd->iff->type != namespace_iface)
|
|
addDefaultCopyCtor(cd);
|
|
|
|
/*
|
|
* Go through each class and add it to it's defining module's tree of
|
|
* classes. The tree reflects the namespace hierarchy.
|
|
*/
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
addNodeToParent(&cd -> iff -> module -> root,cd);
|
|
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
positionClass(cd);
|
|
|
|
/* Assign module specific class numbers for all modules. */
|
|
for (mod = pt->modules; mod != NULL; mod = mod->next)
|
|
assignClassNrs(pt, mod, &mod->root);
|
|
|
|
/* Assign module specific enum numbers for all enums. */
|
|
assignEnumNrs(pt);
|
|
|
|
/* Add any automatically generated methods. */
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
for (od = cd -> overs; od != NULL; od = od -> next)
|
|
if (isAutoGen(od))
|
|
addAutoOverload(pt,cd,od);
|
|
|
|
/* Allocate mapped types numbers. */
|
|
for (mtd = pt -> mappedtypes; mtd != NULL; mtd = mtd -> next)
|
|
mtd -> mappednr = mtd -> iff -> module -> nrmappedtypes++;
|
|
|
|
/*
|
|
* Move casts and slots around to their correct classes (if in the same
|
|
* module) or create proxies for them (if cross-module).
|
|
*/
|
|
if (!pt -> genc)
|
|
{
|
|
memberDef *md;
|
|
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
if (cd->iff->module == pt->module)
|
|
moveClassCasts(pt, cd);
|
|
|
|
for (md = pt->othfuncs; md != NULL; md = md->next)
|
|
if (md->slot != no_slot && md->module == pt->module)
|
|
moveGlobalSlot(pt, md);
|
|
}
|
|
|
|
/* Generate the different class views. */
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
{
|
|
ifaceFileDef *iff = cd -> iff;
|
|
|
|
if (iff -> type == class_iface)
|
|
{
|
|
/* Get the list of visible member functions. */
|
|
getVisibleMembers(pt,cd);
|
|
|
|
/* Get the virtual members. */
|
|
if (hasShadow(cd))
|
|
getVirtuals(pt,cd);
|
|
}
|
|
else if (iff -> type == namespace_iface && iff -> module == pt -> module)
|
|
{
|
|
memberDef *md;
|
|
|
|
for (md = cd -> members; md != NULL; md = md -> next)
|
|
ifaceFilesAreUsedByMethod(pt, cd, md);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* In case there are any global functions that need external interface
|
|
* files.
|
|
*/
|
|
for (od = pt -> overs; od != NULL; od = od -> next)
|
|
if (od->common->module == pt->module)
|
|
ifaceFilesAreUsedFromOther(pt, &od->pysig);
|
|
|
|
/*
|
|
* Remove redundant virtual handlers. It's important that earlier,
|
|
* ie. those at the deepest level of %Import, are done first.
|
|
*/
|
|
nr = 0;
|
|
|
|
for (mld = pt->module->allimports; mld != NULL; mld = mld->next)
|
|
{
|
|
mld->module->modulenr = nr++;
|
|
filterVirtualHandlers(mld->module);
|
|
}
|
|
|
|
pt->module->modulenr = nr;
|
|
filterVirtualHandlers(pt->module);
|
|
|
|
/*
|
|
* Make sure we have the interface files for all types from other modules
|
|
* that are used in virtual handlers implemented in this module.
|
|
*/
|
|
for (vhd = pt->module->virthandlers; vhd != NULL; vhd = vhd->next)
|
|
if (!isDuplicateVH(vhd))
|
|
ifaceFilesAreUsedFromOther(pt, vhd->cppsig);
|
|
|
|
/* Update proxies with some information from the real classes. */
|
|
for (cd = pt->proxies; cd != NULL; cd = cd->next)
|
|
cd->classnr = cd->real->classnr;
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the list of all imports for a module. The list is ordered so that a
|
|
* module appears before any module that imports it.
|
|
*/
|
|
static void setAllImports(sipSpec *pt, moduleDef *mod)
|
|
{
|
|
moduleListDef *mld;
|
|
|
|
/*
|
|
* Handle the trivial case where there are no imports, or the list has
|
|
* already been done.
|
|
*/
|
|
if (mod->imports == NULL || mod->allimports != NULL)
|
|
return;
|
|
|
|
/* Make sure all the direct imports are done first. */
|
|
for (mld = mod->imports; mld != NULL; mld = mld->next)
|
|
setAllImports(pt, mld->module);
|
|
|
|
/*
|
|
* Now build the list from our direct imports lists but ignoring
|
|
* duplicates.
|
|
*/
|
|
for (mld = mod->imports; mld != NULL; mld = mld->next)
|
|
{
|
|
moduleListDef *amld;
|
|
|
|
for (amld = mld->module->allimports; amld != NULL; amld = amld->next)
|
|
addUniqueModule(mod, amld->module);
|
|
|
|
addUniqueModule(mod, mld->module);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Append a module to the list of all imported modules if it isn't already
|
|
* there.
|
|
*/
|
|
static void addUniqueModule(moduleDef *mod, moduleDef *imp)
|
|
{
|
|
moduleListDef **tail;
|
|
|
|
for (tail = &mod->allimports; *tail != NULL; tail = &(*tail)->next)
|
|
if ((*tail)->module == imp)
|
|
return;
|
|
|
|
*tail = sipMalloc(sizeof (moduleListDef));
|
|
|
|
(*tail)->module = imp;
|
|
(*tail)->next = NULL;
|
|
}
|
|
|
|
|
|
/*
|
|
* Move any class casts to its correct class, or publish as a ctor extender.
|
|
*/
|
|
static void moveClassCasts(sipSpec *pt, classDef *cd)
|
|
{
|
|
argList *al;
|
|
|
|
for (al = cd->casts; al != NULL; al = al->next)
|
|
{
|
|
classDef *dcd = al->arg.u.cd;
|
|
ctorDef *ct, **ctp;
|
|
argDef *ad;
|
|
|
|
/*
|
|
* If the destination class is in a different module then use
|
|
* a proxy.
|
|
*/
|
|
if (dcd->iff->module != pt->module)
|
|
dcd = getProxy(pt, dcd);
|
|
|
|
/* Create the new ctor. */
|
|
ct = sipMalloc(sizeof (ctorDef));
|
|
|
|
ct->ctorflags = SECT_IS_PUBLIC | CTOR_CAST;
|
|
ct->cppsig = &ct->pysig;
|
|
ct->exceptions = NULL;
|
|
ct->methodcode = NULL;
|
|
ct->prehook = NULL;
|
|
ct->posthook = NULL;
|
|
ct->next = NULL;
|
|
|
|
/* Add the source class as the only argument. */
|
|
ad = &ct->pysig.args[0];
|
|
|
|
ad->atype = class_type;
|
|
ad->name = NULL;
|
|
ad->argflags = ARG_IN | (al->arg.argflags & (ARG_IS_REF | ARG_IS_CONST));
|
|
ad->nrderefs = al->arg.nrderefs;
|
|
ad->defval = NULL;
|
|
ad->u.cd = cd;
|
|
|
|
ifaceFileIsUsed(pt, dcd->iff, ad);
|
|
|
|
ct->pysig.nrArgs = 1;
|
|
|
|
/* Append it to the list. */
|
|
for (ctp = &dcd->ctors; *ctp != NULL; ctp = &(*ctp)->next)
|
|
if (sameSignature(&(*ctp)->pysig, &ct->pysig, FALSE))
|
|
{
|
|
fatal("operator ");
|
|
fatalScopedName(classFQCName(dcd));
|
|
fatal("::");
|
|
fatalScopedName(classFQCName(dcd));
|
|
fatal("(");
|
|
fatalScopedName(classFQCName(cd));
|
|
fatal(") already defined\n");
|
|
}
|
|
|
|
*ctp = ct;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* If possible, move a global slot to its correct class.
|
|
*/
|
|
static void moveGlobalSlot(sipSpec *pt, memberDef *gmd)
|
|
{
|
|
overDef **odp = &pt->overs, *od;
|
|
|
|
while ((od = *odp) != NULL)
|
|
{
|
|
int second;
|
|
argDef *arg0, *arg1;
|
|
memberDef *md, **mdhead;
|
|
overDef **odhead;
|
|
moduleDef *mod;
|
|
nameDef *nd;
|
|
|
|
if (od->common != gmd)
|
|
{
|
|
odp = &od->next;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* We know that the slot has the right number of arguments, but the
|
|
* first or second one needs to be a class or enum defined in the same
|
|
* module. Otherwise we leave it as it is and publish it as a slot
|
|
* extender.
|
|
*/
|
|
arg0 = &od->pysig.args[0];
|
|
arg1 = &od->pysig.args[1];
|
|
|
|
second = FALSE;
|
|
nd = NULL;
|
|
|
|
if (arg0->atype == class_type)
|
|
{
|
|
mdhead = &arg0->u.cd->members;
|
|
odhead = &arg0->u.cd->overs;
|
|
mod = arg0->u.cd->iff->module;
|
|
}
|
|
else if (arg0->atype == enum_type)
|
|
{
|
|
mdhead = &arg0->u.ed->slots;
|
|
odhead = &arg0->u.ed->overs;
|
|
mod = arg0->u.ed->module;
|
|
nd = arg0->u.ed->pyname;
|
|
}
|
|
else if (arg1->atype == class_type)
|
|
{
|
|
mdhead = &arg1->u.cd->members;
|
|
odhead = &arg1->u.cd->overs;
|
|
mod = arg1->u.cd->iff->module;
|
|
second = TRUE;
|
|
}
|
|
else if (arg1->atype == enum_type)
|
|
{
|
|
mdhead = &arg1->u.ed->slots;
|
|
odhead = &arg1->u.ed->overs;
|
|
mod = arg1->u.ed->module;
|
|
nd = arg1->u.ed->pyname;
|
|
second = TRUE;
|
|
}
|
|
else
|
|
{
|
|
fatal("One of the arguments of ");
|
|
prOverloadName(stderr, od);
|
|
fatal(" must be a class or enum\n");
|
|
}
|
|
|
|
/*
|
|
* For rich comparisons the first argument must be a class or
|
|
* an enum. For cross-module slots then it may only be a
|
|
* class. (This latter limitation is artificial, but is
|
|
* unlikely to be a problem in practice.)
|
|
*/
|
|
if (isRichCompareSlot(gmd))
|
|
{
|
|
if (second)
|
|
{
|
|
fatal("The first argument of ");
|
|
prOverloadName(stderr, od);
|
|
fatal(" must be a class or enum\n");
|
|
}
|
|
|
|
if (mod != gmd->module && arg0->atype == enum_type)
|
|
{
|
|
fatal("The first argument of ");
|
|
prOverloadName(stderr, od);
|
|
fatal(" must be a class\n");
|
|
}
|
|
}
|
|
|
|
if (mod != gmd->module)
|
|
{
|
|
if (isRichCompareSlot(gmd))
|
|
{
|
|
classDef *pcd = getProxy(pt, arg0->u.cd);
|
|
memberDef *pmd;
|
|
overDef *pod;
|
|
|
|
/* Create a new proxy member if needed. */
|
|
for (pmd = pcd->members; pmd != NULL; pmd = pmd->next)
|
|
if (pmd->slot == gmd->slot)
|
|
break;
|
|
|
|
if (pmd == NULL)
|
|
{
|
|
pmd = sipMalloc(sizeof (memberDef));
|
|
|
|
pmd->pyname = gmd->pyname;
|
|
pmd->memberflags = 0;
|
|
pmd->slot = gmd->slot;
|
|
pmd->module = mod;
|
|
pmd->next = pcd->members;
|
|
|
|
pcd->members = pmd;
|
|
}
|
|
|
|
/* Add the proxy overload. */
|
|
pod = sipMalloc(sizeof (overDef));
|
|
|
|
*pod = *od;
|
|
pod->common = pmd;
|
|
pod->next = pcd->overs;
|
|
|
|
pcd->overs = pod;
|
|
|
|
/* Remove the first argument. */
|
|
pod->pysig.args[0] = pod->pysig.args[1];
|
|
pod->pysig.nrArgs = 1;
|
|
|
|
/* Remove from the list. */
|
|
*odp = od->next;
|
|
}
|
|
else
|
|
odp = &od->next;
|
|
|
|
continue;
|
|
}
|
|
|
|
/* Remove from the list. */
|
|
*odp = od->next;
|
|
|
|
/*
|
|
* The only time we need the name of an enum is when it has
|
|
* slots.
|
|
*/
|
|
if (nd != NULL)
|
|
setIsUsedName(nd);
|
|
|
|
/* See if there is already a member or create a new one. */
|
|
for (md = *mdhead; md != NULL; md = md->next)
|
|
if (md->slot == gmd->slot)
|
|
break;
|
|
|
|
if (md == NULL)
|
|
{
|
|
md = sipMalloc(sizeof (memberDef));
|
|
|
|
*md = *gmd;
|
|
|
|
md->module = mod;
|
|
md->next = *mdhead;
|
|
|
|
*mdhead = md;
|
|
}
|
|
|
|
/* Move the overload. */
|
|
setIsPublic(od);
|
|
od->common = md;
|
|
od->next = *odhead;
|
|
|
|
*odhead = od;
|
|
|
|
/* Remove the first argument of comparison operators. */
|
|
if (isRichCompareSlot(md))
|
|
{
|
|
/* Remember if the argument was a pointer. */
|
|
if (arg0->nrderefs > 0)
|
|
setDontDerefSelf(od);
|
|
|
|
*arg0 = *arg1;
|
|
od->pysig.nrArgs = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Create a proxy for a class if it doesn't already exist. Proxies are used as
|
|
* containers for cross-module extenders.
|
|
*/
|
|
static classDef *getProxy(sipSpec *pt, classDef *cd)
|
|
{
|
|
classDef *pcd;
|
|
|
|
for (pcd = pt->proxies; pcd != NULL; pcd = pcd->next)
|
|
if (pcd->iff == cd->iff)
|
|
return pcd;
|
|
|
|
pcd = sipMalloc(sizeof (classDef));
|
|
|
|
pcd->classflags = 0;
|
|
pcd->userflags = 0;
|
|
pcd->classnr = -1;
|
|
pcd->pyname = cd->pyname;
|
|
pcd->iff = cd->iff;
|
|
pcd->ecd = cd->ecd;
|
|
pcd->real = cd;
|
|
pcd->node = NULL;
|
|
pcd->supers = cd->supers;
|
|
pcd->mro = cd->mro;
|
|
pcd->td = NULL;
|
|
pcd->ctors = NULL;
|
|
pcd->defctor = NULL;
|
|
pcd->dealloccode = NULL;
|
|
pcd->dtorcode = NULL;
|
|
pcd->dtorexceptions = NULL;
|
|
pcd->members = NULL;
|
|
pcd->overs = NULL;
|
|
pcd->casts = NULL;
|
|
pcd->vmembers = NULL;
|
|
pcd->visible = NULL;
|
|
pcd->cppcode = NULL;
|
|
pcd->hdrcode = NULL;
|
|
pcd->convtosubcode = NULL;
|
|
pcd->subbase = NULL;
|
|
pcd->convtocode = NULL;
|
|
pcd->travcode = NULL;
|
|
pcd->clearcode = NULL;
|
|
pcd->readbufcode = NULL;
|
|
pcd->writebufcode = NULL;
|
|
pcd->segcountcode = NULL;
|
|
pcd->charbufcode = NULL;
|
|
pcd->next = pt->proxies;
|
|
|
|
pt->proxies = pcd;
|
|
|
|
return pcd;
|
|
}
|
|
|
|
|
|
/*
|
|
* Go through the virtual handlers filtering those that can duplicate earlier
|
|
* ones. Make sure each virtual is numbered within its module, and according
|
|
* to their position in the list (ignoring duplicates).
|
|
*/
|
|
static void filterVirtualHandlers(moduleDef *mod)
|
|
{
|
|
virtHandlerDef *vhd;
|
|
|
|
for (vhd = mod->virthandlers; vhd != NULL; vhd = vhd->next)
|
|
{
|
|
virtHandlerDef *best, *best_thismod, *hd;
|
|
|
|
best = best_thismod = NULL;
|
|
|
|
/*
|
|
* If this has handwritten code then we will want to use it.
|
|
* Otherwise, look for a handler in earlier modules.
|
|
*/
|
|
if (vhd->virtcode == NULL)
|
|
{
|
|
moduleListDef *mld;
|
|
|
|
for (mld = mod->allimports; mld != NULL && mld->module != mod; mld = mld->next)
|
|
{
|
|
for (hd = mld->module->virthandlers; hd != NULL; hd = hd->next)
|
|
if (sameVirtualHandler(vhd, hd))
|
|
{
|
|
best = hd;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* No need to check later modules as this will either be the
|
|
* right one, or a duplicate of the right one.
|
|
*/
|
|
if (best != NULL)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Find the best candidate in this module in case we want to give it
|
|
* our handwritten code.
|
|
*/
|
|
for (hd = mod->virthandlers; hd != vhd; hd = hd->next)
|
|
if (sameVirtualHandler(vhd, hd))
|
|
{
|
|
best_thismod = hd;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* We don't use this one if it doesn't have virtual code and there is
|
|
* an alternative, or if it does have virtual code and there is already
|
|
* an alternative in the same module which doesn't have virtual code.
|
|
*/
|
|
if ((vhd->virtcode == NULL && (best != NULL || best_thismod != NULL)) ||
|
|
(vhd->virtcode != NULL && best_thismod != NULL && best_thismod->virtcode == NULL))
|
|
{
|
|
virtHandlerDef *saved;
|
|
|
|
/*
|
|
* If the alternative is in the same module and we have virtual
|
|
* code then give it to the alternative. Note that there is a bug
|
|
* here. If there are three handlers, the first without code and
|
|
* the second and third with code then which code is transfered to
|
|
* the first is down to luck. We should really only transfer code
|
|
* to methods that are known to be re-implementations - just having
|
|
* the same signature isn't enough.
|
|
*/
|
|
if (best_thismod != NULL)
|
|
{
|
|
if (best_thismod->virtcode == NULL && vhd->virtcode != NULL)
|
|
{
|
|
best_thismod->virtcode = vhd->virtcode;
|
|
resetIsDuplicateVH(best_thismod);
|
|
}
|
|
|
|
best = best_thismod;
|
|
}
|
|
|
|
/* Use the better one in place of this one. */
|
|
saved = vhd->next;
|
|
*vhd = *best;
|
|
setIsDuplicateVH(vhd);
|
|
vhd->next = saved;
|
|
}
|
|
else
|
|
vhd->virthandlernr = mod->nrvirthandlers++;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Add an overload that is automatically generated (typically by Qt's moc).
|
|
*/
|
|
static void addAutoOverload(sipSpec *pt,classDef *autocd,overDef *autood)
|
|
{
|
|
classDef *cd;
|
|
|
|
/* Find every class that has this one in its hierarchy. */
|
|
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
{
|
|
mroDef *mro;
|
|
|
|
if (cd == autocd)
|
|
continue;
|
|
|
|
for (mro = cd -> mro; mro != NULL; mro = mro -> next)
|
|
if (mro -> cd == autocd)
|
|
{
|
|
memberDef *md;
|
|
overDef *od;
|
|
|
|
/* Another overload may already exist. */
|
|
|
|
for (md = cd -> members; md != NULL; md = md -> next)
|
|
if (md -> pyname == autood -> common -> pyname)
|
|
break;
|
|
|
|
if (md == NULL)
|
|
{
|
|
md = sipMalloc(sizeof (memberDef));
|
|
|
|
md -> pyname = autood -> common -> pyname;
|
|
md -> memberflags = autood -> common -> memberflags;
|
|
md -> slot = autood -> common -> slot;
|
|
md -> module = cd -> iff -> module;
|
|
md -> next = cd -> members;
|
|
cd -> members = md;
|
|
}
|
|
|
|
od = sipMalloc(sizeof (overDef));
|
|
|
|
*od = *autood;
|
|
od -> common = md;
|
|
od -> next = cd -> overs;
|
|
cd -> overs = od;
|
|
|
|
resetIsAutoGen(od);
|
|
|
|
if (cd -> iff -> module == pt -> module)
|
|
setIsUsedName(md -> pyname);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the complete hierarchy for a class.
|
|
*/
|
|
static void setHierarchy(sipSpec *pt,classDef *base,classDef *cd,
|
|
classList **head)
|
|
{
|
|
mroDef **tailp = &cd -> mro;
|
|
|
|
/* See if it has already been done. */
|
|
if (cd -> mro != NULL)
|
|
return;
|
|
|
|
if (cd -> ecd != NULL)
|
|
setHierarchy(pt,base,cd -> ecd,head);
|
|
|
|
if (cd -> iff -> type == class_iface)
|
|
{
|
|
classList *cl;
|
|
|
|
/* The first thing is itself. */
|
|
appendToMRO(cd -> mro,&tailp,cd);
|
|
|
|
if (cd -> convtosubcode != NULL)
|
|
cd -> subbase = cd;
|
|
|
|
/* Now do it's superclasses. */
|
|
for (cl = cd -> supers; cl != NULL; cl = cl -> next)
|
|
{
|
|
mroDef *mro;
|
|
|
|
/*
|
|
* Make sure the super-class's hierarchy has been done.
|
|
*/
|
|
setHierarchy(pt,base,cl -> cd,head);
|
|
|
|
/* Append the super-classes hierarchy. */
|
|
for (mro = cl -> cd -> mro; mro != NULL; mro = mro -> next)
|
|
{
|
|
appendToMRO(cd -> mro,&tailp,mro -> cd);
|
|
|
|
/*
|
|
* If the super-class is a QObject sub-class then this one is
|
|
* as well.
|
|
*/
|
|
if (isQObjectSubClass(mro->cd))
|
|
setIsQObjectSubClass(cd);
|
|
|
|
/*
|
|
* If the super-class has a shadow then this one should have
|
|
* one as well.
|
|
*/
|
|
if (hasShadow(mro->cd))
|
|
setHasShadow(cd);
|
|
|
|
/*
|
|
* Ensure that the sub-class base class is the furthest up the
|
|
* hierarchy.
|
|
*/
|
|
if (mro->cd->subbase != NULL)
|
|
cd->subbase = mro->cd->subbase;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We can't have a shadow if the specification is incomplete, there is
|
|
* a private dtor, there are no none-private ctors or there are private
|
|
* abstract methods.
|
|
*/
|
|
if (isIncomplete(cd) || isPrivateDtor(cd) || !canCreate(cd))
|
|
resetHasShadow(cd);
|
|
else
|
|
{
|
|
overDef *od;
|
|
|
|
/*
|
|
* Note that we should be able to provide better support for
|
|
* abstract private methods than we do at the moment.
|
|
*/
|
|
for (od = cd->overs; od != NULL; od = od->next)
|
|
if (isAbstract(od) && isPrivate(od))
|
|
{
|
|
resetHasShadow(cd);
|
|
|
|
/*
|
|
* It also means we cannot create an instance
|
|
* from Python.
|
|
*/
|
|
resetCanCreate(cd);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Add it to the new list. */
|
|
appendToClassList(head,cd);
|
|
}
|
|
|
|
|
|
/*
|
|
* Append a class definition to an mro list
|
|
*/
|
|
static void appendToMRO(mroDef *head,mroDef ***tailp,classDef *cd)
|
|
{
|
|
mroDef *mro, *new;
|
|
|
|
new = sipMalloc(sizeof (mroDef));
|
|
|
|
new -> cd = cd;
|
|
new -> mroflags = 0;
|
|
new -> next = NULL;
|
|
|
|
/* See if it is a duplicate. */
|
|
|
|
for (mro = head; mro != NULL; mro = mro -> next)
|
|
if (mro -> cd == cd)
|
|
{
|
|
setIsDuplicateSuper(new);
|
|
|
|
if (!isDuplicateSuper(mro))
|
|
setHasDuplicateSuper(mro);
|
|
|
|
break;
|
|
}
|
|
|
|
/* Append to the list and update the tail pointer. */
|
|
**tailp = new;
|
|
*tailp = &new -> next;
|
|
}
|
|
|
|
|
|
/*
|
|
* Get the base types for all typedefs.
|
|
*/
|
|
static void transformTypedefs(sipSpec *pt)
|
|
{
|
|
typedefDef *td;
|
|
|
|
for (td = pt -> typedefs; td != NULL; td = td -> next)
|
|
getBaseType(pt, td->module, td -> ecd, &td -> type);
|
|
}
|
|
|
|
|
|
/*
|
|
* Transform the data types for mapped types based on a template.
|
|
*/
|
|
static void transformMappedTypes(sipSpec *pt)
|
|
{
|
|
mappedTypeDef *mt;
|
|
|
|
for (mt = pt -> mappedtypes; mt != NULL; mt = mt -> next)
|
|
{
|
|
/* Nothing to do if this isn't template based. */
|
|
|
|
if (mt -> type.atype == template_type)
|
|
resolveMappedTypeTypes(pt,mt);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Transform the data types for a list of ctors.
|
|
*/
|
|
static void transformCtors(sipSpec *pt, classDef *cd)
|
|
{
|
|
ctorDef *ct;
|
|
|
|
for (ct = cd->ctors; ct != NULL; ct = ct->next)
|
|
{
|
|
ctorDef *prev;
|
|
|
|
resolveCtorTypes(pt, cd, ct);
|
|
|
|
/*
|
|
* Now check that the Python signature doesn't conflict with an
|
|
* earlier one.
|
|
*/
|
|
for (prev = cd->ctors; prev != ct; prev = prev->next)
|
|
if (samePythonSignature(&prev->pysig, &ct->pysig))
|
|
{
|
|
fatalScopedName(classFQCName(cd));
|
|
fatal(" has ctors with the same Python signature\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Transform the data type for a list of casts.
|
|
*/
|
|
static void transformCasts(sipSpec *pt, classDef *cd)
|
|
{
|
|
argList *al;
|
|
|
|
for (al = cd->casts; al != NULL; al = al->next)
|
|
{
|
|
getBaseType(pt, cd->iff->module, cd, &al->arg);
|
|
|
|
if (al->arg.atype != class_type)
|
|
{
|
|
fatalScopedName(classFQCName(cd));
|
|
fatal(" operator cast must be to a class\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Add a default copy ctor is required.
|
|
*/
|
|
static void addDefaultCopyCtor(classDef *cd)
|
|
{
|
|
ctorDef *copyct;
|
|
mroDef *mro;
|
|
|
|
/* See if there is a private copy ctor in the hierarchy. */
|
|
|
|
copyct = NULL;
|
|
|
|
for (mro = cd -> mro; mro != NULL; mro = mro -> next)
|
|
{
|
|
ctorDef *ct;
|
|
|
|
if (isDuplicateSuper(mro))
|
|
continue;
|
|
|
|
for (ct = mro -> cd -> ctors; ct != NULL; ct = ct -> next)
|
|
{
|
|
argDef *ad = &ct -> pysig.args[0];
|
|
|
|
/* See if is a copy ctor. */
|
|
if (ct -> pysig.nrArgs != 1 || ad -> nrderefs != 0 ||
|
|
!isReference(ad) || ad -> atype != class_type ||
|
|
ad -> u.cd != mro -> cd)
|
|
continue;
|
|
|
|
/* Stop now if the copy ctor is private. */
|
|
if (isPrivateCtor(ct))
|
|
return;
|
|
|
|
/*
|
|
* Remember if it's in the class we are dealing with.
|
|
*/
|
|
if (mro == cd -> mro)
|
|
copyct = ct;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (copyct == NULL)
|
|
{
|
|
ctorDef **tailp;
|
|
|
|
/* Create a default public copy ctor. */
|
|
|
|
copyct = sipMalloc(sizeof (ctorDef));
|
|
|
|
copyct -> ctorflags = SECT_IS_PUBLIC;
|
|
copyct -> pysig.nrArgs = 1;
|
|
copyct -> pysig.args[0].name = "other";
|
|
copyct -> pysig.args[0].atype = class_type;
|
|
copyct -> pysig.args[0].u.cd = cd;
|
|
copyct -> pysig.args[0].argflags = (ARG_IS_REF | ARG_IS_CONST | ARG_IN);
|
|
copyct -> pysig.args[0].nrderefs = 0;
|
|
copyct -> pysig.args[0].defval = NULL;
|
|
|
|
copyct -> cppsig = ©ct -> pysig;
|
|
copyct -> exceptions = NULL;
|
|
copyct -> methodcode = NULL;
|
|
copyct -> prehook = NULL;
|
|
copyct -> posthook = NULL;
|
|
copyct -> next = NULL;
|
|
|
|
/* Append it to the list. */
|
|
for (tailp = &cd -> ctors; *tailp != NULL; tailp = &(*tailp) -> next)
|
|
;
|
|
|
|
*tailp = copyct;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Transform the data types for a list of overloads.
|
|
*/
|
|
static void transformOverloads(sipSpec *pt, classDef *scope, overDef *overs)
|
|
{
|
|
overDef *od;
|
|
|
|
for (od = overs; od != NULL; od = od -> next)
|
|
{
|
|
overDef *prev;
|
|
|
|
resolveFuncTypes(pt, od->common->module, scope, od);
|
|
|
|
/*
|
|
* Now check that the Python signature doesn't conflict with an
|
|
* earlier one.
|
|
*/
|
|
for (prev = overs; prev != od; prev = prev->next)
|
|
{
|
|
if (prev->common != od->common)
|
|
continue;
|
|
|
|
if (samePythonSignature(&prev->pysig, &od->pysig))
|
|
{
|
|
if (scope != NULL)
|
|
{
|
|
fatalScopedName(classFQCName(scope));
|
|
fatal("::");
|
|
}
|
|
|
|
fatal("%s() has overloaded functions with the same Python signature\n", od->common->pyname->text);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Transform the data types for the variables.
|
|
*/
|
|
static void transformVariableList(sipSpec *pt)
|
|
{
|
|
varDef *vd;
|
|
|
|
for (vd = pt -> vars; vd != NULL; vd = vd -> next)
|
|
resolveVariableType(pt,vd);
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the list of visible member functions for a class.
|
|
*/
|
|
static void getVisibleMembers(sipSpec *pt,classDef *cd)
|
|
{
|
|
mroDef *mro;
|
|
|
|
cd -> visible = NULL;
|
|
|
|
for (mro = cd -> mro; mro != NULL; mro = mro -> next)
|
|
{
|
|
memberDef *md;
|
|
classDef *mrocd;
|
|
|
|
if (isDuplicateSuper(mro))
|
|
continue;
|
|
|
|
mrocd = mro -> cd;
|
|
|
|
/*
|
|
* If the base class is in the main module, see if it needs to
|
|
* publish any protected enums.
|
|
*/
|
|
if (cd -> iff -> module == pt -> module)
|
|
{
|
|
enumDef *ed;
|
|
|
|
for (ed = pt -> enums; ed != NULL; ed = ed -> next)
|
|
{
|
|
/* Skip unless we are the publisher. */
|
|
if (ed -> pcd != mrocd)
|
|
continue;
|
|
|
|
/*
|
|
* If we are not in the main module then the
|
|
* base class must take over as the publisher.
|
|
*/
|
|
if (mrocd -> iff -> module != pt -> module)
|
|
ed -> pcd = cd;
|
|
}
|
|
}
|
|
|
|
for (md = mrocd -> members; md != NULL; md = md -> next)
|
|
{
|
|
visibleList *vl;
|
|
|
|
/*
|
|
* See if it is already in the list. This has the desired side
|
|
* effect of eliminating any functions that have an implementation
|
|
* closer to this class in the hierarchy. This is the only reason
|
|
* to define private functions.
|
|
*/
|
|
for (vl = cd->visible; vl != NULL; vl = vl->next)
|
|
if (vl->m->pyname == md->pyname)
|
|
break;
|
|
|
|
/* See if it is a new member function. */
|
|
|
|
if (vl == NULL)
|
|
{
|
|
overDef *od;
|
|
|
|
vl = sipMalloc(sizeof (visibleList));
|
|
|
|
vl -> m = md;
|
|
vl -> cd = mrocd;
|
|
vl -> next = cd -> visible;
|
|
|
|
addToUsedList(&cd->iff->used, mrocd->iff);
|
|
|
|
cd -> visible = vl;
|
|
|
|
for (od = mrocd -> overs; od != NULL; od = od -> next)
|
|
if (od -> common == md)
|
|
{
|
|
if (isAbstract(od))
|
|
setIsAbstractClass(cd);
|
|
|
|
ifaceFilesAreUsed(pt, cd->iff, od);
|
|
|
|
/* See if we need the name. */
|
|
if (cd->iff->module != pt->module)
|
|
continue;
|
|
|
|
if (isProtected(od) || (isSignal(od) && !optNoEmitters(pt)))
|
|
setIsUsedName(md->pyname);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Get all the virtuals for a particular class.
|
|
*/
|
|
static void getVirtuals(sipSpec *pt,classDef *cd)
|
|
{
|
|
mroDef *mro;
|
|
virtOverDef *vod;
|
|
|
|
for (mro = cd -> mro; mro != NULL; mro = mro -> next)
|
|
{
|
|
if (isDuplicateSuper(mro))
|
|
continue;
|
|
|
|
getClassVirtuals(cd,mro -> cd);
|
|
}
|
|
|
|
/*
|
|
* Identify any re-implementations of virtuals. We have to do this for
|
|
* all classes, not just those in the main module.
|
|
*/
|
|
for (vod = cd -> vmembers; vod != NULL; vod = vod -> next)
|
|
{
|
|
overDef *od;
|
|
|
|
for (od = cd->overs; od != NULL; od = od->next)
|
|
{
|
|
if (isVirtual(od))
|
|
continue;
|
|
|
|
if (strcmp(vod->o.cppname, od->cppname) == 0 && sameOverload(&vod->o, od))
|
|
{
|
|
setIsVirtualReimp(od);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If this class is defined in the main module make sure we get
|
|
* the API files for all the visible virtuals.
|
|
*/
|
|
if (cd->iff->module == pt->module)
|
|
{
|
|
/* Make sure we get the name. */
|
|
setIsUsedName(vod -> o.common -> pyname);
|
|
|
|
ifaceFilesAreUsed(pt, cd->iff, &vod -> o);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Get the list of visible virtual functions for a class.
|
|
*/
|
|
static void getClassVirtuals(classDef *base,classDef *cd)
|
|
{
|
|
overDef *od;
|
|
|
|
for (od = cd -> overs; od != NULL; od = od -> next)
|
|
{
|
|
virtOverDef **tailp, *vod;
|
|
|
|
if (!isVirtual(od) || isPrivate(od))
|
|
continue;
|
|
|
|
/*
|
|
* See if a virtual of this name and signature is already in
|
|
* the list.
|
|
*/
|
|
for (tailp = &base -> vmembers; (vod = *tailp) != NULL; tailp = &vod -> next)
|
|
if (strcmp(vod -> o.cppname,od -> cppname) == 0 && sameOverload(&vod -> o,od))
|
|
break;
|
|
|
|
if (vod == NULL)
|
|
{
|
|
/*
|
|
* See if there is a non-virtual reimplementation
|
|
* nearer in the class hierarchy.
|
|
*/
|
|
|
|
mroDef *mro;
|
|
classDef *scope = NULL;
|
|
overDef *eod;
|
|
|
|
for (mro = base -> mro; mro -> cd != cd; mro = mro -> next)
|
|
{
|
|
if (isDuplicateSuper(mro))
|
|
continue;
|
|
|
|
/*
|
|
* Ignore classes that are on a different
|
|
* branch of the class hierarchy.
|
|
*/
|
|
if (!isSubClass(mro -> cd,cd))
|
|
continue;
|
|
|
|
for (eod = mro -> cd -> overs; eod != NULL; eod = eod -> next)
|
|
if (strcmp(eod -> cppname,od -> cppname) == 0 && sameSignature(eod -> cppsig,od -> cppsig,TRUE) && isConst(eod) == isConst(od) && !isAbstract(eod))
|
|
{
|
|
scope = mro -> cd;
|
|
break;
|
|
}
|
|
|
|
if (scope != NULL)
|
|
break;
|
|
}
|
|
|
|
vod = sipMalloc(sizeof (virtOverDef));
|
|
|
|
vod -> o = *od;
|
|
vod -> scope = (scope != NULL ? scope : cd);
|
|
vod -> next = NULL;
|
|
|
|
*tailp = vod;
|
|
|
|
/*
|
|
* If there was a nearer reimplementation then we use
|
|
* its protection and abstract flags.
|
|
*/
|
|
if (scope != NULL)
|
|
{
|
|
vod -> o.overflags &= ~(SECT_MASK | OVER_IS_ABSTRACT);
|
|
vod -> o.overflags |= (SECT_MASK | OVER_IS_ABSTRACT) & eod -> overflags;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Return TRUE is a class is derived from another.
|
|
*/
|
|
static int isSubClass(classDef *cc,classDef *pc)
|
|
{
|
|
mroDef *mro;
|
|
|
|
/*
|
|
* In other words, does the parent class appear in the child class's
|
|
* MRO list.
|
|
*/
|
|
for (mro = cc -> mro; mro != NULL; mro = mro -> next)
|
|
if (mro -> cd == pc)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*
|
|
* Resolve the types of a mapped type based on a template.
|
|
*/
|
|
static void resolveMappedTypeTypes(sipSpec *pt,mappedTypeDef *mt)
|
|
{
|
|
int a;
|
|
templateDef *td = mt -> type.u.td;
|
|
|
|
for (a = 0; a < td -> types.nrArgs; ++a)
|
|
{
|
|
getBaseType(pt, mt->iff->module, NULL, &td->types.args[a]);
|
|
|
|
ifaceFileIsUsed(pt, mt->iff, &td->types.args[a]);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Resolve the types of a ctor.
|
|
*/
|
|
static void resolveCtorTypes(sipSpec *pt,classDef *scope,ctorDef *ct)
|
|
{
|
|
int a;
|
|
|
|
/* Handle any C++ signature. */
|
|
if (ct->cppsig != NULL && ct->cppsig != &ct->pysig)
|
|
for (a = 0; a < ct -> cppsig -> nrArgs; ++a)
|
|
getBaseType(pt, scope->iff->module, scope, &ct->cppsig->args[a]);
|
|
|
|
/* Handle the Python signature. */
|
|
for (a = 0; a < ct -> pysig.nrArgs; ++a)
|
|
{
|
|
argDef *ad = &ct -> pysig.args[a];
|
|
|
|
getBaseType(pt, scope->iff->module, scope, ad);
|
|
|
|
if (!supportedType(scope,NULL,ad,FALSE) && (ct -> cppsig == &ct -> pysig || ct -> methodcode == NULL))
|
|
{
|
|
fatalScopedName(classFQCName(scope));
|
|
fatal(" unsupported ctor argument type - provide %%MethodCode and a C++ signature\n");
|
|
}
|
|
|
|
ifaceFileIsUsed(pt, scope->iff, ad);
|
|
scopeDefaultValue(pt,scope,ad);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Resolve the types of a function.
|
|
*/
|
|
static void resolveFuncTypes(sipSpec *pt, moduleDef *mod, classDef *scope, overDef *od)
|
|
{
|
|
argDef *res;
|
|
|
|
/* Handle any C++ signature. */
|
|
if (od -> cppsig != &od -> pysig)
|
|
{
|
|
int a;
|
|
|
|
getBaseType(pt,mod, scope, &od->cppsig->result);
|
|
|
|
for (a = 0; a < od -> cppsig -> nrArgs; ++a)
|
|
getBaseType(pt, mod, scope, &od->cppsig->args[a]);
|
|
}
|
|
|
|
/* Handle the Python signature. */
|
|
resolvePySigTypes(pt, mod, scope, od, &od->pysig,isSignal(od));
|
|
|
|
/* These slots must return int. */
|
|
res = &od -> pysig.result;
|
|
|
|
if (isIntReturnSlot(od->common))
|
|
if (res -> atype != int_type || res -> nrderefs != 0 ||
|
|
isReference(res) || isConstArg(res))
|
|
fatal("%s slots must return int\n",od -> common -> pyname -> text);
|
|
|
|
/* These slots must return void. */
|
|
if (isVoidReturnSlot(od -> common))
|
|
if (res -> atype != void_type || res -> nrderefs != 0 ||
|
|
isReference(res) || isConstArg(res))
|
|
fatal("%s slots must return void\n",od -> common -> pyname -> text);
|
|
|
|
/* These slots must return long. */
|
|
if (isLongReturnSlot(od->common))
|
|
if (res->atype != long_type || res->nrderefs != 0 ||
|
|
isReference(res) || isConstArg(res))
|
|
fatal("%s slots must return long\n", od->common->pyname->text);
|
|
}
|
|
|
|
|
|
/*
|
|
* Resolve the types of a Python signature.
|
|
*/
|
|
static void resolvePySigTypes(sipSpec *pt, moduleDef *mod, classDef *scope,
|
|
overDef *od, signatureDef *pysig, int issignal)
|
|
{
|
|
int a;
|
|
argDef *res = &pysig -> result;
|
|
|
|
if (res -> atype != void_type || res -> nrderefs != 0)
|
|
{
|
|
if (issignal)
|
|
{
|
|
if (scope != NULL)
|
|
{
|
|
fatalScopedName(classFQCName(scope));
|
|
fatal("::");
|
|
}
|
|
|
|
fatal("%s() signals must return void\n",od -> cppname);
|
|
}
|
|
|
|
getBaseType(pt, mod, scope, res);
|
|
|
|
/* Results must be simple. */
|
|
if (!supportedType(scope,od,res,FALSE) && (od -> cppsig == &od -> pysig || od -> methodcode == NULL))
|
|
{
|
|
if (scope != NULL)
|
|
{
|
|
fatalScopedName(classFQCName(scope));
|
|
fatal("::");
|
|
}
|
|
|
|
fatal("%s() unsupported function return type - provide %%MethodCode and a %s signature\n",od -> cppname,(pt -> genc ? "C" : "C++"));
|
|
}
|
|
}
|
|
|
|
for (a = 0; a < pysig -> nrArgs; ++a)
|
|
{
|
|
argDef *ad = &pysig -> args[a];
|
|
|
|
getBaseType(pt, mod, scope, ad);
|
|
|
|
if (ad -> atype == slotcon_type)
|
|
resolvePySigTypes(pt, mod, scope, od, ad->u.sa, TRUE);
|
|
|
|
/*
|
|
* Note signal arguments are restricted in their types because we don't
|
|
* (yet) support handwritten code for them.
|
|
*/
|
|
if (issignal)
|
|
{
|
|
if (!supportedType(scope,od,ad,FALSE))
|
|
{
|
|
if (scope != NULL)
|
|
{
|
|
fatalScopedName(classFQCName(scope));
|
|
fatal("::");
|
|
}
|
|
|
|
fatal("%s() unsupported signal argument type\n");
|
|
}
|
|
}
|
|
else if (!supportedType(scope,od,ad,TRUE) && (od -> cppsig == &od -> pysig || od -> methodcode == NULL || (isVirtual(od) && od -> virthandler -> virtcode == NULL)))
|
|
{
|
|
if (scope != NULL)
|
|
{
|
|
fatalScopedName(classFQCName(scope));
|
|
fatal("::");
|
|
}
|
|
|
|
if (isVirtual(od))
|
|
fatal("%s() unsupported function argument type - provide %%Method code, a valid %%VirtualCatcherCode and a valid C++ signature\n",od -> cppname);
|
|
|
|
fatal("%s() unsupported function argument type - provide %%Method code and a valid %s signature\n",od -> cppname,(pt -> genc ? "C" : "C++"));
|
|
}
|
|
|
|
if (scope != NULL)
|
|
scopeDefaultValue(pt,scope,ad);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Resolve the type of a variable.
|
|
*/
|
|
static void resolveVariableType(sipSpec *pt,varDef *vd)
|
|
{
|
|
int bad = TRUE;
|
|
argDef *vtype = &vd -> type;
|
|
|
|
getBaseType(pt, vd->module, vd->ecd, vtype);
|
|
|
|
switch (vtype -> atype)
|
|
{
|
|
case mapped_type:
|
|
case class_type:
|
|
/* Class, Class & and Class * are supported. */
|
|
|
|
if (vtype -> nrderefs <= 1)
|
|
bad = FALSE;
|
|
break;
|
|
|
|
case sstring_type:
|
|
case ustring_type:
|
|
case string_type:
|
|
case wstring_type:
|
|
/*
|
|
* (signed/unsigned) char, (signed/unsigned) char *, wchar_t, wchar_t *
|
|
* are supported.
|
|
*/
|
|
|
|
if (!isReference(vtype) && vtype -> nrderefs <= 1)
|
|
bad = FALSE;
|
|
break;
|
|
|
|
case cfloat_type:
|
|
case float_type:
|
|
case cdouble_type:
|
|
case double_type:
|
|
case enum_type:
|
|
case bool_type:
|
|
case cbool_type:
|
|
case ushort_type:
|
|
case short_type:
|
|
case uint_type:
|
|
case cint_type:
|
|
case int_type:
|
|
case ulong_type:
|
|
case long_type:
|
|
case ulonglong_type:
|
|
case longlong_type:
|
|
case pyobject_type:
|
|
case pytuple_type:
|
|
case pylist_type:
|
|
case pydict_type:
|
|
case pycallable_type:
|
|
case pyslice_type:
|
|
case pytype_type:
|
|
/* These are supported without pointers or references. */
|
|
|
|
if (!isReference(vtype) && vtype -> nrderefs == 0)
|
|
bad = FALSE;
|
|
break;
|
|
|
|
case struct_type:
|
|
case void_type:
|
|
/* A simple pointer is supported. */
|
|
|
|
if (!isReference(vtype) && vtype -> nrderefs == 1)
|
|
bad = FALSE;
|
|
break;
|
|
}
|
|
|
|
if (bad)
|
|
{
|
|
fatalScopedName(vd -> fqcname);
|
|
fatal(" has an unsupported type\n");
|
|
}
|
|
|
|
if (vtype -> atype != class_type && vd -> accessfunc != NULL)
|
|
{
|
|
fatalScopedName(vd -> fqcname);
|
|
fatal(" has %%AccessCode but isn't a class instance\n");
|
|
}
|
|
|
|
if (vd -> ecd != NULL)
|
|
ifaceFileIsUsed(pt, vd->ecd->iff, vtype);
|
|
else
|
|
ifaceFileIsUsed(pt, NULL, vtype);
|
|
|
|
/*
|
|
* Instance variables or static class variables (unless they are
|
|
* constants) need a handler.
|
|
*/
|
|
if (vd -> ecd != NULL && vd -> accessfunc == NULL &&
|
|
(!isStaticVar(vd) || vtype -> nrderefs != 0 || !isConstArg(vtype)))
|
|
{
|
|
setNeedsHandler(vd);
|
|
setHasVarHandlers(vd -> ecd);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* See if a type is supported by the generated code.
|
|
*/
|
|
static int supportedType(classDef *cd,overDef *od,argDef *ad,int outputs)
|
|
{
|
|
switch (ad -> atype)
|
|
{
|
|
case anyslot_type:
|
|
/*
|
|
* This must be an input, and must also have handwritten code.
|
|
*/
|
|
|
|
ensureInput(cd,od,ad);
|
|
return FALSE;
|
|
|
|
case signal_type:
|
|
case slot_type:
|
|
case rxcon_type:
|
|
case rxdis_type:
|
|
case slotcon_type:
|
|
case slotdis_type:
|
|
case qobject_type:
|
|
case ellipsis_type:
|
|
/* These can only appear in argument lists without * or &. */
|
|
|
|
ensureInput(cd,od,ad);
|
|
return TRUE;
|
|
|
|
case sstring_type:
|
|
case ustring_type:
|
|
case string_type:
|
|
case wstring_type:
|
|
if (isReference(ad))
|
|
{
|
|
if (outputs && ad -> nrderefs <= 1)
|
|
{
|
|
defaultOutput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if (ad -> nrderefs == 0)
|
|
{
|
|
ensureInput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
else if (ad -> nrderefs == 1)
|
|
{
|
|
if (outputs)
|
|
defaultInput(ad);
|
|
else
|
|
ensureInput(cd,od,ad);
|
|
|
|
return TRUE;
|
|
}
|
|
else if (ad -> nrderefs == 2 && outputs)
|
|
{
|
|
defaultOutput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
|
|
break;
|
|
|
|
case cfloat_type:
|
|
case float_type:
|
|
case cdouble_type:
|
|
case double_type:
|
|
case enum_type:
|
|
case bool_type:
|
|
case cbool_type:
|
|
case ushort_type:
|
|
case short_type:
|
|
case uint_type:
|
|
case cint_type:
|
|
case int_type:
|
|
case ulong_type:
|
|
case long_type:
|
|
case ulonglong_type:
|
|
case longlong_type:
|
|
case pyobject_type:
|
|
case pytuple_type:
|
|
case pylist_type:
|
|
case pydict_type:
|
|
case pycallable_type:
|
|
case pyslice_type:
|
|
case pytype_type:
|
|
if (isReference(ad))
|
|
{
|
|
if (ad -> nrderefs == 0 && outputs)
|
|
{
|
|
defaultOutput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if (ad -> nrderefs == 0)
|
|
{
|
|
ensureInput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
else if (ad -> nrderefs == 1 && outputs)
|
|
{
|
|
defaultOutput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
|
|
break;
|
|
|
|
case mapped_type:
|
|
case class_type:
|
|
if (isReference(ad))
|
|
{
|
|
if (ad -> nrderefs == 0)
|
|
{
|
|
defaultInput(ad);
|
|
return TRUE;
|
|
}
|
|
else if (ad -> nrderefs == 1 && outputs)
|
|
{
|
|
defaultOutput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if (ad -> nrderefs == 0)
|
|
{
|
|
ensureInput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
else if (ad -> nrderefs == 1)
|
|
{
|
|
if (outputs)
|
|
defaultInput(ad);
|
|
else
|
|
ensureInput(cd,od,ad);
|
|
|
|
return TRUE;
|
|
}
|
|
else if (ad -> nrderefs == 2 && outputs)
|
|
{
|
|
defaultOutput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
|
|
break;
|
|
|
|
case struct_type:
|
|
case void_type:
|
|
if (isReference(ad))
|
|
{
|
|
if (ad -> nrderefs == 1 && outputs)
|
|
{
|
|
defaultOutput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if (ad -> nrderefs == 1)
|
|
{
|
|
ensureInput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
else if (ad -> nrderefs == 2 && outputs)
|
|
{
|
|
defaultOutput(cd,od,ad);
|
|
return TRUE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
/* Unsupported if we got this far. */
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*
|
|
* Ensure the direction of an argument is an input.
|
|
*/
|
|
static void ensureInput(classDef *cd,overDef *od,argDef *ad)
|
|
{
|
|
if (isOutArg(ad))
|
|
{
|
|
if (cd != NULL)
|
|
{
|
|
fatalScopedName(classFQCName(cd));
|
|
fatal("::");
|
|
}
|
|
|
|
if (od != NULL)
|
|
fatal("%s",od -> cppname);
|
|
|
|
fatal("() invalid argument type for /Out/\n");
|
|
}
|
|
|
|
setIsInArg(ad);
|
|
}
|
|
|
|
|
|
/*
|
|
* Default the direction of an argument to an input.
|
|
*/
|
|
static void defaultInput(argDef *ad)
|
|
{
|
|
if (!isInArg(ad) && !isOutArg(ad))
|
|
setIsInArg(ad);
|
|
}
|
|
|
|
|
|
/*
|
|
* Default the direction of an argument to an output unless the argument is
|
|
* const.
|
|
*/
|
|
static void defaultOutput(classDef *cd,overDef *od,argDef *ad)
|
|
{
|
|
if (isOutArg(ad))
|
|
{
|
|
if (isConstArg(ad))
|
|
{
|
|
if (cd != NULL)
|
|
{
|
|
fatalScopedName(classFQCName(cd));
|
|
fatal("::");
|
|
}
|
|
|
|
if (od != NULL)
|
|
fatal("%s",od -> cppname);
|
|
|
|
fatal("() const argument cannot have /Out/ specified\n");
|
|
}
|
|
}
|
|
else if (!isInArg(ad))
|
|
if (isConstArg(ad))
|
|
setIsInArg(ad);
|
|
else
|
|
setIsOutArg(ad);
|
|
}
|
|
|
|
|
|
/*
|
|
* Put a scoped name to stderr.
|
|
*/
|
|
void fatalScopedName(scopedNameDef *snd)
|
|
{
|
|
while (snd != NULL)
|
|
{
|
|
fatal("%s",snd -> name);
|
|
|
|
snd = snd -> next;
|
|
|
|
if (snd != NULL)
|
|
fatal("::");
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Compare two overloads and return TRUE if they are the same.
|
|
*/
|
|
static int sameOverload(overDef *od1,overDef *od2)
|
|
{
|
|
/* They must both be const, or both not. */
|
|
if (isConst(od1) != isConst(od2))
|
|
return FALSE;
|
|
|
|
return sameSignature(&od1 -> pysig,&od2 -> pysig,TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* Compare two virtual handlers and return TRUE if they are the same.
|
|
*/
|
|
static int sameVirtualHandler(virtHandlerDef *vhd1,virtHandlerDef *vhd2)
|
|
{
|
|
if (isTransferVH(vhd1) != isTransferVH(vhd2))
|
|
return FALSE;
|
|
|
|
if (!sameArgType(&vhd1->pysig->result, &vhd2->pysig->result, TRUE))
|
|
return FALSE;
|
|
|
|
if (!sameSignature(vhd1->pysig, vhd2->pysig, TRUE))
|
|
return FALSE;
|
|
|
|
if (vhd1->pysig == vhd1->cppsig && vhd2->pysig == vhd2->cppsig)
|
|
return TRUE;
|
|
|
|
if (!sameArgType(&vhd1->cppsig->result, &vhd2->cppsig->result, TRUE))
|
|
return FALSE;
|
|
|
|
return sameSignature(vhd1->cppsig, vhd2->cppsig, TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* Compare two signatures and return TRUE if they are the same.
|
|
*/
|
|
int sameSignature(signatureDef *sd1,signatureDef *sd2,int strict)
|
|
{
|
|
int a;
|
|
|
|
if (strict)
|
|
{
|
|
/* The number of arguments must be the same. */
|
|
if (sd1 -> nrArgs != sd2 -> nrArgs)
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
int na1, na2;
|
|
|
|
/* We only count the compulsory arguments. */
|
|
na1 = 0;
|
|
|
|
for (a = 0; a < sd1 -> nrArgs; ++a)
|
|
{
|
|
if (sd1 -> args[a].defval != NULL)
|
|
break;
|
|
|
|
++na1;
|
|
}
|
|
|
|
na2 = 0;
|
|
|
|
for (a = 0; a < sd2 -> nrArgs; ++a)
|
|
{
|
|
if (sd2 -> args[a].defval != NULL)
|
|
break;
|
|
|
|
++na2;
|
|
}
|
|
|
|
if (na1 != na2)
|
|
return FALSE;
|
|
}
|
|
|
|
/* The arguments must be the same. */
|
|
for (a = 0; a < sd1 -> nrArgs; ++a)
|
|
{
|
|
if (!strict && sd1 -> args[a].defval != NULL)
|
|
break;
|
|
|
|
if (!sameArgType(&sd1 -> args[a],&sd2 -> args[a],strict))
|
|
return FALSE;
|
|
}
|
|
|
|
/* Must be the same if we've got this far. */
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
#define pyAsString(t) ((t) == ustring_type || (t) == sstring_type || \
|
|
(t) == string_type)
|
|
#define pyAsFloat(t) ((t) == cfloat_type || (t) == float_type || \
|
|
(t) == cdouble_type || (t) == double_type)
|
|
#define pyAsInt(t) ((t) == cint_type || (t) == bool_type || \
|
|
(t) == short_type || (t) == ushort_type || \
|
|
(t) == int_type || (t) == uint_type)
|
|
#define pyAsLong(t) ((t) == long_type || (t) == longlong_type)
|
|
#define pyAsULong(t) ((t) == ulong_type || (t) == ulonglong_type)
|
|
#define pyAsAuto(t) ((t) == bool_type || \
|
|
(t) == short_type || (t) == ushort_type || \
|
|
(t) == int_type || (t) == uint_type || \
|
|
(t) == float_type || (t) == double_type)
|
|
|
|
/*
|
|
* Compare two argument types and return TRUE if they are the same. "strict"
|
|
* means as C++ would see it, rather than Python.
|
|
*/
|
|
static int sameArgType(argDef *a1, argDef *a2, int strict)
|
|
{
|
|
/* The references must be the same. */
|
|
if (isReference(a1) != isReference(a2) || a1->nrderefs != a2->nrderefs)
|
|
return FALSE;
|
|
|
|
if (strict)
|
|
{
|
|
/* The const should be the same. */
|
|
if (isConstArg(a1) != isConstArg(a2))
|
|
return FALSE;
|
|
|
|
return sameBaseType(a1,a2);
|
|
}
|
|
|
|
/* Python will see all these as strings. */
|
|
if (pyAsString(a1->atype) && pyAsString(a2->atype))
|
|
return TRUE;
|
|
|
|
/* Python will see all these as floats. */
|
|
if (pyAsFloat(a1->atype) && pyAsFloat(a2->atype))
|
|
return TRUE;
|
|
|
|
/* Python will see all these as ints. */
|
|
if (pyAsInt(a1->atype) && pyAsInt(a2->atype))
|
|
return TRUE;
|
|
|
|
/* Python will see all these as longs. */
|
|
if (pyAsLong(a1->atype) && pyAsLong(a2->atype))
|
|
return TRUE;
|
|
|
|
/* Python will see all these as unsigned longs. */
|
|
if (pyAsULong(a1->atype) && pyAsULong(a2->atype))
|
|
return TRUE;
|
|
|
|
/* Python will automatically convert between these. */
|
|
if (pyAsAuto(a1->atype) && pyAsAuto(a2->atype))
|
|
return TRUE;
|
|
|
|
/* All the special cases have been handled. */
|
|
return sameBaseType(a1, a2);
|
|
}
|
|
|
|
|
|
/*
|
|
* Compare two basic types and return TRUE if they are the same.
|
|
*/
|
|
|
|
int sameBaseType(argDef *a1,argDef *a2)
|
|
{
|
|
/* The types must be the same. */
|
|
|
|
if (a1 -> atype != a2 ->atype)
|
|
return FALSE;
|
|
|
|
switch (a1 -> atype)
|
|
{
|
|
case class_type:
|
|
if (a1 -> u.cd != a2 -> u.cd)
|
|
return FALSE;
|
|
|
|
break;
|
|
|
|
case enum_type:
|
|
if (a1 -> u.ed != a2 -> u.ed)
|
|
return FALSE;
|
|
|
|
break;
|
|
|
|
case slotcon_type:
|
|
case slotdis_type:
|
|
if (!sameSignature(a1 -> u.sa,a2 -> u.sa,TRUE))
|
|
return FALSE;
|
|
|
|
break;
|
|
|
|
case template_type:
|
|
{
|
|
int a;
|
|
templateDef *td1, *td2;
|
|
|
|
td1 = a1 -> u.td;
|
|
td2 = a2 -> u.td;
|
|
|
|
if (!sameScopedName(td1 -> fqname,td2 -> fqname) != 0 ||
|
|
td1 -> types.nrArgs != td2 -> types.nrArgs)
|
|
return FALSE;
|
|
|
|
for (a = 0; a < td1 -> types.nrArgs; ++a)
|
|
if (!sameBaseType(&td1 -> types.args[a],&td2 -> types.args[a]))
|
|
return FALSE;
|
|
|
|
break;
|
|
}
|
|
|
|
case struct_type:
|
|
if (!sameScopedName(a1 -> u.sname,a2 -> u.sname) != 0)
|
|
return FALSE;
|
|
|
|
break;
|
|
|
|
case defined_type:
|
|
if (!sameScopedName(a1 -> u.snd,a2 -> u.snd))
|
|
return FALSE;
|
|
|
|
break;
|
|
|
|
case mapped_type:
|
|
if (a1 -> u.mtd != a2 -> u.mtd)
|
|
return FALSE;
|
|
|
|
break;
|
|
}
|
|
|
|
/* Must be the same if we've got this far. */
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* See if two Python signatures are the same as far as Python is concerned.
|
|
*/
|
|
static int samePythonSignature(signatureDef *sd1, signatureDef *sd2)
|
|
{
|
|
int a1, a2;
|
|
|
|
a1 = a2 = -1;
|
|
|
|
for (;;)
|
|
{
|
|
a1 = nextSignificantArg(sd1, a1);
|
|
a2 = nextSignificantArg(sd2, a2);
|
|
|
|
if (a1 < 0 || a2 < 0)
|
|
break;
|
|
|
|
if (!sameArgType(&sd1->args[a1], &sd2->args[a2], FALSE))
|
|
return FALSE;
|
|
}
|
|
|
|
return (a1 < 0 && a2 < 0);
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
* Return the next significant argument from a Python signature (ie. one that
|
|
* is not optional or an output only argument. Return -1 if there isn't one.
|
|
*/
|
|
static int nextSignificantArg(signatureDef *sd, int a)
|
|
{
|
|
while (++a < sd->nrArgs)
|
|
{
|
|
if (sd->args[a].defval != NULL)
|
|
break;
|
|
|
|
if (isInArg(&sd->args[a]))
|
|
return a;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* Return TRUE if two scoped names are the same.
|
|
*/
|
|
|
|
int sameScopedName(scopedNameDef *snd1,scopedNameDef *snd2)
|
|
{
|
|
while (snd1 != NULL && snd2 != NULL && strcmp(snd1 -> name,snd2 -> name) == 0)
|
|
{
|
|
snd1 = snd1 -> next;
|
|
snd2 = snd2 -> next;
|
|
}
|
|
|
|
return (snd1 == NULL && snd2 == NULL);
|
|
}
|
|
|
|
|
|
/*
|
|
* Add an explicit scope to the default value of an argument if possible.
|
|
*/
|
|
|
|
static void scopeDefaultValue(sipSpec *pt,classDef *cd,argDef *ad)
|
|
{
|
|
valueDef *vd, **tailp, *newvd;
|
|
|
|
/*
|
|
* We do a quick check to see if we need to do anything. This means
|
|
* we can limit the times we need to copy the default value. It needs
|
|
* to be copied because it will be shared by class versions that have
|
|
* been created on the fly and it may need to be scoped differently for
|
|
* each of those versions.
|
|
*/
|
|
|
|
for (vd = ad -> defval; vd != NULL; vd = vd -> next)
|
|
if (vd -> vtype == scoped_value && vd -> u.vscp -> next == NULL)
|
|
break;
|
|
|
|
if (vd == NULL)
|
|
return;
|
|
|
|
/*
|
|
* It's not certain that we will do anything, but we assume we will and
|
|
* start copying.
|
|
*/
|
|
|
|
newvd = NULL;
|
|
tailp = &newvd;
|
|
|
|
for (vd = ad -> defval; vd != NULL; vd = vd -> next)
|
|
{
|
|
mroDef *mro;
|
|
scopedNameDef *origname;
|
|
valueDef *new;
|
|
|
|
/* Make the copy. */
|
|
|
|
new = sipMalloc(sizeof (valueDef));
|
|
|
|
*new = *vd;
|
|
*tailp = new;
|
|
tailp = &new -> next;
|
|
|
|
/*
|
|
* Skip this part of the expression if it isn't a named value
|
|
* or it already has a scope.
|
|
*/
|
|
|
|
if (vd -> vtype != scoped_value || vd -> u.vscp -> next != NULL)
|
|
continue;
|
|
|
|
/*
|
|
* Search the class hierarchy for an enum value with the same
|
|
* name. If we don't find one, leave it as it is (the compiler
|
|
* will find out if this is a problem).
|
|
*/
|
|
|
|
origname = vd -> u.vscp;
|
|
|
|
for (mro = cd -> mro; mro != NULL; mro = mro -> next)
|
|
{
|
|
enumDef *ed;
|
|
|
|
if (isDuplicateSuper(mro))
|
|
continue;
|
|
|
|
for (ed = pt -> enums; ed != NULL; ed = ed -> next)
|
|
{
|
|
enumMemberDef *emd;
|
|
|
|
if (ed -> ecd != mro -> cd)
|
|
continue;
|
|
|
|
for (emd = ed -> members; emd != NULL; emd = emd -> next)
|
|
if (strcmp(emd -> cname,origname -> name) == 0)
|
|
{
|
|
scopedNameDef *snd;
|
|
|
|
/*
|
|
* Take the scope from the
|
|
* class that the enum was
|
|
* defined in.
|
|
*/
|
|
|
|
snd = copyScopedName(mro -> cd -> iff -> fqcname);
|
|
appendScopedName(&snd,origname);
|
|
|
|
new -> u.vscp = snd;
|
|
|
|
/* Nothing more to do. */
|
|
|
|
break;
|
|
}
|
|
|
|
if (emd != NULL)
|
|
break;
|
|
}
|
|
|
|
if (ed != NULL)
|
|
break;
|
|
}
|
|
}
|
|
|
|
ad -> defval = newvd;
|
|
}
|
|
|
|
|
|
/*
|
|
* Make sure a type is a base type.
|
|
*/
|
|
static void getBaseType(sipSpec *pt, moduleDef *mod, classDef *defscope, argDef *type)
|
|
{
|
|
/* Loop until we've got to a base type. */
|
|
while (type -> atype == defined_type)
|
|
{
|
|
scopedNameDef *snd = type -> u.snd;
|
|
|
|
type -> atype = no_type;
|
|
|
|
if (defscope != NULL)
|
|
searchScope(pt,defscope,snd,type);
|
|
|
|
if (type -> atype == no_type)
|
|
searchMappedTypes(pt,snd,type);
|
|
|
|
if (type -> atype == no_type)
|
|
searchTypedefs(pt,snd,type);
|
|
|
|
if (type -> atype == no_type)
|
|
searchEnums(pt,snd,type);
|
|
|
|
if (type -> atype == no_type)
|
|
searchClasses(pt, mod, snd, type);
|
|
|
|
if (type -> atype == no_type)
|
|
fatalNoDefinedType(snd);
|
|
}
|
|
|
|
/* Get the base type of any slot arguments. */
|
|
if (type -> atype == slotcon_type || type -> atype == slotdis_type)
|
|
{
|
|
int sa;
|
|
|
|
for (sa = 0; sa < type -> u.sa -> nrArgs; ++sa)
|
|
getBaseType(pt, mod, defscope, &type->u.sa->args[sa]);
|
|
}
|
|
|
|
/* See if the type refers to an instantiated template. */
|
|
if (type->atype == template_type)
|
|
{
|
|
classDef *cd;
|
|
|
|
for (cd = pt->classes; cd != NULL; cd = cd->next)
|
|
if (cd->td != NULL &&
|
|
sameScopedName(cd->td->fqname, type->u.td->fqname) &&
|
|
sameSignature(&cd->td->types, &type->u.td->types, TRUE))
|
|
{
|
|
type->atype = class_type;
|
|
type->u.cd = cd;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Replace the base type if it has been mapped. */
|
|
if (type -> atype == struct_type || type -> atype == template_type)
|
|
{
|
|
searchMappedTypes(pt,NULL,type);
|
|
|
|
/*
|
|
* If we still have a template then see if we need to
|
|
* automatically instantiate it.
|
|
*/
|
|
if (type->atype == template_type)
|
|
{
|
|
mappedTypeTmplDef *mtt;
|
|
|
|
for (mtt = pt->mappedtypetemplates; mtt != NULL; mtt = mtt->next)
|
|
if (sameScopedName(type->u.td->fqname, mtt->mt->type.u.td->fqname) && sameTemplateSignature(&type->u.td->types, &mtt->mt->type.u.td->types, TRUE))
|
|
{
|
|
type->u.mtd = instantiateMappedTypeTemplate(pt, mod, mtt, type);
|
|
type->atype = mapped_type;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Instantiate a mapped type template and return it.
|
|
*/
|
|
static mappedTypeDef *instantiateMappedTypeTemplate(sipSpec *pt, moduleDef *mod, mappedTypeTmplDef *mtt, argDef *type)
|
|
{
|
|
scopedNameDef *type_names, *type_values;
|
|
mappedTypeDef *mtd;
|
|
|
|
type_names = type_values = NULL;
|
|
appendTypeStrings(type->u.td->fqname, &mtt->mt->type.u.td->types, &type->u.td->types, &mtt->sig, &type_names, &type_values);
|
|
|
|
mtd = allocMappedType(type);
|
|
|
|
mtd->iff = findIfaceFile(pt, mod, type->u.td->fqname, mappedtype_iface, type);
|
|
mtd->iff->module = mod;
|
|
|
|
mtd->hdrcode = templateCode(pt, &mtd->iff->used, mtt->mt->hdrcode, type_names, type_values);
|
|
mtd->convfromcode = templateCode(pt, &mtd->iff->used, mtt->mt->convfromcode, type_names, type_values);
|
|
mtd->convtocode = templateCode(pt, &mtd->iff->used, mtt->mt->convtocode, type_names, type_values);
|
|
|
|
mtd->next = pt->mappedtypes;
|
|
pt->mappedtypes = mtd;
|
|
|
|
if (type_names != NULL)
|
|
freeScopedName(type_names);
|
|
|
|
if (type_values != NULL)
|
|
freeScopedName(type_values);
|
|
|
|
return mtd;
|
|
}
|
|
|
|
|
|
/*
|
|
* Search for a name in a scope and return the corresponding type.
|
|
*/
|
|
|
|
static void searchScope(sipSpec *pt,classDef *scope,scopedNameDef *snd,
|
|
argDef *ad)
|
|
{
|
|
scopedNameDef *tmpsnd = NULL;
|
|
mroDef *mro;
|
|
|
|
for (mro = scope -> mro; mro != NULL; mro = mro -> next)
|
|
{
|
|
if (isDuplicateSuper(mro))
|
|
continue;
|
|
|
|
/* Append the name to the scope and see if it exists. */
|
|
|
|
tmpsnd = copyScopedName(classFQCName(mro -> cd));
|
|
appendScopedName(&tmpsnd,copyScopedName(snd));
|
|
|
|
searchMappedTypes(pt,tmpsnd,ad);
|
|
|
|
if (ad -> atype != no_type)
|
|
break;
|
|
|
|
searchTypedefs(pt,tmpsnd,ad);
|
|
|
|
if (ad -> atype != no_type)
|
|
break;
|
|
|
|
searchEnums(pt,tmpsnd,ad);
|
|
|
|
if (ad -> atype != no_type)
|
|
break;
|
|
|
|
searchClasses(pt, mro->cd->iff->module, tmpsnd, ad);
|
|
|
|
if (ad -> atype != no_type)
|
|
break;
|
|
|
|
freeScopedName(tmpsnd);
|
|
tmpsnd = NULL;
|
|
}
|
|
|
|
if (tmpsnd != NULL)
|
|
freeScopedName(tmpsnd);
|
|
}
|
|
|
|
|
|
/*
|
|
* Search the mapped types for a name and return the type.
|
|
*/
|
|
|
|
static void searchMappedTypes(sipSpec *pt,scopedNameDef *snd,argDef *ad)
|
|
{
|
|
mappedTypeDef *mtd;
|
|
scopedNameDef *oname;
|
|
|
|
/* Patch back to defined types so we can use sameBaseType(). */
|
|
if (snd != NULL)
|
|
{
|
|
oname = ad -> u.snd;
|
|
ad -> u.snd = snd;
|
|
ad -> atype = defined_type;
|
|
}
|
|
|
|
for (mtd = pt -> mappedtypes; mtd != NULL; mtd = mtd -> next)
|
|
if (sameBaseType(ad,&mtd -> type))
|
|
{
|
|
/* Copy the type. */
|
|
ad -> atype = mapped_type;
|
|
ad -> u.mtd = mtd;
|
|
|
|
return;
|
|
}
|
|
|
|
/* Restore because we didn't find anything. */
|
|
if (snd != NULL)
|
|
{
|
|
ad -> u.snd = oname;
|
|
ad -> atype = no_type;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Search the typedefs for a name and return the type.
|
|
*/
|
|
|
|
static void searchTypedefs(sipSpec *pt,scopedNameDef *snd,argDef *ad)
|
|
{
|
|
typedefDef *td;
|
|
|
|
for (td = pt -> typedefs; td != NULL; td = td -> next)
|
|
if (sameScopedName(td -> fqname,snd))
|
|
{
|
|
/* Copy the type. */
|
|
|
|
ad -> atype = td -> type.atype;
|
|
ad -> argflags |= td -> type.argflags;
|
|
ad -> nrderefs += td -> type.nrderefs;
|
|
ad -> u = td -> type.u;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Search the enums for a name and return the type.
|
|
*/
|
|
|
|
static void searchEnums(sipSpec *pt,scopedNameDef *snd,argDef *ad)
|
|
{
|
|
enumDef *ed;
|
|
|
|
for (ed = pt -> enums; ed != NULL; ed = ed -> next)
|
|
{
|
|
if (ed -> fqcname == NULL)
|
|
continue;
|
|
|
|
if (sameScopedName(ed -> fqcname,snd))
|
|
{
|
|
ad -> atype = enum_type;
|
|
ad -> u.ed = ed;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Search the classes for one with a particular name and return it as a type.
|
|
*/
|
|
static void searchClasses(sipSpec *pt, moduleDef *mod, scopedNameDef *cname, argDef *ad)
|
|
{
|
|
classDef *cd;
|
|
|
|
for (cd = pt -> classes; cd != NULL; cd = cd -> next)
|
|
{
|
|
/*
|
|
* Ignore an external class unless it was declared in the same
|
|
* context (ie. module) as the name is being used.
|
|
*/
|
|
if (isExternal(cd) && cd->iff->module != mod)
|
|
continue;
|
|
|
|
if (sameScopedName(classFQCName(cd), cname))
|
|
{
|
|
ad -> atype = class_type;
|
|
ad -> u.cd = cd;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Print an error message describing an undefined type to stderr and terminate.
|
|
*/
|
|
|
|
static void fatalNoDefinedType(scopedNameDef *snd)
|
|
{
|
|
fatalScopedName(snd);
|
|
fatal(" is undefined\n");
|
|
}
|
|
|
|
|
|
/*
|
|
* Make sure all external interface files for all other functions of a module
|
|
* are used.
|
|
*/
|
|
static void ifaceFilesAreUsedFromOther(sipSpec *pt, signatureDef *sd)
|
|
{
|
|
int a;
|
|
ifaceFileDef *iff;
|
|
|
|
if ((iff = getIfaceFile(&sd->result)) != NULL && iff->module != pt->module)
|
|
addToUsedList(&pt->used, iff);
|
|
|
|
for (a = 0; a < sd->nrArgs; ++a)
|
|
if ((iff = getIfaceFile(&sd->args[a])) != NULL && iff->module != pt->module)
|
|
addToUsedList(&pt->used, iff);
|
|
}
|
|
|
|
|
|
/*
|
|
* Make sure all interface files for all overloads of a method are used.
|
|
*/
|
|
static void ifaceFilesAreUsedByMethod(sipSpec *pt, classDef *cd, memberDef *md)
|
|
{
|
|
overDef *od;
|
|
|
|
for (od = cd -> overs; od != NULL; od = od -> next)
|
|
if (od -> common == md)
|
|
ifaceFilesAreUsed(pt, cd->iff, od);
|
|
}
|
|
|
|
|
|
/*
|
|
* Make sure all interface files for a signature are used.
|
|
*/
|
|
static void ifaceFilesAreUsed(sipSpec *pt, ifaceFileDef *iff, overDef *od)
|
|
{
|
|
int a;
|
|
|
|
ifaceFileIsUsed(pt, iff, &od->pysig.result);
|
|
|
|
for (a = 0; a < od->pysig.nrArgs; ++a)
|
|
ifaceFileIsUsed(pt, iff, &od->pysig.args[a]);
|
|
|
|
if (od->cppsig != &od->pysig)
|
|
{
|
|
ifaceFileIsUsed(pt, iff, &od->cppsig->result);
|
|
|
|
for (a = 0; a < od->cppsig->nrArgs; ++a)
|
|
ifaceFileIsUsed(pt, iff, &od->cppsig->args[a]);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* If a type has an interface file then add it to the appropriate list of used
|
|
* interface files so that the header file is #included in the generated code.
|
|
*/
|
|
static void ifaceFileIsUsed(sipSpec *pt, ifaceFileDef *iff, argDef *ad)
|
|
{
|
|
ifaceFileDef *usediff;
|
|
|
|
if ((usediff = getIfaceFile(ad)) != NULL && usediff != iff)
|
|
{
|
|
ifaceFileList *iffl, **used;
|
|
|
|
used = (iff != NULL ? &iff->used : &pt->used);
|
|
|
|
iffl = addToUsedList(used, usediff);
|
|
|
|
/*
|
|
* If the type is a protected enum then its scoping shadow
|
|
* class is needed in the generated header file.
|
|
*/
|
|
if (ad->atype == enum_type && isProtectedEnum(ad->u.ed))
|
|
iffl->header = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Return the interface file for a type, or NULL if it doesn't have one.
|
|
*/
|
|
static ifaceFileDef *getIfaceFile(argDef *ad)
|
|
{
|
|
ifaceFileDef *iff;
|
|
|
|
switch (ad -> atype)
|
|
{
|
|
case class_type:
|
|
iff = ad -> u.cd -> iff;
|
|
break;
|
|
|
|
case mapped_type:
|
|
iff = ad -> u.mtd -> iff;
|
|
break;
|
|
|
|
case enum_type:
|
|
if (ad -> u.ed -> fqcname != NULL && ad -> u.ed -> ecd != NULL)
|
|
{
|
|
iff = ad -> u.ed -> ecd -> iff;
|
|
break;
|
|
}
|
|
|
|
/* Drop through. */
|
|
|
|
default:
|
|
iff = NULL;
|
|
}
|
|
|
|
return iff;
|
|
}
|
|
|
|
|
|
/*
|
|
* Position a class so that it is after all its super-classes.
|
|
*/
|
|
static void positionClass(classDef *cd)
|
|
{
|
|
classList *cl;
|
|
|
|
/* See if it has already been done. */
|
|
if (cd -> node -> ordered)
|
|
return;
|
|
|
|
for (cl = cd -> supers; cl != NULL; cl = cl -> next)
|
|
{
|
|
nodeDef **ndp, *nd1, *nd2, *rp;
|
|
|
|
/* Ignore super-classes from different modules. */
|
|
if (cl -> cd -> iff -> module != cd -> iff -> module)
|
|
continue;
|
|
|
|
/* Make sure the super-class is positioned. */
|
|
positionClass(cl -> cd);
|
|
|
|
/*
|
|
* Find ancestors of the two that are siblings (ie. they have a
|
|
* common parent).
|
|
*/
|
|
rp = &cd -> iff -> module -> root;
|
|
|
|
for (nd1 = cd -> node; nd1 != rp; nd1 = nd1 -> parent)
|
|
{
|
|
for (nd2 = cl -> cd -> node; nd2 != rp; nd2 = nd2 -> parent)
|
|
if (nd1 -> parent == nd2 -> parent)
|
|
break;
|
|
|
|
if (nd2 != rp)
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* The first node must appear after the second in the common
|
|
* parent's list of children.
|
|
*/
|
|
for (ndp = &nd1 -> parent -> child; *ndp != NULL; ndp = &(*ndp) -> next)
|
|
{
|
|
nodeDef *nd = *ndp;
|
|
|
|
if (nd == nd2)
|
|
break;
|
|
|
|
if (nd == nd1)
|
|
{
|
|
/* Remove this one from the list. */
|
|
*ndp = nd -> next;
|
|
|
|
/* Find the super-class ancestor. */
|
|
while (*ndp != nd2)
|
|
ndp = &(*ndp) -> next;
|
|
|
|
/*
|
|
* Put this one back after the super-class
|
|
* ancestor.
|
|
*/
|
|
nd -> next = (*ndp) -> next;
|
|
(*ndp) -> next = nd;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
cd -> node -> ordered = TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* Make sure a class is in the namespace tree.
|
|
*/
|
|
static void addNodeToParent(nodeDef *root,classDef *cd)
|
|
{
|
|
nodeDef *nd, *parent;
|
|
|
|
/* Skip classes already in the tree. */
|
|
if (cd -> node != NULL)
|
|
return;
|
|
|
|
/* Add this child to the parent. */
|
|
nd = sipMalloc(sizeof (nodeDef));
|
|
|
|
nd -> ordered = FALSE;
|
|
nd -> cd = cd;
|
|
nd -> child = NULL;
|
|
|
|
/* Get the address of the parent node. */
|
|
if (cd -> ecd == NULL)
|
|
parent = root;
|
|
else
|
|
{
|
|
/* Make sure the parent is in the tree. */
|
|
addNodeToParent(root,cd -> ecd);
|
|
|
|
parent = cd -> ecd -> node;
|
|
}
|
|
|
|
nd -> parent = parent;
|
|
|
|
/* Insert this at the head of the parent's children. */
|
|
nd -> next = parent -> child;
|
|
parent -> child = nd;
|
|
|
|
/* Remember where we are in the tree. */
|
|
cd -> node = nd;
|
|
}
|
|
|
|
|
|
/*
|
|
* Assign the module specific class number for a class and all it's children.
|
|
*/
|
|
static void assignClassNrs(sipSpec *pt,moduleDef *mod,nodeDef *nd)
|
|
{
|
|
classDef *cd;
|
|
nodeDef *cnd;
|
|
|
|
/* Assign the class if it's not the root. */
|
|
if ((cd = nd -> cd) != NULL)
|
|
{
|
|
cd -> classnr = mod -> nrclasses++;
|
|
|
|
/*
|
|
* If we find a class defined in the main module called QObject, assume
|
|
* it's Qt.
|
|
*/
|
|
if (mod == pt -> module && strcmp(classBaseName(cd),"QObject") == 0)
|
|
pt -> qobjclass = cd -> classnr;
|
|
}
|
|
|
|
/* Assign all it's children. */
|
|
for (cnd = nd -> child; cnd != NULL; cnd = cnd -> next)
|
|
assignClassNrs(pt,mod,cnd);
|
|
}
|
|
|
|
|
|
/*
|
|
* Assign the module specific enum number for all named enums.
|
|
*/
|
|
static void assignEnumNrs(sipSpec *pt)
|
|
{
|
|
enumDef *ed;
|
|
|
|
for (ed = pt -> enums; ed != NULL; ed = ed -> next)
|
|
if (ed -> fqcname != NULL)
|
|
ed -> enumnr = ed -> module -> nrenums++;
|
|
}
|