|
336
|
1
|
|
|
2 // Copyright (c) 1999-2006 by Digital Mars
|
|
|
3 // All Rights Reserved
|
|
|
4 // written by Walter Bright
|
|
|
5 // http://www.digitalmars.com
|
|
|
6 // License for redistribution is by either the Artistic License
|
|
|
7 // in artistic.txt, or the GNU General Public License in gnu.txt.
|
|
|
8 // See the included readme.txt for details.
|
|
|
9
|
|
|
10
|
|
|
11 #include <stdio.h>
|
|
|
12 #include <stdlib.h>
|
|
|
13 #include <assert.h>
|
|
|
14
|
|
|
15 #include "root.h"
|
|
|
16 #include "mem.h"
|
|
|
17
|
|
|
18 #include "enum.h"
|
|
|
19 #include "aggregate.h"
|
|
|
20 #include "init.h"
|
|
|
21 #include "attrib.h"
|
|
|
22 #include "scope.h"
|
|
|
23 #include "id.h"
|
|
|
24 #include "mtype.h"
|
|
|
25 #include "declaration.h"
|
|
|
26 #include "aggregate.h"
|
|
|
27 #include "expression.h"
|
|
|
28 #include "module.h"
|
|
|
29
|
|
|
30 #define LOG 0
|
|
|
31
|
|
|
32 /* Code to do access checks
|
|
|
33 */
|
|
|
34
|
|
|
35 int hasPackageAccess(Scope *sc, Dsymbol *s);
|
|
|
36
|
|
|
37 /****************************************
|
|
|
38 * Return PROT access for Dsymbol smember in this declaration.
|
|
|
39 */
|
|
|
40
|
|
|
41 enum PROT AggregateDeclaration::getAccess(Dsymbol *smember)
|
|
|
42 {
|
|
|
43 return PROTpublic;
|
|
|
44 }
|
|
|
45
|
|
|
46 enum PROT StructDeclaration::getAccess(Dsymbol *smember)
|
|
|
47 {
|
|
|
48 enum PROT access_ret = PROTnone;
|
|
|
49
|
|
|
50 #if LOG
|
|
|
51 printf("+StructDeclaration::getAccess(this = '%s', smember = '%s')\n",
|
|
|
52 toChars(), smember->toChars());
|
|
|
53 #endif
|
|
|
54 if (smember->toParent() == this)
|
|
|
55 {
|
|
|
56 access_ret = smember->prot();
|
|
|
57 }
|
|
|
58 else if (smember->isDeclaration()->isStatic())
|
|
|
59 {
|
|
|
60 access_ret = smember->prot();
|
|
|
61 }
|
|
|
62 return access_ret;
|
|
|
63 }
|
|
|
64
|
|
|
65 enum PROT ClassDeclaration::getAccess(Dsymbol *smember)
|
|
|
66 {
|
|
|
67 enum PROT access_ret = PROTnone;
|
|
|
68
|
|
|
69 #if LOG
|
|
|
70 printf("+ClassDeclaration::getAccess(this = '%s', smember = '%s')\n",
|
|
|
71 toChars(), smember->toChars());
|
|
|
72 #endif
|
|
|
73 if (smember->toParent() == this)
|
|
|
74 {
|
|
|
75 access_ret = smember->prot();
|
|
|
76 }
|
|
|
77 else
|
|
|
78 {
|
|
|
79 enum PROT access;
|
|
|
80 int i;
|
|
|
81
|
|
|
82 if (smember->isDeclaration()->isStatic())
|
|
|
83 {
|
|
|
84 access_ret = smember->prot();
|
|
|
85 }
|
|
|
86
|
|
|
87 for (i = 0; i < baseclasses.dim; i++)
|
|
|
88 { BaseClass *b = (BaseClass *)baseclasses.data[i];
|
|
|
89
|
|
|
90 access = b->base->getAccess(smember);
|
|
|
91 switch (access)
|
|
|
92 {
|
|
|
93 case PROTnone:
|
|
|
94 break;
|
|
|
95
|
|
|
96 case PROTprivate:
|
|
|
97 access = PROTnone; // private members of base class not accessible
|
|
|
98 break;
|
|
|
99
|
|
|
100 case PROTpackage:
|
|
|
101 case PROTprotected:
|
|
|
102 case PROTpublic:
|
|
|
103 case PROTexport:
|
|
|
104 // If access is to be tightened
|
|
|
105 if (b->protection < access)
|
|
|
106 access = b->protection;
|
|
|
107
|
|
|
108 // Pick path with loosest access
|
|
|
109 if (access > access_ret)
|
|
|
110 access_ret = access;
|
|
|
111 break;
|
|
|
112
|
|
|
113 default:
|
|
|
114 assert(0);
|
|
|
115 }
|
|
|
116 }
|
|
|
117 }
|
|
|
118 #if LOG
|
|
|
119 printf("-ClassDeclaration::getAccess(this = '%s', smember = '%s') = %d\n",
|
|
|
120 toChars(), smember->toChars(), access_ret);
|
|
|
121 #endif
|
|
|
122 return access_ret;
|
|
|
123 }
|
|
|
124
|
|
|
125 /********************************************************
|
|
|
126 * Helper function for ClassDeclaration::accessCheck()
|
|
|
127 * Returns:
|
|
|
128 * 0 no access
|
|
|
129 * 1 access
|
|
|
130 */
|
|
|
131
|
|
|
132 static int accessCheckX(
|
|
|
133 Dsymbol *smember,
|
|
|
134 Dsymbol *sfunc,
|
|
|
135 AggregateDeclaration *dthis,
|
|
|
136 AggregateDeclaration *cdscope)
|
|
|
137 {
|
|
|
138 assert(dthis);
|
|
|
139
|
|
|
140 #if 0
|
|
|
141 printf("accessCheckX for %s.%s in function %s() in scope %s\n",
|
|
|
142 dthis->toChars(), smember->toChars(),
|
|
|
143 sfunc ? sfunc->toChars() : "NULL",
|
|
|
144 cdscope ? cdscope->toChars() : "NULL");
|
|
|
145 #endif
|
|
|
146 if (dthis->hasPrivateAccess(sfunc) ||
|
|
|
147 dthis->isFriendOf(cdscope))
|
|
|
148 {
|
|
|
149 if (smember->toParent() == dthis)
|
|
|
150 return 1;
|
|
|
151 else
|
|
|
152 {
|
|
|
153 ClassDeclaration *cdthis = dthis->isClassDeclaration();
|
|
|
154 if (cdthis)
|
|
|
155 {
|
|
|
156 for (int i = 0; i < cdthis->baseclasses.dim; i++)
|
|
|
157 { BaseClass *b = (BaseClass *)cdthis->baseclasses.data[i];
|
|
|
158 enum PROT access;
|
|
|
159
|
|
|
160 access = b->base->getAccess(smember);
|
|
|
161 if (access >= PROTprotected ||
|
|
|
162 accessCheckX(smember, sfunc, b->base, cdscope)
|
|
|
163 )
|
|
|
164 return 1;
|
|
|
165
|
|
|
166 }
|
|
|
167 }
|
|
|
168 }
|
|
|
169 }
|
|
|
170 else
|
|
|
171 {
|
|
|
172 if (smember->toParent() != dthis)
|
|
|
173 {
|
|
|
174 ClassDeclaration *cdthis = dthis->isClassDeclaration();
|
|
|
175 if (cdthis)
|
|
|
176 {
|
|
|
177 for (int i = 0; i < cdthis->baseclasses.dim; i++)
|
|
|
178 { BaseClass *b = (BaseClass *)cdthis->baseclasses.data[i];
|
|
|
179
|
|
|
180 if (accessCheckX(smember, sfunc, b->base, cdscope))
|
|
|
181 return 1;
|
|
|
182 }
|
|
|
183 }
|
|
|
184 }
|
|
|
185 }
|
|
|
186 return 0;
|
|
|
187 }
|
|
|
188
|
|
|
189 /*******************************
|
|
|
190 * Do access check for member of this class, this class being the
|
|
|
191 * type of the 'this' pointer used to access smember.
|
|
|
192 */
|
|
|
193
|
|
|
194 void AggregateDeclaration::accessCheck(Loc loc, Scope *sc, Dsymbol *smember)
|
|
|
195 {
|
|
|
196 int result;
|
|
|
197
|
|
|
198 FuncDeclaration *f = sc->func;
|
|
|
199 AggregateDeclaration *cdscope = sc->getStructClassScope();
|
|
|
200 enum PROT access;
|
|
|
201
|
|
|
202 #if LOG
|
|
|
203 printf("AggregateDeclaration::accessCheck() for %s.%s in function %s() in scope %s\n",
|
|
|
204 toChars(), smember->toChars(),
|
|
|
205 f ? f->toChars() : NULL,
|
|
|
206 cdscope ? cdscope->toChars() : NULL);
|
|
|
207 #endif
|
|
|
208
|
|
|
209 Dsymbol *smemberparent = smember->toParent();
|
|
|
210 if (!smemberparent || !smemberparent->isAggregateDeclaration())
|
|
|
211 {
|
|
|
212 #if LOG
|
|
|
213 printf("not an aggregate member\n");
|
|
|
214 #endif
|
|
|
215 return; // then it is accessible
|
|
|
216 }
|
|
|
217
|
|
|
218 // BUG: should enable this check
|
|
|
219 //assert(smember->parent->isBaseOf(this, NULL));
|
|
|
220
|
|
|
221 if (smemberparent == this)
|
|
|
222 { enum PROT access = smember->prot();
|
|
|
223
|
|
|
224 result = access >= PROTpublic ||
|
|
|
225 hasPrivateAccess(f) ||
|
|
|
226 isFriendOf(cdscope) ||
|
|
|
227 (access == PROTpackage && hasPackageAccess(sc, this));
|
|
|
228 #if LOG
|
|
|
229 printf("result1 = %d\n", result);
|
|
|
230 #endif
|
|
|
231 }
|
|
|
232 else if ((access = this->getAccess(smember)) >= PROTpublic)
|
|
|
233 {
|
|
|
234 result = 1;
|
|
|
235 #if LOG
|
|
|
236 printf("result2 = %d\n", result);
|
|
|
237 #endif
|
|
|
238 }
|
|
|
239 else if (access == PROTpackage && hasPackageAccess(sc, this))
|
|
|
240 {
|
|
|
241 result = 1;
|
|
|
242 #if LOG
|
|
|
243 printf("result3 = %d\n", result);
|
|
|
244 #endif
|
|
|
245 }
|
|
|
246 else
|
|
|
247 {
|
|
|
248 result = accessCheckX(smember, f, this, cdscope);
|
|
|
249 #if LOG
|
|
|
250 printf("result4 = %d\n", result);
|
|
|
251 #endif
|
|
|
252 }
|
|
|
253 if (!result)
|
|
|
254 {
|
|
|
255 error(loc, "member %s is not accessible", smember->toChars());
|
|
|
256 halt();
|
|
|
257 }
|
|
|
258 }
|
|
|
259
|
|
|
260 /****************************************
|
|
|
261 * Determine if this is the same or friend of cd.
|
|
|
262 */
|
|
|
263
|
|
|
264 int AggregateDeclaration::isFriendOf(AggregateDeclaration *cd)
|
|
|
265 {
|
|
|
266 #if LOG
|
|
|
267 printf("AggregateDeclaration::isFriendOf(this = '%s', cd = '%s')\n", toChars(), cd ? cd->toChars() : "null");
|
|
|
268 #endif
|
|
|
269 if (this == cd)
|
|
|
270 return 1;
|
|
|
271
|
|
|
272 // Friends if both are in the same module
|
|
|
273 //if (toParent() == cd->toParent())
|
|
|
274 if (cd && getModule() == cd->getModule())
|
|
|
275 {
|
|
|
276 #if LOG
|
|
|
277 printf("\tin same module\n");
|
|
|
278 #endif
|
|
|
279 return 1;
|
|
|
280 }
|
|
|
281
|
|
|
282 #if LOG
|
|
|
283 printf("\tnot friend\n");
|
|
|
284 #endif
|
|
|
285 return 0;
|
|
|
286 }
|
|
|
287
|
|
|
288 /****************************************
|
|
|
289 * Determine if scope sc has package level access to s.
|
|
|
290 */
|
|
|
291
|
|
|
292 int hasPackageAccess(Scope *sc, Dsymbol *s)
|
|
|
293 {
|
|
|
294 #if LOG
|
|
|
295 printf("hasPackageAccess(s = '%s', sc = '%p')\n", s->toChars(), sc);
|
|
|
296 #endif
|
|
|
297
|
|
|
298 for (; s; s = s->parent)
|
|
|
299 {
|
|
|
300 if (s->isPackage() && !s->isModule())
|
|
|
301 break;
|
|
|
302 }
|
|
|
303 #if LOG
|
|
|
304 if (s)
|
|
|
305 printf("\tthis is in package '%s'\n", s->toChars());
|
|
|
306 #endif
|
|
|
307
|
|
|
308 if (s && s == sc->module->parent)
|
|
|
309 {
|
|
|
310 #if LOG
|
|
|
311 printf("\ts is in same package as sc\n");
|
|
|
312 #endif
|
|
|
313 return 1;
|
|
|
314 }
|
|
|
315
|
|
|
316
|
|
|
317 #if LOG
|
|
|
318 printf("\tno package access\n");
|
|
|
319 #endif
|
|
|
320 return 0;
|
|
|
321 }
|
|
|
322
|
|
|
323 /**********************************
|
|
|
324 * Determine if smember has access to private members of this declaration.
|
|
|
325 */
|
|
|
326
|
|
|
327 int AggregateDeclaration::hasPrivateAccess(Dsymbol *smember)
|
|
|
328 {
|
|
|
329 if (smember)
|
|
|
330 { AggregateDeclaration *cd = NULL;
|
|
|
331 Dsymbol *smemberparent = smember->toParent();
|
|
|
332 if (smemberparent)
|
|
|
333 cd = smemberparent->isAggregateDeclaration();
|
|
|
334
|
|
|
335 #if LOG
|
|
|
336 printf("AggregateDeclaration::hasPrivateAccess(class %s, member %s)\n",
|
|
|
337 toChars(), smember->toChars());
|
|
|
338 #endif
|
|
|
339
|
|
|
340 if (this == cd) // smember is a member of this class
|
|
|
341 {
|
|
|
342 #if LOG
|
|
|
343 printf("\tyes 1\n");
|
|
|
344 #endif
|
|
|
345 return 1; // so we get private access
|
|
|
346 }
|
|
|
347
|
|
|
348 // If both are members of the same module, grant access
|
|
|
349 while (1)
|
|
|
350 { Dsymbol *sp = smember->toParent();
|
|
|
351 if (sp->isFuncDeclaration() && smember->isFuncDeclaration())
|
|
|
352 smember = sp;
|
|
|
353 else
|
|
|
354 break;
|
|
|
355 }
|
|
|
356 if (!cd && toParent() == smember->toParent())
|
|
|
357 {
|
|
|
358 #if LOG
|
|
|
359 printf("\tyes 2\n");
|
|
|
360 #endif
|
|
|
361 return 1;
|
|
|
362 }
|
|
|
363 if (!cd && getModule() == smember->getModule())
|
|
|
364 {
|
|
|
365 #if LOG
|
|
|
366 printf("\tyes 3\n");
|
|
|
367 #endif
|
|
|
368 return 1;
|
|
|
369 }
|
|
|
370 }
|
|
|
371 #if LOG
|
|
|
372 printf("\tno\n");
|
|
|
373 #endif
|
|
|
374 return 0;
|
|
|
375 }
|
|
|
376
|
|
|
377 /****************************************
|
|
|
378 * Check access to d for expression e.d
|
|
|
379 */
|
|
|
380
|
|
|
381 void accessCheck(Loc loc, Scope *sc, Expression *e, Declaration *d)
|
|
|
382 {
|
|
|
383 #if LOG
|
|
|
384 if (e)
|
|
|
385 { printf("accessCheck(%s . %s)\n", e->toChars(), d->toChars());
|
|
|
386 printf("\te->type = %s\n", e->type->toChars());
|
|
|
387 }
|
|
|
388 else
|
|
|
389 {
|
|
|
390 //printf("accessCheck(%s)\n", d->toChars());
|
|
|
391 }
|
|
|
392 #endif
|
|
|
393 if (!e)
|
|
|
394 {
|
|
|
395 if (d->prot() == PROTprivate && d->getModule() != sc->module ||
|
|
|
396 d->prot() == PROTpackage && !hasPackageAccess(sc, d))
|
|
|
397
|
|
|
398 error(loc, "%s %s.%s is not accessible from %s",
|
|
|
399 d->kind(), d->getModule()->toChars(), d->toChars(), sc->module->toChars());
|
|
|
400 }
|
|
|
401 else if (e->type->ty == Tclass)
|
|
|
402 { // Do access check
|
|
|
403 ClassDeclaration *cd;
|
|
|
404
|
|
|
405 cd = (ClassDeclaration *)(((TypeClass *)e->type)->sym);
|
|
|
406 #if 1
|
|
|
407 if (e->op == TOKsuper)
|
|
|
408 { ClassDeclaration *cd2;
|
|
|
409
|
|
|
410 cd2 = sc->func->toParent()->isClassDeclaration();
|
|
|
411 if (cd2)
|
|
|
412 cd = cd2;
|
|
|
413 }
|
|
|
414 #endif
|
|
|
415 cd->accessCheck(loc, sc, d);
|
|
|
416 }
|
|
|
417 else if (e->type->ty == Tstruct)
|
|
|
418 { // Do access check
|
|
|
419 StructDeclaration *cd;
|
|
|
420
|
|
|
421 cd = (StructDeclaration *)(((TypeStruct *)e->type)->sym);
|
|
|
422 cd->accessCheck(loc, sc, d);
|
|
|
423 }
|
|
|
424 }
|
