/** * Collects all unit test functions from the given array of symbols. * * This is a helper function used by the implementation of __traits(getUnitTests). * * Input: * symbols array of symbols to collect the functions from * uniqueUnitTests an associative array (should actually be a set) to * keep track of already collected functions. We're * using an AA here to avoid doing a linear search of unitTests * * Output: * unitTests array of DsymbolExp's of the collected unit test functions * uniqueUnitTests updated with symbols from unitTests[ ] */ static void collectUnitTests(Dsymbols *symbols, AA *uniqueUnitTests, Expressions *unitTests) { if (!symbols) return; for (size_t i = 0; i < symbols->dim; i++) { Dsymbol *symbol = (*symbols)[i]; UnitTestDeclaration *unitTest = symbol->isUnitTestDeclaration(); if (unitTest) { if (!_aaGetRvalue(uniqueUnitTests, unitTest)) { FuncAliasDeclaration* alias = new FuncAliasDeclaration(unitTest, 0); alias->protection = unitTest->protection; Expression* e = new DsymbolExp(Loc(), alias); unitTests->push(e); bool* value = (bool*) _aaGet(&uniqueUnitTests, unitTest); *value = true; } } else { AttribDeclaration *attrDecl = symbol->isAttribDeclaration(); if (attrDecl) { Dsymbols *decl = attrDecl->include(NULL, NULL); collectUnitTests(decl, uniqueUnitTests, unitTests); } } } }
void ConditionalDeclaration::parsepragmas(Module *m) { // we only know how to disclude the right version bool doinclude = true; if (dynamic_cast<VersionCondition*>(condition)) { VersionCondition *vc = (VersionCondition *) condition; if (!(vc->include(NULL, NULL))) { doinclude = false; } } else if (dynamic_cast<DebugCondition*>(condition)) { DebugCondition *dc = (DebugCondition *) condition; if (!(dc->include(NULL, NULL))) { doinclude = false; } } if (doinclude) { AttribDeclaration::parsepragmas(m); } else if (elsedecl) { for (int i = 0; i < elsedecl->dim; i++) { Dsymbol *ds = (Dsymbol *) elsedecl->data[i]; if (ds->isAttribDeclaration()) { AttribDeclaration *ad = (AttribDeclaration *) ds; ad->parsepragmas(m); } else if (ds->isImport()) { Import *im = (Import *) ds; im->load(m, NULL); im->mod->parsepragmas(); } else if (dynamic_cast<VersionSymbol*>(ds)) { VersionSymbol *vs = (VersionSymbol *) ds; vs->addMember(NULL, m, 0); } } } }
static unsigned setMangleOverride(Dsymbol *s, char *sym) { AttribDeclaration *ad = s->isAttribDeclaration(); if (ad) { Dsymbols *decls = ad->include(NULL, NULL); unsigned nestedCount = 0; if (decls && decls->dim) for (size_t i = 0; i < decls->dim; ++i) nestedCount += setMangleOverride((*decls)[i], sym); return nestedCount; } else if (s->isFuncDeclaration() || s->isVarDeclaration()) { s->isDeclaration()->mangleOverride = sym; return 1; } else return 0; }
void AttribDeclaration::parsepragmas(Module *m) { if (decl) { for (int i = 0; i < decl->dim; i++) { Dsymbol *ds = (Dsymbol *) decl->data[i]; if (ds->isAttribDeclaration()) { AttribDeclaration *ad = (AttribDeclaration *) ds; ad->parsepragmas(m); } else if (ds->isImport()) { Import *im = (Import *) ds; im->load(m, NULL); im->mod->parsepragmas(); } else if (dynamic_cast<VersionSymbol*>(ds)) { VersionSymbol *vs = (VersionSymbol *) ds; vs->addMember(NULL, m, 0); } } } }
int Dsymbol_canThrow(Dsymbol *s, bool mustNotThrow) { AttribDeclaration *ad; VarDeclaration *vd; TemplateMixin *tm; TupleDeclaration *td; //printf("Dsymbol_toElem() %s\n", s->toChars()); ad = s->isAttribDeclaration(); if (ad) { Dsymbols *decl = ad->include(NULL, NULL); if (decl && decl->dim) { for (size_t i = 0; i < decl->dim; i++) { s = (*decl)[i]; if (Dsymbol_canThrow(s, mustNotThrow)) return 1; } } } else if ((vd = s->isVarDeclaration()) != NULL) { s = s->toAlias(); if (s != vd) return Dsymbol_canThrow(s, mustNotThrow); if (vd->storage_class & STCmanifest) ; else if (vd->isStatic() || vd->storage_class & (STCextern | STCtls | STCgshared)) ; else { if (vd->init) { ExpInitializer *ie = vd->init->isExpInitializer(); if (ie && ie->exp->canThrow(mustNotThrow)) return 1; } if (vd->edtor && !vd->noscope) return vd->edtor->canThrow(mustNotThrow); } } else if ((tm = s->isTemplateMixin()) != NULL) { //printf("%s\n", tm->toChars()); if (tm->members) { for (size_t i = 0; i < tm->members->dim; i++) { Dsymbol *sm = (*tm->members)[i]; if (Dsymbol_canThrow(sm, mustNotThrow)) return 1; } } } else if ((td = s->isTupleDeclaration()) != NULL) { for (size_t i = 0; i < td->objects->dim; i++) { RootObject *o = (*td->objects)[i]; if (o->dyncast() == DYNCAST_EXPRESSION) { Expression *eo = (Expression *)o; if (eo->op == TOKdsymbol) { DsymbolExp *se = (DsymbolExp *)eo; if (Dsymbol_canThrow(se->s, mustNotThrow)) return 1; } } } } return 0; }