public int SetThreadName(string pszName) { #if HIDE_THREADS return(VSConstants.S_OK); #endif if (_setThreadNameMethod == null) { IClassType type = (IClassType)_thread.GetReferenceType(); _setThreadNameMethod = type.GetConcreteMethod("setName", "(Ljava/lang/String;)V"); } if (_setThreadNameMethod == null) { return(VSConstants.E_FAIL); } using (var stringValue = _program.VirtualMachine.GetMirrorOf(pszName)) { using (_thread.InvokeMethod(null, _setThreadNameMethod, InvokeOptions.None, stringValue.Value)) { return(VSConstants.S_OK); } } }
public int GetThreadPriorityId(out int priorityId) { #if HIDE_THREADS priorityId = 0; return(VSConstants.S_OK); #endif if (_getPriorityMethod == null) { IClassType type = (IClassType)_thread.GetReferenceType(); _getPriorityMethod = type.GetConcreteMethod("getPriority", "()I"); } priorityId = 0; if (_getPriorityMethod == null) { return(VSConstants.E_FAIL); } try { using (var result = _thread.InvokeMethod(null, _getPriorityMethod, InvokeOptions.SingleThreaded)) { priorityId = ((IIntegerValue)result.Value).GetValue(); return(VSConstants.S_OK); } } catch (DebuggerException) { priorityId = 0; return(VSConstants.E_FAIL); } }
public int GetThreadId(out uint pdwThreadId) { #if HIDE_THREADS pdwThreadId = 0; return(VSConstants.S_OK); #endif if (_getIdMethod == null) { IClassType type = (IClassType)_thread.GetReferenceType(); _getIdMethod = type.GetConcreteMethod("getId", "()J"); } pdwThreadId = 0; if (_getIdMethod == null) { return(VSConstants.E_FAIL); } try { using (var result = _thread.InvokeMethod(null, _getIdMethod, InvokeOptions.SingleThreaded)) { pdwThreadId = (uint)((ILongValue)result.Value).GetValue(); return(VSConstants.S_OK); } } catch (DebuggerException) { pdwThreadId = 0; return(VSConstants.E_FAIL); } }
private static bool TryGetCollectionValues(IObjectReference objectReference, out ReadOnlyCollection <IValue> values, out IType elementType) { IArrayReference arrayReference = objectReference as IArrayReference; if (arrayReference == null) { int size; if (TryGetCollectionSize(objectReference, out size)) { IClassType classType = objectReference.GetReferenceType() as IClassType; if (classType != null) { IObjectReference collectionObject = null; ReadOnlyCollection <IInterfaceType> interfaces = classType.GetInterfaces(true); if (interfaces.Any(i => i.GetName() == "java.util.Collection")) { collectionObject = objectReference; } else if (interfaces.Any(i => i.GetName() == "java.util.Map")) { IMethod entrySetMethod = classType.GetConcreteMethod("entrySet", "()Ljava/util/Set;"); IStrongValueHandle <IValue> result = objectReference.InvokeMethod(null, entrySetMethod, InvokeOptions.None); if (result != null) { collectionObject = result.Value as IObjectReference; } } if (collectionObject != null) { IClassType collectionObjectType = collectionObject.GetReferenceType() as IClassType; if (collectionObjectType != null) { IMethod toArrayMethod = collectionObjectType.GetConcreteMethod("toArray", "()[Ljava/lang/Object;"); IStrongValueHandle <IValue> result = collectionObject.InvokeMethod(null, toArrayMethod, InvokeOptions.None); if (result != null) { arrayReference = result.Value as IArrayReference; } } } } } } if (arrayReference != null) { values = arrayReference.GetValues(); IArrayType arrayType = (IArrayType)arrayReference.GetReferenceType(); elementType = arrayType.GetComponentType(); return(true); } values = null; elementType = null; return(false); }
private EvaluatedExpression FindClass(string signature) { Contract.Requires <ArgumentNullException>(signature != null, "signature"); Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(signature)); Contract.Ensures(Contract.Result <EvaluatedExpression>() != null); switch (signature[0]) { case 'Z': return(GetField(GetReflectedType(FindClass("Ljava/lang/Boolean;")), "TYPE")); case 'B': return(GetField(GetReflectedType(FindClass("Ljava/lang/Byte;")), "TYPE")); case 'C': return(GetField(GetReflectedType(FindClass("Ljava/lang/Character;")), "TYPE")); case 'D': return(GetField(GetReflectedType(FindClass("Ljava/lang/Double;")), "TYPE")); case 'F': return(GetField(GetReflectedType(FindClass("Ljava/lang/Float;")), "TYPE")); case 'I': return(GetField(GetReflectedType(FindClass("Ljava/lang/Integer;")), "TYPE")); case 'J': return(GetField(GetReflectedType(FindClass("Ljava/lang/Long;")), "TYPE")); case 'S': return(GetField(GetReflectedType(FindClass("Ljava/lang/Short;")), "TYPE")); case 'V': return(GetField(GetReflectedType(FindClass("Ljava/lang/Void;")), "TYPE")); case '[': case 'L': if (_classForNameMethod == null) { _javaLangClassClass = (IClassType)_stackFrame.GetVirtualMachine().GetClassesByName("java.lang.Class").Single(); _classForNameMethod = _javaLangClassClass.GetConcreteMethod("forName", "(Ljava/lang/String;)Ljava/lang/Class;"); } if (signature[0] != '[') { signature = SignatureHelper.DecodeTypeName(signature); } using (var signatureValue = _stackFrame.GetVirtualMachine().GetMirrorOf(signature)) { var result = _javaLangClassClass.InvokeMethod(null, _classForNameMethod, InvokeOptions.None, signatureValue.Value); return(new EvaluatedExpression(signature, signature, result.Value, true)); } default: throw new ArgumentException(); } }
private static bool TryGetCollectionSize(IObjectReference objectReference, out int size) { size = 0; IArrayReference arrayReference = objectReference as IArrayReference; if (arrayReference != null) { size = arrayReference.GetLength(); return(true); } IClassType classType = objectReference.GetReferenceType() as IClassType; if (classType == null) { return(false); } ReadOnlyCollection <IInterfaceType> interfaces = classType.GetInterfaces(true); if (interfaces.Any(i => _collectionInterfaces.Contains(i.GetName()))) { IMethod sizeMethod = classType.GetConcreteMethod("size", "()I"); using (IStrongValueHandle <IValue> result = objectReference.InvokeMethod(null, sizeMethod, InvokeOptions.None)) { if (result == null) { return(false); } IIntegerValue integerValue = result.Value as IIntegerValue; if (integerValue != null) { size = integerValue.GetValue(); return(true); } } } return(false); }
/// <summary> /// Gets the DEBUG_PROPERTY_INFO structure that describes a property. /// </summary> /// <param name="dwFields">[in] A combination of values from the DEBUGPROP_INFO_FLAGS enumeration that specifies which fields are to be filled out in the pPropertyInfo structure.</param> /// <param name="dwRadix">[in] Radix to be used in formatting any numerical information.</param> /// <param name="dwTimeout">[in] Specifies the maximum time, in milliseconds, to wait before returning from this method. Use INFINITE to wait indefinitely.</param> /// <param name="rgpArgs">[in, out] Reserved for future use; set to a null value.</param> /// <param name="dwArgCount">[in] Reserved for future use; set to zero.</param> /// <param name="pPropertyInfo">[out] A DEBUG_PROPERTY_INFO structure that is filled in with the description of the property.</param> /// <returns>If successful, returns S_OK; otherwise returns error code.</returns> public int GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo) { if (pPropertyInfo == null) { throw new ArgumentNullException("pPropertyInfo"); } if (pPropertyInfo.Length == 0) { throw new ArgumentException(); } bool getFullName = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME) != 0; bool getName = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME) != 0; bool getType = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE) != 0; bool getValue = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE) != 0; bool getAttributes = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB) != 0; bool getProperty = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_PROP) != 0; bool useAutoExpandValue = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_AUTOEXPAND) != 0; bool noFormatting = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_RAW) != 0; bool noToString = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_NO_TOSTRING) != 0; if (getFullName) { pPropertyInfo[0].bstrFullName = _evaluatedExpression.FullName; pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME; } if (getName) { pPropertyInfo[0].bstrName = _evaluatedExpression.Name; pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME; } if (getType) { pPropertyInfo[0].bstrType = _evaluatedExpression.ValueType.GetName(); if (_evaluatedExpression.Value != null && !_evaluatedExpression.Value.GetValueType().Equals(_evaluatedExpression.ValueType)) { pPropertyInfo[0].bstrType += " {" + _evaluatedExpression.Value.GetValueType().GetName() + "}"; } pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE; } if (getValue) { if (_evaluatedExpression.Value == null) { pPropertyInfo[0].bstrValue = "null"; } if (_evaluatedExpression.Value is IVoidValue) { pPropertyInfo[0].bstrValue = "The expression has been evaluated and has no value."; } else if (_evaluatedExpression.Value is IPrimitiveValue) { IBooleanValue booleanValue = _evaluatedExpression.Value as IBooleanValue; if (booleanValue != null) { pPropertyInfo[0].bstrValue = booleanValue.GetValue().ToString().ToLowerInvariant(); pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_BOOLEAN; if (booleanValue.GetValue()) { pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_BOOLEAN_TRUE; } } IByteValue byteValue = _evaluatedExpression.Value as IByteValue; if (byteValue != null) { pPropertyInfo[0].bstrValue = byteValue.GetValue().ToString(); } ICharValue charValue = _evaluatedExpression.Value as ICharValue; if (charValue != null) { pPropertyInfo[0].bstrValue = EscapeSpecialCharacters(charValue.GetValue().ToString(), 10, '\''); } IShortValue shortValue = _evaluatedExpression.Value as IShortValue; if (shortValue != null) { pPropertyInfo[0].bstrValue = shortValue.GetValue().ToString(); } IIntegerValue integerValue = _evaluatedExpression.Value as IIntegerValue; if (integerValue != null) { pPropertyInfo[0].bstrValue = integerValue.GetValue().ToString(); } ILongValue longValue = _evaluatedExpression.Value as ILongValue; if (longValue != null) { pPropertyInfo[0].bstrValue = longValue.GetValue().ToString(); } IFloatValue floatValue = _evaluatedExpression.Value as IFloatValue; if (floatValue != null) { pPropertyInfo[0].bstrValue = floatValue.GetValue().ToString(); } IDoubleValue doubleValue = _evaluatedExpression.Value as IDoubleValue; if (doubleValue != null) { pPropertyInfo[0].bstrValue = doubleValue.GetValue().ToString(); } } else if (_evaluatedExpression.Value is IArrayReference) { IArrayReference arrayReference = _evaluatedExpression.Value as IArrayReference; int length = arrayReference.GetLength(); IArrayType arrayType = (IArrayType)arrayReference.GetReferenceType(); pPropertyInfo[0].bstrValue = string.Format("{{{0}[{1}]}}", arrayType.GetComponentTypeName(), length); if (length > 0) { pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE; } } else if (_evaluatedExpression.Value is IObjectReference) { IStringReference stringReference = _evaluatedExpression.Value as IStringReference; if (stringReference != null) { pPropertyInfo[0].bstrValue = EscapeSpecialCharacters(stringReference.GetValue(), 120, '"'); } else { IObjectReference objectReference = _evaluatedExpression.Value as IObjectReference; if (objectReference != null) { int collectionSize; if (TryGetCollectionSize(objectReference, out collectionSize)) { pPropertyInfo[0].bstrValue = string.Format("{{size() = {0}}}", collectionSize); pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE; } else { string displayValue = null; IClassType classType = objectReference.GetReferenceType() as IClassType; if (noToString || classType == null) { displayValue = objectReference.GetReferenceType().GetName(); } else { IMethod method = classType.GetConcreteMethod("toString", "()Ljava/lang/String;"); using (IStrongValueHandle <IValue> result = objectReference.InvokeMethod(null, method, InvokeOptions.None)) { if (result != null) { stringReference = result.Value as IStringReference; if (stringReference != null) { displayValue = stringReference.GetValue(); } } } if (displayValue == null) { IClassType objectClass = classType; while (true) { IClassType parentClass = objectClass.GetSuperclass(); if (parentClass != null) { objectClass = parentClass; } else { break; } } IMethod objectToStringMethod = objectClass.GetConcreteMethod("toString", "()Ljava/lang/String;"); // fall back to a non-virtual call using (IStrongValueHandle <IValue> result = objectReference.InvokeMethod(null, objectToStringMethod, InvokeOptions.NonVirtual | InvokeOptions.SingleThreaded)) { if (result != null) { stringReference = result.Value as IStringReference; if (stringReference != null) { displayValue = stringReference.GetValue(); } } } } } pPropertyInfo[0].bstrValue = "{" + displayValue + "}"; pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE; } } else { pPropertyInfo[0].bstrValue = "Unrecognized value"; pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_ERROR; } } } pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE; } if (getAttributes) { if (_evaluatedExpression.Field != null) { if (_evaluatedExpression.Field.GetIsPrivate()) { pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_PRIVATE; } if (_evaluatedExpression.Field.GetIsProtected()) { pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_PROTECTED; } if (_evaluatedExpression.Field.GetIsPublic()) { pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_PUBLIC; } } pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_READONLY; pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB; #if false bool expandable; bool hasId; bool canHaveId; bool readOnly; bool error; bool sideEffect; bool overloadedContainer; bool boolean; bool booleanTrue; bool invalid; bool notAThing; bool autoExpanded; bool timeout; bool rawString; bool customViewer; bool accessNone; bool accessPrivate; bool accessProtected; bool accessPublic; bool storageNone; bool storageGlobal; bool storageStatic; bool storageRegister; bool noModifiers; bool @virtual; bool constant; bool synchronized; bool @volatile; bool dataField; bool method; bool property; bool @class; bool baseClass; bool @interface; bool innerClass; bool mostDerived; bool multiCustomViewers; #endif } if (getProperty) { pPropertyInfo[0].pProperty = this; pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_PROP; } return(VSConstants.S_OK); }
public EvaluatedExpression EvaluateMethod(EvaluatedExpression expression, CommonTree methodName, IList <EvaluatedExpression> arguments) { Contract.Requires <ArgumentNullException>(expression != null, "expression"); Contract.Requires <ArgumentNullException>(methodName != null, "methodName"); Contract.Requires <ArgumentNullException>(arguments != null, "arguments"); Contract.Ensures(Contract.Result <EvaluatedExpression>() != null); Contract.Ensures(Contract.Result <EvaluatedExpression>().Method != null); IReferenceType referenceType = expression.ValueType as IReferenceType; if (referenceType == null) { throw new InvalidOperationException(); } List <IMethod> methods = referenceType.GetMethodsByName(methodName.Text).ToList(); if (referenceType is IClassType) { methods.RemoveAll(i => !(i.GetDeclaringType() is IClassType)); } if (methods.Count > 0) { methods.RemoveAll(i => i.GetArgumentTypeNames().Count != arguments.Count); } if (methods.Count == 0) { throw new InvalidOperationException("Evaluation failed."); } if (methods.Count > 1) { methods.RemoveAll( m => { ReadOnlyCollection <IType> argumentTypes = m.GetArgumentTypes(); for (int i = 0; i < arguments.Count; i++) { if (!IsAssignableFrom(argumentTypes[0], arguments[i].ValueType)) { return(true); } } return(false); }); } if (methods.Count > 1) { if (arguments.Any(i => i.ValueType is IPrimitiveType) || methods.Any(i => i.GetArgumentTypes().Any(j => j is IPrimitiveType))) { throw new NotImplementedException("Auto boxing/unboxing is not yet implemented."); } throw new InvalidOperationException("Ambiguous match?"); } IMethod method = methods[0]; IObjectReference referencer = null; if (!method.GetIsStatic()) { referencer = expression.Value as IObjectReference; if (referencer == null) { throw new InvalidOperationException(); } if (method.GetDeclaringType() is IInterfaceType) { IClassType concreteType = referencer.GetReferenceType() as IClassType; if (concreteType == null) { throw new InvalidOperationException(); } method = concreteType.GetConcreteMethod(method.GetName(), method.GetSignature()); if (method == null) { throw new InvalidOperationException(); } } } string fullName = string.Format("({0}).{1}", expression.FullName, methodName); bool hasSideEffects = (expression != null && expression.HasSideEffects); return(new EvaluatedExpression(fullName, fullName, referencer, method, hasSideEffects)); }