Pointer to Function of (Sub-)Method?

Question

If you like to use a method's pointer as an argument, you need to type the method as function of object like this works good:

type TAcceptor = function(filename:string):boolean of object;
function acceptor(filename:string):boolean; 
begin 
  result := filename <> ''; 
end;

What if you like to use the pointer of a sub-method? It does not work:

procedure TForm1.Button1Click(Sender:TObject);
  function acceptor(filename:string):boolean of object;
  begin 
    result := filename <> ''; 
  end;
begin
end;

The error occour: ; expected but OF found!

Question: Is there any subfunction-pointer? Can i cast it?

Answer 1

I don't see how that this would be possible.

http://docwiki.embarcadero.com/RADStudio/XE6/en/Procedural_Types

If you look under the method pointers section, it specifically says that nested procedures and functions cannot be used:

"Nested procedures and functions (routines declared within other routines) cannot be used as procedural values, nor can predefined procedures and functions."

You might be able to work around it using an anonymous method. Something like:

procedure TForm1.Button1Click(Sender:TObject);
begin
  DoSomethingWithAcceptor(function(FileName: string): Boolean
  begin 
    Result := FileName <> '';
  end);
end;

Answer 2

CAUTION

I know that the following is not universally applicable, but it works for all known Win32 versions of Delphi. As long as you are aware of this, and check its functionality in new versions, it is a viable hack, IMO.

---

Passing nested functions to methods

In older code, I used this to do some "poor man's anonymous methods":

type
  TLocal = packed record
    Code: Pointer;  // local (nested) function
    Frame: Pointer; // outer stack frame for local function
   end;

To fill such a local inside a method, I wrote the function Local:

function Local(LocalFunction: Pointer): TLocal;
asm
  MOV [EDX].TLocal.Frame,EBP
  MOV [EDX].TLocal.Code,EAX
end;

Inside my unit (some kind of generic collection), I wrote a function to call them, passing one parameter (of type TGeneric, in this case, which is not important here, you can also pass a pointer or some such).

// Calls local function using local closure provided, passing
// T as parameter to the local.
function CallLocal(T: TGeneric; const Local: TLocal): TGeneric;
asm 
  PUSH [EDX].TLocal.Frame
  CALL [EDX].TLocal.Code
  ADD ESP,4
end;

It was used like this:

function TStdCollection.AsArray: TGenericArray;
var
  I: Integer;
  A: TGenericArray;

  procedure ToArray(E: TGeneric);
  begin
    Result[I] := E.Traits.Copy(E);
    Inc(I);
  end;

begin
  SetLength(A, Count);
  I := 0;
  ForEach(Local(@ToArray));
  Assert(I = Count);
  Result := A;
end;

The code in the nested function makes a copy of the element and stores it in the array. The main procedure then passes the nested function ToArray (together with its stack frame) as parameter to ForEach, which is implemented this way:

function TStdCollection.ForEach(Operation: TLocal): ICollection;
var
  Enum: IEnumerator;
  Elem: TGeneric;
begin
  Enum := GetEnumerator;
  Elem := Enum.First;
  while Elem <> nil do
  begin
    CallLocal(Elem, Operation);
    Elem := Enum.Next;
  end;
  Result := Self;
end;

These examples show how to use the Locals. I hope this more or less answers your question.

Note

Note that this code was written in the Delphi 6 timeframe. I know there are better alternatives these days, like generics and anonymous methods. But if compatibility with Delphi 7 is required, the above might be a solution.