Mercurial > projects > ldc
view dmd/import.c @ 1508:e1e93343fc11
Move function codegen data from IrFunction to new FuncGen.
This change reduces memory consumption significantly by releasing the
memory held by the STL containers that are now inside FuncGen.
author | Christian Kamm <kamm incasoftware de> |
---|---|
date | Sat, 20 Jun 2009 19:11:44 +0200 |
parents | 1311dabc6a1f |
children | def7a1d494fd |
line wrap: on
line source
// Compiler implementation of the D programming language // Copyright (c) 1999-2006 by Digital Mars // All Rights Reserved // written by Walter Bright // http://www.digitalmars.com // License for redistribution is by either the Artistic License // in artistic.txt, or the GNU General Public License in gnu.txt. // See the included readme.txt for details. #include <stdio.h> #include <assert.h> #include "root.h" #include "dsymbol.h" #include "import.h" #include "identifier.h" #include "module.h" #include "scope.h" #include "hdrgen.h" #include "mtype.h" #include "declaration.h" #include "id.h" /********************************* Import ****************************/ Import::Import(Loc loc, Array *packages, Identifier *id, Identifier *aliasId, int isstatic) : Dsymbol(id) { this->loc = loc; this->packages = packages; this->id = id; this->aliasId = aliasId; this->isstatic = isstatic; protection = PROTundefined; pkg = NULL; mod = NULL; if (aliasId) this->ident = aliasId; // Kludge to change Import identifier to first package else if (packages && packages->dim) this->ident = (Identifier *)packages->data[0]; } void Import::addAlias(Identifier *name, Identifier *alias) { if (isstatic) error("cannot have an import bind list"); if (!aliasId) this->ident = NULL; // make it an anonymous import names.push(name); aliases.push(alias); } const char *Import::kind() { return isstatic ? (char *)"static import" : (char *)"import"; } enum PROT Import::prot() { return protection; } Dsymbol *Import::syntaxCopy(Dsymbol *s) { assert(!s); Import *si; si = new Import(loc, packages, id, aliasId, isstatic); for (size_t i = 0; i < names.dim; i++) { si->addAlias((Identifier *)names.data[i], (Identifier *)aliases.data[i]); } return si; } void Import::load(Scope *sc) { DsymbolTable *dst; Dsymbol *s; //printf("Import::load('%s')\n", toChars()); // See if existing module dst = Package::resolve(packages, NULL, &pkg); s = dst->lookup(id); if (s) { if (s->isModule()) mod = (Module *)s; else error("package and module have the same name"); } if (!mod) { // Load module mod = Module::load(loc, packages, id); dst->insert(id, mod); // id may be different from mod->ident, // if so then insert alias if (!mod->importedFrom) mod->importedFrom = sc ? sc->module->importedFrom : Module::rootModule; } if (!pkg) pkg = mod; //printf("-Import::load('%s'), pkg = %p\n", toChars(), pkg); } char* escapePath(char* fname, char* buffer, int bufLen) { char* res = buffer; bufLen -= 2; // for \0 and an occasional escape char int dst = 0; for (; dst < bufLen && *fname; ++dst, ++fname) { switch (*fname) { case '(': case ')': case '\\': buffer[dst++] = '\\'; // fall through default: buffer[dst] = *fname; } } buffer[dst] = '\0'; return buffer; } void Import::semantic(Scope *sc) { //printf("Import::semantic('%s')\n", toChars()); load(sc); if (mod) { #if 0 if (mod->loc.linnum != 0) { /* If the line number is not 0, then this is not * a 'root' module, i.e. it was not specified on the command line. */ mod->importedFrom = sc->module->importedFrom; assert(mod->importedFrom); } #endif // Modules need a list of each imported module //printf("%s imports %s\n", sc->module->toChars(), mod->toChars()); sc->module->aimports.push(mod); mod->semantic(); /* Default to private importing */ protection = sc->protection; if (!sc->explicitProtection) protection = PROTprivate; if (!isstatic && !aliasId && !names.dim) { sc->scopesym->importScope(mod, protection); } if (mod->needmoduleinfo) sc->module->needmoduleinfo = 1; sc = sc->push(mod); for (size_t i = 0; i < aliasdecls.dim; i++) { AliasDeclaration *ad = (AliasDeclaration *)aliasdecls.data[i]; //printf("\tImport alias semantic('%s')\n", s->toChars()); if (!mod->search(loc, (Identifier *)names.data[i], 0)) error("%s not found", ((Identifier *)names.data[i])->toChars()); ad->importprot = protection; ad->semantic(sc); } sc = sc->pop(); } //printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg); if (global.params.moduleDeps != NULL) { char fnameBuf[262]; // MAX_PATH+2 OutBuffer *const ob = global.params.moduleDeps; ob->printf("%s (%s) : ", sc->module->toPrettyChars(), escapePath(sc->module->srcfile->toChars(), fnameBuf, sizeof(fnameBuf) / sizeof(*fnameBuf)) ); char* protStr = ""; switch (sc->protection) { case PROTpublic: protStr = "public"; break; case PROTprivate: protStr = "private"; break; case PROTpackage: protStr = "package"; break; default: break; } ob->writestring(protStr); if (isstatic) { ob->writestring(" static"); } ob->writestring(" : "); if (this->packages) { for (size_t i = 0; i < this->packages->dim; i++) { Identifier *pid = (Identifier *)this->packages->data[i]; ob->printf("%s.", pid->toChars()); } } ob->printf("%s (%s)", this->id->toChars(), mod ? escapePath(mod->srcfile->toChars(), fnameBuf, sizeof(fnameBuf) / sizeof(*fnameBuf)) : "???" ); if (aliasId) { ob->printf(" -> %s", aliasId->toChars()); } else { if (names.dim > 0) { ob->writestring(" : "); for (size_t i = 0; i < names.dim; i++) { if (i > 0) { ob->writebyte(','); } Identifier *name = (Identifier *)names.data[i]; Identifier *alias = (Identifier *)aliases.data[i]; if (!alias) { ob->printf("%s", name->toChars()); alias = name; } else { ob->printf("%s=%s", alias->toChars(), name->toChars()); } } } } ob->writenl(); } } void Import::semantic2(Scope *sc) { //printf("Import::semantic2('%s')\n", toChars()); mod->semantic2(); if (mod->needmoduleinfo) sc->module->needmoduleinfo = 1; } Dsymbol *Import::toAlias() { if (aliasId) return mod; return this; } /***************************** * Add import to sd's symbol table. */ int Import::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) { int result = 0; if (names.dim == 0) return Dsymbol::addMember(sc, sd, memnum); if (aliasId) result = Dsymbol::addMember(sc, sd, memnum); /* Instead of adding the import to sd's symbol table, * add each of the alias=name pairs */ for (size_t i = 0; i < names.dim; i++) { Identifier *name = (Identifier *)names.data[i]; Identifier *alias = (Identifier *)aliases.data[i]; if (!alias) alias = name; TypeIdentifier *tname = new TypeIdentifier(loc, name); AliasDeclaration *ad = new AliasDeclaration(loc, alias, tname); result |= ad->addMember(sc, sd, memnum); aliasdecls.push(ad); } return result; } Dsymbol *Import::search(Loc loc, Identifier *ident, int flags) { //printf("%s.Import::search(ident = '%s', flags = x%x)\n", toChars(), ident->toChars(), flags); if (!pkg) { load(NULL); mod->semantic(); } // Forward it to the package/module return pkg->search(loc, ident, flags); } int Import::overloadInsert(Dsymbol *s) { // Allow multiple imports of the same name return s->isImport() != NULL; } void Import::toCBuffer(OutBuffer *buf, HdrGenState *hgs) { if (hgs->hdrgen && id == Id::object) return; // object is imported by default if (isstatic) buf->writestring("static "); buf->writestring("import "); if (aliasId) { buf->printf("%s = ", aliasId->toChars()); } if (packages && packages->dim) { for (size_t i = 0; i < packages->dim; i++) { Identifier *pid = (Identifier *)packages->data[i]; buf->printf("%s.", pid->toChars()); } } buf->printf("%s", id->toChars()); if (names.dim > 0) { buf->writebyte(':'); for (size_t i = 0; i < names.dim; i++) { if (i > 0) { buf->writebyte(','); } Identifier *name = (Identifier *)names.data[i]; Identifier *alias = (Identifier *)aliases.data[i]; if (!alias) { buf->printf("%s", name->toChars()); alias = name; } else { buf->printf("%s=%s", alias->toChars(), name->toChars()); } } } buf->writebyte(';'); buf->writenl(); }