dmd2/import.c

   1
   2 // Compiler implementation of the D programming language
   3 // Copyright (c) 1999-2006 by Digital Mars
   4 // All Rights Reserved
   5 // written by Walter Bright
   6 // http://www.digitalmars.com
   7 // License for redistribution is by either the Artistic License
   8 // in artistic.txt, or the GNU General Public License in gnu.txt.
   9 // See the included readme.txt for details.
  10
  11 #include <stdio.h>
  12 #include <assert.h>
  13
  14 #include "root.h"
  15 #include "dsymbol.h"
  16 #include "import.h"
  17 #include "identifier.h"
  18 #include "module.h"
  19 #include "scope.h"
  20 #include "hdrgen.h"
  21 #include "mtype.h"
  22 #include "declaration.h"
  23 #include "id.h"
  24
  25 /********************************* Import ****************************/
  26
  27 Import::Import(Loc loc, Array *packages, Identifier *id, Identifier *aliasId,
  28         int isstatic)
  29     : Dsymbol(id)
  30 {
  31     this->loc = loc;
  32     this->packages = packages;
  33     this->id = id;
  34     this->aliasId = aliasId;
  35     this->isstatic = isstatic;
  36     pkg = NULL;
  37     mod = NULL;
  38
  39     if (aliasId)
  40         this->ident = aliasId;
  41     // Kludge to change Import identifier to first package
  42     else if (packages && packages->dim)
  43         this->ident = (Identifier *)packages->data[0];
  44 }
  45
  46 void Import::addAlias(Identifier *name, Identifier *alias)
  47 {
  48     if (isstatic)
  49         error("cannot have an import bind list");
  50
  51     if (!aliasId)
  52         this->ident = NULL;     // make it an anonymous import
  53
  54     names.push(name);
  55     aliases.push(alias);
  56 }
  57
  58 char *Import::kind()
  59 {
  60     return isstatic ? (char *)"static import" : (char *)"import";
  61 }
  62
  63 enum PROT Import::prot()
  64 {
  65     return protection;
  66 }
  67
  68 Dsymbol *Import::syntaxCopy(Dsymbol *s)
  69 {
  70     assert(!s);
  71
  72     Import *si;
  73
  74     si = new Import(loc, packages, id, aliasId, isstatic);
  75
  76     for (size_t i = 0; i < names.dim; i++)
  77     {
  78         si->addAlias((Identifier *)names.data[i], (Identifier *)aliases.data[i]);
  79     }
  80
  81     return si;
  82 }
  83
  84 void Import::load(Scope *sc)
  85 {
  86     DsymbolTable *dst;
  87     Dsymbol *s;
  88
  89     //printf("Import::load('%s')\n", toChars());
  90
  91     // See if existing module
  92     dst = Package::resolve(packages, NULL, &pkg);
  93
  94     s = dst->lookup(id);
  95     if (s)
  96     {
  97         if (s->isModule())
  98             mod = (Module *)s;
  99         else
 100             error("package and module have the same name");
 101     }
 102
 103     if (!mod)
 104     {
 105         // Load module
 106         mod = Module::load(loc, packages, id);
 107         dst->insert(id, mod);           // id may be different from mod->ident,
 108                                         // if so then insert alias
 109         if (!mod->importedFrom)
 110             mod->importedFrom = sc ? sc->module->importedFrom : Module::rootModule;
 111     }
 112     if (!pkg)
 113         pkg = mod;
 114     mod->semantic();
 115
 116     //printf("-Import::load('%s'), pkg = %p\n", toChars(), pkg);
 117 }
 118
 119
 120 void Import::semantic(Scope *sc)
 121 {
 122     //printf("Import::semantic('%s')\n", toChars());
 123
 124     load(sc);
 125
 126     /* Default to private importing
 127      */
 128     protection = sc->protection;
 129     if (!sc->explicitProtection)
 130         protection = PROTprivate;
 131
 132     if (mod)
 133     {
 134 #if 0
 135         if (mod->loc.linnum != 0)
 136         {   /* If the line number is not 0, then this is not
 137              * a 'root' module, i.e. it was not specified on the command line.
 138              */
 139             mod->importedFrom = sc->module->importedFrom;
 140             assert(mod->importedFrom);
 141         }
 142 #endif
 143
 144         if (!isstatic && !aliasId && !names.dim)
 145         {
 146             sc->scopesym->importScope(mod, protection);
 147         }
 148
 149         // Modules need a list of each imported module
 150         sc->module->aimports.push(mod);
 151
 152         if (mod->needmoduleinfo)
 153             sc->module->needmoduleinfo = 1;
 154
 155         sc = sc->push(mod);
 156         for (size_t i = 0; i < aliasdecls.dim; i++)
 157         {   AliasDeclaration *ad = (AliasDeclaration *)aliasdecls.data[i];
 158
 159             //printf("\tImport alias semantic('%s')\n", s->toChars());
 160             if (!mod->search(loc, (Identifier *)names.data[i], 0))
 161                 error("%s not found", ((Identifier *)names.data[i])->toChars());
 162
 163             ad->semantic(sc);
 164             ad->protection = protection;
 165         }
 166         sc = sc->pop();
 167     }
 168     //printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg);
 169 }
 170
 171 void Import::semantic2(Scope *sc)
 172 {
 173     //printf("Import::semantic2('%s')\n", toChars());
 174     mod->semantic2();
 175     if (mod->needmoduleinfo)
 176         sc->module->needmoduleinfo = 1;
 177 }
 178
 179 Dsymbol *Import::toAlias()
 180 {
 181     if (aliasId)
 182         return mod;
 183     return this;
 184 }
 185
 186 int Import::addMember(Scope *sc, ScopeDsymbol *sd, int memnum)
 187 {
 188     int result = 0;
 189
 190     if (names.dim == 0)
 191         return Dsymbol::addMember(sc, sd, memnum);
 192
 193     if (aliasId)
 194         result = Dsymbol::addMember(sc, sd, memnum);
 195
 196     for (size_t i = 0; i < names.dim; i++)
 197     {
 198         Identifier *name = (Identifier *)names.data[i];
 199         Identifier *alias = (Identifier *)aliases.data[i];
 200
 201         if (!alias)
 202             alias = name;
 203
 204 #if 1
 205         TypeIdentifier *tname = new TypeIdentifier(loc, name);
 206 #else
 207         TypeIdentifier *tname = new TypeIdentifier(loc, NULL);
 208         if (packages)
 209         {
 210             for (size_t j = 0; j < packages->dim; j++)
 211             {   Identifier *pid = (Identifier *)packages->data[j];
 212
 213                 if (!tname->ident)
 214                     tname->ident = pid;
 215                 else
 216                     tname->addIdent(pid);
 217             }
 218         }
 219         if (!tname->ident)
 220             tname->ident = id;
 221         else
 222             tname->addIdent(id);
 223         tname->addIdent(name);
 224 #endif
 225         AliasDeclaration *ad = new AliasDeclaration(loc, alias, tname);
 226         result |= ad->addMember(sc, sd, memnum);
 227
 228         aliasdecls.push(ad);
 229     }
 230
 231     return result;
 232 }
 233
 234 Dsymbol *Import::search(Loc loc, Identifier *ident, int flags)
 235 {
 236     //printf("%s.Import::search(ident = '%s', flags = x%x)\n", toChars(), ident->toChars(), flags);
 237
 238     if (!pkg)
 239         load(NULL);
 240
 241     // Forward it to the package/module
 242     return pkg->search(loc, ident, flags);
 243 }
 244
 245 int Import::overloadInsert(Dsymbol *s)
 246 {
 247     // Allow multiple imports of the same name
 248     return s->isImport() != NULL;
 249 }
 250
 251 void Import::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 252 {
 253     if (hgs->hdrgen && id == Id::object)
 254         return;         // object is imported by default
 255
 256     if (isstatic)
 257         buf->writestring("static ");
 258     buf->writestring("import ");
 259     if (aliasId)
 260     {
 261         buf->printf("%s = ", aliasId->toChars());
 262     }
 263     if (packages && packages->dim)
 264     {
 265         for (size_t i = 0; i < packages->dim; i++)
 266         {   Identifier *pid = (Identifier *)packages->data[i];
 267
 268             buf->printf("%s.", pid->toChars());
 269         }
 270     }
 271     buf->printf("%s;", id->toChars());
 272     buf->writenl();
 273 }
 274