public static bool CheckForCollection(DebugType type) { string name = type.FullName; int ind = name.IndexOf('<'); if (ind != -1) name = name.Substring(0, ind); return ht[name] != null; }
internal PropertyInfo(DebugType declaringType,string name, MethodInfo getMethod, MethodInfo setMethod): base(declaringType) { if (getMethod == null && setMethod == null) throw new ArgumentNullException("Both getter and setter can not be null."); this.name = name; this.getMethod = getMethod; this.setMethod = setMethod; }
public ValueItem(NamedValue val, DebugType declaringType) { this.val = val; this.declaringType = declaringType; try { //this.primitive = val.IsPrimitive; } catch(System.Exception e) { if (val.Type.IsByRef()) this.primitive = false; } val.Changed += delegate { OnChanged(new ListItemEventArgs(this)); }; }
public ValueItem(Value val, string name, DebugType declaringType) { this.val = val; this.declaringType = declaringType; this.name = name; val.Changed += delegate { OnChanged(new ListItemEventArgs(this)); }; }
public BaseTypeItem(DebugType type, Type mt) { this.type = type; this.managed_type = mt; // if (mt.IsValueType) // this.imageIndex = CodeCompletionProvider.ImagesProvider.IconNumberStruct; // else this.imageIndex = CodeCompletionProvider.ImagesProvider.IconNumberClass; }
IEnumerable<NamedValue> GetObjectMembersEnum(DebugType type, BindingFlags bindingFlags) { DebugType currentType = type ?? this.Type; while (currentType != null) { foreach(FieldInfo field in currentType.GetFields(bindingFlags)) { yield return field.GetValue(this); } foreach(PropertyInfo property in currentType.GetProperties(bindingFlags)) { yield return property.GetValue(this); } if (type == null) { currentType = currentType.BaseType; } else { yield break; } } }
public override void visit(dot_node _dot_node) { bool tmp2 = by_dot; by_dot = true; _dot_node.left.visit(this); by_dot = tmp2; RetValue rv = eval_stack.Pop(); RetValue res = new RetValue(); if (rv.obj_val != null) { if (rv.obj_val.Dereference != null) rv.obj_val = rv.obj_val.Dereference; if (_dot_node.right is ident) { if (rv.obj_val.IsNull) throw new CommonEvaluationError(new NullReferenceException()); ident id = _dot_node.right as ident; names.Add("." + id.name); //IList<Debugger.MemberInfo> members = rv.obj_val.Type.GetMember(id.name, BindingFlags.All); if (rv.obj_val.IsArray) { if (string.Compare(id.name, "Length", true) == 0) res.prim_val = rv.obj_val.ArrayLenght; else if (string.Compare(id.name, "Rank", true) == 0) res.prim_val = rv.obj_val.ArrayRank; } else { res.obj_val = rv.obj_val.GetMember(id.name); if (res.obj_val == null) throw new UnknownName(id.name); if (res.obj_val is MemberValue && (res.obj_val as MemberValue).MemberInfo is PropertyInfo) last_obj = rv.obj_val; } declaringType = rv.obj_val.Type; } } else if (_dot_node.right is ident) { ident id = _dot_node.right as ident; names.Add("." + id.name); string name = build_name(_dot_node.left); if (name != null) { Type t = AssemblyHelper.GetType(name); if (t != null) { //DebugType dt = DebugType.Create(this.debuggedProcess.GetModule(name),(uint)t.MetadataToken); DebugType dt = DebugUtils.GetDebugType(t); IList<MemberInfo> mis = new List<MemberInfo>();//dt.GetMember(id.name,BindingFlags.All); declaringType = dt; DebugType tmp = dt; while (tmp != null && mis.Count == 0) { try { mis = tmp.GetMember(id.name, BindingFlags.All); tmp = tmp.BaseType; } catch { } } if (mis.Count > 0) { if (mis[0] is FieldInfo) { FieldInfo fi = mis[0] as FieldInfo; res.obj_val = fi.GetValue(null); if (res.obj_val == null) throw new UnknownName(id.name); check_for_static(res.obj_val, id.name); } else if (mis[0] is PropertyInfo) { PropertyInfo pi = mis[0] as PropertyInfo; res.obj_val = pi.GetValue(null); if (res.obj_val == null) throw new UnknownName(id.name); check_for_static(res.obj_val, id.name); } } else { System.Reflection.FieldInfo fi = t.GetField(id.name); if (fi != null) res.prim_val = fi.GetRawConstantValue(); else throw new UnknownName(id.name); } } else { t = AssemblyHelper.GetType(name + "." + id.name); if (t != null) { res.type = DebugUtils.GetDebugType(t);//DebugType.Create(this.debuggedProcess.GetModule(name),(uint)t.MetadataToken); res.managed_type = t; } // else // throw new UnknownName(id.name); } } } eval_stack.Push(res); }
public RetValue GetValueForExpression(string expr, out string preformat) { declaringType = null; for_immediate = false; ret_val = default(RetValue); preformat = expr.Trim(' ', '\n', '\r', '\t'); names.Clear(); string fileName = "test" + System.IO.Path.GetExtension(this.FileName); List<PascalABCCompiler.Errors.Error> Errors = new List<PascalABCCompiler.Errors.Error>(); expression e = vec.StandartCompiler.ParsersController.GetExpression(fileName, expr, Errors); RetValue res = new RetValue(); res.syn_err = false; try { if (e != null && Errors.Count == 0) { e.visit(this); if (eval_stack.Count > 0) { res = eval_stack.Pop(); preformat = string.Join("", names.ToArray()); return res; } } } catch (System.Exception ex) { //throw new System.Exception(ex.Message); } finally { if (eval_stack.Count > 0) eval_stack.Clear(); } return new RetValue(); }
/// <summary> Determines whether the current type is sublass of /// the the given type. That is, it derives from the given type. </summary> /// <remarks> Returns false if the given type is same as the current type </remarks> public bool IsSubclassOf(DebugType superType) { DebugType type = this; while (type != null) { if (type.Equals(superType)) return true; if (superType.IsInterface) { // Does this 'type' implement the interface? foreach(DebugType inter in type.Interfaces) { if (inter == superType) return true; } } type = type.BaseType; } return false; }
public static string WrapTypeName(DebugType type) { if (type.IsArray) if (WorkbenchServiceFactory.DebuggerManager.parser != null) return WorkbenchServiceFactory.DebuggerManager.parser.LanguageInformation.GetArrayDescription(WrapTypeName(type.GetElementType()), type.GetArrayRank()); else return "array of " + WrapTypeName(type.GetElementType()); return internalWrapTypeName(type.FullName); }
public static bool IsSortedList(DebugType type) { return type.FullName == "System.Collections.SortedList" || type.FullName.StartsWith("System.Collections.Generic.SortedList"); }
internal FieldInfo(DebugType declaringType, FieldProps fieldProps) : base(declaringType) { this.fieldProps = fieldProps; }
internal MemberInfo(DebugType declaringType) { this.declaringType = declaringType; }
static Value GetLiteralValue(DebugFieldInfo fieldInfo) { CorElementType corElemType = (CorElementType)fieldInfo.FieldProps.ConstantType; if (corElemType == CorElementType.CLASS) { // Only null literals are allowed return(Eval.CreateValue(fieldInfo.AppDomain, null)); } else if (corElemType == CorElementType.STRING) { string str = Marshal.PtrToStringUni(fieldInfo.FieldProps.ConstantPtr, (int)fieldInfo.FieldProps.ConstantStringLength); return(Eval.CreateValue(fieldInfo.AppDomain, str)); } else { DebugType type = DebugType.CreateFromType(fieldInfo.AppDomain.Mscorlib, DebugType.CorElementTypeToManagedType(corElemType)); if (fieldInfo.FieldType.IsEnum && fieldInfo.FieldType.GetEnumUnderlyingType() == type) { Value val = Eval.NewObjectNoConstructor((DebugType)fieldInfo.FieldType); Value backingField = val.GetMemberValue("value__"); backingField.CorGenericValue.SetValue(fieldInfo.FieldProps.ConstantPtr); return(val); } else { Value val = Eval.NewObjectNoConstructor(type); val.CorGenericValue.SetValue(fieldInfo.FieldProps.ConstantPtr); return(val); } } }
public static MethodInfo GetMethod(DebugType t, string name) { return t.GetMember(name, Debugger.BindingFlags.All)[0] as MethodInfo; }
public static List<DebugType> GetUsesTypes(Process p, DebugType dt) { if (unit_debug_types == null) { unit_debug_types = new List<DebugType>(); foreach (Type t in unit_types) unit_debug_types.Add(DebugType.Create(p.GetModule(t.Assembly.ManifestModule.ScopeName),(uint)t.MetadataToken)); } return unit_debug_types; }
public static PropertyInfo GetProperty(DebugType t, string name) { return t.GetMember(name, Debugger.BindingFlags.All)[0] as PropertyInfo; }
/*static Eval CreateEval(Process process, string description, EvalStarter evalStarter) { ICorDebugEval corEval = CreateCorEval(process); Eval newEval = new Eval(process, description, corEval); try { evalStarter(newEval); } catch (COMException e) { if ((uint)e.ErrorCode == 0x80131C26) { throw new GetValueException("Can not evaluate in optimized code"); } else if ((uint)e.ErrorCode == 0x80131C28) { throw new GetValueException("Object is in wrong AppDomain"); } else if ((uint)e.ErrorCode == 0x8013130A) { // Happens on getting of Sytem.Threading.Thread.ManagedThreadId; See SD2-1116 throw new GetValueException("Function does not have IL code"); } else if ((uint)e.ErrorCode == 0x80131C23) { // The operation failed because it is a GC unsafe point. (Exception from HRESULT: 0x80131C23) // This can probably happen when we break and the thread is in native code throw new GetValueException("Thread is in GC unsafe point"); } else { throw; } } process.NotifyEvaluationStarted(newEval); process.AsyncContinue(DebuggeeStateAction.Keep); return newEval; }*/ public static Eval AsyncNewObjectNoConstructor(DebugType debugType) { return new Eval( debugType.Process, "New object: " + debugType.FullName, delegate(ICorDebugEval corEval) { corEval.CastTo<ICorDebugEval2>().NewParameterizedObjectNoConstructor(debugType.CorType.Class, (uint)debugType.GenericArguments.Count, debugType.GenericArgumentsAsCorDebugType); } ); }
public static bool IsQueue(DebugType type) { return type.FullName == "System.Collections.Queue" || type.FullName.StartsWith("System.Collections.Generic.Queue"); }
private string get_type_name(DebugType t) { string name = t.FullName; int ind = name.IndexOf('<'); if (ind != -1) { name = name.Substring(0, ind); name += "`" + t.GetGenericArguments().Length.ToString(); } return name; }
public static bool IsHashtable(DebugType type) { return type.FullName == "System.Collections.Hashtable"; }
private MethodInfo select_method(MethodInfo[] meths, DebugType[] args) { if (meths.Length > 0) return meths[0]; return null; }
public static bool IsLinkedList(DebugType type) { return type.FullName.StartsWith("System.Collections.Generic.LinkedList"); }
/// <summary> /// Get fields and properties of an object which are defined by a given type. /// </summary> /// <param name="type"> Limit to type, null for all types </param> /// <param name="bindingFlags"> Get only members with certain flags </param> public NamedValueCollection GetMembers(DebugType type, BindingFlags bindingFlags) { if (IsObject) { return new NamedValueCollection(GetObjectMembersEnum(type, bindingFlags)); } else { return NamedValueCollection.Empty; } }
public static bool IsDictionary(DebugType type) { return type.FullName.StartsWith("System.Collections.Generic.Dictionary"); }
public BaseTypeItem(Value val, DebugType type) { this.val = val; this.type = type; }
internal MethodInfo(DebugType declaringType, MethodProps methodProps) : base(declaringType) { this.methodProps = methodProps; }
public ValueItem(Value val, string name, DebugType declaringType, bool is_in_collect) { this.val = val; this.declaringType = declaringType; this.name = name; if (is_in_collect) this.imageIndex = 1; val.Changed += delegate { OnChanged(new ListItemEventArgs(this)); }; }
public static Value NewObjectNoConstructor(DebugType debugType) { return(AsyncNewObjectNoConstructor(debugType).EvaluateNow()); }
public ArrayValueItem(NamedValue val, DebugType type, Value arr, Value sz_arr, int ind):base(val,type) { this.arr = arr; this.ind = ind; System.Reflection.FieldInfo tmp_fi = AssemblyHelper.GetType(arr.Type.FullName).GetField("LowerIndex"); if (!tmp_fi.FieldType.IsEnum) low_bound = tmp_fi.GetRawConstantValue(); else low_bound = tmp_fi.GetValue(sz_arr); }
/// <exception cref="GetValueException"><c>GetValueException</c>.</exception> static void MethodInvokeStarter(Eval eval, DebugMethodInfo method, Value thisValue, Value[] args) { List <ICorDebugValue> corArgs = new List <ICorDebugValue>(); args = args ?? new Value[0]; if (args.Length != method.ParameterCount) { throw new GetValueException("Invalid parameter count"); } if (!method.IsStatic) { if (thisValue == null) { throw new GetValueException("'this' is null"); } if (thisValue.IsNull) { throw new GetValueException("Null reference"); } // if (!(thisValue.IsObject)) // eg Can evaluate on array if (!method.DeclaringType.IsInstanceOfType(thisValue)) { throw new GetValueException( "Can not evaluate because the object is not of proper type. " + "Expected: " + method.DeclaringType.FullName + " Seen: " + thisValue.Type.FullName ); } corArgs.Add(thisValue.CorValue); } for (int i = 0; i < args.Length; i++) { Value arg = args[i]; DebugType paramType = (DebugType)method.GetParameters()[i].ParameterType; if (!arg.Type.CanImplicitelyConvertTo(paramType)) { throw new GetValueException("Inncorrect parameter type"); } // Implicitely convert to correct primitve type if (paramType.IsPrimitive && args[i].Type != paramType) { object oldPrimVal = arg.PrimitiveValue; object newPrimVal = Convert.ChangeType(oldPrimVal, paramType.PrimitiveType); arg = CreateValue(method.AppDomain, newPrimVal); } // It is importatnt to pass the parameted in the correct form (boxed/unboxed) if (paramType.IsValueType) { corArgs.Add(arg.CorGenericValue); } else { if (args[i].Type.IsValueType) { corArgs.Add(arg.Box().CorValue); } else { corArgs.Add(arg.CorValue); } } } ICorDebugType[] genericArgs = ((DebugType)method.DeclaringType).GenericArgumentsAsCorDebugType; eval.CorEval2.CallParameterizedFunction( method.CorFunction, (uint)genericArgs.Length, genericArgs, (uint)corArgs.Count, corArgs.ToArray() ); }
internal FieldInfo(DebugType declaringType, FieldProps fieldProps):base (declaringType) { this.fieldProps = fieldProps; }
public static Value NewArray(DebugType type, uint length, uint?lowerBound) { return(AsyncNewArray(type, length, lowerBound).WaitForResult()); }
/// <summary> Obtains instance of DebugType. Same types will return identical instance. </summary> static internal DebugType Create(Process process, ICorDebugType corType) { DateTime startTime = Util.HighPrecisionTimer.Now; DebugType type = new DebugType(process, corType); // Get types with matching names from cache List<DebugType> typesWithMatchingName; if (!loadedTypes.TryGetValue(type.FullName, out typesWithMatchingName)) { // No types with such name - create a new list typesWithMatchingName = new List<DebugType>(1); loadedTypes.Add(type.FullName, typesWithMatchingName); } // Try to find the type foreach(DebugType loadedType in typesWithMatchingName) { if (loadedType.Equals(type)) { TimeSpan totalTime = Util.HighPrecisionTimer.Now - startTime; //process.TraceMessage("Type " + type.FullName + " was loaded already (" + totalTime.TotalMilliseconds + " ms)"); return loadedType; // Type was loaded before } } // The type is not in the cache, finish loading it and add it to the cache if (type.IsClass || type.IsValueType || type.ManagedType == typeof(string)) { type.LoadMemberInfo(); } typesWithMatchingName.Add(type); type.Process.Expired += delegate { typesWithMatchingName.Remove(type); }; TimeSpan totalTime2 = Util.HighPrecisionTimer.Now - startTime; process.TraceMessage("Loaded type " + type.FullName + " (" + totalTime2.TotalMilliseconds + " ms)"); return type; }
public static Value NewObjectNoConstructor(DebugType debugType) { return(AsyncNewObjectNoConstructor(debugType).WaitForResult()); }
internal MethodInfo(DebugType declaringType, MethodProps methodProps):base (declaringType) { this.methodProps = methodProps; }
public static Value NewObjectNoConstructor(DebugType debugType) { return AsyncNewObjectNoConstructor(debugType).EvaluateNow(); }