Inheritance: TargetStructObject
Beispiel #1
0
        static TargetClassObject TryCurrentCast(ScriptingContext context,
							  TargetClassObject source,
							  TargetClassType target_type)
        {
            TargetClassObject current = source.GetCurrentObject (context.CurrentThread);
            if (current == null)
                return null;

            return TryParentCast (context, current, current.Type, target_type);
        }
Beispiel #2
0
        static TargetClassObject TryParentCast(ScriptingContext context,
							 TargetClassObject source,
							 TargetClassType source_type,
							 TargetClassType target_type)
        {
            if (source_type == target_type)
                return source;

            if (!source_type.HasParent)
                return null;

            TargetClassType parent_type = source_type.GetParentType (context.CurrentThread);
            source = TryParentCast (context, source, parent_type, target_type);
            if (source == null)
                return null;

            return source.GetParentObject (context.CurrentThread) as TargetClassObject;
        }
Beispiel #3
0
        string MonoObjectToString(TargetClassObject obj)
        {
            TargetClassType ctype = obj.Type;
            if ((ctype.Name == "System.Object") || (ctype.Name == "System.ValueType"))
                return null;

            string text, dummy;
            EE.EvaluationResult result;

            if (ctype.DebuggerDisplayAttribute != null) {
                result = HandleDebuggerDisplay (Interpreter, CurrentThread, obj,
                                ctype.DebuggerDisplayAttribute,
                                -1, out text, out dummy);
                if (result == EE.EvaluationResult.Ok)
                    return String.Format ("{{ {0} }}", text);
                else if (result == EE.EvaluationResult.InvalidExpression) {
                    if (text != null)
                        return text;
                }
            }

            result = EE.MonoObjectToString (CurrentThread, obj, EE.EvaluationFlags.None, -1, out text);
            if (result == EE.EvaluationResult.Ok)
                return String.Format ("{{ \"{0}\" }}", text);
            return null;
        }
Beispiel #4
0
        static TargetObject ImplicitReferenceConversion(ScriptingContext context,
								 TargetClassObject obj,
								 TargetClassType type)
        {
            if (obj.Type == type)
                return obj;

            if (!obj.Type.HasParent)
                return null;

            return obj.GetParentObject (context.CurrentThread);
        }
Beispiel #5
0
        protected void FormatStructObject(Thread target, TargetClassObject obj)
        {
            bool first = true;

            TargetClass class_info = obj.Type.GetClass (target);
            if (class_info != null)
                FormatClassObject (target, obj, class_info, ref first);
        }
Beispiel #6
0
        protected void FormatClassObject(Thread target, TargetClassObject obj,
						  TargetClass class_info, ref bool first)
        {
            Append ("{ ");
            indent_level += 3;

            if (obj.Type.HasParent) {
                TargetClassObject parent = obj.GetParentObject (target);
                if ((parent != null) && (parent.Type != parent.Type.Language.ObjectType)) {
                    Append ("<{0}> = ", parent.Type.Name);
                    CheckLineWrap ();
                    FormatStructObject (target, parent);
                    first = false;
                }
            }

            TargetFieldInfo[] fields = class_info.GetFields (target);
            for (int i = 0; i < fields.Length; i++) {
                if (fields [i].IsStatic || fields [i].HasConstValue)
                    continue;
                if (fields [i].IsCompilerGenerated)
                    continue;
                if (fields [i].DebuggerBrowsableState == DebuggerBrowsableState.Never)
                    continue;

                if (!first) {
                    Append (", ");
                    CheckLineWrap ();
                }
                first = false;
                Append (fields [i].Name + " = ");
                try {
                    TargetObject fobj = class_info.GetField (target, obj, fields [i]);
                    if (fobj == null)
                        Append ("null");
                    else
                        FormatObjectRecursed (target, fobj, true);
                } catch {
                    Append ("<cannot display object>");
                }
            }

            Append (first ? "}" : " }");
            indent_level -= 3;
        }
		static TargetStructObject TryCurrentCast (MdbEvaluationContext ctx, TargetClassObject source, TargetClassType target_type)
		{
			TargetStructObject current = source.GetCurrentObject (ctx.Thread);
			if (current == null)
				return null;

			return TryParentCast (ctx, current, current.Type, target_type);
		}
		static TargetObject ImplicitReferenceConversion (MdbEvaluationContext ctx,
								 TargetClassObject obj,
								 TargetClassType type)
		{
			if (obj.Type == type)
				return obj;

			if (obj.Type.HasParent) {
				TargetObject pobj = obj.GetParentObject (ctx.Thread);
				if (pobj != null) {
					pobj = ImplicitConversion (ctx, pobj, type);
					if (pobj != null)
						return pobj;
				}
			}
			
			if (ImplicitReferenceConversionExists (ctx, obj.Type, type))
				return obj;
			return null;
		}
		public ClassVariable(string name, StackFrame stackFrame, TargetClassObject obj)
		{
			this.name = name;
			this.stackFrame = stackFrame;
			this.obj = obj;
		}