{ ***************************************************************************** See the file COPYING.modifiedLGPL.txt, included in this distribution, for details about the license. ***************************************************************************** Abstract: Interface for the package IdeDebugger } unit IdeDebuggerWatchValueIntf experimental; {$mode objfpc}{$H+} {$INTERFACES CORBA} {$ModeSwitch advancedrecords} interface uses LazDebuggerIntf, LazDebuggerIntfBaseTypes, LazLoggerBase, SysUtils; type TValueDisplayFormatGroup = ( vdfgBase, vdfgSign, vdfgEnum, vdfgBool, vdfgChar, vdfgFloat, vdfgStruct, vdfgStructAddress, vdfgPointerDeref, vdfgAddress, vdfgCategory ); TValueDisplayFormatGroups = set of TValueDisplayFormatGroup; TValueDisplayFormat = ( // ordinals vdfBaseDecimal, vdfBaseHex, vdfBaseOct, vdfBaseBin, vdfBaseChar, // signed numbers vdfSignAuto, vdfSignSigned, vdfSignUnsigned, // enum vdfEnumName, vdfEnumOrd, vdfEnumNameAndOrd, // bool vdfBoolName, vdfBoolOrd, vdfBoolNameAndOrd, // char vdfCharLetter, vdfCharOrd, vdfCharLetterAndOrd, // float vdfFloatPoint, vdfFloatScientific, // structures vdfStructValOnly, vdfStructFields, vdfStructFull, // structures with pointer vdfStructPointerOff, vdfStructPointerOn, vdfStructPointerOnly, // pointer deref vdfPointerDerefOff, vdfPointerDerefOn, vdfPointerDerefOnly, // address vdfAddressPlain, vdfAddressTyped, // Categories vdfCategoryData, vdfCategoryMemDump // For use in the set TValueDisplayFormats ); TValueDisplayFormats = set of TValueDisplayFormat; TValueDisplayFormatBase = vdfBaseDecimal .. vdfBaseChar; TValueDisplayFormatSign = vdfSignAuto .. vdfSignUnsigned; TValueDisplayFormatEnum = vdfEnumName .. vdfEnumNameAndOrd; TValueDisplayFormatBool = vdfBoolName .. vdfBoolNameAndOrd; TValueDisplayFormatChar = vdfCharLetter .. vdfCharLetterAndOrd; TValueDisplayFormatFloat = vdfFloatPoint .. vdfFloatScientific; TValueDisplayFormatStruct = vdfStructValOnly .. vdfStructFull; TValueDisplayFormatStructPointer= vdfStructPointerOff .. vdfStructPointerOnly; TValueDisplayFormatPointerDeref = vdfPointerDerefOff .. vdfPointerDerefOnly; TValueDisplayFormatAddress = vdfAddressPlain .. vdfAddressTyped; TValueDisplayFormatCategory = vdfCategoryData .. vdfCategoryMemDump; TValueDisplayFormatCategories = set of TValueDisplayFormatCategory; TValueDisplayFormatHexSeperator = (vdfhsNone, vdfhsByte, vdfhsWord, vdfhsLong); TValueDisplayFormatHexSeperators = set of TValueDisplayFormatHexSeperator; TValueDisplayNumDigitsArray = array [TValueDisplayFormatBase] of integer; // Entry for Char is not used TValueDisplayFormatArrayType = (vdfatNone, vdfatAll, vdfatStat, vdfatDyn); TValueDisplayFormatArrayTypes = set of TValueDisplayFormatArrayType; { TWatchDisplayFormatNum } TWatchDisplayFormatNum2 = packed record UseInherited: boolean; Visible: boolean; BaseFormat: TValueDisplayFormatBase; SignFormat: TValueDisplayFormatSign; MinDigits: TValueDisplayNumDigitsArray; SeparatorDec: boolean; SeparatorHexBin: TValueDisplayFormatHexSeperator; class operator = (a,b: TWatchDisplayFormatNum2): boolean; end; TWatchDisplayFormatNum = packed record UseInherited: boolean; BaseFormat: TValueDisplayFormatBase; SignFormat: TValueDisplayFormatSign; MinDigits: TValueDisplayNumDigitsArray; SeparatorDec: boolean; SeparatorHexBin: TValueDisplayFormatHexSeperator; class operator = (a,b: TWatchDisplayFormatNum): boolean; class operator := (a: TWatchDisplayFormatNum2): TWatchDisplayFormatNum; end; TWatchDisplayFormatEnum = packed record UseInherited: boolean; MainFormat: TValueDisplayFormatEnum; BaseFormat: TValueDisplayFormatBase; SignFormat: TValueDisplayFormatSign; class operator = (a,b: TWatchDisplayFormatEnum): boolean; end; TWatchDisplayFormatBool = packed record UseInherited: boolean; MainFormat: TValueDisplayFormatBool; BaseFormat: TValueDisplayFormatBase; SignFormat: TValueDisplayFormatSign; class operator = (a,b: TWatchDisplayFormatBool): boolean; end; TWatchDisplayFormatChar = packed record UseInherited: boolean; MainFormat: TValueDisplayFormatChar; BaseFormat: TValueDisplayFormatBase; SignFormat: TValueDisplayFormatSign; class operator = (a,b: TWatchDisplayFormatChar): boolean; end; TWatchDisplayFormatFloat = packed record UseInherited: boolean; NumFormat: TValueDisplayFormatFloat; Precission: Integer; class operator = (a,b: TWatchDisplayFormatFloat): boolean; end; TWatchDisplayFormatAddr = packed record UseInherited: boolean; TypeFormat: TValueDisplayFormatAddress; BaseFormat: TValueDisplayFormatBase; Signed: boolean; NoLeadZero: boolean; class operator = (a,b: TWatchDisplayFormatAddr): boolean; end; TWatchDisplayFormatStruct = packed record UseInherited: boolean; DataFormat: TValueDisplayFormatStruct; ShowPointerFormat: TValueDisplayFormatStructPointer; Address: TWatchDisplayFormatAddr; class operator = (a,b: TWatchDisplayFormatStruct): boolean; end; TWatchDisplayFormatPointer = packed record UseInherited: boolean; DerefFormat: TValueDisplayFormatPointerDeref; Address: TWatchDisplayFormatAddr; class operator = (a,b: TWatchDisplayFormatPointer): boolean; end; { TWatchDisplayFormatArrayLen } TWatchDisplayFormatArrayLen = packed record UseInherited: boolean; ShowLenPrefix: boolean; ShowLenPrefixEmbedded: boolean; // arary in struct in array LenPrefixMaxNest: integer; // In directly nested arrays, show for n nested levels too LenPrefixCombine: TValueDisplayFormatArrayType; HideLen: boolean; HideLenThresholdCnt: integer; // maximum "len" value to ommit HideLenKeepDepth: integer; // Min-nest level, before considering to hide HideLenThresholdEach: integer; // If each entry has less than n nested entries (0 = only simple values allowed) HideLenThresholdLen: integer; // max printed len of each entry class operator = (a,b: TWatchDisplayFormatArrayLen): boolean; end; TWatchDisplayFormatMultiline = packed record UseInherited: boolean; MaxMultiLineDepth: integer; // Deeper than this will not be line-wrapped ForceSingleLine: Boolean; ForceSingleLineThresholdStructFld: integer; // fields in the struct itself ForceSingleLineThresholdArrayLen: integer; // len of array // ArrayLen is not applied to the most inner, if the most inner is an array // AND if ReverseDepth > 1 ForceSingleLineReverseDepth: integer; // amount of array/struct levels that can be excluded ForceSingleLineThresholdEach: integer; // max nested elements in each field ForceSingleLineThresholdLen: integer; // max printed len of each field (name + content) class operator = (a,b: TWatchDisplayFormatMultiline): boolean; end; TWatchDisplayFormatArrayNav = packed record UseInherited: boolean; PageSize: Integer; EnforceBounds: boolean; AutoHideNavBar: boolean; class operator = (a,b: TWatchDisplayFormatArrayNav): boolean; end; { TWatchDisplayFormat } TWatchDisplayFormat = packed record Num: TWatchDisplayFormatNum; Num2: TWatchDisplayFormatNum2; Enum: TWatchDisplayFormatEnum; EnumVal: TWatchDisplayFormatEnum; Bool: TWatchDisplayFormatBool; Char: TWatchDisplayFormatChar; Float: TWatchDisplayFormatFloat; Struct: TWatchDisplayFormatStruct; Pointer: TWatchDisplayFormatPointer; ArrayLen: TWatchDisplayFormatArrayLen; MultiLine: TWatchDisplayFormatMultiline; ArrayNavBar: TWatchDisplayFormatArrayNav; MemDump: boolean; class operator = (a,b: TWatchDisplayFormat): boolean; function HasOverrides: boolean; procedure MakeAllOverrides; procedure CopyInheritedFrom(AnOther: TWatchDisplayFormat); end; PWatchDisplayFormat = ^TWatchDisplayFormat; operator = (a,b: TValueDisplayNumDigitsArray): boolean; const {$WRITEABLECONST OFF} DefaultWatchDisplayFormat: TWatchDisplayFormat = ( Num: (UseInherited: True; BaseFormat: vdfBaseDecimal; SignFormat: vdfSignAuto; MinDigits: (0, 0, 0, 0, 0); SeparatorDec: False; SeparatorHexBin: vdfhsNone; ); Num2: (UseInherited: True; Visible: False; BaseFormat: vdfBaseHex; SignFormat: vdfSignAuto; MinDigits: (0, 0, 0, 0, 0); SeparatorDec: False; SeparatorHexBin: vdfhsNone; ); Enum: (UseInherited: True; MainFormat: vdfEnumName; BaseFormat: vdfBaseDecimal; SignFormat: vdfSignAuto; ); EnumVal: (UseInherited: True; MainFormat: vdfEnumNameAndOrd; BaseFormat: vdfBaseDecimal; SignFormat: vdfSignAuto; ); Bool: (UseInherited: True; MainFormat: vdfBoolName; BaseFormat: vdfBaseDecimal; SignFormat: vdfSignAuto; ); Char: (UseInherited: True; MainFormat: vdfCharLetter; BaseFormat: vdfBaseDecimal; SignFormat: vdfSignAuto; ); Float: (UseInherited: True; NumFormat: vdfFloatPoint; Precission: 0; ); Struct: (UseInherited: True; DataFormat: vdfStructFields; ShowPointerFormat: vdfStructPointerOff; Address: (UseInherited: True; TypeFormat: vdfAddressPlain; BaseFormat: vdfBaseHex; Signed: False; NoLeadZero: False; ); ); Pointer: (UseInherited: True; DerefFormat: vdfPointerDerefOn; Address: (UseInherited: True; TypeFormat: vdfAddressPlain; BaseFormat:vdfBaseHex; Signed: False; NoLeadZero: False; ); ); ArrayLen: (UseInherited: True; ShowLenPrefix: True; ShowLenPrefixEmbedded: True; LenPrefixMaxNest: 3; LenPrefixCombine: vdfatStat; HideLen: True; HideLenThresholdCnt: 1; HideLenKeepDepth: 1; HideLenThresholdEach: 2; HideLenThresholdLen: 20; ); MultiLine: (UseInherited: True; MaxMultiLineDepth: 3; ForceSingleLine: True; ForceSingleLineThresholdStructFld: 2; ForceSingleLineThresholdArrayLen: 3; ForceSingleLineReverseDepth: 2; ForceSingleLineThresholdEach: 4; ForceSingleLineThresholdLen: 20; ); ArrayNavBar: (UseInherited: True; PageSize: 10; EnforceBounds: True; AutoHideNavBar: True; ); MemDump: False; ); ValueDisplayFormatGroupMap: array [TValueDisplayFormat] of TValueDisplayFormatGroup = ( vdfgBase, vdfgBase, vdfgBase, vdfgBase, vdfgBase, vdfgSign, vdfgSign, vdfgSign, vdfgEnum, vdfgEnum, vdfgEnum, vdfgBool, vdfgBool, vdfgBool, vdfgChar, vdfgChar, vdfgChar, vdfgFloat, vdfgFloat, vdfgStruct, vdfgStruct, vdfgStruct, vdfgStructAddress, vdfgStructAddress, vdfgStructAddress, vdfgPointerDeref, vdfgPointerDeref, vdfgPointerDeref, vdfgAddress, vdfgAddress, vdfgCategory, vdfgCategory ); ValueDisplayFormatMaskMap: array [TValueDisplayFormatGroup] of TValueDisplayFormats = ( [low(TValueDisplayFormatBase) .. high(TValueDisplayFormatBase)], // vdfgBase [low(TValueDisplayFormatSign) .. high(TValueDisplayFormatSign)], // vdfgSign [low(TValueDisplayFormatEnum) .. high(TValueDisplayFormatEnum)], // vdfgEnum [low(TValueDisplayFormatBool) .. high(TValueDisplayFormatBool)], // vdfgBool [low(TValueDisplayFormatChar) .. high(TValueDisplayFormatChar)], // vdfgChar [low(TValueDisplayFormatFloat) .. high(TValueDisplayFormatFloat)], // vdfgFloat [low(TValueDisplayFormatStruct) .. high(TValueDisplayFormatStruct)], // vdfgStruct [low(TValueDisplayFormatStructPointer) .. high(TValueDisplayFormatStructPointer)], // vdfgStructAddress [low(TValueDisplayFormatPointerDeref) .. high(TValueDisplayFormatPointerDeref)], // vdfgPointerDeref [low(TValueDisplayFormatAddress) .. high(TValueDisplayFormatAddress)], // vdfgAddress [low(TValueDisplayFormatCategory) .. high(TValueDisplayFormatCategory)] // vdfgCategory ); type TWatchResultDataKind = ( rdkUnknown, rdkError, rdkPrePrinted, rdkMemDump, rdkString, rdkWideString, rdkChar, rdkSignedNumVal, rdkUnsignedNumVal, rdkPointerVal, rdkFloatVal, rdkBool, rdkEnum, rdkEnumVal, rdkSet, rdkVariant, rdkPCharOrString, rdkArray, rdkStruct, rdkConvertRes, rdkFunction, rdkProcedure, rdkFunctionRef, rdkProcedureRef ); TWatchResultDataKinds = set of TWatchResultDataKind; IWatchResultDataIntf = interface; (* IWatchResultPrinter & ValueFormmatters: If a Valueformatter's FormatValue is called, it is given an IWatchResultPrinter. Calling PrintWatchValue on this, will format the value WITHOUT ANY ValueFormmatters. This can be changed by - Setting a specific ValueFormatter with SetValueFormatter - Specifing flags ~ "Default Valueformatter" is the formatter that was used before calling (the outermost) value formatter. This is either the global list, or list set by the IDE, or a specific fomatter set by the IDE (e.g. due to watch properties specifing a formatter) ~ "Current Valueformatter" is the formatter or list that was in use before the current formatter was called. This can be the "default", or it can be the formatter specified by the next outer value formatter (if they are called nested) In either case, the top "AResValue" passed from a value formatter to IWatchResultPrinter is NOT going to any value formatter (to avoid circles). The exception is, if wpfResValueIsNestedValue is used, as then the value should be a nested value. *) TWatchResultPrinterFlag = ( wpfResValueIsNestedValue, // inc nest level / allow ValueFormatter directly on new top AResValue wpfUseCurrentValueFormatterList, wpfUseDefaultValueFormatterList ); TWatchResultPrinterFlags = set of TWatchResultPrinterFlag; IWatchResultPrinter = interface ['{DD3F17BB-0875-4882-8D8B-348A30166984}'] function PrintWatchValue(AResValue: IWatchResultDataIntf; const ADispFormat: TWatchDisplayFormat; AFlags: TWatchResultPrinterFlags = [] ): String; //procedure SetValueFormatter end; TWatchResultDataFieldInfoIntf = record FieldName: String; FieldVisibility: TLzDbgFieldVisibility; FieldFlags: TLzDbgFieldFlags; Field: IWatchResultDataIntf; Owner: IWatchResultDataIntf; // defined in class end; IWatchResultDataIntf = interface ['{C69FF0ED-94F1-4F1A-BB67-CCED487A3DE5}'] // function GetClassID: TWatchResultDataClassID; function GetInternalObject: TObject; function GetValueKind: TWatchResultDataKind; function GetTypeName: String; function GetAsString: String; function GetAsDesc: String; function GetAsWideString: WideString; function GetAsQWord: QWord; function GetAsInt64: Int64; function GetAsFloat: Extended; function GetByteSize: Integer; function GetFloatPrecission: TLzDbgFloatPrecission; experimental; function GetCount: Integer; function GetLength: Integer; function GetElementName(AnIndex: integer): String; function GetDerefDataIntf: IWatchResultDataIntf; function GetArrayType: TLzDbgArrayType; function GetBoundTypeIntf: IWatchResultDataIntf; function GetLowBound: Int64; function GetSelectedEntryIntf: IWatchResultDataIntf; function GetDataAddress: TDBGPtr; function GetHasDataAddress: Boolean; function GetStructType: TLzDbgStructType; function GetAnchestorIntf: IWatchResultDataIntf; function GetAnchestorCount: Integer; function GetAnchestorsIntf(AnIndex: Integer): IWatchResultDataIntf; function GetDirectFieldCount: Integer; function GetFieldCount: Integer; function GetFieldsIntf(AnIndex: Integer): TWatchResultDataFieldInfoIntf; // function GetConvertedRes: IWatchResultDataIntf; experimental; function GetFieldVisibility: TLzDbgFieldVisibility; ////// property ClassID: TWatchResultDataClassID read GetClassId; property ValueKind: TWatchResultDataKind read GetValueKind; property TypeName: String read GetTypeName; property AsString: String read GetAsString; property AsDesc: String read GetAsDesc; property AsWideString: WideString read GetAsWideString; property AsQWord: QWord read GetAsQWord; property AsInt64: Int64 read GetAsInt64; property AsFloat: Extended read GetAsFloat; property ByteSize: Integer read GetByteSize; property FloatPrecission: TLzDbgFloatPrecission read GetFloatPrecission; experimental; property DerefData: IWatchResultDataIntf read GetDerefDataIntf; property ElementName[AnIndex: Integer]: String read GetElementName; // Array property ArrayType: TLzDbgArrayType read GetArrayType; property LowBound: Int64 read GetLowBound; property Count: Integer read GetCount; // Count of Entries evaluated property ArrayLength: Integer read GetLength; // Declared Length property BoundType: IWatchResultDataIntf read GetBoundTypeIntf; procedure SetSelectedIndex(AnIndex: Integer); property SelectedEntry: IWatchResultDataIntf read GetSelectedEntryIntf; property DataAddress: TDBGPtr read GetDataAddress; property HasDataAddress: Boolean read GetHasDataAddress; // Struct property StructType: TLzDbgStructType read GetStructType; property Anchestor: IWatchResultDataIntf read GetAnchestorIntf; property AnchestorCount: Integer read GetAnchestorCount; property Anchestors[AnIndex: Integer]: IWatchResultDataIntf read GetAnchestorsIntf; property FieldCount: Integer read GetFieldCount; property DirectFieldCount: Integer read GetDirectFieldCount; // without inherited fields property Fields[AnIndex: Integer]: TWatchResultDataFieldInfoIntf read GetFieldsIntf; // property ConvertedRes: IWatchResultDataIntf read GetConvertedRes; experimental; // variant property FieldVisibility: TLzDbgFieldVisibility read GetFieldVisibility; end; function dbgs(vdf: TValueDisplayFormat): string; overload; function dbgs(vdfs: TValueDisplayFormats): string; overload; function dbgs(vds: TValueDisplayFormatHexSeperator): string; overload; function dbgs(vds: TValueDisplayFormatHexSeperators): string; overload; function dbgs(vdnda: TValueDisplayNumDigitsArray): string; overload; function dbgs(df: TWatchDisplayFormat): string; overload; function dbgs(dfat: TValueDisplayFormatArrayType): string; overload; implementation { TWatchDisplayFormat } function dbgs(vdf: TValueDisplayFormat): string; begin WriteStr(Result, vdf); end; function dbgs(vdfs: TValueDisplayFormats): string; var d: TValueDisplayFormat; begin Result := ''; for d in TValueDisplayFormats do if d in vdfs then Result := Result + dbgs(d) + ','; if Result <> '' then begin Result := '[' + Result; Result[Length(Result)] := ']'; end else Result := '[]'; end; function dbgs(vds: TValueDisplayFormatHexSeperator): string; begin WriteStr(Result, vds); end; function dbgs(vds: TValueDisplayFormatHexSeperators): string; var d: TValueDisplayFormatHexSeperator; begin Result := ''; for d in TValueDisplayFormatHexSeperators do if d in vds then Result := Result + dbgs(d) + ','; if Result <> '' then begin Result := '[' + Result; Result[Length(Result)] := ']'; end else Result := '[]'; end; function dbgs(vdnda: TValueDisplayNumDigitsArray): string; var i: TValueDisplayFormatBase; begin Result := '['; for i := low(TValueDisplayNumDigitsArray) to high(TValueDisplayNumDigitsArray) do Result := Result + IntToStr(vdnda[i]) + ','; Result[Length(Result)] := ']'; end; function dbgs(df: TWatchDisplayFormat): string; begin Result := 'Num: ' +dbgs(df.Num.UseInherited)+' '+dbgs(df.Num.BaseFormat)+' '+dbgs(df.Num.SignFormat)+' '+ dbgs(df.Num.MinDigits)+' '+dbgs(df.Num.SeparatorDec)+' '+dbgs(df.Num.SeparatorHexBin)+ LineEnding+ 'Num2: '+' '+dbgs(df.Num2.UseInherited)+' '+dbgs(df.Num2.Visible)+' '+dbgs(df.Num2.BaseFormat)+' '+dbgs(df.Num2.SignFormat)+' '+ dbgs(df.Num2.MinDigits)+' '+dbgs(df.Num2.SeparatorDec)+' '+dbgs(df.Num2.SeparatorHexBin) + LineEnding+ 'Enum: '+dbgs(df.Enum.UseInherited)+' '+dbgs(df.Enum.MainFormat)+' '+dbgs(df.Enum.BaseFormat)+' '+dbgs(df.Enum.SignFormat) + LineEnding+ 'EnumVal: '+dbgs(df.EnumVal.UseInherited)+' '+dbgs(df.EnumVal.MainFormat)+' '+dbgs(df.EnumVal.BaseFormat)+' '+dbgs(df.EnumVal.SignFormat) + LineEnding+ 'Bool: '+dbgs(df.Bool.UseInherited)+' '+dbgs(df.Bool.MainFormat)+' '+dbgs(df.Bool.BaseFormat)+' '+dbgs(df.Bool.SignFormat) + LineEnding+ 'Char: '+dbgs(df.Char.UseInherited)+' '+dbgs(df.Char.MainFormat)+' '+dbgs(df.Char.BaseFormat)+' '+dbgs(df.Char.SignFormat) + LineEnding+ 'Float: '+dbgs(df.Float.UseInherited)+' '+dbgs(df.Float.NumFormat)+' '+dbgs(df.Float.Precission) + LineEnding+ 'Struct: '+dbgs(df.Struct.UseInherited)+' '+dbgs(df.Struct.DataFormat)+' '+dbgs(df.Struct.ShowPointerFormat) + LineEnding+ 'Addr: '+dbgs(df.Struct.Address.UseInherited)+' '+dbgs(df.Struct.Address.TypeFormat)+' '+dbgs(df.Struct.Address.BaseFormat)+' '+dbgs(df.Struct.Address.Signed)+' '+dbgs(df.Struct.Address.NoLeadZero) + LineEnding+ 'Ptr: '+dbgs(df.Pointer.UseInherited)+' '+dbgs(df.Pointer.DerefFormat) + LineEnding+ 'Addr: '+dbgs(df.Pointer.Address.UseInherited)+' '+dbgs(df.Pointer.Address.TypeFormat)+' '+dbgs(df.Pointer.Address.BaseFormat)+' '+dbgs(df.Pointer.Address.Signed)+' '+dbgs(df.Struct.Address.NoLeadZero) + LineEnding+ 'Array: '+dbgs(df.ArrayLen.UseInherited)+' '+dbgs(df.ArrayLen.ShowLenPrefix) +dbgs(df.ArrayLen.ShowLenPrefixEmbedded) +dbgs(df.ArrayLen.LenPrefixMaxNest) +dbgs(df.ArrayLen.LenPrefixCombine) + LineEnding+ 'Indent: '+dbgs(df.MultiLine.UseInherited)+' '+dbgs(df.MultiLine.MaxMultiLineDepth) + LineEnding+ 'ArrayNav: '+dbgs(df.ArrayNavBar.UseInherited)+' '+dbgs(df.ArrayNavBar.PageSize)+' '+dbgs(df.ArrayNavBar.EnforceBounds)+' '+dbgs(df.ArrayNavBar.AutoHideNavBar) + LineEnding+ 'Dmp: '+dbgs(df.MemDump); end; function dbgs(dfat: TValueDisplayFormatArrayType): string; begin WriteStr(Result, dfat); end; operator = (a, b: TValueDisplayNumDigitsArray): boolean; var i: TValueDisplayFormatBase; begin Result := False; for i := low(a) to high(a) do if a[i] <> b[i] then exit; Result := True; end; { TWatchDisplayFormatNum } class operator TWatchDisplayFormatNum. = (a, b: TWatchDisplayFormatNum): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.BaseFormat = b.BaseFormat) and (a.SignFormat = b.SignFormat) and (a.MinDigits = b.MinDigits) and (a.SeparatorDec = b.SeparatorDec) and (a.SeparatorHexBin = b.SeparatorHexBin) ; end; class operator TWatchDisplayFormatNum. := (a: TWatchDisplayFormatNum2): TWatchDisplayFormatNum; begin Result := DefaultWatchDisplayFormat.Num; Result.UseInherited := a.UseInherited; Result.BaseFormat := a.BaseFormat; Result.SignFormat := a.SignFormat; Result.MinDigits := a.MinDigits; Result.SeparatorDec := a.SeparatorDec; Result.SeparatorHexBin := a.SeparatorHexBin; end; { TWatchDisplayFormatNum2 } class operator TWatchDisplayFormatNum2. = (a, b: TWatchDisplayFormatNum2): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.Visible = b.Visible) and (a.BaseFormat = b.BaseFormat) and (a.SignFormat = b.SignFormat) and (a.MinDigits = b.MinDigits) and (a.SeparatorDec = b.SeparatorDec) and (a.SeparatorHexBin = b.SeparatorHexBin) ; end; { TWatchDisplayFormatEnum } class operator TWatchDisplayFormatEnum. = (a, b: TWatchDisplayFormatEnum): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.MainFormat = b.MainFormat) and (a.BaseFormat = b.BaseFormat) and (a.SignFormat = b.SignFormat) ; end; { TWatchDisplayFormatBool } class operator TWatchDisplayFormatBool. = (a, b: TWatchDisplayFormatBool): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.MainFormat = b.MainFormat) and (a.BaseFormat = b.BaseFormat) and (a.SignFormat = b.SignFormat) ; end; { TWatchDisplayFormatChar } class operator TWatchDisplayFormatChar. = (a, b: TWatchDisplayFormatChar): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.MainFormat = b.MainFormat) and (a.BaseFormat = b.BaseFormat) and (a.SignFormat = b.SignFormat) ; end; { TWatchDisplayFormatFloat } class operator TWatchDisplayFormatFloat. = (a, b: TWatchDisplayFormatFloat): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.NumFormat = b.NumFormat) and (a.Precission = b.Precission) ; end; { TWatchDisplayFormatAddr } class operator TWatchDisplayFormatAddr. = (a, b: TWatchDisplayFormatAddr): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.TypeFormat = b.TypeFormat) and (a.BaseFormat = b.BaseFormat) and (a.Signed = b.Signed) and (a.NoLeadZero = b.NoLeadZero) ; end; { TWatchDisplayFormatStruct } class operator TWatchDisplayFormatStruct. = (a, b: TWatchDisplayFormatStruct): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.DataFormat = b.DataFormat) and (a.ShowPointerFormat = b.ShowPointerFormat) and (a.Address = b.Address) ; end; { TWatchDisplayFormatPointer } class operator TWatchDisplayFormatPointer. = (a, b: TWatchDisplayFormatPointer): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.DerefFormat = b.DerefFormat) and (a.Address = b.Address) ; end; { TWatchDisplayFormatArrayLen } class operator TWatchDisplayFormatArrayLen. = (a, b: TWatchDisplayFormatArrayLen): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.ShowLenPrefix = b.ShowLenPrefix) and (a.ShowLenPrefixEmbedded = b.ShowLenPrefixEmbedded) and (a.LenPrefixMaxNest = b.LenPrefixMaxNest) and (a.LenPrefixCombine = b.LenPrefixCombine) and (a.HideLen = b.HideLen) and (a.HideLenThresholdCnt = b.HideLenThresholdCnt) and (a.HideLenKeepDepth = b.HideLenKeepDepth) and (a.HideLenThresholdEach = b.HideLenThresholdEach) and (a.HideLenThresholdLen = b.HideLenThresholdLen) ; end; { TWatchDisplayFormatMultiline } class operator TWatchDisplayFormatMultiline. = (a, b: TWatchDisplayFormatMultiline): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.MaxMultiLineDepth = b.MaxMultiLineDepth) and (a.ForceSingleLine = b.ForceSingleLine) and (a.ForceSingleLineThresholdStructFld = b.ForceSingleLineThresholdStructFld) and (a.ForceSingleLineThresholdArrayLen = b.ForceSingleLineThresholdArrayLen) and (a.ForceSingleLineReverseDepth = b.ForceSingleLineReverseDepth) and (a.ForceSingleLineThresholdEach = b.ForceSingleLineThresholdEach) and (a.ForceSingleLineThresholdLen = b.ForceSingleLineThresholdLen) ; end; { TWatchDisplayFormatArrayNav } class operator TWatchDisplayFormatArrayNav. = (a, b: TWatchDisplayFormatArrayNav): boolean; begin Result := (a.UseInherited = b.UseInherited) and (a.PageSize = b.PageSize) and (a.EnforceBounds = b.EnforceBounds) and (a.AutoHideNavBar = b.AutoHideNavBar); end; class operator TWatchDisplayFormat. = (a, b: TWatchDisplayFormat): boolean; begin Result := (a.Num = b.Num) and (a.Num2 = b.Num2) and (a.Enum = b.Enum) and (a.EnumVal = b.EnumVal) and (a.Bool = b.Bool) and (a.Char = b.Char) and (a.Float = b.Float) and (a.Struct = b.Struct) and (a.Pointer = b.Pointer) and (a.ArrayLen = b.ArrayLen) and (a.MultiLine = b.MultiLine) and (a.ArrayNavBar = b.ArrayNavBar) and (a.MemDump = b.MemDump); end; function TWatchDisplayFormat.HasOverrides: boolean; begin Result := not(Num.UseInherited and Num2.UseInherited and Enum.UseInherited and EnumVal.UseInherited and Bool.UseInherited and Char.UseInherited and Float.UseInherited and Struct.UseInherited and Struct.Address.UseInherited and Pointer.UseInherited and Pointer.Address.UseInherited and ArrayLen.UseInherited and MultiLine.UseInherited and ArrayNavBar.UseInherited ); end; procedure TWatchDisplayFormat.MakeAllOverrides; begin Num.UseInherited := False; Num2.UseInherited := False; Enum.UseInherited := False; EnumVal.UseInherited := False; Bool.UseInherited := False; Char.UseInherited := False; Float.UseInherited := False; Struct.UseInherited := False; Struct.Address.UseInherited := False; Pointer.UseInherited := False; Pointer.Address.UseInherited := False; ArrayLen.UseInherited := False; MultiLine.UseInherited := False; ArrayNavBar.UseInherited := False; end; procedure TWatchDisplayFormat.CopyInheritedFrom(AnOther: TWatchDisplayFormat); var a: TWatchDisplayFormatAddr; begin if Num.UseInherited then Num := AnOther.Num; if Num2.UseInherited then Num2 := AnOther.Num2; if Enum.UseInherited then Enum := AnOther.Enum; if EnumVal.UseInherited then EnumVal := AnOther.EnumVal; if Bool.UseInherited then Bool := AnOther.Bool; if Char.UseInherited then Char := AnOther.Char; if Float.UseInherited then Float := AnOther.Float; a := Struct.Address; if Struct.UseInherited then Struct := AnOther.Struct; if not a.UseInherited then Struct.Address := a; a := Pointer.Address; if Pointer.UseInherited then Pointer := AnOther.Pointer; if not a.UseInherited then Pointer.Address := a; if ArrayLen.UseInherited then ArrayLen := AnOther.ArrayLen; if MultiLine.UseInherited then MultiLine := AnOther.MultiLine; if ArrayNavBar.UseInherited then ArrayNavBar := AnOther.ArrayNavBar; end; end.