|
1
|
1
|
|
|
2 // Compiler implementation of the D programming language
|
|
|
3 // Copyright (c) 1999-2007 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 "mars.h"
|
|
|
15 #include "expression.h"
|
|
|
16 #include "statement.h"
|
|
|
17 #include "mtype.h"
|
|
|
18 #include "utf.h"
|
|
|
19 #include "declaration.h"
|
|
|
20 #include "aggregate.h"
|
|
|
21 #include "scope.h"
|
|
|
22
|
|
|
23 /********************************************
|
|
|
24 * Convert from expression to delegate that returns the expression,
|
|
|
25 * i.e. convert:
|
|
|
26 * expr
|
|
|
27 * to:
|
|
|
28 * t delegate() { return expr; }
|
|
|
29 */
|
|
|
30
|
|
|
31 Expression *Expression::toDelegate(Scope *sc, Type *t)
|
|
|
32 {
|
|
|
33 //printf("Expression::toDelegate(t = %s) %s\n", t->toChars(), toChars());
|
|
|
34 TypeFunction *tf = new TypeFunction(NULL, t, 0, LINKd);
|
|
|
35 FuncLiteralDeclaration *fld =
|
|
|
36 new FuncLiteralDeclaration(loc, loc, tf, TOKdelegate, NULL);
|
|
|
37 Expression *e;
|
|
|
38 #if 1
|
|
|
39 sc = sc->push();
|
|
|
40 sc->parent = fld; // set current function to be the delegate
|
|
|
41 e = this;
|
|
|
42 e->scanForNestedRef(sc);
|
|
|
43 sc = sc->pop();
|
|
|
44 #else
|
|
|
45 e = this->syntaxCopy();
|
|
|
46 #endif
|
|
|
47 Statement *s = new ReturnStatement(loc, e);
|
|
|
48 fld->fbody = s;
|
|
|
49 e = new FuncExp(loc, fld);
|
|
|
50 e = e->semantic(sc);
|
|
|
51 return e;
|
|
|
52 }
|
|
|
53
|
|
|
54 /******************************
|
|
|
55 * Perform scanForNestedRef() on an array of Expressions.
|
|
|
56 */
|
|
|
57
|
|
|
58 void arrayExpressionScanForNestedRef(Scope *sc, Expressions *a)
|
|
|
59 {
|
|
|
60 //printf("arrayExpressionScanForNestedRef(%p)\n", a);
|
|
|
61 if (a)
|
|
|
62 {
|
|
|
63 for (int i = 0; i < a->dim; i++)
|
|
|
64 { Expression *e = (Expression *)a->data[i];
|
|
|
65
|
|
|
66 if (e)
|
|
|
67 {
|
|
|
68 e->scanForNestedRef(sc);
|
|
|
69 }
|
|
|
70 }
|
|
|
71 }
|
|
|
72 }
|
|
|
73
|
|
|
74 void Expression::scanForNestedRef(Scope *sc)
|
|
|
75 {
|
|
|
76 //printf("Expression::scanForNestedRef(%s)\n", toChars());
|
|
|
77 }
|
|
|
78
|
|
|
79 void SymOffExp::scanForNestedRef(Scope *sc)
|
|
|
80 {
|
|
|
81 //printf("SymOffExp::scanForNestedRef(%s)\n", toChars());
|
|
|
82 VarDeclaration *v = var->isVarDeclaration();
|
|
|
83 if (v)
|
|
|
84 v->checkNestedReference(sc, 0);
|
|
|
85 }
|
|
|
86
|
|
|
87 void VarExp::scanForNestedRef(Scope *sc)
|
|
|
88 {
|
|
|
89 //printf("VarExp::scanForNestedRef(%s)\n", toChars());
|
|
|
90 VarDeclaration *v = var->isVarDeclaration();
|
|
|
91 if (v)
|
|
|
92 v->checkNestedReference(sc, 0);
|
|
|
93 }
|
|
|
94
|
|
|
95 void ThisExp::scanForNestedRef(Scope *sc)
|
|
|
96 {
|
|
|
97 assert(var);
|
|
|
98 var->isVarDeclaration()->checkNestedReference(sc, 0);
|
|
|
99 }
|
|
|
100
|
|
|
101 void SuperExp::scanForNestedRef(Scope *sc)
|
|
|
102 {
|
|
|
103 ThisExp::scanForNestedRef(sc);
|
|
|
104 }
|
|
|
105
|
|
|
106 void FuncExp::scanForNestedRef(Scope *sc)
|
|
|
107 {
|
|
|
108 //printf("FuncExp::scanForNestedRef(%s)\n", toChars());
|
|
|
109 //fd->parent = sc->parent;
|
|
|
110 }
|
|
|
111
|
|
|
112 void DeclarationExp::scanForNestedRef(Scope *sc)
|
|
|
113 {
|
|
|
114 //printf("DeclarationExp::scanForNestedRef() %s\n", toChars());
|
|
|
115 declaration->parent = sc->parent;
|
|
|
116 }
|
|
|
117
|
|
|
118 void NewExp::scanForNestedRef(Scope *sc)
|
|
|
119 {
|
|
|
120 //printf("NewExp::scanForNestedRef(Scope *sc): %s\n", toChars());
|
|
|
121
|
|
|
122 if (thisexp)
|
|
|
123 thisexp->scanForNestedRef(sc);
|
|
|
124 arrayExpressionScanForNestedRef(sc, newargs);
|
|
|
125 arrayExpressionScanForNestedRef(sc, arguments);
|
|
|
126 }
|
|
|
127
|
|
|
128 void UnaExp::scanForNestedRef(Scope *sc)
|
|
|
129 {
|
|
|
130 e1->scanForNestedRef(sc);
|
|
|
131 }
|
|
|
132
|
|
|
133 void BinExp::scanForNestedRef(Scope *sc)
|
|
|
134 {
|
|
|
135 e1->scanForNestedRef(sc);
|
|
|
136 e2->scanForNestedRef(sc);
|
|
|
137 }
|
|
|
138
|
|
|
139 void CallExp::scanForNestedRef(Scope *sc)
|
|
|
140 {
|
|
|
141 //printf("CallExp::scanForNestedRef(Scope *sc): %s\n", toChars());
|
|
|
142 e1->scanForNestedRef(sc);
|
|
|
143 arrayExpressionScanForNestedRef(sc, arguments);
|
|
|
144 }
|
|
|
145
|
|
|
146
|
|
|
147 void IndexExp::scanForNestedRef(Scope *sc)
|
|
|
148 {
|
|
|
149 e1->scanForNestedRef(sc);
|
|
|
150
|
|
|
151 if (lengthVar)
|
|
|
152 { //printf("lengthVar\n");
|
|
|
153 lengthVar->parent = sc->parent;
|
|
|
154 }
|
|
|
155 e2->scanForNestedRef(sc);
|
|
|
156 }
|
|
|
157
|
|
|
158
|
|
|
159 void SliceExp::scanForNestedRef(Scope *sc)
|
|
|
160 {
|
|
|
161 e1->scanForNestedRef(sc);
|
|
|
162
|
|
|
163 if (lengthVar)
|
|
|
164 { //printf("lengthVar\n");
|
|
|
165 lengthVar->parent = sc->parent;
|
|
|
166 }
|
|
|
167 if (lwr)
|
|
|
168 lwr->scanForNestedRef(sc);
|
|
|
169 if (upr)
|
|
|
170 upr->scanForNestedRef(sc);
|
|
|
171 }
|
|
|
172
|
|
|
173
|
|
|
174 void ArrayLiteralExp::scanForNestedRef(Scope *sc)
|
|
|
175 {
|
|
|
176 arrayExpressionScanForNestedRef(sc, elements);
|
|
|
177 }
|
|
|
178
|
|
|
179
|
|
|
180 void AssocArrayLiteralExp::scanForNestedRef(Scope *sc)
|
|
|
181 {
|
|
|
182 arrayExpressionScanForNestedRef(sc, keys);
|
|
|
183 arrayExpressionScanForNestedRef(sc, values);
|
|
|
184 }
|
|
|
185
|
|
|
186
|
|
|
187 void StructLiteralExp::scanForNestedRef(Scope *sc)
|
|
|
188 {
|
|
|
189 arrayExpressionScanForNestedRef(sc, elements);
|
|
|
190 }
|
|
|
191
|
|
|
192
|
|
|
193 void TupleExp::scanForNestedRef(Scope *sc)
|
|
|
194 {
|
|
|
195 arrayExpressionScanForNestedRef(sc, exps);
|
|
|
196 }
|
|
|
197
|
|
|
198
|
|
|
199 void ArrayExp::scanForNestedRef(Scope *sc)
|
|
|
200 {
|
|
|
201 e1->scanForNestedRef(sc);
|
|
|
202 arrayExpressionScanForNestedRef(sc, arguments);
|
|
|
203 }
|
|
|
204
|
|
|
205
|
|
|
206 void CondExp::scanForNestedRef(Scope *sc)
|
|
|
207 {
|
|
|
208 econd->scanForNestedRef(sc);
|
|
|
209 e1->scanForNestedRef(sc);
|
|
|
210 e2->scanForNestedRef(sc);
|
|
|
211 }
|
|
|
212
|
|
|
213
|
|
|
214
|
