Поиск функции по её имени в теле программы

type
  TMyProcType = procedure (A,B: integer);

var
  P: TMyProcType;

procedure SomeProc(A,B: integer);
  begin
     DoSomething;
  end;

begin
  P:=SomeProc;  //инициализация
  P (10,14);  //вызов
end;

type
  TFirst = function (A,B: integer): integer; stdcall;
  TSecond = function (A,B: integer): integer; register;

//имеет тип TFirst
function First(A,B: integer): integer; stdcall;
  begin
      Result:=A+B;
  end;

//имеет тип TSecond
function Second(A,B: integer): integer; register;
  begin
      Result:=A+B;
  end;

var
   Res1: integer;
   Res2: integer;

   F: TFirst;
   S: TSecond;

begin
   F:=First;
   S:=Second;
   Res1:=F (10, 15);
   Res2:=S (54,  34);
end;

type
  TCommand = class
    protected
      fCommand: string;
    public
      procedure Execute(const Params: string); virtual; abstract;
      property Command: string read fCommand;
  end;

  TCommandTable = class
    public
      function RegisterCommand(Cmd: TCommand): boolean;
      function ExecuteCommand(const Cmd: string; const Params: string);
  end;

type
  TCommand = class
    private
      fCommand: string;
    public
      procedure Execute(const Params: string); virtual; abstract;
      property Command: string read fCommand;
  end;//of class

  TCommandTable = class
    protected
      procedure AddCommand(Cmd: TCommand);
      function FindCommand(const Cmd: string): TCommand;
      procedure DeleteCommands;
    public
      destructor Destroy; override;
      function RegisterCommand(Cmd: TCommand): boolean;
      function ExecuteCommand(const Cmd: string; const Params: string): boolean;
  end;//of class

  //пример команды
  TSimpleCommand = class(TCommand)
    public
      constructor Create;
      procedure Execute(const Params: string); override;
  end;//of class

procedure TCommandTable.Destroy;
  begin
    DeleteCommands;
  end;

procedure TCommandTable.AddCommand(Cmd: TCommand);
  begin
    //добавляем новую команду в таблицу
    //с Cmd.Command находится идентификатор комманды

    //таблицу команд можно организовать как хэш таблицу
    //в Делфи есть специальный класс: THashedStringList
  end;

function TCommandTable.FindCommand(const Cmd: string): TCommand;
  begin
    //осуществляем поиск команды Cmd в таблице и возвращаем
    //как результат
    //если не нашли, то возвращаем nil
  end;

procedure TCommandTable.DeleteCommands;
  begin
    //очищаем таблицу
  end;

function TCommandTable.RegisterCommand(Cmd: TCommand): boolean;
  begin
    if FindCommand(Cmd.Command) then Result:=false
    else begin
        AddCommand(Cmd);
        Result:=true;
    end;
  end;

function TCommandTable.ExecuteCommand(const Cmd, Params: string): boolean;
  var C: TCommand;
  begin
    c:=FindCommand(Cmd);
    if C = nil then Result:=false
    else begin
        C.Execute(Params);
        Result:=true
    end;
  end;

constructor TSimpleCommand.Create;
  begin
    fCommand:='MyCommandName';
  end;

procedure TSimpleCommand.Execute(const Params: string);
  begin
    //нужно переопределять этот метод
    //чтобы придать комманде функциональность
  end;

var
  CmdTable: TCommandTable;
  Cmd: TSimpleCommand;

begin
//создаём таблицу команд
  CmdTable:=TCommandTable.Create;
//создаём объект команды
  Cmd:=TSimpleCommand.Create;
  if not CmdTable.RegisterCommand(Cmd) //регистрация провалилась
  then begin
     Cmd.Free;
  end else begin
     CmdTable.ExecuteCommand ('MyCommandName', 'Parameters' );
  end;
end;

type
    TCommand = class
        class function Execute(const Params: string): string; virtual; abstract;
    end;
    TCommandClass = class of TCommand;
 
    TCommandTable = class
    private
        FCommandList: TClassList; // Здесь храним команды
        function GetCommand(Name: string): TCommandClass;
    public
        function RegisterCommand(Cmd: TCommandClass): boolean;
        property Commands[Name: string]: TCommandClass read GetCommand; default;
        // Ну и еще что-нибудь...
    end;  

    // Какая-то команда
    TSimpleCommand = class (TCommand)
    public
        class function Execute(const Params: string): string; override;
    end;

// Далее все тоже самое
// GetCommand ищет в списке команду по имени ее класса
function GetCommand(Name: string): TCommandClass;
var i, count: Integer;
begin
    Result:=nil;
    count:=FCommandList.Count;
    for i:=0 to count - 1 do
        if FCommandList.ClassName = Name then
        begin
            Result:=FCommandList as TCommandClass;
            Exit;
        end;
end;

// Как все это работает?
begin
    //Где - то уже создана CommandTable...
    // Регистрируем команду:
    CommandTable.RegisterCommand(TSimpleCommand);
    // Выполняем комманду
    some_result:=CommandTable['TSimpleCommand'].Execute(some_params);
    // А можно просто вот так ;)
    some_result:=TSimpleCommand.Execute(some_params);
end;