?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
**** Merged from MCS ****
[mono-project.git] / mcs / mbas / enum.cs
blob0b8b8baac8ab711fd97bb822613e790ce369277b
1 //
2 // enum.cs: Enum handling.
3 //
4 // Author: Miguel de Icaza (miguel@gnu.org)
5 // Ravi Pratap (ravi@ximian.com)
6 // Anirban Bhattacharjee (banirban@novell.com)
7 //
8 // Licensed under the terms of the GNU GPL
9 //
10 // (C) 2001 Ximian, Inc (http://www.ximian.com)
11 //
12
13 using System;
14 using System.Collections;
15 using System.Reflection;
16 using System.Reflection.Emit;
17
18 namespace Mono.MonoBASIC {
19
20 /// <summary>
21 /// Enumeration container
22 /// </summary>
23 public class Enum : DeclSpace {
24 ArrayList ordered_enums;
25
26 public Expression BaseType;
27
28 public Type UnderlyingType;
29
30 Hashtable member_to_location;
31 Hashtable member_to_attributes;
32
33 //
34 // This is for members that have been defined
35 //
36 Hashtable member_to_value;
37
38 //
39 // This is used to mark members we're currently defining
40 //
41 Hashtable in_transit;
42
43 ArrayList field_builders;
44
45 public const int AllowedModifiers =
46 Modifiers.NEW |
47 Modifiers.PUBLIC |
48 Modifiers.PROTECTED |
49 Modifiers.INTERNAL |
50 Modifiers.PRIVATE;
51
52 public Enum (TypeContainer parent, Expression type, int mod_flags, string name, Attributes attrs, Location l)
53 : base (parent, name, attrs, l)
54 {
55 this.BaseType = type;
56 ModFlags = Modifiers.Check (AllowedModifiers, mod_flags,
57 IsTopLevel ? Modifiers.INTERNAL : Modifiers.PUBLIC, l);
58
59 ordered_enums = new ArrayList ();
60 member_to_location = new Hashtable ();
61 member_to_value = new Hashtable ();
62 in_transit = new Hashtable ();
63 field_builders = new ArrayList ();
64 }
65
66 public override AttributeTargets AttributeTargets {
67 get {
68 return AttributeTargets.Enum;
69 }
70 }
71
72 /// <summary>
73 /// Adds @name to the enumeration space, with @expr
74 /// being its definition.
75 /// </summary>
76 public AdditionResult AddEnumMember (string name, Expression expr, Location loc,
77 Attributes opt_attrs)
78 {
79 if (defined_names.Contains (name))
80 return AdditionResult.NameExists;
81
82 DefineName (name, expr);
83
84 ordered_enums.Add (name);
85 member_to_location.Add (name, loc);
86
87 if (member_to_attributes == null)
88 member_to_attributes = new Hashtable ();
89
90 member_to_attributes.Add (name, opt_attrs);
91
92 return AdditionResult.Success;
93 }
94
95 //
96 // This is used by corlib compilation: we map from our
97 // type to a type that is consumable by the DefineField
98 //
99 Type MapToInternalType (Type t)
100 {
101 if (t == TypeManager.int32_type)
102 return typeof (int);
103 if (t == TypeManager.int64_type)
104 return typeof (long);
105 if (t == TypeManager.uint32_type)
106 return typeof (uint);
107 if (t == TypeManager.uint64_type)
108 return typeof (ulong);
109 if (t == TypeManager.float_type)
110 return typeof (float);
111 if (t == TypeManager.double_type)
112 return typeof (double);
113 if (t == TypeManager.byte_type)
114 return typeof (byte);
115 if (t == TypeManager.sbyte_type)
116 return typeof (sbyte);
117 if (t == TypeManager.char_type)
118 return typeof (char);
119 if (t == TypeManager.short_type)
120 return typeof (short);
121 if (t == TypeManager.ushort_type)
122 return typeof (ushort);
123
124 throw new Exception ();
125 }
126
127 public override TypeBuilder DefineType ()
128 {
129 if (TypeBuilder != null)
130 return TypeBuilder;
131
132 TypeAttributes attr = Modifiers.TypeAttr (ModFlags, IsTopLevel);
133
134 attr |= TypeAttributes.Class | TypeAttributes.Sealed;
135
136 UnderlyingType = ResolveType (BaseType, false, Location);
137
138 if (UnderlyingType != TypeManager.int32_type &&
139 UnderlyingType != TypeManager.uint32_type &&
140 UnderlyingType != TypeManager.int64_type &&
141 UnderlyingType != TypeManager.uint64_type &&
142 UnderlyingType != TypeManager.short_type &&
143 UnderlyingType != TypeManager.ushort_type &&
144 UnderlyingType != TypeManager.byte_type &&
145 UnderlyingType != TypeManager.sbyte_type) {
146 Report.Error (30650, Location,
147 "Type byte, sbyte, short, ushort, int, uint, " +
148 "long, or ulong expected (got: " +
149 TypeManager.MonoBASIC_Name (UnderlyingType) + ")");
150 return null;
151 }
152
153 if (IsTopLevel) {
154 ModuleBuilder builder = CodeGen.ModuleBuilder;
155
156 TypeBuilder = builder.DefineType (Name, attr, TypeManager.enum_type);
157 } else {
158 TypeBuilder builder = Parent.TypeBuilder;
159
160 TypeBuilder = builder.DefineNestedType (
161 Basename, attr, TypeManager.enum_type);
162 }
163
164 //
165 // Call MapToInternalType for corlib
166 //
167 TypeBuilder.DefineField ("value__", UnderlyingType,
168 FieldAttributes.Public | FieldAttributes.SpecialName
169 | FieldAttributes.RTSpecialName);
170
171 TypeManager.AddEnumType (Name, TypeBuilder, this);
172
173 return TypeBuilder;
174 }
175
176 bool IsValidEnumConstant (Expression e)
177 {
178 if (!(e is Constant))
179 return false;
180
181 if (e is IntConstant || e is UIntConstant || e is LongConstant ||
182 e is ByteConstant || e is SByteConstant || e is ShortConstant ||
183 e is UShortConstant || e is ULongConstant || e is EnumConstant)
184 return true;
185 else
186 return false;
187 }
188
189 object GetNextDefaultValue (object default_value)
190 {
191 if (UnderlyingType == TypeManager.int32_type) {
192 int i = (int) default_value;
193
194 if (i < System.Int32.MaxValue)
195 return ++i;
196 else
197 return null;
198 } else if (UnderlyingType == TypeManager.uint32_type) {
199 uint i = (uint) default_value;
200
201 if (i < System.UInt32.MaxValue)
202 return ++i;
203 else
204 return null;
205 } else if (UnderlyingType == TypeManager.int64_type) {
206 long i = (long) default_value;
207
208 if (i < System.Int64.MaxValue)
209 return ++i;
210 else
211 return null;
212 } else if (UnderlyingType == TypeManager.uint64_type) {
213 ulong i = (ulong) default_value;
214
215 if (i < System.UInt64.MaxValue)
216 return ++i;
217 else
218 return null;
219 } else if (UnderlyingType == TypeManager.short_type) {
220 short i = (short) default_value;
221
222 if (i < System.Int16.MaxValue)
223 return ++i;
224 else
225 return null;
226 } else if (UnderlyingType == TypeManager.ushort_type) {
227 ushort i = (ushort) default_value;
228
229 if (i < System.UInt16.MaxValue)
230 return ++i;
231 else
232 return null;
233 } else if (UnderlyingType == TypeManager.byte_type) {
234 byte i = (byte) default_value;
235
236 if (i < System.Byte.MaxValue)
237 return ++i;
238 else
239 return null;
240 } else if (UnderlyingType == TypeManager.sbyte_type) {
241 sbyte i = (sbyte) default_value;
242
243 if (i < System.SByte.MaxValue)
244 return ++i;
245 else
246 return null;
247 }
248
249 return null;
250 }
251
252 void Error_ConstantValueCannotBeConverted (object val, Location loc)
253 {
254 if (val is Constant)
255 Report.Error (30439, loc, "Constant value '" + ((Constant) val).AsString () +
256 "' cannot be converted" +
257 " to a " + TypeManager.MonoBASIC_Name (UnderlyingType));
258 else
259 Report.Error (30439, loc, "Constant value '" + val +
260 "' cannot be converted" +
261 " to a " + TypeManager.MonoBASIC_Name (UnderlyingType));
262 return;
263 }
264
265 /// <summary>
266 /// Determines if a standard implicit conversion exists from
267 /// expr_type to target_type
268 /// </summary>
269 public static bool ImplicitConversionExists (Type expr_type, Type target_type)
270 {
271 expr_type = TypeManager.TypeToCoreType (expr_type);
272
273 if (expr_type == TypeManager.void_type)
274 return false;
275
276 if (expr_type == target_type)
277 return true;
278
279 // First numeric conversions
280
281 if (expr_type == TypeManager.sbyte_type){
282 //
283 // From sbyte to short, int, long, float, double.
284 //
285 if ((target_type == TypeManager.int32_type) ||
286 (target_type == TypeManager.int64_type) ||
287 (target_type == TypeManager.double_type) ||
288 (target_type == TypeManager.float_type) ||
289 (target_type == TypeManager.short_type) ||
290 (target_type == TypeManager.decimal_type))
291 return true;
292
293 } else if (expr_type == TypeManager.byte_type){
294 //
295 // From byte to short, ushort, int, uint, long, ulong, float, double
296 //
297 if ((target_type == TypeManager.short_type) ||
298 (target_type == TypeManager.ushort_type) ||
299 (target_type == TypeManager.int32_type) ||
300 (target_type == TypeManager.uint32_type) ||
301 (target_type == TypeManager.uint64_type) ||
302 (target_type == TypeManager.int64_type) ||
303 (target_type == TypeManager.float_type) ||
304 (target_type == TypeManager.double_type) ||
305 (target_type == TypeManager.decimal_type))
306 return true;
307
308 } else if (expr_type == TypeManager.short_type){
309 //
310 // From short to int, long, float, double
311 //
312 if ((target_type == TypeManager.int32_type) ||
313 (target_type == TypeManager.int64_type) ||
314 (target_type == TypeManager.double_type) ||
315 (target_type == TypeManager.float_type) ||
316 (target_type == TypeManager.decimal_type))
317 return true;
318
319 } else if (expr_type == TypeManager.ushort_type){
320 //
321 // From ushort to int, uint, long, ulong, float, double
322 //
323 if ((target_type == TypeManager.uint32_type) ||
324 (target_type == TypeManager.uint64_type) ||
325 (target_type == TypeManager.int32_type) ||
326 (target_type == TypeManager.int64_type) ||
327 (target_type == TypeManager.double_type) ||
328 (target_type == TypeManager.float_type) ||
329 (target_type == TypeManager.decimal_type))
330 return true;
331
332 } else if (expr_type == TypeManager.int32_type){
333 //
334 // From int to long, float, double
335 //
336 if ((target_type == TypeManager.int64_type) ||
337 (target_type == TypeManager.double_type) ||
338 (target_type == TypeManager.float_type) ||
339 (target_type == TypeManager.decimal_type))
340 return true;
341
342 } else if (expr_type == TypeManager.uint32_type){
343 //
344 // From uint to long, ulong, float, double
345 //
346 if ((target_type == TypeManager.int64_type) ||
347 (target_type == TypeManager.uint64_type) ||
348 (target_type == TypeManager.double_type) ||
349 (target_type == TypeManager.float_type) ||
350 (target_type == TypeManager.decimal_type))
351 return true;
352
353 } else if ((expr_type == TypeManager.uint64_type) ||
354 (expr_type == TypeManager.int64_type)) {
355 //
356 // From long/ulong to float, double
357 //
358 if ((target_type == TypeManager.double_type) ||
359 (target_type == TypeManager.float_type) ||
360 (target_type == TypeManager.decimal_type))
361 return true;
362
363 } else if (expr_type == TypeManager.char_type){
364 //
365 // From char to ushort, int, uint, long, ulong, float, double
366 //
367 if ((target_type == TypeManager.ushort_type) ||
368 (target_type == TypeManager.int32_type) ||
369 (target_type == TypeManager.uint32_type) ||
370 (target_type == TypeManager.uint64_type) ||
371 (target_type == TypeManager.int64_type) ||
372 (target_type == TypeManager.float_type) ||
373 (target_type == TypeManager.double_type) ||
374 (target_type == TypeManager.decimal_type))
375 return true;
376
377 } else if (expr_type == TypeManager.float_type){
378 //
379 // float to double
380 //
381 if (target_type == TypeManager.double_type)
382 return true;
383 }
384
385 return false;
386 }
387
388 /// <summary>
389 /// This is used to lookup the value of an enum member. If the member is undefined,
390 /// it attempts to define it and return its value
391 /// </summary>
392 public object LookupEnumValue (EmitContext ec, string name, Location loc)
393 {
394 object default_value = null;
395 Constant c = null;
396 TypeContainer parent = ec.TypeContainer;
397
398 // first check whether the requested name is there
399 // in the member list of enum
400 bool found = false;
401 name = name.ToLower();
402 foreach (string nm in ordered_enums) {
403 if (nm.ToLower() == name) {
404 name = nm;
405 found = true;
406 break;
407 }
408 }
409
410 if (!found)
411 Report.Error (30456, loc,
412 name + " is not found in member list of enum " + this.Name);
413
414 default_value = member_to_value [name];
415
416 if (default_value != null)
417 return default_value;
418
419 //
420 // This may happen if we're calling a method in System.Enum, for instance
421 // Enum.IsDefined().
422 //
423 if (!defined_names.Contains (name))
424 return null;
425
426 if (in_transit.Contains (name)) {
427 Report.Error (110, loc, "The evaluation of the constant value for `" +
428 Name + "." + name + "' involves a circular definition.");
429 return null;
430 }
431
432 //
433 // So if the above doesn't happen, we have a member that is undefined
434 // We now proceed to define it
435 //
436 Expression val = this [name];
437 int idx = ordered_enums.IndexOf (name);
438
439 if (val == null) {
440
441 //int idx = ordered_enums.IndexOf (name);
442
443 if (idx == 0)
444 default_value = 0;
445 else {
446 for (int i = 0; i < idx; ++i) {
447 string n = (string) ordered_enums [i];
448 Location m_loc = (Mono.MonoBASIC.Location)
449 member_to_location [n];
450 in_transit.Add (name, true);
451 default_value = LookupEnumValue (ec, n, m_loc);
452 in_transit.Remove (name);
453 if (default_value == null)
454 return null;
455 }
456
457 default_value = GetNextDefaultValue (default_value);
458 }
459
460 } else {
461 // check for any cyclic dependency
462 if (val is Mono.MonoBASIC.SimpleName) {
463 int var_idx = ordered_enums.IndexOf (val.ToString());
464
465 if (idx <= var_idx)
466 Report.Error(30500, loc,
467 "The evaluation of the constant value for `" +
468 Name + "." + name + "' involves a circular definition");
469 else
470 default_value = member_to_value [val.ToString()];
471 }
472 else {
473 bool old = ec.InEnumContext;
474 ec.InEnumContext = true;
475 in_transit.Add (name, true);
476 val = val.Resolve (ec);
477 in_transit.Remove (name);
478 ec.InEnumContext = old;
479
480 if (val == null)
481 return null;
482
483 if (!IsValidEnumConstant (val)) {
484 Report.Error (
485 30650, loc,
486 "Type byte, sbyte, short, ushort, int, uint, long, or " +
487 "ulong expected (have: " + val + ")");
488 return null;
489 }
490
491 c = (Constant) val;
492
493 default_value = c.GetValue ();
494 }
495
496 if (default_value == null) {
497 Error_ConstantValueCannotBeConverted (c, loc);
498 return null;
499 }
500
501 if (val is EnumConstant) {
502 Type etype = TypeManager.EnumToUnderlying (c.Type);
503
504 if ( (!ImplicitConversionExists (etype, UnderlyingType)) &&
505 (!Expression.NarrowingConversionExists (ec, val, UnderlyingType)) ){
506 Expression.Error_CannotConvertImplicit (
507 loc, c.Type, UnderlyingType);
508 return null;
509 }
510 }
511 }
512
513 FieldAttributes attr = FieldAttributes.Public | FieldAttributes.Static
514 | FieldAttributes.Literal;
515
516 FieldBuilder fb = TypeBuilder.DefineField (name, TypeBuilder, attr);
517
518 try {
519 default_value = TypeManager.ChangeType (default_value, UnderlyingType);
520 } catch {
521 Error_ConstantValueCannotBeConverted (c, loc);
522 return null;
523 }
524
525 fb.SetConstant (default_value);
526 field_builders.Add (fb);
527 member_to_value [name] = default_value;
528
529 if (!TypeManager.RegisterFieldValue (fb, default_value))
530 return null;
531
532 //
533 // Now apply attributes
534 //
535 Attribute.ApplyAttributes (ec, fb, fb, (Attributes) member_to_attributes [name], loc);
536
537 return default_value;
538 }
539
540 public override bool DefineMembers (TypeContainer parent)
541 {
542 return true;
543 }
544
545 public override bool Define (TypeContainer parent)
546 {
547 //
548 // If there was an error during DefineEnum, return
549 //
550 if (TypeBuilder == null)
551 return false;
552
553 EmitContext ec = new EmitContext (parent, this, Location, null,
554 UnderlyingType, ModFlags, false);
555
556 object default_value = 0;
557
558 foreach (string name in ordered_enums) {
559 if (member_to_value.Contains (name))
560 continue;
561
562 Location loc = (Mono.MonoBASIC.Location) member_to_location [name];
563
564 if (this [name] != null) {
565 default_value = LookupEnumValue (ec, name, loc);
566
567 if (default_value == null)
568 return true;
569 } else {
570 FieldAttributes attr = FieldAttributes.Public | FieldAttributes.Static
571 | FieldAttributes.Literal;
572
573 FieldBuilder fb = TypeBuilder.DefineField (name, TypeBuilder, attr);
574
575 if (default_value == null) {
576 Report.Error (30439, loc, "Enumerator value for '" + name + "' is too large to " +
577 "fit in its type");
578 return false;
579 }
580
581 try {
582 default_value = TypeManager.ChangeType (default_value, UnderlyingType);
583 } catch {
584 Error_ConstantValueCannotBeConverted (default_value, loc);
585 return false;
586 }
587
588 fb.SetConstant (default_value);
589 field_builders.Add (fb);
590 member_to_value [name] = default_value;
591
592 if (!TypeManager.RegisterFieldValue (fb, default_value))
593 return false;
594
595 //
596 // Now apply attributes
597 //
598 Attribute.ApplyAttributes (ec, fb, fb, (Attributes) member_to_attributes [name], loc);
599 }
600
601 default_value = GetNextDefaultValue (default_value);
602 }
603
604 Attribute.ApplyAttributes (ec, TypeBuilder, this, OptAttributes, Location);
605 return true;
606 }
607
608 //
609 // IMemberFinder
610 //
611 public override MemberList FindMembers (MemberTypes mt, BindingFlags bf,
612 MemberFilter filter, object criteria)
613 {
614 ArrayList members = new ArrayList ();
615
616 if ((mt & MemberTypes.Field) != 0) {
617 foreach (FieldBuilder fb in field_builders)
618 if (filter (fb, criteria) == true)
619 members.Add (fb);
620 }
621
622 return new MemberList (members);
623 }
624
625 public override MemberCache MemberCache {
626 get {
627 return null;
628 }
629 }
630
631 public ArrayList ValueNames {
632 get {
633 return ordered_enums;
634 }
635 }
636
637 // indexer
638 public Expression this [string name] {
639 get {
640 return (Expression) defined_names [name];
641 }
642 }
643 }
644 }
Mirror of the official Mono project git repository