Mercurial > projects > dang

comparison ast/Expr.d @ 204:227d6a8fb574

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added some random stuff...
author Anders Johnsen <skabet@gmail.com>
date Mon, 11 Aug 2008 21:27:44 +0200
parents 4f94b5adbc8a
children 8387cbaa85ab
comparison
equal deleted inserted replaced
203:28beb8b110ee 204:227d6a8fb574
3 /** 3 /**
4 The base class for all Expressions. 4 The base class for all Expressions.
5 */ 5 */
6 class Expr 6 class Expr
7 { 7 {
8 /// Get the type of the Expr
9 Object getType()
10 {
11 assert(0, "Unimplemented");
12 return null;
13 }
14
15 /// Set the type of the Expr
16 void setType(Object type)
17 {
18 assert(0, "Unimplemented");
19 }
20
8 /// Returns true if the Expr can be compile-time evaluated. 21 /// Returns true if the Expr can be compile-time evaluated.
9 bool isConstantExpr() { return false; } 22 bool isConstantExpr() { return false; }
10 23
11 NumberLiteral asNumberLiteral() { return null; } 24 NumberLiteral asNumberLiteral() { return null; }
12 bool isNumberLiteral() { return false; } 25 bool isNumberLiteral() { return false; }
14 StringLiteral asStringLiteral() { return null; } 27 StringLiteral asStringLiteral() { return null; }
15 bool isStringLiteral() { return false; } 28 bool isStringLiteral() { return false; }
16 29
17 ArrayLiteral asArrayLiteral() { return null; } 30 ArrayLiteral asArrayLiteral() { return null; }
18 bool isArrayLiteral() { return false; } 31 bool isArrayLiteral() { return false; }
32
33 Assign asAssign() { return null; }
34 bool isAssign() { return false; }
35
36 Binary asBinary() { return null; }
37 bool isBinary() { return false; }
38
39 Negate asNegate() { return null; }
40 bool isNegate() { return false; }
41
42 Deref asDeref() { return null; }
43 bool isDeref() { return false; }
44
45 AddressOf asAddressOf() { return null; }
46 bool isAddressOf() { return false; }
47
48 Index asIndex() { return null; }
49 bool isIndex() { return false; }
50
51 Identifier asIdentifier() { return null; }
52 bool isIdentifier() { return false; }
53
54 Member asMember() { return null; }
55 bool isMember() { return false; }
56
57 private:
58 /// FIXME: Add DType? here
19 } 59 }
20 60
21 /** 61 /**
22 NumberLiteral 62 NumberLiteral
23 */ 63 */
64 /// FIXME: Should there be an IntegerLiteral and FloatLiteral instead?
24 class NumberLiteral : Expr 65 class NumberLiteral : Expr
25 { 66 {
26 override bool isConstantExpr() { return true; } 67 override bool isConstantExpr() { return true; }
27 68
28 override NumberLiteral asNumberLiteral() { return this; } 69 override NumberLiteral asNumberLiteral() { return this; }
38 79
39 override StringLiteral asStringLiteral() { return this; } 80 override StringLiteral asStringLiteral() { return this; }
40 override bool isStringLiteral() { return true; } 81 override bool isStringLiteral() { return true; }
41 } 82 }
42 83
43
44 /** 84 /**
45 StringLiteral 85 ArrayLiteral
46 */ 86 */
47 class ArrayLiteral : Expr 87 class ArrayLiteral : Expr
48 { 88 {
89 /// Return the arguments for the ArrayLiteral
90 Expr[] getArguments() { return arguments; }
91
92 /// Return a given argument for the ArrayLiteral
93 Expr getArgument(int index) { return arguments[index]; }
94
95 /// Get the count of arguments for the ArrayLiteral
96 int getArgumentCount() { return arguments.length; }
97
49 override bool isConstantExpr() 98 override bool isConstantExpr()
50 { 99 {
100 /**
101 If all the arguments to the ArrayLiteral is an constant Expr, then
102 this ArrayLiteral can be considered an constant Expr aswell.
103 */
104 // FIXME: consider if it should save the result
51 foreach (arg; arguments) 105 foreach (arg; arguments)
52 if (!arg.isConstantExpr()) 106 if (!arg.isConstantExpr())
53 return false; 107 return false;
54 return true; 108 return true;
55 } 109 }
59 113
60 private: 114 private:
61 Expr[] arguments; 115 Expr[] arguments;
62 } 116 }
63 117
118 /**
119 Assign
120 */
121 class Assign : Expr
122 {
123 override Assign asAssign() { return this; }
124 override bool isAssign() { return true; }
64 125
126 private:
127 Expr left, right;
128 }
129
130 /**
131 Binary
132 */
133 class Binary : Expr
134 {
135 override Binary asBinary() { return this; }
136 override bool isBinary() { return true; }
137
138 private:
139 Expr left, right;
140 }
141
142 /**
143 Negate
144 */
145 class Negate : Expr
146 {
147 override Negate asNegate() { return this; }
148 override bool isNegate() { return true; }
149
150 private:
151 Expr expr;
152 }
153
154 /**
155 Deref
156 */
157 class Deref : Expr
158 {
159 override Deref asDeref() { return this; }
160 override bool isDeref() { return true; }
161 }
162
163 /**
164 AddressOf
165 */
166 class AddressOf : Expr
167 {
168 override AddressOf asAddressOf() { return this; }
169 override bool isAddressOf() { return true; }
170 }
171
172 /**
173 Index
174 */
175 class Index : Expr
176 {
177 override Index asIndex() { return this; }
178 override bool isIndex() { return true; }
179 }
65 180
66 /** 181 /**
67 Identifier 182 Identifier
68 */ 183 */
69 class Identifier : Expr 184 class Identifier : Expr
70 { 185 {
186 override Identifier asIdentifier() { return this; }
187 override bool isIdentifier() { return true; }
188 }
71 189
190 /**
191 Member
192 */
193 class Member : Expr
194 {
195 override Member asMember() { return this; }
196 override bool isMember() { return true; }
72 } 197 }
198