|
0
|
1 module dmd.InterfaceDeclaration;
|
|
|
2
|
|
|
3 import dmd.ClassDeclaration;
|
|
|
4 import dmd.Loc;
|
|
|
5 import dmd.DsymbolTable;
|
|
|
6 import dmd.STC;
|
|
|
7 import dmd.Type;
|
|
|
8 import dmd.TY;
|
|
|
9 import dmd.LINK;
|
|
|
10 import dmd.Argument;
|
|
|
11 import dmd.Util;
|
|
|
12 import dmd.TypeTuple;
|
|
|
13 import dmd.PROT;
|
|
|
14 import dmd.TypeClass;
|
|
|
15 import dmd.Identifier;
|
|
|
16 import dmd.ArrayTypes;
|
|
|
17 import dmd.Dsymbol;
|
|
|
18 import dmd.Scope;
|
|
|
19 import dmd.Global;
|
|
|
20 import dmd.BaseClass;
|
|
|
21 import dmd.Id;
|
|
|
22
|
|
|
23 import dmd.backend.Symbol;
|
|
|
24 import dmd.backend.TYM;
|
|
|
25 import dmd.backend.dt_t;
|
|
|
26 import dmd.backend.Util;
|
|
|
27 import dmd.codegen.Util;
|
|
|
28 import dmd.backend.SC;
|
|
|
29 import dmd.backend.FL;
|
|
|
30 import dmd.backend.LIST;
|
|
|
31 import dmd.backend.SFL;
|
|
|
32
|
|
|
33 class InterfaceDeclaration : ClassDeclaration
|
|
|
34 {
|
|
|
35 version (DMDV2) {
|
|
|
36 bool cpp; // true if this is a C++ interface
|
|
|
37 }
|
|
|
38 this(Loc loc, Identifier id, BaseClasses baseclasses)
|
|
|
39 {
|
|
|
40 super(loc, id, baseclasses);
|
|
|
41
|
|
|
42 if (id is Id.IUnknown) // IUnknown is the root of all COM interfaces
|
|
|
43 {
|
|
|
44 com = true;
|
|
|
45 cpp = true; // IUnknown is also a C++ interface
|
|
|
46 }
|
|
|
47 }
|
|
|
48
|
|
|
49 Dsymbol syntaxCopy(Dsymbol s)
|
|
|
50 {
|
|
|
51 assert(false);
|
|
|
52 }
|
|
|
53
|
|
|
54 void semantic(Scope sc)
|
|
|
55 {
|
|
|
56 int i;
|
|
|
57
|
|
|
58 //printf("InterfaceDeclaration.semantic(%s), type = %p\n", toChars(), type);
|
|
|
59 if (inuse)
|
|
|
60 return;
|
|
|
61
|
|
|
62 if (!sc)
|
|
|
63 sc = scope_;
|
|
|
64 if (!parent && sc.parent && !sc.parent.isModule())
|
|
|
65 parent = sc.parent;
|
|
|
66
|
|
|
67 type = type.semantic(loc, sc);
|
|
|
68 handle = type;
|
|
|
69
|
|
|
70 if (!members) // if forward reference
|
|
|
71 {
|
|
|
72 //printf("\tinterface '%s' is forward referenced\n", toChars());
|
|
|
73 return;
|
|
|
74 }
|
|
|
75 if (symtab) // if already done
|
|
|
76 {
|
|
|
77 if (!scope_)
|
|
|
78 return;
|
|
|
79 }
|
|
|
80 else
|
|
|
81 symtab = new DsymbolTable();
|
|
|
82
|
|
|
83 Scope scx = null;
|
|
|
84 if (scope_)
|
|
|
85 {
|
|
|
86 sc = scope_;
|
|
|
87 scx = scope_; // save so we don't make redundant copies
|
|
|
88 scope_ = null;
|
|
|
89 }
|
|
|
90
|
|
|
91 if (sc.stc & STC.STCdeprecated)
|
|
|
92 {
|
|
|
93 isdeprecated = true;
|
|
|
94 }
|
|
|
95
|
|
|
96 // Expand any tuples in baseclasses[]
|
|
|
97 for (i = 0; i < baseclasses.dim; )
|
|
|
98 {
|
|
|
99 BaseClass b = cast(BaseClass)baseclasses.data[0];
|
|
|
100 b.type = b.type.semantic(loc, sc);
|
|
|
101 Type tb = b.type.toBasetype();
|
|
|
102
|
|
|
103 if (tb.ty == TY.Ttuple)
|
|
|
104 { TypeTuple tup = cast(TypeTuple)tb;
|
|
|
105 PROT protection = b.protection;
|
|
|
106 baseclasses.remove(i);
|
|
|
107 size_t dim = Argument.dim(tup.arguments);
|
|
|
108 for (size_t j = 0; j < dim; j++)
|
|
|
109 { Argument arg = Argument.getNth(tup.arguments, j);
|
|
|
110 b = new BaseClass(arg.type, protection);
|
|
|
111 baseclasses.insert(i + j, cast(void*)b);
|
|
|
112 }
|
|
|
113 }
|
|
|
114 else
|
|
|
115 i++;
|
|
|
116 }
|
|
|
117
|
|
|
118 if (!baseclasses.dim && sc.linkage == LINK.LINKcpp)
|
|
|
119 cpp = 1;
|
|
|
120
|
|
|
121 // Check for errors, handle forward references
|
|
|
122 for (i = 0; i < baseclasses.dim; )
|
|
|
123 {
|
|
|
124 TypeClass tc;
|
|
|
125 BaseClass b;
|
|
|
126 Type tb;
|
|
|
127
|
|
|
128 b = cast(BaseClass)baseclasses.data[i];
|
|
|
129 b.type = b.type.semantic(loc, sc);
|
|
|
130 tb = b.type.toBasetype();
|
|
|
131 if (tb.ty == TY.Tclass)
|
|
|
132 tc = cast(TypeClass)tb;
|
|
|
133 else
|
|
|
134 tc = null;
|
|
|
135 if (!tc || !tc.sym.isInterfaceDeclaration())
|
|
|
136 {
|
|
|
137 error("base type must be interface, not %s", b.type.toChars());
|
|
|
138 baseclasses.remove(i);
|
|
|
139 continue;
|
|
|
140 }
|
|
|
141 else
|
|
|
142 {
|
|
|
143 // Check for duplicate interfaces
|
|
|
144 for (size_t j = 0; j < i; j++)
|
|
|
145 {
|
|
|
146 BaseClass b2 = cast(BaseClass)baseclasses.data[j];
|
|
|
147 if (b2.base is tc.sym)
|
|
|
148 error("inherits from duplicate interface %s", b2.base.toChars());
|
|
|
149 }
|
|
|
150
|
|
|
151 b.base = tc.sym;
|
|
|
152 if (b.base == this || isBaseOf2(b.base))
|
|
|
153 {
|
|
|
154 error("circular inheritance of interface");
|
|
|
155 baseclasses.remove(i);
|
|
|
156 continue;
|
|
|
157 }
|
|
|
158 if (!b.base.symtab)
|
|
|
159 {
|
|
|
160 // Try to resolve forward reference
|
|
|
161 if (sc.mustsemantic && b.base.scope_)
|
|
|
162 b.base.semantic(null);
|
|
|
163 }
|
|
|
164 if (!b.base.symtab || b.base.scope_ || b.base.inuse)
|
|
|
165 {
|
|
|
166 //error("forward reference of base class %s", baseClass.toChars());
|
|
|
167 // Forward reference of base, try again later
|
|
|
168 //printf("\ttry later, forward reference of base %s\n", b.base.toChars());
|
|
|
169 scope_ = scx ? scx : new Scope(sc);
|
|
|
170 scope_.setNoFree();
|
|
|
171 scope_.module_.addDeferredSemantic(this);
|
|
|
172 return;
|
|
|
173 }
|
|
|
174 }
|
|
|
175 static if (false) {
|
|
|
176 // Inherit const/invariant from base class
|
|
|
177 storage_class |= b.base.storage_class & STC.STC_TYPECTOR;
|
|
|
178 }
|
|
|
179 i++;
|
|
|
180 }
|
|
|
181
|
|
|
182 interfaces_dim = baseclasses.dim;
|
|
|
183 interfaces = cast(BaseClass*)baseclasses.data;
|
|
|
184
|
|
|
185 interfaceSemantic(sc);
|
|
|
186
|
|
|
187 if (vtblOffset())
|
|
|
188 vtbl.push(cast(void*)this); // leave room at vtbl[0] for classinfo
|
|
|
189
|
|
|
190 // Cat together the vtbl[]'s from base interfaces
|
|
|
191 for (i = 0; i < interfaces_dim; i++)
|
|
|
192 {
|
|
|
193 BaseClass b = interfaces[i];
|
|
|
194
|
|
|
195 // Skip if b has already appeared
|
|
|
196 for (int k = 0; k < i; k++)
|
|
|
197 {
|
|
|
198 if (b == interfaces[i])
|
|
|
199 goto Lcontinue;
|
|
|
200 }
|
|
|
201
|
|
|
202 // Copy vtbl[] from base class
|
|
|
203 if (b.base.vtblOffset())
|
|
|
204 { int d = b.base.vtbl.dim;
|
|
|
205 if (d > 1)
|
|
|
206 {
|
|
|
207 vtbl.reserve(d - 1);
|
|
|
208 for (int j = 1; j < d; j++)
|
|
|
209 vtbl.push(b.base.vtbl.data[j]);
|
|
|
210 }
|
|
|
211 }
|
|
|
212 else
|
|
|
213 {
|
|
|
214 vtbl.append(b.base.vtbl);
|
|
|
215 }
|
|
|
216
|
|
|
217 Lcontinue:
|
|
|
218 ;
|
|
|
219 }
|
|
|
220
|
|
|
221 protection = sc.protection;
|
|
|
222 storage_class |= sc.stc & STC.STC_TYPECTOR;
|
|
|
223
|
|
|
224 for (i = 0; i < members.dim; i++)
|
|
|
225 {
|
|
|
226 Dsymbol s = cast(Dsymbol)members.data[i];
|
|
|
227 s.addMember(sc, this, 1);
|
|
|
228 }
|
|
|
229
|
|
|
230 sc = sc.push(this);
|
|
|
231 sc.stc &= ~(STC.STCfinal | STC.STCauto | STC.STCscope | STC.STCstatic |
|
|
|
232 STC.STCabstract | STC.STCdeprecated | STC.STC_TYPECTOR | STC.STCtls | STC.STCgshared);
|
|
|
233 sc.stc |= storage_class & STC.STC_TYPECTOR;
|
|
|
234 sc.parent = this;
|
|
|
235 if (isCOMinterface())
|
|
|
236 sc.linkage = LINK.LINKwindows;
|
|
|
237 else if (isCPPinterface())
|
|
|
238 sc.linkage = LINK.LINKcpp;
|
|
|
239 sc.structalign = 8;
|
|
|
240 structalign = sc.structalign;
|
|
|
241 sc.offset = PTRSIZE * 2;
|
|
|
242 inuse++;
|
|
|
243 for (i = 0; i < members.dim; i++)
|
|
|
244 {
|
|
|
245 Dsymbol s = cast(Dsymbol)members.data[i];
|
|
|
246 s.semantic(sc);
|
|
|
247 }
|
|
|
248 inuse--;
|
|
|
249 //members.print();
|
|
|
250 sc.pop();
|
|
|
251 //printf("-InterfaceDeclaration.semantic(%s), type = %p\n", toChars(), type);
|
|
|
252 }
|
|
|
253
|
|
|
254 bool isBaseOf(ClassDeclaration cd, int* poffset)
|
|
|
255 {
|
|
|
256 uint j;
|
|
|
257
|
|
|
258 //printf("%s.InterfaceDeclaration.isBaseOf(cd = '%s')\n", toChars(), cd.toChars());
|
|
|
259 assert(!baseClass);
|
|
|
260 for (j = 0; j < cd.interfaces_dim; j++)
|
|
|
261 {
|
|
|
262 BaseClass b = cd.interfaces[j];
|
|
|
263
|
|
|
264 //printf("\tbase %s\n", b.base.toChars());
|
|
|
265 if (this == b.base)
|
|
|
266 {
|
|
|
267 //printf("\tfound at offset %d\n", b.offset);
|
|
|
268 if (poffset)
|
|
|
269 {
|
|
|
270 *poffset = b.offset;
|
|
|
271 if (j && cd.isInterfaceDeclaration())
|
|
|
272 *poffset = OFFSET_RUNTIME;
|
|
|
273 }
|
|
|
274 return true;
|
|
|
275 }
|
|
|
276 if (isBaseOf(b, poffset))
|
|
|
277 {
|
|
|
278 if (j && poffset && cd.isInterfaceDeclaration())
|
|
|
279 *poffset = OFFSET_RUNTIME;
|
|
|
280 return true;
|
|
|
281 }
|
|
|
282 }
|
|
|
283
|
|
|
284 if (cd.baseClass && isBaseOf(cd.baseClass, poffset))
|
|
|
285 return true;
|
|
|
286
|
|
|
287 if (poffset)
|
|
|
288 *poffset = 0;
|
|
|
289 return false;
|
|
|
290 }
|
|
|
291
|
|
|
292 bool isBaseOf(BaseClass bc, int* poffset)
|
|
|
293 {
|
|
|
294 assert(false);
|
|
|
295 }
|
|
|
296
|
|
|
297 string kind()
|
|
|
298 {
|
|
|
299 assert(false);
|
|
|
300 }
|
|
|
301
|
|
|
302 /****************************************
|
|
|
303 * Determine if slot 0 of the vtbl[] is reserved for something else.
|
|
|
304 * For class objects, yes, this is where the ClassInfo ptr goes.
|
|
|
305 * For COM interfaces, no.
|
|
|
306 * For non-COM interfaces, yes, this is where the Interface ptr goes.
|
|
|
307 */
|
|
|
308 int vtblOffset()
|
|
|
309 {
|
|
|
310 if (isCOMinterface() || isCPPinterface())
|
|
|
311 return 0;
|
|
|
312 return 1;
|
|
|
313 }
|
|
|
314
|
|
|
315 version (DMDV2) {
|
|
|
316 bool isCPPinterface()
|
|
|
317 {
|
|
|
318 return cpp;
|
|
|
319 }
|
|
|
320 }
|
|
|
321 bool isCOMinterface()
|
|
|
322 {
|
|
|
323 return com;
|
|
|
324 }
|
|
|
325
|
|
|
326 void toObjFile(int multiobj) // compile to .obj file
|
|
|
327 {
|
|
|
328 uint i;
|
|
|
329 uint offset;
|
|
|
330 Symbol* sinit;
|
|
|
331 SC scclass;
|
|
|
332
|
|
|
333 //printf("InterfaceDeclaration.toObjFile('%s')\n", toChars());
|
|
|
334
|
|
|
335 if (!members)
|
|
|
336 return;
|
|
|
337
|
|
|
338 if (global.params.symdebug)
|
|
|
339 toDebug();
|
|
|
340
|
|
|
341 scclass = SCglobal;
|
|
|
342 if (inTemplateInstance())
|
|
|
343 scclass = SCcomdat;
|
|
|
344
|
|
|
345 // Put out the members
|
|
|
346 for (i = 0; i < members.dim; i++)
|
|
|
347 {
|
|
|
348 Dsymbol member;
|
|
|
349
|
|
|
350 member = cast(Dsymbol)members.data[i];
|
|
|
351 if (!member.isFuncDeclaration())
|
|
|
352 member.toObjFile(0);
|
|
|
353 }
|
|
|
354
|
|
|
355 // Generate C symbols
|
|
|
356 toSymbol();
|
|
|
357
|
|
|
358 //////////////////////////////////////////////
|
|
|
359
|
|
|
360 // Put out the TypeInfo
|
|
|
361 type.getTypeInfo(null);
|
|
|
362 type.vtinfo.toObjFile(multiobj);
|
|
|
363
|
|
|
364 //////////////////////////////////////////////
|
|
|
365
|
|
|
366 // Put out the ClassInfo
|
|
|
367 csym.Sclass = scclass;
|
|
|
368 csym.Sfl = FLdata;
|
|
|
369
|
|
|
370 /* The layout is:
|
|
|
371 {
|
|
|
372 void **vptr;
|
|
|
373 monitor_t monitor;
|
|
|
374 byte[] initializer; // static initialization data
|
|
|
375 char[] name; // class name
|
|
|
376 void *[] vtbl;
|
|
|
377 Interface[] interfaces;
|
|
|
378 Object *base; // base class
|
|
|
379 void *destructor;
|
|
|
380 void *invariant; // class invariant
|
|
|
381 uint flags;
|
|
|
382 void *deallocator;
|
|
|
383 OffsetTypeInfo[] offTi;
|
|
|
384 void *defaultConstructor;
|
|
|
385 #if DMDV2
|
|
|
386 const(MemberInfo[]) function(string) xgetMembers; // module getMembers() function
|
|
|
387 #endif
|
|
|
388 TypeInfo typeinfo;
|
|
|
389 }
|
|
|
390 */
|
|
|
391 dt_t *dt = null;
|
|
|
392
|
|
|
393 if (classinfo)
|
|
|
394 dtxoff(&dt, classinfo.toVtblSymbol(), 0, TYnptr); // vtbl for ClassInfo
|
|
|
395 else
|
|
|
396 dtdword(&dt, 0); // BUG: should be an assert()
|
|
|
397 dtdword(&dt, 0); // monitor
|
|
|
398
|
|
|
399 // initializer[]
|
|
|
400 dtdword(&dt, 0); // size
|
|
|
401 dtdword(&dt, 0); // initializer
|
|
|
402
|
|
|
403 // name[]
|
|
|
404 string name = toPrettyChars();
|
|
|
405 size_t namelen = name.length;
|
|
|
406 dtdword(&dt, namelen);
|
|
|
407 dtabytes(&dt, TYnptr, 0, namelen + 1, toStringz(name));
|
|
|
408
|
|
|
409 // vtbl[]
|
|
|
410 dtdword(&dt, 0);
|
|
|
411 dtdword(&dt, 0);
|
|
|
412
|
|
|
413 // vtblInterfaces.data[]
|
|
|
414 dtdword(&dt, vtblInterfaces.dim);
|
|
|
415 if (vtblInterfaces.dim)
|
|
|
416 {
|
|
|
417 if (classinfo)
|
|
|
418 assert(classinfo.structsize == CLASSINFO_SIZE);
|
|
|
419 offset = CLASSINFO_SIZE;
|
|
|
420 dtxoff(&dt, csym, offset, TYnptr); // (*)
|
|
|
421 }
|
|
|
422 else
|
|
|
423 dtdword(&dt, 0);
|
|
|
424
|
|
|
425 // base
|
|
|
426 assert(!baseClass);
|
|
|
427 dtdword(&dt, 0);
|
|
|
428
|
|
|
429 // dtor
|
|
|
430 dtdword(&dt, 0);
|
|
|
431
|
|
|
432 // invariant
|
|
|
433 dtdword(&dt, 0);
|
|
|
434
|
|
|
435 // flags
|
|
|
436 dtdword(&dt, 4 | isCOMinterface() | 32);
|
|
|
437
|
|
|
438 // deallocator
|
|
|
439 dtdword(&dt, 0);
|
|
|
440
|
|
|
441 // offTi[]
|
|
|
442 dtdword(&dt, 0);
|
|
|
443 dtdword(&dt, 0); // null for now, fix later
|
|
|
444
|
|
|
445 // defaultConstructor
|
|
|
446 dtdword(&dt, 0);
|
|
|
447
|
|
|
448 version (DMDV2) {
|
|
|
449 // xgetMembers
|
|
|
450 dtdword(&dt, 0);
|
|
|
451 }
|
|
|
452
|
|
|
453 dtxoff(&dt, type.vtinfo.toSymbol(), 0, TYnptr); // typeinfo
|
|
|
454
|
|
|
455 //////////////////////////////////////////////
|
|
|
456
|
|
|
457 // Put out vtblInterfaces.data[]. Must immediately follow csym, because
|
|
|
458 // of the fixup (*)
|
|
|
459
|
|
|
460 offset += vtblInterfaces.dim * (4 * PTRSIZE);
|
|
|
461 for (i = 0; i < vtblInterfaces.dim; i++)
|
|
|
462 {
|
|
|
463 BaseClass b = cast(BaseClass)vtblInterfaces.data[i];
|
|
|
464 ClassDeclaration id = b.base;
|
|
|
465
|
|
|
466 // ClassInfo
|
|
|
467 dtxoff(&dt, id.toSymbol(), 0, TYnptr);
|
|
|
468
|
|
|
469 // vtbl[]
|
|
|
470 dtdword(&dt, 0);
|
|
|
471 dtdword(&dt, 0);
|
|
|
472
|
|
|
473 // this offset
|
|
|
474 dtdword(&dt, b.offset);
|
|
|
475 }
|
|
|
476
|
|
|
477 csym.Sdt = dt;
|
|
|
478 version (ELFOBJ) {
|
|
|
479 csym.Sseg = CDATA;
|
|
|
480 }
|
|
|
481 version (MACHOBJ) {
|
|
|
482 csym.Sseg = DATA;
|
|
|
483 }
|
|
|
484 outdata(csym);
|
|
|
485 if (isExport())
|
|
|
486 obj_export(csym,0);
|
|
|
487 }
|
|
|
488
|
|
|
489 /*************************************
|
|
|
490 * Create the "InterfaceInfo" symbol
|
|
|
491 */
|
|
|
492 Symbol* toSymbol()
|
|
|
493 {
|
|
|
494 if (!csym)
|
|
|
495 {
|
|
|
496 Symbol *s;
|
|
|
497
|
|
|
498 if (!scc)
|
|
|
499 scc = fake_classsym(Id.ClassInfo);
|
|
|
500
|
|
|
501 s = toSymbolX("__Interface", SCextern, scc.Stype, "Z");
|
|
|
502 s.Sfl = FLextern;
|
|
|
503 s.Sflags |= SFLnodebug;
|
|
|
504 csym = s;
|
|
|
505 slist_add(s);
|
|
|
506 }
|
|
|
507 return csym;
|
|
|
508 }
|
|
|
509
|
|
|
510 InterfaceDeclaration isInterfaceDeclaration() { return this; }
|
|
|
511 } |
