Debugger: more moving value-converters to LazDebuggerIntf.

2025-04-09 08:29:06 +02:00 · 2022-08-23 02:17:12 +02:00 · 2022-08-23 02:17:12 +02:00 · d98c10ac7d
commit d98c10ac7d
parent 99b40ac097
14 changed files with 257 additions and 246 deletions
--- a/components/lazdebuggers/lazdebuggerfp/fpdebugconvdebugforjson.pas
+++ b/components/lazdebuggers/lazdebuggerfp/fpdebugconvdebugforjson.pas
@ -46,7 +46,6 @@ type
    procedure Init; override;
  public
    class function GetName: String; override;
-    class function GetSupportedKinds: TDbgSymbolKinds; override;
    procedure Assign(ASource: TFpDbgValueConverter); override;
    function ConvertValue(ASourceValue: TFpValue;
                          AnFpDebugger: TFpDebugDebuggerBase;
@ -185,11 +184,6 @@ begin
  Result := drsCallJsonForDebug;
 end;

-class function TFpDbgValueConverterJsonForDebug.GetSupportedKinds: TDbgSymbolKinds;
-begin
-  Result := [low(Result)..high(Result)];
-end;
-
 procedure TFpDbgValueConverterJsonForDebug.Assign(ASource: TFpDbgValueConverter);
 begin
  inherited Assign(ASource);
--- a/components/lazdebuggers/lazdebuggerfp/fpdebugdebuggerworkthreads.pas
+++ b/components/lazdebuggers/lazdebuggerfp/fpdebugdebuggerworkthreads.pas
@ -49,8 +49,8 @@ uses
  DbgIntfBaseTypes, FpDbgClasses, FpDbgUtil, FPDbgController, FpPascalBuilder,
  FpdMemoryTools, FpDbgInfo, FpPascalParser, FpErrorMessages,
  FpDebugDebuggerBase, FpDebuggerResultData, FpDbgCallContextInfo, FpDbgDwarf,
-  FpDbgDwarfDataClasses, FpWatchResultData, LazDebuggerIntf, Forms, fgl, math,
-  Classes, sysutils, LazClasses,
+  FpDbgDwarfDataClasses, FpWatchResultData, LazDebuggerIntf,
+  LazDebuggerValueConverter, Forms, fgl, math, Classes, sysutils, LazClasses,
  {$ifdef FORCE_LAZLOGGER_DUMMY} LazLoggerDummy {$else} LazLoggerBase {$endif};

 type
@ -1179,9 +1179,9 @@ begin
      WatchResConv.FirstIndexOffs := FWatchValue.FirstIndexOffs;
      if not (defSkipValConv in AnEvalFlags) then begin
        if (FWatchValue.GetFpDbgConverter <> nil) and
-           (FWatchValue.GetFpDbgConverter.GetBackendSpecificObject is TFpDbgConverterConfig)
+           (FWatchValue.GetFpDbgConverter.GetConverter.GetObject is TFpDbgValueConverter)
        then
-          WatchResConv.ValConfig := TFpDbgConverterConfig(FWatchValue.GetFpDbgConverter.GetBackendSpecificObject)
+          WatchResConv.ValConfig := FWatchValue.GetFpDbgConverter
        else
          WatchResConv.ValConvList := ValueConverterConfigList;
        WatchResConv.Debugger := FDebugger;
--- a/components/lazdebuggers/lazdebuggerfp/fpdebuggerresultdata.pas
+++ b/components/lazdebuggers/lazdebuggerfp/fpdebuggerresultdata.pas
@ -7,7 +7,7 @@ interface
 uses
  Classes, SysUtils, FpWatchResultData, FpDbgInfo, FpdMemoryTools,
  FpErrorMessages, DbgIntfBaseTypes, LazClasses, FpDebugValueConvertors,
-  FpDebugDebuggerBase, LazDebuggerIntf;
+  FpDebugDebuggerBase, LazDebuggerIntf, LazDebuggerValueConverter;

 type

@ -17,8 +17,9 @@ type
  private
    FDebugger: TFpDebugDebuggerBase;
    FExpressionScope: TFpDbgSymbolScope;
-    FValConvList: TFpDbgConverterConfigList;
-    FValConfig: TFpDbgConverterConfig;
+    //FValConvList: TFpDbgConverterConfigList;
+    FValConvList: TLazDbgValueConvertSelectorListIntf;
+    FValConfig: TLazDbgValueConvertSelectorIntf;

    FExtraDephtLevelIsArray: Boolean; // defExtraDepth / RecurseCnt=-1
    FExtraDephtLevelItemConv: TFpDbgValueConverter;
@ -36,8 +37,9 @@ type

    function DoValueToResData(AnFpValue: TFpValue;
      AnResData: TLzDbgWatchDataIntf): Boolean; override;
-    property ValConvList: TFpDbgConverterConfigList read FValConvList write FValConvList;
-    property ValConfig: TFpDbgConverterConfig read FValConfig write FValConfig;
+    //property ValConvList: TFpDbgConverterConfigList read FValConvList write FValConvList;
+    property ValConvList: TLazDbgValueConvertSelectorListIntf read FValConvList write FValConvList;
+    property ValConfig: TLazDbgValueConvertSelectorIntf read FValConfig write FValConfig;
    property Debugger: TFpDebugDebuggerBase read FDebugger write FDebugger;
    property ExpressionScope: TFpDbgSymbolScope read FExpressionScope write FExpressionScope;
    property MaxArrayConv: Integer read FMaxArrayConv write SetMaxArrayConv;
@ -61,7 +63,7 @@ begin

  if (ValConfig <> nil) then begin
    if ValConfig.CheckMatch(AnFpValue) then
-      Result := ValConfig.Converter;
+      Result := ValConfig.GetConverter.GetObject as TFpDbgValueConverter;
    if Result <> nil then
      Result.AddReference;
  end
@ -73,7 +75,7 @@ begin
      while (i >= 0) and (not ValConvList[i].CheckMatch(AnFpValue)) do
        dec(i);
      if i >= 0 then
-        Result := ValConvList[i].Converter;
+        Result := ValConvList[i].GetConverter.GetObject as TFpDbgValueConverter;
      if Result <> nil then
        Result.AddReference;
    finally
--- a/components/lazdebuggers/lazdebuggerfp/fpdebugvalueconvertors.pas
+++ b/components/lazdebuggers/lazdebuggerfp/fpdebugvalueconvertors.pas
@ -1,18 +1,17 @@
 unit FpDebugValueConvertors;

 {$mode objfpc}{$H+}
+{$ModeSwitch typehelpers}

 interface

 uses
-  Classes, SysUtils, fgl, FpDbgInfo, FpdMemoryTools, FpDbgCallContextInfo,
+  Classes, SysUtils, FpDbgInfo, FpdMemoryTools, FpDbgCallContextInfo,
  FpPascalBuilder, FpErrorMessages, FpDbgClasses, FpDbgUtil, DbgIntfBaseTypes,
-  lazCollections, LazClasses, LCLProc, StrUtils, FpDebugDebuggerBase, FpDebugStringConstants,
+  LazClasses, LCLProc, StrUtils, FpDebugDebuggerBase, FpDebugStringConstants,
  LazDebuggerValueConverter, LazDebuggerIntfBaseTypes;

 type
-  TDbgSymbolKinds = set of TDbgSymbolKind;
-
  (* TFpDbgValueConverter and descendants
     - A TFpDbgValueConverter should be immutable, once in the list.
       To change settings a new instance can be set to TFpDbgConverterConfig
@ -29,7 +28,6 @@ type
    procedure Init; virtual;
  public
    class function GetName: String; virtual; abstract;
-    class function GetSupportedKinds: TDbgSymbolKinds; virtual;
    constructor Create; virtual;
    procedure Assign(ASource: TFpDbgValueConverter); virtual;
    function CreateCopy: TFpDbgValueConverter; virtual;
@ -42,43 +40,12 @@ type
  end;
  TFpDbgValueConverterClass = class of TFpDbgValueConverter;

-  { TFpDbgConverterConfig }

-  TFpDbgConverterConfig = class(TFreeNotifyingObject, TLazDbgValueConvertSelectorIntf)
-  private
-    FConverter: TFpDbgValueConverter;
-    FMatchKinds: TDbgSymbolKinds;
-    FMatchTypeNames: TStrings;
-    procedure SetConverter(AValue: TFpDbgValueConverter);
-  protected
-    function GetBackendSpecificObject: TObject; deprecated;
-    function GetConverter: TLazDbgValueConverterIntf;
-  public
-    constructor Create(AConverter: TFpDbgValueConverter);
-    destructor Destroy; override;
-    function CreateCopy: TFpDbgConverterConfig; virtual;
-    procedure Assign(ASource: TFpDbgConverterConfig); virtual;
+  { TFpDbgValueConvertSelectorIntfHelper }

+  TFpDbgValueConvertSelectorIntfHelper = type helper for TLazDbgValueConvertSelectorIntf
    function CheckMatch(AValue: TFpValue): Boolean;
    function CheckTypeMatch(AValue: TFpValue): Boolean;
-    property Converter: TFpDbgValueConverter read FConverter write SetConverter;
-
-    property MatchKinds: TDbgSymbolKinds read FMatchKinds write FMatchKinds;
-    property MatchTypeNames: TStrings read FMatchTypeNames;
-  end;
-  TFpDbgConverterConfigClass = class of TFpDbgConverterConfig;
-
-  { TFpDbgConverterConfigList }
-
-  TFpDbgConverterConfigList = class(specialize TFPGObjectList<TFpDbgConverterConfig>)
-  private
-    FLock: TLazMonitor;
-  public
-    constructor Create;
-    destructor Destroy; override;
-    procedure Assign(ASource: TFpDbgConverterConfigList);
-    procedure Lock;
-    procedure Unlock;
  end;

  { TFpDbgValueConverterRegistryEntry }
@ -98,26 +65,14 @@ type
    function GetProcAddrFromMgr(AnFpDebugger: TFpDebugDebuggerBase; AnExpressionScope: TFpDbgSymbolScope): TDbgPtr;
  public
    class function GetName: String; override;
-    class function GetSupportedKinds: TDbgSymbolKinds; override;
    function ConvertValue(ASourceValue: TFpValue;
                          AnFpDebugger: TFpDebugDebuggerBase;
                          AnExpressionScope: TFpDbgSymbolScope
                         ): TFpValue; override;
  end;

-function ValueConverterConfigList: TFpDbgConverterConfigList;

 implementation
-var
-  TheValueConverterList: TFpDbgConverterConfigList = nil;
-
-
-function ValueConverterConfigList: TFpDbgConverterConfigList;
-begin
-  if TheValueConverterList = nil then
-    TheValueConverterList := TFpDbgConverterConfigList.Create;
-  Result := TheValueConverterList;
-end;

 { TFpDbgValueConverter }

@ -147,11 +102,6 @@ begin
  //
 end;

-class function TFpDbgValueConverter.GetSupportedKinds: TDbgSymbolKinds;
-begin
-  Result := [low(TDbgSymbolKinds)..high(TDbgSymbolKinds)];
-end;
-
 constructor TFpDbgValueConverter.Create;
 begin
  inherited Create;
@ -163,63 +113,17 @@ begin
  //
 end;

-{ TFpDbgConverterConfig }
+{ TFpDbgValueConvertSelectorIntfHelper }

-procedure TFpDbgConverterConfig.SetConverter(AValue: TFpDbgValueConverter);
+function TFpDbgValueConvertSelectorIntfHelper.CheckMatch(AValue: TFpValue
+  ): Boolean;
 begin
-  if FConverter = AValue then Exit;
-  FConverter.ReleaseReference;
-  FConverter := AValue;
-  if FConverter <> nil then
-    FConverter.AddReference;
-end;
-
-function TFpDbgConverterConfig.GetBackendSpecificObject: TObject;
-begin
-  Result := Self;
-end;
-
-function TFpDbgConverterConfig.GetConverter: TLazDbgValueConverterIntf;
-begin
-  Result := FConverter;
-end;
-
-function TFpDbgConverterConfig.CreateCopy: TFpDbgConverterConfig;
-begin
-  Result := TFpDbgConverterConfigClass(ClassType).Create(nil);
-  Result.Assign(Self);
-end;
-
-constructor TFpDbgConverterConfig.Create(AConverter: TFpDbgValueConverter);
-begin
-  inherited Create;
-  Converter := AConverter;
-  FMatchTypeNames := TStringList.Create;
-  TStringList(FMatchTypeNames).CaseSensitive := False;
-  TStringList(FMatchTypeNames).Sorted := True;
-end;
-
-destructor TFpDbgConverterConfig.Destroy;
-begin
-  inherited Destroy;
-  FMatchTypeNames.Free;
-  FConverter.ReleaseReference;
-end;
-
-procedure TFpDbgConverterConfig.Assign(ASource: TFpDbgConverterConfig);
-begin
-  FMatchKinds := ASource.FMatchKinds;
-  FMatchTypeNames.Assign(ASource.FMatchTypeNames);
-  Converter := ASource.FConverter.CreateCopy;
-end;
-
-function TFpDbgConverterConfig.CheckMatch(AValue: TFpValue): Boolean;
-begin
-  Result := (AValue.Kind in (FMatchKinds * Converter.GetSupportedKinds)) and
+  Result := //(AValue.Kind in (MatchKinds * GetConverter.GetSupportedKinds)) and
            CheckTypeMatch(AValue);
 end;

-function TFpDbgConverterConfig.CheckTypeMatch(AValue: TFpValue): Boolean;
+function TFpDbgValueConvertSelectorIntfHelper.CheckTypeMatch(AValue: TFpValue
+  ): Boolean;
  function MatchPattern(const AName, APattern: String): Boolean;
  var
    NamePos, PatternPos, p: Integer;
@ -265,6 +169,7 @@ var
  TpName, Pattern, ValClassName, ValUnitName: String;
  t: TFpSymbol;
  HasMaybeUnitDot: Boolean;
+  MatchTypeNames: TStrings;
 begin
  t := AValue.TypeInfo;
  Result := (t <> nil) and GetTypeName(TpName, t, [tnfNoSubstitute]);
@ -272,10 +177,11 @@ begin
    exit;

  TpName := LowerCase(TpName);
-  i := FMatchTypeNames.Count;
+  MatchTypeNames := AllowedTypeNames;
+  i := MatchTypeNames.Count;
  while i > 0 do begin
    dec(i);
-    Pattern := LowerCase(trim(FMatchTypeNames[i]));
+    Pattern := LowerCase(trim(MatchTypeNames[i]));

    HasMaybeUnitDot := (pos('.', Pattern) > 1) and
                       (AValue.Kind in [skClass]); // only class supports unitnames (via rtti)
@ -338,40 +244,6 @@ begin
  end;
 end;

-{ TFpDbgConverterConfigList }
-
-constructor TFpDbgConverterConfigList.Create;
-begin
-  inherited Create(True);
-  FLock := TLazMonitor.create;
-end;
-
-destructor TFpDbgConverterConfigList.Destroy;
-begin
-  inherited Destroy;
-  FLock.Free;
-end;
-
-procedure TFpDbgConverterConfigList.Assign(ASource: TFpDbgConverterConfigList);
-var
-  i: Integer;
-begin
-  Clear;
-  Count := ASource.Count;
-  for i := 0 to Count - 1 do
-    Items[i] := ASource[i].CreateCopy;
-end;
-
-procedure TFpDbgConverterConfigList.Lock;
-begin
-  FLock.Acquire;
-end;
-
-procedure TFpDbgConverterConfigList.Unlock;
-begin
-  FLock.Leave;
-end;
-
 { TFpDbgValueConverterRegistryEntry }

 class function TFpDbgValueConverterRegistryEntry.CreateValueConvertorIntf: TLazDbgValueConverterIntf;
@ -443,11 +315,6 @@ begin
  Result := drsCallSysVarToLStr;
 end;

-class function TFpDbgValueConverterVariantToLStr.GetSupportedKinds: TDbgSymbolKinds;
-begin
-  Result := [skRecord];
-end;
-
 function TFpDbgValueConverterVariantToLStr.ConvertValue(ASourceValue: TFpValue;
  AnFpDebugger: TFpDebugDebuggerBase; AnExpressionScope: TFpDbgSymbolScope
  ): TFpValue;
@ -587,8 +454,5 @@ end;
 initialization
  ValueConverterRegistry.Add(TFpDbgValueConverterVariantToLStrRegistryEntry);

-finalization;
-  FreeAndNil(TheValueConverterList);
-
 end.

--- a/components/lazdebuggers/lazdebuggerfp/test/testwatches.pas
+++ b/components/lazdebuggers/lazdebuggerfp/test/testwatches.pas
@ -8,8 +8,9 @@ uses
  Classes, SysUtils, fpcunit, testregistry, TestBase, FpDebugValueConvertors,
  FpDebugDebugger, TestDbgControl, TestDbgTestSuites, TestOutputLogger,
  TTestWatchUtilities, TestCommonSources, TestDbgConfig, LazDebuggerIntf,
-  LazDebuggerIntfBaseTypes, DbgIntfDebuggerBase, DbgIntfBaseTypes, FpDbgInfo,
-  FpPascalParser, FpDbgCommon, Forms, IdeDebuggerBase, IdeDebuggerWatchResult;
+  LazDebuggerIntfBaseTypes, LazDebuggerValueConverter, DbgIntfDebuggerBase,
+  DbgIntfBaseTypes, FpDbgInfo, FpPascalParser, FpDbgCommon, Forms,
+  IdeDebuggerBase, IdeDebuggerWatchResult, IdeDebuggerFpDbgValueConv;

 type

@ -2066,7 +2067,8 @@ var
  t: TWatchExpectationList;
  Src: TCommonSource;
  BrkPrg: TDBGBreakPoint;
-  obj: TFpDbgConverterConfig;
+  ValueConverterSelectorList: TIdeDbgValueConvertSelectorList;
+  obj: TIdeDbgValueConvertSelector;
  i, c: Integer;
 begin
  if SkipTest then exit;
@ -2078,6 +2080,8 @@ begin

  AssertTrue('Start debugger', Debugger.StartDebugger(AppDir, ExeName));

+  ValueConverterSelectorList := TIdeDbgValueConvertSelectorList.Create;
+  ValueConverterConfigList := ValueConverterSelectorList;
  try
    t := TWatchExpectationList.Create(Self);
    t.AcceptSkSimple := [skInteger, skCardinal, skBoolean, skChar, skFloat,
@ -2096,10 +2100,10 @@ begin

    RunToPause(BrkPrg);

-    obj := TFpDbgConverterConfig.Create(TFpDbgValueConverterVariantToLStr.Create);
-    obj.MatchKinds := [skRecord];
+    obj := TIdeDbgValueConvertSelector.Create(TFpDbgValueConverterVariantToLStr.Create);
+    //obj.MatchKinds := [skRecord];
    obj.MatchTypeNames.Add('variant');
-    ValueConverterConfigList.Add(obj);
+    ValueConverterSelectorList.Add(obj);

    t.Clear;
    t.Add('variant1 to lstr', 'variant1',    weAnsiStr('102'));
@ -2142,7 +2146,8 @@ begin


  finally
-    ValueConverterConfigList.Clear;
+    ValueConverterConfigList := nil;
+    FreeAndNil(ValueConverterSelectorList);

    Debugger.RunToNextPause(dcStop);
    t.Free;
--- a/components/lazdebuggers/lazdebuggerintf/lazdebuggervalueconverter.pas
+++ b/components/lazdebuggers/lazdebuggerintf/lazdebuggervalueconverter.pas
@ -31,6 +31,23 @@ type
    procedure RemoveFreeNotification(ANotification: TNotifyEvent);
    function GetConverter: TLazDbgValueConverterIntf;
    function GetBackendSpecificObject: TObject; deprecated;
+
+    function AllowedTypeNames: TStrings;
+  end;
+
+  { TLazDbgValueConvertSelectorListIntf }
+
+  TLazDbgValueConvertSelectorListIntf = interface
+    function Count: Integer;
+    function Get(Index: Integer): TLazDbgValueConvertSelectorIntf;
+    property Items[Index: Integer]: TLazDbgValueConvertSelectorIntf read Get; default;
+
+    procedure Lock;
+    procedure Unlock;
+
+    //function CreateCopy: TLazDbgValueConvertSelectorListIntf;
+    //procedure Assign(ASource: TLazDbgValueConvertSelectorListIntf);
+    //procedure Free;
  end;

  { TLazDbgValueConvertRegistryEntry }
@ -53,6 +70,9 @@ type

 function ValueConverterRegistry: TLazDbgValueConvertRegistry;

+var
+  ValueConverterConfigList: TLazDbgValueConvertSelectorListIntf;
+
 implementation
 var
  TheValueConverterRegistry: TLazDbgValueConvertRegistry;
--- a/ide/main.pp
+++ b/ide/main.pp
@ -103,7 +103,7 @@ uses
  LazDebuggerGdbmi, GDBMIDebugger, RunParamsOpts, BaseDebugManager,
  DebugManager, debugger, DebuggerDlg, DebugAttachDialog, DebuggerStrConst,
  DbgIntfDebuggerBase, LazDebuggerIntf, LazDebuggerIntfBaseTypes,
-  idedebuggerpackage, FpDebugValueConvertors,
+  idedebuggerpackage, FpDebugValueConvertors, IdeDebuggerFpDbgValueConv,
  // packager
  PackageSystem, PkgManager, BasePkgManager, LPKCache,
  // source editing
@ -1390,11 +1390,11 @@ begin
  DebuggerOptions.PrimaryConfigPath := GetPrimaryConfigPath;
  DebuggerOptions.CreateConfig;
  DebuggerOptions.Load;
-  ValueConverterConfigList.Lock;
+  ValueConverterSelectorList.Lock;
  try
-    DebuggerOptions.FpDbgConverterConfig.AssignEnabledTo(ValueConverterConfigList);
+    DebuggerOptions.FpDbgConverterConfig.AssignEnabledTo(ValueConverterSelectorList);
  finally
-    ValueConverterConfigList.Unlock;
+    ValueConverterSelectorList.Unlock;
  end;

  Assert(InputHistories = nil, 'TMainIDE.LoadGlobalOptions: InputHistories is already assigned.');
--- a/ide/packages/idedebugger/debugger.pp
+++ b/ide/packages/idedebugger/debugger.pp
@ -754,7 +754,7 @@ type
    FCurrentBackEndExpression: String;
    FUpdateCount: Integer;
    FEvents: array [TWatcheEvaluateEvent] of TMethodList;
-    FFpDbgConverter: TIdeFpDbgConverterConfig;
+    FFpDbgConverter: TIdeDbgValueConvertSelector;

  (* TWatchValueIntf *)
    procedure BeginUpdate;
@ -4044,7 +4044,7 @@ procedure TCurrentWatchValue.RequestData;
 begin
  FreeAndNil(FFpDbgConverter);
  if Watch.FpDbgConverter <> nil then
-    FFpDbgConverter := TIdeFpDbgConverterConfig(Watch.FpDbgConverter.CreateCopy);
+    FFpDbgConverter := TIdeDbgValueConvertSelector(Watch.FpDbgConverter.CreateCopy);

  if (Watch.ParentWatch <> nil) and (Watch.ParentWatch.FpDbgConverter = Watch.FpDbgConverter) then
    if MaybeCopyResult(Watch.ParentWatch) then
--- a/ide/packages/idedebugger/frames/idedebugger_fpvalconv_options.pas
+++ b/ide/packages/idedebugger/frames/idedebugger_fpvalconv_options.pas
@ -17,7 +17,7 @@ type
  TIdeDbgFpValConvOptionsFrame = class(TAbstractIDEOptionsEditor)
    FpDbgValConvFrame1: TFpDbgValConvFrame;
  private
-    FValConvList: TIdeFpDbgConverterConfigList;
+    FValConvList: TIdeDbgValueConvertSelectorList;
  public
    destructor Destroy; override;
    function GetTitle: String; override;
@ -62,7 +62,7 @@ procedure TIdeDbgFpValConvOptionsFrame.ReadSettings(
  AOptions: TAbstractIDEOptions);
 begin
  if FValConvList = nil then
-    FValConvList := TIdeFpDbgConverterConfigList.Create;
+    FValConvList := TIdeDbgValueConvertSelectorList.Create;
  FValConvList.Assign(DebuggerOptions.FpDbgConverterConfig);
  FValConvList.Changed := False;
  FpDbgValConvFrame1.ValConvList := FValConvList;
@ -76,11 +76,11 @@ begin
    DebuggerOptions.FpDbgConverterConfig.Assign(FValConvList);
    DebuggerOptions.FpDbgConverterConfig.Changed := True;

-    ValueConverterConfigList.Lock;
+    ValueConverterSelectorList.Lock;
    try
-      DebuggerOptions.FpDbgConverterConfig.AssignEnabledTo(ValueConverterConfigList);
+      DebuggerOptions.FpDbgConverterConfig.AssignEnabledTo(ValueConverterSelectorList);
    finally
-      ValueConverterConfigList.Unlock;
+      ValueConverterSelectorList.Unlock;
    end;
  end;
 end;
--- a/ide/packages/idedebugger/frames/watchinspecttoolbar.pas
+++ b/ide/packages/idedebugger/frames/watchinspecttoolbar.pas
@ -641,7 +641,7 @@ end;
 procedure TWatchInspectNav.InitWatch(AWatch: TIdeWatch);
 var
  Opts: TWatcheEvaluateFlags;
-  Conv: TIdeFpDbgConverterConfig;
+  Conv: TIdeDbgValueConvertSelector;
 begin
  Opts := AWatch.EvaluateFlags;
  if btnUseInstance.Down then
@ -769,7 +769,7 @@ var
  tid, idx: Integer;
  stack: TIdeCallStack;
  expr: String;
-  Conv: TIdeFpDbgConverterConfig;
+  Conv: TIdeDbgValueConvertSelector;
 begin
  if FUpdateCount > 0 then begin
    FExecAfterUpdate := True;
--- a/ide/packages/idedebugger/idedebuggerbase.pas
+++ b/ide/packages/idedebugger/idedebuggerbase.pas
@ -114,7 +114,7 @@ type
  TWatch = class(TDelayedUdateItem)
  private
    FFirstIndexOffs: Int64;
-    FFpDbgConverter: TIdeFpDbgConverterConfig;
+    FFpDbgConverter: TIdeDbgValueConvertSelector;

    procedure FFpDbgConverterFreed(Sender: TObject);
    procedure SetDisplayFormat(AValue: TWatchDisplayFormat);
@ -122,7 +122,7 @@ type
    procedure SetEvaluateFlags(AValue: TWatcheEvaluateFlags);
    procedure SetExpression(AValue: String);
    procedure SetFirstIndexOffs(AValue: Int64);
-    procedure SetFpDbgConverter(AValue: TIdeFpDbgConverterConfig);
+    procedure SetFpDbgConverter(AValue: TIdeDbgValueConvertSelector);
    procedure SetRepeatCount(AValue: Integer);
    function GetValue(const AThreadId: Integer; const AStackFrame: Integer): TWatchValue;
  protected
@ -154,7 +154,7 @@ type
    property EvaluateFlags: TWatcheEvaluateFlags read FEvaluateFlags write SetEvaluateFlags;
    property FirstIndexOffs: Int64 read FFirstIndexOffs write SetFirstIndexOffs;
    property RepeatCount: Integer read FRepeatCount write SetRepeatCount;
-    property FpDbgConverter: TIdeFpDbgConverterConfig read FFpDbgConverter write SetFpDbgConverter;
+    property FpDbgConverter: TIdeDbgValueConvertSelector read FFpDbgConverter write SetFpDbgConverter;
    property Values[const AThreadId: Integer; const AStackFrame: Integer]: TWatchValue
             read GetValue;
    property ValueList: TWatchValueList read FValueList;
@ -501,7 +501,7 @@ begin
  DoModified;
 end;

-procedure TWatch.SetFpDbgConverter(AValue: TIdeFpDbgConverterConfig);
+procedure TWatch.SetFpDbgConverter(AValue: TIdeDbgValueConvertSelector);
 begin
  if FFpDbgConverter = AValue then Exit;
  FValueList.Clear;
--- a/ide/packages/idedebugger/idedebuggerfpdbgvalueconv.pas
+++ b/ide/packages/idedebugger/idedebuggerfpdbgvalueconv.pas
@ -5,63 +5,137 @@ unit IdeDebuggerFpDbgValueConv;
 interface

 uses
-  Classes, SysUtils, Laz2_XMLCfg, FpDebugValueConvertors,
-  LazDebuggerValueConverter;
+  Classes, SysUtils, fgl, Laz2_XMLCfg, LazClasses, lazCollections,
+  FpDebugValueConvertors, LazDebuggerValueConverter;

 type

-  { TIdeFpDbgConverterConfig }
+  { TIdeDbgValueConvertSelector }

-  TIdeFpDbgConverterConfig = class(TFpDbgConverterConfig)
+  TIdeDbgValueConvertSelector = class(TFreeNotifyingObject, TLazDbgValueConvertSelectorIntf)
  private
+    FConverter: TFpDbgValueConverter;
+    FMatchTypeNames: TStrings;
    FEnabled: Boolean;
    FName: String;
+
+    procedure SetConverter(AValue: TFpDbgValueConverter);
+  protected
+    function GetBackendSpecificObject: TObject; deprecated;
+    function GetConverter: TLazDbgValueConverterIntf;
+
+    function AllowedTypeNames: TStrings;
  public
-    procedure Assign(ASource: TFpDbgConverterConfig); override;
+    constructor Create(AConverter: TFpDbgValueConverter);
+    destructor Destroy; override;
+
+    function CreateCopy: TIdeDbgValueConvertSelector;
+    procedure Assign(ASource: TIdeDbgValueConvertSelector);
    procedure LoadDataFromXMLConfig(const AConfig: TRttiXMLConfig; const APath: string);
    procedure SaveDataToXMLConfig(const AConfig: TRttiXMLConfig; const APath: string);
  published
+    property Converter: TFpDbgValueConverter read FConverter write SetConverter;
    property Enabled: Boolean read FEnabled write FEnabled;
    property Name: String read FName write FName;
-    property MatchKinds;
+    property MatchTypeNames: TStrings read FMatchTypeNames;
  end;
+  TIdeDbgValueConvertSelectorClass = class of TIdeDbgValueConvertSelector;

-  { TIdeFpDbgConverterConfigList }
+  { TIdeDbgValueConvertSelectorList }

-  TIdeFpDbgConverterConfigList = class(TFpDbgConverterConfigList)
+  TIdeDbgValueConvertSelectorList = class(
+    specialize TFPGObjectList<TIdeDbgValueConvertSelector>,
+    TLazDbgValueConvertSelectorListIntf
+  )
  private
+    FLock: TLazMonitor;
    FChanged: Boolean;
-    function GetIdeItems(Index: Integer): TIdeFpDbgConverterConfig;
-    procedure PutIdeItems(Index: Integer; AValue: TIdeFpDbgConverterConfig);
+    function Count: Integer;
+    function Get(Index: Integer): TLazDbgValueConvertSelectorIntf;
+    function GetIdeItems(Index: Integer): TIdeDbgValueConvertSelector;
+    procedure PutIdeItems(Index: Integer; AValue: TIdeDbgValueConvertSelector);
  public
-    procedure AssignEnabledTo(ADest: TFpDbgConverterConfigList);
+    constructor Create;
+    destructor Destroy; override;
+    procedure Assign(ASource: TIdeDbgValueConvertSelectorList);
+
+    procedure Lock;
+    procedure Unlock;
+
+    procedure AssignEnabledTo(ADest: TIdeDbgValueConvertSelectorList);

    procedure LoadDataFromXMLConfig(const AConfig: TRttiXMLConfig; const APath: string);
    procedure SaveDataToXMLConfig(const AConfig: TRttiXMLConfig; const APath: string);

-    function IdeItemByName(AName: String): TIdeFpDbgConverterConfig;
+    function IdeItemByName(AName: String): TIdeDbgValueConvertSelector;

-    property IdeItems[Index: Integer]: TIdeFpDbgConverterConfig read GetIdeItems write PutIdeItems; default;
+    property IdeItems[Index: Integer]: TIdeDbgValueConvertSelector read GetIdeItems write PutIdeItems; default;
    property Changed: Boolean read FChanged write FChanged;
  end;

+var
+  ValueConverterSelectorList: TIdeDbgValueConvertSelectorList;

 implementation

-{ TIdeFpDbgConverterConfig }
+{ TIdeDbgValueConvertSelector }

-procedure TIdeFpDbgConverterConfig.Assign(ASource: TFpDbgConverterConfig);
-var
-  Src: TIdeFpDbgConverterConfig absolute ASource;
+procedure TIdeDbgValueConvertSelector.SetConverter(AValue: TFpDbgValueConverter);
 begin
-  inherited Assign(ASource);
-  if ASource is TIdeFpDbgConverterConfig then begin
-    FName := Src.FName;
-    FEnabled := Src.FEnabled;
-  end;
+  if FConverter = AValue then Exit;
+  FConverter.ReleaseReference;
+  FConverter := AValue;
+  if FConverter <> nil then
+    FConverter.AddReference;
 end;

-procedure TIdeFpDbgConverterConfig.LoadDataFromXMLConfig(
+function TIdeDbgValueConvertSelector.GetBackendSpecificObject: TObject;
+begin
+  Result := Self;
+end;
+
+function TIdeDbgValueConvertSelector.GetConverter: TLazDbgValueConverterIntf;
+begin
+  Result := FConverter;
+end;
+
+function TIdeDbgValueConvertSelector.AllowedTypeNames: TStrings;
+begin
+  Result := FMatchTypeNames;
+end;
+
+constructor TIdeDbgValueConvertSelector.Create(AConverter: TFpDbgValueConverter);
+begin
+  inherited Create;
+  Converter := AConverter;
+  FMatchTypeNames := TStringList.Create;
+  TStringList(FMatchTypeNames).CaseSensitive := False;
+  TStringList(FMatchTypeNames).Sorted := True;
+end;
+
+destructor TIdeDbgValueConvertSelector.Destroy;
+begin
+  inherited Destroy;
+  FMatchTypeNames.Free;
+  FConverter.ReleaseReference;
+end;
+
+function TIdeDbgValueConvertSelector.CreateCopy: TIdeDbgValueConvertSelector;
+begin
+  Result := TIdeDbgValueConvertSelectorClass(ClassType).Create(nil);
+  Result.Assign(Self);
+end;
+
+procedure TIdeDbgValueConvertSelector.Assign(ASource: TIdeDbgValueConvertSelector);
+begin
+
+  Converter := ASource.FConverter.CreateCopy;
+  FMatchTypeNames.Assign(ASource.FMatchTypeNames);
+  FName     := ASource.FName;
+  FEnabled  := ASource.FEnabled;
+end;
+
+procedure TIdeDbgValueConvertSelector.LoadDataFromXMLConfig(
  const AConfig: TRttiXMLConfig; const APath: string);
 var
  s: String;
@ -81,7 +155,7 @@ begin
  Converter := obj;
 end;

-procedure TIdeFpDbgConverterConfig.SaveDataToXMLConfig(
+procedure TIdeDbgValueConvertSelector.SaveDataToXMLConfig(
  const AConfig: TRttiXMLConfig; const APath: string);
 begin
  AConfig.WriteObject(APath + 'Filter/', Self);
@ -91,23 +165,67 @@ begin
  AConfig.WriteObject(APath + 'Conv/', Converter);
 end;

-{ TIdeFpDbgConverterConfigList }
+{ TIdeDbgValueConvertSelectorList }

-function TIdeFpDbgConverterConfigList.GetIdeItems(Index: Integer
-  ): TIdeFpDbgConverterConfig;
+function TIdeDbgValueConvertSelectorList.Count: Integer;
 begin
-  Result := TIdeFpDbgConverterConfig(Items[Index]);
-  assert(Result is TIdeFpDbgConverterConfig, 'TIdeFpDbgConverterConfigList.GetIdeItems: Result is TIdeFpDbgConverterConfig');
+  Result := inherited Count;
 end;

-procedure TIdeFpDbgConverterConfigList.PutIdeItems(Index: Integer;
-  AValue: TIdeFpDbgConverterConfig);
+function TIdeDbgValueConvertSelectorList.Get(Index: Integer
+  ): TLazDbgValueConvertSelectorIntf;
+begin
+  Result := Items[Index];
+end;
+
+function TIdeDbgValueConvertSelectorList.GetIdeItems(Index: Integer
+  ): TIdeDbgValueConvertSelector;
+begin
+  Result := TIdeDbgValueConvertSelector(Items[Index]);
+  assert(Result is TIdeDbgValueConvertSelector, 'TIdeDbgValueConvertSelectorList.GetIdeItems: Result is TIdeDbgValueConvertSelector');
+end;
+
+procedure TIdeDbgValueConvertSelectorList.PutIdeItems(Index: Integer;
+  AValue: TIdeDbgValueConvertSelector);
 begin
  Items[Index] := AValue;
 end;

-procedure TIdeFpDbgConverterConfigList.AssignEnabledTo(
-  ADest: TFpDbgConverterConfigList);
+constructor TIdeDbgValueConvertSelectorList.Create;
+begin
+  inherited Create(True);
+  FLock := TLazMonitor.create;
+end;
+
+destructor TIdeDbgValueConvertSelectorList.Destroy;
+begin
+  inherited Destroy;
+  FLock.Free;
+end;
+
+procedure TIdeDbgValueConvertSelectorList.Assign(
+  ASource: TIdeDbgValueConvertSelectorList);
+var
+  i: Integer;
+begin
+  Clear;
+  inherited Count := ASource.Count;
+  for i := 0 to Count - 1 do
+    Items[i] := ASource[i].CreateCopy;
+end;
+
+procedure TIdeDbgValueConvertSelectorList.Lock;
+begin
+  FLock.Acquire;
+end;
+
+procedure TIdeDbgValueConvertSelectorList.Unlock;
+begin
+  FLock.Leave;
+end;
+
+procedure TIdeDbgValueConvertSelectorList.AssignEnabledTo(
+  ADest: TIdeDbgValueConvertSelectorList);
 var
  i: Integer;
 begin
@ -117,16 +235,16 @@ begin
      ADest.Add(Items[i].CreateCopy);
 end;

-procedure TIdeFpDbgConverterConfigList.LoadDataFromXMLConfig(
+procedure TIdeDbgValueConvertSelectorList.LoadDataFromXMLConfig(
  const AConfig: TRttiXMLConfig; const APath: string);
 var
  i, c: Integer;
-  obj: TIdeFpDbgConverterConfig;
+  obj: TIdeDbgValueConvertSelector;
 begin
  clear;
  c := AConfig.GetChildCount(APath);
  for i := 0 to c - 1 do begin
-    obj := TIdeFpDbgConverterConfig.Create(nil);
+    obj := TIdeDbgValueConvertSelector.Create(nil);
    obj.LoadDataFromXMLConfig(AConfig, APath + 'Entry[' + IntToStr(i+1) + ']/');
    if obj.Converter <> nil then
      Add(obj)
@ -135,7 +253,7 @@ begin
  end
 end;

-procedure TIdeFpDbgConverterConfigList.SaveDataToXMLConfig(
+procedure TIdeDbgValueConvertSelectorList.SaveDataToXMLConfig(
  const AConfig: TRttiXMLConfig; const APath: string);
 var
  i: Integer;
@ -145,8 +263,8 @@ begin
    IdeItems[i].SaveDataToXMLConfig(AConfig, APath + 'Entry[' + IntToStr(i+1) + ']/');
 end;

-function TIdeFpDbgConverterConfigList.IdeItemByName(AName: String
-  ): TIdeFpDbgConverterConfig;
+function TIdeDbgValueConvertSelectorList.IdeItemByName(AName: String
+  ): TIdeDbgValueConvertSelector;
 var
  i: Integer;
 begin
@ -158,5 +276,13 @@ begin
    Result := IdeItems[i];
 end;

+initialization
+  ValueConverterSelectorList := TIdeDbgValueConvertSelectorList.Create;
+  ValueConverterConfigList := ValueConverterSelectorList;
+
+finalization
+  ValueConverterConfigList := nil;
+  FreeAndNil(ValueConverterSelectorList);
+
 end.

--- a/ide/packages/idedebugger/idedebuggeropts.pas
+++ b/ide/packages/idedebugger/idedebuggeropts.pas
@ -15,7 +15,7 @@ type
  TDebuggerOptions = class(TAbstractIDEEnvironmentOptions)
  private
    FFilename: string;
-    FFpDbgConverterConfig: TIdeFpDbgConverterConfigList;
+    FFpDbgConverterConfig: TIdeDbgValueConvertSelectorList;
    FPrimaryConfigPath: String;
    FXMLCfg: TRttiXMLConfig;
  protected
@ -34,7 +34,7 @@ type
    property Filename: string read FFilename;
    property PrimaryConfigPath: String read FPrimaryConfigPath write FPrimaryConfigPath;

-    property FpDbgConverterConfig: TIdeFpDbgConverterConfigList read FFpDbgConverterConfig write FFpDbgConverterConfig;
+    property FpDbgConverterConfig: TIdeDbgValueConvertSelectorList read FFpDbgConverterConfig write FFpDbgConverterConfig;
  end;

 function GetDebuggerOptions: TDebuggerOptions;
@ -79,7 +79,7 @@ end;
 constructor TDebuggerOptions.Create;
 begin
  inherited Create;
-  FpDbgConverterConfig := TIdeFpDbgConverterConfigList.Create;
+  FpDbgConverterConfig := TIdeDbgValueConvertSelectorList.Create;
 end;

 destructor TDebuggerOptions.Destroy;
--- a/ide/packages/idedebugger/idefpdbgvalueconvertersettingsframe.pas
+++ b/ide/packages/idedebugger/idefpdbgvalueconvertersettingsframe.pas
@ -39,25 +39,25 @@ type
    procedure Splitter1CanOffset(Sender: TObject; var NewOffset: Integer;
      var Accept: Boolean);
  private
-    FValConvList: TIdeFpDbgConverterConfigList;
+    FValConvList: TIdeDbgValueConvertSelectorList;
    FCurIdx: Integer;
-    FCurConvConf: TIdeFpDbgConverterConfig;
+    FCurConvConf: TIdeDbgValueConvertSelector;
    FCurConv: TLazDbgValueConverterIntf;
    FCurConvSettings: TLazDbgValueConverterSettingsFrameIntf;

-    procedure SetCurConv(AValConv: TIdeFpDbgConverterConfig);
+    procedure SetCurConv(AValConv: TIdeDbgValueConvertSelector);
    procedure UpdateConvForClass;
    procedure UpdateConvPanel;
    procedure FillList;
    procedure UpdateButtons;
-    procedure SetValConvList(AValue: TIdeFpDbgConverterConfigList);
+    procedure SetValConvList(AValue: TIdeDbgValueConvertSelectorList);
  public
    constructor Create(TheOwner: TComponent); override;
    destructor Destroy; override;
    procedure SaveCurrent;
    procedure Setup;

-    property ValConvList: TIdeFpDbgConverterConfigList read FValConvList write SetValConvList;
+    property ValConvList: TIdeDbgValueConvertSelectorList read FValConvList write SetValConvList;
  end;

 implementation
@ -70,7 +70,7 @@ procedure TFpDbgValConvFrame.btnAddClick(Sender: TObject);
 var
  AvailClass: TLazDbgValueConvertRegistry;
  AName: String;
-  obj: TIdeFpDbgConverterConfig;
+  obj: TIdeDbgValueConvertSelector;
 begin
  AName := InputBox(dlgIdeDbgNewItem, dlgIdeDbgEnterName, '');
  if AName = '' then
@ -80,10 +80,10 @@ begin

  FCurConvConf := nil;
  AvailClass := ValueConverterRegistry;
-  obj := TIdeFpDbgConverterConfig.Create(AvailClass[0].CreateValueConvertorIntf.GetObject as TFpDbgValueConverter);
+  obj := TIdeDbgValueConvertSelector.Create(AvailClass[0].CreateValueConvertorIntf.GetObject as TFpDbgValueConverter);
  obj.Enabled := True;
  obj.Name := AName;
-  obj.MatchKinds := obj.Converter.GetSupportedKinds;
+//  obj.MatchKinds := obj.Converter.GetSupportedKinds;
  FValConvList.Add(obj);

  FillList;
@ -163,7 +163,7 @@ begin

 end;

-procedure TFpDbgValConvFrame.SetCurConv(AValConv: TIdeFpDbgConverterConfig);
+procedure TFpDbgValConvFrame.SetCurConv(AValConv: TIdeDbgValueConvertSelector);
 begin
  FCurConvConf := AValConv;
  FCurConv := TLazDbgValueConvertSelectorIntf(FCurConvConf).GetConverter;
@ -203,7 +203,7 @@ end;
 procedure TFpDbgValConvFrame.FillList;
 var
  i: Integer;
-  obj: TIdeFpDbgConverterConfig;
+  obj: TIdeDbgValueConvertSelector;
 begin
  FCurConvConf := nil;

@ -222,7 +222,7 @@ begin
  pnlCurrentConv.Enabled := FCurConvConf <> nil;
 end;

-procedure TFpDbgValConvFrame.SetValConvList(AValue: TIdeFpDbgConverterConfigList);
+procedure TFpDbgValConvFrame.SetValConvList(AValue: TIdeDbgValueConvertSelectorList);
 begin
  if FValConvList = AValue then Exit;
  FValConvList := AValue;
@ -252,7 +252,7 @@ begin
  then begin
    FValConvList.Changed := True;
    FCurConvConf.Converter := TFpDbgValueConverter(FCurConv.GetObject);
-    FCurConvConf.MatchKinds := FCurConvConf.Converter.GetSupportedKinds;
+//    FCurConvConf.MatchKinds := FCurConvConf.Converter.GetSupportedKinds;
    FCurConvConf.MatchTypeNames.Text := memoTypeNames.Text;
    FCurConvConf.Name := EdName.Text
  end;