protected void FormatProperties(TargetClassType type, TargetMemberAccessibility accessibility, List<string> members, string prefix, Hashtable hash) { FormatProperties (type, false, accessibility, members, prefix, hash); FormatProperties (type, true, accessibility, members, prefix, hash); }
protected void FormatMethods(TargetClassType type, bool is_ctor, bool is_static, TargetMemberAccessibility accessibility, List<string> members, string prefix, Hashtable hash) { List<TargetMethodInfo> list = new List<TargetMethodInfo> (); TargetMethodInfo[] methods = is_ctor ? type.Constructors : type.Methods; foreach (TargetMethodInfo method in methods) { if (method.IsStatic != is_static) continue; if (method.Accessibility != accessibility) continue; list.Add (method); } if (list.Count == 0) return; foreach (TargetMethodInfo method in list) members.Add (FormatMethod (prefix, method, is_static, is_ctor, hash)); }
protected void FormatProperties(TargetClassType type, bool is_static, TargetMemberAccessibility accessibility, List<string> members, string prefix, Hashtable hash) { List<TargetPropertyInfo> list = new List<TargetPropertyInfo> (); foreach (TargetPropertyInfo property in type.Properties) { if (property.IsStatic != is_static) continue; if (property.Accessibility != accessibility) continue; list.Add (property); } if (list.Count == 0) return; foreach (TargetPropertyInfo property in list) members.Add (FormatProperty (prefix, property, is_static, hash)); }
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; }
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 bool ImplicitReferenceConversionExists(ScriptingContext context, TargetClassType source, TargetClassType target) { if (source == target) return true; if (!source.HasParent) return false; TargetClassType parent_type = source.GetParentType (context.CurrentThread); return ImplicitReferenceConversionExists (context, parent_type, target); }
public static bool TryCast(ScriptingContext context, TargetType source, TargetClassType target_type) { if (source == target_type) return true; TargetClassType stype = Convert.ToClassType (source); if (stype == null) return false; return TryParentCast (context, stype, target_type); }
public override bool IsExceptionType(TargetClassType ctype) { MonoClassType mono_type = ctype as MonoClassType; if (mono_type == null) return false; Cecil.TypeDefinition exc_type = builtin_types.ExceptionType.Type; Cecil.TypeDefinition type = mono_type.Type; while (type != null) { if (exc_type == type) return true; type = resolve_cecil_type_ref (type.BaseType); } return false; }
internal void AddCoreType(Cecil.TypeDefinition typedef, TargetType type, TargetClassType klass, TargetAddress klass_address) { corlib.AddType (typedef, type); if (!class_hash.Contains (klass_address)) class_hash.Add (klass_address, type); }
public abstract bool IsExceptionType(TargetClassType type);
void do_read_variables(TargetMemoryAccess memory) { if (!is_loaded) throw new TargetException (TargetError.MethodNotLoaded); if (has_variables) return; MonoLanguageBackend mono = file.MonoLanguage; TargetAddress decl_klass = mono.MetadataHelper.MonoMethodGetClass ( memory, address.MonoMethod); TargetType decl = mono.ReadMonoClass (memory, decl_klass); if (decl.HasClassType) decl_type = decl.ClassType; else decl_type = (TargetClassType) decl; do_read_blocks (); locals = new List<TargetVariable> (); parameters = new List<TargetVariable> (); scopes = new Dictionary<int,ScopeInfo> (); var captured_vars = new Dictionary<string,CapturedVariable> (); if (address.HasThis) this_var = new MonoVariable ( "this", decl_type, true, true, this, address.ThisVariableInfo); var scope_list = new List<ScopeInfo> (); C.ScopeVariable[] scope_vars = method.GetScopeVariables (); int num_scope_vars = scope_vars != null ? scope_vars.Length : 0; for (int i = 0; i < num_scope_vars; i++) { C.ScopeVariable sv = scope_vars [i]; VariableInfo var; if (sv.Index < 0) { var = address.ThisVariableInfo; this_is_captured = true; this_var = null; } else var = address.LocalVariableInfo [sv.Index]; try { TargetClassType type = mono.ReadStructType (memory, var.MonoType); MonoVariable scope_var = new MonoVariable ( "$__" + sv.Scope, type, true, type.IsByRef, this, var); ScopeInfo info = new ScopeInfo (sv.Scope, scope_var, type); scopes.Add (sv.Scope, info); scope_list.Add (info); } catch (Exception ex) { Report.Error ("Cannot read scope variable: {0}\n{1}", var, ex); } } foreach (ScopeInfo scope in scope_list) { read_scope (scope); } foreach (ScopeInfo scope in scopes.Values) { C.AnonymousScopeEntry entry = file.File.GetAnonymousScope (scope.ID); foreach (C.CapturedVariable captured in entry.CapturedVariables) { CapturedVariable cv = new CapturedVariable ( scope, this, captured.Name, captured.CapturedName); switch (captured.Kind) { case C.CapturedVariable.CapturedKind.Local: locals.Add (cv); break; case C.CapturedVariable.CapturedKind.Parameter: parameters.Add (cv); break; case C.CapturedVariable.CapturedKind.This: if (!cv.Resolve (memory)) throw new InternalError (); if (cv.Type.HasClassType) decl_type = cv.Type.ClassType; else decl_type = (TargetClassType) cv.Type; this_var = cv; continue; default: throw new InternalError (); } captured_vars.Add (captured.Name, cv); } } var param_info = mdef.Parameters; for (int i = 0; i < param_info.Count; i++) { if (captured_vars.ContainsKey (param_info [i].Name)) continue; VariableInfo var = address.ParamVariableInfo [i]; TargetType type = mono.ReadType (memory, var.MonoType); if (type == null) type = mono.VoidType; parameters.Add (new MonoVariable ( param_info [i].Name, type, false, type.IsByRef, this, var, 0, 0)); } C.LocalVariableEntry[] symfile_locals = method.GetLocals (); for (int i = 0; i < symfile_locals.Length; i++) { C.LocalVariableEntry local = symfile_locals [i]; if (captured_vars.ContainsKey (local.Name)) continue; VariableInfo var = address.LocalVariableInfo [local.Index]; TargetType type = mono.ReadType (memory, var.MonoType); if (type == null) type = mono.VoidType; if (local.BlockIndex > 0) { int index = local.BlockIndex - 1; MonoCodeBlock block = code_blocks [index]; locals.Add (new MonoVariable ( local.Name, type, true, type.IsByRef, this, var, block.StartAddress, block.EndAddress)); } else { locals.Add (new MonoVariable ( local.Name, type, true, type.IsByRef, this, var)); } } has_variables = true; }
public static bool TryCast (MdbEvaluationContext ctx, TargetType source, TargetClassType target_type) { if (source == target_type) return true; TargetClassType stype = ToClassType (source); if (stype == null) return false; return TryParentCast (ctx, stype, target_type); }
public static TargetObject TryCast (MdbEvaluationContext ctx, TargetObject source, TargetClassType target_type) { if (source.Type == target_type) return source; TargetClassObject sobj = ToClassObject (ctx, source); if (sobj == null) return null; TargetStructObject result = TryParentCast (ctx, sobj, sobj.Type, target_type); if (result != null) return result; return TryCurrentCast (ctx, sobj, target_type); }
protected string FormatStruct(string prefix, TargetClassType type, Hashtable hash) { StringBuilder sb = new StringBuilder (); List<string> public_members = new List<string> (); List<string> protected_members = new List<string> (); List<string> internal_members = new List<string> (); List<string> private_members = new List<string> (); FormatFields (type, TargetMemberAccessibility.Public, public_members, prefix, hash); FormatFields (type, TargetMemberAccessibility.Protected, protected_members, prefix, hash); FormatFields (type, TargetMemberAccessibility.Internal, internal_members, prefix, hash); FormatFields (type, TargetMemberAccessibility.Private, private_members, prefix, hash); FormatProperties (type, TargetMemberAccessibility.Public, public_members, prefix, hash); FormatProperties (type, TargetMemberAccessibility.Protected, protected_members, prefix, hash); FormatProperties (type, TargetMemberAccessibility.Internal, internal_members, prefix, hash); FormatProperties (type, TargetMemberAccessibility.Private, private_members, prefix, hash); FormatEvents (type, TargetMemberAccessibility.Public, public_members, prefix, hash); FormatEvents (type, TargetMemberAccessibility.Protected, protected_members, prefix, hash); FormatEvents (type, TargetMemberAccessibility.Internal, internal_members, prefix, hash); FormatEvents (type, TargetMemberAccessibility.Private, private_members, prefix, hash); FormatMethods (type, TargetMemberAccessibility.Public, public_members, prefix, hash); FormatMethods (type, TargetMemberAccessibility.Protected, protected_members, prefix, hash); FormatMethods (type, TargetMemberAccessibility.Internal, internal_members, prefix, hash); FormatMethods (type, TargetMemberAccessibility.Private, private_members, prefix, hash); if (public_members.Count > 0) { sb.Append (prefix + "public:\n"); foreach (string text in public_members) sb.Append (text); } if (protected_members.Count > 0) { sb.Append (prefix + "protected:\n"); foreach (string text in protected_members) sb.Append (text); } if (internal_members.Count > 0) { sb.Append (prefix + "internal:\n"); foreach (string text in internal_members) sb.Append (text); } if (private_members.Count > 0) { sb.Append (prefix + "private:\n"); foreach (string text in private_members) sb.Append (text); } return sb.ToString (); }
bool IsSubclassOf(TargetMemoryAccess target, TargetClassType type, TargetType parent) { while (type != null) { if (type == parent) return true; if (!type.HasParent) return false; type = type.GetParentType (target); } return false; }
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); }
protected override bool DoResolve(ScriptingContext context) { Language language = CurrentFrame.Language; if (CurrentFrame.Language == null) throw new ScriptingException ("Current frame doesn't have a language."); TargetType exception_type = language.ExceptionType; if (exception_type == null) throw new ScriptingException ("Current language doesn't have any exceptions."); Expression expr = ParseExpression (context); if (expr == null) return false; expr = expr.ResolveType (context); if (expr == null) return false; type = expr.EvaluateType (context) as TargetClassType; if (!language.IsExceptionType (type)) throw new ScriptingException ("Type `{0}' is not an exception type.", expr.Name); if (tgroup == null) tgroup = context.Interpreter.GetThreadGroup (Group, false); return true; }
public static TargetObject TryCast(ScriptingContext context, TargetObject source, TargetClassType target_type) { if (source.Type == target_type) return source; TargetClassObject sobj = Convert.ToClassObject (context.CurrentThread, source); if (sobj == null) return null; TargetClassObject result = TryParentCast (context, sobj, sobj.Type, target_type); if (result != null) return result; return TryCurrentCast (context, sobj, target_type); }
protected void FormatEvents(TargetClassType type, bool is_static, TargetMemberAccessibility accessibility, List<string> members, string prefix, Hashtable hash) { List<TargetEventInfo> list = new List<TargetEventInfo> (); foreach (TargetEventInfo einfo in type.Events) { if (einfo.IsStatic != is_static) continue; if (einfo.Accessibility != accessibility) continue; list.Add (einfo); } if (list.Count == 0) return; foreach (TargetEventInfo einfo in list) members.Add (FormatEvent (prefix, einfo, is_static, hash)); }
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); }
protected void FormatFields(TargetClassType type, bool is_static, TargetMemberAccessibility accessibility, List<string> members, string prefix, Hashtable hash) { List<TargetFieldInfo> list = new List<TargetFieldInfo> (); foreach (TargetFieldInfo field in type.Fields) { if (field.IsStatic != is_static) continue; if (field.Accessibility != accessibility) continue; list.Add (field); } if (list.Count == 0) return; foreach (TargetFieldInfo field in list) members.Add (FormatMember (prefix, field, is_static, hash) + ";\n"); }
static bool TryParentCast(ScriptingContext context, TargetClassType source_type, TargetClassType target_type) { if (source_type == target_type) return true; if (!source_type.HasParent) return false; TargetClassType parent_type = source_type.GetParentType (context.CurrentThread); return TryParentCast (context, parent_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; }