Mercurial > projects > ddmd

comparison dmd/CondExp.d @ 72:2e2a5c3f943a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
reduced warnings by adding override to the methods think this also normalizes different line endings used all over the place
author Trass3r
date Sat, 28 Aug 2010 16:19:48 +0200
parents 4290d870944a
children e28b18c23469
comparison
equal deleted inserted replaced
71:8e24ef1dd139 72:2e2a5c3f943a
36 { 36 {
37 super(loc, TOK.TOKquestion, CondExp.sizeof, e1, e2); 37 super(loc, TOK.TOKquestion, CondExp.sizeof, e1, e2);
38 this.econd = econd; 38 this.econd = econd;
39 } 39 }
40 40
41 Expression syntaxCopy() 41 override Expression syntaxCopy()
42 { 42 {
43 return new CondExp(loc, econd.syntaxCopy(), e1.syntaxCopy(), e2.syntaxCopy()); 43 return new CondExp(loc, econd.syntaxCopy(), e1.syntaxCopy(), e2.syntaxCopy());
44 } 44 }
45 45
46 Expression semantic(Scope sc) 46 override Expression semantic(Scope sc)
47 { 47 {
48 Type t1; 48 Type t1;
49 Type t2; 49 Type t2;
50 uint cs0; 50 uint cs0;
51 uint cs1; 51 uint cs1;
136 printf("e2 : %s\n", e2.type.toChars()); 136 printf("e2 : %s\n", e2.type.toChars());
137 } 137 }
138 return this; 138 return this;
139 } 139 }
140 140
141 Expression optimize(int result) 141 override Expression optimize(int result)
142 { 142 {
143 Expression e; 143 Expression e;
144 144
145 econd = econd.optimize(WANTflags | (result & WANTinterpret)); 145 econd = econd.optimize(WANTflags | (result & WANTinterpret));
146 if (econd.isBool(true)) 146 if (econd.isBool(true))
155 } 155 }
156 156
157 return e; 157 return e;
158 } 158 }
159 159
160 Expression interpret(InterState istate) 160 override Expression interpret(InterState istate)
161 { 161 {
162 assert(false); 162 assert(false);
163 } 163 }
164 164
165 void checkEscape() 165 override void checkEscape()
166 { 166 {
167 e1.checkEscape(); 167 e1.checkEscape();
168 e2.checkEscape(); 168 e2.checkEscape();
169 } 169 }
170 170
171 int isLvalue() 171 override int isLvalue()
172 { 172 {
173 assert(false); 173 assert(false);
174 } 174 }
175 175
176 Expression toLvalue(Scope sc, Expression e) 176 override Expression toLvalue(Scope sc, Expression e)
177 { 177 {
178 assert(false); 178 assert(false);
179 } 179 }
180 180
181 Expression modifiableLvalue(Scope sc, Expression e) 181 override Expression modifiableLvalue(Scope sc, Expression e)
182 { 182 {
183 assert(false); 183 assert(false);
184 } 184 }
185 185
186 Expression checkToBoolean() 186 override Expression checkToBoolean()
187 { 187 {
188 assert(false); 188 assert(false);
189 } 189 }
190 190
191 bool checkSideEffect(int flag) 191 override bool checkSideEffect(int flag)
192 { 192 {
193 if (flag == 2) 193 if (flag == 2)
194 { 194 {
195 return econd.checkSideEffect(2) || e1.checkSideEffect(2) || e2.checkSideEffect(2); 195 return econd.checkSideEffect(2) || e1.checkSideEffect(2) || e2.checkSideEffect(2);
196 } 196 }
200 e1.checkSideEffect(flag); 200 e1.checkSideEffect(flag);
201 return e2.checkSideEffect(flag); 201 return e2.checkSideEffect(flag);
202 } 202 }
203 } 203 }
204 204
205 void toCBuffer(OutBuffer buf, HdrGenState* hgs) 205 override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
206 { 206 {
207 expToCBuffer(buf, hgs, econd, PREC_oror); 207 expToCBuffer(buf, hgs, econd, PREC_oror);
208 buf.writestring(" ? "); 208 buf.writestring(" ? ");
209 expToCBuffer(buf, hgs, e1, PREC_expr); 209 expToCBuffer(buf, hgs, e1, PREC_expr);
210 buf.writestring(" : "); 210 buf.writestring(" : ");
211 expToCBuffer(buf, hgs, e2, PREC_cond); 211 expToCBuffer(buf, hgs, e2, PREC_cond);
212 } 212 }
213 213
214 MATCH implicitConvTo(Type t) 214 override MATCH implicitConvTo(Type t)
215 { 215 {
216 MATCH m1 = e1.implicitConvTo(t); 216 MATCH m1 = e1.implicitConvTo(t);
217 MATCH m2 = e2.implicitConvTo(t); 217 MATCH m2 = e2.implicitConvTo(t);
218 //printf("CondExp: m1 %d m2 %d\n", m1, m2); 218 //printf("CondExp: m1 %d m2 %d\n", m1, m2);
219 219
220 // Pick the worst match 220 // Pick the worst match
221 return (m1 < m2) ? m1 : m2; 221 return (m1 < m2) ? m1 : m2;
222 } 222 }
223 223
224 Expression castTo(Scope sc, Type t) 224 override Expression castTo(Scope sc, Type t)
225 { 225 {
226 Expression e = this; 226 Expression e = this;
227 227
228 if (type !is t) 228 if (type !is t)
229 { 229 {
236 e = Expression.castTo(sc, t); 236 e = Expression.castTo(sc, t);
237 } 237 }
238 return e; 238 return e;
239 } 239 }
240 240
241 void scanForNestedRef(Scope sc) 241 override void scanForNestedRef(Scope sc)
242 { 242 {
243 assert(false); 243 assert(false);
244 } 244 }
245 245
246 bool canThrow() 246 override bool canThrow()
247 { 247 {
248 return econd.canThrow() || e1.canThrow() || e2.canThrow(); 248 return econd.canThrow() || e1.canThrow() || e2.canThrow();
249 } 249 }
250 250
251 int inlineCost(InlineCostState* ics) 251 override int inlineCost(InlineCostState* ics)
252 { 252 {
253 return 1 + e1.inlineCost(ics) + e2.inlineCost(ics) + econd.inlineCost(ics); 253 return 1 + e1.inlineCost(ics) + e2.inlineCost(ics) + econd.inlineCost(ics);
254 } 254 }
255 255
256 Expression doInline(InlineDoState ids) 256 override Expression doInline(InlineDoState ids)
257 { 257 {
258 CondExp ce = cast(CondExp)copy(); 258 CondExp ce = cast(CondExp)copy();
259 259
260 ce.econd = econd.doInline(ids); 260 ce.econd = econd.doInline(ids);
261 ce.e1 = e1.doInline(ids); 261 ce.e1 = e1.doInline(ids);
262 ce.e2 = e2.doInline(ids); 262 ce.e2 = e2.doInline(ids);
263 return ce; 263 return ce;
264 } 264 }
265 265
266 Expression inlineScan(InlineScanState* iss) 266 override Expression inlineScan(InlineScanState* iss)
267 { 267 {
268 econd = econd.inlineScan(iss); 268 econd = econd.inlineScan(iss);
269 e1 = e1.inlineScan(iss); 269 e1 = e1.inlineScan(iss);
270 e2 = e2.inlineScan(iss); 270 e2 = e2.inlineScan(iss);
271 return this; 271 return this;
272 } 272 }
273 273
274 elem* toElem(IRState* irs) 274 override elem* toElem(IRState* irs)
275 { 275 {
276 elem* eleft; 276 elem* eleft;
277 elem* eright; 277 elem* eright;
278 278
279 elem* ec = econd.toElem(irs); 279 elem* ec = econd.toElem(irs);