|
0
|
1 module dmd.Import;
|
|
|
2
|
|
|
3 import dmd.Dsymbol;
|
|
|
4 import dmd.Array;
|
|
|
5 import dmd.DsymbolTable;
|
|
|
6 import dmd.PROT;
|
|
|
7 import dmd.Identifier;
|
|
|
8 import dmd.Module;
|
|
|
9 import dmd.Package;
|
|
|
10 import dmd.Loc;
|
|
|
11 import dmd.OutBuffer;
|
|
|
12 import dmd.HdrGenState;
|
|
|
13 import dmd.Scope;
|
|
|
14 import dmd.TypeIdentifier;
|
|
|
15 import dmd.AliasDeclaration;
|
|
|
16 import dmd.ScopeDsymbol;
|
|
|
17 import dmd.StorageClassDeclaration;
|
|
|
18 import dmd.STC;
|
|
|
19 import dmd.ProtDeclaration;
|
|
|
20 import dmd.Global;
|
|
|
21
|
|
|
22 import std.stdio;
|
|
|
23
|
|
|
24 void escapePath(OutBuffer buf, string fname)
|
|
|
25 {
|
|
79
|
26 foreach (char c; fname)
|
|
|
27 {
|
|
0
|
28 switch (c)
|
|
|
29 {
|
|
|
30 case '(':
|
|
|
31 case ')':
|
|
|
32 case '\\':
|
|
|
33 buf.writebyte('\\');
|
|
|
34 default:
|
|
|
35 buf.writebyte(*fname);
|
|
|
36 break;
|
|
|
37 }
|
|
79
|
38 }
|
|
0
|
39 }
|
|
|
40
|
|
|
41 class Import : Dsymbol
|
|
|
42 {
|
|
79
|
43 Array packages; // array of Identifier's representing packages
|
|
|
44 Identifier id; // module Identifier
|
|
|
45 Identifier aliasId;
|
|
|
46 int isstatic; // !=0 if static import
|
|
0
|
47
|
|
79
|
48 // Pairs of alias=name to bind into current namespace
|
|
|
49 Array names;
|
|
|
50 Array aliases;
|
|
0
|
51
|
|
79
|
52 Array aliasdecls; // AliasDeclarations for names/aliases
|
|
0
|
53
|
|
79
|
54 Module mod;
|
|
|
55 Package pkg; // leftmost package/module
|
|
0
|
56
|
|
79
|
57 this(Loc loc, Array packages, Identifier id, Identifier aliasId, int isstatic)
|
|
0
|
58 {
|
|
|
59 super(id);
|
|
|
60
|
|
|
61 names = new Array();
|
|
|
62 aliases = new Array();
|
|
|
63 aliasdecls = new Array();
|
|
|
64
|
|
|
65 assert(id);
|
|
|
66 this.loc = loc;
|
|
|
67 this.packages = packages;
|
|
|
68 this.id = id;
|
|
|
69 this.aliasId = aliasId;
|
|
|
70 this.isstatic = isstatic;
|
|
|
71
|
|
|
72 if (aliasId)
|
|
|
73 this.ident = aliasId;
|
|
|
74 // Kludge to change Import identifier to first package
|
|
|
75 else if (packages && packages.dim)
|
|
|
76 this.ident = cast(Identifier)packages.data[0];
|
|
|
77 }
|
|
79
|
78
|
|
0
|
79 void addAlias(Identifier name, Identifier alias_)
|
|
|
80 {
|
|
|
81 if (isstatic)
|
|
|
82 error("cannot have an import bind list");
|
|
|
83
|
|
|
84 if (!aliasId)
|
|
|
85 this.ident = null; // make it an anonymous import
|
|
|
86
|
|
|
87 names.push(cast(void*)name);
|
|
|
88 aliases.push(cast(void*)alias_);
|
|
|
89 }
|
|
|
90
|
|
79
|
91 override string kind()
|
|
0
|
92 {
|
|
|
93 return isstatic ? "static import" : "import";
|
|
|
94 }
|
|
|
95
|
|
79
|
96 override Dsymbol syntaxCopy(Dsymbol s) // copy only syntax trees
|
|
0
|
97 {
|
|
|
98 assert(false);
|
|
|
99 }
|
|
|
100
|
|
79
|
101 void load(Scope sc)
|
|
0
|
102 {
|
|
|
103 //writef("Import::load('%s')\n", toChars());
|
|
|
104
|
|
|
105 // See if existing module
|
|
79
|
106 DsymbolTable dst = Package.resolve(packages, null, &pkg);
|
|
0
|
107
|
|
79
|
108 Dsymbol s = dst.lookup(id);
|
|
0
|
109 if (s)
|
|
|
110 {
|
|
79
|
111 version (TARGET_NET)
|
|
|
112 {
|
|
0
|
113 mod = cast(Module)s;
|
|
79
|
114 }
|
|
|
115 else
|
|
|
116 {
|
|
0
|
117 if (s.isModule())
|
|
|
118 mod = cast(Module)s;
|
|
|
119 else
|
|
|
120 error("package and module have the same name");
|
|
|
121 }
|
|
|
122 }
|
|
|
123
|
|
|
124 if (!mod)
|
|
|
125 {
|
|
|
126 // Load module
|
|
|
127 mod = Module.load(loc, packages, id);
|
|
79
|
128 dst.insert(id, mod); // id may be different from mod.ident,
|
|
0
|
129 // if so then insert alias
|
|
|
130 if (!mod.importedFrom)
|
|
|
131 mod.importedFrom = sc ? sc.module_.importedFrom : Module.rootModule;
|
|
|
132 }
|
|
|
133
|
|
|
134 if (!pkg)
|
|
|
135 pkg = mod;
|
|
|
136
|
|
|
137 //writef("-Import::load('%s'), pkg = %p\n", toChars(), pkg);
|
|
|
138 }
|
|
|
139
|
|
79
|
140 override void importAll(Scope sc)
|
|
|
141 {
|
|
|
142 if (!mod)
|
|
|
143 {
|
|
|
144 load(sc);
|
|
|
145 mod.importAll(null);
|
|
|
146
|
|
|
147 if (!isstatic && !aliasId && !names.dim)
|
|
|
148 {
|
|
|
149 /* Default to private importing
|
|
|
150 */
|
|
|
151 PROT prot = sc.protection;
|
|
|
152 if (!sc.explicitProtection)
|
|
|
153 prot = PROT.PROTprivate;
|
|
|
154 sc.scopesym.importScope(mod, prot);
|
|
|
155 }
|
|
|
156 }
|
|
|
157 }
|
|
|
158
|
|
|
159 override void semantic(Scope sc)
|
|
0
|
160 {
|
|
|
161 //writef("Import.semantic('%s')\n", toChars());
|
|
|
162
|
|
79
|
163 // Load if not already done so
|
|
|
164 if (!mod)
|
|
|
165 {
|
|
|
166 load(sc);
|
|
|
167 mod.importAll(null);
|
|
|
168 }
|
|
0
|
169
|
|
|
170 if (mod)
|
|
|
171 {
|
|
79
|
172 static if (false)
|
|
|
173 {
|
|
0
|
174 if (mod.loc.linnum != 0)
|
|
|
175 { /* If the line number is not 0, then this is not
|
|
|
176 * a 'root' module, i.e. it was not specified on the command line.
|
|
|
177 */
|
|
|
178 mod.importedFrom = sc.module_.importedFrom;
|
|
|
179 assert(mod.importedFrom);
|
|
|
180 }
|
|
|
181 }
|
|
|
182
|
|
|
183 // Modules need a list of each imported module
|
|
|
184 //printf("%s imports %s\n", sc.module.toChars(), mod.toChars());
|
|
|
185 sc.module_.aimports.push(cast(void*)mod);
|
|
|
186
|
|
|
187 if (!isstatic && !aliasId && !names.dim)
|
|
|
188 {
|
|
|
189 /* Default to private importing
|
|
|
190 */
|
|
|
191 PROT prot = sc.protection;
|
|
|
192 if (!sc.explicitProtection)
|
|
|
193 prot = PROT.PROTprivate;
|
|
|
194
|
|
|
195 sc.scopesym.importScope(mod, prot);
|
|
|
196 }
|
|
|
197
|
|
|
198 mod.semantic();
|
|
|
199
|
|
|
200 if (mod.needmoduleinfo)
|
|
|
201 sc.module_.needmoduleinfo = 1;
|
|
|
202
|
|
|
203 sc = sc.push(mod);
|
|
|
204 for (size_t i = 0; i < aliasdecls.dim; i++)
|
|
|
205 {
|
|
|
206 Dsymbol s = cast(Dsymbol)aliasdecls.data[i];
|
|
|
207
|
|
|
208 //writef("\tImport alias semantic('%s')\n", s.toChars());
|
|
|
209 if (!mod.search(loc, cast(Identifier)names.data[i], 0))
|
|
|
210 error("%s not found", (cast(Identifier)names.data[i]).toChars());
|
|
|
211
|
|
|
212 s.semantic(sc);
|
|
|
213 }
|
|
|
214 sc = sc.pop();
|
|
|
215 }
|
|
|
216
|
|
|
217 if (global.params.moduleDeps !is null)
|
|
|
218 {
|
|
|
219 /* The grammar of the file is:
|
|
|
220 * ImportDeclaration
|
|
79
|
221 * .= BasicImportDeclaration [ " : " ImportBindList ] [ " . "
|
|
0
|
222 * ModuleAliasIdentifier ] "\n"
|
|
|
223 *
|
|
|
224 * BasicImportDeclaration
|
|
79
|
225 * .= ModuleFullyQualifiedName " (" FilePath ") : " Protection
|
|
0
|
226 * " [ " static" ] : " ModuleFullyQualifiedName " (" FilePath ")"
|
|
|
227 *
|
|
|
228 * FilePath
|
|
79
|
229 * - any string with '(', ')' and '\' escaped with the '\' character
|
|
0
|
230 */
|
|
|
231
|
|
|
232 OutBuffer ob = global.params.moduleDeps;
|
|
|
233
|
|
|
234 ob.writestring(sc.module_.toPrettyChars());
|
|
|
235 ob.writestring(" (");
|
|
|
236 escapePath(ob, sc.module_.srcfile.toChars());
|
|
|
237 ob.writestring(") : ");
|
|
|
238
|
|
|
239 ProtDeclaration.protectionToCBuffer(ob, sc.protection);
|
|
|
240 if (isstatic)
|
|
|
241 StorageClassDeclaration.stcToCBuffer(ob, STC.STCstatic);
|
|
|
242 ob.writestring(": ");
|
|
|
243
|
|
|
244 if (packages)
|
|
|
245 {
|
|
|
246 for (size_t i = 0; i < packages.dim; i++)
|
|
|
247 {
|
|
|
248 Identifier pid = cast(Identifier)packages.data[i];
|
|
|
249 ob.printf("%s.", pid.toChars());
|
|
|
250 }
|
|
|
251 }
|
|
|
252
|
|
|
253 ob.writestring(id.toChars());
|
|
|
254 ob.writestring(" (");
|
|
|
255 if (mod)
|
|
|
256 escapePath(ob, mod.srcfile.toChars());
|
|
|
257 else
|
|
|
258 ob.writestring("???");
|
|
|
259 ob.writebyte(')');
|
|
|
260
|
|
|
261 for (size_t i = 0; i < names.dim; i++)
|
|
|
262 {
|
|
|
263 if (i == 0)
|
|
|
264 ob.writebyte(':');
|
|
|
265 else
|
|
|
266 ob.writebyte(',');
|
|
|
267
|
|
|
268 Identifier name = cast(Identifier)names.data[i];
|
|
|
269 Identifier alias_ = cast(Identifier)aliases.data[i];
|
|
|
270
|
|
|
271 if (!alias_)
|
|
|
272 {
|
|
|
273 ob.printf("%s", name.toChars());
|
|
|
274 alias_ = name;
|
|
|
275 }
|
|
|
276 else
|
|
|
277 ob.printf("%s=%s", alias_.toChars(), name.toChars());
|
|
|
278 }
|
|
|
279
|
|
|
280 if (aliasId)
|
|
|
281 ob.printf(" . %s", aliasId.toChars());
|
|
|
282
|
|
|
283 ob.writenl();
|
|
|
284 }
|
|
|
285
|
|
|
286 //printf("-Import.semantic('%s'), pkg = %p\n", toChars(), pkg);
|
|
|
287 }
|
|
|
288
|
|
79
|
289 override void semantic2(Scope sc)
|
|
0
|
290 {
|
|
|
291 //printf("Import::semantic2('%s')\n", toChars());
|
|
|
292 mod.semantic2();
|
|
|
293 if (mod.needmoduleinfo)
|
|
|
294 sc.module_.needmoduleinfo = 1;
|
|
|
295 }
|
|
|
296
|
|
79
|
297 override Dsymbol toAlias()
|
|
0
|
298 {
|
|
|
299 if (aliasId)
|
|
|
300 return mod;
|
|
|
301 return this;
|
|
|
302 }
|
|
|
303
|
|
|
304 /*****************************
|
|
|
305 * Add import to sd's symbol table.
|
|
|
306 */
|
|
79
|
307 override bool addMember(Scope sc, ScopeDsymbol sd, bool memnum)
|
|
0
|
308 {
|
|
|
309 bool result = false;
|
|
|
310
|
|
|
311 if (names.dim == 0)
|
|
|
312 return Dsymbol.addMember(sc, sd, memnum);
|
|
|
313
|
|
|
314 if (aliasId)
|
|
|
315 result = Dsymbol.addMember(sc, sd, memnum);
|
|
|
316
|
|
|
317 /* Instead of adding the import to sd's symbol table,
|
|
|
318 * add each of the alias=name pairs
|
|
|
319 */
|
|
|
320 for (size_t i = 0; i < names.dim; i++)
|
|
|
321 {
|
|
|
322 Identifier name = cast(Identifier)names.data[i];
|
|
|
323 Identifier alias_ = cast(Identifier)aliases.data[i];
|
|
|
324
|
|
|
325 if (!alias_)
|
|
|
326 alias_ = name;
|
|
|
327
|
|
|
328 TypeIdentifier tname = new TypeIdentifier(loc, name);
|
|
|
329 AliasDeclaration ad = new AliasDeclaration(loc, alias_, tname);
|
|
|
330 result |= ad.addMember(sc, sd, memnum);
|
|
|
331
|
|
|
332 aliasdecls.push(cast(void*)ad);
|
|
|
333 }
|
|
|
334
|
|
|
335 return result;
|
|
|
336 }
|
|
|
337
|
|
79
|
338 override Dsymbol search(Loc loc, Identifier ident, int flags)
|
|
0
|
339 {
|
|
|
340 //printf("%s.Import.search(ident = '%s', flags = x%x)\n", toChars(), ident.toChars(), flags);
|
|
|
341
|
|
|
342 if (!pkg)
|
|
|
343 {
|
|
|
344 load(null);
|
|
|
345 mod.semantic();
|
|
|
346 }
|
|
|
347
|
|
|
348 // Forward it to the package/module
|
|
|
349 return pkg.search(loc, ident, flags);
|
|
|
350 }
|
|
|
351
|
|
79
|
352 override bool overloadInsert(Dsymbol s)
|
|
0
|
353 {
|
|
|
354 // Allow multiple imports of the same name
|
|
|
355 return s.isImport() !is null;
|
|
|
356 }
|
|
|
357
|
|
79
|
358 override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
|
|
0
|
359 {
|
|
|
360 assert(false);
|
|
|
361 }
|
|
|
362
|
|
79
|
363 override Import isImport() { return this; }
|
|
72
|
364 }
|
