Entées / sorties

Ouverture, sortie, prédicat

L'objet qui dans Scheme permet d'accéder aux fichiers est le port. Un port est crée à partir d'un nom de fichier représenté sous la forme d'une chaîne de caractères. On dispose de deux fonctions élémentaires pour lire et écrire dans un port :

(call-with-input-file fichier proc)

et :

(call-with-output-file fichier proc)

L'argument proc est une fonction à un argument et fichier un nom de fichier. Dans le premier cas, le fichier de nom fichier doit exister sur le disque. Dans le second cas, le résultat n'est pas spécifié si le fichier existe déjà ; cependant, en général, les implémentations de Scheme écrasent le contenu du fichier par le nouveau contenu.

La procédure proc est invoquée avec comme argument, respectivement un port d'entrée ou un port de sortie. Ce port peut être donné comme argument aux fonctions d'entrée / sortie pour opérer sur ce port plutôt que sur la console. Le port est automatiquement refermé lorsque l'exécution de proc est terminée.

Le système Scheme définit le port d'entrée courant et le port de sortie courant. Ils sont retournés respectivement par les fonctions :

(current-input-port)

et :

(current-output-port)

Les ports d'entrée / sortie courants ne sont pas modifiés par des appels aux fonctions call-with-input-file et call-with-output-file. Par contre ils sont modifiés par des appels aux fonctions :

(with-input-from-file fichier proc)

et :

(with-output-to-file fichier proc).

Là, fichier représente un nom de fichier et proc, une fonction sans argument. Lorsque le corps de cette fonction est exécutée, le port courant devient le port correspondant au fichier ouvert. Ainsi les fonctions d'entrée / sortie, comme display, opèrent sur ce nouveau port. Les ports sont automatiquement refermés lorsque l'exécution de proc est terminée.

Pour ouvrir et fermer des fichiers de manière explicite, Scheme propose les fonctions :

(open-input-file fichier)

et :

(open-output-file fichier)

qui retournent un port et :

(close-input-port port)

et :

(close-output-port port)

pour refermer ces ports.

Nous disposons des prédicats :

(input-port? objet)

et :

(output-port? objet)

pour vérifier la nature des objets.

Entrée

La fonction :

(read [port])

permet de lire soit de l'entrée courante, soit du port spécifié, un objet Scheme. Cette fonction est très puissante car elle est capable de relire les structure composées, comme les listes et les vecteurs.

Lorsque la fin du fichier est rencontrée sur une opération de lecture, Scheme retourne un objet spécial. Si cet objet spécial est passé en argument à la fonction eof-object?, elle retourne #t. Pour tout autre objet, elle retourne #f.

La fonction :

(read-char [port])

lit un caractère du port courant ou du port spécifié. La fonction :

(peek-char [port])

retourne le caractère qui serait lu par read-char, mais elle ne le supprime pas du port d'entrée.

La fonction :

(char-ready? [port])

retourne #t si au moins un caractère est disponible sur le port considéré. Enfin, la fonction :

(load fichier)

lit le fichier donné et l'interprète. Le fichier doit contenir des expressions Scheme. Cela permet de construire des programmes modulaires.

Sortie

Les fonctions :

(write objet [port])

et :

(display objet [port])

écrivent dans le port spécifié l'objet donné en argument. La différence entre les deux fonctions concerne la représentation des chaînes de caractères. Pour afficher un saut à la ligne, il existe la fonction :

(newline [port])

Enfin, pour écrire un caractère, Scheme propose :

(write-char caractère [port])

Exemple

Le premier exemple permet la recopie d'un fichier :

(define (copie source dest)
  (call-with-input-file
   source
   (lambda (in)
     (call-with-output-file
      dest
      (lambda (out)
       (do ((ch (read-char in) (read-char in)))
           ((eof-object? ch))
         (write-char ch out)))))))

La fonction suivante copie un fichier dans un autre en effectuant une conversion des caractères à l'aide de la fonction proc en argument :

Osm> (define (convertit proc source dest)
       (with-input-from-file
        source
        (lambda ()
          (with-output-to-file
           dest
           (lambda ()
            (do ((ch (read-char in) (read-char in)))
                ((eof-object? ch))
              (write-char (proc ch) out)))))))
  => #unspecified

On remarque que les ports ne sont pas spécifiés car les ports par défaut sont modifiés le temps de l'appel aux procédures lambda. On pourra convertir les lettres minuscules d'un fichier en majuscules avec :

Osm> (convertit char-upcase "source.txt" "dest.txt")
  => #unspecified