Ada (langage de programmation)

Ada est un langage de programmation de haut niveau structuré , typé statiquement , impératif et orienté objet , inspiré de Pascal et d'autres langages. Il dispose d'un support de langage intégré pour la conception par contrat (DbC), un typage extrêmement fort , la concurrence explicite, les tâches, le passage de messages synchrones, les objets protégés et le non-déterminisme . Ada améliore la sécurité et la maintenabilité du code en utilisant le compilateur pour rechercher les erreurs au lieu des erreurs d'exécution . Ada est une norme technique internationale , définie conjointement par l' Organisation internationale de normalisation (ISO) et la Commission électrotechnique internationale (CEI). En mai 2023 , la norme, appelée officieusement Ada 2022, est ISO/IEC 8652:2023.

Ada a été conçu à l'origine par une équipe dirigée par l'informaticien français Jean Ichbiah de Honeywell sous contrat avec le ministère de la Défense des États-Unis (DoD) de 1977 à 1983 pour remplacer plus de 450 langages de programmation utilisés par le DoD à cette époque. Ada doit son nom à Ada Lovelace (1815-1852), qui a été créditée comme la première programmeuse informatique.

Ada a été conçu à l'origine pour les systèmes embarqués et temps réel . La révision Ada 95, conçue par S. Tucker Taft d' Intermetrics entre 1992 et 1995, a amélioré la prise en charge des systèmes, de la programmation numérique, financière et orientée objet (OOP).

Les fonctionnalités d'Ada incluent : le typage fort , les mécanismes de programmation modulaire (packages), la vérification à l'exécution , le traitement parallèle ( tâches , transmission de messages synchrones , objets protégés et instructions de sélection non déterministes ), la gestion des exceptions et les génériques . Ada 95 a ajouté la prise en charge de la programmation orientée objet , y compris la répartition dynamique .

La syntaxe d'Ada minimise le choix des façons d'effectuer les opérations de base et préfère les mots-clés anglais (tels que « or else » et « and then ») aux symboles (tels que « || » et « && »). Ada utilise les opérateurs arithmétiques de base « + », « - », « * » et « / », mais évite d'utiliser d'autres symboles. Les blocs de code sont délimités par des mots tels que « declare », « begin » et « end », où « end » (dans la plupart des cas) est suivi de l'identifiant du bloc qu'il ferme (par exemple, if ... end if , loop ... end loop ). Dans le cas de blocs conditionnels, cela évite un else pendant qui pourrait être associé à la mauvaise expression if imbriquée dans d'autres langages comme C ou Java.

Ada est conçu pour le développement de systèmes logiciels de très grande taille. Les packages Ada peuvent être compilés séparément. Les spécifications des packages Ada (l'interface du package) peuvent également être compilées séparément sans l'implémentation pour vérifier la cohérence. Cela permet de détecter les problèmes dès la phase de conception, avant le début de l'implémentation.

Un grand nombre de vérifications au moment de la compilation sont prises en charge pour éviter les bogues qui ne seraient pas détectables avant l'exécution dans d'autres langages ou qui nécessiteraient l'ajout de vérifications explicites au code source. Par exemple, la syntaxe nécessite la fermeture explicitement nommée des blocs pour éviter les erreurs dues à des jetons de fin incompatibles. Le respect du typage fort permet de détecter de nombreuses erreurs logicielles courantes (paramètres erronés, violations de plage, références non valides, types incompatibles, etc.) soit au moment de la compilation, soit au moment de l'exécution. Comme la concurrence fait partie de la spécification du langage, le compilateur peut dans certains cas détecter des blocages potentiels. Les compilateurs vérifient également couramment les identifiants mal orthographiés , la visibilité des packages, les déclarations redondantes, etc. et peuvent fournir des avertissements et des suggestions utiles sur la façon de corriger l'erreur.

Ada prend également en charge les vérifications d'exécution pour se protéger contre l'accès à la mémoire non allouée, les erreurs de dépassement de tampon , les violations de plage, les erreurs d'un octet , les erreurs d'accès au tableau et d'autres bogues détectables. Ces vérifications peuvent être désactivées dans l'intérêt de l'efficacité de l'exécution, mais peuvent souvent être compilées efficacement. Il comprend également des fonctionnalités pour aider à la vérification des programmes . Pour ces raisons, Ada est parfois utilisé dans les systèmes critiques, où toute anomalie peut entraîner des conséquences très graves, par exemple un décès accidentel, une blessure ou une perte financière grave. Les exemples de systèmes où Ada est utilisé incluent l'avionique , le contrôle du trafic aérien , les chemins de fer , la banque, l'armée et la technologie spatiale .

La gestion dynamique de la mémoire d'Ada est de haut niveau et sûre en termes de type. Ada n'a pas de pointeurs génériques ou non typés ; il ne déclare pas non plus implicitement de type de pointeur. Au lieu de cela, toute allocation et désallocation dynamique de mémoire doit se produire via des types d'accès explicitement déclarés . Chaque type d'accès a un pool de stockage associé qui gère les détails de bas niveau de la gestion de la mémoire ; le programmeur peut soit utiliser le pool de stockage par défaut, soit en définir de nouveaux (ceci est particulièrement pertinent pour l'accès mémoire non uniforme ). Il est même possible de déclarer plusieurs types d'accès différents qui désignent tous le même type mais utilisent des pools de stockage différents. De plus, le langage fournit des contrôles d'accessibilité , à la fois au moment de la compilation et au moment de l'exécution, qui garantissent qu'une valeur d'accès ne peut pas survivre au type de l'objet vers lequel elle pointe.

Bien que la sémantique du langage permette la récupération automatique des objets inaccessibles, la plupart des implémentations ne le prennent pas en charge par défaut, car cela entraînerait un comportement imprévisible dans les systèmes en temps réel. Ada prend en charge une forme limitée de gestion de la mémoire par région ; de plus, l'utilisation créative de pools de stockage peut fournir une forme limitée de récupération automatique des objets, puisque la destruction d'un pool de stockage détruit également tous les objets du pool.

Un double tiret ("--"), ressemblant à un tiret cadratin , désigne le texte du commentaire. Les commentaires s'arrêtent à la fin de la ligne ; il n'existe intentionnellement aucun moyen de faire en sorte qu'un commentaire s'étende sur plusieurs lignes, afin d'empêcher que des commentaires non fermés n'annulent accidentellement des sections entières du code source. La désactivation d'un bloc de code entier nécessite donc de préfixer chaque ligne (ou colonne) individuellement avec "--". Bien que cela indique clairement le code désactivé en créant une colonne de "--" répétés sur la page, cela rend également la désactivation/réactivation expérimentale de gros blocs un processus plus long dans les éditeurs sans prise en charge des commentaires de bloc.

Le point-virgule (« ; ») est un terminateur d'instruction , et l'instruction nulle ou sans opération est un terminateur null;. Une instruction simple ;sans instruction de terminaison n'est pas autorisée.

Contrairement à la plupart des normes ISO , la définition du langage Ada (connue sous le nom de Manuel de référence Ada ou ARM , ou parfois Manuel de référence du langage ou LRM ) est un contenu libre . Il s'agit donc d'une référence courante pour les programmeurs Ada, et pas seulement pour ceux qui implémentent des compilateurs Ada. Outre le manuel de référence, il existe également un document de justification détaillé qui explique la conception du langage et l'utilisation de diverses constructions de langage. Ce document est également largement utilisé par les programmeurs. Lorsque le langage a été révisé, un nouveau document de justification a été rédigé.

Un outil logiciel gratuit notable utilisé par de nombreux programmeurs Ada pour les aider à écrire du code source Ada est le GNAT Programming Studio et GNAT , qui fait partie de la collection de compilateurs GNU .

Dans les années 1970, le département de la Défense américain (DoD) s'est inquiété du nombre de langages de programmation différents utilisés pour ses projets de systèmes informatiques embarqués, dont beaucoup étaient obsolètes ou dépendaient du matériel, et aucun d'entre eux ne prenait en charge la programmation modulaire sûre. En 1975, un groupe de travail , le High Order Language Working Group (HOLWG), a été formé dans le but de réduire ce nombre en trouvant ou en créant un langage de programmation généralement adapté aux besoins du département et du ministère de la Défense britannique . Après de nombreuses itérations commençant par une proposition originale le langage de programmation final a été nommé Ada. Le nombre total de langages de programmation de haut niveau utilisés pour de tels projets est passé de plus de 450 en 1983 à 37 en 1996.

L'équipe HOLWG a élaboré les exigences du langage Steelman , une série de documents énonçant les exigences auxquelles un langage de programmation devrait satisfaire. De nombreux langages existants ont été formellement examinés, mais l'équipe a conclu en 1977 qu'aucun langage existant ne répondait aux spécifications.

Des appels d'offres pour un nouveau langage de programmation furent lancés et quatre entrepreneurs furent embauchés pour développer leurs propositions sous les noms de Red ( Intermetrics dirigé par Benjamin Brosgol), Green ( Honeywell , dirigé par Jean Ichbiah ), Blue ( SofTech , dirigé par John Goodenough) et Yellow ( SRI International , dirigé par Jay Spitzen). En avril 1978, après un examen public, les propositions Red et Green passèrent à la phase suivante. En mai 1979, la proposition Green, conçue par Jean Ichbiah chez Honeywell, fut choisie et baptisée Ada, d'après Augusta Ada King, comtesse de Lovelace, généralement connue sous le nom d' Ada Lovelace . Cette proposition fut influencée par le langage LIS qu'Ichbiah et son groupe avaient développé dans les années 1970. Le manuel de référence préliminaire d'Ada a été publié dans les ACM SIGPLAN Notices en juin 1979. Le manuel de référence Military Standard a été approuvé le 10 décembre 1980 (anniversaire d'Ada Lovelace) et a reçu le numéro MIL-STD-1815 en l'honneur de l'année de naissance d'Ada Lovelace. En 1981, Tony Hoare a profité de son discours pour le prix Turing pour critiquer Ada, le qualifiant de trop complexe et donc peu fiable, mais il a semblé se rétracter par la suite dans l'avant-propos qu'il a écrit pour un manuel Ada.

Ada a attiré l'attention de la communauté des programmeurs dans son ensemble au cours de ses débuts. Ses partisans et d'autres ont prédit qu'il pourrait devenir un langage dominant pour la programmation à usage général et pas seulement pour les travaux liés à la défense. Ichbiah a déclaré publiquement que dans les dix ans, seuls deux langages de programmation resteraient : Ada et Lisp . Les premiers compilateurs Ada ont eu du mal à mettre en œuvre ce langage vaste et complexe, et les performances à la compilation et à l'exécution avaient tendance à être lentes et les outils primitifs. Ada Compiler Validation Capability (ACVC) massive, de tests de conformité au langage et exigée par le gouvernement , qui était requise dans une autre nouvelle fonctionnalité du langage Ada.

La première implémentation Ada validée fut le traducteur NYU Ada/Ed, certifié le 11 avril 1983. NYU Ada/Ed est implémenté dans le langage d'ensemble de haut niveau SETL . Plusieurs sociétés commerciales ont commencé à proposer des compilateurs Ada et des outils de développement associés, notamment Alsys , TeleSoft , DDC-I , Advanced Computer Techniques , Tartan Laboratories , Irvine Compiler, TLD Systems et Verdix . Les fabricants d'ordinateurs qui avaient une activité importante dans les secteurs de la défense, de l'aérospatiale ou des industries connexes proposaient également des compilateurs et des outils Ada sur leurs plates-formes ; il s'agissait notamment de Concurrent Computer Corporation , Cray Research, Inc. , Digital Equipment Corporation , Harris Computer Systems et Siemens Nixdorf Informationssysteme AG .

En 1991, le ministère de la Défense américain a commencé à exiger l'utilisation d'Ada (le mandat Ada ) pour tous les logiciels, bien que des exceptions à cette règle aient souvent été accordées. Le mandat Ada du ministère de la Défense a été effectivement supprimé en 1997, lorsque le DoD a commencé à adopter la technologie commerciale prête à l'emploi (COTS). Des exigences similaires existaient dans d'autres pays de l'OTAN : Ada était requis pour les systèmes de l'OTAN impliquant le commandement et le contrôle et d'autres fonctions, et Ada était le langage obligatoire ou préféré pour les applications liées à la défense dans des pays comme la Suède, l'Allemagne et le Canada.

À la fin des années 1980 et au début des années 1990, les compilateurs Ada avaient amélioré leurs performances, mais il subsistait encore des obstacles à l'exploitation complète des capacités d'Ada, notamment un modèle de tâches différent de celui auquel la plupart des programmeurs en temps réel étaient habitués.

En raison des fonctionnalités de support critiques pour la sécurité d'Ada , il est désormais utilisé non seulement pour les applications militaires, mais aussi dans les projets commerciaux où un bug logiciel peut avoir de graves conséquences, par exemple, l'avionique et le contrôle du trafic aérien , les fusées commerciales telles que l' Ariane 4 et 5 , les satellites et autres systèmes spatiaux, le transport ferroviaire et la banque. Par exemple, le Primary Flight Control System, le logiciel du système fly-by-wire du Boeing 777 , a été écrit en Ada, tout comme les systèmes fly-by-wire de l' Eurofighter Typhoon aérodynamiquement instable , du Saab Gripen , du Lockheed Martin F-22 Raptor et le système de contrôle de vol de remplacement DFCS pour le Grumman F-14 Tomcat . Le système de trafic aérien automatisé canadien a été écrit en 1 million de lignes d'Ada ( nombre de SLOC ). Il comportait un traitement distribué avancé , une base de données Ada distribuée et une conception orientée objet. Ada est également utilisé dans d'autres systèmes de trafic aérien, par exemple, le système de contrôle aérien Interim Future Area Control Tools Support (iFACTS) de nouvelle génération du Royaume-Uni est conçu et mis en œuvre à l'aide de SPARK Ada. Il est également utilisé dans le système de signalisation en cabine TVM français sur le système ferroviaire à grande vitesse TGV et dans les trains de banlieue du métro de Paris, Londres, Hong Kong et New York.

L'Ada préliminaire peut être trouvé dans ACM Sigplan Notices Vol 14, No 6, juin 1979

Ada a été publié pour la première fois en 1980 en tant que norme ANSI/ MIL -STD 1815. Comme cette toute première version comportait de nombreuses erreurs et incohérences, l'édition révisée a été publiée en 1983 sous le nom de ANSI/MIL-STD 1815A. Sans autre modification, elle est devenue une norme ISO en 1987. Cette version du langage est communément connue sous le nom d' Ada 83 , à partir de la date de son adoption par l'ANSI, mais est parfois également appelée Ada 87 , à partir de la date de son adoption par l'ISO. Il existe également une traduction française ; le DIN l'a traduite en allemand sous le nom de DIN 66268 en 1988.

Ada 95 , la norme commune ISO/IEC/ANSI ISO/IEC 8652:1995 a été publiée en février 1995, ce qui en fait le premier langage de programmation orienté objet standardisé par l'ISO. Pour aider à la révision de la norme et à son acceptation future, l' US Air Force a financé le développement du compilateur GNAT . Actuellement, le compilateur GNAT fait partie de la collection de compilateurs GNU .

Les travaux d'amélioration et de mise à jour du contenu technique du langage Ada se sont poursuivis. Un rectificatif technique à Ada 95 a été publié en octobre 2001, et un amendement majeur, ISO/IEC 8652:1995/Amd 1:2007 a été publié le 9 mars 2007, communément appelé Ada 2005 car les travaux sur la nouvelle norme ont été terminés cette année-là.

Lors de la conférence Ada-Europe 2012 à Stockholm, l'Ada Resource Association (ARA) et Ada-Europe ont annoncé l'achèvement de la conception de la dernière version du langage Ada et la soumission du manuel de référence à l' ISO/IEC JTC 1/SC 22 /WG 9 de l' Organisation internationale de normalisation (ISO) et à la Commission électrotechnique internationale (IEC) pour approbation. La norme ISO/IEC 8652:2012 (voir Ada 2012 RM) a été publiée en décembre 2012, connue sous le nom d' Ada 2012. Un corrigendum technique, ISO/IEC 8652:2012/COR 1:2016, a été publié (voir RM 2012 avec TC 1).

Le 2 mai 2023, la communauté Ada a vu l'approbation formelle de la publication de l' édition Ada 2022 de la norme de langage de programmation.

Malgré les noms Ada 83, 95 etc., il n'existe juridiquement qu'une seule norme Ada, celle de la dernière norme ISO/IEC : avec l'acceptation d'une nouvelle version de norme, la précédente est annulée. Les autres noms ne sont que des références informelles à une certaine édition.

D'autres normes connexes incluent ISO/IEC 8651-3 :1988 Systèmes de traitement de l'information — Infographie — Liaisons de langage du système de noyau graphique (GKS) — Partie 3 : Ada .

Ada est un langage de programmation de type ALGOL comportant des structures de contrôle avec des mots réservés tels que if , then , else , while , for , etc. Cependant, Ada dispose également de nombreuses fonctionnalités de structuration des données et d'autres abstractions qui n'étaient pas incluses dans l' ALGOL 60 d'origine , telles que les définitions de type , les enregistrements , les pointeurs , les énumérations . De telles constructions ont été en partie héritées ou inspirées de Pascal .

Un exemple courant de syntaxe de langage est le programme Hello world : (hello.adb)

avec 
Ada.Text_IO ;
procédure 
Bonjour 
c'est
commencer
Ada . Text_IO . Put_Line 
( "Bonjour tout le monde !" );
fin 
Bonjour ;

Ce programme peut être compilé en utilisant le compilateur open source GNAT disponible gratuitement , en exécutant

gnatmake bonjour.adb 

Le système de types d'Ada ne repose pas sur un ensemble de types primitifs prédéfinis mais permet aux utilisateurs de déclarer leurs propres types. Cette déclaration ne repose pas à son tour sur la représentation interne du type mais sur la description de l'objectif à atteindre. Cela permet au compilateur de déterminer une taille de mémoire adaptée au type et de vérifier les violations de la définition de type au moment de la compilation et de l'exécution (c'est-à-dire les violations de plage, les dépassements de tampon, la cohérence de type, etc.). Ada prend en charge les types numériques définis par une plage, les types modulo, les types d'agrégats (enregistrements et tableaux) et les types d'énumération. Les types d'accès définissent une référence à une instance d'un type spécifié ; les pointeurs non typés ne sont pas autorisés. Les types spéciaux fournis par le langage sont les types de tâches et les types protégés.

Par exemple, une date pourrait être représentée comme suit :

type 
Day_type 
est 
compris entre 
1 
.. 
31 ;
type 
Month_type 
est 
compris entre 
1 
.. 
12 ;
type 
Year_type 
est 
compris entre 
1800 
.. 
2100 ;
le type 
Heures 
est 
mod 
24 ;
type 
Jour de la semaine 
est 
( lundi , 
mardi , 
mercredi , 
jeudi , 
vendredi , 
samedi , 
dimanche );
type 
Date 
est
enregistrer
Jour 
: 
Type_de_jour ;
Mois 
: 
Type_mois ;
Année 
: 
Year_type ;
fin d'enregistrement ;

Important à noter : Day_type, Month_type, Year_type, Hours sont des types incompatibles, ce qui signifie que, par exemple, l'expression suivante est illégale :

Aujourd'hui : 
Day_type 
:= 
4 ;
Mois_en_cours : 
Type_mois 
:= 
10 ;
... 
Aujourd'hui 
+ 
Mois_en_cours 
... 
-- illégal

L'opérateur plus prédéfini ne peut ajouter que des valeurs du même type, l'expression est donc illégale.

Les types peuvent être raffinés en déclarant des sous-types :

sous-type 
Working_Hours 
est une 
plage d'heures comprise entre 
0 et 12 ; -- au plus 12 heures de travail par jour
sous-type 
Working_Day 
est 
la plage de jours de la semaine 
Lundi .. Vendredi ; -- Jours de travail
Work_Load : 
tableau constant 
( Working_Day ) de Working_Hours -- déclaration de type implicite
:= 
( vendredi 
=> 
6 , 
lundi 
=> 
4 , 
autres 
=> 
10 ); 
-- table de recherche pour les heures de travail avec initialisation

Les types peuvent avoir des modificateurs tels que limité, abstrait, privé , etc. Les types privés ne montrent pas leur structure interne ; les objets de types limités ne peuvent pas être copiés. Ada 95 ajoute d'autres fonctionnalités pour l'extension orientée objet des types.

Ada est un langage de programmation structuré , ce qui signifie que le flux de contrôle est structuré en instructions standard. Toutes les constructions standard et les sorties anticipées de niveau profond sont prises en charge, de sorte que l'utilisation des commandes « go to », également prises en charge, est rarement nécessaire.

-- tant que a n'est pas égal à b, boucle.
tandis que 
a 
/= 
b 
boucle
Ada . Text_IO . Put_Line 
( "En attente" );
fin de 
boucle ;
si 
a 
> 
b 
alors
Ada . Text_IO . Put_Line 
( "Condition remplie" );
autre
Ada . Text_IO . Put_Line 
( "Condition non remplie" );
fin 
si ;
pour 
i 
dans 
la boucle 1 
.. 
10
Ada . Text_IO . Put 
( "Itération : " );
Ada . Texte_IO . Put 
( i );
Ada . Text_IO . Put_Line ;
fin de 
boucle ;
boucle
a 
:= 
a 
+ 
1 ;
sortir 
quand 
a 
= 
10 ;
fin de 
boucle ;
cas 
i 
est
quand 
0 
=> 
Ada . Text_IO . Put 
( "zéro" );
quand 
1 
=> 
Ada . Text_IO . Put 
( "un" );
quand 
2 
=> 
Ada . Text_IO . Put 
( "deux" );
-- les instructions case doivent couvrir tous les cas possibles :
quand 
les autres 
=> 
Ada . Text_IO . Put 
( "aucun des éléments ci-dessus" );
cas final ;
pour 
un jour de semaine 
dans 
la boucle Range de Weekday -- boucle sur une énumération
Put_Line 
( 
Weekday ' Image ( aWeekday ) 
); 
-- représentation de chaîne de sortie d'une énumération
si 
un jour de semaine 
dans 
un jour ouvrable 
alors 
-- vérification d'un sous-type d'une énumération
Put_Line 
( 
" travailler pour " 
&
Heures_de_travail ' Image 
( Work_Load ( aWeekday )) 
); 
-- accès à une table de recherche
fin 
si ;
fin de 
boucle ;

Parmi les parties d’un programme Ada figurent des packages, des procédures et des fonctions.

Les fonctions diffèrent des procédures dans la mesure où elles doivent renvoyer une valeur. Les appels de fonction ne peuvent pas être utilisés « comme une instruction » et leur résultat doit être affecté à une variable. Cependant, depuis Ada 2012, les fonctions ne sont pas obligées d'être pures et peuvent muter leurs paramètres convenablement déclarés ou l'état global.

Exemple : Spécification du package (exemple.ads)

L'exemple 
de package est
le type 
Nombre 
est 
compris entre 
1 
.. 
11 ;
procédure 
Print_and_Increment 
( j : in 
out 
Number );
fin 
Exemple ;

Corps du paquet (exemple.adb)

avec 
Ada.Text_IO ;
L'exemple du corps 
du package est
i 
: 
Nombre 
:= 
Nombre ' Premier ;
procédure 
Print_and_Increment 
( j : in 
out 
Number ) 
est
fonction 
Suivant 
( k : dans 
Nombre ) 
renvoie 
Nombre 
est
commencer
renvoie 
k 
+ 
1 ;
fin 
Suivant ;
commencer
Ada . Text_IO . Put_Line 
( 
"Le total est : " 
& 
Number ' Image ( j ) 
);
j 
:= 
Suivant 
( j );
fin de 
Print_and_Increment ;
-- initialisation du package exécutée lorsque le package est élaboré
commencer
tant que 
i 
< 
Nombre ' Dernière 
boucle
Imprimer_et_incrémenter 
( i );
fin de 
boucle ;
fin 
Exemple ;

Ce programme peut être compilé, par exemple, en utilisant le compilateur open source GNAT disponible gratuitement , en exécutant

gnatmake -z exemple.adb 

Les packages, les procédures et les fonctions peuvent s'imbriquer à n'importe quelle profondeur, et chacun peut également être le bloc logique le plus externe.

Chaque package, procédure ou fonction peut avoir ses propres déclarations de constantes, types, variables et autres procédures, fonctions et packages, qui peuvent être déclarés dans n'importe quel ordre.

Un pragma est une directive du compilateur qui transmet des informations au compilateur pour permettre une manipulation spécifique de la sortie compilée. Certains pragmas sont intégrés au langage, tandis que d'autres sont spécifiques à l'implémentation.

Des exemples d'utilisation courante des pragmes du compilateur seraient de désactiver certaines fonctionnalités, telles que la vérification du type à l'exécution ou la vérification des limites des indices de tableau, ou d'indiquer au compilateur d'insérer du code objet au lieu d'un appel de fonction (comme le fait C/C++ avec les fonctions en ligne ).