|
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 #ifndef DMD_EXPRESSION_H
|
|
|
12 #define DMD_EXPRESSION_H
|
|
|
13
|
|
|
14 #include "mars.h"
|
|
|
15 #include "identifier.h"
|
|
|
16 #include "lexer.h"
|
|
|
17 #include "arraytypes.h"
|
|
|
18
|
|
|
19 struct Type;
|
|
|
20 struct Scope;
|
|
|
21 struct TupleDeclaration;
|
|
|
22 struct VarDeclaration;
|
|
|
23 struct FuncDeclaration;
|
|
|
24 struct FuncLiteralDeclaration;
|
|
|
25 struct Declaration;
|
|
|
26 struct CtorDeclaration;
|
|
|
27 struct NewDeclaration;
|
|
|
28 struct Dsymbol;
|
|
|
29 struct Import;
|
|
|
30 struct Module;
|
|
|
31 struct ScopeDsymbol;
|
|
|
32 struct InlineCostState;
|
|
|
33 struct InlineDoState;
|
|
|
34 struct InlineScanState;
|
|
|
35 struct Expression;
|
|
|
36 struct Declaration;
|
|
|
37 struct AggregateDeclaration;
|
|
|
38 struct StructDeclaration;
|
|
|
39 struct TemplateInstance;
|
|
|
40 struct TemplateDeclaration;
|
|
|
41 struct ClassDeclaration;
|
|
|
42 struct HdrGenState;
|
|
|
43 struct BinExp;
|
|
|
44 struct InterState;
|
|
|
45 struct Symbol; // back end symbol
|
|
|
46
|
|
|
47 namespace llvm
|
|
|
48 {
|
|
|
49 class ConstantInt;
|
|
|
50 }
|
|
|
51
|
|
|
52 enum TOK;
|
|
|
53
|
|
|
54 // Back end
|
|
|
55 struct IRState;
|
|
|
56 struct dt_t;
|
|
|
57
|
|
|
58 #ifdef IN_GCC
|
|
|
59 union tree_node; typedef union tree_node elem;
|
|
|
60 #else
|
|
|
61 struct elem;
|
|
|
62 #endif
|
|
|
63
|
|
|
64 void initPrecedence();
|
|
|
65
|
|
|
66 Expression *resolveProperties(Scope *sc, Expression *e);
|
|
|
67 void accessCheck(Loc loc, Scope *sc, Expression *e, Declaration *d);
|
|
|
68 Dsymbol *search_function(AggregateDeclaration *ad, Identifier *funcid);
|
|
|
69 void inferApplyArgTypes(enum TOK op, Arguments *arguments, Expression *aggr);
|
|
|
70 void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs);
|
|
|
71 void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs);
|
|
|
72 void expandTuples(Expressions *exps);
|
|
|
73
|
|
|
74 struct Expression : Object
|
|
|
75 {
|
|
|
76 Loc loc; // file location
|
|
|
77 enum TOK op; // handy to minimize use of dynamic_cast
|
|
|
78 Type *type; // !=NULL means that semantic() has been run
|
|
|
79 int size; // # of bytes in Expression so we can copy() it
|
|
|
80
|
|
|
81 Expression(Loc loc, enum TOK op, int size);
|
|
|
82 Expression *copy();
|
|
|
83 virtual Expression *syntaxCopy();
|
|
|
84 virtual Expression *semantic(Scope *sc);
|
|
|
85
|
|
|
86 int dyncast() { return DYNCAST_EXPRESSION; } // kludge for template.isExpression()
|
|
|
87
|
|
|
88 void print();
|
|
|
89 char *toChars();
|
|
|
90 virtual void dump(int indent);
|
|
|
91 void error(const char *format, ...);
|
|
|
92 virtual void rvalue();
|
|
|
93
|
|
|
94 static Expression *combine(Expression *e1, Expression *e2);
|
|
|
95 static Expressions *arraySyntaxCopy(Expressions *exps);
|
|
|
96
|
|
|
97 virtual integer_t toInteger();
|
|
|
98 virtual uinteger_t toUInteger();
|
|
|
99 virtual real_t toReal();
|
|
|
100 virtual real_t toImaginary();
|
|
|
101 virtual complex_t toComplex();
|
|
|
102 virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
103 virtual void toMangleBuffer(OutBuffer *buf);
|
|
|
104 virtual Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
105 virtual Expression *modifiableLvalue(Scope *sc, Expression *e);
|
|
|
106 Expression *implicitCastTo(Scope *sc, Type *t);
|
|
|
107 virtual MATCH implicitConvTo(Type *t);
|
|
|
108 virtual Expression *castTo(Scope *sc, Type *t);
|
|
|
109 virtual void checkEscape();
|
|
|
110 void checkScalar();
|
|
|
111 void checkNoBool();
|
|
|
112 Expression *checkIntegral();
|
|
|
113 void checkArithmetic();
|
|
|
114 void checkDeprecated(Scope *sc, Dsymbol *s);
|
|
|
115 virtual Expression *checkToBoolean();
|
|
|
116 Expression *checkToPointer();
|
|
|
117 Expression *addressOf(Scope *sc);
|
|
|
118 Expression *deref();
|
|
|
119 Expression *integralPromotions(Scope *sc);
|
|
|
120
|
|
|
121 Expression *toDelegate(Scope *sc, Type *t);
|
|
|
122 virtual void scanForNestedRef(Scope *sc);
|
|
|
123
|
|
|
124 virtual Expression *optimize(int result);
|
|
|
125 #define WANTflags 1
|
|
|
126 #define WANTvalue 2
|
|
|
127 #define WANTinterpret 4
|
|
|
128
|
|
|
129 virtual Expression *interpret(InterState *istate);
|
|
|
130
|
|
|
131 virtual int isConst();
|
|
|
132 virtual int isBool(int result);
|
|
|
133 virtual int isBit();
|
|
|
134 virtual int checkSideEffect(int flag);
|
|
|
135
|
|
|
136 virtual int inlineCost(InlineCostState *ics);
|
|
|
137 virtual Expression *doInline(InlineDoState *ids);
|
|
|
138 virtual Expression *inlineScan(InlineScanState *iss);
|
|
|
139
|
|
|
140 // For operator overloading
|
|
|
141 virtual int isCommutative();
|
|
|
142 virtual Identifier *opId();
|
|
|
143 virtual Identifier *opId_r();
|
|
|
144
|
|
|
145 // Back end
|
|
|
146 virtual elem *toElem(IRState *irs);
|
|
|
147 virtual dt_t **toDt(dt_t **pdt);
|
|
|
148 };
|
|
|
149
|
|
|
150 struct IntegerExp : Expression
|
|
|
151 {
|
|
|
152 integer_t value;
|
|
|
153
|
|
|
154 IntegerExp(Loc loc, integer_t value, Type *type);
|
|
|
155 IntegerExp(integer_t value);
|
|
|
156 int equals(Object *o);
|
|
|
157 Expression *semantic(Scope *sc);
|
|
|
158 Expression *interpret(InterState *istate);
|
|
|
159 char *toChars();
|
|
|
160 void dump(int indent);
|
|
|
161 integer_t toInteger();
|
|
|
162 real_t toReal();
|
|
|
163 real_t toImaginary();
|
|
|
164 complex_t toComplex();
|
|
|
165 int isConst();
|
|
|
166 int isBool(int result);
|
|
|
167 MATCH implicitConvTo(Type *t);
|
|
|
168 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
169 void toMangleBuffer(OutBuffer *buf);
|
|
|
170 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
171 elem *toElem(IRState *irs);
|
|
|
172 dt_t **toDt(dt_t **pdt);
|
|
|
173 };
|
|
|
174
|
|
|
175 struct RealExp : Expression
|
|
|
176 {
|
|
|
177 real_t value;
|
|
|
178
|
|
|
179 RealExp(Loc loc, real_t value, Type *type);
|
|
|
180 int equals(Object *o);
|
|
|
181 Expression *semantic(Scope *sc);
|
|
|
182 Expression *interpret(InterState *istate);
|
|
|
183 char *toChars();
|
|
|
184 integer_t toInteger();
|
|
|
185 uinteger_t toUInteger();
|
|
|
186 real_t toReal();
|
|
|
187 real_t toImaginary();
|
|
|
188 complex_t toComplex();
|
|
|
189 Expression *castTo(Scope *sc, Type *t);
|
|
|
190 int isConst();
|
|
|
191 int isBool(int result);
|
|
|
192 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
193 void toMangleBuffer(OutBuffer *buf);
|
|
|
194 elem *toElem(IRState *irs);
|
|
|
195 dt_t **toDt(dt_t **pdt);
|
|
|
196 };
|
|
|
197
|
|
|
198 struct ComplexExp : Expression
|
|
|
199 {
|
|
|
200 complex_t value;
|
|
|
201
|
|
|
202 ComplexExp(Loc loc, complex_t value, Type *type);
|
|
|
203 int equals(Object *o);
|
|
|
204 Expression *semantic(Scope *sc);
|
|
|
205 Expression *interpret(InterState *istate);
|
|
|
206 char *toChars();
|
|
|
207 integer_t toInteger();
|
|
|
208 uinteger_t toUInteger();
|
|
|
209 real_t toReal();
|
|
|
210 real_t toImaginary();
|
|
|
211 complex_t toComplex();
|
|
|
212 Expression *castTo(Scope *sc, Type *t);
|
|
|
213 int isConst();
|
|
|
214 int isBool(int result);
|
|
|
215 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
216 void toMangleBuffer(OutBuffer *buf);
|
|
|
217 #ifdef _DH
|
|
|
218 OutBuffer hexp;
|
|
|
219 #endif
|
|
|
220 elem *toElem(IRState *irs);
|
|
|
221 dt_t **toDt(dt_t **pdt);
|
|
|
222 };
|
|
|
223
|
|
|
224 struct IdentifierExp : Expression
|
|
|
225 {
|
|
|
226 Identifier *ident;
|
|
|
227 Declaration *var;
|
|
|
228
|
|
|
229 IdentifierExp(Loc loc, Identifier *ident);
|
|
|
230 IdentifierExp(Loc loc, Declaration *var);
|
|
|
231 Expression *semantic(Scope *sc);
|
|
|
232 char *toChars();
|
|
|
233 void dump(int indent);
|
|
|
234 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
235 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
236 };
|
|
|
237
|
|
|
238 struct DollarExp : IdentifierExp
|
|
|
239 {
|
|
|
240 DollarExp(Loc loc);
|
|
|
241 };
|
|
|
242
|
|
|
243 struct DsymbolExp : Expression
|
|
|
244 {
|
|
|
245 Dsymbol *s;
|
|
|
246
|
|
|
247 DsymbolExp(Loc loc, Dsymbol *s);
|
|
|
248 Expression *semantic(Scope *sc);
|
|
|
249 char *toChars();
|
|
|
250 void dump(int indent);
|
|
|
251 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
252 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
253 };
|
|
|
254
|
|
|
255 struct ThisExp : Expression
|
|
|
256 {
|
|
|
257 Declaration *var;
|
|
|
258
|
|
|
259 ThisExp(Loc loc);
|
|
|
260 Expression *semantic(Scope *sc);
|
|
|
261 int isBool(int result);
|
|
|
262 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
263 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
264 void scanForNestedRef(Scope *sc);
|
|
|
265
|
|
|
266 int inlineCost(InlineCostState *ics);
|
|
|
267 Expression *doInline(InlineDoState *ids);
|
|
|
268 //Expression *inlineScan(InlineScanState *iss);
|
|
|
269
|
|
|
270 elem *toElem(IRState *irs);
|
|
|
271 };
|
|
|
272
|
|
|
273 struct SuperExp : ThisExp
|
|
|
274 {
|
|
|
275 SuperExp(Loc loc);
|
|
|
276 Expression *semantic(Scope *sc);
|
|
|
277 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
278 void scanForNestedRef(Scope *sc);
|
|
|
279
|
|
|
280 int inlineCost(InlineCostState *ics);
|
|
|
281 Expression *doInline(InlineDoState *ids);
|
|
|
282 //Expression *inlineScan(InlineScanState *iss);
|
|
|
283 };
|
|
|
284
|
|
|
285 struct NullExp : Expression
|
|
|
286 {
|
|
|
287 unsigned char committed; // !=0 if type is committed
|
|
|
288
|
|
|
289 NullExp(Loc loc);
|
|
|
290 Expression *semantic(Scope *sc);
|
|
|
291 int isBool(int result);
|
|
|
292 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
293 void toMangleBuffer(OutBuffer *buf);
|
|
|
294 MATCH implicitConvTo(Type *t);
|
|
|
295 Expression *castTo(Scope *sc, Type *t);
|
|
|
296 Expression *interpret(InterState *istate);
|
|
|
297 elem *toElem(IRState *irs);
|
|
|
298 dt_t **toDt(dt_t **pdt);
|
|
|
299 };
|
|
|
300
|
|
|
301 struct StringExp : Expression
|
|
|
302 {
|
|
|
303 void *string; // char, wchar, or dchar data
|
|
|
304 size_t len; // number of chars, wchars, or dchars
|
|
|
305 unsigned char sz; // 1: char, 2: wchar, 4: dchar
|
|
|
306 unsigned char committed; // !=0 if type is committed
|
|
|
307 unsigned char postfix; // 'c', 'w', 'd'
|
|
|
308
|
|
|
309 StringExp(Loc loc, char *s);
|
|
|
310 StringExp(Loc loc, void *s, size_t len);
|
|
|
311 StringExp(Loc loc, void *s, size_t len, unsigned char postfix);
|
|
|
312 //Expression *syntaxCopy();
|
|
|
313 int equals(Object *o);
|
|
|
314 char *toChars();
|
|
|
315 Expression *semantic(Scope *sc);
|
|
|
316 Expression *interpret(InterState *istate);
|
|
|
317 StringExp *toUTF8(Scope *sc);
|
|
|
318 MATCH implicitConvTo(Type *t);
|
|
|
319 Expression *castTo(Scope *sc, Type *t);
|
|
|
320 int compare(Object *obj);
|
|
|
321 int isBool(int result);
|
|
|
322 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
323 void toMangleBuffer(OutBuffer *buf);
|
|
|
324 elem *toElem(IRState *irs);
|
|
|
325 dt_t **toDt(dt_t **pdt);
|
|
|
326 };
|
|
|
327
|
|
|
328 // Tuple
|
|
|
329
|
|
|
330 struct TupleExp : Expression
|
|
|
331 {
|
|
|
332 Expressions *exps;
|
|
|
333
|
|
|
334 TupleExp(Loc loc, Expressions *exps);
|
|
|
335 TupleExp(Loc loc, TupleDeclaration *tup);
|
|
|
336 Expression *syntaxCopy();
|
|
|
337 int equals(Object *o);
|
|
|
338 Expression *semantic(Scope *sc);
|
|
|
339 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
340 void scanForNestedRef(Scope *sc);
|
|
|
341 void checkEscape();
|
|
|
342 int checkSideEffect(int flag);
|
|
|
343 Expression *optimize(int result);
|
|
|
344 Expression *interpret(InterState *istate);
|
|
|
345 Expression *castTo(Scope *sc, Type *t);
|
|
|
346
|
|
|
347 int inlineCost(InlineCostState *ics);
|
|
|
348 Expression *doInline(InlineDoState *ids);
|
|
|
349 Expression *inlineScan(InlineScanState *iss);
|
|
|
350 };
|
|
|
351
|
|
|
352 struct ArrayLiteralExp : Expression
|
|
|
353 {
|
|
|
354 Expressions *elements;
|
|
|
355
|
|
|
356 ArrayLiteralExp(Loc loc, Expressions *elements);
|
|
|
357 ArrayLiteralExp(Loc loc, Expression *e);
|
|
|
358
|
|
|
359 Expression *syntaxCopy();
|
|
|
360 Expression *semantic(Scope *sc);
|
|
|
361 int isBool(int result);
|
|
|
362 elem *toElem(IRState *irs);
|
|
|
363 int checkSideEffect(int flag);
|
|
|
364 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
365 void toMangleBuffer(OutBuffer *buf);
|
|
|
366 void scanForNestedRef(Scope *sc);
|
|
|
367 Expression *optimize(int result);
|
|
|
368 Expression *interpret(InterState *istate);
|
|
|
369 MATCH implicitConvTo(Type *t);
|
|
|
370 Expression *castTo(Scope *sc, Type *t);
|
|
|
371 dt_t **toDt(dt_t **pdt);
|
|
|
372
|
|
|
373 int inlineCost(InlineCostState *ics);
|
|
|
374 Expression *doInline(InlineDoState *ids);
|
|
|
375 Expression *inlineScan(InlineScanState *iss);
|
|
|
376 };
|
|
|
377
|
|
|
378 struct AssocArrayLiteralExp : Expression
|
|
|
379 {
|
|
|
380 Expressions *keys;
|
|
|
381 Expressions *values;
|
|
|
382
|
|
|
383 AssocArrayLiteralExp(Loc loc, Expressions *keys, Expressions *values);
|
|
|
384
|
|
|
385 Expression *syntaxCopy();
|
|
|
386 Expression *semantic(Scope *sc);
|
|
|
387 int isBool(int result);
|
|
|
388 elem *toElem(IRState *irs);
|
|
|
389 int checkSideEffect(int flag);
|
|
|
390 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
391 void toMangleBuffer(OutBuffer *buf);
|
|
|
392 void scanForNestedRef(Scope *sc);
|
|
|
393 Expression *optimize(int result);
|
|
|
394 Expression *interpret(InterState *istate);
|
|
|
395 MATCH implicitConvTo(Type *t);
|
|
|
396 Expression *castTo(Scope *sc, Type *t);
|
|
|
397
|
|
|
398 int inlineCost(InlineCostState *ics);
|
|
|
399 Expression *doInline(InlineDoState *ids);
|
|
|
400 Expression *inlineScan(InlineScanState *iss);
|
|
|
401 };
|
|
|
402
|
|
|
403 struct StructLiteralExp : Expression
|
|
|
404 {
|
|
|
405 StructDeclaration *sd; // which aggregate this is for
|
|
|
406 Expressions *elements; // parallels sd->fields[] with
|
|
|
407 // NULL entries for fields to skip
|
|
|
408
|
|
|
409 Symbol *sym; // back end symbol to initialize with literal
|
|
|
410 size_t soffset; // offset from start of s
|
|
|
411 int fillHoles; // fill alignment 'holes' with zero
|
|
|
412
|
|
|
413 StructLiteralExp(Loc loc, StructDeclaration *sd, Expressions *elements);
|
|
|
414
|
|
|
415 Expression *syntaxCopy();
|
|
|
416 Expression *semantic(Scope *sc);
|
|
|
417 Expression *getField(Type *type, unsigned offset);
|
|
|
418 int getFieldIndex(Type *type, unsigned offset);
|
|
|
419 elem *toElem(IRState *irs);
|
|
|
420 int checkSideEffect(int flag);
|
|
|
421 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
422 void toMangleBuffer(OutBuffer *buf);
|
|
|
423 void scanForNestedRef(Scope *sc);
|
|
|
424 Expression *optimize(int result);
|
|
|
425 Expression *interpret(InterState *istate);
|
|
|
426 dt_t **toDt(dt_t **pdt);
|
|
|
427 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
428
|
|
|
429 int inlineCost(InlineCostState *ics);
|
|
|
430 Expression *doInline(InlineDoState *ids);
|
|
|
431 Expression *inlineScan(InlineScanState *iss);
|
|
|
432 };
|
|
|
433
|
|
|
434 struct TypeDotIdExp : Expression
|
|
|
435 {
|
|
|
436 Identifier *ident;
|
|
|
437
|
|
|
438 TypeDotIdExp(Loc loc, Type *type, Identifier *ident);
|
|
|
439 Expression *syntaxCopy();
|
|
|
440 Expression *semantic(Scope *sc);
|
|
|
441 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
442 elem *toElem(IRState *irs);
|
|
|
443 };
|
|
|
444
|
|
|
445 struct TypeExp : Expression
|
|
|
446 {
|
|
|
447 TypeExp(Loc loc, Type *type);
|
|
|
448 Expression *semantic(Scope *sc);
|
|
|
449 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
450 Expression *optimize(int result);
|
|
|
451 elem *toElem(IRState *irs);
|
|
|
452 };
|
|
|
453
|
|
|
454 struct ScopeExp : Expression
|
|
|
455 {
|
|
|
456 ScopeDsymbol *sds;
|
|
|
457
|
|
|
458 ScopeExp(Loc loc, ScopeDsymbol *sds);
|
|
|
459 Expression *syntaxCopy();
|
|
|
460 Expression *semantic(Scope *sc);
|
|
|
461 elem *toElem(IRState *irs);
|
|
|
462 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
463 };
|
|
|
464
|
|
|
465 struct TemplateExp : Expression
|
|
|
466 {
|
|
|
467 TemplateDeclaration *td;
|
|
|
468
|
|
|
469 TemplateExp(Loc loc, TemplateDeclaration *td);
|
|
|
470 void rvalue();
|
|
|
471 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
472 };
|
|
|
473
|
|
|
474 struct NewExp : Expression
|
|
|
475 {
|
|
|
476 /* thisexp.new(newargs) newtype(arguments)
|
|
|
477 */
|
|
|
478 Expression *thisexp; // if !NULL, 'this' for class being allocated
|
|
|
479 Expressions *newargs; // Array of Expression's to call new operator
|
|
|
480 Type *newtype;
|
|
|
481 Expressions *arguments; // Array of Expression's
|
|
|
482
|
|
|
483 CtorDeclaration *member; // constructor function
|
|
|
484 NewDeclaration *allocator; // allocator function
|
|
|
485 int onstack; // allocate on stack
|
|
|
486
|
|
|
487 NewExp(Loc loc, Expression *thisexp, Expressions *newargs,
|
|
|
488 Type *newtype, Expressions *arguments);
|
|
|
489 Expression *syntaxCopy();
|
|
|
490 Expression *semantic(Scope *sc);
|
|
|
491 elem *toElem(IRState *irs);
|
|
|
492 int checkSideEffect(int flag);
|
|
|
493 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
494 void scanForNestedRef(Scope *sc);
|
|
|
495
|
|
|
496 //int inlineCost(InlineCostState *ics);
|
|
|
497 Expression *doInline(InlineDoState *ids);
|
|
|
498 //Expression *inlineScan(InlineScanState *iss);
|
|
|
499 };
|
|
|
500
|
|
|
501 struct NewAnonClassExp : Expression
|
|
|
502 {
|
|
|
503 /* thisexp.new(newargs) class baseclasses { } (arguments)
|
|
|
504 */
|
|
|
505 Expression *thisexp; // if !NULL, 'this' for class being allocated
|
|
|
506 Expressions *newargs; // Array of Expression's to call new operator
|
|
|
507 ClassDeclaration *cd; // class being instantiated
|
|
|
508 Expressions *arguments; // Array of Expression's to call class constructor
|
|
|
509
|
|
|
510 NewAnonClassExp(Loc loc, Expression *thisexp, Expressions *newargs,
|
|
|
511 ClassDeclaration *cd, Expressions *arguments);
|
|
|
512 Expression *syntaxCopy();
|
|
|
513 Expression *semantic(Scope *sc);
|
|
|
514 int checkSideEffect(int flag);
|
|
|
515 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
516 };
|
|
|
517
|
|
|
518 // Offset from symbol
|
|
|
519
|
|
|
520 struct SymOffExp : Expression
|
|
|
521 {
|
|
|
522 Declaration *var;
|
|
|
523 unsigned offset;
|
|
|
524
|
|
|
525 SymOffExp(Loc loc, Declaration *var, unsigned offset);
|
|
|
526 Expression *semantic(Scope *sc);
|
|
|
527 void checkEscape();
|
|
|
528 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
529 int isConst();
|
|
|
530 int isBool(int result);
|
|
|
531 Expression *doInline(InlineDoState *ids);
|
|
|
532 MATCH implicitConvTo(Type *t);
|
|
|
533 Expression *castTo(Scope *sc, Type *t);
|
|
|
534 void scanForNestedRef(Scope *sc);
|
|
|
535
|
|
|
536 elem *toElem(IRState *irs);
|
|
|
537 dt_t **toDt(dt_t **pdt);
|
|
|
538 };
|
|
|
539
|
|
|
540 // Variable
|
|
|
541
|
|
|
542 struct VarExp : Expression
|
|
|
543 {
|
|
|
544 Declaration *var;
|
|
|
545
|
|
|
546 VarExp(Loc loc, Declaration *var);
|
|
|
547 int equals(Object *o);
|
|
|
548 Expression *semantic(Scope *sc);
|
|
|
549 Expression *optimize(int result);
|
|
|
550 Expression *interpret(InterState *istate);
|
|
|
551 void dump(int indent);
|
|
|
552 char *toChars();
|
|
|
553 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
554 void checkEscape();
|
|
|
555 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
556 Expression *modifiableLvalue(Scope *sc, Expression *e);
|
|
|
557 elem *toElem(IRState *irs);
|
|
|
558 dt_t **toDt(dt_t **pdt);
|
|
|
559 void scanForNestedRef(Scope *sc);
|
|
|
560
|
|
|
561 int inlineCost(InlineCostState *ics);
|
|
|
562 Expression *doInline(InlineDoState *ids);
|
|
|
563 //Expression *inlineScan(InlineScanState *iss);
|
|
|
564 };
|
|
|
565
|
|
|
566 // Function/Delegate literal
|
|
|
567
|
|
|
568 struct FuncExp : Expression
|
|
|
569 {
|
|
|
570 FuncLiteralDeclaration *fd;
|
|
|
571
|
|
|
572 FuncExp(Loc loc, FuncLiteralDeclaration *fd);
|
|
|
573 Expression *syntaxCopy();
|
|
|
574 Expression *semantic(Scope *sc);
|
|
|
575 void scanForNestedRef(Scope *sc);
|
|
|
576 char *toChars();
|
|
|
577 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
578 elem *toElem(IRState *irs);
|
|
|
579
|
|
|
580 int inlineCost(InlineCostState *ics);
|
|
|
581 //Expression *doInline(InlineDoState *ids);
|
|
|
582 //Expression *inlineScan(InlineScanState *iss);
|
|
|
583 };
|
|
|
584
|
|
|
585 // Declaration of a symbol
|
|
|
586
|
|
|
587 struct DeclarationExp : Expression
|
|
|
588 {
|
|
|
589 Dsymbol *declaration;
|
|
|
590
|
|
|
591 DeclarationExp(Loc loc, Dsymbol *declaration);
|
|
|
592 Expression *syntaxCopy();
|
|
|
593 Expression *semantic(Scope *sc);
|
|
|
594 Expression *interpret(InterState *istate);
|
|
|
595 int checkSideEffect(int flag);
|
|
|
596 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
597 elem *toElem(IRState *irs);
|
|
|
598 void scanForNestedRef(Scope *sc);
|
|
|
599
|
|
|
600 int inlineCost(InlineCostState *ics);
|
|
|
601 Expression *doInline(InlineDoState *ids);
|
|
|
602 Expression *inlineScan(InlineScanState *iss);
|
|
|
603 };
|
|
|
604
|
|
|
605 struct TypeidExp : Expression
|
|
|
606 {
|
|
|
607 Type *typeidType;
|
|
|
608
|
|
|
609 TypeidExp(Loc loc, Type *typeidType);
|
|
|
610 Expression *syntaxCopy();
|
|
|
611 Expression *semantic(Scope *sc);
|
|
|
612 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
613 };
|
|
|
614
|
|
|
615 struct HaltExp : Expression
|
|
|
616 {
|
|
|
617 HaltExp(Loc loc);
|
|
|
618 Expression *semantic(Scope *sc);
|
|
|
619 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
620 int checkSideEffect(int flag);
|
|
|
621
|
|
|
622 elem *toElem(IRState *irs);
|
|
|
623 };
|
|
|
624
|
|
|
625 struct IftypeExp : Expression
|
|
|
626 {
|
|
|
627 /* is(targ id tok tspec)
|
|
|
628 * is(targ id == tok2)
|
|
|
629 */
|
|
|
630 Type *targ;
|
|
|
631 Identifier *id; // can be NULL
|
|
|
632 enum TOK tok; // ':' or '=='
|
|
|
633 Type *tspec; // can be NULL
|
|
|
634 enum TOK tok2; // 'struct', 'union', 'typedef', etc.
|
|
|
635
|
|
|
636 IftypeExp(Loc loc, Type *targ, Identifier *id, enum TOK tok, Type *tspec, enum TOK tok2);
|
|
|
637 Expression *syntaxCopy();
|
|
|
638 Expression *semantic(Scope *sc);
|
|
|
639 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
640 };
|
|
|
641
|
|
|
642 /****************************************************************/
|
|
|
643
|
|
|
644 struct UnaExp : Expression
|
|
|
645 {
|
|
|
646 Expression *e1;
|
|
|
647
|
|
|
648 UnaExp(Loc loc, enum TOK op, int size, Expression *e1);
|
|
|
649 Expression *syntaxCopy();
|
|
|
650 Expression *semantic(Scope *sc);
|
|
|
651 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
652 Expression *optimize(int result);
|
|
|
653 void dump(int indent);
|
|
|
654 void scanForNestedRef(Scope *sc);
|
|
|
655 Expression *interpretCommon(InterState *istate, Expression *(*fp)(Type *, Expression *));
|
|
|
656
|
|
|
657 int inlineCost(InlineCostState *ics);
|
|
|
658 Expression *doInline(InlineDoState *ids);
|
|
|
659 Expression *inlineScan(InlineScanState *iss);
|
|
|
660
|
|
|
661 Expression *op_overload(Scope *sc); // doesn't need to be virtual
|
|
|
662 };
|
|
|
663
|
|
|
664 struct BinExp : Expression
|
|
|
665 {
|
|
|
666 Expression *e1;
|
|
|
667 Expression *e2;
|
|
|
668
|
|
|
669 BinExp(Loc loc, enum TOK op, int size, Expression *e1, Expression *e2);
|
|
|
670 Expression *syntaxCopy();
|
|
|
671 Expression *semantic(Scope *sc);
|
|
|
672 Expression *semanticp(Scope *sc);
|
|
|
673 Expression *commonSemanticAssign(Scope *sc);
|
|
|
674 Expression *commonSemanticAssignIntegral(Scope *sc);
|
|
|
675 int checkSideEffect(int flag);
|
|
|
676 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
677 Expression *scaleFactor(Scope *sc);
|
|
|
678 Expression *typeCombine(Scope *sc);
|
|
|
679 Expression *optimize(int result);
|
|
|
680 int isunsigned();
|
|
|
681 void incompatibleTypes();
|
|
|
682 void dump(int indent);
|
|
|
683 void scanForNestedRef(Scope *sc);
|
|
|
684 Expression *interpretCommon(InterState *istate, Expression *(*fp)(Type *, Expression *, Expression *));
|
|
|
685 Expression *interpretCommon2(InterState *istate, Expression *(*fp)(TOK, Type *, Expression *, Expression *));
|
|
|
686 Expression *interpretAssignCommon(InterState *istate, Expression *(*fp)(Type *, Expression *, Expression *), int post = 0);
|
|
|
687
|
|
|
688 int inlineCost(InlineCostState *ics);
|
|
|
689 Expression *doInline(InlineDoState *ids);
|
|
|
690 Expression *inlineScan(InlineScanState *iss);
|
|
|
691
|
|
|
692 Expression *op_overload(Scope *sc);
|
|
|
693
|
|
|
694 elem *toElemBin(IRState *irs, int op);
|
|
|
695 };
|
|
|
696
|
|
|
697 struct BinAssignExp : BinExp
|
|
|
698 {
|
|
|
699 BinAssignExp(Loc loc, enum TOK op, int size, Expression *e1, Expression *e2);
|
|
|
700 int checkSideEffect(int flag);
|
|
|
701 };
|
|
|
702
|
|
|
703 /****************************************************************/
|
|
|
704
|
|
|
705 struct CompileExp : UnaExp
|
|
|
706 {
|
|
|
707 CompileExp(Loc loc, Expression *e);
|
|
|
708 Expression *semantic(Scope *sc);
|
|
|
709 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
710 };
|
|
|
711
|
|
|
712 struct FileExp : UnaExp
|
|
|
713 {
|
|
|
714 FileExp(Loc loc, Expression *e);
|
|
|
715 Expression *semantic(Scope *sc);
|
|
|
716 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
717 };
|
|
|
718
|
|
|
719 struct AssertExp : UnaExp
|
|
|
720 {
|
|
|
721 Expression *msg;
|
|
|
722
|
|
|
723 AssertExp(Loc loc, Expression *e, Expression *msg = NULL);
|
|
|
724 Expression *syntaxCopy();
|
|
|
725 Expression *semantic(Scope *sc);
|
|
|
726 Expression *interpret(InterState *istate);
|
|
|
727 int checkSideEffect(int flag);
|
|
|
728 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
729
|
|
|
730 int inlineCost(InlineCostState *ics);
|
|
|
731 Expression *doInline(InlineDoState *ids);
|
|
|
732 Expression *inlineScan(InlineScanState *iss);
|
|
|
733
|
|
|
734 elem *toElem(IRState *irs);
|
|
|
735 };
|
|
|
736
|
|
|
737 struct DotIdExp : UnaExp
|
|
|
738 {
|
|
|
739 Identifier *ident;
|
|
|
740
|
|
|
741 DotIdExp(Loc loc, Expression *e, Identifier *ident);
|
|
|
742 Expression *semantic(Scope *sc);
|
|
|
743 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
744 void dump(int i);
|
|
|
745 };
|
|
|
746
|
|
|
747 struct DotTemplateExp : UnaExp
|
|
|
748 {
|
|
|
749 TemplateDeclaration *td;
|
|
|
750
|
|
|
751 DotTemplateExp(Loc loc, Expression *e, TemplateDeclaration *td);
|
|
|
752 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
753 };
|
|
|
754
|
|
|
755 struct DotVarExp : UnaExp
|
|
|
756 {
|
|
|
757 Declaration *var;
|
|
|
758
|
|
|
759 DotVarExp(Loc loc, Expression *e, Declaration *var);
|
|
|
760 Expression *semantic(Scope *sc);
|
|
|
761 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
762 Expression *modifiableLvalue(Scope *sc, Expression *e);
|
|
|
763 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
764 void dump(int indent);
|
|
|
765 elem *toElem(IRState *irs);
|
|
|
766 };
|
|
|
767
|
|
|
768 struct DotTemplateInstanceExp : UnaExp
|
|
|
769 {
|
|
|
770 TemplateInstance *ti;
|
|
|
771
|
|
|
772 DotTemplateInstanceExp(Loc loc, Expression *e, TemplateInstance *ti);
|
|
|
773 Expression *syntaxCopy();
|
|
|
774 Expression *semantic(Scope *sc);
|
|
|
775 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
776 void dump(int indent);
|
|
|
777 };
|
|
|
778
|
|
|
779 struct DelegateExp : UnaExp
|
|
|
780 {
|
|
|
781 FuncDeclaration *func;
|
|
|
782
|
|
|
783 DelegateExp(Loc loc, Expression *e, FuncDeclaration *func);
|
|
|
784 Expression *semantic(Scope *sc);
|
|
|
785 MATCH implicitConvTo(Type *t);
|
|
|
786 Expression *castTo(Scope *sc, Type *t);
|
|
|
787 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
788 void dump(int indent);
|
|
|
789
|
|
|
790 int inlineCost(InlineCostState *ics);
|
|
|
791 elem *toElem(IRState *irs);
|
|
|
792 };
|
|
|
793
|
|
|
794 struct DotTypeExp : UnaExp
|
|
|
795 {
|
|
|
796 Dsymbol *sym; // symbol that represents a type
|
|
|
797
|
|
|
798 DotTypeExp(Loc loc, Expression *e, Dsymbol *sym);
|
|
|
799 Expression *semantic(Scope *sc);
|
|
|
800 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
801 elem *toElem(IRState *irs);
|
|
|
802 };
|
|
|
803
|
|
|
804 struct CallExp : UnaExp
|
|
|
805 {
|
|
|
806 Expressions *arguments; // function arguments
|
|
|
807
|
|
|
808 CallExp(Loc loc, Expression *e, Expressions *exps);
|
|
|
809 CallExp(Loc loc, Expression *e);
|
|
|
810 CallExp(Loc loc, Expression *e, Expression *earg1);
|
|
|
811 CallExp(Loc loc, Expression *e, Expression *earg1, Expression *earg2);
|
|
|
812
|
|
|
813 Expression *syntaxCopy();
|
|
|
814 Expression *semantic(Scope *sc);
|
|
|
815 Expression *optimize(int result);
|
|
|
816 Expression *interpret(InterState *istate);
|
|
|
817 int checkSideEffect(int flag);
|
|
|
818 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
819 void dump(int indent);
|
|
|
820 elem *toElem(IRState *irs);
|
|
|
821 void scanForNestedRef(Scope *sc);
|
|
|
822 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
823
|
|
|
824 int inlineCost(InlineCostState *ics);
|
|
|
825 Expression *doInline(InlineDoState *ids);
|
|
|
826 Expression *inlineScan(InlineScanState *iss);
|
|
|
827 };
|
|
|
828
|
|
|
829 struct AddrExp : UnaExp
|
|
|
830 {
|
|
|
831 AddrExp(Loc loc, Expression *e);
|
|
|
832 Expression *semantic(Scope *sc);
|
|
|
833 elem *toElem(IRState *irs);
|
|
|
834 MATCH implicitConvTo(Type *t);
|
|
|
835 Expression *castTo(Scope *sc, Type *t);
|
|
|
836 Expression *optimize(int result);
|
|
|
837 };
|
|
|
838
|
|
|
839 struct PtrExp : UnaExp
|
|
|
840 {
|
|
|
841 PtrExp(Loc loc, Expression *e);
|
|
|
842 PtrExp(Loc loc, Expression *e, Type *t);
|
|
|
843 Expression *semantic(Scope *sc);
|
|
|
844 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
845 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
846 elem *toElem(IRState *irs);
|
|
|
847 Expression *optimize(int result);
|
|
|
848 Expression *interpret(InterState *istate);
|
|
|
849 };
|
|
|
850
|
|
|
851 struct NegExp : UnaExp
|
|
|
852 {
|
|
|
853 NegExp(Loc loc, Expression *e);
|
|
|
854 Expression *semantic(Scope *sc);
|
|
|
855 Expression *optimize(int result);
|
|
|
856 Expression *interpret(InterState *istate);
|
|
|
857
|
|
|
858 // For operator overloading
|
|
|
859 Identifier *opId();
|
|
|
860
|
|
|
861 elem *toElem(IRState *irs);
|
|
|
862 };
|
|
|
863
|
|
|
864 struct UAddExp : UnaExp
|
|
|
865 {
|
|
|
866 UAddExp(Loc loc, Expression *e);
|
|
|
867 Expression *semantic(Scope *sc);
|
|
|
868
|
|
|
869 // For operator overloading
|
|
|
870 Identifier *opId();
|
|
|
871 };
|
|
|
872
|
|
|
873 struct ComExp : UnaExp
|
|
|
874 {
|
|
|
875 ComExp(Loc loc, Expression *e);
|
|
|
876 Expression *semantic(Scope *sc);
|
|
|
877 Expression *optimize(int result);
|
|
|
878 Expression *interpret(InterState *istate);
|
|
|
879
|
|
|
880 // For operator overloading
|
|
|
881 Identifier *opId();
|
|
|
882
|
|
|
883 elem *toElem(IRState *irs);
|
|
|
884 };
|
|
|
885
|
|
|
886 struct NotExp : UnaExp
|
|
|
887 {
|
|
|
888 NotExp(Loc loc, Expression *e);
|
|
|
889 Expression *semantic(Scope *sc);
|
|
|
890 Expression *optimize(int result);
|
|
|
891 Expression *interpret(InterState *istate);
|
|
|
892 int isBit();
|
|
|
893 elem *toElem(IRState *irs);
|
|
|
894 };
|
|
|
895
|
|
|
896 struct BoolExp : UnaExp
|
|
|
897 {
|
|
|
898 BoolExp(Loc loc, Expression *e, Type *type);
|
|
|
899 Expression *semantic(Scope *sc);
|
|
|
900 Expression *optimize(int result);
|
|
|
901 Expression *interpret(InterState *istate);
|
|
|
902 int isBit();
|
|
|
903 elem *toElem(IRState *irs);
|
|
|
904 };
|
|
|
905
|
|
|
906 struct DeleteExp : UnaExp
|
|
|
907 {
|
|
|
908 DeleteExp(Loc loc, Expression *e);
|
|
|
909 Expression *semantic(Scope *sc);
|
|
|
910 Expression *checkToBoolean();
|
|
|
911 int checkSideEffect(int flag);
|
|
|
912 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
913 elem *toElem(IRState *irs);
|
|
|
914 };
|
|
|
915
|
|
|
916 struct CastExp : UnaExp
|
|
|
917 {
|
|
|
918 // Possible to cast to one type while painting to another type
|
|
|
919 Type *to; // type to cast to
|
|
|
920
|
|
|
921 CastExp(Loc loc, Expression *e, Type *t);
|
|
|
922 Expression *syntaxCopy();
|
|
|
923 Expression *semantic(Scope *sc);
|
|
|
924 Expression *optimize(int result);
|
|
|
925 Expression *interpret(InterState *istate);
|
|
|
926 int checkSideEffect(int flag);
|
|
|
927 void checkEscape();
|
|
|
928 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
929 elem *toElem(IRState *irs);
|
|
|
930
|
|
|
931 // For operator overloading
|
|
|
932 Identifier *opId();
|
|
|
933 };
|
|
|
934
|
|
|
935
|
|
|
936 struct SliceExp : UnaExp
|
|
|
937 {
|
|
|
938 Expression *upr; // NULL if implicit 0
|
|
|
939 Expression *lwr; // NULL if implicit [length - 1]
|
|
|
940 VarDeclaration *lengthVar;
|
|
|
941
|
|
|
942 SliceExp(Loc loc, Expression *e1, Expression *lwr, Expression *upr);
|
|
|
943 Expression *syntaxCopy();
|
|
|
944 Expression *semantic(Scope *sc);
|
|
|
945 void checkEscape();
|
|
|
946 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
947 Expression *modifiableLvalue(Scope *sc, Expression *e);
|
|
|
948 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
949 Expression *optimize(int result);
|
|
|
950 Expression *interpret(InterState *istate);
|
|
|
951 void dump(int indent);
|
|
|
952 elem *toElem(IRState *irs);
|
|
|
953 void scanForNestedRef(Scope *sc);
|
|
|
954
|
|
|
955 int inlineCost(InlineCostState *ics);
|
|
|
956 Expression *doInline(InlineDoState *ids);
|
|
|
957 Expression *inlineScan(InlineScanState *iss);
|
|
|
958 };
|
|
|
959
|
|
|
960 struct ArrayLengthExp : UnaExp
|
|
|
961 {
|
|
|
962 ArrayLengthExp(Loc loc, Expression *e1);
|
|
|
963 Expression *semantic(Scope *sc);
|
|
|
964 Expression *optimize(int result);
|
|
|
965 Expression *interpret(InterState *istate);
|
|
|
966 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
967 elem *toElem(IRState *irs);
|
|
|
968 };
|
|
|
969
|
|
|
970 // e1[a0,a1,a2,a3,...]
|
|
|
971
|
|
|
972 struct ArrayExp : UnaExp
|
|
|
973 {
|
|
|
974 Expressions *arguments; // Array of Expression's
|
|
|
975
|
|
|
976 ArrayExp(Loc loc, Expression *e1, Expressions *arguments);
|
|
|
977 Expression *syntaxCopy();
|
|
|
978 Expression *semantic(Scope *sc);
|
|
|
979 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
980 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
981 void scanForNestedRef(Scope *sc);
|
|
|
982
|
|
|
983 // For operator overloading
|
|
|
984 Identifier *opId();
|
|
|
985
|
|
|
986 int inlineCost(InlineCostState *ics);
|
|
|
987 Expression *doInline(InlineDoState *ids);
|
|
|
988 Expression *inlineScan(InlineScanState *iss);
|
|
|
989 };
|
|
|
990
|
|
|
991 /****************************************************************/
|
|
|
992
|
|
|
993 struct DotExp : BinExp
|
|
|
994 {
|
|
|
995 DotExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
996 Expression *semantic(Scope *sc);
|
|
|
997 };
|
|
|
998
|
|
|
999 struct CommaExp : BinExp
|
|
|
1000 {
|
|
|
1001 CommaExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1002 Expression *semantic(Scope *sc);
|
|
|
1003 void checkEscape();
|
|
|
1004 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
1005 Expression *modifiableLvalue(Scope *sc, Expression *e);
|
|
|
1006 int isBool(int result);
|
|
|
1007 int checkSideEffect(int flag);
|
|
|
1008 Expression *optimize(int result);
|
|
|
1009 Expression *interpret(InterState *istate);
|
|
|
1010 elem *toElem(IRState *irs);
|
|
|
1011 };
|
|
|
1012
|
|
|
1013 struct IndexExp : BinExp
|
|
|
1014 {
|
|
|
1015 VarDeclaration *lengthVar;
|
|
|
1016 int modifiable;
|
|
|
1017
|
|
|
1018 IndexExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1019 Expression *semantic(Scope *sc);
|
|
|
1020 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
1021 Expression *modifiableLvalue(Scope *sc, Expression *e);
|
|
|
1022 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
1023 Expression *optimize(int result);
|
|
|
1024 Expression *interpret(InterState *istate);
|
|
|
1025 Expression *doInline(InlineDoState *ids);
|
|
|
1026 void scanForNestedRef(Scope *sc);
|
|
|
1027
|
|
|
1028 elem *toElem(IRState *irs);
|
|
|
1029 };
|
|
|
1030
|
|
|
1031 /* For both i++ and i--
|
|
|
1032 */
|
|
|
1033 struct PostExp : BinExp
|
|
|
1034 {
|
|
|
1035 PostExp(enum TOK op, Loc loc, Expression *e);
|
|
|
1036 Expression *semantic(Scope *sc);
|
|
|
1037 Expression *interpret(InterState *istate);
|
|
|
1038 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
1039 Identifier *opId(); // For operator overloading
|
|
|
1040 elem *toElem(IRState *irs);
|
|
|
1041 };
|
|
|
1042
|
|
|
1043 struct AssignExp : BinExp
|
|
|
1044 { int ismemset; // !=0 if setting the contents of an array
|
|
|
1045
|
|
|
1046 AssignExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1047 Expression *semantic(Scope *sc);
|
|
|
1048 Expression *checkToBoolean();
|
|
|
1049 Expression *interpret(InterState *istate);
|
|
|
1050 Identifier *opId(); // For operator overloading
|
|
|
1051 elem *toElem(IRState *irs);
|
|
|
1052 };
|
|
|
1053
|
|
|
1054 #define ASSIGNEXP(op) \
|
|
|
1055 struct op##AssignExp : BinExp \
|
|
|
1056 { \
|
|
|
1057 op##AssignExp(Loc loc, Expression *e1, Expression *e2); \
|
|
|
1058 Expression *semantic(Scope *sc); \
|
|
|
1059 Expression *interpret(InterState *istate); \
|
|
|
1060 \
|
|
|
1061 Identifier *opId(); /* For operator overloading */ \
|
|
|
1062 \
|
|
|
1063 elem *toElem(IRState *irs); \
|
|
|
1064 };
|
|
|
1065
|
|
|
1066 ASSIGNEXP(Add)
|
|
|
1067 ASSIGNEXP(Min)
|
|
|
1068 ASSIGNEXP(Cat)
|
|
|
1069 ASSIGNEXP(Mul)
|
|
|
1070 ASSIGNEXP(Div)
|
|
|
1071 ASSIGNEXP(Mod)
|
|
|
1072 ASSIGNEXP(Shl)
|
|
|
1073 ASSIGNEXP(Shr)
|
|
|
1074 ASSIGNEXP(Ushr)
|
|
|
1075 ASSIGNEXP(And)
|
|
|
1076 ASSIGNEXP(Or)
|
|
|
1077 ASSIGNEXP(Xor)
|
|
|
1078
|
|
|
1079 #undef ASSIGNEXP
|
|
|
1080
|
|
|
1081 struct AddExp : BinExp
|
|
|
1082 {
|
|
|
1083 AddExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1084 Expression *semantic(Scope *sc);
|
|
|
1085 Expression *optimize(int result);
|
|
|
1086 Expression *interpret(InterState *istate);
|
|
|
1087
|
|
|
1088 // For operator overloading
|
|
|
1089 int isCommutative();
|
|
|
1090 Identifier *opId();
|
|
|
1091 Identifier *opId_r();
|
|
|
1092
|
|
|
1093 elem *toElem(IRState *irs);
|
|
|
1094 };
|
|
|
1095
|
|
|
1096 struct MinExp : BinExp
|
|
|
1097 {
|
|
|
1098 MinExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1099 Expression *semantic(Scope *sc);
|
|
|
1100 Expression *optimize(int result);
|
|
|
1101 Expression *interpret(InterState *istate);
|
|
|
1102
|
|
|
1103 // For operator overloading
|
|
|
1104 Identifier *opId();
|
|
|
1105 Identifier *opId_r();
|
|
|
1106
|
|
|
1107 elem *toElem(IRState *irs);
|
|
|
1108 };
|
|
|
1109
|
|
|
1110 struct CatExp : BinExp
|
|
|
1111 {
|
|
|
1112 CatExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1113 Expression *semantic(Scope *sc);
|
|
|
1114 Expression *optimize(int result);
|
|
|
1115 Expression *interpret(InterState *istate);
|
|
|
1116
|
|
|
1117 // For operator overloading
|
|
|
1118 Identifier *opId();
|
|
|
1119 Identifier *opId_r();
|
|
|
1120
|
|
|
1121 elem *toElem(IRState *irs);
|
|
|
1122 };
|
|
|
1123
|
|
|
1124 struct MulExp : BinExp
|
|
|
1125 {
|
|
|
1126 MulExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1127 Expression *semantic(Scope *sc);
|
|
|
1128 Expression *optimize(int result);
|
|
|
1129 Expression *interpret(InterState *istate);
|
|
|
1130
|
|
|
1131 // For operator overloading
|
|
|
1132 int isCommutative();
|
|
|
1133 Identifier *opId();
|
|
|
1134 Identifier *opId_r();
|
|
|
1135
|
|
|
1136 elem *toElem(IRState *irs);
|
|
|
1137 };
|
|
|
1138
|
|
|
1139 struct DivExp : BinExp
|
|
|
1140 {
|
|
|
1141 DivExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1142 Expression *semantic(Scope *sc);
|
|
|
1143 Expression *optimize(int result);
|
|
|
1144 Expression *interpret(InterState *istate);
|
|
|
1145
|
|
|
1146 // For operator overloading
|
|
|
1147 Identifier *opId();
|
|
|
1148 Identifier *opId_r();
|
|
|
1149
|
|
|
1150 elem *toElem(IRState *irs);
|
|
|
1151 };
|
|
|
1152
|
|
|
1153 struct ModExp : BinExp
|
|
|
1154 {
|
|
|
1155 ModExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1156 Expression *semantic(Scope *sc);
|
|
|
1157 Expression *optimize(int result);
|
|
|
1158 Expression *interpret(InterState *istate);
|
|
|
1159
|
|
|
1160 // For operator overloading
|
|
|
1161 Identifier *opId();
|
|
|
1162 Identifier *opId_r();
|
|
|
1163
|
|
|
1164 elem *toElem(IRState *irs);
|
|
|
1165 };
|
|
|
1166
|
|
|
1167 struct ShlExp : BinExp
|
|
|
1168 {
|
|
|
1169 ShlExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1170 Expression *semantic(Scope *sc);
|
|
|
1171 Expression *optimize(int result);
|
|
|
1172 Expression *interpret(InterState *istate);
|
|
|
1173
|
|
|
1174 // For operator overloading
|
|
|
1175 Identifier *opId();
|
|
|
1176 Identifier *opId_r();
|
|
|
1177
|
|
|
1178 elem *toElem(IRState *irs);
|
|
|
1179 };
|
|
|
1180
|
|
|
1181 struct ShrExp : BinExp
|
|
|
1182 {
|
|
|
1183 ShrExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1184 Expression *semantic(Scope *sc);
|
|
|
1185 Expression *optimize(int result);
|
|
|
1186 Expression *interpret(InterState *istate);
|
|
|
1187
|
|
|
1188 // For operator overloading
|
|
|
1189 Identifier *opId();
|
|
|
1190 Identifier *opId_r();
|
|
|
1191
|
|
|
1192 elem *toElem(IRState *irs);
|
|
|
1193 };
|
|
|
1194
|
|
|
1195 struct UshrExp : BinExp
|
|
|
1196 {
|
|
|
1197 UshrExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1198 Expression *semantic(Scope *sc);
|
|
|
1199 Expression *optimize(int result);
|
|
|
1200 Expression *interpret(InterState *istate);
|
|
|
1201
|
|
|
1202 // For operator overloading
|
|
|
1203 Identifier *opId();
|
|
|
1204 Identifier *opId_r();
|
|
|
1205
|
|
|
1206 elem *toElem(IRState *irs);
|
|
|
1207 };
|
|
|
1208
|
|
|
1209 struct AndExp : BinExp
|
|
|
1210 {
|
|
|
1211 AndExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1212 Expression *semantic(Scope *sc);
|
|
|
1213 Expression *optimize(int result);
|
|
|
1214 Expression *interpret(InterState *istate);
|
|
|
1215
|
|
|
1216 // For operator overloading
|
|
|
1217 int isCommutative();
|
|
|
1218 Identifier *opId();
|
|
|
1219 Identifier *opId_r();
|
|
|
1220
|
|
|
1221 elem *toElem(IRState *irs);
|
|
|
1222 };
|
|
|
1223
|
|
|
1224 struct OrExp : BinExp
|
|
|
1225 {
|
|
|
1226 OrExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1227 Expression *semantic(Scope *sc);
|
|
|
1228 Expression *optimize(int result);
|
|
|
1229 Expression *interpret(InterState *istate);
|
|
|
1230
|
|
|
1231 // For operator overloading
|
|
|
1232 int isCommutative();
|
|
|
1233 Identifier *opId();
|
|
|
1234 Identifier *opId_r();
|
|
|
1235
|
|
|
1236 elem *toElem(IRState *irs);
|
|
|
1237 };
|
|
|
1238
|
|
|
1239 struct XorExp : BinExp
|
|
|
1240 {
|
|
|
1241 XorExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1242 Expression *semantic(Scope *sc);
|
|
|
1243 Expression *optimize(int result);
|
|
|
1244 Expression *interpret(InterState *istate);
|
|
|
1245
|
|
|
1246 // For operator overloading
|
|
|
1247 int isCommutative();
|
|
|
1248 Identifier *opId();
|
|
|
1249 Identifier *opId_r();
|
|
|
1250
|
|
|
1251 elem *toElem(IRState *irs);
|
|
|
1252 };
|
|
|
1253
|
|
|
1254 struct OrOrExp : BinExp
|
|
|
1255 {
|
|
|
1256 OrOrExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1257 Expression *semantic(Scope *sc);
|
|
|
1258 Expression *checkToBoolean();
|
|
|
1259 int isBit();
|
|
|
1260 Expression *optimize(int result);
|
|
|
1261 Expression *interpret(InterState *istate);
|
|
|
1262 int checkSideEffect(int flag);
|
|
|
1263 elem *toElem(IRState *irs);
|
|
|
1264 };
|
|
|
1265
|
|
|
1266 struct AndAndExp : BinExp
|
|
|
1267 {
|
|
|
1268 AndAndExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1269 Expression *semantic(Scope *sc);
|
|
|
1270 Expression *checkToBoolean();
|
|
|
1271 int isBit();
|
|
|
1272 Expression *optimize(int result);
|
|
|
1273 Expression *interpret(InterState *istate);
|
|
|
1274 int checkSideEffect(int flag);
|
|
|
1275 elem *toElem(IRState *irs);
|
|
|
1276 };
|
|
|
1277
|
|
|
1278 struct CmpExp : BinExp
|
|
|
1279 {
|
|
|
1280 CmpExp(enum TOK op, Loc loc, Expression *e1, Expression *e2);
|
|
|
1281 Expression *semantic(Scope *sc);
|
|
|
1282 Expression *optimize(int result);
|
|
|
1283 Expression *interpret(InterState *istate);
|
|
|
1284 int isBit();
|
|
|
1285
|
|
|
1286 // For operator overloading
|
|
|
1287 int isCommutative();
|
|
|
1288 Identifier *opId();
|
|
|
1289
|
|
|
1290 elem *toElem(IRState *irs);
|
|
|
1291 };
|
|
|
1292
|
|
|
1293 struct InExp : BinExp
|
|
|
1294 {
|
|
|
1295 InExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1296 Expression *semantic(Scope *sc);
|
|
|
1297 int isBit();
|
|
|
1298
|
|
|
1299 // For operator overloading
|
|
|
1300 Identifier *opId();
|
|
|
1301 Identifier *opId_r();
|
|
|
1302
|
|
|
1303 elem *toElem(IRState *irs);
|
|
|
1304 };
|
|
|
1305
|
|
|
1306 struct RemoveExp : BinExp
|
|
|
1307 {
|
|
|
1308 RemoveExp(Loc loc, Expression *e1, Expression *e2);
|
|
|
1309 elem *toElem(IRState *irs);
|
|
|
1310 };
|
|
|
1311
|
|
|
1312 // == and !=
|
|
|
1313
|
|
|
1314 struct EqualExp : BinExp
|
|
|
1315 {
|
|
|
1316 EqualExp(enum TOK op, Loc loc, Expression *e1, Expression *e2);
|
|
|
1317 Expression *semantic(Scope *sc);
|
|
|
1318 Expression *optimize(int result);
|
|
|
1319 Expression *interpret(InterState *istate);
|
|
|
1320 int isBit();
|
|
|
1321
|
|
|
1322 // For operator overloading
|
|
|
1323 int isCommutative();
|
|
|
1324 Identifier *opId();
|
|
|
1325
|
|
|
1326 elem *toElem(IRState *irs);
|
|
|
1327 };
|
|
|
1328
|
|
|
1329 // === and !===
|
|
|
1330
|
|
|
1331 struct IdentityExp : BinExp
|
|
|
1332 {
|
|
|
1333 IdentityExp(enum TOK op, Loc loc, Expression *e1, Expression *e2);
|
|
|
1334 Expression *semantic(Scope *sc);
|
|
|
1335 int isBit();
|
|
|
1336 Expression *optimize(int result);
|
|
|
1337 Expression *interpret(InterState *istate);
|
|
|
1338 elem *toElem(IRState *irs);
|
|
|
1339 };
|
|
|
1340
|
|
|
1341 /****************************************************************/
|
|
|
1342
|
|
|
1343 struct CondExp : BinExp
|
|
|
1344 {
|
|
|
1345 Expression *econd;
|
|
|
1346
|
|
|
1347 CondExp(Loc loc, Expression *econd, Expression *e1, Expression *e2);
|
|
|
1348 Expression *syntaxCopy();
|
|
|
1349 Expression *semantic(Scope *sc);
|
|
|
1350 Expression *optimize(int result);
|
|
|
1351 Expression *interpret(InterState *istate);
|
|
|
1352 void checkEscape();
|
|
|
1353 Expression *toLvalue(Scope *sc, Expression *e);
|
|
|
1354 Expression *modifiableLvalue(Scope *sc, Expression *e);
|
|
|
1355 Expression *checkToBoolean();
|
|
|
1356 int checkSideEffect(int flag);
|
|
|
1357 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
|
|
|
1358 MATCH implicitConvTo(Type *t);
|
|
|
1359 Expression *castTo(Scope *sc, Type *t);
|
|
|
1360 void scanForNestedRef(Scope *sc);
|
|
|
1361
|
|
|
1362 int inlineCost(InlineCostState *ics);
|
|
|
1363 Expression *doInline(InlineDoState *ids);
|
|
|
1364 Expression *inlineScan(InlineScanState *iss);
|
|
|
1365
|
|
|
1366 elem *toElem(IRState *irs);
|
|
|
1367 };
|
|
|
1368
|
|
|
1369
|
|
|
1370 /****************************************************************/
|
|
|
1371
|
|
|
1372 /* Special values used by the interpreter
|
|
|
1373 */
|
|
|
1374 #define EXP_CANT_INTERPRET ((Expression *)1)
|
|
|
1375 #define EXP_CONTINUE_INTERPRET ((Expression *)2)
|
|
|
1376 #define EXP_BREAK_INTERPRET ((Expression *)3)
|
|
|
1377 #define EXP_GOTO_INTERPRET ((Expression *)4)
|
|
|
1378 #define EXP_VOID_INTERPRET ((Expression *)5)
|
|
|
1379
|
|
|
1380 Expression *expType(Type *type, Expression *e);
|
|
|
1381
|
|
|
1382 Expression *Neg(Type *type, Expression *e1);
|
|
|
1383 Expression *Com(Type *type, Expression *e1);
|
|
|
1384 Expression *Not(Type *type, Expression *e1);
|
|
|
1385 Expression *Bool(Type *type, Expression *e1);
|
|
|
1386 Expression *Cast(Type *type, Type *to, Expression *e1);
|
|
|
1387 Expression *ArrayLength(Type *type, Expression *e1);
|
|
|
1388 Expression *Ptr(Type *type, Expression *e1);
|
|
|
1389
|
|
|
1390 Expression *Add(Type *type, Expression *e1, Expression *e2);
|
|
|
1391 Expression *Min(Type *type, Expression *e1, Expression *e2);
|
|
|
1392 Expression *Mul(Type *type, Expression *e1, Expression *e2);
|
|
|
1393 Expression *Div(Type *type, Expression *e1, Expression *e2);
|
|
|
1394 Expression *Mod(Type *type, Expression *e1, Expression *e2);
|
|
|
1395 Expression *Shl(Type *type, Expression *e1, Expression *e2);
|
|
|
1396 Expression *Shr(Type *type, Expression *e1, Expression *e2);
|
|
|
1397 Expression *Ushr(Type *type, Expression *e1, Expression *e2);
|
|
|
1398 Expression *And(Type *type, Expression *e1, Expression *e2);
|
|
|
1399 Expression *Or(Type *type, Expression *e1, Expression *e2);
|
|
|
1400 Expression *Xor(Type *type, Expression *e1, Expression *e2);
|
|
|
1401 Expression *Index(Type *type, Expression *e1, Expression *e2);
|
|
|
1402 Expression *Cat(Type *type, Expression *e1, Expression *e2);
|
|
|
1403
|
|
|
1404 Expression *Equal(enum TOK op, Type *type, Expression *e1, Expression *e2);
|
|
|
1405 Expression *Cmp(enum TOK op, Type *type, Expression *e1, Expression *e2);
|
|
|
1406 Expression *Identity(enum TOK op, Type *type, Expression *e1, Expression *e2);
|
|
|
1407
|
|
|
1408 Expression *Slice(Type *type, Expression *e1, Expression *lwr, Expression *upr);
|
|
|
1409
|
|
|
1410 #endif /* DMD_EXPRESSION_H */
|
