← Back to branch summary

~ubuntu-branches/ubuntu/saucy/lazarus/saucy

« back to all changes in this revision

Viewing changes to debugger/test/Gdbmi/testwatches.pas

  • Committer: Package Import Robot
  • Author(s): Paul Gevers, Abou Al Montacir, Bart Martens, Paul Gevers
  • Date: 2013-06-08 14:12:17 UTC
  • mfrom: (1.1.9)
  • Revision ID: package-import@ubuntu.com-20130608141217-7k0cy9id8ifcnutc
Tags: 1.0.8+dfsg-1
http://bugs.debian.org/708695
[ Abou Al Montacir ]
* New upstream major release and multiple maintenace release offering many
  fixes and new features marking a new milestone for the Lazarus development
  and its stability level.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_fixes_branch
* LCL changes:
  - LCL is now a normal package.
      + Platform independent parts of the LCL are now in the package LCLBase
      + LCL is automatically recompiled when switching the target platform,
        unless pre-compiled binaries for this target are already installed.
      + No impact on existing projects.
      + Linker options needed by LCL are no more added to projects that do
        not use the LCL package.
  - Minor changes in LCL basic classes behaviour
      + TCustomForm.Create raises an exception if a form resource is not
        found.
      + TNotebook and TPage: a new implementation of these classes was added.
      + TDBNavigator: It is now possible to have focusable buttons by setting
        Options = [navFocusableButtons] and TabStop = True, useful for
        accessibility and for devices with neither mouse nor touch screen.
      + Names of TControlBorderSpacing.GetSideSpace and GetSpace were swapped
        and are now consistent. GetSideSpace = Around + GetSpace.
      + TForm.WindowState=wsFullscreen was added
      + TCanvas.TextFitInfo was added to calculate how many characters will
        fit into a specified Width. Useful for word-wrapping calculations.
      + TControl.GetColorResolvingParent and
        TControl.GetRGBColorResolvingParent were added, simplifying the work
        to obtain the final color of the control while resolving clDefault
        and the ParentColor.
      + LCLIntf.GetTextExtentExPoint now has a good default implementation
        which works in any platform not providing a specific implementation.
        However, Widgetset specific implementation is better, when available.
      + TTabControl was reorganized. Now it has the correct class hierarchy
        and inherits from TCustomTabControl as it should.
  - New unit in the LCL:
      + lazdialogs.pas: adds non-native versions of various native dialogs,
        for example TLazOpenDialog, TLazSaveDialog, TLazSelectDirectoryDialog.
        It is used by widgetsets which either do not have a native dialog, or
        do not wish to use it because it is limited. These dialogs can also be
        used by user applications directly.
      + lazdeviceapis.pas: offers an interface to more hardware devices such
        as the accelerometer, GPS, etc. See LazDeviceAPIs
      + lazcanvas.pas: provides a TFPImageCanvas descendent implementing
        drawing in a LCL-compatible way, but 100% in Pascal.
      + lazregions.pas. LazRegions is a wholly Pascal implementation of
        regions for canvas clipping, event clipping, finding in which control
        of a region tree one an event should reach, for drawing polygons, etc.
      + customdrawncontrols.pas, customdrawndrawers.pas,
        customdrawn_common.pas, customdrawn_android.pas and
        customdrawn_winxp.pas: are the Lazarus Custom Drawn Controls -controls
        which imitate the standard LCL ones, but with the difference that they
        are non-native and support skinning.
  - New APIs added to the LCL to improve support of accessibility software
    such as screen readers.
* IDE changes:
  - Many improvments.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/New_IDE_features_since#v1.0_.282012-08-29.29
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes#IDE_Changes
* Debugger / Editor changes:
  - Added pascal sources and breakpoints to the disassembler
  - Added threads dialog.
* Components changes:
  - TAChart: many fixes and new features
  - CodeTool: support Delphi style generics and new syntax extensions.
  - AggPas: removed to honor free licencing. (Closes: Bug#708695)
[Bart Martens]
* New debian/watch file fixing issues with upstream RC release.
[Abou Al Montacir]
* Avoid changing files in .pc hidden directory, these are used by quilt for
  internal purpose and could lead to surprises during build.
[Paul Gevers]
* Updated get-orig-source target and it compinion script orig-tar.sh so that they
  repack the source file, allowing bug 708695 to be fixed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debugger/test/Gdbmi/testwatches.pas
5
5
interface
6
6
 
7
7
uses
8
 
  Classes, SysUtils, fpcunit, testutils, testregistry,
 
8
  Classes, SysUtils, fpcunit, testutils, testregistry, TestGDBMIControl,
9
9
  TestBase, Debugger, GDBMIDebugger, LCLProc, SynRegExpr, Forms, StdCtrls, Controls;
10
10
 
11
11
const
12
 
  BREAK_LINE_FOOFUNC = 113;
 
12
  BREAK_LINE_FOOFUNC_NEST  = 206;
 
13
  BREAK_LINE_FOOFUNC       = 230;
 
14
  BREAK_LINE_FOOFUNC_ARRAY = 254;
 
15
  RUN_GDB_TEST_ONLY = -1; // -1 run all
13
16
  RUN_TEST_ONLY = -1; // -1 run all
14
17
 
15
18
(*  TODO:
25
28
 
26
29
type
27
30
 
28
 
  { TTestWatch }
29
 
 
30
 
  TTestWatch = class(TBaseWatch)
31
 
  private
32
 
    FHasMultiValue: Boolean;
33
 
    FHasValue: Boolean;
34
 
    FMaster: TDBGWatch;
35
 
    FValue: String;
36
 
    FTypeInfo: TDBGType;
37
 
  protected
38
 
    procedure DoChanged; override;
39
 
    function GetTypeInfo: TDBGType; override;
40
 
    procedure SetDisplayFormat(const AValue: TWatchDisplayFormat); override;
41
 
  public
42
 
    constructor Create(AOwner: TBaseWatches; AMaster: TDBGWatch);
43
 
    property Master: TDBGWatch read FMaster;
44
 
    property HasMultiValue: Boolean read FHasMultiValue;
45
 
    property HasValue: Boolean read FHasValue;
46
 
    property Value: String read FValue;
47
 
  end;
 
31
  TWatchExpectationFlag =
 
32
    (IgnDwrf,            // ignore error for dwarf at all
 
33
     IgnDwrf2,           // ignore error for dwarf 2
 
34
     IgnDwrf2IfNoSet,    // ignore error for dwarf2 (-gw) without set
 
35
     IgnDwrf3,           // ignore error for dwarf 3
 
36
     IgnStabs,
 
37
     //IgnDwrfSet,   // no dwarf2 with set // no dwarf3
 
38
 
 
39
     IgnData,           // Ignore the data part
 
40
     IgnDataDw,         // Ignore the data part, if dwarf
 
41
     IgnDataDw2,        // Ignore the data part, if dwarf 2
 
42
     IgnDataDw3,        // Ignore the data part, if dwarf 3
 
43
     IgnDataSt,         // Ignore the data part, if Stabs
 
44
 
 
45
     IgnKind,           // Ignore skSimple, ....
 
46
     IgnKindDw,
 
47
     IgnKindDw2,
 
48
     IgnKindDw3,
 
49
     IgnKindSt,
 
50
 
 
51
     IgnKindPtr,           // Ignore skSimple, ONLY if got kind=skPointer
 
52
     IgnKindPtrDw,
 
53
     IgnKindPtrDw2,
 
54
     IgnKindPtrDw3,
 
55
     IgnKindPtrSt,
 
56
 
 
57
     IgnTpName,           // Ignore the typename
 
58
     IgnTpNameDw,
 
59
     IgnTpNameDw2,
 
60
     IgnTpNameDw3,
 
61
     IgnTpNameSt,
 
62
 
 
63
     fTstSkip,       // Do not run test
 
64
     fTstSkipDwarf3,
 
65
     fTpMtch
 
66
    );
 
67
  TWatchExpectationFlags = set of TWatchExpectationFlag;
 
68
 
 
69
const
 
70
  WatchExpFlagMask: array[TSymbolType] of TWatchExpectationFlags
 
71
  = ( {stNone}     [],
 
72
      {stStabs}    [IgnStabs,
 
73
                    IgnData,    IgnDataSt,
 
74
                    IgnKind,    IgnKindSt,
 
75
                    IgnKindPtr, IgnKindPtrSt,
 
76
                    IgnTpName,  IgnTpNameSt
 
77
                   ],
 
78
      {stDwarf}    [IgnDwrf, IgnDwrf2, IgnDwrf2IfNoSet,
 
79
                    IgnData,    IgnDataDw, IgnDataDw2,
 
80
                    IgnKind,    IgnKindDw, IgnKindDw2,
 
81
                    IgnKindPtr, IgnKindPtrDw, IgnKindPtrDw2,
 
82
                    IgnTpName,  IgnTpNameDw, IgnTpNameDw2
 
83
                   ],
 
84
      {stDwarfSet} [IgnDwrf, IgnDwrf2,
 
85
                    IgnData,    IgnDataDw, IgnDataDw2,
 
86
                    IgnKind,    IgnKindDw, IgnKindDw2,
 
87
                    IgnKindPtr, IgnKindPtrDw, IgnKindPtrDw2,
 
88
                    IgnTpName,  IgnTpNameDw, IgnTpNameDw2
 
89
                   ],
 
90
      {stDwarf3}   [IgnDwrf, IgnDwrf3,
 
91
                    IgnData,    IgnDataDw, IgnDataDw3,
 
92
                    IgnKind,    IgnKindDw, IgnKindDw3,
 
93
                    IgnKindPtr, IgnKindPtrDw, IgnKindPtrDw3,
 
94
                    IgnTpName,  IgnTpNameDw, IgnTpNameDw3
 
95
                   ]
 
96
    );
 
97
 
 
98
  WatchExpFlagSIgnAll     = [IgnStabs, IgnDwrf, IgnDwrf2, IgnDwrf2IfNoSet, IgnDwrf3];
 
99
  WatchExpFlagSIgnData    = [IgnStabs, IgnDwrf, IgnDwrf2, IgnDwrf2IfNoSet, IgnDwrf3,  IgnData,    IgnDataDw, IgnDataDw2, IgnDataDw3, IgnDataSt];
 
100
  WatchExpFlagSIgnKind    = [IgnStabs, IgnDwrf, IgnDwrf2, IgnDwrf2IfNoSet, IgnDwrf3,  IgnKind,    IgnKindDw, IgnKindDw2, IgnKindDw3, IgnKindSt];
 
101
  WatchExpFlagSIgnKindPtr = [IgnStabs, IgnDwrf, IgnDwrf2, IgnDwrf2IfNoSet, IgnDwrf3,  IgnKindPtr, IgnKindPtrDw, IgnKindPtrDw2, IgnKindPtrDw3, IgnKindPtrSt];
 
102
  WatchExpFlagSIgnTpName  = [IgnStabs, IgnDwrf, IgnDwrf2, IgnDwrf2IfNoSet, IgnDwrf3,  IgnTpName,  IgnTpNameDw, IgnTpNameDw2, IgnTpNameDw3, IgnTpNameSt];
 
103
 
 
104
type
 
105
 
 
106
  PWatchExpectation= ^TWatchExpectation;
 
107
  TWatchExpectationResult = record
 
108
    ExpMatch: string;
 
109
    ExpKind: TDBGSymbolKind;
 
110
    ExpTypeName: string;
 
111
    Flgs: TWatchExpectationFlags;
 
112
    MinGdb, MinFpc: Integer;
 
113
  end;
 
114
 
 
115
  TWatchExpectation = record
 
116
    TestName: String;
 
117
    Expression:  string;
 
118
    DspFormat: TWatchDisplayFormat;
 
119
    StackFrame: Integer;
 
120
    Result: Array [TSymbolType] of TWatchExpectationResult;
 
121
  end;
 
122
  TWatchExpectationArray = array of TWatchExpectation;
 
123
 
48
124
 
49
125
  { TTestWatches }
50
126
 
51
127
  TTestWatches = class(TGDBTestCase)
52
128
  private
53
 
    FWatches: TBaseWatches;
54
 
    procedure DoDbgOutput(Sender: TObject; const AText: String);
 
129
    FWatches: TcurrentWatches;
 
130
 
 
131
    ExpectBreakFooGdb: TWatchExpectationArray;    // direct commands to gdb, to check assumptions  // only Exp and Mtch
 
132
    ExpectBreakSubFoo: TWatchExpectationArray;    // Watches, evaluated in SubFoo (nested)
 
133
    ExpectBreakFoo: TWatchExpectationArray;       // Watches, evaluated in Foo
 
134
    ExpectBreakFooArray: TWatchExpectationArray;       // Watches, evaluated in Foo_Array
 
135
 
 
136
    FCurrentExpArray: ^TWatchExpectationArray; // currently added to
 
137
 
 
138
    FDbgOutPut: String;
 
139
    FDbgOutPutEnable: Boolean;
 
140
    FDoStatIntArray: Boolean;
 
141
 
 
142
    procedure DoDbgOutput(Sender: TObject; const AText: String); override;
 
143
    procedure ClearAllTestArrays;
 
144
    function  HasTestArraysData: Boolean;
 
145
    function AddTo(var ExpArray: TWatchExpectationArray;
 
146
      AnExpr:  string; AFmt: TWatchDisplayFormat;
 
147
      AMtch: string; AKind: TDBGSymbolKind; ATpNm: string;
 
148
      AFlgs: TWatchExpectationFlags = [];
 
149
      AStackFrame: Integer = 0;
 
150
      AMinGdb: Integer = 0; AMinFpc: Integer = 0
 
151
    ): PWatchExpectation;
 
152
    function AddTo(var ExpArray: TWatchExpectationArray; ATestName: String;
 
153
      AnExpr:  string; AFmt: TWatchDisplayFormat;
 
154
      AMtch: string; AKind: TDBGSymbolKind; ATpNm: string;
 
155
      AFlgs: TWatchExpectationFlags = [];
 
156
      AStackFrame: Integer = 0;
 
157
      AMinGdb: Integer = 0; AMinFpc: Integer = 0
 
158
    ): PWatchExpectation;
 
159
 
 
160
    // using FCurrentExpArray
 
161
    function Add(AnExpr:  string; AFmt: TWatchDisplayFormat; AMtch: string;
 
162
                 AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
163
    function AddFmtDef        (AnExpr, AMtch: string; AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
164
    function AddStringFmtDef  (AnExpr, AMtch, ATpNm: string; AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
165
    function AddShortStrFmtDef(AnExpr, AMtch: string; ATpNm: string = 'ShortString'; AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
166
    function AddCharFmtDef    (AnExpr, AMtch: string; ATpNm: string = 'Char'; AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
167
    function AddPointerFmtDef (AnExpr,        ATpNm: string; AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
168
    function AddPointerFmtDef (AnExpr, AMtch, ATpNm: string; AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
169
    function AddPointerFmtDefRaw(AnExpr, AMtch, ATpNm: string; AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
170
 
 
171
 
 
172
    procedure UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
173
      AMtch: string; AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags;
 
174
      AMinGdb: Integer; AMinFpc: Integer
 
175
    );
 
176
    procedure UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
177
      AMtch: string; AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags = []
 
178
    );
 
179
    procedure UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
180
      AMtch: string; AKind: TDBGSymbolKind
 
181
    );
 
182
    procedure UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
183
      AKind: TDBGSymbolKind
 
184
    );
 
185
    procedure UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
186
      ATpNm: string; AFlgs: TWatchExpectationFlags
 
187
    );
 
188
    procedure UpdResMinGdb(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType; AMinGdb: Integer);
 
189
    procedure UpdResMinFpc(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType; AMinFpc: Integer);
 
190
 
 
191
    procedure UpdRes(AWatchExp: PWatchExpectation; ASymbolTypes: TSymbolTypes;
 
192
      ATpNm: string; AFlgs: TWatchExpectationFlags
 
193
    );
 
194
    procedure UpdResMinGdb(AWatchExp: PWatchExpectation; ASymbolTypes: TSymbolTypes; AMinGdb: Integer);
 
195
    procedure UpdResMinFpc(AWatchExp: PWatchExpectation; ASymbolTypes: TSymbolTypes; AMinFpc: Integer);
 
196
 
 
197
    procedure AddExpectBreakFooGdb;
 
198
    procedure AddExpectBreakFooAll;
 
199
    procedure AddExpectBreakFooArray;
 
200
    procedure AddExpectBreakFooMixInfo;
 
201
    //procedure AddExpectBreakSubFoo;
 
202
    procedure AddExpectBreakFooAndSubFoo;  // check for caching issues
 
203
    procedure RunTestWatches(NamePreFix: String;
 
204
                             TestExeName, ExtraOpts: String;
 
205
                             UsedUnits: array of TUsesDir
 
206
                            );
55
207
  public
56
208
    procedure DebugInteract(dbg: TGDBMIDebugger);
57
 
 
58
209
  published
59
210
    procedure TestWatches;
60
211
  end;
61
212
 
62
213
implementation
63
214
 
64
 
var
65
 
  DbgForm: TForm;
66
 
  DbgMemo: TMemo;
67
 
  DbgLog: Boolean;
68
 
 
69
215
const
70
216
  RNoPreQuote  = '(^|[^''])'; // No open qoute (Either at start, or other char)
71
217
  RNoPostQuote = '($|[^''])'; // No close qoute (Either at end, or other char)
72
 
 
73
 
type
74
 
  TWatchExpectationFlag =
75
 
    (fnoDwrf,      // no dwarf at all
76
 
     fnoDwrfNoSet, // no dwarf2 (-gw) without set
77
 
     //fnoDwrfSet,   // no dwarf2 with set // no dwarf3
78
 
     fnoDwrf2, fnoDwrf3,
79
 
     fnoStabs, // no stabs
80
 
     fTpMtch
81
 
    );
82
 
  TWatchExpectationFlags = set of TWatchExpectationFlag;
83
 
  TWatchExpectation = record
84
 
    Exp:  string;
85
 
    Fmt: TWatchDisplayFormat;
86
 
 
87
 
    Mtch: string;
88
 
    Kind: TDBGSymbolKind;
89
 
    TpNm: string;
90
 
    Flgs: TWatchExpectationFlags;
91
 
  end;
92
 
 
93
 
const
94
218
  Match_Pointer = '\$[0-9A-F]+';
95
 
  Match_ArgTRec  = 'record TREC .+ valint = -1.+valfoo'; // record TREC {  VALINT = -1,  VALFOO = $0}
96
 
  Match_ArgTRec1 = 'record TREC .+ valint = 1.+valfoo'; // record TREC {  VALINT = 1,  VALFOO = $xxx}
97
 
  Match_ArgTRec2 = 'record TREC .+ valint = 2.+valfoo'; // record TREC {  VALINT = 2,  VALFOO = $xxx}
98
 
  // TODO: TNewRec
99
 
  Match_ArgTNewRec  = 'record T(NEW)?REC .+ valint = 3.+valfoo'; // record TREC {  VALINT = 3,  VALFOO = $0}
 
219
  M_Int = 'Integer|LongInt';
100
220
 
101
221
  {%region    * Classes * }
102
222
  // _vptr$TOBJECt on older gdb e.g. mac 6.3.50
105
225
  {%ebdregion    * Classes * }
106
226
  // Todo: Dwarf fails with dereferenced var pointer types
107
227
 
108
 
  ExpectBrk1NoneNil: Array [1..121] of TWatchExpectation = (
109
 
    {%region    * records * }
110
 
 
111
 
    (Exp: 'ArgTRec';       Fmt: wdfDefault;  Mtch: Match_ArgTRec;                   Kind: skRecord;      TpNm: 'TRec'; Flgs: []),
112
 
    (Exp: 'VArgTRec';      Fmt: wdfDefault;  Mtch: Match_ArgTRec;                   Kind: skRecord;      TpNm: 'TRec'; Flgs: []),
113
 
    (Exp: 'ArgPRec';       Fmt: wdfDefault;  Mtch: '^PRec\('+Match_Pointer;      Kind: skPointer;     TpNm: 'PRec'; Flgs: []),
114
 
    (Exp: 'VArgPRec';      Fmt: wdfDefault;  Mtch: '^PRec\('+Match_Pointer;      Kind: skPointer;     TpNm: 'PRec'; Flgs: []),
115
 
    (Exp: 'ArgPRec^';       Fmt: wdfDefault;  Mtch: Match_ArgTRec1;                  Kind: skRecord;      TpNm: 'TRec'; Flgs: []),
116
 
    (Exp: 'VArgPRec^';      Fmt: wdfDefault;  Mtch: Match_ArgTRec1;                  Kind: skRecord;      TpNm: 'TRec'; Flgs: [fnoDwrf]),
117
 
    (Exp: 'ArgPPRec';      Fmt: wdfDefault;  Mtch: '^PPRec\('+Match_Pointer;     Kind: skPointer;     TpNm: 'PPRec'; Flgs: []),
118
 
    (Exp: 'VArgPPRec';     Fmt: wdfDefault;  Mtch: '^PPRec\('+Match_Pointer;     Kind: skPointer;     TpNm: 'PPRec'; Flgs: []),
119
 
    (Exp: 'ArgPPRec^';      Fmt: wdfDefault;  Mtch: '^PRec\('+Match_Pointer;     Kind: skPointer;      TpNm: 'PRec'; Flgs: []),
120
 
    (Exp: 'VArgPPRec^';     Fmt: wdfDefault;  Mtch: '^PRec\('+Match_Pointer;     Kind: skPointer;      TpNm: 'PRec'; Flgs: [fnoDwrf]),
121
 
    (Exp: 'ArgPPRec^^';     Fmt: wdfDefault;  Mtch: Match_ArgTRec1;                  Kind: skRecord;      TpNm: 'TRec'; Flgs: []),
122
 
    (Exp: 'VArgPPRec^^';    Fmt: wdfDefault;  Mtch: Match_ArgTRec1;                  Kind: skRecord;      TpNm: 'TRec'; Flgs: [fnoDwrf]),
123
 
    (Exp: 'ArgTNewRec';    Fmt: wdfDefault;  Mtch: Match_ArgTNewRec;                Kind: skRecord;      TpNm: 'T(New)?Rec'; Flgs: [fTpMtch]),
124
 
    (Exp: 'VArgTNewRec';   Fmt: wdfDefault;  Mtch: Match_ArgTNewRec;                Kind: skRecord;      TpNm: 'T(New)?Rec'; Flgs: [fTpMtch]),
125
 
 
126
 
    (Exp: 'VarTRec';       Fmt: wdfDefault;  Mtch: Match_ArgTRec;                   Kind: skRecord;      TpNm: 'TRec'; Flgs: []),
127
 
    (Exp: 'VarPRec';       Fmt: wdfDefault;  Mtch: '^PRec\('+Match_Pointer;      Kind: skPointer;     TpNm: 'PRec'; Flgs: []),
128
 
    (Exp: 'VarPRec^';       Fmt: wdfDefault;  Mtch: Match_ArgTRec1;                  Kind: skRecord;      TpNm: 'TRec'; Flgs: []),
129
 
    (Exp: 'VarPPRec';      Fmt: wdfDefault;  Mtch: '^PPRec\('+Match_Pointer;     Kind: skPointer;     TpNm: 'PPRec'; Flgs: []),
130
 
    (Exp: 'VarPPRec^';      Fmt: wdfDefault;  Mtch: '^PRec\('+Match_Pointer;     Kind: skPointer;      TpNm: 'PRec'; Flgs: []),
131
 
    (Exp: 'VarPPRec^^';     Fmt: wdfDefault;  Mtch: Match_ArgTRec1;                  Kind: skRecord;      TpNm: 'TRec'; Flgs: []),
132
 
    (Exp: 'VarTNewRec';    Fmt: wdfDefault;  Mtch: Match_ArgTNewRec;                Kind: skRecord;      TpNm: 'T(New)?Rec'; Flgs: [fTpMtch]),
133
 
 
134
 
    (Exp: 'PVarTRec';      Fmt: wdfDefault;  Mtch: '^(\^T|P)Rec\('+Match_Pointer;     Kind: skPointer;     TpNm: '^(\^T|P)Rec$'; Flgs: [fTpMtch]), // TODO: stabs returns PRec
135
 
    (Exp: 'PVarTRec^';      Fmt: wdfDefault;  Mtch: Match_ArgTRec;                   Kind: skRecord;      TpNm: 'TRec'; Flgs: []),
136
 
    (Exp: 'PVarTNewRec';   Fmt: wdfDefault;  Mtch: '^\^TNewRec\('+Match_Pointer;    Kind: skPointer;     TpNm: '\^T(New)?Rec'; Flgs: [fTpMtch]),
137
 
    (Exp: 'PVarTNewRec^';   Fmt: wdfDefault;  Mtch: Match_ArgTNewRec;                Kind: skRecord;      TpNm: 'T(New)?Rec'; Flgs: [fTpMtch]),
138
 
    {%endregion    * records * }
139
 
 
140
 
// @ArgTRec @VArgTRec  @ArgTRec^ @VArgTRec^
141
 
 
142
 
    {%region    * Classes * }
143
 
 
144
 
    (Exp: 'ArgTFoo';    Fmt: wdfDefault;  Mtch: Match_ArgTFoo;                 Kind: skClass;   TpNm: 'TFoo';  Flgs: []),
145
 
    (Exp: '@ArgTFoo';   Fmt: wdfDefault;  Mtch: '(P|\^T)Foo\('+Match_Pointer;  Kind: skPointer; TpNm: '(P|\^T)Foo';  Flgs: [fTpMtch]),
146
 
    // Only with brackets...
147
 
    (Exp: '(@ArgTFoo)^'; Fmt: wdfDefault;  Mtch: Match_ArgTFoo;                Kind: skClass;   TpNm: 'TFoo';  Flgs: []),
148
 
 
149
 
    (Exp: 'ArgPFoo';    Fmt: wdfDefault;  Mtch: 'PFoo\('+Match_Pointer;        Kind: skPointer; TpNm: 'PFoo';  Flgs: []),
150
 
    (Exp: 'ArgPFoo^';   Fmt: wdfDefault;  Mtch: Match_ArgTFoo1;                Kind: skClass;   TpNm: 'TFoo';  Flgs: []),
151
 
    (Exp: '@ArgPFoo';   Fmt: wdfDefault;  Mtch: '(P|\^)PFoo\('+Match_Pointer;  Kind: skPointer; TpNm: '(P|\^)PFoo';  Flgs: [fTpMtch]),
152
 
 
153
 
    (Exp: 'ArgPPFoo';   Fmt: wdfDefault;  Mtch: 'PPFoo\('+Match_Pointer;       Kind: skPointer; TpNm: 'PPFoo'; Flgs: []),
154
 
    (Exp: 'ArgPPFoo^';  Fmt: wdfDefault;  Mtch: 'PFoo\('+Match_Pointer;        Kind: skPointer; TpNm: 'PFoo';  Flgs: []),
155
 
    (Exp: '@ArgPPFoo';  Fmt: wdfDefault;  Mtch: '\^PPFoo\('+Match_Pointer;      Kind: skPointer; TpNm: '^PPFoo'; Flgs: []),
156
 
    (Exp: 'ArgPPFoo^^'; Fmt: wdfDefault;  Mtch: Match_ArgTFoo1;                Kind: skClass;   TpNm: 'TFoo';  Flgs: []),
157
 
 
158
 
 
159
 
    (Exp: 'VArgTFoo';   Fmt: wdfDefault;  Mtch: Match_ArgTFoo;                 Kind: skClass;   TpNm: 'TFoo';  Flgs: []),
160
 
    (Exp: '@VArgTFoo';  Fmt: wdfDefault;  Mtch: '(P|\^T)Foo\('+Match_Pointer;  Kind: skPointer; TpNm: '(P|\^T)Foo';  Flgs: [fTpMtch]),
161
 
    (Exp: '(@VArgTFoo)^'; Fmt: wdfDefault;  Mtch: Match_ArgTFoo;                 Kind: skClass;   TpNm: 'TFoo';  Flgs: []),
162
 
 
163
 
    (Exp: 'VArgPFoo';   Fmt: wdfDefault;  Mtch: 'PFoo\('+Match_Pointer;        Kind: skPointer; TpNm: 'PFoo';  Flgs: []),
164
 
    (Exp: 'VArgPFoo^' ; Fmt: wdfDefault;  Mtch: Match_ArgTFoo1;                Kind: skClass;   TpNm: 'TFoo';  Flgs: [fnoDwrf]),
165
 
    (Exp: '@VArgPFoo';  Fmt: wdfDefault;  Mtch: '(P|\^)PFoo\('+Match_Pointer;  Kind: skPointer; TpNm: '(P|\^)PFoo';  Flgs: [fTpMtch]),
166
 
 
167
 
    (Exp: 'VArgPPFoo';  Fmt: wdfDefault;  Mtch: 'PPFoo\('+Match_Pointer;       Kind: skPointer; TpNm: 'PPFoo'; Flgs: []),
168
 
    (Exp: 'VArgPPFoo^'; Fmt: wdfDefault;  Mtch: 'PFoo\('+Match_Pointer;        Kind: skPointer; TpNm: 'PFoo';  Flgs: [fnoDwrf]),
169
 
    (Exp: '@VArgPPFoo'; Fmt: wdfDefault;  Mtch: '\^PPFoo\('+Match_Pointer;      Kind: skPointer; TpNm: '^PPFoo'; Flgs: []),
170
 
    (Exp: 'VArgPPFoo^^'; Fmt: wdfDefault;  Mtch: Match_ArgTFoo1;               Kind: skClass;   TpNm: 'TFoo';  Flgs: [fnoDwrf]),
171
 
 
172
 
 
173
 
    (Exp: 'ArgTFoo.ValueInt';     Fmt: wdfDefault;  Mtch: '^-11$';             Kind: skSimple;   TpNm: 'Integer|LongInt';  Flgs: [fTpMtch]),
174
 
    (Exp: 'ArgPFoo^.ValueInt';    Fmt: wdfDefault;  Mtch: '^31$';             Kind: skSimple;   TpNm: 'Integer|LongInt';  Flgs: [fTpMtch]),
175
 
    // GDB automatically derefs the pointer
176
 
    //(Exp: 'ArgPFoo.ValueInt';     Fmt: wdfDefault;  Mtch: 'error';            Kind: skSimple;   TpNm: '';  Flgs: []),
177
 
    (Exp: 'ArgPPFoo^^.ValueInt';  Fmt: wdfDefault;  Mtch: '^31$';             Kind: skSimple;   TpNm: 'Integer|LongInt';  Flgs: [fTpMtch]),
178
 
    //(Exp: 'ArgPPFoo.ValueInt';     Fmt: wdfDefault;  Mtch: 'error';            Kind: skSimple;   TpNm: '';  Flgs: []),
179
 
 
180
 
    (Exp: 'VArgTFoo.ValueInt';    Fmt: wdfDefault;  Mtch: '^-11$';             Kind: skSimple;   TpNm: 'Integer|LongInt';  Flgs: [fTpMtch]),
181
 
    (Exp: 'VArgPFoo^.ValueInt';   Fmt: wdfDefault;  Mtch: '^31$';             Kind: skSimple;   TpNm: 'Integer|LongInt';  Flgs: [fTpMtch]),
182
 
    //(Exp: 'VArgPFoo.ValueInt';    Fmt: wdfDefault;  Mtch: 'error';            Kind: skSimple;   TpNm: '';  Flgs: []),
183
 
    (Exp: 'VArgPPFoo^^.ValueInt'; Fmt: wdfDefault;  Mtch: '^31$';             Kind: skSimple;   TpNm: 'Integer|LongInt';  Flgs: [fTpMtch]),
184
 
    //(Exp: 'VArgPPFoo.ValueInt';    Fmt: wdfDefault;  Mtch: 'error';            Kind: skSimple;   TpNm: '';  Flgs: []),
185
 
 
186
 
 
187
 
    (Exp: 'ArgTFoo';    Fmt: wdfPointer;  Mtch: Match_Pointer;                           Kind: skClass;   TpNm: 'TFoo';  Flgs: []),
188
 
    (Exp: 'ArgTFoo';    Fmt: wdfMemDump;  Mtch: ':.*?6D 65 6D 20 6F 66 20 54 46 6F 6F';  Kind: skClass;   TpNm: 'TFoo';  Flgs: []),
189
 
 
190
 
    (*
191
 
 
192
 
    (Exp: 'ArgTSamePFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TSamePFoo'; Flgs: []),
193
 
    (Exp: 'VArgTSamePFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TSamePFoo'; Flgs: []),
194
 
    (Exp: 'ArgTNewPFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewPFoo'; Flgs: []),
195
 
    (Exp: 'VArgTNewPFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewPFoo'; Flgs: []),
196
 
 
197
 
    (Exp: 'ArgTSameFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TSameFoo'; Flgs: []),
198
 
    (Exp: 'VArgTSameFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TSameFoo'; Flgs: []),
199
 
    (Exp: 'ArgTNewFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewFoo'; Flgs: []),
200
 
    (Exp: 'VArgTNewFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewFoo'; Flgs: []),
201
 
    (Exp: 'ArgPNewFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewFoo'; Flgs: []),
202
 
    (Exp: 'VArgPNewFoo';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewFoo'; Flgs: []),
203
 
 
204
 
      { ClassesTyps }
205
 
    (Exp: 'ArgTFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TFooClass'; Flgs: []),
206
 
    (Exp: 'VArgTFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TFooClass'; Flgs: []),
207
 
    (Exp: 'ArgPFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PFooClass'; Flgs: []),
208
 
    (Exp: 'VArgPFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PFooClass'; Flgs: []),
209
 
    (Exp: 'ArgPPFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPFooClass'; Flgs: []),
210
 
    (Exp: 'VArgPPFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPFooClass'; Flgs: []),
211
 
    (Exp: 'ArgTNewFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewFooClass'; Flgs: []),
212
 
    (Exp: 'VArgTNewFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewFooClass'; Flgs: []),
213
 
    (Exp: 'ArgPNewFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewFooClass'; Flgs: []),
214
 
    (Exp: 'VArgPNewFooClass';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewFooClass'; Flgs: []),
215
 
    *)
216
 
 
217
 
    { Compare Objects }
218
 
    // TODO: not working in Dwarf3
219
 
    (Exp: 'ArgTFoo=ArgTFoo';      Fmt: wdfDefault;  Mtch: 'True';         Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
220
 
    (Exp: 'not(ArgTFoo=ArgTFoo)'; Fmt: wdfDefault;  Mtch: 'False';        Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
221
 
    (Exp: 'VArgTFoo=VArgTFoo';    Fmt: wdfDefault;  Mtch: 'True';         Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
222
 
    (Exp: 'ArgTFoo=VArgTFoo';     Fmt: wdfDefault;  Mtch: 'True';         Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
223
 
    (Exp: 'ArgTFoo=ArgPFoo';      Fmt: wdfDefault;  Mtch: 'False';        Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
224
 
    (Exp: 'ArgTFoo=ArgPFoo^';     Fmt: wdfDefault;  Mtch: 'False';        Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
225
 
    (Exp: 'ArgPFoo=ArgPPFoo^';    Fmt: wdfDefault;  Mtch: 'True';         Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
226
 
 
227
 
    (Exp: '@ArgTFoo=PVarTFoo';    Fmt: wdfDefault;  Mtch: 'True';         Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
228
 
    (Exp: '@VArgTFoo=PVarTFoo';   Fmt: wdfDefault;  Mtch: 'False';        Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
229
 
 
230
 
    //(Exp: 'ArgTFoo<>ArgTFoo';     Fmt: wdfDefault;  Mtch: 'False';        Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
231
 
    //(Exp: 'ArgTFoo<>ArgPFoo^';    Fmt: wdfDefault;  Mtch: 'True';         Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
232
 
 
233
 
    (Exp: 'ArgTFoo=0';          Fmt: wdfDefault;  Mtch: 'False';          Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
234
 
    (Exp: 'not(ArgTFoo=0)';     Fmt: wdfDefault;  Mtch: 'True';           Kind: skSimple;      TpNm: 'bool'; Flgs: [fnoDwrf3]),
235
 
    //(Exp: 'ArgTFoo<>0';         Fmt: wdfDefault;  Mtch: 'True';           Kind: skSimple;      TpNm: 'bool'; Flgs: []),
236
 
 
237
 
    //(Exp: 'ArgTFoo=nil';          Fmt: wdfDefault;  Mtch: 'False';        Kind: skSimple;      TpNm: 'bool'; Flgs: []),
238
 
    //(Exp: 'not(ArgTFoo=nil)';     Fmt: wdfDefault;  Mtch: 'True';         Kind: skSimple;      TpNm: 'bool'; Flgs: []),
239
 
    //(Exp: 'ArgTFoo<>nil';         Fmt: wdfDefault;  Mtch: 'True';         Kind: skSimple;      TpNm: 'bool'; Flgs: []),
240
 
    {%endendregion    * Classes * }
241
 
 
242
 
    {%region    * Strings * }
243
 
      { strings }
244
 
    (Exp: 'ArgTMyAnsiString';      Fmt: wdfDefault;  Mtch: '''ansi''$';         Kind: skPointer;      TpNm: '^(TMy)?AnsiString$'; Flgs: [fTpMtch]),
245
 
    (Exp: 'VArgTMyAnsiString';     Fmt: wdfDefault;  Mtch: '''ansi''$';         Kind: skPointer;      TpNm: '^(TMy)?AnsiString$'; Flgs: [fTpMtch]),
246
 
    (Exp: 'ArgPMyAnsiString';      Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;      TpNm: 'PMyAnsiString'; Flgs: []),
247
 
    (Exp: 'VArgPMyAnsiString';     Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;      TpNm: 'PMyAnsiString'; Flgs: []),
248
 
    (Exp: 'ArgPMyAnsiString^';      Fmt: wdfDefault;  Mtch: '''ansi''$';         Kind: skPointer;      TpNm: '^(TMy)?AnsiString$'; Flgs: [fTpMtch]),
249
 
    (Exp: 'VArgPMyAnsiString^';     Fmt: wdfDefault;  Mtch: '''ansi''$';         Kind: skPointer;      TpNm: '^(TMy)?AnsiString$'; Flgs: [fTpMtch, fnoDwrf]),
250
 
    (Exp: 'ArgPPMyAnsiString';     Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;      TpNm: 'PPMyAnsiString'; Flgs: []),
251
 
    (Exp: 'VArgPPMyAnsiString';    Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;      TpNm: 'PPMyAnsiString'; Flgs: []),
252
 
    (Exp: 'ArgPPMyAnsiString^';     Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;      TpNm: 'PMyAnsiString'; Flgs: []),
253
 
    (Exp: 'VArgPPMyAnsiString^';    Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;      TpNm: 'PMyAnsiString'; Flgs: [fnoDwrf]),
254
 
    (Exp: 'ArgPPMyAnsiString^^';    Fmt: wdfDefault;  Mtch: '''ansi''$';         Kind: skPointer;      TpNm: '^(TMy)?AnsiString$'; Flgs: [fTpMtch]),
255
 
    (Exp: 'VArgPPMyAnsiString^^';   Fmt: wdfDefault;  Mtch: '''ansi''$';         Kind: skPointer;      TpNm: '^(TMy)?AnsiString$'; Flgs: [fTpMtch, fnoDwrf]),
256
 
 
257
 
    (*
258
 
    (Exp: 'ArgTNewAnsiString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewAnsiString'; Flgs: []),
259
 
    (Exp: 'VArgTNewAnsiString';     Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewAnsiString'; Flgs: []),
260
 
    (Exp: 'ArgPNewAnsiString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewAnsiString'; Flgs: []),
261
 
    (Exp: 'VArgPNewAnsiString';     Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewAnsiString'; Flgs: []),
262
 
    *)
263
 
 
264
 
    (Exp: 'ArgTMyShortString';      Fmt: wdfDefault;  Mtch: '''short''$';        Kind: skSimple;      TpNm: '^(TMy)?ShortString$'; Flgs: [fTpMtch]),
265
 
    (Exp: 'VArgTMyShortString';     Fmt: wdfDefault;  Mtch: '''short''$';        Kind: skSimple;      TpNm: '^(TMy)?ShortString$'; Flgs: [fTpMtch]),
266
 
    (Exp: 'ArgPMyShortString';      Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;     TpNm: 'P(My)?ShortString'; Flgs: [fTpMtch]),
267
 
    (Exp: 'VArgPMyShortString';     Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;     TpNm: 'P(My)?ShortString'; Flgs: [fTpMtch]),
268
 
    (Exp: 'ArgPMyShortString^';      Fmt: wdfDefault;  Mtch: '''short''$';        Kind: skSimple;      TpNm: '^(TMy)?ShortString$'; Flgs: [fTpMtch]),
269
 
    (Exp: 'VArgPMyShortString^';     Fmt: wdfDefault;  Mtch: '''short''$';        Kind: skSimple;      TpNm: '^(TMy)?ShortString$'; Flgs: [fTpMtch, fnoDwrf]),
270
 
 
271
 
    (*
272
 
    (Exp: 'ArgPPMyShortString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPMyShortString'; Flgs: []),
273
 
    (Exp: 'VArgPPMyShortString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPMyShortString'; Flgs: []),
274
 
    (Exp: 'ArgTNewhortString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewhortString'; Flgs: []),
275
 
    (Exp: 'VArgTNewhortString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewhortString'; Flgs: []),
276
 
    (Exp: 'ArgPNewhortString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewhortString'; Flgs: []),
277
 
    (Exp: 'VArgPNewhortString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewhortString'; Flgs: []),
278
 
*)
279
 
 
280
 
    // gdb 6.7.5 does not show the text
281
 
    (Exp: 'ArgTMyWideString';      Fmt: wdfDefault;  Mtch: '(''wide''$)|(widestring\(\$.*\))';      Kind: skPointer;      TpNm: '^(TMy)?WideString$'; Flgs: [fTpMtch]),
282
 
    (Exp: 'VArgTMyWideString';     Fmt: wdfDefault;  Mtch: '(''wide''$)|(widestring\(\$.*\))';      Kind: skPointer;      TpNm: '^(TMy)?WideString$'; Flgs: [fTpMtch]),
283
 
    (*
284
 
    (Exp: 'ArgPMyWideString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PMyWideString'; Flgs: []),
285
 
    (Exp: 'VArgPMyWideString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PMyWideString'; Flgs: []),
286
 
    (Exp: 'ArgPPMyWideString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPMyWideString'; Flgs: []),
287
 
    (Exp: 'VArgPPMyWideString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPMyWideString'; Flgs: []),
288
 
 
289
 
    (Exp: 'ArgTNewWideString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewWideString'; Flgs: []),
290
 
    (Exp: 'VArgTNewWideString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TNewWideString'; Flgs: []),
291
 
    (Exp: 'ArgPNewWideString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewWideString'; Flgs: []),
292
 
    (Exp: 'VArgPNewWideString';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PNewWideString'; Flgs: []),
293
 
 
294
 
    (Exp: 'ArgTMyString10';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TMyString10'; Flgs: []),
295
 
    (Exp: 'VArgTMyString10';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'TMyString10'; Flgs: []),
296
 
    (Exp: 'ArgPMyString10';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PMyString10'; Flgs: []),
297
 
    (Exp: 'VArgPMyString10';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PMyString10'; Flgs: []),
298
 
    (Exp: 'ArgPPMyString10';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPMyString10'; Flgs: []),
299
 
    (Exp: 'VArgPPMyString10';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPMyString10'; Flgs: []),
300
 
*)
301
 
 
302
 
 
303
 
    (Exp: 'ArgTMyAnsiString';      Fmt: wdfMemDump;  Mtch: ': 61 6E 73 69 00';         Kind: skPointer;      TpNm: '^(TMy)?AnsiString$'; Flgs: [fTpMtch]),
304
 
 
305
 
    {%endregion    * Strings * }
306
 
 
307
 
    {%region    * Simple * }
308
 
 
309
 
    (Exp: 'ArgByte';      Fmt: wdfDefault;  Mtch: '^25$';      Kind: skSimple;      TpNm: 'Byte'; Flgs: []),
310
 
    (Exp: 'VArgByte';     Fmt: wdfDefault;  Mtch: '^25$';      Kind: skSimple;      TpNm: 'Byte'; Flgs: []),
311
 
    (Exp: 'ArgWord';      Fmt: wdfDefault;  Mtch: '^26$';      Kind: skSimple;      TpNm: 'Word'; Flgs: []),
312
 
    (Exp: 'VArgWord';     Fmt: wdfDefault;  Mtch: '^26$';      Kind: skSimple;      TpNm: 'Word'; Flgs: []),
313
 
    (Exp: 'ArgLongWord';  Fmt: wdfDefault;  Mtch: '^27$';      Kind: skSimple;      TpNm: 'LongWord'; Flgs: []),
314
 
    (Exp: 'VArgLongWord'; Fmt: wdfDefault;  Mtch: '^27$';      Kind: skSimple;      TpNm: 'LongWord'; Flgs: []),
315
 
    (Exp: 'ArgQWord';     Fmt: wdfDefault;  Mtch: '^28$';      Kind: skSimple;      TpNm: 'QWord'; Flgs: []),
316
 
    (Exp: 'VArgQWord';    Fmt: wdfDefault;  Mtch: '^28$';      Kind: skSimple;      TpNm: 'QWord'; Flgs: []),
317
 
 
318
 
    (Exp: 'ArgShortInt';  Fmt: wdfDefault;  Mtch: '^35$';      Kind: skSimple;      TpNm: 'ShortInt'; Flgs: []),
319
 
    (Exp: 'VArgShortInt'; Fmt: wdfDefault;  Mtch: '^35$';      Kind: skSimple;      TpNm: 'ShortInt'; Flgs: []),
320
 
    (Exp: 'ArgSmallInt';  Fmt: wdfDefault;  Mtch: '^36$';      Kind: skSimple;      TpNm: 'SmallInt'; Flgs: []),
321
 
    (Exp: 'VArgSmallInt'; Fmt: wdfDefault;  Mtch: '^36$';      Kind: skSimple;      TpNm: 'SmallInt'; Flgs: []),
322
 
    (Exp: 'ArgInt';       Fmt: wdfDefault;  Mtch: '^37$';      Kind: skSimple;      TpNm: 'Integer|LongInt'; Flgs: [fTpMtch]),
323
 
    (Exp: 'VArgInt';      Fmt: wdfDefault;  Mtch: '^37$';      Kind: skSimple;      TpNm: 'Integer|LongInt'; Flgs: [fTpMtch]),
324
 
    (Exp: 'ArgInt64';     Fmt: wdfDefault;  Mtch: '^38$';      Kind: skSimple;      TpNm: 'Int64'; Flgs: []),
325
 
    (Exp: 'VArgInt64';    Fmt: wdfDefault;  Mtch: '^38$';      Kind: skSimple;      TpNm: 'Int64'; Flgs: []),
326
 
 
327
 
    (Exp: 'ArgPointer';      Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;      TpNm: 'Pointer'; Flgs: []),
328
 
    (Exp: 'VArgPointer';     Fmt: wdfDefault;  Mtch: Match_Pointer;      Kind: skPointer;      TpNm: 'Pointer'; Flgs: []),
329
 
    (*
330
 
    (Exp: 'ArgPPointer';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPointer'; Flgs: []),
331
 
    (Exp: 'VArgPPointer';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PPointer'; Flgs: []),
332
 
*)
333
 
 
334
 
    (Exp: 'ArgDouble';       Fmt: wdfDefault;  Mtch: '1\.123';      Kind: skSimple;      TpNm: 'Double'; Flgs: []),
335
 
    (Exp: 'VArgDouble';      Fmt: wdfDefault;  Mtch: '1\.123';      Kind: skSimple;      TpNm: 'Double'; Flgs: []),
336
 
    (Exp: 'ArgExtended';     Fmt: wdfDefault;  Mtch: '2\.345';      Kind: skSimple;      TpNm: 'Extended'; Flgs: []),
337
 
    (Exp: 'VArgExtended';    Fmt: wdfDefault;  Mtch: '2\.345';      Kind: skSimple;      TpNm: 'Extended'; Flgs: []),
338
 
 
339
 
    (*
340
 
    (Exp: 'ArgPByte';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PByte'; Flgs: []),
341
 
    (Exp: 'VArgPByte';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PByte'; Flgs: []),
342
 
    (Exp: 'ArgPWord';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PWord'; Flgs: []),
343
 
    (Exp: 'VArgPWord';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PWord'; Flgs: []),
344
 
    (Exp: 'ArgPLongWord';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PLongWord'; Flgs: []),
345
 
    (Exp: 'VArgPLongWord';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PLongWord'; Flgs: []),
346
 
    (Exp: 'ArgPQWord';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PQWord'; Flgs: []),
347
 
    (Exp: 'VArgPQWord';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PQWord'; Flgs: []),
348
 
 
349
 
    (Exp: 'ArgPShortInt';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PShortInt'; Flgs: []),
350
 
    (Exp: 'VArgPShortInt';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PShortInt'; Flgs: []),
351
 
    (Exp: 'ArgPSmallInt';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PSmallInt'; Flgs: []),
352
 
    (Exp: 'VArgPSmallInt';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PSmallInt'; Flgs: []),
353
 
    (Exp: 'ArgPInt';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PInteger'; Flgs: []),
354
 
    (Exp: 'VArgPInt';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PInteger'; Flgs: []),
355
 
    (Exp: 'ArgPInt64';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PInt64'; Flgs: []),
356
 
    (Exp: 'VArgPInt64';      Fmt: wdfDefault;  Mtch: '';      Kind: sk;      TpNm: 'PInt64'; Flgs: []),
357
 
*)
358
 
    {%endregion    * Simple * }
359
 
 
360
 
    {%region    * Enum/Set * }
361
 
 
362
 
    (Exp: 'ArgEnum';       Fmt: wdfDefault;  Mtch: '^Two$';                      Kind: skEnum;       TpNm: 'TEnum'; Flgs: []),
363
 
    (Exp: 'ArgEnumSet';    Fmt: wdfDefault;  Mtch: '^\[Two(, ?|\.\.)Three\]$';   Kind: skSet;        TpNm: 'TEnumSet'; Flgs: [fnoDwrfNoSet]),
364
 
    (Exp: 'ArgSet';        Fmt: wdfDefault;  Mtch: '^\[Alpha(, ?|\.\.)Beta\]$';  Kind: skSet;        TpNm: 'TSet'; Flgs: [fnoDwrfNoSet]),
365
 
 
366
 
    (Exp: 'VarEnumA';      Fmt: wdfDefault;  Mtch: '^e3$';                       Kind: skEnum;       TpNm: ''; Flgs: []),
367
 
    // maybe typename = "set of TEnum"
368
 
    (Exp: 'VarEnumSetA';   Fmt: wdfDefault;  Mtch: '^\[Three\]$';                Kind: skSet;        TpNm: ''; Flgs: [fnoDwrfNoSet]),
369
 
    (Exp: 'VarSetA';       Fmt: wdfDefault;  Mtch: '^\[s2\]$';                   Kind: skSet;        TpNm: ''; Flgs: [fnoDwrfNoSet]),
370
 
    {%endregion    * Enum/Set * }
371
 
 
372
 
    {%region    * Variant * }
373
 
 
374
 
    (Exp: 'ArgVariantInt';       Fmt: wdfDefault;  Mtch: '^5$';         Kind: skVariant;       TpNm: 'Variant'; Flgs: []),
375
 
    (Exp: 'ArgVariantString';    Fmt: wdfDefault;  Mtch: '^''v''$';     Kind: skVariant;       TpNm: 'Variant'; Flgs: []),
376
 
 
377
 
    (Exp: 'VArgVariantInt';       Fmt: wdfDefault;  Mtch: '^5$';         Kind: skVariant;       TpNm: 'Variant'; Flgs: []),
378
 
    (Exp: 'VArgVariantString';    Fmt: wdfDefault;  Mtch: '^''v''$';     Kind: skVariant;       TpNm: 'Variant'; Flgs: []),
379
 
    {%endregion    * Variant * }
380
 
 
381
 
    {%region    * procedure/function/method * }
382
 
 
383
 
    (Exp: 'ArgProcedure';       Fmt: wdfDefault;  Mtch: 'procedure';           Kind: skProcedure;       TpNm: 'TProcedure'; Flgs: []),
384
 
    (Exp: 'ArgFunction';        Fmt: wdfDefault;  Mtch: 'function';            Kind: skFunction;        TpNm: 'TFunction';  Flgs: []),
385
 
(*
386
 
// normal procedure on stabs / recodr on dwarf => maybe the data itself may reveal some ?
387
 
    (Exp: 'ArgObjProcedure';    Fmt: wdfDefault;  Mtch: 'procedure.*of object|record.*procedure.*self =';
388
 
                                                             Kind: skRecord;          TpNm: 'TObjProcedure'; Flgs: []),
389
 
    (Exp: 'ArgObjFunction';     Fmt: wdfDefault;  Mtch: 'function.*of object|record.*function.*self =';
390
 
                                                             Kind: skRecord;          TpNm: 'TObjFunction';  Flgs: []),
391
 
 
392
 
*)
393
 
// doesn't work, ptype returns empty in dwarf => maybe via whatis
394
 
//    (Exp: 'VArgProcedure';       Fmt: wdfDefault;  Mtch: 'procedure';           Kind: skProcedure;       TpNm: 'TProcedure'; Flgs: []),
395
 
//    (Exp: 'VArgFunction';        Fmt: wdfDefault;  Mtch: 'function';            Kind: skFunction;        TpNm: 'TFunction';  Flgs: []),
396
 
(*
397
 
    (Exp: 'VArgObjProcedure';    Fmt: wdfDefault;  Mtch: 'procedure.*of object|record.*procedure.*self =';
398
 
                                                              Kind: skRecord;          TpNm: 'TObjProcedure'; Flgs: []),
399
 
    (Exp: 'VArgObjFunction';     Fmt: wdfDefault;  Mtch: 'function.*of object|record.*function.*self =';
400
 
                                                              Kind: skRecord;          TpNm: 'TObjFunction';  Flgs: []),
401
 
*)
402
 
 
403
 
    (Exp: 'VarProcedureA';       Fmt: wdfDefault;  Mtch: 'procedure';           Kind: skProcedure;       TpNm: 'Procedure'; Flgs: []),
404
 
    (Exp: 'VarFunctionA';        Fmt: wdfDefault;  Mtch: 'function';            Kind: skFunction;        TpNm: 'Function';  Flgs: [])//,
405
 
(*
406
 
    (Exp: 'VarObjProcedureA';    Fmt: wdfDefault;  Mtch: 'procedure.*of object|record.*procedure.*self =';
407
 
                                                              Kind: skRecord;          TpNm: 'Procedure'; Flgs: []),
408
 
    (Exp: 'VarObjFunctionA';     Fmt: wdfDefault;  Mtch: 'function.*of object|record.*function.*self =';
409
 
                                                              Kind: skRecord;          TpNm: 'Function';  Flgs: [])//,
410
 
*)
411
 
    {%endregion    * procedure/function/method * }
412
 
 
413
 
  );
414
 
 
415
 
 
416
 
 
417
 
 
418
 
 
419
 
{ TTestWatch }
420
 
 
421
 
procedure TTestWatch.DoChanged;
422
 
var
423
 
  v: String;
424
 
begin
425
 
  if FMaster = nil then exit;
426
 
  if (FMaster.Valid = vsValid) then begin
427
 
    DbgLog := True;
428
 
    v := FMaster.Value;
429
 
    if v <> '<evaluating>' then begin // TODO: need better check
430
 
      if FHasValue and (FValue <> v) then begin
431
 
        FHasMultiValue := True;
432
 
        FValue := FValue + LineEnding + v;
433
 
      end
434
 
      else
435
 
        FValue := v;
436
 
      FHasValue := True;
437
 
 
438
 
      FTypeInfo := Master.TypeInfo;
439
 
    end;
440
 
  end;
441
 
end;
442
 
 
443
 
function TTestWatch.GetTypeInfo: TDBGType;
444
 
begin
445
 
  Result := FTypeInfo;
446
 
end;
447
 
 
448
 
procedure TTestWatch.SetDisplayFormat(const AValue: TWatchDisplayFormat);
449
 
begin
450
 
  inherited SetDisplayFormat(AValue);
451
 
  FMaster.DisplayFormat := AValue;
452
 
end;
453
 
 
454
 
constructor TTestWatch.Create(AOwner: TBaseWatches; AMaster: TDBGWatch);
455
 
begin
456
 
  inherited Create(AOwner);
457
 
  Expression := AMaster.Expression;
458
 
  FMaster := AMaster;
459
 
  FMaster.Slave := Self;
460
 
  FMaster.Enabled := True;
 
228
function MatchPointer(TypeName: String=''): String;
 
229
begin
 
230
  if TypeName = ''
 
231
  then Result := '\$[0-9A-F]+'
 
232
  else Result := TypeName+'\(\$[0-9A-F]+';
 
233
end;
 
234
 
 
235
function MatchRecord(TypeName: String; AContent: String = ''): String;
 
236
begin
 
237
  Result := 'record '+TypeName+' .+'+AContent;
 
238
end;
 
239
function MatchRecord(TypeName: String; AValInt: integer; AValFoo: String = ''): String;
 
240
begin
 
241
  Result := 'record '+TypeName+' .+ valint = '+IntToStr(AValInt);
 
242
  If AValFoo <> '' then Result := Result + ',.* valfoo = '+AValFoo;
 
243
end;
 
244
 
 
245
function MatchClass(TypeName: String; AContent: String = ''): String;
 
246
begin
 
247
  Result := '<'+TypeName+'> = \{.*(vptr\$|<TObject>).+'+AContent;
 
248
end;
 
249
 
 
250
function MatchClassNil(TypeName: String): String;
 
251
begin
 
252
  Result := '<'+TypeName+'> = nil';
461
253
end;
462
254
 
463
255
{ TTestWatches }
464
256
 
 
257
procedure TTestWatches.ClearAllTestArrays;
 
258
begin
 
259
  SetLength(ExpectBreakFooGdb, 0);
 
260
  SetLength(ExpectBreakSubFoo, 0);
 
261
  SetLength(ExpectBreakFoo, 0);
 
262
  SetLength(ExpectBreakFooArray, 0);
 
263
end;
 
264
 
 
265
function TTestWatches.HasTestArraysData: Boolean;
 
266
begin
 
267
  Result := (Length(ExpectBreakFooGdb) > 0) or
 
268
            (Length(ExpectBreakSubFoo) > 0) or
 
269
            (Length(ExpectBreakFoo) > 0) or
 
270
            (Length(ExpectBreakFooArray) >0 );
 
271
 
 
272
end;
 
273
 
 
274
function TTestWatches.AddTo(var ExpArray: TWatchExpectationArray; AnExpr: string;
 
275
  AFmt: TWatchDisplayFormat; AMtch: string; AKind: TDBGSymbolKind; ATpNm: string;
 
276
  AFlgs: TWatchExpectationFlags; AStackFrame: Integer = 0; AMinGdb: Integer = 0;
 
277
  AMinFpc: Integer = 0): PWatchExpectation;
 
278
var
 
279
  i: TSymbolType;
 
280
begin
 
281
  SetLength(ExpArray, Length(ExpArray)+1);
 
282
  with ExpArray[Length(ExpArray)-1] do begin
 
283
    TestName     := AnExpr;
 
284
    Expression   := AnExpr;
 
285
    DspFormat    := AFmt;
 
286
    for i := low(TSymbolType) to high(TSymbolType) do begin
 
287
      Result[i].ExpMatch     := AMtch;
 
288
      Result[i].ExpKind      := AKind;
 
289
      Result[i].ExpTypeName  := ATpNm;
 
290
      Result[i].Flgs         := AFlgs;
 
291
      Result[i].MinGdb := AMinGdb;
 
292
      Result[i].MinFpc := AMinFpc;
 
293
    end;
 
294
    StackFrame   := AStackFrame;
 
295
  end;
 
296
  Result := @ExpArray[Length(ExpArray)-1];
 
297
end;
 
298
 
 
299
function TTestWatches.AddTo(var ExpArray: TWatchExpectationArray; ATestName: String;
 
300
  AnExpr: string; AFmt: TWatchDisplayFormat; AMtch: string; AKind: TDBGSymbolKind;
 
301
  ATpNm: string; AFlgs: TWatchExpectationFlags; AStackFrame: Integer; AMinGdb: Integer = 0;
 
302
  AMinFpc: Integer = 0): PWatchExpectation;
 
303
var
 
304
  i: TSymbolType;
 
305
begin
 
306
  SetLength(ExpArray, Length(ExpArray)+1);
 
307
  with ExpArray[Length(ExpArray)-1] do begin
 
308
    TestName     := ATestName;
 
309
    Expression   := AnExpr;
 
310
    DspFormat    := AFmt;
 
311
    for i := low(TSymbolType) to high(TSymbolType) do begin
 
312
      Result[i].ExpMatch     := AMtch;
 
313
      Result[i].ExpKind      := AKind;
 
314
      Result[i].ExpTypeName  := ATpNm;
 
315
      Result[i].Flgs         := AFlgs;
 
316
      Result[i].MinGdb := AMinGdb;
 
317
      Result[i].MinFpc := AMinFpc;
 
318
    end;
 
319
    StackFrame   := AStackFrame;
 
320
  end;
 
321
  Result := @ExpArray[Length(ExpArray)-1];
 
322
end;
 
323
 
 
324
function TTestWatches.Add(AnExpr: string; AFmt: TWatchDisplayFormat; AMtch: string;
 
325
  AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
326
begin
 
327
  Result := AddTo(FCurrentExpArray^, AnExpr, AFmt, AMtch, AKind, ATpNm, AFlgs );
 
328
end;
 
329
 
 
330
function TTestWatches.AddFmtDef(AnExpr, AMtch: string; AKind: TDBGSymbolKind; ATpNm: string;
 
331
  AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
332
begin
 
333
  Result := Add(AnExpr, wdfDefault, AMtch, AKind, ATpNm, AFlgs );
 
334
end;
 
335
 
 
336
function TTestWatches.AddStringFmtDef(AnExpr, AMtch, ATpNm: string;
 
337
  AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
338
begin
 
339
  // TODO, encoding of special chars
 
340
  // String should be skSimple
 
341
  // but the IDE only gets that with Dwarf-3
 
342
  // might be prefixed, with address
 
343
  Result := AddFmtDef(AnExpr, '''' + AMtch + '''$', skPOINTER, ATpNm, AFlgs );
 
344
  UpdRes(Result, stDwarf3,           skSimple);
 
345
end;
 
346
 
 
347
function TTestWatches.AddShortStrFmtDef(AnExpr, AMtch: string; ATpNm: string;
 
348
  AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
349
begin
 
350
  // TODO, encoding of special chars
 
351
  // shortstring
 
352
  // might be prefixed, with address
 
353
  Result := AddFmtDef(AnExpr, '''' + AMtch + '''$', skSimple, ATpNm, AFlgs );
 
354
end;
 
355
 
 
356
function TTestWatches.AddCharFmtDef(AnExpr, AMtch: string; ATpNm: string;
 
357
  AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
358
begin
 
359
  // TODO, encoding of special chars
 
360
  // might be prefixed, with address
 
361
  Result := AddFmtDef(AnExpr, '''' + AMtch + '''$', skSimple, ATpNm, AFlgs );
 
362
end;
 
363
 
 
364
function TTestWatches.AddPointerFmtDef(AnExpr, ATpNm: string;
 
365
  AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
366
begin
 
367
  Result := AddFmtDef(AnExpr, MatchPointer(ATpNm), skPointer, ATpNm, AFlgs );
 
368
end;
 
369
 
 
370
function TTestWatches.AddPointerFmtDef(AnExpr, AMtch, ATpNm: string;
 
371
  AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
372
begin
 
373
  Result := AddFmtDef(AnExpr, MatchPointer(AMtch), skPointer, ATpNm, AFlgs );
 
374
end;
 
375
 
 
376
function TTestWatches.AddPointerFmtDefRaw(AnExpr, AMtch, ATpNm: string;
 
377
  AFlgs: TWatchExpectationFlags): PWatchExpectation;
 
378
begin
 
379
  Result := AddFmtDef(AnExpr, AMtch, skPointer, ATpNm, AFlgs );
 
380
end;
 
381
 
 
382
procedure TTestWatches.UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
383
  AMtch: string; AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags;
 
384
  AMinGdb: Integer; AMinFpc: Integer);
 
385
begin
 
386
  with AWatchExp^ do begin
 
387
    Result[ASymbolType].ExpMatch     := AMtch;
 
388
    Result[ASymbolType].ExpKind      := AKind;
 
389
    Result[ASymbolType].ExpTypeName  := ATpNm;
 
390
    Result[ASymbolType].Flgs         := AFlgs;
 
391
    Result[ASymbolType].MinGdb := AMinGdb;
 
392
    Result[ASymbolType].MinFpc := AMinFpc;
 
393
  end;
 
394
end;
 
395
 
 
396
procedure TTestWatches.UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
397
  AMtch: string; AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags);
 
398
begin
 
399
  with AWatchExp^ do begin
 
400
    Result[ASymbolType].ExpMatch     := AMtch;
 
401
    Result[ASymbolType].ExpKind      := AKind;
 
402
    Result[ASymbolType].ExpTypeName  := ATpNm;
 
403
    Result[ASymbolType].Flgs         := AFlgs;
 
404
  end;
 
405
end;
 
406
 
 
407
procedure TTestWatches.UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
408
  AMtch: string; AKind: TDBGSymbolKind);
 
409
begin
 
410
  with AWatchExp^ do begin
 
411
    Result[ASymbolType].ExpMatch     := AMtch;
 
412
    Result[ASymbolType].ExpKind      := AKind;
 
413
  end;
 
414
end;
 
415
 
 
416
procedure TTestWatches.UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
417
  AKind: TDBGSymbolKind);
 
418
begin
 
419
  with AWatchExp^ do begin
 
420
    Result[ASymbolType].ExpKind      := AKind;
 
421
  end;
 
422
end;
 
423
 
 
424
procedure TTestWatches.UpdRes(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
425
  ATpNm: string; AFlgs: TWatchExpectationFlags);
 
426
begin
 
427
  with AWatchExp^ do begin
 
428
    Result[ASymbolType].ExpTypeName  := ATpNm;
 
429
    Result[ASymbolType].Flgs         := AFlgs;
 
430
  end;
 
431
end;
 
432
 
 
433
procedure TTestWatches.UpdRes(AWatchExp: PWatchExpectation; ASymbolTypes: TSymbolTypes;
 
434
  ATpNm: string; AFlgs: TWatchExpectationFlags);
 
435
var
 
436
  i: TSymbolType;
 
437
begin
 
438
  for i := low(TSymbolType) to high(TSymbolType) do
 
439
    if i in ASymbolTypes then
 
440
      UpdRes(AWatchExp, i, ATpNm, AFlgs);
 
441
end;
 
442
 
 
443
procedure TTestWatches.UpdResMinGdb(AWatchExp: PWatchExpectation; ASymbolTypes: TSymbolTypes;
 
444
  AMinGdb: Integer);
 
445
var
 
446
  i: TSymbolType;
 
447
begin
 
448
  for i := low(TSymbolType) to high(TSymbolType) do
 
449
    if i in ASymbolTypes then
 
450
      UpdResMinGdb(AWatchExp, i, AMinGdb);
 
451
end;
 
452
 
 
453
procedure TTestWatches.UpdResMinFpc(AWatchExp: PWatchExpectation; ASymbolTypes: TSymbolTypes;
 
454
  AMinFpc: Integer);
 
455
var
 
456
  i: TSymbolType;
 
457
begin
 
458
  for i := low(TSymbolType) to high(TSymbolType) do
 
459
    if i in ASymbolTypes then
 
460
      UpdResMinFpc(AWatchExp, i, AMinFpc);
 
461
end;
 
462
 
 
463
procedure TTestWatches.UpdResMinGdb(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
464
  AMinGdb: Integer);
 
465
begin
 
466
  with AWatchExp^ do begin
 
467
    Result[ASymbolType].MinGdb := AMinGdb;
 
468
  end;
 
469
end;
 
470
 
 
471
procedure TTestWatches.UpdResMinFpc(AWatchExp: PWatchExpectation; ASymbolType: TSymbolType;
 
472
  AMinFpc: Integer);
 
473
begin
 
474
  with AWatchExp^ do begin
 
475
    Result[ASymbolType].MinFpc := AMinFpc;
 
476
  end;
 
477
end;
 
478
 
 
479
procedure TTestWatches.AddExpectBreakFooGdb;
 
480
begin
 
481
  if not TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('  TTestWatch.Gdb')] then exit;
 
482
  FCurrentExpArray := @ExpectBreakFooGdb;
 
483
 
 
484
  Add('ptype ArgTFoo',  wdfDefault, 'type = \^TFoo = class : PUBLIC TObject', skClass, '', []);
 
485
  Add('ptype ArgTFoo^', wdfDefault, 'type = TFoo = class : PUBLIC TObject',   skClass, '', []);
 
486
 
 
487
  Add('-data-evaluate-expression sizeof(ArgTFoo)',  wdfDefault, 'value="(4|8)"|(parse|syntax) error in expression', skClass, '',  []);
 
488
  Add('-data-evaluate-expression sizeof(ArgTFoo^)', wdfDefault, 'value="\d\d+"|(parse|syntax) error in expression', skClass, '',  []);
 
489
 
 
490
  if RUN_GDB_TEST_ONLY > 0 then begin
 
491
    ExpectBreakFooGdb[0] := ExpectBreakFooGdb[abs(RUN_GDB_TEST_ONLY)];
 
492
    SetLength(ExpectBreakFooGdb, 1);
 
493
  end;
 
494
end;
 
495
 
 
496
procedure TTestWatches.AddExpectBreakFooAll;
 
497
var
 
498
  r: PWatchExpectation;
 
499
begin
 
500
  if not TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('  TTestWatch.All')] then exit;
 
501
  FCurrentExpArray := @ExpectBreakFoo;
 
502
 
 
503
  {%region    * records * }
 
504
  // Foo(var XXX: PRecord); DWARF has problems with the implicit pointer for "var"
 
505
 
 
506
  // param to FooFunc
 
507
  AddFmtDef('ArgTRec',           MatchRecord('TREC', -1, '(\$0|nil)'),   skRecord,    'TRec', []);
 
508
  AddFmtDef('ArgPRec',           MatchPointer('PRec'),                   skPointer,   'PRec', []);
 
509
  AddFmtDef('ArgPRec^',          MatchRecord('TREC', 1, '.'),            skRecord,    'TRec', []);
 
510
  AddFmtDef('ArgPPRec',          MatchPointer('PPRec'),                  skPointer,   'PPRec', []);
 
511
  AddFmtDef('ArgPPRec^',         MatchPointer('PRec'),                   skPointer,   'PRec', []);
 
512
  AddFmtDef('ArgPPRec^^',        MatchRecord('TREC', 2, '.'),            skRecord,    'TRec', []);
 
513
  AddFmtDef('ArgTNewRec',        MatchRecord('T(NEW)?REC', 3, '.'),      skRecord,    'T(New)?Rec', [fTpMtch]);
 
514
  AddFmtDef('ArgTRec.ValInt',    '-1',                                   skSimple,    M_Int, [fTpMtch]);
 
515
  AddFmtDef('ArgPRec^.ValInt',   '1',                                    skSimple,    M_Int, [fTpMtch]);
 
516
  AddFmtDef('ArgPPRec^^.ValInt', '2',                                    skSimple,    M_Int, [fTpMtch]);
 
517
  AddFmtDef('ArgPRec^.ValFoo',   MatchClass('TFoo'),                     skClass,     'TFoo', []);
 
518
 
 
519
  AddFmtDef('ArgTRecSelf',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', []);
 
520
  AddFmtDef('ArgTRecSelf.ValInt',   '100',                               skSimple,    M_Int, [fTpMtch]);
 
521
  AddFmtDef('ArgTRecSelf.ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
522
  AddFmtDef('ArgTRecSelf.ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', []);
 
523
  AddFmtDef('ArgTRecSelf.ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
524
  //AddFmtDef('ArgTRecSelf',       MatchRecord('TRecSelf', 'valint = 100'),skSimple,    'TRecSelf', []);
 
525
  //AddFmtDef('ArgTRecSelf',       MatchRecord('TRecSelf', 'valint = 100'),skSimple,    'TRecSelf', []);
 
526
 
 
527
  AddFmtDef('ArgTRecSelfDArray',  '.',                                   skSimple,    'TRecSelfDArray', []);
 
528
  //ArgTRecSelf
 
529
  AddFmtDef('ArgTRecSelfDArray[0]',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', []);
 
530
  AddFmtDef('ArgTRecSelfDArray[0].ValInt',   '100',                               skSimple,    M_Int, [fTpMtch]);
 
531
  AddFmtDef('ArgTRecSelfDArray[0].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
532
  AddFmtDef('ArgTRecSelfDArray[0].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
533
  AddFmtDef('ArgTRecSelfDArray[0].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
534
  //VArgTRecSelf
 
535
  AddFmtDef('ArgTRecSelfDArray[1]',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', []);
 
536
  AddFmtDef('ArgTRecSelfDArray[1].ValInt',   '102',                               skSimple,    M_Int, [fTpMtch]);
 
537
  AddFmtDef('ArgTRecSelfDArray[1].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
538
  AddFmtDef('ArgTRecSelfDArray[1].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
539
  AddFmtDef('ArgTRecSelfDArray[1].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
540
 
 
541
  AddFmtDef('ArgTRecSelfS0Array',  '.',                                   skSimple,    'TRecSelfS0Array', []);
 
542
  //ArgTRecSelf
 
543
  AddFmtDef('ArgTRecSelfS0Array[0]',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', []);
 
544
  AddFmtDef('ArgTRecSelfS0Array[0].ValInt',   '100',                               skSimple,    M_Int, [fTpMtch]);
 
545
  AddFmtDef('ArgTRecSelfS0Array[0].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
546
  AddFmtDef('ArgTRecSelfS0Array[0].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
547
  AddFmtDef('ArgTRecSelfS0Array[0].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
548
  //VArgTRecSelf
 
549
  AddFmtDef('ArgTRecSelfS0Array[1]',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', []);
 
550
  AddFmtDef('ArgTRecSelfS0Array[1].ValInt',   '102',                               skSimple,    M_Int, [fTpMtch]);
 
551
  AddFmtDef('ArgTRecSelfS0Array[1].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
552
  AddFmtDef('ArgTRecSelfS0Array[1].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
553
  AddFmtDef('ArgTRecSelfS0Array[1].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
554
 
 
555
  AddFmtDef('ArgTRecSelfS3Array',  '.',                                   skSimple,    'TRecSelfS3Array', []);
 
556
  //ArgTRecSelf
 
557
  AddFmtDef('ArgTRecSelfS3Array[3]',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', []);
 
558
  AddFmtDef('ArgTRecSelfS3Array[3].ValInt',   '100',                               skSimple,    M_Int, [fTpMtch]);
 
559
  AddFmtDef('ArgTRecSelfS3Array[3].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
560
  AddFmtDef('ArgTRecSelfS3Array[3].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
561
  AddFmtDef('ArgTRecSelfS3Array[3].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
562
  //VArgTRecSelf
 
563
  AddFmtDef('ArgTRecSelfS3Array[4]',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', []);
 
564
  AddFmtDef('ArgTRecSelfS3Array[4].ValInt',   '102',                               skSimple,    M_Int, [fTpMtch]);
 
565
  AddFmtDef('ArgTRecSelfS3Array[4].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', [IgnDwrf3]);
 
566
  AddFmtDef('ArgTRecSelfS3Array[4].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', []);
 
567
  AddFmtDef('ArgTRecSelfS3Array[4].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
568
 
 
569
  AddFmtDef('ArgTPRecSelfDArray',  '.',                                   skSimple,    'TPRecSelfDArray', []);
 
570
  //ArgTRecSelf
 
571
  AddFmtDef('ArgTPRecSelfDArray[0]^',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', [IgnDwrf3]);
 
572
  AddFmtDef('ArgTPRecSelfDArray[0]^.ValInt',   '100',                               skSimple,    M_Int, [fTpMtch, IgnDwrf3]);
 
573
  AddFmtDef('ArgTPRecSelfDArray[0]^.ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
574
  AddFmtDef('ArgTPRecSelfDArray[0]^.ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
575
  AddFmtDef('ArgTPRecSelfDArray[0]^.ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
576
  //VArgTRecSelf
 
577
  AddFmtDef('ArgTPRecSelfDArray[1]^',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', [IgnDwrf3]);
 
578
  AddFmtDef('ArgTPRecSelfDArray[1]^.ValInt',   '102',                               skSimple,    M_Int, [fTpMtch, IgnDwrf3]);
 
579
  AddFmtDef('ArgTPRecSelfDArray[1]^.ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
580
  AddFmtDef('ArgTPRecSelfDArray[1]^.ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
581
  AddFmtDef('ArgTPRecSelfDArray[1]^.ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
582
 
 
583
 
 
584
 
 
585
  // VAR param to FooFunc
 
586
  r := AddFmtDef('VArgTRec',           MatchRecord('TREC', -1, '(\$0|nil)'),   skRecord,    'TRec', []);
 
587
  r := AddFmtDef('VArgPRec',           MatchPointer('PRec'),                   skPointer,   'PRec', []);
 
588
  r := AddFmtDef('VArgPRec^',          MatchRecord('TREC', 1, '.'),            skRecord,    'TRec', []);
 
589
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
590
  r := AddFmtDef('VArgPPRec',          MatchPointer('PPRec'),                  skPointer,   'PPRec', []);
 
591
  r := AddFmtDef('VArgPPRec^',         MatchPointer('PRec'),                   skPointer,   'PRec', []);
 
592
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
593
  r := AddFmtDef('VArgPPRec^^',        MatchRecord('TREC', 2, '.'),            skRecord,    'TRec', []);
 
594
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
595
  AddFmtDef('VArgTNewRec',        MatchRecord('T(NEW)?REC', 3, '.'),      skRecord,    'T(New)?Rec', [fTpMtch]);
 
596
  AddFmtDef('VArgTRec.ValInt',    '-1',                                   skSimple,    M_Int, [fTpMtch]);
 
597
  AddFmtDef('VArgPRec^.ValInt',   '1',                                    skSimple,    M_Int, [fTpMtch]);
 
598
  AddFmtDef('VArgPPRec^^.ValInt', '2',                                    skSimple,    M_Int, [fTpMtch]);
 
599
  AddFmtDef('VArgPRec^.ValFoo',   MatchClass('TFoo'),                      skClass,     'TFoo', []);
 
600
 
 
601
  AddFmtDef('VArgTRecSelf',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', []);
 
602
  AddFmtDef('VArgTRecSelf.ValInt',   '102',                               skSimple,    M_Int, [fTpMtch]);
 
603
  AddFmtDef('VArgTRecSelf.ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
604
  AddFmtDef('VArgTRecSelf.ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', []);
 
605
  AddFmtDef('VArgTRecSelf.ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
606
 
 
607
  r := AddFmtDef('VArgTRecSelfDArray',  '.',                                   skSimple,    'TRecSelfDArray', []);
 
608
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
609
  //ArgTRecSelf
 
610
  r := AddFmtDef('VArgTRecSelfDArray[0]',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', []);
 
611
  AddFmtDef('VArgTRecSelfDArray[0].ValInt',   '100',                               skSimple,    M_Int, [fTpMtch]);
 
612
  AddFmtDef('VArgTRecSelfDArray[0].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
613
  AddFmtDef('VArgTRecSelfDArray[0].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
614
  AddFmtDef('VArgTRecSelfDArray[0].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
615
  //VArgTRecSelf
 
616
  r := AddFmtDef('VArgTRecSelfDArray[1]',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', []);
 
617
  AddFmtDef('VArgTRecSelfDArray[1].ValInt',   '102',                               skSimple,    M_Int, [fTpMtch]);
 
618
  AddFmtDef('VArgTRecSelfDArray[1].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
619
  AddFmtDef('VArgTRecSelfDArray[1].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
620
  AddFmtDef('VArgTRecSelfDArray[1].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
621
 
 
622
  AddFmtDef('VArgTRecSelfS0Array',  '.',                                   skSimple,    'TRecSelfS0Array', []);
 
623
  //ArgTRecSelf
 
624
  AddFmtDef('VArgTRecSelfS0Array[0]',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', []);
 
625
  AddFmtDef('VArgTRecSelfS0Array[0].ValInt',   '100',                               skSimple,    M_Int, [fTpMtch]);
 
626
  AddFmtDef('VArgTRecSelfS0Array[0].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
627
  AddFmtDef('VArgTRecSelfS0Array[0].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
628
  AddFmtDef('VArgTRecSelfS0Array[0].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
629
  //VArgTRecSelf
 
630
  AddFmtDef('VArgTRecSelfS0Array[1]',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', []);
 
631
  AddFmtDef('VArgTRecSelfS0Array[1].ValInt',   '102',                               skSimple,    M_Int, [fTpMtch]);
 
632
  AddFmtDef('VArgTRecSelfS0Array[1].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
633
  AddFmtDef('VArgTRecSelfS0Array[1].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
634
  AddFmtDef('VArgTRecSelfS0Array[1].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
635
 
 
636
  AddFmtDef('VArgTRecSelfS3Array',  '.',                                   skSimple,    'TRecSelfS3Array', []);
 
637
  //ArgTRecSelf
 
638
  AddFmtDef('VArgTRecSelfS3Array[3]',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', []);
 
639
  AddFmtDef('VArgTRecSelfS3Array[3].ValInt',   '100',                               skSimple,    M_Int, [fTpMtch]);
 
640
  AddFmtDef('VArgTRecSelfS3Array[3].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
641
  AddFmtDef('VArgTRecSelfS3Array[3].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
642
  AddFmtDef('VArgTRecSelfS3Array[3].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
643
  //VArgTRecSelf
 
644
  AddFmtDef('VArgTRecSelfS3Array[4]',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', []);
 
645
  AddFmtDef('VArgTRecSelfS3Array[4].ValInt',   '102',                               skSimple,    M_Int, [fTpMtch]);
 
646
  AddFmtDef('VArgTRecSelfS3Array[4].ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
647
  AddFmtDef('VArgTRecSelfS3Array[4].ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
648
  AddFmtDef('VArgTRecSelfS3Array[4].ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
649
 
 
650
  r := AddFmtDef('VArgTPRecSelfDArray',  '.',                                   skSimple,    'TPRecSelfDArray', []);
 
651
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
652
  //ArgTRecSelf
 
653
  AddFmtDef('VArgTPRecSelfDArray[0]^',       MatchRecord('TRecSelf', 'valint = 100'),skRecord,    'TRecSelf', [IgnDwrf3]);
 
654
  AddFmtDef('VArgTPRecSelfDArray[0]^.ValInt',   '100',                               skSimple,    M_Int, [fTpMtch]);
 
655
  AddFmtDef('VArgTPRecSelfDArray[0]^.ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
656
  AddFmtDef('VArgTPRecSelfDArray[0]^.ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
657
  AddFmtDef('VArgTPRecSelfDArray[0]^.ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
658
  //VArgTRecSelf
 
659
  AddFmtDef('VArgTPRecSelfDArray[1]^',       MatchRecord('TRecSelf', 'valint = 102'),skRecord,    'TRecSelf', [IgnDwrf3]);
 
660
  AddFmtDef('VArgTPRecSelfDArray[1]^.ValInt',   '102',                               skSimple,    M_Int, [fTpMtch]);
 
661
  AddFmtDef('VArgTPRecSelfDArray[1]^.ValPrec',  MatchPointer('PRec'),                skPointer,   'PRec', []);
 
662
  AddFmtDef('VArgTPRecSelfDArray[1]^.ValPrec^', MatchRecord('TRec', 1),              skRecord,    'TRec', [IgnDwrf3]);
 
663
  AddFmtDef('VArgTPRecSelfDArray[1]^.ValPrec^.ValInt',  '1',                         skSimple,    M_Int, [fTpMtch]);
 
664
 
 
665
 
 
666
  // LOCAL var (global type)
 
667
  AddFmtDef('VarTRec',           MatchRecord('TREC', -1, '(\$0|nil)'),   skRecord,    'TRec', []);
 
668
  AddFmtDef('VarPRec',           MatchPointer('^PRec'),                  skPointer,   'PRec', []);
 
669
  AddFmtDef('VarPRec^',          MatchRecord('TREC', 1, '.'),            skRecord,    'TRec', []);
 
670
  AddFmtDef('VarPPRec',          MatchPointer('^PPRec'),                 skPointer,   'PPRec', []);
 
671
  AddFmtDef('VarPPRec^',         MatchPointer('^PRec'),                  skPointer,   'PRec', []);
 
672
  AddFmtDef('VarPPRec^^',        MatchRecord('TREC', 2, '.'),            skRecord,    'TRec', []);
 
673
  AddFmtDef('VarTNewRec',        MatchRecord('T(NEW)?REC', 3, '.'),      skRecord,    'T(New)?Rec', [fTpMtch]);
 
674
  AddFmtDef('VarTRec.ValInt',    '-1',                                   skSimple,    M_Int, [fTpMtch]);
 
675
 
 
676
  // LOCAL var (reference (^) to global type)
 
677
  AddFmtDef('PVarTRec',        MatchPointer('^(\^T|P)Rec'),            skPointer,  '^(\^T|P)Rec$', [fTpMtch]); // TODO: stabs returns PRec
 
678
  AddFmtDef('PVarTRec^',       MatchRecord('TREC', -1, '(\$0|nil)'),   skRecord,   'TRec', []);
 
679
  AddFmtDef('PVarTNewRec',     MatchPointer('^\^TNewRec'),             skPointer,  '\^T(New)?Rec', [fTpMtch]);
 
680
  AddFmtDef('PVarTNewRec^',    MatchRecord('T(NEW)?REC', 3, '.'),      skRecord,   'T(New)?Rec',   [fTpMtch]);
 
681
 
 
682
  // LOCAL var (local type)
 
683
  AddFmtDef('VarRecA',         MatchRecord('', 'val = 1'),             skRecord,    '', []);
 
684
  {%endregion    * records * }
 
685
 
 
686
  // @ArgTRec @VArgTRec  @ArgTRec^ @VArgTRec^
 
687
 
 
688
  {%region    * Classes * }
 
689
 
 
690
  AddFmtDef('ArgTFoo',      Match_ArgTFoo,                 skClass,   'TFoo',  []);
 
691
  AddFmtDef('@ArgTFoo',     '(P|\^T)Foo\('+Match_Pointer,  skPointer, '(P|\^T)Foo',  [fTpMtch]);
 
692
  // Only with brackets...
 
693
  AddFmtDef('(@ArgTFoo)^',   Match_ArgTFoo,                skClass,   'TFoo',  []);
 
694
 
 
695
  AddFmtDef('ArgPFoo',      'PFoo\('+Match_Pointer,        skPointer, 'PFoo',  []);
 
696
  AddFmtDef('ArgPFoo^',     Match_ArgTFoo1,                skClass,   'TFoo',  []);
 
697
  AddFmtDef('@ArgPFoo',     '(P|\^)PFoo\('+Match_Pointer,  skPointer, '(P|\^)PFoo',  [fTpMtch]);
 
698
 
 
699
  AddFmtDef('ArgPPFoo',     'PPFoo\('+Match_Pointer,       skPointer, 'PPFoo', []);
 
700
  AddFmtDef('ArgPPFoo^',    'PFoo\('+Match_Pointer,        skPointer, 'PFoo',  []);
 
701
  AddFmtDef('@ArgPPFoo',    '\^PPFoo\('+Match_Pointer,      skPointer, '^PPFoo', []);
 
702
  AddFmtDef('ArgPPFoo^^',   Match_ArgTFoo1,                skClass,   'TFoo',  []);
 
703
 
 
704
 
 
705
  AddFmtDef('VArgTFoo',     Match_ArgTFoo,                 skClass,   'TFoo',  []);
 
706
  AddFmtDef('@VArgTFoo',    '(P|\^T)Foo\('+Match_Pointer,  skPointer, '(P|\^T)Foo',  [fTpMtch]);
 
707
  AddFmtDef('(@VArgTFoo)^',   Match_ArgTFoo,                 skClass,   'TFoo',  []);
 
708
 
 
709
  r := AddFmtDef('VArgPFoo',     'PFoo\('+Match_Pointer,        skPointer, 'PFoo',  []);
 
710
  r := AddFmtDef('VArgPFoo^' ,   Match_ArgTFoo1,                skClass,   'TFoo',  []);
 
711
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
712
  r := AddFmtDef('@VArgPFoo',    '(P|\^)PFoo\('+Match_Pointer,  skPointer, '(P|\^)PFoo',  [fTpMtch]);
 
713
 
 
714
  r := AddFmtDef('VArgPPFoo',    'PPFoo\('+Match_Pointer,       skPointer, 'PPFoo', []);
 
715
  r := AddFmtDef('VArgPPFoo^',   'PFoo\('+Match_Pointer,        skPointer, 'PFoo',  []);
 
716
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
717
  r := AddFmtDef('@VArgPPFoo',   '\^PPFoo\('+Match_Pointer,      skPointer, '^PPFoo', []);
 
718
  r := AddFmtDef('VArgPPFoo^^',   Match_ArgTFoo1,               skClass,   'TFoo',  []);
 
719
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
720
 
 
721
 
 
722
  AddFmtDef('ArgTFoo.ValueInt',       '^-11$',             skSimple,   'Integer|LongInt',  [fTpMtch]);
 
723
  AddFmtDef('ArgPFoo^.ValueInt',      '^31$',             skSimple,   'Integer|LongInt',  [fTpMtch]);
 
724
  // GDB automatically derefs the pointer
 
725
  //AddFmtDef('ArgPFoo.ValueInt',       'error',            skSimple,   '',  []);
 
726
  AddFmtDef('ArgPPFoo^^.ValueInt',    '^31$',             skSimple,   'Integer|LongInt',  [fTpMtch]);
 
727
  //AddFmtDef('ArgPPFoo.ValueInt',       'error',            skSimple,   '',  []);
 
728
 
 
729
  AddFmtDef('VArgTFoo.ValueInt',      '^-11$',             skSimple,   'Integer|LongInt',  [fTpMtch]);
 
730
  AddFmtDef('VArgPFoo^.ValueInt',     '^31$',             skSimple,   'Integer|LongInt',  [fTpMtch]);
 
731
  //AddFmtDef('VArgPFoo.ValueInt',      'error',            skSimple,   '',  []);
 
732
  AddFmtDef('VArgPPFoo^^.ValueInt',   '^31$',             skSimple,   'Integer|LongInt',  [fTpMtch]);
 
733
  //AddFmtDef('VArgPPFoo.ValueInt',      'error',            skSimple,   '',  []);
 
734
 
 
735
 
 
736
  Add('ArgTFoo',    wdfPointer,  Match_Pointer,                           skClass,   'TFoo',  []);
 
737
  Add('ArgTFoo',    wdfMemDump,  ':.*?6D 65 6D 20 6F 66 20 54 46 6F 6F',  skClass,   'TFoo',  []);
 
738
 
 
739
  (*
 
740
 
 
741
  AddFmtDef('ArgTSamePFoo',        '',      sk,      'TSamePFoo', []);
 
742
  AddFmtDef('VArgTSamePFoo',        '',      sk,      'TSamePFoo', []);
 
743
  AddFmtDef('ArgTNewPFoo',        '',      sk,      'TNewPFoo', []);
 
744
  AddFmtDef('VArgTNewPFoo',        '',      sk,      'TNewPFoo', []);
 
745
 
 
746
  AddFmtDef('ArgTSameFoo',        '',      sk,      'TSameFoo', []);
 
747
  AddFmtDef('VArgTSameFoo',        '',      sk,      'TSameFoo', []);
 
748
  AddFmtDef('ArgTNewFoo',        '',      sk,      'TNewFoo', []);
 
749
  AddFmtDef('VArgTNewFoo',        '',      sk,      'TNewFoo', []);
 
750
  AddFmtDef('ArgPNewFoo',        '',      sk,      'PNewFoo', []);
 
751
  AddFmtDef('VArgPNewFoo',        '',      sk,      'PNewFoo', []);
 
752
 
 
753
    { ClassesTyps }
 
754
  AddFmtDef('ArgTFooClass',        '',      sk,      'TFooClass', []);
 
755
  AddFmtDef('VArgTFooClass',        '',      sk,      'TFooClass', []);
 
756
  AddFmtDef('ArgPFooClass',        '',      sk,      'PFooClass', []);
 
757
  AddFmtDef('VArgPFooClass',        '',      sk,      'PFooClass', []);
 
758
  AddFmtDef('ArgPPFooClass',        '',      sk,      'PPFooClass', []);
 
759
  AddFmtDef('VArgPPFooClass',        '',      sk,      'PPFooClass', []);
 
760
  AddFmtDef('ArgTNewFooClass',        '',      sk,      'TNewFooClass', []);
 
761
  AddFmtDef('VArgTNewFooClass',        '',      sk,      'TNewFooClass', []);
 
762
  AddFmtDef('ArgPNewFooClass',        '',      sk,      'PNewFooClass', []);
 
763
  AddFmtDef('VArgPNewFooClass',        '',      sk,      'PNewFooClass', []);
 
764
  *)
 
765
 
 
766
  { Compare Objects }
 
767
  // TODO: not working in Dwarf3
 
768
  AddFmtDef('ArgTFoo=ArgTFoo',        'True',         skSimple,      'bool', []);
 
769
  AddFmtDef('not(ArgTFoo=ArgTFoo)',   'False',        skSimple,      'bool', []);
 
770
  AddFmtDef('VArgTFoo=VArgTFoo',      'True',         skSimple,      'bool', []);
 
771
  AddFmtDef('ArgTFoo=VArgTFoo',       'True',         skSimple,      'bool', []);
 
772
  AddFmtDef('ArgTFoo=ArgPFoo',        'False',        skSimple,      'bool', []);
 
773
  AddFmtDef('ArgTFoo=ArgPFoo^',       'False',        skSimple,      'bool', []);
 
774
  AddFmtDef('ArgPFoo=ArgPPFoo^',      'True',         skSimple,      'bool', []);
 
775
 
 
776
  AddFmtDef('@ArgTFoo=PVarTFoo',      'True',         skSimple,      'bool', []);
 
777
  AddFmtDef('@VArgTFoo=PVarTFoo',     'False',        skSimple,      'bool', []);
 
778
 
 
779
  //AddFmtDef('ArgTFoo<>ArgTFoo',       'False',        skSimple,      'bool', []);
 
780
  //AddFmtDef('ArgTFoo<>ArgPFoo^',      'True',         skSimple,      'bool', []);
 
781
 
 
782
  AddFmtDef('ArgTFoo=0',            'False',          skSimple,      'bool', []);
 
783
  AddFmtDef('not(ArgTFoo=0)',       'True',           skSimple,      'bool', []);
 
784
  //AddFmtDef('ArgTFoo<>0',           'True',           skSimple,      'bool', []);
 
785
 
 
786
  //AddFmtDef('ArgTFoo=nil',            'False',        skSimple,      'bool', []);
 
787
  //AddFmtDef('not(ArgTFoo=nil)',       'True',         skSimple,      'bool', []);
 
788
  //AddFmtDef('ArgTFoo<>nil',           'True',         skSimple,      'bool', []);
 
789
 
 
790
  {%endregion    * Classes * }
 
791
 
 
792
  {%region    * Strings * }
 
793
    { strings }
 
794
    // todo: some skPOINTER should be skSimple
 
795
  // ArgAnsiString
 
796
  r:=AddStringFmtDef('ArgAnsiString',          'Ansi',         'AnsiString', []);
 
797
  r:=AddStringFmtDef('VArgAnsiString',         'Ansi 2',       'AnsiString', []);
 
798
  r:=AddStringFmtDef('ArgTMyAnsiString',       'MyAnsi',       '^(TMy)?AnsiString$', [fTpMtch]);
 
799
  r:=AddStringFmtDef('VArgTMyAnsiString',      'MyAnsi 2',     '^(TMy)?AnsiString$', [fTpMtch]);
 
800
 
 
801
  r:=AddFmtDef('ArgPMyAnsiString',     MatchPointer, skPointer,     'PMyAnsiString', []);
 
802
     UpdRes(r, stStabs,                                             '^(PMyAnsiString|PPChar)$', [fTpMtch]);
 
803
  r:=AddFmtDef('VArgPMyAnsiString',    MatchPointer,  skPointer,    'PMyAnsiString', []);
 
804
     UpdRes(r, stStabs,                                             '^(PMyAnsiString|PPChar)$', [fTpMtch]);
 
805
  r:=AddStringFmtDef('ArgPMyAnsiString^',      'MyAnsi P',     '^(TMy)?AnsiString$', [fTpMtch]);
 
806
  r:=AddStringFmtDef('VArgPMyAnsiString^',     'MyAnsi P2',    '^(TMy)?AnsiString$', [fTpMtch]);
 
807
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
808
 
 
809
  r:=AddFmtDef('ArgPPMyAnsiString',    MatchPointer,  skPointer,    'PPMyAnsiString', []);
 
810
  r:=AddFmtDef('VArgPPMyAnsiString',   MatchPointer,  skPointer,    'PPMyAnsiString', []);
 
811
  r:=AddFmtDef('ArgPPMyAnsiString^',   MatchPointer,  skPointer,    'PMyAnsiString', []);
 
812
     UpdRes(r, stStabs,                                             '^(PMyAnsiString|PPChar)$', [fTpMtch]);
 
813
  r:=AddFmtDef('VArgPPMyAnsiString^',  MatchPointer,  skPointer,    'PMyAnsiString', []);
 
814
     UpdRes(r, stStabs,                                             '^(PMyAnsiString|PPChar)$', [fTpMtch]);
 
815
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
816
  r:=AddStringFmtDef('ArgPPMyAnsiString^^',    'MyAnsi P',     '^(TMy)?AnsiString$', [fTpMtch]);
 
817
  r:=AddStringFmtDef('VArgPPMyAnsiString^^',   'MyAnsi P2',    '^(TMy)?AnsiString$', [fTpMtch]);
 
818
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
819
 
 
820
 
 
821
  r:=AddStringFmtDef('ArgTNewAnsiString',      'NewAnsi',      'TNewAnsiString', []);
 
822
     UpdRes(r, stStabs,                                             '(TNew)?AnsiString', [fTpMtch]);
 
823
  r:=AddStringFmtDef('VArgTNewAnsiString',     'NewAnsi 2',    'TNewAnsiString', []);
 
824
     UpdRes(r, stStabs,                                             '(TNew)?AnsiString', [fTpMtch]);
 
825
 
 
826
  r:=AddFmtDef('ArgPNewAnsiString',    MatchPointer,  skPointer,    'PNewAnsiString', []);
 
827
                    UpdRes(r, stStabs,                              '(\^|PNew|P)AnsiString|PPChar', [fTpMtch]);
 
828
  r:=AddFmtDef('VArgPNewAnsiString',   MatchPointer,  skPointer,    'PNewAnsiString', []);
 
829
                    UpdRes(r, stStabs,                              '(\^|PNew|P)AnsiString|PPChar', [fTpMtch]);
 
830
  r:=AddStringFmtDef('ArgPNewAnsiString^',      'NewAnsi P',   'TNewAnsiString', []);
 
831
     UpdRes(r, stStabs,                                             '(TNew)?AnsiString', [fTpMtch]);
 
832
  r:=AddStringFmtDef('VArgPNewAnsiString^',     'NewAnsi P2',  'TNewAnsiString', []);
 
833
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
834
     UpdRes(r, stStabs,                                             '(TNew)?AnsiString', [fTpMtch]);
 
835
 
 
836
 
 
837
  // typecasts
 
838
  r:=AddStringFmtDef('AnsiString(ArgTMyAnsiString)',   'MyAnsi',      'AnsiString|\^char', [fTpMtch]);
 
839
     UpdRes(r, stDwarf3,                                                   'AnsiString', []);
 
840
  r:=AddStringFmtDef('AnsiString(VArgTMyAnsiString)',  'MyAnsi 2',    'AnsiString|\^char', [fTpMtch]);
 
841
     UpdRes(r, stDwarf3,                                                   'AnsiString', []);
 
842
 
 
843
  r:=AddFmtDef('PMyAnsiString(ArgPMyAnsiString)',     MatchPointer, skPointer,   '^(\^|PMy)AnsiString$', [fTpMtch]);
 
844
     UpdRes(r, stStabs,                                                          '^(PMyAnsiString|PPChar)$', [fTpMtch]);
 
845
  r:=AddFmtDef('PMyAnsiString(VArgPMyAnsiString)',    MatchPointer,  skPointer,  '^(\^|PMy)AnsiString$', [fTpMtch]);
 
846
     UpdRes(r, stStabs,                                                          '^(PMyAnsiString|PPChar)$', [fTpMtch]);
 
847
// TODO,, IDE derefs with dwarf3
 
848
  r:=AddFmtDef('^AnsiString(ArgPMyAnsiString)',       MatchPointer, skPointer,   '^(\^AnsiString|\^\^char)', [fTpMtch]);
 
849
     UpdRes(r, stStabs,                                                          '^(\^AnsiString|PPChar)$', [fTpMtch]);
 
850
  r:=AddFmtDef('^AnsiString(VArgPMyAnsiString)',      MatchPointer,  skPointer,  '^(\^AnsiString|\^\^char)', [fTpMtch]);
 
851
     UpdRes(r, stStabs,                                                          '^(\^AnsiString|PPChar)$', [fTpMtch]);
 
852
 
 
853
  r:=AddStringFmtDef('AnsiString(ArgPMyAnsiString^)',  'MyAnsi P',     '^((TMy)?AnsiString|\^char)$', [fTpMtch]);
 
854
  r:=AddStringFmtDef('AnsiString(VArgPMyAnsiString^)', 'MyAnsi P2',    '^((TMy)?AnsiString|\^char)$', [fTpMtch]);
 
855
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);  // ^char => gdb 6.7.5 with dwarf
 
856
  r:=AddStringFmtDef('PMyAnsiString(ArgPMyAnsiString)^',  'MyAnsi P',  '^(TMy)?AnsiString$', [fTpMtch]);
 
857
  r:=AddStringFmtDef('PMyAnsiString(VArgPMyAnsiString)^', 'MyAnsi P2', '^(TMy)?AnsiString$', [fTpMtch]);
 
858
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
859
 
 
860
 
 
861
  r:=AddFmtDef('PChar(ArgTMyAnsiString)',
 
862
                                               '''MyAnsi''$',      skPOINTER,   '(\^|p)char', [fTpMtch]);
 
863
                    UpdRes(r, stStabs,    '''MyAnsi''$',      skPOINTER,   'pchar|AnsiString', [fTpMtch]);
 
864
                         //UpdRes(r, stDwarf3,   '''MyAnsi''$',      skSimple,    'AnsiString', []);
 
865
 
 
866
  // accessing len/refcount
 
867
  r:=AddFmtDef('^longint(ArgTMyAnsiString)[-1]',
 
868
                                               '6',      skSimple,   'longint', []);
 
869
  r:=AddFmtDef('^longint(VArgTMyAnsiString)[-1]',
 
870
                                               '8',      skSimple,   'longint', []);
 
871
 
 
872
  // accessing char
 
873
  // TODO: only works with dwarf 3
 
874
  r:=AddFmtDef('ArgTMyAnsiString[1]',      '.',      skSimple,   'char', []);
 
875
                    UpdRes(r, stDwarf3,    '''M''$', skSimple,   'char', []);
 
876
  r:=AddFmtDef('VArgTMyAnsiString[1]',     '.',      skSimple,   'char', []);
 
877
                    UpdRes(r, stDwarf3,    '''M''$', skSimple,   'char', []);
 
878
  r:=AddFmtDef('ArgPMyAnsiString^[1]',     '.',      skSimple,   'char', []);
 
879
                    UpdRes(r, stDwarf3,    '''M''$', skSimple,   'char', []);
 
880
  r:=AddFmtDef('VArgPMyAnsiString^[1]',    '.',      skSimple,   'char', []);
 
881
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
882
     UpdRes(r, stDwarf3,    '''M''$', skSimple,   'char', []);
 
883
  r:=AddFmtDef('AnsiString(ArgTMyAnsiString)[1]',      '.',      skSimple,   'char', []);
 
884
                    UpdRes(r, stDwarf3,    '''M''$', skSimple,   'char', []);
 
885
  r:=AddFmtDef('AnsiString(VArgTMyAnsiString)[1]',     '.',      skSimple,   'char', []);
 
886
                    UpdRes(r, stDwarf3,    '''M''$', skSimple,   'char', []);
 
887
 
 
888
  // accessing char, after typecast
 
889
  r:=AddFmtDef('AnsiString(ArgTMyAnsiString)[1]',      '.',      skSimple,   'char', []);
 
890
                    UpdRes(r, stDwarf3,    '''M''$', skSimple,   'char', []);
 
891
 
 
892
 
 
893
  // string in array
 
894
  r:=AddStringFmtDef('ArgTMyAnsiStringDArray[0]',   'DArray1 Str0',         'AnsiString', []);
 
895
  r:=AddStringFmtDef('ArgTMyAnsiStringDArray[1]',   'DArray1 Str1',         'AnsiString', []);
 
896
  r:=AddStringFmtDef('VArgTMyAnsiStringDArray[0]',  'DArray2 Str0',         'AnsiString', []);
 
897
  if (DebuggerInfo.Version > 0) and (DebuggerInfo.Version < 070000) then UpdRes(r, stDwarf2All, '^(\^Char|AnsiString)$', [fTpMtch]);
 
898
  r:=AddStringFmtDef('VArgTMyAnsiStringDArray[1]',  'DArray2 Str1',         'AnsiString', []);
 
899
  if (DebuggerInfo.Version > 0) and (DebuggerInfo.Version < 070000) then UpdRes(r, stDwarf2All, '^(\^Char|AnsiString)$', [fTpMtch]);
 
900
 
 
901
 
 
902
  r:=AddCharFmtDef('ArgTMyAnsiStringDArray[0][1]',  'D', 'char', [IgnDwrf2, IgnStabs]);
 
903
  r:=AddCharFmtDef('ArgTMyAnsiStringDArray[0][12]', '0',   'char', [IgnDwrf2, IgnStabs]);
 
904
  r:=AddCharFmtDef('ArgTMyAnsiStringDArray[1][1]',  'D',    'char', [IgnDwrf2, IgnStabs]);
 
905
  r:=AddCharFmtDef('ArgTMyAnsiStringDArray[1][12]', '1',    'char', [IgnDwrf2, IgnStabs]);
 
906
 
 
907
  r:=AddCharFmtDef('VArgTMyAnsiStringDArray[0][1]',   'D',    'char', [IgnDwrf2, IgnStabs]);
 
908
  r:=AddCharFmtDef('VArgTMyAnsiStringDArray[0][12]',  '0',    'char', [IgnDwrf2, IgnStabs]);
 
909
  r:=AddCharFmtDef('VArgTMyAnsiStringDArray[1][1]',   'D',    'char', [IgnDwrf2, IgnStabs]);
 
910
  r:=AddCharFmtDef('VArgTMyAnsiStringDArray[1][12]',  '1',    'char', [IgnDwrf2, IgnStabs]);
 
911
 
 
912
  r:=AddStringFmtDef('ArgTMyAnsiStringSArray[3]',   'SArray1 Str3',         'AnsiString', []);
 
913
  r:=AddStringFmtDef('ArgTMyAnsiStringSArray[4]',   'SArray1 Str4',         'AnsiString', []);
 
914
  r:=AddStringFmtDef('VArgTMyAnsiStringSArray[3]',  'SArray2 Str3',         'AnsiString', []);
 
915
  r:=AddStringFmtDef('VArgTMyAnsiStringSArray[4]',  'SArray2 Str4',         'AnsiString', []);
 
916
 
 
917
  r:=AddCharFmtDef('ArgTMyAnsiStringSArray[3][1]',   'S',    'char', [IgnDataDw, IgnDataSt]);
 
918
  r:=AddCharFmtDef('ArgTMyAnsiStringSArray[3][12]',  '0',    'char', [IgnDataDw, IgnDataSt]);
 
919
  r:=AddCharFmtDef('ArgTMyAnsiStringSArray[4][1]',   'S',    'char', [IgnDataDw, IgnDataSt]);
 
920
  r:=AddCharFmtDef('ArgTMyAnsiStringSArray[4][12]',  '1',    'char', [IgnDataDw, IgnDataSt]);
 
921
 
 
922
  // string in array // no typename for array
 
923
  r:=AddStringFmtDef('GlobAMyAnsiStringDArray[0]',   'ADArray1 Str0',         'AnsiString', []);
 
924
  r:=AddStringFmtDef('GlobAMyAnsiStringDArray[1]',   'ADArray1 Str1',         'AnsiString', []);
 
925
 
 
926
  r:=AddCharFmtDef('GlobAMyAnsiStringDArray[0][1]',   'A',    'char', [IgnDwrf2, IgnStabs]);
 
927
  r:=AddCharFmtDef('GlobAMyAnsiStringDArray[0][13]',  '0',    'char', [IgnDwrf2, IgnStabs]);
 
928
  r:=AddCharFmtDef('GlobAMyAnsiStringDArray[1][1]',   'A',    'char', [IgnDwrf2, IgnStabs]);
 
929
  r:=AddCharFmtDef('GlobAMyAnsiStringDArray[1][13]',  '1',    'char', [IgnDwrf2, IgnStabs]);
 
930
 
 
931
  // PAnsiString in array
 
932
  r:=AddPointerFmtDefRaw('ArgTMyPAnsiStringDArray[0]',   MatchPointer(),     '^(\^|P)(AnsiString|PChar)$', [fTpMtch]);
 
933
  r:=AddPointerFmtDefRaw('ArgTMyPAnsiStringDArray[1]',   MatchPointer(),     '^(\^|P)(AnsiString|PChar)$', [fTpMtch]);
 
934
  r:=AddStringFmtDef('ArgTMyPAnsiStringDArray[0]^',   'DArray1 Str0',         'AnsiString', []);
 
935
  r:=AddStringFmtDef('ArgTMyPAnsiStringDArray[1]^',   'DArray1 Str1',         'AnsiString', []);
 
936
  r:=AddStringFmtDef('VArgTMyPAnsiStringDArray[0]^',  'DArray2 Str0',         'AnsiString', []);
 
937
  r:=AddStringFmtDef('VArgTMyPAnsiStringDArray[1]^',  'DArray2 Str1',         'AnsiString', []);
 
938
 
 
939
 
 
940
  r:=AddCharFmtDef('ArgTMyPAnsiStringDArray[0]^[1]',   'D'  ,    'char', [IgnDwrf2, IgnStabs]);
 
941
  r:=AddCharFmtDef('ArgTMyPAnsiStringDArray[0]^[12]',  '0'  ,    'char', [IgnDwrf2, IgnStabs]);
 
942
  r:=AddCharFmtDef('ArgTMyPAnsiStringDArray[1]^[1]',   'D'  ,    'char', [IgnDwrf2, IgnStabs]);
 
943
  r:=AddCharFmtDef('ArgTMyPAnsiStringDArray[1]^[12]',  '1'  ,    'char', [IgnDwrf2, IgnStabs]);
 
944
 
 
945
  r:=AddCharFmtDef('VArgTMyPAnsiStringDArray[0]^[1]',  'D'  ,    'char', [IgnDwrf2, IgnStabs]);
 
946
  r:=AddCharFmtDef('VArgTMyPAnsiStringDArray[0]^[12]', '0'  ,    'char', [IgnDwrf2, IgnStabs]);
 
947
  r:=AddCharFmtDef('VArgTMyPAnsiStringDArray[1]^[1]',  'D'  ,    'char', [IgnDwrf2, IgnStabs]);
 
948
  r:=AddCharFmtDef('VArgTMyPAnsiStringDArray[1]^[12]', '1'  ,    'char', [IgnDwrf2, IgnStabs]);
 
949
 
 
950
  r:=AddStringFmtDef('ArgTMyPAnsiStringSArray[3]^',   'SArray1 Str3',         'AnsiString', []);
 
951
  r:=AddStringFmtDef('ArgTMyPAnsiStringSArray[4]^',   'SArray1 Str4',         'AnsiString', []);
 
952
  r:=AddStringFmtDef('VArgTMyPAnsiStringSArray[3]^',  'SArray2 Str3',         'AnsiString', []);
 
953
  r:=AddStringFmtDef('VArgTMyPAnsiStringSArray[4]^',  'SArray2 Str4',         'AnsiString', []);
 
954
 
 
955
  r:=AddCharFmtDef('ArgTMyPAnsiStringSArray[3]^[1]',   'S',    'char', [IgnDataDw, IgnDataSt]);
 
956
  r:=AddCharFmtDef('ArgTMyPAnsiStringSArray[3]^[12]',  '0',    'char', [IgnDataDw, IgnDataSt]);
 
957
  r:=AddCharFmtDef('ArgTMyPAnsiStringSArray[4]^[1]',   'S',    'char', [IgnDataDw, IgnDataSt]);
 
958
  r:=AddCharFmtDef('ArgTMyPAnsiStringSArray[4]^[12]',  '1',    'char', [IgnDataDw, IgnDataSt]);
 
959
 
 
960
 
 
961
  // string in obj
 
962
  r:=AddStringFmtDef('ArgTStringHolderObj.FTMyAnsiString',   'Obj1 MyAnsi',         'AnsiString', []);
 
963
  r:=AddStringFmtDef('VArgTStringHolderObj.FTMyAnsiString',  'Obj2 MyAnsi',         'AnsiString', []);
 
964
 
 
965
  r:=AddFmtDef('ArgTStringHolderObj.FTMyAnsiString[1]',   '.$',  skSimple,    'char', []);
 
966
     UpdRes(r, stDwarf3,                         '''O''$', skSimple);
 
967
  r:=AddFmtDef('VArgTStringHolderObj.FTMyAnsiString[1]',   '.$',  skSimple,    'char', []);
 
968
     UpdRes(r, stDwarf3,                         '''O''$', skSimple);
 
969
 
 
970
  // string in rec
 
971
  r:=AddStringFmtDef('ArgTStringHolderRec.FTMyAnsiString',   'Rec1 MyAnsi',         'AnsiString', [fTstSkipDwarf3]);
 
972
  r:=AddStringFmtDef('VArgTStringHolderRec.FTMyAnsiString',  'Rec2 MyAnsi',         'AnsiString', [fTstSkipDwarf3]);
 
973
 
 
974
  r:=AddFmtDef('ArgTStringHolderRec.FTMyAnsiString[1]',   '.$',  skSimple,    'char', [fTstSkipDwarf3]);
 
975
     UpdRes(r, stDwarf3,                         '''R''$', skSimple);
 
976
  r:=AddFmtDef('VArgTStringHolderRec.FTMyAnsiString[1]',   '.$',  skSimple,    'char', [fTstSkipDwarf3]);
 
977
     UpdRes(r, stDwarf3,                         '''R''$', skSimple);
 
978
 
 
979
 
 
980
  //r:=AddFmtDef('ArgTNewAnsiString',       '''NewAnsi''$',     skPOINTER,   '(TNew)?AnsiString', []);
 
981
  //                  UpdRes(r, stDwarf3,   '''NewAnsi''$',     skSimple,    '(TNew)?AnsiString', [fTpMtch]);
 
982
  //r:=AddFmtDef('VArgTNewAnsiString',      '''NewAnsi 2''$',   skPOINTER,   '(TNew)?AnsiString', []);
 
983
  //                  UpdRes(r, stDwarf3,   '''NewAnsi 2''$',   skSimple,    '(TNew)?AnsiString', [fTpMtch]);
 
984
  //r:=AddFmtDef('ArgPNewAnsiString',       MatchPointer,       skPointer,   '(\^|PNew|P)AnsiString', []);
 
985
  //r:=AddFmtDef('VArgPNewAnsiString',      MatchPointer,       skPointer,   '(\^|PNew|P)AnsiString', []);
 
986
  //r:=AddFmtDef('ArgPNewAnsiString^',      '''NewAnsi P''',    skPOINTER,   '(TNew)?AnsiString', []);
 
987
  //                  UpdRes(r, stDwarf3,   '''NewAnsi''$',     skSimple,    '(TNew)?AnsiString', [fTpMtch]);
 
988
  //r:=AddFmtDef('VArgPNewAnsiString^',     '''NewAnsi P2''',   skPOINTER,   '(TNew)?AnsiString', []);
 
989
  //                  UpdRes(r, stDwarf3,   '''NewAnsi 2''$',   skSimple,    '(TNew)?AnsiString', [fTpMtch]);
 
990
 
 
991
 
 
992
 
 
993
  AddFmtDef('ArgTMyShortString',        '''short''$',        skSimple,      '^(TMy)?ShortString$', [fTpMtch]);
 
994
  AddFmtDef('VArgTMyShortString',       '''short''$',        skSimple,      '^(TMy)?ShortString$', [fTpMtch]);
 
995
  AddFmtDef('ArgPMyShortString',        Match_Pointer,      skPointer,     'P(My)?ShortString', [fTpMtch]);
 
996
  AddFmtDef('VArgPMyShortString',       Match_Pointer,      skPointer,     'P(My)?ShortString', [fTpMtch]);
 
997
  AddFmtDef('ArgPMyShortString^',        '''short''$',        skSimple,      '^(TMy)?ShortString$', [fTpMtch]);
 
998
  r := AddFmtDef('VArgPMyShortString^',       '''short''$',        skSimple,      '^(TMy)?ShortString$', [fTpMtch]);
 
999
     UpdResMinFpc(r, stDwarf, 020600); UpdResMinFpc(r, stDwarfSet, 020600);
 
1000
 
 
1001
  // string in array
 
1002
  r:=AddShortStrFmtDef('ArgTMyShortStringDArray[0]',   'DArray1 Short0',         'ShortString', []);
 
1003
  r:=AddShortStrFmtDef('ArgTMyShortStringDArray[1]',   'DArray1 Short1',         'ShortString', []);
 
1004
  r:=AddShortStrFmtDef('VArgTMyShortStringDArray[0]',  'DArray2 Short0',         'ShortString', []);
 
1005
  r:=AddShortStrFmtDef('VArgTMyShortStringDArray[1]',  'DArray2 Short1',         'ShortString', []);
 
1006
 
 
1007
 
 
1008
  r:=AddCharFmtDef('ArgTMyShortStringDArray[0][1]',   'D',      'char', [IgnDwrf2]);
 
1009
  r:=AddCharFmtDef('ArgTMyShortStringDArray[0][14]',  '0',      'char', [IgnDwrf2]);
 
1010
  r:=AddCharFmtDef('ArgTMyShortStringDArray[1][1]',   'D',      'char', [IgnDwrf2]);
 
1011
  r:=AddCharFmtDef('ArgTMyShortStringDArray[1][14]',  '1',      'char', [IgnDwrf2]);
 
1012
 
 
1013
  r:=AddCharFmtDef('VArgTMyShortStringDArray[0][1]',   'D',      'char', [IgnDwrf2]);
 
1014
  r:=AddCharFmtDef('VArgTMyShortStringDArray[0][14]',  '0',      'char', [IgnDwrf2]);
 
1015
  r:=AddCharFmtDef('VArgTMyShortStringDArray[1][1]',   'D',      'char', [IgnDwrf2]);
 
1016
  r:=AddCharFmtDef('VArgTMyShortStringDArray[1][14]',  '1',      'char', [IgnDwrf2]);
 
1017
 
 
1018
  r:=AddShortStrFmtDef('ArgTMyShortStringSArray[3]',   'SArray1 Short3',         'ShortString', []);
 
1019
  r:=AddShortStrFmtDef('ArgTMyShortStringSArray[4]',   'SArray1 Short4',         'ShortString', []);
 
1020
  r:=AddShortStrFmtDef('VArgTMyShortStringSArray[3]',  'SArray2 Short3',         'ShortString', []);
 
1021
  r:=AddShortStrFmtDef('VArgTMyShortStringSArray[4]',  'SArray2 Short4',         'ShortString', []);
 
1022
 
 
1023
  r:=AddCharFmtDef('ArgTMyShortStringSArray[3][1]',   'S',      'char', [IgnDwrf2]);
 
1024
  r:=AddCharFmtDef('ArgTMyShortStringSArray[3][14]',  '3',      'char', [IgnDwrf2]);
 
1025
  r:=AddCharFmtDef('ArgTMyShortStringSArray[4][1]',   'S',      'char', [IgnDwrf2]);
 
1026
  r:=AddCharFmtDef('ArgTMyShortStringSArray[4][14]',  '4',      'char', [IgnDwrf2]);
 
1027
 
 
1028
  // string in obj
 
1029
  r:=AddFmtDef('ArgTStringHolderObj.FTMyShortString',   '''Obj1 Short''$',  skSimple,     '^(TMy)?ShortString$', [fTpMtch, IgnDwrf3]);
 
1030
  r:=AddFmtDef('VArgTStringHolderObj.FTMyShortString',  '''Obj2 Short''$',  skSimple,     '^(TMy)?ShortString$', [fTpMtch, IgnDwrf3]);
 
1031
 
 
1032
  // string in rec
 
1033
  r:=AddFmtDef('ArgTStringHolderRec.FTMyShortString',   '''Rec1 Short''$',  skSimple,     '^(TMy)?ShortString$', [fTpMtch, IgnDwrf3]);
 
1034
  r:=AddFmtDef('VArgTStringHolderRec.FTMyShortString',  '''Rec2 Short''$',  skSimple,     '^(TMy)?ShortString$', [fTpMtch, IgnDwrf3]);
 
1035
 
 
1036
 
 
1037
  (*
 
1038
  AddFmtDef('ArgPPMyShortString',        '',      sk,      'PPMyShortString', []);
 
1039
  AddFmtDef('VArgPPMyShortString',        '',      sk,      'PPMyShortString', []);
 
1040
  AddFmtDef('ArgTNewhortString',        '',      sk,      'TNewhortString', []);
 
1041
  AddFmtDef('VArgTNewhortString',        '',      sk,      'TNewhortString', []);
 
1042
  AddFmtDef('ArgPNewhortString',        '',      sk,      'PNewhortString', []);
 
1043
  AddFmtDef('VArgPNewhortString',        '',      sk,      'PNewhortString', []);
 
1044
  *)
 
1045
 
 
1046
  // gdb 6.7.5 does not show the text
 
1047
  AddFmtDef('ArgTMyWideString',        '(''wide''$)|(widestring\(\$.*\))',      skPointer,      '^(TMy)?WideString$', [fTpMtch]);
 
1048
  AddFmtDef('VArgTMyWideString',       '(''wide''$)|(widestring\(\$.*\))',      skPointer,      '^(TMy)?WideString$', [fTpMtch]);
 
1049
  (*
 
1050
  AddFmtDef('ArgPMyWideString',        '',      sk,      'PMyWideString', []);
 
1051
  AddFmtDef('VArgPMyWideString',        '',      sk,      'PMyWideString', []);
 
1052
  AddFmtDef('ArgPPMyWideString',        '',      sk,      'PPMyWideString', []);
 
1053
  AddFmtDef('VArgPPMyWideString',        '',      sk,      'PPMyWideString', []);
 
1054
 
 
1055
  AddFmtDef('ArgTNewWideString',        '',      sk,      'TNewWideString', []);
 
1056
  AddFmtDef('VArgTNewWideString',        '',      sk,      'TNewWideString', []);
 
1057
  AddFmtDef('ArgPNewWideString',        '',      sk,      'PNewWideString', []);
 
1058
  AddFmtDef('VArgPNewWideString',        '',      sk,      'PNewWideString', []);
 
1059
 
 
1060
  AddFmtDef('ArgTMyString10',        '',      sk,      'TMyString10', []);
 
1061
  AddFmtDef('VArgTMyString10',        '',      sk,      'TMyString10', []);
 
1062
  AddFmtDef('ArgPMyString10',        '',      sk,      'PMyString10', []);
 
1063
  AddFmtDef('VArgPMyString10',        '',      sk,      'PMyString10', []);
 
1064
  AddFmtDef('ArgPPMyString10',        '',      sk,      'PPMyString10', []);
 
1065
  AddFmtDef('VArgPPMyString10',        '',      sk,      'PPMyString10', []);
 
1066
  *)
 
1067
 
 
1068
 
 
1069
  Add('ArgTMyAnsiString',      wdfMemDump,  ': 4d 79 41 6e 73 69 00',      skPOINTER,      '^(TMy)?AnsiString$', [fTpMtch]);
 
1070
 
 
1071
  {%endregion    * Strings * }
 
1072
 
 
1073
  {%region    * Simple * }
 
1074
 
 
1075
  AddFmtDef('ArgByte',        '^25$',      skSimple,      'Byte', []);
 
1076
  AddFmtDef('VArgByte',       '^25$',      skSimple,      'Byte', []);
 
1077
  AddFmtDef('ArgWord',        '^26$',      skSimple,      'Word', []);
 
1078
  AddFmtDef('VArgWord',       '^26$',      skSimple,      'Word', []);
 
1079
  AddFmtDef('ArgLongWord',    '^27$',      skSimple,      'LongWord', []);
 
1080
  AddFmtDef('VArgLongWord',   '^27$',      skSimple,      'LongWord', []);
 
1081
  AddFmtDef('ArgQWord',       '^28$',      skSimple,      'QWord', []);
 
1082
  AddFmtDef('VArgQWord',      '^28$',      skSimple,      'QWord', []);
 
1083
 
 
1084
  AddFmtDef('ArgShortInt',    '^35$',      skSimple,      'ShortInt', []);
 
1085
  AddFmtDef('VArgShortInt',   '^35$',      skSimple,      'ShortInt', []);
 
1086
  AddFmtDef('ArgSmallInt',    '^36$',      skSimple,      'SmallInt', []);
 
1087
  AddFmtDef('VArgSmallInt',   '^36$',      skSimple,      'SmallInt', []);
 
1088
  AddFmtDef('ArgInt',         '^37$',      skSimple,      'Integer|LongInt', [fTpMtch]);
 
1089
  AddFmtDef('VArgInt',        '^37$',      skSimple,      'Integer|LongInt', [fTpMtch]);
 
1090
  AddFmtDef('ArgInt64',       '^38$',      skSimple,      'Int64', []);
 
1091
  AddFmtDef('VArgInt64',      '^38$',      skSimple,      'Int64', []);
 
1092
 
 
1093
  AddFmtDef('ArgPointer',        Match_Pointer,      skPointer,      'Pointer', []);
 
1094
  AddFmtDef('VArgPointer',       Match_Pointer,      skPointer,      'Pointer', []);
 
1095
  (*
 
1096
  AddFmtDef('ArgPPointer',        '',      sk,      'PPointer', []);
 
1097
  AddFmtDef('VArgPPointer',        '',      sk,      'PPointer', []);
 
1098
  *)
 
1099
 
 
1100
  AddFmtDef('ArgDouble',         '1\.123',      skSimple,      'Double', []);
 
1101
  AddFmtDef('VArgDouble',        '1\.123',      skSimple,      'Double', []);
 
1102
  AddFmtDef('ArgExtended',       '2\.345',      skSimple,      'Extended|double', [fTpMtch]);
 
1103
  AddFmtDef('VArgExtended',      '2\.345',      skSimple,      'Extended|double', [fTpMtch]);
 
1104
 
 
1105
  (*
 
1106
  AddFmtDef('ArgPByte',        '',      sk,      'PByte', []);
 
1107
  AddFmtDef('VArgPByte',        '',      sk,      'PByte', []);
 
1108
  AddFmtDef('ArgPWord',        '',      sk,      'PWord', []);
 
1109
  AddFmtDef('VArgPWord',        '',      sk,      'PWord', []);
 
1110
  AddFmtDef('ArgPLongWord',        '',      sk,      'PLongWord', []);
 
1111
  AddFmtDef('VArgPLongWord',        '',      sk,      'PLongWord', []);
 
1112
  AddFmtDef('ArgPQWord',        '',      sk,      'PQWord', []);
 
1113
  AddFmtDef('VArgPQWord',        '',      sk,      'PQWord', []);
 
1114
 
 
1115
  AddFmtDef('ArgPShortInt',        '',      sk,      'PShortInt', []);
 
1116
  AddFmtDef('VArgPShortInt',        '',      sk,      'PShortInt', []);
 
1117
  AddFmtDef('ArgPSmallInt',        '',      sk,      'PSmallInt', []);
 
1118
  AddFmtDef('VArgPSmallInt',        '',      sk,      'PSmallInt', []);
 
1119
  AddFmtDef('ArgPInt',        '',      sk,      'PInteger', []);
 
1120
  AddFmtDef('VArgPInt',        '',      sk,      'PInteger', []);
 
1121
  AddFmtDef('ArgPInt64',        '',      sk,      'PInt64', []);
 
1122
  AddFmtDef('VArgPInt64',        '',      sk,      'PInt64', []);
 
1123
  *)
 
1124
 
 
1125
  // spaces
 
1126
  AddFmtDef('ArgWord + 1',        '^27$',      skSimple,      'Word|long', [fTpMtch]);
 
1127
  AddFmtDef('ArgWord or 64',      '^90$',      skSimple,      'Word|long', [fTpMtch]);
 
1128
  AddFmtDef('ArgWord and 67',     '^2$',       skSimple,      'Word|long', [fTpMtch]);
 
1129
 
 
1130
  {%endregion    * Simple * }
 
1131
 
 
1132
  {%region    * Enum/Set * }
 
1133
 
 
1134
  AddFmtDef('ArgEnum',         '^Two$',                      skEnum,       'TEnum', []);
 
1135
  AddFmtDef('ArgEnumSet',      '^\[Two(, ?|\.\.)Three\]$',   skSet,        'TEnumSet', [IgnDwrf2IfNoSet]);
 
1136
  AddFmtDef('ArgSet',          '^\[Alpha(, ?|\.\.)Beta\]$',  skSet,        'TSet', [IgnDwrf2IfNoSet]);
 
1137
 
 
1138
  AddFmtDef('VarEnumA',        '^e3$',                       skEnum,       '', []);
 
1139
  // maybe typename = "set of TEnum"
 
1140
  AddFmtDef('VarEnumSetA',     '^\[Three\]$',                skSet,        '', [IgnDwrf2IfNoSet]);
 
1141
  AddFmtDef('VarSetA',         '^\[s2\]$',                   skSet,        '', [IgnDwrf2IfNoSet]);
 
1142
  {%endregion    * Enum/Set * }
 
1143
 
 
1144
  {%region    * Variant * }
 
1145
 
 
1146
  AddFmtDef('ArgVariantInt',         '^5$',         skVariant,       'Variant', []);
 
1147
  AddFmtDef('ArgVariantString',      '^''v''$',     skVariant,       'Variant', []);
 
1148
 
 
1149
  AddFmtDef('VArgVariantInt',         '^5$',         skVariant,       'Variant', []);
 
1150
  AddFmtDef('VArgVariantString',      '^''v''$',     skVariant,       'Variant', []);
 
1151
  {%endregion    * Variant * }
 
1152
 
 
1153
  {%region    * procedure/function/method * }
 
1154
 
 
1155
  AddFmtDef('ArgProcedure',         'procedure',           skProcedure,       'TProcedure', []);
 
1156
  AddFmtDef('ArgFunction',          'function',            skFunction,        'TFunction',  []);
 
1157
  (*
 
1158
  // normal procedure on stabs / recodr on dwarf => maybe the data itself may reveal some ?
 
1159
  AddFmtDef('ArgObjProcedure',      'procedure.*of object|record.*procedure.*self =',
 
1160
                                                           skRecord,          'TObjProcedure', []);
 
1161
  AddFmtDef('ArgObjFunction',       'function.*of object|record.*function.*self =',
 
1162
                                                           skRecord,          'TObjFunction',  []);
 
1163
 
 
1164
  *)
 
1165
  // doesn't work, ptype returns empty in dwarf => maybe via whatis
 
1166
  //    AddFmtDef('VArgProcedure',         'procedure',           skProcedure,       'TProcedure', []);
 
1167
  //    AddFmtDef('VArgFunction',          'function',            skFunction,        'TFunction',  []);
 
1168
  (*
 
1169
  AddFmtDef('VArgObjProcedure',      'procedure.*of object|record.*procedure.*self =',
 
1170
                                                            skRecord,          'TObjProcedure', []);
 
1171
  AddFmtDef('VArgObjFunction',       'function.*of object|record.*function.*self =',
 
1172
                                                            skRecord,          'TObjFunction',  []);
 
1173
  *)
 
1174
 
 
1175
  AddFmtDef('VarProcedureA',         'procedure',           skProcedure,       'Procedure', []);
 
1176
  AddFmtDef('VarFunctionA',          'function',            skFunction,        'Function',  []);
 
1177
  (*
 
1178
  AddFmtDef('VarObjProcedureA',      'procedure.*of object|record.*procedure.*self =',
 
1179
                                                            skRecord,          'Procedure', []);
 
1180
  AddFmtDef('VarObjFunctionA',       'function.*of object|record.*function.*self =',
 
1181
                                                            skRecord,          'Function',  []);
 
1182
  *)
 
1183
  {%endregion    * procedure/function/method * }
 
1184
 
 
1185
  if RUN_TEST_ONLY > 0 then begin
 
1186
    ExpectBreakFoo[0] := ExpectBreakFoo[abs(RUN_TEST_ONLY)];
 
1187
    SetLength(ExpectBreakFoo, 1);
 
1188
  end;
 
1189
end;
 
1190
 
 
1191
procedure TTestWatches.AddExpectBreakFooArray;
 
1192
 
 
1193
  function AddRecForArrFmtDef  (AnExpr: string; ARecSuffix, AValue: Integer;  AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
1194
  begin
 
1195
    case ARecSuffix of
 
1196
      1: Result := Add(AnExpr, wdfDefault, MatchRecord('TRecForArray1', ' a = '+IntToStr(AValue)), skRecord, 'TRecForArray1', AFlgs );
 
1197
      2: Result := Add(AnExpr, wdfDefault, MatchRecord('TRecForArray2', ' c = '+IntToStr(AValue)), skRecord, 'TRecForArray2', AFlgs );
 
1198
      3: Result := Add(AnExpr, wdfDefault, MatchRecord('TRecForArray3', ' a = '+IntToStr(AValue)), skRecord, 'TRecForArray3', AFlgs );
 
1199
      4: Result := Add(AnExpr, wdfDefault, MatchRecord('TRecForArray4', ' c = '+IntToStr(AValue)), skRecord, 'TRecForArray4', AFlgs );
 
1200
    end;
 
1201
 
 
1202
    case ARecSuffix of
 
1203
      1,3: Add(AnExpr+'.a', wdfDefault, '^'+IntToStr(AValue)+'$', skSimple, M_Int, AFlgs+[fTpMtch] );
 
1204
      2,4: Add(AnExpr+'.c', wdfDefault, '^'+IntToStr(AValue)+'$', skSimple, M_Int, AFlgs+[fTpMtch] );
 
1205
    end;
 
1206
  end;
 
1207
 
 
1208
  function AddArrayFmtDef  (AnExpr, AMtch, ATpNm: string; AFlgs: TWatchExpectationFlags=[]): PWatchExpectation;
 
1209
  begin
 
1210
    Result := Add(AnExpr, wdfDefault, AMtch, skSimple, ATpNm, AFlgs );
 
1211
  end;
 
1212
 
 
1213
var
 
1214
  r: PWatchExpectation;
 
1215
  v: string;
 
1216
  i: integer;
 
1217
begin
 
1218
  if not TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('  TTestWatch.All')] then exit;
 
1219
  FCurrentExpArray := @ExpectBreakFooArray;
 
1220
 
 
1221
  {%region    * Array * }
 
1222
  //TODO: DynArray, decide what to display
 
1223
  // TODO {} fixup array => replace with []
 
1224
  AddFmtDef('VarDynIntArray',             Match_Pointer+'|\{\}|0,[\s\r\n]+2',
 
1225
                                skSimple,       'TDynIntArray',
 
1226
                                []);
 
1227
  //TODO add () around list
 
1228
  if FDoStatIntArray then
 
1229
  AddFmtDef('VarStatIntArray',            '10,[\s\r\n]+12,[\s\r\n]+14,[\s\r\n]+16,[\s\r\n]+18',
 
1230
                                skSimple,       'TStatIntArray',
 
1231
                                []);
 
1232
  AddFmtDef('VarPDynIntArray',            Match_Pointer,
 
1233
                                skPointer,      'PDynIntArray',
 
1234
                                []);
 
1235
  AddFmtDef('VarPStatIntArray',           Match_Pointer,
 
1236
                                skPointer,      'PStatIntArray',
 
1237
                                []);
 
1238
  AddFmtDef('VarDynIntArrayA',            Match_Pointer+'|\{\}|0,[\s\r\n]+2',
 
1239
                                skSimple,       '',
 
1240
                                []);
 
1241
  if FDoStatIntArray then
 
1242
  AddFmtDef('VarStatIntArrayA',           '10,[\s\r\n]+12,[\s\r\n]+14,[\s\r\n]+16,[\s\r\n]+18',
 
1243
                                skSimple,       '',
 
1244
                                []);
 
1245
 
 
1246
  AddFmtDef('VarDynIntArray[1]',          '2',
 
1247
                                skSimple,       'Integer|LongInt',
 
1248
                                [fTpMtch]);
 
1249
  AddFmtDef('VarStatIntArray[6]',         '12',
 
1250
                                skSimple,       'Integer|LongInt',
 
1251
                                [fTpMtch]);
 
1252
  AddFmtDef('VarPDynIntArray^[1]',        '2',
 
1253
                                skSimple,       'Integer|LongInt',
 
1254
                                [fTpMtch]);
 
1255
  AddFmtDef('VarPStatIntArray^[6]',       '12',
 
1256
                                skSimple,       'Integer|LongInt',
 
1257
                                [fTpMtch]);
 
1258
  AddFmtDef('VarDynIntArrayA[1]',         '2',
 
1259
                                skSimple,       'Integer|LongInt',
 
1260
                                [fTpMtch]);
 
1261
  AddFmtDef('VarStatIntArrayA[6]',        '12',
 
1262
                                skSimple,       'Integer|LongInt',
 
1263
                                [fTpMtch]);
 
1264
  {%endregion    * Array * }
 
1265
 
 
1266
  for i := 0 to 1 do begin
 
1267
    if i = 0
 
1268
    then v := ''
 
1269
    else v := 'V';
 
1270
 
 
1271
    {%region DYN ARRAY}
 
1272
      {%region DYN ARRAY (norm)}
 
1273
      //TDynArrayTRec1      = array of TRecForArray3;
 
1274
    r := AddArrayFmtDef(v+'ArgTDynArrayTRec1', '.', 'TDynArrayTRec1', []);
 
1275
    if v = 'V' then UpdResMinFpc(r, stDwarf2All, 020600);
 
1276
    r := AddRecForArrFmtDef(v+'ArgTDynArrayTRec1[0]', 3, 90, []);
 
1277
    r := AddRecForArrFmtDef(v+'ArgTDynArrayTRec1[1]', 3, 91, []);
 
1278
      //TDynArrayPRec1      = array of ^TRecForArray3;
 
1279
    r := AddArrayFmtDef(v+'ArgTDynArrayPRec1', '.', 'TDynArrayPRec1', []);
 
1280
    if v = 'V' then UpdResMinFpc(r, stDwarf2All, 020600);
 
1281
    r := AddPointerFmtDef  (v+'ArgTDynArrayPRec1[0]', '\^TRecForArray3', '^TRecForArray3', []);
 
1282
    r := AddRecForArrFmtDef(v+'ArgTDynArrayPRec1[0]^', 3, 90, []);
 
1283
    r := AddPointerFmtDef  (v+'ArgTDynArrayPRec1[1]', '\^TRecForArray3', '^TRecForArray3', []);
 
1284
    r := AddRecForArrFmtDef(v+'ArgTDynArrayPRec1[1]^', 3, 91, []);
 
1285
      //TDynDynArrayTRec1   = array of array of TRecForArray1;
 
1286
    r := AddArrayFmtDef(v+'ArgTDynDynArrayTRec1', '.', 'TDynDynArrayTRec1', []);
 
1287
    if v = 'V' then UpdResMinFpc(r, stDwarf2All, 020600);
 
1288
    r := AddArrayFmtDef(v+'ArgTDynDynArrayTRec1[0]', '.', '', []); // TODO? typename = array of ...
 
1289
    r := AddRecForArrFmtDef(v+'ArgTDynDynArrayTRec1[0][0]', 1, 80, []);
 
1290
    //if v = 'V' then UpdResMinFpc(r, stDwarf2All, 020600);
 
1291
    r := AddRecForArrFmtDef(v+'ArgTDynDynArrayTRec1[0][1]', 1, 81, []);
 
1292
    //if v = 'V' then UpdResMinFpc(r, stDwarf2All, 020600);
 
1293
    r := AddArrayFmtDef(v+'ArgTDynDynArrayTRec1[1]', '.', '', []); // TODO? typename = array of ...
 
1294
    r := AddRecForArrFmtDef(v+'ArgTDynDynArrayTRec1[1][0]', 1, 85, []);
 
1295
    //if v = 'V' then UpdResMinFpc(r, stDwarf2All, 020600);
 
1296
    r := AddRecForArrFmtDef(v+'ArgTDynDynArrayTRec1[1][1]', 1, 86, []);
 
1297
    r := AddRecForArrFmtDef(v+'ArgTDynDynArrayTRec1[1,1]', 1, 86, []);          // comma separated index
 
1298
    //if v = 'V' then UpdResMinFpc(r, stDwarf2All, 020600);
 
1299
      //TDynDynArrayPRec1   = array of array of ^TRecForArray1;
 
1300
      //TDynStatArrayTRec1  = array of array [3..5] of TRecForArray1;
 
1301
      //TDynStatArrayPRec1  = array of array [3..5] of ^TRecForArray1;
 
1302
      //
 
1303
      //TDynArrayTRec2      = array of TRecForArray4;
 
1304
      //TDynArrayPRec2      = array of ^TRecForArray4;
 
1305
      //TDynArrayPPRec2     = array of ^PRecForArray4; // double pointer
 
1306
      //TDynDynArrayTRec2   = array of array of TRecForArray2;
 
1307
      //TDynDynArrayPRec2   = array of array of ^TRecForArray2;
 
1308
      //TDynStatArrayTRec2  = array of array [3..5] of TRecForArray2;
 
1309
      //TDynStatArrayPRec2  = array of array [3..5] of ^TRecForArray2;
 
1310
 
 
1311
      (* Array in expression*)
 
1312
      Add(v+'ArgTDynArrayTRec1[0].a+'+v+'ArgTDynArrayTRec1[1].a', wdfDefault, '^181$', skSimple, M_Int+'|long', [fTpMtch] );
 
1313
      Add(v+'ArgTDynArrayTRec1[0].a+'+'ArgTDynArrayTRec1[1].a', wdfDefault, '^181$', skSimple, M_Int+'|long', [fTpMtch] );
 
1314
      Add('ArgTDynArrayTRec1[0].a+'+v+'ArgTDynArrayTRec1[1].a', wdfDefault, '^181$', skSimple, M_Int+'|long', [fTpMtch] );
 
1315
      Add(v+'ArgTDynArrayTRec1[0].a and '+v+'ArgTDynArrayTRec1[1].a', wdfDefault, '^90$', skSimple, M_Int+'|long', [fTpMtch] );
 
1316
 
 
1317
      Add(v+'ArgTDynDynArrayTRec1[1][1].a+'+v+'ArgTDynArrayPRec1[1]^.a', wdfDefault, '^177$', skSimple, M_Int+'|long', [fTpMtch] );
 
1318
      Add(v+'ArgTDynArrayPRec1[1]^.a+'+v+'ArgTDynDynArrayTRec1[1][1].a', wdfDefault, '^177$', skSimple, M_Int+'|long', [fTpMtch] );
 
1319
 
 
1320
      {%endregion DYN ARRAY (norm)}
 
1321
 
 
1322
    {%region DYN ARRAY (VAR)}
 
1323
        // dyn arrays VAR
 
1324
(*
 
1325
    //TDynArrayTRec1      = array of TRecForArray3;
 
1326
  r := AddArrayFmtDef('VArgTDynArrayTRec1', '.', 'TDynArrayTRec1', []);
 
1327
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1328
  r := AddRecForArrFmtDef('VArgTDynArrayTRec1[0]', 3, 90, []);
 
1329
  r := AddRecForArrFmtDef('VArgTDynArrayTRec1[1]', 3, 91, []);
 
1330
    //TDynArrayPRec1      = array of ^TRecForArray3;
 
1331
  r := AddArrayFmtDef('VArgTDynArrayPRec1', '.', 'TDynArrayPRec1', []);
 
1332
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1333
  r := AddPointerFmtDef  ('VArgTDynArrayPRec1[0]', '\^TRecForArray3', '^TRecForArray3', []);
 
1334
  r := AddRecForArrFmtDef('VArgTDynArrayPRec1[0]^', 3, 90, []);
 
1335
  r := AddPointerFmtDef  ('VArgTDynArrayPRec1[1]', '\^TRecForArray3', '^TRecForArray3', []);
 
1336
  r := AddRecForArrFmtDef('VArgTDynArrayPRec1[1]^', 3, 91, []);
 
1337
    //TDynDynArrayTRec1   = array of array of TRecForArray1;
 
1338
  r := AddArrayFmtDef('VArgTDynDynArrayTRec1', '.', 'TDynDynArrayTRec1', []);
 
1339
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1340
  r := AddArrayFmtDef('VArgTDynDynArrayTRec1[0]', '.', '', []); // TODO? typename = array of ...
 
1341
  r := AddRecForArrFmtDef('VArgTDynDynArrayTRec1[0][0]', 1, 80, []);
 
1342
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1343
  r := AddRecForArrFmtDef('VArgTDynDynArrayTRec1[0][1]', 1, 81, []);
 
1344
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1345
  r := AddArrayFmtDef('VArgTDynDynArrayTRec1[1]', '.', '', []); // TODO? typename = array of ...
 
1346
  r := AddRecForArrFmtDef('VArgTDynDynArrayTRec1[1][0]', 1, 85, []);
 
1347
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1348
  r := AddRecForArrFmtDef('VArgTDynDynArrayTRec1[1][1]', 1, 86, []);
 
1349
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1350
    //TDynDynArrayPRec1   = array of array of ^TRecForArray1;
 
1351
    //TDynStatArrayTRec1  = array of array [3..5] of TRecForArray1;
 
1352
    //TDynStatArrayPRec1  = array of array [3..5] of ^TRecForArray1;
 
1353
    //
 
1354
    //TDynArrayTRec2      = array of TRecForArray4;
 
1355
    //TDynArrayPRec2      = array of ^TRecForArray4;
 
1356
    //TDynArrayPPRec2     = array of ^PRecForArray4; // double pointer
 
1357
    //TDynDynArrayTRec2   = array of array of TRecForArray2;
 
1358
    //TDynDynArrayPRec2   = array of array of ^TRecForArray2;
 
1359
    //TDynStatArrayTRec2  = array of array [3..5] of TRecForArray2;
 
1360
    //TDynStatArrayPRec2  = array of array [3..5] of ^TRecForArray2;
 
1361
*)
 
1362
    {%endregion DYN ARRAY (VAR)}
 
1363
  {%endregion DYN ARRAY}
 
1364
  end;
 
1365
 
 
1366
 
 
1367
  {%region STAT ARRAY}
 
1368
    {%region STAT ARRAY (norm)}
 
1369
    //TStatArrayTRec1     = array [3..5] of TRecForArray3;
 
1370
  r := AddArrayFmtDef('ArgTStatArrayTRec1', '.', 'TStatArrayTRec1', []);
 
1371
  r := AddRecForArrFmtDef('ArgTStatArrayTRec1[3]', 3, 50, []);
 
1372
  r := AddRecForArrFmtDef('ArgTStatArrayTRec1[4]', 3, 51, []);
 
1373
    //TStatArrayPRec1     = array [3..5] of ^TRecForArray3;
 
1374
  r := AddArrayFmtDef('ArgTStatArrayPRec1', '.', 'TStatArrayPRec1', []);
 
1375
  r := AddPointerFmtDef  ('ArgTStatArrayPRec1[3]', '\^TRecForArray3', '^TRecForArray3', []);
 
1376
  r := AddRecForArrFmtDef('ArgTStatArrayPRec1[3]^', 3, 50, []);
 
1377
  r := AddPointerFmtDef  ('ArgTStatArrayPRec1[4]', '\^TRecForArray3', '^TRecForArray3', []);
 
1378
  r := AddRecForArrFmtDef('ArgTStatArrayPRec1[4]^', 3, 51, []);
 
1379
    //TStatDynArrayTRec1  = array [3..5] of array of TRecForArray1;
 
1380
  r := AddArrayFmtDef('ArgTStatDynArrayTRec1', '.', 'TStatDynArrayTRec1', []);
 
1381
  r := AddArrayFmtDef('ArgTStatDynArrayTRec1[3]', '.', '', []); // TODO? typename = array of ...
 
1382
  r := AddRecForArrFmtDef('ArgTStatDynArrayTRec1[3][0]', 1, 40, []);
 
1383
  r := AddRecForArrFmtDef('ArgTStatDynArrayTRec1[3][1]', 1, 41, []);
 
1384
  r := AddArrayFmtDef('ArgTStatDynArrayTRec1[4]', '.', '', []); // TODO? typename = array of ...
 
1385
  r := AddRecForArrFmtDef('ArgTStatDynArrayTRec1[4][0]', 1, 45, []);
 
1386
  r := AddRecForArrFmtDef('ArgTStatDynArrayTRec1[4][1]', 1, 46, []);
 
1387
  r := AddRecForArrFmtDef('ArgTStatDynArrayTRec1[4,1]', 1, 46, []);            // comma separated index
 
1388
    //TStatDynArrayPRec1  = array [3..5] of array of ^TRecForArray1;
 
1389
    //TStatStatArrayTRec1 = array [3..5] of array [3..5] of TRecForArray1;
 
1390
    //TStatStatArrayPRec1 = array [3..5] of array [3..5] of ^TRecForArray1;
 
1391
    //
 
1392
    //TStatArrayTRec2     = array [3..5] of TRecForArray4;
 
1393
    //TStatArrayPRec2     = array [3..5] of ^TRecForArray4;
 
1394
    //TStatArrayPPRec2    = array [3..5] of ^PRecForArray4; // double pointer
 
1395
    //TStatDynArrayTRec2  = array [3..5] of array of TRecForArray2;
 
1396
    //TStatDynArrayPRec2  = array [3..5] of array of ^TRecForArray2;
 
1397
    //TStatStatArrayTRec2 = array [3..5] of array [3..5] of TRecForArray2;
 
1398
    //TStatStatArrayPRec2 = array [3..5] of array [3..5] of ^TRecForArray2;
 
1399
    {%endregion STAT ARRAY (norm)}
 
1400
 
 
1401
    {%region STAT ARRAY (VAR)}
 
1402
    //TStatArrayTRec1     = array [3..5] of TRecForArray3;
 
1403
  r := AddArrayFmtDef('VArgTStatArrayTRec1', '.', 'TStatArrayTRec1', []);
 
1404
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1405
  r := AddRecForArrFmtDef('VArgTStatArrayTRec1[3]', 3, 50, []);
 
1406
  r := AddRecForArrFmtDef('VArgTStatArrayTRec1[4]', 3, 51, []);
 
1407
    //TStatArrayPRec1     = array [3..5] of ^TRecForArray3;
 
1408
  r := AddArrayFmtDef('VArgTStatArrayPRec1', '.', 'TStatArrayPRec1', []);
 
1409
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1410
  r := AddPointerFmtDef  ('VArgTStatArrayPRec1[3]', '\^TRecForArray3', '^TRecForArray3', []);
 
1411
  r := AddRecForArrFmtDef('VArgTStatArrayPRec1[3]^', 3, 50, []);
 
1412
  r := AddPointerFmtDef  ('VArgTStatArrayPRec1[4]', '\^TRecForArray3', '^TRecForArray3', []);
 
1413
  r := AddRecForArrFmtDef('VArgTStatArrayPRec1[4]^', 3, 51, []);
 
1414
    //TStatDynArrayTRec1  = array [3..5] of array of TRecForArray1;
 
1415
  r := AddArrayFmtDef('VArgTStatDynArrayTRec1', '.', 'TStatDynArrayTRec1', []);
 
1416
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1417
  r := AddArrayFmtDef('VArgTStatDynArrayTRec1[3]', '.', '', []); // TODO? typename = array of ...
 
1418
  r := AddRecForArrFmtDef('VArgTStatDynArrayTRec1[3][0]', 1, 40, []);
 
1419
  r := AddRecForArrFmtDef('VArgTStatDynArrayTRec1[3][1]', 1, 41, []);
 
1420
  r := AddArrayFmtDef('VArgTStatDynArrayTRec1[4]', '.', '', []); // TODO? typename = array of ...
 
1421
  r := AddRecForArrFmtDef('VArgTStatDynArrayTRec1[4][0]', 1, 45, []);
 
1422
  r := AddRecForArrFmtDef('VArgTStatDynArrayTRec1[4][1]', 1, 46, []);
 
1423
    //TStatDynArrayPRec1  = array [3..5] of array of ^TRecForArray1;
 
1424
    //TStatStatArrayTRec1 = array [3..5] of array [3..5] of TRecForArray1;
 
1425
    //TStatStatArrayPRec1 = array [3..5] of array [3..5] of ^TRecForArray1;
 
1426
    //
 
1427
    //TStatArrayTRec2     = array [3..5] of TRecForArray4;
 
1428
    //TStatArrayPRec2     = array [3..5] of ^TRecForArray4;
 
1429
    //TStatArrayPPRec2    = array [3..5] of ^PRecForArray4; // double pointer
 
1430
    //TStatDynArrayTRec2  = array [3..5] of array of TRecForArray2;
 
1431
    //TStatDynArrayPRec2  = array [3..5] of array of ^TRecForArray2;
 
1432
    //TStatStatArrayTRec2 = array [3..5] of array [3..5] of TRecForArray2;
 
1433
    //TStatStatArrayPRec2 = array [3..5] of array [3..5] of ^TRecForArray2;
 
1434
    {%endregion STAT ARRAY (VAR)}
 
1435
  {%endregion STAT ARRAY}
 
1436
 
 
1437
 
 
1438
  {%region DYN ARRAY of named arrays}
 
1439
    {%region DYN ARRAY of named arrays (norm)}
 
1440
    //TDynDynTRec1Array   = array of TDynArrayTRec1;
 
1441
  r := AddArrayFmtDef('ArgTDynDynTRec1Array', '.', 'TDynDynTRec1Array', []);
 
1442
  r := AddArrayFmtDef('ArgTDynDynTRec1Array[0]', '.', 'TDynArrayTRec1', []);
 
1443
  r := AddRecForArrFmtDef('ArgTDynDynTRec1Array[0][0]', 3, 80, []);
 
1444
  r := AddRecForArrFmtDef('ArgTDynDynTRec1Array[0][1]', 3, 81, []);
 
1445
  r := AddArrayFmtDef('ArgTDynDynTRec1Array[1]', '.', 'TDynArrayTRec1', []);
 
1446
  r := AddRecForArrFmtDef('ArgTDynDynTRec1Array[1][0]', 3, 85, []);
 
1447
  r := AddRecForArrFmtDef('ArgTDynDynTRec1Array[1][1]', 3, 86, []);
 
1448
    //TDynDynPRec1Array   = array of TDynArrayPRec1;
 
1449
  r := AddArrayFmtDef('ArgTDynDynPRec1Array', '.', 'TDynDynPRec1Array', []);
 
1450
  r := AddArrayFmtDef('ArgTDynDynPRec1Array[0]', '.', 'TDynArrayPRec1', []);
 
1451
  r := AddPointerFmtDef  ('ArgTDynDynPRec1Array[0][0]', '\^TRecForArray3', '^TRecForArray3', []);
 
1452
  r := AddRecForArrFmtDef('ArgTDynDynPRec1Array[0][0]^', 3, 80, []);
 
1453
  r := AddPointerFmtDef  ('ArgTDynDynPRec1Array[0][1]', '\^TRecForArray3', '^TRecForArray3', []);
 
1454
  r := AddRecForArrFmtDef('ArgTDynDynPRec1Array[0][1]^', 3, 81, []);
 
1455
  r := AddArrayFmtDef('ArgTDynDynPRec1Array[1]', '.', 'TDynArrayPRec1', []);
 
1456
  r := AddPointerFmtDef  ('ArgTDynDynPRec1Array[1][0]', '\^TRecForArray3', '^TRecForArray3', []);
 
1457
  r := AddRecForArrFmtDef('ArgTDynDynPRec1Array[1][0]^', 3, 85, []);
 
1458
  r := AddPointerFmtDef  ('ArgTDynDynPRec1Array[1][1]', '\^TRecForArray3', '^TRecForArray3', []);
 
1459
  r := AddRecForArrFmtDef('ArgTDynDynPRec1Array[1][1]^', 3, 86, []);
 
1460
    //TDynStatTRec1Array  = array of TStatArrayTRec1;
 
1461
  r := AddArrayFmtDef('ArgTDynStatTRec1Array', '.', 'TDynStatTRec1Array', []);
 
1462
  r := AddArrayFmtDef('ArgTDynStatTRec1Array[0]', '.', 'TStatArrayTRec1', []);
 
1463
  r := AddRecForArrFmtDef('ArgTDynStatTRec1Array[0][3]', 3, 70, []);
 
1464
  r := AddRecForArrFmtDef('ArgTDynStatTRec1Array[0][4]', 3, 71, []);
 
1465
  r := AddArrayFmtDef('ArgTDynStatTRec1Array[1]', '.', 'TStatArrayTRec1', []);
 
1466
  r := AddRecForArrFmtDef('ArgTDynStatTRec1Array[1][3]', 3, 75, []);
 
1467
  r := AddRecForArrFmtDef('ArgTDynStatTRec1Array[1][4]', 3, 76, []);
 
1468
    //TDynStatPRec1Array  = array of TStatArrayPRec1;
 
1469
  r := AddArrayFmtDef('ArgTDynStatPRec1Array', '.', 'TDynStatPRec1Array', []);
 
1470
  r := AddArrayFmtDef('ArgTDynStatPRec1Array[0]', '.', 'TStatArrayPRec1', []);
 
1471
  r := AddPointerFmtDef  ('ArgTDynStatPRec1Array[0][3]', '\^TRecForArray3', '^TRecForArray3', []);
 
1472
  r := AddRecForArrFmtDef('ArgTDynStatPRec1Array[0][3]^', 3, 70, []);
 
1473
  r := AddPointerFmtDef  ('ArgTDynStatPRec1Array[0][4]', '\^TRecForArray3', '^TRecForArray3', []);
 
1474
  r := AddRecForArrFmtDef('ArgTDynStatPRec1Array[0][4]^', 3, 71, []);
 
1475
  r := AddArrayFmtDef('ArgTDynStatPRec1Array[1]', '.', 'TStatArrayPRec1', []);
 
1476
  r := AddPointerFmtDef  ('ArgTDynStatPRec1Array[1][3]', '\^TRecForArray3', '^TRecForArray3', []);
 
1477
  r := AddRecForArrFmtDef('ArgTDynStatPRec1Array[1][3]^', 3, 75, []);
 
1478
  r := AddPointerFmtDef  ('ArgTDynStatPRec1Array[1][4]', '\^TRecForArray3', '^TRecForArray3', []);
 
1479
  r := AddRecForArrFmtDef('ArgTDynStatPRec1Array[1][4]^', 3, 76, []);
 
1480
    //TDynPDynTRec1Array   = array of ^TDynArrayTRec1;
 
1481
  r := AddArrayFmtDef('ArgTDynPDynTRec1Array', '.', 'TDynPDynTRec1Array', []);
 
1482
  r := AddPointerFmtDef  ('ArgTDynPDynTRec1Array[0]', '(\^T|P)DynArrayTRec1', '^(\^T|P)DynArrayTRec1$', [fTpMtch]);
 
1483
  r := AddArrayFmtDef('ArgTDynPDynTRec1Array[0]^', '.', 'TDynArrayTRec1', []);
 
1484
  r := AddRecForArrFmtDef('ArgTDynPDynTRec1Array[0]^[0]', 3, 80, []);
 
1485
  r := AddRecForArrFmtDef('ArgTDynPDynTRec1Array[0]^[1]', 3, 81, []);
 
1486
  r := AddPointerFmtDef  ('ArgTDynPDynTRec1Array[1]', '(\^T|P)DynArrayTRec1', '^(\^T|P)DynArrayTRec1$', [fTpMtch]);
 
1487
  r := AddArrayFmtDef('ArgTDynPDynTRec1Array[1]^', '.', 'TDynArrayTRec1', []);
 
1488
  r := AddRecForArrFmtDef('ArgTDynPDynTRec1Array[1]^[0]', 3, 85, []);
 
1489
  r := AddRecForArrFmtDef('ArgTDynPDynTRec1Array[1]^[1]', 3, 86, []);
 
1490
    //TDynPStatTRec1Array  = array of ^TStatArrayTRec1;
 
1491
  r := AddArrayFmtDef('ArgTDynPStatTRec1Array', '.', 'TDynPStatTRec1Array', []);
 
1492
  r := AddPointerFmtDef  ('ArgTDynPStatTRec1Array[0]', '(\^T|P)StatArrayTRec1', '(\^T|P)StatArrayTRec1$', [fTpMtch]);
 
1493
  r := AddArrayFmtDef('ArgTDynPStatTRec1Array[0]^', '.', 'TStatArrayTRec1', []);
 
1494
  r := AddRecForArrFmtDef('ArgTDynPStatTRec1Array[0]^[3]', 3, 70, []);
 
1495
  r := AddRecForArrFmtDef('ArgTDynPStatTRec1Array[0]^[4]', 3, 71, []);
 
1496
  r := AddPointerFmtDef  ('ArgTDynPStatTRec1Array[1]', '(\^T|P)StatArrayTRec1', '(\^T|P)StatArrayTRec1$', [fTpMtch]);
 
1497
  r := AddArrayFmtDef('ArgTDynPStatTRec1Array[1]^', '.', 'TStatArrayTRec1', []);
 
1498
  r := AddRecForArrFmtDef('ArgTDynPStatTRec1Array[1]^[3]', 3, 75, []);
 
1499
  r := AddRecForArrFmtDef('ArgTDynPStatTRec1Array[1]^[4]', 3, 76, []);
 
1500
    //TDynPDynTRec1NPArray = array of ^TDynArrayTRec1NP;
 
1501
  r := AddArrayFmtDef('ArgTDynPDynTRec1NPArray', '.', 'TDynPDynTRec1NPArray', []);
 
1502
  r := AddPointerFmtDef  ('ArgTDynPDynTRec1NPArray[0]', '\^TDynArrayTRec1NP', '^TDynArrayTRec1NP', []);
 
1503
  r := AddArrayFmtDef('ArgTDynPDynTRec1NPArray[0]^', '.', 'TDynArrayTRec1NP', []);
 
1504
  r := AddRecForArrFmtDef('ArgTDynPDynTRec1NPArray[0]^[0]', 3, 500, []);
 
1505
  r := AddRecForArrFmtDef('ArgTDynPDynTRec1NPArray[0]^[1]', 3, 501, []);
 
1506
  r := AddPointerFmtDef  ('ArgTDynPDynTRec1NPArray[1]', '\^TDynArrayTRec1NP', '^TDynArrayTRec1NP', []);
 
1507
  r := AddArrayFmtDef('ArgTDynPDynTRec1NPArray[1]^', '.', 'TDynArrayTRec1NP', []);
 
1508
  r := AddRecForArrFmtDef('ArgTDynPDynTRec1NPArray[1]^[0]', 3, 505, []);
 
1509
  r := AddRecForArrFmtDef('ArgTDynPDynTRec1NPArray[1]^[1]', 3, 506, []);
 
1510
    //TDynPStatTRec1NPArray= array of ^TStatArrayTRec1NP;
 
1511
  r := AddArrayFmtDef('ArgTDynPStatTRec1NPArray', '.', 'TDynPStatTRec1NPArray', []);
 
1512
  r := AddPointerFmtDef  ('ArgTDynPStatTRec1NPArray[0]', '\^TStatArrayTRec1NP', '^TStatArrayTRec1NP', []);
 
1513
  r := AddArrayFmtDef('ArgTDynPStatTRec1NPArray[0]^', '.', 'TStatArrayTRec1NP', []);
 
1514
  r := AddRecForArrFmtDef('ArgTDynPStatTRec1NPArray[0]^[3]', 3, 510, []);
 
1515
  r := AddRecForArrFmtDef('ArgTDynPStatTRec1NPArray[0]^[4]', 3, 511, []);
 
1516
  r := AddPointerFmtDef  ('ArgTDynPStatTRec1NPArray[1]', '\^TStatArrayTRec1NP', '^TStatArrayTRec1NP', []);
 
1517
  r := AddArrayFmtDef('ArgTDynPStatTRec1NPArray[1]^', '.', 'TStatArrayTRec1NP', []);
 
1518
  r := AddRecForArrFmtDef('ArgTDynPStatTRec1NPArray[1]^[3]', 3, 515, []);
 
1519
  r := AddRecForArrFmtDef('ArgTDynPStatTRec1NPArray[1]^[4]', 3, 516, []);
 
1520
    //
 
1521
    //TDynDynTRec2Array   = array of TDynArrayTRec2;
 
1522
    //TDynDynPrec2Array   = array of TDynArrayPRec2;
 
1523
    //TDynDynPPrec2Array  = array of TDynArrayPPRec2; // double pointer
 
1524
    //TDynStatTRec2Array  = array of TStatArrayTRec2;
 
1525
    //TDynStatPRec2Array  = array of TStatArrayPRec2;
 
1526
    //TDynStatPPRec2Array = array of TStatArrayPPRec2; // double pointer
 
1527
    {%endregion DYN ARRAY of named arrays (norm)}
 
1528
 
 
1529
    {%region DYN ARRAY of named arrays (VAR)}
 
1530
      // dyn arrays of named arrays  (VAR)
 
1531
    //TDynDynTRec1Array   = array of TDynArrayTRec1;
 
1532
  r := AddArrayFmtDef('VArgTDynDynTRec1Array', '.', 'TDynDynTRec1Array', []);
 
1533
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1534
  r := AddArrayFmtDef('VArgTDynDynTRec1Array[0]', '.', 'TDynArrayTRec1', []);
 
1535
  r := AddRecForArrFmtDef('VArgTDynDynTRec1Array[0][0]', 3, 80, []);
 
1536
  r := AddRecForArrFmtDef('VArgTDynDynTRec1Array[0][1]', 3, 81, []);
 
1537
  r := AddArrayFmtDef('VArgTDynDynTRec1Array[1]', '.', 'TDynArrayTRec1', []);
 
1538
  r := AddRecForArrFmtDef('VArgTDynDynTRec1Array[1][0]', 3, 85, []);
 
1539
  r := AddRecForArrFmtDef('VArgTDynDynTRec1Array[1][1]', 3, 86, []);
 
1540
    //TDynDynPRec1Array   = array of TDynArrayPRec1;
 
1541
  r := AddArrayFmtDef('VArgTDynDynPRec1Array', '.', 'TDynDynPRec1Array', []);
 
1542
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1543
  r := AddArrayFmtDef('VArgTDynDynPRec1Array[0]', '.', 'TDynArrayPRec1', []);
 
1544
  r := AddPointerFmtDef  ('VArgTDynDynPRec1Array[0][0]', '\^TRecForArray3', '^TRecForArray3', []);
 
1545
  r := AddRecForArrFmtDef('VArgTDynDynPRec1Array[0][0]^', 3, 80, []);
 
1546
  r := AddPointerFmtDef  ('VArgTDynDynPRec1Array[0][1]', '\^TRecForArray3', '^TRecForArray3', []);
 
1547
  r := AddRecForArrFmtDef('VArgTDynDynPRec1Array[0][1]^', 3, 81, []);
 
1548
  r := AddArrayFmtDef('VArgTDynDynPRec1Array[1]', '.', 'TDynArrayPRec1', []);
 
1549
  r := AddPointerFmtDef  ('VArgTDynDynPRec1Array[1][0]', '\^TRecForArray3', '^TRecForArray3', []);
 
1550
  r := AddRecForArrFmtDef('VArgTDynDynPRec1Array[1][0]^', 3, 85, []);
 
1551
  r := AddPointerFmtDef  ('VArgTDynDynPRec1Array[1][1]', '\^TRecForArray3', '^TRecForArray3', []);
 
1552
  r := AddRecForArrFmtDef('VArgTDynDynPRec1Array[1][1]^', 3, 86, []);
 
1553
    //TDynStatTRec1Array  = array of TStatArrayTRec1;
 
1554
  r := AddArrayFmtDef('VArgTDynStatTRec1Array', '.', 'TDynStatTRec1Array', []);
 
1555
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1556
  r := AddArrayFmtDef('VArgTDynStatTRec1Array[0]', '.', 'TStatArrayTRec1', []);
 
1557
  r := AddRecForArrFmtDef('VArgTDynStatTRec1Array[0][3]', 3, 70, []);
 
1558
  r := AddRecForArrFmtDef('VArgTDynStatTRec1Array[0][4]', 3, 71, []);
 
1559
  r := AddArrayFmtDef('VArgTDynStatTRec1Array[1]', '.', 'TStatArrayTRec1', []);
 
1560
  r := AddRecForArrFmtDef('VArgTDynStatTRec1Array[1][3]', 3, 75, []);
 
1561
  r := AddRecForArrFmtDef('VArgTDynStatTRec1Array[1][4]', 3, 76, []);
 
1562
    //TDynStatPRec1Array  = array of TStatArrayPRec1;
 
1563
  r := AddArrayFmtDef('VArgTDynStatPRec1Array', '.', 'TDynStatPRec1Array', []);
 
1564
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1565
  r := AddArrayFmtDef('VArgTDynStatPRec1Array[0]', '.', 'TStatArrayPRec1', []);
 
1566
  r := AddPointerFmtDef  ('VArgTDynStatPRec1Array[0][3]', '\^TRecForArray3', '^TRecForArray3', []);
 
1567
  r := AddRecForArrFmtDef('VArgTDynStatPRec1Array[0][3]^', 3, 70, []);
 
1568
  r := AddPointerFmtDef  ('VArgTDynStatPRec1Array[0][4]', '\^TRecForArray3', '^TRecForArray3', []);
 
1569
  r := AddRecForArrFmtDef('VArgTDynStatPRec1Array[0][4]^', 3, 71, []);
 
1570
  r := AddArrayFmtDef('VArgTDynStatPRec1Array[1]', '.', 'TStatArrayPRec1', []);
 
1571
  r := AddPointerFmtDef  ('VArgTDynStatPRec1Array[1][3]', '\^TRecForArray3', '^TRecForArray3', []);
 
1572
  r := AddRecForArrFmtDef('VArgTDynStatPRec1Array[1][3]^', 3, 75, []);
 
1573
  r := AddPointerFmtDef  ('VArgTDynStatPRec1Array[1][4]', '\^TRecForArray3', '^TRecForArray3', []);
 
1574
  r := AddRecForArrFmtDef('VArgTDynStatPRec1Array[1][4]^', 3, 76, []);
 
1575
    //TDynPDynTRec1Array   = array of ^TDynArrayTRec1;
 
1576
  r := AddArrayFmtDef('VArgTDynPDynTRec1Array', '.', 'TDynPDynTRec1Array', []);
 
1577
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1578
  r := AddPointerFmtDef  ('VArgTDynPDynTRec1Array[0]', '(\^T|P)DynArrayTRec1', '^(\^T|P)DynArrayTRec1$', [fTpMtch]);
 
1579
  if (DebuggerInfo.Version > 0) and (DebuggerInfo.Version < 070000) then UpdResMinFpc(r, stDwarf2All, 020600);
 
1580
  r := AddArrayFmtDef('VArgTDynPDynTRec1Array[0]^', '.', 'TDynArrayTRec1', []);
 
1581
  r := AddRecForArrFmtDef('VArgTDynPDynTRec1Array[0]^[0]', 3, 80, []);
 
1582
  r := AddRecForArrFmtDef('VArgTDynPDynTRec1Array[0]^[1]', 3, 81, []);
 
1583
  r := AddPointerFmtDef  ('VArgTDynPDynTRec1Array[1]', '(\^T|P)DynArrayTRec1', '^(\^T|P)DynArrayTRec1$', [fTpMtch]);
 
1584
  if (DebuggerInfo.Version > 0) and (DebuggerInfo.Version < 070000) then UpdResMinFpc(r, stDwarf2All, 020600);
 
1585
  r := AddArrayFmtDef('VArgTDynPDynTRec1Array[1]^', '.', 'TDynArrayTRec1', []);
 
1586
  r := AddRecForArrFmtDef('VArgTDynPDynTRec1Array[1]^[0]', 3, 85, []);
 
1587
  r := AddRecForArrFmtDef('VArgTDynPDynTRec1Array[1]^[1]', 3, 86, []);
 
1588
    //TDynPStatTRec1Array  = array of ^TStatArrayTRec1;
 
1589
  r := AddArrayFmtDef('VArgTDynPStatTRec1Array', '.', 'TDynPStatTRec1Array', []);
 
1590
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1591
  r := AddPointerFmtDef  ('VArgTDynPStatTRec1Array[0]', '(\^T|P)StatArrayTRec1', '(\^T|P)StatArrayTRec1$', [fTpMtch]);
 
1592
  r := AddArrayFmtDef('VArgTDynPStatTRec1Array[0]^', '.', 'TStatArrayTRec1', []);
 
1593
  r := AddRecForArrFmtDef('VArgTDynPStatTRec1Array[0]^[3]', 3, 70, []);
 
1594
  r := AddRecForArrFmtDef('VArgTDynPStatTRec1Array[0]^[4]', 3, 71, []);
 
1595
  r := AddPointerFmtDef  ('VArgTDynPStatTRec1Array[1]', '(\^T|P)StatArrayTRec1', '(\^T|P)StatArrayTRec1$', [fTpMtch]);
 
1596
  r := AddArrayFmtDef('VArgTDynPStatTRec1Array[1]^', '.', 'TStatArrayTRec1', []);
 
1597
  r := AddRecForArrFmtDef('VArgTDynPStatTRec1Array[1]^[3]', 3, 75, []);
 
1598
  r := AddRecForArrFmtDef('VArgTDynPStatTRec1Array[1]^[4]', 3, 76, []);
 
1599
    //TDynPDynTRec1NPArray = array of ^TDynArrayTRec1NP;
 
1600
  r := AddArrayFmtDef('VArgTDynPDynTRec1NPArray', '.', 'TDynPDynTRec1NPArray', []);
 
1601
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1602
  r := AddPointerFmtDef  ('VArgTDynPDynTRec1NPArray[0]', '\^TDynArrayTRec1NP', '^TDynArrayTRec1NP', []);
 
1603
  if (DebuggerInfo.Version > 0) and (DebuggerInfo.Version < 070000) then UpdResMinFpc(r, stDwarf2All, 020600);
 
1604
  r := AddArrayFmtDef('VArgTDynPDynTRec1NPArray[0]^', '.', 'TDynArrayTRec1NP', []);
 
1605
  r := AddRecForArrFmtDef('VArgTDynPDynTRec1NPArray[0]^[0]', 3, 500, []);
 
1606
  r := AddRecForArrFmtDef('VArgTDynPDynTRec1NPArray[0]^[1]', 3, 501, []);
 
1607
  r := AddPointerFmtDef  ('VArgTDynPDynTRec1NPArray[1]', '\^TDynArrayTRec1NP', '^TDynArrayTRec1NP', []);
 
1608
  if (DebuggerInfo.Version > 0) and (DebuggerInfo.Version < 070000) then UpdResMinFpc(r, stDwarf2All, 020600);
 
1609
  r := AddArrayFmtDef('VArgTDynPDynTRec1NPArray[1]^', '.', 'TDynArrayTRec1NP', []);
 
1610
  r := AddRecForArrFmtDef('VArgTDynPDynTRec1NPArray[1]^[0]', 3, 505, []);
 
1611
  r := AddRecForArrFmtDef('VArgTDynPDynTRec1NPArray[1]^[1]', 3, 506, []);
 
1612
    //TDynPStatTRec1NPArray= array of ^TStatArrayTRec1NP;
 
1613
  r := AddArrayFmtDef('VArgTDynPStatTRec1NPArray', '.', 'TDynPStatTRec1NPArray', []);
 
1614
     UpdResMinFpc(r, stDwarf2All, 020600);
 
1615
  r := AddPointerFmtDef  ('VArgTDynPStatTRec1NPArray[0]', '\^TStatArrayTRec1NP', '^TStatArrayTRec1NP', []);
 
1616
  r := AddArrayFmtDef('VArgTDynPStatTRec1NPArray[0]^', '.', 'TStatArrayTRec1NP', []);
 
1617
  r := AddRecForArrFmtDef('VArgTDynPStatTRec1NPArray[0]^[3]', 3, 510, []);
 
1618
  r := AddRecForArrFmtDef('VArgTDynPStatTRec1NPArray[0]^[4]', 3, 511, []);
 
1619
  r := AddPointerFmtDef  ('VArgTDynPStatTRec1NPArray[1]', '\^TStatArrayTRec1NP', '^TStatArrayTRec1NP', []);
 
1620
  r := AddArrayFmtDef('VArgTDynPStatTRec1NPArray[1]^', '.', 'TStatArrayTRec1NP', []);
 
1621
  r := AddRecForArrFmtDef('VArgTDynPStatTRec1NPArray[1]^[3]', 3, 515, []);
 
1622
  r := AddRecForArrFmtDef('VArgTDynPStatTRec1NPArray[1]^[4]', 3, 516, []);
 
1623
    //
 
1624
    //TDynDynTRec2Array   = array of TDynArrayTRec2;
 
1625
    //TDynDynPrec2Array   = array of TDynArrayPRec2;
 
1626
    //TDynDynPPrec2Array  = array of TDynArrayPPRec2; // double pointer
 
1627
    //TDynStatTRec2Array  = array of TStatArrayTRec2;
 
1628
    //TDynStatPRec2Array  = array of TStatArrayPRec2;
 
1629
    //TDynStatPPRec2Array = array of TStatArrayPPRec2; // double pointer
 
1630
    {%endregion DYN ARRAY of named arrays (VAR)}
 
1631
  {%endregion DYN ARRAY of named arrays}
 
1632
 
 
1633
 
 
1634
 
 
1635
 
 
1636
  //r := AddArrayFmtDef('Arg', '.', 'T', []);
 
1637
  //r := AddRecForArrFmtDef('Arg [0]', 3, 90, []);
 
1638
 
 
1639
 
 
1640
      // stat arrays of named arrays
 
1641
 
 
1642
  // comma separated index
 
1643
  r := AddRecForArrFmtDef('GlobAStatDynDynArrayTRec2[4][0][1]', 2, 401, []);
 
1644
  r := AddRecForArrFmtDef('GlobAStatDynDynArrayTRec2[4,0][1]', 2, 401, []);
 
1645
  r := AddRecForArrFmtDef('GlobAStatDynDynArrayTRec2[4][0,1]', 2, 401, []);
 
1646
  r := AddRecForArrFmtDef('GlobAStatDynDynArrayTRec2[4,0,1]', 2, 401, []);
 
1647
 
 
1648
end;
 
1649
 
 
1650
procedure TTestWatches.AddExpectBreakFooMixInfo;
 
1651
  procedure AddTC(AVar, ATCast:  string; AExpClass: String = ''; AFlgs: TWatchExpectationFlags = [];
 
1652
                  AIntMember: String = ''; AIntValue: integer = 0);
 
1653
  begin
 
1654
    if AExpClass = '' then AExpClass := ATCast;
 
1655
    If ATCast <> ''
 
1656
    then Add(ATCast+'('+AVar+')', wdfDefault, MatchClass(AExpClass, ''), skClass, AExpClass, AFlgs)
 
1657
    else Add(AVar,                wdfDefault, MatchClass(AExpClass, ''), skClass, AExpClass, AFlgs);
 
1658
    if AIntMember <> '' then
 
1659
      Add(ATCast+'('+AVar+').'+AIntMember,  wdfDefault, IntToStr(AIntValue), skSimple, M_Int, [fTpMtch]);
 
1660
  end;
 
1661
  procedure AddTCN(AVar, ATCast:  string; AExpClass: String = ''; AFlgs: TWatchExpectationFlags = []);
 
1662
  begin
 
1663
    if AExpClass = '' then AExpClass := ATCast;
 
1664
    If ATCast <> ''
 
1665
    then Add(ATCast+'('+AVar+')', wdfDefault, MatchClassNil(AExpClass), skClass, AExpClass, AFlgs)
 
1666
    else Add(AVar,                wdfDefault, MatchClassNil(AExpClass), skClass, AExpClass, AFlgs);
 
1667
  end;
 
1668
begin
 
1669
  if not TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('  TTestWatch.Mix')] then exit;
 
1670
  FCurrentExpArray := @ExpectBreakFoo;
 
1671
 
 
1672
  // Type Casting objects with mixed symbol type
 
1673
  AddTC('VarOTestTCast', '', 'TObject');
 
1674
  AddTC('VarOTestTCast', 'TObject', '');
 
1675
  AddTC('VarOTestTCast', 'TClassTCast', '', [], 'b', 0);
 
1676
  AddTC('VarOTestTCast', 'TClassTCast3', 'TClassTCast(3)?', [fTpMtch], 'b', 0);
 
1677
 
 
1678
  AddTC('VarOTestTCastObj', '', 'TObject');
 
1679
  AddTC('VarOTestTCastObj', 'TObject', '');
 
1680
  AddTC('VarOTestTCastObj', 'TClassTCastObject', '');
 
1681
 
 
1682
  AddTC('VarOTestTCastComp', '', 'TObject');
 
1683
  AddTC('VarOTestTCastComp', 'TObject', '');
 
1684
  AddTC('VarOTestTCastComp', 'TComponent', '');
 
1685
  AddTC('VarOTestTCastComp', 'TClassTCastComponent', '', [], 'b', 0);
 
1686
 
 
1687
  AddTC('VarOTestTCast2', '', 'TObject');
 
1688
  AddTC('VarOTestTCast2', 'TObject', '');
 
1689
  AddTC('VarOTestTCast2', 'TClassTCast', '', [], 'b', 0);
 
1690
  AddTC('VarOTestTCast2', 'TClassTCast2', '', [], 'b', 0);
 
1691
 
 
1692
  AddTC('VarOTestTCastUW1', '', 'TObject');
 
1693
  AddTC('VarOTestTCastUW1', 'TObject', '');
 
1694
  AddTC('VarOTestTCastUW1', 'TClassUW1Base', '');
 
1695
  AddTC('VarOTestTCastUW1', 'TClassTCastUW1', '');
 
1696
 
 
1697
  AddTC('VarOTestTCastUW1Obj', '', 'TObject');
 
1698
  AddTC('VarOTestTCastUW1Obj', 'TObject', '');
 
1699
  AddTC('VarOTestTCastUW1Obj', 'TClassUW1BaseObject', '');
 
1700
  AddTC('VarOTestTCastUW1Obj', 'TClassTCastUW1Object', '');
 
1701
 
 
1702
  AddTC('VarOTestTCastUW1Comp', '', 'TObject');
 
1703
  AddTC('VarOTestTCastUW1Comp', 'TObject', '');
 
1704
  AddTC('VarOTestTCastUW1Comp', 'TComponent', '');
 
1705
  AddTC('VarOTestTCastUW1Comp', 'TClassUW1BaseComponent', '');
 
1706
  AddTC('VarOTestTCastUW1Comp', 'TClassTCastUW1Component', '');
 
1707
 
 
1708
 
 
1709
  AddTC('VarCTestTCastComp', '', 'TComponent');
 
1710
  AddTC('VarCTestTCastComp', 'TObject', '');
 
1711
  AddTC('VarCTestTCastComp', 'TComponent', '');
 
1712
  AddTC('VarCTestTCastComp', 'TClassTCast', '');
 
1713
 
 
1714
  AddTC('VarCTestTCastUW1Comp', '', 'TComponent');
 
1715
  AddTC('VarCTestTCastUW1Comp', 'TObject', '');
 
1716
  AddTC('VarCTestTCastUW1Comp', 'TComponent', '');
 
1717
  AddTC('VarCTestTCastUW1Comp', 'TClassUW1BaseComponent', '');
 
1718
  AddTC('VarCTestTCastUW1Comp', 'TClassTCastUW1Component', '');
 
1719
 
 
1720
 
 
1721
  AddTC('VarTestTCast', '', 'TClassTCast');
 
1722
  AddTC('VarTestTCast', 'TObject', '');
 
1723
  AddTC('VarTestTCast', 'TClassTCast', '');
 
1724
  AddTC('VarTestTCast', 'TClassTCast3', 'TClassTCast(3)?', [fTpMtch]);
 
1725
 
 
1726
  AddTC('VarTestTCastObj', '', 'TClassTCastObject');
 
1727
  AddTC('VarTestTCastObj', 'TObject', '');
 
1728
  AddTC('VarTestTCastObj', 'TClassTCastObject', '');
 
1729
 
 
1730
  AddTC('VarTestTCastComp', '', 'TClassTCastComponent');
 
1731
  AddTC('VarTestTCastComp', 'TObject', '');
 
1732
  AddTC('VarTestTCastComp', 'TComponent', '');
 
1733
  AddTC('VarTestTCastComp', 'TClassTCastComponent', '');
 
1734
 
 
1735
  AddTC('VarTestTCast2', '', 'TClassTCast2');
 
1736
  AddTC('VarTestTCast2', 'TObject', '');
 
1737
  AddTC('VarTestTCast2', 'TClassTCast', '');
 
1738
  AddTC('VarTestTCast2', 'TClassTCast2', '');
 
1739
 
 
1740
  AddTC('VarTestTCast3', '', 'TClassTCast(3)?', [fTpMtch]);
 
1741
  AddTC('VarTestTCast3', 'TObject', '');
 
1742
  AddTC('VarTestTCast3', 'TClassTCast', '');
 
1743
 
 
1744
  AddTC('VarTestTCastUW1', '', 'TClassTCastUW1');
 
1745
  AddTC('VarTestTCastUW1', 'TObject', '');
 
1746
  AddTC('VarTestTCastUW1', 'TClassUW1Base', '');
 
1747
  AddTC('VarTestTCastUW1', 'TClassTCastUW1', '');
 
1748
 
 
1749
  AddTC('VarTestTCastUW1Obj', '', 'TClassTCastUW1Object');
 
1750
  AddTC('VarTestTCastUW1Obj', 'TObject', '');
 
1751
  AddTC('VarTestTCastUW1Obj', 'TClassUW1BaseObject', '');
 
1752
  AddTC('VarTestTCastUW1Obj', 'TClassTCastUW1Object', '');
 
1753
 
 
1754
  AddTC('VarTestTCastUW1Comp', '', 'TClassTCastUW1Component');
 
1755
  AddTC('VarTestTCastUW1Comp', 'TObject', '');
 
1756
  AddTC('VarTestTCastUW1Comp', 'TComponent', '');
 
1757
  AddTC('VarTestTCastUW1Comp', 'TClassUW1BaseComponent', '');
 
1758
  AddTC('VarTestTCastUW1Comp', 'TClassTCastUW1Component', '');
 
1759
 
 
1760
 
 
1761
 
 
1762
  //AddTCN('VarNOTestTCast', '', 'TObject');
 
1763
  //AddTCN('VarNOTestTCast', 'TObject', '');
 
1764
  //AddTCN('VarNOTestTCast', 'TClassTCast', '');
 
1765
  //AddTCN('VarNOTestTCast', 'TClassTCast3', 'TClassTCast(3)?', [fTpMtch]);
 
1766
 
 
1767
 
 
1768
  // MIXED symbol info types
 
1769
  if FDoStatIntArray then
 
1770
  Add('VarStatIntArray',  wdfDefault,     '10,[\s\r\n]+12,[\s\r\n]+14,[\s\r\n]+16,[\s\r\n]+18',
 
1771
                                skSimple,       'TStatIntArray',
 
1772
                                []);
 
1773
end;
 
1774
 
 
1775
procedure TTestWatches.AddExpectBreakFooAndSubFoo;
 
1776
  procedure AddF(AnExpr:  string; AFmt: TWatchDisplayFormat;
 
1777
    AMtch: string; AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags;
 
1778
    AStackFrame: Integer=0);
 
1779
  begin
 
1780
    FCurrentExpArray := @ExpectBreakFoo;
 
1781
    AddTo(ExpectBreakFoo, AnExpr, AFmt, AMtch, AKind, ATpNm, AFlgs, AStackFrame)
 
1782
  end;
 
1783
  procedure AddS(AnExpr:  string; AFmt: TWatchDisplayFormat;
 
1784
    AMtch: string; AKind: TDBGSymbolKind; ATpNm: string; AFlgs: TWatchExpectationFlags;
 
1785
    AStackFrame: Integer=0);
 
1786
  begin
 
1787
    FCurrentExpArray := @ExpectBreakSubFoo;
 
1788
    AddTo(ExpectBreakSubFoo, AnExpr, AFmt, AMtch, AKind, ATpNm, AFlgs, AStackFrame)
 
1789
  end;
 
1790
begin
 
1791
  if not TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('  TTestWatch.Cache')] then exit;
 
1792
//  FCurrentExpArray := @ExpectBreakSubFoo;
 
1793
 
 
1794
  AddS('VarCacheTest1', wdfDefault, MatchRecord('TCacheTest', 'CTVal = 101'),
 
1795
       skRecord, 'TCacheTest',  []);
 
1796
  AddF('VarCacheTest1', wdfDefault, '<TCacheTest(Type)?> = \{.*(<|vptr\$)TObject>?.+CTVal = 201',
 
1797
       skClass, 'TCacheTest(Type)?',  [fTpMtch]);
 
1798
 
 
1799
  AddS('VarCacheTest2', wdfDefault, '102',  skSimple, M_Int,  [fTpMtch], 0);
 
1800
  AddS('VarCacheTest2', wdfDefault, '202',  skSimple, M_Int,  [fTpMtch], 1);
 
1801
end;
 
1802
 
465
1803
procedure TTestWatches.DoDbgOutput(Sender: TObject; const AText: String);
466
1804
begin
467
 
  if DbgLog then
468
 
    DbgMemo.Lines.Add(AText);
 
1805
  inherited DoDbgOutput(Sender, AText);
 
1806
  if FDbgOutPutEnable then
 
1807
    FDbgOutPut := FDbgOutPut + AText;
469
1808
end;
470
1809
 
471
1810
procedure TTestWatches.DebugInteract(dbg: TGDBMIDebugger);
478
1817
  end;
479
1818
end;
480
1819
 
481
 
procedure TTestWatches.TestWatches;
 
1820
procedure TTestWatches.RunTestWatches(NamePreFix: String; TestExeName, ExtraOpts: String;
 
1821
  UsedUnits: array of TUsesDir);
 
1822
 
 
1823
var
 
1824
  dbg: TGDBMIDebugger;
 
1825
  Only: Integer;
 
1826
  OnlyName, OnlyNamePart: String;
482
1827
 
483
1828
  function SkipTest(const Data: TWatchExpectation): Boolean;
484
1829
  begin
485
1830
    Result := True;
486
 
    if (fnoDwrf in Data.Flgs)      and (SymbolType in [stDwarf, stDwarfSet, stDwarf3]) then exit;
487
 
    if (fnoDwrfNoSet in Data.Flgs) and (SymbolType in [stDwarf]) then exit;
488
 
    //if (fnoDwrfSet   in Data.Flgs) and (SymbolType in [stDwarfSet, stDwarf3]) then exit;
489
 
    if (fnoDwrf2 in Data.Flgs)     and (SymbolType in [stDwarf, stDwarfSet]) then exit;
490
 
    if (fnoDwrf3 in Data.Flgs)     and (SymbolType in [stDwarf3]) then exit;
491
 
 
492
 
    if (fnoStabs in Data.Flgs) and (SymbolType = stStabs) then exit;
 
1831
    if Data.Result[SymbolType].Flgs * [fTstSkip, fTstSkipDwarf3] <> [] then exit;
493
1832
    Result := False;
494
1833
  end;
495
1834
 
496
 
  procedure TestWatch(Name: String; AWatch: TTestWatch; Data: TWatchExpectation);
 
1835
  function MatchOnly(const Data: TWatchExpectation; Idx: Integer): Boolean;
 
1836
  begin
 
1837
    Result := True;
 
1838
    if ((Only >=0) and (Only <> Idx)) or
 
1839
       ((OnlyName<>'') and (OnlyName <> Data.TestName)) or
 
1840
       ((OnlyNamePart<>'') and (pos(OnlyNamePart, Data.TestName)<1))
 
1841
    then Result := False;
 
1842
  end;
 
1843
 
 
1844
  procedure TestWatch(Name: String; AWatch: TCurrentWatch; Data: TWatchExpectation; WatchValue: String = '');
497
1845
  const KindName: array [TDBGSymbolKind] of string =
498
1846
     ('skClass', 'skRecord', 'skEnum', 'skSet', 'skProcedure', 'skFunction', 'skSimple', 'skPointer', 'skVariant');
499
1847
  var
500
1848
    rx: TRegExpr;
501
1849
    s: String;
 
1850
    flag, IsValid, HasTpInfo, f2: Boolean;
 
1851
    WV: TWatchValue;
 
1852
    Stack: Integer;
 
1853
    n: String;
 
1854
    DataRes: TWatchExpectationResult;
 
1855
    IgnoreFlags: TWatchExpectationFlags;
 
1856
    IgnoreAll, IgnoreData, IgnoreKind, IgnoreKindPtr, IgnoreTpName: boolean;
 
1857
    IgnoreText: String;
502
1858
  begin
 
1859
    if not TestTrue('Dbg did NOT enter dsError', dbg.State <> dsError) then exit;
503
1860
    rx := nil;
504
 
 
505
 
    Name := Name + ' ' + Data.Exp + ' (' + TWatchDisplayFormatNames[Data.Fmt] + ')';
506
 
    try
507
 
      AWatch.Master.Value; // trigger read
508
 
      AssertTrue  (Name+ ' (HasValue)',   AWatch.HasValue);
509
 
      AssertFalse (Name+ ' (One Value)',  AWatch.HasMultiValue);
510
 
 
511
 
      s := AWatch.Value;
 
1861
    Stack := Data.StackFrame;
 
1862
    DataRes := Data.Result[SymbolType];
 
1863
    IgnoreFlags := DataRes.Flgs * WatchExpFlagMask[SymbolType];
 
1864
    IgnoreAll     := IgnoreFlags * WatchExpFlagSIgnAll <> [];
 
1865
    IgnoreData    := IgnoreFlags * WatchExpFlagSIgnData <> [];
 
1866
    IgnoreKind    := IgnoreFlags * WatchExpFlagSIgnKind <> [];
 
1867
    IgnoreKindPtr := IgnoreFlags * WatchExpFlagSIgnKindPtr <> [];
 
1868
    IgnoreTpName  := IgnoreFlags * WatchExpFlagSIgnTpName <> [];
 
1869
 
 
1870
    // Get Value
 
1871
    n := Data.TestName;
 
1872
    LogToFile('###### ' + n + '######' +LineEnding);
 
1873
    if n = '' then n := Data.Expression + ' (' + TWatchDisplayFormatNames[Data.DspFormat] + ')';
 
1874
    Name := Name + ' ' + n;
 
1875
    flag := AWatch <> nil; // test for typeinfo/kind  // Awatch=nil > direct gdb command
 
1876
    IsValid := True;
 
1877
    HasTpInfo := True;
 
1878
    if flag then begin;
 
1879
      WV := AWatch.Values[1, Stack];// trigger read
 
1880
      s := WV.Value;
 
1881
      IsValid := WV.Validity = ddsValid;
 
1882
      HasTpInfo := IsValid and (WV.TypeInfo <> nil);
 
1883
//      flag := flag and IsValid;
 
1884
    end
 
1885
    else
 
1886
      s := WatchValue;
 
1887
 
 
1888
    if not TestTrue('Dbg did NOT enter dsError', dbg.State <> dsError) then exit;
 
1889
 
 
1890
    // Check Data
 
1891
    f2 := True;
 
1892
    IgnoreText := '';    if IgnoreData then IgnoreText := 'Ignored by flag';
 
1893
    if IsValid then begin
512
1894
      rx := TRegExpr.Create;
513
1895
      rx.ModifierI := true;
514
 
      rx.Expression := Data.Mtch;
515
 
      if Data.Mtch <> ''
516
 
      then AssertTrue(Name + ' Matches "'+Data.Mtch + '", but was "' + s + '"', rx.Exec(s));
517
 
    except
518
 
      on e: Exception do
519
 
        AddTestError(e.Message);
520
 
    end;
521
 
    try
522
 
      if Data.TpNm <> '' then begin;
523
 
        AssertTrue(Name + ' has typeinfo',  AWatch.TypeInfo <> nil);
524
 
        AssertEquals(Name + ' kind',  KindName[Data.Kind], KindName[AWatch.TypeInfo.Kind]);
525
 
        if fTpMtch  in Data.Flgs
526
 
        then begin
527
 
          FreeAndNil(rx);
528
 
          s := AWatch.TypeInfo.TypeName;
529
 
          rx := TRegExpr.Create;
530
 
          rx.ModifierI := true;
531
 
          rx.Expression := Data.TpNm;
532
 
          AssertTrue(Name + ' TypeName matches '+Data.TpNm+' but was '+AWatch.TypeInfo.TypeName,  rx.Exec(s))
533
 
        end
534
 
        else AssertEquals(Name + ' TypeName',  LowerCase(Data.TpNm), LowerCase(AWatch.TypeInfo.TypeName));
535
 
      end;
536
 
    except
537
 
      on e: Exception do
538
 
        AddTestError(e.Message);
539
 
    end;
540
 
    FreeAndNil(rx);
 
1896
      rx.Expression := DataRes.ExpMatch;
 
1897
      if DataRes.ExpMatch <> ''
 
1898
      then f2 := TestTrue(Name + ' Matches "'+DataRes.ExpMatch + '", but was "' + s + '"', rx.Exec(s), DataRes.MinGdb, DataRes.MinFpc, IgnoreText);
 
1899
      FreeAndNil(rx);
 
1900
    end else begin
 
1901
       f2 := TestTrue(Name + ' Matches "'+DataRes.ExpMatch + '", but STATE was <'+dbgs(WV.Validity)+'> Val="'+s+'"', False, DataRes.MinGdb, DataRes.MinFpc, IgnoreText);
 
1902
       //exit; // failed Data, do not list others as potential unexpected success
 
1903
    end;
 
1904
 
 
1905
    if (not f2) and IgnoreAll then exit; // failed Data, do not list others as potential unexpected success
 
1906
 
 
1907
    // TypeInfo checks ?
 
1908
    if (not flag) or (DataRes.ExpTypeName = '') then exit;
 
1909
 
 
1910
    // Check TypeInfo
 
1911
    s:='';
 
1912
    if HasTpInfo then s := KindName[WV.TypeInfo.Kind];
 
1913
    IgnoreText := '';    if IgnoreKind then IgnoreText := 'Ignored by flag';
 
1914
    if IsValid and HasTpInfo then begin
 
1915
      if (not IgnoreKind) and IgnoreKindPtr and (WV.TypeInfo.Kind = skPointer) then IgnoreText := 'Ignored by flag (Kind may be Ptr)';
 
1916
      f2 := TestEquals(Name + ' Kind',  KindName[DataRes.ExpKind], KindName[WV.TypeInfo.Kind], DataRes.MinGdb, DataRes.MinFpc, IgnoreText);
 
1917
    end else begin
 
1918
      f2 := TestTrue(Name + ' Kind is "'+KindName[DataRes.ExpKind]+'", failed: STATE was <'+dbgs(WV.Validity)+'>, HasTypeInfo='+dbgs(HasTpInfo)+' Val="'+s+'"', False, DataRes.MinGdb, DataRes.MinFpc, IgnoreText);
 
1919
    end;
 
1920
 
 
1921
    if (not f2) and IgnoreAll then exit; // failed Data, do not list others as potential unexpected success
 
1922
 
 
1923
    // Check TypeName
 
1924
    IgnoreText := '';    if IgnoreTpName then IgnoreText := 'Ignored by flag';
 
1925
    if IsValid and HasTpInfo then begin
 
1926
      s:='';
 
1927
      if HasTpInfo then s := WV.TypeInfo.TypeName;
 
1928
      if fTpMtch  in DataRes.Flgs
 
1929
      then begin
 
1930
        rx := TRegExpr.Create;
 
1931
        rx.ModifierI := true;
 
1932
        rx.Expression := DataRes.ExpTypeName;
 
1933
        TestTrue(Name + ' TypeName matches '+DataRes.ExpTypeName+' but was '+s,  rx.Exec(s), DataRes.MinGdb, DataRes.MinFpc, IgnoreText);
 
1934
        FreeAndNil(rx);
 
1935
       end
 
1936
       else TestEquals(Name + ' TypeName',  LowerCase(DataRes.ExpTypeName), LowerCase(s), DataRes.MinGdb, DataRes.MinFpc, IgnoreText);
 
1937
    end else begin
 
1938
        TestTrue(Name + ' TypeName matches '+DataRes.ExpTypeName+' but STATE was <'+dbgs(WV.Validity)+'> HasTypeInfo='+dbgs(HasTpInfo)+' Val="'+s+'"',  False, DataRes.MinGdb, DataRes.MinFpc, IgnoreText);
 
1939
    end;
 
1940
 
541
1941
  end;
542
1942
 
543
1943
var
544
 
  TestExeName: string;
545
 
  dbg: TGDBMIDebugger;
546
1944
  i: Integer;
547
 
  WList: Array of TTestWatch;
 
1945
  WList, WListSub, WListArray: Array of TCurrentWatch;
 
1946
 
548
1947
begin
549
 
  ClearTestErrors;
 
1948
  TestBaseName := NamePreFix;
 
1949
  if not HasTestArraysData then exit;
 
1950
  Only := StrToIntDef(TestControlForm.EdOnlyWatch.Text, -1);
 
1951
  OnlyNamePart := '';OnlyName := '';
 
1952
  if Only < 0
 
1953
  then begin
 
1954
    OnlyName := TestControlForm.EdOnlyWatch.Text;
 
1955
    if (OnlyName <> '') and (OnlyName[1]='*') then begin
 
1956
      OnlyNamePart := copy(OnlyName, 2, length(OnlyName));
 
1957
      OnlyName := '';
 
1958
    end;
 
1959
  end;
 
1960
 
 
1961
 
550
1962
  try
551
 
    TestCompile(AppDir + 'WatchesPrg.pas', TestExeName);
 
1963
    TestCompile(AppDir + 'WatchesPrg.pas', TestExeName, UsedUnits, '', ExtraOpts);
552
1964
  except
553
 
    on e: Exception do Fail('Compile error: ' + e.Message);
 
1965
    on e: Exception do begin
 
1966
      TestTrue('Compile error: ' + e.Message, False);
 
1967
      exit;
 
1968
    end;
554
1969
  end;
555
1970
 
556
1971
  try
557
 
    FWatches := TBaseWatches.Create(TBaseWatch);
558
 
    dbg := TGDBMIDebugger.Create(DebuggerInfo.ExeName);
559
 
 
560
 
    if RUN_TEST_ONLY >= 0 then begin
561
 
      dbg.OnDbgOutput  := @DoDbgOutput;
562
 
      DbgLog := False;
563
 
      if DbgForm = nil then begin
564
 
        DbgForm := TForm.Create(Application);
565
 
        DbgMemo := TMemo.Create(DbgForm);
566
 
        DbgMemo.Parent := DbgForm;
567
 
        DbgMemo.Align := alClient;
568
 
        DbgForm.Show;
569
 
      end;
570
 
      DbgMemo.Lines.Add('');
571
 
      DbgMemo.Lines.Add(' *** ' + Parent.TestSuiteName + ' ' + Parent.TestName + ' ' + TestSuiteName+' '+TestName);
572
 
      DbgMemo.Lines.Add('');
573
 
    end;
574
 
 
575
 
    (* Add breakpoints *)
576
 
    //with dbg.BreakPoints.Add('WatchesPrg.pas', 44) do begin
577
 
    //  InitialEnabled := True;
578
 
    //  Enabled := True;
579
 
    //end;
 
1972
    dbg := StartGDB(AppDir, TestExeName);
 
1973
    FWatches := Watches.CurrentWatches;
 
1974
 
580
1975
    with dbg.BreakPoints.Add('WatchesPrg.pas', BREAK_LINE_FOOFUNC) do begin
581
1976
      InitialEnabled := True;
582
1977
      Enabled := True;
583
1978
    end;
 
1979
    with dbg.BreakPoints.Add('WatchesPrg.pas', BREAK_LINE_FOOFUNC_NEST) do begin
 
1980
      InitialEnabled := True;
 
1981
      Enabled := True;
 
1982
    end;
 
1983
    with dbg.BreakPoints.Add('WatchesPrg.pas', BREAK_LINE_FOOFUNC_ARRAY) do begin
 
1984
      InitialEnabled := True;
 
1985
      Enabled := True;
 
1986
    end;
 
1987
 
 
1988
    if dbg.State = dsError then
 
1989
      Fail(' Failed Init');
584
1990
 
585
1991
    (* Create all watches *)
586
 
    SetLength(WList, high(ExpectBrk1NoneNil)+1);
587
 
    if RUN_TEST_ONLY >= 0 then begin
588
 
      i := RUN_TEST_ONLY;
589
 
      WList[i] := TTestWatch.Create(FWatches, dbg.Watches.Add(ExpectBrk1NoneNil[i].Exp));
590
 
      WList[i].DisplayFormat := ExpectBrk1NoneNil[i].Fmt;
591
 
    end
592
 
    else
593
 
      for i := low(ExpectBrk1NoneNil) to high(ExpectBrk1NoneNil) do begin
594
 
        if not SkipTest(ExpectBrk1NoneNil[i]) then begin
595
 
          WList[i] := TTestWatch.Create(FWatches, dbg.Watches.Add(ExpectBrk1NoneNil[i].Exp));
596
 
          WList[i].DisplayFormat := ExpectBrk1NoneNil[i].Fmt;
597
 
        end;
598
 
      end;
599
 
 
 
1992
    SetLength(WList, length(ExpectBreakFoo));
 
1993
    for i := low(ExpectBreakFoo) to high(ExpectBreakFoo) do begin
 
1994
      if not MatchOnly(ExpectBreakFoo[i], i) then continue;
 
1995
      if not SkipTest(ExpectBreakFoo[i]) then begin
 
1996
        WList[i] := TCurrentWatch.Create(FWatches);
 
1997
        WList[i].Expression := ExpectBreakFoo[i].Expression;
 
1998
        WList[i].DisplayFormat := ExpectBreakFoo[i].DspFormat;
 
1999
        WList[i].enabled := True;
 
2000
      end;
 
2001
    end;
 
2002
 
 
2003
    SetLength(WListSub, length(ExpectBreakSubFoo));
 
2004
    for i := low(ExpectBreakSubFoo) to high(ExpectBreakSubFoo) do begin
 
2005
      if not MatchOnly(ExpectBreakSubFoo[i], i) then continue;
 
2006
      if not SkipTest(ExpectBreakSubFoo[i]) then begin
 
2007
        WListSub[i] := TCurrentWatch.Create(FWatches);
 
2008
        WListSub[i].Expression := ExpectBreakSubFoo[i].Expression;
 
2009
        WListSub[i].DisplayFormat := ExpectBreakSubFoo[i].DspFormat;
 
2010
        WListSub[i].enabled := True;
 
2011
      end;
 
2012
    end;
 
2013
 
 
2014
    SetLength(WListArray, length(ExpectBreakFooArray));
 
2015
    for i := low(ExpectBreakFooArray) to high(ExpectBreakFooArray) do begin
 
2016
      if not MatchOnly(ExpectBreakFooArray[i], i) then continue;
 
2017
      if not SkipTest(ExpectBreakFooArray[i]) then begin
 
2018
        WListArray[i] := TCurrentWatch.Create(FWatches);
 
2019
        WListArray[i].Expression := ExpectBreakFooArray[i].Expression;
 
2020
        WListArray[i].DisplayFormat := ExpectBreakFooArray[i].DspFormat;
 
2021
        WListArray[i].enabled := True;
 
2022
      end;
 
2023
    end;
600
2024
 
601
2025
    (* Start debugging *)
602
 
    dbg.Init;
603
 
    if dbg.State = dsError then
604
 
      Fail(' Failed Init');
605
 
 
606
 
    dbg.WorkingDir := AppDir;
607
 
    dbg.FileName   := TestExeName;
608
 
    dbg.Arguments := '';
609
2026
    dbg.ShowConsole := True;
610
 
 
611
 
    dbg.Run;
612
 
 
613
 
    (* Hit first breakpoint: Test *)
614
 
    if RUN_TEST_ONLY >= 0 then begin
615
 
      i := RUN_TEST_ONLY;
616
 
      TestWatch('Brk1 ', WList[i], ExpectBrk1NoneNil[i]);
617
 
    end
618
 
    else
619
 
      for i := low(ExpectBrk1NoneNil) to high(ExpectBrk1NoneNil) do begin
620
 
        if not SkipTest(ExpectBrk1NoneNil[i]) then
621
 
          TestWatch('Brk1 '+IntToStr(i)+' ', WList[i], ExpectBrk1NoneNil[i]);
622
 
      end;
623
 
 
624
 
    dbg.Run;
625
 
 
 
2027
    dbg.Run;
 
2028
 
 
2029
    if TestTrue('State=Pause', dbg.State = dsPause)
 
2030
    then begin
 
2031
      (* Hit first breakpoint: BREAK_LINE_FOOFUNC_NEST SubFoo -- (1st loop) Called with none nil data *)
 
2032
 
 
2033
      for i := low(ExpectBreakSubFoo) to high(ExpectBreakSubFoo) do begin
 
2034
        if not MatchOnly(ExpectBreakSubFoo[i], i) then continue;
 
2035
        if not SkipTest(ExpectBreakSubFoo[i]) then
 
2036
          TestWatch('Brk1 '+IntToStr(i)+' ', WListSub[i], ExpectBreakSubFoo[i]);
 
2037
      end;
 
2038
 
 
2039
      dbg.Run;
 
2040
    end
 
2041
    else TestTrue('Hit BREAK_LINE_FOOFUNC_NEST', False);
 
2042
 
 
2043
    if TestTrue('State=Pause', dbg.State = dsPause)
 
2044
    then begin
 
2045
      (* Hit 2nd breakpoint: BREAK_LINE_FOOFUNC Foo -- (1st loop) Called with none nil data *)
 
2046
 
 
2047
      FDbgOutPutEnable := True;
 
2048
      for i := low(ExpectBreakFooGdb) to high(ExpectBreakFooGdb) do begin
 
2049
        if not MatchOnly(ExpectBreakFooGdb[i], i) then continue;
 
2050
        if not SkipTest(ExpectBreakFooGdb[i]) then begin
 
2051
          FDbgOutPut := '';
 
2052
          dbg.TestCmd(ExpectBreakFooGdb[i].Expression);
 
2053
          TestWatch('Brk1 Direct Gdb '+IntToStr(i)+' ', nil, ExpectBreakFooGdb[i], FDbgOutPut);
 
2054
        end;
 
2055
      end;
 
2056
      FDbgOutPutEnable := False;
 
2057
 
 
2058
      for i := low(ExpectBreakFoo) to high(ExpectBreakFoo) do begin
 
2059
        if not MatchOnly(ExpectBreakFoo[i], i) then continue;
 
2060
        if not SkipTest(ExpectBreakFoo[i]) then
 
2061
          TestWatch('Brk1 '+IntToStr(i)+' ', WList[i], ExpectBreakFoo[i]);
 
2062
      end;
 
2063
 
 
2064
      dbg.Run;
 
2065
    end
 
2066
    else TestTrue('Hit BREAK_LINE_FOOFUNC', False);
 
2067
 
 
2068
    if TestTrue('State=Pause', dbg.State = dsPause)
 
2069
    then begin
 
2070
      (* Hit 2nd breakpoint: BREAK_LINE_FOOFUNC_ARRAY SubFoo_Watches -- (1st loop) Called with none nil data *)
 
2071
 
 
2072
      for i := low(ExpectBreakFooArray) to high(ExpectBreakFooArray) do begin
 
2073
        if not MatchOnly(ExpectBreakFooArray[i], i) then continue;
 
2074
        if not SkipTest(ExpectBreakFooArray[i]) then
 
2075
          TestWatch('Brk1 '+IntToStr(i)+' ', WListArray[i], ExpectBreakFooArray[i]);
 
2076
      end;
 
2077
 
 
2078
      dbg.Run;
 
2079
    end
 
2080
    else TestTrue('Hit BREAK_LINE_FOOFUNC_ARRAY', False);
 
2081
 
 
2082
 
 
2083
    // TODO: 2nd round, with NIL data
626
2084
        //DebugInteract(dbg);
627
2085
 
628
2086
    dbg.Stop;
629
 
  finally
630
 
    dbg.Free;
631
 
    FreeAndNil(FWatches);
632
 
 
633
 
    if (DbgMemo <> nil) and (TestErrors <> '') then DbgMemo.Lines.Add(TestErrors);
634
 
    //debugln(FailText)
635
 
    AssertTestErrors;
636
 
  end;
 
2087
  except
 
2088
    on e: Exception do begin
 
2089
      TestTrue('Error: ' + e.Message, False);
 
2090
      exit;
 
2091
    end;
 
2092
  end;
 
2093
  dbg.Done;
 
2094
  CleanGdb;
 
2095
  dbg.Free;
 
2096
end;
 
2097
 
 
2098
procedure TTestWatches.TestWatches;
 
2099
var
 
2100
  TestExeName: string;
 
2101
  UsedUnits: TUsesDir;
 
2102
begin
 
2103
  if SkipTest then exit;
 
2104
  if not TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('TTestWatch')] then exit;
 
2105
 
 
2106
  FDoStatIntArray := TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('  TTestWatch.Unstable')];
 
2107
  // GDB 7.0 with fpc 2.4.x has issues with "array of int"
 
2108
  FDoStatIntArray := FDoStatIntArray and
 
2109
                     not ((pos('2.4.', CompilerInfo.Name) > 0) and (DebuggerInfo.Version = 70000));
 
2110
 
 
2111
  ClearTestErrors;
 
2112
 
 
2113
  ClearAllTestArrays;
 
2114
  AddExpectBreakFooGdb;
 
2115
  AddExpectBreakFooAll;
 
2116
  AddExpectBreakFooArray;
 
2117
  //AddExpectBreakFooMixInfo;
 
2118
  AddExpectBreakFooAndSubFoo;
 
2119
  RunTestWatches('', TestExeName,  '', []);
 
2120
 
 
2121
  if TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('  TTestWatch.Mix')]
 
2122
  then begin
 
2123
 
 
2124
    ClearAllTestArrays;
 
2125
    AddExpectBreakFooMixInfo;
 
2126
    with UsedUnits do begin
 
2127
      DirName:= AppDir + 'u1' + DirectorySeparator + 'unitw1.pas';
 
2128
      ExeId:= '';
 
2129
      SymbolType:= stNone;
 
2130
      ExtraOpts:= '';
 
2131
      NamePostFix:= ''
 
2132
    end;
 
2133
    RunTestWatches('unitw1=none', TestExeName,  '-dUSE_W1', [UsedUnits]);
 
2134
 
 
2135
    if TestControlForm.CheckListBox1.Checked[TestControlForm.CheckListBox1.Items.IndexOf('    TTestWatch.Mix.All')]
 
2136
    then begin
 
2137
      if (stStabs in CompilerInfo.SymbolTypes) and (stStabs in DebuggerInfo.SymbolTypes)
 
2138
      then begin
 
2139
        ClearAllTestArrays;
 
2140
        AddExpectBreakFooMixInfo;
 
2141
        with UsedUnits do begin
 
2142
          DirName:= AppDir + 'u1' + DirectorySeparator + 'unitw1.pas';
 
2143
          ExeId:= '';
 
2144
          SymbolType:= stStabs;
 
2145
          ExtraOpts:= '';
 
2146
          NamePostFix:= ''
 
2147
        end;
 
2148
        RunTestWatches('unitw1=stabs', TestExeName,  '-dUSE_W1', [UsedUnits]);
 
2149
      end;
 
2150
 
 
2151
      if (stDwarf in CompilerInfo.SymbolTypes) and (stDwarf in DebuggerInfo.SymbolTypes)
 
2152
      then begin
 
2153
        ClearAllTestArrays;
 
2154
        AddExpectBreakFooMixInfo;
 
2155
        with UsedUnits do begin
 
2156
          DirName:= AppDir + 'u1' + DirectorySeparator + 'unitw1.pas';
 
2157
          ExeId:= '';
 
2158
          SymbolType:= stDwarf;
 
2159
          ExtraOpts:= '';
 
2160
          NamePostFix:= ''
 
2161
        end;
 
2162
        RunTestWatches('unitw1=dwarf', TestExeName,  '-dUSE_W1', [UsedUnits]);
 
2163
      end;
 
2164
 
 
2165
      if (stDwarf3 in CompilerInfo.SymbolTypes) and (stDwarf3 in DebuggerInfo.SymbolTypes)
 
2166
      then begin
 
2167
        ClearAllTestArrays;
 
2168
        AddExpectBreakFooMixInfo;
 
2169
        with UsedUnits do begin
 
2170
          DirName:= AppDir + 'u1' + DirectorySeparator + 'unitw1.pas';
 
2171
          ExeId:= '';
 
2172
          SymbolType:= stDwarf3;
 
2173
          ExtraOpts:= '';
 
2174
          NamePostFix:= ''
 
2175
        end;
 
2176
        RunTestWatches('unitw1=dwarf_3', TestExeName,  '-dUSE_W1', [UsedUnits]);
 
2177
      end;
 
2178
    end;
 
2179
 
 
2180
  end;
 
2181
 
 
2182
  AssertTestErrors;
637
2183
end;
638
2184
 
639
2185