12.3 Using a library in a pascal program

In order to use a function that resides in a library, it is sucient 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 specied in the external statement to your program¹ .

For example, to use the library as dened 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 lename extension, nor was the lib prex 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 nd it. For example, on linux, this is /usr/lib or any directory listed in the /etc/ld.so.conf le. On Windows, this can be the program directory, the Windows 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

The library must be present on the system where the program is compiled.
The library must be present on the system where the program is executed.
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 denition 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]