Exemple #1
0
        private string GetUnderlyingStringImpl(
            DkmClrValue value,
            DkmInspectionContext inspectionContext
            )
        {
            Debug.Assert(!value.IsError());

            if (value.IsNull)
            {
                return(null);
            }

            var lmrType = value.Type.GetLmrType();

            if (lmrType.IsEnum || lmrType.IsArray || lmrType.IsPointer)
            {
                return(null);
            }

            if (lmrType.IsNullable())
            {
                var nullableValue = value.GetNullableValue(inspectionContext);
                return(nullableValue != null
                  ? GetUnderlyingStringImpl(nullableValue, inspectionContext)
                  : null);
            }

            if (lmrType.IsString())
            {
                return((string)value.HostObjectValue);
            }
            else if (!IsPredefinedType(lmrType))
            {
                // Check for special cased non-primitives that have underlying strings
                if (lmrType.IsType("System.Data.SqlTypes", "SqlString"))
                {
                    var fieldValue = value.GetFieldValue(
                        InternalWellKnownMemberNames.SqlStringValue,
                        inspectionContext
                        );
                    return(fieldValue.HostObjectValue as string);
                }
                else if (lmrType.IsOrInheritsFrom("System.Xml.Linq", "XNode"))
                {
                    return(value.EvaluateToString(inspectionContext));
                }
            }

            return(null);
        }
Exemple #2
0
        private string GetUnderlyingStringImpl(DkmClrValue value)
        {
            if (value.IsNull)
            {
                return(null);
            }

            var lmrType = value.Type.GetLmrType();

            if (lmrType.IsEnum || lmrType.IsArray || lmrType.IsPointer)
            {
                return(null);
            }

            if (lmrType.IsNullable())
            {
                var nullableValue = value.GetNullableValue();
                return(nullableValue != null?GetUnderlyingStringImpl(nullableValue) : null);
            }

            if (lmrType.IsString())
            {
                return((string)value.HostObjectValue);
            }
            else if (!IsPredefinedType(lmrType))
            {
                // Check for special cased non-primitives that have underlying strings
                if (string.Equals(lmrType.FullName, "System.Data.SqlTypes.SqlString", StringComparison.Ordinal))
                {
                    var fieldValue = value.GetFieldValue(InternalWellKnownMemberNames.SqlStringValue);
                    return(fieldValue.HostObjectValue as string);
                }

                do
                {
                    if (string.Equals(lmrType.FullName, "System.Xml.Linq.XNode", StringComparison.Ordinal))
                    {
                        return(value.EvaluateToString());
                    }

                    lmrType = lmrType.BaseType;
                }while (lmrType != null);
            }

            return(null);
        }
Exemple #3
0
        internal string GetValueString(DkmClrValue value, ObjectDisplayOptions options, GetValueFlags flags)
        {
            if (value.IsError())
            {
                return((string)value.HostObjectValue);
            }

            if (UsesHexadecimalNumbers(value))
            {
                options |= ObjectDisplayOptions.UseHexadecimalNumbers;
            }

            var lmrType = value.Type.GetLmrType();

            if (IsPredefinedType(lmrType) && !lmrType.IsObject())
            {
                if (lmrType.IsString())
                {
                    var stringValue = (string)value.HostObjectValue;
                    if (stringValue == null)
                    {
                        return(_nullString);
                    }
                    return(IncludeObjectId(
                               value,
                               FormatString(stringValue, options),
                               flags));
                }
                else if (lmrType.IsCharacter())
                {
                    return(IncludeObjectId(
                               value,
                               FormatLiteral((char)value.HostObjectValue, options | ObjectDisplayOptions.IncludeCodePoints),
                               flags));
                }
                else
                {
                    return(IncludeObjectId(
                               value,
                               FormatPrimitive(value, options & ~ObjectDisplayOptions.UseQuotes),
                               flags));
                }
            }
            else if (value.IsNull && !lmrType.IsPointer)
            {
                return(_nullString);
            }
            else if (lmrType.IsEnum)
            {
                return(IncludeObjectId(
                           value,
                           GetEnumDisplayString(lmrType, value, options, (flags & GetValueFlags.IncludeTypeName) != 0),
                           flags));
            }
            else if (lmrType.IsArray)
            {
                return(IncludeObjectId(
                           value,
                           GetArrayDisplayString(lmrType, value.ArrayDimensions, value.ArrayLowerBounds, options),
                           flags));
            }
            else if (lmrType.IsPointer)
            {
                // NOTE: the HostObjectValue will have a size corresponding to the process bitness
                // and FormatPrimitive will adjust accordingly.
                var tmp = FormatPrimitive(value, ObjectDisplayOptions.UseHexadecimalNumbers); // Always in hex.
                Debug.Assert(tmp != null);
                return(tmp);
            }
            else if (lmrType.IsNullable())
            {
                var nullableValue = value.GetNullableValue();
                // It should be impossible to nest nullables, so this recursion should introduce only a single extra stack frame.
                return(nullableValue == null
                    ? _nullString
                    : GetValueString(nullableValue, ObjectDisplayOptions.None, GetValueFlags.IncludeTypeName));
            }

            // "value.EvaluateToString()" will check "Call string-conversion function on objects in variables windows"
            // (Tools > Options setting) and call "value.ToString()" if appropriate.
            return(IncludeObjectId(
                       value,
                       string.Format(_defaultFormat, value.EvaluateToString() ?? value.InspectionContext.GetTypeName(value.Type)),
                       flags));
        }
Exemple #4
0
        private string GetValueString(
            DkmClrValue value,
            DkmInspectionContext inspectionContext,
            ObjectDisplayOptions options,
            GetValueFlags flags
            )
        {
            if (value.IsError())
            {
                return((string)value.HostObjectValue);
            }

            if (UsesHexadecimalNumbers(inspectionContext))
            {
                options |= ObjectDisplayOptions.UseHexadecimalNumbers;
            }

            var lmrType = value.Type.GetLmrType();

            if (IsPredefinedType(lmrType) && !lmrType.IsObject())
            {
                if (lmrType.IsString())
                {
                    var stringValue = (string)value.HostObjectValue;
                    if (stringValue == null)
                    {
                        return(_nullString);
                    }
                    return(IncludeObjectId(value, FormatString(stringValue, options), flags));
                }
                else if (lmrType.IsCharacter())
                {
                    // check if HostObjectValue is null, since any of these types might actually be a synthetic value as well.
                    if (value.HostObjectValue == null)
                    {
                        return(_hostValueNotFoundString);
                    }

                    return(IncludeObjectId(
                               value,
                               FormatLiteral(
                                   (char)value.HostObjectValue,
                                   options | ObjectDisplayOptions.IncludeCodePoints
                                   ),
                               flags
                               ));
                }
                else
                {
                    return(IncludeObjectId(
                               value,
                               FormatPrimitive(
                                   value,
                                   options
                                   & ~(
                                       ObjectDisplayOptions.UseQuotes
                                       | ObjectDisplayOptions.EscapeNonPrintableCharacters
                                       ),
                                   inspectionContext
                                   ),
                               flags
                               ));
                }
            }
            else if (value.IsNull && !lmrType.IsPointer)
            {
                return(_nullString);
            }
            else if (lmrType.IsEnum)
            {
                return(IncludeObjectId(
                           value,
                           GetEnumDisplayString(
                               lmrType,
                               value,
                               options,
                               (flags & GetValueFlags.IncludeTypeName) != 0,
                               inspectionContext
                               ),
                           flags
                           ));
            }
            else if (lmrType.IsArray)
            {
                return(IncludeObjectId(
                           value,
                           GetArrayDisplayString(
                               value.Type.AppDomain,
                               lmrType,
                               value.ArrayDimensions,
                               value.ArrayLowerBounds,
                               options
                               ),
                           flags
                           ));
            }
            else if (lmrType.IsPointer)
            {
                // NOTE: the HostObjectValue will have a size corresponding to the process bitness
                // and FormatPrimitive will adjust accordingly.
                var tmp = FormatPrimitive(
                    value,
                    ObjectDisplayOptions.UseHexadecimalNumbers,
                    inspectionContext
                    ); // Always in hex.
                Debug.Assert(tmp != null);
                return(tmp);
            }
            else if (lmrType.IsNullable())
            {
                var nullableValue = value.GetNullableValue(inspectionContext);
                // It should be impossible to nest nullables, so this recursion should introduce only a single extra stack frame.
                return(nullableValue == null
                  ? _nullString
                  : GetValueString(
                           nullableValue,
                           inspectionContext,
                           ObjectDisplayOptions.None,
                           GetValueFlags.IncludeTypeName
                           ));
            }
            else if (lmrType.IsIntPtr())
            {
                // check if HostObjectValue is null, since any of these types might actually be a synthetic value as well.
                if (value.HostObjectValue == null)
                {
                    return(_hostValueNotFoundString);
                }

                if (IntPtr.Size == 8)
                {
                    var intPtr = ((IntPtr)value.HostObjectValue).ToInt64();
                    return(FormatPrimitiveObject(
                               intPtr,
                               ObjectDisplayOptions.UseHexadecimalNumbers
                               ));
                }
                else
                {
                    var intPtr = ((IntPtr)value.HostObjectValue).ToInt32();
                    return(FormatPrimitiveObject(
                               intPtr,
                               ObjectDisplayOptions.UseHexadecimalNumbers
                               ));
                }
            }
            else if (lmrType.IsUIntPtr())
            {
                // check if HostObjectValue is null, since any of these types might actually be a synthetic value as well.
                if (value.HostObjectValue == null)
                {
                    return(_hostValueNotFoundString);
                }

                if (UIntPtr.Size == 8)
                {
                    var uIntPtr = ((UIntPtr)value.HostObjectValue).ToUInt64();
                    return(FormatPrimitiveObject(
                               uIntPtr,
                               ObjectDisplayOptions.UseHexadecimalNumbers
                               ));
                }
                else
                {
                    var uIntPtr = ((UIntPtr)value.HostObjectValue).ToUInt32();
                    return(FormatPrimitiveObject(
                               uIntPtr,
                               ObjectDisplayOptions.UseHexadecimalNumbers
                               ));
                }
            }
            else
            {
                int cardinality;
                if (lmrType.IsTupleCompatible(out cardinality) && (cardinality > 1))
                {
                    var values = ArrayBuilder <string> .GetInstance();

                    if (value.TryGetTupleFieldValues(cardinality, values, inspectionContext))
                    {
                        return(IncludeObjectId(
                                   value,
                                   GetTupleExpression(values.ToArrayAndFree()),
                                   flags
                                   ));
                    }
                    values.Free();
                }
            }

            // "value.EvaluateToString()" will check "Call string-conversion function on objects in variables windows"
            // (Tools > Options setting) and call "value.ToString()" if appropriate.
            return(IncludeObjectId(
                       value,
                       string.Format(
                           _defaultFormat,
                           value.EvaluateToString(inspectionContext)
                           ?? inspectionContext.GetTypeName(
                               value.Type,
                               CustomTypeInfo: null,
                               FormatSpecifiers: NoFormatSpecifiers
                               )
                           ),
                       flags
                       ));
        }