Question: I am modulating my application to work with separate modules (plugin).

I have already successfully made my EXE application read and load the plugins, including the forms.

Now I need to do the inverse, export functions from the executable to DLL.

Example:
Inside my executable, it has a TMemo component. I want to create a function like this

```
function GetMemo(): widestring;

```

In my idea, whoever wrote the DLL plugin, when calling the *function GetMemo()*, would already take the contents of the TMemo in DLL.

It is possible?

Answer: 
The simplest way to handle this is to define a record of function pointers, and then have the EXE pass an instance of that record to each plugin while initializing it. The EXE can then implement the functions as needed and pass them to the plugins, without actually exporting them from its PE exports table like a DLL would.

For example:

```
type
  PPluginExeFunctions = ^PluginExeFunctions;
  PluginExeFunctions = record
    GetMemo: function: WideString; stdcall;
   ...
  end;

```

```
function MyGetMemoFunc: WideString; stdcall;
begin
  Result := Form1.Memo1.Text;
end;

...

var
  ExeFuncs: PluginExeFunctions;
  hPlugin: THandle;
  InitFunc: procedure(ExeFuncs: PPluginExeFunctions); stdcall;
begin
  ExeFuncs.GetMemo := @MyGetMemoFunc;
  ...
  hPlugin := LoadLibrary('plugin.dll');
  @InitFunc := GetProcAddress(hPlugin, 'InitializePlugin');
  InitFunc(@ExeFuncs);
  ...
end;

```

```
var
  ExeFuncs: PluginExeFunctions;

procedure InitializePlugin(pExeFuncs: PPluginExeFunctions); stdcall;
begin
  ExeFuncs := pExeFuncs^;
end;

procedure DoSomething;
var
  S: WideString;
begin
  S := ExeFuncs.GetMemo();
  ...
end;

```
```
unit uDoingExport;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

procedure testproc; stdcall;

implementation

{$R *.dfm}

procedure testproc;
begin
   ShowMessage('testproc');
End;

exports
   testproc;

end.

```

I simply added the method I want to publish from within my EXE in the unit's Interface, and on the Implementation I added exports (method name). I am using stdcall not cdecl.

In my child, I can loadlibrary the exe file... or you can go a little crazy like Apache does, and in the previous code, add a loadlibrary, which loads a DLL, which intern can loadlibrary the caller.

My point was to show, your EXE is simply like a DLL (just a different binary header) and vise versa. Just slap EXPORTS. Proof it works, I ran tdump against the EXE:

```
Exports from ProjDoingExport.exe
  1 exported name(s), 1 export addresse(s).  Ordinal base is 1.
  Sorted by Name:
    RVA      Ord. Hint Name
    -------- ---- ---- ----
    0005294C    1 0000 testproc

```

* I know, a late answer, but, a great question!