Methodenaufruf umbiegen?

[Neutral General]

Hi,

Ich komme einfach direkt zum Punkt:

Delphi-Quellcode:

TTest = class
  function GetTest: String;
  function GetTest2: String;
end;

Ist es möglich einen Aufruf von GetTest auf GetTest2 umzubiegen?

[Medium]

Mit ein wenig Umweg:

Delphi-Quellcode:

type
  TMyFunc = function: String of object;

  TMyClass
  private
    function FFunc1: String;
    function FFunc2: String;
  public
    GetText: TMyFunc;
    GetText2: TMyFunc;
  end;

implementation

constructor TMyClass(...)
begin
  GetText := FFunc1;
  GetText2 := FFunc2;
end;

Und die Zuweisungen kannst du zur Runtime beliebig umherwürfeln. Ich bin mir grad nur unsicher, ob die Syntax für TMyFunc so geht, bislang hatte ich irgendwie immer nur procedure of object genutzt :)

[Neutral General]

Hi,

Ich habs wohl zu allgemein ausgedrückt..

Auf die Struktur der Klasse habe ich letztendlich keinen Einfluss. Genauer gesagt habe ich soetwas:

Delphi-Quellcode:

TBeispiel = class
private
  FText: String;
  function GetText: String;
public
  property Text: String read GetText;
end;

Diese Klasse ist jetzt auch fest. Daran darf im Code nichts geändert werden.

Was ich jetzt per RTTI rausfinden kann sind die Properties.
Ich hab den Namen der Property und die Pointer zu der jeweiligen Getter und Setter Methode.

Was ich jetzt prinzipiell will ist GetText zu "hooken".

So in der Art:

Delphi-Quellcode:

function GetTextHook(Self: TBeispiel): String;
begin
  Result := Self.GetText + '_Hooked!';
end;

HookProperty(TBeispiel,'Test',mkGetter,@GetTextHook);

[Medium]

Wie wäre es mit einer Ableitung der Klasse, die alles wie ihr Vorfahr durchreicht, aber die Property überdeckt und auf decorator-artige Weise erweitert? (Ich weiss nur grad nicht so 100%ig ob sich Properties überhaupt verdecken lassen...)

[Apollonius]

Wenn du das hooken willst, musst du das ganz klassisch machen, also einen Jump bzw. Call an den Anfang des Methodencodes schreiben.

[himitsu]

Zitat:

Zitat von Apollonius

Wenn du das hooken willst, musst du das ganz klassisch machen, also einen Jump bzw. Call an den Anfang des Methodencodes schreiben.

Wenn er aber den Anfang überschreibt, dann wird es hiermit schwerer

Code:

result := [color=#ff0000]Self.GetText[/color] + '_Hooked!';

(gut, man darf dieses jetzt nicht wörtlich nehmen, denn es würde eine kleine Endlosschleife entstehen :stupid: )

[Neutral General]

Zitat:

Zitat von Medium

Wie wäre es mit einer Ableitung der Klasse, die alles wie ihr Vorfahr durchreicht, aber die Property überdeckt und auf decorator-artige Weise erweitert? (Ich weiss nur grad nicht so 100%ig ob sich Properties überhaupt verdecken lassen...)

Das ist aber nicht was ich will..

Zitat:

Zitat von Apollonius

Wenn du das hooken willst, musst du das ganz klassisch machen, also einen Jump bzw. Call an den Anfang des Methodencodes schreiben.

Ja theoretisch wäre das auch mein erster Ansatz gewesen.. Problem ist nur, dass ich blöderweise einfach keinen Platz dafür hab. Ich überschreibe ja direkt wichtigen Code :?

[Apollonius]

Es geht aber nicht anders. Eigenschaften existieren im Kompilat nur noch als RTTI, die Aufrufe selbst sind nur noch Methodenaufrufe bzw. Feldzugriffe. Zum Hooken musst du dir irgendeine Grenze zwischen Anweisungen suchen. Das ist ein bisschen schwierig, weil du dazu schon fast Maschinencode parsen musst. Quick & Dirty geht es aber meistens, schau dir einfach mal an, was für Code der Delphi-Compiler im Prolog generiert.

[Neutral General]

Das hier:

Delphi-Quellcode:

push ebx
mov ebx, edx
// Result := 'Test';
mov eax, ebx
mov edx, $004D6A10
call UStrAsg
// end;
pop ebx
ret

allerdings ist da halt wirklich nicht viel Platz... :?
Das sind also 3 Bytes bevor der "Result := 'Test'"-Teil kommt... etwas wenig..

[Medium]

Zitat:

Zitat von Neutral General

Das ist aber nicht was ich will..

Aber es könnte das tun, was du hier gezeigt hast ;)

Edit: Alles andere liefe auf recht unschönes Gehacke in der Methodentabelle hinaus, was nicht nur extrem unelegant ist, sondern aufgrund der Freiheit die ein Compiler da hat auch praktisch unportierbar - möglicherweise eben auch innerhalb der Delphiversionen. Evtl. können wir besser hier weiter machen, wenn du konkret vorstellst, was du möchtest, und vor allem in welchem Kontext. Die bisherigen Beispiele waren offenbar zu stark minimiert.