Mercurial > projects > ldc

comparison dmd/expression.h @ 1607:207a8a438dea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge DMD r253: refactor: Argument => Parameter --- dmd/arrayop.c | 30 ++++---- dmd/arraytypes.h | 2 +- dmd/class.c | 8 +- dmd/declaration.c | 10 ++-- dmd/declaration.h | 16 ++-- dmd/doc.c | 12 ++-- dmd/dsymbol.c | 4 +- dmd/expression.c | 48 +++++++------- dmd/expression.h | 32 +++++----- dmd/func.c | 78 +++++++++++----------- dmd/init.c | 2 +- dmd/interpret.c | 8 +- dmd/mtype.c | 190 ++++++++++++++++++++++++++-------------------------- dmd/mtype.h | 32 +++++----- dmd/opover.c | 34 +++++----- dmd/parse.c | 40 ++++++------ dmd/parse.h | 2 +- dmd/statement.c | 90 +++++++++++++------------- dmd/statement.h | 14 ++-- dmd/struct.c | 8 +- dmd/template.c | 30 ++++---- gen/functions.cpp | 10 ++-- gen/functions.h | 2 +- gen/tocall.cpp | 10 ++-- gen/typinf.cpp | 6 +- 25 files changed, 359 insertions(+), 359 deletions(-)
author Leandro Lucarella <llucax@gmail.com>
date Wed, 06 Jan 2010 15:18:20 -0300
parents def7a1d494fd
children 3da302cc4966
comparison
equal deleted inserted replaced
1606:1b24e9c7cc26 1607:207a8a438dea
71 void initPrecedence(); 71 void initPrecedence();
72 72
73 Expression *resolveProperties(Scope *sc, Expression *e); 73 Expression *resolveProperties(Scope *sc, Expression *e);
74 void accessCheck(Loc loc, Scope *sc, Expression *e, Declaration *d); 74 void accessCheck(Loc loc, Scope *sc, Expression *e, Declaration *d);
75 Dsymbol *search_function(AggregateDeclaration *ad, Identifier *funcid); 75 Dsymbol *search_function(AggregateDeclaration *ad, Identifier *funcid);
76 void inferApplyArgTypes(enum TOK op, Arguments *arguments, Expression *aggr, Module* from); 76 void inferApplyArgTypes(enum TOK op, Parameters *arguments, Expression *aggr, Module* from);
77 void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs); 77 void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs);
78 void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs); 78 void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs);
79 void expandTuples(Expressions *exps); 79 void expandTuples(Expressions *exps);
80 FuncDeclaration *hasThis(Scope *sc); 80 FuncDeclaration *hasThis(Scope *sc);
81 Expression *fromConstInitializer(int result, Expression *e); 81 Expression *fromConstInitializer(int result, Expression *e);
159 virtual Identifier *opId(); 159 virtual Identifier *opId();
160 virtual Identifier *opId_r(); 160 virtual Identifier *opId_r();
161 161
162 // For array ops 162 // For array ops
163 virtual void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 163 virtual void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
164 virtual Expression *buildArrayLoop(Arguments *fparams); 164 virtual Expression *buildArrayLoop(Parameters *fparams);
165 int isArrayOperand(); 165 int isArrayOperand();
166 166
167 #if IN_DMD 167 #if IN_DMD
168 // Back end 168 // Back end
169 virtual elem *toElem(IRState *irs); 169 virtual elem *toElem(IRState *irs);
1088 NegExp(Loc loc, Expression *e); 1088 NegExp(Loc loc, Expression *e);
1089 Expression *semantic(Scope *sc); 1089 Expression *semantic(Scope *sc);
1090 Expression *optimize(int result); 1090 Expression *optimize(int result);
1091 Expression *interpret(InterState *istate); 1091 Expression *interpret(InterState *istate);
1092 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1092 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1093 Expression *buildArrayLoop(Arguments *fparams); 1093 Expression *buildArrayLoop(Parameters *fparams);
1094 1094
1095 // For operator overloading 1095 // For operator overloading
1096 Identifier *opId(); 1096 Identifier *opId();
1097 1097
1098 #if IN_DMD 1098 #if IN_DMD
1118 ComExp(Loc loc, Expression *e); 1118 ComExp(Loc loc, Expression *e);
1119 Expression *semantic(Scope *sc); 1119 Expression *semantic(Scope *sc);
1120 Expression *optimize(int result); 1120 Expression *optimize(int result);
1121 Expression *interpret(InterState *istate); 1121 Expression *interpret(InterState *istate);
1122 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1122 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1123 Expression *buildArrayLoop(Arguments *fparams); 1123 Expression *buildArrayLoop(Parameters *fparams);
1124 1124
1125 // For operator overloading 1125 // For operator overloading
1126 Identifier *opId(); 1126 Identifier *opId();
1127 1127
1128 #if IN_DMD 1128 #if IN_DMD
1194 Expression *interpret(InterState *istate); 1194 Expression *interpret(InterState *istate);
1195 int checkSideEffect(int flag); 1195 int checkSideEffect(int flag);
1196 void checkEscape(); 1196 void checkEscape();
1197 void toCBuffer(OutBuffer *buf, HdrGenState *hgs); 1197 void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
1198 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1198 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1199 Expression *buildArrayLoop(Arguments *fparams); 1199 Expression *buildArrayLoop(Parameters *fparams);
1200 #if IN_DMD 1200 #if IN_DMD
1201 elem *toElem(IRState *irs); 1201 elem *toElem(IRState *irs);
1202 #endif 1202 #endif
1203 1203
1204 // For operator overloading 1204 // For operator overloading
1230 #if IN_DMD 1230 #if IN_DMD
1231 elem *toElem(IRState *irs); 1231 elem *toElem(IRState *irs);
1232 #endif 1232 #endif
1233 void scanForNestedRef(Scope *sc); 1233 void scanForNestedRef(Scope *sc);
1234 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1234 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1235 Expression *buildArrayLoop(Arguments *fparams); 1235 Expression *buildArrayLoop(Parameters *fparams);
1236 1236
1237 int inlineCost(InlineCostState *ics); 1237 int inlineCost(InlineCostState *ics);
1238 Expression *doInline(InlineDoState *ids); 1238 Expression *doInline(InlineDoState *ids);
1239 Expression *inlineScan(InlineScanState *iss); 1239 Expression *inlineScan(InlineScanState *iss);
1240 1240
1358 Expression *semantic(Scope *sc); 1358 Expression *semantic(Scope *sc);
1359 Expression *checkToBoolean(); 1359 Expression *checkToBoolean();
1360 Expression *interpret(InterState *istate); 1360 Expression *interpret(InterState *istate);
1361 Identifier *opId(); // For operator overloading 1361 Identifier *opId(); // For operator overloading
1362 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1362 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1363 Expression *buildArrayLoop(Arguments *fparams); 1363 Expression *buildArrayLoop(Parameters *fparams);
1364 #if IN_DMD 1364 #if IN_DMD
1365 elem *toElem(IRState *irs); 1365 elem *toElem(IRState *irs);
1366 #endif 1366 #endif
1367 1367
1368 #if IN_LLVM 1368 #if IN_LLVM
1383 { \ 1383 { \
1384 op##AssignExp(Loc loc, Expression *e1, Expression *e2); \ 1384 op##AssignExp(Loc loc, Expression *e1, Expression *e2); \
1385 Expression *semantic(Scope *sc); \ 1385 Expression *semantic(Scope *sc); \
1386 Expression *interpret(InterState *istate); \ 1386 Expression *interpret(InterState *istate); \
1387 X(void buildArrayIdent(OutBuffer *buf, Expressions *arguments);) \ 1387 X(void buildArrayIdent(OutBuffer *buf, Expressions *arguments);) \
1388 X(Expression *buildArrayLoop(Arguments *fparams);) \ 1388 X(Expression *buildArrayLoop(Parameters *fparams);) \
1389 \ 1389 \
1390 Identifier *opId(); /* For operator overloading */ \ 1390 Identifier *opId(); /* For operator overloading */ \
1391 \ 1391 \
1392 ASSIGNEXP_TOELEM \ 1392 ASSIGNEXP_TOELEM \
1393 }; 1393 };
1419 AddExp(Loc loc, Expression *e1, Expression *e2); 1419 AddExp(Loc loc, Expression *e1, Expression *e2);
1420 Expression *semantic(Scope *sc); 1420 Expression *semantic(Scope *sc);
1421 Expression *optimize(int result); 1421 Expression *optimize(int result);
1422 Expression *interpret(InterState *istate); 1422 Expression *interpret(InterState *istate);
1423 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1423 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1424 Expression *buildArrayLoop(Arguments *fparams); 1424 Expression *buildArrayLoop(Parameters *fparams);
1425 1425
1426 // For operator overloading 1426 // For operator overloading
1427 int isCommutative(); 1427 int isCommutative();
1428 Identifier *opId(); 1428 Identifier *opId();
1429 Identifier *opId_r(); 1429 Identifier *opId_r();
1442 MinExp(Loc loc, Expression *e1, Expression *e2); 1442 MinExp(Loc loc, Expression *e1, Expression *e2);
1443 Expression *semantic(Scope *sc); 1443 Expression *semantic(Scope *sc);
1444 Expression *optimize(int result); 1444 Expression *optimize(int result);
1445 Expression *interpret(InterState *istate); 1445 Expression *interpret(InterState *istate);
1446 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1446 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1447 Expression *buildArrayLoop(Arguments *fparams); 1447 Expression *buildArrayLoop(Parameters *fparams);
1448 1448
1449 // For operator overloading 1449 // For operator overloading
1450 Identifier *opId(); 1450 Identifier *opId();
1451 Identifier *opId_r(); 1451 Identifier *opId_r();
1452 1452
1484 MulExp(Loc loc, Expression *e1, Expression *e2); 1484 MulExp(Loc loc, Expression *e1, Expression *e2);
1485 Expression *semantic(Scope *sc); 1485 Expression *semantic(Scope *sc);
1486 Expression *optimize(int result); 1486 Expression *optimize(int result);
1487 Expression *interpret(InterState *istate); 1487 Expression *interpret(InterState *istate);
1488 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1488 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1489 Expression *buildArrayLoop(Arguments *fparams); 1489 Expression *buildArrayLoop(Parameters *fparams);
1490 1490
1491 // For operator overloading 1491 // For operator overloading
1492 int isCommutative(); 1492 int isCommutative();
1493 Identifier *opId(); 1493 Identifier *opId();
1494 Identifier *opId_r(); 1494 Identifier *opId_r();
1507 DivExp(Loc loc, Expression *e1, Expression *e2); 1507 DivExp(Loc loc, Expression *e1, Expression *e2);
1508 Expression *semantic(Scope *sc); 1508 Expression *semantic(Scope *sc);
1509 Expression *optimize(int result); 1509 Expression *optimize(int result);
1510 Expression *interpret(InterState *istate); 1510 Expression *interpret(InterState *istate);
1511 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1511 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1512 Expression *buildArrayLoop(Arguments *fparams); 1512 Expression *buildArrayLoop(Parameters *fparams);
1513 1513
1514 // For operator overloading 1514 // For operator overloading
1515 Identifier *opId(); 1515 Identifier *opId();
1516 Identifier *opId_r(); 1516 Identifier *opId_r();
1517 1517
1529 ModExp(Loc loc, Expression *e1, Expression *e2); 1529 ModExp(Loc loc, Expression *e1, Expression *e2);
1530 Expression *semantic(Scope *sc); 1530 Expression *semantic(Scope *sc);
1531 Expression *optimize(int result); 1531 Expression *optimize(int result);
1532 Expression *interpret(InterState *istate); 1532 Expression *interpret(InterState *istate);
1533 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1533 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1534 Expression *buildArrayLoop(Arguments *fparams); 1534 Expression *buildArrayLoop(Parameters *fparams);
1535 1535
1536 // For operator overloading 1536 // For operator overloading
1537 Identifier *opId(); 1537 Identifier *opId();
1538 Identifier *opId_r(); 1538 Identifier *opId_r();
1539 1539
1611 AndExp(Loc loc, Expression *e1, Expression *e2); 1611 AndExp(Loc loc, Expression *e1, Expression *e2);
1612 Expression *semantic(Scope *sc); 1612 Expression *semantic(Scope *sc);
1613 Expression *optimize(int result); 1613 Expression *optimize(int result);
1614 Expression *interpret(InterState *istate); 1614 Expression *interpret(InterState *istate);
1615 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1615 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1616 Expression *buildArrayLoop(Arguments *fparams); 1616 Expression *buildArrayLoop(Parameters *fparams);
1617 1617
1618 // For operator overloading 1618 // For operator overloading
1619 int isCommutative(); 1619 int isCommutative();
1620 Identifier *opId(); 1620 Identifier *opId();
1621 Identifier *opId_r(); 1621 Identifier *opId_r();
1634 OrExp(Loc loc, Expression *e1, Expression *e2); 1634 OrExp(Loc loc, Expression *e1, Expression *e2);
1635 Expression *semantic(Scope *sc); 1635 Expression *semantic(Scope *sc);
1636 Expression *optimize(int result); 1636 Expression *optimize(int result);
1637 Expression *interpret(InterState *istate); 1637 Expression *interpret(InterState *istate);
1638 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1638 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1639 Expression *buildArrayLoop(Arguments *fparams); 1639 Expression *buildArrayLoop(Parameters *fparams);
1640 1640
1641 // For operator overloading 1641 // For operator overloading
1642 int isCommutative(); 1642 int isCommutative();
1643 Identifier *opId(); 1643 Identifier *opId();
1644 Identifier *opId_r(); 1644 Identifier *opId_r();
1657 XorExp(Loc loc, Expression *e1, Expression *e2); 1657 XorExp(Loc loc, Expression *e1, Expression *e2);
1658 Expression *semantic(Scope *sc); 1658 Expression *semantic(Scope *sc);
1659 Expression *optimize(int result); 1659 Expression *optimize(int result);
1660 Expression *interpret(InterState *istate); 1660 Expression *interpret(InterState *istate);
1661 void buildArrayIdent(OutBuffer *buf, Expressions *arguments); 1661 void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
1662 Expression *buildArrayLoop(Arguments *fparams); 1662 Expression *buildArrayLoop(Parameters *fparams);
1663 1663
1664 // For operator overloading 1664 // For operator overloading
1665 int isCommutative(); 1665 int isCommutative();
1666 Identifier *opId(); 1666 Identifier *opId();
1667 Identifier *opId_r(); 1667 Identifier *opId_r();