[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 8.11.1 Importing Libraries from Other Languages

To use a function written in another language, you need to provide an external declaration for it -- either in the program, or in the interface part of a unit, or an interface module.

Let's say you want to use the following C library from Pascal:

    File `callc.c':

    #include <unistd.h>
    #include "callc.h"

    int foo = 1;

    void bar (void)
    {
      sleep (foo);
    }

    File `callc.h':

    /* Actually, we wouldn't need this header file, and could instead
       put these prototypes into callc.c, unless we want to use callc.c
       also from other C source files. */

    extern int foo;
    extern void bar (void);

Then your program can look like this:

    program CallCDemo;

    {$L callc.c}  { Or: `callc.o' if you don't have the source }

    var
      Foo: Integer; asmname 'foo'; external;

    procedure Bar; asmname 'bar';

    begin
      Foo := 42;
      Bar
    end.

Or, if you want to provide a ``CallCUnit'` unit:

    unit CallCUnit;

    interface

    var
      Foo: Integer; asmname 'foo'; external;

    procedure Bar; asmname 'bar';

    implementation

    {$L callc.c}  { Or: `callc.o' if you don't have the source }

    end.

    program CallCUDemo;

    uses CallCUnit;

    begin
      foo := 42;
      Bar
    end.

You can either link your program manually with ``callc.o'` or put a compiler directive ``{$L callc.o}'` into your program or unit, and then GPC takes care of correct linking. If you have the source of the C library (you always have it if it is Free Software), you can even write ``{$L callc.c}'` in the program (like above). Then GPC will also link with ``callc.o'`, but in addition GPC will run the C compiler whenever ``callc.c'` has changed if ``--automake'` is given, too.

While it is convenient for most applications, there is no must to give the C function ``bar'` the name ``Bar'` in Pascal; you can name it as you like.

For external functions completely written in lowercase there is the shortcut ``C'` or ``c_language'` for ``asmname 'bar''`. For external functions written with one uppercase letter and the others in lowercase, you can use ``external'` or ``extern'` instead of ``asmname 'Bar''`. Since GPC internally converts all identifiers to this notation, ``external'` is the natural choice when importing other Pascal functions.

Caution: This syntax (``C'`, ``asmname'` and such) is subject to change.

It is important that data types of both languages are mapped correctly onto each other. C's ``int'`, for instance, translates to GPC's ``Integer'`, and C's ``unsigned long'` to ``MedCard'`. For a complete list of integer types with their C counterparts, see section 8.2.3 Integer Types.

In some cases it can be reasonable to translate a C pointer parameter to a Pascal ``var'` parameter. Since const parameters in GPC can be passed by value or by reference internally, possibly depending on the system, ``const foo *'` parameters to C functions cannot reliably declared as ``const'` in Pascal. However, Extended Pascal's ``protected var'` can be used since this guarantees passing by reference.

Some libraries provide a ``main'` function and require your program's "main" to be named differently. To achive this with GPC, invoke it with an option ``--gpc-main="GPCmain"'` (where ``GPCmain'` is an example how you might want to name the program). You can also write it into your source as a directive ``{$gpc-main="GPCmain"}'`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by Frank Heckenbach on May, 10 2002 using texi2html