[next] [prev] [prev-tail] [tail] [up]

### 11.3 Using a library in a pascal program

In order to use a function that resides in a library, it is sufficient to declare the function as it exists in the library as an external function, with correct arguments and return type. The calling convention used by the function should be declared correctly as well. The compiler will then link the library as specified in the external statement to your program1.

For example, to use the library as defined above from a pascal program, you can use the following pascal program:

Listing: progex/psubs.pp

program testsubs;
function SubStr(const CString: PChar; FromPos, ToPos: longint): PChar;
cdecl; external 'subs';
var
s: PChar;
FromPos, ToPos: Integer;
begin
s := 'Test';
FromPos := 2;
ToPos := 3;
WriteLn(SubStr(s, FromPos, ToPos));
end.

As is shown in the example, you must declare the function as external. Here also, it is necessary to specify the correct calling convention (it should always match the convention as used by the function in the library), and to use the correct casing for your declaration. Also notice, that the library importing did not specify the filename extension, nor was the lib prefix added.

This program can be compiled without any additional command-switches, and should run just like that, provided the library is placed where the system can find it. For example, on L I N U X, this is /usr/lib or any directory listed in the /etc/ld.so.conf file. On WI N D O W S, this can be the program directory, the WI N D O W S system directory, or any directoy mentioned in the PATH.

Using the library in this way links the library to your program at compile time. This means that

1. The library must be present on the system where the program is compiled.
2. The library must be present on the system where the program is executed.
3. Both libraries must be exactly the same.

Or it may simply be that you don’t know the name of the function to be called, you just know the arguments it expects.

It is therefore also possible to load the library at run-time, store the function address in a procedural variable, and use this procedural variable to access the function in the library.

The following example demonstrates this technique:

Listing: progex/plsubs.pp

program testsubs;
Type
TSubStrFunc =
function(const CString:PChar;FromPos,ToPos: longint):PChar;cdecl;
Function dlopen(name: pchar;mode: longint):pointer;cdecl;external 'dl';
Function dlsym(lib: pointer; name: pchar):pointer;cdecl;external 'dl';
Function dlclose(lib: pointer):longint;cdecl;external 'dl';
var
s: PChar;
FromPos, ToPos: Integer;
lib : pointer;
SubStr : TSubStrFunc;
begin
s := 'Test';
FromPos := 2;
ToPos := 3;
lib:=dlopen('libsubs.so',1);
Pointer(Substr):=dlsym(lib,'SubStr');
WriteLn(SubStr(s, FromPos, ToPos));
dlclose(lib);
end.

As in the case of compile-time linking, the crucial thing in this listing is the declaration of the TSubStrFunc type. It should match the declaration of the function you’re trying to use. Failure to specify a correct definition will result in a faulty stack or, worse still, may cause your program to crash with an access violation.

[next] [prev] [prev-tail] [front] [up]