public static TargetObject ImplicitConversion(MdbEvaluationContext ctx, TargetObject obj, TargetType type) { if (obj.Type.Equals(type)) { return(obj); } if (type is TargetObjectType || ObjectUtil.FixTypeName(type.Name) == "System.Object") { if (obj.Type.IsByRef) { return(obj); } return(BoxValue(ctx, obj)); } if (obj is TargetEnumObject && type is TargetFundamentalType) { TargetEnumObject e = (TargetEnumObject)obj; return(ImplicitConversion(ctx, e.GetValue(ctx.Thread), type)); } if (type is TargetEnumType) { TargetEnumType e = (TargetEnumType)type; return(ImplicitConversion(ctx, obj, e.Value.Type)); } if (obj is TargetArrayObject && type.Name == "System.Array") { return(obj); } if (obj is TargetArrayObject && type is TargetArrayType) { TargetArrayObject sa = (TargetArrayObject)obj; TargetArrayType ta = (TargetArrayType)type; if (sa.Type.ElementType.Equals(ta.ElementType)) { return(obj); } } if ((obj is TargetFundamentalObject) && (type is TargetFundamentalType)) { return(ImplicitFundamentalConversion( ctx, (TargetFundamentalObject)obj, (TargetFundamentalType)type)); } if ((obj is TargetClassObject) && (type is TargetClassType)) { return(ImplicitReferenceConversion( ctx, (TargetClassObject)obj, (TargetClassType)type)); } return(null); }
public static TargetClassType ToClassType(TargetType type) { TargetClassType ctype = type as TargetClassType; if (ctype != null) { return(ctype); } TargetObjectType otype = type as TargetObjectType; if (otype != null && otype.HasClassType) { ctype = otype.ClassType; if (ctype != null) { return(ctype); } } TargetArrayType atype = type as TargetArrayType; if (atype != null) { if (atype.Language.ArrayType != null) { return(atype.Language.ArrayType); } } throw new Exception(string.Format("Type `{0}' is not a struct or class.", type.Name)); }
public static bool ImplicitConversionExists(MdbEvaluationContext ctx, TargetType source, TargetType target) { if (source.Equals(target)) { return(true); } if (source is TargetArrayType && target.Name == "System.Array") { return(true); } if (ObjectUtil.FixTypeName(target.Name) == "System.Object") { return(true); } if (source is TargetArrayType && target is TargetArrayType) { TargetArrayType sa = (TargetArrayType)source; TargetArrayType ta = (TargetArrayType)target; return(sa.ElementType.Equals(ta.ElementType)); } if (source is TargetEnumType) { TargetEnumType e = (TargetEnumType)source; if (ImplicitConversionExists(ctx, e.Value.Type, target)) { return(true); } } if (target is TargetEnumType) { TargetEnumType e = (TargetEnumType)target; if (ImplicitConversionExists(ctx, source, e.Value.Type)) { return(true); } } if ((source is TargetFundamentalType) && (target is TargetFundamentalType)) { return(ImplicitFundamentalConversionExists( (TargetFundamentalType)source, (TargetFundamentalType)target)); } if ((source is TargetClassType) && (target is TargetClassType)) { return(ImplicitReferenceConversionExists( ctx, (TargetClassType)source, (TargetClassType)target)); } return(false); }
protected string FormatType(Thread target, string prefix, TargetType type, Hashtable hash) { string retval; if (hash == null) { hash = new Hashtable(); } if (hash.Contains(type)) { return(type.Name); } else { hash.Add(type, true); } switch (type.Kind) { case TargetObjectKind.Array: { TargetArrayType atype = (TargetArrayType)type; retval = atype.Name; break; } case TargetObjectKind.Enum: { StringBuilder sb = new StringBuilder(); TargetEnumType etype = type as TargetEnumType; sb.Append("enum "); if (etype.Name != null) { sb.Append(etype.Name); } sb.Append("\n" + prefix + "{\n"); foreach (TargetEnumInfo field in etype.Members) { sb.Append(FormatEnumMember(target, prefix, field, false, hash)); if (field != etype.Members[etype.Members.Length - 1]) { sb.Append(","); } sb.Append("\n"); } sb.Append(prefix + "}"); retval = sb.ToString(); break; } case TargetObjectKind.Class: case TargetObjectKind.Struct: { StringBuilder sb = new StringBuilder(); TargetClassType ctype = (TargetClassType)type; if (type.Kind == TargetObjectKind.Struct) { sb.Append("struct "); } else { sb.Append("class "); } if (ctype.Name != null) { sb.Append(ctype.Name); sb.Append(" "); } if (ctype.HasParent) { TargetClassType parent = ctype.GetParentType(target); sb.Append(": "); sb.Append(parent.Name); } sb.Append("\n" + prefix + "{\n"); sb.Append(FormatStruct(prefix, ctype, hash)); sb.Append(prefix + "}"); retval = sb.ToString(); break; } case TargetObjectKind.Alias: { TargetTypeAlias alias = (TargetTypeAlias)type; string name; if (alias.TargetType != null) { name = FormatType(target, prefix, alias.TargetType, hash); } else { name = "<unknown type>"; } retval = String.Format("typedef {0} = {1}", alias.Name, name); break; } case TargetObjectKind.GenericInstance: { TargetGenericInstanceType gtype = (TargetGenericInstanceType)type; StringBuilder sb = new StringBuilder(); if (gtype.ContainerType.Kind == TargetObjectKind.Struct) { sb.Append("struct "); } else { sb.Append("class "); } sb.Append(String.Format("{0} = ", gtype.Name)); TargetClassType parent = gtype.ContainerType.GetParentType(target); sb.Append(String.Format("{0}", gtype.ContainerType.Name)); if (parent != null) { sb.Append(String.Format(" : {0}", parent.Name)); } sb.Append("\n" + prefix + "{\n"); sb.Append(FormatStruct(prefix, gtype.ContainerType, hash)); sb.Append(prefix + "}"); retval = sb.ToString(); break; } default: retval = type.Name; break; } hash.Remove(type); return(retval); }