« Emprunter » des routines d’I/O tamponnées à  partir de C ILE

pas nécessaire de s’infliger la
lecture du fichier texte, caractère par
caractère.

La figure 7 montre le prototype de
l’API fopen(). Elle est analogue à 
open(), mais elle ouvre le fichier
pour l’utiliser avec les routines de flux
tamponné dans la bibliothèque
d’exécution C ILE. En C ILE, il existe
deux versions de fopen(). L’une est
destinée aux fichiers base de données
DB2 normaux et l’autre est destinée
aux fichiers stream de l’IFS (integrated
file system). Le nom de la procédure
externe de cette API est _C_IFS _fopen()
car il doit la distinguer de l’API
fopen() normale. Le premier paramètre
est le nom du fichier dans l’IFS que vous voulez ouvrir. Le second paramètre
détermine comment le fichier
est ouvert et est constitué d’un mode
open éventuellement suivi de motsclés
séparés par des virgules. La figure
8 montre les modes open possibles
pour l’API fopen() et la figure 9 affiche
les mots-clés.

Au lieu de renvoyer un descripteur
de fichier, comme le fait l’API open(),
l’API fopen() renvoie un pointeur vers
la structure de données interne que la
routine IBM utilise pour suivre l’information
concernant le fichier. Comme
la structure de données n’est utilisée
que par les routines IBM, l’apparence
de la structure de données vous importe
peu en tant que programmeur.
Vous devez simplement passer consciencieusement
le pointeur aux routines
qui en ont besoin, tout comme
vous l’avez fait avec les descripteurs
de fichier dans les exemples antérieurs.

Si l’API fopen() rencontre une erreur,
elle renvoie un pointeur null.
Comme avec l’API open(), on peut vérifier
la valeur de errno pour connaître
la nature de l’anomalie. Pour en savoir
plus sur la vérification des erreurs,
voir « Introduction to Stream Files ».

La figure 7 montre aussi les prototypes
des API fgets(), fputs() et fclose().
Elles serviront respectivement à 
lire une ligne de texte, écrire une ligne
de texte, et fermer un fichier. Pour faciliter
l’utilisation des API d’I/O en flux
tamponné de C ILE dans mes programmes
RPG, j’ai créé un membre
source appelé BUFIO_H qui contient
tous les prototypes nécessaires pour
ces API. (On peut télécharger BUFIO_
H à  iSeriesNetwork.com/code).
Pour utiliser ce membre source, incluez-
le simplement avec la directive
de compilateur /copy afin qu’il soit
dans les D-specs de votre programme.

La figure 10 démontre l’utilisation
du membre BUFIO_H. Il crée le nouveau
fichier en appelant l’API fopen()
et attribue au fichier un CCSID de 819.Ensuite, il ferme le fichier et le réouvre
pour permettre la traduction du CCSID
du job en CCSID du fichier. Il utilise
CRLN=N parce que le texte qu’il
génère devra être compatible avec un
système Linux. Pour qu’il soit compatible
avec Windows, il n’est pas nécessaire
de réécrire tout le programme. Il
suffit de changer la valeur du mot-clé
CRLN en Y et les retours chariot s’ajouteront
automatiquement.

Pour lire un fichier texte ligne à 
ligne en utilisant les API d’I/O de flux
tamponné, il faut appeler l’API fgets().
Son premier paramètre est une zone
de mémoire dans laquelle elle peut
lire des données. Le deuxième paramètre
est la taille de cette zone de mémoire.
Le meilleur moyen de prendre
cela en compte dans un programme
RPG ILE, consiste à  définir une variable
caractère de longueur fixe suffisamment
grande pour stocker n’importe
quelle ligne de texte que l’on
envisage de lire dans un fichier. Le dernier
paramètre de l’API fgets() est le
pointeur qui a été renvoyé par l’API fopen().
Il indique à  fgets() le fichier
stream à  partir duquel doit s’effectuer
la lecture.

L’API fgets() renvoie un pointeur.
Si la lecture a réussi, ce pointeur sera
défini d’après la zone de mémoire
fournie dans le premier paramètre. Si
l’on atteint la fin du fichier ou si une erreur
survient, une valeur de *NULL est
renvoyée.

Les données que fgets() lit, sont
une chaîne terminée par null comme
celle qu’on utilise dans des programmes
C ILE. Une chaîne terminée
par un null est une chaîne de longueur
variable dont la fin est signalée par le
caractère x’00’. On peut utiliser la BIF
%str() pour convertir une chaîne terminée
par un null en une chaîne VARYING
dans le programme RPG.

Le bloc de code téléchargeable
contient un exemple de lecture d’un fichier
texte en utilisant les routines
d’I/O tamponnées C ILE. Comme la
plus longue ligne que ce programme
peut imprimer est de 80 caractères, j’ai
aussi donné cette même longueur de
80 caractères à  la variable « ligne ». Ce
n’est pas une limite immuable : on
peut la remplacer par une plus grande
longueur en changeant simplement les tailles des variables space et line. La variable space a un caractère
de plus que la variable line afin de fournir un espace
pour le caractère x’00’ que C ILE ajoute à  la fin de la ligne.

Pour appeler les fonctions d’I/O stream tamponnées,
votre programme RPG doit être lié à  la bibliothèque runtime
C ILE. Pour cela, je préfère utiliser le mot-clé H-spec BND
DIR(‘QC2LE’) afin que le prochain programmeur qui compilera
ce programme ne doive pas se rappeler d’inclure le
BNDDIR sur la commande CRTP GM (Create Program) ou
CRTBND RPG (Create Bound RPG Program) réelle. Si l’on
souhaite inclure des « binding directories » supplémentaires
sur la H-spec, on peut le faire soit en ayant plusieurs motsclés
BNDDIR, soit en séparant les répertoires liants dans un
mot-clé unique par des signes deux-points (figure 11).