Langage de programmation - Ada - Environnement de langage prédéfini

Environnement de langage prédéfini

Cette annexe décrit la spécification du paquet STANDARD contenant tous les identifiants prédéfinis dans le langage. Le corps du paquet correspondant est défini par l'implémentation et n'est pas affiché.

Les opérateurs prédéfinis pour les types déclarés dans le paquet STANDARD sont indiqués dans les commentaires car ils sont déclarés implicitement. L'italique est utilisée pour les pseudo-noms de types anonymes (tels que universal_real) et pour les informations non définies (telles que implementation_defined et any_fixed_point_type).



package STANDARD is 

 
  type BOOLEAN is (FALSE, TRUE);

  

  -- Les opérateurs relationnels prédéfinis pour ce type sont les suivants :

  -- function "="   (LEFT, RIGHT : BOOLEAN) return BOOLEAN

  -- function "/="  (LEFT, RIGHT : BOOLEAN) return BOOLEAN

  -- function "<"   (LEFT, RIGHT : BOOLEAN) return BOOLEAN

  -- function "<="  (LEFT, RIGHT : BOOLEAN) return BOOLEAN

  -- function ">"   (LEFT, RIGHT : BOOLEAN) return BOOLEAN

  -- function ">="  (LEFT, RIGHT : BOOLEAN) return BOOLEAN

 
  -- Les opérateurs logiques prédéfinis et l'opérateur de négation logique prédéfini sont les suivants :

  -- function "and" (LEFT, RIGHT : BOOLEAN) return BOOLEAN;

  -- function "or"  (LEFT, RIGHT : BOOLEAN) return BOOLEAN;

  -- function "xor" (LEFT, RIGHT : BOOLEAN) return BOOLEAN;

  -- function "not" (RIGHT : BOOLEAN) return BOOLEAN;

  

  -- Le type universel universal_integer est prédéfini.

  

  type INTEGER is implementation_defined;

 
  -- Les opérateurs prédéfinis pour ce type sont les suivants :

  

  -- function "="   (LEFT, RIGHT : INTEGER) return BOOLEAN;

  -- function "/="  (LEFT, RIGHT : INTEGER) return BOOLEAN;

  -- function "<"   (LEFT, RIGHT : INTEGER) return BOOLEAN;

  -- function "<="  (LEFT, RIGHT : INTEGER) return BOOLEAN;

  -- function ">"   (LEFT, RIGHT : INTEGER) return BOOLEAN;

  -- function ">="  (LEFT, RIGHT : INTEGER) return BOOLEAN;

     

  -- function "+"   (RIGHT : INTEGER) return INTEGER;

  -- function "-"   (RIGHT : INTEGER) return INTEGER;

  -- function "abs" (RIGHT : INTEGER) return INTEGER;

 
  -- function "+"   (LEFT, RIGHT : INTEGER) return INTEGER;

  -- function "-"   (LEFT, RIGHT : INTEGER) return INTEGER;

  -- function "*"   (LEFT, RIGHT : INTEGER) return INTEGER;

  -- function "/"   (LEFT, RIGHT : INTEGER) return INTEGER;

  -- function "rem" (LEFT, RIGHT : INTEGER) return INTEGER;

  -- function "mod" (LEFT, RIGHT : INTEGER) return INTEGER;

 
  -- function "**"  (LEFT INTEGER; RIGHT : INTEGER) return INTEGER;

 
  -- Une implémentation peut fournir des types entiers prédéfinis supplémentaires. Il est recommandé que les

  -- noms de ces types supplémentaires se terminent par INTEGER comme dans SHORT_INTEGER ou LONG_INTEGER.

  -- La spécification de chaque opérateur pour le type universal_integer, ou pour tout autre

  -- type entier prédéfini supplémentaire, est obtenue en remplaçant INTEGER par le nom du type dans la

  -- spécification de l'opérateur correspondant du type INTEGER, à l'exception de l'opérande de droite

  -- de l'opérateur exponentiel.

 
  -- Le type universel universal_real est prédéfini.

 
  type FLOAT is implementation_defined;

 
  -- Les opérateurs prédéfinis pour ce type sont les suivants :

 
  -- function "="   (LEFT, RIGHT : FLOAT) return BOOLEAN;

  -- function "/="  (LEFT, RIGHT : FLOAT) return BOOLEAN;

  -- function "<"   (LEFT, RIGHT : FLOAT) return BOOLEAN;

  -- function "<="  (LEFT, RIGHT : FLOAT) return BOOLEAN;

  -- function ">"   (LEFT, RIGHT : FLOAT) return BOOLEAN;

  -- function ">="  (LEFT, RIGHT : FLOAT) return BOOLEAN;

 
  -- function "+"   (RIGHT : FLOAT) return FLOAT;

  -- function "-"   (RIGHT : FLOAT) return FLOAT;

  -- function "abs" (RIGHT : FLOAT) return FLOAT;

 
  -- function "+"   (LEFT, RIGHT : FLOAT) return FLOAT;

  -- function "-"   (LEFT, RIGHT : FLOAT) return FLOAT;

  -- function "*"   (LEFT, RIGHT : FLOAT) return FLOAT;

  -- function "/"   (LEFT, RIGHT : FLOAT) return FLOAT;

 
  -- function "**"  (LEFT : FLOAT; RIGHT : INTEGER) return FLOAT;

 
  -- Une implémentation peut fournir des types de virgule flottante prédéfinis supplémentaires. Il est recommandé

  -- que les noms de ces types supplémentaires se terminent par FLOAT comme dans SHORT_FLOAT ou

  -- LONG_FLOAT. La spécification de chaque opérateur pour le type universal_real, ou pour tout

  -- type de virgule flottante prédéfini supplémentaire, est obtenue en remplaçant FLOAT par le nom du

  -- type dans la spécification de l'opérateur correspondant du type FLOAT.

     

  -- De plus, les opérateurs suivants sont prédéfinis pour les types universels :

 
  -- function "*"   (LEFT : universal_integer; RIGHT : universal_real) return universal_real;

  -- function "*"   (LEFT : universal_real; RIGHT : universal_integer) return universal real;

  -- function "/"   (LEFT : universal_real; RIGHT : universal_integer) return universal_real;

 
  -- Le type universal_fixed est prédéfini. Les seuls opérateurs déclarés pour ce type sont:

  

  -- function "*" (LEFT : any_fixed_point_type; RIGHT : anyfixed_point_type) return universal_fixed;

  -- function "/" (LEFT : any_fixed_point_type; RIGHT : anyfixed_point_type) return universal_fixed;

 
  -- Les caractères suivants constituent le jeu de caractères ASCII standard. Les littéraux de caractères correspondant

  -- aux caractères de contrôle ne sont pas des identifiants ; ils sont indiqués en italique dans cette définition.

 
  type CHARACTER is

 
        ( nul,   sob,   stx,   etx,   eot,   enq,  ack,  bel,

          bs,    ht,    lf,    vt,    ff,    cr,   so,   si,

          die,   del,   dc2,   dc3,   dc4,   nak,  syn,  etb,

          can,   em,    sub,   esc,   fs,    gs,   rs,   us,

 
         ' ',    '!',   '"',   '#',   '$',   '%',  '&',  '''',

         '(',    ')',   '*',   '+',   ',',   '-',  ','   '/',

         '0',    '1',   '2',   '3',   '4',   '5',  '6',  '7',

         '8',    '9',   ':',   ';',   '<',   '=',  '>',  '?',

         '@',    'A',   'B',   'C',   'D',   'E',  'F',  'G',

         'H',    '1',   'J',   'K',   'L',   'M',  'N',  'O',

         'P',    'Q',   'R',   'S',   'T',   'U',  'V',  'W',

         'X',    'V',   'Z',   '[',   '\',   ']',  '"',  '_',

           

         '`',    'a',   'b',   'c',   'd',   'e',  'f',  'g',

         'h',    'i',   'j',   'k',   'l',   'm',  'n',  'o',

         'p',    'q',   'r',   's',   't',   'u',  'v',  'w',

         'x',    'y',   'z',   '{',   '|',   '}',  '~',  del);

 
  for CHARACTER use -- Ensemble de 128 caractères ASCII sans trous

   (0, 1, 2, 3, 4, 5, .. 125, 126, 127);

 
  -- Les opérateurs prédéfinis pour le type CHARACTER sont les mêmes que pour tout type d'énumération,

     

package ASCII is

 
  -- Caractères de contrôle :

  

  NUL       : constant CHARACTER := nut;     SOH      : constant CHARACTER := soh;

  STX       : constant CHARACTER := stx;     ETX      : constant CHARACTER := etx:

  EOT       : constant CHARACTER := eot;     ENQ      : constant CHARACTER := enq;

  ACK       : constant CHARACTER := ack;     BEL      : constant CHARACTER := bel;

  BS        : constant CHARACTER := bs:      HT       : constant CHARACTER := ht;

  LF        : constant CHARACTER := lf;      VT       : constant CHARACTER := vf;

  FF        : constant CHARACTER := ff;      CR       : constant CHARACTER := cr;

  SO        : constant CHARACTER := so;      SI       : constant CHARACTER := si;

  DLE       : constant CHARACTER := die;     DC1      : constant CHARACTER := del;

  DC2       : constant CHARACTER := dc2;     DC3      : constant CHARACTER := dc3;

  DC4       : constant CHARACTER := dc4;     NAK      : constant CHARACTER := nak;

  SYN       : constant CHARACTER := syn;     ETB      : constant CHARACTER := etb;

  CAN       : constant CHARACTER := can;     EM       : constant CHARACTER := em;

  SUB       : constant CHARACTER := sub;     ESC      : constant CHARACTER := esc;

  FS        : constant CHARACTER := fs;      GS       : constant CHARACTER := gs;

  RS        : constant CHARACTER := rs;      US       : constant CHARACTER := us;

  DEL       : constant CHARACTER := del;

  

  -- Autres caractères :

  

  EXCLAM    : constant CHARACTER := '|';   QUOTATION  : constant CHARACTER = '"';

  SHARP     : constant CHARACTER := '#';   DOLLAR     : constant CHARACTER = '$';

  PERCENT   : constant CHARACTER := '%';   AMPERSAND  : constant CHARACTER = '&';

  COLON     : constant CHARACTER := ':';   SEMICOLON  : constant CHARACTER = ';';

  QUERY     : constant CHARACTER := '?';   AT_SIGN    : constant CHARACTER = '@';

  L_BRACKET : constant CHARACTER := '[';   BACK_SLASH : constant CHARACTER = '\';

  R_BRACKET : constant CHARACTER := ']';   CIRCUMFLEX : constant CHARACTER = '~';

  UNDERLINE : constant CHARACTER := '_';   GRAVE      : constant CHARACTER = '`';

  L_BRACE   : constant CHARACTER := '{';   BAR        : constant CHARACTER = '|';

  R_BRACE   : constant CHARACTER := '}';   TILDE      : constant CHARACTER = '~';

 
  -- Lettres minuscules :

  

  LC_A      : constant CHARACTER := 'a';

  LC_Z      : constant CHARACTER := 'z';

 
end ASCII;

 
  -- Sous-types prédéfinis :

  subtype NATURAL  is INTEGER range 0 .. INTEGER'LAST;

  subtype POSITIVE is INTEGER range 1 .. INTEGER'LAST;

  

  -- Type de chaîne prédéfini :

  

  type STRING is array(POSITIVE range <>) of CHARACTER;

  

  pragma PACK(STRING);

  

  -- Les opérateurs prédéfinis pour ce type sont les suivants :

  

  -- function "="  (LEFT, RIGHT : STRING) return BOOLEAN;

  -- function "/=" (LEFT, RIGHT : STRING) return BOOLEAN;

  -- function ">"  (LEFT, RIGHT : STRING) return BOOLEAN;

  -- function "<=" (LEFT, RIGHT : STRING) return BOOLEAN;

  -- function ">"  (LEFT, RIGHT : STRING) return BOOLEAN;

  -- function ">=" (LEFT, RIGHT : STRING) return BOOLEAN;

  

  -- function "&"  (LEFT : STRING;    RIGHT : STRING)    return STRING;

  -- function "&"  (LEFT : CHARACTER; RIGHT : STRING)    return STRING;

  -- function "&"  (LEFT : STRING;    RIGHT : CHARACTER) return STRING;

  -- function "&"  (LEFT : CHARACTER; RIGHT : CHARACTER) return STRING;

  

  type DURATION is delta implementation_defined range implementation_defined;

  

  -- Les opérateurs prédéfinis pour le type DURATION sont les mêmes que pour tout type à virgule fixe.

  

  -- Les exceptions prédéfinies :

  

  CONSTRAINT_ERROR : exception;  

  NUMERIC_ERROR    : exception;

  PROGRAM_ERROR    : exception;

  STORAGE_ERROR    : exception;

  TASKING_ERROR    : exception;

 
end STANDARD;

Certains aspects des entités prédéfinies ne peuvent pas être complètement décrits dans le langage lui-même. Par exemple, bien que le type d'énumération BOOLEAN puisse être écrit en montrant les deux littéraux d'énumération FALSE et TRUE, les formes de contrôle de court-circuit ne peuvent pas être exprimées dans le langage.

Remarque : la définition du langage prédéfinit les unités de bibliothèque suivantes :

Le paquet CALENDAR
Le paquet SYSTEM
Le paquet MACHINE_CODE (si fourni)
La procédure générique UN CHECKED_DEALLOCATION
La fonction générique UNCHECKED_CONVERSION
Le paquet générique SEQUENTIAL_IO
Le paquet générique DIRECT_IO
Le paquet TEXT_IO
Le paquet IO_EXCEPTIONS
Le paquet LOW_LEVEL_IO

Dernière mise à jour : Mardi, le 7 janvier 2025

Section courante

A propos

Section administrative du site

Environnement de langage prédéfini