void mangleParent(OutBuffer *buf, Dsymbol *s)
{
Dsymbol *p;
if (TemplateInstance *ti = s->isTemplateInstance())
p = ti->isTemplateMixin() ? ti->parent : ti->tempdecl->parent;
else
p = s->parent;
if (p)
{
mangleParent(buf, p);
if (p->getIdent())
{
const char *id = p->ident->toChars();
buf->printf("%llu%s", (ulonglong)strlen(id), id);
if (FuncDeclaration *f = p->isFuncDeclaration())
mangleFunc(buf, f, true);
}
else
buf->writeByte('0');
}
}
void mangleParent(Dsymbol *s)
{
Dsymbol *p;
if (TemplateInstance *ti = s->isTemplateInstance())
p = ti->isTemplateMixin() ? ti->parent : ti->tempdecl->parent;
else
p = s->parent;
if (p)
{
mangleParent(p);
if (p->getIdent())
{
const char *id = p->ident->toChars();
toBuffer(id, s);
if (FuncDeclaration *f = p->isFuncDeclaration())
mangleFunc(f, true);
}
else
buf->writeByte('0');
}
}
/******************************************************************************
* isv : for the enclosing auto functions of an inner class/struct type.
* An aggregate type which defined inside auto function, it might
* become Voldemort Type so its object might be returned.
* This flag is necessary due to avoid mutual mangling
* between return type and enclosing scope. See bugzilla 8847.
*/
char *mangleDecl(Declaration *sthis, bool isv)
{
OutBuffer buf;
char *id;
Dsymbol *s;
//printf("::mangleDecl(%s)\n", sthis->toChars());
s = sthis;
do
{
//printf("mangle: s = %p, '%s', parent = %p\n", s, s->toChars(), s->parent);
if (s->getIdent())
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (s != sthis && fd)
{
id = mangleDecl(fd, isv);
buf.prependstring(id);
goto L1;
}
else
{
id = s->ident->toChars();
size_t len = strlen(id);
char tmp[sizeof(len) * 3 + 1];
buf.prependstring(id);
sprintf(tmp, "%d", (int)len);
buf.prependstring(tmp);
}
}
else
buf.prependstring("0");
TemplateInstance *ti = s->isTemplateInstance();
if (ti && !ti->isTemplateMixin())
s = ti->tempdecl->parent;
else
s = s->parent;
} while (s);
// buf.prependstring("_D");
L1:
//printf("deco = '%s'\n", sthis->type->deco ? sthis->type->deco : "null");
//printf("sthis->type = %s\n", sthis->type->toChars());
FuncDeclaration *fd = sthis->isFuncDeclaration();
if (fd && (fd->needThis() || fd->isNested()))
buf.writeByte(Type::needThisPrefix());
if (isv && fd && (fd->inferRetType || getFuncTemplateDecl(fd)))
{
#if DDMD
TypeFunction *tfn = (TypeFunction *)sthis->type->copy();
TypeFunction *tfo = (TypeFunction *)sthis->originalType;
tfn->purity = tfo->purity;
tfn->isnothrow = tfo->isnothrow;
tfn->isproperty = tfo->isproperty;
tfn->isref = fd->storage_class & STCauto ? false : tfo->isref;
tfn->trust = tfo->trust;
tfn->next = NULL; // do not mangle return type
tfn->toDecoBuffer(&buf, 0);
#else
TypeFunction tfn = *(TypeFunction *)sthis->type;
TypeFunction *tfo = (TypeFunction *)sthis->originalType;
tfn.purity = tfo->purity;
tfn.isnothrow = tfo->isnothrow;
tfn.isproperty = tfo->isproperty;
tfn.isref = fd->storage_class & STCauto ? false : tfo->isref;
tfn.trust = tfo->trust;
tfn.next = NULL; // do not mangle return type
tfn.toDecoBuffer(&buf, 0);
#endif
}
else if (sthis->type->deco)
buf.writestring(sthis->type->deco);
else
{
#ifdef DEBUG
if (!fd->inferRetType)
printf("%s\n", fd->toChars());
#endif
assert(fd && fd->inferRetType && fd->type->ty == Tfunction);
TypeFunction *tf = (TypeFunction *)sthis->type;
Type *tn = tf->next;
tf->next = NULL; // do not mangle undetermined return type
tf->toDecoBuffer(&buf, 0);
tf->next = tn;
}
id = buf.extractString();
return id;
}