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 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);
}
