Warum gibt es hier eine Acess Violation?

[Benmik]

Hier noch ein Codesplitter, der in den Bereich des ursprünglichen Themas fällt.

[Uwe Raabe]

Und da steht es ja auch schon genauso drin, daß es in dieser Situation crasht:

Zitat:

There is, however, a pitfall in the above example -
if the "inner" routine references any variable that was pushed onto
the stack before the "inner" procedure was called from testpass
(calltestpass parameters - if there were any, or local variables in
calltestpass - if there were any), your system most probably crashes:

Delphi-Quellcode:

{ This code compiles OK but generates runtime exception (could even be
  EMachineHangs :-) ) }
procedure testpass(p: pointer);
begin
  tProcedure(p);
end;
procedure calltestpass;
var msg: string;
 procedure inner;
 begin
   msg := 'hello';
   showmessage(msg);
 end;
begin
  testpass(@inner);
end;

[Benmik]

Sí, Señor! Es steht aber auch drin, wie man das mit Assembler austrickst. Ein Vorgehen, das David Heffernan immer mit hochrotem Kopf als "filthy hack" geißelt.

Für mich lehrreich, weil ich ja im Leben nicht auf solche Hintergründe gekommen wäre. Es gibt halt mehr zwischen Himmel und Erde, als sich unserer Schulweisheit träumen lässt. Tröstlicherweise gilt das aber auch für die Experten.

[Benmik]

Eine weitere Fundstelle ist AsyncCalls von Andreas Hausladen, und zwar die dortige Funktion LocalVclCall:

Delphi-Quellcode:

procedure TFormMain.MainProc; 

  procedure DoSomething; 

    procedure UpdateProgressBar(Percentage: Integer); 
    begin 
      ProgressBar.Position := Percentage; 
      Sleep(20); // This delay does not affect the time for the 0..100 loop 
                 // because UpdateProgressBar is non-blocking. 
    end; 

    procedure Finished; 
    begin 
      ShowMessage('Finished'); 
    end; 

  var 
    I: Integer; 
  begin 
    for I := 0 to 100 do 
    begin 
      // Do some time consuming stuff 
      Sleep(30); 
      LocalAsyncVclCall(@UpdateProgressBar, I); // non-blocking 
    end; 
    LocalVclCall(@Finished); // blocking 
  end; 

var 
  a: IAsyncCall; 
begin 
  a := LocalAsyncCall(@DoSomething); 
  a.ForceDifferentThread; // Do not execute in the main thread because this will 
                          // change LocalAyncVclCall into a blocking LocalVclCall 
  // do something 
  //a.Sync; The Compiler will call this for us in the Interface._Release method 
end;

Da frage ich mich, ob die auch darauf beruht, dass hier keine "innere" Variable zwischen den Aufrufen geändert wird.
Im Quelltext wird fleißig mit Inline-ASM gearbeitet, offenbar (auch) an den Stack-Adressen.

Warum ist diese Funktion übrigens als "Deprecated" gekennzeichnet? AsyncCalls wird seit 2016 nicht mehr weiterentwickelt, warum dann das "Deprecated" bei einzelnen Funktionen?