public int GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo) {
pPropertyInfo[0] = new DEBUG_PROPERTY_INFO();
if (dwFields.HasFlag(enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB)) {
pPropertyInfo[0].dwAttrib = enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_ERROR;
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB;
}
if (dwFields.HasFlag(enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE)) {
pPropertyInfo[0].bstrValue = _errorText;
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE;
}
return VSConstants.S_OK;
}
// Fills in a DEBUG_PROPERTY_INFO structure that describes a property.
public int GetPropertyInfo(DIF dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo)
{
rgpArgs = null;
pPropertyInfo[0] = ConstructDebugPropertyInfo(dwFields);
return Constants.S_OK;
}
// Get a reference for this property
public void GetReference(out IDebugReference2 ppReference) {
throw new Exception("Not Implemented Yet");
}
// Get the DEBUG_PROPERTY_INFO that describes this property
public void GetPropertyInfo(
DEBUGPROP_INFO_FLAGS dwFields,
uint dwRadix,
uint dwTimeout,
IDebugReference2 []rgpArgs,
uint dwArgCount,
out DEBUG_PROPERTY_INFO pPropertyInfo) {
pPropertyInfo = new DEBUG_PROPERTY_INFO();
if (0 != (dwFields & DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME)) {
pPropertyInfo.dwFields |= DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME;
pPropertyInfo.bstrFullName = this.prop.FullName;
}
if (0 != (dwFields & DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME)) {
pPropertyInfo.dwFields |= DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME;
pPropertyInfo.bstrName = this.prop.Name;
}
if (0 != (dwFields & DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE)) {
pPropertyInfo.dwFields |= DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE;
pPropertyInfo.bstrType = this.prop.Type;
}
if (0 != (dwFields & DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_PROP)) {
pPropertyInfo.dwFields |= DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_PROP;
pPropertyInfo.pProperty = this as IDebugProperty2;
}
if (0 != (dwFields & DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE)) {
pPropertyInfo.dwFields |= DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE;
pPropertyInfo.bstrValue = this.prop.GetValue(dwRadix, dwTimeout);
}
if (0 != (dwFields & DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_AUTOEXPAND)) {
pPropertyInfo.dwFields |= DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_AUTOEXPAND;
}
if (0 != (dwFields & DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB)){
pPropertyInfo.dwFields |= DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB;
DebugPropertyAttributes attrib;
attrib = this.prop.Attributes;
pPropertyInfo.dwAttrib = 0;
if (0 != (attrib & DebugPropertyAttributes.Expandable))
pPropertyInfo.dwAttrib |= DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE;
if (0 != (attrib & DebugPropertyAttributes.ReadOnly))
pPropertyInfo.dwAttrib |= DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_READONLY;
if (0 != (attrib & DebugPropertyAttributes.Error))
pPropertyInfo.dwAttrib |= DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_ERROR;
if (0 != (attrib & DebugPropertyAttributes.SideEffect))
pPropertyInfo.dwAttrib |= DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_SIDE_EFFECT;
if (0 != (attrib & DebugPropertyAttributes.OverloadedContainer))
pPropertyInfo.dwAttrib |= DBG_ATTRIB_FLAGS.DBG_ATTRIB_OVERLOADED_CONTAINER;
if (0 != (attrib & DebugPropertyAttributes.Boolean))
pPropertyInfo.dwAttrib |= DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_BOOLEAN;
if (0 != (attrib & DebugPropertyAttributes.BooleanTrue))
pPropertyInfo.dwAttrib |= DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_BOOLEAN_TRUE;
if (0 != (attrib & DebugPropertyAttributes.Invalid))
pPropertyInfo.dwAttrib |= DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_INVALID;
}
}
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
{
return AD7Constants.E_SETVALUEASREFERENCE_NOTSUPPORTED;
}
// Return an IDebugReference2 for this property. An IDebugReference2 can be thought of as a type and an address.
public int GetReference(out IDebugReference2 ppReference) {
ppReference = null;
return VSConstants.E_NOTIMPL;
}
// The debugger will call this when the user tries to edit the property's values
// the sample has set the read-only flag on its properties, so this should not be called.
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
{
throw new NotImplementedException();
}
public int GetReference(out IDebugReference2 ppReference)
{
ppReference = null;
return AD7Constants.E_GETREFERENCE_NO_REFERENCE;
}
int IDebugProperty3.SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout) => IDebugProperty2.SetValueAsReference(rgpArgs, dwArgCount, pValue, dwTimeout);
int IDebugProperty3.GetReference(out IDebugReference2 ppReference) => IDebugProperty2.GetReference(out ppReference);
int IDebugProperty2.SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout) => VSConstants.E_NOTIMPL;
int IDebugProperty3.GetReference(out IDebugReference2 ppReference)
{
return(IDebugProperty2.GetReference(out ppReference));
}
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
{
return(AD7Constants.E_SETVALUE_VALUE_CANNOT_BE_SET);
}
public int GetReference(out IDebugReference2 ppReference)
{
ppReference = null;
return(AD7Constants.E_GETREFERENCE_NO_REFERENCE);
}
int IDebugProperty3.GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo) {
return IDebugProperty2.GetPropertyInfo(dwFields, dwRadix, dwTimeout, rgpArgs, dwArgCount, pPropertyInfo);
}
int IDebugProperty3.SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout) {
return IDebugProperty2.SetValueAsReference(rgpArgs, dwArgCount, pValue, dwTimeout);
}
public int GetPropertyInfo(uint dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo)
{
if (pPropertyInfo.Length > 0)
{
Expression debugExpr = vs.Debugger.GetExpression(_expression, true, 1000);
pPropertyInfo[0].dwAttrib = (long)Constants.DBG_ATTRIB_ACCESS_ALL;
pPropertyInfo[0].dwAttrib |= (long)Constants.DBG_ATTRIB_TYPE_VOLATILE;
pPropertyInfo[0].dwAttrib |= (long) Constants.DBG_ATTRIB_STORAGE_REGISTER;
pPropertyInfo[0].dwFields = dwFields;
if ((dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME) != 0)
{
pPropertyInfo[0].bstrFullName = _expression;
}
if ((dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME) != 0)
{
pPropertyInfo[0].bstrName = debugExpr.Name;
}
if ((dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE) != 0)
{
pPropertyInfo[0].bstrType = debugExpr.Type;
}
if ((dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE) != 0
|| (dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_RAW) != 0)
{
pPropertyInfo[0].bstrValue = debugExpr.Value;
}
}
return VSConstants.S_OK;
}
public int GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo)
{
pPropertyInfo[0] = ConstructErrorPropertyInfo(dwFields, _name, _message, this);
rgpArgs = null;
return Constants.S_OK;
}
int IDebugProperty2.GetReference(out IDebugReference2 ppReference)
{
ppReference = null;
return(VSConstants.E_NOTIMPL);
}
/// <summary>
/// Sets the value of the property from the value of a given reference. (http://msdn.microsoft.com/en-ca/library/bb145613.aspx)
/// The debugger will call this when the user tries to edit the property's values. As the sample has set the read-only flag on
/// its properties, this should not be called.
/// Not implemented.
/// </summary>
/// <param name="rgpArgs"> An array of arguments to pass to the managed code property setter. If the property setter does not
/// take arguments or if this IDebugProperty2 object does not refer to such a property setter, rgpArgs should be a null value.
/// This parameter is typically a null value. </param>
/// <param name="dwArgCount"> The number of arguments in the rgpArgs array. </param>
/// <param name="pValue"> A reference, in the form of an IDebugReference2 object, to the value to use to set this property. </param>
/// <param name="dwTimeout"> How long to take to set the value, in milliseconds. A typical value is INFINITE. This affects
/// the length of time that any possible evaluation can take. </param>
/// <returns> Not implemented. </returns>
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
{
throw new Exception("The method or operation is not implemented.");
}
public int Compare(enum_REFERENCE_COMPARE dwCompare, IDebugReference2 pReference)
{
throw new NotImplementedException();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public virtual int SetValueAsReference(IDebugReference2 [] debugReferenceArray, uint argumentCount, IDebugReference2 debugReferenceValue, uint timeout)
{
//
// Sets the value of the property from the value of a given reference.
//
LoggingUtils.PrintFunction();
return(Constants.E_SETVALUEASREFERENCE_NOTSUPPORTED);
}
public int GetDerivedMostReference(out IDebugReference2 ppDerivedMost)
{
throw new NotImplementedException();
}
public int GetPropertyInfo(uint dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo)
{
return VSConstants.E_NOTIMPL;
}
public int GetParent(out IDebugReference2 ppParent)
{
throw new NotImplementedException();
}
// Set the value of this property
public void SetValueAsReference(
IDebugReference2 []rgpArgs,
uint dwArgCount,
IDebugReference2 pValue,
uint dwTimeout) {
throw new Exception("Not Implemented Yet");
}
public int GetReferenceInfo(enum_DEBUGREF_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_REFERENCE_INFO[] pReferenceInfo)
{
throw new NotImplementedException();
}
int IDebugProperty2.GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo) {
return VSConstants.E_NOTIMPL;
}
public int GetReference(out IDebugReference2 ppReference)
{
throw new NotImplementedException();
}
int IDebugProperty2.GetReference(out IDebugReference2 ppReference) {
ppReference = null;
return VSConstants.E_NOTIMPL;
}
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
{
throw new NotImplementedException();
}
int IDebugProperty3.GetReference(out IDebugReference2 ppReference) {
return IDebugProperty2.GetReference(out ppReference);
}
public int GetReference(out IDebugReference2 ppReference)
{
ppReference = null;
return(VSConstants.E_NOTIMPL);
}
public int GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo)
{
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 = "Static Members";
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME;
}
if (getName)
{
pPropertyInfo[0].bstrName = "Static Members";
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME;
}
/* no type */
//if (getType)
//{
//}
/* no value */
//if (getValue)
//{
//}
if (getAttributes)
{
pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE;
pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OVERLOADED_CONTAINER;
pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_CLASS;
pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_PRIVATE;
pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_READONLY;
}
if (getProperty)
{
pPropertyInfo[0].pProperty = this;
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_PROP;
}
return VSConstants.S_OK;
}
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
{
return(VSConstants.E_NOTIMPL);
}
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
{
return AD7Constants.E_SETVALUE_VALUE_CANNOT_BE_SET;
}
// The debugger will call this when the user tries to edit the property's values
// We only accept setting values as strings
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
{
throw new Exception("The method or operation is not implemented.");
}
// Return an IDebugReference2 for this property. An IDebugReference2 can be thought of as a type and an address.
public int GetReference(out IDebugReference2 ppReference)
{
throw new NotImplementedException();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public override int GetPropertyInfo (enum_DEBUGPROP_INFO_FLAGS requestedFields, uint radix, uint timeout, IDebugReference2 [] debugReferenceArray, uint argumentCount, DEBUG_PROPERTY_INFO [] propertyInfoArray)
{
//
// Fills in a DEBUG_PROPERTY_INFO structure that describes a property.
//
LoggingUtils.PrintFunction ();
try
{
LoggingUtils.RequireOk (base.GetPropertyInfo (requestedFields, radix, timeout, debugReferenceArray, argumentCount, propertyInfoArray));
#if false
if ((m_gdbVariable != null) && (requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME) != 0)
{
propertyInfoArray [0].bstrFullName = m_gdbVariable.Name;
propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME;
}
#endif
if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME) != 0)
{
if (m_gdbVariable != null)
{
propertyInfoArray [0].bstrName = m_gdbVariable.Expression;
propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME;
}
}
if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE) != 0)
{
if (m_gdbVariable != null)
{
propertyInfoArray [0].bstrType = m_gdbVariable.Type;
propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE;
}
}
if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE) != 0)
{
#if false
if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_AUTOEXPAND) != 0)
{
}
if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_RAW) != 0)
{
}
if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_NO_TOSTRING) != 0)
{
}
#endif
if (m_gdbVariable != null)
{
propertyInfoArray [0].bstrValue = m_gdbVariable.Value;
propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE;
}
}
if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB) != 0)
{
if (m_gdbVariable != null)
{
if (m_gdbVariable.HasChildren)
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE;
}
if (m_gdbVariable.Expression.StartsWith ("$")) // Register. '$r0'
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_STORAGE_REGISTER;
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_DATA;
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_NONE;
}
else if (string.IsNullOrEmpty (m_gdbVariable.Type))
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_PROPERTY;
}
else if (m_gdbVariable.Value.Equals ("{...}"))
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_PROPERTY;
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_CLASS;
}
else if (m_gdbVariable.Type.Contains ("(")) // Function, i.e: 'bool (void)'
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_METHOD;
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_READONLY;
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_NONE;
}
else
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_DATA;
}
if (m_gdbVariable.Name.Contains (".public"))
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_PUBLIC;
}
else if (m_gdbVariable.Name.Contains (".private"))
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_PRIVATE;
}
else if (m_gdbVariable.Name.Contains (".protected"))
{
propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_PROTECTED;
}
}
propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB;
}
if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NO_NONPUBLIC_MEMBERS) != 0)
{
}
return Constants.S_OK;
}
catch (Exception e)
{
LoggingUtils.HandleException (e);
return Constants.E_FAIL;
}
}
/// <summary>
/// Returns a reference to the property's value. IDebugProperty2 represents a property, while IDebugReference2 represents a
/// reference to a property, typically a reference to an object in the program being debugged. Not implemented.
/// (http://msdn.microsoft.com/en-ca/library/bb145600.aspx)
/// </summary>
/// <param name="ppReference"> Returns an IDebugReference2 object representing a reference to the property's value. </param>
/// <returns> Not implemented. </returns>
public int GetReference(out IDebugReference2 ppReference)
{
throw new Exception("The method or operation is not implemented.");
}
// Return an IDebugReference2 for this property. An IDebugReference2 can be thought of as a type and an address.
public int GetReference(out IDebugReference2 ppReference)
{
throw new Exception("The method or operation is not implemented.");
}
// Fills in a DEBUG_PROPERTY_INFO structure that describes a property.
public int GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo) {
pPropertyInfo[0] = ConstructDebugPropertyInfo(dwRadix, dwFields);
return VSConstants.S_OK;
}
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)
{
if (ErrorHandler.Succeeded(_stackFrame.GetName(out pPropertyInfo[0].bstrFullName)))
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME;
}
if (getName)
{
if (ErrorHandler.Succeeded(_stackFrame.GetName(out pPropertyInfo[0].bstrName)))
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME;
}
if (getType)
{
pPropertyInfo[0].bstrType = string.Empty;
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE;
}
if (getValue)
{
// value??
}
if (getAttributes)
{
pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE;
pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_READONLY;
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB;
}
if (getProperty)
{
pPropertyInfo[0].pProperty = this;
pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_PROP;
}
return VSConstants.S_OK;
}
// The debugger will call this when the user tries to edit the property's values
// We only accept setting values as strings
public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout) {
return VSConstants.E_NOTIMPL;
}
/// <summary>
/// Returns a reference to the property's value.
/// </summary>
/// <param name="ppReference">Returns an IDebugReference2 object representing a reference to the property's value.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code, typically E_NOTIMPL or E_GETREFERENCE_NO_REFERENCE.</returns>
public virtual int GetReference(out IDebugReference2 ppReference)
{
Logger.Debug(string.Empty);
ppReference = null;
return(VSConstants.E_NOTIMPL);
}
