Mercurial > projects > ldc

diff dmd/expression.h @ 510:6aee82889553

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merged DMD 1.034, array operations are not yet implemented ;)
author Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
date Thu, 14 Aug 2008 06:55:41 +0200
parents 9db9099583ca
children fbb1a366cfbc
line wrap: on
line diff
--- a/dmd/expression.h	Thu Aug 14 03:09:26 2008 +0200
+++ b/dmd/expression.h	Thu Aug 14 06:55:41 2008 +0200
@@ -43,7 +43,7 @@
 struct BinExp;
 struct InterState;
 struct Symbol;		// back end symbol
-
+struct OverloadSet;
 namespace llvm
 {
     class Constant;
@@ -151,6 +151,10 @@
     virtual Identifier *opId();
     virtual Identifier *opId_r();
 
+    // For array ops
+    virtual void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    virtual Expression *buildArrayLoop(Arguments *fparams);
+
     // Back end
     virtual elem *toElem(IRState *irs);
     virtual dt_t **toDt(dt_t **pdt);
@@ -594,6 +598,19 @@
     virtual llvm::Constant *toConstElem(IRState *irs);
 };
 
+#if DMDV2
+// Overload Set
+
+struct OverExp : Expression
+{
+    OverloadSet *vars;
+
+    OverExp(OverloadSet *s);
+    int isLvalue();
+    Expression *toLvalue(Scope *sc, Expression *e);
+};
+#endif
+
 // Function/Delegate literal
 
 struct FuncExp : Expression
@@ -643,6 +660,19 @@
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 };
 
+#if DMDV2
+struct TraitsExp : Expression
+{
+    Identifier *ident;
+    Objects *args;
+
+    TraitsExp(Loc loc, Identifier *ident, Objects *args);
+    Expression *syntaxCopy();
+    Expression *semantic(Scope *sc);
+    void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+};
+#endif
+
 struct HaltExp : Expression
 {
     HaltExp(Loc loc);
@@ -715,6 +745,7 @@
     Expression *interpretCommon(InterState *istate, Expression *(*fp)(Type *, Expression *, Expression *));
     Expression *interpretCommon2(InterState *istate, Expression *(*fp)(TOK, Type *, Expression *, Expression *));
     Expression *interpretAssignCommon(InterState *istate, Expression *(*fp)(Type *, Expression *, Expression *), int post = 0);
+    Expression *arrayOp(Scope *sc);
 
     int inlineCost(InlineCostState *ics);
     Expression *doInline(InlineDoState *ids);
@@ -887,6 +918,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     Identifier *opId();
@@ -909,6 +942,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     Identifier *opId();
@@ -984,6 +1019,8 @@
     void dump(int indent);
     elem *toElem(IRState *irs);
     void scanForNestedRef(Scope *sc);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     int inlineCost(InlineCostState *ics);
     Expression *doInline(InlineDoState *ids);
@@ -1081,6 +1118,8 @@
     Expression *checkToBoolean();
     Expression *interpret(InterState *istate);
     Identifier *opId();    // For operator overloading
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
     elem *toElem(IRState *irs);
 };
 
@@ -1090,25 +1129,33 @@
     op##AssignExp(Loc loc, Expression *e1, Expression *e2);	\
     Expression *semantic(Scope *sc);				\
     Expression *interpret(InterState *istate);			\
+    X(void buildArrayIdent(OutBuffer *buf, Expressions *arguments);) \
+    X(Expression *buildArrayLoop(Arguments *fparams);)		\
 								\
     Identifier *opId();    /* For operator overloading */	\
 								\
     elem *toElem(IRState *irs);					\
 };
 
+#define X(a) a
 ASSIGNEXP(Add)
 ASSIGNEXP(Min)
-ASSIGNEXP(Cat)
 ASSIGNEXP(Mul)
 ASSIGNEXP(Div)
 ASSIGNEXP(Mod)
+ASSIGNEXP(And)
+ASSIGNEXP(Or)
+ASSIGNEXP(Xor)
+#undef X
+
+#define X(a)
+
 ASSIGNEXP(Shl)
 ASSIGNEXP(Shr)
 ASSIGNEXP(Ushr)
-ASSIGNEXP(And)
-ASSIGNEXP(Or)
-ASSIGNEXP(Xor)
+ASSIGNEXP(Cat)
 
+#undef X
 #undef ASSIGNEXP
 
 struct AddExp : BinExp
@@ -1117,6 +1164,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     int isCommutative();
@@ -1135,6 +1184,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     Identifier *opId();
@@ -1163,6 +1214,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     int isCommutative();
@@ -1178,6 +1231,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     Identifier *opId();
@@ -1192,6 +1247,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     Identifier *opId();
@@ -1248,6 +1305,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     int isCommutative();
@@ -1263,6 +1322,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     int isCommutative();
@@ -1278,6 +1339,8 @@
     Expression *semantic(Scope *sc);
     Expression *optimize(int result);
     Expression *interpret(InterState *istate);
+    void buildArrayIdent(OutBuffer *buf, Expressions *arguments);
+    Expression *buildArrayLoop(Arguments *fparams);
 
     // For operator overloading
     int isCommutative();
@@ -1402,6 +1465,32 @@
     elem *toElem(IRState *irs);
 };
 
+#if DMDV2
+/****************************************************************/
+
+struct DefaultInitExp : Expression
+{
+    enum TOK subop;		// which of the derived classes this is
+
+    DefaultInitExp(Loc loc, enum TOK subop, int size);
+    virtual Expression *resolve(Loc loc, Scope *sc) = 0;
+    void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+};
+
+struct FileInitExp : DefaultInitExp
+{
+    FileInitExp(Loc loc);
+    Expression *semantic(Scope *sc);
+    Expression *resolve(Loc loc, Scope *sc);
+};
+
+struct LineInitExp : DefaultInitExp
+{
+    LineInitExp(Loc loc);
+    Expression *semantic(Scope *sc);
+    Expression *resolve(Loc loc, Scope *sc);
+};
+#endif
 
 /****************************************************************/