Langage de programmation - Ada - Les entrées-sorties

Les entrées-sorties

Les entrées-sorties sont fournies dans le langage au moyen de paquets prédéfinis. Les paquets génériques SEQUENTIAL_IO et DIRECT_IO définissent les opérations d'entrée-sortie applicables aux fichiers contenant des éléments d'un type donné. Des opérations supplémentaires pour les entrées-sorties de texte sont fournies dans le paquet TEXT_IO. Le paquet IO_EXCEPTIONS définit les exceptions nécessaires aux trois paquets ci-dessus. Enfin, un paquet LOW_LEVEL_IO est fourni pour le contrôle direct des périphériques.

Fichiers externes et objets fichiers

Les valeurs entrées depuis l'environnement externe du programme, ou sorties vers l'environnement, sont considérées comme occupant des fichiers externes. Un fichier externe peut être tout élément extérieur au programme pouvant produire une valeur à lire ou recevoir une valeur à écrire. Un fichier externe est identifié par une chaîne (le nom). Une deuxième chaîne (le formulaire) donne d'autres caractéristiques dépendantes du système pouvant être associées au fichier, telles que l'organisation physique ou les droits d'accès.

Les opérations d'entrée et de sortie sont exprimées comme des opérations sur des objets d'un type de fichier, plutôt que directement en termes de fichiers externes. Dans le reste de cette page, le terme fichier est toujours utilisé pour désigner un objet fichier; le terme fichier externe est utilisé dans les autres cas. Les valeurs transférées pour un fichier donné doivent toutes être d'un même type.

L'entrée-sortie pour les fichiers séquentiels de valeurs d'un seul type d'élément est définie au moyen du paquet générique SEQUENTIAL_IO. Le squelette de ce paquet est donné ci-dessous.



with IO_EXCEPTIONS;

generic

  type ELEMENT_TYPE is private;

package SEQUENTIAL_IO is

  type FILE_TYPE is limited private;

 
  type FILE_MODE is (IN_FILE, OUT_FILE);

  ...

  procedure OPEN (FILE : in out FILE_TYPE; ...);

  ...

  procedure READ (FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE);

  procedure WRITE (FILE : in FILE_TYPE; ITEM : in ELEMENT_TYPE);

  ...

end SEQUENTIAL_IO;

Afin de définir une entrée-sortie séquentielle pour un type d'élément donné, une instanciation de cette unité générique, avec le type donné comme paramètre réel, doit être déclarée. Le paquet résultant contient la déclaration d'un type de fichier (appelé FILE_TYPE) pour les fichiers de tels éléments, ainsi que les opérations applicables à ces fichiers, telles que les procédures OPEN, READ et WRITE.

Les entrées-sorties pour les fichiers à accès direct sont également définies par un paquet générique appelé DIRECT_IO. Les entrées-sorties sous une forme lisible par l'homme sont définies par le paquet (non générique) TEXT_IO.

Avant que des opérations d'entrée ou de sortie puissent être effectuées sur un fichier, le fichier doit d'abord être associé à un fichier externe. Tant qu'une telle association est en vigueur, le fichier est dit ouvert, et sinon, le fichier est dit fermé.

Le langage de programmation ne définit pas ce qui arrive aux fichiers externes après la fin du programme principal (en particulier, si les fichiers correspondants n'ont pas été fermés). L'effet des entrées-sorties pour les types d'accès dépend de l'implémentation.

Un fichier ouvert a un mode courant, étant une valeur de l'un des types d'énumération :



type FILE_MODE is (IN_FILE, INOUT_FILE, OUT_FILE); -- pour DIRECT_IO

type FILE_MODE is (IN_FILE, OUT_FILE);             -- pour SEQUENTIAL_IO et TEXT_IO

Ces valeurs correspondent respectivement aux cas où seule la lecture, à la fois la lecture et l'écriture, ou seule l'écriture doivent être effectuées. Le mode d'un fichier peut être modifié.

Plusieurs opérations de gestion de fichiers sont communes aux trois paquets d'entrées-sorties.

Les exceptions pouvant être levées par un appel d'un sous-programme d'entrées-sorties sont toutes définies dans le paquet IO_EXCEPTIONS; les situations dans lesquelles elles peuvent être levées sont décrites, soit à la suite de la description du sous-programme, soit dans l'annexe F dans le cas de situations d'erreur dépendantes de l'implémentation.

Notes : Chaque instanciation des paquets génériques SEQUENTIAL_IO et DIRECT_IO déclare un type FILE_TYPE différent; dans le cas de TEXT_IO, le type FILE_TYPE est unique.

Un périphérique bidirectionnel peut souvent être modélisé comme deux fichiers séquentiels associés au périphérique, l'un en mode IN_FILE et l'autre en mode OUT_FILE. Une implémentation peut restreindre le nombre de fichiers pouvant être associés à un fichier externe donné. L'effet du partage d'un fichier externe de cette manière par plusieurs objets fichier dépend de l'implémentation.

Fichiers séquentiels et directs

Deux types d'accès aux fichiers externes sont définis : l'accès séquentiel et l'accès direct. Les types de fichiers correspondants et les opérations associées sont fournis par les paquets génériques SEQUENTIAL_IO et DIRECT_IO. Un objet fichier à utiliser pour l'accès séquentiel est appelé fichier séquentiel, et un objet fichier à utiliser pour l'accès direct est appelé fichier direct.

Pour l'accès séquentiel, le fichier est considéré comme une séquence de valeurs étant transférées dans l'ordre de leur apparition (tel que produit par le programme ou par l'environnement). Lorsque le fichier est ouvert, le transfert commence depuis le début du fichier.

Pour un accès direct, le fichier est considéré comme un ensemble d'éléments occupant des positions consécutives dans un ordre linéaire; une valeur peut être transférée vers ou depuis un élément du fichier à n'importe quelle position sélectionnée. La position d'un élément est spécifiée par son index, qui est un nombre, supérieur à zéro, du type entier COUNT défini par l'implémentation. Le premier élément, le cas échéant, a un index un; l'index du dernier élément, le cas échéant, est appelé la taille actuelle; la taille actuelle est zéro s'il n'y a aucun élément. La taille actuelle est une propriété du fichier externe.

Un fichier direct ouvert a un index actuel, étant l'index étant utilisé par la prochaine opération de lecture ou d'écriture. Lorsqu'un fichier direct est ouvert, l'index actuel est défini sur un. L'index actuel d'un fichier direct est une propriété d'un objet fichier, et non d'un fichier externe.

Les trois modes de fichier sont autorisés pour les fichiers directs. Les seuls modes autorisés pour les fichiers séquentiels sont les modes IN_FILE et OUT_FILE.

Gestion des fichiers

Les procédures et fonctions décrites dans cette section permettent de contrôler les fichiers externes; leurs déclarations sont répétées dans chacun des trois paquets pour les entrées-sorties séquentielles, directes et de texte. Pour les entrées-sorties de texte, les procédures CREATE, OPEN et RESET ont des effets supplémentaires décrits plus loin.

procedure CREATE(FILE : in out FILE_TYPE;
                  MODE : in FILE_MODE := defauit_mode;
                  NAME : in STRING := "";
                  FORM : in STRING := "");

Crée un nouveau fichier externe, avec le nom et la forme donnés, et associe ce fichier externe au fichier donné. Le fichier donné est laissé ouvert. Le mode actuel du fichier donné est défini sur le mode d'accès donné. Le mode d'accès par défaut est le mode OUT_FILE pour les entrées-sorties séquentielles et texte; c'est le mode INOUT_FILE pour les entrées-sorties directes. Pour un accès direct, la taille du fichier créé dépend de l'implémentation. Une chaîne de caractères nulle pour NAME spécifie un fichier externe n'étant pas accessible après la fin du programme principal (un fichier temporaire). Une chaîne de caractères nulle pour FORM spécifie l'utilisation des options par défaut de l'implémentation pour le fichier externe.

L'exception STATUS_ERROR est levée si le fichier donné est déjà ouvert. L'exception NAME_ERROR est levée si la chaîne donnée comme NAME ne permet pas l'identification d'un fichier externe. L'exception USE_ERROR est levée si, pour le mode spécifié, l'environnement ne prend pas en charge la création d'un fichier externe avec le nom donné (en l'absence de NAME_ERROR) et la forme.

procedure OPEN(FILE : in out FILE_TYPE;
                MODE : in FILE_MODE;
                NAME : in STRING;
                FORM : in STRING := "");

Associe le fichier donné à un fichier externe existant ayant le nom et la forme donnés, et définit le mode actuel du fichier donné sur le mode donné. Le fichier donné reste ouvert.

L'exception STATUS_ERROR est levée si le fichier donné est déjà ouvert. L'exception NAME_ERROR est levée si la chaîne donnée comme NAME ne permet pas l'identification d'un fichier externe ; en particulier, cette exception est levée si aucun fichier externe avec le nom donné n'existe. L'exception USE_ERROR est levée si, pour le mode spécifié, l'environnement ne prend pas en charge l'ouverture d'un fichier externe avec le nom (en l'absence de NAME_ERROR) et le format donnés.

procedure CLOSE(FILE : in out FILE-TYPE);

Rompt l'association entre le fichier donné et son fichier externe associé. Le fichier donné reste fermé.

L'exception STATUS_ERROR est levée si le fichier donné n'est pas ouvert.

procedure DELETE(FILE : in out FILE-TYPE);

Supprime le fichier externe associé au fichier donné. Le fichier donné est fermé et le fichier externe cesse d'exister.

L'exception STATUS_ERROR est levée si le fichier donné n'est pas ouvert. L'exception USE_ERROR est levée si la suppression du fichier externe n'est pas prise en charge par l'environnement.

procedure RESET(FILE : in out FILE_TYPE; MODE : in FILE-MODE);

procedure RESET(FILE : in out FILE-TYPE);

Réinitialise le fichier donné de sorte que la lecture ou l'écriture de ses éléments puisse être redémarrée depuis le début du fichier; en particulier, pour un accès direct, cela signifie que l'index actuel est défini sur un. Si un paramètre MODE est fourni, le mode actuel du fichier donné est défini sur le mode donné.

L'exception STATUS-ERROR est levée si le fichier n'est pas ouvert. L'exception USE-ERROR est levée si l'environnement ne prend pas en charge la réinitialisation pour le fichier externe et, également, si l'environnement ne prend pas en charge la réinitialisation au mode spécifié pour le fichier externe.

function MODE(FILE : in FILE-TYPE) return FILE-MODE

Renvoie le mode actuel du fichier donné.

L'exception STATUS-ERROR est levée si le fichier n'est pas ouvert.

function NAME(FILE : in FILE-TYPE) return STRING;

Renvoie une chaîne identifiant de manière unique le fichier externe actuellement associé au fichier donné (et peut donc être utilisé dans une opération OPEN). Si un environnement autorise des spécifications alternatives du nom (par exemple, des abréviations), la chaîne renvoyée par la fonction doit correspondre à une spécification complète du nom.

L'exception STATUS-ERROR est levée si le fichier donné n'est pas ouvert.

function FORM(FILE : in FILE_TYPE) return STRING;

Renvoie la chaîne de formulaire pour le fichier externe actuellement associé au fichier donné. Si un environnement autorise des spécifications alternatives du formulaire (par exemple, des abréviations utilisant des options par défaut), la chaîne renvoyée par la fonction doit correspondre à une spécification complète (c'est-à-dire qu'elle doit indiquer explicitement toutes les options sélectionnées, y compris les options par défaut).

L'exception STATUS_ERROR est levée si le fichier donné n'est pas ouvert.

function IS_OPEN(FILE : in FILE_TYPE) return BOOLEAN;

Renvoie TRUE si le fichier est ouvert (c'est-à-dire s'il est associé à un fichier externe), sinon renvoie FALSE.

Entrée-sortie séquentielle

Les opérations disponibles pour l'entrée et la sortie séquentielles sont décrites dans cette section. L'exception STATUS_ERROR est générée si l'une de ces opérations est tentée pour un fichier n'étant pas ouvert.

procedure READ(FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE);

Opère sur un fichier de mode IN_FILE. Lit un élément du fichier donné et renvoie la valeur de cet élément dans le paramètre ITEM.

L'exception MODE_ERROR est levée si le mode n'est pas IN_FILE. L'exception END_ERROR est levée si aucun autre élément ne peut être lu dans le fichier donné. L'exception DATA_ERROR est levée si l'élément lu ne peut pas être interprété comme une valeur de type ELEMENT_TYPE ; cependant, une implémentation est autorisée à omettre cette vérification si l'exécution de la vérification est trop complexe.

procedure WRITE(FILE : in FILE_TYPE; ITEM : in ELEMENT_TYPE);

Fonctionne sur un fichier de mode OUT_FILE. Écrit la valeur de ITEM dans le fichier donné. L'exception MODE_ERROR est levée si le mode n'est pas OUT_FILE.

L'exception USE_ERROR est levée si la capacité du fichier externe est dépassée.

function END_OF_FILE(FILE : in FILE_TYPE) return BOOLEAN;

Fonctionne sur un fichier de mode IN_FILE . Renvoie TRUE si aucun autre élément ne peut être lu à partir du fichier donné ; sinon, renvoie FALSE.

L'exception MODE_ERROR est levée si le mode n'est pas IN_FILE.



with IO_EXCEPTIONS;

generic

  type ELEMENT_TYPE is private;

package SEQUENTIAL_IO is

 
  type FILE_TYPE is limited private;

  type FILE_MODE is (IN_FILE, OUT_FILE);

  

  -- Gestion des fichiers

  procedure CREATE (FILE : in out FILE_TYPE;

                    MODE : in FILE_MODE := OUT_FILE;

                    NAME : in STRING := "";

                    FORM : STRING := "");

 
  procedure OPEN (FILE : in out FILE_TYPE;

                  MODE : in FILE_MODE;

                  NAME : in STRING;

                  FORM : in STRING := "");

 
  procedure CLOSE  (FILE : in out FILE_TYPE);

  procedure DELETE (FILE : in out FILE_TYPE);

  procedure RESET  (FILE : in out FILE.TYPE; MODE : in FILE_MODE);

  procedure RESET  (FILE : in out FILE_TYPE);

  

  function MODE    (FILE : in FILE_TYPE) return FILE_MODE;

  function NAME    (FILE : in FILE_TYPE) return STRING;

  function FORM    (FILE : in FILE_TYPE) return STRING;

  

  function IS_OPEN (FILE : in FILE_TYPE) return BOOLEAN;

  

  -- Opération d'entrée et de sortie

  

  procedure READ  (FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE);

  procedure WRITE (FILE : in FILE_TYPE; ITEM : in  ELEMENT_TYPE);

 
  function END_OF_FILE(FILE : in FILE_TYPE) return BOOLEAN;

 
  -- Exceptions

  

  STATUS_ERROR    : exception renames IO_EXCEPTIONS.STATUS_ERROR;

  MODE_ERROR      : exception renames IO_EXCEPTIONS.MODE_ERROR;

  NAME_ERROR      : exception renames IO_EXCEPTIONS.NAME_ERROR;

  USE_ERROR       : exception renames IO_EXCEPTIONS.USE_ERROR;

  DEVICE_ERROR    : exception renames IO_EXCEPTIONS.DEVICE_ERROR;

  END_ERROR       : exception renames IO_EXCEPTIONS.END_ERROR;

  DATA_ERROR      : exception renames IO_EXCEPTIONS.DATA_ERROR;

 
private

  -- dépendant de l'implémentation

end SEQUENTIAL_IO;

Entrée-sortie directe

Les opérations disponibles pour l'entrée et la sortie directes sont décrites dans cette section. L'exception STATUS_ERROR est levée si l'une de ces opérations est tentée pour un fichier qui n'est pas ouvert.

procedure READ(FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE;
FROM : in POSITIVE_COUNT);

procedure READ(FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE);

Opère sur un fichier de mode IN_FILE ou INOUT_FILE. Dans le cas de la première forme, définit l'index courant du fichier donné à la valeur d'index donnée par le paramètre FROM. Puis (pour les deux formes) renvoie, dans le paramètre ITEM, la valeur de l'élément dont la position dans le fichier donné est spécifiée par l'index courant du fichier; enfin, augmente l'index courant d'une unité.

L'exception MODE_ERROR est levée si le mode du fichier donné est OUT_FILE. L'exception END_ERROR est levée si l'index à utiliser dépasse la taille du fichier externe. L'exception DATA_ERROR est levée si l'élément lu ne peut pas être interprété comme une valeur de type ELEMENT_TYPE ; cependant, une implémentation est autorisée à omettre cette vérification si l'exécution de la vérification est trop complexe.

procedure WRITE(FILE : in FILE_TYPE; ITEM : in ELEMENT_TYPE;
TO : in POSITIVE_COUNT);

procedure WRITE(FILE : in FILE_TYPE; ITEM : in ELEMENT_TYPE);

Fonctionne sur un fichier de mode INOUT_FILE ou OUT_FILE. Dans le cas de la première forme, définit l'index du fichier donné à la valeur d'index donnée par le paramètre TO. Ensuite (pour les deux formes) donne la valeur du paramètre ITEM à l'élément dont la position dans le fichier donné est spécifiée par l'index courant du fichier ; enfin, augmente l'index courant d'une unité.

L'exception MODE_ERROR est levée si le mode du fichier donné est IN_FILE. L'exception USE_ERROR est levée si la capacité du fichier externe est dépassée.

procedure SET_INDEX(FILE : in FILE_TYPE; TO : in POSITIVE_COUNT);

Fonctionne sur un fichier de n'importe quel mode. Définit l'index actuel du fichier donné sur la valeur d'index donnée (pouvant dépasser la taille actuelle du fichier).

function INDEX(FILE : in FILE_TYPE) return POSITIVE_COUNT;

Fonctionne sur un fichier de n'importe quel mode. Renvoie l'index actuel du fichier donné.

function SIZE(FILE : in FILE_TYPE) return COUNT;

Fonctionne sur un fichier de n'importe quel mode. Renvoie la taille actuelle du fichier externe associé au fichier donné.

function END_OF_FILE(FILE : in FILE_TYPE) return BOOLEAN;

Fonctionne sur un fichier de mode IN_FILE ou INOUT_FILE. Renvoie TRUE si l'index actuel dépasse la taille du fichier externe ; sinon, renvoie FALSE.

L'exception MODE_ERROR est levée si le mode du fichier donné est OUT_FILE.

Spécification du paquet Direct_IO



with IO_EXCEPTIONS;

generic

  type ELEMENT_TYPE is private;

package DIRECT_IO is

 
  type FILE_TYPE is limited private;

  type FILE_MODE is (IN_FILE, INOUT_FILE, OUT_FILE);

  type COUNT is range 0 .. implementation_defined;

  subtype POSITIVE_CQUNT is COUNT range 1 .. COUNT'LAST;

 
  -- Gestion des fichiers

 

  procedure CREATE ( FILE : in out FILE_TYPE;

                     MODE : in FILE_MODE := INOUT_FILE;

                     NAME : in STRING := "";

                     FORM : in STRING := "");

 
  procedure OPEN   ( FILE : in out FILE_TYPE;

                     MODE : in FILE_MODE;

                     NAME : in STRING;

                     FORM : in STRING := "");

 
  procedure CLOSE  (FILE : in out FILE_TYPE);

  procedure DELETE (FILE : in out FILE_TYPE);

  procedure RESET  (FILE : in out FILE_TYPE; MODE : in FILE_MODE);

  procedure RESET  (FILE : in out FILE_TYPE);

 
  function MODE    (FILE : in FILE_TYPE) return FILE_MODE;

  function NAME    (FILE : in FILE_TYPE) return STRING;

  function FORM    (FILE : in FILE_TYPE) return STRING;

  function IS_OPEN (FILE : in FILE_TYPE) return BOOLEAN;

 
  -- Opérations d'entrée et de sortie

  

  procedure READ (FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE; FROM : POSITIVE_COUNT);

  procedure READ (FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE);

 
  procedure WRITE (FILE : in FILE_TYPE; ITEM : in ELEMENT_TYPE; TO : POSITIVE_COUNT);

  procedure WRITE (FILE : in FILE_TYPE; ITEM : in ELEMENT_TYPE);

 
  procedure SET_INDEX(FILE : in FILE_TYPE; TO : in POSITIVE_COUNT);

 
  function INDEX (FILE : in FILE_TYPE) return POSITIVE_COUNT;

  function SIZE (FILE : in FILE_TYPE) return COUNT;

 
  function END_OF_FILE (FILE : in FILE_TYPE) return BOOLEAN;

 

  -- Exceptions

 
  STATUS_ERROR  : exception renames IO_EXCEPTIONS.STATUS_ERROR;

  MODE_ERROR    : exception renames IO_EXCEPTIONS.MODE_ERROR;

  NAME_ERROR    : exception renames IO_EXCEPTIONS.NAME_ERROR;

  USE_ERROR     : exception renames IO_EXCEPTIONS.USE_ERROR;

  DEVICE_ERROR  : exception renames IO_EXCEPTIONS.DEVICE_ERROR;

  END_ERROR     : exception renames IO_EXCEPTIONS.END_ERROR;

  DATA_ERROR    : exception renames IO_EXCEPTIONS.DATA_ERROR;

 
private

  -- dépendant de l'implémentation

end DIRECT_IO;

Entrée-sortie de texte

Cette section décrit le paquet TEXT_IO, fournissant des fonctions d'entrée et de sortie sous une forme lisible par l'homme. Chaque fichier est lu ou écrit séquentiellement, sous forme de séquence de caractères groupés en lignes, et sous forme de séquence de lignes groupées en pages.

Les fonctions de gestion de fichiers données ci-dessus, sont disponibles pour l'entrée-sortie de texte. Cependant, à la place de READ et WRITE, il existe des procédures GET et PUT saisissant des valeurs de types appropriés à partir de fichiers texte, et leur envoient des valeurs en sortie. Ces valeurs sont fournies aux procédures PUT, et renvoyées par les procédures GET, dans un paramètre ITEM. Plusieurs procédures surchargées de ces noms existent, pour différents types d'ITEM. Ces procédures GET analysent les séquences de caractères en entrée comme des éléments lexicaux et renvoient les valeurs correspondantes ; les procédures PUT renvoient les valeurs données comme des éléments lexicaux appropriés. Les procédures GET et PUT sont également disponibles, saisissant et génèrent des caractères individuels traités comme des valeurs de caractères plutôt que comme des éléments lexicaux.

En plus des procédures GET et PUT pour les types numériques et d'énumération d'ITEM fonctionnant sur des fichiers texte, des procédures analogues sont fournies pour lire et écrire dans un paramètre de type STRING. Ces procédures effectuent la même analyse et la même composition de séquences de caractères que leurs homologues ayant un paramètre de fichier.

Pour toutes les procédures GET et PUT fonctionnant sur des fichiers texte, et pour de nombreux autres sous-programmes, il existe des formulaires avec et sans paramètre de fichier. Chaque procédure GET fonctionne sur un fichier d'entrée et chaque procédure PUT fonctionne sur un fichier de sortie. Si aucun fichier n'est spécifié, un fichier d'entrée par défaut ou un fichier de sortie par défaut est utilisé.

Au début de l'exécution du programme, les fichiers d'entrée et de sortie par défaut sont ce que l'on appelle le fichier d'entrée standard et le fichier de sortie standard. Ces fichiers sont ouverts, ont respectivement les modes actuels IN_FILE et OUT_FILE, et sont associés à deux fichiers externes définis par l'implémentation. Des procédures sont fournies pour modifier le fichier d'entrée par défaut actuel et le fichier de sortie par défaut actuel.

D'un point de vue logique, un fichier texte est une séquence de pages, une page est une séquence de lignes et une ligne est une séquence de caractères ; la fin d'une ligne est marquée par un terminateur de ligne, la fin d'une page est marquée par la combinaison d'un terminateur de ligne immédiatement suivi d'un terminateur de page ; et la fin d'un fichier est marquée par la combinaison d'un terminateur de ligne immédiatement suivi d'un terminateur de page puis d'un terminateur de fichier. Les terminateurs sont générés pendant la sortie ; soit par des appels de procédures prévues expressément à cet effet ; soit implicitement dans le cadre d'autres opérations, par exemple, lorsqu'une longueur de ligne limitée, une longueur de page limitée ou les deux ont été spécifiées pour un fichier.

La nature réelle des terminateurs n'est pas définie par le langage et dépend donc de l'implémentation. Bien que les terminateurs soient reconnus ou générés par certaines des procédures qui suivent, ils ne sont pas nécessairement implémentés sous forme de caractères ou de séquences de caractères. Qu'il s'agisse de caractères (et si oui lesquels) dans une implémentation particulière ne doit pas concerner un utilisateur qui n'affiche ni ne saisit explicitement de caractères de contrôle. L'effet de l'entrée ou de la sortie de caractères de contrôle (autre que la tabulation horizontale) n'est pas défini par le langage.

Les caractères d'une ligne sont numérotés, en commençant par un ; le numéro d'un caractère est appelé son numéro de colonne. Pour un terminateur de ligne, un numéro de colonne est également défini : il est supérieur de un au nombre de caractères de la ligne. Les lignes d'une page et les pages d'un fichier sont numérotées de la même manière. Le numéro de colonne actuel est le numéro de colonne du prochain caractère ou terminateur de ligne à transférer. Le numéro de ligne actuel est le numéro de la ligne actuelle. Le numéro de page actuel est le numéro de la page actuelle. Ces numéros sont des valeurs du sous-type POSITIVE_COUNT du type COUNT (par convention, la valeur zéro du type COUNT est utilisée pour indiquer des conditions spéciales).



type COUNT is range 0 .. implementation_defined;

subtype POSITIVE_COUNT is COUNT range 1 .. COUNT'LAST;

Pour un fichier de sortie, une longueur maximale de ligne et une longueur maximale de page peuvent être spécifiées. Si une valeur à sortir ne peut pas tenir sur la ligne courante, pour une longueur de ligne maximale spécifiée, une nouvelle ligne est automatiquement démarrée avant que la valeur ne soit sortie; si, en outre, cette nouvelle ligne ne peut pas tenir sur la page courante, pour une longueur de page maximale spécifiée, une nouvelle page est automatiquement démarrée avant que la valeur ne soit sortie. Des fonctions sont fournies pour déterminer la longueur maximale de ligne et la longueur maximale de page. Lorsqu'un fichier est ouvert avec le mode OUT_FILE, les deux valeurs sont nulles : par convention, cela signifie que les longueurs de ligne et de page ne sont pas limitées. (Par conséquent, la sortie se compose d'une seule ligne si les sous-programmes de contrôle explicite de la structure de ligne et de page ne sont pas utilisés.) La constante UNBOUNDED est fournie à cet effet.

Gestion des fichiers

Les seuls modes de fichiers autorisés pour les fichiers texte sont les modes IN_FILE et OUT_FILE. Il existe également une version de END_OF_FILE faisant référence au fichier d'entrée par défaut actuel. Pour les fichiers texte, les procédures ont les effets supplémentaires suivants :

Pour les procédures CREATE et OPEN : après l'ouverture d'un fichier avec le mode OUT_FILE, la longueur de page et la longueur de ligne sont illimitées (elles ont toutes deux la valeur conventionnelle zéro). Après l'ouverture d'un fichier avec le mode IN_FILE ou OUT_FILE, les numéros de colonne, de ligne et de page courants sont définis sur un.
Pour la procédure CLOSE : si le fichier a le mode actuel OUT_FILE , a pour effet d'appeler NEW_PAGE, sauf si la page courante est déjà terminée ; génère alors un terminateur de fichier.
Pour la procédure RESET : si le fichier a le mode actuel OUT_FILE , a pour effet d'appeler NEW_PAGE, sauf si la page courante est déjà terminée ; génère alors un terminateur de fichier. Si le nouveau mode de fichier est OUT_FILE, les longueurs de page et de ligne sont illimitées. Pour tous les modes, les numéros de colonne, de ligne et de page courants sont définis sur un.

L'exception MODE_ERROR est levée par la procédure RESET lors d'une tentative de modification du mode d'un fichier étant soit le fichier d'entrée par défaut actuel, soit le fichier de sortie par défaut actuel.

Fichiers d'entrée et de sortie par défaut

Les sous-programmes suivants permettent de contrôler les fichiers par défaut particuliers qui sont utilisés lorsqu'un paramètre de fichier est omis d'une opération GET, PUT ou autre opération d'entrée-sortie de texte décrite ci-dessous.

procedure SET_INPUT(FILE : in FILE.TYPE);

Fonctionne sur un fichier de mode IN_FILE. Définit le fichier d'entrée par défaut actuel sur FILE. L'exception STATUS_ERROR est levée si le fichier donné n'est pas ouvert. L'exception MODE_ERROR est levée si le mode du fichier donné n'est pas IN_FILE.

procedure SET_OUTPUT(FILE : in FILE_TYPE);

Fonctionne sur un fichier de mode OUT_FILE. Définit le fichier de sortie par défaut actuel sur FILE.

L'exception STATUS_ERROR est levée si le fichier donné n'est pas ouvert. L'exception MODE_ERROR est levée si le mode du fichier donné n'est pas OUT_FILE.

function STANDARD_INPUT return FILE_TYPE;

Renvoie le fichier d'entrée standard.

function STANDARD_OUTPUT return FILE_TYPE;

Renvoie le fichier de sortie standard.

function CURRENT_INPUT return FILE_TYPE;

Renvoie le fichier d'entrée par défaut actuel.

function CURRENT_OUTPUT return F!LE_TYPE;

Renvoie le fichier de sortie par défaut actuel.

Remarque : les fichiers d'entrée standard et de sortie standard ne peuvent pas être ouverts, fermés, réinitialisés ou supprimés, car le paramètre FILE des procédures correspondantes a le mode in out.

Spécification des longueurs de ligne et de page

Les sous-programmes décrits dans cette section concernent la structure de ligne et de page d'un fichier de mode OUT_FILE. Ils fonctionnent soit sur le fichier donné comme premier paramètre, soit, en l'absence d'un tel paramètre de fichier, sur le fichier de sortie par défaut actuel. Ils permettent la sortie de texte avec une longueur de ligne ou de page maximale spécifiée. Dans ces cas, les terminateurs de ligne et de page sont générés implicitement et automatiquement lorsque cela est nécessaire. Lorsque les longueurs de ligne et de page ne sont pas limitées (c'est-à-dire lorsqu'elles ont la valeur conventionnelle zéro), comme dans le cas d'un fichier nouvellement ouvert, de nouvelles lignes et de nouvelles pages ne sont démarrées que lorsqu'elles sont explicitement demandées.

Dans tous les cas, l'exception STATUS_ERROR est levée si le fichier à utiliser n'est pas ouvert ; l'exception MODE_ERROR est levée si le mode du fichier n'est pas OUT_FILE.

procedure SET_LINE_LENGTH(FILE : in FILE_TYPE; TO : in COUNT);

procedure SET_LINE_LENGTH(TO : in COUNT);

Définit la longueur de ligne maximale du fichier de sortie spécifié sur le nombre de caractères spécifié par TO. La valeur zéro pour TO spécifie une longueur de ligne illimitée.

L'exception USE_ERROR est générée si la longueur de ligne spécifiée est inappropriée pour le fichier externe associé.

procedure SET_PAGE_LENGTH (FILE : in FILE_TYPE; TO : in COUNT);

procedure SET_PAGE_LENGTH (TO : in COUNT);

Définit la longueur de page maximale du fichier de sortie spécifié sur le nombre de lignes spécifié par TO. La valeur zéro pour TO spécifie une longueur de page illimitée.

L'exception USE_ERROR est générée si la longueur de page spécifiée est inappropriée pour le fichier externe associé.

function LINE_LENGTH(FILE : in FILE_TYPE) return COUNT;

function LINE_LENGTH return COUNT;

Renvoie la longueur de ligne maximale actuellement définie pour le fichier de sortie spécifié, ou zéro si la longueur de ligne n'est pas limitée.

function PAGE_LENGTH(FILE : in FILE._TYPE) return COUNT;

function PAGE_LENGTH return COUNT;

Renvoie la longueur de page maximale actuellement définie pour le fichier de sortie spécifié, ou zéro si la longueur de page n'est pas limitée.

Opérations sur les colonnes, les lignes et les pages

Les sous-programmes décrits dans cette section permettent de contrôler explicitement la structure des lignes et des pages ; ils opèrent soit sur le fichier donné comme premier paramètre, soit, en l'absence d'un tel paramètre de fichier, sur le fichier par défaut courant approprié (d'entrée ou de sortie). L'exception STATUS_ERROR est levée par l'un de ces sous-programmes si le fichier à utiliser n'est pas ouvert.

procedure NEW_LINE(FILE : in FILE_TYPE; SPACING : in POSITIVE_COUNT := 1);

procedure NEW_LINE(SPACING : in POSITIVE_COUNT := 1);

Fonctionne sur un fichier de mode OUT_FILE.

Pour un SPACING de un : génère un terminateur de ligne et définit le numéro de colonne actuel sur un. Puis incrémente le numéro de ligne actuel de un, sauf dans le cas où le numéro de ligne actuel est déjà supérieur ou égal à la longueur de page maximale, pour une longueur de page limitée ; dans ce cas, un terminateur de page est généré, le numéro de page actuel est incrémenté de un et le numéro de ligne actuel est défini sur un.

Pour un SPACING supérieur à un, les actions ci-dessus sont effectuées SPACING fois.

L'exception MODE_ERROR est levée si le mode n'est pas OUT_FILE.

procedure SKIP_LINE(FILE : in FILE_TYPE; SPACING : in POSITIVE_COUNT := 1);

procedure SKIP_LINE(SPACING : in POSITIVE_COUNT := 1);

Fonctionne sur un fichier de mode IN_FILE.

Pour un SPACING de un : lit et supprime tous les caractères jusqu'à ce qu'un terminateur de ligne ait été lu, puis définit le numéro de colonne actuel sur un. Si le terminateur de ligne n'est pas immédiatement suivi d'un terminateur de page, le numéro de ligne actuel est incrémenté de un. Sinon, si le terminateur de ligne est immédiatement suivi d'un terminateur de page, le terminateur de page est ignoré, le numéro de page actuel est incrémenté de un et le numéro de ligne actuel est défini sur un.

Pour un SPACING supérieur à un, les actions ci-dessus sont effectuées SPACING fois.

L'exception MODE_ERROR est levée si le mode n'est pas IN_FILE. L'exception END_ERROR est levée si une tentative de lecture d'un terminateur de fichier est effectuée.

function END_OF_LINE(FILE : in FILE.TYPE) return BOOLEAN;

function END_OF_LINE return BOOLEAN;

Fonctionne sur un fichier de mode IN_FILE. Renvoie TRUE si un terminateur de ligne ou un terminateur de fichier est le suivant ; sinon, renvoie FALSE.

L'exception MODE_ERROR est levée si le mode n'est pas IN_FILE.

procedure NEW_PAGE(FILE : in FILE_TYPE);

procedure NEW_PAGE;

Fonctionne sur un fichier de mode OUT_FILE. Génère un terminateur de ligne si la ligne courante n'est pas terminée ou si la page courante est vide (c'est-à-dire si les numéros de colonne et de ligne courants sont tous deux égaux à un). Génère ensuite un terminateur de page, qui termine la page courante. Ajoute un au numéro de page courant et définit les numéros de colonne et de ligne courants à un.

L'exception MODE_ERROR est levée si le mode n'est pas OUT_FILE.

procedure SKIP_PAGE(FILE : in FILE_TYPE);

procedure SKIP_PAGE;

Fonctionne sur un fichier de mode IN_FILE. Lit et supprime tous les caractères et les terminateurs de ligne jusqu'à ce qu'un terminateur de page ait été lu. Ajoute ensuite un au numéro de page actuel et définit les numéros de colonne et de ligne actuels sur un.

L'exception MODE_ERROR est levée si le mode n'est pas IN_FILE. L'exception END_ERROR est levée si une tentative de lecture d'un terminateur de fichier est effectuée.

function END_OF_PAGE(FILE : in FILE_TYPE) return BOOLEAN;

function END_OF_PAGE return BOOLEAN;

Fonctionne sur un fichier de mode IN_FILE. Renvoie TRUE si la combinaison d'un terminateur de ligne et d'un terminateur de page est la suivante, ou si un terminateur de fichier est la suivante ; sinon, renvoie FALSE.

L'exception MODE_ERROR est levée si le mode n'est pas IN_FILE.

function END_OF_FILE(FILE : in FILE_TYPE) return BOOLEAN;

function END_OF_FILE return BOOLEAN;

Fonctionne sur un fichier de mode IN_FILE. Renvoie TRUE si un terminateur de fichier est le suivant, ou si la combinaison d'une ligne, d'une page et d'un terminateur de fichier est le suivant ; sinon, renvoie FALSE.

L'exception MODE_ERROR est levée si le mode n'est pas IN_FILE.

Les sous-programmes suivants permettent de contrôler la position actuelle de lecture ou d'écriture dans un fichier. Dans tous les cas, le fichier par défaut est le fichier de sortie actuel.

procedure SET_COL(FILE : in FILE_TYPE; TO : in POSITIVE_COUNT);

procedure SET_COL(TO : in POSITIVE.COUNT);

Si le mode de fichier est OUT_FILE :

Si la valeur spécifiée par TO est supérieure au numéro de colonne actuel, génère des espaces, en ajoutant un au numéro de colonne actuel après chaque espace, jusqu'à ce que le numéro de colonne actuel soit égal à la valeur spécifiée. Si la valeur spécifiée par TO est égale au numéro de colonne actuel, il n'y a aucun effet. Si la valeur spécifiée par TO est inférieure au numéro de colonne actuel, il a pour effet d'appeler NEW_LINE (avec un espacement de un), puis génère (TO - 1) espaces et définit le numéro de colonne actuel sur la valeur spécifiée. L'exception LAYOUT_ERROR est levée si la valeur spécifiée par TO dépasse LINE_LENGTH lorsque la longueur de ligne est limitée (c'est-à-dire lorsqu'elle n'a pas la valeur conventionnelle zéro).

Si le mode de fichier est IN_FILE :

Lit (et supprime) les caractères individuels, les terminateurs de ligne et les terminateurs de page, jusqu'à ce que le prochain caractère à lire ait un numéro de colonne égal à la valeur spécifiée par TO ; il n'y a aucun effet si le numéro de colonne actuel est déjà égal à cette valeur. Chaque transfert d'un caractère ou d'un terminateur conserve les numéros de colonne, de ligne et de page actuels de la même manière qu'une procédure GET (voir 14.3.5). (Les lignes courtes seront ignorées jusqu'à ce qu'une ligne contenant un caractère à la position de colonne spécifiée soit atteinte.) L'exception END_ERROR est levée si une tentative de lecture d'un terminateur de fichier est effectuée.

procedure SET_LINE(FILE : in FILE_TYPE; TO : in POSITIVE_COUNT);

procedure SET_LINE(TO : in POSITIVE_COUNT);

Si le mode du fichier est OUT_FILE :

Si la valeur spécifiée par TO est supérieure au numéro de ligne courant, a pour effet d'appeler de manière répétée NEW_LINE (avec un espacement de un), jusqu'à ce que le numéro de ligne courant soit égal à la valeur spécifiée. Si la valeur spécifiée par TO est égale au numéro de ligne courant, il n'y a aucun effet. Si la valeur spécifiée par TO est inférieure au numéro de ligne courant, a pour effet d'appeler NEW_PAGE suivi d'un appel de NEW_LINE avec un espacement égal à (TO - 1).

L'exception LAYOUT_ERROR est levée si la valeur spécifiée par TO dépasse PAGE_LENGTH lorsque la longueur de page est limitée (c'est-à-dire lorsqu'elle n'a pas la valeur conventionnelle zéro).

Si le mode est IN_FILE :

A pour effet d'appeler de manière répétée SKIP_LINE (avec un espacement de un), jusqu'à ce que le numéro de ligne courant soit égal à la valeur spécifiée par TO ; il n'y a aucun effet si le numéro de ligne courant est déjà égal à cette valeur. (Les pages courtes seront ignorées jusqu'à ce qu'une page contenant une ligne à la position de ligne spécifiée soit atteinte) L'exception END_ERROR est levée si une tentative est effectuée pour lire un terminateur de fichier.

function COL(FILE : in FILE.TYPE) return POSITIVE_COUNT;

function COL return POSITIVE_COUNT;

Renvoie le numéro de colonne actuel.

L'exception LAYOUT_ERROR est levée si ce nombre dépasse COUNT'LAST.

function LINE(FILE : in FILE_TYPE) return POSITIVE_COUNT;

function LINE return POSITIVE_COUNT;

Renvoie le numéro de ligne actuel.

L'exception LAYOUT_ERROR est levée si ce nombre dépasse COUNT'LAST.

function PAGE(FILE : in FILE_TYPE) return POSITIVE_COUNT;

function PAGE return POSITIVE_COUNT;

Renvoie le numéro de page actuel.

L'exception LAYOUT_ERROR est levée si ce nombre dépasse COUNT'LAST.

Le numéro de colonne, le numéro de ligne ou le numéro de page peuvent dépasser COUNT'LAST (en raison de l'entrée ou de la sortie d'un nombre suffisant de caractères, de lignes ou de pages). Ces événements ne génèrent aucune exception. Cependant, un appel à COL, LINE ou PAGE génère l'exception LAYOUT_ERROR si le nombre correspondant dépasse COUNT'LAST.

Remarque : un terminateur de page est toujours ignoré lorsque le terminateur de ligne précédent est ignoré. Une implémentation peut représenter la combinaison de ces terminateurs par un seul caractère, à condition qu'il soit correctement reconnu à l'entrée.

Procédures Get et Put

Les procédures GET et PUT pour les éléments de type CHARACTER, STRING, les types numériques et les types d'énumération sont décrites dans les sections suivantes. Les caractéristiques de ces procédures étant communes à la plupart de ces types sont décrites dans cette section. Les procédures GET et PUT pour les éléments de type CHARACTER et STRING traitent des valeurs de caractères individuelles ; les procédures GET et PUT pour les types numériques et d'énumération traitent les éléments comme des éléments lexicaux. Toutes les procédures GET et PUT ont des formes avec un paramètre de fichier, écrit en premier. Lorsque ce paramètre est omis, le fichier par défaut actuel approprié (d'entrée ou de sortie) est censé être spécifié. Chaque procédure GET fonctionne sur un fichier de mode IN_FILE. Chaque procédure PUT fonctionne sur un fichier de mode OUT_FILE.

Toutes les procédures GET et PUT conservent les numéros de colonne, de ligne et de page actuels du fichier spécifié : l'effet de chacune de ces procédures sur ces numéros est le résultat des effets des transferts individuels de caractères et de la sortie individuelle ou du saut de terminateurs. Chaque transfert d'un caractère ajoute un au numéro de colonne actuel. Chaque sortie d'un terminateur de ligne définit le numéro de colonne actuel à un et ajoute un au numéro de ligne actuel. Chaque sortie d'un terminateur de page définit les numéros de colonne et de ligne actuels à un et ajoute un au numéro de page actuel. Pour l'entrée, chaque saut d'un terminateur de ligne définit le numéro de colonne actuel à un et ajoute un au numéro de ligne actuel ; chaque saut d'un terminateur de page définit les numéros de colonne et de ligne actuels à un et ajoute un au numéro de page actuel. Des considérations similaires s'appliquent aux procédures GET_LINE, PUT_LINE et SET_COL.

Plusieurs procédures GET et PUT, pour les types numériques et d'énumération, ont des paramètres de format qui spécifient les longueurs de champ; ces paramètres sont du sous-type non négatif FIELD de type INTEGER.

L'entrée-sortie des valeurs d'énumération utilise la syntaxe des éléments lexicaux correspondants. Toute procédure GET pour un type d'énumération commence par ignorer les espaces de début, ou les terminateurs de ligne ou de page ; un espace étant défini comme un espace ou un caractère de tabulation horizontale. Ensuite, les caractères ne sont saisis que tant que la séquence saisie est une séquence initiale d'un identifiant ou d'un caractère littéral (en particulier, la saisie cesse lorsqu'un terminateur de ligne est rencontré). Le caractère ou le terminateur de ligne qui provoque la fin de la saisie reste disponible pour les saisies suivantes.

Pour un type numérique, les procédures GET ont un paramètre de format appelé WIDTH. Si la valeur donnée pour ce paramètre est zéro, la procédure GET se déroule de la même manière que pour les types d'énumération, mais en utilisant la syntaxe des littéraux numériques au lieu de celle des littéraux d'énumération. Si une valeur différente de zéro est donnée, alors exactement WIDTH caractères sont saisis, ou les caractères jusqu'à un terminateur de ligne, selon la première éventualité ; tous les espaces de début ignorés sont inclus dans le décompte. La syntaxe utilisée pour les littéraux numériques est une syntaxe étendue qui autorise un signe de début (mais pas d'espaces intermédiaires, ni de terminateurs de ligne ou de page).

Toute procédure PUT, pour un élément de type numérique ou d'énumération, génère la valeur de l'élément sous forme de littéral numérique, d'identifiant ou de littéral de caractère, selon le cas. Elle est précédée d'espaces de début si cela est requis par les paramètres de format WIDTH ou FORE (comme décrit dans les sections suivantes), puis d'un signe moins pour une valeur négative; pour un type d'énumération, les espaces suivent au lieu de commencer. Le format donné pour une procédure PUT est remplacé s'il n'est pas suffisamment large.

Deux autres cas se présentent pour les procédures PUT pour les types numérique et d'énumération, si la longueur de ligne du fichier de sortie spécifié est limitée (c'est-à-dire s'il n'a pas la valeur conventionnelle zéro). Si le nombre de caractères à générer ne dépasse pas la longueur de ligne maximale, mais est tel qu'ils ne peuvent pas tenir sur la ligne actuelle, à partir de la colonne actuelle, alors (en fait) NEW_LINE est appelé (avec un espacement de un) avant la génération de l'élément. Sinon, si le nombre de caractères dépasse la longueur de ligne maximale, l'exception LAYOUT_ERROR est levée et aucun caractère n'est généré.

L'exception STATUS_ERROR est levée par l'une des procédures GET, GET_LINE, PUT et PUT_LINE si le fichier à utiliser n'est pas ouvert. L'exception MODE_ERROR est levée par les procédures GET et GET_LINE si le mode du fichier à utiliser n'est pas IN_FILE; et par les procédures PUT et PUT_LINE, si le mode n'est pas OUT_FILE.

L'exception END_ERROR est levée par une procédure GET si une tentative est faite pour ignorer un terminateur de fichier. L'exception DATA_ERROR est levée par une procédure GET si la séquence finally entrée n'est pas un élément lexical correspondant au type, en particulier si aucun caractère n'a été saisi ; pour ce test, les espaces de début sont ignorés ; pour un élément de type numérique, lorsqu'un signe est saisi, cette règle s'applique au littéral numérique suivant. L'exception LAYOUT_ERROR est levée par une procédure PUT qui génère un paramètre de type STRING, si la longueur de la chaîne réelle est insuffisante pour la sortie de l'élément.

Exemples :

Dans les exemples, les guillemets de chaîne et la lettre minuscule b ne sont pas transférés : ils sont affichés uniquement pour révéler la mise en page et les espaces.



N : INTEGER;

 ...

GET(N);

 
-- Caractères en entrée           Entrée de séquence       Valeur de N

 
--       bb-12535b                -12535                   -12535

--       bbl2_535E1b               12_535E1                 125350

--       bbl2_535E;                12_535E                  (aucun) DATA_ERROR a été générée

Exemple de paramètre de largeur remplacé :



PUT(ITEM => -23, WIDTH => 2); - "-23"

Entrée-Sortie de caractères et de chaînes de caractères

Pour un élément de type CHARACTER, les procédures suivantes sont fournies :

procedure GET(FILE : in FILE_TYPE; ITEM : out CHARACTER);

procedure GET(ITEM : out CHARACTER);

Après avoir ignoré les terminateurs de ligne et de page, lit le caractère suivant dans le fichier d'entrée spécifié et renvoie la valeur de ce caractère dans le paramètre de sortie ITEM.

L'exception END_ERROR est générée si une tentative est faite pour ignorer un terminateur de fichier.

procedure PUT(FILE : in FILE_TYPE; ITEM : in CHARACTER);

procedure PUT(ITEM : in CHARACTER);

Si la longueur de ligne du fichier de sortie spécifié est limitée (c'est-à-dire qu'elle n'a pas la valeur conventionnelle zéro) et que le numéro de colonne actuel la dépasse, cela a pour effet d'appeler NEW_LINE avec un espacement de un. Ensuite, ou autrement, génère le caractère donné dans le fichier.

Pour un élément de type STRING, les procédures suivantes sont fournies :

procedure GET(FILE : in FILE_TYPE; ITEM : out STRING);

procedure GET(ITEM : out STRING);

Détermine la longueur de la chaîne donnée et tente ce nombre d'opérations GET pour les caractères successifs de la chaîne (en particulier, aucune opération n'est effectuée si la chaîne de caractères est nulle).

procedure PUT(FILE : in FILE.TYPE; ITEM : in STRING);

procedure PUT(ITEM : in STRING);

Détermine la longueur de la chaîne donnée et tente ce nombre d'opérations PUT pour les caractères successifs de la chaîne de caractères (en particulier, aucune opération n'est effectuée si la chaîne est nulle).

procedure GET_LINE(FILE : in FILE_TYPE; ITEM : out STRING; LAST : out NATURAL);

procedure GET_LINE(ITEM : out STRING; LAST : out NATURAL);

Remplace les caractères successifs de la chaîne spécifiée par des caractères successifs lus dans le fichier d'entrée spécifié. La lecture s'arrête si la fin de la ligne est atteinte, auquel cas la procédure SKIP_LINE est alors appelée (en fait) avec un espacement de un ; la lecture s'arrête également si la fin de la chaîne de caractères est atteinte. Les caractères non remplacés restent indéfinis.

Si des caractères sont lus, renvoie dans LAST la valeur d'index telle que ITEM (LAST) soit le dernier caractère remplacé (l'index du premier caractère remplacé est ITEM'FIRST). Si aucun caractère n'est lu, renvoie dans LAST une valeur d'index inférieure de un à ITEM'FIRST.

L'exception END_ERROR est levée si une tentative est faite pour ignorer un terminateur de fichier.

procedure PUT_LINE(FILE : in FILE.TYPE; ITEM : in STRING);

procedure PUT_LINE(ITEM : in STRING);

Appelle la procédure PUT pour la chaîne donnée, puis la procédure NEW_LINE avec un espacement de un.

Remarques : Dans un paramètre de chaîne littérale de PUT, les caractères de crochets de chaîne englobants ne sont pas affichés. Chaque caractère de crochet de chaîne doublé dans la chaîne englobante est affiché sous la forme d'un caractère de crochet de chaîne simple, en conséquence de la règle pour les littéraux de chaîne de caractères.

Une chaîne de caractères lue par GET ou écrite par PUT peut s'étendre sur plusieurs lignes.

Entrée-sortie pour les types entiers

Les procédures suivantes sont définies dans le paquet générique INTEGER_IO. Celle-ci doit être instanciée pour le type entier approprié (indiqué par NUM dans la spécification).

Les valeurs sont sorties sous forme de littéraux décimaux ou de base, sans caractères de soulignement ni exposant, et précédées d'un signe moins si elles sont négatives. Le format (comprenant les espaces de début et le signe moins) peut être spécifié par un paramètre de largeur de champ facultatif. Les valeurs de largeur des champs dans les formats de sortie sont du sous-type entier non négatif FIELD. Les valeurs de bases sont du sous-type entier NUMBER_BASE.



subtype NUMBER_BASE is INTEGER range 2 .. 16;

La largeur et la base de champ par défaut à utiliser par les procédures de sortie sont définies par les variables suivantes étant déclarées dans le paquet générique INTEGER_IO :



DEFAULT_WIDTH : FIELD := NUM'WIDTH;

DEFAULT_BASE  : NUMBER_BASE := 10;

Les procédures suivantes sont prévues :

procedure GET(FILE : in FILE_TYPE; ITEM : out NUM; WIDTH : in FIELD := 0);

procedure GET(ITEM : out NUM; WIDTH : in FIELD := 0);

Si la valeur du paramètre WIDTH est zéro, ignore les espaces de début, les terminateurs de ligne ou les terminateurs de page, puis lit un signe plus ou moins s'il est présent, puis lit selon la syntaxe d'un littéral entier (pouvant être un littéral de base). Si une valeur différente de zéro de WIDTH est fournie, alors exactement WIDTH caractères sont saisis, ou les caractères (éventuellement aucun) jusqu'à un terminateur de ligne, selon la première éventualité; tous les espaces de début ignorés sont inclus dans le décompte.

Renvoie, dans le paramètre ITEM, la valeur de type NUM correspondant à l'entrée de séquence.

L'exception DATA_ERROR est levée si l'entrée de séquence n'a pas la syntaxe requise ou si la valeur obtenue n'est pas du sous-type NUM.

procedure PUT(FILE  : in FILE_TYPE;
              ITEM  : in NUM;
              WIDTH : in FIELD := DEFAULT_WIDTH;
              BASE  : in NUMBER_BASE := DEFAULT_BASE);

procedure PUT(ITEM  : in NUM;
              WIDTH : in FIELD := DEFAULT_WIDTH;
              BASE  : in NUMBER_BASE := DEFAULT_BASE);

Affiche la valeur du paramètre ITEM sous forme de littéral entier, sans soulignement, sans exposant et sans zéros non significatifs (mais un seul zéro pour la valeur zéro) et un signe moins avant pour une valeur négative.

Si la séquence de caractères résultante à afficher comporte moins de caractères WIDTH, les espaces non significatifs sont d'abord affichés pour compenser la différence.

Utilise la syntaxe pour le littéral décimal si le paramètre BASE a la valeur dix (explicitement ou via DEFAULT_BASE) ; sinon, utilise la syntaxe pour le littéral basé, avec toutes les lettres en majuscules.

procedure GET(FROM : in STRING; ITEM : out NUM; LAST : out POSITIVE);

Lit une valeur entière à partir du début de la chaîne donnée, en suivant les mêmes règles que la procédure GET lisant une valeur entière à partir d'un fichier, mais en traitant la fin de la chaîne comme un terminateur de fichier. Renvoie, dans le paramètre ITEM, la valeur de type NUM qui correspond à l'entrée de séquence. Renvoie dans LAST la valeur d'index telle que FROM (LAST) soit le dernier caractère lu.

L'exception DATA_ERROR est levée si l'entrée de séquence n'a pas la syntaxe requise ou si la valeur obtenue n'est pas du sous-type NUM.

procedure PUT(TO   : out STRING;
              ITEM : in NUM;
              BASE : in NUMBER_BASE := DEFAULT_BASE);

Génère la valeur du paramètre ITEM dans la chaîne donnée, en suivant la même règle que pour la sortie vers un fichier, en utilisant la longueur de la chaîne donnée comme valeur pour WIDTH.

Exemples :



package INT_IO is new INTEGER_IO(SMALL_INT); use INT_IO;

-- format par défaut utilisé lors de l'instanciation, DEFAULT_WIDTH = 4, DEFAULT_BASE = 10

 
PUT(126);                            -- "bl 26"

PUT(-126, 7);                        -- "bbb-126"

PUT(126, WIDTH => 13, BASE => 2);    -- "bbb2#1111110#"

Entrée-Sortie pour les types réels

Les procédures suivantes sont définies dans les paquets génériques FLOAT_IO et FIXED_IO, devant être instanciées respectivement pour le type à virgule flottante ou à virgule fixe approprié (indiqué par NUM dans les spécifications).

Les valeurs sont sorties sous forme de littéraux décimaux sans caractères de soulignement. Le format de chaque sortie de valeur se compose d'un champ FORE, d'un point décimal, d'un champ AFT et (si un paramètre EXP différent de zéro est fourni) de la lettre E et d'un champ EXP. Les deux formats possibles correspondent donc à :

FORE . AFT

et à :

FORE . AFT E EXP

sans aucun espace entre ces champs. Le champ FORE peut inclure des espaces de début et un signe moins pour les valeurs négatives. Le champ AFT ne contient que des chiffres décimaux (éventuellement avec des zéros de fin). Le champ EXP contient le signe (plus ou moins) et l'exposant (éventuellement avec des zéros de début).

Pour les types à virgule flottante, les longueurs par défaut de ces champs sont définies par les variables suivantes étant déclarées dans le paquet générique FLOAT_IO :



DEFAULT_FORE : FIELD := 2;

DEFAULT_AFT  : FIELD := NUM'DIGITS-1;

DEFAULT_EXP  : FIELD := 3;

Pour les types à virgule fixe, les longueurs par défaut de ces champs sont définies par les variables suivantes qui sont déclarées dans le paquet générique FIXED_IO :



DEFAULT_FORE : FIELD := NUM'FORE;

DEFAULT_AFT  : FIELD := NUM'AFT;

DEFAULT_EXP  : FIELD := 0;

Les procédures suivantes sont prévues :

procedure GET(FILE : in FILE_TYPE; ITEM : out NUM; WIDTH : in FIELD := 0);

procedure GET(ITEM : out NUM; WIDTH : in FIELD := 0);

Si la valeur du paramètre WIDTH est zéro, ignore les espaces de début, les terminateurs de ligne ou les terminateurs de page, puis lit un signe plus ou moins s'il est présent, puis lit selon la syntaxe d'un littéral réel (pouvant être un littéral basé). Si une valeur différente de zéro de WIDTH est fournie, alors exactement WIDTH caractères sont saisis, ou les caractères (éventuellement aucun) jusqu'à un terminateur de ligne, selon la première éventualité ; tous les espaces de début ignorés sont inclus dans le décompte.

Renvoie, dans le paramètre ITEM, la valeur de type NUM correspondant à l'entrée de séquence.

L'exception DATA_ERROR est levée si l'entrée de séquence n'a pas la syntaxe requise ou si la valeur obtenue n'est pas du sous-type NUM.

procedure PUT(FILE : in FILE_TYPE;
              ITEM : in NUM;
              FORE : in FIELD := DEFAULT_FORE;
              AFT  : in FIELD := DEFAULT_AFT;
              EXP  : in FIELD := DEFAULT.EXP);

procedure PUT(ITEM : in NUM;
              FORE : in FIELD := DEFAULT_FORE;
              AFT  : in FIELD := DEFAULT_AFT;
              EXP  : in FIELD := DEFAULT.EXP);

Affiche la valeur du paramètre ITEM sous forme de littéral décimal au format défini par FORE, AFT et EXP. Si la valeur est négative, un signe moins est inclus dans la partie entière. Si EXP a la valeur zéro, la partie entière à afficher comporte autant de chiffres que nécessaire pour représenter la partie entière de la valeur de ITEM, en remplaçant FORE si nécessaire, ou se compose du chiffre zéro si la valeur de ITEM n'a pas de partie entière.

Si EXP a une valeur supérieure à zéro, la partie entière à afficher comporte un seul chiffre, étant différent de zéro, sauf pour la valeur 0,0 de ITEM. Dans les deux cas, cependant, si la partie entière à afficher comporte moins de caractères FORE, y compris un signe moins, les espaces de début sont d'abord affichés pour compenser la différence. Le nombre de chiffres de la partie fractionnaire est donné par AFT, ou est égal à un si AFT est égal à zéro. La valeur est arrondie ; une valeur d'exactement un demi à la dernière position peut être arrondie vers le haut ou vers le bas.

Si EXP a la valeur zéro, il n'y a pas de partie exposant. Si EXP a une valeur supérieure à zéro, alors la partie exposant à afficher comporte autant de chiffres que nécessaire pour représenter la partie exposant de la valeur de ITEM (pour laquelle une partie entière à un seul chiffre est utilisée), et inclut un signe initial (plus ou moins). Si la partie exposant à afficher comporte moins de caractères EXP, signe compris, alors des zéros non significatifs précèdent les chiffres, pour compenser la différence. Pour la valeur 0.0 de ITEM, l'exposant a la valeur zéro.

procedure GET(FROM : in STRING; ITEM : out NUM; LAST : out POSITIVE);

Lit une valeur réelle à partir du début de la chaîne donnée, en suivant la même règle que la procédure GET lisant une valeur réelle à partir d'un fichier, mais en traitant la fin de la chaîne comme un terminateur de fichier. Renvoie, dans le paramètre ITEM, la valeur de type NUM qui correspond à la séquence d'entrée. Renvoie dans LAST la valeur d'index telle que FROM(LAST) soit le dernier caractère lu.

L'exception DATA_ERROR est levée si la séquence d'entrée n'a pas la syntaxe requise, ou si la valeur obtenue n'est pas du sous-type NUM.

procedure PUT(TO   : out STRING;
              ITEM : in NUM;
              AFT  : in FIELD := DEFAULT_AFT;
              EXP  : in INTEGER := DEFAULT_EXP);

Génère la valeur du paramètre ITEM dans la chaîne donnée, en suivant la même règle que pour la sortie dans un fichier, en utilisant une valeur pour FORE telle que la séquence de caractères de sortie remplisse exactement la chaîne, y compris les espaces de début.

Exemples :



package REAL_IO is new FLOAT_IO(REAL); use REAL_IO;

-- format par défaut utilisé lors de l'instanciation, DEFAULT_EXP = 3

 
X : REAL := -123.4567; -- chiffres 8

 
PUT(X); -- format par défaut              "-1.2345670E+02"

PUT(X, FORE => 5, AFT => 3, EXP => 2); -- "bbb-1.235E+2"

PUT(X, 5, 3, 0);                       -- "b-123.457"

Remarque : pour un élément avec une valeur positive, si la sortie vers une chaîne de caractères remplit exactement la chaîne sans espaces de début, la sortie de la valeur négative correspondante générera LAYOUT_ERROR.

Entrée-Sortie pour les types d'énumération

Les procédures suivantes sont définies dans le paquet générique ENUMERATION_IO, devant être instancié pour le type d'énumération approprié (indiqué par ENUM dans la spécification). Les valeurs sont sorties en utilisant des lettres majuscules ou minuscules pour les identifiants. Ceci est spécifié par le paramètre SET, étant du type d'énumération TYPE_SET.



type TYPE_SET is (LOWER_CASE, UPPER_CASE);

Le format (incluant les espaces de fin) peut être spécifié par un paramètre de largeur de champ facultatif. La largeur de champ par défaut et la casse des lettres sont définies par les variables suivantes étant déclarées dans le paquet générique ENUMERATION_IO :



DEFAULT_WIDTH   : FIELD := 0;

DEFAULT_SETTING : TYPE_SET := UPPERCASE;

Les procédures suivantes sont prévues :

procedure GET(FILE : in FILE_TYPE; ITEM : out ENUM);

procedure GET(ITEM : out ENUM);

Après avoir ignoré les espaces de début, les terminateurs de ligne ou les terminateurs de page, lit un identifiant selon la syntaxe de cet élément lexical (minuscules et majuscules étant considérées comme équivalentes), ou un littéral de caractère selon la syntaxe de cet élément lexical (y compris les apostrophes). Renvoie, dans le paramètre ITEM, la valeur de type ENUM correspondant à la séquence d'entrée.

L'exception DATA_ERROR est levée si la séquence d'entrée n'a pas la syntaxe requise, ou si l'identifiant ou le littéral de caractère ne correspond pas à une valeur du sous-type ENUM.

procedure PUT(FILE   : in FILE_TYPE;
              ITEM   : in ENUM;
              WIDTH  : in FIELD := DEFAULT_WIDTH;
              SET    : in TYPE_SET := DEFAULT_SETTING);

procedure PUT(ITEM   : in ENUM;
              WIDTH  : in FIELD := DEFAULT_WIDTH;
              SET    : in TYPE_SET := DEFAULT_SETTING);

Affiche la valeur du paramètre ITEM sous forme de littéral d'énumération (soit un identifiant, soit un littéral de caractère). Le paramètre facultatif SET indique si les identifiants sont en minuscules ou en majuscules ; il n'a aucun effet pour les littéraux de caractère. Si la séquence de caractères produite comporte moins de caractères WIDTH, les espaces de fin sont finalement affichés pour compenser la différence.

procedure GET(FROM : in STRING; ITEM : out ENUM; LAST : out POSITIVE):

Lit une valeur d'énumération à partir du début de la chaîne donnée, en suivant la même règle que la procédure GET lisant une valeur d'énumération à partir d'un fichier, mais en traitant la fin de la chaîne comme un terminateur de fichier. Renvoie, dans le paramètre ITEM, la valeur de type ENUM correspondant à l'entrée de séquence. Renvoie dans LAST la valeur d'index telle que FROM (LAST) soit le dernier caractère lu.

L'exception DATA_ERROR est levée si l'entrée de séquence n'a pas la syntaxe requise, ou si l'identifiant ou le littéral de caractère ne correspond pas à une valeur du sous-type ENUM.

procedure PUT(TO   : out STRING;
              ITEM : in ENUM;
              SET  : in TYPE.SET := DEFAULT_SETTING);

Affiche la valeur du paramètre ITEM dans la chaîne donnée, en suivant la même règle que pour la sortie dans un fichier, en utilisant la longueur de la chaîne donnée comme valeur pour WIDTH.

Bien que la spécification du paquet ENUMERATIQN_IO autorise l'instanciation pour un type entier, ce n'est pas le but recherché de ce paquet générique, et l'effet de telles instanciations n'est pas défini par le langage.

Remarques : il existe une différence entre PUT défini pour les caractères et pour les valeurs d'énumération. Ainsi :



TEXT_IO.PUT('A');                                          -- génère le caractère A

package CHAR_IO is new TEXT_IO.ENUMERATION_IO(CHARACTER);

CHAR_IO.PUT('A');                                          -- affiche le caractère «A», entre guillemets simples

Le type BOOLEAN est un type d'énumération, par conséquent des ENUMERATIONS peuvent être instanciées pour ce type.

Spécification du paquet Text_IO



with IO_EXCEPTIONS;

package TEXT_IO is

 
  type FILE_TYPE is limited private;

 
  type FILE_MODE is (IN_FILE, OUT_FILE);

 
  type COUNT is range 0 .. implementation_defined;

  subtype POSITIVE_COUNT is COUNT range 1 .. COUNT'LAST;

  UNBOUNDED : constant COUNT := 0; -- longueur de la ligne et de la page

 
  subtype FIELD       is INTEGER range 0 .. implementation_defined;

  subtype NUMBER_BASE is INTEGER range 2 .. 16;

 
  type TYPE_SET is (LOWER_CASE, UPPER_CASE);

  

  -- Gestion des fichiers

  

  procedure CREATE(FILE : in out FILE_TYPE;

                   MODE : in FILE_MODE := OUT_FILE;

                   NAME : in STRING := "";

                   FORM : in STRING := "");

 
  procedure OPEN  (FILE : in out FILE_TYPE;

                   MODE : in FILE_MODE;

                   NAME : in STRING;

                   FORM : in STRING := "");

 
  procedure CLOSE  (FILE : in out FILE_TYPE);

  procedure DELETE (FILE : in out FILE_TYPE);

  procedure RESET  (FILE : in out FILE_TYPE; MODE : in FILE_MODE);

  procedure RESET  (FILE : in out FILE_TYPE);

 
  function MODE    (FILE : in FILE_TYPE) return FILE_MODE;

  function NAME    (FILE : in FILE_TYPE) return STRING;

  function FORM    (FILE : in FILE_TYPE) return STRING;

  

  function IS_OPEN (FILE : in FILE_TYPE) return BOOLEAN;

  

  -- Contrôle des fichiers d'entrée et de sortie par défaut

  procedure SET_INPUT  (FILE : in FILE_TYPE);

  procedure SET_OUTPUT (FILE : in FILE_TYPE);

  

  function STANDARD_INPUT  return FILE_TYPE;

  function STANDARD_OUTPUT return FILE_TYPE;

 
  function CURRENT_INPUT   return FILE_TYPE;

  function CURRENT_OUTPUT  return FILE_TYPE;

 
  -- Spécification des longueurs de lignes et de pages

  

  procedure SET_LINE_LENGTH (FILE : in FILE_TYPE; TO : in COUNT);

  procedure SET_LINE_LENGTH (TO : in COUNT);

  

  procedure SET_PAGE_LENGTH (FILE : in FILE_TYPE; TO : in COUNT);

  procedure SET_PAGE_LENGTH (TO : in COUNT);

  

  function LINE_LENGTH (FILE : in FILE_TYPE) return COUNT;

  function LINE_LENGTH return COUNT;

 
  function PAGE_LENGTH (FILE : in FILE_TYPE) return COUNT;

  function PAGE_LENGTH return COUNT;

  

  -- Contrôle des colonnes, des lignes et des pages

  procedure NEW_LINE   (FILE : in FILE.TYPE; SPACING : in POSITIVE_COUNT := 1);

  procedure NEW_LINE   (SPACING : in POSITIVE_COUNT := 1);

  

  procedure SKIP_LINE  (FILE : in FILE_TYPE; SPACING : in POSITIVE_COUNT := 1);

  procedure SKIP_LINE  (SPACING : in POSITIVE_COUNT := 1);

 
  function END_OF_LINE (FILE : in FILE_TYPE) return BOOLEAN;

  function END_OF_LINE return BOOLEAN;

 
  procedure NEW_PAGE   (FILE : in FILE_TYPE);

  procedure NEW_PAGE;

 
  procedure SKIP_PAGE  (FILE : in FILE_TYPE);

  procedure SKIP_PAGE;

 
  function END_OF_PAGE (FILE : in FILE_TYPE) return BOOLEAN;

  function END_OF_PAGE return BOOLEAN;

 
  function END_OF_FILE (FILE : in FILE_TYPE) return BOOLEAN;

  function END_OF_FILE return BOOLEAN;

 
  procedure SET_COL    (FILE : in FILE_TYPE; TO : in POSITIVE_COUNT);

  procedure SET_COL    (TO   : in POSITIVE_COUNT);

 
  procedure SET_LINE   (FILE : in FILE_TYPE; TO ; in POSITIVE_COUNT);

  procedure SET_LINE   (TO   : in POSITIVE_COUNT);

 
  function COL  (FILE : in FILE_TYPE) return POSITIVE_COUNT;

  function COL  return POSITIVE_COUNT;

  

  function LINE (FILE : in FILE_TYPE) return POSITIVE_COUNT;

  function LINE return POSITIVE.COUNT;

 
  function PAGE (FILE : in FILE_TYPE) return POSITIVE_COUNT;

  function PAGE return POSITIVE_COUNT;

 
  -- Entrée-Sortie de caractères

 
  procedure GET(FILE : in FILE_TYPE; ITEM out CHARACTER);

  procedure GET(ITEM : out CHARACTER);

  procedure PUT(FILE : in FILE_TYPE; ITEM in CHARACTER);

  procedure PUT(ITEM : in CHARACTER);

  

  -- Entrée-Sortie de chaîne

 
  procedure GET(FILE in FILE.TYPE; ITEM out STRING);

  procedure GET(ITEM out STRING);

  procedure PUT(FILE in FILE_TYPE; ITEM in STRING);

  procedure PUT(ITEM in STRING);

 
  procedure GET_LINE(FILE : in FILE_TYPE; ITEM : out STRING; LAST : cut NATURAL);

  procedure GET_LINE(ITEM : out STRING; LAST ; out NATURAL);

  procedure PUT_LINE(FILE : in F!LE_TYPE; ITEM : in STRING);

  procedure PUT_LINE(ITEM : in STRING);

  

  -- Paquet générique pour l'entrée-sortie de types entiers

 
generic

  type NUM is range <>;

package INTEGER_IO is

 
  DEFAULT_WIDTH : FIELD := NUM'WIDTH;

  DEFAULT_BASE  : NUMBER_BASE := 10;

 
  procedure GET(FILE : in FILE_TYPE; ITEM out NUM; WIDTH : in FIELD := 0);

  procedure GET(ITEM : out NUM; WIDTH : in FIELD := 0);

 
  procedure PUT(FILE  : in FILE_TYPE;

                ITEM  : in NUM;

                WIDTH : in FIELD := DEFAULT_WIDTH;

                BASE  : in NUMBER.BASE = DEFAULT_BASE);

  procedure PUT(ITEM  : in NUM;

                WIDTH : in FIELD := DEFAULT.WIDTH;

                BASE  : in NUMBER_BASE = DEFAULT_BASE);

 
  procedure GET(FROM  : in STRING; ITEM : out NUM; LAST : out POSITIVE);

  procedure PUT(TO    : out STRING;

                ITEM  : in NUM;

                BASE  : in NUMBER.BASE := DEFAULT_BASE);

 
 
end INTEGER_IO;

 
-- Paquets génériques pour l'entrée-sortie de types réels

 
generic

  type NUM is digits <>;

package FLOAT_IO is

 
  DEFAULT_FORE : FIELD := 2;

  DEFAULT_AFT  : FIELD := NUM'DIGITS-1;

  DEFAULT_EXP  : FIELD := 3;

 
  procedure GET(FILE : in  FILE_TYPE; ITEM : out NUM; WIDTH : in FIELD := 0);

  procedure GET(ITEM : out NUM; WIDTH : in FIELD := 0);

 

  procedure PUT(FILE : in FILE_TYPE;

                ITEM : in NUM;

                    FORE : in FIELD := DEFAULT_FORE;

                AFT  : in FIELD := DEFAULT_AFT;

                EXP  : in FIELD := DEFAULT_EXP);

  procedure PUT(ITEM : in NUM;

                FORE : in FIELD := DEFAULT_FORE;

                AFT  : in FIELD := DEFAULT_AFT;

                EXP  : in FIELD := DEFAULT_EXP);

 
  procedure GET(FROM : in STRING; ITEM : out NUM; LAST : out POSITIVE);

  procedure PUT(TO   : out STRING;

                ITEM : in NUM;

                AFT  : in FIELD := DEFAULT_AFT;

                EXP  : in FIELD := DEFAULT_EXP);

end FLOAT_IO;

 
generic

  type NUM is delta <>;

package FIXED_I0 is

 
  DEFAULT_FORE : FIELD := NUM'FORE;

  DEFAULT_AFT  : FIELD := NUM'AFT;

  DEFAULT_EXP  : FIELD := 0;

 
  procedure GET(FILE : in FILE_TYPE; ITEM : out NUM; WIDTH : in FIELD := 0);

  procedure GET(ITEM : out NUM; WIDTH : in FIELD := 0);

 
  procedure PUT(FILE : in FILE_TYPE;

                ITEM : in NUM;

                FORE : in FIELD := DEFAULT_FORE;                

                    AFT  : in FIELD := DEFAULT_AFT;

                EXP  : in FIELD := DEFAULT_EXP);

  procedure PUT(ITEM : in NUM;

                FORE : in FIELD := DEFAULT_FORE;

                AFT  : in FIELD := DEFAULT_AFT;

                EXP  : in FIELD := DEFAULT.EXP);

 
  procedure GET(FROM : in STRING; ITEM : out NUM; LAST : out POSITIVE);

  procedure PUT(TO   : out STRING;

                ITEM : in NUM;

                AFT  : in FIELD := DEFAULT_AFT;

                EXP  : in FIELD := DEFAULT_EXP);

 
end FIXED_IO;

 
-- Paquet générique pour l'entrée-sortie des types d'énumération

 
generic

  type ENUM is (<>);

package ENUMERATION_IO is

 
  DEFAULT_WIDTH   : FIELD := 0;

  DEFAULT_SETTING : TYPE_SET := UPPER_CASE;

 

  procedure GET(FILE : in FILE_TYPE; ITEM : out ENUM);

  procedure GET(ITEM : out ENUM);

 
  procedure PUT(FILE  : in FILE_TYPE;

                ITEM  : in ENUM;

                WIDTH : in FIELD := DEFAULT_WIDTH;

                SET   : in TYPE_SET := DEFAULT_SETTING);

 
  procedure PUT(ITEM in ENUM;

                WIDTH in FIELD := DEFAULT_WIDTH;

                SET in TYPE.SET := DEFAULT_SETTING);

                    

  procedure GET(FROM : in STRING; ITEM : out ENUM; LAST : out POSITIVE),

  procedure PUT(TO   : out STRING;

                ITEM : in ENUM;

                SET  : in TYPE_SET := DEFAULT_SETTING);

end ENUMERATIONS;

 
-- Exceptions

STATUS_ERROR  : exception renames IO_EXCEPTIONS.STATUS_ERROR;

MODE_ERROR    : exception renames IO_EXCEPTIONS.MODE_ERROR;

NAME_ERROR    : exception renames IO_EXCEPTIONS.NAME_ERROR;

USE_ERROR     : exception renames IO_EXCEPTIONS.USE_ERROR;

DEVICE_ERROR  : exception renames IO_EXCEPTIONS.DEVICE_ERROR;

END_ERROR     : exception renames IO_EXCEPTIONS.END_ERROR;

DATA_ERROR    : exception renames IO_EXCEPTIONS.DATA_ERROR;

LAYOUT_ERROR  : exception renames IO_EXCEPTI0NS.LAYOUT_ERROR;

 
private

  -- dépendant de l'implémentation

end TEXT_IO;

Exceptions dans les entrées-sorties

Les exceptions suivantes peuvent être levées par des opérations d'entrée-sortie. Elles sont déclarées dans le paquet IO_EXCEPTIONS; ce paquet est nommé dans la clause de contexte de chacun des trois paquets d'entrée-sortie. Seules des descriptions sommaires sont données des conditions dans lesquelles NAME_ERROR, USE_ERROR et DEVICE_ERROR sont levées. Si plusieurs conditions d'erreur existent, l'exception correspondante qui apparaît en premier dans la liste suivante est celle étant levée.

L'exception STATUS_ERROR est levée par une tentative d'opération sur un fichier qui n'est pas ouvert et par une tentative d'ouverture d'un fichier déjà ouvert.

L'exception MODE_ERROR est levée par une tentative de lecture ou de test de fin d'un fichier dont le mode actuel est OUT_FILE, et également par une tentative d'écriture dans un fichier dont le mode actuel est IN_FILE. Dans le cas de TEXT_IO, l'exception MODE_ERROR est également levée en spécifiant un fichier dont le mode actuel est OUT_FILE dans un appel de SET_INPUT, SKIP_LINE, END_OF_LINE, SKIP_PAGE ou END_OF_PAGE ; et en spécifiant un fichier dont le mode actuel est IN_FILE dans un appel de SET_OUTPUT, SET_LINE_LENGTH, SET_PAGE_LENGTH, LINE_LENGTH, PAGE_LENGTH, NEW_LINE ou NEW_PAGE.

L'exception NAME_ERROR est levée par un appel de CREATE ou OPEN si la chaîne donnée pour le paramètre NAME ne permet pas l'identification d'un fichier externe. Par exemple, cette exception est levée si la chaîne est incorrecte ou, au contraire, si aucun ou plusieurs fichiers externes correspondent à la chaîne.

L'exception USE_ERROR est levée si une opération est tentée n'étant pas possible pour des raisons dépendant des caractéristiques du fichier externe. Par exemple, cette exception est levée par la procédure CREATE, entre autres circonstances, si le mode donné est OUT_FILE mais que le formulaire spécifie un périphérique d'entrée uniquement, si le paramètre FORM spécifie des droits d'accès non valides ou si un fichier externe portant le nom donné existe déjà et que l'écrasement n'est pas autorisé.

L'exception DEVICE_ERROR est levée si une opération d'entrée-sortie ne peut pas être effectuée en raison d'un dysfonctionnement du système sous-jacent.

L'exception END_ERROR est levée par une tentative de saut (lecture au-delà) de la fin d'un fichier.

L'exception DATA_ERROR peut être levée par la procédure READ si l'élément lu ne peut pas être interprété comme une valeur du type requis. Cette exception est également levée par une procédure GET (définie dans le paquet TEXT_IO) si la séquence de caractères d'entrée ne satisfait pas la syntaxe requise ou si la valeur d'entrée n'appartient pas à la plage du type ou du sous-type requis.

L'exception LAYOUT_ERROR est levée (en entrée-sortie de texte) par COL, LINE ou PAGE si la valeur renvoyée dépasse COUNT'LAST. L'exception LAYOUT_ERROR est également levée en sortie par une tentative de définition de numéros de colonne ou de ligne dépassant les longueurs de ligne ou de page maximales spécifiées, respectivement (à l'exclusion des cas non limités). Elle est également levée par une tentative d'insertion de trop de caractères dans une chaîne.

Spécification du paquet IO_Exceptions

Ce paquet définit les exceptions nécessaires aux paquets SEQUENTIAL_IO, DIRECT_IO et TEXT_IO :



package IO_EXCEPTIONS is

 
  STATUS_ERROR  : exception;

  MODE_ERROR    : exception;

  NAME_ERROR    : exception;

  USE_ERROR     : exception;

  DEVICE_ERROR  : exception;

  END_ERROR     : exception;

  DATA_ERROR    : exception;

  LAYOUT_ERROR  : exception;

 
end IO_EXCEPTIONS;

Entrée-sortie de bas niveau

Une opération d'entrée-sortie de bas niveau est une opération agissant sur un périphérique physique. Une telle opération est gérée en utilisant l'une des procédures prédéfinies (surchargées) SEND_CONTROL et RECEIVE_CONTROL.

Une procédure SEND_CONTROL peut être utilisée pour envoyer des informations de contrôle à un périphérique physique. Une procédure RECEIVE_COIMTROL peut être utilisée pour surveiller l'exécution d'une opération d'entrée-sortie en demandant des informations au périphérique physique.

De telles procédures sont déclarées dans le paquet standard LOW_LEVEL_IO et ont deux paramètres identifiant le périphérique et les données. Cependant, les types et formats des informations de contrôle dépendront des caractéristiques physiques de la machine et du périphérique. Par conséquent, les types de paramètres sont définis par l'implémentation. Des définitions surchargées de ces procédures doivent être fournies pour les périphériques pris en charge.

La partie visible du paquet définissant ces procédures est décrite comme suit :



package LOW_LEVEL_IO is

  -- déclarations des types possibles pour DEVICE et DATA ;

  -- déclarations de procédures surchargées pour ces types :

  procedure SEND_CONTROL (DEVICE : device_type; DATA : in out data_type);

  procedure RECEIVE_CONTROL (DEVICE : device_type; DATA : in out data_type);

end;

Les corps des procédures SEND_CONTROL et RECEIVE_CONTROL pour différents périphériques peuvent être fournis dans le corps du paquet LOW_LEVEL_IO. Ces corps de procédure peuvent être écrits avec des instructions de code.

Exemple d'entrée-sortie

L'exemple suivant montre l'utilisation de certaines fonctions d'entrée-sortie de texte dans un dialogue avec un utilisateur sur un terminal. L'utilisateur est invité à saisir une couleur et le programme répond en indiquant le nombre d'articles de cette couleur disponibles en stock, selon un inventaire. Les fichiers d'entrée et de sortie par défaut sont utilisés. Pour plus de simplicité, toutes les instances requises sont fournies dans un sous-programme ; en pratique, un paquet, distinct de la procédure, serait utilisé.



with TEXT_IO; use TEXT_IO;

 
procedure DIALOGUE is

  type COLOR is (WHITE, RED, ORANGE, YELLOW, GREEN, BLUE, BROWN);

  package COLOR_IO is new ENUMERATION_IO(ENUM => COLOR);

  package NUMBER_IO is new INTEGER_IO(INTEGER);

  use COLOR_IO, NUMBER_IO;

 
  INVENTORY : array (COLOR) of INTEGER := (20, 17, 43, 10, 28, 173, 87);

  CHOICE : COLOR;

 
  procedure ENTER_COLOR (SELECTION : out COLOR) is

  begin

    loop

      begin

        PUT ("Couleur sélectionnée:"); -- prompt l'utilisateur

        GET (SELECTION);               -- accepte la couleur typée ou génère une exception

        return;

      exception

         when DATA_ERROR =>

           PUT("Couleur non valide, réessayez."); -- l'utilisateur a tapé une nouvelle ligne

           NEW_LINE(2);

           -- termine l'exécution de l'instruction de bloc

      end;

    end loop; -- répète l'instruction de bloc jusqu'à ce que la couleur soit acceptée

  end;

begin -- déclarations de DIALOGUE;

  NUMBER_IO.DEFAULT_WIDTH := 5;

 
  loop

    ENTER_COLOR(CHOICE); -- types d'utilisateur couleur et nouvelle ligne

 
    SET_COL(5); PUT(CHOICE); PUT("item disponibles:");

    SET_COL(40); PUT(INVENTORY(CHOICE)); -- la largeur par défaut est 5

    NEW_LINE;

  end loop;

end DIALOGUE;

Exemple d'interaction (les caractères saisis par l'utilisateur sont en italique) :

Couleur sélectionnée : Black Couleur non valide, réessayez. Couleur sélectionnée : Blue Item BLUE disponibles : 173 Couleur sélectionnée : Yellow Item YELLOW disponibles : 10

PARTAGER CETTE PAGE SUR

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

	ABAP/4
	Ada
	Assembleur
	Assembly & bytecode
	ASP (Active Server Pages)
	Basic
	C
	C++
	C# (C Sharp)
	Cobol
	ColdFusion
	Fortran
	HTML
	Java
	JavaScript
	LISP
	Logo
	LotusScript
	Oberon
	Pascal
	Perl
	PHP
	PL/1
	Prolog
	Python
	Rebol
	REXX
	Ruby
	Rust
	SAS
	NoSQL
	SQL
	Swift
	X++ (Axapta)

	Assembleur 370
	Assembleur 1802
	Assembleur 4004
	Assembleur 6502
	Assembleur 6800
	Assembleur 68000
	Assembleur 8080 et 8085
	Assembleur 8089
	Assembleur 80x86
	Assembleur AGC4
	Assembleur ARM
	Assembleur DPS 8000
	Assembleur i860
	Assembleur Itanium
	Assembleur MIPS
	Assembleur PDP-11
	Assembleur PowerPC
	Assembleur RISC-V
	Assembleur SPARC
	Assembleur SuperH
	Assembleur UNIVAC I
	Assembleur VAX
	Assembleur Z80
	Assembleur Z8000
	Assembleur z/Architecture

	CIL
	Jasmin
	LLVM
	MSIL
	Parrot
	P-Code (PCode)
	SWEET16

	ASP 1.0
	ASP 2.0
	ASP 3.0
	ASP.NET

	ABasiC (Amiga)
	Adam SmartBASIC
	Altair BASIC
	AmigaBASIC (Amiga)
	AMOS Basic (Amiga)
	Atari Basic (Atari 400, 600 XL, 800, 800XL)
	Basic Apple II (Integer BASIC/APPLESOFT)
	Basic Commodore 64 (CBM-BASIC)
	Basic Commodore 128 (BASIC 7.0)
	Basic Commodore VIC-20 (CBM-BASIC 2.0)
	Basic Coco 1 (Color Basic)
	Basic Coco 2 (Extended Color Basic)
	Basic Coco 3 (Extended Color Basic 2.0)
	BASICA (PC DOS)
	Basic Pro
	BBC BASIC
	Blitz BASIC (Amiga)
	DarkBASIC
	Dartmouth BASIC
	GFA-Basic (Atari ST/Amiga)
	GWBASIC (MS-DOS)
	Liberty BASIC
	Locomotive BASIC (Amstrad CPC)
	MSX-Basic
	Omikron Basic (Atari ST)
	Oric Extended Basic
	Power Basic
	Quick Basic/QBasic (MS-DOS)
	Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
	ST BASIC (Atari ST)
	Turbo Basic
	Vintage BASIC
	VBScript
	Visual Basic (VB)
	Visual Basic .NET (VB .NET)
	Visual Basic pour DOS
	Yabasic

Section courante

A propos

Section administrative du site

Les entrées-sorties

Fichiers externes et objets fichiers

Fichiers séquentiels et directs

Gestion des fichiers

Entrée-sortie séquentielle

Entrée-sortie directe

Spécification du paquet Direct_IO

Entrée-sortie de texte

Gestion des fichiers

Fichiers d'entrée et de sortie par défaut

Spécification des longueurs de ligne et de page

Opérations sur les colonnes, les lignes et les pages

Procédures Get et Put

Entrée-Sortie de caractères et de chaînes de caractères

Entrée-sortie pour les types entiers

Entrée-Sortie pour les types réels

Entrée-Sortie pour les types d'énumération

Spécification du paquet Text_IO

Exceptions dans les entrées-sorties

Spécification du paquet IO_Exceptions

Entrée-sortie de bas niveau

Exemple d'entrée-sortie

	C Shell Unix (csh)

	C pour Amiga
	C pour Atari ST
	C pour DOS
	C pour Falcon030
	C pour GEMDOS (Atari ST)
	C pour Linux
	C pour PowerTV OS
	C pour OS/2
	C pour Unix
	C pour Windows

	Aztec C
	CoCo-C
	GNU C
	HiSoft C
	IBM C/2
	Introl-C
	Lattice C
	Microsoft C
	MinGW C
	MSX-C
	Open Watcom C
	OS-9 C Compiler
	Pure C
	Quick C
	Turbo C

	C++ pour OS/2
	C++ pour Windows

	Borland C++
	C++Builder
	IBM VisualAge C++
	Intel C++
	MinGW C++
	Open Watcom C++
	Symantec C++
	Turbo C++
	Visual C++
	Visual C++ .NET
	Watcom C++
	Zortech C++

	Apple Pascal
	Delphi/Kylix/Lazarus
	Free Pascal
	GNU Pascal
	HighSpeed Pascal
	IBM Personal Computer Pascal
	Lisa Pascal
	Maxon Pascal
	MPW Pascal
	OS-9 Pascal
	OSS Personal Pascal
	Pascal-86
	Pascal du Cray Research
	Pascal/VS
	Pascal-XT
	PURE Pascal
	QuickPascal
	RemObjets Chrome
	Sun Pascal
	THINK Pascal
	Tiny Pascal (TRS-80)
	Turbo Pascal
	UCSD Pascal
	VAX Pascal
	Virtual Pascal

	Turbo Pascal for CP/M-80
	Turbo Pascal for DOS
	Turbo Pascal for Macintosh
	Turbo Pascal for Windows

	CodeIgniter (Cadre d'application)
	Drupal (Projet)
	Joomla! (Projet)
	Phalanger (PHP .NET)
	phpBB (Projet)
	Smarty (balise)
	Twig (balise)
	Symfony (Cadre d'application)
	WordPress (Projet)
	Zend (Cadre d'application)

	Btrieve
	Cassandra
	Clipper
	CouchDB
	dBASE
	Hbase
	Hypertable
	MongoDB
	Redis

	Access
	BigQuery
	DB2
	H2
	Interbase
	MySQL
	Oracle
	PostgreSQL
	SAP HANA
	SQL Server
	Sybase
	U-SQL

	Introduction
	Les remarques
	Les opérateurs
	Les instruction conditionnelles
	Les instructions de boucles
	Type de données
	Définition de fonction
	Référence de mots réservés (mots clefs)
	Référence de procédures et fonctions
	Les modules (Packages)

	Les premiers pas
	Les éléments lexicaux
	Les déclarations et types
	Les noms et les expressions
	Les instructions
	Les sous-programmes
	Les paquets
	Les règles de visibilité
	Les tâches
	Structure du programme et problèmes de compilation
	Les exceptions
	Les unités génériques
	Clauses de représentation et fonctionnalités dépendantes de la mise en oeuvre
	Les entrées-sorties

	Bonjour
	Biochimie
	Géographie
	Géométrie
	Histoire
	Mathématique
	Médicale
	Météorologie
	Océanographie
	Sport
	Temps
	Trigonométrie
	Validation

	GNAT
	SMALLAda
	VHDL

	ASSEMBLER/MONITOR 64
	Micol Assembler

	A86
	MASM (Macro Assembler)
	TASM (Turbo Assembler)

	BeckerBASIC
	SIMONS' BASIC

	Aire d'un cercle
	Aire d'une surface de prisme rectangulaire
	Aire d'un triangle
	Distance entre deux points

	Ackermann
	Exp
	Factoriel
	Fibonacci
	Log
	Nombre premier
	Odd
	Random
	Sqrt
	Triangle Pascal

	Attributs de langages prédéfinis
	Les pragma de langage prédéfinis
	Environnement de langage prédéfini
	Référence de termes et du vocabulaire
	Téléchargement