Error: Inkompatible Typen Reguläre Prozedur u Methodenzeiger

[BlueStarHH]

Das klappt so leider auch nicht. Es kommt ein neuer Fehler:

Delphi-Quellcode:

TMyList = class(TList) 
  private 
     SortedColumn: Integer; 
     function MyListSortCompare(Item1, Item2: Pointer): Integer; stdcall; 
  public 
     procedure SortByColumn(Column: Integer); 
  end; 

procedure TMyList.SortByColumn(Column: Integer); 
var MyListComparef:function(Item1,Item2:Pointer):integer; 
begin 
  SortedColumn := Column; 
  MyListcomparef:=MakeProcInstance(MyListSortCompare); //<-- Fehler: Nicht genügend wirkliche Parameter
  Sort(MyListSortCompare);
  FreeProcinstance(MyListcompareF); 
end; 

function TMyList.MyListSortCompare(Item1, Item2: Pointer): Integer; 
begin 
  result := MachWas(Item1, Item2, SortedColumn); 
end;

[shmia]

Delphi-Quellcode:

TMyList = class(TList) 
  protected 
     SortedColumn: Integer; 
  public 
     procedure SortByColumn(Column: Integer); 
  end; 

implementation
var
   _sortlist: TMyList;  // globale hilfsvariable

// "normale" Funktion
function MyListSortCompare(Item1, Item2: Pointer): Integer; 
begin 
  result := MachWas(Item1, Item2, _sortlist.SortedColumn); 
end;

procedure TMyList.SortByColumn(Column: Integer); 
begin 
  SortedColumn := Column;
  _sortlist := self;
  Sort(MyListSortCompare); 
end;

[Muetze1]

... Oder einfach ein QuickSort selber implementieren...

[sirius]

Das muss auch einfach ohne ASM gehen

Delphi-Quellcode:

procedure TMyList.SortByColumn(Column: Integer); 
var MyListComparef:function(Item1,Item2:Pointer):integer; 
    m:Tmethod;
begin 
  SortedColumn := Column; 

  asm //m.code:=@MyListCompare (ging leider nur so)
    push edi
    mov edi, offset MyListCompare
    mov m.code,edi
    pop edi
  end;

  m.Data:=self;  

  MyListcomparef:=MakeProcInstance(m); //<-- Fehler: Nicht genügend wirkliche Parameter 
  Sort(MyListSortCompare); 
  FreeProcinstance(MyListcompareF); 
end;

Wie weist man nur m eine Methode zu?

[BlueStarHH]

Zitat von Muetze1:

... Oder einfach ein QuickSort selber implementieren...

Das könnte man natürlch machen. Aber es könnte ja auch mal andere Fälle geben, wo man es nicht mal eben selbst implementeiren könnte. Deswegen müsste es doch eine Lösung geben? Eine globale Hilfsvariable wie von shmia vorgeschalgen ist auch nicht das gelbe vom Ei. Da verstößt gegen jegliche Grundsätze vom OOP und bringt Probleme, wenn ich mehrere Instanzen geleichzeitig nutzen möchten (z.B. in Threads).

[jbg]

Zitat von sirius:

Delphi-Quellcode:

  asm //m.code:=@MyListCompare (ging leider nur so)
    push edi
    mov edi, offset MyListCompare
    mov m.code,edi
    pop edi
  end;

Pfui.
m.Code := @TMyList.MyListCompare; Und zum Code "der Schweizer" muss ich sagen: Viel glück unter Systemen mit aktivierter Data Execution Prevention (DEP).

Delphi-Quellcode:

type
  TSortCompareMethod = function(Item1, Item2: Pointer): Integer of object;

procedure MQuickSort(SortList: PPointerList; L, R: Integer;
  SCompare: TSortCompareMethod);
var
  I, J: Integer;
  P, T: Pointer;
begin
  repeat
    I := L;
    J := R;
    P := SortList^[(L + R) shr 1];
    repeat
      while SCompare(SortList^[I], P) < 0 do
        Inc(I);
      while SCompare(SortList^[J], P) > 0 do
        Dec(J);
      if I <= J then
      begin
        if I <> J then // kleine zusätzliche Optimierung
        begin
          T := SortList^[I];
          SortList^[I] := SortList^[J];
          SortList^[J] := T;
        end;
        Inc(I);
        Dec(J);
      end;
    until I > J;
    if L < J then
      MQuickSort(SortList, L, J, SCompare);
    L := I;
  until I >= R;
end;

procedure TMyList.Sort(Compare: TListSortCompareMethod);
begin
  if (FList <> nil) and (Count > 0) then
    MQuickSort(FList, 0, Count - 1, Compare);
end;

[sirius]

Zitat:

Pfui.
m.Code := @TMyList.MyListCompare;

Mir lags auf der Zunge
Ich habe heute auch einen schweren Tag hintermir.

Zitat:

Und zum Code "der Schweizer" muss ich sagen: Viel glück unter Systemen mit aktivierter Data Execution Prevention (DEP).

Das hatte ich woanders schonmal mit Luckie diskutiert/gelöst/geändert.


Edit: Ich sollte besser ins Bett

[Apollonius]

Fertig.

Delphi-Quellcode:

function MakeListSortMethodProc(Method:TListSortMethod): TListSortCompare;
begin
Pointer(result):=VirtualAlloc(0, $0F, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
asm
//mov ecx, edx
mov [eax],     $D189
//mov edx, eax
mov [eax+$02], $C289
//mov eax, Method.Data
mov [eax+$04], $B8
mov ecx, [ebp+$0C]
mov [eax+$05], ecx
//push Method.Code
mov [eax+$09], $68
mov ecx, [ebp+$08]
mov [eax+$0A], ecx
//ret
mov [eax+$0E], $C3
end;
end;

procedure FreeListSortProc(Proc: TListSortCompare);
begin
VirtualFree(Pointer(@Proc), 0, MEM_RELEASE);
end;

Ihr Assemblerkundigen da draußen, nehmt es mal kritisch unter die Lupe.

[Edit] Zusätzlich zu Sirius' Korrektur nocheinmal 6 Bytes Assemblercode gespart. [/edit]

[sirius]

Zitat:

Ihr Assemblerkundigen da draußen, nehmt es mal kritisch unter die Lupe.

Assembler ist das eine..fließend Intel x86 zu lesen (hatten wir gestern in nem anderen Thread) ist aber etwas anderes.

Also, vorausgesetzt, dein Kommentar passt zu den Opcodes, denn fehlt ein "$C3"=return am Ende.

[Apollonius]

Tja, sowas kommt davon, sich selbst zu hetzen Ist korrigiert.
[edit] Nachtrag zum Thema hetzen: Buchstabendreher kommen auch daher.[/edit]