Context Navigation

source: stable/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/Parser/mcs/cfold.cs @ 11937

Visit:

Last change on this file since 11937 was 11700, checked in by jkarder, 10 years ago
#2077: created branch and added first version
File size: 38.0 KB

Line
1	//
2	// cfold.cs: Constant Folding
3	//
4	// Author:
5	// Miguel de Icaza (miguel@ximian.com)
6	// Marek Safar (marek.safar@seznam.cz)
7	//
8	// Copyright 2002, 2003 Ximian, Inc.
9	// Copyright 2003-2011, Novell, Inc.
10	//
11	using System;
12
13	namespace Mono.CSharp {
14
15	public static class ConstantFold
16	{
17	public static TypeSpec[] CreateBinaryPromotionsTypes (BuiltinTypes types)
18	{
19	return new TypeSpec[] {
20	types.Decimal, types.Double, types.Float,
21	types.ULong, types.Long, types.UInt
22	};
23	}
24
25	//
26	// Performs the numeric promotions on the left and right expresions
27	// and deposits the results on `lc' and `rc'.
28	//
29	// On success, the types of `lc' and `rc' on output will always match,
30	// and the pair will be one of:
31	//
32	// TODO: BinaryFold should be called as an optimization step only,
33	// error checking here is weak
34	//
35	static bool DoBinaryNumericPromotions (ResolveContext rc, ref Constant left, ref Constant right)
36	{
37	TypeSpec ltype = left.Type;
38	TypeSpec rtype = right.Type;
39
40	foreach (TypeSpec t in rc.BuiltinTypes.BinaryPromotionsTypes) {
41	if (t == ltype)
42	return t == rtype \|\| ConvertPromotion (rc, ref right, ref left, t);
43
44	if (t == rtype)
45	return t == ltype \|\| ConvertPromotion (rc, ref left, ref right, t);
46	}
47
48	left = left.ConvertImplicitly (rc.BuiltinTypes.Int);
49	right = right.ConvertImplicitly (rc.BuiltinTypes.Int);
50	return left != null && right != null;
51	}
52
53	static bool ConvertPromotion (ResolveContext rc, ref Constant prim, ref Constant second, TypeSpec type)
54	{
55	Constant c = prim.ConvertImplicitly (type);
56	if (c != null) {
57	prim = c;
58	return true;
59	}
60
61	if (type.BuiltinType == BuiltinTypeSpec.Type.UInt) {
62	type = rc.BuiltinTypes.Long;
63	prim = prim.ConvertImplicitly (type);
64	second = second.ConvertImplicitly (type);
65	return prim != null && second != null;
66	}
67
68	return false;
69	}
70
71	internal static void Error_CompileTimeOverflow (ResolveContext rc, Location loc)
72	{
73	rc.Report.Error (220, loc, "The operation overflows at compile time in checked mode");
74	}
75
76	/// <summary>
77	/// Constant expression folder for binary operations.
78	///
79	/// Returns null if the expression can not be folded.
80	/// </summary>
81	static public Constant BinaryFold (ResolveContext ec, Binary.Operator oper,
82	Constant left, Constant right, Location loc)
83	{
84	Constant result = null;
85
86	if (left is EmptyConstantCast)
87	return BinaryFold (ec, oper, ((EmptyConstantCast)left).child, right, loc);
88
89	if (left is SideEffectConstant) {
90	result = BinaryFold (ec, oper, ((SideEffectConstant) left).value, right, loc);
91	if (result == null)
92	return null;
93	return new SideEffectConstant (result, left, loc);
94	}
95
96	if (right is EmptyConstantCast)
97	return BinaryFold (ec, oper, left, ((EmptyConstantCast)right).child, loc);
98
99	if (right is SideEffectConstant) {
100	result = BinaryFold (ec, oper, left, ((SideEffectConstant) right).value, loc);
101	if (result == null)
102	return null;
103	return new SideEffectConstant (result, right, loc);
104	}
105
106	TypeSpec lt = left.Type;
107	TypeSpec rt = right.Type;
108	bool bool_res;
109
110	if (lt.BuiltinType == BuiltinTypeSpec.Type.Bool && lt == rt) {
111	bool lv = (bool) left.GetValue ();
112	bool rv = (bool) right.GetValue ();
113	switch (oper) {
114	case Binary.Operator.BitwiseAnd:
115	case Binary.Operator.LogicalAnd:
116	return new BoolConstant (ec.BuiltinTypes, lv && rv, left.Location);
117	case Binary.Operator.BitwiseOr:
118	case Binary.Operator.LogicalOr:
119	return new BoolConstant (ec.BuiltinTypes, lv \|\| rv, left.Location);
120	case Binary.Operator.ExclusiveOr:
121	return new BoolConstant (ec.BuiltinTypes, lv ^ rv, left.Location);
122	case Binary.Operator.Equality:
123	return new BoolConstant (ec.BuiltinTypes, lv == rv, left.Location);
124	case Binary.Operator.Inequality:
125	return new BoolConstant (ec.BuiltinTypes, lv != rv, left.Location);
126	}
127	return null;
128	}
129
130	//
131	// During an enum evaluation, none of the rules are valid
132	// Not sure whether it is bug in csc or in documentation
133	//
134	if (ec.HasSet (ResolveContext.Options.EnumScope)){
135	if (left is EnumConstant)
136	left = ((EnumConstant) left).Child;
137
138	if (right is EnumConstant)
139	right = ((EnumConstant) right).Child;
140	} else if (left is EnumConstant && rt == lt) {
141	switch (oper){
142	///
143	/// E operator \|(E x, E y);
144	/// E operator &(E x, E y);
145	/// E operator ^(E x, E y);
146	///
147	case Binary.Operator.BitwiseOr:
148	case Binary.Operator.BitwiseAnd:
149	case Binary.Operator.ExclusiveOr:
150	result = BinaryFold (ec, oper, ((EnumConstant)left).Child, ((EnumConstant)right).Child, loc);
151	if (result != null)
152	result = result.Reduce (ec, lt);
153	return result;
154
155	///
156	/// U operator -(E x, E y);
157	///
158	case Binary.Operator.Subtraction:
159	result = BinaryFold (ec, oper, ((EnumConstant)left).Child, ((EnumConstant)right).Child, loc);
160	if (result != null)
161	result = result.Reduce (ec, EnumSpec.GetUnderlyingType (lt));
162	return result;
163
164	///
165	/// bool operator ==(E x, E y);
166	/// bool operator !=(E x, E y);
167	/// bool operator <(E x, E y);
168	/// bool operator >(E x, E y);
169	/// bool operator <=(E x, E y);
170	/// bool operator >=(E x, E y);
171	///
172	case Binary.Operator.Equality:
173	case Binary.Operator.Inequality:
174	case Binary.Operator.LessThan:
175	case Binary.Operator.GreaterThan:
176	case Binary.Operator.LessThanOrEqual:
177	case Binary.Operator.GreaterThanOrEqual:
178	return BinaryFold(ec, oper, ((EnumConstant)left).Child, ((EnumConstant)right).Child, loc);
179	}
180	return null;
181	}
182
183	switch (oper){
184	case Binary.Operator.BitwiseOr:
185	//
186	// bool? operator \|(bool? x, bool? y);
187	//
188	if ((lt.BuiltinType == BuiltinTypeSpec.Type.Bool && right is NullLiteral) \|\|
189	(rt.BuiltinType == BuiltinTypeSpec.Type.Bool && left is NullLiteral)) {
190	var b = new Binary (oper, left, right).ResolveOperator (ec);
191
192	// false \| null => null
193	// null \| false => null
194	if ((right is NullLiteral && left.IsDefaultValue) \|\| (left is NullLiteral && right.IsDefaultValue))
195	return Nullable.LiftedNull.CreateFromExpression (ec, b);
196
197	// true \| null => true
198	// null \| true => true
199	return ReducedExpression.Create (new BoolConstant (ec.BuiltinTypes, true, loc), b);
200	}
201
202	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
203	return null;
204
205	if (left is IntConstant){
206	int res = ((IntConstant) left).Value \| ((IntConstant) right).Value;
207
208	return new IntConstant (ec.BuiltinTypes, res, left.Location);
209	}
210	if (left is UIntConstant){
211	uint res = ((UIntConstant)left).Value \| ((UIntConstant)right).Value;
212
213	return new UIntConstant (ec.BuiltinTypes, res, left.Location);
214	}
215	if (left is LongConstant){
216	long res = ((LongConstant)left).Value \| ((LongConstant)right).Value;
217
218	return new LongConstant (ec.BuiltinTypes, res, left.Location);
219	}
220	if (left is ULongConstant){
221	ulong res = ((ULongConstant)left).Value \|
222	((ULongConstant)right).Value;
223
224	return new ULongConstant (ec.BuiltinTypes, res, left.Location);
225	}
226	break;
227
228	case Binary.Operator.BitwiseAnd:
229	//
230	// bool? operator &(bool? x, bool? y);
231	//
232	if ((lt.BuiltinType == BuiltinTypeSpec.Type.Bool && right is NullLiteral) \|\|
233	(rt.BuiltinType == BuiltinTypeSpec.Type.Bool && left is NullLiteral)) {
234	var b = new Binary (oper, left, right).ResolveOperator (ec);
235
236	// false & null => false
237	// null & false => false
238	if ((right is NullLiteral && left.IsDefaultValue) \|\| (left is NullLiteral && right.IsDefaultValue))
239	return ReducedExpression.Create (new BoolConstant (ec.BuiltinTypes, false, loc), b);
240
241	// true & null => null
242	// null & true => null
243	return Nullable.LiftedNull.CreateFromExpression (ec, b);
244	}
245
246	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
247	return null;
248
249	///
250	/// int operator &(int x, int y);
251	/// uint operator &(uint x, uint y);
252	/// long operator &(long x, long y);
253	/// ulong operator &(ulong x, ulong y);
254	///
255	if (left is IntConstant){
256	int res = ((IntConstant) left).Value & ((IntConstant) right).Value;
257	return new IntConstant (ec.BuiltinTypes, res, left.Location);
258	}
259	if (left is UIntConstant){
260	uint res = ((UIntConstant)left).Value & ((UIntConstant)right).Value;
261	return new UIntConstant (ec.BuiltinTypes, res, left.Location);
262	}
263	if (left is LongConstant){
264	long res = ((LongConstant)left).Value & ((LongConstant)right).Value;
265	return new LongConstant (ec.BuiltinTypes, res, left.Location);
266	}
267	if (left is ULongConstant){
268	ulong res = ((ULongConstant)left).Value &
269	((ULongConstant)right).Value;
270
271	return new ULongConstant (ec.BuiltinTypes, res, left.Location);
272	}
273	break;
274
275	case Binary.Operator.ExclusiveOr:
276	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
277	return null;
278
279	if (left is IntConstant){
280	int res = ((IntConstant) left).Value ^ ((IntConstant) right).Value;
281	return new IntConstant (ec.BuiltinTypes, res, left.Location);
282	}
283	if (left is UIntConstant){
284	uint res = ((UIntConstant)left).Value ^ ((UIntConstant)right).Value;
285
286	return new UIntConstant (ec.BuiltinTypes, res, left.Location);
287	}
288	if (left is LongConstant){
289	long res = ((LongConstant)left).Value ^ ((LongConstant)right).Value;
290
291	return new LongConstant (ec.BuiltinTypes, res, left.Location);
292	}
293	if (left is ULongConstant){
294	ulong res = ((ULongConstant)left).Value ^
295	((ULongConstant)right).Value;
296
297	return new ULongConstant (ec.BuiltinTypes, res, left.Location);
298	}
299	break;
300
301	case Binary.Operator.Addition:
302	//
303	// If both sides are strings, then concatenate
304	//
305	// string operator + (string x, string y)
306	//
307	if (lt.BuiltinType == BuiltinTypeSpec.Type.String \|\| rt.BuiltinType == BuiltinTypeSpec.Type.String){
308	if (lt == rt)
309	return new StringConstant (ec.BuiltinTypes, (string)left.GetValue () + (string)right.GetValue (),
310	left.Location);
311
312	if (lt == InternalType.NullLiteral \|\| left.IsNull)
313	return new StringConstant (ec.BuiltinTypes, "" + right.GetValue (), left.Location);
314
315	if (rt == InternalType.NullLiteral \|\| right.IsNull)
316	return new StringConstant (ec.BuiltinTypes, left.GetValue () + "", left.Location);
317
318	return null;
319	}
320
321	//
322	// string operator + (string x, object y)
323	//
324	if (lt == InternalType.NullLiteral) {
325	if (rt.BuiltinType == BuiltinTypeSpec.Type.Object)
326	return new StringConstant (ec.BuiltinTypes, "" + right.GetValue (), left.Location);
327
328	if (lt == rt) {
329	ec.Report.Error (34, loc, "Operator `{0}' is ambiguous on operands of type `{1}' and `{2}'",
330	"+", lt.GetSignatureForError (), rt.GetSignatureForError ());
331	return null;
332	}
333
334	return right;
335	}
336
337	//
338	// string operator + (object x, string y)
339	//
340	if (rt == InternalType.NullLiteral) {
341	if (lt.BuiltinType == BuiltinTypeSpec.Type.Object)
342	return new StringConstant (ec.BuiltinTypes, right.GetValue () + "", left.Location);
343
344	return left;
345	}
346
347	//
348	// handle "E operator + (E x, U y)"
349	// handle "E operator + (Y y, E x)"
350	//
351	EnumConstant lc = left as EnumConstant;
352	EnumConstant rc = right as EnumConstant;
353	if (lc != null \|\| rc != null){
354	if (lc == null) {
355	lc = rc;
356	lt = lc.Type;
357	right = left;
358	}
359
360	// U has to be implicitly convetible to E.base
361	right = right.ConvertImplicitly (lc.Child.Type);
362	if (right == null)
363	return null;
364
365	result = BinaryFold (ec, oper, lc.Child, right, loc);
366	if (result == null)
367	return null;
368
369	result = result.Reduce (ec, lt);
370	if (result == null \|\| lt.IsEnum)
371	return result;
372
373	return new EnumConstant (result, lt);
374	}
375
376	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
377	return null;
378
379	try {
380	if (left is DoubleConstant){
381	double res;
382
383	if (ec.ConstantCheckState)
384	res = checked (((DoubleConstant) left).Value +
385	((DoubleConstant) right).Value);
386	else
387	res = unchecked (((DoubleConstant) left).Value +
388	((DoubleConstant) right).Value);
389
390	return new DoubleConstant (ec.BuiltinTypes, res, left.Location);
391	}
392	if (left is FloatConstant){
393	double a, b, res;
394	a = ((FloatConstant) left).DoubleValue;
395	b = ((FloatConstant) right).DoubleValue;
396
397	if (ec.ConstantCheckState)
398	res = checked (a + b);
399	else
400	res = unchecked (a + b);
401
402	result = new FloatConstant (ec.BuiltinTypes, res, left.Location);
403	} else if (left is ULongConstant){
404	ulong res;
405
406	if (ec.ConstantCheckState)
407	res = checked (((ULongConstant) left).Value +
408	((ULongConstant) right).Value);
409	else
410	res = unchecked (((ULongConstant) left).Value +
411	((ULongConstant) right).Value);
412
413	result = new ULongConstant (ec.BuiltinTypes, res, left.Location);
414	} else if (left is LongConstant){
415	long res;
416
417	if (ec.ConstantCheckState)
418	res = checked (((LongConstant) left).Value +
419	((LongConstant) right).Value);
420	else
421	res = unchecked (((LongConstant) left).Value +
422	((LongConstant) right).Value);
423
424	result = new LongConstant (ec.BuiltinTypes, res, left.Location);
425	} else if (left is UIntConstant){
426	uint res;
427
428	if (ec.ConstantCheckState)
429	res = checked (((UIntConstant) left).Value +
430	((UIntConstant) right).Value);
431	else
432	res = unchecked (((UIntConstant) left).Value +
433	((UIntConstant) right).Value);
434
435	result = new UIntConstant (ec.BuiltinTypes, res, left.Location);
436	} else if (left is IntConstant){
437	int res;
438
439	if (ec.ConstantCheckState)
440	res = checked (((IntConstant) left).Value +
441	((IntConstant) right).Value);
442	else
443	res = unchecked (((IntConstant) left).Value +
444	((IntConstant) right).Value);
445
446	result = new IntConstant (ec.BuiltinTypes, res, left.Location);
447	} else if (left is DecimalConstant) {
448	decimal res;
449
450	if (ec.ConstantCheckState)
451	res = checked (((DecimalConstant) left).Value +
452	((DecimalConstant) right).Value);
453	else
454	res = unchecked (((DecimalConstant) left).Value +
455	((DecimalConstant) right).Value);
456
457	result = new DecimalConstant (ec.BuiltinTypes, res, left.Location);
458	}
459	} catch (OverflowException){
460	Error_CompileTimeOverflow (ec, loc);
461	}
462
463	return result;
464
465	case Binary.Operator.Subtraction:
466	//
467	// handle "E operator - (E x, U y)"
468	// handle "E operator - (Y y, E x)"
469	//
470	lc = left as EnumConstant;
471	rc = right as EnumConstant;
472	if (lc != null \|\| rc != null){
473	if (lc == null) {
474	lc = rc;
475	lt = lc.Type;
476	right = left;
477	}
478
479	// U has to be implicitly convetible to E.base
480	right = right.ConvertImplicitly (lc.Child.Type);
481	if (right == null)
482	return null;
483
484	result = BinaryFold (ec, oper, lc.Child, right, loc);
485	if (result == null)
486	return null;
487
488	result = result.Reduce (ec, lt);
489	if (result == null)
490	return null;
491
492	return new EnumConstant (result, lt);
493	}
494
495	if (left is NullLiteral && right is NullLiteral) {
496	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
497	lifted_int.ResolveAsType (ec);
498	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
499	}
500
501	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
502	return null;
503
504	try {
505	if (left is DoubleConstant){
506	double res;
507
508	if (ec.ConstantCheckState)
509	res = checked (((DoubleConstant) left).Value -
510	((DoubleConstant) right).Value);
511	else
512	res = unchecked (((DoubleConstant) left).Value -
513	((DoubleConstant) right).Value);
514
515	result = new DoubleConstant (ec.BuiltinTypes, res, left.Location);
516	} else if (left is FloatConstant){
517	double a, b, res;
518	a = ((FloatConstant) left).DoubleValue;
519	b = ((FloatConstant) right).DoubleValue;
520
521	if (ec.ConstantCheckState)
522	res = checked (a - b);
523	else
524	res = unchecked (a - b);
525
526	result = new FloatConstant (ec.BuiltinTypes, res, left.Location);
527	} else if (left is ULongConstant){
528	ulong res;
529
530	if (ec.ConstantCheckState)
531	res = checked (((ULongConstant) left).Value -
532	((ULongConstant) right).Value);
533	else
534	res = unchecked (((ULongConstant) left).Value -
535	((ULongConstant) right).Value);
536
537	result = new ULongConstant (ec.BuiltinTypes, res, left.Location);
538	} else if (left is LongConstant){
539	long res;
540
541	if (ec.ConstantCheckState)
542	res = checked (((LongConstant) left).Value -
543	((LongConstant) right).Value);
544	else
545	res = unchecked (((LongConstant) left).Value -
546	((LongConstant) right).Value);
547
548	result = new LongConstant (ec.BuiltinTypes, res, left.Location);
549	} else if (left is UIntConstant){
550	uint res;
551
552	if (ec.ConstantCheckState)
553	res = checked (((UIntConstant) left).Value -
554	((UIntConstant) right).Value);
555	else
556	res = unchecked (((UIntConstant) left).Value -
557	((UIntConstant) right).Value);
558
559	result = new UIntConstant (ec.BuiltinTypes, res, left.Location);
560	} else if (left is IntConstant){
561	int res;
562
563	if (ec.ConstantCheckState)
564	res = checked (((IntConstant) left).Value -
565	((IntConstant) right).Value);
566	else
567	res = unchecked (((IntConstant) left).Value -
568	((IntConstant) right).Value);
569
570	result = new IntConstant (ec.BuiltinTypes, res, left.Location);
571	} else if (left is DecimalConstant) {
572	decimal res;
573
574	if (ec.ConstantCheckState)
575	res = checked (((DecimalConstant) left).Value -
576	((DecimalConstant) right).Value);
577	else
578	res = unchecked (((DecimalConstant) left).Value -
579	((DecimalConstant) right).Value);
580
581	return new DecimalConstant (ec.BuiltinTypes, res, left.Location);
582	} else {
583	throw new Exception ( "Unexepected subtraction input: " + left);
584	}
585	} catch (OverflowException){
586	Error_CompileTimeOverflow (ec, loc);
587	}
588
589	return result;
590
591	case Binary.Operator.Multiply:
592	if (left is NullLiteral && right is NullLiteral) {
593	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
594	lifted_int.ResolveAsType (ec);
595	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
596	}
597
598	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
599	return null;
600
601	try {
602	if (left is DoubleConstant){
603	double res;
604
605	if (ec.ConstantCheckState)
606	res = checked (((DoubleConstant) left).Value *
607	((DoubleConstant) right).Value);
608	else
609	res = unchecked (((DoubleConstant) left).Value *
610	((DoubleConstant) right).Value);
611
612	return new DoubleConstant (ec.BuiltinTypes, res, left.Location);
613	} else if (left is FloatConstant){
614	double a, b, res;
615	a = ((FloatConstant) left).DoubleValue;
616	b = ((FloatConstant) right).DoubleValue;
617
618	if (ec.ConstantCheckState)
619	res = checked (a * b);
620	else
621	res = unchecked (a * b);
622
623	return new FloatConstant (ec.BuiltinTypes, res, left.Location);
624	} else if (left is ULongConstant){
625	ulong res;
626
627	if (ec.ConstantCheckState)
628	res = checked (((ULongConstant) left).Value *
629	((ULongConstant) right).Value);
630	else
631	res = unchecked (((ULongConstant) left).Value *
632	((ULongConstant) right).Value);
633
634	return new ULongConstant (ec.BuiltinTypes, res, left.Location);
635	} else if (left is LongConstant){
636	long res;
637
638	if (ec.ConstantCheckState)
639	res = checked (((LongConstant) left).Value *
640	((LongConstant) right).Value);
641	else
642	res = unchecked (((LongConstant) left).Value *
643	((LongConstant) right).Value);
644
645	return new LongConstant (ec.BuiltinTypes, res, left.Location);
646	} else if (left is UIntConstant){
647	uint res;
648
649	if (ec.ConstantCheckState)
650	res = checked (((UIntConstant) left).Value *
651	((UIntConstant) right).Value);
652	else
653	res = unchecked (((UIntConstant) left).Value *
654	((UIntConstant) right).Value);
655
656	return new UIntConstant (ec.BuiltinTypes, res, left.Location);
657	} else if (left is IntConstant){
658	int res;
659
660	if (ec.ConstantCheckState)
661	res = checked (((IntConstant) left).Value *
662	((IntConstant) right).Value);
663	else
664	res = unchecked (((IntConstant) left).Value *
665	((IntConstant) right).Value);
666
667	return new IntConstant (ec.BuiltinTypes, res, left.Location);
668	} else if (left is DecimalConstant) {
669	decimal res;
670
671	if (ec.ConstantCheckState)
672	res = checked (((DecimalConstant) left).Value *
673	((DecimalConstant) right).Value);
674	else
675	res = unchecked (((DecimalConstant) left).Value *
676	((DecimalConstant) right).Value);
677
678	return new DecimalConstant (ec.BuiltinTypes, res, left.Location);
679	} else {
680	throw new Exception ( "Unexepected multiply input: " + left);
681	}
682	} catch (OverflowException){
683	Error_CompileTimeOverflow (ec, loc);
684	}
685	break;
686
687	case Binary.Operator.Division:
688	if (left is NullLiteral && right is NullLiteral) {
689	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
690	lifted_int.ResolveAsType (ec);
691	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
692	}
693
694	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
695	return null;
696
697	try {
698	if (left is DoubleConstant){
699	double res;
700
701	if (ec.ConstantCheckState)
702	res = checked (((DoubleConstant) left).Value /
703	((DoubleConstant) right).Value);
704	else
705	res = unchecked (((DoubleConstant) left).Value /
706	((DoubleConstant) right).Value);
707
708	return new DoubleConstant (ec.BuiltinTypes, res, left.Location);
709	} else if (left is FloatConstant){
710	double a, b, res;
711	a = ((FloatConstant) left).DoubleValue;
712	b = ((FloatConstant) right).DoubleValue;
713
714	if (ec.ConstantCheckState)
715	res = checked (a / b);
716	else
717	res = unchecked (a / b);
718
719	return new FloatConstant (ec.BuiltinTypes, res, left.Location);
720	} else if (left is ULongConstant){
721	ulong res;
722
723	if (ec.ConstantCheckState)
724	res = checked (((ULongConstant) left).Value /
725	((ULongConstant) right).Value);
726	else
727	res = unchecked (((ULongConstant) left).Value /
728	((ULongConstant) right).Value);
729
730	return new ULongConstant (ec.BuiltinTypes, res, left.Location);
731	} else if (left is LongConstant){
732	long res;
733
734	if (ec.ConstantCheckState)
735	res = checked (((LongConstant) left).Value /
736	((LongConstant) right).Value);
737	else
738	res = unchecked (((LongConstant) left).Value /
739	((LongConstant) right).Value);
740
741	return new LongConstant (ec.BuiltinTypes, res, left.Location);
742	} else if (left is UIntConstant){
743	uint res;
744
745	if (ec.ConstantCheckState)
746	res = checked (((UIntConstant) left).Value /
747	((UIntConstant) right).Value);
748	else
749	res = unchecked (((UIntConstant) left).Value /
750	((UIntConstant) right).Value);
751
752	return new UIntConstant (ec.BuiltinTypes, res, left.Location);
753	} else if (left is IntConstant){
754	int res;
755
756	if (ec.ConstantCheckState)
757	res = checked (((IntConstant) left).Value /
758	((IntConstant) right).Value);
759	else
760	res = unchecked (((IntConstant) left).Value /
761	((IntConstant) right).Value);
762
763	return new IntConstant (ec.BuiltinTypes, res, left.Location);
764	} else if (left is DecimalConstant) {
765	decimal res;
766
767	if (ec.ConstantCheckState)
768	res = checked (((DecimalConstant) left).Value /
769	((DecimalConstant) right).Value);
770	else
771	res = unchecked (((DecimalConstant) left).Value /
772	((DecimalConstant) right).Value);
773
774	return new DecimalConstant (ec.BuiltinTypes, res, left.Location);
775	} else {
776	throw new Exception ( "Unexepected division input: " + left);
777	}
778	} catch (OverflowException){
779	Error_CompileTimeOverflow (ec, loc);
780
781	} catch (DivideByZeroException) {
782	ec.Report.Error (20, loc, "Division by constant zero");
783	}
784
785	break;
786
787	case Binary.Operator.Modulus:
788	if (left is NullLiteral && right is NullLiteral) {
789	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
790	lifted_int.ResolveAsType (ec);
791	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
792	}
793
794	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
795	return null;
796
797	try {
798	if (left is DoubleConstant){
799	double res;
800
801	if (ec.ConstantCheckState)
802	res = checked (((DoubleConstant) left).Value %
803	((DoubleConstant) right).Value);
804	else
805	res = unchecked (((DoubleConstant) left).Value %
806	((DoubleConstant) right).Value);
807
808	return new DoubleConstant (ec.BuiltinTypes, res, left.Location);
809	} else if (left is FloatConstant){
810	double a, b, res;
811	a = ((FloatConstant) left).DoubleValue;
812	b = ((FloatConstant) right).DoubleValue;
813
814	if (ec.ConstantCheckState)
815	res = checked (a % b);
816	else
817	res = unchecked (a % b);
818
819	return new FloatConstant (ec.BuiltinTypes, res, left.Location);
820	} else if (left is ULongConstant){
821	ulong res;
822
823	if (ec.ConstantCheckState)
824	res = checked (((ULongConstant) left).Value %
825	((ULongConstant) right).Value);
826	else
827	res = unchecked (((ULongConstant) left).Value %
828	((ULongConstant) right).Value);
829
830	return new ULongConstant (ec.BuiltinTypes, res, left.Location);
831	} else if (left is LongConstant){
832	long res;
833
834	if (ec.ConstantCheckState)
835	res = checked (((LongConstant) left).Value %
836	((LongConstant) right).Value);
837	else
838	res = unchecked (((LongConstant) left).Value %
839	((LongConstant) right).Value);
840
841	return new LongConstant (ec.BuiltinTypes, res, left.Location);
842	} else if (left is UIntConstant){
843	uint res;
844
845	if (ec.ConstantCheckState)
846	res = checked (((UIntConstant) left).Value %
847	((UIntConstant) right).Value);
848	else
849	res = unchecked (((UIntConstant) left).Value %
850	((UIntConstant) right).Value);
851
852	return new UIntConstant (ec.BuiltinTypes, res, left.Location);
853	} else if (left is IntConstant){
854	int res;
855
856	if (ec.ConstantCheckState)
857	res = checked (((IntConstant) left).Value %
858	((IntConstant) right).Value);
859	else
860	res = unchecked (((IntConstant) left).Value %
861	((IntConstant) right).Value);
862
863	return new IntConstant (ec.BuiltinTypes, res, left.Location);
864	}
865
866	if (left is DecimalConstant) {
867	decimal res;
868
869	if (ec.ConstantCheckState)
870	res = checked (((DecimalConstant) left).Value %
871	((DecimalConstant) right).Value);
872	else
873	res = unchecked (((DecimalConstant) left).Value %
874	((DecimalConstant) right).Value);
875
876	return new DecimalConstant (ec.BuiltinTypes, res, left.Location);
877	}
878
879	throw new Exception ( "Unexepected modulus input: " + left);
880	} catch (DivideByZeroException){
881	ec.Report.Error (20, loc, "Division by constant zero");
882	} catch (OverflowException){
883	Error_CompileTimeOverflow (ec, loc);
884	}
885	break;
886
887	//
888	// There is no overflow checking on left shift
889	//
890	case Binary.Operator.LeftShift:
891	if (left is NullLiteral && right is NullLiteral) {
892	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
893	lifted_int.ResolveAsType (ec);
894	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
895	}
896
897	IntConstant ic = right.ConvertImplicitly (ec.BuiltinTypes.Int) as IntConstant;
898	if (ic == null){
899	return null;
900	}
901
902	int lshift_val = ic.Value;
903	switch (left.Type.BuiltinType) {
904	case BuiltinTypeSpec.Type.ULong:
905	return new ULongConstant (ec.BuiltinTypes, ((ULongConstant) left).Value << lshift_val, left.Location);
906	case BuiltinTypeSpec.Type.Long:
907	return new LongConstant (ec.BuiltinTypes, ((LongConstant) left).Value << lshift_val, left.Location);
908	case BuiltinTypeSpec.Type.UInt:
909	return new UIntConstant (ec.BuiltinTypes, ((UIntConstant) left).Value << lshift_val, left.Location);
910	}
911
912	// null << value => null
913	if (left is NullLiteral)
914	return (Constant) new Binary (oper, left, right).ResolveOperator (ec);
915
916	left = left.ConvertImplicitly (ec.BuiltinTypes.Int);
917	if (left.Type.BuiltinType == BuiltinTypeSpec.Type.Int)
918	return new IntConstant (ec.BuiltinTypes, ((IntConstant) left).Value << lshift_val, left.Location);
919
920	return null;
921
922	//
923	// There is no overflow checking on right shift
924	//
925	case Binary.Operator.RightShift:
926	if (left is NullLiteral && right is NullLiteral) {
927	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
928	lifted_int.ResolveAsType (ec);
929	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
930	}
931
932	IntConstant sic = right.ConvertImplicitly (ec.BuiltinTypes.Int) as IntConstant;
933	if (sic == null){
934	return null;
935	}
936	int rshift_val = sic.Value;
937	switch (left.Type.BuiltinType) {
938	case BuiltinTypeSpec.Type.ULong:
939	return new ULongConstant (ec.BuiltinTypes, ((ULongConstant) left).Value >> rshift_val, left.Location);
940	case BuiltinTypeSpec.Type.Long:
941	return new LongConstant (ec.BuiltinTypes, ((LongConstant) left).Value >> rshift_val, left.Location);
942	case BuiltinTypeSpec.Type.UInt:
943	return new UIntConstant (ec.BuiltinTypes, ((UIntConstant) left).Value >> rshift_val, left.Location);
944	}
945
946	// null >> value => null
947	if (left is NullLiteral)
948	return (Constant) new Binary (oper, left, right).ResolveOperator (ec);
949
950	left = left.ConvertImplicitly (ec.BuiltinTypes.Int);
951	if (left.Type.BuiltinType == BuiltinTypeSpec.Type.Int)
952	return new IntConstant (ec.BuiltinTypes, ((IntConstant) left).Value >> rshift_val, left.Location);
953
954	return null;
955
956	case Binary.Operator.Equality:
957	if (TypeSpec.IsReferenceType (lt) && TypeSpec.IsReferenceType (rt) \|\|
958	(left is Nullable.LiftedNull && right.IsNull) \|\|
959	(right is Nullable.LiftedNull && left.IsNull)) {
960	if (left.IsNull \|\| right.IsNull) {
961	return ReducedExpression.Create (
962	new BoolConstant (ec.BuiltinTypes, left.IsNull == right.IsNull, left.Location),
963	new Binary (oper, left, right));
964	}
965
966	if (left is StringConstant && right is StringConstant)
967	return new BoolConstant (ec.BuiltinTypes,
968	((StringConstant) left).Value == ((StringConstant) right).Value, left.Location);
969
970	return null;
971	}
972
973	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
974	return null;
975
976	bool_res = false;
977	if (left is DoubleConstant)
978	bool_res = ((DoubleConstant) left).Value ==
979	((DoubleConstant) right).Value;
980	else if (left is FloatConstant)
981	bool_res = ((FloatConstant) left).DoubleValue ==
982	((FloatConstant) right).DoubleValue;
983	else if (left is ULongConstant)
984	bool_res = ((ULongConstant) left).Value ==
985	((ULongConstant) right).Value;
986	else if (left is LongConstant)
987	bool_res = ((LongConstant) left).Value ==
988	((LongConstant) right).Value;
989	else if (left is UIntConstant)
990	bool_res = ((UIntConstant) left).Value ==
991	((UIntConstant) right).Value;
992	else if (left is IntConstant)
993	bool_res = ((IntConstant) left).Value ==
994	((IntConstant) right).Value;
995	else
996	return null;
997
998	return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
999
1000	case Binary.Operator.Inequality:
1001	if (TypeSpec.IsReferenceType (lt) && TypeSpec.IsReferenceType (rt) \|\|
1002	(left is Nullable.LiftedNull && right.IsNull) \|\|
1003	(right is Nullable.LiftedNull && left.IsNull)) {
1004	if (left.IsNull \|\| right.IsNull) {
1005	return ReducedExpression.Create (
1006	new BoolConstant (ec.BuiltinTypes, left.IsNull != right.IsNull, left.Location),
1007	new Binary (oper, left, right));
1008	}
1009
1010	if (left is StringConstant && right is StringConstant)
1011	return new BoolConstant (ec.BuiltinTypes,
1012	((StringConstant) left).Value != ((StringConstant) right).Value, left.Location);
1013
1014	return null;
1015	}
1016
1017	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
1018	return null;
1019
1020	bool_res = false;
1021	if (left is DoubleConstant)
1022	bool_res = ((DoubleConstant) left).Value !=
1023	((DoubleConstant) right).Value;
1024	else if (left is FloatConstant)
1025	bool_res = ((FloatConstant) left).DoubleValue !=
1026	((FloatConstant) right).DoubleValue;
1027	else if (left is ULongConstant)
1028	bool_res = ((ULongConstant) left).Value !=
1029	((ULongConstant) right).Value;
1030	else if (left is LongConstant)
1031	bool_res = ((LongConstant) left).Value !=
1032	((LongConstant) right).Value;
1033	else if (left is UIntConstant)
1034	bool_res = ((UIntConstant) left).Value !=
1035	((UIntConstant) right).Value;
1036	else if (left is IntConstant)
1037	bool_res = ((IntConstant) left).Value !=
1038	((IntConstant) right).Value;
1039	else
1040	return null;
1041
1042	return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
1043
1044	case Binary.Operator.LessThan:
1045	if (right is NullLiteral) {
1046	if (left is NullLiteral) {
1047	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
1048	lifted_int.ResolveAsType (ec);
1049	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
1050	}
1051	}
1052
1053	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
1054	return null;
1055
1056	bool_res = false;
1057	if (left is DoubleConstant)
1058	bool_res = ((DoubleConstant) left).Value <
1059	((DoubleConstant) right).Value;
1060	else if (left is FloatConstant)
1061	bool_res = ((FloatConstant) left).DoubleValue <
1062	((FloatConstant) right).DoubleValue;
1063	else if (left is ULongConstant)
1064	bool_res = ((ULongConstant) left).Value <
1065	((ULongConstant) right).Value;
1066	else if (left is LongConstant)
1067	bool_res = ((LongConstant) left).Value <
1068	((LongConstant) right).Value;
1069	else if (left is UIntConstant)
1070	bool_res = ((UIntConstant) left).Value <
1071	((UIntConstant) right).Value;
1072	else if (left is IntConstant)
1073	bool_res = ((IntConstant) left).Value <
1074	((IntConstant) right).Value;
1075	else
1076	return null;
1077
1078	return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
1079
1080	case Binary.Operator.GreaterThan:
1081	if (right is NullLiteral) {
1082	if (left is NullLiteral) {
1083	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
1084	lifted_int.ResolveAsType (ec);
1085	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
1086	}
1087	}
1088
1089	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
1090	return null;
1091
1092	bool_res = false;
1093	if (left is DoubleConstant)
1094	bool_res = ((DoubleConstant) left).Value >
1095	((DoubleConstant) right).Value;
1096	else if (left is FloatConstant)
1097	bool_res = ((FloatConstant) left).DoubleValue >
1098	((FloatConstant) right).DoubleValue;
1099	else if (left is ULongConstant)
1100	bool_res = ((ULongConstant) left).Value >
1101	((ULongConstant) right).Value;
1102	else if (left is LongConstant)
1103	bool_res = ((LongConstant) left).Value >
1104	((LongConstant) right).Value;
1105	else if (left is UIntConstant)
1106	bool_res = ((UIntConstant) left).Value >
1107	((UIntConstant) right).Value;
1108	else if (left is IntConstant)
1109	bool_res = ((IntConstant) left).Value >
1110	((IntConstant) right).Value;
1111	else
1112	return null;
1113
1114	return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
1115
1116	case Binary.Operator.GreaterThanOrEqual:
1117	if (right is NullLiteral) {
1118	if (left is NullLiteral) {
1119	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
1120	lifted_int.ResolveAsType (ec);
1121	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
1122	}
1123	}
1124
1125	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
1126	return null;
1127
1128	bool_res = false;
1129	if (left is DoubleConstant)
1130	bool_res = ((DoubleConstant) left).Value >=
1131	((DoubleConstant) right).Value;
1132	else if (left is FloatConstant)
1133	bool_res = ((FloatConstant) left).DoubleValue >=
1134	((FloatConstant) right).DoubleValue;
1135	else if (left is ULongConstant)
1136	bool_res = ((ULongConstant) left).Value >=
1137	((ULongConstant) right).Value;
1138	else if (left is LongConstant)
1139	bool_res = ((LongConstant) left).Value >=
1140	((LongConstant) right).Value;
1141	else if (left is UIntConstant)
1142	bool_res = ((UIntConstant) left).Value >=
1143	((UIntConstant) right).Value;
1144	else if (left is IntConstant)
1145	bool_res = ((IntConstant) left).Value >=
1146	((IntConstant) right).Value;
1147	else
1148	return null;
1149
1150	return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
1151
1152	case Binary.Operator.LessThanOrEqual:
1153	if (right is NullLiteral) {
1154	if (left is NullLiteral) {
1155	var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
1156	lifted_int.ResolveAsType (ec);
1157	return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
1158	}
1159	}
1160
1161	if (!DoBinaryNumericPromotions (ec, ref left, ref right))
1162	return null;
1163
1164	bool_res = false;
1165	if (left is DoubleConstant)
1166	bool_res = ((DoubleConstant) left).Value <=
1167	((DoubleConstant) right).Value;
1168	else if (left is FloatConstant)
1169	bool_res = ((FloatConstant) left).DoubleValue <=
1170	((FloatConstant) right).DoubleValue;
1171	else if (left is ULongConstant)
1172	bool_res = ((ULongConstant) left).Value <=
1173	((ULongConstant) right).Value;
1174	else if (left is LongConstant)
1175	bool_res = ((LongConstant) left).Value <=
1176	((LongConstant) right).Value;
1177	else if (left is UIntConstant)
1178	bool_res = ((UIntConstant) left).Value <=
1179	((UIntConstant) right).Value;
1180	else if (left is IntConstant)
1181	bool_res = ((IntConstant) left).Value <=
1182	((IntConstant) right).Value;
1183	else
1184	return null;
1185
1186	return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
1187	}
1188
1189	return null;
1190	}
1191	}
1192	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences