System unit/fr

│ English (en) │ français (fr) │

Dans FPC l'unité system est celle qui est inclue par tout programme.

La bibliothèque d'exécution (RTL) est livrée avec l'unité system où la plupart de ses fonctionnalités, si ce n'est pas toutes, tournent sur chaque plateforme disponible.

Compilation des unités système

To compile a system unit one calls FPC with the -Us flag. This will tell the compiler that only basic type definitions are being made, and including a system unit is skipped. Types such as integer won't be available.

Tâches obligatoire pour l'unité system

If you attempt to create your own system unit, you'll incrementally notice what the compiler needs or what the generated code expects. On a Linux target, the minimal system unit has to contain:

1unit system;
2
3interface

The type definition of hresult.

5type
6	hresult = longint;

The identifier operatingsystem_result has to be declared. The data stored at that position are communicated to the operating system as return value. Whether hresult and operatingsystem_result are defined in the interface section is irrelevant. However, it is very plausible to put those into the interface section, so programs using this system unit can manipulate those.

 8var
 9	exitCode: hresult = 0; export name 'operatingsystem_result';
10
11implementation

Here comes to light what the system responsibilities are: It has to initialize (or should) initialize units, that means call every unit's initialization routines. For that the label FPC_INITIALIZEUNITS has to be defined.

13procedure initializeUnits; alias: 'FPC_INITIALIZEUNITS'; 
14begin
15end;

Also the label FPC_DO_EXIT has to be defined. Here, system unit programmers have the chance to finalize units.

17procedure doExit; alias: 'FPC_DO_EXIT';
18begin
19end;
20
21end.

Furthermore FPC will possibly complain the unit fpintres.pp were missing. So create a file fpintres.pas:

1unit FPIntRes;
2interface
3implementation
4end.

After doing so, you can compile your system unit with fpc -Us system.pas, or directly create an empty program and compile it to examine the impact on the binary's size. On a x86-64 Linux target the executable had a size of 2744 bytes. The big trade-off is no convenience. All functionality that can't be “implemented” by the compiler is gone. For example addr or ord still work, while sin or random are not available.

  Remarque: Depending on what your program uses, there might other mandatory tasks, too.

Especially OOP won't work without a functional objpas unit.

Initialisation et finalisation des unités

For those who are curious, how to implement FPC_INITIALIZEUNITS: FPC puts into every program's data section a INITFINAL table. Compiling a program with the -al flag will retain the assembler file. Examining it you will encounter something like:

33.section .data.n_INITFINAL
34        .balign 8
35.globl  INITFINAL
36        .type   INITFINAL,@object
37INITFINAL:
38        .quad   1,0
39        .quad   INIT$_$SOMEUNIT
40        .quad   FINALIZE$_$SOMEUNIT

For further investigations have a glimpse at an actual implementation helps: rtl/inc/system.inc.

  Remarque: In general, implementing an “own” system unit is a stupid idea. There is “smartlinking” if size matters.

Remarques comparatives

D'autres compilateurs tels que GNU Pascal (GPC) ou Delphi utilise des constructions similaires, mais à des degrés divers, et l'unité système n'est pas nécessairement nommée system.pp.

Voir aussi

• FPC RTL system unit reference
• Structure de l'unité System, quelques explications sur l'unité system distribuée.
• RTL minimale (en)
• Articles de développement RTL (en)