Exemple #1
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
                       ));
        }