2004-07-18 Martin Baulig <martin@ximian.com>
[mono.git] / mcs / gmcs / const.cs
1 //
2 // const.cs: Constant declarations.
3 //
4 // Author:
5 //   Miguel de Icaza (miguel@ximian.com)
6 //
7 // (C) 2001 Ximian, Inc.
8 //
9 //
10
11 //
12 // This is needed because the following situation arises:
13 //
14 //     The FieldBuilder is declared with the real type for an enumeration
15 //
16 //     When we attempt to set the value for the constant, the FieldBuilder.SetConstant
17 //     function aborts because it requires its argument to be of the same type
18 //
19
20 namespace Mono.CSharp {
21
22         using System;
23         using System.Reflection;
24         using System.Reflection.Emit;
25         using System.Collections;
26
27         public class Const : FieldBase {
28                 public Expression Expr;
29                 EmitContext const_ec;
30
31                 bool resolved = false;
32                 object ConstantValue = null;
33                 Type type;
34
35                 bool in_transit = false;
36
37                 public const int AllowedModifiers =
38                         Modifiers.NEW |
39                         Modifiers.PUBLIC |
40                         Modifiers.PROTECTED |
41                         Modifiers.INTERNAL |
42                         Modifiers.PRIVATE;
43
44                 public Const (Expression constant_type, string name, Expression expr,
45                               int mod_flags, Attributes attrs, Location loc)
46                         : base (constant_type, mod_flags, AllowedModifiers,
47                                 new MemberName (name), null, attrs, loc)
48                 {
49                         Expr = expr;
50                 }
51
52                 public FieldAttributes FieldAttr {
53                         get {
54                                 return FieldAttributes.Literal | FieldAttributes.Static |
55                                         Modifiers.FieldAttr (ModFlags) ;
56                         }
57                 }
58
59 #if DEBUG
60                 void dump_tree (Type t)
61                 {
62                         Console.WriteLine ("Dumping hierarchy");
63                         while (t != null){
64                                 Console.WriteLine ("   " + t.FullName + " " +
65                                         (t.GetType ().IsEnum ? "yes" : "no"));
66                                 t = t.BaseType;
67                         }
68                 }
69 #endif
70
71                 /// <summary>
72                 ///   Defines the constant in the @parent
73                 /// </summary>
74                 public override bool Define (TypeContainer parent)
75                 {
76                         type = parent.ResolveType (Type, false, Location);
77
78                         if (type == null)
79                                 return false;
80
81                         const_ec = new EmitContext (parent, Location, null, type, ModFlags);
82                         
83                         Type ttype = type;
84                         while (ttype.IsArray)
85                             ttype = TypeManager.GetElementType (ttype);
86                         
87                         if (!TypeManager.IsBuiltinType (ttype) &&
88                             (!ttype.IsSubclassOf (TypeManager.enum_type))) {
89                                 Report.Error (
90                                         -3, Location,
91                                         "Constant type is not valid (only system types are allowed)");
92                                 return false;
93                         }
94
95                         Type ptype = parent.TypeBuilder.BaseType;
96
97                         if (ptype != null) {
98                                 MemberList list = TypeContainer.FindMembers (
99                                         ptype, MemberTypes.Field, BindingFlags.Public,
100                                         System.Type.FilterName, Name);
101                                 
102                                 if (list.Count == 0)
103                                         if ((ModFlags & Modifiers.NEW) != 0)
104                                                 WarningNotHiding (parent);
105
106                         } else if ((ModFlags & Modifiers.NEW) != 0)
107                                 WarningNotHiding (parent);
108
109                         FieldBuilder = parent.TypeBuilder.DefineField (Name, type, FieldAttr);
110
111                         TypeManager.RegisterConstant (FieldBuilder, this);
112
113                         return true;
114                 }
115
116                 //
117                 // Changes the type of the constant expression `expr' to the Type `type'
118                 // Returns null on failure.
119                 //
120                 public static Constant ChangeType (Location loc, Constant expr, Type type)
121                 {
122                         if (type == TypeManager.object_type)
123                                 return expr;
124
125                         bool fail;
126
127                         // from the null type to any reference-type.
128                         if (expr is NullLiteral && !type.IsValueType && !TypeManager.IsEnumType (type))
129                                 return NullLiteral.Null;
130
131                         if (!Convert.ImplicitStandardConversionExists (expr, type)){
132                                 Convert.Error_CannotImplicitConversion (loc, expr.Type, type);
133                                 return null;
134                         }
135                         
136                         object constant_value = TypeManager.ChangeType (expr.GetValue (), type, out fail);
137                         if (fail){
138                                 Convert.Error_CannotImplicitConversion (loc, expr.Type, type);
139                                 
140                                 //
141                                 // We should always catch the error before this is ever
142                                 // reached, by calling Convert.ImplicitStandardConversionExists
143                                 //
144                                 throw new Exception (
145                                                      String.Format ("LookupConstantValue: This should never be reached {0} {1}", expr.Type, type));
146                         }
147
148                         Constant retval;
149                         if (type == TypeManager.int32_type)
150                                 retval = new IntConstant ((int) constant_value);
151                         else if (type == TypeManager.uint32_type)
152                                 retval = new UIntConstant ((uint) constant_value);
153                         else if (type == TypeManager.int64_type)
154                                 retval = new LongConstant ((long) constant_value);
155                         else if (type == TypeManager.uint64_type)
156                                 retval = new ULongConstant ((ulong) constant_value);
157                         else if (type == TypeManager.float_type)
158                                 retval = new FloatConstant ((float) constant_value);
159                         else if (type == TypeManager.double_type)
160                                 retval = new DoubleConstant ((double) constant_value);
161                         else if (type == TypeManager.string_type)
162                                 retval = new StringConstant ((string) constant_value);
163                         else if (type == TypeManager.short_type)
164                                 retval = new ShortConstant ((short) constant_value);
165                         else if (type == TypeManager.ushort_type)
166                                 retval = new UShortConstant ((ushort) constant_value);
167                         else if (type == TypeManager.sbyte_type)
168                                 retval = new SByteConstant ((sbyte) constant_value);
169                         else if (type == TypeManager.byte_type)
170                                 retval = new ByteConstant ((byte) constant_value);
171                         else if (type == TypeManager.char_type)
172                                 retval = new CharConstant ((char) constant_value);
173                         else if (type == TypeManager.bool_type)
174                                 retval = new BoolConstant ((bool) constant_value);
175                         else
176                                 throw new Exception ("LookupConstantValue: Unhandled constant type: " + type);
177                         
178                         return retval;
179                 }
180                 
181                 /// <summary>
182                 ///  Looks up the value of a constant field. Defines it if it hasn't
183                 ///  already been. Similar to LookupEnumValue in spirit.
184                 /// </summary>
185                 public bool LookupConstantValue (out object value)
186                 {
187                         if (resolved) {
188                                 value = ConstantValue;
189                                 return true;
190                         }
191
192                         if (in_transit) {
193                                 Report.Error (110, Location,
194                                               "The evaluation of the constant value for `" +
195                                               Name + "' involves a circular definition.");
196                                 value = null;
197                                 return false;
198                         }
199
200                         in_transit = true;
201                         int errors = Report.Errors;
202
203                         //
204                         // We might have cleared Expr ourselves in a recursive definition
205                         //
206                         if (Expr == null){
207                                 value = null;
208                                 return false;
209                         }
210                         
211                         Expr = Expr.Resolve (const_ec);
212
213                         in_transit = false;
214
215                         if (Expr == null) {
216                                 if (errors == Report.Errors)
217                                         Report.Error (150, Location, "A constant value is expected");
218                                 value = null;
219                                 return false;
220                         }
221
222                         Expression real_expr = Expr;
223
224                         Constant ce = Expr as Constant;
225                         if (ce == null){
226                                 UnCheckedExpr un_expr = Expr as UnCheckedExpr;
227                                 CheckedExpr ch_expr = Expr as CheckedExpr;
228                                 EmptyCast ec_expr = Expr as EmptyCast;
229
230                                 if ((un_expr != null) && (un_expr.Expr is Constant))
231                                         Expr = un_expr.Expr;
232                                 else if ((ch_expr != null) && (ch_expr.Expr is Constant))
233                                         Expr = ch_expr.Expr;
234                                 else if ((ec_expr != null) && (ec_expr.Child is Constant))
235                                         Expr = ec_expr.Child;
236                                 else if (Expr is ArrayCreation) {
237                                         ArrayCreation ac = (ArrayCreation) Expr;
238
239                                         Expr = ac.TurnIntoConstant ();
240                                         if (Expr == null){
241                                                 Report.Error (150, Location, "A constant value is expected");
242                                                 value = null;
243                                                 return false;
244                                         }
245                                 } else {
246                                         if (errors == Report.Errors)
247                                                 Report.Error (150, Location, "A constant value is expected");
248                                         value = null;
249                                         return false;
250                                 }
251
252                                 ce = Expr as Constant;
253                         }
254
255                         if (type != real_expr.Type) {
256                                 ce = ChangeType (Location, ce, type);
257                                 if (ce == null){
258                                         value = null;
259                                         return false;
260                                 }
261                                 Expr = ce;
262                         }
263                         ConstantValue = ce.GetValue ();
264
265                         if (type.IsEnum){
266                                 //
267                                 // This sadly does not work for our user-defined enumerations types ;-(
268                                 //
269                                 try {
270                                         ConstantValue = System.Enum.ToObject (
271                                                 type, ConstantValue);
272                                 } catch (ArgumentException){
273                                         Report.Error (
274                                                 -16, Location,
275                                                 ".NET SDK 1.0 does not permit to create the constant "+
276                                                 " field from a user-defined enumeration");
277                                 }
278                         }
279
280                         FieldBuilder.SetConstant (ConstantValue);
281
282                         if (!TypeManager.RegisterFieldValue (FieldBuilder, ConstantValue))
283                                 throw new Exception ("Cannot register const value");
284
285                         value = ConstantValue;
286                         resolved = true;
287                         return true;
288                 }
289                 
290                 
291                 /// <summary>
292                 ///  Emits the field value by evaluating the expression
293                 /// </summary>
294                 public override void Emit (TypeContainer parent)
295                 {
296                         object value;
297                         LookupConstantValue (out value);
298
299                         if (OptAttributes != null) {
300                                 OptAttributes.Emit (const_ec, this);
301                         }
302
303                         base.Emit (parent);
304                 }
305         }
306 }
307
308