Debugger: more moving value-converters to LazDebuggerIntf.

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);

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,
+  FpDbgDwarfDataClasses, FpWatchResultData, LazDebuggerIntf,
-  Classes, sysutils, LazClasses,
+  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;

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;
+    //FValConvList: TFpDbgConverterConfigList;
-    FValConfig: TFpDbgConverterConfig;
+    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 ValConvList: TFpDbgConverterConfigList read FValConvList write FValConvList;
-    property ValConfig: TFpDbgConverterConfig read FValConfig write FValConfig;
+    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

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)
+  { TFpDbgValueConvertSelectorIntfHelper }
-  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 = 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;
+  Result := //(AValue.Kind in (MatchKinds * GetConverter.GetSupportedKinds)) and
-  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
             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.
 

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,
+  LazDebuggerIntfBaseTypes, LazDebuggerValueConverter, DbgIntfDebuggerBase,
-  FpPascalParser, FpDbgCommon, Forms, IdeDebuggerBase, IdeDebuggerWatchResult;
+  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 := TIdeDbgValueConvertSelector.Create(TFpDbgValueConverterVariantToLStr.Create);
-    obj.MatchKinds := [skRecord];
+    //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;

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;

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.');

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

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;

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;

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;

ide/packages/idedebugger/idedebuggerfpdbgvalueconv.pas

@@ -5,63 +5,137 @@ unit IdeDebuggerFpDbgValueConv;
 interface
 
 uses
-  Classes, SysUtils, Laz2_XMLCfg, FpDebugValueConvertors,
+  Classes, SysUtils, fgl, Laz2_XMLCfg, LazClasses, lazCollections,
-  LazDebuggerValueConverter;
+  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;
+    function Count: Integer;
-    procedure PutIdeItems(Index: Integer; AValue: TIdeFpDbgConverterConfig);
+    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);
+procedure TIdeDbgValueConvertSelector.SetConverter(AValue: TFpDbgValueConverter);
-var
-  Src: TIdeFpDbgConverterConfig absolute ASource;
 begin
-  inherited Assign(ASource);
+  if FConverter = AValue then Exit;
-  if ASource is TIdeFpDbgConverterConfig then begin
+  FConverter.ReleaseReference;
-    FName := Src.FName;
+  FConverter := AValue;
-    FEnabled := Src.FEnabled;
+  if FConverter <> nil then
-  end;
+    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
+function TIdeDbgValueConvertSelectorList.Count: Integer;
-  ): TIdeFpDbgConverterConfig;
 begin
-  Result := TIdeFpDbgConverterConfig(Items[Index]);
+  Result := inherited Count;
-  assert(Result is TIdeFpDbgConverterConfig, 'TIdeFpDbgConverterConfigList.GetIdeItems: Result is TIdeFpDbgConverterConfig');
 end;
 
-procedure TIdeFpDbgConverterConfigList.PutIdeItems(Index: Integer;
+function TIdeDbgValueConvertSelectorList.Get(Index: Integer
-  AValue: TIdeFpDbgConverterConfig);
+  ): 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(
+constructor TIdeDbgValueConvertSelectorList.Create;
-  ADest: TFpDbgConverterConfigList);
+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
+function TIdeDbgValueConvertSelectorList.IdeItemByName(AName: String
-  ): TIdeFpDbgConverterConfig;
+  ): 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.
 

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;

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;