72
|
1 module dmd.TupleExp;
|
|
2
|
|
3 import dmd.Expression;
|
|
4 import dmd.TupleDeclaration;
|
|
5 import dmd.backend.elem;
|
|
6 import dmd.InterState;
|
|
7 import dmd.WANT;
|
|
8 import dmd.Type;
|
|
9 import dmd.OutBuffer;
|
|
10 import dmd.Loc;
|
|
11 import dmd.Scope;
|
|
12 import dmd.InlineCostState;
|
|
13 import dmd.IRState;
|
|
14 import dmd.InlineDoState;
|
|
15 import dmd.HdrGenState;
|
|
16 import dmd.InlineScanState;
|
|
17 import dmd.ArrayTypes;
|
|
18 import dmd.TypeExp;
|
|
19 import dmd.TypeTuple;
|
|
20 import dmd.TOK;
|
|
21 import dmd.TY;
|
|
22 import dmd.Dsymbol;
|
|
23 import dmd.DsymbolExp;
|
|
24 import dmd.DYNCAST;
|
|
25 import dmd.expression.Util;
|
|
26
|
|
27 /****************************************
|
|
28 * Expand tuples.
|
|
29 */
|
|
30 /+
|
|
31 void expandTuples(Expressions exps)
|
|
32 {
|
|
33 //printf("expandTuples()\n");
|
|
34 if (exps)
|
|
35 {
|
|
36 for (size_t i = 0; i < exps.dim; i++)
|
|
37 { Expression arg = cast(Expression)exps.data[i];
|
|
38 if (!arg)
|
|
39 continue;
|
|
40
|
|
41 // Look for tuple with 0 members
|
|
42 if (arg.op == TOKtype)
|
|
43 { TypeExp e = cast(TypeExp)arg;
|
|
44 if (e.type.toBasetype().ty == Ttuple)
|
|
45 { TypeTuple tt = cast(TypeTuple)e.type.toBasetype();
|
|
46
|
|
47 if (!tt.arguments || tt.arguments.dim == 0)
|
|
48 {
|
|
49 exps.remove(i);
|
|
50 if (i == exps.dim)
|
|
51 return;
|
|
52 i--;
|
|
53 continue;
|
|
54 }
|
|
55 }
|
|
56 }
|
|
57
|
|
58 // Inline expand all the tuples
|
|
59 while (arg.op == TOKtuple)
|
|
60 { TupleExp te = cast(TupleExp)arg;
|
|
61
|
|
62 exps.remove(i); // remove arg
|
|
63 exps.insert(i, te.exps); // replace with tuple contents
|
|
64 if (i == exps.dim)
|
|
65 return; // empty tuple, no more arguments
|
|
66 arg = cast(Expression)exps.data[i];
|
|
67 }
|
|
68 }
|
|
69 }
|
|
70 }
|
|
71 +/
|
|
72 class TupleExp : Expression
|
|
73 {
|
|
74 Expressions exps;
|
|
75
|
|
76 this(Loc loc, Expressions exps)
|
|
77 {
|
|
78 super(loc, TOKtuple, TupleExp.sizeof);
|
|
79
|
|
80 this.exps = exps;
|
|
81 this.type = null;
|
|
82 }
|
|
83
|
|
84 this(Loc loc, TupleDeclaration tup)
|
|
85 {
|
|
86 super(loc, TOKtuple, TupleExp.sizeof);
|
|
87 exps = new Expressions();
|
|
88 type = null;
|
|
89
|
|
90 exps.reserve(tup.objects.dim);
|
|
91 for (size_t i = 0; i < tup.objects.dim; i++)
|
|
92 {
|
|
93 Object o = cast(Object)tup.objects.data[i];
|
|
94 if (auto e = cast(Expression)o)
|
|
95 {
|
|
96 e = e.syntaxCopy();
|
|
97 exps.push(cast(void*)e);
|
|
98 }
|
|
99 else if (auto s = cast(Dsymbol)o)
|
|
100 {
|
|
101 Expression e = new DsymbolExp(loc, s);
|
|
102 exps.push(cast(void*)e);
|
|
103 }
|
|
104 else if (auto t = cast(Type)o)
|
|
105 {
|
|
106 Expression e = new TypeExp(loc, t);
|
|
107 exps.push(cast(void*)e);
|
|
108 }
|
|
109 else
|
|
110 {
|
|
111 error("%s is not an expression", o.toString());
|
|
112 }
|
|
113 }
|
|
114 }
|
|
115
|
|
116 override Expression syntaxCopy()
|
|
117 {
|
|
118 return new TupleExp(loc, arraySyntaxCopy(exps));
|
|
119 }
|
|
120
|
|
121 override bool equals(Object o)
|
|
122 {
|
|
123 TupleExp ne;
|
|
124
|
|
125 if (this == o)
|
|
126 return 1;
|
|
127 if ((cast(Expression)o).op == TOKtuple)
|
|
128 {
|
|
129 TupleExp te = cast(TupleExp)o;
|
|
130 if (exps.dim != te.exps.dim)
|
|
131 return 0;
|
|
132 for (size_t i = 0; i < exps.dim; i++)
|
|
133 { Expression e1 = cast(Expression)exps.data[i];
|
|
134 Expression e2 = cast(Expression)te.exps.data[i];
|
|
135
|
|
136 if (!e1.equals(e2))
|
|
137 return 0;
|
|
138 }
|
|
139 return 1;
|
|
140 }
|
|
141 return 0;
|
|
142 }
|
|
143
|
|
144 override Expression semantic(Scope sc)
|
|
145 {
|
|
146 version (LOGSEMANTIC) {
|
|
147 printf("+TupleExp::semantic(%s)\n", toChars());
|
|
148 }
|
|
149 if (type)
|
|
150 return this;
|
|
151
|
|
152 // Run semantic() on each argument
|
|
153 for (size_t i = 0; i < exps.dim; i++)
|
|
154 { Expression e = cast(Expression)exps.data[i];
|
|
155
|
|
156 e = e.semantic(sc);
|
|
157 if (!e.type)
|
|
158 { error("%s has no value", e.toChars());
|
|
159 e.type = Type.terror;
|
|
160 }
|
|
161 exps.data[i] = cast(void *)e;
|
|
162 }
|
|
163
|
|
164 expandTuples(exps);
|
|
165 if (0 && exps.dim == 1)
|
|
166 {
|
|
167 return cast(Expression)exps.data[0];
|
|
168 }
|
|
169 type = new TypeTuple(exps);
|
|
170 type = type.semantic(loc, sc);
|
|
171 //printf("-TupleExp::semantic(%s)\n", toChars());
|
|
172 return this;
|
|
173 }
|
|
174
|
|
175 override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
|
|
176 {
|
|
177 buf.writestring("tuple(");
|
|
178 argsToCBuffer(buf, exps, hgs);
|
|
179 buf.writeByte(')');
|
|
180 }
|
|
181
|
|
182 override void scanForNestedRef(Scope sc)
|
|
183 {
|
|
184 assert(false);
|
|
185 }
|
|
186
|
|
187 override void checkEscape()
|
|
188 {
|
|
189 for (size_t i = 0; i < exps.dim; i++)
|
|
190 { Expression e = cast(Expression)exps.data[i];
|
|
191 e.checkEscape();
|
|
192 }
|
|
193 }
|
|
194
|
|
195 override bool checkSideEffect(int flag)
|
|
196 {
|
|
197 bool f = false;
|
|
198
|
|
199 for (int i = 0; i < exps.dim; i++)
|
|
200 { Expression e = cast(Expression)exps.data[i];
|
|
201
|
|
202 f |= e.checkSideEffect(2);
|
|
203 }
|
|
204 if (flag == 0 && f == 0)
|
|
205 Expression.checkSideEffect(0);
|
|
206 return f;
|
|
207 }
|
|
208
|
|
209 override Expression optimize(int result)
|
|
210 {
|
|
211 for (size_t i = 0; i < exps.dim; i++)
|
|
212 {
|
|
213 Expression e = cast(Expression)exps.data[i];
|
|
214
|
|
215 e = e.optimize(WANTvalue | (result & WANTinterpret));
|
|
216 exps.data[i] = cast(void*)e;
|
|
217 }
|
|
218 return this;
|
|
219 }
|
|
220
|
|
221 override Expression interpret(InterState istate)
|
|
222 {
|
|
223 assert(false);
|
|
224 }
|
|
225
|
|
226 override Expression castTo(Scope sc, Type t)
|
|
227 {
|
|
228 assert(false);
|
|
229 }
|
|
230
|
|
231 override elem* toElem(IRState* irs)
|
|
232 {
|
|
233 assert(false);
|
|
234 }
|
|
235
|
|
236 override bool canThrow()
|
|
237 {
|
|
238 return arrayExpressionCanThrow(exps);
|
|
239 }
|
|
240
|
|
241 override int inlineCost(InlineCostState* ics)
|
|
242 {
|
|
243 assert(false);
|
|
244 }
|
|
245
|
|
246 override Expression doInline(InlineDoState ids)
|
|
247 {
|
|
248 assert(false);
|
|
249 }
|
|
250
|
|
251 override Expression inlineScan(InlineScanState* iss)
|
|
252 {
|
|
253 assert(false);
|
|
254 }
|
|
255 }
|
|
256
|